lgl_template_new ()

lglTemplate *
lgl_template_new (const gchar *brand,
                  const gchar *part,
                  const gchar *description,
                  const gchar *paper_id,
                  gdouble page_width,
                  gdouble page_height);

Create a new template structure, with the given top-level attributes. The created template will have no initial categories, or frames associated with it. See lgl_template_add_category() and lgl_template_add_frame() to add these.

lgl_template_new_from_equiv ()

lglTemplate *
lgl_template_new_from_equiv (const gchar *brand,
                             const gchar *part,
                             const gchar *equiv_part);

Create a new template structure based on an existing template. The created template will be a duplicate of the original template, except with the new part name/number.

lgl_template_dup ()

lglTemplate *
lgl_template_dup (const lglTemplate *orig_template);

This function duplicates a template structure.

lgl_template_free ()

void
lgl_template_free (lglTemplate *template);

This function frees all memory associated with given template structure.

lgl_template_add_category ()

void
lgl_template_add_category (lglTemplate *template,
                           const gchar *category_id);

This function adds the given category ID to a templates category list.

lgl_template_add_frame ()

void
lgl_template_add_frame (lglTemplate *template,
                        lglTemplateFrame *frame);

This function adds the given frame structure to the template. Once added, the frame structure belongs to the given template; do not attempt to free it.

Note: Currently glabels only supports a single frame per template.

lgl_template_get_name ()

gchar *
lgl_template_get_name (const lglTemplate *template);

This function returns the name of the given template. The name is the concetenation of the brand and part name/number.

lgl_template_do_templates_match ()

gboolean
lgl_template_do_templates_match (const lglTemplate *template1,
                                 const lglTemplate *template2);

This function tests if the given templates match. This is a simple test that only tests the brand and part name/number. It does not test if they are actually identical.

lgl_template_does_brand_match ()

gboolean
lgl_template_does_brand_match (const lglTemplate *template,
                               const gchar *brand);

This function tests if the brand of the template matches the given brand.

lgl_template_does_page_size_match ()

gboolean
lgl_template_does_page_size_match (const lglTemplate *template,
                                   const gchar *paper_id);

This function tests if the page size of the template matches the given ID.

lgl_template_does_category_match ()

gboolean
lgl_template_does_category_match (const lglTemplate *template,
                                  const gchar *category_id);

This function tests if the given template belongs to the given category ID.

lgl_template_are_templates_identical ()

gboolean
lgl_template_are_templates_identical (const lglTemplate *template1,
                                      const lglTemplate *template2);

This function tests if the given templates have identical size and layout properties.

lgl_template_frame_rect_new ()

lglTemplateFrame *
lgl_template_frame_rect_new (const gchar *id,
                             gdouble w,
                             gdouble h,
                             gdouble r,
                             gdouble x_waste,
                             gdouble y_waste);

This function creates a new template frame for a rectangular label or card.

lgl_template_frame_ellipse_new ()

lglTemplateFrame *
lgl_template_frame_ellipse_new (const gchar *id,
                                gdouble w,
                                gdouble h,
                                gdouble waste);

This function creates a new template frame for an elliptical label or card.

lgl_template_frame_round_new ()

lglTemplateFrame *
lgl_template_frame_round_new (const gchar *id,
                              gdouble r,
                              gdouble waste);

This function creates a new template frame for a round label.

lgl_template_frame_cd_new ()

lglTemplateFrame *
lgl_template_frame_cd_new (const gchar *id,
                           gdouble r1,
                           gdouble r2,
                           gdouble w,
                           gdouble h,
                           gdouble waste);

This function creates a new template frame for a CD/DVD label.

lgl_template_frame_dup ()

lglTemplateFrame *
lgl_template_frame_dup (const lglTemplateFrame *orig_frame);

This function duplicates a template frame structure.

lgl_template_frame_free ()

void
lgl_template_frame_free (lglTemplateFrame *frame);

This function frees all memory associated with given template frame structure.

lgl_template_frame_add_layout ()

void
lgl_template_frame_add_layout (lglTemplateFrame *frame,
                               lglTemplateLayout *layout);

This function adds a layout structure to the given template frame.

lgl_template_frame_add_markup ()

void
lgl_template_frame_add_markup (lglTemplateFrame *frame,
                               lglTemplateMarkup *markup);

This function adds a markup structure to the given template frame.

lgl_template_frame_get_size ()

void
lgl_template_frame_get_size (const lglTemplateFrame *frame,
                             gdouble *w,
                             gdouble *h);

Get size (width and height) of given lglTemplateFrame in points.

lgl_template_frame_get_n_labels ()

gint
lgl_template_frame_get_n_labels (const lglTemplateFrame *frame);

Get total number of labels per sheet corresponding to the given frame.

lgl_template_frame_get_origins ()

