← Back to branch summary

~ubuntu-branches/ubuntu/precise/xfce4-panel/precise

« back to all changes in this revision

Viewing changes to plugins/tasklist/tasklist.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2010-12-04 15:45:53 UTC
  • mto: (4.1.3 experimental)
  • mto: This revision was merged to the branch mainline in revision 50.
  • Revision ID: james.westby@ubuntu.com-20101204154553-f452gq02eiksf09f
Tags: upstream-4.7.5
Import upstream version 4.7.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/tasklist/tasklist.c
1
 
/* $Id$
2
 
 *
3
 
 * Copyright (c) 2005-2007 Jasper Huijsmans <jasper@xfce.org>
4
 
 * Copyright (c) 2007      Nick Schermer <nick@xfce.org>
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU Library General Public License as published
8
 
 * by the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program 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
14
 
 * GNU Library General Public License for more details.
 
1
/*
 
2
 * Copyright (C) 2008-2009 Nick Schermer <nick@xfce.org>
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or modify it
 
5
 * under the terms of the GNU General Public License as published by the Free
 
6
 * Software Foundation; either version 2 of the License, or (at your option)
 
7
 * any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful, but WITHOUT
 
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 
12
 * more details.
15
13
 *
16
14
 * You should have received a copy of the GNU Library General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
15
 * along with this library; if not, write to the Free Software Foundation,
 
16
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19
17
 */
20
18
 
21
19
#ifdef HAVE_CONFIG_H
22
20
#include <config.h>
23
21
#endif
24
22
 
25
 
#ifdef HAVE_STRING_H
26
 
#include <string.h>
 
23
#include <exo/exo.h>
 
24
#include <libxfce4ui/libxfce4ui.h>
 
25
#include <common/panel-xfconf.h>
 
26
#include <common/panel-utils.h>
 
27
#include <common/panel-private.h>
 
28
#include <libxfce4panel/libxfce4panel.h>
 
29
 
 
30
#include "tasklist-widget.h"
 
31
#include "tasklist-dialog_ui.h"
 
32
 
 
33
/* TODO move to header */
 
34
GType tasklist_plugin_get_type (void) G_GNUC_CONST;
 
35
void tasklist_plugin_register_type (XfcePanelTypeModule *type_module);
 
36
#define XFCE_TYPE_TASKLIST_PLUGIN            (tasklist_plugin_get_type ())
 
37
#define XFCE_TASKLIST_PLUGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), XFCE_TYPE_TASKLIST_PLUGIN, TasklistPlugin))
 
38
#define XFCE_TASKLIST_PLUGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), XFCE_TYPE_TASKLIST_PLUGIN, TasklistPluginClass))
 
39
#define XFCE_IS_TASKLIST_PLUGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XFCE_TYPE_TASKLIST_PLUGIN))
 
40
#define XFCE_IS_TASKLIST_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), XFCE_TYPE_TASKLIST_PLUGIN))
 
41
#define XFCE_TASKLIST_PLUGIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), XFCE_TYPE_TASKLIST_PLUGIN, TasklistPluginClass))
 
42
 
 
43
 
 
44
typedef struct _TasklistPluginClass TasklistPluginClass;
 
45
struct _TasklistPluginClass
 
46
{
 
47
  XfcePanelPluginClass __parent__;
 
48
};
 
49
 
 
50
typedef struct _TasklistPlugin TasklistPlugin;
 
51
struct _TasklistPlugin
 
52
{
 
53
  XfcePanelPlugin __parent__;
 
54
 
 
55
  /* the tasklist widget */
 
56
  GtkWidget     *tasklist;
 
57
  GtkWidget     *handle;
 
58
};
 
59
 
 
60
 
 
61
 
 
62
static void     tasklist_plugin_construct           (XfcePanelPlugin *panel_plugin);
 
63
static void     tasklist_plugin_orientation_changed (XfcePanelPlugin *panel_plugin,
 
64
                                                     GtkOrientation   orientation);
 
65
static gboolean tasklist_plugin_size_changed        (XfcePanelPlugin *panel_plugin,
 
66
                                                     gint             size);
 
67
static void     tasklist_plugin_configure_plugin    (XfcePanelPlugin *panel_plugin);
 
68
static gboolean tasklist_plugin_handle_expose_event (GtkWidget       *widget,
 
69
                                                     GdkEventExpose  *event,
 
70
                                                     TasklistPlugin  *plugin);
 
71
 
 
72
 
 
73
 
 
74
/* define and register the plugin */
 
75
XFCE_PANEL_DEFINE_PLUGIN_RESIDENT (TasklistPlugin, tasklist_plugin)
 
76
 
 
77
 
 
78
 
 
79
static void
 
80
tasklist_plugin_class_init (TasklistPluginClass *klass)
 
81
{
 
82
  XfcePanelPluginClass *plugin_class;
 
83
 
 
84
  plugin_class = XFCE_PANEL_PLUGIN_CLASS (klass);
 
85
  plugin_class->construct = tasklist_plugin_construct;
 
86
  plugin_class->orientation_changed = tasklist_plugin_orientation_changed;
 
87
  plugin_class->size_changed = tasklist_plugin_size_changed;
 
88
  plugin_class->configure_plugin = tasklist_plugin_configure_plugin;
 
89
}
 
90
 
 
91
 
 
92
 
 
93
static void
 
94
tasklist_plugin_init (TasklistPlugin *plugin)
 
95
{
 
96
  GtkWidget *box;
 
97
 
 
98
  /* create widgets */
 
99
  box = xfce_hvbox_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
 
100
  gtk_container_add (GTK_CONTAINER (plugin), box);
 
101
  exo_binding_new (G_OBJECT (plugin), "orientation", G_OBJECT (box), "orientation");
 
102
  gtk_widget_show (box);
 
103
 
 
104
  plugin->handle = gtk_alignment_new (0.00, 0.00, 0.00, 0.00);
 
105
  gtk_box_pack_start (GTK_BOX (box), plugin->handle, FALSE, FALSE, 0);
 
106
  g_signal_connect (G_OBJECT (plugin->handle), "expose-event",
 
107
      G_CALLBACK (tasklist_plugin_handle_expose_event), plugin);
 
108
  gtk_widget_set_size_request (plugin->handle, 8, 8);
 
109
  gtk_widget_show (plugin->handle);
 
110
 
 
111
  plugin->tasklist = g_object_new (XFCE_TYPE_TASKLIST, NULL);
 
112
  gtk_box_pack_start (GTK_BOX (box), plugin->tasklist, TRUE, TRUE, 0);
 
113
 
 
114
  exo_binding_new (G_OBJECT (plugin->tasklist), "show-handle",
 
115
                   G_OBJECT (plugin->handle), "visible");
 
116
}
 
117
 
 
118
 
 
119
 
 
120
static void
 
121
tasklist_plugin_construct (XfcePanelPlugin *panel_plugin)
 
122
{
 
123
  TasklistPlugin      *plugin = XFCE_TASKLIST_PLUGIN (panel_plugin);
 
124
  const PanelProperty  properties[] =
 
125
  {
 
126
    { "show-labels", G_TYPE_BOOLEAN },
 
127
    { "grouping", G_TYPE_UINT },
 
128
    { "include-all-workspaces", G_TYPE_BOOLEAN },
 
129
    { "flat-buttons", G_TYPE_BOOLEAN },
 
130
    { "switch-workspace-on-unminimize", G_TYPE_BOOLEAN },
 
131
    { "show-only-minimized", G_TYPE_BOOLEAN },
 
132
    { "show-wireframes", G_TYPE_BOOLEAN },
 
133
    { "show-handle", G_TYPE_BOOLEAN },
 
134
    { "sort-order", G_TYPE_UINT },
 
135
    { "rotate-vertically", G_TYPE_BOOLEAN },
 
136
    { NULL }
 
137
  };
 
138
 
 
139
  /* show configure */
 
140
  xfce_panel_plugin_menu_show_configure (XFCE_PANEL_PLUGIN (plugin));
 
141
 
 
142
  /* expand the plugin */
 
143
  xfce_panel_plugin_set_expand (panel_plugin, TRUE);
 
144
 
 
145
  /* bind all properties */
 
146
  panel_properties_bind (NULL, G_OBJECT (plugin->tasklist),
 
147
                         xfce_panel_plugin_get_property_base (panel_plugin),
 
148
                         properties, FALSE);
 
149
 
 
150
  /* show the tasklist */
 
151
  gtk_widget_show (plugin->tasklist);
 
152
}
 
153
 
 
154
 
 
155
 
 
156
static void
 
