Attachment 4066 Details for Bug 5311 – Test program

Test program

simple_popup.c (text/plain), 22.35 KB, created by Ron Yorston on 2005-12-11 04:27:04 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ron Yorston

Created: 2005-12-11 04:27:04 UTC

Size: 22.35 KB

patch

obsolete

>/* simple_popup.c -- demonstrate how to use a simple popup menu.
>** Create a main window that contains a DrawingArea widget, which
>** displays a popup menu when the user presses the third mouse button.
>*/
>
>#include <stdio.h>
>#include <X11/Xproto.h>
>#include <X11/Xlib.h>
>
>#include <Xm/RowColumn.h>
>#include <Xm/MainW.h>
>#include <Xm/DrawingA.h>
>
>Display *display ;
>Widget popup_menu ;
>
>
>/*
> * xev - event diagnostics
> *
> * $XConsortium: xev.c,v 1.14 91/05/04 23:15:11 keith Exp $
> *
> * Copyright 1988 Massachusetts Institute of Technology
> *
> * Permission to use, copy, modify, and distribute this software and its
> * documentation for any purpose and without fee is hereby granted, provided
> * that the above copyright notice appear in all copies and that both that
> * copyright notice and this permission notice appear in supporting
> * documentation, and that the name of M.I.T. not be used in advertising or
> * publicity pertaining to distribution of the software without specific,
> * written prior permission.  M.I.T. makes no representations about the
> * suitability of this software for any purpose.  It is provided "as is"
> * without express or implied warranty.
> *
> * Author:  Jim Fulton, MIT X Consortium
> */
>
>static char *Yes = "YES";
>static char *No = "NO";
>static char *Unknown = "unknown";
>
>
>static void prologue (const XEvent *eventp, char *event_name)
>{
>    const XAnyEvent *e = (const XAnyEvent *) eventp;
>
>    fprintf(stderr, "\n%s event, serial %ld, synthetic %s, window 0x%lx,\n",
>	    event_name, e->serial, e->send_event ? Yes : No, e->window);
>    return;
>}
>
>
>static void do_KeyPress (const XEvent *eventp)
>{
>    const XKeyEvent *e = (const XKeyEvent *) eventp;
>    KeySym ks;
>    char *ksname;
>    int nbytes;
>    char str[256+1];
>
>    nbytes = XLookupString ((XKeyEvent *)e, str, 256, &ks, NULL);
>    if (ks == NoSymbol)
>	ksname = "NoSymbol";
>    else if (!(ksname = XKeysymToString (ks)))
>	ksname = "(no name)";
>    fprintf(stderr, "    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
>	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
>    fprintf(stderr, "    state 0x%x, keycode %u (keysym 0x%lx, %s), same_screen %s,\n",
>	    e->state, e->keycode, ks, ksname, e->same_screen ? Yes : No);
>    if (nbytes < 0) nbytes = 0;
>    if (nbytes > 256) nbytes = 256;
>    str[nbytes] = '\0';
>    fprintf(stderr, "    XLookupString gives %d characters:  \"%s\"\n", nbytes, str);
>
>    return;
>}
>
>static void do_KeyRelease (const XEvent *eventp)
>{
>    do_KeyPress (eventp);		/* since it has the same info */
>    return;
>}
>
>static void do_ButtonPress (const XEvent *eventp)
>{
>    const XButtonEvent *e = (const XButtonEvent *) eventp;
>
>    fprintf(stderr, "    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
>	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
>    fprintf(stderr, "    state 0x%x, button %u, same_screen %s\n",
>	    e->state, e->button, e->same_screen ? Yes : No);
>
>    return;
>}
>
>static void do_ButtonRelease (const XEvent *eventp)
>{
>    do_ButtonPress (eventp);		/* since it has the same info */
>    return;
>}
>
>static void do_MotionNotify (const XEvent *eventp)
>{
>    const XMotionEvent *e = (const XMotionEvent *) eventp;
>
>    fprintf(stderr, "    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
>	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
>    fprintf(stderr, "    state 0x%x, is_hint %u, same_screen %s\n",
>	    e->state, e->is_hint, e->same_screen ? Yes : No);
>
>    return;
>}
>
>static void do_EnterNotify (const XEvent *eventp)
>{
>    const XCrossingEvent *e = (const XCrossingEvent *) eventp;
>    char *mode, *detail;
>    char dmode[10], ddetail[10];
>
>    switch (e->mode) {
>      case NotifyNormal:  mode = "NotifyNormal"; break;
>      case NotifyGrab:  mode = "NotifyGrab"; break;
>      case NotifyUngrab:  mode = "NotifyUngrab"; break;
>      case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
>      default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
>    }
>
>    switch (e->detail) {
>      case NotifyAncestor:  detail = "NotifyAncestor"; break;
>      case NotifyVirtual:  detail = "NotifyVirtual"; break;
>      case NotifyInferior:  detail = "NotifyInferior"; break;
>      case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
>      case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
>      case NotifyPointer:  detail = "NotifyPointer"; break;
>      case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
>      case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
>      default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
>    }
>
>    fprintf(stderr, "    root 0x%lx, subw 0x%lx, time %lu, (%d,%d), root:(%d,%d),\n",
>	    e->root, e->subwindow, e->time, e->x, e->y, e->x_root, e->y_root);
>    fprintf(stderr, "    mode %s, detail %s, same_screen %s,\n",
>	    mode, detail, e->same_screen ? Yes : No);
>    fprintf(stderr, "    focus %s, state %u\n", e->focus ? Yes : No, e->state);
>
>    return;
>}
>
>static void do_LeaveNotify (const XEvent *eventp)
>{
>    do_EnterNotify (eventp);		/* since it has same information */
>    return;
>}
>
>static void do_FocusIn (const XEvent *eventp)
>{
>    const XFocusChangeEvent *e = (const XFocusChangeEvent *) eventp;
>    char *mode, *detail;
>    char dmode[10], ddetail[10];
>
>    switch (e->mode) {
>      case NotifyNormal:  mode = "NotifyNormal"; break;
>      case NotifyGrab:  mode = "NotifyGrab"; break;
>      case NotifyUngrab:  mode = "NotifyUngrab"; break;
>      case NotifyWhileGrabbed:  mode = "NotifyWhileGrabbed"; break;
>      default:  mode = dmode, sprintf (dmode, "%u", e->mode); break;
>    }
>
>    switch (e->detail) {
>      case NotifyAncestor:  detail = "NotifyAncestor"; break;
>      case NotifyVirtual:  detail = "NotifyVirtual"; break;
>      case NotifyInferior:  detail = "NotifyInferior"; break;
>      case NotifyNonlinear:  detail = "NotifyNonlinear"; break;
>      case NotifyNonlinearVirtual:  detail = "NotifyNonlinearVirtual"; break;
>      case NotifyPointer:  detail = "NotifyPointer"; break;
>      case NotifyPointerRoot:  detail = "NotifyPointerRoot"; break;
>      case NotifyDetailNone:  detail = "NotifyDetailNone"; break;
>      default:  detail = ddetail; sprintf (ddetail, "%u", e->detail); break;
>    }
>
>    fprintf(stderr, "    mode %s, detail %s\n", mode, detail);
>    return;
>}
>
>static void do_FocusOut (const XEvent *eventp)
>{
>    do_FocusIn (eventp);		/* since it has same information */
>    return;
>}
>
>static void do_KeymapNotify (const XEvent *eventp)
>{
>    const XKeymapEvent *e = (const XKeymapEvent *) eventp;
>    int i;
>
>    fprintf(stderr, "    keys:  ");
>    for (i = 0; i < 32; i++) {
>	if (i == 16) fprintf(stderr, "\n           ");
>	fprintf(stderr, "%-3u ", (unsigned int) e->key_vector[i]);
>    }
>    fprintf(stderr, "\n");
>    return;
>}
>
>static void do_Expose (const XEvent *eventp)
>{
>    const XExposeEvent *e = (const XExposeEvent *) eventp;
>
>    fprintf(stderr, "    (%d,%d), width %d, height %d, count %d\n",
>	    e->x, e->y, e->width, e->height, e->count);
>    return;
>}
>
>static void do_GraphicsExpose (const XEvent *eventp)
>{
>    const XGraphicsExposeEvent *e = (const XGraphicsExposeEvent *) eventp;
>    char *m;
>    char mdummy[10];
>
>    switch (e->major_code) {
>      case X_CopyArea:  m = "CopyArea";  break;
>      case X_CopyPlane:  m = "CopyPlane";  break;
>      default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
>    }
>
>    fprintf(stderr, "    (%d,%d), width %d, height %d, count %d,\n",
>	    e->x, e->y, e->width, e->height, e->count);
>    fprintf(stderr, "    major %s, minor %d\n", m, e->minor_code);
>    return;
>}
>
>static void do_NoExpose (const XEvent *eventp)
>{
>    const XNoExposeEvent *e = (const XNoExposeEvent *) eventp;
>    char *m;
>    char mdummy[10];
>
>    switch (e->major_code) {
>      case X_CopyArea:  m = "CopyArea";  break;
>      case X_CopyPlane:  m = "CopyPlane";  break;
>      default:  m = mdummy; sprintf (mdummy, "%d", e->major_code); break;
>    }
>
>    fprintf(stderr, "    major %s, minor %d\n", m, e->minor_code);
>    return;
>}
>
>static void do_VisibilityNotify (const XEvent *eventp)
>{
>    const XVisibilityEvent *e = (const XVisibilityEvent *) eventp;
>    char *v;
>    char vdummy[10];
>
>    switch (e->state) {
>      case VisibilityUnobscured:  v = "VisibilityUnobscured"; break;
>      case VisibilityPartiallyObscured:  v = "VisibilityPartiallyObscured"; break;
>      case VisibilityFullyObscured:  v = "VisibilityFullyObscured"; break;
>      default:  v = vdummy; sprintf (vdummy, "%d", e->state); break;
>    }
>
>    fprintf(stderr, "    state %s\n", v);
>    return;
>}
>
>static void do_CreateNotify (const XEvent *eventp)
>{
>    const XCreateWindowEvent *e = (const XCreateWindowEvent *) eventp;
>
>    fprintf(stderr, "    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d\n",
>	    e->parent, e->window, e->x, e->y, e->width, e->height);
>    fprintf(stderr, "border_width %d, override %s\n",
>	    e->border_width, e->override_redirect ? Yes : No);
>    return;
>}
>
>static void do_DestroyNotify (const XEvent *eventp)
>{
>    const XDestroyWindowEvent *e = (const XDestroyWindowEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx\n", e->event, e->window);
>    return;
>}
>
>static void do_UnmapNotify (const XEvent *eventp)
>{
>    const XUnmapEvent *e = (const XUnmapEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, from_configure %s\n",
>	    e->event, e->window, e->from_configure ? Yes : No);
>    return;
>}
>
>static void do_MapNotify (const XEvent *eventp)
>{
>    const XMapEvent *e = (const XMapEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, override %s\n",
>	    e->event, e->window, e->override_redirect ? Yes : No);
>    return;
>}
>
>static void do_MapRequest (const XEvent *eventp)
>{
>    const XMapRequestEvent *e = (const XMapRequestEvent *) eventp;
>
>    fprintf(stderr, "    parent 0x%lx, window 0x%lx\n", e->parent, e->window);
>    return;
>}
>
>static void do_ReparentNotify (const XEvent *eventp)
>{
>    const XReparentEvent *e = (const XReparentEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, parent 0x%lx,\n",
>	    e->event, e->window, e->parent);
>    fprintf(stderr, "    (%d,%d), override %s\n", e->x, e->y, 
>	    e->override_redirect ? Yes : No);
>    return;
>}
>
>static void do_ConfigureNotify (const XEvent *eventp)
>{
>    const XConfigureEvent *e = (const XConfigureEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
>	    e->event, e->window, e->x, e->y, e->width, e->height);
>    fprintf(stderr, "    border_width %d, above 0x%lx, override %s\n",
>	    e->border_width, e->above, e->override_redirect ? Yes : No);
>    return;
>}
>
>static void do_ConfigureRequest (const XEvent *eventp)
>{
>    const XConfigureRequestEvent *e = (const XConfigureRequestEvent *) eventp;
>    char *detail;
>    char ddummy[10];
>
>    switch (e->detail) {
>      case Above:  detail = "Above";  break;
>      case Below:  detail = "Below";  break;
>      case TopIf:  detail = "TopIf";  break;
>      case BottomIf:  detail = "BottomIf"; break;
>      case Opposite:  detail = "Opposite"; break;
>      default:  detail = ddummy; sprintf (ddummy, "%d", e->detail); break;
>    }
>
>    fprintf(stderr, "    parent 0x%lx, window 0x%lx, (%d,%d), width %d, height %d,\n",
>	    e->parent, e->window, e->x, e->y, e->width, e->height);
>    fprintf(stderr, "    border_width %d, above 0x%lx, detail %s, value 0x%lx\n",
>	    e->border_width, e->above, detail, e->value_mask);
>    return;
>}
>
>static void do_GravityNotify (const XEvent *eventp)
>{
>    const XGravityEvent *e = (const XGravityEvent *) eventp;
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, (%d,%d)\n",
>	    e->event, e->window, e->x, e->y);
>    return;
>}
>
>static void do_ResizeRequest (const XEvent *eventp)
>{
>    const XResizeRequestEvent *e = (const XResizeRequestEvent *) eventp;
>
>    fprintf(stderr, "    width %d, height %d\n", e->width, e->height);
>    return;
>}
>
>static void do_CirculateNotify (const XEvent *eventp)
>{
>    const XCirculateEvent *e = (const XCirculateEvent *) eventp;
>    char *p;
>    char pdummy[10];
>
>    switch (e->place) {
>      case PlaceOnTop:  p = "PlaceOnTop"; break;
>      case PlaceOnBottom:  p = "PlaceOnBottom"; break;
>      default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
>    }
>
>    fprintf(stderr, "    event 0x%lx, window 0x%lx, place %s\n",
>	    e->event, e->window, p);
>    return;
>}
>
>static void do_CirculateRequest (const XEvent *eventp)
>{
>    const XCirculateRequestEvent *e = (const XCirculateRequestEvent *) eventp;
>    char *p;
>    char pdummy[10];
>
>    switch (e->place) {
>      case PlaceOnTop:  p = "PlaceOnTop"; break;
>      case PlaceOnBottom:  p = "PlaceOnBottom"; break;
>      default:  p = pdummy; sprintf (pdummy, "%d", e->place); break;
>    }
>
>    fprintf(stderr, "    parent 0x%lx, window 0x%lx, place %s\n",
>	    e->parent, e->window, p);
>    return;
>}
>
>static void do_PropertyNotify (const XEvent *eventp)
>{
>    const XPropertyEvent *e = (const XPropertyEvent *) eventp;
>    char *aname = XGetAtomName (display, e->atom);
>    char *s;
>    char sdummy[10];
>
>    switch (e->state) {
>      case PropertyNewValue:  s = "PropertyNewValue"; break;
>      case PropertyDelete:  s = "PropertyDelete"; break;
>      default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
>    }
>
>    fprintf(stderr, "    atom 0x%lx (%s), time %lu, state %s\n",
>	   e->atom, aname ? aname : Unknown, e->time,  s);
>
>    if (aname) XFree (aname);
>    return;
>}
>
>static void do_SelectionClear (const XEvent *eventp)
>{
>    const XSelectionClearEvent *e = (const XSelectionClearEvent *) eventp;
>    char *sname = XGetAtomName (display, e->selection);
>
>    fprintf(stderr, "    selection 0x%lx (%s), time %lu\n",
>	    e->selection, sname ? sname : Unknown, e->time);
>
>    if (sname) XFree (sname);
>    return;
>}
>
>static void do_SelectionRequest (const XEvent *eventp)
>{
>    const XSelectionRequestEvent *e = (const XSelectionRequestEvent *) eventp;
>    char *sname = XGetAtomName (display, e->selection);
>    char *tname = XGetAtomName (display, e->target);
>    char *pname = XGetAtomName (display, e->property);
>
>    fprintf(stderr, "    owner 0x%lx, requestor 0x%lx, selection 0x%lx (%s),\n",
>	    e->owner, e->requestor, e->selection, sname ? sname : Unknown);
>    fprintf(stderr, "    target 0x%lx (%s), property 0x%lx (%s), time %lu\n",
>	    e->target, tname ? tname : Unknown, e->property,
>	    pname ? pname : Unknown, e->time);
>
>    if (sname) XFree (sname);
>    if (tname) XFree (tname);
>    if (pname) XFree (pname);
>
>    return;
>}
>
>static void do_SelectionNotify (const XEvent *eventp)
>{
>    const XSelectionEvent *e = (const XSelectionEvent *) eventp;
>    char *sname = XGetAtomName (display, e->selection);
>    char *tname = XGetAtomName (display, e->target);
>    char *pname = XGetAtomName (display, e->property);
>
>    fprintf(stderr, "    selection 0x%lx (%s), target 0x%lx (%s),\n",
>	    e->selection, sname ? sname : Unknown, e->target,
>	    tname ? tname : Unknown);
>    fprintf(stderr, "    property 0x%lx (%s), time %lu\n",
>	    e->property, pname ? pname : Unknown, e->time);
>
>    if (sname) XFree (sname);
>    if (tname) XFree (tname);
>    if (pname) XFree (pname);
>
>    return;
>}
>
>static void do_ColormapNotify (const XEvent *eventp)
>{
>    const XColormapEvent *e = (const XColormapEvent *) eventp;
>    char *s;
>    char sdummy[10];
>
>    switch (e->state) {
>      case ColormapInstalled:  s = "ColormapInstalled"; break;
>      case ColormapUninstalled:  s = "ColormapUninstalled"; break;
>      default:  s = sdummy; sprintf (sdummy, "%d", e->state); break;
>    }
>
>    fprintf(stderr, "    colormap 0x%lx, new %s, state %s\n",
>	    e->colormap, e->new ? Yes : No, s);
>    return;
>}
>
>static void do_ClientMessage (const XEvent *eventp)
>{
>    const XClientMessageEvent *e = (const XClientMessageEvent *) eventp;
>    char *mname = XGetAtomName (display, e->message_type);
>
>    fprintf(stderr, "    message_type 0x%lx (%s), format %d\n",
>	    e->message_type, mname ? mname : Unknown, e->format);
>
>    if (mname) XFree (mname);
>    return;
>}
>
>static void do_MappingNotify (const XEvent *eventp)
>{
>    const XMappingEvent *e = (const XMappingEvent *) eventp;
>    char *r;
>    char rdummy[10];
>
>    switch (e->request) {
>      case MappingModifier:  r = "MappingModifier"; break;
>      case MappingKeyboard:  r = "MappingKeyboard"; break;
>      case MappingPointer:  r = "MappingPointer"; break;
>      default:  r = rdummy; sprintf (rdummy, "%d", e->request); break;
>    }
>
>    fprintf(stderr, "    request %s, first_keycode %d, count %d\n",
>	    r, e->first_keycode, e->count);
>    XRefreshKeyboardMapping((XMappingEvent *)e);
>    return;
>}
>
>void pxPrintEvent(const XEvent *event)
>{
>
>	switch (event->type) {
>	  case KeyPress:
>	    prologue (event, "KeyPress");
>	    do_KeyPress (event);
>	    break;
>	  case KeyRelease:
>	    prologue (event, "KeyRelease");
>	    do_KeyRelease (event);
>	    break;
>	  case ButtonPress:
>	    prologue (event, "ButtonPress");
>	    do_ButtonPress (event);
>	    break;
>	  case ButtonRelease:
>	    prologue (event, "ButtonRelease");
>	    do_ButtonRelease (event);
>	    break;
>	  case MotionNotify:
>	    prologue (event, "MotionNotify");
>	    do_MotionNotify (event);
>	    break;
>	  case EnterNotify:
>	    prologue (event, "EnterNotify");
>	    do_EnterNotify (event);
>	    break;
>	  case LeaveNotify:
>	    prologue (event, "LeaveNotify");
>	    do_LeaveNotify (event);
>	    break;
>	  case FocusIn:
>	    prologue (event, "FocusIn");
>	    do_FocusIn (event);
>	    break;
>	  case FocusOut:
>	    prologue (event, "FocusOut");
>	    do_FocusOut (event);
>	    break;
>	  case KeymapNotify:
>	    prologue (event, "KeymapNotify");
>	    do_KeymapNotify (event);
>	    break;
>	  case Expose:
>	    prologue (event, "Expose");
>	    do_Expose (event);
>	    break;
>	  case GraphicsExpose:
>	    prologue (event, "GraphicsExpose");
>	    do_GraphicsExpose (event);
>	    break;
>	  case NoExpose:
>	    prologue (event, "NoExpose");
>	    do_NoExpose (event);
>	    break;
>	  case VisibilityNotify:
>	    prologue (event, "VisibilityNotify");
>	    do_VisibilityNotify (event);
>	    break;
>	  case CreateNotify:
>	    prologue (event, "CreateNotify");
>	    do_CreateNotify (event);
>	    break;
>	  case DestroyNotify:
>	    prologue (event, "DestroyNotify");
>	    do_DestroyNotify (event);
>	    break;
>	  case UnmapNotify:
>	    prologue (event, "UnmapNotify");
>	    do_UnmapNotify (event);
>	    break;
>	  case MapNotify:
>	    prologue (event, "MapNotify");
>	    do_MapNotify (event);
>	    break;
>	  case MapRequest:
>	    prologue (event, "MapRequest");
>	    do_MapRequest (event);
>	    break;
>	  case ReparentNotify:
>	    prologue (event, "ReparentNotify");
>	    do_ReparentNotify (event);
>	    break;
>	  case ConfigureNotify:
>	    prologue (event, "ConfigureNotify");
>	    do_ConfigureNotify (event);
>	    break;
>	  case ConfigureRequest:
>	    prologue (event, "ConfigureRequest");
>	    do_ConfigureRequest (event);
>	    break;
>	  case GravityNotify:
>	    prologue (event, "GravityNotify");
>	    do_GravityNotify (event);
>	    break;
>	  case ResizeRequest:
>	    prologue (event, "ResizeRequest");
>	    do_ResizeRequest (event);
>	    break;
>	  case CirculateNotify:
>	    prologue (event, "CirculateNotify");
>	    do_CirculateNotify (event);
>	    break;
>	  case CirculateRequest:
>	    prologue (event, "CirculateRequest");
>	    do_CirculateRequest (event);
>	    break;
>	  case PropertyNotify:
>	    prologue (event, "PropertyNotify");
>	    do_PropertyNotify (event);
>	    break;
>	  case SelectionClear:
>	    prologue (event, "SelectionClear");
>	    do_SelectionClear (event);
>	    break;
>	  case SelectionRequest:
>	    prologue (event, "SelectionRequest");
>	    do_SelectionRequest (event);
>	    break;
>	  case SelectionNotify:
>	    prologue (event, "SelectionNotify");
>	    do_SelectionNotify (event);
>	    break;
>	  case ColormapNotify:
>	    prologue (event, "ColormapNotify");
>	    do_ColormapNotify (event);
>	    break;
>	  case ClientMessage:
>	    prologue (event, "ClientMessage");
>	    do_ClientMessage (event);
>	    break;
>	  case MappingNotify:
>	    prologue (event, "MappingNotify");
>	    do_MappingNotify (event);
>	    break;
>	  default:
>	    fprintf(stderr, "Unknown event type %d\n", event->type);
>	    break;
>    }
>
>}
>void move_callback(Widget parent, XtPointer w, XEvent *ev, Boolean *flag)
>{
>	fprintf(stderr, "mouse move\n") ;
>}
>
>void menu_callback(Widget parent, XtPointer w, XEvent *ev, Boolean *flag)
>{
>	XButtonEvent *event = (XButtonEvent *)ev ;
>
>	fprintf(stderr, "button press\n") ;
>	XmMenuPosition(popup_menu, event) ;
>	XtManageChild(popup_menu) ;
>
>}
>
>main (int argc, char *argv[])
>{
>	XmString     line, square, circle, exit, exit_acc;
>	Widget       toplevel, main_w, drawing_a;
>	void         popup_cb(Widget, XtPointer, XtPointer);
>	XtAppContext app;
>	Arg          args[4];
>	int          n;
>	
>	XtSetLanguageProc (NULL, NULL, NULL);
>	toplevel = XtVaOpenApplication (&app, "Demos", NULL, 0, &argc, argv, NULL, 
>					sessionShellWidgetClass, NULL);
>	display = XtDisplay(toplevel);
>	
>	/* Create a MainWindow widget that contains a DrawingArea in 
>	** its work window. 
>	*/
>	n = 0;
>	XtSetArg (args[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
>	main_w = XmCreateMainWindow (toplevel, "main_w", args, n);
>	
>	/* Create a DrawingArea -- no actual drawing will be done. */
>	n = 0;
>	XtSetArg (args[n], XmNwidth, 500); n++;
>	XtSetArg (args[n], XmNheight, 500); n++;
>	drawing_a = XmCreateDrawingArea (main_w, "drawing_a", args, n);
>	XtManageChild (drawing_a);
>	
>	line = XmStringCreateLocalized ("Line");
>	square = XmStringCreateLocalized ("Square");
>	circle = XmStringCreateLocalized ("Circle");
>	exit = XmStringCreateLocalized ("Exit");
>	exit_acc = XmStringCreateLocalized ("Ctrl+C");
>	popup_menu = XmVaCreateSimplePopupMenu (drawing_a, "popup", popup_cb,
>						XmVaPUSHBUTTON, line, 'L', NULL, NULL,
>						XmVaPUSHBUTTON, square, 'S', NULL, NULL,
>						XmVaPUSHBUTTON, circle, 'C', NULL, NULL,
>						XmVaSEPARATOR,
>						XmVaPUSHBUTTON, exit, 'x', "Ctrl<Key>c", exit_acc,
>						NULL);
>	XmStringFree (line);
>	XmStringFree (square);
>	XmStringFree (circle);
>	XmStringFree (exit);
>	XmStringFree (exit_acc);
>
>	XtAddEventHandler(drawing_a, ButtonPressMask, False, menu_callback, NULL) ;
>	XtAddEventHandler(drawing_a, ButtonMotionMask, False, move_callback, NULL) ;
>	
>	XtManageChild (main_w);
>	XtRealizeWidget (toplevel);
>	/* XtAppMainLoop (app); */
>	do {
>		XEvent event ;
>
>		XtAppNextEvent(app, &event) ;
>		pxPrintEvent(&event) ;
>		XtDispatchEvent(&event) ;
>	} while (1) ;
>}
>	
>/* popup_cb() -- invoked when the user selects an item in the popup menu */
>void popup_cb (Widget menu_item, XtPointer client_data, XtPointer call_data)
>{
>	int item_no = (int) client_data;
>	
>	if (item_no == 3) /* Exit was selected -- exit */
>		exit (0);
>	
>	/* Otherwise, just print the selection */
>	puts (XtName (menu_item));
>}

Actions: View

Attachments on bug 5311: 4066

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.