template

template

Functions

lglTemplate * lgl_template_new ()
lglTemplate * lgl_template_new_from_equiv ()
lglTemplate * lgl_template_dup ()
void lgl_template_free ()
void lgl_template_add_category ()
void lgl_template_add_frame ()
gchar * lgl_template_get_name ()
gboolean lgl_template_do_templates_match ()
gboolean lgl_template_does_brand_match ()
gboolean lgl_template_does_page_size_match ()
gboolean lgl_template_does_category_match ()
gboolean lgl_template_are_templates_identical ()
lglTemplateFrame * lgl_template_frame_rect_new ()
lglTemplateFrame * lgl_template_frame_ellipse_new ()
lglTemplateFrame * lgl_template_frame_round_new ()
lglTemplateFrame * lgl_template_frame_cd_new ()
lglTemplateFrame * lgl_template_frame_dup ()
void lgl_template_frame_free ()
void lgl_template_frame_add_layout ()
void lgl_template_frame_add_markup ()
void lgl_template_frame_get_size ()
gint lgl_template_frame_get_n_labels ()
lglTemplateOrigin * lgl_template_frame_get_origins ()
gchar * lgl_template_frame_get_layout_description ()
gchar * lgl_template_frame_get_size_description ()
lglTemplateLayout * lgl_template_layout_new ()
lglTemplateLayout * lgl_template_layout_dup ()
void lgl_template_layout_free ()
lglTemplateMarkup * lgl_template_markup_margin_new ()
lglTemplateMarkup * lgl_template_markup_line_new ()
lglTemplateMarkup * lgl_template_markup_circle_new ()
lglTemplateMarkup * lgl_template_markup_rect_new ()
lglTemplateMarkup * lgl_template_markup_ellipse_new ()
lglTemplateMarkup * lgl_template_markup_dup ()
void lgl_template_markup_free ()
void lgl_template_print ()

Types and Values

Includes

#include <libglabels/lgl-template.h>

Description

Functions

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.

Parameters

brand

Template brand

 

part

Template part name/number

 

description

Template descriptions

 

paper_id

Page size id

 

page_width

Page width in points, set to zero unless paper_id="Other"

 

page_height

Page height in points, set to zero unless paper_id="Other"

 

Returns

pointer to a newly allocated lglTemplate structure.


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.

Parameters

brand

Template brand

 

part

Template part name/number

 

equiv_part

Name of equivalent part to base template on

 

Returns

pointer to a newly allocated lglTemplate structure.


lgl_template_dup ()

lglTemplate *
lgl_template_dup (const lglTemplate *orig_template);

This function duplicates a template structure.

Parameters

orig_template

Template to duplicate.

 

Returns

a newly allocated lglTemplate structure.


lgl_template_free ()

void
lgl_template_free (lglTemplate *template);

This function frees all memory associated with given template structure.

Parameters

template

Template to free.

 

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.

Parameters

template

Pointer to template structure

 

category_id

Category ID string

 

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.

Parameters

template

Pointer to template structure

 

frame

Pointer to frame structure

 

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.

Parameters

template

Pointer to template structure to test

 

Returns

A pointer to a newly allocated name string. Should be freed with g_free().


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.

Parameters

template1

Pointer to 1st template structure to test

 

template2

Pointer to 2nd template structure to test

 

Returns

TRUE if the two templates match.


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.

Parameters

template

Pointer to template structure to test

 

brand

Brand string

 

Returns

TRUE if 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.

Parameters

template

Pointer to template structure to test

 

paper_id

Page size ID string

 

Returns

TRUE if the template matches the given page size 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.

Parameters

template

Pointer to template structure to test

 

category_id

Category ID string

 

Returns

TRUE if the template matches 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.

Parameters

template1

Pointer to 1st template structure to test

 

template2

Pointer to 2nd template structure to test

 

Returns

TRUE if the two templates are identical.


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.

Parameters

id

ID of frame. (This should currently always be "0").

 

w

width of frame in points.

 

h

height of frame in points.

 

r

radius of rounded corners in points. (Should be 0 for square corners.)

 

x_waste

Amount of overprint to allow in the horizontal direction.

 

y_waste

Amount of overprint to allow in the vertical direction.

 

Returns

Pointer to newly allocated lglTemplateFrame structure.


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.

Parameters

id

ID of frame. (This should currently always be "0").

 

w

width of frame in points.

 

h

height of frame in points.

 

waste

Amount of overprint to allow in points.

 

Returns

Pointer to newly allocated lglTemplateFrame structure.


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.

Parameters

id

ID of frame. (This should currently always be "0").

 

r

radius of label in points.

 

waste

Amount of overprint to allow.

 

Returns

Pointer to newly allocated lglTemplateFrame structure.


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.

Parameters

id

ID of frame. (This should currently always be "0").

 

r1

outer radius of label in points.

 

r2

radius of center hole in points.

 

w

clip width of frame in points for business card CDs. Should be 0 for no clipping.

 

h

clip height of frame in points for business card CDs. Should be 0 for no clipping.

 

waste

Amount of overprint to allow.

 

Returns

Pointer to newly allocated lglTemplateFrame structure.


lgl_template_frame_dup ()

