unix/gtkpanel.c

   1 /*
   2  * gtkpanel.c - implementation of the `Panels' GTK layout container.
   3  */
   4
   5 #include "gtkpanel.h"
   6
   7 static void panels_init(Panels *panels);
   8 static void panels_class_init(PanelsClass *klass);
   9 static void panels_map(GtkWidget *widget);
  10 static void panels_unmap(GtkWidget *widget);
  11 static void panels_draw(GtkWidget *widget, GdkRectangle *area);
  12 static gint panels_expose(GtkWidget *widget, GdkEventExpose *event);
  13 static void panels_base_add(GtkContainer *container, GtkWidget *widget);
  14 static void panels_remove(GtkContainer *container, GtkWidget *widget);
  15 static void panels_forall(GtkContainer *container, gboolean include_internals,
  16                            GtkCallback callback, gpointer callback_data);
  17 static GtkType panels_child_type(GtkContainer *container);
  18 static void panels_size_request(GtkWidget *widget, GtkRequisition *req);
  19 static void panels_size_allocate(GtkWidget *widget, GtkAllocation *alloc);
  20
  21 static GtkContainerClass *parent_class = NULL;
  22
  23 GtkType panels_get_type(void)
  24 {
  25     static GtkType panels_type = 0;
  26
  27     if (!panels_type) {
  28         static const GtkTypeInfo panels_info = {
  29             "Panels",
  30             sizeof(Panels),
  31             sizeof(PanelsClass),
  32             (GtkClassInitFunc) panels_class_init,
  33             (GtkObjectInitFunc) panels_init,
  34             /* reserved_1 */ NULL,
  35             /* reserved_2 */ NULL,
  36             (GtkClassInitFunc) NULL,
  37         };
  38
  39         panels_type = gtk_type_unique(GTK_TYPE_CONTAINER, &panels_info);
  40     }
  41
  42     return panels_type;
  43 }
  44
  45 static void panels_class_init(PanelsClass *klass)
  46 {
  47     GtkObjectClass *object_class;
  48     GtkWidgetClass *widget_class;
  49     GtkContainerClass *container_class;
  50
  51     object_class = (GtkObjectClass *)klass;
  52     widget_class = (GtkWidgetClass *)klass;
  53     container_class = (GtkContainerClass *)klass;
  54
  55     parent_class = gtk_type_class(GTK_TYPE_CONTAINER);
  56
  57     /*
  58      * FIXME: do we have to do all this faffing with set_arg,
  59      * get_arg and child_arg_type? Ick.
  60      */
  61
  62     widget_class->map = panels_map;
  63     widget_class->unmap = panels_unmap;
  64     widget_class->draw = panels_draw;
  65     widget_class->expose_event = panels_expose;
  66     widget_class->size_request = panels_size_request;
  67     widget_class->size_allocate = panels_size_allocate;
  68
  69     container_class->add = panels_base_add;
  70     container_class->remove = panels_remove;
  71     container_class->forall = panels_forall;
  72     container_class->child_type = panels_child_type;
  73 }
  74
  75 static void panels_init(Panels *panels)
  76 {
  77     GTK_WIDGET_SET_FLAGS(panels, GTK_NO_WINDOW);
  78
  79     panels->children = NULL;
  80 }
  81
  82 /*
  83  * These appear to be thoroughly tedious functions; the only reason
  84  * we have to reimplement them at all is because we defined our own
  85  * format for our GList of children...
  86  */
  87 static void panels_map(GtkWidget *widget)
  88 {
  89     Panels *panels;
  90     GtkWidget *child;
  91     GList *children;
  92
  93     g_return_if_fail(widget != NULL);
  94     g_return_if_fail(IS_PANELS(widget));
  95
  96     panels = PANELS(widget);
  97     GTK_WIDGET_SET_FLAGS(panels, GTK_MAPPED);
  98
  99     for (children = panels->children;
 100          children && (child = children->data);
 101          children = children->next) {
 102         if (child &&
 103             GTK_WIDGET_VISIBLE(child) &&
 104             !GTK_WIDGET_MAPPED(child))
 105             gtk_widget_map(child);
 106     }
 107 }
 108 static void panels_unmap(GtkWidget *widget)
 109 {
 110     Panels *panels;
 111     GtkWidget *child;
 112     GList *children;
 113
 114     g_return_if_fail(widget != NULL);
 115     g_return_if_fail(IS_PANELS(widget));
 116
 117     panels = PANELS(widget);
 118     GTK_WIDGET_UNSET_FLAGS(panels, GTK_MAPPED);
 119
 120     for (children = panels->children;
 121          children && (child = children->data);
 122          children = children->next) {
 123         if (child &&
 124             GTK_WIDGET_VISIBLE(child) &&
 125             GTK_WIDGET_MAPPED(child))
 126             gtk_widget_unmap(child);
 127     }
 128 }
 129 static void panels_draw(GtkWidget *widget, GdkRectangle *area)
 130 {
 131     Panels *panels;
 132     GtkWidget *child;
 133     GList *children;
 134     GdkRectangle child_area;
 135
 136     g_return_if_fail(widget != NULL);
 137     g_return_if_fail(IS_PANELS(widget));
 138
 139     if (GTK_WIDGET_DRAWABLE(widget)) {
 140         panels = PANELS(widget);
 141
 142         for (children = panels->children;
 143              children && (child = children->data);
 144              children = children->next) {
 145             if (child &&
 146                 GTK_WIDGET_DRAWABLE(child) &&
 147                 gtk_widget_intersect(child, area, &child_area))
 148                 gtk_widget_draw(child, &child_area);
 149         }
 150     }
 151 }
 152 static gint panels_expose(GtkWidget *widget, GdkEventExpose *event)
 153 {
 154     Panels *panels;
 155     GtkWidget *child;
 156     GList *children;
 157     GdkEventExpose child_event;
 158
 159     g_return_val_if_fail(widget != NULL, FALSE);
 160     g_return_val_if_fail(IS_PANELS(widget), FALSE);
 161     g_return_val_if_fail(event != NULL, FALSE);
 162
 163     if (GTK_WIDGET_DRAWABLE(widget)) {
 164         panels = PANELS(widget);
 165         child_event = *event;
 166
 167         for (children = panels->children;
 168              children && (child = children->data);
 169              children = children->next) {
 170             if (child &&
 171                 GTK_WIDGET_DRAWABLE(child) &&
 172                 GTK_WIDGET_NO_WINDOW(child) &&
 173                 gtk_widget_intersect(child, &event->area,
 174                                      &child_event.area))
 175                 gtk_widget_event(child, (GdkEvent *)&child_event);
 176         }
 177     }
 178     return FALSE;
 179 }
 180
 181 static void panels_base_add(GtkContainer *container, GtkWidget *widget)
 182 {
 183     Panels *panels;
 184
 185     g_return_if_fail(container != NULL);
 186     g_return_if_fail(IS_PANELS(container));
 187     g_return_if_fail(widget != NULL);
 188
 189     panels = PANELS(container);
 190
 191     panels_add(panels, widget);
 192 }
 193
 194 static void panels_remove(GtkContainer *container, GtkWidget *widget)
 195 {
 196     Panels *panels;
 197     GtkWidget *child;
 198     GList *children;
 199     gboolean was_visible;
 200
 201     g_return_if_fail(container != NULL);
 202     g_return_if_fail(IS_PANELS(container));
 203     g_return_if_fail(widget != NULL);
 204
 205     panels = PANELS(container);
 206
 207     for (children = panels->children;
 208          children && (child = children->data);
 209          children = children->next) {
 210         if (child != widget)
 211             continue;
 212
 213         was_visible = GTK_WIDGET_VISIBLE(widget);
 214         gtk_widget_unparent(widget);
 215         panels->children = g_list_remove_link(panels->children, children);
 216         g_list_free(children);
 217         if (was_visible)
 218             gtk_widget_queue_resize(GTK_WIDGET(container));
 219         break;
 220     }
 221 }
 222
 223 static void panels_forall(GtkContainer *container, gboolean include_internals,
 224                            GtkCallback callback, gpointer callback_data)
 225 {
 226     Panels *panels;
 227     GtkWidget *child;
 228     GList *children;
 229
 230     g_return_if_fail(container != NULL);
 231     g_return_if_fail(IS_PANELS(container));
 232     g_return_if_fail(callback != NULL);
 233
 234     panels = PANELS(container);
 235
 236     for (children = panels->children;
 237          children && (child = children->data);
 238          children = children->next)
 239         if (child)
 240             callback(child, callback_data);
 241 }
 242
 243 static GtkType panels_child_type(GtkContainer *container)
 244 {
 245     return GTK_TYPE_WIDGET;
 246 }
 247
 248 GtkWidget *panels_new(void)
 249 {
 250     Panels *panels;
 251
 252     panels = gtk_type_new(panels_get_type());
 253
 254     return GTK_WIDGET(panels);
 255 }
 256
 257 void panels_add(Panels *panels, GtkWidget *child)
 258 {
 259     g_return_if_fail(panels != NULL);
 260     g_return_if_fail(IS_PANELS(panels));
 261     g_return_if_fail(child != NULL);
 262     g_return_if_fail(child->parent == NULL);
 263
 264     panels->children = g_list_append(panels->children, child);
 265
 266     gtk_widget_set_parent(child, GTK_WIDGET(panels));
 267
 268     if (GTK_WIDGET_REALIZED(panels))
 269         gtk_widget_realize(child);
 270
 271     if (GTK_WIDGET_VISIBLE(panels)) {
 272         if (GTK_WIDGET_MAPPED(panels))
 273             gtk_widget_map(child);
 274         gtk_widget_queue_resize(child);
 275     }
 276 }
 277
 278 void panels_switch_to(Panels *panels, GtkWidget *target)
 279 {
 280     GtkWidget *child;
 281     GList *children;
 282     gboolean changed;
 283
 284     g_return_if_fail(panels != NULL);
 285     g_return_if_fail(IS_PANELS(panels));
 286     g_return_if_fail(target != NULL);
 287     g_return_if_fail(target->parent == GTK_WIDGET(panels));
 288
 289     for (children = panels->children;
 290          children && (child = children->data);
 291          children = children->next) {
 292
 293         if (!child)
 294             continue;
 295
 296         if (child == target) {
 297             if (!GTK_WIDGET_VISIBLE(child)) {
 298                 gtk_widget_show(child);
 299                 changed = TRUE;
 300             }
 301         } else {
 302             if (GTK_WIDGET_VISIBLE(child)) {
 303                 gtk_widget_hide(child);
 304                 changed = TRUE;
 305             }
 306         }
 307     }
 308     if (changed)
 309         gtk_widget_queue_resize(child);
 310 }
 311
 312 /*
 313  * Now here comes the interesting bit. The actual layout part is
 314  * done in the following two functions:
 315  *
 316  * panels_size_request() examines the list of widgets held in the
 317  * Panels, and returns a requisition stating the absolute minimum
 318  * size it can bear to be.
 319  *
 320  * panels_size_allocate() is given an allocation telling it what
 321  * size the whole container is going to be, and it calls
 322  * gtk_widget_size_allocate() on all of its (visible) children to
 323  * set their size and position relative to the top left of the
 324  * container.
 325  */
 326
 327 static void panels_size_request(GtkWidget *widget, GtkRequisition *req)
 328 {
 329     Panels *panels;
 330     GtkWidget *child;
 331     GList *children;
 332
 333     g_return_if_fail(widget != NULL);
 334     g_return_if_fail(IS_PANELS(widget));
 335     g_return_if_fail(req != NULL);
 336
 337     panels = PANELS(widget);
 338
 339     req->width = 0;
 340     req->height = 0;
 341
 342     for (children = panels->children;
 343          children && (child = children->data);
 344          children = children->next) {
 345         GtkRequisition creq;
 346
 347         gtk_widget_size_request(child, &creq);
 348         if (req->width < creq.width)
 349             req->width = creq.width;
 350         if (req->height < creq.height)
 351             req->height = creq.height;
 352     }
 353
 354     req->width += 2*GTK_CONTAINER(panels)->border_width;
 355     req->height += 2*GTK_CONTAINER(panels)->border_width;
 356 }
 357
 358 static void panels_size_allocate(GtkWidget *widget, GtkAllocation *alloc)
 359 {
 360     Panels *panels;
 361     GtkWidget *child;
 362     GList *children;
 363     gint border;
 364
 365     g_return_if_fail(widget != NULL);
 366     g_return_if_fail(IS_PANELS(widget));
 367     g_return_if_fail(alloc != NULL);
 368
 369     panels = PANELS(widget);
 370     widget->allocation = *alloc;
 371     border = GTK_CONTAINER(panels)->border_width;
 372
 373     for (children = panels->children;
 374          children && (child = children->data);
 375          children = children->next) {
 376         GtkAllocation call;
 377
 378         /* Only take visible widgets into account. */
 379         if (!GTK_WIDGET_VISIBLE(child))
 380             continue;
 381
 382         call.x = alloc->x + border;
 383         call.width = alloc->width - 2*border;
 384         call.y = alloc->y + border;
 385         call.height = alloc->height - 2*border;
 386
 387         gtk_widget_size_allocate(child, &call);
 388     }
 389 }