Fwd: Help with GdkWindow size

From: Carl Nygard <cjnygard gmail com>
To: gtk-app-devel-list gnome org
Subject: Fwd: Help with GdkWindow size
Date: Mon, 24 Mar 2014 21:12:55 -0700

Getting resize and expose events through XWindows, but still nothing
through gdk.  The g_signal_connect still complains about invalid instance.
Based on some other docs (
http://gtk.10911.n7.nabble.com/Capture-GdkWindow-event-td8313.html) it
seems like I can't attach the configure-event to the GdkWindow.

So now I'm still left with the fact that the GdkWindow doesn't update it's
internal size, even if I use gdk_window_get_geometry to pull the info from
the X Server, the GdkWindow doesn't update it's internal cache.

So... how to get the GdkWindow to update it's internal size values?

Code and output below:

// Written by Ch. Tronche (http://tronche.lri.fr:8000/)
// Modified by C. Nygard to illustrate gdk_window resize issue
// Copyright by the author. This is unmaintained, no-warranty free
software.
// Please use freely. It is appreciated (but by no means mandatory) to
// acknowledge the author's contribution. Thank you.
// Started on Thu Jun 26 23:29:03 1997

// gcc -o test test.c `pkg-config --libs --cflags gtk+-2.0 gtk+-x11-2.0`


#include <X11/Xlib.h>
#include <assert.h>
#include <unistd.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#define NIL (0)

void frame_callback(GtkWindow *window,
      GdkEvent *event, gpointer data)
{
   printf("frame_callback: %d, %d\n",
          event->configure.x, event->configure.y);
}

gboolean window_expose_event (GtkWidget *widget, GdkEventExpose *event)
{
    printf("expose_event: (%d, %d) (%d,%d)\n",
           event->area.x, event->area.y,
           event->area.width, event->area.height);
    return FALSE;

}

main(int argc, char **argv)
{
      GdkWindow *gdk_win;
      gdk_init(&argc, &argv);

      // Open the display
      Display *dpy = XOpenDisplay(NIL);
      int blackColor = BlackPixel(dpy, DefaultScreen(dpy));
      int whiteColor = WhitePixel(dpy, DefaultScreen(dpy));
      Window w = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), 0, 0,
                                     200, 100, 0, blackColor, blackColor);
      gdk_win = gdk_window_foreign_new((guint32)w);
      printf("gdk_win = %p (should be null since window isn't mapped\n",
             gdk_win);

      // We want to get MapNotify events
      XSelectInput(dpy, w, StructureNotifyMask | ExposureMask);
      XMapWindow(dpy, w);

      GC gc = XCreateGC(dpy, w, 0, NIL);

      // Tell the GC we draw using the white color
      XSetForeground(dpy, gc, whiteColor);

      // Wait for the MapNotify event
      int done = 0;
      while(!done) {
            XEvent e;
            Window root;
            int x, y, xret, yret;
            unsigned int widthret,heightret,borderwidthret,depthret;

            // process gdk event loop
            while(gdk_events_pending()) {
                GdkEvent *ev = gdk_event_get();
                if(ev) {
                    printf("Processing event [%d]\n", ev->type);
                    switch(ev->type) {
                    case GDK_DELETE:
                        done = 1;
                        break;
                    default:
                        printf("GDK Event: [%d]", ev->type);
                        break;
                    }
                    gdk_event_free(ev);
                }else{
                    printf("Pending event null\n");
                }
            }

            XNextEvent(dpy, &e);
            printf("Handling event (%d)\n", e.type);
            switch(e.type) {
            case Expose:
                printf("  Expose (%d,%d) (%d,%d)\n",
                       e.xexpose.x, e.xexpose.y,
                       e.xexpose.width, e.xexpose.height);
                // Draw the line
                XDrawLine(dpy, w, gc, e.xexpose.x, e.xexpose.y,
                          e.xexpose.width, e.xexpose.height);
                XFlush(dpy);
                break;
            case MapNotify:
                gdk_win = gdk_window_foreign_new((guint32)w);
                g_signal_connect(G_OBJECT(gdk_win), "configure-event",
                                 G_CALLBACK(frame_callback), NULL);
                g_signal_connect(G_OBJECT(gdk_win), "expose-event",
                                 G_CALLBACK(window_expose_event), NULL);
                gdk_window_get_size(gdk_win, &x, &y);
                printf("  MapNotify [%p] dims: (%d, %d)\n", gdk_win, x, y);
                break;
            case ConfigureNotify:
                printf("  ConfigureNotify dims: (%d, %d) \n",
                       e.xconfigure.width, e.xconfigure.height);
                if(gdk_win) {
                    gdk_window_get_geometry(gdk_win, NULL, NULL,
                                            &widthret,&heightret, NULL);
                    gdk_window_get_size(gdk_win, &x, &y);
                    printf("  GdkWindow[%p] geometry:(%d, %d) dims:(%d,
%d)\n",
                       gdk_win, widthret, heightret, x, y);
                }
                break;
            default:
                printf("  Unhandled event: (%d)\n", e.type);

            }
            XGetGeometry(dpy, w,
                         &root, &xret, &yret,
                         &widthret, &heightret, &borderwidthret, &depthret);
      }
}