157
tasklist_plugin_orientation_changed (XfcePanelPlugin *panel_plugin,
 
158
                                     GtkOrientation   orientation)
 
159
{
 
160
  TasklistPlugin *plugin = XFCE_TASKLIST_PLUGIN (panel_plugin);
 
161
 
 
162
  /* set the new tasklist orientation */
 
163
  xfce_tasklist_set_orientation (XFCE_TASKLIST (plugin->tasklist), orientation);
 
164
}
 
165
 
 
166
 
 
167
 
 
168
static gboolean
 
169
tasklist_plugin_size_changed (XfcePanelPlugin *panel_plugin,
 
170
                              gint             size)
 
171
{
 
172
  TasklistPlugin *plugin = XFCE_TASKLIST_PLUGIN (panel_plugin);
 
173
 
 
174
  /* set the tasklist size */
 
175
  xfce_tasklist_set_size (XFCE_TASKLIST (plugin->tasklist), size);
 
176
 
 
177
  return TRUE;
 
178
}
 
179
 
 
180
 
 
181
 
 
182
static void
 
183
tasklist_plugin_configure_plugin (XfcePanelPlugin *panel_plugin)
 
184
{
 
185
  TasklistPlugin *plugin = XFCE_TASKLIST_PLUGIN (panel_plugin);
 
186
  GtkBuilder     *builder;
 
187
  GObject        *dialog;
 
188
  GObject        *object;
 
189
  GtkTreeIter     iter;
 
190
 
 
191
  /* setup the dialog */
 
192
  PANEL_UTILS_LINK_4UI
 
193
  builder = panel_utils_builder_new (panel_plugin, tasklist_dialog_ui,
 
194
                                     tasklist_dialog_ui_length, &dialog);
 
195
  if (G_UNLIKELY (builder == NULL))
 
196
    return;
 
197
 
 
198
#define TASKLIST_DIALOG_BIND(name, property) \
 
199
  object = gtk_builder_get_object (builder, (name)); \
 
200
  panel_return_if_fail (G_IS_OBJECT (object)); \
 
201
  exo_mutual_binding_new (G_OBJECT (plugin->tasklist), (name), \
 
202
                          G_OBJECT (object), (property));
 
203
 
 
204
#define TASKLIST_DIALOG_BIND_INV(name, property) \
 
205
  object = gtk_builder_get_object (builder, (name)); \
 
206
  panel_return_if_fail (G_IS_OBJECT (object)); \
 
207
  exo_mutual_binding_new_with_negation (G_OBJECT (plugin->tasklist), \
 
208
                                        name,  G_OBJECT (object), \
 
209
                                        property);
 
210
 
 
211
  TASKLIST_DIALOG_BIND ("show-labels", "active")
 
212
  TASKLIST_DIALOG_BIND ("grouping", "active")
 
213
  TASKLIST_DIALOG_BIND ("include-all-workspaces", "active")
 
214
  TASKLIST_DIALOG_BIND ("flat-buttons", "active")
 
215
  TASKLIST_DIALOG_BIND ("rotate-vertically", "active")
 
216
  TASKLIST_DIALOG_BIND_INV ("switch-workspace-on-unminimize", "active")
 
217
  TASKLIST_DIALOG_BIND ("show-only-minimized", "active")
 
218
  TASKLIST_DIALOG_BIND ("show-wireframes", "active")
 
219
  TASKLIST_DIALOG_BIND ("show-handle", "active")
 
220
  TASKLIST_DIALOG_BIND ("sort-order", "active")
 
221
 
 
222
#ifndef GDK_WINDOWING_X11
 
223
  /* not functional in x11, so avoid confusion */
 
224
  object = gtk_builder_get_object (builder, "show-wireframes");
 
225
  gtk_widget_hide (GTK_WIDGET (object));
27
226
#endif
28
227
 
29
 
#include <libwnck/libwnck.h>
30
 
#include <libxfce4util/libxfce4util.h>
31
 
#include <libxfce4panel/xfce-hvbox.h>
32
 
 
33
 
#include "tasklist.h"
34
 
#include "tasklist-dialogs.h"
35
 
 
36
 
#define TASKLIST_HANDLE_SIZE (8)
37
 
 
38
 
 
39
 
/* prototypes */
40
 
static gboolean        tasklist_handle_exposed                (GtkWidget          *widget,
41
 
                                                               GdkEventExpose     *event,
42
 
                                                               TasklistPlugin     *tasklist);
43
 
static GdkPixbuf      *tasklist_icon_loader                   (const gchar        *name,
44
 
                                                               gint                size,
45
 
                                                               guint               flags,
46
 
                                                               TasklistPlugin     *tasklist);
47
 
static TasklistPlugin *tasklist_plugin_new                    (XfcePanelPlugin    *panel_plugin);
48
 
static void            tasklist_plugin_screen_changed         (TasklistPlugin     *tasklist,
49
 
                                                               GdkScreen          *previous_screen);
50
 
static void            tasklist_plugin_orientation_changed    (TasklistPlugin     *tasklist,
51
 
                                                               GtkOrientation      orientation);
52
 
static gboolean        tasklist_plugin_size_changed           (TasklistPlugin     *tasklist,
53
 
                                                               guint               size);
54
 
static void            tasklist_plugin_size_request           (TasklistPlugin     *tasklist,
55
 
                                                               GtkRequisition     *requisition);
56
 
static void            tasklist_plugin_read                   (TasklistPlugin     *tasklist);
57
 
static void            tasklist_plugin_free                   (TasklistPlugin     *tasklist);
58
 
static void            tasklist_plugin_construct              (XfcePanelPlugin    *panel_plugin);
59
 
 
60
 
 
61
 
 
62
 
/* register with the panel */
63
 
XFCE_PANEL_PLUGIN_REGISTER_INTERNAL (tasklist_plugin_construct);
64
 
 
65
 
 
66
 
 
67
 
gboolean
68
 
tasklist_using_xinerama (XfcePanelPlugin *panel_plugin)
69
 
{
70
 
    return (gdk_screen_get_n_monitors (gtk_widget_get_screen (GTK_WIDGET (panel_plugin))) > 1);
 
228
  /* TODO: remove this if always group is supported */
 
229
  object = gtk_builder_get_object (builder, "grouping-model");
 
230
  if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (object), &iter, NULL, 2))
 
