GDK_POINTER_MOTION_HINT_MASK has no effect

["Richard Boaz" <riboaz xs4all nl>]

Stewart,

Yes, all philosophies must ultimately collapse to an actual workable frame
at the end of the day.  Sorry for any confusion caused.  In an attempt to
clear this up (and hopefully not make more), you will find below a
complete workable program that does nothing, really, except to
demonstrate:

  1) programmatically generated RGB buffers converted to pixmap for display
  2) bg pixmaps used as the main background layer
  3) temporary bg pixmaps used to display layers of other drawing info
  4) copying parts of bg pixmaps to another bg pixmap
  5) swapping multiple background pixmaps for display (via the expose
handler) according to a deterministic display state
  6) a pixel to user coordinate and conversion system (very handy)
  7) dragging with mouse-down and mouse-up, with effect
  8) mouse leaving and entering drawing area, with effect
  9) etc...

Copy to drawingSample.c and it will compile "out of the box" using:

sh>  gcc `pkg-config --cflags --libs gtk+2.0` drawSample.c -o drawSample

User functions:

  1) startup - display program-generated RGB buffer
  2) drag/mouse-UP - draw dashed lines as cross hairs at mouse point
  3) drag/mouse-DOWN - draw dashed lines - display user-defined bounding box
  4) mouse-UP/post-Drag - draw solid lines - display bounding box
  5) drawing area leave/enter - display an interesting effect, before and
after bounding box definitions
  6) mouse-CLICK/no-Drag - start over
  7) resize window - start over

As Paul and John have made clear, one issue in deciding how to effectuate
all this rests very much on the size of your background pixmaps (among
other important points).  My problem entails many data points that all map
to a single displayable pixmap, i.e., my bg pixmaps are not very big, so
they're cheap.  Employing this method for large pixmaps on display could
be costly memory-wise.

As Paul also pointed out, pixmaps are server-side objects.  When they are
not large, and the distance between the client and the server is
relatively close, this is not such an issue for me.  However, one way that
the attached program could be brought more "up-to-date" (and work
everywhere) would be to convert all drawing commands to cairo routines,
thus using a drawing canvas that is client-side, only converting to a
pixmap at the last possible moment (or wherever it would make the most
sense).

As I said, hope this helps.  If there is anything confusing, please ask. 
Also, I program from the bottom of the file to the top, start at the
bottom and work your way backwards when reading it the first time.

cheers,

richard

=== BEGIN drawingSample.c ===

#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <gtk/gtk.h>

// defines and structures we need
enum {
 MOUSEIN,
 MOUSEOUT,
 TTLPMAPS
};

#define MAX_PIXEL_VALUE 255

typedef struct {
 gint     startX, startY, endX, endY;
 gboolean mouseDown;
 gboolean mouseIn;
} MouseState;

typedef struct {
    double user_xmin, user_xmax;
    float  user_ymin, user_ymax;
    float  user_xdif, user_ydif;
    int    pix_xmin, pix_xmax;
    int    pix_ymin, pix_ymax;
    int    pix_ydif, pix_xdif;
} graph;

typedef struct {
 guchar R, G, B;
} myColorStruct;

// some globals
GdkPixmap    *DAdisplay, *pmap[TTLPMAPS];
GdkGC        *gcSolid, *gcDash;
int CG[6][3] =   // color spectrum
 {{255, 0, 255},  // R = 255->0
  {0, 0, 255},  // G = 0->255
  {0, 255, 255},  // B = 255->0
  {0, 255, 0},  // R = 0->255
  {255, 255, 0},  // G = 255->0
  {240, 240, 240}}; // 0%

