gtk2_ardour/utils.cc

   1 /*
   2     Copyright (C) 2003 Paul Davis
   3
   4     This program is free software; you an redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <pango/pangoft2.h> // for fontmap resolution control for GnomeCanvas
  25 #include <pango/pangocairo.h> // for fontmap resolution control for GnomeCanvas
  26
  27 #include <cstdlib>
  28 #include <cctype>
  29 #include <fstream>
  30 #include <list>
  31 #include <sys/stat.h>
  32 #include <libart_lgpl/art_misc.h>
  33 #include <gtkmm/rc.h>
  34 #include <gtkmm/window.h>
  35 #include <gtkmm/combo.h>
  36 #include <gtkmm/label.h>
  37 #include <gtkmm/paned.h>
  38 #include <gtk/gtkpaned.h>
  39
  40 #include "pbd/file_utils.h"
  41
  42 #include <gtkmm2ext/utils.h>
  43 #include "ardour/configuration.h"
  44 #include "ardour/rc_configuration.h"
  45
  46 #include "ardour/filesystem_paths.h"
  47
  48 #include "ardour_ui.h"
  49 #include "debug.h"
  50 #include "public_editor.h"
  51 #include "keyboard.h"
  52 #include "utils.h"
  53 #include "i18n.h"
  54 #include "rgb_macros.h"
  55 #include "canvas_impl.h"
  56 #include "gui_thread.h"
  57
  58 using namespace std;
  59 using namespace Gtk;
  60 using namespace Glib;
  61 using namespace PBD;
  62 using Gtkmm2ext::Keyboard;
  63
  64 sigc::signal<void>  DPIReset;
  65
  66
  67 /** Add an element to a menu, settings its sensitivity.
  68  * @param m Menu to add to.
  69  * @param e Element to add.
  70  * @param s true to make sensitive, false to make insensitive
  71  */
  72 void
  73 add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s)
  74 {
  75         m.push_back (e);
  76         if (!s) {
  77                 m.back().set_sensitive (false);
  78         }
  79 }
  80
  81
  82 gint
  83 just_hide_it (GdkEventAny */*ev*/, Gtk::Window *win)
  84 {
  85         win->hide ();
  86         return 0;
  87 }
  88
  89 /* xpm2rgb copied from nixieclock, which bore the legend:
  90
  91     nixieclock - a nixie desktop timepiece
  92     Copyright (C) 2000 Greg Ercolano, erco@3dsite.com
  93
  94     and was released under the GPL.
  95 */
  96
  97 unsigned char*
  98 xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h)
  99 {
 100         static long vals[256], val;
 101         uint32_t t, x, y, colors, cpp;
 102         unsigned char c;
 103         unsigned char *savergb, *rgb;
 104
 105         // PARSE HEADER
 106
 107         if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
 108                 error << string_compose (_("bad XPM header %1"), xpm[0])
 109                       << endmsg;
 110                 return 0;
 111         }
 112
 113         savergb = rgb = (unsigned char*) malloc (h * w * 3);
 114
 115         // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 116         for (t = 0; t < colors; ++t) {
 117                 sscanf (xpm[t+1], "%c c #%lx", &c, &val);
 118                 vals[c] = val;
 119         }
 120
 121         // COLORMAP -> RGB CONVERSION
 122         //    Get low 3 bytes from vals[]
 123         //
 124
 125         const char *p;
 126         for (y = h-1; y > 0; --y) {
 127
 128                 for (p = xpm[1+colors+(h-y-1)], x = 0; x < w; x++, rgb += 3) {
 129                         val = vals[(int)*p++];
 130                         *(rgb+2) = val & 0xff; val >>= 8;  // 2:B
 131                         *(rgb+1) = val & 0xff; val >>= 8;  // 1:G
 132                         *(rgb+0) = val & 0xff;             // 0:R
 133                 }
 134         }
 135
 136         return (savergb);
 137 }
 138
 139 unsigned char*
 140 xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
 141 {
 142         static long vals[256], val;
 143         uint32_t t, x, y, colors, cpp;
 144         unsigned char c;
 145         unsigned char *savergb, *rgb;
 146         char transparent;
 147
 148         // PARSE HEADER
 149
 150         if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
 151                 error << string_compose (_("bad XPM header %1"), xpm[0])
 152                       << endmsg;
 153                 return 0;
 154         }
 155
 156         savergb = rgb = (unsigned char*) malloc (h * w * 4);
 157
 158         // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 159
 160         if (strstr (xpm[1], "None")) {
 161                 sscanf (xpm[1], "%c", &transparent);
 162                 t = 1;
 163         } else {
 164                 transparent = 0;
 165                 t = 0;
 166         }
 167
 168         for (; t < colors; ++t) {
 169                 sscanf (xpm[t+1], "%c c #%lx", &c, &val);
 170                 vals[c] = val;
 171         }
 172
 173         // COLORMAP -> RGB CONVERSION
 174         //    Get low 3 bytes from vals[]
 175         //
 176
 177         const char *p;
 178         for (y = h-1; y > 0; --y) {
 179
 180                 char alpha;
 181
 182                 for (p = xpm[1+colors+(h-y-1)], x = 0; x < w; x++, rgb += 4) {
 183
 184                         if (transparent && (*p++ == transparent)) {
 185                                 alpha = 0;
 186                                 val = 0;
 187                         } else {
 188                                 alpha = 255;
 189                                 val = vals[(int)*p];
 190                         }
 191
 192                         *(rgb+3) = alpha;                  // 3: alpha
 193                         *(rgb+2) = val & 0xff; val >>= 8;  // 2:B
 194                         *(rgb+1) = val & 0xff; val >>= 8;  // 1:G
 195                         *(rgb+0) = val & 0xff;             // 0:R
 196                 }
 197         }
 198
 199         return (savergb);
 200 }
 201
 202 ArdourCanvas::Points*
 203 get_canvas_points (string /*who*/, uint32_t npoints)
 204 {
 205         // cerr << who << ": wants " << npoints << " canvas points" << endl;
 206 #ifdef TRAP_EXCESSIVE_POINT_REQUESTS
 207         if (npoints > (uint32_t) gdk_screen_width() + 4) {
 208                 abort ();
 209         }
 210 #endif
 211         return new ArdourCanvas::Points (npoints);
 212 }
 213
 214 Pango::FontDescription
 215 get_font_for_style (string widgetname)
 216 {
 217         Gtk::Window window (WINDOW_TOPLEVEL);
 218         Gtk::Label foobar;
 219         Glib::RefPtr<Gtk::Style> style;
 220
 221         window.add (foobar);
 222         foobar.set_name (widgetname);
 223         foobar.ensure_style();
 224
 225         style = foobar.get_style ();
 226
 227         Glib::RefPtr<const Pango::Layout> layout = foobar.get_layout();
 228
 229         PangoFontDescription *pfd = (PangoFontDescription *)pango_layout_get_font_description((PangoLayout *)layout->gobj());
 230
 231         if (!pfd) {
 232
 233                 /* layout inherited its font description from a PangoContext */
 234
 235                 PangoContext* ctxt = (PangoContext*) pango_layout_get_context ((PangoLayout*) layout->gobj());
 236                 pfd =  pango_context_get_font_description (ctxt);
 237                 return Pango::FontDescription (pfd); /* make a copy */
 238         }
 239
 240         return Pango::FontDescription (pfd); /* make a copy */
 241 }
 242
 243 uint32_t
 244 rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, string attr, int state, bool rgba)
 245 {
 246         /* In GTK+2, styles aren't set up correctly if the widget is not
 247            attached to a toplevel window that has a screen pointer.
 248         */
 249
 250         static Gtk::Window* window = 0;
 251
 252         if (window == 0) {
 253                 window = new Window (WINDOW_TOPLEVEL);
 254         }
 255
 256         Gtk::Label foo;
 257
 258         window->add (foo);
 259
 260         foo.set_name (style);
 261         foo.ensure_style ();
 262
 263         GtkRcStyle* rc = foo.get_style()->gobj()->rc_style;
 264
 265         if (rc) {
 266                 if (attr == "fg") {
 267                         r = rc->fg[state].red / 257;
 268                         g = rc->fg[state].green / 257;
 269                         b = rc->fg[state].blue / 257;
 270
 271                         /* what a hack ... "a" is for "active" */
 272                         if (state == Gtk::STATE_NORMAL && rgba) {
 273                                 a = rc->fg[GTK_STATE_ACTIVE].red / 257;
 274                         }
 275                 } else if (attr == "bg") {
 276                         r = g = b = 0;
 277                         r = rc->bg[state].red / 257;
 278                         g = rc->bg[state].green / 257;
 279                         b = rc->bg[state].blue / 257;
 280                 } else if (attr == "base") {
 281                         r = rc->base[state].red / 257;
 282                         g = rc->base[state].green / 257;
 283                         b = rc->base[state].blue / 257;
 284                 } else if (attr == "text") {
 285                         r = rc->text[state].red / 257;
 286                         g = rc->text[state].green / 257;
 287                         b = rc->text[state].blue / 257;
 288                 }
 289         } else {
 290                 warning << string_compose (_("missing RGBA style for \"%1\""), style) << endl;
 291         }
 292
 293         window->remove ();
 294
 295         if (state == Gtk::STATE_NORMAL && rgba) {
 296                 return (uint32_t) RGBA_TO_UINT(r,g,b,a);
 297         } else {
 298                 return (uint32_t) RGB_TO_UINT(r,g,b);
 299         }
 300 }
 301
 302 bool
 303 canvas_item_visible (ArdourCanvas::Item* item)
 304 {
 305         return (item->gobj()->object.flags & GNOME_CANVAS_ITEM_VISIBLE) ? true : false;
 306 }
 307
 308 void
 309 set_color (Gdk::Color& c, int rgb)
 310 {
 311         c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256);
 312 }
 313
 314 bool
 315 relay_key_press (GdkEventKey* ev, Gtk::Window* win)
 316 {
 317         if (!key_press_focus_accelerator_handler (*win, ev)) {
 318                 return PublicEditor::instance().on_key_press_event(ev);
 319         } else {
 320                 return true;
 321         }
 322 }
 323
 324 bool
 325 forward_key_press (GdkEventKey* ev)
 326 {
 327         return PublicEditor::instance().on_key_press_event(ev);
 328 }
 329
 330 bool
 331 key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
 332 {
 333         GtkWindow* win = window.gobj();
 334         GtkWidget* focus = gtk_window_get_focus (win);
 335         bool special_handling_of_unmodified_accelerators = false;
 336         bool allow_activating = true;
 337         /* consider all relevant modifiers but not LOCK or SHIFT */
 338         const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
 339
 340         if (focus) {
 341                 if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
 342                         special_handling_of_unmodified_accelerators = true;
 343                 }
 344         }
 345
 346 #ifdef GTKOSX
 347         /* should this be universally true? */
 348         if (Keyboard::some_magic_widget_has_focus ()) {
 349                 allow_activating = false;
 350         }
 351 #endif
 352
 353
 354         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Win = %1 focus = %7 Key event: code = %2  state = %3 special handling ? %4 magic widget focus ? %5 allow_activation ? %6\n",
 355                                                           win,
 356                                                           ev->keyval,
 357                                                           ev->state,
 358                                                           special_handling_of_unmodified_accelerators,
 359                                                           Keyboard::some_magic_widget_has_focus(),
 360                                                           allow_activating,
 361                                                           focus));
 362
 363         /* This exists to allow us to override the way GTK handles
 364            key events. The normal sequence is:
 365
 366            a) event is delivered to a GtkWindow
 367            b) accelerators/mnemonics are activated
 368            c) if (b) didn't handle the event, propagate to
 369                the focus widget and/or focus chain
 370
 371            The problem with this is that if the accelerators include
 372            keys without modifiers, such as the space bar or the
 373            letter "e", then pressing the key while typing into
 374            a text entry widget results in the accelerator being
 375            activated, instead of the desired letter appearing
 376            in the text entry.
 377
 378            There is no good way of fixing this, but this
 379            represents a compromise. The idea is that
 380            key events involving modifiers (not Shift)
 381            get routed into the activation pathway first, then
 382            get propagated to the focus widget if necessary.
 383
 384            If the key event doesn't involve modifiers,
 385            we deliver to the focus widget first, thus allowing
 386            it to get "normal text" without interference
 387            from acceleration.
 388
 389            Of course, this can also be problematic: if there
 390            is a widget with focus, then it will swallow
 391            all "normal text" accelerators.
 392         */
 393
 394         if (!special_handling_of_unmodified_accelerators) {
 395
 396                 /* XXX note that for a brief moment, the conditional above
 397                  * included "|| (ev->state & mask)" so as to enforce the
 398                  * implication of special_handling_of_UNMODIFIED_accelerators.
 399                  * however, this forces any key that GTK doesn't allow and that
 400                  * we have an alternative (see next comment) for to be
 401                  * automatically sent through the accel groups activation
 402                  * pathway, which prevents individual widgets & canvas items
 403                  * from ever seeing it if is used by a key binding.
 404                  *
 405                  * specifically, this hid Ctrl-down-arrow from MIDI region
 406                  * views because it is also bound to an action.
 407                  *
 408                  * until we have a robust, clean binding system, this
 409                  * quirk will have to remain in place.
 410                  */
 411
 412                 /* pretend that certain key events that GTK does not allow
 413                    to be used as accelerators are actually something that
 414                    it does allow. but only where there are no modifiers.
 415                 */
 416
 417                 uint32_t fakekey = ev->keyval;
 418
 419                 if (Gtkmm2ext::possibly_translate_keyval_to_make_legal_accelerator (fakekey)) {
 420                         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tactivate (was %1 now %2) without special hanlding of unmodified accels\n",
 421                                                                           ev->keyval, fakekey));
 422
 423                         GdkModifierType mod = GdkModifierType (ev->state);
 424
 425                         mod = GdkModifierType (mod & gtk_accelerator_get_default_mod_mask());
 426 #ifdef GTKOSX
 427                         /* GTK on OS X is currently (February 2012) setting both
 428                            the Meta and Mod2 bits in the event modifier state if
 429                            the Command key is down.
 430
 431                            gtk_accel_groups_activate() does not invoke any of the logic
 432                            that gtk_window_activate_key() will that sorts out that stupid
 433                            state of affairs, and as a result it fails to find a match
 434                            for the key event and the current set of accelerators.
 435
 436                            to fix this, if the meta bit is set, remove the mod2 bit
 437                            from the modifier. this assumes that our bindings use Primary
 438                            which will have set the meta bit in the accelerator entry.
 439                         */
 440                         if (mod & GDK_META_MASK) {
 441                                 mod = GdkModifierType (mod & ~GDK_MOD2_MASK);
 442                         }
 443 #endif
 444
 445                         if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, mod)) {
 446                                 DEBUG_TRACE (DEBUG::Accelerators, "\taccel group activated by fakekey\n");
 447                                 return true;
 448                         }
 449                 }
 450         }
 451
 452         if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
 453
 454                 /* no special handling or there are modifiers in effect: accelerate first */
 455
 456                 DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n");
 457
 458                 if (allow_activating) {
 459                         if (gtk_window_activate_key (win, ev)) {
 460                                 return true;
 461                         }
 462                 } else {
 463                         DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
 464                 }
 465
 466                 DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n");
 467
 468                 return gtk_window_propagate_key_event (win, ev);
 469         }
 470
 471         /* no modifiers, propagate first */
 472
 473         DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n");
 474
 475         if (!gtk_window_propagate_key_event (win, ev)) {
 476                 DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n");
 477                 if (allow_activating) {
 478                         return gtk_window_activate_key (win, ev);
 479                 } else {
 480                         DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
 481                 }
 482
 483         } else {
 484                 DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n");
 485                 return true;
 486         }
 487
 488         DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n");
 489         return true;
 490 }
 491
 492 Glib::RefPtr<Gdk::Pixbuf>
 493 get_xpm (std::string name)
 494 {
 495         if (!xpm_map[name]) {
 496
 497                 SearchPath spath(ARDOUR::ardour_search_path());
 498                 spath += ARDOUR::system_data_search_path();
 499
 500                 spath.add_subdirectory_to_paths("pixmaps");
 501
 502                 sys::path data_file_path;
 503
 504                 if(!find_file_in_search_path (spath, name, data_file_path)) {
 505                         fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg;
 506                 }
 507
 508                 try {
 509                         xpm_map[name] =  Gdk::Pixbuf::create_from_file (data_file_path.to_string());
 510                 } catch(const Glib::Error& e)   {
 511                         warning << "Caught Glib::Error: " << e.what() << endmsg;
 512                 }
 513         }
 514
 515         return xpm_map[name];
 516 }
 517
 518 std::string
 519 get_icon_path (const char* cname)
 520 {
 521         string name = cname;
 522         name += X_(".png");
 523
 524         SearchPath spath(ARDOUR::ardour_search_path());
 525         spath += ARDOUR::system_data_search_path();
 526
 527         spath.add_subdirectory_to_paths("icons");
 528
 529         sys::path data_file_path;
 530
 531         if (!find_file_in_search_path (spath, name, data_file_path)) {
 532                 fatal << string_compose (_("cannot find icon image for %1"), name) << endmsg;
 533         }
 534
 535         return data_file_path.to_string();
 536 }
 537
 538 Glib::RefPtr<Gdk::Pixbuf>
 539 get_icon (const char* cname)
 540 {
 541         Glib::RefPtr<Gdk::Pixbuf> img;
 542         try {
 543                 img = Gdk::Pixbuf::create_from_file (get_icon_path (cname));
 544         } catch (const Gdk::PixbufError &e) {
 545                 cerr << "Caught PixbufError: " << e.what() << endl;
 546         } catch (...) {
 547                 g_message("Caught ... ");
 548         }
 549
 550         return img;
 551 }
 552
 553 string
 554 longest (vector<string>& strings)
 555 {
 556         if (strings.empty()) {
 557                 return string ("");
 558         }
 559
 560         vector<string>::iterator longest = strings.begin();
 561         string::size_type longest_length = (*longest).length();
 562
 563         vector<string>::iterator i = longest;
 564         ++i;
 565
 566         while (i != strings.end()) {
 567
 568                 string::size_type len = (*i).length();
 569
 570                 if (len > longest_length) {
 571                         longest = i;
 572                         longest_length = len;
 573                 }
 574
 575                 ++i;
 576         }
 577
 578         return *longest;
 579 }
 580
 581 bool
 582 key_is_legal_for_numeric_entry (guint keyval)
 583 {
 584         switch (keyval) {
 585         case GDK_minus:
 586         case GDK_plus:
 587         case GDK_period:
 588         case GDK_comma:
 589         case GDK_0:
 590         case GDK_1:
 591         case GDK_2:
 592         case GDK_3:
 593         case GDK_4:
 594         case GDK_5:
 595         case GDK_6:
 596         case GDK_7:
 597         case GDK_8:
 598         case GDK_9:
 599         case GDK_KP_Add:
 600         case GDK_KP_Subtract:
 601         case GDK_KP_Decimal:
 602         case GDK_KP_0:
 603         case GDK_KP_1:
 604         case GDK_KP_2:
 605         case GDK_KP_3:
 606         case GDK_KP_4:
 607         case GDK_KP_5:
 608         case GDK_KP_6:
 609         case GDK_KP_7:
 610         case GDK_KP_8:
 611         case GDK_KP_9:
 612         case GDK_Return:
 613         case GDK_BackSpace:
 614         case GDK_Delete:
 615         case GDK_KP_Enter:
 616         case GDK_Home:
 617         case GDK_End:
 618         case GDK_Left:
 619         case GDK_Right:
 620                 return true;
 621
 622         default:
 623                 break;
 624         }
 625
 626         return false;
 627 }
 628 void
 629 set_pango_fontsize ()
 630 {
 631         long val = ARDOUR::Config->get_font_scale();
 632
 633         /* FT2 rendering - used by GnomeCanvas, sigh */
 634
 635         pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_for_display(), val/1024, val/1024);
 636
 637         /* Cairo rendering, in case there is any */
 638
 639         pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) pango_cairo_font_map_get_default(), val/1024);
 640 }
 641
 642 void
 643 reset_dpi ()
 644 {
 645         long val = ARDOUR::Config->get_font_scale();
 646         set_pango_fontsize ();
 647         /* Xft rendering */
 648
 649         gtk_settings_set_long_property (gtk_settings_get_default(),
 650                                         "gtk-xft-dpi", val, "ardour");
 651         DPIReset();//Emit Signal
 652 }
 653
 654 void
 655 resize_window_to_proportion_of_monitor (Gtk::Window* window, int max_width, int max_height)
 656 {
 657         Glib::RefPtr<Gdk::Screen> screen = window->get_screen ();
 658         Gdk::Rectangle monitor_rect;
 659         screen->get_monitor_geometry (0, monitor_rect);
 660
 661         int const w = std::min (int (monitor_rect.get_width() * 0.8), max_width);
 662         int const h = std::min (int (monitor_rect.get_height() * 0.8), max_height);
 663
 664         window->resize (w, h);
 665 }
 666
 667
 668 /** Replace _ with __ in a string; for use with menu item text to make underscores displayed correctly */
 669 string
 670 escape_underscores (string const & s)
 671 {
 672         string o;
 673         string::size_type const N = s.length ();
 674
 675         for (string::size_type i = 0; i < N; ++i) {
 676                 if (s[i] == '_') {
 677                         o += "__";
 678                 } else {
 679                         o += s[i];
 680                 }
 681         }
 682
 683         return o;
 684 }
 685
 686 Gdk::Color
 687 unique_random_color (list<Gdk::Color>& used_colors)
 688 {
 689         Gdk::Color newcolor;
 690
 691         while (1) {
 692
 693                 /* avoid neon/glowing tones by limiting them to the
 694                    "inner section" (paler) of a color wheel/circle.
 695                 */
 696
 697                 const int32_t max_saturation = 48000; // 65535 would open up the whole color wheel
 698
 699                 newcolor.set_red (random() % max_saturation);
 700                 newcolor.set_blue (random() % max_saturation);
 701                 newcolor.set_green (random() % max_saturation);
 702
 703                 if (used_colors.size() == 0) {
 704                         used_colors.push_back (newcolor);
 705                         return newcolor;
 706                 }
 707
 708                 for (list<Gdk::Color>::iterator i = used_colors.begin(); i != used_colors.end(); ++i) {
 709                   Gdk::Color c = *i;
 710                         float rdelta, bdelta, gdelta;
 711
 712                         rdelta = newcolor.get_red() - c.get_red();
 713                         bdelta = newcolor.get_blue() - c.get_blue();
 714                         gdelta = newcolor.get_green() - c.get_green();
 715
 716                         if (sqrt (rdelta*rdelta + bdelta*bdelta + gdelta*gdelta) > 25.0) {
 717                                 used_colors.push_back (newcolor);
 718                                 return newcolor;
 719                         }
 720                 }
 721
 722                 /* XXX need throttle here to make sure we don't spin for ever */
 723         }
 724 }