231
    gtk_list_store_remove (GTK_LIST_STORE (object), &iter);
 
232
 
 
233
  gtk_widget_show (GTK_WIDGET (dialog));
71
234
}
72
235
 
73
236
 
74
237
 
75
238
static gboolean
76
 
tasklist_handle_exposed (GtkWidget      *widget,
77
 
                         GdkEventExpose *event,
78
 
                         TasklistPlugin *tasklist)
 
239
tasklist_plugin_handle_expose_event (GtkWidget *widget,
 
240
                                     GdkEventExpose *event,
 
241
                                     TasklistPlugin *plugin)
79
242
{
80
 
    GtkOrientation orientation;
81
 
    gint           x, y, w, h;
82
 
 
83
 
    if (GTK_WIDGET_DRAWABLE (widget))
84
 
    {
85
 
        /* get the panel orientation */
86
 
        orientation = xfce_panel_plugin_get_orientation (tasklist->panel_plugin);
87
 
 
88
 
        /* set sizes */
89
 
        x = widget->allocation.x;
90
 
        y = widget->allocation.y;
91
 
        w = widget->allocation.width;
92
 
        h = widget->allocation.height;
93
 
 
94
 
        if (orientation == GTK_ORIENTATION_HORIZONTAL)
95
 
        {
96
 
            y += widget->style->ythickness;
97
 
            h -= 2 * widget->style->ythickness;
98
 
        }
99
 
        else
100
 
        {
101
 
            x += widget->style->xthickness;
102
 
            w -= 2 * widget->style->xthickness;
103
 
        }
104
 
 
105
 
        gtk_paint_handle (widget->style, widget->window,
106
 
                          GTK_WIDGET_STATE (widget), GTK_SHADOW_NONE,
107
 
                          &(event->area), widget, "handlebox",
108
 
                          x, y, w, h,
109
 
                          orientation == GTK_ORIENTATION_HORIZONTAL ?
110
 
                              GTK_ORIENTATION_VERTICAL :
111
 
                              GTK_ORIENTATION_HORIZONTAL);
112
 
 
113
 
        return TRUE;
114
 
    }
115
 
 
 
243
  GtkOrientation orientation;
 
244
 
 
245
  panel_return_val_if_fail (XFCE_IS_TASKLIST_PLUGIN (plugin), FALSE);
 
246
  panel_return_val_if_fail (plugin->handle == widget, FALSE);
 
247
 
 
248
  if (!GTK_WIDGET_DRAWABLE (widget))
116
249
    return FALSE;
117
 
}
118
 
 
119
 
 
120
 
 
121
 
