2
* panel-applet.c: panel applet writing library.
4
* Copyright (C) 2001 Sun Microsystems, Inc.
6
* This library is free software; you can redistribute it and/or
7
* modify it under the terms of the GNU Library General Public
8
* License as published by the Free Software Foundation; either
9
* version 2 of the License, or (at your option) any later version.
11
* This library is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14
* Library General Public License for more details.
16
* You should have received a copy of the GNU Library General Public
17
* License along with this library; if not, write to the
18
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19
* Boston, MA 02111-1307, USA.
22
* Mark McLoughlin <mark@skynet.ie>
36
#include <gdk/gdkkeysyms.h>
38
#include <bonobo/bonobo-ui-util.h>
39
#include <bonobo/bonobo-main.h>
40
#include <bonobo/bonobo-types.h>
41
#include <bonobo/bonobo-property-bag.h>
42
#include <bonobo/bonobo-item-handler.h>
43
#include <bonobo/bonobo-shlib-factory.h>
44
#include <bonobo/bonobo-property-bag-client.h>
45
#include <gconf/gconf.h>
46
#include <gconf/gconf-client.h>
47
#include <X11/Xatom.h>
49
#include "panel-applet.h"
50
#include "panel-applet-private.h"
51
#include "panel-applet-shell.h"
52
#include "panel-applet-marshal.h"
53
#include "panel-applet-enums.h"
55
#define PANEL_APPLET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), PANEL_TYPE_APPLET, PanelAppletPrivate))
57
struct _PanelAppletPrivate {
58
PanelAppletShell *shell;
59
BonoboControl *control;
60
BonoboPropertyBag *prop_sack;
61
BonoboItemHandler *item_handler;
69
PanelAppletFlags flags;
70
PanelAppletOrient orient;
73
GtkWidget *background_widget;
81
gboolean moving_focus_out;
90
MOVE_FOCUS_OUT_OF_APPLET,
95
static guint panel_applet_signals [LAST_SIGNAL];
97
#define PROPERTY_ORIENT "panel-applet-orient"
98
#define PROPERTY_SIZE "panel-applet-size"
99
#define PROPERTY_BACKGROUND "panel-applet-background"
100
#define PROPERTY_FLAGS "panel-applet-flags"
101
#define PROPERTY_SIZE_HINTS "panel-applet-size-hints"
102
#define PROPERTY_LOCKED_DOWN "panel-applet-locked-down"
107
PROPERTY_BACKGROUND_IDX,
109
PROPERTY_SIZE_HINTS_IDX,
110
PROPERTY_LOCKED_DOWN_IDX
113
G_DEFINE_TYPE (PanelApplet, panel_applet, GTK_TYPE_EVENT_BOX)
115
static void panel_applet_handle_background (PanelApplet *applet);
116
static void panel_applet_setup (PanelApplet *applet);
119
panel_applet_associate_schemas_in_dir (GConfClient *client,
120
const gchar *prefs_key,
121
const gchar *schema_dir,
126
list = gconf_client_all_entries (client, schema_dir, error);
131
for (l = list; l; l = l->next) {
132
GConfEntry *entry = l->data;
133
const gchar *schema_key;
134
GConfEntry *applet_entry;
135
const gchar *applet_schema_key;
139
schema_key = gconf_entry_get_key (entry);
140
tmp = g_path_get_basename (schema_key);
142
if (strchr (tmp, '-'))
143
g_warning ("Applet key '%s' contains a hyphen. Please "
144
"use underscores in gconf keys\n", tmp);
146
key = g_strdup_printf ("%s/%s", prefs_key, tmp);
149
/* Associating a schema is potentially expensive, so let's try
150
* to avoid this by doing it only when needed. So we check if
151
* the key is already correctly associated. */
153
applet_entry = gconf_client_get_entry (client, key,
156
applet_schema_key = gconf_entry_get_schema_name (applet_entry);
158
applet_schema_key = NULL;
160
if (g_strcmp0 (schema_key, applet_schema_key) != 0) {
161
gconf_engine_associate_schema (client->engine,
162
key, schema_key, error);
164
if (applet_entry == NULL ||
165
gconf_entry_get_value (applet_entry) == NULL ||
166
gconf_entry_get_is_default (applet_entry)) {
167
/* unset the key: gconf_client_get_entry()
168
* brought an invalid entry in the client
169
* cache, and we want to fix this */
170
gconf_client_unset (client, key, NULL);
177
gconf_entry_unref (applet_entry);
178
gconf_entry_unref (entry);
188
list = gconf_client_all_dirs (client, schema_dir, error);
190
for (l = list; l; l = l->next) {
191
gchar *subdir = l->data;
193
gchar *schema_subdir;
196
tmp = g_path_get_basename (subdir);
198
prefs_subdir = g_strdup_printf ("%s/%s", prefs_key, tmp);
199
schema_subdir = g_strdup_printf ("%s/%s", schema_dir, tmp);
201
panel_applet_associate_schemas_in_dir (client,
206
g_free (prefs_subdir);
207
g_free (schema_subdir);
221
panel_applet_add_preferences (PanelApplet *applet,
222
const gchar *schema_dir,
225
GError **error = NULL;
226
GError *our_error = NULL;
228
g_return_if_fail (PANEL_IS_APPLET (applet));
229
g_return_if_fail (schema_dir != NULL);
231
if (!applet->priv->prefs_key)
239
panel_applet_associate_schemas_in_dir (applet->priv->client,
240
applet->priv->prefs_key,
244
if (!opt_error && our_error) {
245
g_warning (G_STRLOC ": failed to add preferences from '%s' : '%s'",
246
schema_dir, our_error->message);
247
g_error_free (our_error);
252
panel_applet_get_preferences_key (PanelApplet *applet)
254
g_return_val_if_fail (PANEL_IS_APPLET (applet), NULL);
256
if (!applet->priv->prefs_key)
259
return g_strdup (applet->priv->prefs_key);
263
panel_applet_set_preferences_key (PanelApplet *applet,
264
const char *prefs_key)
266
g_return_if_fail (PANEL_IS_APPLET (applet));
268
if (applet->priv->prefs_key) {
269
gconf_client_remove_dir (applet->priv->client,
270
applet->priv->prefs_key,
273
g_free (applet->priv->prefs_key);
274
applet->priv->prefs_key = NULL;
278
applet->priv->prefs_key = g_strdup (prefs_key);
280
gconf_client_add_dir (applet->priv->client,
281
applet->priv->prefs_key,
282
GCONF_CLIENT_PRELOAD_RECURSIVE,
288
panel_applet_get_flags (PanelApplet *applet)
290
g_return_val_if_fail (PANEL_IS_APPLET (applet), PANEL_APPLET_FLAGS_NONE);
292
return applet->priv->flags;
296
panel_applet_set_flags (PanelApplet *applet,
297
PanelAppletFlags flags)
299
g_return_if_fail (PANEL_IS_APPLET (applet));
301
if (applet->priv->prop_sack != NULL)
302
bonobo_pbclient_set_short (BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_FLAGS, flags, NULL);
304
applet->priv->flags = flags;
308
panel_applet_set_size_hints (PanelApplet *applet,
309
const int *size_hints,
313
CORBA_sequence_CORBA_long *seq;
314
CORBA_Environment env;
318
CORBA_exception_init (&env);
320
seq = CORBA_sequence_CORBA_long__alloc ();
321
seq->_length = seq->_maximum = n_elements;
322
seq->_release = CORBA_TRUE;
323
seq->_buffer = CORBA_sequence_CORBA_long_allocbuf (seq->_length);
325
for (i = 0; i < n_elements; i++)
326
seq->_buffer [i] = size_hints [i] + base_size;
328
any._type = TC_CORBA_sequence_CORBA_long;
329
any._release = CORBA_FALSE;
332
Bonobo_PropertyBag_setValue (BONOBO_OBJREF (applet->priv->prop_sack),
339
CORBA_exception_free (&env);
343
panel_applet_get_size (PanelApplet *applet)
345
g_return_val_if_fail (PANEL_IS_APPLET (applet), 0);
347
return applet->priv->size;
351
panel_applet_get_orient (PanelApplet *applet)
353
g_return_val_if_fail (PANEL_IS_APPLET (applet), 0);
355
return applet->priv->orient;
359
panel_applet_get_locked_down (PanelApplet *applet)
361
g_return_val_if_fail (PANEL_IS_APPLET (applet), FALSE);
363
return applet->priv->locked_down;
366
static Atom _net_wm_window_type = None;
367
static Atom _net_wm_window_type_dock = None;
368
static Atom _net_active_window = None;
371
panel_applet_init_atoms (Display *xdisplay)
373
if (_net_wm_window_type == None)
374
_net_wm_window_type = XInternAtom (xdisplay,
375
"_NET_WM_WINDOW_TYPE",
378
if (_net_wm_window_type_dock == None)
379
_net_wm_window_type_dock = XInternAtom (xdisplay,
380
"_NET_WM_WINDOW_TYPE_DOCK",
383
if (_net_active_window == None)
384
_net_active_window = XInternAtom (xdisplay,
385
"_NET_ACTIVE_WINDOW",
390
panel_applet_find_toplevel_dock_window (PanelApplet *applet,
395
Window root, parent, *child;
398
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (applet));
399
if (!gtk_widget_get_realized (toplevel))
402
xwin = GDK_WINDOW_XID (gtk_widget_get_window (toplevel));
405
parent = root = None;
410
gulong number_return, bytes_after_return;
413
XGetWindowProperty (xdisplay,
418
&type_return, &format_return,
423
if (type_return == XA_ATOM) {
424
window_type = *(Atom *) data_return;
429
if (window_type == _net_wm_window_type_dock)
433
if (!XQueryTree (xdisplay,
435
&root, &parent, &child,
436
(guint *) &num_children)) {
440
if (child && num_children > 0)
445
} while (xwin != None && xwin != root);
451
* 1) Gets the window id of the panel that contains the applet
452
* using XQueryTree and XGetWindowProperty to find an ancestor
453
* window with the _NET_WM_WINDOW_TYPE_DOCK window type.
454
* 2) Sends a _NET_ACTIVE_WINDOW message to get that panel focused
457
panel_applet_request_focus (PanelApplet *applet,
468
g_return_if_fail (PANEL_IS_APPLET (applet));
470
screen = gtk_widget_get_screen (GTK_WIDGET (applet));
471
root = gdk_screen_get_root_window (screen);
472
display = gdk_screen_get_display (screen);
474
xdisplay = GDK_DISPLAY_XDISPLAY (display);
475
xroot = GDK_WINDOW_XWINDOW (root);
477
panel_applet_init_atoms (xdisplay);
479
dock_xwindow = panel_applet_find_toplevel_dock_window (applet, xdisplay);
480
if (dock_xwindow == None)
483
xev.xclient.type = ClientMessage;
484
xev.xclient.serial = 0;
485
xev.xclient.send_event = True;
486
xev.xclient.window = dock_xwindow;
487
xev.xclient.message_type = _net_active_window;
488
xev.xclient.format = 32;
489
xev.xclient.data.l[0] = 1; /* requestor type; we're an app, I guess */
490
xev.xclient.data.l[1] = timestamp;
491
xev.xclient.data.l[2] = None; /* "currently active window", supposedly */
492
xev.xclient.data.l[3] = 0;
493
xev.xclient.data.l[4] = 0;
495
XSendEvent (xdisplay,
497
SubstructureRedirectMask | SubstructureNotifyMask,
502
panel_applet_setup_menu (PanelApplet *applet,
504
const BonoboUIVerb *verb_list,
507
BonoboUIComponent *popup_component;
509
g_return_if_fail (PANEL_IS_APPLET (applet));
510
g_return_if_fail (xml != NULL && verb_list != NULL);
512
popup_component = panel_applet_get_popup_component (applet);
514
bonobo_ui_component_set (popup_component, "/", "<popups/>", NULL);
516
bonobo_ui_component_set_translate (popup_component, "/popups", xml, NULL);
518
bonobo_ui_component_add_verb_list_with_data (popup_component, verb_list, user_data);
522
panel_applet_setup_menu_from_file (PanelApplet *applet,
523
const gchar *opt_datadir,
525
const gchar *opt_app_name,
526
const BonoboUIVerb *verb_list,
529
BonoboUIComponent *popup_component;
530
gchar *app_name = NULL;
532
g_return_if_fail (PANEL_IS_APPLET (applet));
533
g_return_if_fail (file != NULL && verb_list != NULL);
536
opt_datadir = PANEL_APPLET_DATADIR;
539
opt_app_name = app_name = g_strdup_printf ("%lu",
540
(unsigned long) getpid ());
542
popup_component = panel_applet_get_popup_component (applet);
544
bonobo_ui_util_set_ui (popup_component, opt_datadir, file, opt_app_name, NULL);
546
bonobo_ui_component_add_verb_list_with_data (popup_component, verb_list, user_data);
553
panel_applet_get_control (PanelApplet *applet)
555
g_return_val_if_fail (PANEL_IS_APPLET (applet), NULL);
557
return applet->priv->control;
561
panel_applet_get_popup_component (PanelApplet *applet)
563
g_return_val_if_fail (PANEL_IS_APPLET (applet), NULL);
565
return bonobo_control_get_popup_ui_component (applet->priv->control);
569
panel_applet_finalize (GObject *object)
571
PanelApplet *applet = PANEL_APPLET (object);
573
panel_applet_set_preferences_key (applet, NULL);
575
if (applet->priv->client)
576
g_object_unref (applet->priv->client);
577
applet->priv->client = NULL;
579
if (applet->priv->prop_sack)
580
bonobo_object_unref (
581
BONOBO_OBJECT (applet->priv->prop_sack));
582
applet->priv->prop_sack = NULL;
584
g_free (applet->priv->size_hints);
585
g_free (applet->priv->prefs_key);
586
g_free (applet->priv->background);
587
g_free (applet->priv->iid);
589
if (applet->priv->closure)
590
g_closure_unref (applet->priv->closure);
591
applet->priv->closure = NULL;
593
G_OBJECT_CLASS (panel_applet_parent_class)->finalize (object);
597
container_has_focusable_child (GtkContainer *container)
602
gboolean retval = FALSE;
604
list = gtk_container_get_children (container);
606
for (t = list; t; t = t->next) {
607
child = GTK_WIDGET (t->data);
608
if (gtk_widget_get_can_focus (child)) {
611
} else if (GTK_IS_CONTAINER (child)) {
612
retval = container_has_focusable_child (GTK_CONTAINER (child));
622
panel_applet_position_menu (GtkMenu *menu,
629
GtkAllocation allocation;
630
GtkRequisition requisition;
637
g_return_if_fail (PANEL_IS_APPLET (widget));
639
applet = PANEL_APPLET (widget);
641
screen = gtk_widget_get_screen (widget);
643
gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
645
gdk_window_get_origin (gtk_widget_get_window (widget),
647
gtk_widget_get_pointer (widget, &pointer_x, &pointer_y);
649
gtk_widget_get_allocation (widget, &allocation);
651
menu_x += allocation.x;
652
menu_y += allocation.y;
654
if (applet->priv->orient == PANEL_APPLET_ORIENT_UP ||
655
applet->priv->orient == PANEL_APPLET_ORIENT_DOWN) {
656
if (gtk_widget_get_direction (GTK_WIDGET (menu)) != GTK_TEXT_DIR_RTL) {
657
if (pointer_x < allocation.width &&
658
requisition.width < pointer_x)
659
menu_x += MIN (pointer_x,
660
allocation.width - requisition.width);
662
menu_x += allocation.width - requisition.width;
663
if (pointer_x > 0 && pointer_x < allocation.width &&
664
pointer_x < allocation.width - requisition.width) {
665
menu_x -= MIN (allocation.width - pointer_x,
666
allocation.width - requisition.width);
669
menu_x = MIN (menu_x, gdk_screen_get_width (screen) - requisition.width);
671
if (menu_y > gdk_screen_get_height (screen) / 2)
672
menu_y -= requisition.height;
674
menu_y += allocation.height;
676
if (pointer_y < allocation.height &&
677
requisition.height < pointer_y)
678
menu_y += MIN (pointer_y, allocation.height - requisition.height);
679
menu_y = MIN (menu_y, gdk_screen_get_height (screen) - requisition.height);
681
if (menu_x > gdk_screen_get_width (screen) / 2)
682
menu_x -= requisition.width;
684
menu_x += allocation.width;
694
panel_applet_can_focus (GtkWidget *widget)
697
* A PanelApplet widget can focus if it has a tooltip or it does
698
* not have any focusable children.
700
if (gtk_widget_get_has_tooltip (widget))
703
if (!PANEL_IS_APPLET (widget))
706
return !container_has_focusable_child (GTK_CONTAINER (widget));
710
panel_applet_button_press (GtkWidget *widget,
711
GdkEventButton *event)
713
PanelApplet *applet = PANEL_APPLET (widget);
715
if (!container_has_focusable_child (GTK_CONTAINER (applet))) {
716
if (!gtk_widget_has_focus (widget)) {
717
gtk_widget_set_can_focus (widget, TRUE);
718
gtk_widget_grab_focus (widget);
722
if (event->button == 1)
724
else if (event->button == 3) {
725
bonobo_control_do_popup_full (
726
applet->priv->control,
728
(GtkMenuPositionFunc) panel_applet_position_menu,
739
_panel_applet_popup_menu (PanelApplet *applet,
743
bonobo_control_do_popup_full (applet->priv->control, NULL, NULL,
744
(GtkMenuPositionFunc) panel_applet_position_menu,
745
applet, button, time);
750
panel_applet_popup_menu (PanelApplet *applet)
752
return _panel_applet_popup_menu (applet, 3, GDK_CURRENT_TIME);
756
panel_applet_size_request (GtkWidget *widget, GtkRequisition *requisition)
760
GTK_WIDGET_CLASS (panel_applet_parent_class)->size_request (widget,
763
if (!panel_applet_can_focus (widget))
767
* We are deliberately ignoring focus-padding here to
768
* save valuable panel real estate.
770
gtk_widget_style_get (widget,
771
"focus-line-width", &focus_width,
774
requisition->width += 2 * focus_width;
775
requisition->height += 2 * focus_width;
779
panel_applet_size_allocate (GtkWidget *widget,
780
GtkAllocation *allocation)
782
GtkAllocation child_allocation;
789
if (!panel_applet_can_focus (widget)) {
790
GTK_WIDGET_CLASS (panel_applet_parent_class)->size_allocate (widget, allocation);
793
* We are deliberately ignoring focus-padding here to
794
* save valuable panel real estate.
796
gtk_widget_style_get (widget,
797
"focus-line-width", &focus_width,
800
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
802
gtk_widget_set_allocation (widget, allocation);
803
bin = GTK_BIN (widget);
805
child_allocation.x = focus_width;
806
child_allocation.y = focus_width;
808
child_allocation.width = MAX (allocation->width - border_width * 2, 0);
809
child_allocation.height = MAX (allocation->height - border_width * 2, 0);
811
if (gtk_widget_get_realized (widget))
812
gdk_window_move_resize (gtk_widget_get_window (widget),
813
allocation->x + border_width,
814
allocation->y + border_width,
815
child_allocation.width,
816
child_allocation.height);
818
child_allocation.width = MAX (child_allocation.width - 2 * focus_width, 0);
819
child_allocation.height = MAX (child_allocation.height - 2 * focus_width, 0);
821
child = gtk_bin_get_child (bin);
823
gtk_widget_size_allocate (child, &child_allocation);
826
applet = PANEL_APPLET (widget);
828
if (applet->priv->previous_height != allocation->height ||
829
applet->priv->previous_width != allocation->width) {
830
applet->priv->previous_height = allocation->height;
831
applet->priv->previous_width = allocation->width;
833
panel_applet_handle_background (applet);
838
panel_applet_expose (GtkWidget *widget,
839
GdkEventExpose *event)
841
GtkAllocation allocation;
844
int x, y, width, height;
846
g_return_val_if_fail (PANEL_IS_APPLET (widget), FALSE);
847
g_return_val_if_fail (event != NULL, FALSE);
849
GTK_WIDGET_CLASS (panel_applet_parent_class)->expose_event (widget,
852
if (!gtk_widget_has_focus (widget))
855
gtk_widget_get_allocation (widget, &allocation);
858
* We are deliberately ignoring focus-padding here to
859
* save valuable panel real estate.
861
gtk_widget_style_get (widget,
862
"focus-line-width", &focus_width,
865
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
870
width = allocation.width - 2 * border_width;
871
height = allocation.height - 2 * border_width;
873
gtk_paint_focus (gtk_widget_get_style (widget),
874
gtk_widget_get_window (widget),
875
gtk_widget_get_state (widget),
876
&event->area, widget, "panel_applet",
877
x, y, width, height);
883
panel_applet_focus (GtkWidget *widget,
884
GtkDirectionType dir)
887
GtkWidget *previous_focus_child;
890
g_return_val_if_fail (PANEL_IS_APPLET (widget), FALSE);
892
applet = PANEL_APPLET (widget);
893
if (applet->priv->moving_focus_out) {
895
* Applet will retain focus if there is nothing else on the
898
applet->priv->moving_focus_out = FALSE;
902
previous_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
903
if (!previous_focus_child && !gtk_widget_has_focus (widget)) {
904
if (gtk_widget_get_has_tooltip (widget)) {
905
gtk_widget_set_can_focus (widget, TRUE);
906
gtk_widget_grab_focus (widget);
907
gtk_widget_set_can_focus (widget, FALSE);
911
ret = GTK_WIDGET_CLASS (panel_applet_parent_class)->focus (widget, dir);
913
if (!ret && !previous_focus_child) {
914
if (!gtk_widget_has_focus (widget)) {
916
* Applet does not have a widget which can focus so set
917
* the focus on the applet unless it already had focus
918
* because it had a tooltip.
920
gtk_widget_set_can_focus (widget, TRUE);
921
gtk_widget_grab_focus (widget);
922
gtk_widget_set_can_focus (widget, FALSE);
931
panel_applet_parse_color (const gchar *color_str,
936
g_assert (color_str && color);
938
if (sscanf (color_str, "%4x%4x%4x", &r, &g, &b) != 3)
949
panel_applet_parse_pixmap_str (const char *str,
950
GdkNativeWindow *xid,
957
g_return_val_if_fail (str != NULL, FALSE);
958
g_return_val_if_fail (xid != NULL, FALSE);
959
g_return_val_if_fail (x != NULL, FALSE);
960
g_return_val_if_fail (y != NULL, FALSE);
962
elements = g_strsplit (str, ",", -1);
967
if (!elements [0] || !*elements [0] ||
968
!elements [1] || !*elements [1] ||
969
!elements [2] || !*elements [2])
972
*xid = strtol (elements [0], &tmp, 10);
973
if (tmp == elements [0])
976
*x = strtol (elements [1], &tmp, 10);
977
if (tmp == elements [1])
980
*y = strtol (elements [2], &tmp, 10);
981
if (tmp == elements [2])
984
g_strfreev (elements);
988
g_strfreev (elements);
993
panel_applet_get_pixmap (PanelApplet *applet,
998
gboolean display_grabbed;
1000
GdkDisplay *display;
1006
cairo_pattern_t *pattern;
1008
g_return_val_if_fail (PANEL_IS_APPLET (applet), NULL);
1010
if (!gtk_widget_get_realized (GTK_WIDGET (applet)))
1013
display = gdk_display_get_default ();
1014
display_grabbed = FALSE;
1016
window = gtk_widget_get_window (GTK_WIDGET (applet));
1018
pixmap = gdk_pixmap_lookup_for_display (display, xid);
1020
g_object_ref (pixmap);
1022
display_grabbed = TRUE;
1023
gdk_x11_display_grab (display);
1024
pixmap = gdk_pixmap_foreign_new_for_display (display, xid);
1027
/* This can happen if the user changes the background very fast.
1028
* We'll get the next update, so it's not a big deal. */
1029
if (pixmap == NULL) {
1030
if (display_grabbed)
1031
gdk_x11_display_ungrab (display);
1035
gdk_drawable_get_size (GDK_DRAWABLE (window),
1037
retval = gdk_pixmap_new (window,
1040
/* the pixmap has no colormap, and we need one */
1041
gdk_drawable_set_colormap (GDK_DRAWABLE (pixmap),
1042
gdk_drawable_get_colormap (window));
1044
cr = gdk_cairo_create (GDK_DRAWABLE (retval));
1045
gdk_cairo_set_source_pixmap (cr, pixmap, -x, -y);
1046
pattern = cairo_get_source (cr);
1047
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
1049
cairo_rectangle (cr, 0, 0, width, height);
1054
g_object_unref (pixmap);
1056
if (display_grabbed)
1057
gdk_x11_display_ungrab (display);
1062
static PanelAppletBackgroundType
1063
panel_applet_handle_background_string (PanelApplet *applet,
1067
PanelAppletBackgroundType retval;
1070
retval = PANEL_NO_BACKGROUND;
1072
if (!gtk_widget_get_realized (GTK_WIDGET (applet)) || !applet->priv->background)
1075
elements = g_strsplit (applet->priv->background, ":", -1);
1077
if (elements [0] && !strcmp (elements [0], "none" )) {
1078
retval = PANEL_NO_BACKGROUND;
1080
} else if (elements [0] && !strcmp (elements [0], "color")) {
1081
g_return_val_if_fail (color != NULL, PANEL_NO_BACKGROUND);
1083
if (!elements [1] || !panel_applet_parse_color (elements [1], color)) {
1085
g_warning ("Incomplete '%s' background type received", elements [0]);
1086
g_strfreev (elements);
1087
return PANEL_NO_BACKGROUND;
1090
retval = PANEL_COLOR_BACKGROUND;
1092
} else if (elements [0] && !strcmp (elements [0], "pixmap")) {
1093
GdkNativeWindow pixmap_id;
1096
g_return_val_if_fail (pixmap != NULL, PANEL_NO_BACKGROUND);
1098
if (!panel_applet_parse_pixmap_str (elements [1], &pixmap_id, &x, &y)) {
1099
g_warning ("Incomplete '%s' background type received: %s",
1100
elements [0], elements [1]);
1102
g_strfreev (elements);
1103
return PANEL_NO_BACKGROUND;
1106
*pixmap = panel_applet_get_pixmap (applet, pixmap_id, x, y);
1108
g_warning ("Failed to get pixmap %s", elements [1]);
1109
g_strfreev (elements);
1110
return PANEL_NO_BACKGROUND;
1113
retval = PANEL_PIXMAP_BACKGROUND;
1115
g_warning ("Unknown background type received");
1117
g_strfreev (elements);
1122
PanelAppletBackgroundType
1123
panel_applet_get_background (PanelApplet *applet,
1127
g_return_val_if_fail (PANEL_IS_APPLET (applet), PANEL_NO_BACKGROUND);
1129
/* initial sanity */
1133
memset (color, 0, sizeof (GdkColor));
1135
return panel_applet_handle_background_string (applet, color, pixmap);
1139
panel_applet_get_prop (BonoboPropertyBag *sack,
1142
CORBA_Environment *ev,
1145
PanelApplet *applet = PANEL_APPLET (user_data);
1148
case PROPERTY_ORIENT_IDX:
1149
BONOBO_ARG_SET_SHORT (arg, applet->priv->orient);
1151
case PROPERTY_SIZE_IDX:
1152
BONOBO_ARG_SET_SHORT (arg, applet->priv->size);
1154
case PROPERTY_BACKGROUND_IDX:
1155
BONOBO_ARG_SET_STRING (arg, applet->priv->background);
1157
case PROPERTY_FLAGS_IDX:
1158
BONOBO_ARG_SET_SHORT (arg, applet->priv->flags);
1160
case PROPERTY_SIZE_HINTS_IDX: {
1161
CORBA_sequence_CORBA_long *seq;
1166
seq->_length = seq->_maximum = applet->priv->size_hints_len;
1167
seq->_buffer = CORBA_sequence_CORBA_long_allocbuf (seq->_length);
1168
seq->_release = CORBA_TRUE;
1170
for (i = 0; i < applet->priv->size_hints_len; i++)
1171
seq->_buffer [i] = applet->priv->size_hints [i];
1174
case PROPERTY_LOCKED_DOWN_IDX:
1175
BONOBO_ARG_SET_BOOLEAN (arg, applet->priv->locked_down);
1178
g_assert_not_reached ();
1184
panel_applet_update_background_for_widget (GtkWidget *widget,
1185
PanelAppletBackgroundType type,
1189
GtkRcStyle *rc_style;
1193
gtk_widget_set_style (widget, NULL);
1194
rc_style = gtk_rc_style_new ();
1195
gtk_widget_modify_style (widget, rc_style);
1196
g_object_unref (rc_style);
1199
case PANEL_NO_BACKGROUND:
1201
case PANEL_COLOR_BACKGROUND:
1202
gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, color);
1204
case PANEL_PIXMAP_BACKGROUND:
1205
style = gtk_style_copy (gtk_widget_get_style (widget));
1206
if (style->bg_pixmap[GTK_STATE_NORMAL])
1207
g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]);
1208
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (pixmap);
1209
gtk_widget_set_style (widget, style);
1210
g_object_unref (style);
1213
g_assert_not_reached ();
1219
panel_applet_handle_background (PanelApplet *applet)
1221
PanelAppletBackgroundType type;
1225
type = panel_applet_get_background (applet, &color, &pixmap);
1227
if (applet->priv->background_widget)
1228
panel_applet_update_background_for_widget (applet->priv->background_widget,
1229
type, &color, pixmap);
1232
case PANEL_NO_BACKGROUND:
1233
g_signal_emit (G_OBJECT (applet),
1234
panel_applet_signals [CHANGE_BACKGROUND],
1235
0, PANEL_NO_BACKGROUND, NULL, NULL);
1237
case PANEL_COLOR_BACKGROUND:
1238
g_signal_emit (G_OBJECT (applet),
1239
panel_applet_signals [CHANGE_BACKGROUND],
1240
0, PANEL_COLOR_BACKGROUND, &color, NULL);
1242
case PANEL_PIXMAP_BACKGROUND:
1243
g_signal_emit (G_OBJECT (applet),
1244
panel_applet_signals [CHANGE_BACKGROUND],
1245
0, PANEL_PIXMAP_BACKGROUND, NULL, pixmap);
1247
g_object_unref (pixmap);
1250
g_assert_not_reached ();
1256
panel_applet_set_prop (BonoboPropertyBag *sack,
1257
const BonoboArg *arg,
1259
CORBA_Environment *ev,
1262
PanelApplet *applet = PANEL_APPLET (user_data);
1265
case PROPERTY_ORIENT_IDX: {
1266
PanelAppletOrient orient;
1268
orient = BONOBO_ARG_GET_SHORT (arg);
1270
if (applet->priv->orient != orient) {
1271
applet->priv->orient = orient;
1273
g_signal_emit (G_OBJECT (applet),
1274
panel_applet_signals [CHANGE_ORIENT],
1279
case PROPERTY_SIZE_IDX: {
1282
size = BONOBO_ARG_GET_SHORT (arg);
1284
if (applet->priv->size != size) {
1285
applet->priv->size = size;
1287
g_signal_emit (G_OBJECT (applet),
1288
panel_applet_signals [CHANGE_SIZE],
1293
case PROPERTY_BACKGROUND_IDX:
1294
if (applet->priv->background)
1295
g_free (applet->priv->background);
1297
applet->priv->background = g_strdup (BONOBO_ARG_GET_STRING (arg));
1299
panel_applet_handle_background (applet);
1301
case PROPERTY_FLAGS_IDX:
1302
applet->priv->flags = BONOBO_ARG_GET_SHORT (arg);
1304
case PROPERTY_SIZE_HINTS_IDX: {
1305
CORBA_sequence_CORBA_long *seq = arg->_value;
1308
applet->priv->size_hints = g_realloc (applet->priv->size_hints,
1309
seq->_length * sizeof (int));
1310
for (i = 0; i < seq->_length; i++)
1311
applet->priv->size_hints [i] = seq->_buffer [i];
1313
applet->priv->size_hints_len = seq->_length;;
1316
case PROPERTY_LOCKED_DOWN_IDX:
1317
applet->priv->locked_down = BONOBO_ARG_GET_BOOLEAN (arg);
1320
g_assert_not_reached ();
1325
static BonoboPropertyBag *
1326
panel_applet_property_bag (PanelApplet *applet)
1328
BonoboPropertyBag *sack;
1330
sack = bonobo_property_bag_new (panel_applet_get_prop,
1331
panel_applet_set_prop,
1334
bonobo_property_bag_add (sack,
1336
PROPERTY_ORIENT_IDX,
1339
"The Applet's containing Panel's orientation",
1340
Bonobo_PROPERTY_READABLE | Bonobo_PROPERTY_WRITEABLE);
1342
bonobo_property_bag_add (sack,
1347
"The Applet's containing Panel's size in pixels",
1348
Bonobo_PROPERTY_READABLE | Bonobo_PROPERTY_WRITEABLE);
1350
bonobo_property_bag_add (sack,
1351
PROPERTY_BACKGROUND,
1352
PROPERTY_BACKGROUND_IDX,
1355
"The Applet's containing Panel's background color or pixmap",
1356
Bonobo_PROPERTY_READABLE | Bonobo_PROPERTY_WRITEABLE);
1358
bonobo_property_bag_add (sack,
1363
"The Applet's flags",
1364
Bonobo_PROPERTY_READABLE);
1366
bonobo_property_bag_add (sack,
1367
PROPERTY_SIZE_HINTS,
1368
PROPERTY_SIZE_HINTS_IDX,
1369
TC_CORBA_sequence_CORBA_long,
1371
"Ranges that hint what sizes are acceptable for the applet",
1372
Bonobo_PROPERTY_READABLE);
1374
bonobo_property_bag_add (sack,
1375
PROPERTY_LOCKED_DOWN,
1376
PROPERTY_LOCKED_DOWN_IDX,
1379
"The Applet's containing Panel is locked down",
1380
Bonobo_PROPERTY_READABLE | Bonobo_PROPERTY_WRITEABLE);
1386
panel_applet_realize (GtkWidget *widget)
1388
GTK_WIDGET_CLASS (panel_applet_parent_class)->realize (widget);
1390
if (PANEL_APPLET (widget)->priv->background)
1391
panel_applet_handle_background (PANEL_APPLET (widget));
1395
panel_applet_control_bound (BonoboControl *control,
1396
PanelApplet *applet)
1400
g_return_if_fail (PANEL_IS_APPLET (applet));
1401
g_return_if_fail (applet->priv->iid != NULL &&
1402
applet->priv->closure != NULL);
1404
if (applet->priv->bound)
1407
bonobo_closure_invoke (applet->priv->closure,
1408
G_TYPE_BOOLEAN, &ret,
1409
PANEL_TYPE_APPLET, applet,
1410
G_TYPE_STRING, applet->priv->iid,
1414
if (!ret) { /* FIXME */
1415
g_warning ("need to free the control here");
1420
applet->priv->bound = TRUE;
1423
static Bonobo_Unknown
1424
panel_applet_item_handler_get_object (BonoboItemHandler *handler,
1425
const char *item_name,
1426
gboolean only_if_exists,
1428
CORBA_Environment *ev)
1430
PanelApplet *applet = user_data;
1434
g_return_val_if_fail (PANEL_IS_APPLET (applet), CORBA_OBJECT_NIL);
1436
options = bonobo_item_option_parse (item_name);
1438
for (l = options; l; l = l->next) {
1439
BonoboItemOption *option = l->data;
1441
if (!option->value || !option->value [0])
1444
if (!strcmp (option->key, "prefs_key") && !applet->priv->prefs_key)
1445
panel_applet_set_preferences_key (applet, option->value);
1447
else if (!strcmp (option->key, "background"))
1448
bonobo_pbclient_set_string (BONOBO_OBJREF (applet->priv->prop_sack),
1449
PROPERTY_BACKGROUND, option->value, NULL);
1451
else if (!strcmp (option->key, "orient")) {
1452
if (!strcmp (option->value, "up"))
1453
bonobo_pbclient_set_short (
1454
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_ORIENT,
1455
PANEL_APPLET_ORIENT_UP, NULL);
1457
else if (!strcmp (option->value, "down"))
1458
bonobo_pbclient_set_short (
1459
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_ORIENT,
1460
PANEL_APPLET_ORIENT_DOWN, NULL);
1462
else if (!strcmp (option->value, "left"))
1463
bonobo_pbclient_set_short (
1464
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_ORIENT,
1465
PANEL_APPLET_ORIENT_LEFT, NULL);
1467
else if (!strcmp (option->value, "right"))
1468
bonobo_pbclient_set_short (
1469
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_ORIENT,
1470
PANEL_APPLET_ORIENT_RIGHT, NULL);
1472
} else if (!strcmp (option->key, "size")) {
1473
if (!strcmp (option->value, "xx-small"))
1474
bonobo_pbclient_set_short (
1475
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1476
GNOME_Vertigo_PANEL_XX_SMALL, NULL);
1478
else if (!strcmp (option->value, "x-small"))
1479
bonobo_pbclient_set_short (
1480
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1481
GNOME_Vertigo_PANEL_X_SMALL, NULL);
1483
else if (!strcmp (option->value, "small"))
1484
bonobo_pbclient_set_short (
1485
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1486
GNOME_Vertigo_PANEL_SMALL, NULL);
1488
else if (!strcmp (option->value, "medium"))
1489
bonobo_pbclient_set_short (
1490
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1491
GNOME_Vertigo_PANEL_MEDIUM, NULL);
1493
else if (!strcmp (option->value, "large"))
1494
bonobo_pbclient_set_short (
1495
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1496
GNOME_Vertigo_PANEL_LARGE, NULL);
1498
else if (!strcmp (option->value, "x-large"))
1499
bonobo_pbclient_set_short (
1500
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1501
GNOME_Vertigo_PANEL_X_LARGE, NULL);
1503
else if (!strcmp (option->value, "xx-large"))
1504
bonobo_pbclient_set_short (
1505
BONOBO_OBJREF (applet->priv->prop_sack), PROPERTY_SIZE,
1506
GNOME_Vertigo_PANEL_XX_LARGE, NULL);
1507
} else if (!strcmp (option->key, "locked_down")) {
1508
gboolean val = FALSE;
1509
if (option->value[0] == 'T' ||
1510
option->value[0] == 't' ||
1511
option->value[0] == 'Y' ||
1512
option->value[0] == 'y' ||
1513
atoi (option->value) != 0)
1515
bonobo_pbclient_set_boolean (BONOBO_OBJREF (applet->priv->prop_sack),
1516
PROPERTY_LOCKED_DOWN, val, NULL);
1520
bonobo_item_options_free (options);
1522
return bonobo_object_dup_ref (BONOBO_OBJREF (applet->priv->control), ev);
1526
panel_applet_move_focus_out_of_applet (PanelApplet *applet,
1527
GtkDirectionType dir)
1529
GtkWidget *toplevel;
1531
applet->priv->moving_focus_out = TRUE;
1532
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (applet));
1533
g_return_if_fail (toplevel);
1535
gtk_widget_child_focus (toplevel, dir);
1536
applet->priv->moving_focus_out = FALSE;
1540
add_tab_bindings (GtkBindingSet *binding_set,
1541
GdkModifierType modifiers,
1542
GtkDirectionType direction)
1544
gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
1545
"move_focus_out_of_applet", 1,
1546
GTK_TYPE_DIRECTION_TYPE, direction);
1547
gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
1548
"move_focus_out_of_applet", 1,
1549
GTK_TYPE_DIRECTION_TYPE, direction);
1553
panel_applet_constructor (GType type,
1554
guint n_construct_properties,
1555
GObjectConstructParam *construct_properties)
1558
PanelApplet *applet;
1560
obj = G_OBJECT_CLASS (panel_applet_parent_class)->constructor (type,
1561
n_construct_properties,
1562
construct_properties);
1564
applet = PANEL_APPLET (obj);
1566
panel_applet_setup (applet);
1572
panel_applet_class_init (PanelAppletClass *klass)
1574
GObjectClass *gobject_class = (GObjectClass *) klass;
1575
GtkObjectClass *object_class = (GtkObjectClass *) klass;
1576
GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
1577
GtkBindingSet *binding_set;
1579
gobject_class->constructor = panel_applet_constructor;
1580
klass->move_focus_out_of_applet = panel_applet_move_focus_out_of_applet;
1582
widget_class->button_press_event = panel_applet_button_press;
1583
widget_class->size_request = panel_applet_size_request;
1584
widget_class->size_allocate = panel_applet_size_allocate;
1585
widget_class->expose_event = panel_applet_expose;
1586
widget_class->focus = panel_applet_focus;
1587
widget_class->realize = panel_applet_realize;
1589
gobject_class->finalize = panel_applet_finalize;
1591
g_type_class_add_private (klass, sizeof (PanelAppletPrivate));
1593
panel_applet_signals [CHANGE_ORIENT] =
1594
g_signal_new ("change_orient",
1595
G_TYPE_FROM_CLASS (klass),
1597
G_STRUCT_OFFSET (PanelAppletClass, change_orient),
1600
panel_applet_marshal_VOID__UINT,
1605
panel_applet_signals [CHANGE_SIZE] =
1606
g_signal_new ("change_size",
1607
G_TYPE_FROM_CLASS (klass),
1609
G_STRUCT_OFFSET (PanelAppletClass, change_size),
1612
panel_applet_marshal_VOID__INT,
1617
panel_applet_signals [CHANGE_BACKGROUND] =
1618
g_signal_new ("change_background",
1619
G_TYPE_FROM_CLASS (klass),
1621
G_STRUCT_OFFSET (PanelAppletClass, change_background),
1624
panel_applet_marshal_VOID__ENUM_BOXED_OBJECT,
1627
PANEL_TYPE_PANEL_APPLET_BACKGROUND_TYPE,
1631
panel_applet_signals [MOVE_FOCUS_OUT_OF_APPLET] =
1632
g_signal_new ("move_focus_out_of_applet",
1633
G_TYPE_FROM_CLASS (klass),
1634
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1635
G_STRUCT_OFFSET (PanelAppletClass, move_focus_out_of_applet),
1638
panel_applet_marshal_VOID__ENUM,
1641
GTK_TYPE_DIRECTION_TYPE);
1643
binding_set = gtk_binding_set_by_class (object_class);
1644
add_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
1645
add_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
1646
add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
1647
add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
1651
panel_applet_init (PanelApplet *applet)
1653
applet->priv = PANEL_APPLET_GET_PRIVATE (applet);
1655
applet->priv->client = gconf_client_get_default ();
1657
applet->priv->bound = FALSE;
1658
applet->priv->flags = PANEL_APPLET_FLAGS_NONE;
1659
applet->priv->orient = PANEL_APPLET_ORIENT_UP;
1660
applet->priv->size = GNOME_Vertigo_PANEL_MEDIUM;
1662
applet->priv->moving_focus_out = FALSE;
1664
gtk_widget_set_events (GTK_WIDGET (applet),
1665
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
1669
panel_applet_setup (PanelApplet *applet)
1671
PanelAppletPrivate *priv;
1673
priv = applet->priv;
1675
priv->control = bonobo_control_new (GTK_WIDGET (applet));
1677
g_signal_connect (priv->control, "set_frame",
1678
G_CALLBACK (panel_applet_control_bound),
1681
priv->prop_sack = panel_applet_property_bag (applet);
1683
bonobo_control_set_properties (
1684
priv->control, BONOBO_OBJREF (priv->prop_sack), NULL);
1686
priv->shell = panel_applet_shell_new (applet);
1688
bonobo_object_add_interface (BONOBO_OBJECT (priv->control),
1689
BONOBO_OBJECT (priv->shell));
1691
priv->item_handler =
1692
bonobo_item_handler_new (
1693
NULL, panel_applet_item_handler_get_object, applet);
1695
bonobo_object_add_interface (BONOBO_OBJECT (priv->control),
1696
BONOBO_OBJECT (priv->item_handler));
1698
g_signal_connect (applet, "popup_menu",
1699
G_CALLBACK (panel_applet_popup_menu), NULL);
1703
panel_applet_new (void)
1705
PanelApplet *applet;
1707
applet = g_object_new (PANEL_TYPE_APPLET, NULL);
1709
return GTK_WIDGET (applet);
1715
} PanelAppletCallBackData;
1717
static PanelAppletCallBackData *
1718
panel_applet_callback_data_new (GType applet_type,
1721
PanelAppletCallBackData *retval;
1723
retval = g_new0 (PanelAppletCallBackData, 1);
1725
retval->applet_type = applet_type;
1726
retval->closure = closure;
1732
panel_applet_callback_data_free (PanelAppletCallBackData *data)
1734
g_closure_unref (data->closure);
1738
static BonoboObject *
1739
panel_applet_factory_callback (BonoboGenericFactory *factory,
1741
PanelAppletCallBackData *data)
1743
PanelApplet *applet;
1745
applet = g_object_new (data->applet_type, NULL);
1747
applet->priv->iid = g_strdup (iid);
1748
applet->priv->closure = g_closure_ref (data->closure);
1750
bonobo_control_life_instrument (applet->priv->control);
1752
return BONOBO_OBJECT (applet->priv->control);
1756
panel_applet_all_controls_dead (void)
1758
if (!bonobo_control_life_get_count())
1759
bonobo_main_quit ();
1763
panel_applet_factory_main_closure (const gchar *iid,
1769
PanelAppletCallBackData *data;
1771
g_return_val_if_fail (iid != NULL, 1);
1772
g_return_val_if_fail (closure != NULL, 1);
1774
g_assert (g_type_is_a (applet_type, PANEL_TYPE_APPLET));
1776
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
1777
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1779
bonobo_control_life_set_callback (panel_applet_all_controls_dead);
1781
closure = bonobo_closure_store (closure, panel_applet_marshal_BOOLEAN__STRING);
1783
data = panel_applet_callback_data_new (applet_type, closure);
1785
display_iid = bonobo_activation_make_registration_id (
1786
iid, DisplayString (gdk_display_get_default ()));
1787
retval = bonobo_generic_factory_main (
1789
(BonoboFactoryCallback) panel_applet_factory_callback,
1791
g_free (display_iid);
1793
panel_applet_callback_data_free (data);
1799
panel_applet_factory_main (const gchar *iid,
1801
PanelAppletFactoryCallback callback,
1806
g_return_val_if_fail (iid != NULL, 1);
1807
g_return_val_if_fail (callback != NULL, 1);
1809
closure = g_cclosure_new (G_CALLBACK (callback), data, NULL);
1811
return panel_applet_factory_main_closure (iid, applet_type, closure);
1815
panel_applet_shlib_factory_closure (const char *iid,
1817
PortableServer_POA poa,
1820
CORBA_Environment *ev)
1822
BonoboShlibFactory *factory;
1824
g_return_val_if_fail (iid != NULL, CORBA_OBJECT_NIL);
1825
g_return_val_if_fail (closure != NULL, CORBA_OBJECT_NIL);
1827
g_assert (g_type_is_a (applet_type, PANEL_TYPE_APPLET));
1829
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
1830
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1832
closure = bonobo_closure_store (closure, panel_applet_marshal_BOOLEAN__STRING);
1834
factory = bonobo_shlib_factory_new_closure (
1836
g_cclosure_new (G_CALLBACK (panel_applet_factory_callback),
1837
panel_applet_callback_data_new (applet_type, closure),
1838
(GClosureNotify) panel_applet_callback_data_free));
1840
return CORBA_Object_duplicate (BONOBO_OBJREF (factory), ev);
1844
panel_applet_shlib_factory (const char *iid,
1846
PortableServer_POA poa,
1848
PanelAppletFactoryCallback callback,
1850
CORBA_Environment *ev)
1852
g_return_val_if_fail (iid != NULL, CORBA_OBJECT_NIL);
1853
g_return_val_if_fail (callback != NULL, CORBA_OBJECT_NIL);
1855
return panel_applet_shlib_factory_closure (
1856
iid, applet_type, poa, impl_ptr,
1857
g_cclosure_new (G_CALLBACK (callback),
1863
panel_applet_set_background_widget (PanelApplet *applet,
1866
applet->priv->background_widget = widget;
1869
PanelAppletBackgroundType type;
1873
type = panel_applet_get_background (applet, &color, &pixmap);
1874
panel_applet_update_background_for_widget (widget, type,
1876
if (type == PANEL_PIXMAP_BACKGROUND)
1877
g_object_unref (pixmap);
added
removed
bonobo/libpanel-applet/panel-applet.c
