Pileus Git - ~andy/gtk/blob - demos/gtk-demo/offscreen_window.c

   1 /* Offscreen windows/Rotated button
   2  *
   3  * Offscreen windows can be used to transform parts of a widget
   4  * hierarchy. Note that the rotated button is fully functional.
   5  */
   6 #include <math.h>
   7 #include <gtk/gtk.h>
   8
   9 #define GTK_TYPE_ROTATED_BIN              (gtk_rotated_bin_get_type ())
  10 #define GTK_ROTATED_BIN(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBin))
  11 #define GTK_ROTATED_BIN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
  12 #define GTK_IS_ROTATED_BIN(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ROTATED_BIN))
  13 #define GTK_IS_ROTATED_BIN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ROTATED_BIN))
  14 #define GTK_ROTATED_BIN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ROTATED_BIN, GtkRotatedBinClass))
  15
  16 typedef struct _GtkRotatedBin   GtkRotatedBin;
  17 typedef struct _GtkRotatedBinClass  GtkRotatedBinClass;
  18
  19 struct _GtkRotatedBin
  20 {
  21   GtkContainer container;
  22
  23   GtkWidget *child;
  24   GdkWindow *offscreen_window;
  25   gdouble angle;
  26 };
  27
  28 struct _GtkRotatedBinClass
  29 {
  30   GtkContainerClass parent_class;
  31 };
  32
  33 GType      gtk_rotated_bin_get_type  (void) G_GNUC_CONST;
  34 GtkWidget* gtk_rotated_bin_new       (void);
  35 void       gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
  36                                       gdouble        angle);
  37
  38 /*** implementation ***/
  39
  40 static void     gtk_rotated_bin_realize       (GtkWidget       *widget);
  41 static void     gtk_rotated_bin_unrealize     (GtkWidget       *widget);
  42 static void     gtk_rotated_bin_size_request  (GtkWidget       *widget,
  43                                                GtkRequisition  *requisition);
  44 static void     gtk_rotated_bin_size_allocate (GtkWidget       *widget,
  45                                                GtkAllocation   *allocation);
  46 static gboolean gtk_rotated_bin_damage        (GtkWidget       *widget,
  47                                                GdkEventExpose  *event);
  48 static gboolean gtk_rotated_bin_expose        (GtkWidget       *widget,
  49                                                GdkEventExpose  *offscreen);
  50
  51 static void     gtk_rotated_bin_add           (GtkContainer    *container,
  52                                                GtkWidget       *child);
  53 static void     gtk_rotated_bin_remove        (GtkContainer    *container,
  54                                                GtkWidget       *widget);
  55 static void     gtk_rotated_bin_forall        (GtkContainer    *container,
  56                                                gboolean         include_internals,
  57                                                GtkCallback      callback,
  58                                                gpointer         callback_data);
  59 static GType    gtk_rotated_bin_child_type    (GtkContainer    *container);
  60
  61 G_DEFINE_TYPE (GtkRotatedBin, gtk_rotated_bin, GTK_TYPE_CONTAINER);
  62
  63 static void
  64 to_child (GtkRotatedBin *bin,
  65           double         widget_x,
  66           double         widget_y,
  67           double        *x_out,
  68           double        *y_out)
  69 {
  70   GtkAllocation child_area;
  71   double x, y, xr, yr;
  72   double c, s;
  73   double w, h;
  74
  75   s = sin (bin->angle);
  76   c = cos (bin->angle);
  77   gtk_widget_get_allocation (bin->child, &child_area);
  78
  79   w = c * child_area.width + s * child_area.height;
  80   h = s * child_area.width + c * child_area.height;
  81
  82   x = widget_x;
  83   y = widget_y;
  84
  85   x -= (w - child_area.width) / 2;
  86   y -= (h - child_area.height) / 2;
  87
  88   x -= child_area.width / 2;
  89   y -= child_area.height / 2;
  90
  91   xr = x * c + y * s;
  92   yr = y * c - x * s;
  93   x = xr;
  94   y = yr;
  95
  96   x += child_area.width / 2;
  97   y += child_area.height / 2;
  98
  99   *x_out = x;
 100   *y_out = y;
 101 }
 102
 103 static void
 104 to_parent (GtkRotatedBin *bin,
 105            double         offscreen_x,
 106            double         offscreen_y,
 107            double        *x_out,
 108            double        *y_out)
 109 {
 110   GtkAllocation child_area;
 111   double x, y, xr, yr;
 112   double c, s;
 113   double w, h;
 114
 115   s = sin (bin->angle);
 116   c = cos (bin->angle);
 117   gtk_widget_get_allocation (bin->child, &child_area);
 118
 119   w = c * child_area.width + s * child_area.height;
 120   h = s * child_area.width + c * child_area.height;
 121
 122   x = offscreen_x;
 123   y = offscreen_y;
 124
 125   x -= child_area.width / 2;
 126   y -= child_area.height / 2;
 127
 128   xr = x * c - y * s;
 129   yr = x * s + y * c;
 130   x = xr;
 131   y = yr;
 132
 133   x += child_area.width / 2;
 134   y += child_area.height / 2;
 135
 136   x -= (w - child_area.width) / 2;
 137   y -= (h - child_area.height) / 2;
 138
 139   *x_out = x;
 140   *y_out = y;
 141 }
 142
 143 static void
 144 gtk_rotated_bin_class_init (GtkRotatedBinClass *klass)
 145 {
 146   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 147   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 148
 149   widget_class->realize = gtk_rotated_bin_realize;
 150   widget_class->unrealize = gtk_rotated_bin_unrealize;
 151   widget_class->size_request = gtk_rotated_bin_size_request;
 152   widget_class->size_allocate = gtk_rotated_bin_size_allocate;
 153   widget_class->expose_event = gtk_rotated_bin_expose;
 154
 155   g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
 156                                    GTK_TYPE_ROTATED_BIN,
 157                                    g_cclosure_new (G_CALLBACK (gtk_rotated_bin_damage),
 158                                                    NULL, NULL));
 159
 160   container_class->add = gtk_rotated_bin_add;
 161   container_class->remove = gtk_rotated_bin_remove;
 162   container_class->forall = gtk_rotated_bin_forall;
 163   container_class->child_type = gtk_rotated_bin_child_type;
 164 }
 165
 166 static void
 167 gtk_rotated_bin_init (GtkRotatedBin *bin)
 168 {
 169   gtk_widget_set_has_window (GTK_WIDGET (bin), TRUE);
 170 }
 171
 172 GtkWidget *
 173 gtk_rotated_bin_new (void)
 174 {
 175   return g_object_new (GTK_TYPE_ROTATED_BIN, NULL);
 176 }
 177
 178 static GdkWindow *
 179 pick_offscreen_child (GdkWindow     *offscreen_window,
 180                       double         widget_x,
 181                       double         widget_y,
 182                       GtkRotatedBin *bin)
 183 {
 184  GtkAllocation child_area;
 185  double x, y;
 186
 187  if (bin->child && gtk_widget_get_visible (bin->child))
 188     {
 189       to_child (bin, widget_x, widget_y, &x, &y);
 190
 191       gtk_widget_get_allocation (bin->child, &child_area);
 192
 193       if (x >= 0 && x < child_area.width &&
 194           y >= 0 && y < child_area.height)
 195         return bin->offscreen_window;
 196     }
 197
 198   return NULL;
 199 }
 200
 201 static void
 202 offscreen_window_to_parent (GdkWindow     *offscreen_window,
 203                             double         offscreen_x,
 204                             double         offscreen_y,
 205                             double        *parent_x,
 206                             double        *parent_y,
 207                             GtkRotatedBin *bin)
 208 {
 209   to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
 210 }
 211
 212 static void
 213 offscreen_window_from_parent (GdkWindow     *window,
 214                               double         parent_x,
 215                               double         parent_y,
 216                               double        *offscreen_x,
 217                               double        *offscreen_y,
 218                               GtkRotatedBin *bin)
 219 {
 220   to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
 221 }
 222
 223 static void
 224 gtk_rotated_bin_realize (GtkWidget *widget)
 225 {
 226   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 227   GtkAllocation allocation;
 228   GtkStyle *style;
 229   GdkWindow *window;
 230   GdkWindowAttr attributes;
 231   gint attributes_mask;
 232   guint border_width;
 233   GtkRequisition child_requisition;
 234
 235   gtk_widget_set_realized (widget, TRUE);
 236
 237   gtk_widget_get_allocation (widget, &allocation);
 238   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 239
 240   attributes.x = allocation.x + border_width;
 241   attributes.y = allocation.y + border_width;
 242   attributes.width = allocation.width - 2 * border_width;
 243   attributes.height = allocation.height - 2 * border_width;
 244   attributes.window_type = GDK_WINDOW_CHILD;
 245   attributes.event_mask = gtk_widget_get_events (widget)
 246                         | GDK_EXPOSURE_MASK
 247                         | GDK_POINTER_MOTION_MASK
 248                         | GDK_BUTTON_PRESS_MASK
 249                         | GDK_BUTTON_RELEASE_MASK
 250                         | GDK_SCROLL_MASK
 251                         | GDK_ENTER_NOTIFY_MASK
 252                         | GDK_LEAVE_NOTIFY_MASK;
 253
 254   attributes.visual = gtk_widget_get_visual (widget);
 255   attributes.colormap = gtk_widget_get_colormap (widget);
 256   attributes.wclass = GDK_INPUT_OUTPUT;
 257
 258   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 259
 260   window = gdk_window_new (gtk_widget_get_parent_window (widget),
 261                            &attributes, attributes_mask);
 262   gtk_widget_set_window (widget, window);
 263   gdk_window_set_user_data (window, widget);
 264   g_signal_connect (window, "pick-embedded-child",
 265                     G_CALLBACK (pick_offscreen_child), bin);
 266
 267   attributes.window_type = GDK_WINDOW_OFFSCREEN;
 268
 269   child_requisition.width = child_requisition.height = 0;
 270   if (bin->child && gtk_widget_get_visible (bin->child))
 271     {
 272       GtkAllocation child_allocation;
 273
 274       gtk_widget_get_allocation (bin->child, &child_allocation);
 275       attributes.width = child_allocation.width;
 276       attributes.height = child_allocation.height;
 277     }
 278   bin->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
 279                                           &attributes, attributes_mask);
 280   gdk_window_set_user_data (bin->offscreen_window, widget);
 281   if (bin->child)
 282     gtk_widget_set_parent_window (bin->child, bin->offscreen_window);
 283   gdk_offscreen_window_set_embedder (bin->offscreen_window, window);
 284   g_signal_connect (bin->offscreen_window, "to-embedder",
 285                     G_CALLBACK (offscreen_window_to_parent), bin);
 286   g_signal_connect (bin->offscreen_window, "from-embedder",
 287                     G_CALLBACK (offscreen_window_from_parent), bin);
 288
 289   gtk_widget_style_attach (widget);
 290   style = gtk_widget_get_style (widget);
 291   gtk_style_set_background (style, window, GTK_STATE_NORMAL);
 292   gtk_style_set_background (style, bin->offscreen_window, GTK_STATE_NORMAL);
 293   gdk_window_show (bin->offscreen_window);
 294 }
 295
 296 static void
 297 gtk_rotated_bin_unrealize (GtkWidget *widget)
 298 {
 299   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 300
 301   gdk_window_set_user_data (bin->offscreen_window, NULL);
 302   gdk_window_destroy (bin->offscreen_window);
 303   bin->offscreen_window = NULL;
 304
 305   GTK_WIDGET_CLASS (gtk_rotated_bin_parent_class)->unrealize (widget);
 306 }
 307
 308 static GType
 309 gtk_rotated_bin_child_type (GtkContainer *container)
 310 {
 311   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 312
 313   if (bin->child)
 314     return G_TYPE_NONE;
 315
 316   return GTK_TYPE_WIDGET;
 317 }
 318
 319 static void
 320 gtk_rotated_bin_add (GtkContainer *container,
 321                      GtkWidget    *widget)
 322 {
 323   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 324
 325   if (!bin->child)
 326     {
 327       gtk_widget_set_parent_window (widget, bin->offscreen_window);
 328       gtk_widget_set_parent (widget, GTK_WIDGET (bin));
 329       bin->child = widget;
 330     }
 331   else
 332     g_warning ("GtkRotatedBin cannot have more than one child\n");
 333 }
 334
 335 static void
 336 gtk_rotated_bin_remove (GtkContainer *container,
 337                         GtkWidget    *widget)
 338 {
 339   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 340   gboolean was_visible;
 341
 342   was_visible = gtk_widget_get_visible (widget);
 343
 344   if (bin->child == widget)
 345     {
 346       gtk_widget_unparent (widget);
 347
 348       bin->child = NULL;
 349
 350       if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
 351         gtk_widget_queue_resize (GTK_WIDGET (container));
 352     }
 353 }
 354
 355 static void
 356 gtk_rotated_bin_forall (GtkContainer *container,
 357                         gboolean      include_internals,
 358                         GtkCallback   callback,
 359                         gpointer      callback_data)
 360 {
 361   GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
 362
 363   g_return_if_fail (callback != NULL);
 364
 365   if (bin->child)
 366     (*callback) (bin->child, callback_data);
 367 }
 368
 369 void
 370 gtk_rotated_bin_set_angle (GtkRotatedBin *bin,
 371                            gdouble        angle)
 372 {
 373   g_return_if_fail (GTK_IS_ROTATED_BIN (bin));
 374
 375   bin->angle = angle;
 376   gtk_widget_queue_resize (GTK_WIDGET (bin));
 377
 378   gdk_window_geometry_changed (bin->offscreen_window);
 379 }
 380
 381 static void
 382 gtk_rotated_bin_size_request (GtkWidget      *widget,
 383                               GtkRequisition *requisition)
 384 {
 385   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 386   GtkRequisition child_requisition;
 387   double s, c;
 388   double w, h;
 389   guint border_width;
 390
 391   child_requisition.width = 0;
 392   child_requisition.height = 0;
 393
 394   if (bin->child && gtk_widget_get_visible (bin->child))
 395     gtk_size_request_get_size (GTK_SIZE_REQUEST (bin->child),
 396                                &child_requisition, NULL);
 397
 398   s = sin (bin->angle);
 399   c = cos (bin->angle);
 400   w = c * child_requisition.width + s * child_requisition.height;
 401   h = s * child_requisition.width + c * child_requisition.height;
 402
 403   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 404   requisition->width = border_width * 2 + w;
 405   requisition->height = border_width * 2 + h;
 406 }
 407
 408 static void
 409 gtk_rotated_bin_size_allocate (GtkWidget     *widget,
 410                                GtkAllocation *allocation)
 411 {
 412   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 413   guint border_width;
 414   gint w, h;
 415   gdouble s, c;
 416
 417   gtk_widget_set_allocation (widget, allocation);
 418
 419   border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
 420
 421   w = allocation->width - border_width * 2;
 422   h = allocation->height - border_width * 2;
 423
 424   if (gtk_widget_get_realized (widget))
 425     gdk_window_move_resize (gtk_widget_get_window (widget),
 426                             allocation->x + border_width,
 427                             allocation->y + border_width,
 428                             w, h);
 429
 430   if (bin->child && gtk_widget_get_visible (bin->child))
 431     {
 432       GtkRequisition child_requisition;
 433       GtkAllocation child_allocation;
 434
 435       s = sin (bin->angle);
 436       c = cos (bin->angle);
 437
 438       gtk_size_request_get_size (GTK_SIZE_REQUEST (bin->child),
 439                                  &child_requisition, NULL);
 440       child_allocation.x = 0;
 441       child_allocation.y = 0;
 442       child_allocation.height = child_requisition.height;
 443       if (c == 0.0)
 444         child_allocation.width = h / s;
 445       else if (s == 0.0)
 446         child_allocation.width = w / c;
 447       else
 448         child_allocation.width = MIN ((w - s * child_allocation.height) / c,
 449                                       (h - c * child_allocation.height) / s);
 450
 451       if (gtk_widget_get_realized (widget))
 452         gdk_window_move_resize (bin->offscreen_window,
 453                                 child_allocation.x,
 454                                 child_allocation.y,
 455                                 child_allocation.width,
 456                                 child_allocation.height);
 457
 458       child_allocation.x = child_allocation.y = 0;
 459       gtk_widget_size_allocate (bin->child, &child_allocation);
 460     }
 461 }
 462
 463 static gboolean
 464 gtk_rotated_bin_damage (GtkWidget      *widget,
 465                         GdkEventExpose *event)
 466 {
 467   gdk_window_invalidate_rect (gtk_widget_get_window (widget),
 468                               NULL, FALSE);
 469
 470   return TRUE;
 471 }
 472
 473 static gboolean
 474 gtk_rotated_bin_expose (GtkWidget      *widget,
 475                         GdkEventExpose *event)
 476 {
 477   GtkRotatedBin *bin = GTK_ROTATED_BIN (widget);
 478   GdkWindow *window;
 479   gint width, height;
 480   gdouble s, c;
 481   gdouble w, h;
 482
 483   if (gtk_widget_is_drawable (widget))
 484     {
 485       window = gtk_widget_get_window (widget);
 486       if (event->window == window)
 487         {
 488           cairo_surface_t *surface;
 489           GtkAllocation child_area;
 490           cairo_t *cr;
 491
 492           if (bin->child && gtk_widget_get_visible (bin->child))
 493             {
 494               surface = gdk_offscreen_window_get_surface (bin->offscreen_window);
 495               gtk_widget_get_allocation (bin->child, &child_area);
 496
 497               cr = gdk_cairo_create (window);
 498
 499               /* transform */
 500               s = sin (bin->angle);
 501               c = cos (bin->angle);
 502               w = c * child_area.width + s * child_area.height;
 503               h = s * child_area.width + c * child_area.height;
 504
 505               cairo_translate (cr, (w - child_area.width) / 2, (h - child_area.height) / 2);
 506               cairo_translate (cr, child_area.width / 2, child_area.height / 2);
 507               cairo_rotate (cr, bin->angle);
 508               cairo_translate (cr, -child_area.width / 2, -child_area.height / 2);
 509
 510               /* clip */
 511               gdk_drawable_get_size (bin->offscreen_window, &width, &height);
 512               cairo_rectangle (cr, 0, 0, width, height);
 513               cairo_clip (cr);
 514               /* paint */
 515               cairo_set_source_surface (cr, surface, 0, 0);
 516               cairo_paint (cr);
 517
 518               cairo_destroy (cr);
 519             }
 520         }
 521       else if (event->window == bin->offscreen_window)
 522         {
 523           gtk_paint_flat_box (gtk_widget_get_style (widget), event->window,
 524                               GTK_STATE_NORMAL, GTK_SHADOW_NONE,
 525                               &event->area, widget, "blah",
 526                               0, 0, -1, -1);
 527
 528           if (bin->child)
 529             gtk_container_propagate_expose (GTK_CONTAINER (widget),
 530                                             bin->child,
 531                                             event);
 532         }
 533     }
 534
 535   return FALSE;
 536 }
 537
 538 /*** ***/
 539
 540 static void
 541 scale_changed (GtkRange      *range,
 542                GtkRotatedBin *bin)
 543 {
 544   gtk_rotated_bin_set_angle (bin, gtk_range_get_value (range));
 545 }
 546
 547 static GtkWidget *window = NULL;
 548
 549 GtkWidget *
 550 do_offscreen_window (GtkWidget *do_widget)
 551 {
 552   if (!window)
 553     {
 554       GtkWidget *bin, *vbox, *scale, *button;
 555       GdkColor black;
 556
 557       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 558       gtk_window_set_screen (GTK_WINDOW (window),
 559                              gtk_widget_get_screen (do_widget));
 560       gtk_window_set_title (GTK_WINDOW (window), "Rotated widget");
 561
 562       g_signal_connect (window, "destroy",
 563                         G_CALLBACK (gtk_widget_destroyed), &window);
 564
 565       gdk_color_parse ("black", &black);
 566       gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &black);
 567       gtk_container_set_border_width (GTK_CONTAINER (window), 10);
 568
 569       vbox = gtk_vbox_new (0, FALSE);
 570       scale = gtk_hscale_new_with_range (0, G_PI/2, 0.01);
 571       gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
 572
 573       button = gtk_button_new_with_label ("A Button");
 574       bin = gtk_rotated_bin_new ();
 575
 576       g_signal_connect (scale, "value-changed", G_CALLBACK (scale_changed), bin);
 577
 578       gtk_container_add (GTK_CONTAINER (window), vbox);
 579       gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 580       gtk_box_pack_start (GTK_BOX (vbox), bin, TRUE, TRUE, 0);
 581       gtk_container_add (GTK_CONTAINER (bin), button);
 582     }
 583
 584   if (!gtk_widget_get_visible (window))
 585     gtk_widget_show_all (window);
 586   else
 587     {
 588       gtk_widget_destroy (window);
 589       window = NULL;
 590     }
 591
 592   return window;
 593 }
 594