myColorStruct * colorP(float prob)
{	// probability to color conversion routine
//  return the color to be associated with the given input of probability:
//  each probability falls into a colour range as follows:
//  0 - 1%:   240,240,240 - 255,000,255 (grey (background) to purple)
//  1 - 6%:   255,000,255 - 000,000,255 (purple to blue)
//  6 - 12%:  000,000,255 - 000,255,255 (blue to cyan)
//  12 - 18%: 000,255,255 - 000,255,000 (cyan to green)
//  18 - 24%: 000,255,000 - 255,255,000 (green to yellow)
//  24 - 30%: 255,255,000 - 255,000,000 (yellow to red)
//
 int      probI = prob, cg;
 static myColorStruct probColor;

 if (prob < 1.f)
 {
  probColor.R = 240 - prob*27.;  // R = 213 - 240, 1% - 0%
  probColor.G = 240 - prob*240.;  // G =   0 - 240, 1% - 0%
  probColor.B = 240 + prob*15.;  // B = 255 - 240, 1% - 0%
  return &probColor;
 }

 cg = probI/6;
 if (cg>4) // normalize all probs > 30...
 {
  cg = 4;
  prob = 30.f;
 }

 probColor.R = CG[cg][0]; probColor.G = CG[cg][1]; probColor.B = CG[cg][2];

 switch(cg)
 {
  case 0:
   probColor.R = 255 - (prob*(MAX_PIXEL_VALUE/6.)); // R=255->0
  break;             // 1% - 6%
  case 1:
   probColor.G = (prob-6.)*(MAX_PIXEL_VALUE/6.);  // G=0->255
  break;             // 6% - 12%
  case 2:
   probColor.B = 255 - ((prob-12.)*(MAX_PIXEL_VALUE/6.)); // B=255->0
  break;             // 12% - 18%
  case 3:
   probColor.R = (prob-18.)*(MAX_PIXEL_VALUE/6.);  // R=0->255
  break;             // 18% - 24%
  case 4:
   probColor.G = 255 - ((prob-24.)*(MAX_PIXEL_VALUE/6.)); // G=255->0
  break;             // 24% - 30%
 }
 return &probColor;
}

// our graphing/user coordinate system and conversions
int user_to_pix_x(graph *gr, double x)
{
 double rint();
 return ((rint) (((x - gr->user_xmin) / gr->user_xdif) *
        ((double) gr->pix_xdif) +
        ((double) gr->pix_xmin)));
}
int user_to_pix_y(graph *gr, double y)
{
 return ((int) ((double) gr->pix_ydif) -
     ((double) (y - gr->user_ymin) / gr->user_ydif) *
     ((double) gr->pix_ydif) +
     ((double) gr->pix_ymin));
}
double pix_to_user_x(graph *gr, int pix_x)
{
 return ((double) (((pix_x - gr->pix_xmin) / ((double) gr->pix_xdif))*
         (double) (gr->user_xdif) + gr->user_xmin));
}
double pix_to_user_y(graph *gr, int pix_y)
{
 return((double) (1. -
    (((double) pix_y - gr->pix_ymin) / ((double) gr->pix_ydif))) *
    gr->user_ydif + gr->user_ymin);
}
void window(graph *gr, double x1, double x2, double y1, double y2)
{
 gr->user_xmin = x1;
 gr->user_xmax = x2;
 gr->user_ymin = y1;
 gr->user_ymax = y2;
 gr->user_xdif = gr->user_xmax - gr->user_xmin;
 gr->user_ydif = gr->user_ymax - gr->user_ymin;
}
void viewport(graph *gr, int x1, int x2, int y1, int y2)
{
 gr->pix_xmin = x1;
 gr->pix_xmax = x2;
 gr->pix_xdif = x2 - x1;
 gr->pix_ymin = y1;
 gr->pix_ymax = y2;
 gr->pix_ydif = y2 - y1;
}

