static gboolean prefs_custom_header_selected(GtkTreeSelection *selector, GtkTreeModel *model, GtkTreePath *path, gboolean currently_selected, gpointer data) { GtkTreeIter iter; CustomHeader *ch; GtkImage *preview; GdkPixbuf *pixbuf; CustomHeader default_ch = { 0, "", NULL }; if (currently_selected) return TRUE; if (!gtk_tree_model_get_iter(model, &iter, path)) return TRUE; gtk_tree_model_get(model, &iter, CUSTHDR_DATA, &ch, -1); if (!ch) ch = &default_ch; ENTRY_SET_TEXT(customhdr.hdr_entry, ch->name); ENTRY_SET_TEXT(customhdr.val_entry, ch->value); if (!strcmp2("Face",ch->name)) { preview = GTK_IMAGE(face_get_from_header (ch->value)); pixbuf = gtk_image_get_pixbuf(preview); gtk_image_set_from_pixbuf (GTK_IMAGE(customhdr.preview), pixbuf); gtk_widget_show(customhdr.preview); #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink (G_OBJECT(preview)); #else gtk_object_ref (G_OBJECT(preview)); gtk_object_sink (G_OBJECT(preview)); #endif } #if HAVE_LIBCOMPFACE else if (!strcmp2("X-Face", ch->name)) { preview = GTK_IMAGE(xface_get_from_header(ch->value)); pixbuf = gtk_image_get_pixbuf(preview); gtk_image_set_from_pixbuf (GTK_IMAGE(customhdr.preview), pixbuf); gtk_widget_show(customhdr.preview); #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink (G_OBJECT(preview)); #else gtk_object_ref (G_OBJECT(preview)); gtk_object_sink (G_OBJECT(preview)); #endif } #endif else { gtk_widget_hide(customhdr.preview); } return TRUE; }
static void _gwy_app_file_chooser_init(GwyAppFileChooser *chooser) { chooser->filter = gtk_file_filter_new(); g_object_ref(chooser->filter); gtk_object_sink(GTK_OBJECT(chooser->filter)); chooser->no_filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(chooser->no_filter, "*"); g_object_ref(chooser->no_filter); gtk_object_sink(GTK_OBJECT(chooser->no_filter)); }
/** * @brief Tie a marker's position to a pair of GtkAdjustments * * @param marker HosMarker for which to set adjustments * @param adjustment_x The GtkAdjustment to tie to the X position of 'marker' * @param adjustment_y The GtkAdjustment to tie to the Y position of 'marker' */ void marker_set_adjustments(HosMarker *marker, GtkAdjustment *adjustment_x, GtkAdjustment *adjustment_y) { gboolean need_configure = FALSE; g_return_if_fail(HOS_IS_MARKER(marker)); if (GTK_IS_ADJUSTMENT(adjustment_x) && (marker->adjustment_x != adjustment_x)) { need_configure = TRUE; if (marker->adjustment_x) { g_signal_handlers_disconnect_by_func (marker->adjustment_x, marker_adjustment_value_changed, marker); g_object_unref (marker->adjustment_x); } marker->adjustment_x = adjustment_x; if (adjustment_x) { g_object_ref (adjustment_x); gtk_object_sink (GTK_OBJECT (adjustment_x)); g_signal_connect (adjustment_x, "value_changed", G_CALLBACK (marker_adjustment_value_changed), marker); } } if (GTK_IS_ADJUSTMENT(adjustment_y) && (marker->adjustment_y != adjustment_y)) { need_configure = TRUE; if (marker->adjustment_y) { g_signal_handlers_disconnect_by_func (marker->adjustment_y, marker_adjustment_value_changed, marker); g_object_unref (marker->adjustment_y); } marker->adjustment_y = adjustment_y; if (adjustment_y) { g_object_ref (adjustment_y); gtk_object_sink (GTK_OBJECT (adjustment_y)); g_signal_connect (adjustment_y, "value_changed", G_CALLBACK (marker_adjustment_value_changed), marker); } } if (need_configure) canvas_item_configure(HOS_CANVAS_ITEM(marker)); }
static void mailwatch_free(Control *c) { XfceMailwatchPlugin *mwp = c->data; gint i; xfce_mailwatch_destroy(mwp->mailwatch); g_free(mwp->normal_icon); g_free(mwp->new_mail_icon); if(mwp->pix_normal) g_object_unref(G_OBJECT(mwp->pix_normal)); if(mwp->pix_newmail) g_object_unref(G_OBJECT(mwp->pix_newmail)); for(i = 0; i < XFCE_MAILWATCH_N_LOG_LEVELS; i++) { if(mwp->pix_log[i]) g_object_unref(G_OBJECT(mwp->pix_log[i])); } g_object_unref(G_OBJECT(mwp->loglist)); gtk_object_sink(GTK_OBJECT(mwp->tooltip)); g_free(mwp); c->data = NULL; }
static GObject * hildon_home_window_constructor (GType gtype, guint n_params, GObjectConstructParam *params) { GObject *retval; HildonHomeWindow *window; HildonHomeWindowPrivate *priv; GtkWidget *widget; retval = G_OBJECT_CLASS (hildon_home_window_parent_class)->constructor (gtype, n_params, params); widget = GTK_WIDGET (retval); window = HILDON_HOME_WINDOW (retval); priv = window->priv; gtk_widget_push_composite_child (); priv->titlebar = hildon_home_titlebar_new (); g_object_ref (priv->titlebar); gtk_object_sink (GTK_OBJECT (priv->titlebar)); gtk_widget_set_parent (priv->titlebar, widget); gtk_widget_show (priv->titlebar); gtk_widget_pop_composite_child (); return retval; }
void cursor_set_adjustment(HosCursor *cursor, GtkAdjustment *adjustment) { g_return_if_fail(HOS_IS_CURSOR(cursor)); if (cursor->adjustment != adjustment) { if (cursor->adjustment) { g_signal_handlers_disconnect_by_func (cursor->adjustment, cursor_adjustment_value_changed, cursor); g_object_unref (cursor->adjustment); } cursor->adjustment = adjustment; if (adjustment) { g_object_ref (adjustment); gtk_object_sink (GTK_OBJECT (adjustment)); g_signal_connect (adjustment, "value_changed", G_CALLBACK (cursor_adjustment_value_changed), cursor); /* cursor_adjustment_value_changed(adjustment, cursor); */ } canvas_item_configure(HOS_CANVAS_ITEM(cursor)); } }
static void egg_status_icon_init (EggStatusIcon *status_icon) { status_icon->priv = g_new0 (EggStatusIconPrivate, 1); status_icon->priv->image_type = GTK_IMAGE_EMPTY; status_icon->priv->size = G_MAXINT; status_icon->priv->tray_icon = GTK_WIDGET (egg_tray_icon_new (NULL)); gtk_widget_add_events (GTK_WIDGET (status_icon->priv->tray_icon), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); g_signal_connect_swapped (status_icon->priv->tray_icon, "button-release-event", G_CALLBACK (egg_status_icon_button_release), status_icon); status_icon->priv->image = gtk_image_new (); /* Center the icon */ gtk_misc_set_alignment (GTK_MISC (status_icon->priv->image), 0.5, 0.5); gtk_container_add (GTK_CONTAINER (status_icon->priv->tray_icon), status_icon->priv->image); g_signal_connect_swapped (status_icon->priv->image, "size-allocate", G_CALLBACK (egg_status_icon_size_allocate), status_icon); gtk_widget_show (status_icon->priv->image); gtk_widget_show (status_icon->priv->tray_icon); status_icon->priv->tooltips = gtk_tooltips_new (); g_object_ref (status_icon->priv->tooltips); gtk_object_sink (GTK_OBJECT (status_icon->priv->tooltips)); }
/** * go_combo_popup_reparent * @popup: Popup * @new_parent: New parent * @unrealize: Unrealize popup if TRUE. * * Reparent the popup, taking care of the refcounting * * Compare with gtk_menu_reparent in gtk/gtkmenu.c */ static void go_combo_popup_reparent (GtkWidget *popup, GtkWidget *new_parent, gboolean unrealize) { #if GLIB_CHECK_VERSION(2,10,0) && GTK_CHECK_VERSION(2,8,14) gboolean was_floating = g_object_is_floating (popup); g_object_ref_sink (popup); #else gboolean was_floating = GTK_OBJECT_FLOATING (popup); g_object_ref (popup); gtk_object_sink (GTK_OBJECT (popup)); #endif if (unrealize) { g_object_ref (popup); gtk_container_remove (GTK_CONTAINER (popup->parent), popup); gtk_container_add (GTK_CONTAINER (new_parent), popup); g_object_unref (popup); } else gtk_widget_reparent (GTK_WIDGET (popup), new_parent); gtk_widget_set_size_request (new_parent, -1, -1); if (was_floating) { #if GLIB_CHECK_VERSION(2,10,0) && GTK_CHECK_VERSION(2,8,14) g_object_force_floating (G_OBJECT (popup)); #else GTK_OBJECT_SET_FLAGS (GTK_OBJECT (popup), GTK_FLOATING); #endif } else g_object_unref (popup); }
void loadimg (GtkWidget *img) { /* GtkImage *img; GtkWidget *vbox; */ GdkPixbuf *pixbuf; GError *error=NULL; char *imgfile = NULL; if ((imgfile = get_imgfile_name ()) == NULL) { perror ("get_imgfile_name"); fputs("error getting file name", stderr); } if ((pixbuf = gdk_pixbuf_new_from_file (imgfile, &error)) != NULL) { img = gtk_image_new_from_pixbuf (pixbuf); gtk_container_add (GTK_CONTAINER (fme), img); gtk_object_sink (GTK_OBJECT (img)); gtk_widget_show_all (fme); /* very important, I wasted 2 days over this!! */ } else { fprintf(stderr, (error->message)); /* pixbuf is null */ } free (imgfile); }
static void hippo_canvas_widget_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { HippoCanvasWidget *widget; widget = HIPPO_CANVAS_WIDGET(object); switch (prop_id) { case PROP_WIDGET: { GtkWidget *w = (GtkWidget*) g_value_get_object(value); if (widget->widget != w) { if (w) { gtk_object_ref(GTK_OBJECT(w)); gtk_object_sink(GTK_OBJECT(w)); } if (widget->widget) g_object_unref(widget->widget); widget->widget = w; update_widget_visibility(widget); hippo_canvas_item_emit_request_changed(HIPPO_CANVAS_ITEM(widget)); } } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void filter_dir(fpick_dd *dt, const char *pattern) { #if GTK2VERSION >= 4 /* GTK+ 2.4+ */ GtkFileFilter *filt = gtk_file_filter_new(); GtkFileFilterInfo info; gtk_file_filter_add_pattern(filt, pattern); info.contains = GTK_FILE_FILTER_DISPLAY_NAME; #endif int *cols = dt->fcols, *map = dt->fmap; int i, cnt = dt->cnt; char *s; for (i = 0; i < cnt; i++ , cols += COL_MAX) { s = RELREF(cols[COL_NAME]); /* Filter files, let directories pass */ if (pattern[0] && (s[0] == 'F')) { #if GTK2VERSION >= 4 /* GTK+ 2.4+ */ info.display_name = s + 1; if (!gtk_file_filter_filter(filt, &info)) continue; #else if (!fpick_fnmatch(pattern, s + 1)) continue; #endif } *map++ = i; } dt->cntx = map - dt->fmap; #if GTK2VERSION >= 4 /* GTK+ 2.4+ */ gtk_object_sink(GTK_OBJECT(filt)); #endif }
static gint cb_thumbview_button_press (GtkWidget * widget, GdkEventButton * event, ThumbView * tv) { if (ZALBUM (tv->album)->len == 0 || ZLIST (tv->album)->focus < 0) return FALSE; gtk_widget_grab_focus (GTK_WIDGET (tv->album)); if (event->type == GDK_BUTTON_PRESS && event->button == 3) { gint type; guint n_menu_items; GtkWidget *popup_menu, *progs_submenu, *scripts_submenu; GtkWidget *menuitem; GtkItemFactory *ifactory; /* * create popup menu */ n_menu_items = sizeof (thumbview_popupmenu_items) / sizeof (thumbview_popupmenu_items[0]) - 1; popup_menu = menu_create_items (BROWSER_WINDOW, thumbview_popupmenu_items, n_menu_items, "<ThumbnailButtonPop>", tv); ifactory = gtk_item_factory_from_widget (popup_menu); type = (gint) zalbum_get_cell_data (ZALBUM (tv->album), tv->current); thumbview_update_popupmenu (type, ifactory); menuitem = gtk_item_factory_get_item (ifactory, "/Open in External Program"); progs_submenu = create_progs_submenu (tv); menu_set_submenu (popup_menu, "/Open in External Program", progs_submenu); menuitem = gtk_item_factory_get_item (ifactory, "/Scripts"); scripts_submenu = create_scripts_submenu (tv); menu_set_submenu (popup_menu, "/Scripts", scripts_submenu); gtk_menu_popup (GTK_MENU (popup_menu), NULL, NULL, NULL, NULL, event->button, event->time); #ifdef USE_GTK2 gtk_object_ref (GTK_OBJECT (popup_menu)); gtk_object_sink (GTK_OBJECT (popup_menu)); #endif gtk_widget_unref (popup_menu); return TRUE; } tv->current = ZLIST (tv->album)->focus; return FALSE; }
GtkWidget* bst_choice_menu_createv (const gchar *menu_path, BstChoice *first_choice, ...) { BstChoice *choice; GtkWidget *menu; va_list args; va_start (args, first_choice); menu = g_object_connect (gtk_widget_new (GTK_TYPE_MENU, NULL), "signal::selection-done", check_modal_quit, NULL, NULL); gtk_menu_set_accel_path (GTK_MENU (menu), menu_path); gtk_widget_ref (menu); gtk_object_sink (GTK_OBJECT (menu)); choice = first_choice; while (choice) { bst_choice_menu_add_choice_and_free (menu, choice); choice = va_arg (args, BstChoice*); } va_end (args); return menu; }
static void gwy_data_view_set_layer(GwyDataView *data_view, GwyDataViewLayer **which, GwyDataViewLayer *layer) { g_return_if_fail(GWY_IS_DATA_VIEW(data_view)); g_return_if_fail(which); if (layer == *which) return; if (*which) { gwy_data_view_layer_unplugged(*which); (*which)->parent = NULL; g_object_unref(*which); } if (layer) { g_assert(layer->parent == NULL); g_object_ref(layer); gtk_object_sink(GTK_OBJECT(layer)); layer->parent = (GtkWidget*)data_view; gwy_data_view_layer_plugged(layer); } *which = layer; data_view->force_update = TRUE; }
/** * thunarx_property_page_set_label_widget: * @property_page : a #ThunarxPropertyPage. * @label_widget : the new label widget. * * Sets the label widget for the @property_page. This is the widget * that will appear in the notebook header for the @property_page. **/ void thunarx_property_page_set_label_widget (ThunarxPropertyPage *property_page, GtkWidget *label_widget) { g_return_if_fail (THUNARX_IS_PROPERTY_PAGE (property_page)); g_return_if_fail (label_widget == NULL || (GTK_IS_WIDGET (label_widget) && label_widget->parent == NULL)); if (G_UNLIKELY (label_widget == property_page->priv->label_widget)) return; /* disconnect from the previous label widget */ if (G_LIKELY (property_page->priv->label_widget != NULL)) g_object_unref (G_OBJECT (property_page->priv->label_widget)); /* activate the new label widget */ property_page->priv->label_widget = label_widget; /* connect to the new label widget */ if (G_LIKELY (label_widget != NULL)) { g_object_ref (G_OBJECT (label_widget)); gtk_object_sink (GTK_OBJECT (label_widget)); } /* notify listeners */ g_object_freeze_notify (G_OBJECT (property_page)); g_object_notify (G_OBJECT (property_page), "label"); g_object_notify (G_OBJECT (property_page), "label-widget"); g_object_thaw_notify (G_OBJECT (property_page)); }
static void create_dialog() { dialog = gtk_dialog_new_with_buttons( _("Object defaults"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); dialog_vbox = GTK_DIALOG (dialog)->vbox; gtk_window_set_role (GTK_WINDOW (dialog), "defaults_window"); g_signal_connect(G_OBJECT (dialog), "response", G_CALLBACK(defaults_respond), NULL); g_signal_connect(G_OBJECT(dialog), "delete_event", G_CALLBACK(gtk_widget_hide), NULL); no_defaults_dialog = gtk_label_new(_("This object has no defaults.")); gtk_widget_show (no_defaults_dialog); #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink(GTK_OBJECT(no_defaults_dialog)); #else g_object_ref(GTK_OBJECT(no_defaults_dialog)); gtk_object_sink(GTK_OBJECT(no_defaults_dialog)); #endif }
/** * go_combo_popup_tear_off * @combo: Combo box * @set_position: Set to position of popup shell if true * * Tear off the popup * * FIXME: * Gtk popup menus are toplevel windows, not dialogs. I think this is wrong, * and make the popups dialogs. But may be there should be a way to make * them toplevel. We can do this after creating: * GTK_WINDOW (tearoff)->type = GTK_WINDOW_TOPLEVEL; */ static void go_combo_popup_tear_off (GOComboBox *combo, gboolean set_position) { int x, y; if (!combo->priv->tearoff_window) { GtkWidget *tearoff; gchar const *title; /* FIXME: made this a toplevel, not a dialog ! */ tearoff = gtk_window_new (GTK_WINDOW_TOPLEVEL); #if GLIB_CHECK_VERSION(2,10,0) && GTK_CHECK_VERSION(2,8,14) g_object_ref_sink (tearoff); #else g_object_ref (tearoff); gtk_object_sink (GTK_OBJECT (tearoff)); #endif combo->priv->tearoff_window = tearoff; gtk_widget_set_app_paintable (tearoff, TRUE); g_signal_connect (tearoff, "key_press_event", G_CALLBACK (cb_combo_keypress), combo); gtk_widget_realize (tearoff); title = go_combo_box_get_title (combo); if (title) gdk_window_set_title (tearoff->window, title); g_object_set (G_OBJECT (tearoff), "allow-shrink", FALSE, "allow-grow", TRUE, NULL); gtk_window_set_transient_for (GTK_WINDOW (tearoff), GTK_WINDOW (gtk_widget_get_toplevel GTK_WIDGET (combo))); } if (GTK_WIDGET_VISIBLE (combo->priv->popup)) { gtk_widget_hide (combo->priv->toplevel); gtk_grab_remove (combo->priv->toplevel); gdk_display_pointer_ungrab (gtk_widget_get_display (combo->priv->toplevel), GDK_CURRENT_TIME); } go_combo_popup_reparent (combo->priv->popup, combo->priv->tearoff_window, FALSE); /* It may have got confused about size */ gtk_widget_queue_resize (GTK_WIDGET (combo->priv->popup)); if (set_position) { go_combo_box_get_pos (combo, &x, &y); gtk_window_move (GTK_WINDOW (combo->priv->tearoff_window), x, y); } gtk_widget_show (GTK_WIDGET (combo->priv->popup)); gtk_widget_show (combo->priv->tearoff_window); }
bool wxToolBar::Create( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) { if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxToolBar creation failed") ); return false; } FixupStyle(); m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() ); #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) if (gtk_check_version(2, 12, 0)) { m_tooltips = gtk_tooltips_new(); g_object_ref(m_tooltips); gtk_object_sink(GTK_OBJECT(m_tooltips)); } #endif GtkSetStyle(); if (style & wxTB_DOCKABLE) { m_widget = gtk_handle_box_new(); g_signal_connect(m_widget, "child_detached", G_CALLBACK(child_detached), NULL); g_signal_connect(m_widget, "child_attached", G_CALLBACK(child_attached), NULL); if (style & wxTB_FLAT) gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE ); } else { m_widget = gtk_event_box_new(); ConnectWidget( m_widget ); } g_object_ref(m_widget); gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar)); gtk_widget_show(GTK_WIDGET(m_toolbar)); m_parent->DoAddChild( this ); PostCreation(size); g_signal_connect_after(m_toolbar, "size_request", G_CALLBACK(size_request), this); return true; }
static void gwy_graph_window_init(G_GNUC_UNUSED GwyGraphWindow *graphwindow) { if (!tooltips_set && !tooltips) { tooltips = gtk_tooltips_new(); g_object_ref(tooltips); gtk_object_sink(GTK_OBJECT(tooltips)); } }
static GtkWidget * wireless_applet_new (WirelessApplet *applet) { panel_applet_set_flags (PANEL_APPLET (applet), PANEL_APPLET_EXPAND_MINOR); applet->skfd = iw_sockets_open (); /* this ensures that properties are loaded */ wireless_applet_load_properties (applet); wireless_applet_load_theme (applet); setup_widgets (applet); applet->tips = gtk_tooltips_new (); g_object_ref (applet->tips); gtk_object_sink (GTK_OBJECT (applet->tips)); applet->prefs = NULL; g_signal_connect (applet,"destroy", G_CALLBACK (wireless_applet_destroy),NULL); g_signal_connect (applet->button, "button_press_event", G_CALLBACK (do_not_eat_button_press), NULL); /* Setup the menus */ panel_applet_setup_menu_from_file (PANEL_APPLET (applet), NULL, "GNOME_WirelessApplet.xml", NULL, wireless_menu_verbs, applet); if (panel_applet_get_locked_down (PANEL_APPLET (applet))) { BonoboUIComponent *popup_component; popup_component = panel_applet_get_popup_component (PANEL_APPLET (applet)); bonobo_ui_component_set_prop (popup_component, "/commands/WirelessProperties", "hidden", "1", NULL); } check_wireless (applet); wireless_applet_timeout_handler (applet); wireless_applet_start_timeout (applet); g_signal_connect (G_OBJECT (applet), "change_size", G_CALLBACK (change_size_cb), applet); g_signal_connect (G_OBJECT (applet), "change_orient", G_CALLBACK (change_orient_cb), applet); return GTK_WIDGET (applet); }
static void GetTooltipColors() { GtkTooltips* tooltips = gtk_tooltips_new(); gtk_tooltips_force_window(tooltips); gtk_widget_ensure_style(tooltips->tip_window); GdkColor c = tooltips->tip_window->style->bg[GTK_STATE_NORMAL]; gs_objects.m_colTooltip = wxColor(c.red >> SHIFT, c.green >> SHIFT, c.blue >> SHIFT); c = tooltips->tip_window->style->fg[GTK_STATE_NORMAL]; gs_objects.m_colTooltipText = wxColor(c.red >> SHIFT, c.green >> SHIFT, c.blue >> SHIFT); gtk_object_sink(reinterpret_cast<GtkObject*>(tooltips)); }
gpointer gtr_object_ref_sink( gpointer object ) { #if GLIB_CHECK_VERSION( 2, 10, 0 ) g_object_ref_sink( object ); #else g_object_ref( object ); gtk_object_sink( GTK_OBJECT( object ) ); #endif return object; }
void Widget::retainPlatformWidget() { if (!platformWidget()) return; #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink(platformWidget()); #else g_object_ref(platformWidget()); gtk_object_sink(GTK_OBJECT(platformWidget())); #endif }
static void gdl_dock_item_grip_instance_init (GdlDockItemGrip *grip) { GtkWidget *image; GTK_WIDGET_SET_FLAGS (grip, GTK_NO_WINDOW); grip->_priv = g_new0 (GdlDockItemGripPrivate, 1); grip->_priv->icon_pixbuf_valid = FALSE; grip->_priv->icon_pixbuf = NULL; grip->_priv->title_layout = NULL; gtk_widget_push_composite_child (); grip->_priv->close_button = gtk_button_new (); gtk_widget_pop_composite_child (); GTK_WIDGET_UNSET_FLAGS (grip->_priv->close_button, GTK_CAN_FOCUS); gtk_widget_set_parent (grip->_priv->close_button, GTK_WIDGET (grip)); gtk_button_set_relief (GTK_BUTTON (grip->_priv->close_button), GTK_RELIEF_NONE); gtk_widget_show (grip->_priv->close_button); image = gtk_image_new_from_stock (GDL_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (grip->_priv->close_button), image); gtk_widget_show (image); g_signal_connect (G_OBJECT (grip->_priv->close_button), "clicked", G_CALLBACK (gdl_dock_item_grip_close_clicked), grip); gtk_widget_push_composite_child (); grip->_priv->iconify_button = gtk_button_new (); gtk_widget_pop_composite_child (); GTK_WIDGET_UNSET_FLAGS (grip->_priv->iconify_button, GTK_CAN_FOCUS); gtk_widget_set_parent (grip->_priv->iconify_button, GTK_WIDGET (grip)); gtk_button_set_relief (GTK_BUTTON (grip->_priv->iconify_button), GTK_RELIEF_NONE); gtk_widget_show (grip->_priv->iconify_button); image = gtk_image_new_from_stock (GDL_STOCK_MENU_RIGHT, GTK_ICON_SIZE_MENU); gtk_container_add (GTK_CONTAINER (grip->_priv->iconify_button), image); gtk_widget_show (image); g_signal_connect (G_OBJECT (grip->_priv->iconify_button), "clicked", G_CALLBACK (gdl_dock_item_grip_iconify_clicked), grip); grip->_priv->tooltips = gtk_tooltips_new (); g_object_ref (grip->_priv->tooltips); gtk_object_sink (GTK_OBJECT (grip->_priv->tooltips)); gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->iconify_button, _("Iconify"), _("Iconify this dock")); gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->close_button, _("Close"), _("Close this dock")); }
static void hildon_home_window_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { HildonHomeWindowPrivate *priv = HILDON_HOME_WINDOW_GET_PRIVATE (gobject); switch (prop_id) { case PROP_MENU: hildon_home_window_set_menu (HILDON_HOME_WINDOW (gobject), GTK_MENU (g_value_get_object (value))); break; case PROP_WORK_AREA: hildon_home_window_set_work_area (HILDON_HOME_WINDOW (gobject), (GdkRectangle *) g_value_get_pointer (value)); break; case PROP_TITLE: g_object_set (priv->titlebar, "title", g_value_get_string (value), NULL); break; case PROP_TITLEBAR: { GtkWidget *titlebar = GTK_WIDGET (g_value_get_object (value)); if (GTK_IS_WIDGET (titlebar)) { if (priv->titlebar) g_object_unref (priv->titlebar); priv->titlebar = titlebar; gtk_widget_push_composite_child (); g_object_ref (priv->titlebar); gtk_object_sink (GTK_OBJECT (priv->titlebar)); gtk_widget_set_parent (priv->titlebar, GTK_WIDGET (gobject)); gtk_widget_show (priv->titlebar); gtk_widget_pop_composite_child (); } } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
wxFont wxSystemSettingsNative::GetFont( wxSystemFont index ) { wxFont font; switch (index) { case wxSYS_OEM_FIXED_FONT: case wxSYS_ANSI_FIXED_FONT: case wxSYS_SYSTEM_FIXED_FONT: font = *wxNORMAL_FONT; break; case wxSYS_ANSI_VAR_FONT: case wxSYS_SYSTEM_FONT: case wxSYS_DEVICE_DEFAULT_FONT: case wxSYS_DEFAULT_GUI_FONT: if (!gs_objects.m_fontSystem.Ok()) { GtkWidget *widget = gtk_button_new(); GtkStyle *def = gtk_rc_get_style( widget ); if ( !def || !def->font_desc ) def = gtk_widget_get_default_style(); if ( def && def->font_desc ) { wxNativeFontInfo info; info.description = pango_font_description_copy(def->font_desc); gs_objects.m_fontSystem = wxFont(info); } else { GtkSettings *settings = gtk_settings_get_default(); gchar *font_name = NULL; g_object_get ( settings, "gtk-font-name", &font_name, NULL); if (!font_name) gs_objects.m_fontSystem = wxFont( 12, wxSWISS, wxNORMAL, wxNORMAL ); else gs_objects.m_fontSystem = wxFont(wxString::FromAscii(font_name)); g_free (font_name); } gtk_object_sink((GtkObject*)widget); } font = gs_objects.m_fontSystem; break; default: break; } return font; }
GdkDragAction nautilus_drag_drop_background_ask (GtkWidget *widget, GdkDragAction actions) { GtkWidget *menu; GtkWidget *menu_item; DropActionMenuData damd; /* Create the menu and set the sensitivity of the items based on the * allowed actions. */ menu = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget)); append_drop_action_menu_item (menu, _("Set as background for _all folders"), NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND, (actions & NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND) != 0, &damd); append_drop_action_menu_item (menu, _("Set as background for _this folder"), NAUTILUS_DND_ACTION_SET_AS_FOLDER_BACKGROUND, (actions & NAUTILUS_DND_ACTION_SET_AS_FOLDER_BACKGROUND) != 0, &damd); eel_gtk_menu_append_separator (GTK_MENU (menu)); menu_item = gtk_menu_item_new_with_mnemonic (_("Cancel")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); gtk_widget_show (menu_item); damd.chosen = 0; damd.loop = g_main_loop_new (NULL, FALSE); g_signal_connect (menu, "deactivate", G_CALLBACK (menu_deactivate_callback), &damd); gtk_grab_add (menu); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME); g_main_loop_run (damd.loop); gtk_grab_remove (menu); g_main_loop_unref (damd.loop); gtk_object_sink (GTK_OBJECT (menu)); return damd.chosen; }
/** * gwy_graph_window_class_set_tooltips: * @tips: #GtkTooltips object #GwyGraphWindow should use for setting tooltips. * A %NULL value disables tooltips altogether. * * Sets the tooltips object to use for adding tooltips to graph window parts. * * This is a class method. It affects only newly created graph windows, * existing graph windows will continue to use the tooltips they were * constructed with. * * If no class tooltips object is set before first #GwyGraphWindow is created, * the class instantiates one on its own. You can normally obtain it with * gwy_graph_window_class_get_tooltips() then. The class takes a reference on * the tooltips in either case. **/ void gwy_graph_window_class_set_tooltips(GtkTooltips *tips) { g_return_if_fail(!tips || GTK_IS_TOOLTIPS(tips)); if (tips) { g_object_ref(tips); gtk_object_sink(GTK_OBJECT(tips)); } gwy_object_unref(tooltips); tooltips = tips; tooltips_set = TRUE; }
static Megahertz * megahertz_new (void) { Megahertz *ac = g_new (Megahertz, 1); GtkWidget *align; ac->mhz=ac->ghz=-1; ac->size = settings.size; ac->tips = gtk_tooltips_new (); g_object_ref (ac->tips); gtk_object_sink (GTK_OBJECT (ac->tips)); ac->eventbox = gtk_event_box_new (); gtk_widget_set_name (ac->eventbox, "xfce_panel"); gtk_widget_show (ac->eventbox); align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_set_border_width (GTK_CONTAINER (align), 2); gtk_widget_show (align); gtk_container_add (GTK_CONTAINER (ac->eventbox), align); ac->table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (ac->table), 2); gtk_table_set_row_spacings (GTK_TABLE (ac->table), 0); gtk_widget_show (ac->table); gtk_container_add (GTK_CONTAINER (align), ac->table); ac->mhzlabel = gtk_label_new (NULL); gtk_widget_show (ac->mhzlabel); gtk_label_set_use_markup (GTK_LABEL (ac->mhzlabel), TRUE); gtk_table_attach (GTK_TABLE (ac->table), ac->mhzlabel, 0, 1, 0, 2, 0, 0, 0, 0); ac->strlabel = gtk_label_new (NULL); gtk_widget_show (ac->strlabel); gtk_label_set_use_markup (GTK_LABEL (ac->strlabel), TRUE); gtk_table_attach (GTK_TABLE (ac->table), ac->strlabel, 1, 2, 0, 1, 0, 0, 0, 0); megahertz_timeout (ac); ac->timeout_id = g_timeout_add (1000, (GSourceFunc) megahertz_timeout, ac); return ac; }
static void screenshot_free_data (XfcePanelPlugin * plugin, ScreenshotData * sd) { if (sd->netk_id) g_signal_handler_disconnect (sd->screen, sd->netk_id); if (sd->screen_id) g_signal_handler_disconnect (plugin, sd->screen_id); if (sd->style_id) g_signal_handler_disconnect (plugin, sd->style_id); sd->netk_id = sd->screen_id = sd->style_id = 0; gtk_object_sink (GTK_OBJECT (sd->tooltips)); gtk_widget_destroy (sd->chooser); g_free (sd); }