← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-panel/oneiric

« back to all changes in this revision

Viewing changes to gnome-panel/panel-menu-bar-object.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-05-30 11:04:49 UTC
  • mfrom: (1.3.4 upstream)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: james.westby@ubuntu.com-20110530110449-ut1tc5t61rpvf9e3
Tags: upstream-3.0.2
Import upstream version 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-panel/panel-menu-bar-object.c
 
1
/*
 
2
 * panel-menu-bar-object.c: a base class for menu bar objects
 
3
 *
 
4
 * Copyright (C) 2003 Sun Microsystems, Inc.
 
5
 * Copyright (C) 2004 Vincent Untz
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU General Public License as
 
9
 * published by the Free Software Foundation; either version 2 of the
 
10
 * License, or (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful, but
 
13
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 
20
 * 02111-1307, USA.
 
21
 *
 
22
 * Authors:
 
23
 *      Mark McLoughlin <mark@skynet.ie>
 
24
 *      Vincent Untz <vincent@vuntz.net>
 
25
 */
 
26
 
 
27
#include <config.h>
 
28
 
 
29
#include "panel-background.h"
 
30
#include "panel-typebuiltins.h"
 
31
 
 
32
#include "panel-menu-bar-object.h"
 
33
 
 
34
G_DEFINE_TYPE (PanelMenuBarObject, panel_menu_bar_object, GTK_TYPE_MENU_BAR)
 
35
 
 
36
#define PANEL_MENU_BAR_OBJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), PANEL_TYPE_MENU_BAR_OBJECT, PanelMenuBarObjectPrivate))
 
37
 
 
38
struct _PanelMenuBarObjectPrivate {
 
39
        PanelWidget *panel;
 
40
 
 
41
        PanelOrientation orientation;
 
42
};
 
43
 
 
44
enum {
 
45
        PROP_0,
 
46
        PROP_ORIENTATION,
 
47
};
 
48
 
 
49
static void panel_menu_bar_object_update_text_gravity (PanelMenuBarObject *menubar);
 
50
static void panel_menu_bar_object_update_orientation (PanelMenuBarObject *menubar);
 
51
 
 
52
static void
 
53
panel_menu_bar_object_init (PanelMenuBarObject *menubar)
 
