kernel/go.h

Go to the documentation of this file.

#ifndef _KERNEL_GO_H_
#define _KERNEL_GO_H_

/*
 * GROUP
 */

// Structure representing GO group and group's subtypes are defined in types.h.

SCHEME SO_go_group go_group_new(void) STRANS ;

SCHEME SO_go_path go_path_new(void) STRANS ;


/*
 * EMPTY
 */

struct go_empty
{
        struct go go;
        struct geom_callback_item geom;
        struct anchor a[0];
        struct hanger h[0];
};

enum go_empty_subtype
{
        GOST_EMPTY,
        GOST_EMPTY_MAX,
};

SCHEME SO_go_empty go_empty_new(void) STRANS ;


/*
 * POINT
 */

struct go_point
{
        struct go go;
        struct geom_point_item geom;
        struct anchor a[1];
        struct hanger h[1];
        u8 unit_coordinate_x, unit_coordinate_y;
};

enum go_point_subtype
{
        GOST_POINT,
        GOST_POINT_MAX,
};

SCHEME SO_go_point go_point_new(SHANGER h) STRANS ;



/*
 * SEGMENT
 */

struct go_segment
{
        struct go go;
        struct geom_segment geom;
        struct anchor a[2]; // start point, end point
        struct hanger h[3]; // curve, start point, end point
        uns fill_color, stroke_color, stroke_cap, stroke_join, stroke_style;
        real stroke_width;
        u8 unit_stroke_width, unit_start_x, unit_start_y, unit_end_x, unit_end_y;
};

enum go_segment_subtype
{
        GOST_SEGMENT,
        GOST_SEGMENT_MAX,
};

SCHEME SO_go_segment go_segment_new(SHANGER starting_point, SHANGER end_point) STRANS ;



/*
 * BEZIER
 */

struct go_bezier
{
        struct go go;
        struct geom_bezier geom;
        struct anchor a[4]; // control points
        struct hanger h[3]; // curve, start point, end point
        uns fill_color, stroke_color, stroke_cap, stroke_join, stroke_style;
        real stroke_width;
        u8 unit_stroke_width,
                unit_control_0_x, unit_control_0_y, unit_control_1_x, unit_control_1_y,
                unit_control_2_x, unit_control_2_y, unit_control_3_x, unit_control_3_y;
};

enum go_bezier_subtype
{
        GOST_BEZIER_QUADRATIC,
        GOST_BEZIER_CUBIC,
        GOST_BEZIER_MAX,
};

SCHEME SO_go_bezier go_bezier_new_cubic(SHANGER control_1, SREAL weight_1, SHANGER control_2, SREAL weight_2, SHANGER control_3, SREAL weight_3, SHANGER control_4, SREAL weight_4) STRANS ;

SCHEME SO_go_bezier go_bezier_new_quadratic(SHANGER control_1, SREAL weight_1, SHANGER control_2, SREAL weight_2, SHANGER control_3, SREAL weight_3) STRANS ;



/*
 * ELLIPTIC ARC
 */

struct go_elarc
{
        struct go go;
        struct geom_elliptic_arc geom;
        struct anchor a[3]; // Hangers depend on subtype.
        struct hanger h[4]; // curve, start point, end point, center
        real ecc;
        uns conic;
        uns fill_color, stroke_color, stroke_cap, stroke_join, stroke_style;
        real stroke_width;
        u8 unit_stroke_width, unit_center_x, unit_center_y, unit_rotation, unit_a_radius, unit_b_radius, unit_start, unit_dif, unit_ecc;
};

enum go_elarc_subtype
{
        GOST_ELARC_XYR,
        GOST_ELARC_FOCI,
        GOST_ELARC_3SMALL,
        GOST_ELARC_3ECC,
        GOST_ELARC_XY1ECC,
        GOST_ELARC_MAX,
};

SCHEME SO_go_elarc go_elarc_new_xyr(SHANGER center, SREAL rotation, SREAL horizontal_radius, SREAL vertical_radius, SREAL start, SREAL dif, SUNS conic) STRANS ;

SCHEME SO_go_elarc go_elarc_new_foci(SHANGER focus1, SHANGER focus2, SHANGER point, SUNS conic) STRANS ;

SCHEME SO_go_elarc go_elarc_new_3small(SHANGER point1, SHANGER point2, SHANGER point3, SUNS conic) STRANS ;

SCHEME SO_go_elarc go_elarc_new_3ecc(SHANGER point1, SHANGER point2, SHANGER point3, SREAL rotation, SREAL eccentricity, SUNS conic) STRANS ;

SCHEME SO_go_elarc go_elarc_new_xy1ecc(SHANGER center, SHANGER point, SREAL rotation, SREAL eccentricity, SUNS conic) STRANS ;



/*
 * PARAMETRIC POINT
 */