// make our RBG Buffer and convert to pixmap for display
void makeRGBpmap(GtkWidget *da)
{
 struct timeval tv;
 struct timezone tz;
 int startColor;
 gint w = da->allocation.width;
 gint h = da->allocation.height;

 int  i, j, y, y1, lumin;
 graph grL;
 myColorStruct *colorProb;
 guchar *posC, *rgbbufC;
 guchar *posG, *rgbbufG;
 static GdkGC *gc=NULL;

 gettimeofday(&tv, &tz);
 srand(tv.tv_usec); // randomly select our starting color
 startColor = (int) ((float) 30 * rand()/(RAND_MAX+1.0));

 if (!gc)
  gc = gdk_gc_new(da->window);

 if (pmap[MOUSEIN])
 {
  g_object_unref(pmap[MOUSEIN]);
  g_object_unref(pmap[MOUSEOUT]);
 }
 pmap[MOUSEIN] = gdk_pixmap_new(da->window, w, h, -1);
 pmap[MOUSEOUT] = gdk_pixmap_new(da->window, w, h, -1);
 rgbbufC = malloc(w * h * 3);
 rgbbufG = malloc(w * h * 3);

 viewport(&grL, 0, w, 0, h);
 window(&grL, (double) 0, (double) w, (double) 0., (double) 30.0);

 posC = rgbbufC;
 posG = rgbbufG;
 for(i=0;i<h;i++)
 {
  colorProb = colorP((float) pix_to_user_y(&grL, i));
  lumin = (int) (colorProb->R*.299+colorProb->G*.587+colorProb->B*.114);
  for(j=0;j<w;j++)
  {
   *posC++ = colorProb->R;
   *posC++ = colorProb->G;
   *posC++ = colorProb->B;
   *posG++ = (guchar) lumin;
   *posG++ = (guchar) lumin;
   *posG++ = (guchar) lumin;
  }
 }
 gdk_draw_rgb_image (pmap[MOUSEIN], gc, 0, 0, w, h,
                     GDK_RGB_DITHER_NONE, rgbbufC, w*3);
 gdk_draw_rgb_image (pmap[MOUSEOUT], gc, 0, 0, w, h,
                     GDK_RGB_DITHER_NONE, rgbbufG, w*3);
 free(rgbbufC);
 free(rgbbufG);

 DAdisplay = pmap[MOUSEIN];
 return;
}

// draw our user-defined bounding box
void drawBox(GdkPixmap *pixM, GdkGC *gc, MouseState *mouse)
{
 GdkPoint rect[5];
 rect[0].x = mouse->startX;
 rect[0].y = mouse->startY;
 rect[1].x = mouse->endX;
 rect[1].y = mouse->startY;
 rect[2].x = mouse->endX;
 rect[2].y = mouse->endY;
 rect[3].x = mouse->startX;
 rect[3].y = mouse->endY;
 rect[4].x = mouse->startX;
 rect[4].y = mouse->startY;
 gdk_draw_lines(pixM, gc, rect, 5);
}

gboolean doMouse(GtkWidget *da, GdkEventButton *event, MouseState *mouse)
{ // got a cat?
 gint w = da->allocation.width;
 gint h = da->allocation.height;

 switch(event->type)
 {
   case GDK_BUTTON_PRESS:
      mouse->startX = event->x;
      mouse->startY = event->y;
      mouse->mouseDown = TRUE;
    break;
    case GDK_BUTTON_RELEASE:
      mouse->endX = event->x;
      mouse->endY = event->y;
      if (mouse->startX == mouse->endX &&
      mouse->startY == mouse->endY)
      { // start over
        makeRGBpmap(da);
      }
      else
      { // copy to greymap and draw the solid outline
        if (mouse->startX > mouse->endX)
        {
          gint tmp = mouse->startX;
          mouse->startX = mouse->endX;
          mouse->endX = tmp;
        }
        if (mouse->startY > mouse->endY)
        {
          gint tmp = mouse->startY;
          mouse->startY = mouse->endY;
          mouse->endY = tmp;
        }
        gdk_draw_drawable(pmap[MOUSEOUT],
            da->style->fg_gc[GTK_STATE_NORMAL],
            pmap[MOUSEIN],
            mouse->startX, mouse->startY,  // source (x,y)
            mouse->startX, mouse->startY, // dest (x,y)
            mouse->endX - mouse->startX, // width
            mouse->endY - mouse->startY); // height
        drawBox(pmap[MOUSEIN], gcSolid, mouse);
      }
      mouse->mouseDown = FALSE;
   break;
 }

 gtk_widget_queue_draw_area(da, 0, 0, w, h);
 return TRUE;
}