54
{
 
55
        GtkStyleContext *context;
 
56
        GtkCssProvider *provider;
 
57
 
 
58
        menubar->priv = PANEL_MENU_BAR_OBJECT_GET_PRIVATE (menubar);
 
59
 
 
60
        provider = gtk_css_provider_new ();
 
61
        gtk_css_provider_load_from_data (provider,
 
62
                                         "PanelMenuBarObject {\n"
 
63
                                         " border-width: 0px;\n"
 
64
                                         "}",
 
65
                                         -1, NULL);
 
66
        context = gtk_widget_get_style_context (GTK_WIDGET (menubar));
 
67
        gtk_style_context_add_provider (context,
 
68
                                        GTK_STYLE_PROVIDER (provider),
 
69
                                        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 
70
        g_object_unref (provider);
 
71
        gtk_style_context_add_class (context, "gnome-panel-menu-bar");
 
72
 
 
73
        menubar->priv->panel = NULL;
 
74
}
 
75
 
 
76
static void
 
77
panel_menu_bar_object_get_property (GObject     *object,
 
78
                                    guint        prop_id,
 
79
                                    GValue      *value,
 
80
                                    GParamSpec  *pspec)
 
81
{
 
82
        PanelMenuBarObject *menubar;
 
83
 
 
84
        g_return_if_fail (PANEL_IS_MENU_BAR_OBJECT (object));
 
85
 
 
86
        menubar = PANEL_MENU_BAR_OBJECT (object);
 
87
 
 
88
        switch (prop_id) {
 
89
        case PROP_ORIENTATION:
 
90
                g_value_set_enum (value, menubar->priv->orientation);
 
91
                break;
 
92
        default:
 
93
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
94
                break;
 
95
        }
 
96
}
 
97
 
 
98
static void
 
99
panel_menu_bar_object_set_property (GObject       *object,
 
100
                                    guint          prop_id,
 
101
                                    const GValue *value,
 
102
                                    GParamSpec    *pspec)
 
103
{
 
104
        PanelMenuBarObject *menubar;
 
105
 
 
106
        g_return_if_fail (PANEL_IS_MENU_BAR_OBJECT (object));
 
107
 
 
108
        menubar = PANEL_MENU_BAR_OBJECT (object);
 
109
 
 
110
        switch (prop_id) {
 
111
        case PROP_ORIENTATION:
 
112
                panel_menu_bar_object_set_orientation (menubar,
 
113
                                                       g_value_get_enum (value));
 
114
                break;
 
115
        default:
 
116
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
117
                break;
 
118
        }
 
119
}
 
120
 
 
121
static void
 
122
panel_menu_bar_object_size_allocate (GtkWidget     *widget,
 
123
                                     GtkAllocation *allocation)
 
124
{
 
125
        GtkAllocation    old_allocation;
 
126
        GtkAllocation    widget_allocation;
 
127
        PanelBackground *background;
 
128
 
 
129
        gtk_widget_get_allocation (widget, &widget_allocation);
 
130
 
 
131
        old_allocation.x      = widget_allocation.x;
 
132
        old_allocation.y      = widget_allocation.y;
 
133
        old_allocation.width  = widget_allocation.width;
 
134
        old_allocation.height = widget_allocation.height;
 
135
 
 
136
        GTK_WIDGET_CLASS (panel_menu_bar_object_parent_class)->size_allocate (widget, allocation);
 
137
 
 
138
        if (old_allocation.x      == allocation->x &&
 
139
            old_allocation.y      == allocation->y &&
 
140
            old_allocation.width  == allocation->width &&
 
141
            old_allocation.height == allocation->height)
 
142
                return;
 
143
 
 
144
        background = &PANEL_MENU_BAR_OBJECT (widget)->priv->panel->background;
 
145
 
 
146
        if (background->type == PANEL_BACK_NONE ||
 
147
           (background->type == PANEL_BACK_COLOR && !background->has_alpha))
 
148
                return;
 
149
 
 
150
        panel_menu_bar_object_change_background (PANEL_MENU_BAR_OBJECT (widget));
 
151
}
 
152
 
 
153
static void
 
154
panel_menu_bar_object_class_init (PanelMenuBarObjectClass *klass)
 
155
{
 
156
        GObjectClass   *gobject_class = (GObjectClass   *) klass;
 
157
        GtkWidgetClass *widget_class  = (GtkWidgetClass *) klass;
 
158
 
 
159
        gobject_class->get_property = panel_menu_bar_object_get_property;
 
160
        gobject_class->set_property = panel_menu_bar_object_set_property;
 
161
 
 
162
        widget_class->size_allocate = panel_menu_bar_object_size_allocate;
 
163
 
 
164
        g_type_class_add_private (klass, sizeof (PanelMenuBarObjectPrivate));
 
165
 
 
166
        g_object_class_install_property (
 
167
                gobject_class,
 
168
                PROP_ORIENTATION,
 
169
                g_param_spec_enum ("orientation",
 
170
                                   "Orientation",
 
171
                                   "The PanelMenuBarObject orientation",
 
172
                                   PANEL_TYPE_ORIENTATION,
 
173
                                   PANEL_ORIENTATION_TOP,
 
174
                                   G_PARAM_READWRITE));
 
175
}
 
176
 
 
177
static gboolean
 
178
panel_menu_bar_object_on_draw (GtkWidget *widget,
 
179
                               cairo_t   *cr,
 
180
                               gpointer   data)
 
181
{
 
182
        PanelMenuBarObject *menubar = data;
 
183
 
 
184
        if (gtk_widget_has_focus (GTK_WIDGET (menubar))) {
 
185
                GtkStyleContext *context;
 
186
 
 
187
                context = gtk_widget_get_style_context (widget);
 
188
                gtk_style_context_save (context);
 
189
                gtk_style_context_set_state (context,
 
190
                                             gtk_widget_get_state_flags (widget));
 
191
 
 
192
                cairo_save (cr);
 
193
                gtk_render_focus (context, cr,
 
194
                                  0, 0,
 
195
                                  gtk_widget_get_allocated_width (widget),
 
196
                                  gtk_widget_get_allocated_height (widget));
 
197
                cairo_restore (cr);
 
198
 
 
199
                gtk_style_context_restore (context);
 
200
        }
 
201
 
 
202
        return FALSE;
 
203
}
 
204
 
 
205
void
 
206
panel_menu_bar_object_object_load_finish (PanelMenuBarObject *menubar,
 
207
                                          PanelWidget        *panel)
 
208
{
 
209
        menubar->priv->panel = panel;
 
210
 
 
211
        /* we didn't do this on "applet-added" since we didn't have the panel yet */
 
212
        panel_menu_bar_object_change_background (menubar);
 
213
        panel_menu_bar_object_update_orientation (menubar);
 
214
        panel_menu_bar_object_update_text_gravity (menubar);
 
215
 
 
216
        g_signal_connect (menubar, "screen-changed",
 
217
                          G_CALLBACK (panel_menu_bar_object_update_text_gravity),
 
218
                          NULL);
 
219
 
 
220
        g_signal_connect_after (menubar, "focus-in-event",
 
221
                                G_CALLBACK (gtk_widget_queue_draw), menubar);
 
222
        g_signal_connect_after (menubar, "focus-out-event",
 
223
                                G_CALLBACK (gtk_widget_queue_draw), menubar);
 
224
        g_signal_connect_after (menubar, "draw",
 
225
                                G_CALLBACK (panel_menu_bar_object_on_draw), menubar);
 
226
        gtk_widget_set_can_focus (GTK_WIDGET (menubar), TRUE);
 
227
 
 
228
        panel_widget_set_applet_expandable (panel, GTK_WIDGET (menubar), FALSE, TRUE);
 
229
}
 
230
 
 
231
void
 
232
panel_menu_bar_object_change_background (PanelMenuBarObject *menubar)
 
233
{
 
234
        if (!menubar->priv->panel)
 
235
                return;
 
236
 
 
237
        panel_background_change_background_on_widget (&menubar->priv->panel->background,
 
238
                                                      GTK_WIDGET (menubar));
 
239
}
 
240
 
 
241
static void
 
242
set_item_text_gravity (GtkWidget *item)
 
243
{
 
244
        GtkWidget    *label;
 
245
        PangoLayout  *layout;
 
246
        PangoContext *context;
 
247
 
 
248
        label = gtk_bin_get_child (GTK_BIN (item));
 
249
        layout = gtk_label_get_layout (GTK_LABEL (label));
 
250
        context = pango_layout_get_context (layout);
 
251
        pango_context_set_base_gravity (context, PANGO_GRAVITY_AUTO);
 
252
}
 
253
 
 
254
static void
 
255
panel_menu_bar_object_update_text_gravity (PanelMenuBarObject *menubar)
 
256
{
 
257
        GList *children, *l;
 
258
 
 
259
        children = gtk_container_get_children (GTK_CONTAINER (menubar));
 
260
        for (l = children; l != NULL; l = l->next)
 
261
                set_item_text_gravity (GTK_WIDGET (l->data));
 
262
        g_list_free (children);
 
263
}
 
264
 
 
265
static void
 
266
set_item_text_angle_and_alignment (GtkWidget *item,
 
267
                                   double     text_angle,
 
268
                                   float      xalign,
 
269
                                   float      yalign)
 
270
{
 
271
        GtkWidget *label;
 
272
 
 
273
        label = gtk_bin_get_child (GTK_BIN (item));
 
274
 
 
275
        gtk_label_set_angle (GTK_LABEL (label), text_angle);
 
276
 
 
277
        gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
 
278
}
 
279
 
 
280
static void
 
281
panel_menu_bar_object_update_orientation (PanelMenuBarObject *menubar)
 
282
{
 
283
        GtkPackDirection pack_direction;
 
284
        double           text_angle;
 
285
        float            text_xalign;
 
286
        float            text_yalign;
 
287
        GList           *children, *l;
 
288
 
 
289
        pack_direction = GTK_PACK_DIRECTION_LTR;
 
290
        text_angle = 0.0;
 
291
        text_xalign = 0.0;
 
292
        text_yalign = 0.5;
 
293
 
 
294
        switch (menubar->priv->orientation) {
 
295
        case PANEL_ORIENTATION_TOP:
 
296
        case PANEL_ORIENTATION_BOTTOM:
 
297
                break;
 
298
        case PANEL_ORIENTATION_LEFT:
 
299
                pack_direction = GTK_PACK_DIRECTION_BTT;
 
300
                text_angle = 90.0;
 
301
                text_xalign = 0.5;
 
302
                text_yalign = 0.0;
 
303
                break;
 
304
        case PANEL_ORIENTATION_RIGHT:
 
305
                pack_direction = GTK_PACK_DIRECTION_TTB;
 
306
                text_angle = 270.0;
 
307
                text_xalign = 0.5;
 
308
                text_yalign = 0.0;
 
309
                break;
 
310
        default:
 
311
                g_assert_not_reached ();
 
312
                break;
 
313
        }
 
314
 
 
315
        gtk_menu_bar_set_pack_direction (GTK_MENU_BAR (menubar), pack_direction);
 
316
        gtk_menu_bar_set_child_pack_direction (GTK_MENU_BAR (menubar), pack_direction);
 
317
 
 
318
        children = gtk_container_get_children (GTK_CONTAINER (menubar));
 
319
        for (l = children; l != NULL; l = l->next)
 
320
                set_item_text_angle_and_alignment (GTK_WIDGET (l->data),
 
321
                                                   text_angle,
 
322
                                                   text_xalign,
 
323
                                                   text_yalign);
 
324
        g_list_free (children);
 
325
}
 
326
 
 
327
void
 
328
panel_menu_bar_object_set_orientation (PanelMenuBarObject *menubar,
 
329
                                       PanelOrientation    orientation)
 
330
{
 
331
        g_return_if_fail (PANEL_IS_MENU_BAR_OBJECT (menubar));
 
332
 
 
333
        if (menubar->priv->orientation == orientation)
 
334
                return;
 
335
 
 
336
        menubar->priv->orientation = orientation;
 
337
 
 
338
        panel_menu_bar_object_update_orientation (menubar);
 
339
 
 
340
        g_object_notify (G_OBJECT (menubar), "orientation");
 
341
}
 
342
 
 
343
PanelOrientation
 
344
panel_menu_bar_object_get_orientation (PanelMenuBarObject *menubar)
 
345
{
 
346
        g_return_val_if_fail (PANEL_IS_MENU_BAR_OBJECT (menubar), 0);
 
347
 
 
348
        return menubar->priv->orientation;
 
349
}