Commit | Line | Data |
---|---|---|
c67daf87 | 1 | /* /////////////////////////////////////////////////////////////////////////// |
c67d8618 | 2 | // Name: win_gtk.c |
ed673c6a RR |
3 | // Purpose: Native GTK+ widget for wxWindows, based on GtkLayout and |
4 | // GtkFixed. It makes use of the gravity window property and | |
5 | // therefore does not work with GTK 1.0. | |
c801d85f | 6 | // Author: Robert Roebling |
c67d8618 | 7 | // Id: $Id$ |
01111366 | 8 | // Copyright: (c) 1998 Robert Roebling |
bf3dab48 | 9 | // Licence: wxWindows licence |
c67daf87 | 10 | /////////////////////////////////////////////////////////////////////////// */ |
c801d85f | 11 | |
d02af7bb JJ |
12 | #ifdef VMS |
13 | #define XCheckIfEvent XCHECKIFEVENT | |
3fa056ab | 14 | #endif |
27df579a | 15 | |
d02af7bb | 16 | #include "wx/setup.h" |
27df579a | 17 | #include "wx/gtk/win_gtk.h" |
034be888 | 18 | #include "gtk/gtksignal.h" |
ed673c6a RR |
19 | #include "gtk/gtkprivate.h" |
20 | #include "gdk/gdkx.h" | |
38c7b3d3 | 21 | |
c801d85f KB |
22 | #ifdef __cplusplus |
23 | extern "C" { | |
24 | #endif /* __cplusplus */ | |
25 | ||
c916e13b RR |
26 | #include <X11/Xlib.h> |
27 | #include <X11/Xutil.h> | |
28 | #include <X11/Xatom.h> | |
29 | ||
ed673c6a RR |
30 | #define IS_ONSCREEN(x,y) ((x >= G_MINSHORT) && (x <= G_MAXSHORT) && \ |
31 | (y >= G_MINSHORT) && (y <= G_MAXSHORT)) | |
32 | ||
da048e3d | 33 | typedef struct _GtkPizzaAdjData GtkPizzaAdjData; |
ed673c6a | 34 | |
bf3dab48 | 35 | struct _GtkPizzaAdjData |
ed673c6a RR |
36 | { |
37 | gint dx; | |
38 | gint dy; | |
39 | }; | |
40 | ||
b6fa52db RR |
41 | static void gtk_pizza_class_init (GtkPizzaClass *klass); |
42 | static void gtk_pizza_init (GtkPizza *pizza); | |
ed673c6a | 43 | |
b6fa52db RR |
44 | static void gtk_pizza_realize (GtkWidget *widget); |
45 | static void gtk_pizza_unrealize (GtkWidget *widget); | |
ed673c6a | 46 | |
b6fa52db | 47 | static void gtk_pizza_map (GtkWidget *widget); |
ed673c6a | 48 | |
da048e3d | 49 | static void gtk_pizza_size_request (GtkWidget *widget, |
bf3dab48 | 50 | GtkRequisition *requisition); |
da048e3d | 51 | static void gtk_pizza_size_allocate (GtkWidget *widget, |
bf3dab48 | 52 | GtkAllocation *allocation); |
da048e3d | 53 | static void gtk_pizza_draw (GtkWidget *widget, |
bf3dab48 | 54 | GdkRectangle *area); |
da048e3d | 55 | static gint gtk_pizza_expose (GtkWidget *widget, |
bf3dab48 | 56 | GdkEventExpose *event); |
da048e3d | 57 | static void gtk_pizza_add (GtkContainer *container, |
bf3dab48 | 58 | GtkWidget *widget); |
da048e3d | 59 | static void gtk_pizza_remove (GtkContainer *container, |
bf3dab48 | 60 | GtkWidget *widget); |
b6fa52db RR |
61 | static void gtk_pizza_forall (GtkContainer *container, |
62 | gboolean include_internals, | |
63 | GtkCallback callback, | |
64 | gpointer callback_data); | |
ed673c6a | 65 | |
da048e3d | 66 | static void gtk_pizza_position_child (GtkPizza *pizza, |
b6fa52db | 67 | GtkPizzaChild *child); |
da048e3d | 68 | static void gtk_pizza_allocate_child (GtkPizza *pizza, |
b6fa52db | 69 | GtkPizzaChild *child); |
da048e3d | 70 | static void gtk_pizza_position_children (GtkPizza *pizza); |
ed673c6a | 71 | |
da048e3d | 72 | static void gtk_pizza_adjust_allocations_recurse (GtkWidget *widget, |
b6fa52db RR |
73 | gpointer cb_data); |
74 | static void gtk_pizza_adjust_allocations (GtkPizza *pizza, | |
75 | gint dx, | |
76 | gint dy); | |
ed673c6a RR |
77 | |
78 | ||
3ca6a5f0 BP |
79 | /* unused */ |
80 | #if 0 | |
b6fa52db RR |
81 | static void gtk_pizza_expose_area (GtkPizza *pizza, |
82 | gint x, | |
83 | gint y, | |
84 | gint width, | |
85 | gint height); | |
da048e3d | 86 | static void gtk_pizza_adjustment_changed (GtkAdjustment *adjustment, |
b6fa52db | 87 | GtkPizza *pizza); |
f6bcfd97 BP |
88 | #endif |
89 | ||
da048e3d | 90 | static GdkFilterReturn gtk_pizza_filter (GdkXEvent *gdk_xevent, |
b6fa52db RR |
91 | GdkEvent *event, |
92 | gpointer data); | |
da048e3d | 93 | static GdkFilterReturn gtk_pizza_main_filter (GdkXEvent *gdk_xevent, |
b6fa52db RR |
94 | GdkEvent *event, |
95 | gpointer data); | |
ed673c6a RR |
96 | |
97 | ||
da048e3d | 98 | static GtkType gtk_pizza_child_type (GtkContainer *container); |
c801d85f | 99 | |
b6fa52db | 100 | static void gtk_pizza_scroll_set_adjustments (GtkPizza *pizza, |
bf3dab48 VZ |
101 | GtkAdjustment *hadj, |
102 | GtkAdjustment *vadj); | |
c801d85f KB |
103 | |
104 | ||
034be888 | 105 | static GtkContainerClass *parent_class = NULL; |
ed673c6a | 106 | static gboolean gravity_works; |
034be888 | 107 | |
c801d85f | 108 | guint |
da048e3d | 109 | gtk_pizza_get_type () |
c801d85f | 110 | { |
da048e3d | 111 | static guint pizza_type = 0; |
c801d85f | 112 | |
da048e3d | 113 | if (!pizza_type) |
c801d85f | 114 | { |
da048e3d | 115 | GtkTypeInfo pizza_info = |
053f9cc1 | 116 | { |
bf3dab48 VZ |
117 | "GtkPizza", |
118 | sizeof (GtkPizza), | |
119 | sizeof (GtkPizzaClass), | |
120 | (GtkClassInitFunc) gtk_pizza_class_init, | |
121 | (GtkObjectInitFunc) gtk_pizza_init, | |
122 | /* reserved_1 */ NULL, | |
053f9cc1 RR |
123 | /* reserved_2 */ NULL, |
124 | (GtkClassInitFunc) NULL, | |
053f9cc1 | 125 | }; |
da048e3d | 126 | pizza_type = gtk_type_unique (gtk_container_get_type (), &pizza_info); |
c801d85f | 127 | } |
bf3dab48 | 128 | |
da048e3d | 129 | return pizza_type; |
c801d85f KB |
130 | } |
131 | ||
132 | static void | |
da048e3d | 133 | gtk_pizza_class_init (GtkPizzaClass *klass) |
c801d85f | 134 | { |
053f9cc1 RR |
135 | GtkObjectClass *object_class; |
136 | GtkWidgetClass *widget_class; | |
137 | GtkContainerClass *container_class; | |
c801d85f | 138 | |
053f9cc1 RR |
139 | object_class = (GtkObjectClass*) klass; |
140 | widget_class = (GtkWidgetClass*) klass; | |
141 | container_class = (GtkContainerClass*) klass; | |
053f9cc1 | 142 | parent_class = gtk_type_class (GTK_TYPE_CONTAINER); |
c801d85f | 143 | |
da048e3d RR |
144 | widget_class->map = gtk_pizza_map; |
145 | widget_class->realize = gtk_pizza_realize; | |
146 | widget_class->unrealize = gtk_pizza_unrealize; | |
147 | widget_class->size_request = gtk_pizza_size_request; | |
148 | widget_class->size_allocate = gtk_pizza_size_allocate; | |
149 | widget_class->draw = gtk_pizza_draw; | |
150 | widget_class->expose_event = gtk_pizza_expose; | |
053f9cc1 | 151 | |
da048e3d RR |
152 | container_class->add = gtk_pizza_add; |
153 | container_class->remove = gtk_pizza_remove; | |
154 | container_class->forall = gtk_pizza_forall; | |
38c7b3d3 | 155 | |
da048e3d | 156 | container_class->child_type = gtk_pizza_child_type; |
034be888 | 157 | |
da048e3d | 158 | klass->set_scroll_adjustments = gtk_pizza_scroll_set_adjustments; |
034be888 | 159 | |
053f9cc1 | 160 | widget_class->set_scroll_adjustments_signal = |
034be888 | 161 | gtk_signal_new ("set_scroll_adjustments", |
bf3dab48 | 162 | GTK_RUN_LAST, |
31124903 VS |
163 | |
164 | #ifdef __WXGTK20__ | |
a2d8ce85 | 165 | GTK_CLASS_TYPE(object_class), |
31124903 VS |
166 | #else |
167 | object_class->type, | |
168 | #endif | |
bf3dab48 VZ |
169 | GTK_SIGNAL_OFFSET (GtkPizzaClass, set_scroll_adjustments), |
170 | gtk_marshal_NONE__POINTER_POINTER, | |
171 | GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); | |
38c7b3d3 RR |
172 | } |
173 | ||
38c7b3d3 | 174 | static GtkType |
da048e3d | 175 | gtk_pizza_child_type (GtkContainer *container) |
38c7b3d3 | 176 | { |
053f9cc1 | 177 | return GTK_TYPE_WIDGET; |
c801d85f KB |
178 | } |
179 | ||
180 | static void | |
da048e3d | 181 | gtk_pizza_init (GtkPizza *pizza) |
c801d85f | 182 | { |
da048e3d | 183 | GTK_WIDGET_UNSET_FLAGS (pizza, GTK_NO_WINDOW); |
bf3dab48 | 184 | |
da048e3d | 185 | pizza->shadow_type = GTK_MYSHADOW_NONE; |
034be888 | 186 | |
da048e3d | 187 | pizza->children = NULL; |
bf3dab48 | 188 | |
da048e3d RR |
189 | pizza->width = 20; |
190 | pizza->height = 20; | |
ed673c6a | 191 | |
da048e3d | 192 | pizza->bin_window = NULL; |
3dd9b88a | 193 | |
8e217128 RR |
194 | pizza->xoffset = 0; |
195 | pizza->yoffset = 0; | |
ed673c6a | 196 | |
da048e3d RR |
197 | pizza->configure_serial = 0; |
198 | pizza->scroll_x = 0; | |
199 | pizza->scroll_y = 0; | |
200 | pizza->visibility = GDK_VISIBILITY_PARTIAL; | |
bf3dab48 | 201 | |
da048e3d | 202 | pizza->clear_on_draw = TRUE; |
b6fa52db | 203 | pizza->use_filter = TRUE; |
b420fb6a | 204 | pizza->external_expose = FALSE; |
c801d85f KB |
205 | } |
206 | ||
207 | GtkWidget* | |
da048e3d | 208 | gtk_pizza_new () |
c801d85f | 209 | { |
da048e3d | 210 | GtkPizza *pizza; |
c801d85f | 211 | |
da048e3d | 212 | pizza = gtk_type_new (gtk_pizza_get_type ()); |
bf3dab48 | 213 | |
da048e3d | 214 | return GTK_WIDGET (pizza); |
c801d85f KB |
215 | } |
216 | ||
bf3dab48 | 217 | static void |
da048e3d | 218 | gtk_pizza_scroll_set_adjustments (GtkPizza *pizza, |
bf3dab48 VZ |
219 | GtkAdjustment *hadj, |
220 | GtkAdjustment *vadj) | |
034be888 | 221 | { |
ed673c6a | 222 | /* We handle scrolling in the wxScrolledWindow, not here. */ |
034be888 RR |
223 | } |
224 | ||
bf3dab48 | 225 | void |
b6fa52db | 226 | gtk_pizza_set_shadow_type (GtkPizza *pizza, |
0e09f76e | 227 | GtkMyShadowType type) |
034be888 | 228 | { |
da048e3d RR |
229 | g_return_if_fail (pizza != NULL); |
230 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
034be888 | 231 | |
da048e3d | 232 | if ((GtkMyShadowType) pizza->shadow_type != type) |
034be888 | 233 | { |
da048e3d | 234 | pizza->shadow_type = type; |
034be888 | 235 | |
da048e3d | 236 | if (GTK_WIDGET_VISIBLE (pizza)) |
bf3dab48 VZ |
237 | { |
238 | gtk_widget_size_allocate (GTK_WIDGET (pizza), &(GTK_WIDGET (pizza)->allocation)); | |
239 | gtk_widget_queue_draw (GTK_WIDGET (pizza)); | |
240 | } | |
034be888 RR |
241 | } |
242 | } | |
034be888 | 243 | |
bf3dab48 | 244 | void |
b6fa52db RR |
245 | gtk_pizza_set_clear (GtkPizza *pizza, |
246 | gboolean clear) | |
147bc491 | 247 | { |
da048e3d RR |
248 | g_return_if_fail (pizza != NULL); |
249 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
bf3dab48 | 250 | |
da048e3d | 251 | pizza->clear_on_draw = clear; |
bf3dab48 VZ |
252 | } |
253 | ||
3dd9b88a | 254 | void |
b6fa52db RR |
255 | gtk_pizza_set_filter (GtkPizza *pizza, |
256 | gboolean use) | |
0e09f76e RR |
257 | { |
258 | g_return_if_fail (pizza != NULL); | |
259 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
260 | ||
261 | pizza->use_filter = use; | |
3dd9b88a VZ |
262 | } |
263 | ||
264 | void | |
b420fb6a RR |
265 | gtk_pizza_set_external (GtkPizza *pizza, |
266 | gboolean expose) | |
267 | { | |
268 | g_return_if_fail (pizza != NULL); | |
269 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
270 | ||
271 | pizza->external_expose = expose; | |
272 | } | |
273 | ||
c801d85f | 274 | void |
b6fa52db RR |
275 | gtk_pizza_put (GtkPizza *pizza, |
276 | GtkWidget *widget, | |
277 | gint x, | |
278 | gint y, | |
279 | gint width, | |
280 | gint height) | |
c801d85f | 281 | { |
da048e3d | 282 | GtkPizzaChild *child_info; |
053f9cc1 | 283 | |
da048e3d RR |
284 | g_return_if_fail (pizza != NULL); |
285 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
053f9cc1 RR |
286 | g_return_if_fail (widget != NULL); |
287 | ||
da048e3d | 288 | child_info = g_new (GtkPizzaChild, 1); |
bf3dab48 | 289 | |
053f9cc1 RR |
290 | child_info->widget = widget; |
291 | child_info->x = x; | |
292 | child_info->y = y; | |
293 | child_info->width = width; | |
294 | child_info->height = height; | |
bf3dab48 VZ |
295 | |
296 | pizza->children = g_list_append (pizza->children, child_info); | |
ed673c6a | 297 | |
da048e3d | 298 | gtk_widget_set_parent (widget, GTK_WIDGET (pizza)); |
c801d85f | 299 | |
da048e3d RR |
300 | if (GTK_WIDGET_REALIZED (pizza)) |
301 | gtk_widget_set_parent_window (widget, pizza->bin_window); | |
bf3dab48 | 302 | |
a2d8ce85 | 303 | #ifndef __WXGTK20__ /* FIXME? */ |
ed673c6a RR |
304 | if (!IS_ONSCREEN (x, y)) |
305 | GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN); | |
a2d8ce85 | 306 | #endif |
c801d85f | 307 | |
0e09f76e | 308 | /* |
da048e3d | 309 | if (GTK_WIDGET_REALIZED (pizza)) |
053f9cc1 | 310 | gtk_widget_realize (widget); |
0e09f76e | 311 | */ |
c801d85f | 312 | |
ed673c6a | 313 | gtk_widget_set_usize (widget, width, height); |
bf3dab48 | 314 | |
0e09f76e | 315 | /* |
da048e3d | 316 | if (GTK_WIDGET_VISIBLE (pizza) && GTK_WIDGET_VISIBLE (widget)) |
326f9654 | 317 | { |
da048e3d | 318 | if (GTK_WIDGET_MAPPED (pizza)) |
bf3dab48 VZ |
319 | gtk_widget_map (widget); |
320 | ||
ed673c6a | 321 | gtk_widget_queue_resize (widget); |
326f9654 | 322 | } |
0e09f76e | 323 | */ |
c801d85f KB |
324 | } |
325 | ||
326 | void | |
b6fa52db RR |
327 | gtk_pizza_move (GtkPizza *pizza, |
328 | GtkWidget *widget, | |
329 | gint x, | |
330 | gint y) | |
c801d85f | 331 | { |
da048e3d | 332 | GtkPizzaChild *child; |
053f9cc1 | 333 | GList *children; |
c801d85f | 334 | |
da048e3d RR |
335 | g_return_if_fail (pizza != NULL); |
336 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
053f9cc1 | 337 | g_return_if_fail (widget != NULL); |
c801d85f | 338 | |
da048e3d | 339 | children = pizza->children; |
053f9cc1 | 340 | while (children) |
fdd3ed7a | 341 | { |
053f9cc1 RR |
342 | child = children->data; |
343 | children = children->next; | |
bf3dab48 | 344 | |
053f9cc1 | 345 | if (child->widget == widget) |
fdd3ed7a | 346 | { |
bf3dab48 VZ |
347 | if ((child->x == x) && (child->y == y)) |
348 | break; | |
349 | ||
ed673c6a RR |
350 | child->x = x; |
351 | child->y = y; | |
bf3dab48 VZ |
352 | |
353 | if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza)) | |
354 | gtk_widget_queue_resize (widget); | |
355 | break; | |
356 | } | |
fdd3ed7a RR |
357 | } |
358 | } | |
359 | ||
360 | void | |
b6fa52db RR |
361 | gtk_pizza_resize (GtkPizza *pizza, |
362 | GtkWidget *widget, | |
363 | gint width, | |
364 | gint height) | |
fdd3ed7a | 365 | { |
da048e3d | 366 | GtkPizzaChild *child; |
053f9cc1 | 367 | GList *children; |
fdd3ed7a | 368 | |
da048e3d RR |
369 | g_return_if_fail (pizza != NULL); |
370 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
053f9cc1 | 371 | g_return_if_fail (widget != NULL); |
fdd3ed7a | 372 | |
da048e3d | 373 | children = pizza->children; |
053f9cc1 | 374 | while (children) |
fdd3ed7a | 375 | { |
053f9cc1 RR |
376 | child = children->data; |
377 | children = children->next; | |
bf3dab48 | 378 | |
053f9cc1 | 379 | if (child->widget == widget) |
fdd3ed7a | 380 | { |
bf3dab48 VZ |
381 | if ((child->width == width) && (child->height == height)) |
382 | break; | |
383 | ||
ed673c6a RR |
384 | child->width = width; |
385 | child->height = height; | |
bf3dab48 VZ |
386 | |
387 | gtk_widget_set_usize (widget, width, height); | |
388 | ||
da048e3d | 389 | if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza)) |
bf3dab48 VZ |
390 | gtk_widget_queue_resize (widget); |
391 | break; | |
392 | } | |
fdd3ed7a RR |
393 | } |
394 | } | |
395 | ||
396 | void | |
b6fa52db RR |
397 | gtk_pizza_set_size (GtkPizza *pizza, |
398 | GtkWidget *widget, | |
399 | gint x, | |
400 | gint y, | |
401 | gint width, | |
402 | gint height) | |
fdd3ed7a | 403 | { |
da048e3d | 404 | GtkPizzaChild *child; |
053f9cc1 | 405 | GList *children; |
fdd3ed7a | 406 | |
da048e3d RR |
407 | g_return_if_fail (pizza != NULL); |
408 | g_return_if_fail (GTK_IS_PIZZA (pizza)); | |
053f9cc1 | 409 | g_return_if_fail (widget != NULL); |
fdd3ed7a | 410 | |
da048e3d | 411 | children = pizza->children; |
053f9cc1 | 412 | while (children) |
c801d85f | 413 | { |
053f9cc1 RR |
414 | child = children->data; |
415 | children = children->next; | |
c801d85f | 416 | |
053f9cc1 | 417 | if (child->widget == widget) |
c801d85f | 418 | { |
bf3dab48 VZ |
419 | if ((child->x == x) && |
420 | (child->y == y) && | |
421 | (child->width == width) && | |
422 | (child->height == height)) return; | |
423 | ||
053f9cc1 RR |
424 | child->x = x; |
425 | child->y = y; | |
426 | child->width = width; | |
427 | child->height = height; | |
bf3dab48 VZ |
428 | |
429 | gtk_widget_set_usize (widget, width, height); | |
430 | ||
da048e3d | 431 | if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (pizza)) |
bf3dab48 VZ |
432 | gtk_widget_queue_resize (widget); |
433 | ||
6d693bb4 | 434 | return; |
c801d85f KB |
435 | } |
436 | } | |
437 | } | |
438 | ||
3dd9b88a | 439 | gint |
8cb9f0d0 RR |
440 | gtk_pizza_child_resized (GtkPizza *pizza, |
441 | GtkWidget *widget) | |
442 | { | |
443 | GtkPizzaChild *child; | |
444 | GList *children; | |
445 | ||
446 | g_return_val_if_fail (pizza != NULL, FALSE); | |
447 | g_return_val_if_fail (GTK_IS_PIZZA (pizza), FALSE); | |
448 | g_return_val_if_fail (widget != NULL, FALSE); | |
449 | ||
450 | children = pizza->children; | |
451 | while (children) | |
452 | { | |
453 | child = children->data; | |
454 | children = children->next; | |
455 | ||
456 | if (child->widget == widget) | |
457 | { | |
458 | return ((child->width == widget->allocation.width) && | |
459 | (child->height == widget->allocation.height)); | |
460 | } | |
461 | } | |
3dd9b88a | 462 | |
8cb9f0d0 RR |
463 | return FALSE; |
464 | } | |
3dd9b88a | 465 | |
c801d85f | 466 | static void |
da048e3d | 467 | gtk_pizza_map (GtkWidget *widget) |
c801d85f | 468 | { |
da048e3d RR |
469 | GtkPizza *pizza; |
470 | GtkPizzaChild *child; | |
053f9cc1 | 471 | GList *children; |
c801d85f | 472 | |
053f9cc1 | 473 | g_return_if_fail (widget != NULL); |
da048e3d | 474 | g_return_if_fail (GTK_IS_PIZZA (widget)); |
c801d85f | 475 | |
053f9cc1 | 476 | GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED); |
da048e3d | 477 | pizza = GTK_PIZZA (widget); |
c801d85f | 478 | |
da048e3d | 479 | children = pizza->children; |
053f9cc1 | 480 | while (children) |
c801d85f | 481 | { |
053f9cc1 RR |
482 | child = children->data; |
483 | children = children->next; | |
c801d85f | 484 | |
bf3dab48 VZ |
485 | if ( GTK_WIDGET_VISIBLE (child->widget) && |
486 | !GTK_WIDGET_MAPPED (child->widget) && | |
a2d8ce85 OK |
487 | #ifdef __WXGTK20__ |
488 | TRUE) | |
489 | #else | |
bf3dab48 | 490 | !GTK_WIDGET_IS_OFFSCREEN (child->widget)) |
a2d8ce85 | 491 | #endif |
bf3dab48 VZ |
492 | { |
493 | gtk_widget_map (child->widget); | |
494 | } | |
c801d85f | 495 | } |
bf3dab48 | 496 | |
053f9cc1 | 497 | gdk_window_show (widget->window); |
da048e3d | 498 | gdk_window_show (pizza->bin_window); |
c801d85f KB |
499 | } |
500 | ||
c801d85f | 501 | static void |
da048e3d | 502 | gtk_pizza_realize (GtkWidget *widget) |
c801d85f | 503 | { |
da048e3d | 504 | GtkPizza *pizza; |
053f9cc1 RR |
505 | GdkWindowAttr attributes; |
506 | gint attributes_mask; | |
da048e3d | 507 | GtkPizzaChild *child; |
ed673c6a | 508 | GList *children; |
c801d85f | 509 | |
053f9cc1 | 510 | g_return_if_fail (widget != NULL); |
da048e3d | 511 | g_return_if_fail (GTK_IS_PIZZA (widget)); |
c801d85f | 512 | |
da048e3d | 513 | pizza = GTK_PIZZA (widget); |
bf3dab48 | 514 | |
053f9cc1 | 515 | GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED); |
c801d85f | 516 | |
053f9cc1 | 517 | attributes.window_type = GDK_WINDOW_CHILD; |
bf3dab48 | 518 | |
053f9cc1 RR |
519 | attributes.x = widget->allocation.x; |
520 | attributes.y = widget->allocation.y; | |
521 | attributes.width = widget->allocation.width; | |
522 | attributes.height = widget->allocation.height; | |
523 | ||
1e6feb95 | 524 | #ifndef __WXUNIVERSAL__ |
da048e3d | 525 | if (pizza->shadow_type == GTK_MYSHADOW_NONE) |
053f9cc1 | 526 | { |
5e014a0c | 527 | /* no border, no changes to sizes */ |
1e6feb95 VZ |
528 | } |
529 | else if (pizza->shadow_type == GTK_MYSHADOW_THIN) | |
5e014a0c RR |
530 | { |
531 | /* GTK_MYSHADOW_THIN == wxSIMPLE_BORDER */ | |
532 | attributes.x += 1; | |
533 | attributes.y += 1; | |
534 | attributes.width -= 2; | |
535 | attributes.height -= 2; | |
1e6feb95 VZ |
536 | } |
537 | else | |
5e014a0c RR |
538 | { |
539 | /* GTK_MYSHADOW_IN == wxSUNKEN_BORDER */ | |
540 | /* GTK_MYSHADOW_OUT == wxRAISED_BORDER */ | |
053f9cc1 RR |
541 | attributes.x += 2; |
542 | attributes.y += 2; | |
543 | attributes.width -= 4; | |
544 | attributes.height -= 4; | |
545 | } | |
1e6feb95 | 546 | #endif /* __WXUNIVERSAL__ */ |
bf3dab48 | 547 | |
ed673c6a | 548 | /* minimal size */ |
053f9cc1 RR |
549 | if (attributes.width < 2) attributes.width = 2; |
550 | if (attributes.height < 2) attributes.height = 2; | |
bf3dab48 | 551 | |
053f9cc1 RR |
552 | attributes.wclass = GDK_INPUT_OUTPUT; |
553 | attributes.visual = gtk_widget_get_visual (widget); | |
554 | attributes.colormap = gtk_widget_get_colormap (widget); | |
3dd9b88a | 555 | attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK; |
ed673c6a | 556 | attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; |
bf3dab48 | 557 | |
c916e13b | 558 | widget->window = gdk_window_new(gtk_widget_get_parent_window (widget), |
bf3dab48 | 559 | &attributes, attributes_mask); |
ed673c6a RR |
560 | gdk_window_set_user_data (widget->window, widget); |
561 | ||
562 | attributes.x = 0; | |
563 | attributes.y = 0; | |
bf3dab48 | 564 | |
053f9cc1 | 565 | attributes.event_mask = gtk_widget_get_events (widget); |
3dd9b88a VZ |
566 | attributes.event_mask |= GDK_EXPOSURE_MASK | |
567 | GDK_POINTER_MOTION_MASK | | |
568 | GDK_POINTER_MOTION_HINT_MASK | | |
569 | GDK_BUTTON_MOTION_MASK | | |
570 | GDK_BUTTON1_MOTION_MASK | | |
571 | GDK_BUTTON2_MOTION_MASK | | |
572 | GDK_BUTTON3_MOTION_MASK | | |
573 | GDK_BUTTON_PRESS_MASK | | |
574 | GDK_BUTTON_RELEASE_MASK | | |
575 | GDK_KEY_PRESS_MASK | | |
576 | GDK_KEY_RELEASE_MASK | | |
577 | GDK_ENTER_NOTIFY_MASK | | |
578 | GDK_LEAVE_NOTIFY_MASK | | |
579 | GDK_FOCUS_CHANGE_MASK; | |
053f9cc1 | 580 | |
c916e13b | 581 | pizza->bin_window = gdk_window_new(widget->window, |
bf3dab48 | 582 | &attributes, attributes_mask); |
da048e3d | 583 | gdk_window_set_user_data (pizza->bin_window, widget); |
bf3dab48 | 584 | |
053f9cc1 RR |
585 | widget->style = gtk_style_attach (widget->style, widget->window); |
586 | gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); | |
b6fa52db | 587 | gtk_style_set_background (widget->style, pizza->bin_window, GTK_STATE_NORMAL ); |
33611ebb RR |
588 | |
589 | /* | |
590 | gdk_window_set_back_pixmap( widget->window, NULL, FALSE ); | |
591 | gdk_window_set_back_pixmap( pizza->bin_window, NULL, FALSE ); | |
592 | */ | |
bf3dab48 | 593 | |
ed673c6a | 594 | /* add filters for intercepting visibility and expose events */ |
da048e3d RR |
595 | gdk_window_add_filter (widget->window, gtk_pizza_main_filter, pizza); |
596 | gdk_window_add_filter (pizza->bin_window, gtk_pizza_filter, pizza); | |
ed673c6a RR |
597 | |
598 | /* we NEED gravity or we'll give up */ | |
da048e3d | 599 | gravity_works = gdk_window_set_static_gravities (pizza->bin_window, TRUE); |
ed673c6a RR |
600 | |
601 | /* cannot be done before realisation */ | |
da048e3d | 602 | children = pizza->children; |
ed673c6a RR |
603 | while (children) |
604 | { | |
605 | child = children->data; | |
606 | children = children->next; | |
607 | ||
da048e3d | 608 | gtk_widget_set_parent_window (child->widget, pizza->bin_window); |
ed673c6a RR |
609 | } |
610 | } | |
611 | ||
bf3dab48 | 612 | static void |
da048e3d | 613 | gtk_pizza_unrealize (GtkWidget *widget) |
ed673c6a | 614 | { |
d5ab387d | 615 | GtkPizza *pizza; |
ed673c6a | 616 | |
d5ab387d RR |
617 | g_return_if_fail (widget != NULL); |
618 | g_return_if_fail (GTK_IS_PIZZA (widget)); | |
ed673c6a | 619 | |
d5ab387d | 620 | pizza = GTK_PIZZA (widget); |
ed673c6a | 621 | |
d5ab387d RR |
622 | gdk_window_set_user_data (pizza->bin_window, NULL); |
623 | gdk_window_destroy (pizza->bin_window); | |
624 | pizza->bin_window = NULL; | |
ed673c6a | 625 | |
d5ab387d RR |
626 | if (GTK_WIDGET_CLASS (parent_class)->unrealize) |
627 | (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); | |
c801d85f KB |
628 | } |
629 | ||
630 | static void | |
da048e3d | 631 | gtk_pizza_size_request (GtkWidget *widget, |
b6fa52db | 632 | GtkRequisition *requisition) |
c801d85f | 633 | { |
da048e3d RR |
634 | GtkPizza *pizza; |
635 | GtkPizzaChild *child; | |
053f9cc1 RR |
636 | GList *children; |
637 | GtkRequisition child_requisition; | |
bf3dab48 | 638 | |
053f9cc1 | 639 | g_return_if_fail (widget != NULL); |
da048e3d | 640 | g_return_if_fail (GTK_IS_PIZZA (widget)); |
053f9cc1 | 641 | g_return_if_fail (requisition != NULL); |
c801d85f | 642 | |
da048e3d | 643 | pizza = GTK_PIZZA (widget); |
bf3dab48 | 644 | |
da048e3d | 645 | children = pizza->children; |
053f9cc1 | 646 | while (children) |
c801d85f | 647 | { |
053f9cc1 RR |
648 | child = children->data; |
649 | children = children->next; | |
c801d85f | 650 | |
053f9cc1 | 651 | if (GTK_WIDGET_VISIBLE (child->widget)) |
bf3dab48 | 652 | { |
053f9cc1 | 653 | gtk_widget_size_request (child->widget, &child_requisition); |
bf3dab48 | 654 | } |
c801d85f | 655 | } |
bf3dab48 | 656 | |
053f9cc1 RR |
657 | /* request very little, I'm not sure if requesting nothing |
658 | will always have positive effects on stability... */ | |
659 | requisition->width = 2; | |
660 | requisition->height = 2; | |
c801d85f KB |
661 | } |
662 | ||
663 | static void | |
da048e3d | 664 | gtk_pizza_size_allocate (GtkWidget *widget, |
b6fa52db | 665 | GtkAllocation *allocation) |
c801d85f | 666 | { |
da048e3d | 667 | GtkPizza *pizza; |
053f9cc1 | 668 | gint border; |
ed673c6a | 669 | gint x,y,w,h; |
da048e3d | 670 | GtkPizzaChild *child; |
ed673c6a | 671 | GList *children; |
c801d85f | 672 | |
053f9cc1 | 673 | g_return_if_fail (widget != NULL); |
da048e3d | 674 | g_return_if_fail (GTK_IS_PIZZA(widget)); |
053f9cc1 | 675 | g_return_if_fail (allocation != NULL); |
c801d85f | 676 | |
da048e3d | 677 | pizza = GTK_PIZZA (widget); |
bf3dab48 | 678 | |
227e5e99 | 679 | widget->allocation = *allocation; |
bf3dab48 | 680 | |
da048e3d | 681 | if (pizza->shadow_type == GTK_MYSHADOW_NONE) |
053f9cc1 | 682 | border = 0; |
5e014a0c | 683 | else |
da048e3d | 684 | if (pizza->shadow_type == GTK_MYSHADOW_THIN) |
5e014a0c | 685 | border = 1; |
053f9cc1 RR |
686 | else |
687 | border = 2; | |
bf3dab48 | 688 | |
ed673c6a RR |
689 | x = allocation->x + border; |
690 | y = allocation->y + border; | |
691 | w = allocation->width - border*2; | |
692 | h = allocation->height - border*2; | |
034be888 | 693 | |
053f9cc1 RR |
694 | if (GTK_WIDGET_REALIZED (widget)) |
695 | { | |
ed673c6a | 696 | gdk_window_move_resize( widget->window, x, y, w, h ); |
da048e3d | 697 | gdk_window_move_resize( pizza->bin_window, 0, 0, w, h ); |
053f9cc1 | 698 | } |
bf3dab48 | 699 | |
da048e3d | 700 | children = pizza->children; |
6d693bb4 RR |
701 | while (children) |
702 | { | |
703 | child = children->data; | |
704 | children = children->next; | |
bf3dab48 | 705 | |
da048e3d RR |
706 | gtk_pizza_position_child (pizza, child); |
707 | gtk_pizza_allocate_child (pizza, child); | |
6d693bb4 | 708 | } |
c801d85f KB |
709 | } |
710 | ||
711 | static void | |
da048e3d | 712 | gtk_pizza_draw (GtkWidget *widget, |
b6fa52db | 713 | GdkRectangle *area) |
c801d85f | 714 | { |
b420fb6a RR |
715 | GtkPizza *pizza; |
716 | GtkPizzaChild *child; | |
717 | GdkRectangle child_area; | |
718 | GList *children; | |
719 | ||
720 | g_return_if_fail (widget != NULL); | |
721 | g_return_if_fail (GTK_IS_PIZZA (widget)); | |
722 | ||
723 | pizza = GTK_PIZZA (widget); | |
724 | ||
725 | /* Sometimes, We handle all expose events in window.cpp now. */ | |
726 | if (pizza->external_expose) | |
727 | return; | |
728 | ||
729 | children = pizza->children; | |
730 | if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) && | |
731 | (pizza->clear_on_draw)) | |
732 | { | |
733 | gdk_window_clear_area( pizza->bin_window, | |
734 | area->x, area->y, area->width, area->height); | |
735 | } | |
736 | ||
737 | while (children) | |
738 | { | |
739 | child = children->data; | |
740 | children = children->next; | |
741 | ||
742 | if (gtk_widget_intersect (child->widget, area, &child_area)) | |
743 | gtk_widget_draw (child->widget, &child_area); | |
744 | } | |
c801d85f KB |
745 | } |
746 | ||
c801d85f | 747 | static gint |
da048e3d | 748 | gtk_pizza_expose (GtkWidget *widget, |
b6fa52db | 749 | GdkEventExpose *event) |
c801d85f | 750 | { |
b420fb6a RR |
751 | GtkPizza *pizza; |
752 | GtkPizzaChild *child; | |
753 | GdkEventExpose child_event; | |
754 | GList *children; | |
755 | ||
756 | g_return_val_if_fail (widget != NULL, FALSE); | |
757 | g_return_val_if_fail (GTK_IS_PIZZA (widget), FALSE); | |
758 | g_return_val_if_fail (event != NULL, FALSE); | |
759 | ||
760 | pizza = GTK_PIZZA (widget); | |
761 | ||
762 | /* Sometimes, We handle all expose events in window.cpp now. */ | |
763 | if (pizza->external_expose) | |
d5ab387d | 764 | return FALSE; |
b420fb6a RR |
765 | |
766 | if (event->window != pizza->bin_window) | |
767 | return FALSE; | |
768 | ||
769 | children = pizza->children; | |
770 | while (children) | |
771 | { | |
772 | child = children->data; | |
773 | children = children->next; | |
774 | ||
775 | child_event = *event; | |
776 | ||
777 | if (GTK_WIDGET_NO_WINDOW (child->widget) && | |
778 | GTK_WIDGET_DRAWABLE (child->widget) && | |
779 | gtk_widget_intersect (child->widget, &event->area, &child_event.area)) | |
780 | { | |
781 | gtk_widget_event (child->widget, (GdkEvent*) &child_event); | |
782 | } | |
783 | } | |
3dd9b88a | 784 | |
b420fb6a | 785 | return TRUE; |
c801d85f KB |
786 | } |
787 | ||
788 | static void | |
da048e3d | 789 | gtk_pizza_add (GtkContainer *container, |
bf3dab48 | 790 | GtkWidget *widget) |
c801d85f | 791 | { |
ed673c6a | 792 | g_return_if_fail (container != NULL); |
da048e3d | 793 | g_return_if_fail (GTK_IS_PIZZA (container)); |
ed673c6a | 794 | g_return_if_fail (widget != NULL); |
c801d85f | 795 | |
da048e3d | 796 | gtk_pizza_put (GTK_PIZZA (container), widget, 0, 0, 20, 20 ); |
c801d85f KB |
797 | } |
798 | ||
799 | static void | |
da048e3d | 800 | gtk_pizza_remove (GtkContainer *container, |
b6fa52db | 801 | GtkWidget *widget) |
c801d85f | 802 | { |
da048e3d RR |
803 | GtkPizza *pizza; |
804 | GtkPizzaChild *child; | |
ed673c6a | 805 | GList *children; |
c801d85f | 806 | |
ed673c6a | 807 | g_return_if_fail (container != NULL); |
da048e3d | 808 | g_return_if_fail (GTK_IS_PIZZA (container)); |
ed673c6a | 809 | g_return_if_fail (widget != NULL); |
c801d85f | 810 | |
da048e3d | 811 | pizza = GTK_PIZZA (container); |
c801d85f | 812 | |
da048e3d | 813 | children = pizza->children; |
ed673c6a | 814 | while (children) |
c801d85f | 815 | { |
ed673c6a | 816 | child = children->data; |
c801d85f | 817 | |
ed673c6a | 818 | if (child->widget == widget) |
bf3dab48 VZ |
819 | { |
820 | gtk_widget_unparent (widget); | |
c801d85f | 821 | |
ed673c6a RR |
822 | /* security checks */ |
823 | g_return_if_fail (GTK_IS_WIDGET (widget)); | |
bf3dab48 VZ |
824 | |
825 | pizza->children = g_list_remove_link (pizza->children, children); | |
826 | g_list_free (children); | |
827 | g_free (child); | |
c801d85f | 828 | |
ed673c6a | 829 | /* security checks */ |
bf3dab48 VZ |
830 | g_return_if_fail (GTK_IS_WIDGET (widget)); |
831 | ||
a2d8ce85 | 832 | #ifndef __WXGTK20__ |
ed673c6a | 833 | GTK_PRIVATE_UNSET_FLAG (widget, GTK_IS_OFFSCREEN); |
a2d8ce85 | 834 | #endif |
bf3dab48 VZ |
835 | |
836 | break; | |
837 | } | |
c801d85f | 838 | |
ed673c6a | 839 | children = children->next; |
c801d85f KB |
840 | } |
841 | } | |
842 | ||
843 | static void | |
da048e3d | 844 | gtk_pizza_forall (GtkContainer *container, |
b6fa52db RR |
845 | gboolean include_internals, |
846 | GtkCallback callback, | |
847 | gpointer callback_data) | |
c801d85f | 848 | { |
da048e3d RR |
849 | GtkPizza *pizza; |
850 | GtkPizzaChild *child; | |
6d693bb4 | 851 | GList *children; |
c801d85f | 852 | |
6d693bb4 | 853 | g_return_if_fail (container != NULL); |
da048e3d | 854 | g_return_if_fail (GTK_IS_PIZZA (container)); |
6d693bb4 | 855 | g_return_if_fail (callback != NULL); |
c801d85f | 856 | |
da048e3d | 857 | pizza = GTK_PIZZA (container); |
c801d85f | 858 | |
da048e3d | 859 | children = pizza->children; |
6d693bb4 | 860 | while (children) |
c801d85f | 861 | { |
6d693bb4 RR |
862 | child = children->data; |
863 | children = children->next; | |
c801d85f | 864 | |
6d693bb4 | 865 | (* callback) (child->widget, callback_data); |
c801d85f KB |
866 | } |
867 | } | |
868 | ||
869 | ||
ed673c6a RR |
870 | /* Operations on children |
871 | */ | |
872 | ||
873 | static void | |
da048e3d | 874 | gtk_pizza_position_child (GtkPizza *pizza, |
b6fa52db | 875 | GtkPizzaChild *child) |
ed673c6a | 876 | { |
6d693bb4 RR |
877 | gint x; |
878 | gint y; | |
ed673c6a | 879 | |
da048e3d RR |
880 | x = child->x - pizza->xoffset; |
881 | y = child->y - pizza->yoffset; | |
ed673c6a | 882 | |
6d693bb4 | 883 | if (IS_ONSCREEN (x,y)) |
ed673c6a | 884 | { |
da048e3d | 885 | if (GTK_WIDGET_MAPPED (pizza) && |
bf3dab48 VZ |
886 | GTK_WIDGET_VISIBLE (child->widget)) |
887 | { | |
888 | if (!GTK_WIDGET_MAPPED (child->widget)) | |
889 | gtk_widget_map (child->widget); | |
890 | } | |
ed673c6a | 891 | |
a2d8ce85 | 892 | #ifndef __WXGTK20__ |
6d693bb4 | 893 | if (GTK_WIDGET_IS_OFFSCREEN (child->widget)) |
bf3dab48 | 894 | GTK_PRIVATE_UNSET_FLAG (child->widget, GTK_IS_OFFSCREEN); |
a2d8ce85 | 895 | #endif |
ed673c6a | 896 | } |
6d693bb4 | 897 | else |
ed673c6a | 898 | { |
a2d8ce85 | 899 | #ifndef __WXGTK20__ |
6d693bb4 | 900 | if (!GTK_WIDGET_IS_OFFSCREEN (child->widget)) |
bf3dab48 | 901 | GTK_PRIVATE_SET_FLAG (child->widget, GTK_IS_OFFSCREEN); |
a2d8ce85 | 902 | #endif |
ed673c6a | 903 | |
6d693bb4 | 904 | if (GTK_WIDGET_MAPPED (child->widget)) |
bf3dab48 | 905 | gtk_widget_unmap (child->widget); |
ed673c6a RR |
906 | } |
907 | } | |
908 | ||
909 | static void | |
da048e3d | 910 | gtk_pizza_allocate_child (GtkPizza *pizza, |
b6fa52db | 911 | GtkPizzaChild *child) |
ed673c6a | 912 | { |
6d693bb4 RR |
913 | GtkAllocation allocation; |
914 | GtkRequisition requisition; | |
915 | ||
da048e3d RR |
916 | allocation.x = child->x - pizza->xoffset; |
917 | allocation.y = child->y - pizza->yoffset; | |
6d693bb4 RR |
918 | gtk_widget_get_child_requisition (child->widget, &requisition); |
919 | allocation.width = requisition.width; | |
920 | allocation.height = requisition.height; | |
bf3dab48 | 921 | |
6d693bb4 | 922 | gtk_widget_size_allocate (child->widget, &allocation); |
ed673c6a RR |
923 | } |
924 | ||
925 | static void | |
da048e3d | 926 | gtk_pizza_position_children (GtkPizza *pizza) |
ed673c6a | 927 | { |
6d693bb4 | 928 | GList *tmp_list; |
ed673c6a | 929 | |
da048e3d | 930 | tmp_list = pizza->children; |
6d693bb4 | 931 | while (tmp_list) |
ed673c6a | 932 | { |
da048e3d | 933 | GtkPizzaChild *child = tmp_list->data; |
6d693bb4 | 934 | tmp_list = tmp_list->next; |
bf3dab48 | 935 | |
da048e3d | 936 | gtk_pizza_position_child (pizza, child); |
ed673c6a RR |
937 | } |
938 | } | |
939 | ||
940 | static void | |
da048e3d | 941 | gtk_pizza_adjust_allocations_recurse (GtkWidget *widget, |
bf3dab48 | 942 | gpointer cb_data) |
ed673c6a | 943 | { |
da048e3d | 944 | GtkPizzaAdjData *data = cb_data; |
ed673c6a | 945 | |
6d693bb4 RR |
946 | widget->allocation.x += data->dx; |
947 | widget->allocation.y += data->dy; | |
ed673c6a | 948 | |
6d693bb4 RR |
949 | if (GTK_WIDGET_NO_WINDOW (widget) && GTK_IS_CONTAINER (widget)) |
950 | { | |
bf3dab48 VZ |
951 | gtk_container_forall (GTK_CONTAINER (widget), |
952 | gtk_pizza_adjust_allocations_recurse, | |
953 | cb_data); | |
6d693bb4 | 954 | } |
ed673c6a RR |
955 | } |
956 | ||
957 | static void | |
da048e3d | 958 | gtk_pizza_adjust_allocations (GtkPizza *pizza, |
bf3dab48 VZ |
959 | gint dx, |
960 | gint dy) | |
ed673c6a | 961 | { |
0e09f76e RR |
962 | GList *tmp_list; |
963 | GtkPizzaAdjData data; | |
ed673c6a | 964 | |
0e09f76e RR |
965 | data.dx = dx; |
966 | data.dy = dy; | |
ed673c6a | 967 | |
0e09f76e RR |
968 | tmp_list = pizza->children; |
969 | while (tmp_list) | |
ed673c6a | 970 | { |
0e09f76e RR |
971 | GtkPizzaChild *child = tmp_list->data; |
972 | tmp_list = tmp_list->next; | |
bf3dab48 | 973 | |
0e09f76e RR |
974 | child->widget->allocation.x += dx; |
975 | child->widget->allocation.y += dy; | |
ed673c6a | 976 | |
0e09f76e RR |
977 | if (GTK_WIDGET_NO_WINDOW (child->widget) && |
978 | GTK_IS_CONTAINER (child->widget)) | |
979 | { | |
980 | gtk_container_forall (GTK_CONTAINER (child->widget), | |
981 | gtk_pizza_adjust_allocations_recurse, | |
982 | &data); | |
983 | } | |
ed673c6a RR |
984 | } |
985 | } | |
bf3dab48 | 986 | |
ed673c6a RR |
987 | /* Callbacks */ |
988 | ||
3ca6a5f0 BP |
989 | /* unused */ |
990 | #if 0 | |
ed673c6a RR |
991 | /* Send a synthetic expose event to the widget |
992 | */ | |
993 | static void | |
da048e3d | 994 | gtk_pizza_expose_area (GtkPizza *pizza, |
bf3dab48 | 995 | gint x, gint y, gint width, gint height) |
ed673c6a | 996 | { |
0e09f76e | 997 | if (pizza->visibility == GDK_VISIBILITY_UNOBSCURED) |
ed673c6a | 998 | { |
0e09f76e | 999 | GdkEventExpose event; |
bf3dab48 | 1000 | |
0e09f76e RR |
1001 | event.type = GDK_EXPOSE; |
1002 | event.send_event = TRUE; | |
1003 | event.window = pizza->bin_window; | |
1004 | event.count = 0; | |
bf3dab48 | 1005 | |
0e09f76e RR |
1006 | event.area.x = x; |
1007 | event.area.y = y; | |
1008 | event.area.width = width; | |
1009 | event.area.height = height; | |
bf3dab48 | 1010 | |
0e09f76e RR |
1011 | gdk_window_ref (event.window); |
1012 | gtk_widget_event (GTK_WIDGET (pizza), (GdkEvent *)&event); | |
1013 | gdk_window_unref (event.window); | |
ed673c6a RR |
1014 | } |
1015 | } | |
3ca6a5f0 | 1016 | #endif /* unused */ |
ed673c6a RR |
1017 | |
1018 | /* This function is used to find events to process while scrolling | |
1019 | */ | |
1020 | ||
bf3dab48 VZ |
1021 | static Bool |
1022 | gtk_pizza_expose_predicate (Display *display, | |
1023 | XEvent *xevent, | |
1024 | XPointer arg) | |
ed673c6a | 1025 | { |
f6bcfd97 BP |
1026 | if ((xevent->type == Expose) || |
1027 | ((xevent->xany.window == *(Window *)arg) && | |
ed673c6a | 1028 | (xevent->type == ConfigureNotify))) |
f6bcfd97 BP |
1029 | return True; |
1030 | else | |
1031 | return False; | |
ed673c6a RR |
1032 | } |
1033 | ||
1034 | /* This is the main routine to do the scrolling. Scrolling is | |
1035 | * done by "Guffaw" scrolling, as in the Mozilla XFE, with | |
1036 | * a few modifications. | |
bf3dab48 | 1037 | * |
ed673c6a RR |
1038 | * The main improvement is that we keep track of whether we |
1039 | * are obscured or not. If not, we ignore the generated expose | |
1040 | * events and instead do the exposes ourself, without having | |
1041 | * to wait for a roundtrip to the server. This also provides | |
1042 | * a limited form of expose-event compression, since we do | |
1043 | * the affected area as one big chunk. | |
1044 | */ | |
1045 | ||
1046 | void | |
da048e3d | 1047 | gtk_pizza_scroll (GtkPizza *pizza, gint dx, gint dy) |
ed673c6a | 1048 | { |
f6bcfd97 BP |
1049 | GtkWidget *widget; |
1050 | XEvent xevent; | |
ed673c6a | 1051 | |
f6bcfd97 | 1052 | gint x,y,w,h,border; |
bf3dab48 | 1053 | |
f6bcfd97 | 1054 | widget = GTK_WIDGET (pizza); |
ed673c6a | 1055 | |
f6bcfd97 BP |
1056 | pizza->xoffset += dx; |
1057 | pizza->yoffset += dy; | |
ed673c6a | 1058 | |
f6bcfd97 | 1059 | if (!GTK_WIDGET_MAPPED (pizza)) |
ed673c6a | 1060 | { |
f6bcfd97 BP |
1061 | gtk_pizza_position_children (pizza); |
1062 | return; | |
ed673c6a RR |
1063 | } |
1064 | ||
f6bcfd97 | 1065 | gtk_pizza_adjust_allocations (pizza, -dx, -dy); |
ed673c6a | 1066 | |
f6bcfd97 BP |
1067 | if (pizza->shadow_type == GTK_MYSHADOW_NONE) |
1068 | border = 0; | |
1069 | else | |
1070 | if (pizza->shadow_type == GTK_MYSHADOW_THIN) | |
1071 | border = 1; | |
1072 | else | |
1073 | border = 2; | |
bf3dab48 | 1074 | |
f6bcfd97 BP |
1075 | x = 0; |
1076 | y = 0; | |
1077 | w = widget->allocation.width - 2*border; | |
1078 | h = widget->allocation.height - 2*border; | |
bf3dab48 | 1079 | |
f6bcfd97 | 1080 | if (dx > 0) |
ed673c6a | 1081 | { |
f6bcfd97 | 1082 | if (gravity_works) |
bf3dab48 VZ |
1083 | { |
1084 | gdk_window_resize (pizza->bin_window, | |
1085 | w + dx, | |
1086 | h); | |
1087 | gdk_window_move (pizza->bin_window, x-dx, y); | |
1088 | gdk_window_move_resize (pizza->bin_window, x, y, w, h ); | |
1089 | } | |
f6bcfd97 | 1090 | else |
bf3dab48 VZ |
1091 | { |
1092 | /* FIXME */ | |
1093 | } | |
ed673c6a | 1094 | } |
f6bcfd97 | 1095 | else if (dx < 0) |
ed673c6a | 1096 | { |
f6bcfd97 | 1097 | if (gravity_works) |
bf3dab48 VZ |
1098 | { |
1099 | gdk_window_move_resize (pizza->bin_window, | |
1100 | x + dx, | |
1101 | y, | |
1102 | w - dx, | |
1103 | h); | |
1104 | gdk_window_move (pizza->bin_window, x, y); | |
1105 | gdk_window_resize (pizza->bin_window, w, h ); | |
1106 | } | |
f6bcfd97 | 1107 | else |
bf3dab48 VZ |
1108 | { |
1109 | /* FIXME */ | |
1110 | } | |
ed673c6a RR |
1111 | } |
1112 | ||
f6bcfd97 | 1113 | if (dy > 0) |
ed673c6a | 1114 | { |
f6bcfd97 | 1115 | if (gravity_works) |
bf3dab48 VZ |
1116 | { |
1117 | gdk_window_resize (pizza->bin_window, w, h + dy); | |
1118 | gdk_window_move (pizza->bin_window, x, y-dy); | |
1119 | gdk_window_move_resize (pizza->bin_window, | |
1120 | x, y, w, h ); | |
1121 | } | |
f6bcfd97 | 1122 | else |
bf3dab48 VZ |
1123 | { |
1124 | /* FIXME */ | |
1125 | } | |
ed673c6a | 1126 | } |
f6bcfd97 | 1127 | else if (dy < 0) |
ed673c6a | 1128 | { |
f6bcfd97 | 1129 | if (gravity_works) |
bf3dab48 VZ |
1130 | { |
1131 | gdk_window_move_resize (pizza->bin_window, | |
1132 | x, y+dy, w, h - dy ); | |
1133 | gdk_window_move (pizza->bin_window, x, y); | |
1134 | gdk_window_resize (pizza->bin_window, w, h ); | |
1135 | } | |
f6bcfd97 | 1136 | else |
bf3dab48 VZ |
1137 | { |
1138 | /* FIXME */ | |
1139 | } | |
ed673c6a RR |
1140 | } |
1141 | ||
f6bcfd97 BP |
1142 | gtk_pizza_position_children (pizza); |
1143 | ||
1144 | gdk_flush(); | |
1145 | while (XCheckIfEvent(GDK_WINDOW_XDISPLAY (pizza->bin_window), | |
1146 | &xevent, | |
1147 | gtk_pizza_expose_predicate, | |
1148 | (XPointer)&GDK_WINDOW_XWINDOW (pizza->bin_window))) | |
ed673c6a | 1149 | { |
f6bcfd97 BP |
1150 | GdkEvent event; |
1151 | GtkWidget *event_widget; | |
ed673c6a | 1152 | |
f6bcfd97 BP |
1153 | if ((xevent.xany.window == GDK_WINDOW_XWINDOW (pizza->bin_window)) ) |
1154 | gtk_pizza_filter (&xevent, &event, pizza); | |
bf3dab48 | 1155 | |
f6bcfd97 | 1156 | if (xevent.type == Expose) |
bf3dab48 | 1157 | { |
f6bcfd97 BP |
1158 | event.expose.window = gdk_window_lookup (xevent.xany.window); |
1159 | gdk_window_get_user_data (event.expose.window, | |
bf3dab48 VZ |
1160 | (gpointer *)&event_widget); |
1161 | ||
f6bcfd97 | 1162 | if (event_widget) |
bf3dab48 | 1163 | { |
f6bcfd97 BP |
1164 | event.expose.type = GDK_EXPOSE; |
1165 | event.expose.area.x = xevent.xexpose.x; | |
1166 | event.expose.area.y = xevent.xexpose.y; | |
1167 | event.expose.area.width = xevent.xexpose.width; | |
1168 | event.expose.area.height = xevent.xexpose.height; | |
1169 | event.expose.count = xevent.xexpose.count; | |
1170 | ||
1171 | gdk_window_ref (event.expose.window); | |
1172 | gtk_widget_event (event_widget, &event); | |
1173 | gdk_window_unref (event.expose.window); | |
bf3dab48 VZ |
1174 | } |
1175 | } | |
ed673c6a RR |
1176 | } |
1177 | } | |
1178 | ||
1179 | /* The main event filter. Actually, we probably don't really need | |
1180 | * to install this as a filter at all, since we are calling it | |
1181 | * directly above in the expose-handling hack. But in case scrollbars | |
1182 | * are fixed up in some manner... | |
1183 | * | |
1184 | * This routine identifies expose events that are generated when | |
1185 | * we've temporarily moved the bin_window_origin, and translates | |
1186 | * them or discards them, depending on whether we are obscured | |
1187 | * or not. | |
1188 | */ | |
bf3dab48 | 1189 | static GdkFilterReturn |
da048e3d | 1190 | gtk_pizza_filter (GdkXEvent *gdk_xevent, |
bf3dab48 VZ |
1191 | GdkEvent *event, |
1192 | gpointer data) | |
ed673c6a | 1193 | { |
0e09f76e RR |
1194 | XEvent *xevent; |
1195 | GtkPizza *pizza; | |
ed673c6a | 1196 | |
0e09f76e | 1197 | xevent = (XEvent *)gdk_xevent; |
3dd9b88a | 1198 | |
0e09f76e | 1199 | pizza = GTK_PIZZA (data); |
3dd9b88a | 1200 | |
b6fa52db RR |
1201 | if (!pizza->use_filter) |
1202 | return GDK_FILTER_CONTINUE; | |
1203 | ||
f6bcfd97 | 1204 | switch (xevent->type) |
ed673c6a | 1205 | { |
3dd9b88a VZ |
1206 | case Expose: |
1207 | if (xevent->xexpose.serial == pizza->configure_serial) | |
1208 | { | |
1209 | xevent->xexpose.x += pizza->scroll_x; | |
1210 | xevent->xexpose.y += pizza->scroll_y; | |
1211 | } | |
1212 | break; | |
bf3dab48 | 1213 | |
3dd9b88a VZ |
1214 | case ConfigureNotify: |
1215 | { | |
1216 | pizza->configure_serial = xevent->xconfigure.serial; | |
1217 | pizza->scroll_x = xevent->xconfigure.x; | |
1218 | pizza->scroll_y = xevent->xconfigure.y; | |
1219 | } | |
1220 | break; | |
ed673c6a | 1221 | } |
bf3dab48 | 1222 | |
0e09f76e | 1223 | return GDK_FILTER_CONTINUE; |
ed673c6a RR |
1224 | } |
1225 | ||
1226 | /* Although GDK does have a GDK_VISIBILITY_NOTIFY event, | |
1227 | * there is no corresponding event in GTK, so we have | |
1228 | * to get the events from a filter | |
1229 | */ | |
bf3dab48 | 1230 | static GdkFilterReturn |
da048e3d | 1231 | gtk_pizza_main_filter (GdkXEvent *gdk_xevent, |
bf3dab48 VZ |
1232 | GdkEvent *event, |
1233 | gpointer data) | |
ed673c6a | 1234 | { |
0e09f76e RR |
1235 | XEvent *xevent; |
1236 | GtkPizza *pizza; | |
ed673c6a | 1237 | |
0e09f76e RR |
1238 | xevent = (XEvent *)gdk_xevent; |
1239 | pizza = GTK_PIZZA (data); | |
3dd9b88a | 1240 | |
b6fa52db RR |
1241 | if (!pizza->use_filter) |
1242 | return GDK_FILTER_CONTINUE; | |
ed673c6a | 1243 | |
0e09f76e | 1244 | if (xevent->type == VisibilityNotify) |
ed673c6a | 1245 | { |
0e09f76e | 1246 | switch (xevent->xvisibility.state) |
bf3dab48 | 1247 | { |
0e09f76e RR |
1248 | case VisibilityFullyObscured: |
1249 | pizza->visibility = GDK_VISIBILITY_FULLY_OBSCURED; | |
1250 | break; | |
ed673c6a | 1251 | |
0e09f76e RR |
1252 | case VisibilityPartiallyObscured: |
1253 | pizza->visibility = GDK_VISIBILITY_PARTIAL; | |
1254 | break; | |
ed673c6a | 1255 | |
0e09f76e RR |
1256 | case VisibilityUnobscured: |
1257 | pizza->visibility = GDK_VISIBILITY_UNOBSCURED; | |
1258 | break; | |
bf3dab48 | 1259 | } |
3dd9b88a | 1260 | |
0e09f76e | 1261 | return GDK_FILTER_REMOVE; |
ed673c6a RR |
1262 | } |
1263 | ||
0e09f76e | 1264 | return GDK_FILTER_CONTINUE; |
ed673c6a RR |
1265 | } |
1266 | ||
1267 | ||
c801d85f KB |
1268 | #ifdef __cplusplus |
1269 | } | |
1270 | #endif /* __cplusplus */ | |
1271 |