| /* |
| * Copyright © 2020 Ebrahim Byagowi |
| * |
| * This is part of HarfBuzz, a text shaping library. |
| * |
| * Permission is hereby granted, without written agreement and without |
| * license or royalty fees, to use, copy, modify, and distribute this |
| * software and its documentation for any purpose, provided that the |
| * above copyright notice and the following two paragraphs appear in |
| * all copies of this software. |
| * |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| * |
| * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| */ |
| |
| #ifndef HB_DRAW_HH |
| #define HB_DRAW_HH |
| |
| #include "hb.hh" |
| |
| |
| /* |
| * hb_draw_funcs_t |
| */ |
| |
| #define HB_DRAW_FUNCS_IMPLEMENT_CALLBACKS \ |
| HB_DRAW_FUNC_IMPLEMENT (move_to) \ |
| HB_DRAW_FUNC_IMPLEMENT (line_to) \ |
| HB_DRAW_FUNC_IMPLEMENT (quadratic_to) \ |
| HB_DRAW_FUNC_IMPLEMENT (cubic_to) \ |
| HB_DRAW_FUNC_IMPLEMENT (close_path) \ |
| /* ^--- Add new callbacks here */ |
| |
| struct hb_draw_funcs_t |
| { |
| hb_object_header_t header; |
| |
| struct { |
| #define HB_DRAW_FUNC_IMPLEMENT(name) hb_draw_##name##_func_t name; |
| HB_DRAW_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_DRAW_FUNC_IMPLEMENT |
| } func; |
| |
| struct { |
| #define HB_DRAW_FUNC_IMPLEMENT(name) void *name; |
| HB_DRAW_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_DRAW_FUNC_IMPLEMENT |
| } *user_data; |
| |
| struct { |
| #define HB_DRAW_FUNC_IMPLEMENT(name) hb_destroy_func_t name; |
| HB_DRAW_FUNCS_IMPLEMENT_CALLBACKS |
| #undef HB_DRAW_FUNC_IMPLEMENT |
| } *destroy; |
| |
| void emit_move_to (void *draw_data, hb_draw_state_t &st, |
| float to_x, float to_y) |
| { func.move_to (this, draw_data, &st, |
| to_x, to_y, |
| !user_data ? nullptr : user_data->move_to); } |
| void emit_line_to (void *draw_data, hb_draw_state_t &st, |
| float to_x, float to_y) |
| { func.line_to (this, draw_data, &st, |
| to_x, to_y, |
| !user_data ? nullptr : user_data->line_to); } |
| void emit_quadratic_to (void *draw_data, hb_draw_state_t &st, |
| float control_x, float control_y, |
| float to_x, float to_y) |
| { func.quadratic_to (this, draw_data, &st, |
| control_x, control_y, |
| to_x, to_y, |
| !user_data ? nullptr : user_data->quadratic_to); } |
| void emit_cubic_to (void *draw_data, hb_draw_state_t &st, |
| float control1_x, float control1_y, |
| float control2_x, float control2_y, |
| float to_x, float to_y) |
| { func.cubic_to (this, draw_data, &st, |
| control1_x, control1_y, |
| control2_x, control2_y, |
| to_x, to_y, |
| !user_data ? nullptr : user_data->cubic_to); } |
| void emit_close_path (void *draw_data, hb_draw_state_t &st) |
| { func.close_path (this, draw_data, &st, |
| !user_data ? nullptr : user_data->close_path); } |
| |
| |
| void move_to (void *draw_data, hb_draw_state_t &st, |
| float to_x, float to_y) |
| { |
| if (st.path_open) close_path (draw_data, st); |
| st.current_x = to_x; |
| st.current_y = to_y; |
| } |
| |
| void line_to (void *draw_data, hb_draw_state_t &st, |
| float to_x, float to_y) |
| { |
| if (!st.path_open) start_path (draw_data, st); |
| emit_line_to (draw_data, st, to_x, to_y); |
| st.current_x = to_x; |
| st.current_y = to_y; |
| } |
| |
| void |
| quadratic_to (void *draw_data, hb_draw_state_t &st, |
| float control_x, float control_y, |
| float to_x, float to_y) |
| { |
| if (!st.path_open) start_path (draw_data, st); |
| emit_quadratic_to (draw_data, st, control_x, control_y, to_x, to_y); |
| st.current_x = to_x; |
| st.current_y = to_y; |
| } |
| |
| void |
| cubic_to (void *draw_data, hb_draw_state_t &st, |
| float control1_x, float control1_y, |
| float control2_x, float control2_y, |
| float to_x, float to_y) |
| { |
| if (!st.path_open) start_path (draw_data, st); |
| emit_cubic_to (draw_data, st, control1_x, control1_y, control2_x, control2_y, to_x, to_y); |
| st.current_x = to_x; |
| st.current_y = to_y; |
| } |
| |
| void |
| close_path (void *draw_data, hb_draw_state_t &st) |
| { |
| if (st.path_open) |
| { |
| if ((st.path_start_x != st.current_x) || (st.path_start_y != st.current_y)) |
| emit_line_to (draw_data, st, st.path_start_x, st.path_start_y); |
| emit_close_path (draw_data, st); |
| } |
| st.path_open = false; |
| st.path_start_x = st.current_x = st.path_start_y = st.current_y = 0; |
| } |
| |
| protected: |
| |
| void start_path (void *draw_data, hb_draw_state_t &st) |
| { |
| assert (!st.path_open); |
| emit_move_to (draw_data, st, st.current_x, st.current_y); |
| st.path_open = true; |
| st.path_start_x = st.current_x; |
| st.path_start_y = st.current_y; |
| } |
| }; |
| DECLARE_NULL_INSTANCE (hb_draw_funcs_t); |
| |
| struct hb_draw_session_t |
| { |
| hb_draw_session_t (hb_draw_funcs_t *funcs_, void *draw_data_, float slant_ = 0.f) |
| : slant {slant_}, not_slanted {slant == 0.f}, |
| funcs {funcs_}, draw_data {draw_data_}, st HB_DRAW_STATE_DEFAULT |
| {} |
| |
| ~hb_draw_session_t () { close_path (); } |
| |
| void move_to (float to_x, float to_y) |
| { |
| if (likely (not_slanted)) |
| funcs->move_to (draw_data, st, |
| to_x, to_y); |
| else |
| funcs->move_to (draw_data, st, |
| to_x + to_y * slant, to_y); |
| } |
| void line_to (float to_x, float to_y) |
| { |
| if (likely (not_slanted)) |
| funcs->line_to (draw_data, st, |
| to_x, to_y); |
| else |
| funcs->line_to (draw_data, st, |
| to_x + to_y * slant, to_y); |
| } |
| void |
| quadratic_to (float control_x, float control_y, |
| float to_x, float to_y) |
| { |
| if (likely (not_slanted)) |
| funcs->quadratic_to (draw_data, st, |
| control_x, control_y, |
| to_x, to_y); |
| else |
| funcs->quadratic_to (draw_data, st, |
| control_x + control_y * slant, control_y, |
| to_x + to_y * slant, to_y); |
| } |
| void |
| cubic_to (float control1_x, float control1_y, |
| float control2_x, float control2_y, |
| float to_x, float to_y) |
| { |
| if (likely (not_slanted)) |
| funcs->cubic_to (draw_data, st, |
| control1_x, control1_y, |
| control2_x, control2_y, |
| to_x, to_y); |
| else |
| funcs->cubic_to (draw_data, st, |
| control1_x + control1_y * slant, control1_y, |
| control2_x + control2_y * slant, control2_y, |
| to_x + to_y * slant, to_y); |
| } |
| void close_path () |
| { |
| funcs->close_path (draw_data, st); |
| } |
| |
| protected: |
| float slant; |
| bool not_slanted; |
| hb_draw_funcs_t *funcs; |
| void *draw_data; |
| hb_draw_state_t st; |
| }; |
| |
| #endif /* HB_DRAW_HH */ |