The Tor Browser / file comparison
comparison: widget/gtk/mozcontainer.c
widget/gtk/mozcontainer.c
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:d5bea47d6a59 |
|---|---|
| 1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ | |
| 2 /* vim:expandtab:shiftwidth=4:tabstop=4: | |
| 3 */ | |
| 4 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 5 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 6 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 7 | |
| 8 #include "mozcontainer.h" | |
| 9 #include <gtk/gtk.h> | |
| 10 #include <stdio.h> | |
| 11 | |
| 12 #ifdef ACCESSIBILITY | |
| 13 #include <atk/atk.h> | |
| 14 #include "maiRedundantObjectFactory.h" | |
| 15 #endif | |
| 16 | |
| 17 /* init methods */ | |
| 18 static void moz_container_class_init (MozContainerClass *klass); | |
| 19 static void moz_container_init (MozContainer *container); | |
| 20 | |
| 21 /* widget class methods */ | |
| 22 static void moz_container_map (GtkWidget *widget); | |
| 23 static void moz_container_unmap (GtkWidget *widget); | |
| 24 static void moz_container_realize (GtkWidget *widget); | |
| 25 static void moz_container_size_allocate (GtkWidget *widget, | |
| 26 GtkAllocation *allocation); | |
| 27 | |
| 28 /* container class methods */ | |
| 29 static void moz_container_remove (GtkContainer *container, | |
| 30 GtkWidget *child_widget); | |
| 31 static void moz_container_forall (GtkContainer *container, | |
| 32 gboolean include_internals, | |
| 33 GtkCallback callback, | |
| 34 gpointer callback_data); | |
| 35 static void moz_container_add (GtkContainer *container, | |
| 36 GtkWidget *widget); | |
| 37 | |
| 38 typedef struct _MozContainerChild MozContainerChild; | |
| 39 | |
| 40 struct _MozContainerChild { | |
| 41 GtkWidget *widget; | |
| 42 gint x; | |
| 43 gint y; | |
| 44 }; | |
| 45 | |
| 46 static void moz_container_allocate_child (MozContainer *container, | |
| 47 MozContainerChild *child); | |
| 48 static MozContainerChild * | |
| 49 moz_container_get_child (MozContainer *container, GtkWidget *child); | |
| 50 | |
| 51 /* public methods */ | |
| 52 | |
| 53 GType | |
| 54 moz_container_get_type(void) | |
| 55 { | |
| 56 static GType moz_container_type = 0; | |
| 57 | |
| 58 if (!moz_container_type) { | |
| 59 static GTypeInfo moz_container_info = { | |
| 60 sizeof(MozContainerClass), /* class_size */ | |
| 61 NULL, /* base_init */ | |
| 62 NULL, /* base_finalize */ | |
| 63 (GClassInitFunc) moz_container_class_init, /* class_init */ | |
| 64 NULL, /* class_destroy */ | |
| 65 NULL, /* class_data */ | |
| 66 sizeof(MozContainer), /* instance_size */ | |
| 67 0, /* n_preallocs */ | |
| 68 (GInstanceInitFunc) moz_container_init, /* instance_init */ | |
| 69 NULL, /* value_table */ | |
| 70 }; | |
| 71 | |
| 72 moz_container_type = g_type_register_static (GTK_TYPE_CONTAINER, | |
| 73 "MozContainer", | |
| 74 &moz_container_info, 0); | |
| 75 #ifdef ACCESSIBILITY | |
| 76 /* Set a factory to return accessible object with ROLE_REDUNDANT for | |
| 77 * MozContainer, so that gail won't send focus notification for it */ | |
| 78 atk_registry_set_factory_type(atk_get_default_registry(), | |
| 79 moz_container_type, | |
| 80 mai_redundant_object_factory_get_type()); | |
| 81 #endif | |
| 82 } | |
| 83 | |
| 84 return moz_container_type; | |
| 85 } | |
| 86 | |
| 87 GtkWidget * | |
| 88 moz_container_new (void) | |
| 89 { | |
| 90 MozContainer *container; | |
| 91 | |
| 92 container = g_object_new (MOZ_CONTAINER_TYPE, NULL); | |
| 93 | |
| 94 return GTK_WIDGET(container); | |
| 95 } | |
| 96 | |
| 97 void | |
| 98 moz_container_put (MozContainer *container, GtkWidget *child_widget, | |
| 99 gint x, gint y) | |
| 100 { | |
| 101 MozContainerChild *child; | |
| 102 | |
| 103 child = g_new (MozContainerChild, 1); | |
| 104 | |
| 105 child->widget = child_widget; | |
| 106 child->x = x; | |
| 107 child->y = y; | |
| 108 | |
| 109 /* printf("moz_container_put %p %p %d %d\n", (void *)container, | |
| 110 (void *)child_widget, x, y); */ | |
| 111 | |
| 112 container->children = g_list_append (container->children, child); | |
| 113 | |
| 114 /* we assume that the caller of this function will have already set | |
| 115 the parent GdkWindow because we can have many anonymous children. */ | |
| 116 gtk_widget_set_parent(child_widget, GTK_WIDGET(container)); | |
| 117 } | |
| 118 | |
| 119 void | |
| 120 moz_container_move (MozContainer *container, GtkWidget *child_widget, | |
| 121 gint x, gint y, gint width, gint height) | |
| 122 { | |
| 123 MozContainerChild *child; | |
| 124 GtkAllocation new_allocation; | |
| 125 | |
| 126 child = moz_container_get_child (container, child_widget); | |
| 127 | |
| 128 child->x = x; | |
| 129 child->y = y; | |
| 130 | |
| 131 new_allocation.x = x; | |
| 132 new_allocation.y = y; | |
| 133 new_allocation.width = width; | |
| 134 new_allocation.height = height; | |
| 135 | |
| 136 /* printf("moz_container_move %p %p will allocate to %d %d %d %d\n", | |
| 137 (void *)container, (void *)child_widget, | |
| 138 new_allocation.x, new_allocation.y, | |
| 139 new_allocation.width, new_allocation.height); */ | |
| 140 | |
| 141 gtk_widget_size_allocate(child_widget, &new_allocation); | |
| 142 } | |
| 143 | |
| 144 /* static methods */ | |
| 145 | |
| 146 void | |
| 147 moz_container_class_init (MozContainerClass *klass) | |
| 148 { | |
| 149 /*GObjectClass *gobject_class = G_OBJECT_CLASS (klass); | |
| 150 GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); */ | |
| 151 GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); | |
| 152 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); | |
| 153 | |
| 154 widget_class->map = moz_container_map; | |
| 155 widget_class->unmap = moz_container_unmap; | |
| 156 widget_class->realize = moz_container_realize; | |
| 157 widget_class->size_allocate = moz_container_size_allocate; | |
| 158 | |
| 159 container_class->remove = moz_container_remove; | |
| 160 container_class->forall = moz_container_forall; | |
| 161 container_class->add = moz_container_add; | |
| 162 } | |
| 163 | |
| 164 void | |
| 165 moz_container_init (MozContainer *container) | |
| 166 { | |
| 167 gtk_widget_set_can_focus(GTK_WIDGET(container), TRUE); | |
| 168 gtk_container_set_resize_mode(GTK_CONTAINER(container), GTK_RESIZE_IMMEDIATE); | |
| 169 gtk_widget_set_redraw_on_allocate(GTK_WIDGET(container), FALSE); | |
| 170 } | |
| 171 | |
| 172 void | |
| 173 moz_container_map (GtkWidget *widget) | |
| 174 { | |
| 175 MozContainer *container; | |
| 176 GList *tmp_list; | |
| 177 GtkWidget *tmp_child; | |
| 178 | |
| 179 g_return_if_fail (IS_MOZ_CONTAINER(widget)); | |
| 180 container = MOZ_CONTAINER (widget); | |
| 181 | |
| 182 gtk_widget_set_mapped(widget, TRUE); | |
| 183 | |
| 184 tmp_list = container->children; | |
| 185 while (tmp_list) { | |
| 186 tmp_child = ((MozContainerChild *)tmp_list->data)->widget; | |
| 187 | |
| 188 if (gtk_widget_get_visible(tmp_child)) { | |
| 189 if (!gtk_widget_get_mapped(tmp_child)) | |
| 190 gtk_widget_map(tmp_child); | |
| 191 } | |
| 192 tmp_list = tmp_list->next; | |
| 193 } | |
| 194 | |
| 195 if (gtk_widget_get_has_window (widget)) { | |
| 196 gdk_window_show (gtk_widget_get_window(widget)); | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 void | |
| 201 moz_container_unmap (GtkWidget *widget) | |
| 202 { | |
| 203 g_return_if_fail (IS_MOZ_CONTAINER (widget)); | |
| 204 | |
| 205 gtk_widget_set_mapped(widget, FALSE); | |
| 206 | |
| 207 if (gtk_widget_get_has_window (widget)) { | |
| 208 gdk_window_hide (gtk_widget_get_window(widget)); | |
| 209 } | |
| 210 } | |
| 211 | |
| 212 void | |
| 213 moz_container_realize (GtkWidget *widget) | |
| 214 { | |
| 215 GdkWindow *parent = gtk_widget_get_parent_window (widget); | |
| 216 GdkWindow *window; | |
| 217 | |
| 218 gtk_widget_set_realized(widget, TRUE); | |
| 219 | |
| 220 if (gtk_widget_get_has_window (widget)) { | |
| 221 GdkWindowAttr attributes; | |
| 222 gint attributes_mask = GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y; | |
| 223 GtkAllocation allocation; | |
| 224 | |
| 225 gtk_widget_get_allocation (widget, &allocation); | |
| 226 attributes.event_mask = gtk_widget_get_events (widget); | |
| 227 attributes.x = allocation.x; | |
| 228 attributes.y = allocation.y; | |
| 229 attributes.width = allocation.width; | |
| 230 attributes.height = allocation.height; | |
| 231 attributes.wclass = GDK_INPUT_OUTPUT; | |
| 232 attributes.visual = gtk_widget_get_visual (widget); | |
| 233 attributes.window_type = GDK_WINDOW_CHILD; | |
| 234 | |
| 235 #if (MOZ_WIDGET_GTK == 2) | |
| 236 attributes.colormap = gtk_widget_get_colormap (widget); | |
| 237 attributes_mask |= GDK_WA_COLORMAP; | |
| 238 #endif | |
| 239 | |
| 240 window = gdk_window_new (parent, &attributes, attributes_mask); | |
| 241 gdk_window_set_user_data (window, widget); | |
| 242 #if (MOZ_WIDGET_GTK == 2) | |
| 243 /* TODO GTK3? */ | |
| 244 /* set the back pixmap to None so that you don't end up with the gtk | |
| 245 default which is BlackPixel */ | |
| 246 gdk_window_set_back_pixmap (window, NULL, FALSE); | |
| 247 #endif | |
| 248 } else { | |
| 249 window = parent; | |
| 250 g_object_ref (window); | |
| 251 } | |
| 252 | |
| 253 gtk_widget_set_window (widget, window); | |
| 254 | |
| 255 #if (MOZ_WIDGET_GTK == 2) | |
| 256 widget->style = gtk_style_attach (widget->style, widget->window); | |
| 257 #endif | |
| 258 } | |
| 259 | |
| 260 void | |
| 261 moz_container_size_allocate (GtkWidget *widget, | |
| 262 GtkAllocation *allocation) | |
| 263 { | |
| 264 MozContainer *container; | |
| 265 GList *tmp_list; | |
| 266 GtkAllocation tmp_allocation; | |
| 267 GtkRequisition tmp_requisition; | |
| 268 GtkWidget *tmp_child; | |
| 269 | |
| 270 g_return_if_fail (IS_MOZ_CONTAINER (widget)); | |
| 271 | |
| 272 /* printf("moz_container_size_allocate %p %d %d %d %d\n", | |
| 273 (void *)widget, | |
| 274 allocation->x, | |
| 275 allocation->y, | |
| 276 allocation->width, | |
| 277 allocation->height); */ | |
| 278 | |
| 279 /* short circuit if you can */ | |
| 280 container = MOZ_CONTAINER (widget); | |
| 281 gtk_widget_get_allocation(widget, &tmp_allocation); | |
| 282 if (!container->children && | |
| 283 tmp_allocation.x == allocation->x && | |
| 284 tmp_allocation.y == allocation->y && | |
| 285 tmp_allocation.width == allocation->width && | |
| 286 tmp_allocation.height == allocation->height) { | |
| 287 return; | |
| 288 } | |
| 289 | |
| 290 gtk_widget_set_allocation(widget, allocation); | |
| 291 | |
| 292 tmp_list = container->children; | |
| 293 | |
| 294 while (tmp_list) { | |
| 295 MozContainerChild *child = tmp_list->data; | |
| 296 | |
| 297 moz_container_allocate_child (container, child); | |
| 298 | |
| 299 tmp_list = tmp_list->next; | |
| 300 } | |
| 301 | |
| 302 if (gtk_widget_get_has_window (widget) && | |
| 303 gtk_widget_get_realized (widget)) { | |
| 304 | |
| 305 gdk_window_move_resize(gtk_widget_get_window(widget), | |
| 306 allocation->x, | |
| 307 allocation->y, | |
| 308 allocation->width, | |
| 309 allocation->height); | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 void | |
| 314 moz_container_remove (GtkContainer *container, GtkWidget *child_widget) | |
| 315 { | |
| 316 MozContainerChild *child; | |
| 317 MozContainer *moz_container; | |
| 318 GdkWindow* parent_window; | |
| 319 | |
| 320 g_return_if_fail (IS_MOZ_CONTAINER(container)); | |
| 321 g_return_if_fail (GTK_IS_WIDGET(child_widget)); | |
| 322 | |
| 323 moz_container = MOZ_CONTAINER(container); | |
| 324 | |
| 325 child = moz_container_get_child (moz_container, child_widget); | |
| 326 g_return_if_fail (child); | |
| 327 | |
| 328 /* gtk_widget_unparent will remove the parent window (as well as the | |
| 329 * parent widget), but, in Mozilla's window hierarchy, the parent window | |
| 330 * may need to be kept because it may be part of a GdkWindow sub-hierarchy | |
| 331 * that is being moved to another MozContainer. | |
| 332 * | |
| 333 * (In a conventional GtkWidget hierarchy, GdkWindows being reparented | |
| 334 * would have their own GtkWidget and that widget would be the one being | |
| 335 * reparented. In Mozilla's hierarchy, the parent_window needs to be | |
| 336 * retained so that the GdkWindow sub-hierarchy is maintained.) | |
| 337 */ | |
| 338 parent_window = gtk_widget_get_parent_window(child_widget); | |
| 339 if (parent_window) | |
| 340 g_object_ref(parent_window); | |
| 341 | |
| 342 gtk_widget_unparent(child_widget); | |
| 343 | |
| 344 if (parent_window) { | |
| 345 /* The child_widget will always still exist because g_signal_emit, | |
| 346 * which invokes this function, holds a reference. | |
| 347 * | |
| 348 * If parent_window is the container's root window then it will not be | |
| 349 * the parent_window if the child_widget is placed in another | |
| 350 * container. | |
| 351 */ | |
| 352 if (parent_window != gtk_widget_get_window(GTK_WIDGET(container))) | |
| 353 gtk_widget_set_parent_window(child_widget, parent_window); | |
| 354 | |
| 355 g_object_unref(parent_window); | |
| 356 } | |
| 357 | |
| 358 moz_container->children = g_list_remove(moz_container->children, child); | |
| 359 g_free(child); | |
| 360 } | |
| 361 | |
| 362 void | |
| 363 moz_container_forall (GtkContainer *container, gboolean include_internals, | |
| 364 GtkCallback callback, gpointer callback_data) | |
| 365 { | |
| 366 MozContainer *moz_container; | |
| 367 GList *tmp_list; | |
| 368 | |
| 369 g_return_if_fail (IS_MOZ_CONTAINER(container)); | |
| 370 g_return_if_fail (callback != NULL); | |
| 371 | |
| 372 moz_container = MOZ_CONTAINER(container); | |
| 373 | |
| 374 tmp_list = moz_container->children; | |
| 375 while (tmp_list) { | |
| 376 MozContainerChild *child; | |
| 377 child = tmp_list->data; | |
| 378 tmp_list = tmp_list->next; | |
| 379 (* callback) (child->widget, callback_data); | |
| 380 } | |
| 381 } | |
| 382 | |
| 383 static void | |
| 384 moz_container_allocate_child (MozContainer *container, | |
| 385 MozContainerChild *child) | |
| 386 { | |
| 387 GtkAllocation allocation; | |
| 388 GtkRequisition requisition; | |
| 389 | |
| 390 gtk_widget_get_allocation (child->widget, &allocation); | |
| 391 allocation.x = child->x; | |
| 392 allocation.y = child->y; | |
| 393 /* gtk_widget_get_child_requisition (child->widget, &requisition); */ | |
| 394 /* gtk_widget_size_request (child->widget, &requisition); */ | |
| 395 | |
| 396 gtk_widget_size_allocate (child->widget, &allocation); | |
| 397 } | |
| 398 | |
| 399 MozContainerChild * | |
| 400 moz_container_get_child (MozContainer *container, GtkWidget *child_widget) | |
| 401 { | |
| 402 GList *tmp_list; | |
| 403 | |
| 404 tmp_list = container->children; | |
| 405 while (tmp_list) { | |
| 406 MozContainerChild *child; | |
| 407 | |
| 408 child = tmp_list->data; | |
| 409 tmp_list = tmp_list->next; | |
| 410 | |
| 411 if (child->widget == child_widget) | |
| 412 return child; | |
| 413 } | |
| 414 | |
| 415 return NULL; | |
| 416 } | |
| 417 | |
| 418 static void | |
| 419 moz_container_add(GtkContainer *container, GtkWidget *widget) | |
| 420 { | |
| 421 moz_container_put(MOZ_CONTAINER(container), widget, 0, 0); | |
| 422 } | |
| 423 |
