memphis-rule

memphis-rule — Describes a drawing rule.

Synopsis

                    MemphisRule;
                    MemphisRuleAttr;
#define             MEMPHIS_RULE                        (obj)
enum                MemphisRuleType;
GType               memphis_rule_get_type               (void);
#define             MEMPHIS_TYPE_RULE
MemphisRule *       memphis_rule_new                    (void);
MemphisRule *       memphis_rule_copy                   (const MemphisRule *rule);
void                memphis_rule_free                   (MemphisRule *rule);

Description

A boxed struct to describe a drawing rule for the MemphisRuleSet.

Details

MemphisRule

typedef struct {
  gchar **keys;
  gchar **values;
  MemphisRuleType type;
  MemphisRuleAttr *polygon;
  MemphisRuleAttr *line;
  MemphisRuleAttr *border;
  MemphisRuleAttr *text;
} MemphisRule;

Defines a drawing rule for the MemphisRuleSet.

gchar **keys;

an array of key strings

gchar **values;

an array of value strings

MemphisRuleType type;

the type of the rule

MemphisRuleAttr *polygon;

a pointer to the polygon or NULL

MemphisRuleAttr *line;

a pointer to the line or NULL

MemphisRuleAttr *border;

a pointer to the border or NULL

MemphisRuleAttr *text;

a pointer to the text or NULL

Since 0.1


MemphisRuleAttr

typedef struct {
  guint8 z_min;
  guint8 z_max;
  guint8 color_red;
  guint8 color_green;
  guint8 color_blue;
  guint8 color_alpha;
  gchar *style;
  gdouble size;
} MemphisRuleAttr;

Defines the drawing attributes for a MemphisRule.

guint8 z_min;

minimum visible zoom level

guint8 z_max;

maximum visible zoom level

guint8 color_red;

red component, between 0 and 255

guint8 color_green;

green component, between 0 and 255

guint8 color_blue;

blue component, between 0 and 255

guint8 color_alpha;

transparency component, between 0 and 255

gchar *style;

field for future use (line style, polygon pattern...)

gdouble size;

the size

Since 0.1


MEMPHIS_RULE()

#define MEMPHIS_RULE(obj)     ((MemphisRule *) (obj))

obj :


enum MemphisRuleType

typedef enum {
  MEMPHIS_RULE_TYPE_UNKNOWN,
  MEMPHIS_RULE_TYPE_NODE,
  MEMPHIS_RULE_TYPE_WAY,
  MEMPHIS_RULE_TYPE_RELATION
} MemphisRuleType;

Defines a the data type of the rule. Only ways are supported in Memphis 0.1.x.

MEMPHIS_RULE_TYPE_UNKNOWN

unknown

MEMPHIS_RULE_TYPE_NODE

a node

MEMPHIS_RULE_TYPE_WAY

a way

MEMPHIS_RULE_TYPE_RELATION

a realtion

Since 0.1


memphis_rule_get_type ()

GType               memphis_rule_get_type               (void);

Returns :


MEMPHIS_TYPE_RULE

#define MEMPHIS_TYPE_RULE (memphis_rule_get_type ())


memphis_rule_new ()

MemphisRule *       memphis_rule_new                    (void);

Returns :

a new MemphisRule.

Since 0.1


memphis_rule_copy ()

MemphisRule *       memphis_rule_copy                   (const MemphisRule *rule);

rule :

a MemphisRule

Returns :

a copy of the rule.

Since 0.1


memphis_rule_free ()

void                memphis_rule_free                   (MemphisRule *rule);

Frees the memory of a MemphisRule.

rule :

a MemphisRule

Since 0.1