static GdkPixbuf *
122
 
tasklist_icon_loader (const gchar    *name,
123
 
                      gint            size,
124
 
                      guint           flags,
125
 
                      TasklistPlugin *tasklist)
126
 
{
127
 
    GdkPixbuf   *pixbuf = NULL;
128
 
    gchar       *base = NULL;
129
 
    const gchar *p;
130
 
 
131
 
    /* do nothing on invalid names */
132
 
    if (G_UNLIKELY (name == NULL || *name == '\0'))
133
 
        return NULL;
134
 
 
135
 
    if (g_path_is_absolute (name))
136
 
    {
137
 
        if (g_file_test (name, G_FILE_TEST_EXISTS))
138
 
        {
139
 
            /* directly load the file */
140
 
            pixbuf = gdk_pixbuf_new_from_file_at_size (name, size, size, NULL);
141
 
        }
142
 
        else
143
 
        {
144
 
            /* get the base name */
145
 
            base = g_path_get_basename (name);
146
 
 
147
 
            /* use this function to try again */
148
 
            pixbuf = tasklist_icon_loader (base, size, flags, tasklist);
149
 
 
150
 
            /* cleanup */
151
 
            g_free (base);
152
 
        }
153
 
    }
154
 
    else
155
 
    {
156
 
        /* strip prefix */
157
 
        p = strrchr (name, '.');
158
 
        if (G_UNLIKELY (p))
159
 
            base = g_strndup (name, p - name);
160
 
 
161
 
        /* load the icon */
162
 
        pixbuf = gtk_icon_theme_load_icon (tasklist->icon_theme, base ? base : name, size, 0, NULL);
163
 
 
164
 
        /* cleanup */
165
 
        g_free (base);
166
 
    }
167
 
 
168
 
    return pixbuf;
169
 
}
170
 
 
171
 
 
172
 
 
173
 
static TasklistPlugin *
174
 
tasklist_plugin_new (XfcePanelPlugin *panel_plugin)
175
 
{
176
 
    TasklistPlugin *tasklist;
177
 
    GdkScreen      *screen;
178
 
    gint            screen_n;
179
 
 
180
 
    /* allocate structure */
181
 
    tasklist = panel_slice_new0 (TasklistPlugin);
182
 
 
183
 
    /* init data */
184
 
    tasklist->panel_plugin = panel_plugin;
185
 
 
186
 
    /* read settings */
187
 
    tasklist_plugin_read (tasklist);
188
 
 
189
 
    /* create hvbox */
190
 
    tasklist->box = xfce_hvbox_new (xfce_panel_plugin_get_orientation (panel_plugin), FALSE, 0);
191
 
    gtk_container_add (GTK_CONTAINER (panel_plugin), tasklist->box);
192
 
    gtk_widget_show (tasklist->box);
193
 
 
194
 
    /* create handle */
195
 
    tasklist->handle = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
196
 
    gtk_widget_set_size_request (tasklist->handle, TASKLIST_HANDLE_SIZE, TASKLIST_HANDLE_SIZE);
197
 
    gtk_box_pack_start (GTK_BOX (tasklist->box), tasklist->handle, FALSE, FALSE, 0);
198
 
    g_signal_connect (tasklist->handle, "expose-event", G_CALLBACK (tasklist_handle_exposed), tasklist);
199
 
    if (tasklist->show_handles)
200
 
        gtk_widget_show (tasklist->handle);
201
 
 
202
 
    /* get the current screen number */
203
 
    screen = gtk_widget_get_screen (GTK_WIDGET (panel_plugin));
204
 
    screen_n = gdk_screen_get_number (screen);
205
 
 
206
 
    /* set the icon theme */
207
 
    tasklist->icon_theme = gtk_icon_theme_get_for_screen (screen);
208
 
 
209
 
    /* create tasklist */
210
 
    tasklist->list = wnck_tasklist_new (wnck_screen_get (screen_n));
211
 
    gtk_box_pack_start (GTK_BOX (tasklist->box), tasklist->list, FALSE, FALSE, 0);
212
 
    gtk_widget_show (tasklist->list);
213
 
 
214
 
    /* set the tasklist settings */
215
 
    wnck_tasklist_set_include_all_workspaces (WNCK_TASKLIST (tasklist->list), tasklist->all_workspaces);
216
 
    wnck_tasklist_set_grouping (WNCK_TASKLIST (tasklist->list), tasklist->grouping);
217
 
    wnck_tasklist_set_button_relief (WNCK_TASKLIST (tasklist->list), tasklist->flat_buttons ? GTK_RELIEF_NONE : GTK_RELIEF_NORMAL);
218
 
    wnck_tasklist_set_icon_loader (WNCK_TASKLIST (tasklist->list), (WnckLoadIconFunction) tasklist_icon_loader, tasklist, NULL);
219
 
 
220
 
    return tasklist;
221
 
}
222
 
 
223
 
 
224
 
 
225
 
