home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xt / Shell.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  66.9 KB  |  2,202 lines
  1. /* $XConsortium: Shell.c,v 1.134 93/05/25 10:38:24 kaleb Exp $ */
  2.  
  3. /***********************************************************
  4. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  5. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  6.  
  7.                         All Rights Reserved
  8.  
  9. Permission to use, copy, modify, and distribute this software and its 
  10. documentation for any purpose and without fee is hereby granted, 
  11. provided that the above copyright notice appear in all copies and that
  12. both that copyright notice and this permission notice appear in 
  13. supporting documentation, and that the names of Digital or MIT not be
  14. used in advertising or publicity pertaining to distribution of the
  15. software without specific, written prior permission.  
  16.  
  17. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  19. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  20. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23. SOFTWARE.
  24.  
  25. ******************************************************************/
  26.  
  27. #define SHELL
  28.  
  29. #ifndef DEFAULT_WM_TIMEOUT
  30. #define DEFAULT_WM_TIMEOUT 5000
  31. #endif
  32.  
  33. #include "IntrinsicI.h"
  34. #include "StringDefs.h"
  35. #include "Shell.h"
  36. #include "ShellP.h"
  37. #include "Vendor.h"
  38. #include "VendorP.h"
  39. #include <X11/Xatom.h>
  40. #include <X11/Xlocale.h>
  41. #include <stdio.h>
  42.  
  43. /***************************************************************************
  44.  *
  45.  * Note: per the Xt spec, the Shell geometry management assumes in
  46.  * several places that there is only one managed child.  This is
  47.  * *not* a bug.  Any subclass that assumes otherwise is broken.
  48.  *
  49.  ***************************************************************************/
  50.  
  51. #define WM_CONFIGURE_DENIED(w) (((WMShellWidget) (w))->wm.wm_configure_denied)
  52. #define WM_MOVED(w) (((WMShellWidget) (w))->wm.wm_moved)
  53.  
  54. #define BIGSIZE ((Dimension)32767)
  55.  
  56. /***************************************************************************
  57.  *
  58.  * Default values for resource lists
  59.  *
  60.  ***************************************************************************/
  61.  
  62. #ifdef CRAY
  63. void _XtShellDepth();
  64. void _XtShellColormap();
  65. void _XtShellAncestorSensitive();
  66. void _XtTitleEncoding();
  67. #else
  68. static void _XtShellDepth();
  69. static void _XtShellColormap();
  70. static void _XtShellAncestorSensitive();
  71. static void _XtTitleEncoding();
  72. #endif
  73.  
  74. /***************************************************************************
  75.  *
  76.  * Shell class record
  77.  *
  78.  ***************************************************************************/
  79.  
  80. #define Offset(x)    (XtOffsetOf(ShellRec, x))
  81. static XtResource shellResources[]=
  82. {
  83.     {XtNx, XtCPosition, XtRPosition, sizeof(Position),
  84.         Offset(core.x), XtRImmediate, (XtPointer)BIGSIZE},
  85.     {XtNy, XtCPosition, XtRPosition, sizeof(Position),
  86.         Offset(core.y), XtRImmediate, (XtPointer)BIGSIZE},
  87.     { XtNdepth, XtCDepth, XtRInt, sizeof(int),
  88.         Offset(core.depth), XtRCallProc, (XtPointer) _XtShellDepth},
  89.     { XtNcolormap, XtCColormap, XtRColormap, sizeof(Colormap),
  90.         Offset(core.colormap), XtRCallProc, (XtPointer) _XtShellColormap},
  91.     { XtNancestorSensitive, XtCSensitive, XtRBoolean, sizeof(Boolean),
  92.         Offset(core.ancestor_sensitive), XtRCallProc,
  93.         (XtPointer) _XtShellAncestorSensitive},
  94.     { XtNallowShellResize, XtCAllowShellResize, XtRBoolean,
  95.         sizeof(Boolean), Offset(shell.allow_shell_resize),
  96.         XtRImmediate, (XtPointer)False},
  97.     { XtNgeometry, XtCGeometry, XtRString, sizeof(String), 
  98.         Offset(shell.geometry), XtRString, (XtPointer)NULL},
  99.     { XtNcreatePopupChildProc, XtCCreatePopupChildProc, XtRFunction,
  100.         sizeof(XtCreatePopupChildProc), Offset(shell.create_popup_child_proc),
  101.         XtRFunction, NULL},
  102.     { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
  103.         Offset(shell.save_under), XtRImmediate, (XtPointer)False},
  104.     { XtNpopupCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
  105.         Offset(shell.popup_callback), XtRCallback, (XtPointer) NULL},
  106.     { XtNpopdownCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
  107.         Offset(shell.popdown_callback), XtRCallback, (XtPointer) NULL},
  108.     { XtNoverrideRedirect, XtCOverrideRedirect,
  109.         XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
  110.         XtRImmediate, (XtPointer)False},
  111.     { XtNvisual, XtCVisual, XtRVisual, sizeof(Visual*),
  112.         Offset(shell.visual), XtRImmediate, CopyFromParent}
  113. };
  114.  
  115. static void ClassPartInitialize(), Initialize();
  116. static void Realize();
  117. static void Resize();
  118. static Boolean SetValues();
  119. static void GetValuesHook();
  120. static void ChangeManaged(); /* XXX */
  121. static XtGeometryResult GeometryManager(), RootGeometryManager();
  122. static void Destroy();
  123.  
  124. static ShellClassExtensionRec shellClassExtRec = {
  125.     NULL,
  126.     NULLQUARK,
  127.     XtShellExtensionVersion,
  128.     sizeof(ShellClassExtensionRec),
  129.     RootGeometryManager
  130. };
  131.  
  132. externaldef(shellclassrec) ShellClassRec shellClassRec = {
  133.   {   /* Core */
  134.     /* superclass      */    (WidgetClass) &compositeClassRec,
  135.     /* class_name      */    "Shell",
  136.     /* size          */    sizeof(ShellRec),
  137.     /* Class Initializer  */    NULL,
  138.     /* class_part_initialize*/    ClassPartInitialize,
  139.     /* Class init'ed ?      */    FALSE,
  140.     /* initialize      */    Initialize,
  141.     /* initialize_notify  */    NULL,        
  142.     /* realize          */    Realize,
  143.     /* actions          */    NULL,
  144.     /* num_actions      */    0,
  145.     /* resources      */    shellResources,
  146.     /* resource_count      */    XtNumber(shellResources),
  147.     /* xrm_class      */    NULLQUARK,
  148.     /* compress_motion      */    FALSE,
  149.     /* compress_exposure  */    TRUE,
  150.     /* compress_enterleave*/    FALSE,
  151.     /* visible_interest      */    FALSE,
  152.     /* destroy          */    Destroy,
  153.     /* resize          */    Resize,
  154.     /* expose          */    NULL,
  155.     /* set_values      */    SetValues,
  156.     /* set_values_hook      */    NULL,            
  157.     /* set_values_almost  */    XtInheritSetValuesAlmost,  
  158.     /* get_values_hook      */    GetValuesHook,
  159.     /* accept_focus      */    NULL,
  160.     /* intrinsics version */    XtVersion,
  161.     /* callback offsets      */    NULL,
  162.     /* tm_table          */    NULL,
  163.     /* query_geometry      */    NULL,
  164.     /* display_accelerator*/    NULL,
  165.     /* extension      */    NULL
  166.   },{ /* Composite */
  167.     /* geometry_manager      */    GeometryManager,
  168.     /* change_managed      */    ChangeManaged,
  169.     /* insert_child      */    XtInheritInsertChild,
  170.     /* delete_child      */    XtInheritDeleteChild,
  171.     /* extension      */    NULL
  172.   },{ /* Shell */
  173.     /* extension      */    (XtPointer)&shellClassExtRec
  174.   }
  175. };
  176.  
  177. externaldef(shellwidgetclass) WidgetClass shellWidgetClass = (WidgetClass) (&shellClassRec);
  178.  
  179. /***************************************************************************
  180.  *
  181.  * OverrideShell class record
  182.  *
  183.  ***************************************************************************/
  184.  
  185. static XtResource overrideResources[]=
  186. {
  187.     { XtNoverrideRedirect, XtCOverrideRedirect,
  188.         XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
  189.         XtRImmediate, (XtPointer)True},
  190.     { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
  191.         Offset(shell.save_under), XtRImmediate, (XtPointer)True},
  192. };
  193.  
  194. externaldef(overrideshellclassrec) OverrideShellClassRec overrideShellClassRec = {
  195.   {
  196.     /* superclass         */    (WidgetClass) &shellClassRec,
  197.     /* class_name         */    "OverrideShell",
  198.     /* size               */    sizeof(OverrideShellRec),
  199.     /* Class Initializer  */    NULL,
  200.     /* class_part_initialize*/    NULL,
  201.     /* Class init'ed ?    */    FALSE,
  202.     /* initialize         */    NULL,
  203.     /* initialize_notify    */    NULL,        
  204.     /* realize            */    XtInheritRealize,
  205.     /* actions            */    NULL,
  206.     /* num_actions        */    0,
  207.     /* resources          */    overrideResources,
  208.     /* resource_count     */    XtNumber(overrideResources),
  209.     /* xrm_class          */    NULLQUARK,
  210.     /* compress_motion    */    FALSE,
  211.     /* compress_exposure  */    TRUE,
  212.     /* compress_enterleave*/     FALSE,
  213.     /* visible_interest   */    FALSE,
  214.     /* destroy            */    NULL,
  215.     /* resize             */    XtInheritResize,
  216.     /* expose             */    NULL,
  217.     /* set_values         */    NULL,
  218.     /* set_values_hook      */    NULL,            
  219.     /* set_values_almost    */    XtInheritSetValuesAlmost,  
  220.     /* get_values_hook      */    NULL,            
  221.     /* accept_focus       */    NULL,
  222.     /* intrinsics version */    XtVersion,
  223.     /* callback offsets   */    NULL,
  224.     /* tm_table            */  NULL,
  225.     /* query_geometry        */  NULL,
  226.     /* display_accelerator  */  NULL,
  227.     /* extension        */  NULL
  228.   },{
  229.     /* geometry_manager   */    XtInheritGeometryManager,
  230.     /* change_managed     */    XtInheritChangeManaged,
  231.     /* insert_child      */    XtInheritInsertChild,
  232.     /* delete_child      */    XtInheritDeleteChild,
  233.     /* extension        */  NULL
  234.   },{
  235.     /* extension        */  NULL
  236.   },{
  237.     /* extension        */  NULL
  238.   }
  239. };
  240.  
  241. externaldef(overrideshellwidgetclass) WidgetClass overrideShellWidgetClass = 
  242.     (WidgetClass) (&overrideShellClassRec);
  243.  
  244. /***************************************************************************
  245.  *
  246.  * WMShell class record
  247.  *
  248.  ***************************************************************************/
  249.  
  250. #undef Offset
  251. #define Offset(x)    (XtOffsetOf(WMShellRec, x))
  252.  
  253. static int default_unspecified_shell_int = XtUnspecifiedShellInt;
  254. /*
  255.  * Warning, casting XtUnspecifiedShellInt (which is -1) to an (XtPointer)
  256.  * can result is loss of bits on some machines (i.e. crays)
  257.  */
  258.  
  259. static XtResource wmResources[]=
  260. {
  261.     { XtNtitle, XtCTitle, XtRString, sizeof(String),
  262.         Offset(wm.title), XtRString, NULL},
  263.     { XtNtitleEncoding, XtCTitleEncoding, XtRAtom, sizeof(Atom),
  264.         Offset(wm.title_encoding),
  265.         XtRCallProc, (XtPointer) _XtTitleEncoding},
  266.     { XtNwmTimeout, XtCWmTimeout, XtRInt, sizeof(int),
  267.         Offset(wm.wm_timeout), XtRImmediate,(XtPointer)DEFAULT_WM_TIMEOUT},
  268.     { XtNwaitForWm, XtCWaitForWm, XtRBoolean, sizeof(Boolean),
  269.         Offset(wm.wait_for_wm), XtRImmediate, (XtPointer)True},
  270.     { XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
  271.         Offset(wm.transient), XtRImmediate, (XtPointer)False},
  272. /* size_hints minus things stored in core */
  273.     { XtNbaseWidth, XtCBaseWidth, XtRInt, sizeof(int),
  274.         Offset(wm.base_width),
  275.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  276.     { XtNbaseHeight, XtCBaseHeight, XtRInt, sizeof(int),
  277.         Offset(wm.base_height),
  278.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  279.     { XtNwinGravity, XtCWinGravity, XtRInt, sizeof(int),
  280.         Offset(wm.win_gravity),
  281.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  282.     { XtNminWidth, XtCMinWidth, XtRInt, sizeof(int),
  283.         Offset(wm.size_hints.min_width),
  284.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  285.     { XtNminHeight, XtCMinHeight, XtRInt, sizeof(int),
  286.         Offset(wm.size_hints.min_height),
  287.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  288.     { XtNmaxWidth, XtCMaxWidth, XtRInt, sizeof(int),
  289.         Offset(wm.size_hints.max_width),
  290.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  291.     { XtNmaxHeight, XtCMaxHeight, XtRInt, sizeof(int),
  292.         Offset(wm.size_hints.max_height),
  293.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  294.     { XtNwidthInc, XtCWidthInc, XtRInt, sizeof(int),
  295.         Offset(wm.size_hints.width_inc),
  296.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  297.     { XtNheightInc, XtCHeightInc, XtRInt, sizeof(int),
  298.         Offset(wm.size_hints.height_inc),
  299.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  300.     { XtNminAspectX, XtCMinAspectX, XtRInt, sizeof(int),
  301.         Offset(wm.size_hints.min_aspect.x),
  302.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  303.     { XtNminAspectY, XtCMinAspectY, XtRInt, sizeof(int),
  304.         Offset(wm.size_hints.min_aspect.y),
  305.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  306.     { XtNmaxAspectX, XtCMaxAspectX, XtRInt, sizeof(int),
  307.         Offset(wm.size_hints.max_aspect.x),
  308.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  309.     { XtNmaxAspectY, XtCMaxAspectY, XtRInt, sizeof(int),
  310.         Offset(wm.size_hints.max_aspect.y),
  311.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  312. /* wm_hints */
  313.     { XtNinput, XtCInput, XtRBool, sizeof(Bool),
  314.         Offset(wm.wm_hints.input), XtRImmediate, (XtPointer)False},
  315.     { XtNinitialState, XtCInitialState, XtRInitialState, sizeof(int),
  316.         Offset(wm.wm_hints.initial_state),
  317.         XtRImmediate, (XtPointer)NormalState},
  318.     { XtNiconPixmap, XtCIconPixmap, XtRBitmap, sizeof(Pixmap),
  319.         Offset(wm.wm_hints.icon_pixmap), XtRPixmap, NULL},
  320.     { XtNiconWindow, XtCIconWindow, XtRWindow, sizeof(Window),
  321.         Offset(wm.wm_hints.icon_window), XtRWindow,   (XtPointer) NULL},
  322.     { XtNiconX, XtCIconX, XtRInt, sizeof(int),
  323.         Offset(wm.wm_hints.icon_x),
  324.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  325.     { XtNiconY, XtCIconY, XtRInt, sizeof(int),
  326.         Offset(wm.wm_hints.icon_y),
  327.         XtRInt, (XtPointer) &default_unspecified_shell_int},
  328.     { XtNiconMask, XtCIconMask, XtRBitmap, sizeof(Pixmap),
  329.         Offset(wm.wm_hints.icon_mask), XtRPixmap, NULL},
  330.     { XtNwindowGroup, XtCWindowGroup, XtRWindow, sizeof(Window),
  331.         Offset(wm.wm_hints.window_group),
  332.         XtRImmediate, (XtPointer)XtUnspecifiedWindow}
  333. };
  334.  
  335. static void WMInitialize();
  336. static Boolean WMSetValues();
  337. static void WMDestroy();
  338.  
  339. externaldef(wmshellclassrec) WMShellClassRec wmShellClassRec = {
  340.   {
  341.     /* superclass         */    (WidgetClass) &shellClassRec,
  342.     /* class_name         */    "WMShell",
  343.     /* size               */    sizeof(WMShellRec),
  344.     /* Class Initializer  */    NULL,
  345.     /* class_part_initialize*/    NULL,
  346.     /* Class init'ed ?    */    FALSE,
  347.     /* initialize         */    WMInitialize,
  348.     /* initialize_notify    */    NULL,        
  349.     /* realize            */    XtInheritRealize,
  350.     /* actions            */    NULL,
  351.     /* num_actions        */    0,
  352.     /* resources          */    wmResources,
  353.     /* resource_count     */    XtNumber(wmResources),
  354.     /* xrm_class          */    NULLQUARK,
  355.     /* compress_motion    */    FALSE,
  356.     /* compress_exposure  */    TRUE,
  357.     /* compress_enterleave*/    FALSE,
  358.     /* visible_interest   */    FALSE,
  359.     /* destroy            */    WMDestroy,
  360.     /* resize             */    XtInheritResize,
  361.     /* expose             */    NULL,
  362.     /* set_values         */    WMSetValues,
  363.     /* set_values_hook      */    NULL,            
  364.     /* set_values_almost    */    XtInheritSetValuesAlmost,  
  365.     /* get_values_hook      */    NULL,            
  366.     /* accept_focus       */    NULL,
  367.     /* intrinsics version */    XtVersion,
  368.     /* callback offsets   */    NULL,
  369.     /* tm_table            */  NULL,
  370.     /* query_geometry        */  NULL,
  371.     /* display_accelerator  */  NULL,
  372.     /* extension        */  NULL
  373.   },{
  374.     /* geometry_manager   */    XtInheritGeometryManager,
  375.     /* change_managed     */    XtInheritChangeManaged,
  376.     /* insert_child      */    XtInheritInsertChild,
  377.     /* delete_child      */    XtInheritDeleteChild,
  378.     /* extension        */  NULL
  379.   },{
  380.     /* extension        */  NULL
  381.   },{
  382.     /* extension        */  NULL
  383.   }
  384. };
  385.  
  386. externaldef(wmshellwidgetclass) WidgetClass wmShellWidgetClass = (WidgetClass) (&wmShellClassRec);
  387.  
  388. /***************************************************************************
  389.  *
  390.  * TransientShell class record
  391.  *
  392.  ***************************************************************************/
  393.  
  394. #undef Offset
  395. #define Offset(x)    (XtOffsetOf(TransientShellRec, x))
  396.  
  397. static XtResource transientResources[]=
  398. {
  399.     { XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
  400.         Offset(wm.transient), XtRImmediate, (XtPointer)True},
  401.     { XtNtransientFor, XtCTransientFor, XtRWidget, sizeof(Widget),
  402.         Offset(transient.transient_for), XtRWidget, NULL},
  403.     { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
  404.         Offset(shell.save_under), XtRImmediate, (XtPointer)True},
  405. };
  406.  
  407. static void TransientRealize();
  408. static Boolean TransientSetValues();
  409.  
  410. externaldef(transientshellclassrec) TransientShellClassRec transientShellClassRec = {
  411.   {
  412.     /* superclass      */    (WidgetClass) &vendorShellClassRec,
  413.     /* class_name      */    "TransientShell",
  414.     /* size          */    sizeof(TransientShellRec),
  415.     /* Class Initializer  */    NULL,
  416.     /* class_part_initialize*/    NULL,
  417.     /* Class init'ed ?      */    FALSE,
  418.     /* initialize      */    NULL,
  419.     /* initialize_notify  */    NULL,        
  420.     /* realize          */    TransientRealize,
  421.     /* actions          */    NULL,
  422.     /* num_actions      */    0,
  423.     /* resources      */    transientResources,
  424.     /* resource_count      */    XtNumber(transientResources),
  425.     /* xrm_class      */    NULLQUARK,
  426.     /* compress_motion      */    FALSE,
  427.     /* compress_exposure  */    TRUE,
  428.     /* compress_enterleave*/    FALSE,
  429.     /* visible_interest      */    FALSE,
  430.     /* destroy          */    NULL,
  431.     /* resize          */    XtInheritResize,
  432.     /* expose          */    NULL,
  433.     /* set_values      */    TransientSetValues,
  434.     /* set_values_hook      */    NULL,            
  435.     /* set_values_almost  */    XtInheritSetValuesAlmost,  
  436.     /* get_values_hook      */    NULL,            
  437.     /* accept_focus      */    NULL,
  438.     /* intrinsics version */    XtVersion,
  439.     /* callback offsets      */    NULL,
  440.     /* tm_table          */    XtInheritTranslations,
  441.     /* query_geometry      */    NULL,
  442.     /* display_accelerator*/    NULL,
  443.     /* extension      */    NULL
  444.   },{
  445.     /* geometry_manager      */    XtInheritGeometryManager,
  446.     /* change_managed      */    XtInheritChangeManaged,
  447.     /* insert_child      */    XtInheritInsertChild,
  448.     /* delete_child      */    XtInheritDeleteChild,
  449.     /* extension      */    NULL
  450.   },{
  451.     /* extension      */    NULL
  452.   },{
  453.     /* extension      */    NULL
  454.   },{
  455.     /* extension      */    NULL
  456.   },{
  457.     /* extension      */    NULL
  458.   }
  459. };
  460.  
  461. externaldef(transientshellwidgetclass) WidgetClass transientShellWidgetClass =
  462.     (WidgetClass) (&transientShellClassRec);
  463.  
  464. /***************************************************************************
  465.  *
  466.  * TopLevelShell class record
  467.  *
  468.  ***************************************************************************/
  469.  
  470. #undef Offset
  471. #define Offset(x)    (XtOffsetOf(TopLevelShellRec, x))
  472.  
  473. static XtResource topLevelResources[]=
  474. {
  475.     { XtNiconName, XtCIconName, XtRString, sizeof(String),
  476.         Offset(topLevel.icon_name), XtRString, (XtPointer) NULL},
  477.     { XtNiconNameEncoding, XtCIconNameEncoding, XtRAtom, sizeof(Atom),
  478.         Offset(topLevel.icon_name_encoding),
  479.         XtRCallProc, (XtPointer) _XtTitleEncoding},
  480.     { XtNiconic, XtCIconic, XtRBoolean, sizeof(Boolean),
  481.         Offset(topLevel.iconic), XtRImmediate, (XtPointer)False}
  482. };
  483.  
  484. static void TopLevelInitialize();
  485. static Boolean TopLevelSetValues();
  486. static void TopLevelDestroy();
  487.  
  488. externaldef(toplevelshellclassrec) TopLevelShellClassRec topLevelShellClassRec = {
  489.   {
  490.     /* superclass         */    (WidgetClass) &vendorShellClassRec,
  491.     /* class_name         */    "TopLevelShell",
  492.     /* size               */    sizeof(TopLevelShellRec),
  493.     /* Class Initializer  */    NULL,
  494.     /* class_part_initialize*/    NULL,
  495.     /* Class init'ed ?    */    FALSE,
  496.     /* initialize         */    TopLevelInitialize,
  497.     /* initialize_notify    */    NULL,        
  498.     /* realize            */    XtInheritRealize,
  499.     /* actions            */    NULL,
  500.     /* num_actions        */    0,
  501.     /* resources          */    topLevelResources,
  502.     /* resource_count     */    XtNumber(topLevelResources),
  503.     /* xrm_class          */    NULLQUARK,
  504.     /* compress_motion    */    FALSE,
  505.     /* compress_exposure  */    TRUE,
  506.     /* compress_enterleave*/     FALSE,
  507.     /* visible_interest   */    FALSE,
  508.     /* destroy            */    TopLevelDestroy,
  509.     /* resize             */    XtInheritResize,
  510.     /* expose             */    NULL,
  511.     /* set_values         */    TopLevelSetValues,
  512.     /* set_values_hook      */    NULL,            
  513.     /* set_values_almost    */    XtInheritSetValuesAlmost,  
  514.     /* get_values_hook      */    NULL,            
  515.     /* accept_focus       */    NULL,
  516.     /* intrinsics version */    XtVersion,
  517.     /* callback offsets   */    NULL,
  518.     /* tm_table            */  XtInheritTranslations,
  519.     /* query_geometry        */  NULL,
  520.     /* display_accelerator  */  NULL,
  521.     /* extension        */  NULL
  522.   },{
  523.     /* geometry_manager   */    XtInheritGeometryManager,
  524.     /* change_managed     */    XtInheritChangeManaged,
  525.     /* insert_child      */    XtInheritInsertChild,
  526.     /* delete_child      */    XtInheritDeleteChild,
  527.     /* extension        */  NULL
  528.   },{
  529.     /* extension        */  NULL
  530.   },{
  531.     /* extension        */  NULL
  532.   },{
  533.     /* extension        */  NULL
  534.   },{
  535.     /* extension        */  NULL
  536.   }
  537. };
  538.  
  539. externaldef(toplevelshellwidgetclass) WidgetClass topLevelShellWidgetClass =
  540.     (WidgetClass) (&topLevelShellClassRec);
  541.  
  542. /***************************************************************************
  543.  *
  544.  * ApplicationShell class record
  545.  *
  546.  ***************************************************************************/
  547.  
  548. #undef Offset
  549. #define Offset(x)    (XtOffsetOf(ApplicationShellRec, x))
  550.  
  551. static XtResource applicationResources[]=
  552. {
  553.     { XtNargc, XtCArgc, XtRInt, sizeof(int),
  554.         Offset(application.argc), XtRImmediate, (XtPointer)0}, 
  555.     { XtNargv, XtCArgv, XtRStringArray, sizeof(String*),
  556.         Offset(application.argv), XtRPointer, (XtPointer) NULL}
  557. };
  558.  
  559. static void ApplicationInitialize();
  560. static void ApplicationDestroy();
  561. static Boolean ApplicationSetValues();
  562. static void ApplicationShellInsertChild();
  563.  
  564. static CompositeClassExtensionRec compositeClassExtension = {
  565.     /* next_extension    */    NULL,
  566.     /* record_type    */    NULLQUARK,
  567.     /* version        */    XtCompositeExtensionVersion,
  568.     /* record_size    */    sizeof(CompositeClassExtensionRec),
  569.     /* accepts_objects    */    TRUE
  570. };
  571.  
  572.  
  573. externaldef(applicationshellclassrec) ApplicationShellClassRec applicationShellClassRec = {
  574.   {
  575.     /* superclass         */    (WidgetClass) &topLevelShellClassRec,
  576.     /* class_name         */    "ApplicationShell",
  577.     /* size               */    sizeof(ApplicationShellRec),
  578.     /* Class Initializer  */    NULL,
  579.     /* class_part_initialize*/    NULL,
  580.     /* Class init'ed ?    */    FALSE,
  581.     /* initialize         */    ApplicationInitialize,
  582.     /* initialize_notify  */    NULL,        
  583.     /* realize            */    XtInheritRealize,
  584.     /* actions            */    NULL,
  585.     /* num_actions        */    0,
  586.     /* resources          */    applicationResources,
  587.     /* resource_count     */    XtNumber(applicationResources),
  588.     /* xrm_class          */    NULLQUARK,
  589.     /* compress_motion    */    FALSE,
  590.     /* compress_exposure  */    TRUE,
  591.     /* compress_enterleave*/    FALSE,
  592.     /* visible_interest   */    FALSE,
  593.     /* destroy            */    ApplicationDestroy,
  594.     /* resize             */    XtInheritResize,
  595.     /* expose             */    NULL,
  596.     /* set_values         */    ApplicationSetValues,
  597.     /* set_values_hook    */    NULL,            
  598.     /* set_values_almost  */    XtInheritSetValuesAlmost,
  599.     /* get_values_hook    */    NULL,            
  600.     /* accept_focus       */    NULL,
  601.     /* intrinsics version */    XtVersion,
  602.     /* callback offsets   */    NULL,
  603.     /* tm_table          */    XtInheritTranslations,
  604.     /* query_geometry      */    NULL,
  605.     /* display_accelerator*/    NULL,
  606.     /* extension      */    NULL
  607.   },{
  608.     /* geometry_manager   */    XtInheritGeometryManager,
  609.     /* change_managed     */    XtInheritChangeManaged,
  610.     /* insert_child      */    ApplicationShellInsertChild,
  611.     /* delete_child      */    XtInheritDeleteChild,
  612.     /* extension      */    (XtPointer)&compositeClassExtension
  613.   },{
  614.     /* extension      */    NULL
  615.   },{
  616.     /* extension      */    NULL
  617.   },{
  618.     /* extension      */    NULL
  619.   },{
  620.     /* extension      */    NULL
  621.   },{
  622.     /* extension      */    NULL
  623.   }
  624. };
  625.  
  626. externaldef(applicationshellwidgetclass) WidgetClass applicationShellWidgetClass =
  627.     (WidgetClass) (&applicationShellClassRec);
  628.  
  629. /****************************************************************************
  630.  * Whew!
  631.  ****************************************************************************/
  632.  
  633. static void ComputeWMSizeHints(w, hints)
  634.     WMShellWidget w;
  635.     XSizeHints *hints;
  636. {
  637.     register long flags;
  638.     hints->flags = flags = w->wm.size_hints.flags;
  639. #define copy(field) hints->field = w->wm.size_hints.field
  640.     if (flags & (USPosition | PPosition)) {
  641.     copy(x);
  642.     copy(y);
  643.     }
  644.     if (flags & (USSize | PSize)) {
  645.     copy(width);
  646.     copy(height);
  647.     }
  648.     if (flags & PMinSize) {
  649.     copy(min_width);
  650.     copy(min_height);
  651.     }
  652.     if (flags & PMaxSize) {
  653.     copy(max_width);
  654.     copy(max_height);
  655.     }
  656.     if (flags & PResizeInc) {
  657.     copy(width_inc);
  658.     copy(height_inc);
  659.     }
  660.     if (flags & PAspect) {
  661.     copy(min_aspect.x);
  662.     copy(min_aspect.y);
  663.     copy(max_aspect.x);
  664.     copy(max_aspect.y);
  665.     }
  666. #undef copy
  667. #define copy(field) hints->field = w->wm.field
  668.     if (flags & PBaseSize) {
  669.     copy(base_width);
  670.     copy(base_height);
  671.     }
  672.     if (flags & PWinGravity)
  673.     copy(win_gravity);
  674. #undef copy
  675. }
  676.  
  677. static void _SetWMSizeHints(w)
  678.     WMShellWidget w;
  679. {
  680.     XSizeHints *size_hints = XAllocSizeHints();
  681.  
  682.     if (size_hints == NULL) _XtAllocError("XAllocSizeHints");
  683.     ComputeWMSizeHints(w, size_hints);
  684.     XSetWMNormalHints(XtDisplay((Widget)w), XtWindow((Widget)w), size_hints);
  685.     XFree((char*)size_hints);
  686. }
  687.  
  688. static ShellClassExtension _FindClassExtension(widget_class)
  689.     WidgetClass widget_class;
  690. {
  691.     ShellClassExtension ext;
  692.     for (ext = (ShellClassExtension)((ShellWidgetClass)widget_class)
  693.            ->shell_class.extension;
  694.      ext != NULL && ext->record_type != NULLQUARK;
  695.      ext = (ShellClassExtension)ext->next_extension);
  696.  
  697.     if (ext != NULL) {
  698.     if (  ext->version == XtShellExtensionVersion
  699.           && ext->record_size == sizeof(ShellClassExtensionRec)) {
  700.         /* continue */
  701.     } else {
  702.         String params[1];
  703.         Cardinal num_params = 1;
  704.         params[0] = widget_class->core_class.class_name;
  705.         XtErrorMsg( "invalidExtension", "shellClassPartInitialize",
  706.                 XtCXtToolkitError,
  707.          "widget class %s has invalid ShellClassExtension record",
  708.          params, &num_params);
  709.     }
  710.     }
  711.     return ext;
  712. }
  713.  
  714. static void ClassPartInitialize(widget_class)
  715.     WidgetClass widget_class;
  716. {
  717.     ShellClassExtension ext = _FindClassExtension(widget_class);
  718.     if (ext != NULL) {
  719.     if (ext->root_geometry_manager == XtInheritRootGeometryManager) {
  720.         ext->root_geometry_manager =
  721.         _FindClassExtension(widget_class->core_class.superclass)
  722.             ->root_geometry_manager;
  723.     }
  724.     } else {
  725.     /* if not found, spec requires XtInheritRootGeometryManager */
  726.     XtPointer *extP
  727.         = &((ShellWidgetClass)widget_class)->shell_class.extension;
  728.     ext = XtNew(ShellClassExtensionRec);
  729.     bcopy((char*)_FindClassExtension(widget_class->core_class.superclass),
  730.           (char*)ext,
  731.           sizeof(ShellClassExtensionRec));
  732.     ext->next_extension = *extP;
  733.     *extP = (XtPointer)ext;
  734.     }
  735. }
  736.  
  737.  
  738. static void EventHandler();
  739. static void _popup_set_prop();
  740.  
  741.  
  742. /*ARGSUSED*/
  743. static void XtCopyDefaultDepth(widget, offset, value)
  744.     Widget      widget;
  745.     int        offset;
  746.     XrmValue    *value;
  747. {
  748.     value->addr = (XPointer)(&DefaultDepthOfScreen(XtScreenOfObject(widget)));
  749. }
  750.  
  751. #ifndef CRAY
  752. static
  753. #endif
  754. void _XtShellDepth(widget,closure,value)
  755.     Widget widget;
  756.     int closure;
  757.     XrmValue *value;
  758. {
  759.    if (widget->core.parent == NULL) XtCopyDefaultDepth(widget,closure,value);
  760.    else _XtCopyFromParent (widget,closure,value);
  761. }
  762.  
  763. /*ARGSUSED*/
  764. static void XtCopyDefaultColormap(widget, offset, value)
  765.     Widget      widget;
  766.     int        offset;
  767.     XrmValue    *value;
  768. {
  769.     value->addr = (XPointer)(&DefaultColormapOfScreen(XtScreenOfObject(widget)));
  770. }
  771.  
  772. #ifndef CRAY
  773. static
  774. #endif
  775. void _XtShellColormap(widget,closure,value)
  776.     Widget widget;
  777.     int closure;
  778.     XrmValue *value;
  779. {
  780.    if (widget->core.parent == NULL)
  781.        XtCopyDefaultColormap(widget,closure,value);
  782.    else _XtCopyFromParent (widget,closure,value);
  783. }
  784.  
  785. #ifndef CRAY
  786. static
  787. #endif
  788. void _XtShellAncestorSensitive(widget,closure,value)
  789.     Widget widget;
  790.     int closure;
  791.     XrmValue *value;
  792. {
  793.    static Boolean true = True;
  794.    if (widget->core.parent == NULL) value->addr = (XPointer)(&true);
  795.    else _XtCopyFromParent (widget,closure,value);
  796. }
  797.  
  798. /*ARGSUSED*/
  799. #ifndef CRAY
  800. static
  801. #endif
  802. void _XtTitleEncoding(widget, offset, value)
  803.     Widget widget;
  804.     int offset;
  805.     XrmValue *value;
  806. {
  807.     static Atom atom;
  808.     if (XtWidgetToApplicationContext(widget)->langProcRec.proc) atom = None;
  809.     else atom = XA_STRING;
  810.     value->addr = (XPointer) &atom;
  811. }
  812.  
  813.  
  814. /* ARGSUSED */
  815. static void Initialize(req, new, args, num_args)
  816.     Widget req, new;
  817.     ArgList args;        /* unused */
  818.     Cardinal *num_args;    /* unused */
  819. {
  820.     ShellWidget w = (ShellWidget) new;
  821.  
  822.     w->shell.popped_up = FALSE;
  823.     w->shell.client_specified =
  824.         _XtShellNotReparented | _XtShellPositionValid;
  825.  
  826.     if (w->core.x == BIGSIZE) {
  827.         w->core.x = 0;
  828.         if (w->core.y == BIGSIZE) w->core.y = 0;
  829.     } else {
  830.         if (w->core.y == BIGSIZE) w->core.y = 0;
  831.         else w->shell.client_specified |= _XtShellPPositionOK;
  832.     }
  833.  
  834.     XtAddEventHandler(new, (EventMask) StructureNotifyMask,
  835.         TRUE, EventHandler, (XtPointer) NULL);
  836. }
  837.  
  838. /* ARGSUSED */
  839. static void WMInitialize(req, new, args, num_args)
  840.     Widget req,new;
  841.     ArgList args;        /* unused */
  842.     Cardinal *num_args;    /* unused */
  843. {
  844.     WMShellWidget w = (WMShellWidget) new;
  845.     TopLevelShellWidget tls = (TopLevelShellWidget) new;    /* maybe */
  846.  
  847.     if(w->wm.title == NULL) {
  848.         if (XtIsTopLevelShell(new) &&
  849.             tls->topLevel.icon_name != NULL &&
  850.             strlen(tls->topLevel.icon_name) != 0) {
  851.         w->wm.title = XtNewString(tls->topLevel.icon_name);
  852.         } else {
  853.         w->wm.title = XtNewString(w->core.name);
  854.         }
  855.     } else {
  856.         w->wm.title = XtNewString(w->wm.title);
  857.     }
  858.     w->wm.size_hints.flags = 0;
  859.     w->wm.wm_hints.flags = 0;
  860.  
  861.     /* Find the values of the atoms, somewhere... */
  862.  
  863.     for (new = new->core.parent;
  864.         new != NULL && !XtIsWMShell(new);
  865.         new = new->core.parent) {}
  866.     if (new == NULL) {
  867.         w->wm.wm_configure_denied =
  868.             XInternAtom(XtDisplay(w), "WM_CONFIGURE_DENIED", FALSE);
  869.         w->wm.wm_moved = XInternAtom(XtDisplay(w), "WM_MOVED", FALSE);
  870.     } else {
  871.         w->wm.wm_configure_denied = WM_CONFIGURE_DENIED(new);
  872.         w->wm.wm_moved = WM_MOVED(new);
  873.     }
  874. }
  875.  
  876.  
  877. /* ARGSUSED */
  878. static void TopLevelInitialize(req, new, args, num_args)
  879.     Widget req, new;
  880.     ArgList args;        /* unused */
  881.     Cardinal *num_args;    /* unused */
  882. {
  883.     TopLevelShellWidget w = (TopLevelShellWidget) new;
  884.  
  885.     if (w->topLevel.icon_name == NULL) {
  886.         w->topLevel.icon_name = XtNewString(w->core.name);
  887.     } else {
  888.         w->topLevel.icon_name = XtNewString(w->topLevel.icon_name);
  889.     }
  890.  
  891.     if (w->topLevel.iconic)
  892.         w->wm.wm_hints.initial_state = IconicState;
  893. }
  894.  
  895. /* ARGSUSED */
  896. static void ApplicationInitialize(req, new, args, num_args)
  897.     Widget req, new;
  898.     ArgList args;        /* unused */
  899.     Cardinal *num_args;        /* unused */
  900. {
  901.     ApplicationShellWidget w = (ApplicationShellWidget)new;
  902.     /* copy the argv if passed */
  903.     if (w->application.argc > 0) {
  904.     int i = w->application.argc;
  905.     char **argv = (char**)XtMalloc( (unsigned)i*sizeof(char*) );
  906.     char **argp = w->application.argv + i;
  907.     while (--i >= 0) {
  908.         argv[i] = *--argp;
  909.     }
  910.     w->application.argv = argv;
  911.     }
  912. }
  913.  
  914. static void Resize(w)
  915.     Widget w;
  916. {
  917.     register ShellWidget sw = (ShellWidget)w;    
  918.     Widget childwid;
  919.     int i;
  920.     for(i = 0; i < sw->composite.num_children; i++) {
  921.         if (XtIsManaged(sw->composite.children[i])) {
  922.              childwid = sw->composite.children[i];
  923.              XtResizeWidget(childwid, sw->core.width, sw->core.height,
  924.                            childwid->core.border_width);
  925.          break;        /* can only be one managed child */
  926.         }
  927.     }
  928. }
  929.  
  930. static void GetGeometry();
  931.  
  932. static void Realize(wid, vmask, attr)
  933.     Widget wid;
  934.     Mask *vmask;
  935.     XSetWindowAttributes *attr;
  936. {
  937.     ShellWidget w = (ShellWidget) wid;
  938.         Mask mask = *vmask;
  939.  
  940.     if (! (w->shell.client_specified & _XtShellGeometryParsed)) {
  941.         /* we'll get here only if there was no child the first
  942.            time we were realized.  If the shell was Unrealized
  943.            and then re-Realized, we probably don't want to
  944.            re-evaluate the defaults anyway.
  945.          */
  946.         GetGeometry(wid, (Widget)NULL);
  947.     }
  948.     else if (w->core.background_pixmap == XtUnspecifiedPixmap) {
  949.         /* I attempt to inherit my child's background to avoid screen flash
  950.          * if there is latency between when I get resized and when my child
  951.          * is resized.  Background=None is not satisfactory, as I want the
  952.          * user to get immediate feedback on the new dimensions (most
  953.          * particularly in the case of a non-reparenting wm).  It is
  954.          * especially important to have the server clear any old cruft
  955.          * from the display when I am resized larger.
  956.          */
  957.         register Widget *childP = w->composite.children;
  958.         int i;
  959.         for (i = w->composite.num_children; i; i--, childP++) {
  960.         if (XtIsWidget(*childP) && XtIsManaged(*childP)) {
  961.             if ((*childP)->core.background_pixmap
  962.                 != XtUnspecifiedPixmap) {
  963.             mask &= ~(CWBackPixel);
  964.             mask |= CWBackPixmap;
  965.             attr->background_pixmap =
  966.                 w->core.background_pixmap =
  967.                 (*childP)->core.background_pixmap;
  968.             } else {
  969.             attr->background_pixel = 
  970.                 w->core.background_pixel = 
  971.                 (*childP)->core.background_pixel;
  972.             }
  973.             break;
  974.         }
  975.         }
  976.     }
  977.  
  978.     if(w->shell.save_under) {
  979.         mask |= CWSaveUnder;
  980.         attr->save_under = TRUE;
  981.     }
  982.     if(w->shell.override_redirect) {
  983.         mask |= CWOverrideRedirect;
  984.         attr->override_redirect = TRUE;
  985.     }
  986.     if (wid->core.width == 0 || wid->core.height == 0) {
  987.         Cardinal count = 1;
  988.         XtErrorMsg("invalidDimension", "shellRealize", XtCXtToolkitError,
  989.                "Shell widget %s has zero width and/or height",
  990.                &wid->core.name, &count);
  991.     }
  992.     wid->core.window = XCreateWindow(XtDisplay(wid),
  993.         wid->core.screen->root, (int)wid->core.x, (int)wid->core.y,
  994.         (unsigned int)wid->core.width, (unsigned int)wid->core.height,
  995.         (unsigned int)wid->core.border_width, (int) wid->core.depth,
  996.         (unsigned int) InputOutput, w->shell.visual,
  997.         mask, attr);
  998.  
  999.     _popup_set_prop(w);
  1000. }
  1001.  
  1002.  
  1003. static void _SetTransientForHint(w, delete)
  1004.      TransientShellWidget w;
  1005.      Boolean delete;
  1006. {
  1007.     Window window_group;
  1008.  
  1009.     if (w->wm.transient) {
  1010.     if (w->transient.transient_for != NULL
  1011.         && XtIsRealized(w->transient.transient_for))
  1012.         window_group = XtWindow(w->transient.transient_for);
  1013.     else if ((window_group = w->wm.wm_hints.window_group)
  1014.          == XtUnspecifiedWindowGroup) {
  1015.         if (delete)
  1016.         XDeleteProperty( XtDisplay((Widget)w),
  1017.                  XtWindow((Widget)w),
  1018.                  XA_WM_TRANSIENT_FOR
  1019.                 );
  1020.         return;
  1021.     }
  1022.  
  1023.     XSetTransientForHint( XtDisplay((Widget)w),
  1024.                   XtWindow((Widget)w),
  1025.                   window_group
  1026.                  );
  1027.     }
  1028. }
  1029.  
  1030.  
  1031. static void TransientRealize(w, vmask, attr)
  1032.      Widget w;
  1033.      Mask *vmask;
  1034.      XSetWindowAttributes *attr;
  1035. {
  1036.     (*transientShellWidgetClass->core_class.superclass->
  1037.      core_class.realize) (w, vmask, attr);
  1038.  
  1039.     _SetTransientForHint((TransientShellWidget)w, False);
  1040. }
  1041.  
  1042.  
  1043. static void EvaluateWMHints(w)
  1044.     WMShellWidget w;
  1045. {
  1046.     XWMHints *hintp = &w->wm.wm_hints;
  1047.  
  1048.     hintp->flags = StateHint | InputHint;
  1049.  
  1050.     if (hintp->icon_x == XtUnspecifiedShellInt)
  1051.         hintp->icon_x = -1;
  1052.     else
  1053.         hintp->flags |= IconPositionHint;
  1054.  
  1055.     if (hintp->icon_y == XtUnspecifiedShellInt)
  1056.         hintp->icon_y = -1;
  1057.     else
  1058.         hintp->flags |= IconPositionHint;
  1059.  
  1060.     if (hintp->icon_pixmap != None) hintp->flags |= IconPixmapHint;
  1061.     if (hintp->icon_mask != None)   hintp->flags |= IconMaskHint;
  1062.     if (hintp->icon_window != None) hintp->flags |= IconWindowHint;
  1063.  
  1064.     if (hintp->window_group == XtUnspecifiedWindow) {
  1065.         if(w->core.parent) {
  1066.         Widget p;
  1067.         for (p = w->core.parent; p->core.parent; p = p->core.parent);
  1068.         if (XtIsRealized(p)) {
  1069.             hintp->window_group = XtWindow(p);
  1070.             hintp->flags |=  WindowGroupHint;
  1071.         }
  1072.         }
  1073.     } else if (hintp->window_group != XtUnspecifiedWindowGroup)
  1074.         hintp->flags |=  WindowGroupHint;
  1075. }
  1076.  
  1077.  
  1078. static void EvaluateSizeHints(w)
  1079.     WMShellWidget w;
  1080. {
  1081.     struct _OldXSizeHints *sizep = &w->wm.size_hints;
  1082.  
  1083.     sizep->x = w->core.x;
  1084.     sizep->y = w->core.y;
  1085.     sizep->width = w->core.width;
  1086.     sizep->height = w->core.height;
  1087.  
  1088.     if (sizep->flags & USSize) {
  1089.         if (sizep->flags & PSize) sizep->flags &= ~PSize;
  1090.     } else
  1091.         sizep->flags |= PSize;
  1092.  
  1093.     if (sizep->flags & USPosition) {
  1094.         if (sizep->flags & PPosition) sizep->flags &= ~PPosition;
  1095.     } else if (w->shell.client_specified & _XtShellPPositionOK)
  1096.         sizep->flags |= PPosition;
  1097.  
  1098.     if (sizep->min_aspect.x != XtUnspecifiedShellInt
  1099.         || sizep->min_aspect.y != XtUnspecifiedShellInt
  1100.         || sizep->max_aspect.x != XtUnspecifiedShellInt
  1101.         || sizep->max_aspect.y != XtUnspecifiedShellInt) {
  1102.         sizep->flags |= PAspect;
  1103.     }
  1104.     if (sizep->flags & PBaseSize
  1105.         || w->wm.base_width != XtUnspecifiedShellInt
  1106.         || w->wm.base_height != XtUnspecifiedShellInt) {
  1107.         sizep->flags |= PBaseSize;
  1108.         if (w->wm.base_width == XtUnspecifiedShellInt)
  1109.         w->wm.base_width = 0;
  1110.         if (w->wm.base_height == XtUnspecifiedShellInt)
  1111.         w->wm.base_height = 0;
  1112.     }
  1113.     if (sizep->flags & PResizeInc
  1114.         || sizep->width_inc != XtUnspecifiedShellInt
  1115.         || sizep->height_inc != XtUnspecifiedShellInt) {
  1116.         if (sizep->width_inc < 1) sizep->width_inc = 1;
  1117.         if (sizep->height_inc < 1) sizep->height_inc = 1;
  1118.         sizep->flags |= PResizeInc;
  1119.     }
  1120.     if (sizep->flags & PMaxSize
  1121.         || sizep->max_width != XtUnspecifiedShellInt
  1122.         || sizep->max_height != XtUnspecifiedShellInt) {
  1123.         sizep->flags |= PMaxSize;
  1124.         if (sizep->max_width == XtUnspecifiedShellInt)
  1125.         sizep->max_width = BIGSIZE;
  1126.         if (sizep->max_height == XtUnspecifiedShellInt)
  1127.         sizep->max_height = BIGSIZE;
  1128.     }
  1129.     if (sizep->flags & PMinSize
  1130.         || sizep->min_width != XtUnspecifiedShellInt
  1131.         || sizep->min_height != XtUnspecifiedShellInt) {
  1132.         sizep->flags |= PMinSize;
  1133.         if (sizep->min_width == XtUnspecifiedShellInt)
  1134.         sizep->min_width = 1;
  1135.         if (sizep->min_height == XtUnspecifiedShellInt)
  1136.         sizep->min_height = 1;
  1137.     }
  1138. }
  1139.  
  1140. static void _popup_set_prop(w)
  1141.     ShellWidget w;
  1142. {
  1143.     Widget p;
  1144.     WMShellWidget wmshell = (WMShellWidget) w;
  1145.     TopLevelShellWidget tlshell = (TopLevelShellWidget) w;
  1146.     ApplicationShellWidget appshell = (ApplicationShellWidget) w;
  1147.     XTextProperty icon_name;
  1148.     XTextProperty window_name;
  1149.     char **argv;
  1150.     int argc;
  1151.     XSizeHints *size_hints;
  1152.     Window window_group;
  1153.     XClassHint classhint;
  1154.     Boolean copied_iname, copied_wname;
  1155.  
  1156.     if (!XtIsWMShell((Widget)w) || w->shell.override_redirect) return;
  1157.  
  1158.     if ((size_hints = XAllocSizeHints()) == NULL)
  1159.         _XtAllocError("XAllocSizeHints");
  1160.  
  1161.     copied_iname = copied_wname = False;
  1162.         if (wmshell->wm.title_encoding == None &&
  1163.         XmbTextListToTextProperty(XtDisplay((Widget)w),
  1164.                       (char**)&wmshell->wm.title,
  1165.                       1, XStdICCTextStyle,
  1166.                       &window_name) >= Success) {
  1167.         copied_wname = True;
  1168.     } else {
  1169.         window_name.value = (unsigned char*)wmshell->wm.title;
  1170.         window_name.encoding = wmshell->wm.title_encoding;
  1171.         window_name.format = 8;
  1172.         window_name.nitems = strlen((char *)window_name.value);
  1173.     }
  1174.  
  1175.     if (XtIsTopLevelShell((Widget)w)) {
  1176.             if (tlshell->topLevel.icon_name_encoding == None &&
  1177.         XmbTextListToTextProperty(XtDisplay((Widget)w),
  1178.                       (char**)&tlshell->topLevel.icon_name,
  1179.                       1, XStdICCTextStyle,
  1180.                       &icon_name) >= Success) {
  1181.         copied_iname = True;
  1182.         } else {
  1183.         icon_name.value = (unsigned char*)tlshell->topLevel.icon_name;
  1184.         icon_name.encoding = tlshell->topLevel.icon_name_encoding;
  1185.         icon_name.format = 8;
  1186.         icon_name.nitems = strlen((char *)icon_name.value);
  1187.         }
  1188.     }
  1189.  
  1190.     EvaluateWMHints(wmshell);
  1191.     EvaluateSizeHints(wmshell);
  1192.     ComputeWMSizeHints(wmshell, size_hints);
  1193.  
  1194.     if (wmshell->wm.transient
  1195.         && !XtIsTransientShell((Widget)w)
  1196.         && (window_group = wmshell->wm.wm_hints.window_group)
  1197.            != XtUnspecifiedWindowGroup) {
  1198.  
  1199.         XSetTransientForHint(XtDisplay((Widget)w),
  1200.                  XtWindow((Widget)w),
  1201.                  window_group
  1202.                  );
  1203.     }
  1204.  
  1205.     classhint.res_name = w->core.name;
  1206.     /* For the class, look up to the top of the tree */
  1207.     for (p = (Widget)w; p->core.parent != NULL; p = p->core.parent);
  1208.     if (XtIsApplicationShell(p)) {
  1209.         classhint.res_class =
  1210.         ((ApplicationShellWidget)p)->application.class;
  1211.     } else classhint.res_class = XtClass(p)->core_class.class_name;
  1212.  
  1213.     if (XtIsApplicationShell((Widget)w)
  1214.         && (argc = appshell->application.argc) != -1)
  1215.         argv = (char**)appshell->application.argv;
  1216.     else {
  1217.         argv = NULL;
  1218.         argc = 0;
  1219.     }
  1220.  
  1221.     XSetWMProperties(XtDisplay((Widget)w), XtWindow((Widget)w),
  1222.              &window_name,
  1223.              (XtIsTopLevelShell((Widget)w)) ? &icon_name : NULL,
  1224.              argv, argc,
  1225.              size_hints,
  1226.              &wmshell->wm.wm_hints,
  1227.              &classhint);
  1228.     XFree((char*)size_hints);
  1229.     if (copied_wname)
  1230.         XFree((XPointer)window_name.value);
  1231.     if (copied_iname)
  1232.         XFree((XPointer)icon_name.value);
  1233.  
  1234.     if (XtWidgetToApplicationContext((Widget)w)->langProcRec.proc) {
  1235.         char *locale = setlocale(LC_CTYPE, (char *)NULL);
  1236.         if (locale)
  1237.         XChangeProperty(XtDisplay((Widget)w), XtWindow((Widget)w),
  1238.                 XInternAtom(XtDisplay((Widget)w),
  1239.                         "WM_LOCALE_NAME", False),
  1240.                 XA_STRING, 8, PropModeReplace,
  1241.                 (unsigned char *)locale, strlen(locale));
  1242.     }
  1243. }
  1244.  
  1245. /* ARGSUSED */
  1246. static void EventHandler(wid, closure, event, continue_to_dispatch)
  1247.     Widget wid;
  1248.     XtPointer closure;    /* unused */
  1249.     XEvent *event;
  1250.         Boolean *continue_to_dispatch; /* unused */
  1251. {
  1252.     register ShellWidget w = (ShellWidget) wid;
  1253.     WMShellWidget wmshell = (WMShellWidget) w;
  1254.     Boolean  sizechanged = FALSE;
  1255.     unsigned int width, height, border_width, tmpdepth;
  1256.     int tmpx, tmpy, tmp2x, tmp2y;
  1257.     Window tmproot, tmpchild;
  1258.  
  1259.     if(w->core.window != event->xany.window) {
  1260.         XtAppErrorMsg(XtWidgetToApplicationContext(wid),
  1261.             "invalidWindow","eventHandler",XtCXtToolkitError,
  1262.                         "Event with wrong window",
  1263.             (String *)NULL, (Cardinal *)NULL);
  1264.         return;
  1265.     }
  1266.  
  1267.     switch(event->type) {
  1268.         case ConfigureNotify:
  1269.             if (w->core.window != event->xconfigure.window)
  1270.             return;  /* in case of SubstructureNotify */
  1271. #define NEQ(x)    ( w->core.x != event->xconfigure.x )
  1272.         if( NEQ(width) || NEQ(height) || NEQ(border_width) ) {
  1273.             sizechanged = TRUE;
  1274. #undef NEQ
  1275.             w->core.width = event->xconfigure.width;
  1276.             w->core.height = event->xconfigure.height;
  1277.             w->core.border_width = event->xconfigure.border_width;
  1278.         }
  1279.         if (event->xany.send_event /* ICCCM compliant synthetic ev */
  1280.             /* || w->shell.override_redirect */
  1281.             || w->shell.client_specified & _XtShellNotReparented)
  1282.             {
  1283.             w->core.x = event->xconfigure.x;
  1284.             w->core.y = event->xconfigure.y;
  1285.             w->shell.client_specified |= _XtShellPositionValid;
  1286.         }
  1287.         else w->shell.client_specified &= ~_XtShellPositionValid;
  1288.         if (XtIsWMShell(wid) && !wmshell->wm.wait_for_wm) {
  1289.             /* Consider trusting the wm again */
  1290.             register struct _OldXSizeHints *hintp
  1291.             = &wmshell->wm.size_hints;
  1292. #define EQ(x) (hintp->x == w->core.x)
  1293.             if (EQ(x) && EQ(y) && EQ(width) && EQ(height)) {
  1294.             wmshell->wm.wait_for_wm = TRUE;
  1295.             }
  1296. #undef EQ
  1297.         }            
  1298.         break;
  1299.  
  1300.         case ClientMessage:
  1301.         if( event->xclient.message_type == WM_CONFIGURE_DENIED(wid)
  1302.             && XtIsWMShell(wid)) {
  1303.  
  1304.             /* 
  1305.              * UT Oh! the window manager has come back alive
  1306.              * This means either I didn't wait long enough or
  1307.              * The WM is sick.
  1308.              * Query my real size and position, and adjust my child
  1309.              * it needs be.
  1310.              */
  1311.  
  1312.             if(wmshell->wm.wait_for_wm) {
  1313.             XtAppWarningMsg(XtWidgetToApplicationContext(wid),
  1314.                 "communicationError","windowManager",
  1315.                                   XtCXtToolkitError,
  1316.                                   "Window Manager is confused",
  1317.                   (String *)NULL, (Cardinal *)NULL);
  1318.             }
  1319.             wmshell->wm.wait_for_wm = TRUE;
  1320.             (void) XGetGeometry(XtDisplay(w), XtWindow(w), &tmproot,
  1321.                 &tmpx, &tmpy, &width, &height, &border_width,
  1322.                 &tmpdepth);
  1323.             (void) XTranslateCoordinates(XtDisplay(w), XtWindow(w), 
  1324.                 tmproot, (int) tmpx, (int) tmpy,
  1325.                 &tmp2x, &tmp2y, &tmpchild);
  1326.             w->core.x = tmp2x;
  1327.             w->core.y = tmp2y;
  1328.             if( width != w->core.width || height != w->core.height
  1329.                || border_width != w->core.border_width ) {
  1330.                 w->core.width = width;
  1331.                 w->core.height = height;
  1332.                 w->core.border_width = border_width;
  1333.                 sizechanged = TRUE;
  1334.             }
  1335.  
  1336.             break;
  1337.         }
  1338.         if(event->xclient.message_type == WM_MOVED(wid)) {
  1339.             w->core.x = event->xclient.data.s[0];
  1340.             w->core.y  = event->xclient.data.s[1];
  1341.             if (XtIsWMShell((Widget)w)) {
  1342.             WMShellWidget wmshell = (WMShellWidget) w;
  1343.             /* Any window manager which sends this must be 
  1344.                good guy.  Let's reset our flag. */
  1345.             wmshell->wm.wait_for_wm = TRUE;
  1346.             }
  1347.         }
  1348.         break;
  1349.  
  1350.           case ReparentNotify:
  1351.         if (event->xreparent.window == XtWindow(w)) {
  1352.            if (event->xreparent.parent !=
  1353.                RootWindowOfScreen(XtScreen(w)))
  1354.                w->shell.client_specified &= 
  1355.                ~(_XtShellNotReparented | _XtShellPositionValid);
  1356.            else {
  1357.                w->core.x = event->xreparent.x;
  1358.                w->core.y = event->xreparent.y;
  1359.                w->shell.client_specified |= 
  1360.                (_XtShellNotReparented | _XtShellPositionValid);
  1361.            }
  1362.             }
  1363.         return;
  1364.  
  1365.           case UnmapNotify:
  1366.         {
  1367.             XtPerDisplayInput    pdi;
  1368.             XtDevice        device;
  1369.             Widget        p;
  1370.  
  1371.             pdi = _XtGetPerDisplayInput(event->xunmap.display);
  1372.  
  1373.             device = &pdi->pointer;
  1374.             if (device->grabType == XtPassiveServerGrab) {
  1375.             p = device->grab.widget;
  1376.             while (p && !(XtIsShell(p)))
  1377.                 p = p->core.parent;
  1378.             if (p == wid)
  1379.                 device->grabType = XtNoServerGrab;
  1380.             }
  1381.  
  1382.             device = &pdi->keyboard;
  1383.             if (IsEitherPassiveGrab(device->grabType)) {
  1384.             p = device->grab.widget;
  1385.             while (p && !(XtIsShell(p)))
  1386.                 p = p->core.parent;
  1387.             if (p == wid) {
  1388.                 device->grabType = XtNoServerGrab;
  1389.                 pdi->activatingKey = 0;
  1390.             }
  1391.             }
  1392.  
  1393.             return;
  1394.         }
  1395.           default:
  1396.          return;
  1397.      } 
  1398.  
  1399.      if (sizechanged && 
  1400.                  XtClass(wid)->core_class.resize != (XtWidgetProc) NULL)
  1401.                     (*(XtClass(wid)->core_class.resize))(wid);
  1402.  
  1403. }
  1404.  
  1405. static void Destroy(wid)
  1406.     Widget wid;
  1407. {
  1408.     if (XtIsRealized(wid))
  1409.         XDestroyWindow( XtDisplay(wid), XtWindow(wid) );
  1410. }
  1411.  
  1412. static void WMDestroy(wid)
  1413.     Widget wid;
  1414. {
  1415.     WMShellWidget w = (WMShellWidget) wid;
  1416.  
  1417.     XtFree((char *) w->wm.title);
  1418. }
  1419.  
  1420. static void TopLevelDestroy(wid)
  1421.     Widget wid;
  1422. {
  1423.     TopLevelShellWidget w = (TopLevelShellWidget) wid;
  1424.  
  1425.     XtFree((char *) w->topLevel.icon_name);
  1426. }
  1427.  
  1428. static void ApplicationDestroy(wid)
  1429.     Widget wid;
  1430. {
  1431.     ApplicationShellWidget w = (ApplicationShellWidget) wid;
  1432.  
  1433.     if(w->application.argv != NULL) XtFree((char *) w->application.argv);
  1434.     w->application.argv = NULL;
  1435. }
  1436.  
  1437. /*
  1438.  * If the Shell has a width and a height which are zero, and as such
  1439.  * suspect, and it has not yet been realized then it will grow to
  1440.  * match the child before parsing the geometry resource.
  1441.  *
  1442.  */
  1443. static void GetGeometry(W, child)
  1444.     Widget W, child;
  1445. {
  1446.     register ShellWidget w = (ShellWidget)W;
  1447.     Boolean is_wmshell = XtIsWMShell(W);
  1448.     int x, y, width, height, win_gravity = -1, flag;
  1449.     XSizeHints hints;
  1450.  
  1451.     if (child != NULL) {
  1452.     /* we default to our child's size */
  1453.     if (is_wmshell && (w->core.width == 0 || w->core.height == 0))
  1454.         ((WMShellWidget)W)->wm.size_hints.flags |= PSize;
  1455.     if (w->core.width == 0)        w->core.width = child->core.width;
  1456.     if (w->core.height == 0)    w->core.height = child->core.height;
  1457.     }
  1458.     if(w->shell.geometry != NULL) {
  1459.     char def_geom[64];
  1460.     x = w->core.x;
  1461.     y = w->core.y;
  1462.     width = w->core.width;
  1463.     height = w->core.height;
  1464.     if (is_wmshell) {
  1465.         WMShellPart* wm = &((WMShellWidget)w)->wm;
  1466.         EvaluateSizeHints((WMShellWidget)w);
  1467.         bcopy((char*)&wm->size_hints, (char*)&hints,
  1468.           sizeof(struct _OldXSizeHints));
  1469.         hints.win_gravity = wm->win_gravity;
  1470.         if (wm->size_hints.flags & PBaseSize) {
  1471.         width -= wm->base_width;
  1472.         height -= wm->base_height;
  1473.         hints.base_width = wm->base_width;
  1474.         hints.base_height = wm->base_height;
  1475.         }
  1476.         else if (wm->size_hints.flags & PMinSize) {
  1477.         width -= wm->size_hints.min_width;
  1478.         height -= wm->size_hints.min_height;
  1479.         }
  1480.         if (wm->size_hints.flags & PResizeInc) {
  1481.         width /= wm->size_hints.width_inc;
  1482.         height /= wm->size_hints.height_inc;
  1483.         }
  1484.     }
  1485.     else hints.flags = 0;
  1486.  
  1487.     sprintf( def_geom, "%dx%d+%d+%d", width, height, x, y );
  1488.     flag = XWMGeometry( XtDisplay(W),
  1489.                 XScreenNumberOfScreen(XtScreen(W)),
  1490.                 w->shell.geometry, def_geom,
  1491.                 (unsigned int)w->core.border_width,
  1492.                 &hints, &x, &y, &width, &height,
  1493.                 &win_gravity
  1494.                );
  1495.     if (flag) {
  1496.         if (flag & XValue) w->core.x = (Position)x;
  1497.         if (flag & YValue) w->core.y = (Position)y;
  1498.         if (flag & WidthValue) w->core.width = (Dimension)width;
  1499.         if (flag & HeightValue) w->core.height = (Dimension)height;
  1500.     }
  1501.     else {
  1502.         String params[2];
  1503.         Cardinal num_params = 2;
  1504.         params[0] = XtName(W);
  1505.         params[1] = w->shell.geometry;
  1506.         XtAppWarningMsg(XtWidgetToApplicationContext(W),
  1507.        "badGeometry", "shellRealize", XtCXtToolkitError,
  1508.        "Shell widget \"%s\" has an invalid geometry specification: \"%s\"",
  1509.                 params, &num_params);
  1510.     }
  1511.     }
  1512.     else
  1513.     flag = 0;
  1514.  
  1515.     if (is_wmshell) {
  1516.     WMShellWidget wmshell = (WMShellWidget) w;
  1517.     if (wmshell->wm.win_gravity == XtUnspecifiedShellInt) {
  1518.         if (win_gravity != -1)
  1519.         wmshell->wm.win_gravity = win_gravity;
  1520.         else
  1521.         wmshell->wm.win_gravity = NorthWestGravity;
  1522.     }
  1523.     wmshell->wm.size_hints.flags |= PWinGravity;
  1524.     if ((flag & (XValue|YValue)) == (XValue|YValue))
  1525.         wmshell->wm.size_hints.flags |= USPosition;
  1526.     if ((flag & (WidthValue|HeightValue)) == (WidthValue|HeightValue))
  1527.         wmshell->wm.size_hints.flags |= USSize;
  1528.     }
  1529.     w->shell.client_specified |= _XtShellGeometryParsed;
  1530. }
  1531.  
  1532.  
  1533. static void ChangeManaged(wid)
  1534.     Widget wid;
  1535. {
  1536.     ShellWidget w = (ShellWidget) wid;
  1537.     Widget child = NULL;
  1538.     int i;
  1539.  
  1540.     for (i = 0; i < w->composite.num_children; i++) {
  1541.     if (XtIsManaged(w->composite.children[i])) {
  1542.         child = w->composite.children[i];
  1543.         break;        /* there can only be one of them! */
  1544.     }
  1545.     }
  1546.  
  1547.     if (!XtIsRealized (wid))    /* then we're about to be realized... */
  1548.     GetGeometry(wid, child);
  1549.  
  1550.     if (child != NULL)
  1551.     XtConfigureWidget (child, (Position)0, (Position)0,
  1552.                w->core.width, w->core.height, (Dimension)0 );
  1553. }
  1554.  
  1555. /*
  1556.  * This is gross, I can't wait to see if the change happened so I will ask
  1557.  * the window manager to change my size and do the appropriate X work.
  1558.  * I will then tell the requester that he can.  Care must be taken because
  1559.  * it is possible that some time in the future the request will be
  1560.  * asynchronusly denied and the window reverted to it's old size/shape.
  1561.  */
  1562.  
  1563. /*ARGSUSED*/
  1564. static XtGeometryResult GeometryManager( wid, request, reply )
  1565.     Widget wid;
  1566.     XtWidgetGeometry *request;
  1567.     XtWidgetGeometry *reply;
  1568. {
  1569.     ShellWidget shell = (ShellWidget)(wid->core.parent);
  1570.     XtWidgetGeometry my_request;
  1571.  
  1572.     if(shell->shell.allow_shell_resize == FALSE && XtIsRealized(wid))
  1573.         return(XtGeometryNo);
  1574.  
  1575.     if (request->request_mode & (CWX | CWY))
  1576.         return(XtGeometryNo);
  1577.  
  1578.     my_request.request_mode = (request->request_mode & XtCWQueryOnly);
  1579.     if (request->request_mode & CWWidth) {
  1580.         my_request.width = request->width;
  1581.         my_request.request_mode |= CWWidth;
  1582.     }
  1583.     if (request->request_mode & CWHeight) {
  1584.         my_request.height = request->height;
  1585.         my_request.request_mode |= CWHeight;
  1586.     }
  1587.     if (request->request_mode & CWBorderWidth) {
  1588.         my_request.border_width = request->border_width;
  1589.         my_request.request_mode |= CWBorderWidth;
  1590.     }
  1591.     if (XtMakeGeometryRequest((Widget)shell, &my_request, NULL)
  1592.         == XtGeometryYes) {
  1593.         /* assert: if (request->request_mode & CWWidth) then
  1594.          *           shell->core.width == request->width
  1595.          * assert: if (request->request_mode & CWHeight) then
  1596.          *           shell->core.height == request->height
  1597.          *
  1598.          * so, whatever the WM sized us to (if the Shell requested
  1599.          * only one of the two) is now the correct child size
  1600.          */
  1601.         
  1602.         if (!(request->request_mode & XtCWQueryOnly)) {
  1603.         wid->core.width = shell->core.width;
  1604.         wid->core.height = shell->core.height;
  1605.         if (request->request_mode & CWBorderWidth) {
  1606.             wid->core.x = wid->core.y = -request->border_width;
  1607.         }
  1608.         }
  1609.         return XtGeometryYes;
  1610.     } else return XtGeometryNo;
  1611. }
  1612.  
  1613. typedef struct {
  1614.     Widget  w;
  1615.     unsigned long request_num;
  1616.     Boolean done;
  1617. } QueryStruct;
  1618.  
  1619. static Bool isMine(dpy, event, arg)
  1620.     Display *dpy;
  1621.     register XEvent  *event;
  1622.     char *arg;
  1623. {
  1624.     QueryStruct *q = (QueryStruct *) arg;
  1625.     register Widget w = q->w;
  1626.     
  1627.     if ( (dpy != XtDisplay(w)) || (event->xany.window != XtWindow(w)) ) {
  1628.         return FALSE;
  1629.     }
  1630.     if (event->xany.serial >= q->request_num) {
  1631.         if (event->type == ConfigureNotify) {
  1632.         q->done = TRUE;
  1633.         return TRUE;
  1634.         } else
  1635.         /* This is draft-ICCCM stuff; here for compatibility */
  1636.         if (event->type == ClientMessage &&
  1637.             (event->xclient.message_type == WM_CONFIGURE_DENIED(w) ||
  1638.              event->xclient.message_type == WM_MOVED(w))) {
  1639.             q->done = TRUE;
  1640.             return TRUE;
  1641.         }
  1642.     }
  1643.     else if (event->type == ConfigureNotify ||
  1644.          (event->type == ClientMessage &&
  1645.           (event->xclient.message_type == WM_CONFIGURE_DENIED(w) ||
  1646.            event->xclient.message_type == WM_MOVED(w))))
  1647.         return TRUE;    /* flush old events */
  1648.     if (event->type == ReparentNotify
  1649.          && event->xreparent.window == XtWindow(w)) {
  1650.         /* we might get ahead of this event, so just in case someone
  1651.          * asks for coordinates before this event is dispatched...
  1652.          */
  1653.         register ShellWidget s = (ShellWidget)w;
  1654.         if (event->xreparent.parent != RootWindowOfScreen(XtScreen(w)))
  1655.         s->shell.client_specified &= ~_XtShellNotReparented;
  1656.         else
  1657.         s->shell.client_specified |= _XtShellNotReparented;
  1658.     }
  1659.     return FALSE;
  1660. }
  1661.  
  1662. static _wait_for_response(w, event, request_num)
  1663.     ShellWidget    w;
  1664.     XEvent        *event;
  1665.         unsigned long    request_num;
  1666. {
  1667.     XtAppContext app = XtWidgetToApplicationContext((Widget) w);
  1668.     QueryStruct q;
  1669.     unsigned long timeout;
  1670.  
  1671.     if (XtIsWMShell((Widget)w))
  1672.         timeout = ((WMShellWidget)w)->wm.wm_timeout;
  1673.     else
  1674.         timeout = DEFAULT_WM_TIMEOUT;
  1675.  
  1676.     XFlush(XtDisplay(w));
  1677.     q.w = (Widget) w;
  1678.     q.request_num = request_num;
  1679.     q.done = FALSE;
  1680.     
  1681.     for(;;) {
  1682.          /*
  1683.           * look for match event and discard all prior configures
  1684.           */
  1685.         if (XCheckIfEvent( XtDisplay(w), event, isMine, (char*)&q)) {
  1686.         if (q.done)
  1687.             return TRUE;
  1688.         else
  1689.             continue;    /* flush old events */
  1690.         }
  1691.  
  1692.         if (_XtwaitForSomething(TRUE, TRUE, FALSE, TRUE, &timeout, app)
  1693.         != -1) continue;
  1694.         if (timeout == 0)
  1695.         return FALSE;
  1696.     }
  1697. }
  1698.  
  1699. /*ARGSUSED*/
  1700. static XtGeometryResult RootGeometryManager(gw, request, reply)
  1701.     Widget gw;
  1702.     XtWidgetGeometry *request, *reply;
  1703. {
  1704.     register ShellWidget w = (ShellWidget)gw;
  1705.     XWindowChanges values;
  1706.     unsigned int mask = request->request_mode;
  1707.     XEvent event;
  1708.     Boolean wm;
  1709.     register struct _OldXSizeHints *hintp;
  1710.     int oldx, oldy, oldwidth, oldheight, oldborder_width;
  1711.     unsigned long request_num;
  1712.  
  1713.     if (XtIsWMShell(gw)) {
  1714.     wm = True;
  1715.     hintp = &((WMShellWidget)w)->wm.size_hints;
  1716.     /* for draft-ICCCM wm's, need to make sure hints reflect
  1717.        (current) reality so client can move and size separately. */
  1718.       hintp->x = w->core.x;
  1719.       hintp->y = w->core.y;
  1720.       hintp->width = w->core.width;
  1721.        hintp->height = w->core.height;
  1722.     } else
  1723.     wm = False;
  1724.     
  1725.     oldx = w->core.x;
  1726.     oldy = w->core.y;
  1727.     oldwidth = w->core.width;
  1728.     oldheight = w->core.height;
  1729.     oldborder_width = w->core.border_width;
  1730.  
  1731. #define PutBackGeometry() \
  1732.     { w->core.x = oldx; \
  1733.       w->core.y = oldy; \
  1734.       w->core.width = oldwidth; \
  1735.       w->core.height = oldheight; \
  1736.       w->core.border_width = oldborder_width; }
  1737.  
  1738.     if (mask & CWX) {
  1739.         if (w->core.x == request->x) mask &= ~CWX;
  1740.         else {
  1741.         w->core.x = values.x = request->x;
  1742.         if (wm) {
  1743.             hintp->flags &= ~USPosition;
  1744.             hintp->flags |= PPosition;
  1745.             hintp->x = values.x;
  1746.         }
  1747.         }
  1748.     }
  1749.     if (mask & CWY) {
  1750.         if (w->core.y == request->y) mask &= ~CWY;
  1751.         else {
  1752.         w->core.y = values.y = request->y;
  1753.         if (wm) {
  1754.             hintp->flags &= ~USPosition;
  1755.             hintp->flags |= PPosition;
  1756.             hintp->y = values.y;
  1757.         }
  1758.         }
  1759.     }
  1760.     if (mask & CWBorderWidth) {
  1761.         if (w->core.border_width == request->border_width) {
  1762.             mask &= ~CWBorderWidth;
  1763.         } else
  1764.         w->core.border_width =
  1765.             values.border_width =
  1766.             request->border_width;
  1767.     }
  1768.     if (mask & CWWidth) {
  1769.         if (w->core.width == request->width) mask &= ~CWWidth;
  1770.         else {
  1771.         w->core.width = values.width = request->width;
  1772.         if (wm) {
  1773.             hintp->flags &= ~USSize;
  1774.             hintp->flags |= PSize;
  1775.             hintp->width = values.width;
  1776.         }
  1777.         }
  1778.     }
  1779.     if (mask & CWHeight) {
  1780.         if (w->core.height == request->height) mask &= ~CWHeight;
  1781.         else {
  1782.         w->core.height = values.height = request->height;
  1783.         if (wm) {
  1784.             hintp->flags &= ~USSize;
  1785.             hintp->flags |= PSize;
  1786.             hintp->height = values.height;
  1787.         }
  1788.         }
  1789.     }
  1790.     if (mask & CWStackMode) {
  1791.     values.stack_mode = request->stack_mode;
  1792.     if (mask & CWSibling)
  1793.         values.sibling = XtWindow(request->sibling);
  1794.     }
  1795.  
  1796.     if (!XtIsRealized((Widget)w)) return XtGeometryYes;
  1797.  
  1798.     request_num = NextRequest(XtDisplay(w));
  1799.     XConfigureWindow(XtDisplay((Widget)w), XtWindow((Widget)w), mask,&values);
  1800.  
  1801.     if (wm && !w->shell.override_redirect
  1802.     && mask & (CWX | CWY | CWWidth | CWHeight | CWBorderWidth)) {
  1803.     _SetWMSizeHints((WMShellWidget)w);
  1804.     }
  1805.  
  1806.     if (w->shell.override_redirect) return XtGeometryYes;
  1807.  
  1808.     /* If no non-stacking bits are set, there's no way to tell whether
  1809.        or not this worked, so assume it did */
  1810.  
  1811.     if (!(mask & ~(CWStackMode | CWSibling))) return XtGeometryYes;
  1812.  
  1813.     if (wm && ((WMShellWidget)w)->wm.wait_for_wm == FALSE) {
  1814.         /* the window manager is sick
  1815.          * so I will do the work and 
  1816.          * say no so if a new WM starts up,
  1817.          * or the current one recovers
  1818.          * my size requests will be visible
  1819.          */
  1820.         PutBackGeometry();
  1821.         return XtGeometryNo;
  1822.     }
  1823.  
  1824.     if (_wait_for_response(w, &event, request_num)) {
  1825.     /* got an event */
  1826.     if (event.type == ConfigureNotify) {
  1827.  
  1828. #define NEQ(x, msk) ((mask & msk) && (values.x != event.xconfigure.x))    
  1829.         if (NEQ(x, CWX) ||
  1830.         NEQ(y, CWY) ||
  1831.         NEQ(width, CWWidth) ||
  1832.         NEQ(height, CWHeight) ||
  1833.         NEQ(border_width, CWBorderWidth)) {
  1834. #undef NEQ
  1835.         XPutBackEvent(XtDisplay(w), &event);
  1836.         PutBackGeometry();
  1837.         /*
  1838.          * We just potentially re-ordered the event queue
  1839.          * w.r.t. ConfigureNotifies with some trepidation.
  1840.          * But this is probably a Good Thing because we
  1841.          * will know the new true state of the world sooner
  1842.          * this way.
  1843.          */
  1844.         return XtGeometryNo;
  1845.         }
  1846.         else {
  1847.         w->core.width = event.xconfigure.width;
  1848.         w->core.height = event.xconfigure.height;
  1849.         w->core.border_width = event.xconfigure.border_width;
  1850.         if (event.xany.send_event || /* ICCCM compliant synth */
  1851.             w->shell.client_specified & _XtShellNotReparented) {
  1852.  
  1853.             w->core.x = event.xconfigure.x;
  1854.             w->core.y = event.xconfigure.y;
  1855.             w->shell.client_specified |= _XtShellPositionValid;
  1856.         }
  1857.         else w->shell.client_specified &= ~_XtShellPositionValid;
  1858.         return XtGeometryYes;
  1859.         }
  1860.     } else if (!wm ||
  1861.            (event.type == ClientMessage &&
  1862.             event.xclient.message_type == WM_CONFIGURE_DENIED(w))) {
  1863.         PutBackGeometry();
  1864.         return XtGeometryNo;
  1865.     } else if (event.type == ClientMessage &&
  1866.             event.xclient.message_type == WM_MOVED(w)) {
  1867.         w->core.x = event.xclient.data.s[0];
  1868.         w->core.y = event.xclient.data.s[1];
  1869.         w->shell.client_specified |= _XtShellPositionValid;
  1870.         return XtGeometryYes;
  1871.     } else XtAppWarningMsg(XtWidgetToApplicationContext((Widget)w),
  1872.                    "internalError", "shell", XtCXtToolkitError,
  1873.                    "Shell's window manager interaction is broken",
  1874.                    (String *)NULL, (Cardinal *)NULL);
  1875.     } else if (wm) { /* no event */ 
  1876.     ((WMShellWidget)w)->wm.wait_for_wm = FALSE; /* timed out; must be broken */
  1877.     }
  1878.     PutBackGeometry();
  1879. #undef PutBackGeometry
  1880.     return XtGeometryNo;
  1881. }
  1882.  
  1883. /* ARGSUSED */
  1884. static Boolean SetValues(old, ref, new, args, num_args)
  1885.     Widget old, ref, new;
  1886.     ArgList args;
  1887.     Cardinal *num_args;
  1888. {
  1889.     ShellWidget nw = (ShellWidget) new;
  1890.     ShellWidget ow = (ShellWidget) old;
  1891.     Mask mask = 0;
  1892.     XSetWindowAttributes attr;
  1893.  
  1894.     if (!XtIsRealized(new))
  1895.         return False;
  1896.  
  1897.     if (ow->shell.save_under != nw->shell.save_under) {
  1898.         mask = CWSaveUnder;
  1899.         attr.save_under = nw->shell.save_under;
  1900.     }
  1901.  
  1902.     if (ow->shell.override_redirect != nw->shell.override_redirect) {
  1903.         mask |= CWOverrideRedirect;
  1904.         attr.override_redirect = nw->shell.override_redirect;
  1905.     }
  1906.  
  1907.     if (mask) {
  1908.         XChangeWindowAttributes(XtDisplay(new),XtWindow(new), mask, &attr);
  1909.         if ((mask & CWOverrideRedirect) && !nw->shell.override_redirect)
  1910.         _popup_set_prop(nw);
  1911.     }
  1912.  
  1913.     if (! (ow->shell.client_specified & _XtShellPositionValid)) {
  1914.         Cardinal n;
  1915.         void _XtShellGetCoordinates();
  1916.  
  1917.         for (n = *num_args; n; n--, args++) {
  1918.         if (strcmp(XtNx, args->name) == 0) {
  1919.             _XtShellGetCoordinates(ow, &ow->core.x, &ow->core.y);
  1920.         } else if (strcmp(XtNy, args->name) == 0) {
  1921.             _XtShellGetCoordinates(ow, &ow->core.x, &ow->core.y);
  1922.         }
  1923.         }
  1924.     }
  1925.     return FALSE;
  1926. }
  1927.  
  1928. /* ARGSUSED */
  1929. static Boolean WMSetValues(old, ref, new, args, num_args)
  1930.     Widget old, ref, new;
  1931.     ArgList args;        /* unused */
  1932.     Cardinal *num_args;    /* unused */
  1933. {
  1934.     WMShellWidget nwmshell = (WMShellWidget) new;
  1935.     WMShellWidget owmshell = (WMShellWidget) old;
  1936.     Boolean set_prop
  1937.         = XtIsRealized(new) && !nwmshell->shell.override_redirect;
  1938.     Boolean title_changed;
  1939.  
  1940.     EvaluateSizeHints(nwmshell);
  1941.  
  1942. #define NEQ(f) (nwmshell->wm.size_hints.f != owmshell->wm.size_hints.f)
  1943.  
  1944.     if (set_prop
  1945.         && (NEQ(flags) || NEQ(min_width) || NEQ(min_height)
  1946.         || NEQ(max_width) || NEQ(max_height)
  1947.         || NEQ(width_inc) || NEQ(height_inc)
  1948.         || NEQ(min_aspect.x) || NEQ(min_aspect.y)
  1949.         || NEQ(max_aspect.x) || NEQ(max_aspect.y)
  1950. #undef NEQ
  1951. #define NEQ(f) (nwmshell->wm.f != owmshell->wm.f)
  1952.  
  1953.         || NEQ(base_width) || NEQ(base_height) || NEQ(win_gravity))) {
  1954.         _SetWMSizeHints(nwmshell);
  1955.     }
  1956. #undef NEQ
  1957.  
  1958.     if (nwmshell->wm.title != owmshell->wm.title) {
  1959.         XtFree(owmshell->wm.title);
  1960.         if (! nwmshell->wm.title) nwmshell->wm.title = "";
  1961.         nwmshell->wm.title = XtNewString(nwmshell->wm.title);
  1962.         title_changed = True;
  1963.     } else
  1964.         title_changed = False;
  1965.  
  1966.     if (set_prop
  1967.         && (title_changed ||
  1968.         nwmshell->wm.title_encoding != owmshell->wm.title_encoding)) {
  1969.  
  1970.         XTextProperty title;
  1971.         Boolean copied = False;
  1972.  
  1973.             if (nwmshell->wm.title_encoding == None &&
  1974.         XmbTextListToTextProperty(XtDisplay(new),
  1975.                       (char**)&nwmshell->wm.title,
  1976.                       1, XStdICCTextStyle,
  1977.                       &title) >= Success) {
  1978.         copied = True;
  1979.         } else {
  1980.         title.value = (unsigned char*)nwmshell->wm.title;
  1981.         title.encoding = nwmshell->wm.title_encoding;
  1982.         title.format = 8;
  1983.         title.nitems = strlen(nwmshell->wm.title);
  1984.         }
  1985.         XSetWMName(XtDisplay(new), XtWindow(new), &title);
  1986.         if (copied)
  1987.         XFree((XPointer)title.value);
  1988.     }
  1989.  
  1990.     EvaluateWMHints(nwmshell);
  1991.  
  1992. #define NEQ(f)    (nwmshell->wm.wm_hints.f != owmshell->wm.wm_hints.f)
  1993.  
  1994.     if (set_prop
  1995.         && (NEQ(flags) || NEQ(input) || NEQ(initial_state)
  1996.         || NEQ(icon_x) || NEQ(icon_y)
  1997.         || NEQ(icon_pixmap) || NEQ(icon_mask) || NEQ(icon_window)
  1998.         || NEQ(window_group))) {
  1999.  
  2000.         XSetWMHints(XtDisplay(new), XtWindow(new), &nwmshell->wm.wm_hints);
  2001.     }
  2002. #undef NEQ
  2003.  
  2004.      if (XtIsRealized(new) &&
  2005.         nwmshell->wm.transient != owmshell->wm.transient) {
  2006.          if (nwmshell->wm.transient) {
  2007.         if (!XtIsTransientShell(new) &&
  2008.             !nwmshell->shell.override_redirect &&
  2009.             nwmshell->wm.wm_hints.window_group != 
  2010.                XtUnspecifiedWindowGroup)
  2011.             XSetTransientForHint(XtDisplay(new), XtWindow(new),
  2012.                      nwmshell->wm.wm_hints.window_group);
  2013.         }
  2014.          else XDeleteProperty(XtDisplay(new), XtWindow(new),
  2015.                   XA_WM_TRANSIENT_FOR);
  2016.      }
  2017.     
  2018.     return FALSE;
  2019. }
  2020.  
  2021. /*ARGSUSED*/
  2022. static Boolean TransientSetValues(oldW, refW, newW, args, num_args)
  2023.      Widget oldW, refW, newW;
  2024.      ArgList args;        /* unused */
  2025.      Cardinal *num_args;    /* unused */
  2026. {
  2027.     TransientShellWidget old = (TransientShellWidget)oldW;
  2028.     TransientShellWidget new = (TransientShellWidget)newW;
  2029.     
  2030.     if (XtIsRealized(newW)
  2031.     && ((new->wm.transient && !old->wm.transient)
  2032.         || ((new->transient.transient_for != old->transient.transient_for)
  2033.         || (new->transient.transient_for == NULL
  2034.             && (new->wm.wm_hints.window_group
  2035.             != old->wm.wm_hints.window_group))))) {
  2036.  
  2037.     _SetTransientForHint(new, True);
  2038.     }
  2039.     return False;
  2040. }
  2041.  
  2042.  
  2043. /* ARGSUSED */
  2044. static Boolean TopLevelSetValues(oldW, refW, newW, args, num_args)
  2045.      Widget oldW, refW, newW;
  2046.      ArgList args;        /* unused */
  2047.      Cardinal *num_args;    /* unused */
  2048. {
  2049.     TopLevelShellWidget old = (TopLevelShellWidget)oldW;
  2050.     TopLevelShellWidget new = (TopLevelShellWidget)newW;
  2051.     Boolean name_changed;
  2052.  
  2053.     if (old->topLevel.icon_name != new->topLevel.icon_name) {
  2054.     XtFree((XtPointer)old->topLevel.icon_name);
  2055.     if (! new->topLevel.icon_name) new->topLevel.icon_name = "";
  2056.     new->topLevel.icon_name = XtNewString(new->topLevel.icon_name);
  2057.     name_changed = True;
  2058.     } else
  2059.     name_changed = False;
  2060.  
  2061.     if (XtIsRealized(newW)) {
  2062.     if (new->topLevel.iconic != old->topLevel.iconic) {
  2063.         if (new->topLevel.iconic)
  2064.         XIconifyWindow(XtDisplay(newW),
  2065.                    XtWindow(newW),
  2066.                    XScreenNumberOfScreen(XtScreen(newW))
  2067.                    );
  2068.         else {
  2069.         Boolean map = new->shell.popped_up;
  2070.         XtPopup(newW, XtGrabNone);
  2071.         if (map) XMapWindow(XtDisplay(newW), XtWindow(newW));
  2072.         }
  2073.     }
  2074.  
  2075.     if (!new->shell.override_redirect &&
  2076.         (name_changed ||
  2077.          (old->topLevel.icon_name_encoding
  2078.           != new->topLevel.icon_name_encoding))) {
  2079.  
  2080.         XTextProperty icon_name;
  2081.         Boolean copied = False;
  2082.  
  2083.             if (new->topLevel.icon_name_encoding == None &&
  2084.         XmbTextListToTextProperty(XtDisplay(newW),
  2085.                       (char**) &new->topLevel.icon_name,
  2086.                       1, XStdICCTextStyle,
  2087.                       &icon_name) >= Success) {
  2088.         copied = True;
  2089.         } else {
  2090.         icon_name.value = (unsigned char *)new->topLevel.icon_name;
  2091.         icon_name.encoding = new->topLevel.icon_name_encoding;
  2092.         icon_name.format = 8;
  2093.         icon_name.nitems = strlen((char *)icon_name.value);
  2094.         }
  2095.         XSetWMIconName(XtDisplay(newW), XtWindow(newW), &icon_name);
  2096.         if (copied)
  2097.         XFree((XPointer)icon_name.value);
  2098.     }
  2099.     }
  2100.     return False;
  2101. }
  2102.  
  2103.  
  2104. /*ARGSUSED*/
  2105. static Boolean ApplicationSetValues(current, request, new, args, num_args)
  2106.     Widget current, request, new;
  2107.     ArgList args;
  2108.     Cardinal *num_args;
  2109. {
  2110.     ApplicationShellWidget nw = (ApplicationShellWidget) new;
  2111.     ApplicationShellWidget cw = (ApplicationShellWidget) current;
  2112.  
  2113.     if (cw->application.argv != nw->application.argv ||
  2114.     cw->application.argc != nw->application.argc) {
  2115.  
  2116.     if (nw->application.argc > 0) {
  2117.         int i = nw->application.argc;
  2118.         char **argp = nw->application.argv + i;
  2119.         char **argv = (char **) XtMalloc((unsigned) i * sizeof(char *));
  2120.         while (--i >= 0)
  2121.         argv[i] = *--argp;
  2122.         nw->application.argv = argv;
  2123.     }
  2124.     if (cw->application.argc > 0 &&
  2125.         cw->application.argv != nw->application.argv)
  2126.         XtFree((char *) cw->application.argv);
  2127.  
  2128.     if (XtIsRealized(new) && !nw->shell.override_redirect) {
  2129.         if (nw->application.argc >= 0 && nw->application.argv)
  2130.         XSetCommand(XtDisplay(new), XtWindow(new),
  2131.                 nw->application.argv, nw->application.argc);
  2132.         else
  2133.         XDeleteProperty(XtDisplay(new), XtWindow(new), XA_WM_COMMAND);
  2134.     }
  2135.     }
  2136.     return False;
  2137. }
  2138.  
  2139. void _XtShellGetCoordinates( widget, x, y)
  2140.     Widget widget;
  2141.     Position* x;
  2142.     Position* y;
  2143. {
  2144.     ShellWidget w = (ShellWidget)widget;
  2145.     if (XtIsRealized(widget) && 
  2146.     !(w->shell.client_specified & _XtShellPositionValid)) {
  2147.     int tmpx, tmpy;
  2148.     Window tmpchild;
  2149.     (void) XTranslateCoordinates(XtDisplay(w), XtWindow(w), 
  2150.                      RootWindowOfScreen(XtScreen(w)),
  2151.                      (int) -w->core.border_width,
  2152.                      (int) -w->core.border_width,
  2153.                      &tmpx, &tmpy, &tmpchild);
  2154.     w->core.x = tmpx;
  2155.     w->core.y = tmpy;
  2156.     w->shell.client_specified |= _XtShellPositionValid;
  2157.     }
  2158.     *x = w->core.x;
  2159.     *y = w->core.y;
  2160. }
  2161.  
  2162. static void GetValuesHook(widget, args, num_args)
  2163.     Widget    widget;
  2164.     ArgList    args;
  2165.     Cardinal*    num_args;
  2166. {
  2167.     ShellWidget w = (ShellWidget) widget;
  2168.     extern void _XtCopyToArg();
  2169.  
  2170.     /* x and y resource values may be invalid after a shell resize */
  2171.     if (XtIsRealized(widget) &&
  2172.     !(w->shell.client_specified & _XtShellPositionValid)) {
  2173.     Cardinal    n;
  2174.     Position    x, y;
  2175.  
  2176.     for (n = *num_args; n; n--, args++) {
  2177.         if (strcmp(XtNx, args->name) == 0) {
  2178.         _XtShellGetCoordinates(widget, &x, &y);
  2179.         _XtCopyToArg((char *) &x, &args->value, sizeof(Position));
  2180.         } else if (strcmp(XtNy, args->name) == 0) {
  2181.         _XtShellGetCoordinates(widget, &x, &y);
  2182.         _XtCopyToArg((char *) &y, &args->value, sizeof(Position));
  2183.         }
  2184.     }
  2185.     }
  2186. }
  2187.  
  2188. static void ApplicationShellInsertChild(widget)
  2189.     Widget widget;
  2190. {
  2191.     if (! XtIsWidget(widget) && XtIsRectObj(widget)) {
  2192.     XtAppWarningMsg(XtWidgetToApplicationContext(widget),
  2193.            "invalidClass", "applicationShellInsertChild", XtCXtToolkitError,
  2194.            "ApplicationShell does not accept RectObj children; ignored",
  2195.            (String*)NULL, (Cardinal*)NULL);
  2196.     }
  2197.     else {
  2198.     (*((CompositeWidgetClass)applicationShellClassRec.core_class.
  2199.        superclass)->composite_class.insert_child) (widget);
  2200.     }
  2201. }
  2202.