struct go_parametric_point
{
        struct go go;
        struct geom_point_item geom;
        real parameter;
        struct anchor a[1]; // curve
        struct hanger h[1]; // point
        u8 unit_coordinate_x, unit_coordinate_y, unit_parameter;
};

enum go_parametric_point_subtype
{
        GOST_PARAMETRIC_POINT,
        GOST_PARAMETRIC_POINT_MAX,
};

SCHEME SO_go_parametric_point go_parametric_point_new(SO_go go, SREAL parameter) STRANS ;

SCHEME SO_go_parametric_point go_parametric_point_new_on_hanger(SHANGER h, SREAL parameter, SBOOL position_important, SREAL x, SREAL y); STRANS

SCHEME static inline SBOOL go_parametric_point_is_valid(SO_go_parametric_point p)
        { return hanger_get_go(p->a[0].h)->type != GOT_GROUP; }

SCHEME static inline SBOOL go_parametric_point_is_position_important(SO_go_parametric_point p)
        { return p->go.flags & GOF_PARPOINT_INVALID_X; }



/*
 * INTERSECTION POINT
 */

struct go_intersection
{
        struct go go;
        struct geom_point_item geom;
        real parameter;
        struct anchor a[2];
        struct hanger h[1];
        u8 unit_coordinate_x, unit_coordinate_y, unit_parameter;
};

enum go_intersection_subtype
{
        GOST_INTERSECTION,
        GOST_INTERSECTION_MAX,
};

SCHEME SO_go_intersection go_intersection_new(SO_go go1, SO_go go2, SREAL parameter) STRANS ;

SCHEME SO_go_intersection go_intersection_new_on_hanger(SHANGER h1, SHANGER h2, SREAL parameter, SBOOL position_important, SREAL x, SREAL y) STRANS ;

SCHEME SBOOL go_intersection_is_valid(SO_go_intersection i);

SCHEME static inline SBOOL go_intersection_is_position_important(SO_go_intersection i)
        { return i->go.flags & GOF_INTERSECTION_INVALID_X; }

/*
 * TEXT
 */

struct go_text
{
        struct go go;
        struct geom_point_item geom;
        struct anchor a[1];
        struct geom_point apos, rpos;
        struct geom_transform *transformation;
        int font_id;
        real font_size;
        string text;
        uns fill_color;
        struct geom_rectangle string_bbox, // bbox stringu v LFT souradnicich
                                                                 text_bbox; // bbox textu v PAGE souradnicich
        uns alignment_x, alignment_y;
        u8 unit_rpos_x, unit_rpos_y, unit_apos_x, unit_apos_y, unit_coordinate_x, unit_coordinate_y, unit_size;
        struct hanger h[];
};

enum go_text_subtype
{
        GOST_TEXT,
        GOST_TEXT_MAX,
};

SCHEME SO_go_text go_text_new(SHANGER refpoint, SREAL rpos_x, SREAL rpos_y, SREAL apos_x, SREAL apos_y, SSTRINGS text, SINT fontid, SREAL fntsize) STRANS ;

static inline void go_text_get_string_bbox(struct go_text *t, struct geom_rectangle *bbox)
        { *bbox = t->string_bbox; }

static inline void go_text_get_text_bbox(struct go_text *t, struct geom_rectangle *bbox)
        { *bbox = t->text_bbox; }
        
static inline void go_text_get_visualisation_point(struct go_text *t, struct geom_point *gp)
        { *gp = (struct geom_point) { t->transformation->coef[0][2], t->transformation->coef[1][2] }; }

static inline void go_text_get_transformation(struct go_text *t, struct geom_transform *tr)
        { *tr = *t->transformation; }


/*
 * TEX
 */

struct tex_process
{
        uns ref_count;
        struct garr *glyphs;
        uns glyphs_cnt;                 
        struct geom_rectangle bbox;     
        string text;
};

static inline struct tex_process* tex_process_ref(struct tex_process *tp)
        { tp->ref_count++; return tp; }

static inline void tex_process_unref(struct tex_process *tp)
        { tp->ref_count--; if(tp->ref_count) return; garr_destroy(tp->glyphs); string_unref(tp->text); xfree(tp); }

struct go_tex_text
{
        struct go go;
        struct geom_point_item geom;
        struct anchor a[1];
        struct geom_point apos, rpos;
        struct geom_transform *transformation;
        struct tex_process *process;
        struct geom_rectangle text_bbox; // bbox textu v PAGE souradnicich
        uns alignment_x, alignment_y;
        uns fill_color;
        u8 unit_rpos_x, unit_rpos_y, unit_apos_x, unit_apos_y, unit_coordinate_x, unit_coordinate_y;
        struct hanger h[];
};

enum go_tex_text_subtype
{
        GOST_TEX_TEXT,
        GOST_TEX_TEXT_MAX,
};