static void
226
 
tasklist_plugin_screen_changed (TasklistPlugin *tasklist,
227
 
                                GdkScreen      *previous_screen)
228
 
{
229
 
    GdkScreen  *screen;
230
 
    WnckScreen *wnck_screen;
231
 
 
232
 
    /* get the new screen */
233
 
    screen = gtk_widget_get_screen (GTK_WIDGET (tasklist->panel_plugin));
234
 
    if (G_UNLIKELY (screen == NULL))
235
 
        screen = gdk_screen_get_default ();
236
 
 
237
 
    /* get the wnck screen */
238
 
    wnck_screen = wnck_screen_get (gdk_screen_get_number (screen));
239
 
 
240
 
    /* set the new tasklist screen */
241
 
    wnck_tasklist_set_screen (WNCK_TASKLIST (tasklist->list), wnck_screen);
242
 
 
243
 
    /* set the icon theme */
244
 
    tasklist->icon_theme = gtk_icon_theme_get_for_screen (screen);
245
 
}
246
 
 
247
 
 
248
 
 
249
 
static void
250
 
tasklist_plugin_orientation_changed (TasklistPlugin *tasklist,
251
 
                                     GtkOrientation orientation)
252
 
{
253
 
    /* set the new orientation of the hvbox */
254
 
    xfce_hvbox_set_orientation (XFCE_HVBOX (tasklist->box), orientation);
255
 
 
256
 
    /* redraw the handle */
257
 
    gtk_widget_queue_draw (tasklist->handle);
258
 
}
259
 
 
260
 
 
261
 
 
262
 
gboolean
263
 
tasklist_plugin_size_changed (TasklistPlugin *tasklist,
264
 
                              guint           size)
265
 
{
266
 
    /* size is handled in the size_request function */
267
 
    return TRUE;
268
 
}
269
 
 
270
 
 
271
 
 
272
 
static void
273
 
tasklist_plugin_size_request (TasklistPlugin *tasklist,
274
 
                              GtkRequisition *requisition)
275
 
{
276
 
    const gint     *size_hints;
277
 
    gint            length;
278
 
    gint            size;
279
 
    GtkOrientation  orientation;
280
 
 
281
 
    /* get the size hints */
282
 
    size_hints = wnck_tasklist_get_size_hint_list (WNCK_TASKLIST (tasklist->list), &length);
283
 
 
284
 
    /* check for pairs of 2 */
285
 
    if (G_LIKELY (length > 0))
286
 
    {
287
 
        /* get the first size */
288
 
        size = size_hints[0];
289
 
 
290
 
        /* add the handle size */
291
 
        if (tasklist->show_handles)
292
 
            size += TASKLIST_HANDLE_SIZE;
293
 
 
294
 
        /* use the requested size when it is bigger then the prefered size */
295
 
        if (tasklist->fixed_width)
296
 
            size = MAX (100, tasklist->width);
297
 
 
298
 
        /* get plugin orientation */
299
 
        orientation = xfce_panel_plugin_get_orientation (tasklist->panel_plugin);
300
 
 
301
 
        /* set the panel size */
302
 
        requisition->width = requisition->height = xfce_panel_plugin_get_size (tasklist->panel_plugin);
303
 
 
304
 
        /* set the requested plugin size */
305
 
        if (orientation == GTK_ORIENTATION_HORIZONTAL)
306
 
            requisition->width = size;
307
 
        else
308
 
            requisition->height = size;
309
 
 
310
 
        /* save the requested size */
311
 
        tasklist->req_size = size;
312
 
    }
313
 
}
314
 
 
315
 
 
316
 
static void
317
 
tasklist_plugin_size_allocate (TasklistPlugin *tasklist,
318
 
                               GtkAllocation  *allocation)