lglTemplateOrigin *
lgl_template_frame_get_origins (const lglTemplateFrame *frame);

Get an array of label origins for the given frame. These origins represent the upper left hand corner of each label on a page corresponding to the given frame. The origins will be ordered geometrically left to right and then top to bottom. The array should be freed using g_free().

lgl_template_frame_get_layout_description ()

gchar *
lgl_template_frame_get_layout_description
                               (const lglTemplateFrame *frame);

Get a description of the label layout including number of labels per sheet.

lgl_template_frame_get_size_description ()

gchar *
lgl_template_frame_get_size_description
                               (const lglTemplateFrame *frame,
                                lglUnits units);

Get a description of the label size.

lgl_template_layout_new ()

lglTemplateLayout *
lgl_template_layout_new (gint nx,
                         gint ny,
                         gdouble x0,
                         gdouble y0,
                         gdouble dx,
                         gdouble dy);

This function creates a new layout structure with the given parameters.

lgl_template_layout_dup ()

lglTemplateLayout *
lgl_template_layout_dup (const lglTemplateLayout *orig_layout);

This function duplicates a template layout structure.

lgl_template_layout_free ()

void
lgl_template_layout_free (lglTemplateLayout *layout);

This function frees all memory associated with given template layout structure.

lgl_template_markup_margin_new ()

lglTemplateMarkup *
lgl_template_markup_margin_new (gdouble size);

This function creates a new margin markup structure.

lgl_template_markup_line_new ()

lglTemplateMarkup *
lgl_template_markup_line_new (gdouble x1,
                              gdouble y1,
                              gdouble x2,
                              gdouble y2);

This function creates a new line markup structure.

lgl_template_markup_circle_new ()

lglTemplateMarkup *
lgl_template_markup_circle_new (gdouble x0,
                                gdouble y0,
                                gdouble r);

This function creates a new circle markup structure.

lgl_template_markup_rect_new ()

lglTemplateMarkup *
lgl_template_markup_rect_new (gdouble x1,
                              gdouble y1,
                              gdouble w,
                              gdouble h,
                              gdouble r);

This function creates a new rectangle markup structure.

lgl_template_markup_ellipse_new ()

lglTemplateMarkup *
lgl_template_markup_ellipse_new (gdouble x1,
                                 gdouble y1,
                                 gdouble w,
                                 gdouble h);

This function creates a new ellipse markup structure.

lgl_template_markup_dup ()

lglTemplateMarkup *
lgl_template_markup_dup (const lglTemplateMarkup *orig_markup);

This function duplicates a template markup structure.

lgl_template_markup_free ()

void
lgl_template_markup_free (lglTemplateMarkup *markup);

This function frees all memory associated with given template markup structure.

lgl_template_print ()

void
lgl_template_print (const lglTemplate *template);

Print template details (for debugging purposes).

struct lglTemplate

struct lglTemplate {
        gchar               *brand;
        gchar               *part;
        gchar               *equiv_part;

        gchar               *description;
        gchar               *paper_id;
        gdouble              page_width;
        gdouble              page_height;

        /* Meta information. */
        gchar               *product_url;   /* URL to manufacturer's product website. */
        GList               *category_ids;  /* List of (gchar *) category ids. */

        /* List of (lglTemplateFrame *) label frame structures.
         * Currently glabels only supports a single label frame per
         * template. */
        GList               *frames;
};

This is the main structure of a libglabels template. A template represents a single sheet of peel-off labels or cards.

enum lglTemplateFrameShape

This enumeration defines frame types that are supported by libglabels

union lglTemplateFrame

A union of all possible frame structures. The type of structure is indicated by the shape member, which overlays the first field of all other member structures.

struct lglTemplateFrameAll

struct lglTemplateFrameAll {
        /* Begin Common Fields */
        lglTemplateFrameShape shape;

        gchar                *id;       /* Id, currently always "0" */
        GList                *layouts;  /* List of lglTemplateLayouts */
        GList                *markups;  /* List of lglTemplateMarkups */
        /* End Common Fields */
};

This structure is composed of a set of fields common to all frame structures. All frame types can be cast to this structure.

struct lglTemplateFrameRect

struct lglTemplateFrameRect {
        /* Begin Common Fields */
        lglTemplateFrameShape shape;    /* Always LGL_TEMPLATE_FRAME_SHAPE_RECT. */

        gchar                *id;       /* Id, currently always "0" */
        GList                *layouts;  /* List of lglTemplateLayouts */
        GList                *markups;  /* List of lglTemplateMarkups */
        /* End Common Fields */

        gdouble               w;        /* Width */
        gdouble               h;        /* Height */
        gdouble               r;        /* Corner radius */
        gdouble               x_waste;  /* Amount of horiz overprint allowed. */
        gdouble               y_waste;  /* Amount of vert overprint allowed. */
};

This structure defines the frame for a rectangular label or card.

