src/widgets/paint-selector.cpp

   1 #define __SP_PAINT_SELECTOR_C__
   2
   3 /** \file
   4  * SPPaintSelector: Generic paint selector widget.
   5  */
   6
   7 /*
   8  * Copyright (C) Lauris Kaplinski 2002
   9  *   bulia byak <buliabyak@users.sf.net>
  10 */
  11
  12 #define noSP_PS_VERBOSE
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include "config.h"
  16 #endif
  17
  18
  19
  20 #include <gtk/gtkhbox.h>
  21 #include <gtk/gtkradiobutton.h>
  22 #include <gtk/gtkframe.h>
  23 #include <gtk/gtklabel.h>
  24 #include <gtk/gtkoptionmenu.h>
  25 #include <gtk/gtktooltips.h>
  26 #include <gtk/gtkmenuitem.h>
  27
  28 #include "../sp-pattern.h"
  29 #include <glibmm/i18n.h>
  30 #include "../widgets/icon.h"
  31 #include "../inkscape-stock.h"
  32 #include "widgets/widget-sizes.h"
  33 #include "xml/repr.h"
  34
  35 #include "sp-color-notebook.h"
  36 #include "sp-linear-gradient-fns.h"
  37 #include "sp-radial-gradient-fns.h"
  38 /* fixme: Move it from dialogs to here */
  39 #include "gradient-selector.h"
  40 #include <inkscape.h>
  41 #include <document-private.h>
  42 #include <desktop-style.h>
  43 #include <style.h>
  44 #include "svg/svg-color.h"
  45 #include "svg/css-ostringstream.h"
  46
  47 #include "paint-selector.h"
  48
  49 #ifdef SP_PS_VERBOSE
  50 #include "svg/svg-icc-color.h"
  51 #endif // SP_PS_VERBOSE
  52
  53 enum {
  54     MODE_CHANGED,
  55     GRABBED,
  56     DRAGGED,
  57     RELEASED,
  58     CHANGED,
  59     FILLRULE_CHANGED,
  60     LAST_SIGNAL
  61 };
  62
  63 static void sp_paint_selector_class_init(SPPaintSelectorClass *klass);
  64 static void sp_paint_selector_init(SPPaintSelector *slider);
  65 static void sp_paint_selector_destroy(GtkObject *object);
  66
  67 static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelectorMode mode, GtkTooltips *tt, gchar const *tip);
  68 static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  69 static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
  70
  71 static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
  72 static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
  73 static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
  74 static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode);
  75 static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode);
  76 static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode);
  77 static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
  78
  79
  80 static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
  81
  82 static GtkVBoxClass *parent_class;
  83 static guint psel_signals[LAST_SIGNAL] = {0};
  84
  85 GtkType
  86 sp_paint_selector_get_type(void)
  87 {
  88     static GtkType type = 0;
  89     if (!type) {
  90         GtkTypeInfo info = {
  91             "SPPaintSelector",
  92             sizeof(SPPaintSelector),
  93             sizeof(SPPaintSelectorClass),
  94             (GtkClassInitFunc) sp_paint_selector_class_init,
  95             (GtkObjectInitFunc) sp_paint_selector_init,
  96             NULL, NULL, NULL
  97         };
  98         type = gtk_type_unique(GTK_TYPE_VBOX, &info);
  99     }
 100     return type;
 101 }
 102
 103 static void
 104 sp_paint_selector_class_init(SPPaintSelectorClass *klass)
 105 {
 106     GtkObjectClass *object_class;
 107     GtkWidgetClass *widget_class;
 108
 109     object_class = (GtkObjectClass *) klass;
 110     widget_class = (GtkWidgetClass *) klass;
 111
 112     parent_class = (GtkVBoxClass*)gtk_type_class(GTK_TYPE_VBOX);
 113
 114     psel_signals[MODE_CHANGED] = gtk_signal_new("mode_changed",
 115                                                 (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 116                                                 GTK_CLASS_TYPE(object_class),
 117                                                 GTK_SIGNAL_OFFSET(SPPaintSelectorClass, mode_changed),
 118                                                 gtk_marshal_NONE__UINT,
 119                                                 GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 120     psel_signals[GRABBED] =  gtk_signal_new("grabbed",
 121                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 122                                             GTK_CLASS_TYPE(object_class),
 123                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, grabbed),
 124                                             gtk_marshal_NONE__NONE,
 125                                             GTK_TYPE_NONE, 0);
 126     psel_signals[DRAGGED] =  gtk_signal_new("dragged",
 127                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 128                                             GTK_CLASS_TYPE(object_class),
 129                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, dragged),
 130                                             gtk_marshal_NONE__NONE,
 131                                             GTK_TYPE_NONE, 0);
 132     psel_signals[RELEASED] = gtk_signal_new("released",
 133                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 134                                             GTK_CLASS_TYPE(object_class),
 135                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, released),
 136                                             gtk_marshal_NONE__NONE,
 137                                             GTK_TYPE_NONE, 0);
 138     psel_signals[CHANGED] =  gtk_signal_new("changed",
 139                                             (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 140                                             GTK_CLASS_TYPE(object_class),
 141                                             GTK_SIGNAL_OFFSET(SPPaintSelectorClass, changed),
 142                                             gtk_marshal_NONE__NONE,
 143                                             GTK_TYPE_NONE, 0);
 144     psel_signals[FILLRULE_CHANGED] = gtk_signal_new("fillrule_changed",
 145                                                     (GtkSignalRunType)(GTK_RUN_FIRST | GTK_RUN_NO_RECURSE),
 146                                                     GTK_CLASS_TYPE(object_class),
 147                                                     GTK_SIGNAL_OFFSET(SPPaintSelectorClass, fillrule_changed),
 148                                                     gtk_marshal_NONE__UINT,
 149                                                     GTK_TYPE_NONE, 1, GTK_TYPE_UINT);
 150
 151     object_class->destroy = sp_paint_selector_destroy;
 152 }
 153
 154 #define XPAD 4
 155 #define YPAD 1
 156
 157 static void
 158 sp_paint_selector_init(SPPaintSelector *psel)
 159 {
 160     GtkTooltips *tt = gtk_tooltips_new();
 161
 162     psel->mode = (SPPaintSelectorMode)-1; // huh?  do you mean 0xff?  --  I think this means "not in the enum"
 163
 164     /* Paint style button box */
 165     psel->style = gtk_hbox_new(FALSE, 0);
 166     gtk_widget_show(psel->style);
 167     gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
 168     gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
 169
 170     /* Buttons */
 171     psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_NONE,
 172                                                     SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint"));
 173     psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_SOLID,
 174                                                      SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color"));
 175     psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_GRADIENT,
 176                                                         SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient"));
 177     psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_RADIAL,
 178                                                       SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient"));
 179     psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_PATTERN,
 180                                                        SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern"));
 181     psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_UNSET,
 182                                                      SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)"));
 183
 184     /* Fillrule */
 185     {
 186         psel->fillrulebox = gtk_hbox_new(FALSE, 0);
 187         gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
 188
 189         GtkWidget *w;
 190         psel->evenodd = gtk_radio_button_new(NULL);
 191         gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
 192         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
 193         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 194         gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL);
 195         gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 196         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_evenodd");
 197         gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
 198         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
 199         gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 200
 201         psel->nonzero = gtk_radio_button_new(gtk_radio_button_group(GTK_RADIO_BUTTON(psel->evenodd)));
 202         gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
 203         gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
 204         // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
 205         gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL);
 206         gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 207         w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_nonzero");
 208         gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
 209         gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
 210         gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel);
 211     }
 212
 213     /* Frame */
 214     psel->frame = gtk_frame_new("");
 215     gtk_widget_show(psel->frame);
 216     gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
 217     gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
 218
 219     /* Last used color */
 220     psel->color.set( 0.0, 0.0, 0.0 );
 221     psel->alpha = 1.0;
 222 }
 223
 224 static void
 225 sp_paint_selector_destroy(GtkObject *object)
 226 {
 227     SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
 228
 229     // clean up our long-living pattern menu
 230     g_object_set_data(G_OBJECT(psel),"patternmenu",NULL);
 231
 232     if (((GtkObjectClass *) parent_class)->destroy)
 233         (* ((GtkObjectClass *) parent_class)->destroy)(object);
 234 }
 235
 236 static GtkWidget *
 237 sp_paint_selector_style_button_add(SPPaintSelector *psel,
 238                                    gchar const *pixmap, SPPaintSelectorMode mode,
 239                                    GtkTooltips *tt, gchar const *tip)
 240 {
 241     GtkWidget *b, *w;
 242
 243     b = gtk_toggle_button_new();
 244     gtk_tooltips_set_tip(tt, b, tip, NULL);
 245     gtk_widget_show(b);
 246
 247     gtk_container_set_border_width(GTK_CONTAINER(b), 0);
 248
 249     gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
 250
 251     gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
 252     gtk_object_set_data(GTK_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
 253
 254     w = sp_icon_new(Inkscape::ICON_SIZE_BUTTON, pixmap);
 255     gtk_widget_show(w);
 256     gtk_container_add(GTK_CONTAINER(b), w);
 257
 258     gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
 259     gtk_signal_connect(GTK_OBJECT(b), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_style_button_toggled), psel);
 260
 261     return b;
 262 }
 263
 264 static void
 265 sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 266 {
 267     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 268         sp_paint_selector_set_mode(psel, (SPPaintSelectorMode)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode")));
 269     }
 270 }
 271
 272 static void
 273 sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
 274 {
 275     if (!psel->update && gtk_toggle_button_get_active(tb)) {
 276         SPPaintSelectorFillRule fr = (SPPaintSelectorFillRule)GPOINTER_TO_UINT(gtk_object_get_data(GTK_OBJECT(tb), "mode"));
 277         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[FILLRULE_CHANGED], fr);
 278     }
 279 }
 280
 281 void
 282 sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
 283 {
 284     if (psel->fillrulebox) {
 285         if (is_fill) {
 286             gtk_widget_show_all(psel->fillrulebox);
 287         } else {
 288             gtk_widget_destroy(psel->fillrulebox);
 289             psel->fillrulebox = NULL;
 290         }
 291     }
 292 }
 293
 294
 295 GtkWidget *
 296 sp_paint_selector_new(bool is_fill)
 297 {
 298     SPPaintSelector *psel;
 299
 300     psel = (SPPaintSelector*)gtk_type_new(SP_TYPE_PAINT_SELECTOR);
 301
 302     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_MULTIPLE);
 303
 304     // This silliness is here because I don't know how to pass a parameter to the
 305     // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
 306     // becomes a normal class.
 307     sp_paint_selector_show_fillrule(psel, is_fill);
 308
 309     return GTK_WIDGET(psel);
 310 }
 311
 312 void
 313 sp_paint_selector_set_mode(SPPaintSelector *psel, SPPaintSelectorMode mode)
 314 {
 315     if (psel->mode != mode) {
 316         psel->update = TRUE;
 317 #ifdef SP_PS_VERBOSE
 318         g_print("Mode change %d -> %d\n", psel->mode, mode);
 319 #endif
 320         switch (mode) {
 321             case SP_PAINT_SELECTOR_MODE_EMPTY:
 322                 sp_paint_selector_set_mode_empty(psel);
 323                 break;
 324             case SP_PAINT_SELECTOR_MODE_MULTIPLE:
 325                 sp_paint_selector_set_mode_multiple(psel);
 326                 break;
 327             case SP_PAINT_SELECTOR_MODE_NONE:
 328                 sp_paint_selector_set_mode_none(psel);
 329                 break;
 330             case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
 331             case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
 332                 sp_paint_selector_set_mode_color(psel, mode);
 333                 break;
 334             case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
 335             case SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL:
 336                 sp_paint_selector_set_mode_gradient(psel, mode);
 337                 break;
 338             case SP_PAINT_SELECTOR_MODE_PATTERN:
 339                 sp_paint_selector_set_mode_pattern(psel, mode);
 340                 break;
 341             case SP_PAINT_SELECTOR_MODE_UNSET:
 342                 sp_paint_selector_set_mode_unset(psel);
 343                 break;
 344             default:
 345                 g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
 346                 break;
 347         }
 348         psel->mode = mode;
 349         gtk_signal_emit(GTK_OBJECT(psel), psel_signals[MODE_CHANGED], psel->mode);
 350         psel->update = FALSE;
 351     }
 352 }
 353
 354 void
 355 sp_paint_selector_set_fillrule(SPPaintSelector *psel, SPPaintSelectorFillRule fillrule)
 356 {
 357     if (psel->fillrulebox) {
 358         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->evenodd), (fillrule == SP_PAINT_SELECTOR_FILLRULE_EVENODD));
 359         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->nonzero), (fillrule == SP_PAINT_SELECTOR_FILLRULE_NONZERO));
 360     }
 361 }
 362
 363 void
 364 sp_paint_selector_set_color_alpha(SPPaintSelector *psel, SPColor const *color, float alpha)
 365 {
 366     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 367     SPColorSelector *csel;
 368     guint32 rgba;
 369
 370 /*
 371     if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
 372     {
 373 #ifdef SP_PS_VERBOSE
 374         g_print("PaintSelector set CMYKA\n");
 375 #endif
 376         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
 377     }
 378     else
 379 */
 380     {
 381 #ifdef SP_PS_VERBOSE
 382         g_print("PaintSelector set RGBA\n");
 383 #endif
 384         sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
 385     }
 386
 387     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 388     rgba = color->toRGBA32( alpha );
 389     csel->base->setColorAlpha( *color, alpha );
 390 }
 391
 392 void
 393 sp_paint_selector_set_gradient_linear(SPPaintSelector *psel, SPGradient *vector)
 394 {
 395     SPGradientSelector *gsel;
 396 #ifdef SP_PS_VERBOSE
 397     g_print("PaintSelector set GRADIENT LINEAR\n");
 398 #endif
 399     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR);
 400
 401     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 402
 403     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_LINEAR);
 404     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 405 }
 406
 407 void
 408 sp_paint_selector_set_gradient_radial(SPPaintSelector *psel, SPGradient *vector)
 409 {
 410     SPGradientSelector *gsel;
 411 #ifdef SP_PS_VERBOSE
 412     g_print("PaintSelector set GRADIENT RADIAL\n");
 413 #endif
 414     sp_paint_selector_set_mode(psel, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL);
 415
 416     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 417
 418     sp_gradient_selector_set_mode(gsel, SP_GRADIENT_SELECTOR_MODE_RADIAL);
 419     sp_gradient_selector_set_vector(gsel, (vector) ? SP_OBJECT_DOCUMENT(vector) : NULL, vector);
 420 }
 421
 422 void
 423 sp_paint_selector_set_gradient_properties(SPPaintSelector *psel, SPGradientUnits units, SPGradientSpread spread)
 424 {
 425     SPGradientSelector *gsel;
 426     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 427     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 428                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 429     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 430     sp_gradient_selector_set_units(gsel, units);
 431     sp_gradient_selector_set_spread(gsel, spread);
 432 }
 433
 434 void
 435 sp_paint_selector_get_gradient_properties(SPPaintSelector *psel, SPGradientUnits *units, SPGradientSpread *spread)
 436 {
 437     SPGradientSelector *gsel;
 438     g_return_if_fail(SP_IS_PAINT_SELECTOR(psel));
 439     g_return_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 440                      (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL));
 441     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 442     if (units) *units = sp_gradient_selector_get_units(gsel);
 443     if (spread) *spread = sp_gradient_selector_get_spread(gsel);
 444 }
 445
 446 /**
 447  * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
 448  */
 449 void
 450 sp_paint_selector_get_color_alpha(SPPaintSelector *psel, SPColor *color, gfloat *alpha)
 451 {
 452     SPColorSelector *csel;
 453
 454     csel = (SPColorSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 455
 456     csel->base->getColorAlpha( *color, alpha );
 457
 458     g_assert( !alpha
 459               || ( ( 0.0 <= *alpha )
 460                    && ( *alpha <= 1.0 ) ) );
 461 }
 462
 463 SPGradient *
 464 sp_paint_selector_get_gradient_vector(SPPaintSelector *psel)
 465 {
 466     SPGradientSelector *gsel;
 467
 468     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) ||
 469                          (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL), NULL);
 470
 471     gsel = (SPGradientSelector*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 472
 473     return sp_gradient_selector_get_vector(gsel);
 474 }
 475
 476 void
 477 sp_gradient_selector_attrs_to_gradient(SPGradient *gr, SPPaintSelector *psel)
 478 {
 479     SPGradientUnits units;
 480     SPGradientSpread spread;
 481     sp_paint_selector_get_gradient_properties(psel, &units, &spread);
 482     sp_gradient_set_units(gr, units);
 483     sp_gradient_set_spread(gr, spread);
 484     SP_OBJECT(gr)->updateRepr();
 485 }
 486
 487 static void
 488 sp_paint_selector_clear_frame(SPPaintSelector *psel)
 489 {
 490     g_return_if_fail( psel != NULL);
 491
 492     if (psel->selector) {
 493
 494         /* before we destroy the frame contents, we must detach
 495          * the patternmenu so that Gtk doesn't gtk_widget_destroy
 496          * all the children of the menu.  (We also have a g_object_ref
 497          * count set on it too so that the gtk_container_remove doesn't
 498          * end up destroying it.
 499          */
 500         GtkWidget *patterns = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 501         if (patterns != NULL) {
 502             GtkWidget * parent = gtk_widget_get_parent( GTK_WIDGET(patterns));
 503             if ( parent != NULL ) {
 504                 g_assert( GTK_IS_CONTAINER(parent) );
 505                 gtk_container_remove( GTK_CONTAINER(parent), patterns );
 506             }
 507         }
 508
 509         gtk_widget_destroy(psel->selector);
 510         psel->selector = NULL;
 511     }
 512 }
 513
 514 static void
 515 sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
 516 {
 517     sp_paint_selector_set_style_buttons(psel, NULL);
 518     gtk_widget_set_sensitive(psel->style, FALSE);
 519
 520     sp_paint_selector_clear_frame(psel);
 521
 522     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No objects"));
 523 }
 524
 525 static void
 526 sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
 527 {
 528     sp_paint_selector_set_style_buttons(psel, NULL);
 529     gtk_widget_set_sensitive(psel->style, TRUE);
 530
 531     sp_paint_selector_clear_frame(psel);
 532
 533     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Multiple styles"));
 534 }
 535
 536 static void
 537 sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
 538 {
 539     sp_paint_selector_set_style_buttons(psel, psel->unset);
 540     gtk_widget_set_sensitive(psel->style, TRUE);
 541
 542     sp_paint_selector_clear_frame(psel);
 543
 544     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Paint is undefined"));
 545 }
 546
 547 static void
 548 sp_paint_selector_set_mode_none(SPPaintSelector *psel)
 549 {
 550     sp_paint_selector_set_style_buttons(psel, psel->none);
 551     gtk_widget_set_sensitive(psel->style, TRUE);
 552
 553     sp_paint_selector_clear_frame(psel);
 554
 555     gtk_frame_set_label(GTK_FRAME(psel->frame), _("No paint"));
 556 }
 557
 558 /* Color paint */
 559
 560 static void
 561 sp_paint_selector_color_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 562 {
 563     (void)csel;
 564     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 565 }
 566
 567 static void
 568 sp_paint_selector_color_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 569 {
 570     (void)csel;
 571     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 572 }
 573
 574 static void
 575 sp_paint_selector_color_released(SPColorSelector *csel, SPPaintSelector *psel)
 576 {
 577     (void)csel;
 578     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 579 }
 580
 581 static void
 582 sp_paint_selector_color_changed(SPColorSelector *csel, SPPaintSelector *psel)
 583 {
 584     csel->base->getColorAlpha( psel->color, &psel->alpha );
 585
 586     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 587 }
 588
 589 static void
 590 sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelectorMode mode)
 591 {
 592     (void)mode;
 593     GtkWidget *csel;
 594
 595     sp_paint_selector_set_style_buttons(psel, psel->solid);
 596     gtk_widget_set_sensitive(psel->style, TRUE);
 597
 598     if ((psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_RGB) || (psel->mode == SP_PAINT_SELECTOR_MODE_COLOR_CMYK)) {
 599         /* Already have color selector */
 600         csel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "color-selector");
 601     } else {
 602
 603         sp_paint_selector_clear_frame(psel);
 604         /* Create new color selector */
 605         /* Create vbox */
 606         GtkWidget *vb = gtk_vbox_new(FALSE, 4);
 607         gtk_widget_show(vb);
 608
 609         /* Color selector */
 610         csel = sp_color_selector_new( SP_TYPE_COLOR_NOTEBOOK );
 611         gtk_widget_show(csel);
 612         gtk_object_set_data(GTK_OBJECT(vb), "color-selector", csel);
 613         gtk_box_pack_start(GTK_BOX(vb), csel, TRUE, TRUE, 0);
 614         gtk_signal_connect(GTK_OBJECT(csel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_color_grabbed), psel);
 615         gtk_signal_connect(GTK_OBJECT(csel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_color_dragged), psel);
 616         gtk_signal_connect(GTK_OBJECT(csel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_color_released), psel);
 617         gtk_signal_connect(GTK_OBJECT(csel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_color_changed), psel);
 618         /* Pack everything to frame */
 619         gtk_container_add(GTK_CONTAINER(psel->frame), vb);
 620         psel->selector = vb;
 621
 622         /* Set color */
 623         SP_COLOR_SELECTOR( csel )->base->setColorAlpha( psel->color, psel->alpha );
 624
 625     }
 626
 627     gtk_frame_set_label(GTK_FRAME(psel->frame), _("Flat color"));
 628 #ifdef SP_PS_VERBOSE
 629     g_print("Color req\n");
 630 #endif
 631 }
 632
 633 /* Gradient */
 634
 635 static void
 636 sp_paint_selector_gradient_grabbed(SPColorSelector *csel, SPPaintSelector *psel)
 637 {
 638     (void)csel;
 639     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[GRABBED]);
 640 }
 641
 642 static void
 643 sp_paint_selector_gradient_dragged(SPColorSelector *csel, SPPaintSelector *psel)
 644 {
 645     (void)csel;
 646     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[DRAGGED]);
 647 }
 648
 649 static void
 650 sp_paint_selector_gradient_released(SPColorSelector *csel, SPPaintSelector *psel)
 651 {
 652     (void)csel;
 653     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[RELEASED]);
 654 }
 655
 656 static void
 657 sp_paint_selector_gradient_changed(SPColorSelector *csel, SPPaintSelector *psel)
 658 {
 659     (void)csel;
 660     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 661 }
 662
 663 static void
 664 sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelectorMode mode)
 665 {
 666     GtkWidget *gsel;
 667
 668     /* fixme: We do not need function-wide gsel at all */
 669
 670     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 671         sp_paint_selector_set_style_buttons(psel, psel->gradient);
 672     } else {
 673         sp_paint_selector_set_style_buttons(psel, psel->radial);
 674     }
 675     gtk_widget_set_sensitive(psel->style, TRUE);
 676
 677     if ((psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) || (psel->mode == SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL)) {
 678         /* Already have gradient selector */
 679         gsel = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "gradient-selector");
 680     } else {
 681         sp_paint_selector_clear_frame(psel);
 682         /* Create new gradient selector */
 683         gsel = sp_gradient_selector_new();
 684         gtk_widget_show(gsel);
 685         gtk_signal_connect(GTK_OBJECT(gsel), "grabbed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_grabbed), psel);
 686         gtk_signal_connect(GTK_OBJECT(gsel), "dragged", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_dragged), psel);
 687         gtk_signal_connect(GTK_OBJECT(gsel), "released", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_released), psel);
 688         gtk_signal_connect(GTK_OBJECT(gsel), "changed", GTK_SIGNAL_FUNC(sp_paint_selector_gradient_changed), psel);
 689         /* Pack everything to frame */
 690         gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
 691         psel->selector = gsel;
 692         gtk_object_set_data(GTK_OBJECT(psel->selector), "gradient-selector", gsel);
 693     }
 694
 695     /* Actually we have to set optiomenu history here */
 696     if (mode == SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR) {
 697         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
 698         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Linear gradient"));
 699     } else {
 700         sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_RADIAL);
 701         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Radial gradient"));
 702     }
 703 #ifdef SP_PS_VERBOSE
 704     g_print("Gradient req\n");
 705 #endif
 706 }
 707
 708 static void
 709 sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
 710 {
 711     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
 712     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
 713     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
 714     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
 715     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
 716     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
 717 }
 718
 719 static void
 720 sp_psel_pattern_destroy(GtkWidget *widget,  SPPaintSelector *psel)
 721 {
 722     (void)psel;
 723     // drop our reference to the pattern menu widget
 724     g_object_unref( G_OBJECT(widget) );
 725 }
 726
 727 static void
 728 sp_psel_pattern_change(GtkWidget *widget,  SPPaintSelector *psel)
 729 {
 730     (void)widget;
 731     gtk_signal_emit(GTK_OBJECT(psel), psel_signals[CHANGED]);
 732 }
 733
 734 static GtkWidget*
 735 ink_pattern_menu(GtkWidget *mnu)
 736 {
 737     /* Create new menu widget */
 738     GtkWidget *m = gtk_menu_new();
 739     gtk_widget_show(m);
 740
 741     /* Pick up all patterns  */
 742     SPDocument *doc = SP_ACTIVE_DOCUMENT;
 743     GSList *pl = NULL;
 744     GSList const *patterns = sp_document_get_resource_list(doc, "pattern");
 745     for (GSList *l = (GSList *) patterns; l != NULL; l = l->next) {
 746         if (SP_PATTERN(l->data) == pattern_getroot(SP_PATTERN(l->data))) {  // only if this is a root pattern
 747             pl = g_slist_prepend(pl, l->data);
 748         }
 749     }
 750
 751     pl = g_slist_reverse(pl);
 752
 753     if (!doc) {
 754         GtkWidget *i;
 755         i = gtk_menu_item_new_with_label(_("No document selected"));
 756         gtk_widget_show(i);
 757         gtk_menu_append(GTK_MENU(m), i);
 758         gtk_widget_set_sensitive(mnu, FALSE);
 759     } else if (!pl) {
 760         GtkWidget *i;
 761         i = gtk_menu_item_new_with_label(_("No patterns in document"));
 762         gtk_widget_show(i);
 763         gtk_menu_append(GTK_MENU(m), i);
 764         gtk_widget_set_sensitive(mnu, FALSE);
 765     } else {
 766         for (; pl != NULL; pl = pl->next){
 767             if (SP_IS_PATTERN(pl->data)){
 768                 SPPattern *pat = SP_PATTERN(pl->data);
 769                 GtkWidget *i = gtk_menu_item_new();
 770                 gtk_widget_show(i);
 771                 g_object_set_data(G_OBJECT(i), "pattern", pat);
 772                 GtkWidget *hb = gtk_hbox_new(FALSE, 4);
 773                 gtk_widget_show(hb);
 774                 Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) pl->data);
 775                 GtkWidget *l = gtk_label_new(repr->attribute("id"));
 776                 gtk_widget_show(l);
 777                 gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5);
 778                 gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, 0);
 779                 gtk_widget_show(hb);
 780                 gtk_container_add(GTK_CONTAINER(i), hb);
 781                 gtk_menu_append(GTK_MENU(m), i);
 782             }
 783         }
 784
 785         gtk_widget_set_sensitive(mnu, TRUE);
 786     }
 787     gtk_option_menu_set_menu(GTK_OPTION_MENU(mnu), m);
 788
 789     /* Set history */
 790     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 791
 792     g_slist_free(pl);
 793     return mnu;
 794 }
 795
 796
 797 /*update pattern list*/
 798 void
 799 sp_update_pattern_list( SPPaintSelector *psel,  SPPattern *pattern)
 800 {
 801     if (psel->update) return;
 802     GtkWidget *mnu = (GtkWidget *)g_object_get_data(G_OBJECT(psel), "patternmenu");
 803     g_assert( mnu != NULL );
 804
 805     /* Clear existing menu if any */
 806     gtk_option_menu_remove_menu(GTK_OPTION_MENU(mnu));
 807
 808     ink_pattern_menu(mnu);
 809
 810     /* Set history */
 811
 812     if (pattern && !gtk_object_get_data(GTK_OBJECT(mnu), "update")) {
 813
 814         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(TRUE));
 815
 816         gchar *patname = (gchar *) SP_OBJECT_REPR(pattern)->attribute("id");
 817
 818         GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(mnu)));
 819         GList *kids = GTK_MENU_SHELL(m)->children;
 820
 821         int patpos = 0;
 822         int i = 0;
 823
 824         for (; kids != NULL; kids = kids->next) {
 825             gchar *men_pat = (gchar *) SP_OBJECT_REPR(g_object_get_data(G_OBJECT(kids->data), "pattern"))->attribute("id");
 826             if ( strcmp(men_pat, patname) == 0 ) {
 827                 patpos = i;
 828             }
 829             i++;
 830         }
 831
 832         gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), patpos);
 833         gtk_object_set_data(GTK_OBJECT(mnu), "update", GINT_TO_POINTER(FALSE));
 834     }
 835     //gtk_option_menu_set_history(GTK_OPTION_MENU(mnu), 0);
 836 }
 837
 838 static void
 839 sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelectorMode mode)
 840 {
 841     if (mode == SP_PAINT_SELECTOR_MODE_PATTERN)
 842         sp_paint_selector_set_style_buttons(psel, psel->pattern);
 843
 844     gtk_widget_set_sensitive(psel->style, TRUE);
 845
 846     GtkWidget *tbl = NULL;
 847
 848     if (psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN){
 849         /* Already have pattern menu */
 850         tbl = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(psel->selector), "pattern-selector");
 851     } else {
 852         sp_paint_selector_clear_frame(psel);
 853
 854         /* Create vbox */
 855         tbl = gtk_vbox_new(FALSE, 4);
 856         gtk_widget_show(tbl);
 857
 858         {
 859             GtkWidget *hb = gtk_hbox_new(FALSE, 1);
 860
 861             GtkWidget *mnu = gtk_option_menu_new();
 862             ink_pattern_menu(mnu);
 863             gtk_signal_connect(GTK_OBJECT(mnu), "changed", GTK_SIGNAL_FUNC(sp_psel_pattern_change), psel);
 864             gtk_signal_connect(GTK_OBJECT(mnu), "destroy", GTK_SIGNAL_FUNC(sp_psel_pattern_destroy), psel);
 865             gtk_object_set_data(GTK_OBJECT(psel), "patternmenu", mnu);
 866             g_object_ref( G_OBJECT(mnu));
 867
 868             gtk_container_add(GTK_CONTAINER(hb), mnu);
 869             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 870         }
 871
 872         {
 873             GtkWidget *hb = gtk_hbox_new(FALSE, 0);
 874             GtkWidget *l = gtk_label_new(NULL);
 875             gtk_label_set_markup(GTK_LABEL(l), _("Use <b>Object &gt; Pattern &gt; Objects to Pattern</b> to create a new pattern from selection."));
 876             gtk_label_set_line_wrap(GTK_LABEL(l), true);
 877             gtk_widget_set_size_request(l, 180, -1);
 878             gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
 879             gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
 880         }
 881
 882         gtk_widget_show_all(tbl);
 883
 884         gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
 885         psel->selector = tbl;
 886         gtk_object_set_data(GTK_OBJECT(psel->selector), "pattern-selector", tbl);
 887
 888         gtk_frame_set_label(GTK_FRAME(psel->frame), _("Pattern fill"));
 889     }
 890 #ifdef SP_PS_VERBOSE
 891     g_print("Pattern req\n");
 892 #endif
 893 }
 894
 895 SPPattern *
 896 sp_paint_selector_get_pattern(SPPaintSelector *psel)
 897 {
 898     SPPattern *pat;
 899
 900     g_return_val_if_fail((psel->mode == SP_PAINT_SELECTOR_MODE_PATTERN) , NULL);
 901
 902     GtkWidget *patmnu = (GtkWidget *) g_object_get_data(G_OBJECT(psel), "patternmenu");
 903     /* no pattern menu if we were just selected */
 904     if ( patmnu == NULL ) return NULL;
 905
 906     GtkMenu *m = GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(patmnu)));
 907
 908     pat = pattern_getroot(SP_PATTERN(g_object_get_data(G_OBJECT(gtk_menu_get_active(m)), "pattern")));
 909
 910     return pat;
 911 }
 912
 913 void
 914 sp_paint_selector_set_flat_color(SPPaintSelector *psel, SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property)
 915 {
 916     SPCSSAttr *css = sp_repr_css_attr_new();
 917
 918     SPColor color;
 919     gfloat alpha;
 920     sp_paint_selector_get_color_alpha(psel, &color, &alpha);
 921
 922     std::string colorStr = color.toString();
 923
 924 #ifdef SP_PS_VERBOSE
 925     guint32 rgba = color.toRGBA32( alpha );
 926     g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
 927               colorStr.c_str(),
 928               rgba,
 929               (color.icc?color.icc->colorProfile.c_str():"<null>") );
 930 #endif // SP_PS_VERBOSE
 931
 932     sp_repr_css_set_property(css, color_property, colorStr.c_str());
 933     Inkscape::CSSOStringStream osalpha;
 934     osalpha << alpha;
 935     sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
 936
 937     sp_desktop_set_style(desktop, css);
 938
 939     sp_repr_css_attr_unref(css);
 940 }
 941
 942 SPPaintSelectorMode
 943 sp_style_determine_paint_selector_mode(SPStyle *style, bool isfill)
 944 {
 945     SPPaintSelectorMode mode = SP_PAINT_SELECTOR_MODE_UNSET;
 946     SPIPaint& target = isfill ? style->fill : style->stroke;
 947
 948     if ( !target.set ) {
 949         mode = SP_PAINT_SELECTOR_MODE_UNSET;
 950     } else if ( target.isPaintserver() ) {
 951         SPPaintServer *server = isfill? SP_STYLE_FILL_SERVER(style) : SP_STYLE_STROKE_SERVER(style);
 952
 953         if (SP_IS_LINEARGRADIENT(server)) {
 954             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR;
 955         } else if (SP_IS_RADIALGRADIENT(server)) {
 956             mode = SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL;
 957         } else if (SP_IS_PATTERN(server)) {
 958             mode = SP_PAINT_SELECTOR_MODE_PATTERN;
 959         } else {
 960             g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
 961             mode = SP_PAINT_SELECTOR_MODE_NONE;
 962         }
 963     } else if ( target.isColor() ) {
 964         mode = SP_PAINT_SELECTOR_MODE_COLOR_RGB; // so far only rgb can be read from svg
 965     } else if ( target.isNone() ) {
 966         mode = SP_PAINT_SELECTOR_MODE_NONE;
 967     } else {
 968         g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
 969         mode = SP_PAINT_SELECTOR_MODE_NONE;
 970     }
 971
 972     return mode;
 973 }
 974
 975 /*
 976   Local Variables:
 977   mode:c++
 978   c-file-style:"stroustrup"
 979   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 980   indent-tabs-mode:nil
 981   fill-column:99
 982   End:
 983 */
 984 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :