home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume15 / olvwm-3.0 / part10 < prev    next >
Text File  |  1992-02-03  |  56KB  |  2,107 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!elroy.jpl.nasa.gov!ames!pasteur!nntp
  3. From: scott.oaks@East.Sun.COM (Scott Oaks)
  4. Subject: v15i156: OpenLook Virtual Window Mgr (3.0), Part10/21
  5. Message-ID: <1992Feb4.135728.7486@pasteur.Berkeley.EDU>
  6. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  7. Nntp-Posting-Host: postgres.berkeley.edu
  8. Organization: University of California, at Berkeley
  9. References: <csx-15i147-olvwm-3.0@uunet.UU.NET>
  10. Date: Tue, 4 Feb 1992 13:57:28 GMT
  11. Approved: dcmartin@msi.com
  12.  
  13. Submitted-by: scott.oaks@East.Sun.COM (Scott Oaks)
  14. Posting-number: Volume 15, Issue 156
  15. Archive-name: olvwm-3.0/part10
  16.  
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  21. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  22. # If this archive is complete, you will see the following message at the end:
  23. #        "End of archive 10 (of 21)."
  24. # Contents:  olwm.c states.c
  25. # Wrapped by dcmartin@fascet on Tue Jan 14 05:54:44 1992
  26. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  27. if test -f 'olwm.c' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'olwm.c'\"
  29. else
  30. echo shar: Extracting \"'olwm.c'\" \(18395 characters\)
  31. sed "s/^X//" >'olwm.c' <<'END_OF_FILE'
  32. X/*
  33. X *      (c) Copyright 1989, 1990 Sun Microsystems, Inc. Sun design patents
  34. X *      pending in the U.S. and foreign countries. See LEGAL_NOTICE
  35. X *      file for terms of the license.
  36. X */
  37. X
  38. X#ident    "@(#)olwm.c    1.1 olvwm version 1/3/92"
  39. X
  40. X/*
  41. X * Based on
  42. X#ident    "@(#)olwm.c    26.42    91/09/14 SMI"
  43. X *
  44. X */
  45. X
  46. X#include <errno.h>
  47. X#include <memory.h>
  48. X#include <signal.h>
  49. X#include <stdio.h>
  50. X#include <string.h>
  51. X
  52. X#include <sys/time.h>
  53. X#include <sys/types.h>
  54. X
  55. X#include <sys/param.h>
  56. X#include <sys/resource.h>
  57. X#include <sys/stat.h>
  58. X#include <sys/wait.h>
  59. X
  60. X#include <X11/Xos.h>
  61. X#include <X11/Xlib.h>
  62. X#include <X11/Xutil.h>
  63. X#include <X11/Xatom.h>
  64. X#include <X11/Xresource.h>
  65. X
  66. X#include "i18n.h"
  67. X#include "ollocale.h"
  68. X#include "events.h"
  69. X#include "mem.h"
  70. X#include "olwm.h"
  71. X#include "win.h"
  72. X#include "menu.h"
  73. X#include "defaults.h"
  74. X#include "resources.h"
  75. X#include "globals.h"
  76. X#include "group.h"
  77. X#include "slots.h"
  78. X
  79. X#include "patchlevel.h"
  80. X
  81. Xtypedef    void    (*VoidFunc)();
  82. X
  83. X/*
  84. X * Globals
  85. X */
  86. Xchar    *ProgramName;
  87. Xchar    *AppName;        /* strictly last component of ProgramName */
  88. XGlobalResourceVariables GRV;
  89. XXrmDatabase OlwmDB;
  90. X
  91. X
  92. X/*
  93. X * Global Quarks.  "Top" refers to the root of the resource name/instance 
  94. X * hierarchy.
  95. X */
  96. XXrmQuark TopClassQ;
  97. XXrmQuark TopInstanceQ;
  98. XXrmQuark OpenWinQ;
  99. X/*
  100. X * Quark for olwm instance -- we read resources with an instance name of
  101. X * olwm for backwards compatibility
  102. X */
  103. XXrmQuark OlwmQ;
  104. X
  105. X/* Current Display */
  106. XDisplay    *DefDpy;
  107. X
  108. X
  109. Xstatic Display *openDisplay();
  110. Xstatic void    parseCommandline();
  111. Xstatic void    sendSyncSignal();
  112. X
  113. X
  114. X/* Note that changes to RMTable instance names must also be made here !! */
  115. Xstatic    XrmOptionDescRec    optionTable[] = {
  116. X    { "-display",        ".display",    
  117. X        XrmoptionSepArg, (caddr_t) NULL },
  118. X    { "-f",            ".setInput",
  119. X        XrmoptionNoArg, (caddr_t) "follow" },
  120. X    { "-follow",        ".setInput", 
  121. X        XrmoptionNoArg, (caddr_t) "follow" },
  122. X    { "-c",         ".setInput",    
  123. X        XrmoptionNoArg, (caddr_t) "select" },
  124. X    { "-click",         ".setInput",    
  125. X        XrmoptionNoArg, (caddr_t) "select" },
  126. X    { "-2d",         ".use3D",    
  127. X        XrmoptionNoArg, (caddr_t) "False" },
  128. X    { "-3d",         ".use3D",    
  129. X        XrmoptionNoArg, (caddr_t) "True" },
  130. X    { "-parent",         ".reparentOK",    
  131. X        XrmoptionNoArg, (caddr_t) "False" },
  132. X    { "-orphans",         ".printOrphans", 
  133. X        XrmoptionNoArg, (caddr_t) "True" },
  134. X    { "-all",         ".printAll", 
  135. X        XrmoptionNoArg, (caddr_t) "True" },
  136. X    { "-synchronize",    ".synchronize",
  137. X        XrmoptionNoArg, (caddr_t) "True" },
  138. X    { "-debug",    ".printOrphans", XrmoptionNoArg, (caddr_t) "True" },
  139. X    { "-name",        ".name",    
  140. X        XrmoptionSepArg, (caddr_t) NULL },
  141. X    { "-bg",    "*Background",    XrmoptionSepArg, (caddr_t) NULL },
  142. X    { "-background", "*Background",    XrmoptionSepArg, (caddr_t) NULL },
  143. X    { "-fg",    "*Foreground",    XrmoptionSepArg, (caddr_t) NULL },
  144. X    { "-foreground","*Foreground",    XrmoptionSepArg, (caddr_t) NULL },
  145. X    { "-bd",    "*Background",    
  146. X        XrmoptionSepArg, (caddr_t) NULL },
  147. X    { "-bordercolor",    "*Background",    
  148. X        XrmoptionSepArg, (caddr_t) NULL },
  149. X    { "-fn",    "*TitleFont",    XrmoptionSepArg, (caddr_t) NULL },
  150. X    { "-font",    "*TitleFont",    XrmoptionSepArg, (caddr_t) NULL },
  151. X    { "-xrm",    NULL,        XrmoptionResArg, (caddr_t) NULL },
  152. X    { "-single",    ".singleScreen",XrmoptionNoArg, (caddr_t) "True" },
  153. X    { "-multi",    ".singleScreen",XrmoptionNoArg, (caddr_t) "False" },
  154. X    { "-syncpid",   ".syncPid",     XrmoptionSepArg, (caddr_t) NULL },
  155. X    { "-syncsignal",".syncSignal",  XrmoptionSepArg, (caddr_t) NULL },
  156. X    { "-depth",    "*depth",    XrmoptionSepArg, (caddr_t) NULL },
  157. X    { "-visual",    "*visual",    XrmoptionSepArg, (caddr_t) NULL },
  158. X#ifdef OW_I18N_L3
  159. X        { "-basiclocale", "*basicLocaleCL", XrmoptionSepArg, (caddr_t) NULL },
  160. X           { "-displaylang", "*displayLangCL", XrmoptionSepArg, (caddr_t) NULL },
  161. X           { "-inputlang",   "*inputLangCL", XrmoptionSepArg, (caddr_t) NULL },
  162. X           { "-numeric",     "*numericCL", XrmoptionSepArg, (caddr_t) NULL },
  163. X           { "-dateFormat",  "*dateFormatCL", XrmoptionSepArg, (caddr_t) NULL },
  164. X#endif /* OW_I18N_L3 */
  165. X};
  166. X#define OPTION_TABLE_ENTRIES (sizeof(optionTable)/sizeof(XrmOptionDescRec))
  167. X
  168. Xstatic void    initWinClasses();
  169. X
  170. X/* Child Process Handling */
  171. Xvoid HandleChildSignal();
  172. Xvoid ReapChildren();
  173. Xint DeadChildren = 0;
  174. Xint SlavePid;
  175. X
  176. X#ifdef ALLPLANES
  177. Xint allplanes;            /* server supports the ALLPLANES extension */
  178. X#endif
  179. X
  180. X#ifdef SHAPE
  181. XBool ShapeSupported;        /* server supports the SHAPE extension */
  182. Xint  ShapeEventBase;
  183. Xint  ShapeErrorBase;
  184. X#endif
  185. X
  186. X
  187. Xstatic char    **argVec;
  188. X
  189. X/*
  190. X * main    -- parse arguments, perform initialization, call event-loop
  191. X *
  192. X * The OpenLook window manager was written before the OpenLook
  193. X * spec. was completed.  Because of this, some of it works in
  194. X * an awkward way.  Specifically, the way a window's focus and
  195. X * select state is shown.
  196. X *
  197. X * For example, when a window is focused in click-to-focus mode
  198. X * the header gets highlighted, (black background, white text).
  199. X * As it was written, the titlebar window sits just inside of the 
  200. X * resize corners.  Because the OpenLook spec. requires the header to 
  201. X * be highlighted in line with the resize corners, blacking in the
  202. X * the background of the titlebar window is one pixel short in each
  203. X * direction of being a big enough highlighted area.  We can't make
  204. X * the titlebar bigger because it would then overlap the resize corners.
  205. X * Now that the spec. is complete, OLWM should be restructured.
  206. X *
  207. X * Overview:
  208. X *
  209. X *    Upon startup OLWM reparents all the client windows unless
  210. X *    the user has told it otherwise (-p option).
  211. X *     OLWM creates a frame which will contain the client window (the pane)
  212. X *      and the decoration windows (resize corners, titlebar).  The
  213. X *    titlebar window contains the pushpin, if any.
  214. X *
  215. X *    After creating the decorations for the windows OLWM sits
  216. X *     in a forever loop getting the next event and calling the
  217. X *     corresponding window's event handling routine.
  218. X *
  219. X *    Each window has associated with it an event handling 
  220. X *     routine (EventFrame, EventPushPin) which the main EventLoop
  221. X *    will call when an event happens in that window.  The event
  222. X *    handling routine will call the proper routines to move a 
  223. X *    window, create a menu, etc.
  224. X */
  225. Xmain(argc, argv)
  226. X    int argc;
  227. X    char **argv;
  228. X{
  229. X    int            ErrorHandler();
  230. X    int            ExitOLWM();
  231. X    XrmDatabase        commandlineDB = NULL;
  232. X    char            *dpystr;
  233. X
  234. X#ifdef OW_I18N_L3
  235. X#ifndef MAXPATHLEN
  236. X#define MAXPATHLEN 256
  237. X#endif
  238. X    char            *OpenWinHome;
  239. X    char            locale_dir[MAXPATHLEN+1];
  240. X    extern char        *getenv();
  241. X#endif /* OW_I18N_L3 */
  242. X
  243. X#ifdef MALLOCDEBUG
  244. X    malloc_debug(MALLOCDEBUG);
  245. X#endif /* MALLOCDEBUG */
  246. X#ifdef GPROF_HOOKS
  247. X    moncontrol(0);
  248. X#endif /* GPROF_HOOKS */
  249. X
  250. X#ifdef OW_I18N_L3
  251. X           /*
  252. X            * Even in the SUNDAE1.0 (first release) we might need the
  253. X            * dynamic locale change for window manager, since window
  254. X            * manager is usually never re-start again in one sesstion.
  255. X            * But leave static for now.
  256. X            */
  257. X           /*
  258. X            * We are setting the locale (issuing the setlocale) by
  259. X            * EffectOLLC() function, but we need to call setlocale here
  260. X            * to handle command line argument with certain locale.
  261. X            * FIX_ME! But may not work well, because we did not touch the
  262. X            * Xlib function XrmParseCommand().
  263. X            */
  264. X           if (setlocale(LC_ALL, "") == NULL) {
  265. X        /*
  266. X         * FIX_ME: Following message may be misleading,
  267. X         * because setlocale will retrieve more than just a
  268. X         * $LANG environment variable (such as $LC_CTYPE).
  269. X         * Also, later if the resource DB has a locale
  270. X         * infomation, we will use it. Hence, this setting is
  271. X         * may be only for the command line processing.
  272. X         */
  273. X        fprintf(stderr, gettext("\
  274. X        olwm: Warning: '%s' is invalid locale, using 'C' locale.\n"),
  275. X                getenv("LANG"));
  276. X        (void)setlocale(LC_ALL,"C");
  277. X    }
  278. X    if ((OpenWinHome = getenv("OPENWINHOME")) != 0)
  279. X        (void)strcpy(locale_dir,OpenWinHome);
  280. X    else
  281. X        (void)strcpy(locale_dir,"/usr");
  282. X    (void)strcat(locale_dir,"/lib/locale");
  283. X    bindtextdomain("olwm_messages",locale_dir);
  284. X           textdomain("olwm_messages");
  285. X#endif /* OW_I18N_L3 */
  286. X
  287. X    ProgramName = argv[0];
  288. X    argVec = argv;
  289. X
  290. X    /* Set up a signal handler so that if we are killed we put
  291. X     * the windows back into a usable state.  Specifically we
  292. X     * need to reset the focus so they will be able to get input.
  293. X     */
  294. X    signal(SIGHUP, (VoidFunc)ExitOLWM);
  295. X    signal(SIGINT, (VoidFunc)ExitOLWM);
  296. X    signal(SIGTERM, (VoidFunc)ExitOLWM);
  297. X    signal(SIGCHLD, HandleChildSignal);
  298. X
  299. X    /* initialize the resource manager */
  300. X    XrmInitialize();
  301. X
  302. X    /* parse the command line arguments into local tmp DB */
  303. X    parseCommandline( &argc, argv, &commandlineDB );
  304. X
  305. X    DefDpy = openDisplay(commandlineDB);
  306. X
  307. X#ifdef ALLPLANES
  308. X    {
  309. X        int tmp;
  310. X        allplanes = XAllPlanesQueryExtension(DefDpy, &tmp, &tmp);
  311. X    }
  312. X#endif /* ALLPLANES */
  313. X
  314. X
  315. X#ifdef SHAPE
  316. X    ShapeSupported = XShapeQueryExtension(DefDpy, &ShapeEventBase,
  317. X                          &ShapeErrorBase);
  318. X#endif /* SHAPE */
  319. X
  320. X    /* put all resources into global OlwmDB and set olwm variables */
  321. X    GetDefaults(DefDpy, commandlineDB);
  322. X
  323. X    /* Initialize the event handling system. */
  324. X    InitEvents(DefDpy);
  325. X    InitBindings(DefDpy);
  326. X
  327. X    /* Set up the error handling function. */
  328. X    XSetErrorHandler(ErrorHandler);
  329. X
  330. X    /* this can be useful for debuging strange client behaivior */
  331. X    if (GRV.Synchronize)
  332. X        XSynchronize(DefDpy, True);
  333. X
  334. X    /* Initialize the atoms we will need to communicate with
  335. X     * Open Look clients.
  336. X     */
  337. X    InitAtoms(DefDpy);
  338. X
  339. X    /* Initialize the database. */
  340. X    WIInit( DefDpy );
  341. X
  342. X    /* Initialise all types of window classes */
  343. X    initWinClasses(DefDpy);
  344. X
  345. X    /* Initialize client led state */
  346. X    InitClientState(DefDpy);
  347. X
  348. X    /* initialise the group module */
  349. X    GroupInit();
  350. X
  351. X    /*
  352. X     * Force child processes to disinherit the TCP file descriptor.
  353. X     * This helps shell commands forked and exec'ed from menus
  354. X     * to work properly.
  355. X     */
  356. X    if (fcntl(ConnectionNumber(DefDpy), F_SETFD, 1) == -1)
  357. X    {
  358. X        perror( gettext("olvwm: child cannot disinherit TCP fd") );
  359. X        exit( -1 );
  360. X    }
  361. X
  362. X#ifdef OW_I18N_L3
  363. X    EffectOLLC(DefDpy);
  364. X#endif /* OW_I18N_L3 */
  365. X    /* Init the global menus -- No more global menus; done in InitScreens
  366. X    InitMenus(DefDpy);
  367. X    */
  368. X
  369. X    /* init region handling code */
  370. X    InitRegions();
  371. X
  372. X    /* Init screen */
  373. X    InitScreens(DefDpy);
  374. X    InitOlvwmRC(DefDpy);
  375. X    GrabKeys(DefDpy, True);
  376. X    GrabButtons(DefDpy, True);
  377. X    ReparentScreens(DefDpy);
  378. X    if (!GRV.FocusFollowsMouse)
  379. X        ClientFocusTopmost(DefDpy, GetFirstScrInfo(), CurrentTime);
  380. X    CreateAutoRootMenu(DefDpy);
  381. X    
  382. X    /*
  383. X      * Start olwmslave - using the same args we got.
  384. X     */
  385. X    if (GRV.RunSlaveProcess)
  386. X        SlavePid = SlaveStart(argVec);
  387. X
  388. X    if (GRV.Beep != BeepNever)
  389. X        XBell(DefDpy, 100);
  390. X
  391. X    sendSyncSignal();
  392. X
  393. X    EventLoop( DefDpy );
  394. X
  395. X    /*NOTREACHED*/
  396. X}
  397. X
  398. X
  399. X/* 
  400. X * parseCommandline - parse the command line arguments into a resource
  401. X *    database
  402. X */
  403. Xstatic void
  404. XparseCommandline( argc, argv, tmpDB )
  405. Xint        *argc;
  406. Xchar        *argv[];
  407. XXrmDatabase    *tmpDB;
  408. X{
  409. X    char    instName[MAX_NAME];
  410. X    char    namestr[MAX_NAME];
  411. X    char    *type, *p;
  412. X    XrmValue val;
  413. X
  414. X    /* Extract trailing pathname component of argv[0] into AppName. */
  415. X
  416. X    AppName = strrchr(argv[0], '/');
  417. X    if (AppName == NULL)
  418. X        AppName = argv[0];
  419. X    else
  420. X        ++AppName;
  421. X
  422. X    XrmParseCommand(tmpDB, optionTable, OPTION_TABLE_ENTRIES,
  423. X            AppName, argc, argv );
  424. X
  425. X    /*
  426. X     * Initialize root instance and class quarks.  Create the instance
  427. X     * name by first looking up the "name" resource in the command line
  428. X     * database (for the -name option).  If it's not present, use AppName
  429. X     * (the trailing pathname component of argv[0]).  Then, scan it and
  430. X     * replace all illegal characters with underscores.  Note: we don't
  431. X     * use the ctype functions here, because they are internationalized.
  432. X     * In some locales, isalpha() will return true for characters that are
  433. X     * not valid in resource component names.  Thus, we must fall back to
  434. X     * standard character comparisions.
  435. X     *
  436. X     * REMIND: specifying the -name option changes the name with which 
  437. X     * resources are looked up.  But the command line options were put 
  438. X     * into the database using AppName, which is based on argv[0].  Thus, 
  439. X     * specifying -name causes all command-line args to be ignored, which 
  440. X     * is wrong.
  441. X     */
  442. X
  443. X    (void) strcpy(namestr, AppName);
  444. X    (void) strcat(namestr, ".name");
  445. X    if (XrmGetResource(*tmpDB, namestr, namestr, &type, &val)) {
  446. X        (void) strncpy(instName, (char *)val.addr, MAX_NAME);
  447. X    } else {
  448. X        (void) strncpy(instName, AppName, MAX_NAME);
  449. X    }
  450. X
  451. X    instName[MAX_NAME-1] = '\0';
  452. X    for (p=instName; *p != '\0'; ++p) {
  453. X        if (!(*p >= 'a' && *p <= 'z' ||
  454. X          *p >= 'A' && *p <= 'Z' ||
  455. X          *p >= '0' && *p <= '9' ||
  456. X          *p == '_' || *p == '-')) {
  457. X        *p = '_';
  458. X        }
  459. X    }
  460. X    TopInstanceQ = XrmStringToQuark(instName);
  461. X    TopClassQ = XrmStringToQuark("Olwm");
  462. X    OpenWinQ = XrmStringToQuark("OpenWindows");
  463. X    OlwmQ = XrmStringToQuark("olwm");
  464. X
  465. X    /* check to see if there are any arguments left unparsed */
  466. X    if ( *argc != 1 )
  467. X    {
  468. X        /* check to see if it's -help */
  469. X        if ( argv[1][0] == '-' && argv[1][1] == 'h' )
  470. X            usage(gettext("Command line arguments accepted"),gettext("are:"));
  471. X        else
  472. X            usage(gettext("Unknown argument(s)"), gettext("encountered"));
  473. X    }
  474. X}
  475. X
  476. X
  477. X/*
  478. X * openDisplay
  479. X */
  480. Xstatic Display *
  481. XopenDisplay(rdb)
  482. X    XrmDatabase rdb;
  483. X{
  484. X    char namebuf[MAX_NAME];
  485. X    char *type;
  486. X    XrmValue value;
  487. X    char *dpystr = NULL;
  488. X    char *envstr;
  489. X    Display *dpy;
  490. X
  491. X    (void) strcpy(namebuf, AppName);
  492. X    (void) strcat(namebuf, ".display");
  493. X
  494. X    if (XrmGetResource(rdb, namebuf, namebuf, &type, &value)) {
  495. X    dpystr = (char *)value.addr;
  496. X    envstr = (char *)MemAlloc(8+strlen(dpystr)+1);
  497. X    sprintf(envstr, "DISPLAY=%s", dpystr);
  498. X    putenv(envstr);
  499. X    }
  500. X
  501. X    dpy = XOpenDisplay(dpystr);
  502. X    if (dpy == NULL) {
  503. X    fprintf(stderr, gettext("%s: cannot connect to %s\n"),
  504. X        ProgramName, dpystr);
  505. X    exit(1);
  506. X    }
  507. X    return dpy;
  508. X}
  509. X
  510. X
  511. X/*
  512. X * sendSyncSignal
  513. X *
  514. X * Send a signal to the process named on the command line (if any).  Values
  515. X * for the process id and signal to send are looked up in the resource 
  516. X * database; they are settable with command-line options.  The resources are 
  517. X * looked up with the names
  518. X * 
  519. X *    <appname>.syncPid        process id
  520. X *    <appname>.syncSignal        signal to send (integer)
  521. X *
  522. X * where <appname> is the trailing pathname component of argv[0].
  523. X */
  524. Xstatic void
  525. XsendSyncSignal()
  526. X{
  527. X    char *type;
  528. X    XrmValue value;
  529. X    int pid;
  530. X    int sig = SIGALRM;
  531. X    int tmp;
  532. X    char namebuf[100];
  533. X
  534. X    (void) strcpy(namebuf, AppName);
  535. X    (void) strcat(namebuf, ".syncPid");
  536. X    if (!XrmGetResource(OlwmDB, namebuf, namebuf, &type, &value))
  537. X    return;
  538. X    pid = atoi((char *)value.addr);
  539. X    if (pid <= 0 || pid > MAXPID)
  540. X    return;
  541. X
  542. X    (void) strcpy(namebuf, AppName);
  543. X    (void) strcat(namebuf, ".syncSignal");
  544. X    if (XrmGetResource(OlwmDB, namebuf, namebuf, &type, &value)) {
  545. X    tmp = atoi((char *)value.addr);
  546. X    if (tmp > 0 && tmp <= SIGUSR2)
  547. X        sig = tmp;
  548. X    }
  549. X    (void) kill(pid, sig);
  550. X}
  551. X 
  552. X
  553. Xstatic void
  554. XinitWinClasses(dpy)
  555. XDisplay *dpy;
  556. X{
  557. X    FrameInit(dpy);
  558. X    IconInit(dpy);
  559. X    ResizeInit(dpy);
  560. X    ColormapInit(dpy);
  561. X    ButtonInit(dpy);
  562. X    BusyInit(dpy);
  563. X    MenuInit(dpy);
  564. X    PinMenuInit(dpy);
  565. X    RootInit(dpy);
  566. X    NoFocusInit(dpy);
  567. X    PushPinInit(dpy);
  568. X    PaneInit(dpy);
  569. X    IconPaneInit(dpy);
  570. X    VirtualInit(dpy);
  571. X}
  572. X
  573. X
  574. X/*
  575. X * Exit -- exit routine called by menus.
  576. X *    Kill all running applications.
  577. X */
  578. XExit(dpy)
  579. XDisplay    *dpy;
  580. X{
  581. X    extern void *ClientShutdown();
  582. X    
  583. X    SlaveStop();
  584. X    ListApply(ActiveClientList, ClientShutdown, (void *)0);
  585. X    XSync(dpy, True);
  586. X    exit(0);
  587. X    /*NOTREACHED*/
  588. X}
  589. X
  590. X
  591. Xstatic void
  592. Xcleanup()
  593. X{
  594. X    extern void *UnparentClient();
  595. X
  596. X    /*
  597. X      * If DefDpy is NULL then we didn't get to the XOpenDisplay()
  598. X     * so basically there is nothing to clean up so return.
  599. X     */
  600. X    if (DefDpy == NULL)
  601. X        return;
  602. X
  603. X    /*
  604. X     * Stop olwmslave
  605. X      */
  606. X    SlaveStop();
  607. X
  608. X    /*
  609. X     * destroy all pinned menus
  610. X     */
  611. X    DestroyPinnedMenuClients();
  612. X
  613. X    /*
  614. X     * Clean up the virtual desktop -- if we aren't left in the upper
  615. X     * left corner, nothing will start in the right place
  616. X     */
  617. X    VirtualCleanup(DefDpy);
  618. X
  619. X    /*
  620. X     * Go through the list of windows.  Unmap all icons that are on the
  621. X     * screen.  Reparent all windows back to the root, suitably offset
  622. X     * according to their window-gravities.  Also remap all non-withdrawn
  623. X     * windows, and remove all Withdrawn windows from the save-set (so
  624. X     * they don't get remapped.  REMIND: We have to do this because
  625. X     * Withdrawn windows are still left reparented inside the frame; this
  626. X     * shouldn't be the case.
  627. X     */
  628. X    ListApply(ActiveClientList,UnparentClient,NULL);
  629. X
  630. X    /* Destroy the screens - which will restore input focus, colormap,
  631. X     * and background, etc.
  632. X     */
  633. X    DestroyScreens(DefDpy);
  634. X
  635. X    XSync(DefDpy, True);
  636. X}
  637. X
  638. X
  639. X/* Clean up and then re-exec argv. */
  640. Xint
  641. XRestartOLWM()
  642. X{
  643. X    cleanup();
  644. X    execvp(argVec[0], argVec);
  645. X    ErrorGeneral("cannot restart");
  646. X    /*NOTREACHED*/
  647. X}
  648. X
  649. X
  650. X/* Clean up and then exit. */
  651. Xint
  652. XExitOLWM()
  653. X{
  654. X    cleanup();
  655. X    exit(0);
  656. X}
  657. X
  658. X
  659. X/*
  660. X * HandleChildSignal - keep track of children that have died
  661. X */
  662. Xstatic void
  663. XHandleChildSignal()
  664. X{
  665. X    /*
  666. X     * Following is only neede for SYSV but it doesn't hurt in BSD
  667. X     */
  668. X    signal(SIGCHLD, HandleChildSignal);
  669. X    ++DeadChildren;
  670. X}
  671. X
  672. X/*
  673. X * ReapChildren - wait() for all dead child processes
  674. X */
  675. Xvoid
  676. XReapChildren()
  677. X{
  678. X#ifdef SYSV
  679. X        sigset_t newmask, oldmask;
  680. X        int status;
  681. X        pid_t pid;
  682. X#else
  683. X    int oldmask;
  684. X    int pid;
  685. X    union wait status;
  686. X#endif
  687. X
  688. X#ifdef SYSV
  689. X        sigemptyset(&newmask);
  690. X        sigemptyset(&oldmask);
  691. X        sigaddset(&newmask, SIGCHLD);
  692. X        sigprocmask(SIG_BLOCK, &newmask, &oldmask);
  693. X#else
  694. X    oldmask = sigblock(sigmask(SIGCHLD));
  695. X#endif
  696. X    while (DeadChildren>0)
  697. X    {
  698. X#ifdef SYSV
  699. X                pid = waitpid(-1, &status, WNOHANG);
  700. X#else
  701. X                pid = wait3(&status, WNOHANG, (struct rusage *)0);
  702. X#endif
  703. X        /* if it's the slave process then stop its use */
  704. X        if (pid == SlavePid) 
  705. X            SlaveStopped();
  706. X
  707. X        if (pid == 0)
  708. X        {
  709. X            /* Removed error message - deemed not useful */
  710. X            DeadChildren = 0;
  711. X            break;
  712. X        }
  713. X        if (WIFSTOPPED(status))
  714. X        {
  715. X            kill(pid, SIGKILL);
  716. X        }
  717. X        --DeadChildren;
  718. X    }
  719. X#ifdef SYSV
  720. X        sigprocmask(SIG_SETMASK, &oldmask, &oldmask);
  721. X#else
  722. X        (void) sigsetmask(oldmask);
  723. X#endif
  724. X}
  725. X
  726. X/*
  727. X * usage(s1, s2)    -- print informative message regarding usage
  728. X */
  729. Xstatic
  730. Xusage(s1, s2)
  731. Xchar    *s1, *s2;
  732. X{
  733. X    fprintf(stderr, "%s %s\n", s1, s2);
  734. X    fprintf(stderr,
  735. X    "usage: %s [-2d] [-3d] [-click] [-follow] [-parent]\n", ProgramName);
  736. X    fputs(
  737. X       /* STRING_EXTRACTION - do not translate "-display" ,"-name"
  738. X        * and "-xrm", becuase those are namne of command line option.
  739. X        */
  740. X    gettext("\t[-display <display>] [-name <classname>] [-xrm <rsrcstring>]\n"),
  741. X    stderr);
  742. X    fputs("\t[-all] [-debug] [-orphans] [-synchronize] [-single]\n", stderr);
  743. X    fputs("\t[-syncpid pid] [-syncsignal signal]\n", stderr);
  744. X    exit(1);
  745. X}
  746. X
  747. END_OF_FILE
  748. if test 18395 -ne `wc -c <'olwm.c'`; then
  749.     echo shar: \"'olwm.c'\" unpacked with wrong size!
  750. fi
  751. # end of 'olwm.c'
  752. fi
  753. if test -f 'states.c' -a "${1}" != "-c" ; then 
  754.   echo shar: Will not clobber existing file \"'states.c'\"
  755. else
  756. echo shar: Extracting \"'states.c'\" \(33415 characters\)
  757. sed "s/^X//" >'states.c' <<'END_OF_FILE'
  758. X/*      (c) Copyright 1989, 1990 Sun Microsystems, Inc. Sun design patents
  759. X *      pending in the U.S. and foreign countries. See LEGAL_NOTICE
  760. X *      file for terms of the license.
  761. X */
  762. X
  763. X/* states.c - functions relating to changes in client state 
  764. X *    (Normal, Iconic, Withdrawn)
  765. X */
  766. X
  767. X#ident    "@(#)states.c    1.1 olvwm version 1/3/92"
  768. X
  769. X/*
  770. X * Based on
  771. X#ident    "@(#)states.c    26.50    91/09/14 SMI"
  772. X *
  773. X */
  774. X
  775. X#include <errno.h>
  776. X#include <stdio.h>
  777. X#include <X11/Xos.h>
  778. X#include <X11/Xlib.h>
  779. X#include <X11/Xutil.h>
  780. X#include <X11/Xatom.h>
  781. X
  782. X#include "i18n.h"
  783. X#include "ollocale.h"
  784. X#include "mem.h"
  785. X#include "olwm.h"
  786. X#include "win.h"
  787. X#include "group.h"
  788. X#include "globals.h"
  789. X#include "properties.h"
  790. X#include "virtual.h"
  791. X
  792. X/***************************************************************************
  793. X* global data
  794. X***************************************************************************/
  795. X
  796. Xextern Atom AtomWMClass;
  797. Xextern Atom AtomDecorAdd;
  798. Xextern Atom AtomDecorClose;
  799. Xextern Atom AtomDecorDel;
  800. Xextern Atom AtomDecorFooter;
  801. Xextern Atom AtomDecorHeader;
  802. Xextern Atom AtomDecorIconName;
  803. Xextern Atom AtomDecorPin;
  804. Xextern Atom AtomDecorResize;
  805. Xextern Atom AtomDeleteWindow;
  806. Xextern Atom AtomMenuFull;
  807. Xextern Atom AtomMenuLimited;
  808. Xextern Atom AtomNone;
  809. Xextern Atom AtomOlwmTimestamp;
  810. Xextern Atom AtomPinIn;
  811. Xextern Atom AtomPinOut;
  812. Xextern Atom AtomProtocols;
  813. Xextern Atom AtomSaveYourself;
  814. Xextern Atom AtomTakeFocus;
  815. Xextern Atom AtomWinAttr;
  816. Xextern Atom AtomWTBase;
  817. Xextern Atom AtomWTCmd;
  818. Xextern Atom AtomWTHelp;
  819. Xextern Atom AtomWTNotice;
  820. Xextern Atom AtomWTOther;
  821. X
  822. Xextern Client *CurrentClient;
  823. X
  824. Xextern    int    WinDrawFunc();
  825. Xextern    void    IconPaneSetPixmap();
  826. Xextern    void    IconPaneSetMask();
  827. X
  828. X/***************************************************************************
  829. X* private data
  830. X***************************************************************************/
  831. X
  832. X/* sanity checks for getting stuff out of hints */
  833. X#define IsCard16(x)    ((x) == ((unsigned short)(x)) && (x) > 0 )
  834. X#define IsInt16(x)    ((x) == ((short) (x)))
  835. X
  836. Xstatic WMDecorations BaseWindow = {
  837. X    WMDecorationCloseButton | WMDecorationResizeable | WMDecorationHeader 
  838. X    | WMDecorationIconName,
  839. X    MENU_FULL,
  840. X    0,
  841. X    PIN_IN,
  842. X    0
  843. X};
  844. X
  845. Xstatic WMDecorations CmdWindow = {
  846. X    WMDecorationPushPin | WMDecorationResizeable | WMDecorationHeader
  847. X    | WMDecorationIconName,
  848. X    MENU_LIMITED,
  849. X    0,
  850. X    PIN_IN,
  851. X    0
  852. X};
  853. X
  854. Xstatic WMDecorations NoticeWindow = {
  855. X    WMDecorationIconName,
  856. X    MENU_NONE,
  857. X    0,
  858. X    PIN_IN,
  859. X    0
  860. X};
  861. X
  862. Xstatic WMDecorations HelpWindow = {
  863. X    WMDecorationPushPin | WMDecorationHeader | WMDecorationIconName
  864. X    | WMDecorationWarpToPin,
  865. X    MENU_LIMITED,
  866. X    0,
  867. X    PIN_IN,
  868. X    0
  869. X};
  870. X
  871. Xstatic WMDecorations OtherWindow = {
  872. X    WMDecorationIconName,
  873. X    MENU_NONE,
  874. X    0, 
  875. X    PIN_IN,
  876. X    0
  877. X};
  878. X
  879. Xstatic WMDecorations TransientWindow = {
  880. X    WMDecorationResizeable | WMDecorationIconName,
  881. X    MENU_LIMITED,
  882. X    0,
  883. X    PIN_IN,
  884. X    0
  885. X};
  886. X
  887. Xstatic WMDecorations MinimalWindow = {
  888. X    WMDecorationResizeable | WMDecorationIconName,
  889. X    MENU_FULL,
  890. X    0,
  891. X    PIN_IN,
  892. X    0
  893. X};
  894. X
  895. Xstatic WMDecorations NoDecors = {
  896. X    WMNoDecor,
  897. X    MENU_NONE,
  898. X    0,
  899. X    PIN_OUT,
  900. X    0
  901. X};
  902. X
  903. Xtypedef struct {
  904. X    char *class, *instance, *name;
  905. X} minimalclosure;
  906. X
  907. X
  908. X/***************************************************************************
  909. X* private functions
  910. X***************************************************************************/
  911. X
  912. X/*
  913. X * Determine FocusMode from wmHints and protocols
  914. X */
  915. Xstatic FocusMode
  916. XfocusModeFromHintsProtocols(wmHints,protocols)
  917. X    XWMHints    *wmHints;
  918. X    int        protocols;
  919. X{
  920. X    FocusMode    focusMode;
  921. X
  922. X    if (wmHints && wmHints->input) {
  923. X        if (protocols & TAKE_FOCUS)
  924. X            focusMode = LocallyActive;    
  925. X        else
  926. X            focusMode = Passive;    
  927. X    } else { /* wmHints->input == False */
  928. X        if (protocols & TAKE_FOCUS)
  929. X            focusMode = GloballyActive;    
  930. X        else
  931. X            focusMode = NoInput;    
  932. X    }
  933. X    return focusMode;
  934. X}
  935. X
  936. X/* matchInstClass -- run through the list of names to be minimally
  937. X * decorated, and see if this window's class or instance match
  938. X * any.
  939. X *
  940. X * In olvwm, we check the name as well as class/instance
  941. X */
  942. Xstatic Bool
  943. XmatchInstClass(str,mc)
  944. Xchar *str;
  945. Xminimalclosure *mc;
  946. X{
  947. X    if ((mc->class != NULL) && (!strcmp(str, mc->class)))
  948. X    return True;
  949. X    if ((mc->instance != NULL) && (!strcmp(str, mc->instance)))
  950. X    return True;
  951. X    if ((mc->name != NULL) && (!strncmp(str, mc->name, strlen(str))))
  952. X    return True;
  953. X    return False;
  954. X}
  955. X
  956. X
  957. X/*
  958. X * getOlWinDecors - given the window attributes and decoration add/delete
  959. X *    requests, determine what kind of window (according to the OpenLook
  960. X *    kinds of windows) the client represents, and determine what sort of
  961. X *    decorations are appropriate.
  962. X */
  963. XWMDecorations *
  964. XgetOLWinDecors(dpy, win, transient, cli)
  965. XDisplay *dpy;
  966. XWindow  win;
  967. XBool    transient;
  968. XClient    *cli;
  969. X{
  970. X        WMDecorations           *decors;
  971. X    minimalclosure        mc;
  972. X    XWMHints            *wmHints = cli->wmHints;
  973. X    OLWinAttr        *winAttrs;
  974. X    Bool            oldVersion;
  975. X    int            decorFlags;
  976. X
  977. X        decors = MemNew(WMDecorations);
  978. X
  979. X    /*
  980. X     * REMIND: there is no way for a program to 
  981. X     * specify the default item, even if it should
  982. X     * specify the menu
  983. X     * so this get's initialized here
  984. X     * (one per window)
  985. X     */
  986. X    decors->def_item = 0;
  987. X
  988. X    /* if the instance or class strings match any of the names
  989. X     * listed for minimal decoration, only provide resize corners
  990. X     * and a menu.
  991. X     */
  992. X    mc.class = cli->wmClass;
  993. X    mc.instance = cli->wmInstance;
  994. X    if (!XFetchName(dpy, win, &mc.name))
  995. X        mc.name = NULL;
  996. X    if (ListApply(GRV.Minimals,matchInstClass,&mc) != NULL)
  997. X    {
  998. X            *decors = MinimalWindow;
  999. X        return decors;
  1000. X    }
  1001. X    if (ListApply(GRV.NoDecors, matchInstClass, &mc) != NULL) {
  1002. X        *decors = NoDecors;
  1003. X        if (mc.name)
  1004. X        XFree(mc.name);
  1005. X        return decors;
  1006. X    }
  1007. X    if (mc.name)
  1008. X        XFree(mc.name);
  1009. X
  1010. X#ifdef SHAPE
  1011. X    if (cli->isShaped) {
  1012. X        *decors = MinimalWindow;
  1013. X        return decors;
  1014. X    }
  1015. X#endif
  1016. X
  1017. X    oldVersion = False;
  1018. X    winAttrs = MemNew(OLWinAttr);
  1019. X
  1020. X    /*
  1021. X     * If the _OL_WIN_ATTR property is not present then make the
  1022. X     * window into a base window unless is a transient window.
  1023. X     */
  1024. X    if (!PropGetOLWinAttr(dpy,win,winAttrs,&oldVersion)) {
  1025. X        if (transient) {
  1026. X            *decors = TransientWindow;
  1027. X            if (GRV.TransientsTitled)
  1028. X                decors->flags |= WMDecorationHeader;
  1029. X        } else {
  1030. X            *decors = BaseWindow;
  1031. X        }
  1032. X    /*
  1033. X      * Else we do have that property; so interpret it
  1034. X      */
  1035. X    } else {
  1036. X        /*
  1037. X         * Choose the decor from win_type
  1038. X         */
  1039. X        if ((winAttrs->flags & WA_WINTYPE) == 0) {
  1040. X                *decors = BaseWindow;
  1041. X        } else if (winAttrs->win_type == AtomWTBase) {
  1042. X                *decors = BaseWindow;
  1043. X        } else if (winAttrs->win_type == AtomWTCmd) {
  1044. X                *decors = CmdWindow;
  1045. X        } else if (winAttrs->win_type == AtomWTHelp) {
  1046. X                *decors = HelpWindow;
  1047. X        } else if (winAttrs->win_type == AtomWTNotice) {
  1048. X                *decors = NoticeWindow;
  1049. X        } else if (winAttrs->win_type == AtomWTOther) {
  1050. X                *decors = OtherWindow;
  1051. X
  1052. X                /* 
  1053. X             * This is the only case where we look at menu type
  1054. X             */
  1055. X                if (winAttrs->flags & WA_MENUTYPE) {
  1056. X                if (winAttrs->menu_type == AtomMenuFull)
  1057. X                    decors->menu_type = MENU_FULL;
  1058. X                else if (winAttrs->menu_type == AtomMenuLimited)
  1059. X                    decors->menu_type = MENU_LIMITED;
  1060. X                else if (winAttrs->menu_type == AtomNone)
  1061. X                    decors->menu_type = MENU_NONE;
  1062. X                }
  1063. X        }
  1064. X
  1065. X        /*
  1066. X          * Backward compatibility.  If we had a old/short attribute 
  1067. X         * property, and the client specified an icon window, we're 
  1068. X         * probably dealing with an old XView client.  These clients 
  1069. X         * assume the window manager doesn't put the icon name in 
  1070. X         * the icon, so they paint it into the icon window itself.
  1071. X         * Turn off the painting of the icon name for icons of 
  1072. X         * these windows.
  1073. X         */
  1074. X        if (oldVersion && wmHints && (wmHints->flags & IconWindowHint))
  1075. X            decors->flags &= ~WMDecorationIconName;
  1076. X
  1077. X        /*
  1078. X         * Set cancel if something specified
  1079. X         */
  1080. X        if (winAttrs->flags & WA_CANCEL)
  1081. X            decors->cancel = (winAttrs->cancel != 0);
  1082. X
  1083. X        /*
  1084. X         * Set the pin state
  1085. X         */
  1086. X        if (winAttrs->flags & WA_PINSTATE) {
  1087. X            decors->pushpin_initial_state = 
  1088. X                        winAttrs->pin_initial_state;
  1089. X        } else {
  1090. X            decors->pushpin_initial_state = PIN_OUT;
  1091. X        }
  1092. X    }
  1093. X
  1094. X    /*
  1095. X      * Apply DecorAdd flags
  1096. X     */
  1097. X    if (PropGetOLDecorAdd(dpy,win,&decorFlags)) {
  1098. X        decors->flags |= decorFlags;
  1099. X    }
  1100. X
  1101. X    /*
  1102. X      * Apply DecorDel flags
  1103. X     */
  1104. X    if (PropGetOLDecorDel(dpy,win,&decorFlags)) {
  1105. X        decors->flags &= ~decorFlags;
  1106. X    }
  1107. X
  1108. X    /*
  1109. X     * If the window has no header it can't have any header
  1110. X     * decorations; ie. pushpin or a close button.
  1111. X     */
  1112. X    if (!(decors->flags & WMDecorationHeader)) {
  1113. X        decors->flags &= ~(WMDecorationHeaderDeco);
  1114. X    }
  1115. X
  1116. X        /* 
  1117. X     * If the window wants both a pushpin and a close button it
  1118. X         * only can have a pushpin.
  1119. X         */
  1120. X        if ((decors->flags & WMDecorationCloseButton) &&
  1121. X            (decors->flags & WMDecorationPushPin))
  1122. X                decors->flags &= ~(WMDecorationCloseButton);
  1123. X
  1124. X    /*
  1125. X     * Don't warp to the pin if there's no pin.
  1126. X     */
  1127. X    if (!(decors->flags & WMDecorationPushPin))
  1128. X        decors->flags &= ~WMDecorationWarpToPin;
  1129. X
  1130. X        return  decors;
  1131. X}
  1132. X
  1133. X
  1134. X/*
  1135. X * calcPosition
  1136. X *
  1137. X * Calculate the next position to place a new window.  This function places
  1138. X * all new windows on the diagonal and makes sure that there is enough room on
  1139. X * the screen for the new window's size passed in w and h.
  1140. X */
  1141. Xstatic void
  1142. XcalcPosition(dpy, screen, attrs, frame)
  1143. X    Display        *dpy;
  1144. X    int            screen;
  1145. X    XWindowAttributes    *attrs;
  1146. X    WinPaneFrame    *frame;
  1147. X{
  1148. X    int        stepValue;
  1149. X    ScreenInfo    *scrInfo;
  1150. X
  1151. X    if ((scrInfo = GetScrInfoOfScreen(screen)) == NULL) {
  1152. X        attrs->x = attrs->y = 0;
  1153. X        return;
  1154. X    }
  1155. X
  1156. X    /* if the height of the current window is too large ... */
  1157. X    if ((scrInfo->framepos + frame->core.height
  1158. X        > DisplayHeight(dpy, screen)) ||
  1159. X        (scrInfo->framepos + frame->core.width
  1160. X        > DisplayWidth(dpy, screen)))
  1161. X    {
  1162. X        scrInfo->framepos = 0;
  1163. X    }
  1164. X
  1165. X    /* REMIND this should really be based on the header height */
  1166. X    stepValue = 30;
  1167. X
  1168. X    /* we will return the current position */
  1169. X    attrs->x = attrs->y = scrInfo->framepos;
  1170. X
  1171. X    /* calculate the next return value */
  1172. X    scrInfo->framepos = scrInfo->framepos + stepValue;
  1173. X    if ((scrInfo->framepos > DisplayWidth(dpy, screen)) ||
  1174. X        (scrInfo->framepos > DisplayHeight(dpy, screen)))
  1175. X    {
  1176. X        scrInfo->framepos = 0;
  1177. X    }
  1178. X}
  1179. X
  1180. X
  1181. X/*
  1182. X * iconifyOne -- iconify one client
  1183. X */
  1184. Xstatic void *
  1185. XiconifyOne(cli, winIcon)
  1186. XClient *cli;
  1187. XWinGeneric *winIcon;
  1188. X{
  1189. X    if (cli->groupmask == GROUP_DEPENDENT)
  1190. X            RemoveSelection(cli);    /* warp if necessary */
  1191. X    else
  1192. X        DrawIconToWindowLines(cli->dpy, winIcon, cli->framewin);
  1193. X
  1194. X    UnmapWindow(cli->framewin);
  1195. X    XUnmapWindow(cli->dpy, PANEWINOFCLIENT(cli));
  1196. X    cli->framewin->fcore.panewin->pcore.pendingUnmaps++;
  1197. X    cli->wmState = IconicState;
  1198. X    ClientSetWMState(cli);
  1199. X    return NULL;
  1200. X}
  1201. X
  1202. X/* deiconifyOne -- deiconify one client
  1203. X */
  1204. Xstatic void *
  1205. XdeiconifyOne(cli, winIcon, raise)
  1206. XClient *cli;
  1207. XWinGeneric *winIcon;
  1208. XBool raise;
  1209. X{
  1210. X    if (cli->groupmask != GROUP_DEPENDENT)
  1211. X        DrawIconToWindowLines(cli->dpy, winIcon, cli->framewin);
  1212. X
  1213. X    if (raise)
  1214. X        RaiseWindow(cli->framewin);
  1215. X
  1216. X    MapWindow(cli->framewin);
  1217. X    XMapRaised(cli->dpy, PANEWINOFCLIENT(cli));
  1218. X    cli->wmState = NormalState;
  1219. X    ClientSetWMState(cli);
  1220. X    return NULL;
  1221. X}
  1222. X
  1223. X
  1224. X/*
  1225. X * markFrame
  1226. X *
  1227. X * Marks a client's frame window with a given value.  Suitable for calling by
  1228. X * ListApply or GroupApply.
  1229. X */
  1230. Xstatic void *
  1231. XmarkFrame(cli, value)
  1232. X    Client *cli;
  1233. X    int value;
  1234. X{
  1235. X    if (cli->framewin != NULL)
  1236. X    cli->framewin->core.tag = value;
  1237. X    return NULL;
  1238. X}
  1239. X
  1240. X
  1241. X/*
  1242. X * deiconifyGroup
  1243. X *
  1244. X * Deiconify a window group, preserving stacking order.  Mark all the frames
  1245. X * that are to be deiconified, then query the server for all children-of-root.
  1246. X * Walk backward through this array (i.e. from top to bottom).  For each group
  1247. X * member found, stack it just below the previous one (raise the first one to
  1248. X * the top) and deiconify it.  Finally, unmark all the frames in the group.
  1249. X * Note: this algorithm depends on having the stacking order of windows
  1250. X * preserved when the group is iconified.
  1251. X */
  1252. Xstatic void
  1253. XdeiconifyGroup(cli, winIcon)
  1254. X    Client *cli;
  1255. X    WinIconFrame* winIcon;
  1256. X{
  1257. X    Window root, parent;
  1258. X    Window *children;
  1259. X    Window prev = None;
  1260. X    unsigned int nchildren;
  1261. X    int i;
  1262. X    WinGeneric *wi;
  1263. X    XWindowChanges xwc;
  1264. X
  1265. X    GroupApply(cli->groupid, markFrame, 1, GROUP_LEADER|GROUP_DEPENDENT);
  1266. X
  1267. X    (void) XQueryTree(cli->dpy, cli->scrInfo->rootid, &root, &parent,
  1268. X              &children, &nchildren);
  1269. X
  1270. X    xwc.stack_mode = Below;
  1271. X    for (i=nchildren-1; i>=0; --i) {
  1272. X    wi = WIGetInfo(children[i]);
  1273. X    if (wi != NULL && wi->core.tag == 1) {
  1274. X        if (prev == None) {
  1275. X        RaiseWindow(wi);
  1276. X        } else {
  1277. X        xwc.sibling = prev;
  1278. X        ConfigureWindow(cli->dpy, wi,
  1279. X                 CWSibling|CWStackMode, &xwc);
  1280. X        }
  1281. X        prev = children[i];
  1282. X        deiconifyOne(wi->core.client, winIcon, False);
  1283. X    }
  1284. X    }
  1285. X
  1286. X    if (children != NULL)
  1287. X    XFree((char *)children);
  1288. X
  1289. X    GroupApply(cli->groupid, markFrame, 0, GROUP_LEADER|GROUP_DEPENDENT);
  1290. X}
  1291. X
  1292. X
  1293. X/***************************************************************************
  1294. X* global functions
  1295. X***************************************************************************/
  1296. X
  1297. X
  1298. X/*
  1299. X * StateNew -- A client is mapping a top-level window (either a new window
  1300. X *    or a Withdrawn window).  The window may become Iconic or Normal 
  1301. X *    depending on the hints.  Check to see if this window needs to be mapped
  1302. X *    and if so add the required adornments.
  1303. X *        dpy         -- display pointer
  1304. X *        rootWin        -- root window
  1305. X *                    if None will determine the root window
  1306. X *                    for the client window
  1307. X *        window         -- client's window
  1308. X *        fexisting    -- the window already exists and we
  1309. X *                   are starting olwm, so positioning should
  1310. X *                   be special-cased
  1311. X *        ourWinInfo    -- if is this one of our menu windows, this
  1312. X *            will be its WinMenu structure; this window must
  1313. X *            be a subclass of Pane
  1314. X *            If this is a VDM,  this will be a subclass of
  1315. X *            VPane
  1316. X */
  1317. XClient *
  1318. XStateNew(dpy, rootWin, window, fexisting, ourWinInfo)
  1319. XDisplay *dpy;
  1320. XWindow rootWin;
  1321. XWindow window;
  1322. XBool fexisting;
  1323. XWinPane *ourWinInfo;
  1324. X{
  1325. X    Client         *cli;
  1326. X    WinGeneric    *winGeneric;
  1327. X    WinPane        *winPane;
  1328. X    WinIconFrame    *winIcon;
  1329. X    WinPaneFrame    *winFrame;
  1330. X    WinIconPane    *winIconPane;
  1331. X    XSizeHints    *normHints;
  1332. X    Bool        preICCCM;
  1333. X    Bool        transient = False;
  1334. X    int        status;
  1335. X    int        initstate;
  1336. X    XWindowAttributes paneAttr;
  1337. X    int         screen;
  1338. X    int        tmpx, tmpy;
  1339. X    ScreenInfo     *scrInfo;
  1340. X    int        winState;
  1341. X    Window        iconWin;
  1342. X    minimalclosure    mc;
  1343. X    int        icon_x, icon_y;
  1344. X
  1345. X    /*
  1346. X     * If the window is thought to be new (i.e. if ourWinInfo is null, as
  1347. X     * it is always except for the case of pinned menus and the VDM) and
  1348. X     * the window * has already been registered in the WinInfo database
  1349. X     * and it's anything other than colormap window, then return.
  1350. X     *
  1351. X     * This is to head off (a) clients that might be mapping the olwm
  1352. X     * frame, (b) clients that map their top-level window (pane) more than
  1353. X     * once before olwm can reparent it to a frame, and (c) olwm's own 
  1354. X     * popup menus.
  1355. X     */
  1356. X    if (!ourWinInfo &&
  1357. X       (winGeneric = WIGetInfo(window)) != NULL &&
  1358. X        winGeneric->core.kind != WIN_COLORMAP) {
  1359. X        return NULL;
  1360. X    }
  1361. X
  1362. X    /* Find the screen the client window is on.
  1363. X     * If ourWinInfo is valid, use it's screen
  1364. X     * Else if know the root then use it's screen
  1365. X     * Lastly QueryTree to find out from the server
  1366. X     */
  1367. X    if (ourWinInfo) {
  1368. X        screen = ourWinInfo->core.client->scrInfo->screen;
  1369. X    } else if (rootWin != None) {
  1370. X        if ((scrInfo = GetScrInfoOfRoot(rootWin)) == NULL) 
  1371. X            return NULL;
  1372. X        screen = scrInfo->screen;
  1373. X    } else {
  1374. X        Window    root, parent, *children;
  1375. X        unsigned int    nChild;
  1376. X        Status    result;
  1377. X        
  1378. X        result  = XQueryTree(dpy, window, &root, &parent, 
  1379. X                &children, &nChild);
  1380. X
  1381. X        if (result == 0 || parent != root)
  1382. X            return NULL;
  1383. X        if ((scrInfo = GetScrInfoOfRoot(root)) == NULL) 
  1384. X            return NULL;
  1385. X        screen = scrInfo->screen;
  1386. X    }
  1387. X
  1388. X    /*
  1389. X     * Select for events on the pane right now (including StructureNotify)
  1390. X     * so that we are guaranteed to get a DestroyNotify if the window goes
  1391. X     * away.  If the window has already gone away, the call to
  1392. X     * XGetWindowAttributes below will tell us without race conditions.
  1393. X     */
  1394. X    if (!ourWinInfo)
  1395. X        XSelectInput(dpy, window,
  1396. X             PropertyChangeMask | StructureNotifyMask |
  1397. X             ColormapChangeMask | EnterWindowMask);
  1398. X
  1399. X        /* get all the info about the new pane */
  1400. X        status = XGetWindowAttributes(dpy, window, &paneAttr);
  1401. X        if ( status == 0 ) {
  1402. X            return NULL;
  1403. X        }
  1404. X
  1405. X    /*
  1406. X     * If it's an override-redirect window, or if already exists but is 
  1407. X     * unmapped, ignore it after first removing our StructureNotify 
  1408. X     * interest.
  1409. X     */
  1410. X    if (paneAttr.override_redirect ||
  1411. X        (fexisting && paneAttr.map_state != IsViewable)) {
  1412. X        if (!ourWinInfo)
  1413. X        XSelectInput(dpy, window, NoEventMask);
  1414. X        return NULL;
  1415. X    }
  1416. X
  1417. X    /* Create the client structure so we can start hooking things to it */
  1418. X    if ((cli = ClientCreate(dpy,screen)) == NULL)
  1419. X    {
  1420. X        return NULL;
  1421. X    }
  1422. X
  1423. X#ifdef SHAPE
  1424. X    {
  1425. X        Bool bshaped, cshaped;
  1426. X        int bx, by, cx, cy;
  1427. X        unsigned int bw, bh, cw, ch;
  1428. X
  1429. X        if (ShapeSupported &&
  1430. X        0 != XShapeQueryExtents(dpy, window, &bshaped, &bx, &by,
  1431. X                    &bw, &bh, &cshaped, &cx, &cy,
  1432. X                    &cw, &ch))
  1433. X        {
  1434. X        XShapeSelectInput(dpy, window, ShapeNotifyMask);
  1435. X        cli->isShaped = bshaped;
  1436. X        } else {
  1437. X        cli->isShaped = False;
  1438. X        }
  1439. X    }
  1440. X#endif /* SHAPE */
  1441. X
  1442. X    /*
  1443. X      * Turn on prop read filtering with set of available properties
  1444. X      */
  1445. X    PropSetAvailable(dpy,window);
  1446. X
  1447. X    /*
  1448. X     * Get the WM_TRANSIENT_FOR hint.  If the property exists but has a
  1449. X     * contents of zero, or the window itself, substitute the root's
  1450. X     * window ID.  This is because some (buggy) clients actually write
  1451. X     * zero in the WM_TRANSIENT_FOR property, and we want to give them
  1452. X     * transient window behavior.
  1453. X     */
  1454. X    if (!PropGetWMTransientFor(dpy,window,cli->scrInfo->rootid,
  1455. X                    &(cli->transientFor))) {
  1456. X        cli->transientFor = 0;
  1457. X        transient = False;
  1458. X    } else {
  1459. X        transient = True;
  1460. X    }
  1461. X
  1462. X    /*
  1463. X     * Get the WM_NORMAL_HINTS property.  If it's short, then we have a
  1464. X     * pre-ICCCM client on our hands, so we interpret some values 
  1465. X     * specially.
  1466. X     */
  1467. X    normHints = MemNew(XSizeHints);
  1468. X
  1469. X    if (!PropGetWMNormalHints(dpy,window,normHints,&preICCCM)) {
  1470. X        normHints->win_gravity = NorthWestGravity;
  1471. X        normHints->flags = PWinGravity;
  1472. X    }
  1473. X
  1474. X    /*
  1475. X     * We got a short property.  Assume that this is a pre-X11R4
  1476. X     * client who's using the short version of the property.  Copy
  1477. X     * the data into a correctly-sized structure.  Then, depending
  1478. X     * on the flags set, ignore the window's real geometry and use
  1479. X     * the data in the hint (but only if it passes some sanity 
  1480. X     * checking).  The sanity checking is necessary because early 
  1481. X     * versions of XView write a short property, but rely on the 
  1482. X     * window manager to look at the window's geometry instead of 
  1483. X     * at the values in the hint.
  1484. X     */
  1485. X    if (preICCCM) {
  1486. X        int     maxDpyWidth = 2*DisplayWidth(dpy,screen);
  1487. X        int     maxDpyHeight = 2*DisplayHeight(dpy,screen);
  1488. X
  1489. X        if (!fexisting
  1490. X            && (normHints->flags & (USPosition|PPosition))
  1491. X            && IsInt16(normHints->x) 
  1492. X            && IsInt16(normHints->y)
  1493. X            && normHints->x > -maxDpyWidth
  1494. X            && normHints->y > -maxDpyHeight
  1495. X            && normHints->x < maxDpyWidth
  1496. X            && normHints->y < maxDpyHeight) {
  1497. X            paneAttr.x = normHints->x;
  1498. X            paneAttr.y = normHints->y;
  1499. X        }
  1500. X        if ((normHints->flags & (USSize|PSize)) 
  1501. X            && IsCard16(normHints->width) 
  1502. X            && IsCard16(normHints->height)
  1503. X            && normHints->width >= MINSIZE
  1504. X            && normHints->height >= MINSIZE
  1505. X            && normHints->width < maxDpyWidth
  1506. X            && normHints->height < maxDpyHeight) {
  1507. X            paneAttr.width = normHints->width;
  1508. X            paneAttr.height = normHints->height;
  1509. X        }
  1510. X    }
  1511. X
  1512. X    cli->normHints = normHints;
  1513. X
  1514. X    /*
  1515. X     * Get the WM_HINTS
  1516. X     */
  1517. X    cli->wmHints = MemNew(XWMHints);
  1518. X
  1519. X    if (!PropGetWMHints(dpy,window,cli->wmHints)) {
  1520. X        cli->wmHints->flags = 0L;
  1521. X    }
  1522. X
  1523. X    /* 
  1524. X     * Get the protocols in which the client will participate
  1525. X     */
  1526. X    if (!PropGetWMProtocols(dpy,window,&(cli->protocols))) {
  1527. X        cli->protocols = 0;
  1528. X    }
  1529. X
  1530. X        /* 
  1531. X     * Figure out what focus mode this window intends
  1532. X     */
  1533. X    cli->focusMode = focusModeFromHintsProtocols(cli->wmHints,
  1534. X                             cli->protocols);
  1535. X
  1536. X    /* 
  1537. X     * Get the window class and instance strings
  1538. X     */
  1539. X    if (!PropGetWMClass(dpy,window,&(cli->wmClass),&(cli->wmInstance))) {
  1540. X        cli->wmClass = cli->wmInstance = NULL;
  1541. X    }
  1542. X
  1543. X    /* 
  1544. X     * Get the OpenLook window type and associated decorations
  1545. X     */
  1546. X    cli->wmDecors = getOLWinDecors(dpy, window, transient, cli);
  1547. X
  1548. X    /*
  1549. X     * Establish window groups.  Policy: if the window is transient, this 
  1550. X     * takes priority over any window group specified in WM_HINTS.  If
  1551. X     * it's transient, make it be part of the window group of the window 
  1552. X     * it is transient for.  Otherwise, use the group specified in
  1553. X     * WM_HINTS.  If no group is specified in WM_HINTS, consider the 
  1554. X     * window to be the leader of its own group.
  1555. X     */
  1556. X    if (transient) {
  1557. X        winGeneric = WIGetInfo(cli->transientFor);
  1558. X        if (winGeneric != NULL)
  1559. X        cli->groupid = winGeneric->core.client->groupid;
  1560. X        else
  1561. X        cli->groupid = cli->transientFor;
  1562. X    } else if ((cli->wmHints) && (cli->wmHints->flags & WindowGroupHint)) {
  1563. X        cli->groupid = cli->wmHints->window_group;
  1564. X    } else {
  1565. X        cli->groupid = window;
  1566. X    }
  1567. X
  1568. X    if (cli->groupid == window)
  1569. X        cli->groupmask = GROUP_LEADER;
  1570. X    else
  1571. X    {
  1572. X        if (((cli->wmDecors->flags & WMDecorationPushPin) &&
  1573. X         (cli->wmDecors->menu_type == MENU_LIMITED))
  1574. X        || transient)
  1575. X        {
  1576. X        cli->groupmask = GROUP_DEPENDENT;
  1577. X        }
  1578. X        else
  1579. X        {
  1580. X        cli->groupmask = GROUP_INDEPENDENT;
  1581. X        }
  1582. X    }
  1583. X    GroupAdd(cli->groupid,cli,cli->groupmask);
  1584. X
  1585. X    /* 
  1586. X     * Officially set up the frame
  1587. X     */
  1588. X    winFrame = MakeFrame(cli,window,&paneAttr);
  1589. X
  1590. X    /*
  1591. X     * If the hints don't specify a location, we choose a suitable one, 
  1592. X     * taking into account the window size and decoration sizes.
  1593. X     */
  1594. X    if ( !fexisting &&
  1595. X         !(normHints->flags & USPosition) &&
  1596. X        (!(normHints->flags & PPosition) ||
  1597. X         (GRV.PPositionCompat && paneAttr.x <= 1 && paneAttr.y <= 1)))
  1598. X    {
  1599. X        calcPosition(dpy, screen, &paneAttr, winFrame);
  1600. X    }
  1601. X    else if (!fexisting && (normHints->flags & USPosition) &&
  1602. X         !GRV.UseRelativePosition) {
  1603. X        paneAttr.x += cli->scrInfo->vdm->offsetX;
  1604. X        paneAttr.y += cli->scrInfo->vdm->offsetY;
  1605. X    }
  1606. X
  1607. X    /*
  1608. X     * See if the position needs to be constrained to a logical
  1609. X     * screen due to entries in .olvwmrc
  1610. X     */
  1611. X    if (!XFetchName(dpy, window, &mc.name))
  1612. X        mc.name = NULL;
  1613. X    icon_x = icon_y = 0;
  1614. X    if (cli->groupmask != GROUP_DEPENDENT)
  1615. X        if (cli->wmHints)
  1616. X            if (cli->wmHints->flags & IconPositionHint)
  1617. X                SearchProgString(dpy, cli->scrInfo, mc.name,
  1618. X                cli->wmInstance, cli->wmClass,
  1619. X                &paneAttr.x, &paneAttr.y,
  1620. X                    &cli->wmHints->icon_x, &cli->wmHints->icon_y);
  1621. X            else SearchProgString(dpy, cli->scrInfo, mc.name,
  1622. X                cli->wmInstance, cli->wmClass,
  1623. X                &paneAttr.x, &paneAttr.y,
  1624. X                    &icon_x, &icon_y);
  1625. X        else SearchProgString(dpy, cli->scrInfo, mc.name, NULL, NULL,
  1626. X                     &paneAttr.x, &paneAttr.y, &icon_x, &icon_y);
  1627. X    else {
  1628. X        /*
  1629. X         * Map the popup on the same screen as the group leader
  1630. X         */
  1631. X        Client *leader = GroupLeader(cli->groupid);
  1632. X        int    curScreen;
  1633. X        int    dw = DisplayWidth(dpy, screen);
  1634. X        int    dh = DisplayHeight(dpy, screen);
  1635. X
  1636. X        if (leader != NULL) {
  1637. X        curScreen = leader->framewin->core.x / dw;
  1638. X        if (leader->framewin->core.x < 0)
  1639. X            curScreen--;
  1640. X        if (paneAttr.x < 0)
  1641. X            paneAttr.x = dw + (paneAttr.x % dw) + (curScreen * dw);
  1642. X        else paneAttr.x = (paneAttr.x % dw) + (curScreen * dw);
  1643. X        curScreen = leader->framewin->core.y / dh;
  1644. X        if (leader->framewin->core.y < 0)
  1645. X            curScreen--;
  1646. X        if (paneAttr.y < 0)
  1647. X            paneAttr.y = dh + (paneAttr.y % dh) + (curScreen * dh);
  1648. X        else paneAttr.y = (paneAttr.y % dh) + (curScreen * dh);
  1649. X        }
  1650. X    }
  1651. X        
  1652. X
  1653. X    /*
  1654. X     * If a non-olwm created window then create the pane for it
  1655. X     * Else if it is a pinned menu then call the creation callback
  1656. X     * so that it can fix up its pane
  1657. X     */
  1658. X    if (ourWinInfo == NULL) {
  1659. X        winPane = MakePane(cli,winFrame,window,&paneAttr);
  1660. X    } else {
  1661. X        winPane = ourWinInfo;
  1662. X        (WinClass(winPane)->core.createcallback)(ourWinInfo,cli,
  1663. X                                winFrame);
  1664. X    }
  1665. X
  1666. X    /* 
  1667. X     * Officially set up the icon
  1668. X     */
  1669. X    winIcon = MakeIcon(cli,window,&paneAttr);
  1670. X    winIconPane = MakeIconPane(cli,winIcon,cli->wmHints,fexisting);
  1671. X
  1672. X    /* 
  1673. X     * Keep track of any subwindows that need colormap installation
  1674. X     */
  1675. X    TrackSubwindows(cli);
  1676. X
  1677. X    /* 
  1678. X     * Size and generally configure the frame window tree
  1679. X     */
  1680. X    FrameSetPosFromPane(winFrame,paneAttr.x,paneAttr.y);
  1681. X    WinCallConfig(dpy, winPane, NULL);
  1682. X
  1683. X    /* 
  1684. X     * Size and generally configure the icon window tree
  1685. X     */
  1686. X    WinCallConfig(dpy, winIconPane, NULL);
  1687. X    if (cli->wmHints != NULL && (cli->wmHints->flags & IconPositionHint))
  1688. X        IconSetPos(winIcon,cli->wmHints->icon_x,cli->wmHints->icon_y);
  1689. X    else
  1690. X        IconSetPos(winIcon,icon_x,icon_y);
  1691. X    WinCallConfig(dpy, winIcon, NULL);
  1692. X
  1693. X        /*
  1694. X     * We manually move the icon pane window, since all the configuration
  1695. X     * has been done with the icon pane parented to root.
  1696. X     */
  1697. X        WinRootPos(winIconPane, &tmpx, &tmpy);
  1698. X        XMoveWindow(dpy, winIconPane->core.self, tmpx, tmpy);
  1699. X
  1700. X    /*
  1701. X     * Set the sticky bit according to the sticky list.  We check the
  1702. X     * window's group below (stickyness is inherited by group).
  1703. X     * sticky was set when the client was created; if this is a VDM
  1704. X     * then sticky will be set to true in the callback
  1705. X     */
  1706. X    mc.class = cli->wmClass;
  1707. X    mc.instance = cli->wmInstance;
  1708. X    if (ListApply(GRV.StickyList, matchInstClass, &mc) != NULL)
  1709. X        cli->sticky = True;
  1710. X    if (mc.name)
  1711. X        XFree(mc.name);
  1712. X
  1713. X    /* 
  1714. X     * Determine the proper initial state of the window. 
  1715. X     * If the window already exists and there is a WM_STATE property 
  1716. X     * then use the state that the last window manager left there, 
  1717. X     * otherwise use WM_HINTS.
  1718. X     */
  1719. X    if (fexisting &&
  1720. X        PropGetWMState(dpy,winPane->core.self,&winState,&iconWin)) {
  1721. X        if (winState == IconicState)
  1722. X        initstate = IconicState;
  1723. X        else
  1724. X        initstate = NormalState;
  1725. X    } else {
  1726. X        /* For new windows, check the initial_state field of WM_HINTS. */
  1727. X        if (cli->wmHints && (cli->wmHints->flags & StateHint)
  1728. X        && (cli->wmHints->initial_state == IconicState))
  1729. X            initstate = IconicState;
  1730. X        else
  1731. X            initstate = NormalState;
  1732. X    }
  1733. X
  1734. X    /*
  1735. X     * Don't allow the popup into iconic state if its leader is in normal 
  1736. X     * state.
  1737. X     *
  1738. X     * Also set the sticky field of the client based on the leader
  1739. X     */
  1740. X    if (cli->groupmask == GROUP_DEPENDENT) {
  1741. X        Client *leader = GroupLeader(cli->groupid);
  1742. X        if (leader != NULL) {
  1743. X        if (leader->wmState == NormalState && initstate == IconicState)
  1744. X            initstate = NormalState;
  1745. X        cli->sticky = leader->sticky;
  1746. X        }
  1747. X    }
  1748. X
  1749. X    if (cli->sticky)
  1750. X        MakeSticky(cli, True);
  1751. X    MakeVirtual(cli);
  1752. X    ClientProcessDragDropInterest(cli, PropertyNewValue);
  1753. X
  1754. X    /*
  1755. X     * Put the window into the correct initial state
  1756. X     */
  1757. X    switch ( initstate ) {
  1758. X    case NormalState:
  1759. X        cli->wmState = NormalState;
  1760. X        MapRaised(winFrame);
  1761. X        XMapRaised(dpy, winPane->core.self);
  1762. X        if (!fexisting) {
  1763. X        FrameWarpPointer(cli);
  1764. X        if (GRV.AutoInputFocus)
  1765. X            ClientSetFocus(cli, True, CurrentTime);
  1766. X        if (GRV.AutoColorFocus)
  1767. X            LockColormap(dpy, cli, winPane);
  1768. X        }
  1769. X        break;
  1770. X    case IconicState:
  1771. X        cli->wmState = IconicState;
  1772. X        /* unmap the window in case it was mapped originally */
  1773. X        XUnmapWindow(dpy, winPane->core.self);
  1774. X        winPane->pcore.pendingUnmaps++;
  1775. X        /* dependent group followers don't get their own icons */
  1776. X        if (cli->groupmask != GROUP_DEPENDENT)
  1777. X        IconShow(cli, winIcon);
  1778. X        break;
  1779. X    }
  1780. X    ClientSetWMState(cli);
  1781. X
  1782. X    /* 
  1783. X     * Get the window state
  1784. X     */
  1785. X    ClientGetWindowState(cli);
  1786. X
  1787. X    /*
  1788. X      * Turn off prop read filtering
  1789. X      */
  1790. X    PropClearAvailable();
  1791. X
  1792. X    return cli;
  1793. X}
  1794. X
  1795. X/*
  1796. X * ReparentTree -- called at start up, this routine queries the window
  1797. X *    tree and reparents all the windows 
  1798. X */
  1799. Xvoid
  1800. XReparentTree(dpy,treeroot)
  1801. XDisplay    *dpy;
  1802. XWindow     treeroot;
  1803. X{
  1804. X    unsigned int numChildren;
  1805. X    Window *children, root, parent, w;
  1806. X    int ii;
  1807. X    Client *cli;
  1808. X
  1809. X    children = NULL;
  1810. X
  1811. X    if (XQueryTree(dpy, treeroot, &root, &parent,
  1812. X                      &children, &numChildren)) 
  1813. X    {
  1814. X        for (ii=0; ii<numChildren; ii++)
  1815. X        {
  1816. X        w = children[ii];
  1817. X        if (WIGetInfo(w) == NULL)
  1818. X        {
  1819. X                cli = StateNew(dpy, treeroot, w, True, NULL);
  1820. X            if (cli != NULL)
  1821. X            {
  1822. X            cli->framewin->fcore.panewin->pcore.pendingUnmaps++;    
  1823. X                    /* unmap because of reparent */
  1824. X            }
  1825. X        }
  1826. X        }
  1827. X    }
  1828. X
  1829. X    if (children != NULL)
  1830. X        XFree((char *)children);
  1831. X}
  1832. X
  1833. X
  1834. X/* 
  1835. X * StateNormIcon - transition a window to IconicState from NormalState
  1836. X */
  1837. Xvoid
  1838. XStateNormIcon(cli)
  1839. XClient *cli;
  1840. X{
  1841. X    WinIconFrame *winIcon = cli->iconwin;
  1842. X
  1843. X    if (winIcon == NULL)
  1844. X        return;
  1845. X
  1846. X    /* don't do some other transition */
  1847. X    if (cli->wmState != NormalState)
  1848. X        return;
  1849. X
  1850. X    /* we can't iconify if we are a dependent */
  1851. X    if (cli->groupmask == GROUP_DEPENDENT)
  1852. X        return;
  1853. X
  1854. X    /* Map the icon window */
  1855. X    IconShow(cli, winIcon);
  1856. X
  1857. X    /* iconify self and dependents */
  1858. X    if (cli->groupmask == GROUP_LEADER)
  1859. X        GroupApply(cli->groupid, iconifyOne, winIcon,
  1860. X               GROUP_LEADER|GROUP_DEPENDENT);
  1861. X    else
  1862. X        iconifyOne(cli,winIcon);
  1863. X
  1864. X    if (cli == CurrentClient && !GRV.FocusFollowsMouse)
  1865. X        ClientSetFocus(cli, False, TimeFresh(cli->iconwin));
  1866. X}
  1867. X
  1868. X/* 
  1869. X * StateIconNorm - transition a window to NormalState from IconicState 
  1870. X */
  1871. Xvoid
  1872. XStateIconNorm(cli)
  1873. XClient *cli;
  1874. X{
  1875. X    WinIconFrame *winIcon = cli->iconwin;
  1876. X
  1877. X    if (winIcon == NULL)
  1878. X        return;
  1879. X
  1880. X    /* don't do some other transition */
  1881. X    if (cli->wmState != IconicState)
  1882. X        return;
  1883. X
  1884. X    if (cli->groupmask == GROUP_LEADER)
  1885. X        deiconifyGroup(cli, winIcon);
  1886. X    else
  1887. X        deiconifyOne(cli,winIcon,True);
  1888. X
  1889. X    /* Unmap icons */
  1890. X    IconHide(cli, winIcon);
  1891. X
  1892. X    if (cli == CurrentClient && !GRV.FocusFollowsMouse)
  1893. X        ClientSetFocus(cli, True, TimeFresh(cli->framewin));
  1894. X}
  1895. X
  1896. X/*
  1897. X * StateWithdrawn - a window is being withdrawn; tear down all related
  1898. X *    structures; clear the client out of all lists it may be
  1899. X *     on; reparent the pane window
  1900. X */
  1901. Xvoid
  1902. XStateWithdrawn(cli)
  1903. XClient *cli;
  1904. X{
  1905. X    WinIconFrame *iconInfo = cli->iconwin;
  1906. X    WinPaneFrame *frameInfo = cli->framewin;
  1907. X    WinPane *paneInfo;
  1908. X    Window pane;
  1909. X    Display *dpy = cli->dpy;
  1910. X
  1911. X    if (iconInfo == NULL || frameInfo == NULL)
  1912. X        return;
  1913. X
  1914. X    paneInfo = (WinPane*)(frameInfo->fcore.panewin);
  1915. X    pane = paneInfo->core.self;
  1916. X    iconInfo = cli->iconwin;
  1917. X
  1918. X        /* Return the pointer if necessary */
  1919. X    FrameUnwarpPointer(cli);
  1920. X
  1921. X        /* Unmap the frame and pane. */
  1922. X        UnmapWindow(frameInfo);
  1923. X        XUnmapWindow(dpy, pane);
  1924. X
  1925. X    /* Unmap the icon */
  1926. X    if (iconInfo != NULL)
  1927. X        IconHide(cli, iconInfo);
  1928. X
  1929. X    /* move the pane and unparent it */
  1930. X    FrameUnparentPane(cli, frameInfo, paneInfo);
  1931. X
  1932. X    DestroyClient(cli);
  1933. X}
  1934. X
  1935. X/************************************************************************
  1936. X *        Top-Level Window Property Update Functions
  1937. X ************************************************************************/
  1938. X
  1939. X/*
  1940. X * Refresh SizeHints from WM_NORMAL_HINTS property.  The new values
  1941. X * can simply be copied into the client's normHints.
  1942. X */
  1943. Xvoid
  1944. XStateUpdateWMNormalHints(cli,event)
  1945. X    Client        *cli;
  1946. X    XPropertyEvent    *event;
  1947. X{
  1948. X    Window        pane;
  1949. X    XSizeHints    sizeHints;
  1950. X    Bool        preICCCM;
  1951. X
  1952. X    if (event->state != PropertyNewValue)
  1953. X        return;
  1954. X
  1955. X    pane = PANEWINOFCLIENT(cli);
  1956. X
  1957. X    if (!PropGetWMNormalHints(cli->dpy,pane,&sizeHints,&preICCCM))
  1958. X        return;
  1959. X
  1960. X    *(cli->normHints) = sizeHints;
  1961. X}
  1962. X
  1963. X/*
  1964. X * Reapply WMHints from the WM_HINTS property.  Ignore everything but
  1965. X * InputHint and Icon{Pixmap/Mask}Hint.
  1966. X */
  1967. Xvoid
  1968. XStateUpdateWMHints(cli,event)
  1969. X    Client        *cli;
  1970. X    XPropertyEvent    *event;
  1971. X{
  1972. X    Window        pane;
  1973. X    XWMHints    wmHints;
  1974. X    WinIconPane    *iconPane;
  1975. X    Pixmap        iconMask;
  1976. X
  1977. X    if (cli->framewin == NULL || cli->iconwin == NULL ||
  1978. X        event->state != PropertyNewValue)
  1979. X        return;
  1980. X
  1981. X    pane = PANEWINOFCLIENT(cli);
  1982. X    iconPane = (WinIconPane *)cli->iconwin->fcore.panewin;
  1983. X
  1984. X    if (!PropGetWMHints(cli->dpy,pane,&wmHints))
  1985. X        return;
  1986. X
  1987. X    if (wmHints.flags & InputHint) {
  1988. X        cli->focusMode = 
  1989. X            focusModeFromHintsProtocols(&wmHints,cli->protocols);
  1990. X    }
  1991. X
  1992. X    if (wmHints.flags & IconPixmapHint)
  1993. X        IconPaneSetPixmap(cli->dpy,iconPane,wmHints.icon_pixmap);
  1994. X    if (wmHints.flags & IconMaskHint) 
  1995. X        IconPaneSetMask(cli->dpy,iconPane,wmHints.icon_mask);
  1996. X    if (wmHints.flags & IconPixmapHint || wmHints.flags & IconMaskHint) 
  1997. X        WinDrawFunc(iconPane);
  1998. X
  1999. X    if (cli->wmHints == NULL)
  2000. X        cli->wmHints = MemNew(XWMHints);
  2001. X
  2002. X    *(cli->wmHints) = wmHints;
  2003. X}
  2004. X
  2005. X/*
  2006. X * Reset client protocols and focusMode from WM_PROTOCOLS
  2007. X */
  2008. Xvoid
  2009. XStateUpdateWMProtocols(cli,event)
  2010. X    Client        *cli;
  2011. X    XPropertyEvent    *event;
  2012. X{
  2013. X    Window        pane;
  2014. X    int        protocols;
  2015. X
  2016. X    if (cli->framewin == NULL || event->state != PropertyNewValue)
  2017. X        return;
  2018. X
  2019. X    pane = PANEWINOFCLIENT(cli);
  2020. X
  2021. X    if (!PropGetWMProtocols(cli->dpy,pane,&protocols))
  2022. X        return;
  2023. X
  2024. X    if (cli->protocols == protocols)
  2025. X        return;
  2026. X
  2027. X    cli->focusMode = focusModeFromHintsProtocols(cli->wmHints,protocols);
  2028. X    cli->protocols = protocols;
  2029. X}
  2030. X
  2031. X/*
  2032. X * StateUpdateWinAttr - reread the _OL_WIN_ATTR property. 
  2033. X *    For now just apply WA_PINSTATE.
  2034. X */
  2035. Xvoid
  2036. XStateUpdateWinAttr(cli,event)
  2037. X    Client        *cli;
  2038. X    XPropertyEvent    *event;
  2039. X{
  2040. X    OLWinAttr    winAttr;
  2041. X    Bool        old;
  2042. X    Window        pane;
  2043. X
  2044. X    if (cli->framewin == NULL || event->state != PropertyNewValue)
  2045. X        return;
  2046. X
  2047. X    pane = PANEWINOFCLIENT(cli);
  2048. X
  2049. X    if (!PropGetOLWinAttr(cli->dpy,pane,&winAttr,&old))
  2050. X        return;
  2051. X        
  2052. X    if ((winAttr.flags & WA_PINSTATE) && ClientIsPinnable(cli)) {
  2053. X        WinPushPin *pushPin = (WinPushPin *)cli->framewin->winDeco;
  2054. X        PushPinSetPinState(cli->dpy,pushPin,
  2055. X                    winAttr.pin_initial_state,False);
  2056. X    }
  2057. X}
  2058. X
  2059. X/*
  2060. X * StateUpdateDecorAdd - read the DecorAdd property and reapply it
  2061. X */
  2062. Xvoid
  2063. XStateUpdateDecorAdd(cli,event)
  2064. X    Client        *cli;
  2065. X    XPropertyEvent    *event;
  2066. X{
  2067. X    /* REMIND - this needs to be implemented */
  2068. X}
  2069. X
  2070. X/*
  2071. X * StateUpdateDecorDel - read the DecorDel property and reapply it
  2072. X */
  2073. Xvoid
  2074. XStateUpdateDecorDel(cli,event)
  2075. X    Client        *cli;
  2076. X    XPropertyEvent    *event;
  2077. X{
  2078. X    /* REMIND - this needs to be implemented */
  2079. X}
  2080. END_OF_FILE
  2081. if test 33415 -ne `wc -c <'states.c'`; then
  2082.     echo shar: \"'states.c'\" unpacked with wrong size!
  2083. fi
  2084. # end of 'states.c'
  2085. fi
  2086. echo shar: End of archive 10 \(of 21\).
  2087. cp /dev/null ark10isdone
  2088. MISSING=""
  2089. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ; do
  2090.     if test ! -f ark${I}isdone ; then
  2091.     MISSING="${MISSING} ${I}"
  2092.     fi
  2093. done
  2094. if test "${MISSING}" = "" ; then
  2095.     echo You have unpacked all 21 archives.
  2096.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2097. else
  2098.     echo You still need to unpack the following archives:
  2099.     echo "        " ${MISSING}
  2100. fi
  2101. ##  End of shell archive.
  2102. exit 0
  2103. --
  2104. Molecular Simulations, Inc.             mail: dcmartin@postgres.berkeley.edu
  2105. 796 N. Pastoria Avenue                  uucp: uwvax!ucbvax!dcmartin
  2106. Sunnyvale, California 94086             at&t: 408/522-9236
  2107.