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);
}
