src/ui/dialog/swatches.cpp

   1
   2 /** @file
   3  * @brief Color swatches dialog
   4  */
   5 /* Authors:
   6  *   Jon A. Cruz
   7  *   John Bintz
   8  *
   9  * Copyright (C) 2005 Jon A. Cruz
  10  * Copyright (C) 2008 John Bintz
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #include <errno.h>
  16 #include <map>
  17
  18 #include <gtk/gtkdialog.h> //for GTK_RESPONSE* types
  19 #include <gtk/gtkdnd.h>
  20 #include <gtk/gtkmenu.h>
  21 #include <gtk/gtkmenuitem.h>
  22 #include <gtk/gtkseparatormenuitem.h>
  23 #include <glibmm/i18n.h>
  24 #include <gdkmm/pixbuf.h>
  25
  26 #include "color-item.h"
  27 #include "desktop.h"
  28 #include "desktop-handles.h"
  29 #include "desktop-style.h"
  30 #include "document.h"
  31 #include "document-private.h"
  32 #include "extension/db.h"
  33 #include "inkscape.h"
  34 #include "inkscape.h"
  35 #include "io/sys.h"
  36 #include "io/resource.h"
  37 #include "message-context.h"
  38 #include "path-prefix.h"
  39 #include "preferences.h"
  40 #include "sp-item.h"
  41 #include "sp-gradient-fns.h"
  42 #include "sp-gradient.h"
  43 #include "sp-gradient-vector.h"
  44 #include "swatches.h"
  45 #include "style.h"
  46 #include "ui/previewholder.h"
  47 #include "widgets/desktop-widget.h"
  48 #include "widgets/gradient-vector.h"
  49 #include "widgets/eek-preview.h"
  50 #include "display/nr-plain-stuff.h"
  51 #include "sp-gradient-reference.h"
  52
  53
  54 namespace Inkscape {
  55 namespace UI {
  56 namespace Dialogs {
  57
  58 #define VBLOCK 16
  59 #define PREVIEW_PIXBUF_WIDTH 128
  60
  61 void _loadPaletteFile( gchar const *filename );
  62
  63
  64 class DocTrack;
  65
  66 std::vector<SwatchPage*> possible;
  67 static std::map<SPDocument*, SwatchPage*> docPalettes;
  68 static std::vector<DocTrack*> docTrackings;
  69 static std::map<SwatchesPanel*, SPDocument*> docPerPanel;
  70
  71
  72 class SwatchesPanelHook : public SwatchesPanel
  73 {
  74 public:
  75     static void convertGradient( GtkMenuItem * menuitem, gpointer userData );
  76 };
  77
  78 static void handleClick( GtkWidget* /*widget*/, gpointer callback_data ) {
  79     ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
  80     if ( item ) {
  81         item->buttonClicked(false);
  82     }
  83 }
  84
  85 static void handleSecondaryClick( GtkWidget* /*widget*/, gint /*arg1*/, gpointer callback_data ) {
  86     ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
  87     if ( item ) {
  88         item->buttonClicked(true);
  89     }
  90 }
  91
  92 static GtkWidget* popupMenu = 0;
  93 static GtkWidget *popupSubHolder = 0;
  94 static GtkWidget *popupSub = 0;
  95 static std::vector<Glib::ustring> popupItems;
  96 static std::vector<GtkWidget*> popupExtras;
  97 static ColorItem* bounceTarget = 0;
  98 static SwatchesPanel* bouncePanel = 0;
  99
 100 static void redirClick( GtkMenuItem *menuitem, gpointer /*user_data*/ )
 101 {
 102     if ( bounceTarget ) {
 103         handleClick( GTK_WIDGET(menuitem), bounceTarget );
 104     }
 105 }
 106
 107 static void redirSecondaryClick( GtkMenuItem *menuitem, gpointer /*user_data*/ )
 108 {
 109     if ( bounceTarget ) {
 110         handleSecondaryClick( GTK_WIDGET(menuitem), 0, bounceTarget );
 111     }
 112 }
 113
 114 static void editGradientImpl( SPGradient* gr )
 115 {
 116     if ( gr ) {
 117         GtkWidget *dialog = sp_gradient_vector_editor_new( gr );
 118         gtk_widget_show( dialog );
 119     }
 120 }
 121
 122 static void editGradient( GtkMenuItem */*menuitem*/, gpointer /*user_data*/ )
 123 {
 124     if ( bounceTarget ) {
 125         SwatchesPanel* swp = bouncePanel;
 126         SPDesktop* desktop = swp ? swp->getDesktop() : 0;
 127         SPDocument *doc = desktop ? desktop->doc() : 0;
 128         if (doc) {
 129             std::string targetName(bounceTarget->def.descr);
 130             const GSList *gradients = sp_document_get_resource_list(doc, "gradient");
 131             for (const GSList *item = gradients; item; item = item->next) {
 132                 SPGradient* grad = SP_GRADIENT(item->data);
 133                 if ( targetName == grad->getId() ) {
 134                     editGradientImpl( grad );
 135                     break;
 136                 }
 137             }
 138         }
 139     }
 140 }
 141
 142 static void addNewGradient( GtkMenuItem */*menuitem*/, gpointer /*user_data*/ )
 143 {
 144     if ( bounceTarget ) {
 145         SwatchesPanel* swp = bouncePanel;
 146         SPDesktop* desktop = swp ? swp->getDesktop() : 0;
 147         SPDocument *doc = desktop ? desktop->doc() : 0;
 148         if (doc) {
 149             Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
 150
 151             Inkscape::XML::Node *repr = xml_doc->createElement("svg:linearGradient");
 152             repr->setAttribute("osb:paint", "solid");
 153             Inkscape::XML::Node *stop = xml_doc->createElement("svg:stop");
 154             stop->setAttribute("offset", "0");
 155             stop->setAttribute("style", "stop-color:#000;stop-opacity:1;");
 156             repr->appendChild(stop);
 157             Inkscape::GC::release(stop);
 158
 159             SP_OBJECT_REPR( SP_DOCUMENT_DEFS(doc) )->addChild(repr, NULL);
 160
 161             SPGradient * gr = static_cast<SPGradient *>(doc->getObjectByRepr(repr));
 162
 163             Inkscape::GC::release(repr);
 164
 165
 166             editGradientImpl( gr );
 167         }
 168     }
 169 }
 170
 171 void SwatchesPanelHook::convertGradient( GtkMenuItem * /*menuitem*/, gpointer userData )
 172 {
 173     if ( bounceTarget ) {
 174         SwatchesPanel* swp = bouncePanel;
 175         SPDesktop* desktop = swp ? swp->getDesktop() : 0;
 176         SPDocument *doc = desktop ? desktop->doc() : 0;
 177         gint index = GPOINTER_TO_INT(userData);
 178         if ( doc && (index >= 0) && (static_cast<guint>(index) < popupItems.size()) ) {
 179             Glib::ustring targetName = popupItems[index];
 180
 181             const GSList *gradients = sp_document_get_resource_list(doc, "gradient");
 182             for (const GSList *item = gradients; item; item = item->next) {
 183                 SPGradient* grad = SP_GRADIENT(item->data);
 184                 if ( targetName == grad->getId() ) {
 185                     grad->repr->setAttribute("osb:paint", "solid");
 186
 187                     sp_document_done(doc, SP_VERB_CONTEXT_GRADIENT,
 188                                      _("Add gradient stop"));
 189
 190                     handleGradientsChange(doc); // work-around for signal not being emmitted
 191                     break;
 192                 }
 193             }
 194         }
 195     }
 196 }
 197
 198 static SwatchesPanel* findContainingPanel( GtkWidget *widget )
 199 {
 200     SwatchesPanel *swp = 0;
 201
 202     std::map<GtkWidget*, SwatchesPanel*> rawObjects;
 203     for (std::map<SwatchesPanel*, SPDocument*>::iterator it = docPerPanel.begin(); it != docPerPanel.end(); ++it) {
 204         rawObjects[GTK_WIDGET(it->first->gobj())] = it->first;
 205     }
 206
 207     for (GtkWidget* curr = widget; curr && !swp; curr = gtk_widget_get_parent(curr)) {
 208         if (rawObjects.find(curr) != rawObjects.end()) {
 209             swp = rawObjects[curr];
 210         }
 211     }
 212
 213     return swp;
 214 }
 215
 216 static void removeit( GtkWidget *widget, gpointer data )
 217 {
 218     gtk_container_remove( GTK_CONTAINER(data), widget );
 219 }
 220
 221 gboolean colorItemHandleButtonPress( GtkWidget* widget, GdkEventButton* event, gpointer user_data )
 222 {
 223     gboolean handled = FALSE;
 224
 225     if ( (event->button == 3) && (event->type == GDK_BUTTON_PRESS) ) {
 226         SwatchesPanel* swp = findContainingPanel( widget );
 227
 228         if ( !popupMenu ) {
 229             popupMenu = gtk_menu_new();
 230             GtkWidget* child = 0;
 231
 232             //TRANSLATORS: An item in context menu on a colour in the swatches
 233             child = gtk_menu_item_new_with_label(_("Set fill"));
 234             g_signal_connect( G_OBJECT(child),
 235                               "activate",
 236                               G_CALLBACK(redirClick),
 237                               user_data);
 238             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 239
 240             //TRANSLATORS: An item in context menu on a colour in the swatches
 241             child = gtk_menu_item_new_with_label(_("Set stroke"));
 242
 243             g_signal_connect( G_OBJECT(child),
 244                               "activate",
 245                               G_CALLBACK(redirSecondaryClick),
 246                               user_data);
 247             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 248
 249             child = gtk_separator_menu_item_new();
 250             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 251             popupExtras.push_back(child);
 252
 253             child = gtk_menu_item_new_with_label(_("Add"));
 254             g_signal_connect( G_OBJECT(child),
 255                               "activate",
 256                               G_CALLBACK(addNewGradient),
 257                               user_data );
 258             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 259             popupExtras.push_back(child);
 260
 261             child = gtk_menu_item_new_with_label(_("Delete"));
 262             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 263             //popupExtras.push_back(child);
 264             gtk_widget_set_sensitive( child, FALSE );
 265
 266             child = gtk_menu_item_new_with_label(_("Edit..."));
 267             g_signal_connect( G_OBJECT(child),
 268                               "activate",
 269                               G_CALLBACK(editGradient),
 270                               user_data );
 271             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 272             popupExtras.push_back(child);
 273
 274             child = gtk_separator_menu_item_new();
 275             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 276             popupExtras.push_back(child);
 277
 278             child = gtk_menu_item_new_with_label(_("Convert"));
 279             gtk_menu_shell_append(GTK_MENU_SHELL(popupMenu), child);
 280             //popupExtras.push_back(child);
 281             //gtk_widget_set_sensitive( child, FALSE );
 282             {
 283                 popupSubHolder = child;
 284                 popupSub = gtk_menu_new();
 285                 gtk_menu_item_set_submenu( GTK_MENU_ITEM(child), popupSub );
 286             }
 287
 288             gtk_widget_show_all(popupMenu);
 289         }
 290
 291         ColorItem* item = reinterpret_cast<ColorItem*>(user_data);
 292         if ( item ) {
 293             bool show = swp && (swp->getSelectedIndex() == 0);
 294             for ( std::vector<GtkWidget*>::iterator it = popupExtras.begin(); it != popupExtras.end(); ++ it) {
 295                 gtk_widget_set_sensitive(*it, show);
 296             }
 297
 298             bounceTarget = item;
 299             bouncePanel = swp;
 300             popupItems.clear();
 301             if ( popupMenu ) {
 302                 gtk_container_foreach(GTK_CONTAINER(popupSub), removeit, popupSub);
 303                 bool processed = false;
 304                 GtkWidget *wdgt = gtk_widget_get_ancestor(widget, SP_TYPE_DESKTOP_WIDGET);
 305                 if ( wdgt ) {
 306                     SPDesktopWidget *dtw = SP_DESKTOP_WIDGET(wdgt);
 307                     if ( dtw && dtw->desktop ) {
 308                         // Pick up all gradients with vectors
 309                         const GSList *gradients = sp_document_get_resource_list(dtw->desktop->doc(), "gradient");
 310                         gint index = 0;
 311                         for (const GSList *curr = gradients; curr; curr = curr->next) {
 312                             SPGradient* grad = SP_GRADIENT(curr->data);
 313                             if (SP_GRADIENT_HAS_STOPS(grad) && !grad->isSwatch()) {
 314                                 //gl = g_slist_prepend(gl, curr->data);
 315                                 processed = true;
 316                                 GtkWidget *child = gtk_menu_item_new_with_label(grad->getId());
 317                                 gtk_menu_shell_append(GTK_MENU_SHELL(popupSub), child);
 318
 319                                 popupItems.push_back(grad->getId());
 320                                 g_signal_connect( G_OBJECT(child),
 321                                                   "activate",
 322                                                   G_CALLBACK(SwatchesPanelHook::convertGradient),
 323                                                   GINT_TO_POINTER(index) );
 324                                 index++;
 325                             }
 326                         }
 327
 328                         gtk_widget_show_all(popupSub);
 329                     }
 330                 }
 331                 gtk_widget_set_sensitive( popupSubHolder, processed );
 332
 333                 gtk_menu_popup(GTK_MENU(popupMenu), NULL, NULL, NULL, NULL, event->button, event->time);
 334                 handled = TRUE;
 335             }
 336         }
 337     }
 338
 339     return handled;
 340 }
 341
 342
 343 static char* trim( char* str ) {
 344     char* ret = str;
 345     while ( *str && (*str == ' ' || *str == '\t') ) {
 346         str++;
 347     }
 348     ret = str;
 349     while ( *str ) {
 350         str++;
 351     }
 352     str--;
 353     while ( str > ret && (( *str == ' ' || *str == '\t' ) || *str == '\r' || *str == '\n') ) {
 354         *str-- = 0;
 355     }
 356     return ret;
 357 }
 358
 359 void skipWhitespace( char*& str ) {
 360     while ( *str == ' ' || *str == '\t' ) {
 361         str++;
 362     }
 363 }
 364
 365 bool parseNum( char*& str, int& val ) {
 366     val = 0;
 367     while ( '0' <= *str && *str <= '9' ) {
 368         val = val * 10 + (*str - '0');
 369         str++;
 370     }
 371     bool retval = !(*str == 0 || *str == ' ' || *str == '\t' || *str == '\r' || *str == '\n');
 372     return retval;
 373 }
 374
 375
 376 void _loadPaletteFile( gchar const *filename )
 377 {
 378     char block[1024];
 379     FILE *f = Inkscape::IO::fopen_utf8name( filename, "r" );
 380     if ( f ) {
 381         char* result = fgets( block, sizeof(block), f );
 382         if ( result ) {
 383             if ( strncmp( "GIMP Palette", block, 12 ) == 0 ) {
 384                 bool inHeader = true;
 385                 bool hasErr = false;
 386
 387                 SwatchPage *onceMore = new SwatchPage();
 388
 389                 do {
 390                     result = fgets( block, sizeof(block), f );
 391                     block[sizeof(block) - 1] = 0;
 392                     if ( result ) {
 393                         if ( block[0] == '#' ) {
 394                             // ignore comment
 395                         } else {
 396                             char *ptr = block;
 397                             // very simple check for header versus entry
 398                             while ( *ptr == ' ' || *ptr == '\t' ) {
 399                                 ptr++;
 400                             }
 401                             if ( (*ptr == 0) || (*ptr == '\r') || (*ptr == '\n') ) {
 402                                 // blank line. skip it.
 403                             } else if ( '0' <= *ptr && *ptr <= '9' ) {
 404                                 // should be an entry link
 405                                 inHeader = false;
 406                                 ptr = block;
 407                                 Glib::ustring name("");
 408                                 int r = 0;
 409                                 int g = 0;
 410                                 int b = 0;
 411                                 skipWhitespace(ptr);
 412                                 if ( *ptr ) {
 413                                     hasErr = parseNum(ptr, r);
 414                                     if ( !hasErr ) {
 415                                         skipWhitespace(ptr);
 416                                         hasErr = parseNum(ptr, g);
 417                                     }
 418                                     if ( !hasErr ) {
 419                                         skipWhitespace(ptr);
 420                                         hasErr = parseNum(ptr, b);
 421                                     }
 422                                     if ( !hasErr && *ptr ) {
 423                                         char* n = trim(ptr);
 424                                         if (n != NULL) {
 425                                             name = n;
 426                                         }
 427                                     }
 428                                     if ( !hasErr ) {
 429                                         // Add the entry now
 430                                         Glib::ustring nameStr(name);
 431                                         ColorItem* item = new ColorItem( r, g, b, nameStr );
 432                                         onceMore->_colors.push_back(item);
 433                                     }
 434                                 } else {
 435                                     hasErr = true;
 436                                 }
 437                             } else {
 438                                 if ( !inHeader ) {
 439                                     // Hmmm... probably bad. Not quite the format we want?
 440                                     hasErr = true;
 441                                 } else {
 442                                     char* sep = strchr(result, ':');
 443                                     if ( sep ) {
 444                                         *sep = 0;
 445                                         char* val = trim(sep + 1);
 446                                         char* name = trim(result);
 447                                         if ( *name ) {
 448                                             if ( strcmp( "Name", name ) == 0 )
 449                                             {
 450                                                 onceMore->_name = val;
 451                                             }
 452                                             else if ( strcmp( "Columns", name ) == 0 )
 453                                             {
 454                                                 gchar* endPtr = 0;
 455                                                 guint64 numVal = g_ascii_strtoull( val, &endPtr, 10 );
 456                                                 if ( (numVal == G_MAXUINT64) && (ERANGE == errno) ) {
 457                                                     // overflow
 458                                                 } else if ( (numVal == 0) && (endPtr == val) ) {
 459                                                     // failed conversion
 460                                                 } else {
 461                                                     onceMore->_prefWidth = numVal;
 462                                                 }
 463                                             }
 464                                         } else {
 465                                             // error
 466                                             hasErr = true;
 467                                         }
 468                                     } else {
 469                                         // error
 470                                         hasErr = true;
 471                                     }
 472                                 }
 473                             }
 474                         }
 475                     }
 476                 } while ( result && !hasErr );
 477                 if ( !hasErr ) {
 478                     possible.push_back(onceMore);
 479 #if ENABLE_MAGIC_COLORS
 480                     ColorItem::_wireMagicColors( onceMore );
 481 #endif // ENABLE_MAGIC_COLORS
 482                 } else {
 483                     delete onceMore;
 484                 }
 485             }
 486         }
 487
 488         fclose(f);
 489     }
 490 }
 491
 492 static void loadEmUp()
 493 {
 494     static bool beenHere = false;
 495     if ( !beenHere ) {
 496         beenHere = true;
 497
 498         std::list<gchar *> sources;
 499         sources.push_back( profile_path("palettes") );
 500         sources.push_back( g_strdup(INKSCAPE_PALETTESDIR) );
 501         sources.push_back( g_strdup(CREATE_PALETTESDIR) );
 502
 503         // Use this loop to iterate through a list of possible document locations.
 504         while (!sources.empty()) {
 505             gchar *dirname = sources.front();
 506
 507             if ( Inkscape::IO::file_test( dirname, G_FILE_TEST_EXISTS )
 508                 && Inkscape::IO::file_test( dirname, G_FILE_TEST_IS_DIR )) {
 509                 GError *err = 0;
 510                 GDir *directory = g_dir_open(dirname, 0, &err);
 511                 if (!directory) {
 512                     gchar *safeDir = Inkscape::IO::sanitizeString(dirname);
 513                     g_warning(_("Palettes directory (%s) is unavailable."), safeDir);
 514                     g_free(safeDir);
 515                 } else {
 516                     gchar *filename = 0;
 517                     while ((filename = (gchar *)g_dir_read_name(directory)) != NULL) {
 518                         gchar* lower = g_ascii_strdown( filename, -1 );
 519 //                        if ( g_str_has_suffix(lower, ".gpl") ) {
 520                             gchar* full = g_build_filename(dirname, filename, NULL);
 521                             if ( !Inkscape::IO::file_test( full, G_FILE_TEST_IS_DIR ) ) {
 522                                 _loadPaletteFile(full);
 523                             }
 524                             g_free(full);
 525 //                      }
 526                         g_free(lower);
 527                     }
 528                     g_dir_close(directory);
 529                 }
 530             }
 531
 532             // toss the dirname
 533             g_free(dirname);
 534             sources.pop_front();
 535         }
 536     }
 537 }
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547 SwatchesPanel& SwatchesPanel::getInstance()
 548 {
 549     return *new SwatchesPanel();
 550 }
 551
 552
 553 /**
 554  * Constructor
 555  */
 556 SwatchesPanel::SwatchesPanel(gchar const* prefsPath) :
 557     Inkscape::UI::Widget::Panel("", prefsPath, SP_VERB_DIALOG_SWATCHES, "", true),
 558     _holder(0),
 559     _clear(0),
 560     _remove(0),
 561     _currentIndex(0),
 562     _currentDesktop(0),
 563     _currentDocument(0)
 564 {
 565     Gtk::RadioMenuItem* hotItem = 0;
 566     _holder = new PreviewHolder();
 567     _clear = new ColorItem( ege::PaintDef::CLEAR );
 568     _remove = new ColorItem( ege::PaintDef::NONE );
 569     if (docPalettes.empty()) {
 570         SwatchPage *docPalette = new SwatchPage();
 571
 572         docPalette->_name = "Auto";
 573         docPalettes[0] = docPalette;
 574     }
 575
 576     loadEmUp();
 577     if ( !possible.empty() ) {
 578         SwatchPage* first = 0;
 579         int index = 0;
 580         Glib::ustring targetName;
 581         if ( !_prefs_path.empty() ) {
 582             Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 583             targetName = prefs->getString(_prefs_path + "/palette");
 584             if (!targetName.empty()) {
 585                 if (targetName == "Auto") {
 586                     first = docPalettes[0];
 587                 } else {
 588                     index++;
 589                     for ( std::vector<SwatchPage*>::iterator iter = possible.begin(); iter != possible.end(); ++iter ) {
 590                         if ( (*iter)->_name == targetName ) {
 591                             first = *iter;
 592                             break;
 593                         }
 594                         index++;
 595                     }
 596                 }
 597             }
 598         }
 599
 600         if ( !first ) {
 601             first = docPalettes[0];
 602             _currentIndex = 0;
 603         } else {
 604             _currentIndex = index;
 605         }
 606
 607         _rebuild();
 608
 609         Gtk::RadioMenuItem::Group groupOne;
 610
 611         int i = 0;
 612         std::vector<SwatchPage*> swatchSets = _getSwatchSets();
 613         for ( std::vector<SwatchPage*>::iterator it = swatchSets.begin(); it != swatchSets.end(); it++ ) {
 614             SwatchPage* curr = *it;
 615             Gtk::RadioMenuItem* single = manage(new Gtk::RadioMenuItem(groupOne, curr->_name));
 616             if ( curr == first ) {
 617                 hotItem = single;
 618             }
 619             _regItem( single, 3, i );
 620             i++;
 621         }
 622     }
 623
 624
 625     _getContents()->pack_start(*_holder, Gtk::PACK_EXPAND_WIDGET);
 626     _setTargetFillable(_holder);
 627
 628     show_all_children();
 629
 630     restorePanelPrefs();
 631     if ( hotItem ) {
 632         hotItem->set_active();
 633     }
 634 }
 635
 636 SwatchesPanel::~SwatchesPanel()
 637 {
 638     _trackDocument( this, 0 );
 639
 640     _documentConnection.disconnect();
 641     _selChanged.disconnect();
 642
 643     if ( _clear ) {
 644         delete _clear;
 645     }
 646     if ( _remove ) {
 647         delete _remove;
 648     }
 649     if ( _holder ) {
 650         delete _holder;
 651     }
 652 }
 653
 654 void SwatchesPanel::setOrientation( Gtk::AnchorType how )
 655 {
 656     // Must call the parent class or bad things might happen
 657     Inkscape::UI::Widget::Panel::setOrientation( how );
 658
 659     if ( _holder )
 660     {
 661         _holder->setOrientation( Gtk::ANCHOR_SOUTH );
 662     }
 663 }
 664
 665 void SwatchesPanel::setDesktop( SPDesktop* desktop )
 666 {
 667     if ( desktop != _currentDesktop ) {
 668         if ( _currentDesktop ) {
 669             _documentConnection.disconnect();
 670             _selChanged.disconnect();
 671         }
 672
 673         _currentDesktop = desktop;
 674
 675         if ( desktop ) {
 676             _currentDesktop->selection->connectChanged(
 677                 sigc::hide(sigc::mem_fun(*this, &SwatchesPanel::_updateFromSelection)));
 678
 679             _currentDesktop->selection->connectModified(
 680                 sigc::hide(sigc::hide(sigc::mem_fun(*this, &SwatchesPanel::_updateFromSelection))));
 681
 682             _currentDesktop->connectToolSubselectionChanged(
 683                 sigc::hide(sigc::mem_fun(*this, &SwatchesPanel::_updateFromSelection)));
 684
 685             sigc::bound_mem_functor1<void, Inkscape::UI::Dialogs::SwatchesPanel, SPDocument*> first = sigc::mem_fun(*this, &SwatchesPanel::_setDocument);
 686             sigc::slot<void, SPDocument*> base2 = first;
 687             sigc::slot<void,SPDesktop*, SPDocument*> slot2 = sigc::hide<0>( base2 );
 688             _documentConnection = desktop->connectDocumentReplaced( slot2 );
 689
 690             _setDocument( desktop->doc() );
 691         } else {
 692             _setDocument(0);
 693         }
 694     }
 695 }
 696
 697
 698 class DocTrack
 699 {
 700 public:
 701     DocTrack(SPDocument *doc, sigc::connection &gradientRsrcChanged, sigc::connection &defsChanged, sigc::connection &defsModified) :
 702         doc(doc),
 703         gradientRsrcChanged(gradientRsrcChanged),
 704         defsChanged(defsChanged),
 705         defsModified(defsModified)
 706     {
 707     }
 708
 709     ~DocTrack()
 710     {
 711         if (doc) {
 712             gradientRsrcChanged.disconnect();
 713             defsChanged.disconnect();
 714             defsModified.disconnect();
 715         }
 716     }
 717
 718     SPDocument *doc;
 719     sigc::connection gradientRsrcChanged;
 720     sigc::connection defsChanged;
 721     sigc::connection defsModified;
 722
 723 private:
 724     DocTrack(DocTrack const &); // no copy
 725     DocTrack &operator=(DocTrack const &); // no assign
 726 };
 727
 728 void SwatchesPanel::_trackDocument( SwatchesPanel *panel, SPDocument *document )
 729 {
 730     SPDocument *oldDoc = 0;
 731     if (docPerPanel.find(panel) != docPerPanel.end()) {
 732         oldDoc = docPerPanel[panel];
 733         if (!oldDoc) {
 734             docPerPanel.erase(panel); // Should not be needed, but clean up just in case.
 735         }
 736     }
 737     if (oldDoc != document) {
 738         if (oldDoc) {
 739             docPerPanel[panel] = 0;
 740             bool found = false;
 741             for (std::map<SwatchesPanel*, SPDocument*>::iterator it = docPerPanel.begin(); (it != docPerPanel.end()) && !found; ++it) {
 742                 found = (it->second == document);
 743             }
 744             if (!found) {
 745                 for (std::vector<DocTrack*>::iterator it = docTrackings.begin(); it != docTrackings.end(); ++it){
 746                     if ((*it)->doc == oldDoc) {
 747                         delete *it;
 748                         docTrackings.erase(it);
 749                         break;
 750                     }
 751                 }
 752             }
 753         }
 754
 755         if (document) {
 756             bool found = false;
 757             for (std::map<SwatchesPanel*, SPDocument*>::iterator it = docPerPanel.begin(); (it != docPerPanel.end()) && !found; ++it) {
 758                 found = (it->second == document);
 759             }
 760             docPerPanel[panel] = document;
 761             if (!found) {
 762                 sigc::connection conn1 = sp_document_resources_changed_connect( document, "gradient", sigc::bind(sigc::ptr_fun(&SwatchesPanel::handleGradientsChange), document) );
 763                 sigc::connection conn2 = SP_DOCUMENT_DEFS(document)->connectRelease( sigc::hide(sigc::bind(sigc::ptr_fun(&SwatchesPanel::handleDefsModified), document)) );
 764                 sigc::connection conn3 = SP_DOCUMENT_DEFS(document)->connectModified( sigc::hide(sigc::hide(sigc::bind(sigc::ptr_fun(&SwatchesPanel::handleDefsModified), document))) );
 765
 766                 DocTrack *dt = new DocTrack(document, conn1, conn2, conn3);
 767                 docTrackings.push_back(dt);
 768
 769                 if (docPalettes.find(document) == docPalettes.end()) {
 770                     SwatchPage *docPalette = new SwatchPage();
 771                     docPalette->_name = "Auto";
 772                     docPalettes[document] = docPalette;
 773                 }
 774             }
 775         }
 776     }
 777
 778     std::set<SPDocument*> docs;
 779     for (std::map<SwatchesPanel*, SPDocument*>::iterator it = docPerPanel.begin(); it != docPerPanel.end(); ++it) {
 780         docs.insert(it->second);
 781     }
 782 }
 783
 784 void SwatchesPanel::_setDocument( SPDocument *document )
 785 {
 786     if ( document != _currentDocument ) {
 787         _trackDocument(this, document);
 788         _currentDocument = document;
 789         handleGradientsChange( document );
 790     }
 791 }
 792
 793 static void recalcSwatchContents(SPDocument* doc,
 794                 std::vector<ColorItem*> &tmpColors,
 795                 std::map<ColorItem*, guchar*> &previewMappings,
 796                 std::map<ColorItem*, SPGradient*> &gradMappings)
 797 {
 798     std::vector<SPGradient*> newList;
 799
 800     const GSList *gradients = sp_document_get_resource_list(doc, "gradient");
 801     for (const GSList *item = gradients; item; item = item->next) {
 802         SPGradient* grad = SP_GRADIENT(item->data);
 803         if ( grad->isSwatch() ) {
 804             newList.push_back(SP_GRADIENT(item->data));
 805         }
 806     }
 807
 808     if ( !newList.empty() ) {
 809         for ( std::vector<SPGradient*>::iterator it = newList.begin(); it != newList.end(); ++it )
 810         {
 811             SPGradient* grad = *it;
 812             sp_gradient_ensure_vector( grad );
 813             SPGradientStop first = grad->vector.stops[0];
 814             SPColor color = first.color;
 815             guint32 together = color.toRGBA32(first.opacity);
 816
 817             SPGradientStop second = (*it)->vector.stops[1];
 818             SPColor color2 = second.color;
 819
 820             Glib::ustring name( grad->getId() );
 821             unsigned int r = SP_RGBA32_R_U(together);
 822             unsigned int g = SP_RGBA32_G_U(together);
 823             unsigned int b = SP_RGBA32_B_U(together);
 824             ColorItem* item = new ColorItem( r, g, b, name );
 825
 826             gint width = PREVIEW_PIXBUF_WIDTH;
 827             gint height = VBLOCK;
 828             guchar* px = g_new( guchar, 3 * height * width );
 829             nr_render_checkerboard_rgb( px, width, height, 3 * width, 0, 0 );
 830
 831             sp_gradient_render_vector_block_rgb( grad,
 832                                                  px, width, height, 3 * width,
 833                                                  0, width, TRUE );
 834
 835             previewMappings[item] = px;
 836
 837             tmpColors.push_back(item);
 838             gradMappings[item] = grad;
 839         }
 840     }
 841 }
 842
 843 void SwatchesPanel::handleGradientsChange(SPDocument *document)
 844 {
 845     SwatchPage *docPalette = (docPalettes.find(document) != docPalettes.end()) ? docPalettes[document] : 0;
 846     if (docPalette) {
 847         std::vector<ColorItem*> tmpColors;
 848         std::map<ColorItem*, guchar*> tmpPrevs;
 849         std::map<ColorItem*, SPGradient*> tmpGrads;
 850         recalcSwatchContents(document, tmpColors, tmpPrevs, tmpGrads);
 851
 852         for (std::map<ColorItem*, guchar*>::iterator it = tmpPrevs.begin(); it != tmpPrevs.end(); ++it) {
 853             it->first->setPixData(it->second, PREVIEW_PIXBUF_WIDTH, VBLOCK);
 854         }
 855
 856         for (std::map<ColorItem*, SPGradient*>::iterator it = tmpGrads.begin(); it != tmpGrads.end(); ++it) {
 857             it->first->setGradient(it->second);
 858         }
 859
 860         docPalette->_colors.swap(tmpColors);
 861         for (std::vector<ColorItem*>::iterator it = tmpColors.begin(); it != tmpColors.end(); ++it) {
 862             delete *it;
 863         }
 864
 865
 866         // Figure out which SwatchesPanel instances are affected and update them.
 867
 868         for (std::map<SwatchesPanel*, SPDocument*>::iterator it = docPerPanel.begin(); it != docPerPanel.end(); ++it) {
 869             if (it->second == document) {
 870                 SwatchesPanel* swp = it->first;
 871                 std::vector<SwatchPage*> pages = swp->_getSwatchSets();
 872                 SwatchPage* curr = pages[swp->_currentIndex];
 873                 if (curr == docPalette) {
 874                     swp->_rebuild();
 875                 }
 876             }
 877         }
 878     }
 879 }
 880
 881 void SwatchesPanel::handleDefsModified(SPDocument *document)
 882 {
 883     SwatchPage *docPalette = (docPalettes.find(document) != docPalettes.end()) ? docPalettes[document] : 0;
 884     if (docPalette) {
 885         std::vector<ColorItem*> tmpColors;
 886         std::map<ColorItem*, guchar*> tmpPrevs;
 887         std::map<ColorItem*, SPGradient*> tmpGrads;
 888         recalcSwatchContents(document, tmpColors, tmpPrevs, tmpGrads);
 889
 890         int cap = std::min(docPalette->_colors.size(), tmpColors.size());
 891         for (int i = 0; i < cap; i++) {
 892             ColorItem* newColor = tmpColors[i];
 893             ColorItem* oldColor = docPalette->_colors[i];
 894             if ( (newColor->def.getType() != oldColor->def.getType()) ||
 895                  (newColor->def.getR() != oldColor->def.getR()) ||
 896                  (newColor->def.getG() != oldColor->def.getG()) ||
 897                  (newColor->def.getB() != oldColor->def.getB()) ) {
 898                 oldColor->def.setRGB(newColor->def.getR(), newColor->def.getG(), newColor->def.getB());
 899             }
 900             if (tmpGrads.find(newColor) != tmpGrads.end()) {
 901                 oldColor->setGradient(tmpGrads[newColor]);
 902             }
 903             if ( tmpPrevs.find(newColor) != tmpPrevs.end() ) {
 904                 oldColor->setPixData(tmpPrevs[newColor], PREVIEW_PIXBUF_WIDTH, VBLOCK);
 905             }
 906         }
 907     }
 908 }
 909
 910 std::vector<SwatchPage*> SwatchesPanel::_getSwatchSets() const
 911 {
 912     std::vector<SwatchPage*> tmp;
 913     if (docPalettes.find(_currentDocument) != docPalettes.end()) {
 914         tmp.push_back(docPalettes[_currentDocument]);
 915     }
 916
 917     tmp.insert(tmp.end(), possible.begin(), possible.end());
 918
 919     return tmp;
 920 }
 921
 922 void SwatchesPanel::_updateFromSelection()
 923 {
 924     SwatchPage *docPalette = (docPalettes.find(_currentDocument) != docPalettes.end()) ? docPalettes[_currentDocument] : 0;
 925     if ( docPalette ) {
 926         Glib::ustring fillId;
 927         Glib::ustring strokeId;
 928
 929         SPStyle *tmpStyle = sp_style_new( sp_desktop_document(_currentDesktop) );
 930         int result = sp_desktop_query_style( _currentDesktop, tmpStyle, QUERY_STYLE_PROPERTY_FILL );
 931         switch (result) {
 932             case QUERY_STYLE_SINGLE:
 933             case QUERY_STYLE_MULTIPLE_AVERAGED:
 934             case QUERY_STYLE_MULTIPLE_SAME:
 935             {
 936                 if (tmpStyle->fill.set && tmpStyle->fill.isPaintserver()) {
 937                     SPPaintServer* server = tmpStyle->getFillPaintServer();
 938                     if ( SP_IS_GRADIENT(server) ) {
 939                         SPGradient* target = 0;
 940                         SPGradient* grad = SP_GRADIENT(server);
 941                         if (grad->repr->attribute("osb:paint")) {
 942                             target = grad;
 943                         } else if ( grad->ref ) {
 944                             SPGradient *tmp = grad->ref->getObject();
 945                             if ( tmp && tmp->repr->attribute("osb:paint") ) {
 946                                 target = tmp;
 947                             }
 948                         }
 949                         if ( target ) {
 950                             gchar const* id = target->repr->attribute("id");
 951                             if ( id ) {
 952                                 fillId = id;
 953                             }
 954                         }
 955                     }
 956                 }
 957                 break;
 958             }
 959         }
 960
 961         result = sp_desktop_query_style( _currentDesktop, tmpStyle, QUERY_STYLE_PROPERTY_STROKE );
 962         switch (result) {
 963             case QUERY_STYLE_SINGLE:
 964             case QUERY_STYLE_MULTIPLE_AVERAGED:
 965             case QUERY_STYLE_MULTIPLE_SAME:
 966             {
 967                 if (tmpStyle->stroke.set && tmpStyle->stroke.isPaintserver()) {
 968                     SPPaintServer* server = tmpStyle->getStrokePaintServer();
 969                     if ( SP_IS_GRADIENT(server) ) {
 970                         SPGradient* target = 0;
 971                         SPGradient* grad = SP_GRADIENT(server);
 972                         if (grad->repr->attribute("osb:paint")) {
 973                             target = grad;
 974                         } else if ( grad->ref ) {
 975                             SPGradient *tmp = grad->ref->getObject();
 976                             if ( tmp && tmp->repr->attribute("osb:paint") ) {
 977                                 target = tmp;
 978                             }
 979                         }
 980                         if ( target ) {
 981                             gchar const* id = target->repr->attribute("id");
 982                             if ( id ) {
 983                                 strokeId = id;
 984                             }
 985                         }
 986                     }
 987                 }
 988                 break;
 989             }
 990         }
 991         sp_style_unref(tmpStyle);
 992
 993         for ( std::vector<ColorItem*>::iterator it = docPalette->_colors.begin(); it != docPalette->_colors.end(); ++it ) {
 994             ColorItem* item = *it;
 995             bool isFill = (fillId == item->def.descr);
 996             bool isStroke = (strokeId == item->def.descr);
 997             item->setState( isFill, isStroke );
 998         }
 999     }
1000 }
1001
1002 void SwatchesPanel::_handleAction( int setId, int itemId )
1003 {
1004     switch( setId ) {
1005         case 3:
1006         {
1007             std::vector<SwatchPage*> pages = _getSwatchSets();
1008             if ( itemId >= 0 && itemId < static_cast<int>(pages.size()) ) {
1009                 _currentIndex = itemId;
1010
1011                 if ( !_prefs_path.empty() ) {
1012                     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
1013                     prefs->setString(_prefs_path + "/palette", pages[_currentIndex]->_name);
1014                 }
1015
1016                 _rebuild();
1017             }
1018         }
1019         break;
1020     }
1021 }
1022
1023 void SwatchesPanel::_rebuild()
1024 {
1025     std::vector<SwatchPage*> pages = _getSwatchSets();
1026     SwatchPage* curr = pages[_currentIndex];
1027     _holder->clear();
1028
1029     if ( curr->_prefWidth > 0 ) {
1030         _holder->setColumnPref( curr->_prefWidth );
1031     }
1032     _holder->freezeUpdates();
1033     // TODO restore once 'clear' works _holder->addPreview(_clear);
1034     _holder->addPreview(_remove);
1035     for ( std::vector<ColorItem*>::iterator it = curr->_colors.begin(); it != curr->_colors.end(); it++ ) {
1036         _holder->addPreview(*it);
1037     }
1038     _holder->thawUpdates();
1039 }
1040
1041
1042
1043
1044 } //namespace Dialogs
1045 } //namespace UI
1046 } //namespace Inkscape
1047
1048
1049 /*
1050   Local Variables:
1051   mode:c++
1052   c-file-style:"stroustrup"
1053   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1054   indent-tabs-mode:nil
1055   fill-column:99
1056   End:
1057 */
1058 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :