libjava/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c

   1 /* gtkwindowpeer.c -- Native implementation of GtkWindowPeer
   2    Copyright (C) 1998, 1999, 2002, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 #include "gtkpeer.h"
  40 #include "gnu_java_awt_peer_gtk_GtkWindowPeer.h"
  41 #include <gdk/gdkprivate.h>
  42 #include <gdk/gdkx.h>
  43 #include <X11/Xatom.h>
  44
  45 /* FIXME: we're currently seeing the double-activation that occurs
  46    with metacity and GTK.  See
  47    http://bugzilla.gnome.org/show_bug.cgi?id=140977 for details. */
  48
  49 static void window_get_frame_extents (GtkWidget *window,
  50                                       int *top, int *left,
  51                                       int *bottom, int *right);
  52
  53 static void request_frame_extents (GtkWidget *window);
  54
  55 static Bool property_notify_predicate (Display *display,
  56                                        XEvent  *xevent,
  57                                        XPointer arg);
  58
  59 static void window_delete_cb (GtkWidget *widget, GdkEvent *event,
  60                               jobject peer);
  61 static void window_destroy_cb (GtkWidget *widget, GdkEvent *event,
  62                                jobject peer);
  63 static void window_show_cb (GtkWidget *widget, jobject peer);
  64 static void window_active_state_change_cb (GtkWidget *widget,
  65                                            GParamSpec *pspec,
  66                                            jobject peer);
  67 static void window_focus_state_change_cb (GtkWidget *widget,
  68                                           GParamSpec *pspec,
  69                                           jobject peer);
  70 static gboolean window_focus_in_cb (GtkWidget * widget,
  71                                     GdkEventFocus *event,
  72                                     jobject peer);
  73 static gboolean window_focus_out_cb (GtkWidget * widget,
  74                                      GdkEventFocus *event,
  75                                      jobject peer);
  76 static gboolean window_window_state_cb (GtkWidget *widget,
  77                                         GdkEvent *event,
  78                                         jobject peer);
  79 static jint window_get_new_state (GtkWidget *widget);
  80 static gboolean window_property_changed_cb (GtkWidget *widget,
  81                                             GdkEventProperty *event,
  82                                             jobject peer);
  83 static void realize_cb (GtkWidget *widget, jobject peer);
  84
  85 /* Union used for type punning. */
  86 union extents_union
  87 {
  88   guchar **gu_extents;
  89   unsigned long **extents;
  90 };
  91
  92 union atom_list_union
  93 {
  94   guchar **gu_extents;
  95   Atom **atom_list;
  96 };
  97
  98 JNIEXPORT void JNICALL
  99 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_create
 100   (JNIEnv *env, jobject obj, jint type, jboolean decorated, jobject parent)
 101 {
 102   GtkWidget *window_widget;
 103   GtkWindow *window;
 104   void *window_parent;
 105   GtkWidget *fixed;
 106
 107   NSA_SET_GLOBAL_REF (env, obj);
 108
 109   gdk_threads_enter ();
 110
 111   window_widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 112   window = GTK_WINDOW (window_widget);
 113
 114   /* Keep this window in front of its parent, if it has one. */
 115   if (parent)
 116     {
 117       window_parent = NSA_GET_PTR (env, parent);
 118       gtk_window_set_transient_for (window, GTK_WINDOW(window_parent));
 119     }
 120
 121   gtk_window_set_decorated (window, decorated);
 122
 123   gtk_window_set_type_hint (window, type);
 124
 125   gtk_window_group_add_window (global_gtk_window_group, window);
 126
 127   fixed = gtk_fixed_new ();
 128   gtk_container_add (GTK_CONTAINER (window_widget), fixed);
 129
 130   gtk_widget_show (fixed);
 131
 132   gdk_threads_leave ();
 133
 134   NSA_SET_PTR (env, obj, window_widget);
 135 }
 136
 137 JNIEXPORT void JNICALL
 138 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetTitle
 139   (JNIEnv *env, jobject obj, jstring title)
 140 {
 141   const char *c_title;
 142   void *ptr;
 143
 144   ptr = NSA_GET_PTR (env, obj);
 145
 146   c_title = (*env)->GetStringUTFChars (env, title, NULL);
 147
 148   gdk_threads_enter ();
 149
 150   gtk_window_set_title (GTK_WINDOW (ptr), c_title);
 151
 152   gdk_threads_leave ();
 153
 154   (*env)->ReleaseStringUTFChars (env, title, c_title);
 155 }
 156
 157 JNIEXPORT void JNICALL
 158 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetResizable
 159   (JNIEnv *env, jobject obj, jboolean resizable)
 160 {
 161   void *ptr;
 162
 163   ptr = NSA_GET_PTR (env, obj);
 164
 165   gdk_threads_enter ();
 166
 167   gtk_window_set_policy (GTK_WINDOW (ptr), resizable, resizable, FALSE);
 168
 169   gdk_threads_leave ();
 170 }
 171
 172 JNIEXPORT void JNICALL
 173 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetModal
 174   (JNIEnv *env, jobject obj, jboolean modal)
 175 {
 176   void *ptr;
 177
 178   ptr = NSA_GET_PTR (env, obj);
 179
 180   gdk_threads_enter ();
 181
 182   gtk_window_set_modal (GTK_WINDOW (ptr), modal);
 183
 184   gdk_threads_leave ();
 185 }
 186
 187 JNIEXPORT void JNICALL
 188 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetVisible
 189   (JNIEnv *env, jobject obj, jboolean visible)
 190 {
 191   void *ptr;
 192
 193   ptr = NSA_GET_PTR (env, obj);
 194
 195   gdk_threads_enter ();
 196
 197   if (visible)
 198     gtk_widget_show (GTK_WIDGET (ptr));
 199   else
 200     gtk_widget_hide (GTK_WIDGET (ptr));
 201
 202   XFlush (GDK_DISPLAY ());
 203
 204   gdk_threads_leave ();
 205 }
 206
 207 JNIEXPORT void JNICALL
 208 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_connectSignals
 209   (JNIEnv *env, jobject obj)
 210 {
 211   void *ptr;
 212   jobject *gref;
 213
 214   ptr = NSA_GET_PTR (env, obj);
 215   gref = NSA_GET_GLOBAL_REF (env, obj);
 216
 217   gdk_threads_enter ();
 218
 219   g_signal_connect (G_OBJECT (ptr), "event",
 220                     G_CALLBACK (pre_event_handler), *gref);
 221
 222   g_signal_connect (G_OBJECT (ptr), "delete-event",
 223                     G_CALLBACK (window_delete_cb), *gref);
 224
 225   g_signal_connect (G_OBJECT (ptr), "destroy-event",
 226                     G_CALLBACK (window_destroy_cb), *gref);
 227
 228   g_signal_connect (G_OBJECT (ptr), "show",
 229                     G_CALLBACK (window_show_cb), *gref);
 230
 231   g_signal_connect (G_OBJECT (ptr), "notify::is-active",
 232                     G_CALLBACK (window_active_state_change_cb), *gref);
 233
 234   g_signal_connect (G_OBJECT (ptr), "notify::has-toplevel-focus",
 235                     G_CALLBACK (window_focus_state_change_cb), *gref);
 236
 237   g_signal_connect (G_OBJECT (ptr), "focus-in-event",
 238                     G_CALLBACK (window_focus_in_cb), *gref);
 239
 240   g_signal_connect (G_OBJECT (ptr), "focus-out-event",
 241                     G_CALLBACK (window_focus_out_cb), *gref);
 242
 243   g_signal_connect (G_OBJECT (ptr), "window-state-event",
 244                     G_CALLBACK (window_window_state_cb), *gref);
 245
 246   g_signal_connect (G_OBJECT (ptr), "property-notify-event",
 247                     G_CALLBACK (window_property_changed_cb), *gref);
 248
 249   g_signal_connect_after (G_OBJECT (ptr), "realize",
 250                           G_CALLBACK (realize_cb), *gref);
 251
 252   g_signal_connect_after (G_OBJECT (ptr), "realize",
 253                           G_CALLBACK (connect_awt_hook_cb), *gref);
 254
 255   gdk_threads_leave ();
 256 }
 257
 258 JNIEXPORT void JNICALL
 259 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_toBack (JNIEnv *env,
 260     jobject obj)
 261 {
 262   void *ptr;
 263   ptr = NSA_GET_PTR (env, obj);
 264
 265   gdk_threads_enter ();
 266
 267   gdk_window_lower (GTK_WIDGET (ptr)->window);
 268   gdk_flush ();
 269
 270   gdk_threads_leave ();
 271 }
 272
 273 JNIEXPORT void JNICALL
 274 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_toFront (JNIEnv *env,
 275     jobject obj)
 276 {
 277   void *ptr;
 278   ptr = NSA_GET_PTR (env, obj);
 279
 280   gdk_threads_enter ();
 281
 282   gdk_window_raise (GTK_WIDGET (ptr)->window);
 283   gdk_flush ();
 284
 285   gdk_threads_leave ();
 286 }
 287
 288 JNIEXPORT void JNICALL
 289 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setBoundsCallback
 290   (JNIEnv *env __attribute__((unused)), jobject obj __attribute__((unused)),
 291    jobject window, jint x, jint y, jint width, jint height)
 292 {
 293   /* Circumvent package-private access to call Window's
 294      setBoundsCallback method. */
 295   (*gdk_env())->CallVoidMethod (gdk_env(), window, setBoundsCallbackID,
 296                               x, y, width, height);
 297 }
 298
 299 JNIEXPORT void JNICALL
 300 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setSize
 301   (JNIEnv *env, jobject obj, jint width, jint height)
 302 {
 303   void *ptr = NSA_GET_PTR (env, obj);
 304
 305   /* Avoid GTK runtime assertion failures. */
 306   width = (width < 1) ? 1 : width;
 307   height = (height < 1) ? 1 : height;
 308
 309   gdk_threads_enter ();
 310
 311   gtk_widget_set_size_request (GTK_WIDGET(ptr), width, height);
 312
 313   gdk_threads_leave ();
 314 }
 315
 316 JNIEXPORT void JNICALL
 317 Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetBounds
 318   (JNIEnv *env, jobject obj, jint x, jint y, jint width, jint height)
 319 {
 320   void *ptr = NSA_GET_PTR (env, obj);
 321
 322   /* Avoid GTK runtime assertion failures. */
 323   width = (width < 1) ? 1 : width;
 324   height = (height < 1) ? 1 : height;
 325
 326   gdk_threads_enter ();
 327
 328   gtk_window_move (GTK_WINDOW(ptr), x, y);
 329   /* The call to gdk_window_move is needed in addition to the call to
 330      gtk_window_move.  If gdk_window_move isn't called, then the
 331      following set of operations doesn't give the expected results:
 332
 333      1. show a window
 334      2. manually move it to another position on the screen
 335      3. hide the window
 336      4. reposition the window with Component.setLocation
 337      5. show the window
 338
 339      Instead of being at the position set by setLocation, the window
 340      is reshown at the position to which it was moved manually. */
 341   if (GTK_WIDGET (ptr)->window != NULL)
 342     gdk_window_move (GTK_WIDGET (ptr)->window, x, y);
 343
 344   /* Need to change the widget's request size. */
 345   gtk_widget_set_size_request (GTK_WIDGET(ptr), width, height);
 346   /* Also need to call gtk_window_resize.  If the resize is requested
 347      by the program and the window's "resizable" property is true then
 348      the size request will not be honoured. */
 349   gtk_window_resize (GTK_WINDOW (ptr), width, height);
 350   gdk_threads_leave ();
 351 }
 352
 353 static void
 354 window_get_frame_extents (GtkWidget *window,
 355                           int *top, int *left, int *bottom, int *right)
 356 {
 357   unsigned long *extents = NULL;
 358   union extents_union gu_ex;
 359
 360   /* Guess frame extents in case _NET_FRAME_EXTENTS is not
 361      supported. */
 362   *top = 23;
 363   *left = 6;
 364   *bottom = 6;
 365   *right = 6;
 366
 367   /* Request that the window manager set window's
 368      _NET_FRAME_EXTENTS property. */
 369   request_frame_extents (window);
 370
 371   /* Attempt to retrieve window's frame extents. */
 372   gu_ex.extents = &extents;
 373   if (gdk_property_get (window->window,
 374                         gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE),
 375                         gdk_atom_intern ("CARDINAL", FALSE),
 376                         0,
 377                         sizeof (unsigned long) * 4,
 378                         FALSE,
 379                         NULL,
 380                         NULL,
 381                         NULL,
 382                         gu_ex.gu_extents))
 383     {
 384       *left = extents [0];
 385       *right = extents [1];
 386       *top = extents [2];
 387       *bottom = extents [3];
 388     }
 389 }
 390
 391 static Atom extents_atom = 0;
 392
 393 /* Requests that the window manager set window's
 394    _NET_FRAME_EXTENTS property. */
 395 static void
 396 request_frame_extents (GtkWidget *window)
 397 {
 398   const char *request_str = "_NET_REQUEST_FRAME_EXTENTS";
 399   GdkAtom request_extents = gdk_atom_intern (request_str, FALSE);
 400
 401   /* Check if the current window manager supports
 402      _NET_REQUEST_FRAME_EXTENTS. */
 403   if (gdk_net_wm_supports (request_extents))
 404     {
 405       GdkDisplay *display = gtk_widget_get_display (window);
 406       Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
 407
 408       GdkWindow *root_window = gdk_get_default_root_window ();
 409       Window xroot_window = GDK_WINDOW_XID (root_window);
 410
 411       Atom extents_request_atom =
 412         gdk_x11_get_xatom_by_name_for_display (display, request_str);
 413
 414       XEvent xevent;
 415       XEvent notify_xevent;
 416
 417       unsigned long window_id = GDK_WINDOW_XID (GDK_DRAWABLE(window->window));
 418
 419       if (!extents_atom)
 420         {
 421           const char *extents_str = "_NET_FRAME_EXTENTS";
 422           extents_atom =
 423             gdk_x11_get_xatom_by_name_for_display (display, extents_str);
 424         }
 425
 426       xevent.xclient.type = ClientMessage;
 427       xevent.xclient.message_type = extents_request_atom;
 428       xevent.xclient.display = xdisplay;
 429       xevent.xclient.window = window_id;
 430       xevent.xclient.format = 32;
 431       xevent.xclient.data.l[0] = 0;
 432       xevent.xclient.data.l[1] = 0;
 433       xevent.xclient.data.l[2] = 0;
 434       xevent.xclient.data.l[3] = 0;
 435       xevent.xclient.data.l[4] = 0;
 436
 437       XSendEvent (xdisplay, xroot_window, False,
 438                   (SubstructureRedirectMask | SubstructureNotifyMask),
 439                   &xevent);
 440
 441       XIfEvent(xdisplay, &notify_xevent,
 442                property_notify_predicate, (XPointer) &window_id);
 443     }
 444 }
 445
 446 static Bool
 447 property_notify_predicate (Display *xdisplay __attribute__((unused)),
 448                            XEvent  *event,
 449                            XPointer window_id)
 450 {
 451   unsigned long *window = (unsigned long *) window_id;
 452
 453   if (event->xany.type == PropertyNotify
 454       && event->xany.window == *window
 455       && event->xproperty.atom == extents_atom)
 456     return True;
 457   else
 458     return False;
 459 }
 460
 461 static void
 462 window_delete_cb (GtkWidget *widget __attribute__((unused)),
 463                   GdkEvent *event __attribute__((unused)),
 464                   jobject peer)
 465 {
 466   gdk_threads_leave ();
 467   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 468                               postWindowEventID,
 469                               (jint) AWT_WINDOW_CLOSING,
 470                               (jobject) NULL, (jint) 0);
 471   gdk_threads_enter ();
 472 }
 473
 474 static void
 475 window_destroy_cb (GtkWidget *widget __attribute__((unused)),
 476                    GdkEvent *event __attribute__((unused)),
 477                    jobject peer)
 478 {
 479   gdk_threads_leave ();
 480   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 481                               postWindowEventID,
 482                               (jint) AWT_WINDOW_CLOSED,
 483                               (jobject) NULL, (jint) 0);
 484   gdk_threads_enter ();
 485 }
 486
 487 static void
 488 window_show_cb (GtkWidget *widget __attribute__((unused)),
 489                 jobject peer)
 490 {
 491   gdk_threads_leave ();
 492   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 493                               postWindowEventID,
 494                               (jint) AWT_WINDOW_OPENED,
 495                               (jobject) NULL, (jint) 0);
 496   gdk_threads_enter ();
 497 }
 498
 499 static void
 500 window_active_state_change_cb (GtkWidget *widget __attribute__((unused)),
 501                                GParamSpec *pspec __attribute__((unused)),
 502                                jobject peer __attribute__((unused)))
 503 {
 504   /* FIXME: not sure if this is needed or not. */
 505   /* Remove the unused attributes if you fix the below.  */
 506 #if 0
 507   gdk_threads_leave ();
 508   if (GTK_WINDOW (widget)->is_active)
 509     (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 510                                 postWindowEventID,
 511                                 (jint) AWT_WINDOW_GAINED_FOCUS,
 512                                 (jobject) NULL, (jint) 0);
 513   else
 514     (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 515                                 postWindowEventID,
 516                                 (jint) AWT_WINDOW_DEACTIVATED,
 517                                 (jobject) NULL, (jint) 0);
 518   gdk_threads_enter ();
 519 #endif
 520 }
 521
 522 static void
 523 window_focus_state_change_cb (GtkWidget *widget,
 524                               GParamSpec *pspec __attribute__((unused)),
 525                               jobject peer)
 526 {
 527   gdk_threads_leave ();
 528   if (GTK_WINDOW (widget)->has_toplevel_focus)
 529     (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 530                                 postWindowEventID,
 531                                 (jint) AWT_WINDOW_ACTIVATED,
 532                                 (jobject) NULL, (jint) 0);
 533   else
 534     (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 535                                 postWindowEventID,
 536                                 (jint) AWT_WINDOW_DEACTIVATED,
 537                                 (jobject) NULL, (jint) 0);
 538   gdk_threads_enter ();
 539 }
 540
 541 static gboolean
 542 window_focus_in_cb (GtkWidget * widget  __attribute__((unused)),
 543                     GdkEventFocus *event  __attribute__((unused)),
 544                     jobject peer)
 545 {
 546   gdk_threads_leave ();
 547   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 548                               postWindowEventID,
 549                               (jint) AWT_WINDOW_GAINED_FOCUS,
 550                               (jobject) NULL, (jint) 0);
 551   /* FIXME: somewhere after this is handled, the child window is
 552      getting an expose event. */
 553   gdk_threads_enter ();
 554   return FALSE;
 555 }
 556
 557 static gboolean
 558 window_focus_out_cb (GtkWidget * widget __attribute__((unused)),
 559                      GdkEventFocus *event __attribute__((unused)),
 560                      jobject peer)
 561 {
 562   gdk_threads_leave ();
 563   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 564                               postWindowEventID,
 565                               (jint) AWT_WINDOW_LOST_FOCUS,
 566                               (jobject) NULL, (jint) 0);
 567   /* FIXME: somewhere after this is handled, the child window is
 568      getting an expose event. */
 569   gdk_threads_enter ();
 570   return FALSE;
 571 }
 572
 573 static gboolean
 574 window_window_state_cb (GtkWidget *widget,
 575                         GdkEvent *event,
 576                         jobject peer)
 577 {
 578   jint new_state;
 579
 580   /* Handle WINDOW_ICONIFIED and WINDOW_DEICONIFIED events. */
 581   if (event->window_state.changed_mask & GDK_WINDOW_STATE_ICONIFIED)
 582     {
 583       /* We've either been iconified or deiconified. */
 584       if (event->window_state.new_window_state & GDK_WINDOW_STATE_ICONIFIED)
 585         {
 586           /* We've been iconified. */
 587           gdk_threads_leave ();
 588           (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 589                                       postWindowEventID,
 590                                       (jint) AWT_WINDOW_ICONIFIED,
 591                                       (jobject) NULL, (jint) 0);
 592           gdk_threads_enter ();
 593         }
 594       else
 595         {
 596           /* We've been deiconified. */
 597           gdk_threads_leave ();
 598           (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 599                                       postWindowEventID,
 600                                       (jint) AWT_WINDOW_DEICONIFIED,
 601                                       (jobject) NULL, (jint) 0);
 602           gdk_threads_enter ();
 603         }
 604     }
 605
 606   /* Post a WINDOW_STATE_CHANGED event, passing the new frame state to
 607      GtkWindowPeer. */
 608   new_state = AWT_FRAME_STATE_NORMAL;
 609
 610   if (event->window_state.new_window_state & GDK_WINDOW_STATE_ICONIFIED)
 611     new_state |= AWT_FRAME_STATE_ICONIFIED;
 612
 613   new_state |= window_get_new_state (widget);
 614
 615   gdk_threads_leave ();
 616   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 617                               postWindowEventID,
 618                               (jint) AWT_WINDOW_STATE_CHANGED,
 619                               (jobject) NULL, new_state);
 620   gdk_threads_enter ();
 621   return TRUE;
 622 }
 623
 624 static jint
 625 window_get_new_state (GtkWidget *widget)
 626 {
 627   GdkDisplay *display = gtk_widget_get_display(widget);
 628   jint new_state = AWT_FRAME_STATE_NORMAL;
 629   Atom type;
 630   gint format;
 631   gulong atom_count;
 632   gulong bytes_after;
 633   Atom *atom_list = NULL;
 634   union atom_list_union alu;
 635   gulong i;
 636
 637   alu.atom_list = &atom_list;
 638   XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display),
 639                       GDK_WINDOW_XID (widget->window),
 640                       gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE"),
 641                       0, G_MAXLONG, False, XA_ATOM, &type, &format, &atom_count,
 642                       &bytes_after, alu.gu_extents);
 643
 644   if (type != None)
 645     {
 646       Atom maxvert = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_MAXIMIZED_VERT");
 647       Atom maxhorz      = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_STATE_MAXIMIZED_HORZ");
 648
 649       i = 0;
 650       while (i < atom_count)
 651         {
 652           if (atom_list[i] == maxhorz)
 653             new_state |= AWT_FRAME_STATE_MAXIMIZED_HORIZ;
 654           else if (atom_list[i] == maxvert)
 655             new_state |= AWT_FRAME_STATE_MAXIMIZED_VERT;
 656
 657           ++i;
 658         }
 659
 660       XFree (atom_list);
 661     }
 662   return new_state;
 663 }
 664
 665 static gboolean
 666 window_property_changed_cb (GtkWidget *widget __attribute__((unused)),
 667                             GdkEventProperty *event,
 668                             jobject peer)
 669 {
 670   unsigned long *extents;
 671   union extents_union gu_ex;
 672
 673   gu_ex.extents = &extents;
 674   if (gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE) == event->atom
 675       && gdk_property_get (event->window,
 676                            gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE),
 677                            gdk_atom_intern ("CARDINAL", FALSE),
 678                            0,
 679                            sizeof (unsigned long) * 4,
 680                            FALSE,
 681                            NULL,
 682                            NULL,
 683                            NULL,
 684                            gu_ex.gu_extents))
 685     {
 686       gdk_threads_leave ();
 687       (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 688                                     postInsetsChangedEventID,
 689                                     (jint) extents[2],  /* top */
 690                                     (jint) extents[0],  /* left */
 691                                     (jint) extents[3],  /* bottom */
 692                                     (jint) extents[1]); /* right */
 693       gdk_threads_enter ();
 694     }
 695
 696
 697   return FALSE;
 698 }
 699
 700 static void
 701 realize_cb (GtkWidget *widget, jobject peer)
 702 {
 703   jint top = 0;
 704   jint left = 0;
 705   jint bottom = 0;
 706   jint right = 0;
 707   jint width = 0;
 708   jint height = 0;
 709
 710   width = (*gdk_env())->CallIntMethod (gdk_env(), peer, windowGetWidthID);
 711   height = (*gdk_env())->CallIntMethod (gdk_env(), peer, windowGetHeightID);
 712
 713   window_get_frame_extents (widget, &top, &left, &bottom, &right);
 714
 715   (*gdk_env())->CallVoidMethod (gdk_env(), peer,
 716                                 postInsetsChangedEventID,
 717                                 top, left, bottom, right);
 718
 719   gtk_window_set_default_size (GTK_WINDOW (widget),
 720                                MAX (1, width - left - right),
 721                                MAX (1, height - top - bottom));
 722
 723   /* set the size like we do in nativeSetBounds */
 724   gtk_widget_set_size_request (widget,
 725                                MAX (1, width - left - right),
 726                                MAX (1, height - top - bottom));
 727
 728   gtk_window_resize (GTK_WINDOW (widget),
 729                      MAX (1, width - left - right),
 730                      MAX (1, height - top - bottom));
 731 }