home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / apps / cmapDoctor / cmapdoctor / DrcmapControlDerived.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  15.6 KB  |  639 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /////////////////////////////////////////////////////////////
  18. //
  19. // Source file for DrcmapControlDerived
  20. //
  21. //    This file generated by BuilderXcessory. 
  22. /////////////////////////////////////////////////////////////
  23.  
  24. #include "DrcmapControlDerived.h"
  25. #include <iostream.h>
  26. #include <Xm/List.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <unistd.h>
  30. #include "XLayerUtil.h"
  31. #include <Vk/VkApp.h>
  32. #include <Vk/VkIcon.h>
  33. #include <Vk/xpm.h>
  34. #include "drcmap.xpm"
  35. #include "bbl.xpm"
  36. #include "bbinvl.xpm"
  37. #include "bbr.xpm"
  38. #include "bbinvr.xpm"
  39. #include <X11/cursorfont.h>
  40. #include <X11/Xmu/WinUtil.h>
  41.  
  42. char *installNames[] = {
  43.     "No",
  44.     "Yes",
  45. };
  46.  
  47. char *vtypeNames[] = {
  48.     "Underlay",
  49.     "Normal",
  50.     "Overlay",
  51.     "Popup",
  52. };
  53.  
  54.  
  55. char *vclassNames[] = {
  56.     "StaticGray",
  57.     "GrayScale",
  58.     "StaticColor",
  59.     "PseudoColor",
  60.     "TrueColor",
  61.     "DirectColor",
  62. };
  63.  
  64. enum Vtype {underlay, normal, overlay, popup};
  65.  
  66. struct {
  67.     Colormap cmap;
  68.     int vclass;
  69.     enum Vtype vtype;
  70.     int depth;
  71.     int installed;
  72.     int numRefs;
  73.     int layer;
  74.     Visual *visual;
  75.     GC gc;
  76.     Window win;
  77.     int winIO;
  78.     char title[80];
  79. } allcmaps[1000];
  80.  
  81. int cmapCnt = 0;
  82. int cmapsInstalled = 0;
  83. int winCnt = 0;
  84. int winChoice;
  85. Widget list;
  86. Widget rgbDisp;
  87. Window drawArea;
  88. Window basewind;
  89. DrawwinDerived *drawwin;
  90. Pixmap drcmapPixmap;
  91. Pixmap drcmapShapemask;
  92. Pixmap bblPixmap;
  93. Pixmap bblShapemask;
  94. Pixmap bbinvlPixmap;
  95. Pixmap bbinvlShapemask;
  96. Pixmap bbrPixmap;
  97. Pixmap bbrShapemask;
  98. Pixmap bbinvrPixmap;
  99. Pixmap bbinvrShapemask;
  100.  
  101. extern "C" {
  102. Boolean buildList(XtPointer);
  103. void scanXTree(Display *, Window, Window, int);
  104. void walkTree(Display *, Window, Window, int, int);
  105. enum Vtype identifyVisual(Display *, Visual *);
  106. void buildWin(Display *, Window, int);
  107. void setWMColormaps(Display *, Window);
  108. void displayColormap(Display *);
  109. void updateWindowsAndList(Display *);
  110. Window Select_Window(Display *);
  111. void getWindowCmapInfo(Display *, Window, Window);
  112. };
  113.  
  114.  
  115. DrcmapControlDerived::DrcmapControlDerived(const char *name, Widget parent) : 
  116.                    DrcmapControl(name, parent) 
  117. { 
  118.     char *colors[] = {
  119.      "highlightColor1",
  120.       NULL
  121.     };
  122.  
  123.     XpmAttributes attr;
  124.     int status = 0;
  125.     Display *dpy;
  126.  
  127.     
  128.     winChoice = 0;
  129.     list = _list1;
  130.     rgbDisp = _rgbDisp;
  131.     drawwin = _drawwin;
  132.     XtAppContext app = XtWidgetToApplicationContext(_drawwin->baseWidget());
  133.     XtAppAddWorkProc(app, buildList, _drawwin);
  134.  
  135.     dpy = XtDisplay(theApplication->baseWidget());
  136.     basewind = XtWindow(theApplication->baseWidget());
  137. /*
  138.     colormap = XCreateColormap(dpy, basewind,
  139.                    DefaultVisual(dpy, DefaultScreen(dpy)),
  140.                    AllocNone);
  141.     attr.colormap = colormap;
  142.     attr.valuemask = XpmColormap | XpmCloseness;
  143. */
  144.     attr.valuemask = XpmCloseness;
  145.     attr.closeness = 40000;
  146.     
  147.        status = XpmCreatePixmapFromData(dpy, 
  148.                                        DefaultRootWindow(dpy), 
  149.                                        docbak, &drcmapPixmap, &drcmapShapemask, 
  150.                                        &attr);
  151.     if (status)
  152.          cout << "error creating pixmap" << endl;
  153.                        
  154.        XtVaSetValues(_baseWidget, 
  155.                    XmNbackgroundPixmap, drcmapPixmap,
  156.                    NULL); 
  157.  
  158.        status = XpmCreatePixmapFromData(dpy, 
  159.                                        basewind, 
  160.                                        bbl, &bblPixmap, &bblShapemask, 
  161.                                        &attr);
  162.     if (status)
  163.          cout << "error creating pixmap" << endl;
  164.                        
  165.        status = XpmCreatePixmapFromData(dpy, 
  166.                                        basewind, 
  167.                                        bbinvl, &bbinvlPixmap, &bbinvlShapemask, 
  168.                                        &attr);
  169.     if (status)
  170.          cout << "error creating pixmap" << endl;
  171.                        
  172.     status = XpmCreatePixmapFromData(dpy, 
  173.                                        basewind, 
  174.                                        bbr, &bbrPixmap, &bbrShapemask, 
  175.                                        &attr);
  176.     if (status)
  177.          cout << "error creating pixmap" << endl;
  178.                        
  179.        status = XpmCreatePixmapFromData(dpy, 
  180.                                        basewind, 
  181.                                        bbinvr, &bbinvrPixmap, &bbinvrShapemask, 
  182.                                        &attr);
  183.     if (status)
  184.          cout << "error creating pixmap" << endl;
  185.                        
  186.                       
  187.        XtVaSetValues(_prevCmap1, 
  188.                    XmNlabelPixmap, bblPixmap,
  189.                    NULL); 
  190.                        
  191.        XtVaSetValues(_nextCmap1, 
  192.                    XmNlabelPixmap, bbrPixmap,
  193.                    NULL); 
  194. }
  195.  
  196.  
  197. DrcmapControlDerived::~DrcmapControlDerived()
  198. {
  199.   // Empty
  200. }
  201.  
  202.  
  203. const char * DrcmapControlDerived::className() // classname
  204. {
  205.     return ("DrcmapControlDerived");
  206. }
  207.  
  208. void DrcmapControlDerived::pickCmap(Widget w, XtPointer calldata)
  209. {
  210.     XmListCallbackStruct *cbs = (XmListCallbackStruct *)calldata;
  211.     
  212.     if (cbs->reason == XmCR_BROWSE_SELECT) {
  213.         winChoice = cbs->item_position - 1;
  214.         updateWindowsAndList(XtDisplay(w));
  215.         displayColormap(XtDisplay(w));
  216.     }
  217.     else
  218.          cout << "other select" << endl;
  219. }
  220.  
  221. void DrcmapControlDerived::prevCmap(Widget w, XtPointer) 
  222. {    
  223.     if (cmapCnt == 1)
  224.         return;
  225.     winChoice--;
  226.     if (winChoice < 0)
  227.         winChoice = cmapCnt - 1;
  228.     updateWindowsAndList(XtDisplay(w));
  229.     displayColormap(XtDisplay(w));
  230. }
  231.  
  232.  
  233. void DrcmapControlDerived::nextCmap(Widget w, XtPointer) 
  234. {   
  235.     if (cmapCnt == 1)
  236.         return;
  237.     winChoice++;
  238.     winChoice = winChoice % cmapCnt;
  239.     updateWindowsAndList(XtDisplay(w));
  240.     displayColormap(XtDisplay(w));
  241. }
  242.  
  243.  
  244. void DrcmapControlDerived::pushedBtnl(Widget w, XtPointer) 
  245. {    
  246.        XtVaSetValues(w, 
  247.                    XmNlabelPixmap, bbinvlPixmap,
  248.                    NULL); 
  249. }
  250.  
  251. void DrcmapControlDerived::normalBtnl(Widget w, XtPointer) 
  252. {    
  253.        XtVaSetValues(w, 
  254.                    XmNlabelPixmap, bblPixmap,
  255.                    NULL); 
  256. }
  257.  
  258.  
  259. void DrcmapControlDerived::pushedBtnr(Widget w, XtPointer) 
  260. {    
  261.        XtVaSetValues(w, 
  262.                    XmNlabelPixmap, bbinvrPixmap,
  263.                    NULL); 
  264. }
  265.  
  266. void DrcmapControlDerived::normalBtnr(Widget w, XtPointer) 
  267. {    
  268.        XtVaSetValues(w, 
  269.                    XmNlabelPixmap, bbrPixmap,
  270.                    NULL); 
  271. }
  272.  
  273.  
  274. void DrcmapControlDerived::rootList(Widget w, XtPointer) 
  275. {
  276.     scanXTree(XtDisplay(w), 
  277.                 RootWindow(XtDisplay(w), DefaultScreen(XtDisplay(w))), 
  278.                 XtWindow(_drawwin->baseWidget()), 1);
  279. }
  280.  
  281.  
  282. void DrcmapControlDerived::pickList(Widget w, XtPointer) 
  283. {
  284.     scanXTree(XtDisplay(w), 
  285.                 Select_Window(XtDisplay(w)), 
  286.                 XtWindow(_drawwin->baseWidget()), 1);
  287. }
  288.  
  289.  
  290. void DrcmapControlDerived::setList(XmString *items, int itemCnt)
  291. {
  292.  
  293.     XmListAddItems(_list1, items, itemCnt, 0);
  294. }
  295.  
  296.  
  297. Boolean
  298. buildList(XtPointer widg) 
  299. {
  300.     DrawwinDerived *drawW = (DrawwinDerived *)widg;
  301.      Widget w = drawW->baseWidget();
  302.      static int first = 1;
  303.  
  304.      drawArea = XtWindow(w);
  305.      if (!drawW->isExposed())
  306.          return(False);
  307.          
  308.     if (first) {
  309.         first = 0;
  310.         scanXTree(XtDisplay(w), 
  311.                     RootWindow(XtDisplay(w), DefaultScreen(XtDisplay(w))), 
  312.                     XtWindow(w), 0);
  313.         setWMColormaps(XtDisplay(w), XtWindow(theApplication->baseWidget()));
  314.         updateWindowsAndList(XtDisplay(w));
  315.         displayColormap(XtDisplay(w));
  316.     }
  317.     return(True);
  318. }
  319.  
  320.  
  321.  
  322.  
  323. void
  324. scanXTree(Display *dpy, Window startWin, Window attachWin, int recurse)
  325. {
  326.     winCnt = 0;
  327.     XDestroySubwindows(dpy, attachWin);        
  328.     cmapCnt = 0;
  329.     XmListDeleteAllItems(list);
  330.     theApplication->busy();
  331.     getWindowCmapInfo(dpy, startWin, attachWin);
  332.     walkTree(dpy, startWin, attachWin, recurse, 0);
  333.     theApplication->notBusy();
  334. }
  335.  
  336.  
  337.  
  338. void
  339. walkTree(Display *dpy, Window startWin, Window attachWin, int recurse, int level)
  340. {
  341.   int i;
  342.   Window root_win, parent_win;
  343.   unsigned int num_children;
  344.   Window *child_list;
  345.     
  346.   if (!XQueryTree(dpy, startWin, &root_win, &parent_win, &child_list,
  347.           &num_children)) {
  348.     fprintf(stderr, "Can't query window tree.");
  349.     exit(-1);
  350.   }
  351.    
  352.   winCnt += num_children;
  353.   
  354.   getWindowCmapInfo(dpy, startWin, attachWin);
  355.  
  356.   for (i = (int)num_children - 1; i >= 0; i--) {    
  357.     if (recurse)
  358.         walkTree(dpy, child_list[i], attachWin, 1, level+1);
  359.   }
  360.   if (child_list) XFree((char *)child_list);
  361. }
  362.  
  363.  
  364. void
  365. getWindowCmapInfo(Display *dpy, Window startWin, Window attachWin)
  366. {
  367.   int j;
  368.   XWindowAttributes win_attributes;
  369.   XVisualInfo vistemplate;
  370.   XVisualInfo *vinfo;
  371.   int junk;
  372.   XmString item;
  373.   int newcmap;
  374.  
  375.  
  376.       if (!XGetWindowAttributes(dpy, startWin, &win_attributes)) {
  377.         fprintf(stderr, "Can't get window attributes.");
  378.         exit(-1);
  379.     }
  380.       vistemplate.visualid = XVisualIDFromVisual(win_attributes.visual);
  381.       vinfo = XGetVisualInfo(dpy, VisualIDMask, &vistemplate, &junk);
  382.  
  383.     newcmap = 1;
  384.     for (j = 0; j < cmapCnt; j++) 
  385.         if (win_attributes.colormap == allcmaps[j].cmap) {
  386.             allcmaps[j].numRefs++;
  387.             if (win_attributes.map_installed) 
  388.                 allcmaps[j].installed = True;
  389.             newcmap = 0;
  390.             break;
  391.         }
  392.         
  393.     if (newcmap && win_attributes.depth != 0) { /* if InputOnly, ignore */
  394.         allcmaps[cmapCnt].numRefs++;
  395.         allcmaps[cmapCnt].cmap = win_attributes.colormap;
  396.         allcmaps[cmapCnt].vclass = vinfo->c_class;
  397.         allcmaps[cmapCnt].visual = vinfo->visual;
  398.         allcmaps[cmapCnt].vtype = identifyVisual(dpy, vinfo->visual);
  399.         allcmaps[cmapCnt].depth = win_attributes.depth;
  400.         allcmaps[cmapCnt].winIO = win_attributes.c_class;
  401.         if (win_attributes.map_installed)
  402.             cmapsInstalled++;
  403.         else 
  404.             allcmaps[cmapCnt].installed = 0;
  405.         sprintf(allcmaps[cmapCnt].title, "%-8s %2d  %-11s  0x%-x",
  406.                 vtypeNames[allcmaps[cmapCnt].vtype],
  407.                 allcmaps[cmapCnt].depth,
  408.                 vclassNames[allcmaps[cmapCnt].vclass],
  409.                 allcmaps[cmapCnt].cmap);
  410.         item = XmStringCreateSimple(allcmaps[cmapCnt].title);
  411.         XmListAddItem(list, item, 0);
  412.         buildWin(dpy, attachWin, cmapCnt);
  413.         winChoice = cmapCnt;
  414.         cmapCnt++;
  415.         updateWindowsAndList(dpy);
  416.         displayColormap(dpy);
  417.     }
  418. }
  419.  
  420.  
  421.  
  422. enum Vtype
  423. identifyVisual(Display *dpy, Visual *vis)
  424. {
  425.   int nVisuals;
  426.   static int defLayer;
  427.   int tmpLayer;
  428.   XLayerVisualInfo tmpLayerInfo;
  429.   XLayerVisualInfo *defaultLayerInfo;
  430.   Visual *defaultVisual;
  431.   static int first = 1;
  432.   
  433.    if (first) { 
  434.      defaultVisual = DefaultVisual(dpy, DefaultScreen(dpy));
  435.         tmpLayerInfo.vinfo.visualid = defaultVisual->visualid;
  436.         defaultLayerInfo = XGetLayerVisualInfo(dpy, VisualIDMask, &tmpLayerInfo, &nVisuals);
  437.      defLayer = defaultLayerInfo->layer;
  438.      first = 0;
  439.    }
  440.    
  441.    tmpLayerInfo.vinfo.visualid = vis->visualid; 
  442.    defaultLayerInfo = XGetLayerVisualInfo(dpy, 
  443.                  VisualIDMask, &tmpLayerInfo, &nVisuals);
  444.    tmpLayer = defaultLayerInfo->layer;
  445.    
  446.    if (tmpLayer < defLayer && defaultLayerInfo->type != None)
  447.       return(underlay);
  448.    else if (tmpLayer == defLayer)
  449.       return(normal);
  450.    else if (tmpLayer == defLayer + 1 && defaultLayerInfo->type != None)
  451.       return(overlay);
  452.    else if (tmpLayer == defLayer + 2 && defaultLayerInfo->type != None)
  453.       return(popup);
  454.    else {
  455.       fprintf(stderr, "error determining layer\n");
  456.       exit(-1);
  457.       return(popup);
  458.    }
  459. }
  460.  
  461.  
  462. void
  463. buildWin(Display *dpy, Window win, int newWin)
  464. {
  465.   XSetWindowAttributes winattr;
  466.   
  467.     winattr.event_mask = ExposureMask;
  468.     winattr.background_pixel = None;
  469.     winattr.colormap = allcmaps[newWin].cmap;
  470.     winattr.border_pixel = None;
  471.           
  472.     allcmaps[newWin].win = XCreateWindow(dpy, win,
  473.         1, 1, 256, 256,
  474.         0, allcmaps[newWin].depth, allcmaps[newWin].winIO, 
  475.         allcmaps[newWin].visual,
  476.         CWEventMask | CWBackPixel | CWBorderPixel | CWColormap, &winattr);
  477.  
  478.     allcmaps[newWin].gc = XCreateGC(dpy, allcmaps[newWin].win, NULL, NULL);
  479. }
  480.  
  481.  
  482. void
  483. setWMColormaps(Display *dpy, Window win)
  484. {
  485.   int i;
  486.   Window tmpwins[100];
  487.   
  488.   for (i = 0; i < cmapCnt; i++) 
  489.       tmpwins[i] = allcmaps[i].win;
  490.   XSetWMColormapWindows(dpy, win, tmpwins, cmapCnt);
  491. }
  492.  
  493.  
  494. void
  495. updateWindowsAndList(Display *dpy)
  496. {
  497.   static int lastChoice = 0;
  498.   int top, visible;
  499.   
  500.     XmListSelectPos(list, winChoice + 1, False);
  501.     XtVaGetValues(list,
  502.                   XmNtopItemPosition, &top,
  503.                   XmNvisibleItemCount, &visible,
  504.                   NULL);
  505.     if (winChoice + 1 < top)
  506.         XmListSetPos(list, winChoice + 1);
  507.     else if (winChoice + 1 >= top + visible)
  508.         XmListSetBottomPos(list, winChoice + 1);
  509.     
  510. //    XClearWindow(dpy, drawArea);
  511. //    XUnmapWindow(dpy, allcmaps[lastChoice].win);
  512.     XUnmapSubwindows(dpy, drawArea);
  513.     XClearWindow(dpy, allcmaps[winChoice].win);
  514.     XMapWindow(dpy, allcmaps[winChoice].win);
  515.     lastChoice = winChoice;
  516. }
  517.  
  518.  
  519. void
  520. displayColormap(Display *dpy)
  521. {
  522.   int i;
  523.   int sqw = 16;
  524.   int sqh = 16;
  525.   int cells;
  526.   int cellx;  
  527.   div_t loc;
  528.   int locx, locy, loccell;
  529.   XColor color;
  530.   char colorStr[80];
  531.   XmString item;
  532.   
  533.     if (cmapCnt == 0)  // buildList (of cmaps) has not be run yet
  534.         return;
  535.             
  536.     cells = allcmaps[winChoice].visual->map_entries;
  537.     if (cells > 256)
  538.         cells = 256;
  539.     cellx = 16;
  540.  
  541.     loc = div(drawwin->selectx, sqw);
  542.     locx = loc.quot;
  543.  
  544.     loc = div(drawwin->selecty, sqh);
  545.     locy = loc.quot;
  546.     
  547.     loccell = locy * cellx + locx;
  548.  
  549.     if (loccell > cells)
  550.         loccell = cells;
  551.         
  552.     for (i = 0; i < cells; i++) {
  553.         XSetForeground(dpy, allcmaps[winChoice].gc, i);
  554.         if (cells <= 256) {
  555.             XFillRectangle(dpy, allcmaps[winChoice].win, allcmaps[winChoice].gc,
  556.                   (i % cellx) * sqw, (i / cellx) * sqh, sqw, sqh);
  557.             if (i == loccell) {
  558.                 XSetFunction(dpy, allcmaps[winChoice].gc, GXxor);
  559.                 XSetLineAttributes(dpy, allcmaps[winChoice].gc, 2, 0, 0, 0);
  560.                 XDrawRectangle(dpy, allcmaps[winChoice].win, allcmaps[winChoice].gc,
  561.                   (i % cellx) * sqw, (i / cellx) * sqh, sqw - 1, sqh - 1);
  562.                 XSetLineAttributes(dpy, allcmaps[winChoice].gc, 1, 0, 0, 0);
  563.                 XSetFunction(dpy, allcmaps[winChoice].gc, GXcopy);
  564.                 color.pixel = i;
  565.                 XQueryColor(dpy, allcmaps[winChoice].cmap, &color);
  566.                 sprintf(colorStr, "%d R:%d G:%d B:%d", i,
  567.                             color.red >> 8, 
  568.                             color.green >> 8,
  569.                             color.blue >> 8);
  570.                 item = XmStringCreateSimple(colorStr);
  571.                    XtVaSetValues(rgbDisp, 
  572.                                    XmNlabelString, item,
  573.                                    NULL); 
  574.             }
  575.         }
  576.         else
  577.             XDrawPoint(dpy, allcmaps[winChoice].win, allcmaps[winChoice].gc,
  578.                         (i % cellx), (i / cellx));
  579.     }
  580. }
  581.  
  582.  
  583.  
  584.  
  585. /*
  586.  * Routine to let user select a window using the mouse
  587.  */
  588.  
  589. Window Select_Window(Display *dpy)
  590. {
  591.   int status;
  592.   Cursor cursor;
  593.   XEvent event;
  594.   Window target_win = None, root = RootWindow(dpy,DefaultScreen(dpy));
  595.   int buttons = 0;
  596.   int dummyi;
  597.   unsigned int dummy;
  598.  
  599.   /* Make the target cursor */
  600.   cursor = XCreateFontCursor(dpy, XC_crosshair);
  601.  
  602.   /* Grab the pointer using target cursor, letting it room all over */
  603.   status = XGrabPointer(dpy, root, False,
  604.             (unsigned long)ButtonPressMask|ButtonReleaseMask, GrabModeSync,
  605.             GrabModeAsync, root, cursor, CurrentTime);
  606.   if (status != GrabSuccess) printf("Can't grab the mouse.");
  607.  
  608.   /* Let the user select a window... */
  609.   while ((target_win == None) || (buttons != 0)) {
  610.     /* allow one more event */
  611.     XAllowEvents(dpy, SyncPointer, CurrentTime);
  612.     XWindowEvent(dpy, root, ButtonPressMask|ButtonReleaseMask, &event);
  613.     switch (event.type) {
  614.     case ButtonPress:
  615.       if (target_win == None) {
  616.     target_win = event.xbutton.subwindow; /* window selected */
  617.     if (target_win == None) target_win = root;
  618.       }
  619.       buttons++;
  620.       break;
  621.     case ButtonRelease:
  622.       if (buttons > 0) /* there may have been some down before we started */
  623.     buttons--;
  624.        break;
  625.     }
  626.   } 
  627.  
  628.   XUngrabPointer(dpy, CurrentTime);      /* Done with pointer */
  629.  
  630.   if (XGetGeometry (dpy, target_win, &root, &dummyi, &dummyi,
  631.                     &dummy, &dummy, &dummy, &dummy) &&
  632.                       target_win != root)
  633.       target_win = XmuClientWindow (dpy, target_win);
  634.  
  635.   return(target_win);
  636. }
  637.  
  638.  
  639.