static void gimp_procedure_action_connect_proxy (GtkAction *action, GtkWidget *proxy) { GimpProcedureAction *procedure_action = GIMP_PROCEDURE_ACTION (action); GTK_ACTION_CLASS (parent_class)->connect_proxy (action, proxy); if (GTK_IS_IMAGE_MENU_ITEM (proxy) && procedure_action->procedure) { GdkPixbuf *pixbuf; g_object_get (procedure_action->procedure, "icon-pixbuf", &pixbuf, NULL); if (pixbuf) { GtkSettings *settings = gtk_widget_get_settings (proxy); gint width; gint height; GtkWidget *image; gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU, &width, &height); if (width != gdk_pixbuf_get_width (pixbuf) || height != gdk_pixbuf_get_height (pixbuf)) { GdkPixbuf *copy; copy = gdk_pixbuf_scale_simple (pixbuf, width, height, GDK_INTERP_BILINEAR); g_object_unref (pixbuf); pixbuf = copy; } image = gtk_image_new_from_pixbuf (pixbuf); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), image); g_object_unref (pixbuf); } } }
void wxColourDialog::DialogToColourData() { GtkColorSelection* sel = GTK_COLOR_SELECTION( gtk_color_selection_dialog_get_color_selection( GTK_COLOR_SELECTION_DIALOG(m_widget))); #ifdef __WXGTK3__ GdkRGBA clr; gtk_color_selection_get_current_rgba(sel, &clr); #else GdkColor clr; gtk_color_selection_get_current_color(sel, &clr); #endif m_data.SetColour(clr); // Extract custom palette: GtkSettings *settings = gtk_widget_get_settings(GTK_WIDGET(sel)); gchar *pal; g_object_get(settings, "gtk-color-palette", &pal, NULL); GdkColor *colors; gint n_colors; if (gtk_color_selection_palette_from_string(pal, &colors, &n_colors)) { #if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */ # pragma ivdep # pragma swp # pragma unroll # pragma prefetch # if 0 # pragma simd noassert # endif #endif /* VDM auto patch */ for (int i = 0; i < n_colors && i < wxColourData::NUM_CUSTOM; i++) { m_data.SetCustomColour(i, wxColour(colors[i])); } g_free(colors); } g_free(pal); }
static void gtk_application_window_real_realize (GtkWidget *widget) { GtkApplicationWindow *window = GTK_APPLICATION_WINDOW (widget); GtkSettings *settings; settings = gtk_widget_get_settings (widget); g_signal_connect (settings, "notify::gtk-shell-shows-app-menu", G_CALLBACK (gtk_application_window_shell_shows_app_menu_changed), window); g_signal_connect (settings, "notify::gtk-shell-shows-menubar", G_CALLBACK (gtk_application_window_shell_shows_menubar_changed), window); GTK_WIDGET_CLASS (gtk_application_window_parent_class)->realize (widget); gtk_application_window_update_shell_shows_app_menu (window, settings); gtk_application_window_update_shell_shows_menubar (window, settings); gtk_application_window_update_menubar (window); }
static void gsr2_scroll_value_changed_cb (GtkAdjustment *adj, gpointer user_data) { GNCSplitReg2 *gsr = user_data; GncTreeModelSplitReg *model; gchar *text; gint trans_position; model = gnc_ledger_display2_get_split_model_register (gsr->ledger); trans_position = gtk_adjustment_get_value (adj); text = gnc_tree_model_split_reg_get_tooltip (model, trans_position); g_object_set (gtk_widget_get_settings (gsr->scroll_bar), "gtk-tooltip-timeout", 2, NULL); gtk_widget_set_tooltip_text (gsr->scroll_bar, text); g_free (text); }
/* Button up/down is being pressed. Update the time. */ static gboolean hildon_time_picker_key_repeat_timeout (gpointer tpicker) { HildonTimePicker *picker; HildonTimePickerPrivate *priv = NULL; gint newval = 0; gint key_repeat = 0; picker = HILDON_TIME_PICKER(tpicker); g_assert(picker != NULL); priv = HILDON_TIME_PICKER_GET_PRIVATE (tpicker); g_assert (priv); /* Change the time, wrapping if needed */ newval = priv->minutes + priv->mul; if (newval < 0) newval += MINS_IN_24H; hildon_time_picker_change_time (picker, newval); if (priv->start_key_repeat) { /* Get button press repeater timeout from settings (in milliseconds) */ g_object_get (gtk_widget_get_settings ((GtkWidget *) tpicker), "gtk-timeout-repeat", &key_repeat, NULL); key_repeat *= 8; /* This is the first repeat. Shorten the timeout to key_repeat (instead of the first time's 3*key_repeat) */ priv->timer_id = gdk_threads_add_timeout (key_repeat, hildon_time_picker_key_repeat_timeout, picker); priv->start_key_repeat = FALSE; return FALSE; } return TRUE; }
static gboolean gimp_tool_check_click_distance (GimpTool *tool, const GimpCoords *coords, guint32 time, GimpDisplay *display) { GimpDisplayShell *shell; gint double_click_time; gint double_click_distance; if (! tool->in_click_distance) return FALSE; shell = gimp_display_get_shell (display); g_object_get (gtk_widget_get_settings (GTK_WIDGET (shell)), "gtk-double-click-time", &double_click_time, "gtk-double-click-distance", &double_click_distance, NULL); if ((time - tool->button_press_time) > double_click_time) { tool->in_click_distance = FALSE; } else { GimpDisplayShell *shell = gimp_display_get_shell (display); gdouble dx; gdouble dy; dx = SCALEX (shell, tool->button_press_coords.x - coords->x); dy = SCALEY (shell, tool->button_press_coords.y - coords->y); if ((SQR (dx) + SQR (dy)) > SQR (double_click_distance)) { tool->in_click_distance = FALSE; } } return tool->in_click_distance; }
static gboolean gsr2_scroll_button_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { GNCSplitReg2 *gsr = user_data; GncTreeModelSplitReg *model; gint trans_position; model = gnc_ledger_display2_get_split_model_register (gsr->ledger); trans_position = gtk_adjustment_get_value (gsr->scroll_adj); gnc_tree_model_split_reg_set_current_trans_by_position (model, trans_position); //FIXME should we store what it was... g_object_set (gtk_widget_get_settings (gsr->scroll_bar), "gtk-tooltip-timeout", 500, NULL); g_signal_emit_by_name (model, "refresh_trans"); return FALSE; }
static GtkWidget * about_wireshark_page_new(void) { GtkWidget *main_vb, *msg_label /*, *icon*/; gchar *message; main_vb = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 12); #if GTK_CHECK_VERSION(2,9,0) g_object_set(gtk_widget_get_settings(main_vb), "gtk-label-select-on-focus", FALSE, NULL); #endif about_wireshark(top_level, main_vb); /* Construct the message string */ message = g_strdup_printf( "Version " VERSION "%s\n" "\n" "%s" "\n" "%s" "\n" "%s" "\n" "Wireshark is Open Source Software released under the GNU General Public License.\n" "\n" "Check the man page and http://www.wireshark.org for more information.", wireshark_svnversion, get_copyright_info(), comp_info_str->str, runtime_info_str->str); msg_label = gtk_label_new(message); g_free(message); gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL); gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE); gtk_container_add(GTK_CONTAINER(main_vb), msg_label); return main_vb; }
/** * gtk_expander_set_expanded: * @expander: a #GtkExpander * @expanded: whether the child widget is revealed * * Sets the state of the expander. Set to %TRUE, if you want * the child widget to be revealed, and %FALSE if you want the * child widget to be hidden. * * Since: 2.4 **/ void gtk_expander_set_expanded (GtkExpander *expander, gboolean expanded) { GtkExpanderPrivate *priv; g_return_if_fail (GTK_IS_EXPANDER (expander)); priv = expander->priv; expanded = expanded != FALSE; if (priv->expanded != expanded) { GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (expander)); gboolean enable_animations; priv->expanded = expanded; g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL); if (enable_animations && gtk_widget_get_realized (GTK_WIDGET (expander))) { gtk_expander_start_animation (expander); } else { priv->expander_style = expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED; if (GTK_BIN (expander)->child) { gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded); gtk_widget_queue_resize (GTK_WIDGET (expander)); } } g_object_notify (G_OBJECT (expander), "expanded"); } }
static void _gtk_gesture_multi_press_update_timeout (GtkGestureMultiPress *gesture) { GtkGestureMultiPressPrivate *priv; guint double_click_time; GtkSettings *settings; GtkWidget *widget; priv = gtk_gesture_multi_press_get_instance_private (gesture); if (priv->double_click_timeout_id) g_source_remove (priv->double_click_timeout_id); widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)); settings = gtk_widget_get_settings (widget); g_object_get (settings, "gtk-double-click-time", &double_click_time, NULL); priv->double_click_timeout_id = gdk_threads_add_timeout (double_click_time, _double_click_timeout_cb, gesture); }
/** * ephy_notebook_prev_page: * @notebook: an #EphyNotebook * * Advances to the previous page in the @notebook. Note that unlike * gtk_notebook_next_page() this method will wrap around if * #GtkSettings:gtk-keynav-wrap-around is set. **/ void ephy_notebook_prev_page (EphyNotebook *notebook) { gint current_page; g_assert (EPHY_IS_NOTEBOOK (notebook)); current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); if (current_page > 0) gtk_notebook_prev_page (GTK_NOTEBOOK (notebook)); else { gboolean wrap_around; g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)), "gtk-keynav-wrap-around", &wrap_around, NULL); if (wrap_around) gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), -1); } }
static GtkRevealerTransitionType effective_transition (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gboolean animations_enabled; g_object_get (gtk_widget_get_settings (GTK_WIDGET (revealer)), "gtk-enable-animations", &animations_enabled, NULL); if (!animations_enabled) return GTK_REVEALER_TRANSITION_TYPE_NONE; if (gtk_widget_get_direction (GTK_WIDGET (revealer)) == GTK_TEXT_DIR_RTL) { if (priv->transition_type == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT) return GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT; else if (priv->transition_type == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) return GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT; } return priv->transition_type; }
static void ephy_title_box_switch_to_entry_after_double_click_time (EphyTitleBox *title_box) { gint double_click_time; if (title_box->switch_to_entry_timeout_id > 0) return; LOG ("switch_to_entry_after_double_click_time title-box %p switch_to_entry_timeout_id %u", title_box, title_box->switch_to_entry_timeout_id); g_object_get (gtk_widget_get_settings (GTK_WIDGET (title_box)), "gtk-double-click-time", &double_click_time, NULL); /* We don't want to wait the maximum time allowed between two * clicks before showing the entry. A quarter of this time is enough. */ title_box->switch_to_entry_timeout_id = g_timeout_add (double_click_time / 4, ephy_title_box_switch_to_entry_timeout_cb, title_box); }
void nautilus_notebook_prev_page (NautilusNotebook *notebook) { gint current_page; g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook)); current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); if (current_page > 0) gtk_notebook_prev_page (GTK_NOTEBOOK (notebook)); else { gboolean wrap_around; g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)), "gtk-keynav-wrap-around", &wrap_around, NULL); if (wrap_around) gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), -1); } }
/* * We need to override this because when we don't show the tabs, like in * fullscreen we need to have wrap around too */ static gboolean gedit_notebook_change_current_page (GtkNotebook *notebook, gint offset) { gboolean wrap_around; gint current; current = gtk_notebook_get_current_page (notebook); if (current != -1) { current = current + offset; g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)), "gtk-keynav-wrap-around", &wrap_around, NULL); if (wrap_around) { if (current < 0) { current = gtk_notebook_get_n_pages (notebook) - 1; } else if (current >= gtk_notebook_get_n_pages (notebook)) { current = 0; } } gtk_notebook_set_current_page (notebook, current); } else { gtk_widget_error_bell (GTK_WIDGET (notebook)); } return TRUE; }
static GtkWidget* inputMethodsMenuItem (WebKitWebView* webView) { if (gtk_major_version > 2 || (gtk_major_version == 2 && gtk_minor_version >= 10)) { GtkSettings* settings = webView ? gtk_widget_get_settings(GTK_WIDGET(webView)) : gtk_settings_get_default(); gboolean showMenu = TRUE; if (settings) g_object_get(settings, "gtk-show-input-method-menu", &showMenu, NULL); if (!showMenu) return 0; } GtkWidget* menuitem = gtk_image_menu_item_new_with_mnemonic( _("Input _Methods")); WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(webView); GtkWidget* imContextMenu = gtk_menu_new(); gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(priv->imContext), GTK_MENU_SHELL(imContextMenu)); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), imContextMenu); return menuitem; }
static gboolean gtk_expander_drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time) { GtkExpander *expander = GTK_EXPANDER (widget); GtkExpanderPrivate *priv = expander->priv; if (!priv->expanded && !priv->expand_timer) { GtkSettings *settings; guint timeout; settings = gtk_widget_get_settings (widget); g_object_get (settings, "gtk-timeout-expand", &timeout, NULL); priv->expand_timer = gdk_threads_add_timeout (timeout, (GSourceFunc) expand_timeout, expander); } return TRUE; }
static gboolean gimp_tag_popup_scroll_timeout_initial (gpointer data) { GimpTagPopup *popup = data; guint timeout; gboolean touchscreen_mode; g_object_get (gtk_widget_get_settings (GTK_WIDGET (popup)), "gtk-timeout-repeat", &timeout, "gtk-touchscreen-mode", &touchscreen_mode, NULL); gimp_tag_popup_scroll_by (popup, popup->scroll_step); gimp_tag_popup_remove_scroll_timeout (popup); popup->scroll_timeout_id = gdk_threads_add_timeout (timeout, gimp_tag_popup_scroll_timeout, popup); return FALSE; }
static void editing_started_cb (GtkCellRenderer *renderer, GtkCellEditable *editable, gchar *path, struct editing_data *data) { gchar *name; gint len; gint dot; gchar *s; g_signal_handler_disconnect (renderer, data->editing_started_sid); data->editing_started_sid = 0; data->editing_done_sid = g_signal_connect (editable, "editing-done", (GCallback) editing_done_cb, data); data->key_press_event_sid = g_signal_connect (editable, "key-press-event", (GCallback) _key_press_ctrl_a_cb, NULL); /* do not select the whole name */ g_object_set (gtk_widget_get_settings ((GtkWidget *) editable), "gtk-entry-select-on-focus", FALSE, NULL); /* locate the dot before the extension */ name = donna_node_get_name (data->node); dot = -1; for (len = 1, s = g_utf8_next_char (name); *s != '\0'; ++len, s = g_utf8_next_char (s)) { if (*s == '.') dot = len; } g_free (name); /* select only up to the .ext, or all if no .ext found */ gtk_editable_select_region ((GtkEditable *) editable, 0, dot); }
static void gtk_image_menu_item_screen_changed (GtkWidget *widget, GdkScreen *previous_screen) { GtkSettings *settings; gulong show_image_connection; if (!gtk_widget_has_screen (widget)) return; settings = gtk_widget_get_settings (widget); show_image_connection = g_signal_handler_find (settings, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, gtk_image_menu_item_setting_changed, NULL); if (show_image_connection) return; g_signal_connect (settings, "notify::gtk-menu-images", G_CALLBACK (gtk_image_menu_item_setting_changed), NULL); show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget)); }
static GtkWidget * gimp_container_box_get_preview (GimpDocked *docked, GimpContext *context, GtkIconSize size) { GimpContainerBox *box = GIMP_CONTAINER_BOX (docked); GimpContainerView *view = GIMP_CONTAINER_VIEW (docked); GimpContainer *container; GtkWidget *preview; gint width; gint height; gint border_width = 1; const gchar *prop_name; container = gimp_container_view_get_container (view); g_return_val_if_fail (container != NULL, NULL); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (box)), size, &width, &height); prop_name = gimp_context_type_to_prop_name (container->children_type); preview = gimp_prop_view_new (G_OBJECT (context), prop_name, context, height); GIMP_VIEW (preview)->renderer->size = -1; gimp_container_view_get_view_size (view, &border_width); border_width = MIN (1, border_width); gimp_view_renderer_set_size_full (GIMP_VIEW (preview)->renderer, width, height, border_width); return preview; }
static gboolean gimp_tag_popup_button_scroll (GimpTagPopup *popup, GdkEventButton *event) { if (popup->upper_arrow_prelight || popup->lower_arrow_prelight) { gboolean touchscreen_mode; g_object_get (gtk_widget_get_settings (GTK_WIDGET (popup)), "gtk-touchscreen-mode", &touchscreen_mode, NULL); if (touchscreen_mode) gimp_tag_popup_handle_scrolling (popup, event->x_root, event->y_root, event->type == GDK_BUTTON_PRESS, FALSE); return TRUE; } return FALSE; }
static Tcolsel *colsel_dialog(Tbfwin *bfwin,const gchar *setcolor, gint modal, gint startpos, gint endpos) { Tcolsel *csd; GtkWidget *vbox, *hbox, *but; GdkColor gcolor; const gchar *this_color=setcolor; csd = g_new0(Tcolsel, 1); /* warning: bfwin might be NULL if this dialog is started by return_color() */ csd->bfwin = bfwin; csd->is_modal = modal; csd->startpos = startpos; csd->endpos = endpos; csd->returnval = setcolor ? g_strdup(setcolor) : g_strdup(""); DEBUG_MSG("colsel_dialog, malloced at %p, setcolor=%s\n", csd, setcolor); csd->win = window_full2(_("Bluefish: Select color"), GTK_WIN_POS_CENTER, 12, G_CALLBACK(colsel_destroy_lcb), csd, TRUE, bfwin?bfwin->main_window:NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(csd->win), vbox); csd->csel = gtk_color_selection_new(); gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(csd->csel), FALSE); if (this_color) { if (gdk_color_parse(this_color, &gcolor)) { gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(csd->csel), &gcolor); } else { this_color=NULL; } } gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(csd->csel), TRUE); gtk_box_pack_start(GTK_BOX(vbox), csd->csel, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 12); #if GTK_CHECK_VERSION(3,0,0) hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbox = gtk_hbutton_box_new(); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), 12); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); but = bf_stock_cancel_button(G_CALLBACK(colsel_cancel_clicked_lcb), csd); gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0); but = bf_stock_ok_button(G_CALLBACK(colsel_ok_clicked_lcb), csd); gtk_window_set_default(GTK_WINDOW(csd->win), but); gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0); if (bfwin && bfwin->session->colorlist) { GtkSettings* gtksettings; /* Note that this function can only be called when the GtkWidget is attached to a toplevel, since the settings object is specific to a particular GdkScreen. */ gtksettings = gtk_widget_get_settings(GTK_WIDGET(csd->csel)); if (gtksettings) { gchar *strings; DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist)); bfwin->session->colorlist = limit_stringlist(bfwin->session->colorlist, 20, TRUE); DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist)); strings = stringlist_to_string(bfwin->session->colorlist, ":"); strings[strlen(strings)-1] = '\0'; /* this property may contain max 20 colors, otherwise gtk will crash */ g_object_set(G_OBJECT(gtksettings), "gtk-color-palette", strings, NULL); g_free(strings); } /* DEBUG_MSG("colsel_dialog, setting palette from %s\n", strings); if (gtk_color_selection_palette_from_string(strings, &gcolorarr, &num)) { DEBUG_MSG("num=%d, gcolorarr=%p\n",num,gcolorarr); } else { DEBUG_MSG("hmm, failed to parse our string :(\n"); } */ } gtk_widget_show_all(csd->win); DEBUG_MSG("colsel_dialog, finished\n"); return csd; }
MidoriBrowser* midori_private_app_new (const gchar* config, const gchar* webapp, gchar** open_uris, gchar** execute_commands, gint inactivity_reset, const gchar* block_uris) { guint i; midori_paths_init (MIDORI_RUNTIME_MODE_PRIVATE, config); #ifndef HAVE_WEBKIT2 g_object_set_data (G_OBJECT (webkit_get_default_session ()), "pass-through-console", (void*)1); #endif /* Mask the timezone, which can be read by Javascript */ g_setenv ("TZ", "UTC", TRUE); MidoriBrowser* browser = midori_browser_new (); g_signal_connect (browser, "new-window", G_CALLBACK (midori_frontend_browser_new_window_cb), NULL); MidoriWebSettings* settings = midori_settings_new_full (NULL); g_object_set (settings, "preferred-languages", "en", "enable-private-browsing", TRUE, #ifdef HAVE_LIBSOUP_2_29_91 "first-party-cookies-only", TRUE, #endif "enable-html5-database", FALSE, "enable-html5-local-storage", FALSE, "enable-offline-web-application-cache", FALSE, /* Arguably DNS prefetching is or isn't a privacy concern. For the * lack of more fine-grained control we'll go the safe route. */ "enable-dns-prefetching", FALSE, "strip-referer", TRUE, "show-panel", FALSE, "last-window-state", MIDORI_WINDOW_NORMAL, "inactivity-reset", inactivity_reset, "block-uris", block_uris, NULL); midori_load_soup_session (settings); /* In-memory trash for re-opening closed tabs */ KatzeArray* trash = katze_array_new (KATZE_TYPE_ITEM); g_signal_connect_after (trash, "add-item", G_CALLBACK (midori_trash_add_item_no_save_cb), NULL); KatzeArray* search_engines = midori_search_engines_new_from_folder (NULL); g_object_set (browser, "settings", settings, "trash", trash, "search-engines", search_engines, NULL); g_object_unref (settings); g_object_unref (trash); g_object_unref (search_engines); midori_browser_set_action_visible (browser, "Tools", FALSE); midori_browser_set_action_visible (browser, "ClearPrivateData", FALSE); #if ENABLE_ADDSPEEDDIAL midori_browser_set_action_visible (browser, "AddSpeedDial", FALSE); #endif #if GTK_CHECK_VERSION (3, 0, 0) g_object_set (gtk_widget_get_settings (GTK_WIDGET (browser)), "gtk-application-prefer-dark-theme", TRUE, NULL); #endif if (webapp != NULL) { gchar* tmp_uri = sokoke_magic_uri (webapp, FALSE, TRUE); g_object_set (settings, "homepage", tmp_uri, NULL); midori_browser_add_uri (browser, tmp_uri); g_free (tmp_uri); } for (i = 0; open_uris && open_uris[i]; i++) { gchar* new_uri = sokoke_magic_uri (open_uris[i], FALSE, TRUE); midori_browser_add_uri (browser, new_uri); g_free (new_uri); } if (midori_browser_get_n_pages (browser) == 0) midori_browser_add_uri (browser, "about:private"); gtk_widget_show (GTK_WIDGET (browser)); for (i = 0; execute_commands && execute_commands[i]; i++) { midori_browser_assert_action (browser, execute_commands[i]); midori_browser_activate_action (browser, execute_commands[i]); } /* FIXME need proper stock extension mechanism */ //由于整合了若干预置扩展,此处相应修改 #if 0 midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libabout." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libopen-with." G_MODULE_SUFFIX "=true"); #else midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true"); midori_browser_activate_action (browser, "libbuiltinextension." G_MODULE_SUFFIX "=true"); #endif g_assert (g_module_error () == NULL); return browser; }
/* part stolen from pidgin/gtkconv.c */ static GtkWidget * capture_rename (PurplePlugin * plugin, const gchar * entry_init) { GdkColor red = { 0, 65535, 0, 0 }; GtkWidget *dlgbox_rename; GtkWidget *hbox; GtkWidget *label; GtkWidget *entry; GtkWidget *warn_label; GtkWidget *gtkconv_window; GtkWidget *blist_window; GtkWidget *img; GtkWidget *content_area; img = gtk_image_new_from_stock (PIDGIN_STOCK_DIALOG_QUESTION, gtk_icon_size_from_name (PIDGIN_ICON_SIZE_TANGO_HUGE)); gtkconv_window = get_receiver_window (plugin); blist_window = pidgin_blist_get_default_gtk_blist ()->window; dlgbox_rename = gtk_dialog_new_with_buttons (DLGBOX_CAPNAME_TITLE, GTK_WINDOW ((gtkconv_window) ? gtkconv_window : blist_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); #if GTK_CHECK_VERSION(2,14,0) content_area = gtk_dialog_get_content_area (GTK_DIALOG (dlgbox_rename)); #else content_area = GTK_DIALOG (dlgbox_rename)->vbox; #endif gtk_dialog_set_default_response (GTK_DIALOG (dlgbox_rename), GTK_RESPONSE_OK); gtk_container_set_border_width (GTK_CONTAINER (dlgbox_rename), PIDGIN_HIG_BOX_SPACE); gtk_window_set_resizable (GTK_WINDOW (dlgbox_rename), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dlgbox_rename), FALSE); gtk_box_set_spacing (GTK_BOX (content_area), PIDGIN_HIG_BORDER); gtk_container_set_border_width (GTK_CONTAINER (content_area), PIDGIN_HIG_BOX_SPACE); hbox = gtk_hbox_new (FALSE, PIDGIN_HIG_BORDER); gtk_container_add (GTK_CONTAINER (content_area), hbox); gtk_box_pack_start (GTK_BOX (hbox), img, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (img), 0, 0); label = gtk_label_new (DLGBOX_CAPNAME_LABEL); warn_label = gtk_label_new (NULL); gtk_widget_modify_fg (warn_label, GTK_STATE_NORMAL, &red); gtk_label_set_text (GTK_LABEL (warn_label), DLGBOX_CAPNAME_WARNEXISTS); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (content_area), warn_label, FALSE, FALSE, 0); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), entry_init); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); g_object_set (gtk_widget_get_settings (entry), "gtk-entry-select-on-focus", FALSE, NULL); g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (set_sensitive_if_input_and_noexist), dlgbox_rename /* plugin */ ); g_signal_connect (G_OBJECT (entry), "focus-out-event", G_CALLBACK (entry_select_filename_in_focus_cb), plugin); g_signal_connect (G_OBJECT (entry), "focus-in-event", G_CALLBACK (entry_select_filename_in_focus_cb), plugin); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (entry); gtk_widget_show (img); gtk_widget_show (hbox); gtk_widget_show (content_area); g_object_set_data (G_OBJECT (dlgbox_rename), "entry", entry); g_object_set_data (G_OBJECT (dlgbox_rename), "warn-label", warn_label); return dlgbox_rename; }
static GtkWidget * display_simple_dialog(gint type, gint btn_mask, char *message) { GtkWidget *win, *main_vb, *top_hb, *msg_vb, *type_pm, *msg_label, *ask_cb, *bbox, *ok_bt, *yes_bt, *bt, *save_bt, *dont_save_bt; GdkPixmap *pixmap; GdkBitmap *mask; GtkStyle *style; GdkColormap *cmap; const gchar **icon; /* Main window */ switch (type) { case ESD_TYPE_WARN : icon = stock_dialog_warning_48_xpm; break; case ESD_TYPE_CONFIRMATION: icon = stock_dialog_warning_48_xpm; break; case ESD_TYPE_ERROR: icon = stock_dialog_error_48_xpm; break; case ESD_TYPE_STOP : icon = stock_dialog_stop_48_xpm; break; case ESD_TYPE_INFO : default : icon = stock_dialog_info_48_xpm; break; } /* * The GNOME HIG: * * http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows * * says that the title should be empty for alert boxes, so there's "less * visual noise and confounding text." * * The Windows HIG: * * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwue/html/ch09f.asp * * says it should * * ...appropriately identify the source of the message -- usually * the name of the object. For example, if the message results * from editing a document, the title text is the name of the * document, optionally followed by the application name. If the * message results from a non-document object, then use the * application name." * * and notes that the title is important "because message boxes might * not always the the result of current user interaction" (e.g., some * app might randomly pop something up, e.g. some browser letting you * know that it couldn't fetch something because of a timeout). * * It also says not to use "warning" or "caution", as there's already * an icon that tells you what type of alert it is, and that you * shouldn't say "error", as that provides no useful information. * * So we give it a title on Win32, and don't give it one on UN*X. * For now, we give it a Win32 title of just "Wireshark"; we should * arguably take an argument for the title. */ if(btn_mask == ESD_BTN_NONE) { win = splash_window_new(); } else { #ifdef _WIN32 win = dlg_window_new("Wireshark"); #else win = dlg_window_new(""); #endif } gtk_window_set_modal(GTK_WINDOW(win), TRUE); gtk_container_set_border_width(GTK_CONTAINER(win), 6); /* Container for our rows */ main_vb = gtk_vbox_new(FALSE, 12); gtk_container_add(GTK_CONTAINER(win), main_vb); gtk_widget_show(main_vb); /* Top row: Icon and message text */ top_hb = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6); gtk_container_add(GTK_CONTAINER(main_vb), top_hb); gtk_widget_show(top_hb); /* icon */ style = gtk_widget_get_style(win); cmap = gdk_colormap_get_system(); pixmap = gdk_pixmap_colormap_create_from_xpm_d(NULL, cmap, &mask, &style->bg[GTK_STATE_NORMAL], (gchar **) icon); type_pm = gtk_image_new_from_pixmap(pixmap, mask); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_container_add(GTK_CONTAINER(top_hb), type_pm); gtk_widget_show(type_pm); /* column for message and optional check button */ msg_vb = gtk_vbox_new(FALSE, 6); gtk_box_set_spacing(GTK_BOX(msg_vb), 24); gtk_container_add(GTK_CONTAINER(top_hb), msg_vb); gtk_widget_show(msg_vb); /* message */ msg_label = gtk_label_new(message); gtk_label_set_markup(GTK_LABEL(msg_label), message); gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE); #if GTK_CHECK_VERSION(2,9,0) g_object_set(gtk_widget_get_settings(msg_label), "gtk-label-select-on-focus", FALSE, NULL); #endif gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_container_add(GTK_CONTAINER(msg_vb), msg_label); gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE); gtk_widget_show(msg_label); if(btn_mask == ESD_BTN_NONE) { gtk_widget_show(win); return win; } /* optional check button */ ask_cb = gtk_check_button_new_with_label("replace with text..."); gtk_container_add(GTK_CONTAINER(msg_vb), ask_cb); g_object_set_data(G_OBJECT(win), CHECK_BUTTON, ask_cb); /* Button row */ switch(btn_mask) { case(ESD_BTN_OK): bbox = dlg_button_row_new(GTK_STOCK_OK, NULL); break; case(ESD_BTN_OK | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTN_CLEAR | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_CLEAR, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, NULL); break; default: g_assert_not_reached(); bbox = NULL; break; } gtk_container_add(GTK_CONTAINER(main_vb), bbox); gtk_widget_show(bbox); ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); if(ok_bt) { g_object_set_data(G_OBJECT(ok_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_OK)); g_signal_connect(ok_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } save_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE); if (save_bt) { g_object_set_data(G_OBJECT(save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_SAVE)); g_signal_connect(save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_QUIT_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_QUIT_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLEAR); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CLEAR)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } yes_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_YES); if(yes_bt) { g_object_set_data(G_OBJECT(yes_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_YES)); g_signal_connect(yes_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_NO); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_NO)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CANCEL)); window_set_cancel_button(win, bt, simple_dialog_cancel_cb); } if(!bt) { if(yes_bt) { window_set_cancel_button(win, yes_bt, simple_dialog_cancel_cb); } else { window_set_cancel_button(win, ok_bt, simple_dialog_cancel_cb); } } dlg_button_focus_nth(bbox, 0); gtk_widget_show(win); return win; }
static gboolean gossip_cell_renderer_expander_activate (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path_string, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { GossipCellRendererExpander *expander; GossipCellRendererExpanderPriv *priv; GtkTreePath *path; GtkSettings *settings; gboolean animate = FALSE; gboolean expanding; gboolean in_cell; int mouse_x; int mouse_y; expander = GOSSIP_CELL_RENDERER_EXPANDER (cell); priv = GET_PRIV (cell); if (!GTK_IS_TREE_VIEW (widget) || !priv->activatable) return FALSE; path = gtk_tree_path_new_from_string (path_string); gtk_widget_get_pointer (widget, &mouse_x, &mouse_y); gtk_tree_view_convert_widget_to_bin_window_coords (GTK_TREE_VIEW (widget), mouse_x, mouse_y, &mouse_x, &mouse_y); /* check if click is within the cell */ if (mouse_x - cell_area->x >= 0 && mouse_x - cell_area->x <= cell_area->width) { in_cell = TRUE; } else { in_cell = FALSE; } if (! in_cell) { return FALSE; } #if 0 if (gtk_tree_path_get_depth (path) > 1) { gtk_tree_path_free (path); return TRUE; } #endif settings = gtk_widget_get_settings (GTK_WIDGET (widget)); if (g_object_class_find_property (G_OBJECT_GET_CLASS (settings), "gtk-enable-animations")) { g_object_get (settings, "gtk-enable-animations", &animate, NULL); } if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) { gtk_tree_view_collapse_row (GTK_TREE_VIEW (widget), path); expanding = FALSE; } else { gtk_tree_view_expand_row (GTK_TREE_VIEW (widget), path, FALSE); expanding = TRUE; } if (animate) { gossip_cell_renderer_expander_start_animation (expander, GTK_TREE_VIEW (widget), path, expanding, background_area); } gtk_tree_path_free (path); return TRUE; }
static void gimp_tag_popup_handle_scrolling (GimpTagPopup *popup, gint x, gint y, gboolean enter, gboolean motion) { GdkRectangle rect; gboolean in_arrow; gboolean scroll_fast = FALSE; gboolean touchscreen_mode; g_object_get (gtk_widget_get_settings (GTK_WIDGET (popup)), "gtk-touchscreen-mode", &touchscreen_mode, NULL); /* upper arrow handling */ get_arrows_sensitive_area (popup, &rect, NULL); in_arrow = FALSE; if (popup->arrows_visible && x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height) { in_arrow = TRUE; } if (touchscreen_mode) popup->upper_arrow_prelight = in_arrow; if (popup->upper_arrow_state != GTK_STATE_INSENSITIVE) { gboolean arrow_pressed = FALSE; if (popup->arrows_visible) { if (touchscreen_mode) { if (enter && popup->upper_arrow_prelight) { if (popup->scroll_timeout_id == 0) { gimp_tag_popup_remove_scroll_timeout (popup); popup->scroll_step = -MENU_SCROLL_STEP2; /* always fast */ if (! motion) { /* Only do stuff on click. */ gimp_tag_popup_start_scrolling (popup); arrow_pressed = TRUE; } } else { arrow_pressed = TRUE; } } else if (! enter) { gimp_tag_popup_stop_scrolling (popup); } } else /* !touchscreen_mode */ { scroll_fast = (y < rect.y + MENU_SCROLL_FAST_ZONE); if (enter && in_arrow && (! popup->upper_arrow_prelight || popup->scroll_fast != scroll_fast)) { popup->upper_arrow_prelight = TRUE; popup->scroll_fast = scroll_fast; gimp_tag_popup_remove_scroll_timeout (popup); popup->scroll_step = (scroll_fast ? -MENU_SCROLL_STEP2 : -MENU_SCROLL_STEP1); popup->scroll_timeout_id = gdk_threads_add_timeout (scroll_fast ? MENU_SCROLL_TIMEOUT2 : MENU_SCROLL_TIMEOUT1, gimp_tag_popup_scroll_timeout, popup); } else if (! enter && ! in_arrow && popup->upper_arrow_prelight) { gimp_tag_popup_stop_scrolling (popup); } } } /* gimp_tag_popup_start_scrolling() might have hit the top of the * tag_popup, so check if the button isn't insensitive before * changing it to something else. */ if (popup->upper_arrow_state != GTK_STATE_INSENSITIVE) { GtkStateType arrow_state = GTK_STATE_NORMAL; if (arrow_pressed) arrow_state = GTK_STATE_ACTIVE; else if (popup->upper_arrow_prelight) arrow_state = GTK_STATE_PRELIGHT; if (arrow_state != popup->upper_arrow_state) { popup->upper_arrow_state = arrow_state; gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (popup)), &rect, FALSE); } } } /* lower arrow handling */ get_arrows_sensitive_area (popup, NULL, &rect); in_arrow = FALSE; if (popup->arrows_visible && x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height) { in_arrow = TRUE; } if (touchscreen_mode) popup->lower_arrow_prelight = in_arrow; if (popup->lower_arrow_state != GTK_STATE_INSENSITIVE) { gboolean arrow_pressed = FALSE; if (popup->arrows_visible) { if (touchscreen_mode) { if (enter && popup->lower_arrow_prelight) { if (popup->scroll_timeout_id == 0) { gimp_tag_popup_remove_scroll_timeout (popup); popup->scroll_step = MENU_SCROLL_STEP2; /* always fast */ if (! motion) { /* Only do stuff on click. */ gimp_tag_popup_start_scrolling (popup); arrow_pressed = TRUE; } } else { arrow_pressed = TRUE; } } else if (! enter) { gimp_tag_popup_stop_scrolling (popup); } } else /* !touchscreen_mode */ { scroll_fast = (y > rect.y + rect.height - MENU_SCROLL_FAST_ZONE); if (enter && in_arrow && (! popup->lower_arrow_prelight || popup->scroll_fast != scroll_fast)) { popup->lower_arrow_prelight = TRUE; popup->scroll_fast = scroll_fast; gimp_tag_popup_remove_scroll_timeout (popup); popup->scroll_step = (scroll_fast ? MENU_SCROLL_STEP2 : MENU_SCROLL_STEP1); popup->scroll_timeout_id = gdk_threads_add_timeout (scroll_fast ? MENU_SCROLL_TIMEOUT2 : MENU_SCROLL_TIMEOUT1, gimp_tag_popup_scroll_timeout, popup); } else if (! enter && ! in_arrow && popup->lower_arrow_prelight) { gimp_tag_popup_stop_scrolling (popup); } } } /* gimp_tag_popup_start_scrolling() might have hit the bottom of the * popup, so check if the button isn't insensitive before * changing it to something else. */ if (popup->lower_arrow_state != GTK_STATE_INSENSITIVE) { GtkStateType arrow_state = GTK_STATE_NORMAL; if (arrow_pressed) arrow_state = GTK_STATE_ACTIVE; else if (popup->lower_arrow_prelight) arrow_state = GTK_STATE_PRELIGHT; if (arrow_state != popup->lower_arrow_state) { popup->lower_arrow_state = arrow_state; gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (popup)), &rect, FALSE); } } } }
static void gimp_controller_list_init (GimpControllerList *list) { GtkWidget *hbox; GtkWidget *sw; GtkWidget *tv; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *vbox; GtkWidget *image; GtkIconSize icon_size; gint icon_width; gint icon_height; GType *controller_types; guint n_controller_types; gint i; gtk_orientable_set_orientation (GTK_ORIENTABLE (list), GTK_ORIENTATION_VERTICAL); list->gimp = NULL; list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); gtk_widget_show (sw); list->src = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_GTYPE); tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src)); g_object_unref (list->src); gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Available Controllers")); gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "icon-name", COLUMN_ICON, NULL); g_object_get (cell, "stock-size", &icon_size, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show (tv); g_signal_connect_object (tv, "row-activated", G_CALLBACK (gimp_controller_list_row_activated), G_OBJECT (list), 0); list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv)); gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE); g_signal_connect_object (list->src_sel, "changed", G_CALLBACK (gimp_controller_list_src_sel_changed), G_OBJECT (list), 0); controller_types = g_type_children (GIMP_TYPE_CONTROLLER, &n_controller_types); for (i = 0; i < n_controller_types; i++) { GimpControllerClass *controller_class; GtkTreeIter iter; controller_class = g_type_class_ref (controller_types[i]); gtk_list_store_append (list->src, &iter); gtk_list_store_set (list->src, &iter, COLUMN_ICON, controller_class->icon_name, COLUMN_NAME, controller_class->name, COLUMN_TYPE, controller_types[i], -1); g_type_class_unref (controller_class); } g_free (controller_types); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); list->add_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->add_button, FALSE); gtk_widget_show (list->add_button); image = gtk_image_new_from_icon_name ("go-next", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->add_button), image); gtk_widget_show (image); g_signal_connect (list->add_button, "clicked", G_CALLBACK (gimp_controller_list_add_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->add_button), (gpointer) &list->add_button); list->remove_button = gtk_button_new (); gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0); gtk_widget_set_sensitive (list->remove_button, FALSE); gtk_widget_show (list->remove_button); image = gtk_image_new_from_icon_name ("go-previous", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (list->remove_button), image); gtk_widget_show (image); g_signal_connect (list->remove_button, "clicked", G_CALLBACK (gimp_controller_list_remove_clicked), list); g_object_add_weak_pointer (G_OBJECT (list->remove_button), (gpointer) &list->remove_button); gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)), icon_size, &icon_width, &icon_height); list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0); gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest), _("Active Controllers")); gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view, TRUE); gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0); gtk_widget_show (list->dest); g_signal_connect_object (list->dest, "select-item", G_CALLBACK (gimp_controller_list_select_item), G_OBJECT (list), 0); g_signal_connect_object (list->dest, "activate-item", G_CALLBACK (gimp_controller_list_activate_item), G_OBJECT (list), 0); list->edit_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "document-properties", _("Configure the selected controller"), NULL, G_CALLBACK (gimp_controller_list_edit_clicked), NULL, list); list->up_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-up", _("Move the selected controller up"), NULL, G_CALLBACK (gimp_controller_list_up_clicked), NULL, list); list->down_button = gimp_editor_add_button (GIMP_EDITOR (list->dest), "go-down", _("Move the selected controller down"), NULL, G_CALLBACK (gimp_controller_list_down_clicked), NULL, list); gtk_widget_set_sensitive (list->edit_button, FALSE); gtk_widget_set_sensitive (list->up_button, FALSE); gtk_widget_set_sensitive (list->down_button, FALSE); }
static int gtkButtonMapMethod(Ihandle* ih) { int impress; char* value; value = iupAttribGet(ih, "IMAGE"); if (value) { ih->data->type = IUP_BUTTON_IMAGE; value = iupAttribGet(ih, "TITLE"); if (value && *value!=0) ih->data->type |= IUP_BUTTON_TEXT; } else ih->data->type = IUP_BUTTON_TEXT; if (ih->data->type == IUP_BUTTON_IMAGE && iupAttribGet(ih, "IMPRESS") && !iupAttribGetBoolean(ih, "IMPRESSBORDER")) { GtkWidget *img = gtk_image_new(); ih->handle = gtk_event_box_new(); gtk_container_add((GtkContainer*)ih->handle, img); gtk_widget_show(img); iupAttribSetStr(ih, "_IUPGTK_EVENTBOX", "1"); } else ih->handle = gtk_button_new(); if (!ih->handle) return IUP_ERROR; if (ih->data->type & IUP_BUTTON_IMAGE) { if (!iupAttribGet(ih, "_IUPGTK_EVENTBOX")) { gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new()); if (ih->data->type & IUP_BUTTON_TEXT) { GtkSettings* settings = gtk_widget_get_settings(ih->handle); g_object_set(settings, "gtk-button-images", (int)TRUE, NULL); gtk_button_set_label((GtkButton*)ih->handle, iupgtkStrConvertToUTF8(iupAttribGet(ih, "TITLE"))); #if GTK_CHECK_VERSION(2, 10, 0) gtk_button_set_image_position((GtkButton*)ih->handle, ih->data->img_position); /* IUP and GTK have the same Ids */ #endif } } } else { char* title = iupAttribGet(ih, "TITLE"); if (!title) { if (iupAttribGet(ih, "BGCOLOR")) { int x=0, y=0; GtkWidget* frame = gtk_frame_new(NULL); #if GTK_CHECK_VERSION(2, 18, 0) GtkWidget* drawarea = gtk_drawing_area_new(); gtk_widget_set_has_window(drawarea, TRUE); #else GtkWidget* drawarea = gtk_fixed_new(); gtk_fixed_set_has_window(GTK_FIXED(drawarea), TRUE); #endif gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); iupdrvButtonAddBorders(&x, &y); gtk_widget_set_size_request (frame, ih->currentwidth-x, ih->currentheight-y); gtk_container_add(GTK_CONTAINER(frame), drawarea); gtk_widget_show(drawarea); gtk_button_set_image((GtkButton*)ih->handle, frame); } else gtk_button_set_label((GtkButton*)ih->handle, ""); } else gtk_button_set_label((GtkButton*)ih->handle, iupgtkStrConvertToUTF8(title)); } /* add to the parent, all GTK controls must call this. */ iupgtkAddToParent(ih); if (!iupAttribGetBoolean(ih, "CANFOCUS")) iupgtkSetCanFocus(ih->handle, 0); value = iupAttribGet(ih, "IMPRESS"); impress = (ih->data->type & IUP_BUTTON_IMAGE && value)? 1: 0; if (!impress && iupAttribGetBoolean(ih, "FLAT")) { gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkButtonEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkButtonEnterLeaveEvent), ih); } else { if (!iupAttribGet(ih, "_IUPGTK_EVENTBOX")) { if (impress && !iupAttribGetStr(ih, "IMPRESSBORDER")) gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE); else gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NORMAL); } g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); } g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); if (!iupAttribGet(ih, "_IUPGTK_EVENTBOX")) g_signal_connect(G_OBJECT(ih->handle), "clicked", G_CALLBACK(gtkButtonClicked), ih); g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkButtonEvent), ih); gtk_widget_realize(ih->handle); /* update a mnemonic in a label if necessary */ iupgtkUpdateMnemonic(ih); return IUP_NOERROR; }