The lglTemplate Structure: LibGlabels 3.0 Reference Manual

## The lglTemplate Structure The lglTemplate Structure — How templates are represented in memory |

## 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

struct | lglTemplate
enum | lglTemplateFrameShape
union | lglTemplateFrame
struct | lglTemplateFrameAll
struct | lglTemplateFrameRect
struct | lglTemplateFrameEllipse
struct | lglTemplateFrameRound
struct | lglTemplateFrameCD
struct | lglTemplateLayout
enum | lglTemplateMarkupType
union | lglTemplateMarkup
struct | lglTemplateMarkupMargin
struct | lglTemplateMarkupLine
struct | lglTemplateMarkupCircle
struct | lglTemplateMarkupRect
struct | lglTemplateMarkupEllipse
struct | lglTemplateOrigin

## Includes

    #include <libglabels/lgl-template.h>

## Description

This section describes a set of structures that represent a template in memory. It also describes functions to help create and interpret these structures.

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

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

#### Members

gchar *`brand`; | Vendor or brand name of label or card. E.g. "Avery." |
gchar *`part`; | Part name or number of label or card. E.g. "8160." |
gchar *`equiv_part`; | Part name or number of a part with identical layout. Must be from same vendor. |
gchar *`description`; | A description of the template. E.g. "Mailing labels." |
gchar *`paper_id`; | A paper ID. E.g. "A4" or "US-Letter." |
gdouble `page_width`; | Page width in points. Used only if paper_id is "Other." |
gdouble `page_height`; | Page height in points. Used only if paper_id is "Other." |
gchar *`product_url`; | URL to a webpage describing product. |
GList *`category_ids`; | A list of category IDs that this template belongs to. |
GList *`frames`; | A list of (lglTemplateFrame *) structures. GLabels currently only supports one frame per template -- future versions may support multiple frames per template. |

### enum lglTemplateFrameShape

This enumeration defines frame types that are supported by libglabels

#### Members

LGL_TEMPLATE_FRAME_SHAPE_RECT | A rectangular frame. (May have rounded corners.) |
LGL_TEMPLATE_FRAME_SHAPE_ELLIPSE | An elliptical frame. |
LGL_TEMPLATE_FRAME_SHAPE_ROUND | A round frame. |
LGL_TEMPLATE_FRAME_SHAPE_CD | A CD or DVD frame. (Includes credit-card style CDs.) |

### 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.

#### Members

lglTemplateFrameShape `shape`; | The shape of the frame. |
gchar *`id`; | Reserved for future use. Should always be zero. |
GList *`layouts`; | A list of (lglTemplateLayout *) structures. Typically a frame will have a single layout, representing a simple grid of labels or cards. If the layout of labels or cards is more complex, multiple (lglTemplateLayout *) structures may be needed. |
GList *`markups`; | A list of (lglTemplateMarkup *) structures, which represent non-printing markup lines. |

### 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.

#### Members

lglTemplateFrameShape `shape`; | Common field. Always LGL_TEMPLATE_FRAME_SHAPE_RECT for lglTemplateFrameRect. |
gchar *`id`; | Common field. See lglTemplateFrameAll. |
GList *`layouts`; | Common field. See lglTemplateFrameAll. |
GList *`markups`; | Common field. See lglTemplateFrameAll. |
gdouble `w`; | Width of label or card in points. |
gdouble `h`; | Height of label or card in points. |
gdouble `r`; | Radius of corners in points. |
gdouble `x_waste`; | Amount of horizontal over-print to allow in points. |
gdouble `y_waste`; | Amount of vertical over-print to allow in points. |

### 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.

#### Members

lglTemplateFrameShape `shape`; | Common field. Always LGL_TEMPLATE_FRAME_SHAPE_ELLIPSE for lglTemplateFrameEllipse. |
gchar *`id`; | Common field. See lglTemplateFrameAll. |
GList *`layouts`; | Common field. See lglTemplateFrameAll. |
GList *`markups`; | Common field. See lglTemplateFrameAll. |
gdouble `w`; | Width of label or card in points. |
gdouble `h`; | Height of label or card in points. |
gdouble `waste`; | Amount of over-print to allow in points. |

### 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.

#### Members

lglTemplateFrameShape `shape`; | Common field. Always LGL_TEMPLATE_FRAME_SHAPE_ROUND for lglTemplateFrameRound. |
gchar *`id`; | Common field. See lglTemplateFrameAll. |
GList *`layouts`; | Common field. See lglTemplateFrameAll. |
GList *`markups`; | Common field. See lglTemplateFrameAll. |
gdouble `r`; | Radius of label or card in points. |
gdouble `waste`; | Amount of over-print to allow in points. |