struct lglTemplateFrameEllipse

struct lglTemplateFrameEllipse {
        /* Begin Common Fields */
        lglTemplateFrameShape shape;    /* Always LGL_TEMPLATE_FRAME_SHAPE_ELLIPSE. */

        gchar                *id;       /* Id, currently always "0" */
        GList                *layouts;  /* List of lglTemplateLayouts */
        GList                *markups;  /* List of lglTemplateMarkups */
        /* End Common Fields */

        gdouble               w;        /* Width */
        gdouble               h;        /* Height */
        gdouble               waste;    /* Amount of overprint allowed. */
};

This structure defines the frame for an elliptical label or card.

struct lglTemplateFrameRound

struct lglTemplateFrameRound {
        /* Begin Common Fields */
        lglTemplateFrameShape shape;    /* Always LGL_TEMPLATE_FRAME_SHAPE_ROUND. */

        gchar                *id;       /* Id, currently always "0" */
        GList                *layouts;  /* List of lglTemplateLayouts */
        GList                *markups;  /* List of lglTemplateMarkups */
        /* End Common Fields */

        gdouble               r;      /* Radius */
        gdouble               waste;  /* Amount of overprint allowed. */
};

This structure defines the frame for a round label or card.

struct lglTemplateFrameCD

struct lglTemplateFrameCD {
        /* Begin Common Fields */
        lglTemplateFrameShape shape;    /* Always LGL_TEMPLATE_FRAME_SHAPE_CD. */

        gchar                *id;       /* Id, currently always "0" */
        GList                *layouts;  /* List of lglTemplateLayouts */
        GList                *markups;  /* List of lglTemplateMarkups */
        /* End Common Fields */

        gdouble               r1;     /* Outer radius */
        gdouble               r2;     /* Inner radius (hole) */
        gdouble               w;      /* Clip width, business card CDs */
        gdouble               h;      /* Clip height, business card CDs */
        gdouble               waste;  /* Amount of overprint allowed. */
};

This structure defines the frame for a CD or DVD label. This structure also supports credit-card CD labels.

struct lglTemplateLayout

struct lglTemplateLayout {
        gint                  nx;  /* Number of labels across */
        gint                  ny;  /* Number of labels up and down */

        gdouble               x0;  /* Left of grid from left edge of paper */
        gdouble               y0;  /* Top of grid from top edge of paper */

        gdouble               dx;  /* Horizontal pitch of grid */
        gdouble               dy;  /* Vertical pitch of grid */
};

This structure defines a simple grid layout of labels or cards.

enum lglTemplateMarkupType

This enumeration defines markup types that are supported by libglabels

union lglTemplateMarkup

A union of all possible markup structures. The type of structure is indicated by the type member, which overlays the first field of all other member structures.

struct lglTemplateMarkupMargin

struct lglTemplateMarkupMargin {
        lglTemplateMarkupType  type;  /* Always LGL_TEMPLATE_MARKUP_MARGIN */

        gdouble                size;  /* Margin size */
};

This structure defines a simple margin markup around the perimeter of a label or card.

struct lglTemplateMarkupLine

struct lglTemplateMarkupLine {
        lglTemplateMarkupType  type;   /* Always LGL_TEMPLATE_MARKUP_LINE */

        gdouble                x1, y1; /* 1st endpoint */
        gdouble                x2, y2; /* 2nd endpoint */
};

This structure defines a simple line segment markup.

struct lglTemplateMarkupCircle

struct lglTemplateMarkupCircle {
        lglTemplateMarkupType  type;   /* Always LGL_TEMPLATE_MARKUP_CIRCLE */

        gdouble                x0, y0; /* Center of circle */
        gdouble                r;      /* Radius of circle */
};

This structure defines a simple circle markup.

struct lglTemplateMarkupRect

struct lglTemplateMarkupRect {
        lglTemplateMarkupType  type;   /* Always LGL_TEMPLATE_MARKUP_RECT */

        gdouble                x1, y1; /* Upper left corner */
        gdouble                w, h;   /* Width and height. */
        gdouble                r;      /* Radius of corners. */
};

This structure defines a simple rectangle markup. The rectangle can have rounded corners.

struct lglTemplateMarkupEllipse

struct lglTemplateMarkupEllipse {
        lglTemplateMarkupType  type;   /* Always LGL_TEMPLATE_MARKUP_ELLIPSE */

        gdouble                x1, y1; /* Upper left corner */
        gdouble                w, h;   /* Width and height. */
};

This structure defines a simple elliptical markup.

struct lglTemplateOrigin

struct lglTemplateOrigin {
        gdouble               x, y; /* Label origin relative to upper 
                                     * upper left hand corner of paper */
};

This structure represents the cartesian coordinates of the origin of a label or card on the page. The orign is the upper left corner of the extent of the label or card. These coordinates are relative to the upper left corner of the page.