X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Futils.cc;h=c0fc619f6878b453914d710f12135df31b083e5b;hb=6618c9e4060da66964bd5707be442ba3f0f156ef;hp=dc410136d7f2d78a67d5f9cf35f3aa46e1ffe69d;hpb=b895b677bf29cca95fe0626616d7495113386b04;p=ardour.git diff --git a/gtk2_ardour/utils.cc b/gtk2_ardour/utils.cc index dc410136d7..c0fc619f68 100644 --- a/gtk2_ardour/utils.cc +++ b/gtk2_ardour/utils.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2003 Paul Davis + Copyright (C) 2003 Paul Davis This program is free software; you an redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,136 +17,70 @@ */ +#ifdef WAF_BUILD +#include "gtk2ardour-config.h" +#endif + #include // for fontmap resolution control for GnomeCanvas #include // for fontmap resolution control for GnomeCanvas #include +#include +#include #include #include +#include #include -#include #include #include #include #include #include #include +#include #include "pbd/file_utils.h" #include -#include "ardour/configuration.h" -#include "ardour/configuration.h" - +#include "ardour/rc_configuration.h" #include "ardour/filesystem_paths.h" +#include "canvas/item.h" #include "ardour_ui.h" +#include "debug.h" +#include "public_editor.h" #include "keyboard.h" #include "utils.h" #include "i18n.h" #include "rgb_macros.h" -#include "canvas_impl.h" +#include "gui_thread.h" using namespace std; using namespace Gtk; -using namespace sigc; using namespace Glib; using namespace PBD; +using Gtkmm2ext::Keyboard; sigc::signal DPIReset; -int -pixel_width (const ustring& str, Pango::FontDescription& font) -{ - Label foo; - Glib::RefPtr layout = foo.create_pango_layout (""); - - layout->set_font_description (font); - layout->set_text (str); - - int width, height; - Gtkmm2ext::get_ink_pixel_size (layout, width, height); - return width; -} - -ustring -fit_to_pixels (const ustring& str, int pixel_width, Pango::FontDescription& font, int& actual_width, bool with_ellipses) -{ - Label foo; - Glib::RefPtr layout = foo.create_pango_layout (""); - ustring::size_type shorter_by = 0; - ustring txt; - - layout->set_font_description (font); - - actual_width = 0; - - ustring ustr = str; - ustring::iterator last = ustr.end(); - --last; /* now points at final entry */ - - txt = ustr; - - while (!ustr.empty()) { - layout->set_text (txt); - - int width, height; - Gtkmm2ext::get_ink_pixel_size (layout, width, height); - - if (width < pixel_width) { - actual_width = width; - break; - } - - ustr.erase (last--); - shorter_by++; - - if (with_ellipses && shorter_by > 3) { - txt = ustr; - txt += "..."; - } else { - txt = ustr; - } - } - - return txt; -} - -std::pair -fit_to_pixels (cairo_t* cr, std::string name, double avail) +/** Add an element to a menu, settings its sensitivity. + * @param m Menu to add to. + * @param e Element to add. + * @param s true to make sensitive, false to make insensitive + */ +void +add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s) { - /* XXX hopefully there exists a more efficient way of doing this */ - - bool abbreviated = false; - uint32_t width = 0; - - while (1) { - if (name.length() <= 4) { - break; - } - - cairo_text_extents_t ext; - cairo_text_extents (cr, name.c_str(), &ext); - if (ext.width < avail) { - width = ext.width; - break; - } - - if (abbreviated) { - name = name.substr (0, name.length() - 4) + "..."; - } else { - name = name.substr (0, name.length() - 3) + "..."; - abbreviated = true; - } + m.push_back (e); + if (!s) { + m.back().set_sensitive (false); } - - return std::make_pair (name, width); } gint -just_hide_it (GdkEventAny *ev, Gtk::Window *win) +just_hide_it (GdkEventAny */*ev*/, Gtk::Window *win) { win->hide (); return 0; @@ -167,9 +101,9 @@ xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h) uint32_t t, x, y, colors, cpp; unsigned char c; unsigned char *savergb, *rgb; - + // PARSE HEADER - + if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) { error << string_compose (_("bad XPM header %1"), xpm[0]) << endmsg; @@ -177,13 +111,13 @@ xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h) } savergb = rgb = (unsigned char*) malloc (h * w * 3); - + // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION for (t = 0; t < colors; ++t) { sscanf (xpm[t+1], "%c c #%lx", &c, &val); vals[c] = val; } - + // COLORMAP -> RGB CONVERSION // Get low 3 bytes from vals[] // @@ -220,7 +154,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h) } savergb = rgb = (unsigned char*) malloc (h * w * 4); - + // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION if (strstr (xpm[1], "None")) { @@ -235,7 +169,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h) sscanf (xpm[t+1], "%c c #%lx", &c, &val); vals[c] = val; } - + // COLORMAP -> RGB CONVERSION // Get low 3 bytes from vals[] // @@ -265,19 +199,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h) return (savergb); } -ArdourCanvas::Points* -get_canvas_points (string who, uint32_t npoints) -{ - // cerr << who << ": wants " << npoints << " canvas points" << endl; -#ifdef TRAP_EXCESSIVE_POINT_REQUESTS - if (npoints > (uint32_t) gdk_screen_width() + 4) { - abort (); - } -#endif - return new ArdourCanvas::Points (npoints); -} - -Pango::FontDescription* +Pango::FontDescription get_font_for_style (string widgetname) { Gtk::Window window (WINDOW_TOPLEVEL); @@ -291,19 +213,19 @@ get_font_for_style (string widgetname) style = foobar.get_style (); Glib::RefPtr layout = foobar.get_layout(); - - PangoFontDescription *pfd = (PangoFontDescription *)pango_layout_get_font_description((PangoLayout *)layout->gobj()); - + + PangoFontDescription *pfd = const_cast (pango_layout_get_font_description(const_cast(layout->gobj()))); + if (!pfd) { - + /* layout inherited its font description from a PangoContext */ - PangoContext* ctxt = (PangoContext*) pango_layout_get_context ((PangoLayout*) layout->gobj()); + PangoContext* ctxt = (PangoContext*) pango_layout_get_context (const_cast(layout->gobj())); pfd = pango_context_get_font_description (ctxt); - return new Pango::FontDescription (pfd, true); /* make a copy */ - } + return Pango::FontDescription (pfd); /* make a copy */ + } - return new Pango::FontDescription (pfd, true); /* make a copy */ + return Pango::FontDescription (pfd); /* make a copy */ } uint32_t @@ -320,44 +242,44 @@ rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, s } Gtk::Label foo; - + window->add (foo); foo.set_name (style); foo.ensure_style (); - - GtkRcStyle* waverc = foo.get_style()->gobj()->rc_style; - if (waverc) { + GtkRcStyle* rc = foo.get_style()->gobj()->rc_style; + + if (rc) { if (attr == "fg") { - r = waverc->fg[state].red / 257; - g = waverc->fg[state].green / 257; - b = waverc->fg[state].blue / 257; - + r = rc->fg[state].red / 257; + g = rc->fg[state].green / 257; + b = rc->fg[state].blue / 257; + /* what a hack ... "a" is for "active" */ if (state == Gtk::STATE_NORMAL && rgba) { - a = waverc->fg[GTK_STATE_ACTIVE].red / 257; + a = rc->fg[GTK_STATE_ACTIVE].red / 257; } } else if (attr == "bg") { r = g = b = 0; - r = waverc->bg[state].red / 257; - g = waverc->bg[state].green / 257; - b = waverc->bg[state].blue / 257; + r = rc->bg[state].red / 257; + g = rc->bg[state].green / 257; + b = rc->bg[state].blue / 257; } else if (attr == "base") { - r = waverc->base[state].red / 257; - g = waverc->base[state].green / 257; - b = waverc->base[state].blue / 257; + r = rc->base[state].red / 257; + g = rc->base[state].green / 257; + b = rc->base[state].blue / 257; } else if (attr == "text") { - r = waverc->text[state].red / 257; - g = waverc->text[state].green / 257; - b = waverc->text[state].blue / 257; + r = rc->text[state].red / 257; + g = rc->text[state].green / 257; + b = rc->text[state].blue / 257; } } else { warning << string_compose (_("missing RGBA style for \"%1\""), style) << endl; } window->remove (); - + if (state == Gtk::STATE_NORMAL && rgba) { return (uint32_t) RGBA_TO_UINT(r,g,b,a); } else { @@ -365,130 +287,57 @@ rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, s } } - -Gdk::Color -color_from_style (string widget_style_name, int state, string attr) +void +set_color (Gdk::Color& c, int rgb) { - GtkStyle* style; - - style = gtk_rc_get_style_by_paths (gtk_settings_get_default(), - widget_style_name.c_str(), - 0, G_TYPE_NONE); - - if (!style) { - error << string_compose (_("no style found for %1, using red"), style) << endmsg; - return Gdk::Color ("red"); - } - - if (attr == "fg") { - return Gdk::Color (&style->fg[state]); - } - - if (attr == "bg") { - return Gdk::Color (&style->bg[state]); - } - - if (attr == "light") { - return Gdk::Color (&style->light[state]); - } - - if (attr == "dark") { - return Gdk::Color (&style->dark[state]); - } - - if (attr == "mid") { - return Gdk::Color (&style->mid[state]); - } - - if (attr == "text") { - return Gdk::Color (&style->text[state]); - } - - if (attr == "base") { - return Gdk::Color (&style->base[state]); - } - - if (attr == "text_aa") { - return Gdk::Color (&style->text_aa[state]); - } - - error << string_compose (_("unknown style attribute %1 requested for color; using \"red\""), attr) << endmsg; - return Gdk::Color ("red"); + c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256); } -Glib::RefPtr -gc_from_style (string widget_style_name, int state, string attr) +bool +relay_key_press (GdkEventKey* ev, Gtk::Window* win) { - GtkStyle* style; - - style = gtk_rc_get_style_by_paths (gtk_settings_get_default(), - widget_style_name.c_str(), - 0, G_TYPE_NONE); - - if (!style) { - error << string_compose (_("no style found for %1, using red"), style) << endmsg; - Glib::RefPtr ret = Gdk::GC::create(); - ret->set_rgb_fg_color(Gdk::Color("red")); - return ret; - } - - if (attr == "fg") { - return Glib::wrap(style->fg_gc[state]); - } - - if (attr == "bg") { - return Glib::wrap(style->bg_gc[state]); - } - - if (attr == "light") { - return Glib::wrap(style->light_gc[state]); - } - - if (attr == "dark") { - return Glib::wrap(style->dark_gc[state]); - } - - if (attr == "mid") { - return Glib::wrap(style->mid_gc[state]); - } - - if (attr == "text") { - return Glib::wrap(style->text_gc[state]); - } - - if (attr == "base") { - return Glib::wrap(style->base_gc[state]); - } - - if (attr == "text_aa") { - return Glib::wrap(style->text_aa_gc[state]); - } - - error << string_compose (_("unknown style attribute %1 requested for color; using \"red\""), attr) << endmsg; - Glib::RefPtr ret = Gdk::GC::create(); - ret->set_rgb_fg_color(Gdk::Color("red")); - return ret; + if (!key_press_focus_accelerator_handler (*win, ev)) { + return PublicEditor::instance().on_key_press_event(ev); + } else { + return true; + } } - -bool -canvas_item_visible (ArdourCanvas::Item* item) +bool +forward_key_press (GdkEventKey* ev) { - return (item->gobj()->object.flags & GNOME_CANVAS_ITEM_VISIBLE) ? true : false; + return PublicEditor::instance().on_key_press_event(ev); } -void -set_color (Gdk::Color& c, int rgb) +bool +emulate_key_event (Gtk::Widget* w, unsigned int keyval) { - c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256); + GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET(w->gobj())); + GdkKeymap *keymap = gdk_keymap_get_for_display (display); + GdkKeymapKey *keymapkey = NULL; + gint n_keys; + + if (!gdk_keymap_get_entries_for_keyval(keymap, keyval, &keymapkey, &n_keys)) return false; + if (n_keys !=1) { g_free(keymapkey); return false;} + + GdkEventKey ev; + ev.type = GDK_KEY_PRESS; + ev.window = gtk_widget_get_window(GTK_WIDGET(w->gobj())); + ev.send_event = FALSE; + ev.time = 0; + ev.state = 0; + ev.keyval = keyval; + ev.length = 0; + ev.string = const_cast (""); + ev.hardware_keycode = keymapkey[0].keycode; + ev.group = keymapkey[0].group; + g_free(keymapkey); + + forward_key_press(&ev); + ev.type = GDK_KEY_RELEASE; + return forward_key_press(&ev); } -#ifdef GTKOSX -extern "C" { - gboolean gdk_quartz_possibly_forward (GdkEvent*); -} -#endif - bool key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev) { @@ -496,37 +345,37 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev) GtkWidget* focus = gtk_window_get_focus (win); bool special_handling_of_unmodified_accelerators = false; bool allow_activating = true; + /* consider all relevant modifiers but not LOCK or SHIFT */ + const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK)); -#undef DEBUG_ACCELERATOR_HANDLING -#ifdef DEBUG_ACCELERATOR_HANDLING - //bool debug = (getenv ("ARDOUR_DEBUG_ACCELERATOR_HANDLING") != 0); - bool debug=true; -#endif if (focus) { if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) { special_handling_of_unmodified_accelerators = true; - } - } + } + } #ifdef GTKOSX - /* should this be universally true? */ + /* at one time this appeared to be necessary. As of July 2012, it does not + appear to be. if it ever is necessar, figure out if it should apply + to all platforms. + */ +#if 0 if (Keyboard::some_magic_widget_has_focus ()) { - allow_activating = false; + allow_activating = false; } #endif - -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "Win = " << win << " Key event: code = " << ev->keyval << " state = " << hex << ev->state << dec << " special handling ? " - << special_handling_of_unmodified_accelerators - << " magic widget focus ? " - << Keyboard::some_magic_widget_has_focus() - << " allow_activation ? " - << allow_activating - << endl; - } #endif + + 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", + win, + ev->keyval, + ev->state, + special_handling_of_unmodified_accelerators, + Keyboard::some_magic_widget_has_focus(), + allow_activating, + focus)); + /* This exists to allow us to override the way GTK handles key events. The normal sequence is: @@ -536,18 +385,18 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev) the focus widget and/or focus chain The problem with this is that if the accelerators include - keys without modifiers, such as the space bar or the + keys without modifiers, such as the space bar or the letter "e", then pressing the key while typing into a text entry widget results in the accelerator being activated, instead of the desired letter appearing in the text entry. There is no good way of fixing this, but this - represents a compromise. The idea is that + represents a compromise. The idea is that key events involving modifiers (not Shift) get routed into the activation pathway first, then get propagated to the focus widget if necessary. - + If the key event doesn't involve modifiers, we deliver to the focus widget first, thus allowing it to get "normal text" without interference @@ -558,126 +407,125 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev) all "normal text" accelerators. */ - if (!special_handling_of_unmodified_accelerators) { + /* XXX note that for a brief moment, the conditional above + * included "|| (ev->state & mask)" so as to enforce the + * implication of special_handling_of_UNMODIFIED_accelerators. + * however, this forces any key that GTK doesn't allow and that + * we have an alternative (see next comment) for to be + * automatically sent through the accel groups activation + * pathway, which prevents individual widgets & canvas items + * from ever seeing it if is used by a key binding. + * + * specifically, this hid Ctrl-down-arrow from MIDI region + * views because it is also bound to an action. + * + * until we have a robust, clean binding system, this + * quirk will have to remain in place. + */ + /* pretend that certain key events that GTK does not allow to be used as accelerators are actually something that - it does allow. + it does allow. but only where there are no modifiers. */ uint32_t fakekey = ev->keyval; - if (possibly_translate_keyval_to_make_legal_accelerator (fakekey)) { - if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, GdkModifierType(ev->state))) { - return true; - } + if (Gtkmm2ext::possibly_translate_keyval_to_make_legal_accelerator (fakekey)) { + DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tactivate (was %1 now %2) without special hanlding of unmodified accels\n", + ev->keyval, fakekey)); + + GdkModifierType mod = GdkModifierType (ev->state); + mod = GdkModifierType (mod & gtk_accelerator_get_default_mod_mask()); #ifdef GTKOSX - if (allow_activating) { - int oldval = ev->keyval; - ev->keyval = fakekey; - if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) { - return true; - } - ev->keyval = oldval; + /* GTK on OS X is currently (February 2012) setting both + the Meta and Mod2 bits in the event modifier state if + the Command key is down. + + gtk_accel_groups_activate() does not invoke any of the logic + that gtk_window_activate_key() will that sorts out that stupid + state of affairs, and as a result it fails to find a match + for the key event and the current set of accelerators. + + to fix this, if the meta bit is set, remove the mod2 bit + from the modifier. this assumes that our bindings use Primary + which will have set the meta bit in the accelerator entry. + */ + if (mod & GDK_META_MASK) { + mod = GdkModifierType (mod & ~GDK_MOD2_MASK); } #endif + + if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, mod)) { + DEBUG_TRACE (DEBUG::Accelerators, "\taccel group activated by fakekey\n"); + return true; + } } } - /* consider all relevant modifiers but not LOCK or SHIFT */ - - guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK)); - if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) { /* no special handling or there are modifiers in effect: accelerate first */ -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\tactivate, then propagate\n"; - } -#endif + DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n"); + DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tevent send-event:%1 time:%2 length:%3 string:%4 hardware_keycode:%5 group:%6\n", + ev->send_event, ev->time, ev->length, ev->string, ev->hardware_keycode, ev->group)); if (allow_activating) { -#ifdef GTKOSX - if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) { - return true; - } -#endif + DEBUG_TRACE (DEBUG::Accelerators, "\tsending to window\n"); if (gtk_window_activate_key (win, ev)) { + DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n"); return true; } + } else { + DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n"); } -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\tnot accelerated, now propagate\n"; - } -#endif + DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n"); + return gtk_window_propagate_key_event (win, ev); } - + /* no modifiers, propagate first */ - -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\tpropagate, then activate\n"; - } -#endif - if (!gtk_window_propagate_key_event (win, ev)) { -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\tpropagation didn't handle, so activate\n"; - } -#endif + DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n"); + + if (!gtk_window_propagate_key_event (win, ev)) { + DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n"); if (allow_activating) { - -#ifdef GTKOSX - if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) { - return true; - } -#endif return gtk_window_activate_key (win, ev); - } - - } else { -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\thandled by propagate\n"; + } else { + DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n"); } -#endif + + } else { + DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n"); return true; } -#ifdef DEBUG_ACCELERATOR_HANDLING - if (debug) { - cerr << "\tnot handled\n"; - } -#endif + DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n"); return true; } -Glib::RefPtr +Glib::RefPtr get_xpm (std::string name) { if (!xpm_map[name]) { - SearchPath spath(ARDOUR::ardour_search_path()); - spath += ARDOUR::system_data_search_path(); - + SearchPath spath(ARDOUR::ardour_data_search_path()); + spath.add_subdirectory_to_paths("pixmaps"); - - sys::path data_file_path; - + + std::string data_file_path; + if(!find_file_in_search_path (spath, name, data_file_path)) { fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg; } - + try { - xpm_map[name] = Gdk::Pixbuf::create_from_file (data_file_path.to_string()); + xpm_map[name] = Gdk::Pixbuf::create_from_file (data_file_path); } catch(const Glib::Error& e) { warning << "Caught Glib::Error: " << e.what() << endmsg; } @@ -686,31 +534,35 @@ get_xpm (std::string name) return xpm_map[name]; } - -Glib::RefPtr -get_icon (const char* cname) +std::string +get_icon_path (const char* cname) { string name = cname; name += X_(".png"); - SearchPath spath(ARDOUR::ardour_search_path()); - spath += ARDOUR::system_data_search_path(); + SearchPath spath(ARDOUR::ardour_data_search_path()); spath.add_subdirectory_to_paths("icons"); - sys::path data_file_path; + std::string data_file_path; if (!find_file_in_search_path (spath, name, data_file_path)) { - fatal << string_compose (_("cannot find icon image for %1"), name) << endmsg; + fatal << string_compose (_("cannot find icon image for %1 using %2"), name, spath.to_string()) << endmsg; } + return data_file_path; +} + +Glib::RefPtr +get_icon (const char* cname) +{ Glib::RefPtr img; try { - img = Gdk::Pixbuf::create_from_file (data_file_path.to_string()); + img = Gdk::Pixbuf::create_from_file (get_icon_path (cname)); } catch (const Gdk::PixbufError &e) { cerr << "Caught PixbufError: " << e.what() << endl; } catch (...) { - g_message("Caught ... "); + error << string_compose (_("Caught exception while loading icon named %1"), cname) << endmsg; } return img; @@ -725,33 +577,70 @@ longest (vector& strings) vector::iterator longest = strings.begin(); string::size_type longest_length = (*longest).length(); - + vector::iterator i = longest; ++i; while (i != strings.end()) { - + string::size_type len = (*i).length(); - + if (len > longest_length) { longest = i; longest_length = len; - } - + } + ++i; } - + return *longest; } bool key_is_legal_for_numeric_entry (guint keyval) { + /* we assume that this does not change over the life of the process + */ + + static int comma_decimal = -1; + switch (keyval) { - case GDK_minus: - case GDK_plus: case GDK_period: case GDK_comma: + if (comma_decimal < 0) { + std::lconv* lc = std::localeconv(); + if (strchr (lc->decimal_point, ',') != 0) { + comma_decimal = 1; + } else { + comma_decimal = 0; + } + } + break; + default: + break; + } + + switch (keyval) { + case GDK_decimalpoint: + case GDK_KP_Separator: + return true; + + case GDK_period: + if (comma_decimal) { + return false; + } else { + return true; + } + break; + case GDK_comma: + if (comma_decimal) { + return true; + } else { + return false; + } + break; + case GDK_minus: + case GDK_plus: case GDK_0: case GDK_1: case GDK_2: @@ -784,7 +673,7 @@ key_is_legal_for_numeric_entry (guint keyval) case GDK_Left: case GDK_Right: return true; - + default: break; } @@ -798,10 +687,10 @@ set_pango_fontsize () /* FT2 rendering - used by GnomeCanvas, sigh */ - pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_for_display(), val/1024, val/1024); + pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_new(), val/1024, val/1024); /* Cairo rendering, in case there is any */ - + pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) pango_cairo_font_map_get_default(), val/1024); } @@ -817,74 +706,95 @@ reset_dpi () DPIReset();//Emit Signal } -bool -possibly_translate_keyval_to_make_legal_accelerator (uint32_t& keyval) +void +resize_window_to_proportion_of_monitor (Gtk::Window* window, int max_width, int max_height) { - int fakekey = GDK_VoidSymbol; + Glib::RefPtr screen = window->get_screen (); + Gdk::Rectangle monitor_rect; + screen->get_monitor_geometry (0, monitor_rect); - switch (keyval) { - case GDK_Tab: - case GDK_ISO_Left_Tab: - fakekey = GDK_nabla; - break; - - case GDK_Up: - fakekey = GDK_uparrow; - break; - - case GDK_Down: - fakekey = GDK_downarrow; - break; - - case GDK_Right: - fakekey = GDK_rightarrow; - break; - - case GDK_Left: - fakekey = GDK_leftarrow; - break; - - default: - break; + int const w = std::min (int (monitor_rect.get_width() * 0.8), max_width); + int const h = std::min (int (monitor_rect.get_height() * 0.8), max_height); + + window->resize (w, h); +} + + +/** Replace _ with __ in a string; for use with menu item text to make underscores displayed correctly */ +string +escape_underscores (string const & s) +{ + string o; + string::size_type const N = s.length (); + + for (string::size_type i = 0; i < N; ++i) { + if (s[i] == '_') { + o += "__"; + } else { + o += s[i]; + } } - - if (fakekey != GDK_VoidSymbol) { - keyval = fakekey; - return true; - } - return false; + return o; } - -inline guint8 -convert_color_channel (guint8 src, - guint8 alpha) +/** Replace < and > with < and > respectively to make < > display correctly in markup strings */ +string +escape_angled_brackets (string const & s) { - return alpha ? ((guint (src) << 8) - src) / alpha : 0; + string o = s; + boost::replace_all (o, "<", "<"); + boost::replace_all (o, ">", ">"); + return o; } -void -convert_bgra_to_rgba (guint8 const* src, - guint8* dst, - int width, - int height) +Gdk::Color +unique_random_color (list& used_colors) { - guint8 const* src_pixel = src; - guint8* dst_pixel = dst; - - for (int y = 0; y < height; y++) - for (int x = 0; x < width; x++) - { - dst_pixel[0] = convert_color_channel (src_pixel[2], - src_pixel[3]); - dst_pixel[1] = convert_color_channel (src_pixel[1], - src_pixel[3]); - dst_pixel[2] = convert_color_channel (src_pixel[0], - src_pixel[3]); - dst_pixel[3] = src_pixel[3]; - - dst_pixel += 4; - src_pixel += 4; + Gdk::Color newcolor; + + while (1) { + + double h, s, v; + + h = fmod (random(), 360.0); + s = (random() % 65535) / 65535.0; + v = (random() % 65535) / 65535.0; + +#if 0 + /* avoid neon/glowing tones by limiting them to the + "inner section" (paler) of a color wheel/circle. + */ + + const int32_t max_saturation = 48000; // 65535 would open up the whole color wheel + + newcolor.set_red (random() % max_saturation); + newcolor.set_blue (random() % max_saturation); + newcolor.set_green (random() % max_saturation); +#else + s = min (0.5, s); /* not too saturated */ + v = max (0.9, v); /* not too bright */ + newcolor.set_hsv (h, s, v); +#endif + if (used_colors.size() == 0) { + used_colors.push_back (newcolor); + return newcolor; } + + for (list::iterator i = used_colors.begin(); i != used_colors.end(); ++i) { + Gdk::Color c = *i; + float rdelta, bdelta, gdelta; + + rdelta = newcolor.get_red() - c.get_red(); + bdelta = newcolor.get_blue() - c.get_blue(); + gdelta = newcolor.get_green() - c.get_green(); + + if (sqrt (rdelta*rdelta + bdelta*bdelta + gdelta*gdelta) > 25.0) { + used_colors.push_back (newcolor); + return newcolor; + } + } + + /* XXX need throttle here to make sure we don't spin for ever */ + } }