Update the orientation of the plugins and the panel when config changed.
authorHong Jen Yee (PCMan) <pcman.tw@gmail.com>
Tue, 31 Oct 2006 03:55:28 +0000 (03:55 +0000)
committerHong Jen Yee (PCMan) <pcman.tw@gmail.com>
Tue, 31 Oct 2006 03:55:28 +0000 (03:55 +0000)
14 files changed:
data/Makefile.am
src/configurator.c
src/gtkbar.c
src/gtkbar.h
src/misc.c
src/misc.h
src/panel.c
src/panel.h
src/plugin.h
src/plugins/dclock.c
src/plugins/launchbar.c
src/plugins/separator.c
src/plugins/taskbar.c
src/systray/tray.c

index b5e48bc..30f41f2 100644 (file)
@@ -9,10 +9,6 @@ lxpanel_images_DATA = \
        images/redhat-internet.svg \
        images/stock_volume.png \
        images/thunderbird.svg \
-       images/top-left.xpm \
-       images/top-right.xpm \
-       images/bottom-left.xpm \
-       images/bottom-right.xpm \
        images/default.xpm \
        images/emacs.svg \
        images/file-manager.svg \
index 376e865..e84d979 100644 (file)
@@ -141,6 +141,7 @@ set_edge(GtkComboBox *widget, gpointer bp)
     ENTER;
     edge = gtk_combo_box_get_active(widget) + 1;
     p->edge = edge;
+    panel_set_orientation( p );
     update_panel_geometry();
     RET();
 }
index a9c8f6e..eeda002 100644 (file)
@@ -21,7 +21,7 @@
  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  * file for a list of people on the GTK+ Team.  See the ChangeLog
  * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  */
 
 #include "gtkbar.h"
@@ -88,7 +88,7 @@ gtk_bar_init (GtkBar *bar)
 }
 
 GtkWidget*