319
 
{
320
 
  GtkOrientation  orientation;
321
 
  gint            a_size, p_size;
322
 
 
323
 
  /* get orientation */
324
 
  orientation = xfce_panel_plugin_get_orientation (tasklist->panel_plugin);
325
 
 
326
 
  /* get plugin size */
327
 
  p_size = xfce_panel_plugin_get_size (tasklist->panel_plugin);
328
 
 
329
 
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
330
 
    a_size = MIN (tasklist->req_size, allocation->width);
331
 
  else
332
 
    a_size = MIN (tasklist->req_size, allocation->height);
333
 
 
334
 
  if (tasklist->show_handles)
335
 
    a_size -= TASKLIST_HANDLE_SIZE;
336
 
 
337
 
  /* force the size request of the taskbar */
338
 
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
339
 
    gtk_widget_set_size_request (GTK_WIDGET (tasklist->list), a_size, p_size);
340
 
  else
341
 
    gtk_widget_set_size_request (GTK_WIDGET (tasklist->list), p_size, a_size);
342
 
}
343
 
 
344
 
 
345
 
static void
346
 
tasklist_plugin_read (TasklistPlugin *tasklist)
347
 
{
348
 
    gchar  *file;
349
 
    XfceRc *rc;
350
 
 
351
 
    /* set defaults */
352
 
    tasklist->grouping       = WNCK_TASKLIST_AUTO_GROUP;
353
 
    tasklist->all_workspaces = FALSE;
354
 
    tasklist->expand         = TRUE;
355
 
    tasklist->flat_buttons   = TRUE;
356
 
    tasklist->show_handles   = TRUE;
357
 
    tasklist->width          = 300;
358
 
    tasklist->fixed_width    = FALSE;
359
 
 
360
 
    /* get rc file name */
361
 
    file = xfce_panel_plugin_lookup_rc_file (tasklist->panel_plugin);
362
 
 
363
 
    if (G_LIKELY (file))
364
 
    {
365
 
        /* open the file, readonly */
366
 
        rc = xfce_rc_simple_open (file, TRUE);
367
 
 
368
 
        /* cleanup */
369
 
        g_free (file);
370
 
 
371
 
        if (G_LIKELY (rc))
372
 
        {
373
 
            /* read settings */
374
 
            tasklist->grouping       = xfce_rc_read_int_entry  (rc, "grouping", tasklist->grouping);
375
 
            tasklist->all_workspaces = xfce_rc_read_bool_entry (rc, "all_workspaces", tasklist->all_workspaces);
376
 
            tasklist->flat_buttons   = xfce_rc_read_bool_entry (rc, "flat_buttons", tasklist->flat_buttons);
377
 
            tasklist->show_handles   = xfce_rc_read_bool_entry (rc, "show_handles", tasklist->show_handles);
378
 
            tasklist->width          = xfce_rc_read_int_entry  (rc, "width",tasklist->width);
379
 
            tasklist->fixed_width    = xfce_rc_read_bool_entry (rc, "fixed_width", tasklist->fixed_width);
380
 
 
381
 
            /* only set expand flag if xinerama is used */
382
 
            if (tasklist_using_xinerama (tasklist->panel_plugin))
383
 
                tasklist->expand = xfce_rc_read_bool_entry (rc, "expand", tasklist->expand);
384
 
 
385
 
            /* close the rc file */
386
 
            xfce_rc_close (rc);
387
 
        }
388
 
    }
389
 
}
390
 
 
391
 
 
392
 
 
393
 
void
394
 
tasklist_plugin_write (TasklistPlugin *tasklist)
395
 