lglTemplateFrame *
lgl_template_frame_dup (const lglTemplateFrame *orig_frame);

This function duplicates a template frame structure.

Parameters

orig_frame

Frame to duplicate.

 

Returns

a newly allocated lglTemplateFrame structure.


lgl_template_frame_free ()

void
lgl_template_frame_free (lglTemplateFrame *frame);

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

Parameters

frame

Frame to free.

 

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.

Parameters

frame

Pointer to template frame to add layout to.

 

layout

Pointer to layout structure to add to 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.

Parameters

frame

Pointer to template frame to add markup to.

 

markup

Pointer to markup structure to add to 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.

Parameters

frame

lglTemplateFrame structure to query

 

w

pointer to location to receive width of frame

 

h

pointer to location to receive height of frame

 

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.

Parameters

frame

lglTemplateFrame structure to query

 

Returns

number of labels per sheet.


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().

Parameters

frame

lglTemplateFrame structure to query

 

Returns

A newly allocated array of lglTemplateOrigin structures.


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.

Parameters

frame

lglTemplateFrame structure to query

 

Returns

a newly allocation description string.


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.

Parameters

frame

lglTemplateFrame structure to query

 

units

lglUnits

 

Returns

a newly allocation description string.


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.

Parameters

nx

Number of labels across.

 

ny

Number of labels down.

 

x0

X coordinate of the top-left corner of the top-left label in the layout in points.

 

y0

Y coordinate of the top-left corner of the top-left label in the layout in points.

 

dx

Horizontal pitch in points. This is the distance from left-edge to left-edge.

 

dy

Vertical pitch in points. This is the distance from top-edge to top-edge.

 

Returns

a newly allocated lglTemplateLayout structure.


lgl_template_layout_dup ()

lglTemplateLayout *
lgl_template_layout_dup (const lglTemplateLayout *orig_layout);

This function duplicates a template layout structure.

Parameters

orig_layout

Layout to duplicate.

 

Returns

a newly allocated lglTemplateLayout structure.


lgl_template_layout_free ()

void
lgl_template_layout_free (lglTemplateLayout *layout);

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

Parameters

layout

Layout to free.

 

lgl_template_markup_margin_new ()

lglTemplateMarkup *
lgl_template_markup_margin_new (gdouble size);

This function creates a new margin markup structure.

Parameters

size

margin size in points.

 

Returns

a newly allocated lglTemplateMarkup 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.

Parameters

x1

x coordinate of first endpoint.

 

y1

y coordinate of first endpoint.

 

x2

x coordinate of second endpoint.

 

y2

y coordinate of second endpoint.

 

Returns

a newly allocated lglTemplateMarkup 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.

Parameters

x0

x coordinate of center of circle.

 

y0

y coordinate of center of circle.

 

r

radius of circle.

 

Returns

a newly allocated lglTemplateMarkup 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.

Parameters

x1

x coordinate of top-left corner of rectangle.

 

y1

y coordinate of top-left corner of rectangle.

 

w

width of rectangle.

 

h

height of rectangle.

 

r

radius of rounded corner.

 

Returns

a newly allocated lglTemplateMarkup 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.

Parameters

x1

x coordinate of top-left corner of ellipse.

 

y1

y coordinate of top-left corner of ellipse.

 

w

width of ellipse.

 

h

height of ellipse.

 

Returns

a newly allocated lglTemplateMarkup structure.


lgl_template_markup_dup ()

lglTemplateMarkup *
lgl_template_markup_dup (const lglTemplateMarkup *orig_markup);

This function duplicates a template markup structure.

Parameters

orig_markup

Markup to duplicate.

 

Returns

a newly allocated lglTemplateMarkup structure.


lgl_template_markup_free ()

void
lgl_template_markup_free (lglTemplateMarkup *markup);

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

Parameters

markup

Markup to free.

 

lgl_template_print ()

void
lgl_template_print (const lglTemplate *template);

Print template details (for debugging purposes).

Parameters

template

template

 

Types and Values

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;
};

enum lglTemplateFrameShape

Members

LGL_TEMPLATE_FRAME_SHAPE_RECT

   

LGL_TEMPLATE_FRAME_SHAPE_ELLIPSE

   

LGL_TEMPLATE_FRAME_SHAPE_ROUND

   

LGL_TEMPLATE_FRAME_SHAPE_CD

   

union lglTemplateFrame


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 */
};

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. */
};

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. */
};

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. */
};

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. */
};

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 */
};

enum lglTemplateMarkupType

Members

LGL_TEMPLATE_MARKUP_MARGIN

   

LGL_TEMPLATE_MARKUP_LINE

   

LGL_TEMPLATE_MARKUP_CIRCLE

   

LGL_TEMPLATE_MARKUP_RECT

   

LGL_TEMPLATE_MARKUP_ELLIPSE

   

union lglTemplateMarkup


struct lglTemplateMarkupMargin

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

        gdouble                size;  /* Margin size */
};

struct lglTemplateMarkupLine

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

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

struct lglTemplateMarkupCircle

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

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

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. */
};

struct lglTemplateMarkupEllipse

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

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

struct lglTemplateOrigin

struct lglTemplateOrigin {
        gdouble               x, y; /* Label origin relative to upper

                                     * upper left hand corner of paper */
};