-gtk_bar_new (GtkBarOrientation orient, gint spacing)
+gtk_bar_new (GtkOrientation orient, gint spacing)
 {
     GtkBar *bar;
 
@@ -123,7 +123,7 @@ gtk_bar_size_request (GtkWidget *widget, GtkRequisition *requisition)
             GtkRequisition child_requisition;
 
             gtk_widget_size_request (child->widget, &child_requisition);
-            if (bar->orient == GTK_BAR_HORIZ)
+            if (bar->orient == GTK_ORIENTATION_HORIZONTAL)
                 requisition->height = MAX (requisition->height, child_requisition.height);
             else
                 requisition->width = MAX (requisition->width, child_requisition.width);
@@ -132,7 +132,7 @@ gtk_bar_size_request (GtkWidget *widget, GtkRequisition *requisition)
     }
 
     if (nvis_children > 0) {
-        if (bar->orient == GTK_BAR_HORIZ) {
+        if (bar->orient == GTK_ORIENTATION_HORIZONTAL) {
             requisition->width = nvis_children * GTK_BAR(widget)->max_child_size;
             requisition->width += (nvis_children - 1) * box->spacing;
         } else {
@@ -177,11 +177,11 @@ gtk_bar_size_allocate (GtkWidget     *widget,
     gtk_widget_queue_draw(widget);
     if (nvis_children == 0)
         RET();
-    
+
     child_allocation.x = allocation->x + bw;
     child_allocation.y = allocation->y + bw;
 
-    if (bar->orient == GTK_BAR_HORIZ) {
+    if (bar->orient == GTK_ORIENTATION_HORIZONTAL) {
         child_allocation.height = MAX (1, (gint) allocation->height - bw * 2);
         tmp = (allocation->width - bw * 2 - (nvis_children - 1) * box->spacing);
         child_allocation.width = MAX (1, MIN(tmp / nvis_children, bar->max_child_size));
@@ -190,7 +190,7 @@ gtk_bar_size_allocate (GtkWidget     *widget,
         tmp = (allocation->height - bw * 2 - (nvis_children - 1) * box->spacing);
         child_allocation.height = MAX (1, MIN(tmp / nvis_children, bar->max_child_size));
     }
-    
+
     children = box->children;
     while (children) {
         child = children->data;
@@ -200,7 +200,7 @@ gtk_bar_size_allocate (GtkWidget     *widget,
             gtk_widget_size_allocate (child->widget, &child_allocation);
             bar->maxx = child_allocation.x;
             bar->maxy = child_allocation.y;
-            if (bar->orient == GTK_BAR_HORIZ)
+            if (bar->orient == GTK_ORIENTATION_HORIZONTAL)
                 child_allocation.x += child_allocation.width + box->spacing;
             else
                 child_allocation.y += child_allocation.height + box->spacing;
@@ -218,7 +218,7 @@ void
 gtk_bar_set_max_child_size(GtkBar *bar, gint size)
 {
     g_return_if_fail (GTK_IS_BAR (bar));
-    
+
     if (size != bar->max_child_size) {
         bar->max_child_size = size;
         //g_object_notify (G_OBJECT (bar), "spacing");
@@ -234,7 +234,7 @@ gtk_bar_expose (GtkWidget *widget, GdkEventExpose *event)
 
     if (GTK_WIDGET_DRAWABLE (widget)) {
         int w, h;
-        
+
         w = GTK_BAR(widget)->maxx;
         h = GTK_BAR(widget)->maxy;
         DBG("w, h = %d,%d\n", w, h);
@@ -247,3 +247,11 @@ gtk_bar_expose (GtkWidget *widget, GdkEventExpose *event)
     RET(FALSE);
 }
 #endif
+
+void gtk_bar_set_orientation( GtkBar *bar, GtkOrientation ori )
+{
+    if( ori == bar->orient )
+        return;
+    bar->orient = ori;
+    gtk_widget_queue_resize( GTK_WIDGET(bar) );
+}
index 70cbd24..f199c72 100644 (file)
@@ -21,7 +21,7 @@
  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  * file for a list of people on the GTK+ Team.  See the ChangeLog
  * files for a list of changes.  These files are distributed with
- * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  */
 
 #ifndef __GTK_BAR_H__
 
 typedef struct _GtkBar       GtkBar;
 typedef struct _GtkBarClass  GtkBarClass;
-typedef enum { GTK_BAR_VERTICAL, GTK_BAR_HORIZ } GtkBarOrientation;
 
 struct _GtkBar
 {
     GtkBox box;
     gint max_child_size;
-    GtkBarOrientation orient;
+    GtkOrientation orient;
     int maxx, maxy;
 };
 
@@ -64,9 +63,10 @@ struct _GtkBarClass
 
 
 GType     gtk_bar_get_type (void) G_GNUC_CONST;
-GtkWidget* gtk_bar_new      (GtkBarOrientation orient, gint spacing);
+GtkWidget* gtk_bar_new      (GtkOrientation orient, gint spacing);
 void       gtk_bar_set_max_child_size(GtkBar *bar, gint size);
-
+void       gtk_bar_set_orientation( GtkBar *bar,
+                                    GtkOrientation ori );
 
 #ifdef __cplusplus
 }
index 14cce6f..29ab503 100644 (file)
@@ -1111,3 +1111,47 @@ char* translate_exec_to_cmd( const char* exec, const char* icon,
     return g_string_free( cmd, FALSE );
 }
 
+/*
+ This function is used to re-create a new box with different
+ orientation from the old one, add all children of the old one to
+ the new one, and then destroy the old box.
+ It's mainly used when we need to change the orientation of the panel or
+ any plugin with a layout box. Since GtkHBox cannot be changed to GtkVBox,
+ recreating a new box to replace the old one is required.
+*/
+GtkWidget* recreate_box( GtkBox* oldbox, GtkOrientation orientation )
+{
+    GtkBox* newbox;
+    GList *child, *children;
+    GtkWidget* (*my_box_new) (gboolean homogeneous, gint spacing);
+
+    if( GTK_IS_HBOX(oldbox) ) {
+        if( orientation == GTK_ORIENTATION_HORIZONTAL )
+            return oldbox;
+    }
+    else {
+        if( orientation == GTK_ORIENTATION_VERTICAL )
+            return oldbox;
+    }
+    my_box_new = orientation == GTK_ORIENTATION_HORIZONTAL ? gtk_hbox_new : gtk_vbox_new;
+
+    newbox = my_box_new( gtk_box_get_homogeneous(oldbox),
+                         gtk_box_get_spacing(oldbox) );
+    gtk_container_set_border_width (GTK_CONTAINER (newbox),
+                                    gtk_container_get_border_width(oldbox) );
+    children = gtk_container_get_children( GTK_CONTAINER (oldbox) );
+    for( child = children; child; child = child->next ) {
+        gboolean expand, fill, padding;
+        GtkWidget* w = GTK_WIDGET(child->data);
+        gtk_box_query_child_packing( oldbox, w,
+                                     &expand, &fill, &padding, NULL );
+        g_object_ref( w );
+        gtk_container_remove( GTK_CONTAINER (oldbox), w );
+        gtk_box_pack_start( newbox, w, expand, fill, padding );
+        g_object_unref( w );
+    }
+    g_list_free( children );
+    gtk_widget_show_all(newbox);
+    gtk_widget_destroy( oldbox );
+    return newbox;
+}
index 5093687..03d730e 100644 (file)
@@ -59,7 +59,7 @@ void calculate_position(panel *np);
 gchar *expand_tilda(gchar *file);
 GdkPixbuf *gdk_pixbuf_scale_ratio(GdkPixbuf *p, int width, int height, GdkInterpType itype,
                                   gboolean keep_ratio);
-GtkWidget *gtk_image_new_from_file_scaled(const gchar *file, gint width, gint height,  
+GtkWidget *gtk_image_new_from_file_scaled(const gchar *file, gint width, gint height,
                                           gboolean keep_ratio);
 void get_button_spacing(GtkRequisition *req, GtkContainer *parent, gchar *name);
 guint32 gcolor2rgb24(GdkColor *color);
@@ -70,4 +70,15 @@ GtkWidget *fb_button_new_from_file_with_label(gchar *fname, int width, int heigh
 
 char* translate_exec_to_cmd( const char* exec, const char* icon,
                              const char* title, const char* fpath );
+
+/*
+ This function is used to re-create a new box with different
+ orientation from the old one, add all children of the old one to
+ the new one, and then destroy the old box.
+ It's mainly used when we need to change the orientation of the panel or
+ any plugin with a layout box. Since GtkHBox cannot be changed to GtkVBox,
+ recreating a new box to replace the old one is required.
+*/
+GtkWidget* recreate_box( GtkBox* oldbox, GtkOrientation orientation );
+
 #endif
index 3102bd2..7a9a0a8 100644 (file)
@@ -318,6 +318,8 @@ panel_configure_event (GtkWidget *widget, GdkEventConfigure *e, panel *p)
 static void
 make_round_corners(panel *p)
 {
+    /* FIXME: This should be re-written with shape extension of X11 */
+#if 0
     GtkWidget *b1, *b2, *img;
     GtkWidget *(*box_new) (gboolean, gint);
     void (*box_pack)(GtkBox *, GtkWidget *, gboolean, gboolean, guint);
@@ -358,6 +360,7 @@ make_round_corners(panel *p)
     gtk_box_pack_start(GTK_BOX(p->lbox), b1, FALSE, FALSE, 0);
     gtk_box_pack_end(GTK_BOX(p->lbox), b2, FALSE, FALSE, 0);
     RET();
+#endif
 }
 
 void panel_set_dock_type(panel *p)
@@ -419,17 +422,12 @@ panel_start_gui(panel *p)
     }
 
     // main layout manager as a single child of background widget box
-    p->lbox = p->my_box_new(FALSE, 0);
-    gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
-    gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox);
-    gtk_widget_show(p->lbox);
-    if (p->round_corners)
-        make_round_corners(p);
-
-    p->box = p->my_box_new(FALSE, p->spacing);
+    p->box = p->my_box_new(FALSE, 0);
     gtk_container_set_border_width(GTK_CONTAINER(p->box), 0);
-    gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE, 0);
+    gtk_container_add(GTK_CONTAINER(p->bbox), p->box);
     gtk_widget_show(p->box);
+    if (p->round_corners)
+        make_round_corners(p);
 
     p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window);
     DBG("topxwin = %x\n", p->topxwin);
@@ -474,6 +472,40 @@ panel_start_gui(panel *p)
     RET();
 }
 
+void panel_set_orientation(panel *p)
+{
+    GList* l;
+    p->orientation = (p->edge == EDGE_TOP || p->edge == EDGE_BOTTOM)
+        ? ORIENT_HORIZ : ORIENT_VERT;
+    if (p->orientation == ORIENT_HORIZ) {
+        p->my_box_new = gtk_hbox_new;
+        p->my_separator_new = gtk_vseparator_new;
+    } else {
+        p->my_box_new = gtk_vbox_new;
+        p->my_separator_new = gtk_hseparator_new;
+    }
+
+    /* recreate the main layout box */
+    if( p->box ) {
+        GtkBox* newbox = recreate_box( p->box, p->orientation );
+        if( newbox != p->box ) {
+            p->box = newbox;
+            gtk_container_add( p->bbox, newbox );
+        }
+    }
+    /* NOTE: This loop won't be executed when panel started since
+       plugins are not loaded at that time.
+       This is used when the orientation of the panel is changed
+       from the config dialog, and plugins should be re-layout.
+    */
+    for( l = p->plugins; l; l = l->next ) {
+        plugin* pl = (plugin*)l->data;
+        if( pl->class->orientation ) {
+            pl->class->orientation( pl );
+        }
+    }
+}
+
 static int
 panel_parse_global(panel *p, char **fp)
 {
@@ -527,15 +559,7 @@ panel_parse_global(panel *p, char **fp)
             RET(0);
         }
     }
-    p->orientation = (p->edge == EDGE_TOP || p->edge == EDGE_BOTTOM)
-        ? ORIENT_HORIZ : ORIENT_VERT;
-    if (p->orientation == ORIENT_HORIZ) {
-        p->my_box_new = gtk_hbox_new;
-        p->my_separator_new = gtk_vseparator_new;
-    } else {
-        p->my_box_new = gtk_vbox_new;
-        p->my_separator_new = gtk_hseparator_new;
-    }
+    panel_set_orientation( p );
     if (p->width < 0)
         p->width = 100;
     if (p->widthtype == WIDTH_PERCENT && p->width > 100)
index e89e8f9..9039926 100644 (file)
@@ -15,7 +15,11 @@ enum { ALLIGN_NONE, ALLIGN_LEFT, ALLIGN_CENTER, ALLIGN_RIGHT  };
 enum { EDGE_NONE, EDGE_LEFT, EDGE_RIGHT, EDGE_TOP, EDGE_BOTTOM };
 enum { WIDTH_NONE, WIDTH_REQUEST, WIDTH_PIXEL, WIDTH_PERCENT };
 enum { HEIGHT_NONE, HEIGHT_PIXEL, HEIGHT_REQUEST };
-enum { ORIENT_NONE, ORIENT_VERT, ORIENT_HORIZ };
+enum {
+    ORIENT_NONE = -1,
+    ORIENT_VERT = GTK_ORIENTATION_VERTICAL,
+    ORIENT_HORIZ = GTK_ORIENTATION_HORIZONTAL
+};
 enum { POS_NONE, POS_START, POS_END };
 
 #define PANEL_HEIGHT_DEFAULT  26
@@ -27,9 +31,8 @@ typedef struct {
 
     GtkWidget *topgwin;           /* main panel window */
     Window topxwin;               /* and it X window   */
-    GtkWidget *lbox;              /* primary layout box */
+    GtkWidget *box;              /* primary layout box which contains all plugins */
     GtkWidget *bbox;              /* backgound box for box */
-    GtkWidget *box;               /* box that contains all plugins */
     GtkRequisition requisition;
     GtkWidget *(*my_box_new) (gboolean, gint);
     GtkWidget *(*my_separator_new) ();
@@ -155,5 +158,6 @@ extern FbEv *fbev;
 
 void panel_set_wm_strut(panel *p);
 void panel_set_dock_type(panel *p);
+void panel_set_orientation(panel *p);
 
 #endif
index 31317d7..8dc2420 100644 (file)
@@ -28,7 +28,7 @@ typedef struct {
     void (*destructor)(struct _plugin *this);
     void (*config)(struct _plugin *this, GtkWindow* parent); /* config UI */
     void (*save)(struct _plugin *this, FILE* fp);
-
+    void (*orientation)(struct _plugin *this);
 } plugin_class;
 
 typedef struct _plugin{
index b709c55..a44a18f 100644 (file)
@@ -32,6 +32,8 @@ typedef struct {
 
 //static dclock me;
 
+static void
+update_label_orient( plugin* p );
 
 
 static  gboolean
@@ -53,11 +55,11 @@ clock_update(gpointer data )
     struct tm * detail;
     dclock *dc;
     gchar *utf8;
-    
+
     ENTER;
     g_assert(data != NULL);
     dc = (dclock *)data;
-    
+
     time(&now);
     detail = localtime(&now);
     strftime(output, sizeof(output), dc->cfmt, detail) ;
@@ -99,7 +101,7 @@ dclock_constructor(plugin *p, char** fp)
                 goto error;
             }
             if (s.type == LINE_VAR) {
-                if (!g_ascii_strcasecmp(s.t[0], "ClockFmt")) 
+                if (!g_ascii_strcasecmp(s.t[0], "ClockFmt"))
                     dc->cfmt = g_strdup(s.t[1]);
                 else if (!g_ascii_strcasecmp(s.t[0], "TooltipFmt"))
                     dc->tfmt = g_strdup(s.t[1]);
@@ -129,7 +131,7 @@ dclock_constructor(plugin *p, char** fp)
     dc->clockw = gtk_label_new("");
     gtk_misc_set_alignment(GTK_MISC(dc->clockw), 0.5, 0.5);
     gtk_misc_set_padding(GTK_MISC(dc->clockw), 4, 0);
-    //gtk_widget_show(dc->clockw);
+    update_label_orient( p );
     gtk_container_add(GTK_CONTAINER(dc->main), dc->clockw);
     gtk_widget_show_all(dc->main);
     dc->tip = gtk_tooltips_new();
@@ -204,6 +206,22 @@ static void save_config( plugin* p, FILE* fp )
     lxpanel_put_str( fp, "Action", dc->action );
 }
 
+static void
+update_label_orient( plugin* p )
+{
+    dclock *dc = (dclock *)p->priv;
+    GtkLabel* label = GTK_LABEL(dc->clockw);
+    /* FIXME: gtk+ has only limited support for this, sigh! */
+    gdouble angle;
+    if( p->panel->edge == EDGE_LEFT )
+        angle = 90.0;
+    else if( p->panel->edge == EDGE_RIGHT )
+        angle = 270.0;
+    else
+        angle = 0.0;
+    gtk_label_set_angle( GTK_LABEL(label), angle );
+}
+
 plugin_class dclock_plugin_class = {
     fname: NULL,
     count: 0,
@@ -216,5 +234,6 @@ plugin_class dclock_plugin_class = {
     constructor : dclock_constructor,
     destructor  : dclock_destructor,
     config : dclock_config,
-    save : save_config
+    save : save_config,
+    orientation : update_label_orient
 };
index 538daec..63c28e8 100644 (file)
@@ -395,6 +395,19 @@ static void save_config( plugin* p, FILE* fp )
     }
 }
 
+static void orientation_changed( plugin* p )
+{
+    launchbar *lb = (launchbar *)p->priv;
+    GtkBox* newbox;
+    newbox = recreate_box( lb->box, p->panel->orientation );
+    if( newbox != lb->box ) {
+        /* Since the old box has been destroyed,
+        we need to re-add the new box to the container */
+        lb->box = newbox;
+        gtk_container_add(GTK_CONTAINER(p->pwid), lb->box);
+    }
+}
+
 plugin_class launchbar_plugin_class = {
     fname: NULL,
     count: 0,
@@ -407,5 +420,6 @@ plugin_class launchbar_plugin_class = {
     constructor : launchbar_constructor,
     destructor  : launchbar_destructor,
     config : NULL,
-    save : save_config
+    save : save_config,
+    orientation : orientation_changed
 };
index 4e80f74..2fdc9fc 100644 (file)
@@ -28,12 +28,12 @@ separator_constructor(plugin *p, char **fp)
     /*
     g_signal_connect(G_OBJECT(eb), "expose_event",
           G_CALLBACK(gtk_widget_queue_draw), NULL);
-         */
+    */
     sep = p->panel->my_separator_new();
     gtk_widget_show(sep);
     gtk_container_add (GTK_CONTAINER (eb), sep);
     gtk_container_add(GTK_CONTAINER(p->pwid), eb);
-    p->priv = g_new0(int, 1); /* just to alloc smth */
+    p->priv = eb; /* just to alloc smth */
 
     RET(1);
 }
@@ -42,10 +42,28 @@ static void
 separator_destructor(plugin *p)
 {
     ENTER;
-    g_free(p->priv);
+    GtkWidget* eb = (GtkEventBox*)p->priv;
+    gtk_widget_destroy( eb );
     RET();
 }
 
+static void orientation_changed( plugin* p )
+{
+    GtkWidget* eb = (GtkEventBox*)p->priv;
+    GtkWidget* sep = gtk_bin_get_child( GTK_BIN(eb) );
+    if( GTK_IS_VSEPARATOR(sep) ) {
+        if( p->panel->orientation == GTK_ORIENTATION_HORIZONTAL )
+            return;
+    }
+    else {
+        if( p->panel->orientation == GTK_ORIENTATION_VERTICAL )
+            return;
+    }
+    gtk_widget_destroy( sep );
+    sep = p->panel->my_separator_new();
+    gtk_widget_show(sep);
+    gtk_container_add (GTK_CONTAINER (eb), sep);
+}
 
 plugin_class separator_plugin_class = {
     fname: NULL,
@@ -59,5 +77,6 @@ plugin_class separator_plugin_class = {
     constructor : separator_constructor,
     destructor  : separator_destructor,
     config : NULL,
-    save : NULL
+    save : NULL,
+    orientation : orientation_changed
 };
index ea2f8f9..48f03c9 100644 (file)
@@ -56,24 +56,19 @@ typedef struct _task{
     unsigned int flash_state:1;
 } task;
 
-
-
 typedef struct _taskbar{
     plugin *plug;
     Window *wins;
     Window topxwin;
     int win_num;
     GHashTable  *task_list;
-    GtkWidget *hbox, *bar, *space, *menu;
+    GtkWidget *bar, *menu;
     GtkTooltips *tips;
     GdkPixbuf *gen_pixbuf;
     GtkStateType normal_state;
     GtkStateType focused_state;
     int num_tasks;
-    int task_width;
     int vis_task_num;
-    int req_width;
-    int hbox_width;
     int spacing;
     int cur_desk;
     task *focused;
@@ -96,7 +91,6 @@ typedef struct _taskbar{
     gboolean use_urgency_hint;// : 1;
 } taskbar;
 
-
 static gchar *taskbar_rc = "style 'taskbar-style'\n"
 "{\n"
 "GtkWidget::focus-line-width = 0\n"
@@ -127,6 +121,10 @@ static void tk_flash_window( task *tk );
 static void tk_unflash_window( task *tk );
 static void tk_raise_window( task *tk, guint32 time );
 
+static void
+update_label_orient( GtkWidget* child, gpointer user_data );
+
+
 #define TASK_VISIBLE(tb, tk) \
  ((tk)->desktop == (tb)->cur_desk || (tk)->desktop == -1 /* 0xFFFFFFFF */ )
 
@@ -859,9 +857,7 @@ tk_build_gui(taskbar *tb, task *tk)
 
     /* name */
     tk->label = gtk_label_new(tk->iconified ? tk->iname : tk->name);
-    //gtk_label_set_justify(GTK_LABEL(tk->label), GTK_JUSTIFY_LEFT);
-    gtk_label_set_ellipsize(GTK_LABEL(tk->label), PANGO_ELLIPSIZE_END);
-    gtk_misc_set_alignment(GTK_MISC(tk->label), 0.0, 0.5);
+    update_label_orient( tk->label, tb->plug );
     if (!tb->icons_only)
         gtk_widget_show(tk->label);
     gtk_box_pack_start(GTK_BOX(w1), tk->label, TRUE, TRUE, 0);
@@ -955,8 +951,6 @@ tb_net_client_list(GtkWidget *widget, taskbar *tb)
     RET();
 }
 
-
-
 static void
 tb_net_current_desktop(GtkWidget *widget, taskbar *tb)
 {
@@ -966,7 +960,6 @@ tb_net_current_desktop(GtkWidget *widget, taskbar *tb)
     RET();
 }
 
-
 static void
 tb_net_number_of_desktops(GtkWidget *widget, taskbar *tb)
 {
@@ -1240,10 +1233,10 @@ static void
 taskbar_build_gui(plugin *p)
 {
     taskbar *tb = (taskbar *)p->priv;
-    GtkBarOrientation  bo;
+    GtkOrientation  bo;
 
     ENTER;
-    bo = (tb->plug->panel->orientation == ORIENT_HORIZ) ? GTK_BAR_HORIZ : GTK_BAR_VERTICAL;
+    bo = (tb->plug->panel->orientation == ORIENT_HORIZ) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
     tb->bar = gtk_bar_new(bo, tb->spacing);
     if (tb->icons_only) {
         gtk_bar_set_max_child_size(GTK_BAR(tb->bar),
@@ -1460,6 +1453,55 @@ static void save_config( plugin* p, FILE* fp )
     lxpanel_put_int( fp, "spacing", tb->spacing );
 }
 
+static void
+update_label_orient( GtkWidget* child, gpointer user_data )
+{
+    /* FIXME: gtk+ has only limited support for this, sigh! */
+    plugin* p = (plugin*)user_data;
+    if( GTK_IS_LABEL(child) ) {
+        gdouble angle;
+        if( p->panel->edge == EDGE_LEFT ) {
+            angle = 90.0;
+            /* FIXME: ellipsize cannot be used in conjunction with angle.
+                      This is the limit of gtk+, and turn off ellipsize do
+                      cause problems here. How can this be solved? Sigh!
+            */
+            gtk_label_set_ellipsize( child, PANGO_ELLIPSIZE_NONE );
+        }
+        else if( p->panel->edge == EDGE_RIGHT ) {
+            angle = 270.0;
+            gtk_label_set_ellipsize( child, PANGO_ELLIPSIZE_NONE );
+        }
+        else {
+            angle = 0.0;
+            gtk_label_set_ellipsize( child, PANGO_ELLIPSIZE_END );
+        }
+        gtk_label_set_angle( GTK_LABEL(child), angle );
+        gtk_misc_set_alignment(GTK_MISC(child), 0.0, 0.5);
+    }
+}
+
+static void orientation_changed( plugin* p )
+{
+    taskbar *tb = (taskbar *)p->priv;
+    GList *child, *children;
+
+    children = gtk_container_get_children( GTK_CONTAINER (tb->bar) );
+    for( child = children; child; child = child->next ) {
+        GtkWidget *button = GTK_WIDGET(child->data);
+        GtkBox *box = (GtkBox*)gtk_bin_get_child( GTK_BIN(button) );
+        GtkBox *newbox = recreate_box( box, p->panel->orientation );
+        if( newbox != box ) {
+            gtk_container_add( GTK_CONTAINER(button), newbox );
+        }
+        gtk_container_foreach( GTK_CONTAINER(newbox),
+                               update_label_orient, p );
+    }
+    g_list_free( children );
+
+    gtk_bar_set_orientation( tb->bar, p->panel->orientation );
+}
+
 plugin_class taskbar_plugin_class = {
     fname: NULL,
     count: 0,
@@ -1472,6 +1514,7 @@ plugin_class taskbar_plugin_class = {
     constructor : taskbar_constructor,
     destructor  : taskbar_destructor,
     config : taskbar_config,
-    save : save_config
+    save : save_config,
+    orientation : orientation_changed
 };
 
index a2e093a..719f20b 100644 (file)
@@ -64,7 +64,7 @@ message_sent (EggTrayManager *manager, GtkWidget *icon, const char *text, glong
 {
     /* FIXME multihead */
     int x, y;
-    
+
     gdk_window_get_origin (icon->window, &x, &y);
     fixed_tip_show (0, x, y, FALSE, gdk_screen_height () - 50, text);
 }
@@ -73,7 +73,7 @@ static void
 message_cancelled (EggTrayManager *manager, GtkWidget *icon, glong id,
                    void *data)
 {
-  
+
 }
 
 
@@ -92,7 +92,7 @@ tray_destructor(plugin *p)
     RET();
 }
 
-    
+
 
 
 static int
@@ -102,7 +102,7 @@ tray_constructor(plugin *p, char** fp)
     tray *tr;
     GdkScreen *screen;
     //GtkWidget *frame;
-    
+
     ENTER;
     s.len = 256;
     if( fp )
@@ -130,7 +130,7 @@ tray_constructor(plugin *p, char** fp)
     //gtk_bgbox_set_background(p->pwid, BG_STYLE, 0, 0);
     gtk_container_set_border_width(GTK_CONTAINER(p->pwid), 0);
     screen = gtk_widget_get_screen (GTK_WIDGET (p->panel->topgwin));
-    
+
     if (egg_tray_manager_check_running(screen)) {
         tr->tray_manager = NULL;
         ERR("tray: another systray already running\n");
@@ -139,17 +139,29 @@ tray_constructor(plugin *p, char** fp)
     tr->tray_manager = egg_tray_manager_new ();
     if (!egg_tray_manager_manage_screen (tr->tray_manager, screen))
         g_printerr ("tray: System tray didn't get the system tray manager selection\n");
-    
+
     g_signal_connect (tr->tray_manager, "tray_icon_added", G_CALLBACK (tray_added), tr);
     g_signal_connect (tr->tray_manager, "tray_icon_removed", G_CALLBACK (tray_removed), tr);
     g_signal_connect (tr->tray_manager, "message_sent", G_CALLBACK (message_sent), tr);
     g_signal_connect (tr->tray_manager, "message_cancelled", G_CALLBACK (message_cancelled), tr);
-    
+
     gtk_widget_show_all(tr->box);
     RET(1);
 
 }
 
+static void orientation_changed( plugin* p )
+{
+    tray *tr = (tray *)p->priv;
+    GtkBox* newbox;
+    newbox = recreate_box( tr->box, p->panel->orientation );
+    if( newbox != tr->box ) {
+        /* Since the old box has been destroyed,
+        we need to re-add the new box to the container */
+        tr->box = newbox;
+        gtk_container_add(GTK_CONTAINER(p->pwid), tr->box);
+    }
+}
 
 plugin_class tray_plugin_class = {
     fname: NULL,
@@ -163,5 +175,6 @@ plugin_class tray_plugin_class = {
     constructor : tray_constructor,
     destructor  : tray_destructor,
     config : NULL,
-    save : NULL
+    save : NULL,
+    orientation : orientation_changed
 };