gdk_win = (nil) (should be null since window isn't mapped
Pending event null
Handling event (21)
  Unhandled event: (21)
Handling event (22)
  ConfigureNotify dims: (200, 100)
Handling event (19)

(test:35771): GLib-GObject-WARNING **: gsignal.c:2275: signal
`configure-event' is invalid for instance `0x193e350'

(test:35771): GLib-GObject-WARNING **: gsignal.c:2275: signal
`expose-event' is invalid for instance `0x193e350'
  MapNotify [0x193e350] dims: (200, 100)
Handling event (12)
  Expose (0,0) (200,100)
Handling event (22)
  ConfigureNotify dims: (204, 104)
  GdkWindow[0x193e350] geometry:(204, 104) dims:(200, 100)
Handling event (12)
  Expose (0,0) (204,104)
Handling event (22)
  ConfigureNotify dims: (212, 111)
  GdkWindow[0x193e350] geometry:(212, 111) dims:(200, 100)
Handling event (12)
  Expose (0,0) (212,111)
Handling event (22)
  ConfigureNotify dims: (217, 117)
  GdkWindow[0x193e350] geometry:(217, 117) dims:(200, 100)
Handling event (12)
  Expose (0,0) (217,117)
Handling event (22)
  ConfigureNotify dims: (224, 124)
  GdkWindow[0x193e350] geometry:(224, 124) dims:(200, 100)
Handling event (12)
  Expose (0,0) (224,124)
Handling event (22)
  ConfigureNotify dims: (227, 128)
  GdkWindow[0x193e350] geometry:(227, 128) dims:(200, 100)
Handling event (12)
  Expose (0,0) (227,128)
Handling event (22)
  ConfigureNotify dims: (228, 130)
  GdkWindow[0x193e350] geometry:(228, 130) dims:(200, 100)
Handling event (12)
  Expose (0,0) (228,130)




On Mon, Mar 24, 2014 at 5:51 AM, David Marceau <uticdmarceau2007 yahoo ca>wrote:

On 03/23/2014 11:07 PM, Carl Nygard wrote:

Thanks for the links.  However, most of the information is geared toward
GtkWindow instead of GdkWindow. I tried adding the configure-event signal
connection but I get a message from Gtk saying:
(test:25776): GLib-GObject-WARNING **: gsignal.c:2275: signal
`configure-event' is invalid for instance `0xe45350'

two possibilities:
-bad window handle
-configure-event not flagged on at window create

Suggestions:
-you create the window with x, so set the configure-event flag, right
after the win create at the x level for starters.
-validate the x window handle before hand, right after its creation.
-Get the x callback to at least log some resize/expose events.  Don't do
anything here apart from that for the time being.

-validate the gdk window handle before hand, right after its creation.
-then again set the callback with the configure event at the gdk window
level and log the resize event and expose events.

-you will need to delete the pixmap and recreate a new one with a
different size within the window resize and set it within the window
with the respective position and size.  From what I understand you still
don't correctly capture the window resize event yet so deal with that
first with log messages.  Once that's settled you can fix this.

Cheers,
David Marceau

All I really care about is getting GdkWindow to have current size
information when the XWindow resizes.

To answer your question about the code, it does work on FC4, but we're
porting the existing code to RH5 and some of the drawing started

breaking.

Specifically, we are drawing to a backing pixmap to create animation
frames, but when the frames are copied to the windows, the area that is
rendered is limited to whatever the window size was at the time we create
the GdkWindow via gdk_window_foreign_new().  This is because the

GdkWindow

does not have accurate information regarding it's true size.

--carl




On Sun, Mar 23, 2014 at 4:09 PM, David Marceau <

uticdmarceau2007 yahoo ca>wrote:

There is a difference between resize and expose events.  You're going to
have to take care of this difference within your code and possibly force
the expose event to trigger a resize event which is not necessarily done
by default.

The urls below show how to set the configure event in X, Motif and
GTK/GDK to the appropriate window resize callback.  The gtk tutorial
mentioned a drawing area pixmap to be removed and recreated with the
correct size.

http://www.lemoda.net/c/xlib-resize/
http://zetcode.com/tutorials/gtktutorial/gtkevents/
http://www.gtk.org/tutorial1.2/gtk_tut-23.html
http://www-f9.ijs.si/~matevz/docs/007-2392-003/sgi_html/ch03.html

With all the above being said, have you succeeded in running your app on
the newer os without changing the lines of code?  I tend to believe you
don't need to change your c code if you simply recompile and run on the
newer os.  Motif Libs exist on the newer os, just to get it running.

Cheers,
David Marceau





_______________________________________________
gtk-app-devel-list mailing list
gtk-app-devel-list gnome org
https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list

Follow-Ups:
- Re: Fwd: Help with GdkWindow size
  - From: David Marceau

References:
- Help with GdkWindow size
  - From: Carl Nygard
- Re: Help with GdkWindow size
  - From: David Marceau

[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]