### 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.

#### Members

lglTemplateFrameShape `shape`; | Common field. Always LGL_TEMPLATE_FRAME_SHAPE_CD for lglTemplateFrameCD. |
gchar *`id`; | Common field. See lglTemplateFrameAll. |
GList *`layouts`; | Common field. See lglTemplateFrameAll. |
GList *`markups`; | Common field. See lglTemplateFrameAll. |
gdouble `r1`; | Outer radius of label in points. |
gdouble `r2`; | Radius of center hole in points. |
gdouble `w`; | Clip width in points. Used for credit-card CD labels. This field is ignored if zero. |
gdouble `h`; | Clip height in points. Used for credit-card CD labels. This field is ignored if zero. |
gdouble `waste`; | Amount of over-print to allow in points. |

### 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.

#### Members

gint `nx`; | Number of labels or cards across in the grid (horizontal). |
gint `ny`; | Number of labels or cards down in the grid (vertical). |
gdouble `x0`; | Distance (in points) from the left edge of page to the left edge of the left column of cards or labels in the layout. |
gdouble `y0`; | Distance (in points) from the top edge of page to the top edge of the top row of cards or labels in the layout. |
gdouble `dx`; | Horizontal pitch of grid in points. This is the distance from left edge to left edge (not the gap between labels or cards). |
gdouble `dy`; | Vertical pitch of grid in points. This is the distance from top edge to top edge (not the gap between labels or cards). |

### enum lglTemplateMarkupType

This enumeration defines markup types that are supported by libglabels

#### Members

LGL_TEMPLATE_MARKUP_MARGIN | A margin line around perimeter of label or card. |
LGL_TEMPLATE_MARKUP_LINE | A simple line segment. |
LGL_TEMPLATE_MARKUP_CIRCLE | A circle. |
LGL_TEMPLATE_MARKUP_RECT | A rectangle. Possibly with rounded corners. |
LGL_TEMPLATE_MARKUP_ELLIPSE | An ellipse. |

### 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.

#### Members

lglTemplateMarkupType `type`; | Common field. Always LGL_TEMPLATE_MARKUP_MARGIN for lglTemplateMarkupMargin. |
gdouble `size`; | Distance of margin from edge of 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.

#### Members

lglTemplateMarkupType `type`; | Common field. Always LGL_TEMPLATE_MARKUP_LINE for lglTemplateMarkupLine. |
gdouble `x1`; | Distance (in points) of first endpoint from left edge of label or card. |
gdouble `y1`; | Distance (in points) of first endpoint from top edge of label or card. |
gdouble `x2`; | Distance (in points) of second endpoint from left edge of label or card. |
gdouble `y2`; | Distance (in points) of second endpoint from top edge of label or card. |

### 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.

#### Members

lglTemplateMarkupType `type`; | Common field. Always LGL_TEMPLATE_MARKUP_CIRCLE for lglTemplateMarkupCircle. |
gdouble `x0`; | Distance (in points) of vertex from left edge of label or card. |
gdouble `y0`; | Distance (in points) of vertex from top edge of label or card. |
gdouble `r`; | Radius of circle in points. |

### 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.

#### Members

lglTemplateMarkupType `type`; | Common field. Always LGL_TEMPLATE_MARKUP_RECT for lglTemplateMarkupRect. |
gdouble `x1`; | Distance (in points) of left edge of markup from left edge of label or card. |
gdouble `y1`; | Distance (in points) of top edge of markup from top edge of label or card. |
gdouble `w`; | Width of rectangle in points. |
gdouble `h`; | Height of rectangle in points. |
gdouble `r`; | Radius of corners in points. Should be zero for sharp 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.

#### Members

lglTemplateMarkupType `type`; | Common field. Always LGL_TEMPLATE_MARKUP_ELLIPSE for lglTemplateMarkupEllipse. |
gdouble `x1`; | Distance (in points) of left edge of markup from left edge of label or card. |
gdouble `y1`; | Distance (in points) of top edge of markup from top edge of label or card. |
gdouble `w`; | Width of rectangle in points. |
gdouble `h`; | Height of rectangle in points. |

### 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.

#### Members

gdouble `x`; | Distance in points from top edge of page. |
gdouble `y`; | Distance in points from left edge of page. |