Changeset 158


Ignore:
Timestamp:
Oct 17, 2009, 3:35:00 PM (5 years ago)
Author:
simon
Message:

Replace MemphisRule? with a new boxed-struct implementation

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/memphis-rule-set.c

    r156 r158  
    256256      if (drw->type == POLYGONE) 
    257257        { 
    258           rule->polygon_color[0] = drw->color[0]; 
    259           rule->polygon_color[1] = drw->color[1]; 
    260           rule->polygon_color[2] = drw->color[2]; 
    261           rule->polygon_z[0] = drw->minzoom; 
    262           rule->polygon_z[1] = drw->maxzoom; 
     258          rule->polygon = g_slice_new0 (MemphisRuleAttr); 
     259          rule->polygon->color_red = drw->color[0]; 
     260          rule->polygon->color_green = drw->color[1]; 
     261          rule->polygon->color_blue = drw->color[2]; 
     262          rule->polygon->color_alpha = 255; 
     263          rule->polygon->z_min = drw->minzoom; 
     264          rule->polygon->z_max = drw->maxzoom; 
    263265          // TODO support pattern 
    264266        } 
     
    266268        { 
    267269          if (line_seen) { 
    268             rule->line_color[0] = drw->color[0]; 
    269             rule->line_color[1] = drw->color[1]; 
    270             rule->line_color[2] = drw->color[2]; 
    271             rule->line_size = drw->width; 
    272             rule->line_z[0] = drw->minzoom; 
    273             rule->line_z[1] = drw->maxzoom; 
     270            rule->line = g_slice_new0 (MemphisRuleAttr); 
     271            rule->line->color_red = drw->color[0]; 
     272            rule->line->color_green = drw->color[1]; 
     273            rule->line->color_blue = drw->color[2]; 
     274            rule->line->color_alpha = 255; 
     275            rule->line->size = drw->width; 
     276            rule->line->z_min = drw->minzoom; 
     277            rule->line->z_max = drw->maxzoom; 
    274278          } else { 
    275             rule->border_color[0] = drw->color[0]; 
    276             rule->border_color[1] = drw->color[1]; 
    277             rule->border_color[2] = drw->color[2]; 
    278             rule->border_size = drw->width; 
    279             rule->border_z[0] = drw->minzoom; 
    280             rule->border_z[1] = drw->maxzoom; 
     279            rule->border = g_slice_new0 (MemphisRuleAttr); 
     280            rule->border->color_red = drw->color[0]; 
     281            rule->border->color_green = drw->color[1]; 
     282            rule->border->color_blue = drw->color[2]; 
     283            rule->border->color_alpha = 255; 
     284            rule->border->size = drw->width; 
     285            rule->border->z_min = drw->minzoom; 
     286            rule->border->z_max = drw->maxzoom; 
    281287            line_seen = TRUE; 
    282288          } 
     
    284290      else if (drw->type == TEXT) 
    285291        { 
    286           rule->text_color[0] = drw->color[0]; 
    287           rule->text_color[1] = drw->color[1]; 
    288           rule->text_color[2] = drw->color[2]; 
    289           rule->text_size = drw->width; 
    290           rule->text_z[0] = drw->minzoom; 
    291           rule->text_z[1] = drw->maxzoom; 
     292          rule->text = g_slice_new0 (MemphisRuleAttr); 
     293          rule->text->color_red = drw->color[0]; 
     294          rule->text->color_green = drw->color[1]; 
     295          rule->text->color_blue = drw->color[2]; 
     296          rule->text->color_alpha = 255; 
     297          rule->text->size = drw->width; 
     298          rule->text->z_min = drw->minzoom; 
     299          rule->text->z_max = drw->maxzoom; 
    292300        } 
    293301      drw = drw->next; 
     
    311319  cfgDraw *drw = NULL; 
    312320 
    313   if (rule->polygon_color[0] != -1) 
     321  if (rule->polygon != NULL) 
    314322    { 
    315323      tmp = g_new (cfgDraw, 1); 
    316324      tmp->next = drw; 
    317325      tmp->type = POLYGONE; 
    318       tmp->minzoom = rule->polygon_z[0]; 
    319       tmp->maxzoom = rule->polygon_z[1]; 
    320       tmp->color[0] = rule->polygon_color[0]; 
    321       tmp->color[1] = rule->polygon_color[1]; 
    322       tmp->color[2] = rule->polygon_color[2]; 
     326      tmp->minzoom = rule->polygon->z_min; 
     327      tmp->maxzoom = rule->polygon->z_max; 
     328      tmp->color[0] = rule->polygon->color_red; 
     329      tmp->color[1] = rule->polygon->color_green; 
     330      tmp->color[2] = rule->polygon->color_blue; 
    323331      drw = tmp; 
    324332    } 
    325   if (rule->line_color[0] != -1) 
     333  if (rule->line != NULL) 
    326334    { 
    327335      tmp = g_new (cfgDraw, 1); 
    328336      tmp->next = drw; 
    329337      tmp->type = LINE; 
    330       tmp->minzoom = rule->line_z[0]; 
    331       tmp->maxzoom = rule->line_z[1]; 
    332       tmp->color[0] = rule->line_color[0]; 
    333       tmp->color[1] = rule->line_color[1]; 
    334       tmp->color[2] = rule->line_color[2]; 
    335       tmp->width = rule->line_size; 
     338      tmp->minzoom = rule->line->z_min; 
     339      tmp->maxzoom = rule->line->z_max; 
     340      tmp->color[0] = rule->line->color_red; 
     341      tmp->color[1] = rule->line->color_green; 
     342      tmp->color[2] = rule->line->color_blue; 
     343      tmp->width = rule->line->size; 
    336344      drw = tmp; 
    337345    } 
    338   if (rule->border_color[0] != -1) 
     346  if (rule->border != NULL) 
    339347    { 
    340348      tmp = g_new (cfgDraw, 1); 
    341349      tmp->next = drw; 
    342350      tmp->type = LINE; 
    343       tmp->minzoom = rule->border_z[0]; 
    344       tmp->maxzoom = rule->border_z[1]; 
    345       tmp->color[0] = rule->border_color[0]; 
    346       tmp->color[1] = rule->border_color[1]; 
    347       tmp->color[2] = rule->border_color[2]; 
    348       tmp->width = rule->border_size; 
     351      tmp->minzoom = rule->border->z_min; 
     352      tmp->maxzoom = rule->border->z_max; 
     353      tmp->color[0] = rule->border->color_red; 
     354      tmp->color[1] = rule->border->color_green; 
     355      tmp->color[2] = rule->border->color_blue; 
     356      tmp->width = rule->border->size; 
    349357      drw = tmp; 
    350358    } 
    351   if (rule->text_color[0] != -1) 
     359  if (rule->text != NULL) 
    352360    { 
    353361      tmp = g_new (cfgDraw, 1); 
    354362      tmp->next = drw; 
    355363      tmp->type = TEXT; 
    356       tmp->minzoom = rule->text_z[0]; 
    357       tmp->maxzoom = rule->text_z[1]; 
    358       tmp->color[0] = rule->text_color[0]; 
    359       tmp->color[1] = rule->text_color[1]; 
    360       tmp->color[2] = rule->text_color[2]; 
    361       tmp->width = rule->text_size; 
     364      tmp->minzoom = rule->text->z_min; 
     365      tmp->maxzoom = rule->text->z_max; 
     366      tmp->color[0] = rule->text->color_red; 
     367      tmp->color[1] = rule->text->color_green; 
     368      tmp->color[2] = rule->text->color_blue; 
     369      tmp->width = rule->text->size; 
    362370      drw = tmp; 
    363371    } 
     
    501509memphis_rule_set_set_rule (MemphisRuleSet *self, MemphisRule *rule) 
    502510{ 
    503   g_return_if_fail (MEMPHIS_IS_RULE_SET (self) && MEMPHIS_IS_RULE (rule)); 
     511  g_return_if_fail (MEMPHIS_IS_RULE_SET (self) && MEMPHIS_RULE (rule)); 
    504512 
    505513  MemphisRuleSetPrivate *priv = MEMPHIS_RULE_SET_GET_PRIVATE (self); 
  • trunk/src/memphis-rule.c

    r156 r158  
    11/* 
    2  * Memphis - Cairo Rederer for OSM in C 
    3  * Copyright (C) 2009  Simon Wenner <simon@wenner.ch> 
     2 * Copyright (C) 2009 Simon Wenner <simon@wenner.ch> 
     3 * 
     4 * This file is inspired by clutter-color.c which is 
     5 * Copyright (C) 2006 OpenedHand, and has the same license. 
    46 * 
    57 * This library is free software; you can redistribute it and/or 
     
    1820 */ 
    1921 
     22/** 
     23 * SECTION:memphis-rule 
     24 * @short_description: A basic struct to describe a drawing rule for 
     25 * the #MemphisRuleSet. 
     26 */ 
     27 
    2028#include "memphis-rule.h" 
    2129 
    22 G_DEFINE_TYPE (MemphisRule, memphis_rule, G_TYPE_OBJECT) 
     30static void 
     31rule_attr_free (MemphisRuleAttr * attr) 
     32{ 
     33  g_assert (attr != NULL); 
    2334 
    24 #define GET_PRIVATE(o) \ 
    25   (G_TYPE_INSTANCE_GET_PRIVATE ((o), MEMPHIS_TYPE_RULE, MemphisRulePrivate)) 
     35  if (attr->style) 
     36    g_free (attr->style); 
    2637 
    27 typedef struct _MemphisRulePrivate MemphisRulePrivate; 
    28  
    29 /* 
    30 struct _MemphisRulePrivate { 
    31     int dummy; 
    32 }; 
    33 */ 
    34  
    35 static void 
    36 memphis_rule_get_property (GObject *object, guint property_id, 
    37                               GValue *value, GParamSpec *pspec) 
    38 { 
    39   switch (property_id) { 
    40   default: 
    41     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); 
    42   } 
     38  g_slice_free (MemphisRuleAttr, attr); 
    4339} 
    4440 
    45 static void 
    46 memphis_rule_set_property (GObject *object, guint property_id, 
    47                               const GValue *value, GParamSpec *pspec) 
     41static MemphisRuleAttr * 
     42rule_attr_copy (MemphisRuleAttr * attr) 
    4843{ 
    49   switch (property_id) { 
    50   default: 
    51     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); 
    52   } 
     44  g_assert (attr != NULL); 
     45 
     46  MemphisRuleAttr * new; 
     47  new = g_slice_dup (MemphisRuleAttr, attr); 
     48 
     49  if (attr->style) 
     50    new->style = g_strdup (attr->style); 
     51 
     52  return new; 
    5353} 
    5454 
    55 static void 
    56 memphis_rule_dispose (GObject *object) 
     55GType 
     56memphis_rule_get_type (void) 
    5757{ 
    58   G_OBJECT_CLASS (memphis_rule_parent_class)->dispose (object); 
     58  static GType type = 0; 
     59 
     60  if (G_UNLIKELY (type == 0)) 
     61    { 
     62      type = g_boxed_type_register_static ( 
     63          g_intern_static_string ("MemphisRule"), 
     64          (GBoxedCopyFunc) memphis_rule_copy, 
     65          (GBoxedFreeFunc) memphis_rule_free); 
     66    } 
     67 
     68  return type; 
    5969} 
    6070 
    61 static void 
    62 memphis_rule_finalize (GObject *object) 
     71/** 
     72 * memphis_rule_new: 
     73 * 
     74 * Creates a newly allocated #MemphisRule to be freed 
     75 * with memphis_rule_free(). 
     76 * 
     77 * Returns: a #MemphisRule 
     78 * 
     79 * Since: 0.1 
     80 */ 
     81MemphisRule * 
     82memphis_rule_new (void) 
    6383{ 
    64   MemphisRule *self = MEMPHIS_RULE (object); 
    65  
    66   if (self->keys != NULL) 
    67     g_strfreev (self->keys); 
    68   if (self->values != NULL) 
    69     g_strfreev (self->values); 
    70   G_OBJECT_CLASS (memphis_rule_parent_class)->finalize (object); 
     84  MemphisRule *rule = g_slice_new (MemphisRule); 
     85  rule->keys = NULL; 
     86  rule->values = NULL; 
     87  rule->type = MEMPHIS_RULE_TYPE_UNKNOWN; 
     88  rule->polygon = NULL; 
     89  rule->line = NULL; 
     90  rule->border = NULL; 
     91  rule->text = NULL; 
     92  return rule; 
    7193} 
    7294 
    73 static void 
    74 memphis_rule_class_init (MemphisRuleClass *klass) 
     95/** 
     96 * memphis_rule_copy: 
     97 * @bbox: a #MemphisRule 
     98 * 
     99 * Makes a copy of the bounding box structure. The result must be 
     100 * freed using memphis_rule_free(). 
     101 * 
     102 * Returns: an allocated copy of @rule. 
     103 * 
     104 * Since: 0.1 
     105 */ 
     106MemphisRule * 
     107memphis_rule_copy (const MemphisRule *rule) 
    75108{ 
    76   GObjectClass *object_class = G_OBJECT_CLASS (klass); 
     109  if (G_UNLIKELY (rule == NULL)) 
     110    return NULL; 
    77111 
    78   //g_type_class_add_private (klass, sizeof (MemphisRulePrivate)); 
     112  MemphisRule *res; 
     113  res = g_slice_dup (MemphisRule, rule); 
    79114 
    80   object_class->get_property = memphis_rule_get_property; 
    81   object_class->set_property = memphis_rule_set_property; 
    82   object_class->dispose = memphis_rule_dispose; 
    83   object_class->finalize = memphis_rule_finalize; 
     115  if (rule->keys) 
     116    res->keys = g_strdupv (rule->keys); 
     117  if (rule->values) 
     118    res->values = g_strdupv (rule->values); 
     119  if (rule->polygon) 
     120    res->polygon = rule_attr_copy (rule->polygon); 
     121  if (rule->line) 
     122    res->line = rule_attr_copy (rule->line); 
     123  if (rule->border) 
     124    res->border = rule_attr_copy (rule->border); 
     125  if (rule->text) 
     126    res->text = rule_attr_copy (rule->text); 
     127 
     128  return res; 
    84129} 
    85130 
    86 static void 
    87 memphis_rule_init (MemphisRule *self) 
     131/** 
     132 * memphis_rule_free: 
     133 * @bbox: a #MemphisRule 
     134 * 
     135 * Frees a bounding box structure created with memphis_rule_new() or 
     136 * memphis_rule_copy(). 
     137 * 
     138 * Since: 0.6 
     139 */ 
     140void 
     141memphis_rule_free (MemphisRule *rule) 
    88142{ 
    89   self->keys = NULL; 
    90   self->values = NULL; 
    91   self->type = MEMPHIS_RULE_TYPE_UNKNOWN; 
    92143 
    93   self->polygon_color[0] = -1; 
    94   self->polygon_color[1] = -1; 
    95   self->polygon_color[2] = -1; 
    96   self->polygon_z[0] = -1; 
    97   self->polygon_z[1] = -1; 
     144  if (G_UNLIKELY (rule == NULL)) 
     145    return; 
    98146 
    99   self->line_color[0] = -1; 
    100   self->line_color[1] = -1; 
    101   self->line_color[2] = -1; 
    102   self->line_size = -1.0; 
    103   self->line_z[0] = -1; 
    104   self->line_z[1] = -1; 
     147  if (rule->keys) 
     148    g_strfreev (rule->keys); 
     149  if (rule->values) 
     150    g_strfreev (rule->values); 
     151  if (rule->polygon) 
     152    rule_attr_free (rule->polygon); 
     153  if (rule->line) 
     154    rule_attr_free (rule->line); 
     155  if (rule->border) 
     156    rule_attr_free (rule->border); 
     157  if (rule->text) 
     158    rule_attr_free (rule->text); 
    105159 
    106   self->border_color[0] = -1; 
    107   self->border_color[1] = -1; 
    108   self->border_color[2] = -1; 
    109   self->border_size = -1.0; 
    110   self->border_z[0] = -1; 
    111   self->border_z[1] = -1; 
    112  
    113   self->text_color[0] = -1; 
    114   self->text_color[1] = -1; 
    115   self->text_color[2] = -1; 
    116   self->text_size = -1.0; 
    117   self->text_z[0] = -1; 
    118   self->text_z[1] = -1; 
     160  g_slice_free (MemphisRule, rule); 
    119161} 
    120  
    121 MemphisRule* 
    122 memphis_rule_new (void) 
    123 { 
    124   return g_object_new (MEMPHIS_TYPE_RULE, NULL); 
    125 } 
    126  
    127 void 
    128 memphis_rule_free (MemphisRule* rule) 
    129 { 
    130   g_object_unref (rule); 
    131 } 
  • trunk/src/memphis-rule.h

    r156 r158  
    11/* 
    2  * Memphis - Cairo Rederer for OSM in C 
    3  * Copyright (C) 2009  Simon Wenner <simon@wenner.ch> 
     2 * Copyright (C) 2009 Simon Wenner <simon@wenner.ch> 
    43 * 
    54 * This library is free software; you can redistribute it and/or 
     
    1817 */ 
    1918 
    20 #ifndef _MEMPHIS_RULE 
    21 #define _MEMPHIS_RULE 
     19#ifndef MEMPHIS_RULE_H 
     20#define MEMPHIS_RULE_H 
    2221 
    2322#include <glib-object.h> 
     
    2524G_BEGIN_DECLS 
    2625 
    27 #define MEMPHIS_TYPE_RULE memphis_rule_get_type() 
     26typedef struct _MemphisRule MemphisRule; 
     27typedef struct _MemphisRuleAttr MemphisRuleAttr; 
    2828 
    29 #define MEMPHIS_RULE(obj) \ 
    30   (G_TYPE_CHECK_INSTANCE_CAST ((obj), MEMPHIS_TYPE_RULE, MemphisRule)) 
     29#define MEMPHIS_RULE(obj)     ((MemphisRule *) (obj)) 
    3130 
    32 #define MEMPHIS_RULE_CLASS(klass) \ 
    33   (G_TYPE_CHECK_CLASS_CAST ((klass), MEMPHIS_TYPE_RULE, MemphisRuleClass)) 
     31/** 
     32 * MemphisRuleAttr: 
     33 * @z_min: minimum visible zoom level 
     34 * @z_max: maximum visible zoom level 
     35 * @style: field for future use (line style, polygon pattern...) 
     36 * @size: the size 
     37 * @color_red: red component, between 0 and 255 
     38 * @color_green: green component, between 0 and 255 
     39 * @color_blue: blue component, between 0 and 255 
     40 * @color_alpha: transparency component, between 0 and 255 
     41 * 
     42 * Defines the drawing attributes for a #MemphisRule. 
     43 * 
     44 * Since: 0.1 
     45 */ 
     46struct _MemphisRuleAttr { 
     47  gint8 z_min; 
     48  gint8 z_max; 
     49  gchar *style; 
     50  gdouble size; 
     51  guint8 color_red; 
     52  guint8 color_green; 
     53  guint8 color_blue; 
     54  guint8 color_alpha; 
     55}; 
    3456 
    35 #define MEMPHIS_IS_RULE(obj) \ 
    36   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MEMPHIS_TYPE_RULE)) 
    37  
    38 #define MEMPHIS_IS_RULE_CLASS(klass) \ 
    39   (G_TYPE_CHECK_CLASS_TYPE ((klass), MEMPHIS_TYPE_RULE)) 
    40  
    41 #define MEMPHIS_RULE_GET_CLASS(obj) \ 
    42   (G_TYPE_INSTANCE_GET_CLASS ((obj), MEMPHIS_TYPE_RULE, MemphisRuleClass)) 
    43  
    44 typedef enum 
    45 { 
     57/** 
     58 * MemphisRuleType: 
     59 * 
     60 * Defines a the data type of the rule. Only ways are supported in 
     61 * Memphis 0.1.x. 
     62 * 
     63 * Since: 0.1 
     64 */ 
     65typedef enum { 
    4666  MEMPHIS_RULE_TYPE_UNKNOWN, 
     67  MEMPHIS_RULE_TYPE_NODE, 
    4768  MEMPHIS_RULE_TYPE_WAY, 
    48   MEMPHIS_RULE_TYPE_NODE, 
    4969  MEMPHIS_RULE_TYPE_RELATION 
    5070} MemphisRuleType; 
    5171 
    52 typedef struct { 
    53   GObject parent; 
    54  
     72/** 
     73 * MemphisRule: 
     74 * 
     75 * Defines a drawing rule for the #MemphisRuleSet. 
     76 * 
     77 * Since: 0.1 
     78 */ 
     79struct _MemphisRule { 
    5580  gchar **keys; 
    5681  gchar **values; 
    5782  MemphisRuleType type; 
     83  MemphisRuleAttr *polygon; 
     84  MemphisRuleAttr *line; 
     85  MemphisRuleAttr *border; 
     86  MemphisRuleAttr *text; 
     87}; 
    5888 
    59   gint16 polygon_color[3]; 
    60   gint16 polygon_z[2]; 
     89GType memphis_rule_get_type (void) G_GNUC_CONST; 
     90#define MEMPHIS_TYPE_RULE (memphis_rule_get_type ()) 
    6191 
    62   gint16 line_color[3]; 
    63   gdouble line_size; 
    64   gint16 line_z[2]; 
     92MemphisRule * memphis_rule_new (void); 
    6593 
    66   gint16 border_color[3]; 
    67   gdouble border_size; 
    68   gint16 border_z[2]; 
     94MemphisRule * memphis_rule_copy (const MemphisRule *rule); 
    6995 
    70   gint16 text_color[3]; 
    71   gdouble text_size; 
    72   gint16 text_z[2]; 
    73 } MemphisRule; 
    74  
    75 typedef struct { 
    76   GObjectClass parent_class; 
    77 } MemphisRuleClass; 
    78  
    79 GType memphis_rule_get_type (void); 
    80  
    81 MemphisRule* memphis_rule_new (void); 
    82 void memphis_rule_free (MemphisRule* rule); 
     96void memphis_rule_free (MemphisRule *rule); 
    8397 
    8498G_END_DECLS 
    8599 
    86 #endif /* _MEMPHIS_RULE */ 
    87  
    88  
     100#endif 
  • trunk/tests/unit-tests.c

    r156 r158  
    8989  MemphisRule *rule = NULL; 
    9090  rule = memphis_rule_new (); 
    91   g_assert (MEMPHIS_IS_RULE (rule)); 
     91  g_assert (MEMPHIS_RULE (rule)); 
    9292  memphis_rule_free (rule); 
    9393} 
     
    175175      "highway:motorway"); 
    176176 
    177   g_assert (MEMPHIS_IS_RULE (rule)); 
     177  g_assert (MEMPHIS_RULE (rule)); 
    178178  g_assert_cmpstr (rule->keys[0], ==, "highway"); 
    179179  g_assert_cmpstr (rule->values[0], ==, "motorway"); 
     
    185185      "landuse|natural:wood|forest"); 
    186186 
    187   g_assert (MEMPHIS_IS_RULE (rule)); 
     187  g_assert (MEMPHIS_RULE (rule)); 
    188188  g_assert_cmpstr (rule->keys[0], ==, "landuse"); 
    189189  g_assert_cmpstr (rule->keys[1], ==, "natural"); 
     
    191191  g_assert_cmpstr (rule->values[1], ==, "forest"); 
    192192 
    193   rule->line_size = 10.0; 
    194   rule->line_color[0] = 255; 
    195   rule->line_color[1] = 0; 
    196   rule->line_color[2] = 0; 
    197   rule->border_size = 12.0; 
    198   rule->text_z[0] = 13; 
    199   rule->text_size = 9.0; 
     193  g_assert (rule->polygon != NULL); 
     194  rule->polygon->color_red = 255; 
     195  rule->polygon->color_green = 0; 
     196  rule->polygon->color_blue = 0; 
     197  rule->polygon->color_alpha = 255; 
     198 
    200199  memphis_rule_set_set_rule (rules, rule); 
    201200  memphis_rule_free (rule); 
     
    232231  a_rule->keys = g_strsplit ("highway", "|", -1); 
    233232  a_rule->values = g_strsplit ("test|test2", "|", -1); 
    234   a_rule->line_size = 5.0; 
    235   a_rule->line_color[0] = 255; 
    236   a_rule->line_color[1] = 0; 
    237   a_rule->line_color[2] = 0; 
     233 
     234  g_assert (a_rule->line == NULL); 
     235  a_rule->line = g_new (MemphisRuleAttr, 1); 
     236  a_rule->line->size = 5.0; 
     237  a_rule->line->color_red = 255; 
     238  a_rule->line->color_green = 0; 
     239  a_rule->line->color_blue = 0; 
    238240  memphis_rule_set_set_rule (rules, a_rule); 
    239241 
Note: See TracChangeset for help on using the changeset viewer.