gboolean doDrag (GtkWidget *da, GdkEventMotion *event, MouseState *mouse)
{ // as often as possible
 GdkModifierType     state;
 gint        x, y;
 gint  w = da->allocation.width;
 gint  h = da->allocation.height;
 GdkPixmap   *pixmap;

 pixmap = gdk_pixmap_new(da->window, w, h, -1);
 gdk_draw_drawable(pixmap, da->style->fg_gc[GTK_STATE_NORMAL],
                   pmap[MOUSEIN], 0, 0, 0, 0, -1, -1);

 switch(mouse->mouseDown)
 {
   case FALSE:  // draw dashed lines as cross-hairs
     gdk_draw_line(pixmap, gcDash, event->x, 0, event->x, h);
     gdk_draw_line(pixmap, gcDash, 0, event->y, w, event->y);
   break;
   case TRUE:  // draw dashed lines as box
     mouse->endX = event->x;
     mouse->endY = event->y;
     drawBox(pixmap, gcDash, mouse);
   break;
 }

 gdk_draw_drawable(da->window, da->style->fg_gc[GTK_STATE_NORMAL],
      pixmap, 0, 0, 0, 0, -1, -1);
 g_object_unref(pixmap);
 gdk_window_get_pointer(event->window, &x, &y, &state);
 return TRUE;
}

gboolean doFocus(GtkWidget *da, GdkEvent *event, MouseState *mouse)
{
 gint w = da->allocation.width;
 gint h = da->allocation.height;
 switch(event->type)
 {
  case GDK_ENTER_NOTIFY:
   mouse->mouseIn = TRUE;
   DAdisplay = pmap[MOUSEIN];
  break;
  case GDK_LEAVE_NOTIFY:
   mouse->mouseIn = FALSE;
   DAdisplay = pmap[MOUSEOUT];
  break;
 }
 gtk_widget_queue_draw_area(da, 0, 0, w, h);
 return TRUE;
}

gboolean exposeME(GtkWidget *da, GdkEventExpose *event, gpointer nil)
{
 gdk_draw_drawable(da->window,
     da->style->fg_gc[GTK_WIDGET_STATE (da)],
     DAdisplay,
     event->area.x, event->area.y,
     event->area.x, event->area.y,
     event->area.width, event->area.height);
}

gboolean configME(GtkWidget *da, GdkEventConfigure *event, gpointer nil)
{
 if (!gcSolid)
 { // first-time called
  gcSolid = gdk_gc_new(da->window);
  gcDash = gdk_gc_new(da->window);
  gdk_gc_set_function(gcSolid, GDK_INVERT);
  gdk_gc_set_function(gcDash, GDK_INVERT);
  gdk_gc_set_line_attributes(gcDash, 1, GDK_LINE_ON_OFF_DASH, 0, 0);
 }
 makeRGBpmap(da);
}

int main(int argc, char **argv)
{
 GtkWidget    *topWindow, *frame, *da;
 MouseState  mouseState;

 memset(&mouseState, 0, sizeof(MouseState));
 gtk_init(&argc, &argv);

 topWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_container_set_border_width(GTK_CONTAINER (topWindow), 2);
 g_signal_connect (topWindow, "destroy", G_CALLBACK (gtk_main_quit), NULL);

 frame = gtk_frame_new(NULL);
 gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_IN);
 da = gtk_drawing_area_new();
 gtk_container_add(GTK_CONTAINER (frame), da);
 gtk_container_add (GTK_CONTAINER (topWindow), frame);

 g_signal_connect (da, "configure_event", G_CALLBACK(configME), NULL);
 g_signal_connect (da, "expose_event", G_CALLBACK(exposeME), NULL);
 g_signal_connect (da, "button_press_event", G_CALLBACK (doMouse),
      (gpointer) &mouseState);
 g_signal_connect (da, "button_release_event", G_CALLBACK (doMouse),
      (gpointer) &mouseState);
 g_signal_connect (da, "motion_notify_event", G_CALLBACK (doDrag),
      (gpointer) &mouseState);
 g_signal_connect (da, "enter_notify_event", G_CALLBACK (doFocus),
      (gpointer) &mouseState);
 g_signal_connect (da, "leave_notify_event", G_CALLBACK (doFocus),
      (gpointer) &mouseState);
 gtk_widget_set_events (da, gtk_widget_get_events (da)
      | GDK_LEAVE_NOTIFY_MASK
      | GDK_ENTER_NOTIFY_MASK
      | GDK_POINTER_MOTION_MASK
      | GDK_POINTER_MOTION_HINT_MASK
      | GDK_BUTTON_PRESS_MASK
      | GDK_BUTTON_RELEASE_MASK);

 gtk_widget_show_all(topWindow);
 gtk_window_resize (GTK_WINDOW (topWindow), 300, 350);
 gtk_main();
}

=== END drawingSample.c ===