{
396
 
    gchar  *file;
397
 
    XfceRc *rc;
398
 
 
399
 
    /* get rc file name, create it if needed */
400
 
    file = xfce_panel_plugin_save_location (tasklist->panel_plugin, TRUE);
401
 
 
402
 
    if (G_LIKELY (file))
403
 
    {
404
 
        /* open the file, writable */
405
 
        rc = xfce_rc_simple_open (file, FALSE);
406
 
 
407
 
        /* cleanup */
408
 
        g_free (file);
409
 
 
410
 
        if (G_LIKELY (rc))
411
 
        {
412
 
            /* write settings */
413
 
            xfce_rc_write_int_entry (rc, "grouping", tasklist->grouping);
414
 
            xfce_rc_write_int_entry (rc, "width", tasklist->width);
415
 
            xfce_rc_write_bool_entry (rc, "all_workspaces", tasklist->all_workspaces);
416
 
            xfce_rc_write_bool_entry (rc, "expand", tasklist->expand);
417
 
            xfce_rc_write_bool_entry (rc, "flat_buttons", tasklist->flat_buttons);
418
 
            xfce_rc_write_bool_entry (rc, "show_handles", tasklist->show_handles);
419
 
            xfce_rc_write_bool_entry (rc, "fixed_width", tasklist->fixed_width);
420
 
 
421
 
            /* close the rc file */
422
 
            xfce_rc_close (rc);
423
 
        }
424
 
    }
425
 
}
426
 
 
427
 
 
428
 
 
429
 
static void
430
 
tasklist_plugin_free (TasklistPlugin *tasklist)
431
 
{
432
 
    GtkWidget *dialog;
433
 
 
434
 
    /* destroy the dialog */
435
 
    dialog = g_object_get_data (G_OBJECT (tasklist->panel_plugin), I_("dialog"));
436
 
    if (dialog)
437
 
        gtk_widget_destroy (dialog);
438
 
 
439
 
    /* disconnect screen changed signal */
440
 
    g_signal_handler_disconnect (G_OBJECT (tasklist->panel_plugin), tasklist->screen_changed_id);
441
 
 
442
 
    /* free slice */
443
 
    panel_slice_free (TasklistPlugin, tasklist);
444
 
}
445
 
 
446
 
 
447
 
 
448
 
static void
449
 
tasklist_plugin_construct (XfcePanelPlugin *panel_plugin)
450
 
{
451
 
    TasklistPlugin *tasklist;
452
 
 
453
 
    /* create the tray panel plugin */
454
 
    tasklist = tasklist_plugin_new (panel_plugin);
455
 
 
456
 
    /* set the action widgets and show configure */
457
 
    xfce_panel_plugin_add_action_widget (panel_plugin, tasklist->handle);
458
 
    xfce_panel_plugin_menu_show_configure (panel_plugin);
459
 
 
460
 
    /* whether to expand the plugin */
461
 
    xfce_panel_plugin_set_expand (panel_plugin, tasklist->expand);
462
 
 
463
 
    /* connect plugin signals */
464
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "orientation-changed",
465
 
                              G_CALLBACK (tasklist_plugin_orientation_changed), tasklist);
466
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "size-changed",
467
 
                              G_CALLBACK (tasklist_plugin_size_changed), tasklist);
468
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "size-request",
469
 
                              G_CALLBACK (tasklist_plugin_size_request), tasklist);
470
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "size-allocate",
471
 
                              G_CALLBACK (tasklist_plugin_size_allocate), tasklist);
472
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "save",
473
 
                              G_CALLBACK (tasklist_plugin_write), tasklist);
474
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "free-data",
475
 
                              G_CALLBACK (tasklist_plugin_free), tasklist);
476
 
    g_signal_connect_swapped (G_OBJECT (panel_plugin), "configure-plugin",
477
 
                              G_CALLBACK (tasklist_dialogs_configure), tasklist);
478
 
 
479
 
    /* screen changed signal */
480
 
    tasklist->screen_changed_id =
481
 
        g_signal_connect_swapped (G_OBJECT (panel_plugin), "screen-changed",
482
 
                                  G_CALLBACK (tasklist_plugin_screen_changed), tasklist);
 
250
 
 
251
  /* get the orientation */
 
252
  if (xfce_panel_plugin_get_orientation (XFCE_PANEL_PLUGIN (plugin)) ==
 
253
      GTK_ORIENTATION_HORIZONTAL)
 
254
    orientation = GTK_ORIENTATION_VERTICAL;
 
255
  else
 
256
    orientation = GTK_ORIENTATION_HORIZONTAL;
 
257
 
 
258
  /* paint the handle */
 
259
  gtk_paint_handle (widget->style, widget->window,
 
260
                    GTK_WIDGET_STATE (widget), GTK_SHADOW_NONE,
 
261
                    &(event->area), widget, "handlebox",
 
262
                    widget->allocation.x,
 
263
                    widget->allocation.y,
 
264
                    widget->allocation.width,
 
265
                    widget->allocation.height,
 
266
                    orientation);
 
267
 
 
268
  return TRUE;
483
269
}