static void ink_toggle_action_update_icon( InkToggleAction* action ) { if ( action ) { GSList* proxies = gtk_action_get_proxies( GTK_ACTION(action) ); while ( proxies ) { if ( GTK_IS_TOOL_ITEM(proxies->data) ) { if ( GTK_IS_TOOL_BUTTON(proxies->data) ) { GtkToolButton* button = GTK_TOOL_BUTTON(proxies->data); GtkWidget* child = sp_icon_new( action->private_data->iconSize, action->private_data->iconId ); #if GTK_CHECK_VERSION(3,0,0) gtk_widget_set_hexpand(child, FALSE); gtk_widget_set_vexpand(child, FALSE); gtk_widget_show_all(child); gtk_tool_button_set_icon_widget(button, child); #else GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 ); gtk_container_add( GTK_CONTAINER(align), child ); gtk_widget_show_all( align ); gtk_tool_button_set_icon_widget( button, align ); #endif } } proxies = g_slist_next( proxies ); } } }
static GtkWidget* ink_radio_action_create_tool_item( GtkAction* action ) { InkRadioAction* act = INK_RADIO_ACTION( action ); GtkWidget* item = GTK_RADIO_ACTION_CLASS(ink_radio_action_parent_class)->parent_class.parent_class.create_tool_item(action); if ( act->private_data->iconId ) { if ( GTK_IS_TOOL_BUTTON(item) ) { GtkToolButton* button = GTK_TOOL_BUTTON(item); GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId ); #if GTK_CHECK_VERSION(3,0,0) gtk_widget_set_hexpand(child, FALSE); gtk_widget_set_vexpand(child, FALSE); gtk_tool_button_set_icon_widget(button, child); #else GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 ); gtk_container_add( GTK_CONTAINER(align), child ); gtk_tool_button_set_icon_widget( button, align ); #endif } else { // For now trigger a warning but don't do anything else GtkToolButton* button = GTK_TOOL_BUTTON(item); (void)button; } } // TODO investigate if needed gtk_widget_show_all( item ); return item; }
static GtkWidget* ink_toggle_action_create_tool_item( GtkAction* action ) { InkToggleAction* act = INK_TOGGLE_ACTION( action ); GtkWidget* item = GTK_TOGGLE_ACTION_CLASS(ink_toggle_action_parent_class)->parent_class.create_tool_item(action); if ( GTK_IS_TOOL_BUTTON(item) ) { GtkToolButton* button = GTK_TOOL_BUTTON(item); if ( act->private_data->iconId ) { GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId ); #if GTK_CHECK_VERSION(3,0,0) gtk_widget_set_hexpand(child, FALSE); gtk_widget_set_vexpand(child, FALSE); gtk_tool_button_set_icon_widget(button, child); #else GtkWidget* align = gtk_alignment_new( 0.5, 0.5, 0.0, 0.0 ); gtk_container_add( GTK_CONTAINER(align), child ); gtk_tool_button_set_icon_widget( button, align ); #endif } else { gchar *label = 0; g_object_get( G_OBJECT(action), "short_label", &label, NULL ); gtk_tool_button_set_label( button, label ); g_free( label ); label = 0; } } else { // For now trigger a warning but don't do anything else GtkToolButton* button = GTK_TOOL_BUTTON(item); (void)button; } gtk_widget_show_all( item ); return item; }
static void gtk_tool_button_sync_action_properties (GtkActivatable *activatable, GtkAction *action) { GtkToolButton *button; GIcon *icon; const gchar *stock_id; GtkIconSet *icon_set = NULL; parent_activatable_iface->sync_action_properties (activatable, action); if (!action) return; if (!gtk_activatable_get_use_action_appearance (activatable)) return; button = GTK_TOOL_BUTTON (activatable); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; stock_id = gtk_action_get_stock_id (action); G_GNUC_END_IGNORE_DEPRECATIONS; gtk_tool_button_set_label (button, gtk_action_get_short_label (action)); gtk_tool_button_set_use_underline (button, TRUE); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_tool_button_set_stock_id (button, stock_id); G_GNUC_END_IGNORE_DEPRECATIONS; gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action)); if (stock_id) { G_GNUC_BEGIN_IGNORE_DEPRECATIONS; icon_set = gtk_icon_factory_lookup_default (stock_id); G_GNUC_END_IGNORE_DEPRECATIONS; } if (icon_set != NULL) gtk_tool_button_set_icon_widget (button, NULL); else if ((icon = gtk_action_get_gicon (action)) != NULL) { GtkIconSize icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button)); GtkWidget *image = gtk_tool_button_get_icon_widget (button); if (!image) { image = gtk_image_new (); gtk_widget_show (image); gtk_tool_button_set_icon_widget (button, image); } gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size); } else if (gtk_action_get_icon_name (action)) gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action)); else gtk_tool_button_set_label (button, gtk_action_get_short_label (action)); }
GtkToolItem * ToolButton::newItem() { XOJ_CHECK_TYPE(ToolButton); GtkToolItem * it; if (!stock.isEmpty()) { if (popupMenu) { it = gtk_menu_tool_button_new_from_stock(stock.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new_from_stock(stock.c_str()); } } else if (group != GROUP_NOGROUP) { if (popupMenu) { it = gtk_menu_tool_toggle_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_toggle_button_set_menu(GTK_MENU_TOOL_TOGGLE_BUTTON(it), popupMenu); } else { it = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->gui->loadIcon(iconName.c_str())); } } else { if (popupMenu) { it = gtk_menu_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); } } gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), description.c_str()); gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), description.c_str()); return it; }
static void connect_proxy_cb (GtkUIManager *manager, GtkAction *action, GtkWidget *proxy, NautilusWindow *window) { GdkPixbuf *icon; GtkWidget *widget; if (GTK_IS_MENU_ITEM (proxy)) { g_signal_connect (proxy, "select", G_CALLBACK (menu_item_select_cb), window); g_signal_connect (proxy, "deselect", G_CALLBACK (menu_item_deselect_cb), window); /* This is a way to easily get pixbufs into the menu items */ icon = g_object_get_data (G_OBJECT (action), "menu-icon"); if (icon != NULL) { gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), gtk_image_new_from_pixbuf (icon)); } } if (GTK_IS_TOOL_BUTTON (proxy)) { icon = g_object_get_data (G_OBJECT (action), "toolbar-icon"); if (icon != NULL) { widget = gtk_image_new_from_pixbuf (icon); gtk_widget_show (widget); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (proxy), widget); } } }
void attach_icon(const char *toolbutton_name, const char *filename) { GtkWidget *img, *button = lookup_widget ( main_window, toolbutton_name ); GdkPixbuf *pixbuf; GError *error = NULL; if (!button) { Publisher::warn ( std::string("Code bug:\nattach_icon() called with an invalid widget name\n")+toolbutton_name ); return; } pixbuf = gdk_pixbuf_new_from_file(filename,&error); if (!pixbuf) { Publisher::warn ( std::string("Pixmap problem:\nCould not create a pixmap from\n") + filename + ",\nerror message:\n" + error->message ); return; } img = gtk_image_new_from_pixbuf(pixbuf); if (!img) { Publisher::warn ( "Unknown origin bug:\nCould not create an image from a pixmap" ); return; } gtk_widget_show(img); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (button), img); }
/* * Creates a new GtkWidget of class GtkToggleToolButton, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. */ static GtkWidget* gb_toggle_tool_button_new (GbWidgetNewData *data) { GtkWidget *new_widget, *image; GbWidget *pixmap_gbwidget; /* Place the pixmap icon in the button initially (even when loading). */ pixmap_gbwidget = gb_widget_lookup_class ("GtkImage"); if (pixmap_gbwidget) { image = gtk_image_new_from_pixmap (pixmap_gbwidget->gdkpixmap, pixmap_gbwidget->mask); } else { image = gtk_image_new (); g_warning ("Couldn't find GtkPixmap data"); } gtk_widget_show (image); new_widget = (GtkWidget*) gtk_toggle_tool_button_new (); gtk_tool_button_set_label (GTK_TOOL_BUTTON (new_widget), ""); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (new_widget), image); return new_widget; }
void Sidebar::initPages(GtkWidget* sidebar, GladeGui* gui) { XOJ_CHECK_TYPE(Sidebar); addPage(new SidebarIndexPage(this->control)); addPage(new SidebarPreviewPages(this->control)); #ifdef UNSTABLE_LAYERS_SIDEBAR addPage(new SidebarPreviewLayers(this->control)); #endif //UNSTABLE_LAYERS_SIDEBAR // Init toolbar with icons int i = 0; for (AbstractSidebarPage* p : this->pages) { GtkToolItem* it = gtk_toggle_tool_button_new(); p->tabButton = it; gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), gui->loadIcon(p->getIconName().c_str())); g_signal_connect(it, "clicked", G_CALLBACK(&buttonClicked), new SidebarPageButton(this, i, p)); gtk_tool_item_set_tooltip_text(it, p->getName().c_str()); gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), p->getName().c_str()); gtk_toolbar_insert(tbSelectPage, it, -1); // Add widget to sidebar gtk_box_pack_start(GTK_BOX(sidebar), p->getWidget(), TRUE, TRUE, 0); i++; } gtk_widget_show_all(GTK_WIDGET(this->tbSelectPage)); updateEnableDisableButtons(); }
static void gtk_tool_button_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkToolButton *button = GTK_TOOL_BUTTON (object); switch (prop_id) { case PROP_LABEL: gtk_tool_button_set_label (button, g_value_get_string (value)); break; case PROP_USE_UNDERLINE: gtk_tool_button_set_use_underline (button, g_value_get_boolean (value)); break; case PROP_LABEL_WIDGET: gtk_tool_button_set_label_widget (button, g_value_get_object (value)); break; case PROP_STOCK_ID: gtk_tool_button_set_stock_id (button, g_value_get_string (value)); break; case PROP_ICON_NAME: gtk_tool_button_set_icon_name (button, g_value_get_string (value)); break; case PROP_ICON_WIDGET: gtk_tool_button_set_icon_widget (button, g_value_get_object (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/* Checks the passed xmlNode for a recognized item (ToolButton, ToggleToolButton, Separator) * Returns the widget or NULL if nothing useful is found */ GtkWidget* ToolbarCreator::createToolItem(xml::Node& node, GtkToolbar* toolbar) { const std::string nodeName = node.getName(); GtkWidget* toolItem; if (nodeName == "separator") { toolItem = GTK_WIDGET(gtk_separator_tool_item_new()); } else if (nodeName == "toolbutton" || nodeName == "toggletoolbutton") { // Found a button, load the values that are shared by both types const std::string name = node.getAttributeValue("name"); const std::string icon = node.getAttributeValue("icon"); const std::string tooltip = _(node.getAttributeValue("tooltip").c_str()); const std::string action = node.getAttributeValue("action"); if (nodeName == "toolbutton") { // Create a new GtkToolButton and assign the right callback toolItem = GTK_WIDGET(gtk_tool_button_new(NULL, name.c_str())); } else { // Create a new GtkToggleToolButton and assign the right callback toolItem = GTK_WIDGET(gtk_toggle_tool_button_new()); } IEvent* event = GlobalEventManager().findEvent(action); if (event != NULL) { event->connectWidget(GTK_WIDGET(toolItem)); // Tell the event to update the state of this button event->updateWidgets(); } else { globalErrorStream() << "ToolbarCreator: Failed to lookup command " << action << "\n"; } // Set the tooltip, if not empty if (!tooltip.empty()) { gtk_tooltips_set_tip(_tooltips, GTK_WIDGET(toolItem), tooltip.c_str(), ""); //gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(toolItem), _tooltips, tooltip.c_str(), ""); } // Load and assign the icon, if specified if (icon != "") { GtkWidget* image = gtk_image_new_from_pixbuf(gtkutil::getLocalPixbufWithMask(icon)); gtk_widget_show(image); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toolItem), image); } } else { return NULL; } gtk_widget_show(toolItem); return toolItem; }
/*# @method set_icon_widget GtkToolButton @brief Sets icon as the widget used as icon on button. @param icon_widget the widget used as icon, or NULL. If icon_widget is NULL the icon is determined by the "stock_id" property. If the "stock_id" property is also NULL, button will not have an icon. */ FALCON_FUNC ToolButton::set_icon_widget( VMARG ) { Item* i_wdt = vm->param( 0 ); #ifndef NO_PARAMETER_CHECK if ( !i_wdt || !( i_wdt->isNil() || ( i_wdt->isObject() && IS_DERIVED( i_wdt, GtkWidget ) ) ) ) throw_inv_params( "[GtkWidget]" ); #endif GtkWidget* wdt = i_wdt->isNil() ? NULL : (GtkWidget*) COREGOBJECT( i_wdt )->getObject(); MYSELF; GET_OBJ( self ); gtk_tool_button_set_icon_widget( (GtkToolButton*)_obj, wdt ); }
GtkToolItem * ColorToolItem::newItem() { XOJ_CHECK_TYPE(ColorToolItem); this->iconWidget = selectcolor_new(this->color); selectcolor_set_circle(this->iconWidget, !isSelector()); GtkToolItem * it = gtk_toggle_tool_button_new(); gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), this->name.c_str()); gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), this->name.c_str()); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->iconWidget); return it; }
GtkToolItem *hwidget_get_tool_button(const gchar *image_file, const gchar *label, const gchar *tooltips_string, gpointer callback, gpointer data, guint type) { GtkToolItem *button; GtkWidget *pixmap; GtkTooltips *tooltips; switch (type) { case HWIDGET_TOGGLE_TOOL_BUTTON: button = gtk_toggle_tool_button_new(); if (callback) { g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(callback), data); } break; case HWIDGET_TOOL_BUTTON: button = gtk_tool_button_new(NULL, NULL); if (callback) { g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(callback), data); } break; default: return NULL; } if (image_file) { pixmap = hutil_create_pixmap(image_file); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), pixmap); } if (label) { gtk_tool_button_set_label(GTK_TOOL_BUTTON(button), label); } if (tooltips_string) { tooltips = gtk_tooltips_new(); gtk_tool_item_set_tooltip(button, tooltips, tooltips_string, NULL); } return button; }
void set_sidepane_state(ChmSee* self, gboolean state) { GtkWidget* icon_widget; g_object_set(selfp->ui_chmfile, "sidepane-visible", state, NULL); if (state) { icon_widget = gtk_image_new_from_file(get_resource_path("hide-pane.png")); } else { icon_widget = gtk_image_new_from_file(get_resource_path("show-pane.png")); } gtk_widget_show(icon_widget); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(gtk_ui_manager_get_widget(selfp->ui_manager, "/toolbar/sidepane")), icon_widget); };
void replace_button_icon(GladeXML * xml, GdkDrawable * window, GtkStyle * style, gchar * btn_name, gchar ** xpm) { GdkPixmap *pixmap; GdkBitmap *mask; GtkToolButton *button; GtkWidget *image; pixmap = gdk_pixmap_create_from_xpm_d(window, &mask, &style->bg[GTK_STATE_NORMAL], xpm); button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, btn_name)); image = gtk_image_new_from_pixmap(pixmap, mask); gtk_widget_show(image); gtk_tool_button_set_icon_widget(button, image); }
static void on_toolbar_reconfigured(GtkToolItem *tool_item, ToolItem *item) { GtkToolShell *shell = GTK_TOOL_SHELL(gtk_widget_get_parent(item->widget)); gboolean large = gtk_tool_shell_get_icon_size(shell) > GTK_ICON_SIZE_MENU; gchar *tooltip = NULL; if (gtk_tool_shell_get_style(shell) == GTK_TOOLBAR_ICONS) { GtkMenuItem *menu_item = GTK_MENU_ITEM(debug_menu_items[item->index].widget); tooltip = g_strdup(gtk_menu_item_get_label(menu_item)); utils_str_remove_chars(tooltip, "_"); } gtk_tool_item_set_tooltip_text(tool_item, tooltip); g_free(tooltip); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(tool_item), get_widget(item->icon[large])); }
static void collecturiCallback(BrowserWindow *window, GtkEntryIconPosition iconPosition, GdkEvent *event) { if (iconPosition == GTK_ENTRY_ICON_SECONDARY) { g_print("add bookmarkbutton\n"); /* GtkWidget *bookmarkbtn = gtk_button_new(); GtkBox *hBox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));` GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon); GtkWidget *lab = gtk_label_new(webkit_web_view_get_title(window->webView)); gtk_box_pack_start(hBox, image, FALSE, FALSE, 0); gtk_box_pack_start(hBox, lab, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(bookmarkbtn), hBox); gtk_box_pack_start(window->bookmarkbox, bookmarkbtn, FALSE, FALSE, 0); gtk_widget_show_all(bookmarkbtn); */ GtkToolItem *item = gtk_tool_button_new(NULL, ""); GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon); cairo_surface_t* fivacon = webkit_web_view_get_favicon(window->webView); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), fivacon); GtkWidget* label = gtk_label_new (webkit_web_view_get_title(window->webView)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_max_width_chars (GTK_LABEL (label), 25); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE); gtk_widget_show (label); gtk_tool_button_set_label_widget (GTK_TOOL_BUTTON (item), label); // g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window); gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1); gtk_widget_show_all(GTK_WIDGET(item)); /* GtkToolItem *item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME); // g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window); gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1); gtk_widget_show(GTK_WIDGET(item)); */ // GdkEventButton *eventButton = (GdkEventButton *)event; //todo 弹出对话框 } }
static void ink_toggle_action_update_icon( InkToggleAction* action ) { if ( action ) { GSList* proxies = gtk_action_get_proxies( GTK_ACTION(action) ); while ( proxies ) { if ( GTK_IS_TOOL_ITEM(proxies->data) ) { if ( GTK_IS_TOOL_BUTTON(proxies->data) ) { GtkToolButton* button = GTK_TOOL_BUTTON(proxies->data); GtkWidget* child = sp_icon_new( action->private_data->iconSize, action->private_data->iconId ); gtk_widget_show_all( child ); gtk_tool_button_set_icon_widget( button, child ); } } proxies = g_slist_next( proxies ); } } }
static void gtk_tool_button_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { GtkToolButton *button; GtkWidget *image; parent_activatable_iface->update (activatable, action, property_name); if (!gtk_activatable_get_use_action_appearance (activatable)) return; button = GTK_TOOL_BUTTON (activatable); if (strcmp (property_name, "short-label") == 0) gtk_tool_button_set_label (button, gtk_action_get_short_label (action)); else if (strcmp (property_name, "stock-id") == 0) gtk_tool_button_set_stock_id (button, gtk_action_get_stock_id (action)); else if (strcmp (property_name, "gicon") == 0) { const gchar *stock_id = gtk_action_get_stock_id (action); GIcon *icon = gtk_action_get_gicon (action); GtkIconSize icon_size = GTK_ICON_SIZE_BUTTON; if ((stock_id && gtk_icon_factory_lookup_default (stock_id)) || !icon) image = NULL; else { image = gtk_tool_button_get_icon_widget (button); icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button)); if (!image) image = gtk_image_new (); } gtk_tool_button_set_icon_widget (button, image); gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size); } else if (strcmp (property_name, "icon-name") == 0) gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action)); }
/* * Creates a new GtkWidget of class GtkRadioToolButton, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. */ static GtkWidget* gb_radio_tool_button_new (GbWidgetNewData *data) { GtkWidget *new_widget, *image; GbWidget *pixmap_gbwidget; GSList *group_list = NULL; /* When creating a radiotoolbutton we try to place it in the same group as other radiotoolbuttons in the same toolbar. */ if (data->action == GB_CREATING) { GtkWidget *parent = data->parent; while (parent && !GTK_IS_TOOLBAR (parent)) parent = parent->parent; if (parent) gb_widget_children_foreach (parent, (GtkCallback) find_parents_group, &group_list); } /* Place the pixmap icon in the button initially (even when loading). */ pixmap_gbwidget = gb_widget_lookup_class ("GtkImage"); if (pixmap_gbwidget) { image = gtk_image_new_from_pixmap (pixmap_gbwidget->gdkpixmap, pixmap_gbwidget->mask); } else { image = gtk_image_new (); g_warning ("Couldn't find GtkPixmap data"); } gtk_widget_show (image); new_widget = (GtkWidget*) gtk_radio_tool_button_new (group_list); gtk_tool_button_set_label (GTK_TOOL_BUTTON (new_widget), ""); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (new_widget), image); return new_widget; }
static void gtk_tool_button_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkToolButton *button = GTK_TOOL_BUTTON (object); switch (prop_id) { case PROP_LABEL: gtk_tool_button_set_label (button, g_value_get_string (value)); break; case PROP_USE_UNDERLINE: gtk_tool_button_set_use_underline (button, g_value_get_boolean (value)); break; case PROP_LABEL_WIDGET: gtk_tool_button_set_label_widget (button, g_value_get_object (value)); break; case PROP_STOCK_ID: G_GNUC_BEGIN_IGNORE_DEPRECATIONS; gtk_tool_button_set_stock_id (button, g_value_get_string (value)); G_GNUC_END_IGNORE_DEPRECATIONS; break; case PROP_ICON_NAME: gtk_tool_button_set_icon_name (button, g_value_get_string (value)); break; case PROP_ICON_WIDGET: gtk_tool_button_set_icon_widget (button, g_value_get_object (value)); break; case PROP_ACTION_NAME: g_object_set_property (G_OBJECT (button->priv->button), "action-name", value); break; case PROP_ACTION_TARGET: g_object_set_property (G_OBJECT (button->priv->button), "action-target", value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
//gqk static void fcitx_im_widget_init(FcitxImWidget* self) { self->builder = gtk_builder_new(); gtk_builder_add_from_resource(self->builder, "/org/fcitx/fcitx-config-gtk3/im_widget.ui", NULL); #define _GET_OBJECT(NAME) \ self->NAME = (typeof(self->NAME)) gtk_builder_get_object(self->builder, #NAME); _GET_OBJECT(imstore) _GET_OBJECT(imview) _GET_OBJECT(addimbutton) _GET_OBJECT(delimbutton) _GET_OBJECT(moveupbutton) _GET_OBJECT(movedownbutton) _GET_OBJECT(configurebutton) _GET_OBJECT(default_layout_button) _GET_OBJECT(scrolledwindow) _GET_OBJECT(toolbar) GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->imview)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_fcitx_im_widget_im_selection_changed), self); GtkStyleContext* context; context = gtk_widget_get_style_context (self->scrolledwindow); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM); context = gtk_widget_get_style_context (self->toolbar); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); gtk_style_context_add_class (context, "inline-toolbar"); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->addimbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("list-add-symbolic"), GTK_ICON_SIZE_BUTTON)); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->delimbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("list-remove-symbolic"), GTK_ICON_SIZE_BUTTON)); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->moveupbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("go-up-symbolic"), GTK_ICON_SIZE_BUTTON)); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->movedownbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("go-down-symbolic"), GTK_ICON_SIZE_BUTTON)); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->configurebutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("preferences-system-symbolic"), GTK_ICON_SIZE_BUTTON)); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->default_layout_button), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("input-keyboard-symbolic"), GTK_ICON_SIZE_BUTTON)); g_signal_connect(G_OBJECT(self->addimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_addim_button_clicked), self); g_signal_connect(G_OBJECT(self->delimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_delim_button_clicked), self); g_signal_connect(G_OBJECT(self->moveupbutton), "clicked", G_CALLBACK(_fcitx_im_widget_moveup_button_clicked), self); g_signal_connect(G_OBJECT(self->movedownbutton), "clicked", G_CALLBACK(_fcitx_im_widget_movedown_button_clicked), self); g_signal_connect(G_OBJECT(self->configurebutton), "clicked", G_CALLBACK(_fcitx_im_widget_configure_button_clicked), self); g_signal_connect(G_OBJECT(self->default_layout_button), "clicked", G_CALLBACK(_fcitx_im_widget_default_layout_button_clicked), self); g_signal_connect(G_OBJECT(self->imview), "row-activated", G_CALLBACK(_fcitx_im_widget_row_activated), self); }
GtkToolItem *ZLGtkApplicationWindow::createGtkToolButton(const ZLToolbar::AbstractButtonItem &button) { GtkToolItem *gtkItem = 0; static std::string imagePrefix = ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter; GtkWidget *image = gtk_image_new_from_file( (imagePrefix + button.iconName() + ".png").c_str() ); switch (button.type()) { case ZLToolbar::Item::PLAIN_BUTTON: gtkItem = gtk_tool_button_new(image, button.tooltip().c_str()); break; case ZLToolbar::Item::TOGGLE_BUTTON: gtkItem = gtk_toggle_tool_button_new(); gtk_tool_button_set_label(GTK_TOOL_BUTTON(gtkItem), button.tooltip().c_str()); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(gtkItem), image); break; case ZLToolbar::Item::MENU_BUTTON: { gtkItem = gtk_menu_tool_button_new(image, button.tooltip().c_str()); const ZLToolbar::MenuButtonItem &menuButton = (const ZLToolbar::MenuButtonItem&)button; shared_ptr<ZLPopupData> popupData = menuButton.popupData(); myPopupIdMap[gtkItem] = popupData.isNull() ? (size_t)-1 : (popupData->id() - 1); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(gtkItem), gtk_menu_new()); gtk_menu_tool_button_set_arrow_tooltip(GTK_MENU_TOOL_BUTTON(gtkItem), myToolbar->tooltips, menuButton.popupTooltip().c_str(), 0); break; } default: break; } gtk_tool_item_set_tooltip(gtkItem, myToolbar->tooltips, button.tooltip().c_str(), 0); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(gtkItem), "clicked", GTK_SIGNAL_FUNC(onButtonClicked), this); //GTK_WIDGET_UNSET_FLAGS(gtkItem, GTK_CAN_FOCUS); return gtkItem; }
static void gb_gnome_app_add_toolbar_button (GtkToolbar *toolbar, const gchar *stock_id, const gchar *tooltip) { GtkWidget *button; GladeWidgetData *wdata; button = gb_widget_new ("GtkToolButton", NULL); gtk_tool_button_set_stock_id (GTK_TOOL_BUTTON (button), stock_id); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (button), NULL); gtk_tool_button_set_label (GTK_TOOL_BUTTON (button), NULL); gtk_object_set_data_full (GTK_OBJECT (button), GladeToolButtonStockIDKey, g_strdup (stock_id), g_free); wdata = gtk_object_get_data (GTK_OBJECT (button), GB_WIDGET_DATA_KEY); wdata->tooltip = g_strdup (tooltip); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (button), -1); }
static GtkWidget* ink_action_create_tool_item( GtkAction* action ) { InkAction* act = INK_ACTION( action ); GtkWidget* item = GTK_ACTION_CLASS(ink_action_parent_class)->create_tool_item(action); if ( act->private_data->iconId ) { if ( GTK_IS_TOOL_BUTTON(item) ) { GtkToolButton* button = GTK_TOOL_BUTTON(item); GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId ); gtk_tool_button_set_icon_widget( button, child ); } else { // For now trigger a warning but don't do anything else GtkToolButton* button = GTK_TOOL_BUTTON(item); (void)button; } } // TODO investigate if needed gtk_widget_show_all( item ); return item; }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); } g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(tool->m_item, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(tool->m_item, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (control->m_widget->parent == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } // Inserted items "slide" into place using an animated effect that // causes multiple size events on the item. Must set size request // to keep item size from getting permanently set too small by the // first of these size events. const wxSize size = control->GetSize(); gtk_widget_set_size_request(control->m_widget, size.x, size.y); break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
static void moko_talking_init (MokoTalking *talking) { MokoTalkingPrivate *priv; GtkWidget *notebook; GtkWidget *toolbar, *image, *vbox, *hbox, *label, *align, *frame, *main_vbox; GtkWidget *duration; GtkToolItem *item; gint i; priv = talking->priv = MOKO_TALKING_GET_PRIVATE (talking); /* initialize dtimer to NULL */ priv->dtimer = NULL; notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM); priv->notebook = notebook; /* status page */ main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/phone.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); priv->incoming_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_ANSWER, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Answer"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_answer_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_IGNORE, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Ignore"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_silence_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_REJECT, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Reject"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_reject_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Volume controls */ priv->headphone = moko_alsa_volume_control_new (); moko_alsa_volume_control_set_device_from_name (priv->headphone, "neo1973"); moko_alsa_volume_control_set_element_from_name (priv->headphone, "Headphone"); priv->volume = moko_alsa_volume_scale_new (GTK_ORIENTATION_HORIZONTAL); moko_alsa_volume_scale_set_control (MOKO_ALSA_VOLUME_SCALE (priv->volume), priv->headphone); /* Outgoing call and talking share the same toolbar */ priv->main_bar = toolbar = gtk_toolbar_new (); gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name (MOKO_STOCK_SPEAKER, GTK_ICON_SIZE_BUTTON); item = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "toggled", G_CALLBACK (on_speaker_toggled), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); priv->speaker_toggle_btn = item; image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_HANGUP, GTK_ICON_SIZE_BUTTON); item = gtk_tool_button_new (image, "Hangup"); gtk_tool_item_set_expand (item, TRUE); g_signal_connect (item, "clicked", G_CALLBACK (on_cancel_clicked), talking); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The title label and image */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); priv->title = label = gtk_label_new ("Incoming Call"); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 8); priv->icon = image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (align), image); priv->duration = duration = gtk_label_new ("00:00:00"); gtk_misc_set_alignment (GTK_MISC (duration), 0.5, 0.5); gtk_box_pack_start (GTK_BOX (vbox), duration, FALSE, FALSE, 0); /* The status area */ align = gtk_alignment_new (0.5, 0.5, 1, 0 ); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_container_set_border_width (GTK_CONTAINER (frame), 10); gtk_container_add (GTK_CONTAINER (align), frame); hbox = gtk_hbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), hbox); priv->person = image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); priv->status = label = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* The volume control */ gtk_box_pack_start (GTK_BOX (vbox), priv->volume, FALSE, TRUE, 12); /* Load the pixbufs */ for (i = 0; i < N_PICS; i++) { if (i == 0) priv->talking[i] = gdk_pixbuf_new_from_file (PKGDATADIR"/talking.png", NULL); else { gchar *name = g_strdup_printf ("%s/talking_%d.png", PKGDATADIR, i-1); priv->talking[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); } if (G_IS_OBJECT (priv->talking[i])) g_object_ref (priv->talking[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/outgoing_%d.png", PKGDATADIR, i); priv->outgoing[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->outgoing[i])) g_object_ref (priv->outgoing[i]); } for (i = 0; i < N_PICS-1; i++) { gchar *name = g_strdup_printf ("%s/incoming_%d.png", PKGDATADIR, i); priv->incoming[i] = gdk_pixbuf_new_from_file (name, NULL); g_free (name); if (G_IS_OBJECT (priv->incoming[i])) g_object_ref (priv->incoming[i]); } /* dtmf page */ GtkWidget *pad, *display; main_vbox = gtk_vbox_new (FALSE, 0); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, gtk_image_new_from_file (PKGDATADIR"/dtmf.png")); gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand", TRUE, NULL); display = moko_dialer_textview_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), display); priv->dtmf_display = display; pad = moko_dialer_panel_new (); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), pad); g_signal_connect (pad, "user_input", G_CALLBACK (on_pad_user_input), talking); priv->dtmf_pad = pad; priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (priv->window, "delete-event", G_CALLBACK (window_delete_event_cb), talking); gtk_container_add (GTK_CONTAINER (priv->window), notebook); gtk_widget_show_all (notebook); }
void nsgtk_theme_implement(struct gtk_scaffolding *g) { struct nsgtk_theme *theme[IMAGE_SET_COUNT]; int i; struct nsgtk_button_connect *button; struct gtk_search *search; for (i = 0; i <= IMAGE_SET_POPUP_MENU; i++) theme[i] = nsgtk_theme_load(GTK_ICON_SIZE_MENU); theme[IMAGE_SET_BUTTONS] = nsgtk_theme_load(GTK_ICON_SIZE_LARGE_TOOLBAR); for (i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) { if ((i == URL_BAR_ITEM) || (i == THROBBER_ITEM) || (i == WEBSEARCH_ITEM)) continue; button = nsgtk_scaffolding_button(g, i); if (button == NULL) continue; /* gtk_image_menu_item_set_image accepts NULL image */ if ((button->main != NULL) && (theme[IMAGE_SET_MAIN_MENU] != NULL)) { gtk_image_menu_item_set_image(button->main, GTK_WIDGET( theme[IMAGE_SET_MAIN_MENU]-> image[i])); gtk_widget_show_all(GTK_WIDGET(button->main)); } if ((button->rclick != NULL) && (theme[IMAGE_SET_RCLICK_MENU] != NULL)) { gtk_image_menu_item_set_image(button->rclick, GTK_WIDGET( theme[IMAGE_SET_RCLICK_MENU]-> image[i])); gtk_widget_show_all(GTK_WIDGET(button->rclick)); } if ((button->popup != NULL) && (theme[IMAGE_SET_POPUP_MENU] != NULL)) { gtk_image_menu_item_set_image(button->popup, GTK_WIDGET( theme[IMAGE_SET_POPUP_MENU]-> image[i])); gtk_widget_show_all(GTK_WIDGET(button->popup)); } if ((button->location != -1) && (button->button != NULL) && (theme[IMAGE_SET_BUTTONS] != NULL)) { gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(button->button), GTK_WIDGET( theme[IMAGE_SET_BUTTONS]-> image[i])); gtk_widget_show_all(GTK_WIDGET(button->button)); } } /* set search bar images */ search = nsgtk_scaffolding_search(g); if ((search != NULL) && (theme[IMAGE_SET_MAIN_MENU] != NULL)) { /* gtk_tool_button_set_icon_widget accepts NULL image */ if (search->buttons[SEARCH_BACK_BUTTON] != NULL) { gtk_tool_button_set_icon_widget( search->buttons[SEARCH_BACK_BUTTON], GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]-> searchimage[SEARCH_BACK_BUTTON])); gtk_widget_show_all(GTK_WIDGET( search->buttons[SEARCH_BACK_BUTTON])); } if (search->buttons[SEARCH_FORWARD_BUTTON] != NULL) { gtk_tool_button_set_icon_widget( search->buttons[SEARCH_FORWARD_BUTTON], GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]-> searchimage[SEARCH_FORWARD_BUTTON])); gtk_widget_show_all(GTK_WIDGET( search->buttons[ SEARCH_FORWARD_BUTTON])); } if (search->buttons[SEARCH_CLOSE_BUTTON] != NULL) { gtk_tool_button_set_icon_widget( search->buttons[SEARCH_CLOSE_BUTTON], GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]-> searchimage[SEARCH_CLOSE_BUTTON])); gtk_widget_show_all(GTK_WIDGET( search->buttons[SEARCH_CLOSE_BUTTON])); } } for (i = 0; i < IMAGE_SET_COUNT; i++) { if (theme[i] != NULL) { free(theme[i]); } } }
GTKGeomWindow::GTKGeomWindow( class GTKPlotter &plotter, const Geometry &geom, const EpotField *epot, const EpotEfield *efield, const MeshScalarField *scharge, const MeshScalarField *tdens, const VectorField *bfield, const ParticleDataBase *pdb ) : GTKFrameWindow(plotter), _geomplot(_frame,geom), _geom(geom), _epot(epot), _efield(efield), _scharge(scharge), _tdens(tdens), _bfield(bfield), _pdb(pdb), _tool(TOOL_UNKNOWN), _prefdata(NULL) { //std::cout << "GTKGeomWindow constructor\n"; // Setup GeomPlot _geomplot.set_epot( epot ); _geomplot.set_scharge( scharge ); _geomplot.set_trajdens( tdens ); _geomplot.set_bfield( bfield ); _geomplot.set_efield( efield ); _geomplot.set_particle_database( pdb ); // Set window title gtk_window_set_title( GTK_WINDOW(_window), "Simulation geometry" ); // Adding geometry window specific tools to toolbar // Creating separator GtkToolItem *toolitem = gtk_separator_tool_item_new(); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); // Creating "Particle diagnostics" button GdkPixbuf *pixbuf = gdk_pixbuf_new_from_inline( -1, icon_particle_diag_inline, FALSE, NULL ); GtkWidget *icon = gtk_image_new_from_pixbuf( pixbuf ); toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) ); gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Particle diagnostics" ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Particle diagnostics" ); #endif gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon ); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); g_signal_connect( G_OBJECT(toolitem), "toggled", G_CALLBACK(menuitem_tool_change_signal), (gpointer)this ); // Creating "Field diagnostics" button pixbuf = gdk_pixbuf_new_from_inline( -1, icon_field_diag_inline, FALSE, NULL ); icon = gtk_image_new_from_pixbuf( pixbuf ); toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) ); gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Field diagnostics" ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Field diagnostics" ); #endif gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon ); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); g_signal_connect( G_OBJECT(toolitem), "toggled", G_CALLBACK(menuitem_tool_change_signal), (gpointer)this ); // Creating "Geom 3D" button pixbuf = gdk_pixbuf_new_from_inline( -1, icon_geom3d_inline, FALSE, NULL ); icon = gtk_image_new_from_pixbuf( pixbuf ); toolitem = gtk_tool_button_new( icon, "3D geometry view" ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "3D geometry view" ); #endif gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); if( _geom.geom_mode() != MODE_3D || !_geom.surface_built() ) gtk_widget_set_sensitive( GTK_WIDGET(toolitem), FALSE ); g_signal_connect( G_OBJECT(toolitem), "clicked", G_CALLBACK(menuitem_geom3d_signal), (gpointer)this ); // Creating separator toolitem = gtk_separator_tool_item_new(); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); // Creating view combobox and level spinbutton //_combobox = gtk_combo_box_new_text(); _combobox = gtk_combo_box_text_new(); if( geom.geom_mode() == MODE_3D ) { gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XZ" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YZ" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZX" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZY" ); /* gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XY" ); gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XZ" ); gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YX" ); gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YZ" ); gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZX" ); gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZY" ); */ gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 ); _spinbutton = gtk_spin_button_new_with_range( 0, geom.size(2)-1, 1 ); gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), geom.size(2)/2 ); _geomplot.set_view( VIEW_XY, geom.size(2)/2 ); } else { gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" ); gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" ); gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 ); _spinbutton = gtk_spin_button_new_with_range( 0, 0, 1 ); gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), 0 ); } toolitem = gtk_tool_item_new(); gtk_container_add( GTK_CONTAINER(toolitem), _combobox ); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view direction" ); #endif gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_spinbutton), 0 ); toolitem = gtk_tool_item_new(); gtk_container_add( GTK_CONTAINER(toolitem), _spinbutton ); gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view level" ); #endif g_signal_connect( G_OBJECT(_combobox), "changed", G_CALLBACK(combobox_signal), (gpointer)this ); g_signal_connect( G_OBJECT(_spinbutton), "value-changed", G_CALLBACK(spinbutton_signal), (gpointer)this ); // Drawing area signals g_signal_connect( G_OBJECT(_darea), "button_press_event", G_CALLBACK(darea_button_signal2), (gpointer)this ); g_signal_connect( G_OBJECT(_darea), "button_release_event", G_CALLBACK(darea_button_signal2), (gpointer)this ); g_signal_connect( G_OBJECT(_darea), "motion_notify_event", G_CALLBACK(darea_motion_signal2), (gpointer)this ); update_view(); show(); }