SCHEME SO_go_tex_text go_tex_text_new(SHANGER refpoint, SREAL rpos_x, SREAL rpos_y, SREAL apos_x, SREAL apos_y, SSTRINGS text) STRANS ;

struct go_tex_text* go_tex_text_new_process(struct hanger* ll, real refp_x, real refp_y, real marg_x, real marg_y, struct tex_process *process);

static inline void go_tex_text_get_text_bbox(struct go_tex_text *t, struct geom_rectangle *bbox)
        { *bbox = t->text_bbox; }
        
static inline void go_tex_text_get_string_bbox(struct go_tex_text *t, struct geom_rectangle *bbox)
        { *bbox = t->process->bbox; }

static inline void go_tex_text_get_visualisation_point(struct go_tex_text *t, struct geom_point *gp)
        { *gp = (struct geom_point) { t->transformation->coef[0][2], t->transformation->coef[1][2] }; }

static inline void go_tex_text_get_transformation(struct go_tex_text *t, struct geom_transform *tr)
        { *tr = *t->transformation; }

void go_tex_text_rerun_tex_process(struct go_tex_text *t);
void group_rerun_tex_process(struct go_group *group);


/*
 * DECORATOR_POINT
 */

#define GO_DECORATOR_POINT_MAX_VERTICES 100
        
struct go_decorator_point
{
        struct go go;
        struct geom_callback_item geom;
        struct anchor a[1];
        struct hanger h[1];
        struct geom_point x;
        uns n;
        real radius, rotation;
        uns fill_color, stroke_color, stroke_cap, stroke_join, stroke_style;
        real stroke_width;
        u8 unit_stroke_width, unit_radius, unit_rotation, unit_coordinate_x, unit_coordinate_y;
};

enum go_decorator_point_subtype
{
        GOST_DECORATOR_POINT,
        GOST_DECORATOR_POINT_MAX,
};

SCHEME SO_go_decorator_point go_decorator_point_new(SHANGER point, SUNS n, SREAL radius, SREAL rotation) STRANS ;


/*
 * ARROW
 */

struct go_arrow
{
        struct go go;
        struct geom_callback_item geom;
        struct anchor a[1];
        struct geom_point x;
        uns reversed;
        real rotation, parameter;
        real arrow_length; //[0, REAL_MAX] ... vzdalenost hrotu a koncovych bodu sipky
        real arrow_angle; // [0, R_PI] ... uhel mezi hrotem a koncovymi body krivky
        real front_curvature; // [0, 1] ... pro parabolicky tvar predni casti krivky parametr, jak moc ma byt zakrivena
        real back_distance; // [0, 1] ... relativni vzdalenost "zadniho bodu" sipky
        uns arrow_alignment;
        uns arrow_front;
        uns arrow_back;
        uns fill_color, stroke_color, stroke_cap, stroke_join, stroke_style;
        real stroke_width;
        u8 unit_stroke_width, unit_arrow_length, unit_rotation, unit_coordinate_x, unit_coordinate_y, unit_arrow_angle, unit_parameter, unit_front_curvature, unit_back_distance;
        struct hanger h[];
};

enum go_arrow_subtype
{
        GOST_ARROW,
        GOST_ARROW_MAX,
};

SCHEME SO_go_arrow go_arrow_new(SO_go go, SREAL parameter, SREAL arrow_length, SREAL rotation) STRANS ;

SCHEME SO_go_arrow go_arrow_new_on_hanger(SHANGER point, SREAL parameter, SREAL arrow_length, SREAL rotation) STRANS ;


/*
 * USER
 */

struct go_user_description
{
        void (* call_dump)(struct go*);
        struct go* (* call_duplicate)(struct go*);
        void (* call_finish)(struct go*);
        void (* call_recompute)(struct go*, struct geom_rectangle*);
        void (* call_transform)(struct go*, struct geom_transform*, struct geom_rectangle*);
        int (* call_expand)(struct geom_callback_item*, struct geom_fpath*);
        int (* call_bbox)(struct go*, const struct geom_transform*, struct geom_rectangle*);
};

extern struct go_user_description *go_user_desc;
extern int go_user_count;

int go_user_register(
        string name,
        struct go_info *gi,
        void (* call_dump)(struct go*),
        struct go* (* call_duplicate)(struct go*),
        void (* call_finish)(struct go*),
        void (* call_recompute)(struct go*, struct geom_rectangle*),
        void (* call_transform)(struct go*, struct geom_transform*, struct geom_rectangle*),
        int (* call_expand)(struct geom_callback_item*, struct geom_fpath*),
        int (* call_bbox)(struct go*, const struct geom_transform*, struct geom_rectangle*));

enum go_user_subtype
{
        GOST_USER_MAX,
};

#endif

---