home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume15 / olvwm-3.0 / part02 < prev    next >
Text File  |  1992-02-03  |  56KB  |  1,913 lines
  1. Newsgroups: comp.sources.x
  2. Path: uunet!usc!elroy.jpl.nasa.gov!ames!pasteur!nntp
  3. From: scott.oaks@East.Sun.COM (Scott Oaks)
  4. Subject: v15i148: OpenLook Virtual Window Mgr (3.0), Part02/21
  5. Message-ID: <1992Feb4.135406.6724@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:54:06 GMT
  11. Approved: dcmartin@msi.com
  12.  
  13. Submitted-by: scott.oaks@East.Sun.COM (Scott Oaks)
  14. Posting-number: Volume 15, Issue 148
  15. Archive-name: olvwm-3.0/part02
  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 2 (of 21)."
  24. # Contents:  patchlevel.h virtual.c
  25. # Wrapped by dcmartin@fascet on Tue Jan 14 05:54:41 1992
  26. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  27. if test -f 'patchlevel.h' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'patchlevel.h'\"
  29. else
  30. echo shar: Extracting \"'patchlevel.h'\" \(24 characters\)
  31. sed "s/^X//" >'patchlevel.h' <<'END_OF_FILE'
  32. X#define PATCHLEVELv3 0    
  33. END_OF_FILE
  34. if test 24 -ne `wc -c <'patchlevel.h'`; then
  35.     echo shar: \"'patchlevel.h'\" unpacked with wrong size!
  36. fi
  37. # end of 'patchlevel.h'
  38. fi
  39. if test -f 'virtual.c' -a "${1}" != "-c" ; then 
  40.   echo shar: Will not clobber existing file \"'virtual.c'\"
  41. else
  42. echo shar: Extracting \"'virtual.c'\" \(51849 characters\)
  43. sed "s/^X//" >'virtual.c' <<'END_OF_FILE'
  44. X/*
  45. X * (c) Copyright 1991 Scott Oaks.  See LEGAL_NOTICE file for terms of the
  46. X * license
  47. X */
  48. X
  49. X#include <stdio.h>
  50. X#include <string.h>
  51. X#include <dirent.h>
  52. X#include <X11/Xos.h>
  53. X#include <X11/Xlib.h>
  54. X#include <X11/Xutil.h>
  55. X#include <X11/keysym.h>
  56. X#include <X11/keysymdef.h>
  57. X#include <X11/Xatom.h>
  58. X
  59. X#include "i18n.h"
  60. X#include "ollocale.h"
  61. X#include "mem.h"
  62. X#include "olwm.h"
  63. X#include "st.h"
  64. X#include "globals.h"
  65. X#include "win.h"
  66. X#include "menu.h"
  67. X#include "math.h"
  68. X#include "virtual.h"
  69. X#include "patchlevel.h"
  70. X
  71. X#include "vdm.icon"
  72. X#include "vdm.mask"
  73. X
  74. X/* Class Function Vector; a virtual pane is the VDM window in which all
  75. X * the little virtual windows appear (and to which said windows are
  76. X * parented)
  77. X */
  78. Xstatic ClassVirtualPane    classVirtualPane;
  79. X
  80. X/*
  81. X * Last select time in the VDM.  This is technically different for each
  82. X * VDM, but who can click in a VDM, move between screens, and then click
  83. X * again?
  84. X */
  85. Xstatic int    lastSelectTime;
  86. X
  87. Xextern List    *ScreenInfoList;
  88. X
  89. Xextern Pixmap    VirtualGetPixmap();
  90. X
  91. Xextern Button    *MakeUpLeftButton(),*MakeLeftButton(),*MakeDownLeftButton(),
  92. X        *MakeUpButton(),*MakeHomeButton(),*MakeDownButton(),
  93. X        *MakeUpRightButton(),*MakeRightButton(),*MakeDownRightButton();
  94. X
  95. X/*
  96. X * Semantic action associated with each of the buttons above.  These must
  97. X * be in the same order as the button array; it would be better if the Button
  98. X * structure had an opaque entry for this purpose.
  99. X */
  100. X
  101. Xstatic SemanticAction    vdmButtonActions[] = {
  102. X    ACTION_UPLEFT,
  103. X    ACTION_LEFT,
  104. X    ACTION_DOWNLEFT,
  105. X    ACTION_UP,
  106. X    ACTION_HOME,
  107. X    ACTION_DOWN,
  108. X    ACTION_UPRIGHT,
  109. X    ACTION_RIGHT,
  110. X    ACTION_DOWNRIGHT,
  111. X};
  112. X
  113. Xstatic char pixdata[] = { 0xaa, 0x55 };
  114. X
  115. X#define VDMSelectMask (ButtonPressMask | ButtonReleaseMask | \
  116. X               ButtonMotionMask | ExposureMask )
  117. X
  118. X/*
  119. X * ==========================================================================
  120. X *
  121. X * VDM Utility/Drawing/Moving Functions
  122. X *
  123. X */
  124. X
  125. X/*
  126. X * Draw the dotted lines on the VDM background
  127. X */
  128. Xstatic void
  129. XdrawVDMGrid(dpy, vdm)
  130. X    Display        *dpy;
  131. X    VirtualDesktop    *vdm;
  132. X
  133. X{
  134. Xint        i;
  135. XXPoint        pts[5];
  136. Xint        dh = DisplayHeight(dpy, vdm->client->screen);
  137. Xint        dw = DisplayWidth(dpy, vdm->client->screen);
  138. XScreenInfo    *scrInfo = vdm->client->scrInfo;
  139. X
  140. X    XClearArea(dpy, PANEWINOFCLIENT(vdm->client), 0, 0, 0, 0, 0);
  141. X    XSetForeground(dpy, scrInfo->gc[VDM_GC],
  142. X           scrInfo->colorInfo.virtualGridColor);
  143. X    if (vdm->resources->grid == GridVisible) {
  144. X    XSetLineAttributes(dpy, scrInfo->gc[VDM_GC], 0, LineOnOffDash,
  145. X               CapNotLast, JoinMiter);
  146. X    pts[0].y = 0;
  147. X    pts[1].y = vdm->height;
  148. X    for (i = dw; i < vdm->absoluteWidth; i += dw) {
  149. X        pts[0].x = pts[1].x = i / vdm->resources->scale;
  150. X        XDrawLines(dpy, PANEWINOFCLIENT(vdm->client), scrInfo->gc[VDM_GC],
  151. X            pts, 2, CoordModeOrigin);
  152. X    }
  153. X    pts[0].x = 0;
  154. X    pts[1].x = vdm->width;
  155. X    for (i = dh; i < vdm->absoluteHeight; i+= dh) {
  156. X        pts[0].y = pts[1].y = i / vdm->resources->scale;
  157. X        XDrawLines(dpy, PANEWINOFCLIENT(vdm->client), scrInfo->gc[VDM_GC],
  158. X            pts, 2, CoordModeOrigin);
  159. X    }
  160. X    XSetLineAttributes(dpy, scrInfo->gc[VDM_GC], 0,
  161. X               LineSolid, CapNotLast, JoinMiter);
  162. X    }
  163. X    pts[0].x = pts[4].x = -vdm->offsetX / vdm->resources->scale;
  164. X    pts[0].y = pts[4].y = -vdm->offsetY / vdm->resources->scale;
  165. X    pts[1].x = (dw - vdm->offsetX) / vdm->resources->scale;
  166. X    pts[1].y = pts[0].y;
  167. X    pts[2].x = pts[1].x;
  168. X    pts[2].y = (dh - vdm->offsetY) / vdm->resources->scale;
  169. X    pts[3].x = pts[0].x;
  170. X    pts[3].y = pts[2].y;
  171. X    XDrawLines(dpy, PANEWINOFCLIENT(vdm->client), scrInfo->gc[VDM_GC],
  172. X        pts, 5, CoordModeOrigin);
  173. X    XSetForeground(dpy, scrInfo->gc[VDM_GC], scrInfo->colorInfo.virtualFontColor);
  174. X}
  175. X
  176. X/*
  177. X *  Function for re-placing (not replacing!) all windows when the view into
  178. X *  the desktop is changed
  179. X */
  180. Xtypedef struct _replacestickyinfo {
  181. X    struct deltas    *deltas;
  182. X    int            screen;
  183. X} replaceStickyInfo;
  184. X
  185. Xstatic void *
  186. XreplaceSticky(cli, c)
  187. X    Client        *cli;
  188. X    replaceStickyInfo    *c;
  189. X
  190. X{
  191. XWinGenericFrame    *win;
  192. X
  193. X    if (cli->screen != c->screen)
  194. X    return NULL;
  195. X    if (cli && !cli->sticky) {
  196. X    win = (WinGenericFrame *) cli->framewin;
  197. X    if (win)
  198. X        GFrameSetConfig(win, (int) (win->core.x - c->deltas->delta_x),
  199. X                (int) (win->core.y - c->deltas->delta_y),
  200. X                win->core.width, win->core.height);
  201. X    win = (WinGenericFrame *) cli->iconwin;
  202. X    if (win)
  203. X        GFrameSetConfig(win, (int) (win->core.x - c->deltas->delta_x),
  204. X                (int) (win->core.y - c->deltas->delta_y),
  205. X                win->core.width, win->core.height);
  206. X    }
  207. X    else if (cli) {
  208. X    /*
  209. X     * client is sticky; its real window stays where it is but its
  210. X     * virtual window must move
  211. X     */
  212. X    if (cli->framewin)
  213. X        XMoveWindow(cli->dpy, cli->framewin->core.virtual,
  214. X            (cli->framewin->core.x) / cli->scrInfo->vdm->resources->scale +
  215. X                cli->scrInfo->vdm->screenX,
  216. X            (cli->framewin->core.y) / cli->scrInfo->vdm->resources->scale +
  217. X                cli->scrInfo->vdm->screenY);
  218. X    if (cli->iconwin)
  219. X        XMoveWindow(cli->dpy, cli->iconwin->core.virtual,
  220. X            (cli->iconwin->core.x) / cli->scrInfo->vdm->resources->scale +
  221. X                cli->scrInfo->vdm->screenX,
  222. X            (cli->iconwin->core.y) / cli->scrInfo->vdm->resources->scale +
  223. X                cli->scrInfo->vdm->screenY);
  224. X    }
  225. X    return NULL;
  226. X}
  227. X
  228. Xstatic void
  229. XmoveDesktop(dpy, deltas, vdm)
  230. X    Display        *dpy;
  231. X    struct deltas    *deltas;
  232. X    VirtualDesktop    *vdm;
  233. X{
  234. Xextern List    *ActiveClientList;
  235. XreplaceStickyInfo    info;
  236. X
  237. X    vdm->offsetX -= deltas->delta_x;
  238. X    vdm->offsetY -= deltas->delta_y;
  239. X    vdm->screenX = -vdm->offsetX / vdm->resources->scale;
  240. X    vdm->screenY = -vdm->offsetY / vdm->resources->scale;
  241. X    info.screen = vdm->client->screen;
  242. X    info.deltas = deltas;
  243. X    ListApply(ActiveClientList, replaceSticky, &info);
  244. X    drawVDMGrid(dpy, vdm);
  245. X}
  246. X
  247. X/*
  248. X * Make sure the given deltas don't move off the screen
  249. X */
  250. Xstatic void
  251. XconstrainDeltas(dpy, vdm, deltas)
  252. X    Display        *dpy;
  253. X    VirtualDesktop    *vdm;
  254. X    struct deltas    *deltas;
  255. X{
  256. Xint    dw = DisplayWidth(dpy, vdm->client->screen);
  257. Xint    dh = DisplayHeight(dpy, vdm->client->screen);
  258. X
  259. X    if (vdm->offsetX - deltas->delta_x < dw - vdm->absoluteWidth)
  260. X    deltas->delta_x = vdm->offsetX + vdm->absoluteWidth - dw;
  261. X    else if (vdm->offsetX - deltas->delta_x > 0)
  262. X    deltas->delta_x = vdm->offsetX;
  263. X
  264. X    if (vdm->offsetY - deltas->delta_y < dh - vdm->absoluteHeight)
  265. X    deltas->delta_y = vdm->offsetY + vdm->absoluteHeight - dh;
  266. X    else if (vdm->offsetY - deltas->delta_y > 0)
  267. X    deltas->delta_y = vdm->offsetY;
  268. X}
  269. X 
  270. Xstatic Bool
  271. XvdmPerformAction(dpy, vdm, a)
  272. X    Display        *dpy;
  273. X    VirtualDesktop    *vdm;
  274. X    SemanticAction    a;
  275. X
  276. X{
  277. Xstruct deltas    deltas;
  278. Xint    dh = DisplayHeight(dpy, vdm->client->screen);
  279. Xint    dw = DisplayWidth(dpy, vdm->client->screen);
  280. X
  281. X    deltas.delta_x = deltas.delta_y = 0;
  282. X    switch(a) {
  283. X    case ACTION_UP:
  284. X        deltas.delta_y = -dh;
  285. X        break;
  286. X    case ACTION_JUMP_UP:
  287. X        deltas.delta_y = -dh * 20;
  288. X        break;
  289. X    case ACTION_HALF_UP:
  290. X        deltas.delta_y = -dh * .5;
  291. X        break;
  292. X    case ACTION_DOWN:
  293. X        deltas.delta_y = dh;
  294. X        break;
  295. X    case ACTION_JUMP_DOWN:
  296. X        deltas.delta_y = dh * 20;
  297. X        break;
  298. X    case ACTION_HALF_DOWN:
  299. X        deltas.delta_y = dh * .5;
  300. X        break;
  301. X    case ACTION_LEFT:
  302. X        deltas.delta_x = -dw;
  303. X        break;
  304. X    case ACTION_JUMP_LEFT:
  305. X        deltas.delta_x = -dw * 20;
  306. X        break;
  307. X    case ACTION_HALF_LEFT:
  308. X        deltas.delta_x = -dw * .5;
  309. X        break;
  310. X    case ACTION_RIGHT:
  311. X        deltas.delta_x = dw;
  312. X        break;
  313. X    case ACTION_JUMP_RIGHT:
  314. X        deltas.delta_x = dw * 20;
  315. X        break;
  316. X    case ACTION_HALF_RIGHT:
  317. X        deltas.delta_x = dw * .5;
  318. X        break;
  319. X    case ACTION_UPLEFT:
  320. X    case ACTION_ROW_START:
  321. X        deltas.delta_x = -dw;
  322. X        deltas.delta_y = -dh;
  323. X        break;
  324. X    case ACTION_JUMP_UPLEFT:
  325. X        deltas.delta_x = -dw * 20;
  326. X        deltas.delta_y = -dh * 20;
  327. X        break;
  328. X    case ACTION_HALF_UPLEFT:
  329. X    case ACTION_DATA_START:
  330. X        deltas.delta_x = -dw * .5;
  331. X        deltas.delta_y = -dh * .5;
  332. X        break;
  333. X    case ACTION_UPRIGHT:
  334. X        deltas.delta_x = dw;
  335. X        deltas.delta_y = -dh;
  336. X        break;
  337. X    case ACTION_JUMP_UPRIGHT:
  338. X        deltas.delta_x = dw * 20;
  339. X        deltas.delta_y = -dh * 20;
  340. X        break;
  341. X    case ACTION_HALF_UPRIGHT:
  342. X        deltas.delta_x = dw * .5;
  343. X        deltas.delta_y = -dh * .5;
  344. X        break;
  345. X    case ACTION_HOME:
  346. X        deltas.delta_x = vdm->offsetX;
  347. X        deltas.delta_y = vdm->offsetY;
  348. X        break;
  349. X    case ACTION_DOWNLEFT:
  350. X    case ACTION_ROW_END:
  351. X        deltas.delta_x = -dw;
  352. X        deltas.delta_y = dh;
  353. X        break;
  354. X    case ACTION_JUMP_DOWNLEFT:
  355. X        deltas.delta_x = -dw * 20;
  356. X        deltas.delta_y = dh * 20;
  357. X        break;
  358. X    case ACTION_HALF_DOWNLEFT:
  359. X    case ACTION_DATA_END:
  360. X        deltas.delta_x = -dw * .5;
  361. X        deltas.delta_y = dh * .5;
  362. X        break;
  363. X    case ACTION_DOWNRIGHT:
  364. X        deltas.delta_x = dw;
  365. X        deltas.delta_y = dh;
  366. X        break;
  367. X    case ACTION_JUMP_DOWNRIGHT:
  368. X        deltas.delta_x = dw * 20;
  369. X        deltas.delta_y = dh * 20;
  370. X        break;
  371. X    case ACTION_HALF_DOWNRIGHT:
  372. X        deltas.delta_x = dw * .5;
  373. X        deltas.delta_y = dh * .5;
  374. X        break;
  375. X    case ACTION_GOTO_1:
  376. X    case ACTION_GOTO_2:
  377. X    case ACTION_GOTO_3:
  378. X    case ACTION_GOTO_4:
  379. X    case ACTION_GOTO_5:
  380. X    case ACTION_GOTO_6:
  381. X    case ACTION_GOTO_7:
  382. X    case ACTION_GOTO_8:
  383. X    case ACTION_GOTO_9:
  384. X    case ACTION_GOTO_10:
  385. X        deltas.delta_x = vdm->offsetX +
  386. X                ((a - ACTION_GOTO_1) % vdm->columns) * dw;
  387. X        deltas.delta_y = vdm->offsetY +
  388. X                ((a - ACTION_GOTO_1) / vdm->columns) * dh;
  389. X        break;
  390. X    default:
  391. X        return False;
  392. X    }
  393. X    constrainDeltas(dpy, vdm, &deltas);
  394. X
  395. X    if (fabs(deltas.delta_x) < 0.1 && fabs(deltas.delta_y) < 0.1)
  396. X    return False;
  397. X    moveDesktop(dpy, &deltas, vdm);
  398. X    return True;
  399. X}
  400. X
  401. X/*
  402. X * Given root and logical coordinates relative to the VDM, turn them into
  403. X * absolute screen coordinates
  404. X */
  405. Xstatic void
  406. XtranslateVirtualCoords(vdm, root_x, root_y, x, y)
  407. X    VirtualDesktop    *vdm;
  408. X    int            *root_x, *root_y, *x, *y;
  409. X
  410. X{
  411. Xint     tx, ty, tw, th, bw, d;
  412. XWindow  root;
  413. X
  414. X    if (x)
  415. X    *x *= vdm->resources->scale;
  416. X    if (y)
  417. X    *y *= vdm->resources->scale;
  418. X    if (!root_x || !root_y)
  419. X    return;
  420. X    XGetGeometry(vdm->client->dpy, vdm->client->framewin->core.self,
  421. X         &root, &tx, &ty, &tw, &th, &bw, &d);
  422. X    *root_x -= tx;
  423. X    *root_y -= ty;
  424. X    XGetGeometry(vdm->client->dpy,
  425. X         vdm->client->framewin->fcore.panewin->core.self,
  426. X         &root, &tx, &ty, &tw, &th, &bw, &d);
  427. X    *root_x -= tx;
  428. X    *root_y -= ty;
  429. X    *root_x *= vdm->resources->scale;
  430. X    *root_x += vdm->offsetX;
  431. X    *root_y *= vdm->resources->scale;
  432. X    *root_y += vdm->offsetY;
  433. X}
  434. X
  435. Xvoid
  436. XcalculateVirtualDesktopSize(dpy, screen, v)
  437. X    Display        *dpy;
  438. X    int            screen;
  439. X    VirtualDesktop    *v;
  440. X
  441. X{
  442. X    int    width, height;
  443. X    int    dw = DisplayWidth(dpy, screen);
  444. X    int    dh = DisplayHeight(dpy, screen);
  445. X
  446. X    sscanf(v->resources->size, "%dx%d", &width, &height);
  447. X    if (width < dw)
  448. X        v->columns = width;
  449. X    else v->columns = ceil((double) width / dw);
  450. X    if (height < dh)
  451. X    v->rows = height;
  452. X    else v->rows = ceil((double) height / dh);
  453. X
  454. X    v->absoluteWidth = v->columns * dw;
  455. X    v->absoluteHeight = v->rows * dh;
  456. X
  457. X    v->screenWidth = dw / v->resources->scale;
  458. X    v->screenHeight = dh / v->resources->scale;
  459. X    if (v->resources->grid) {
  460. X        v->width = v->columns * v->screenWidth;
  461. X        v->height = v->rows * v->screenHeight;
  462. X    }
  463. X    else {
  464. X    v->width = v->absoluteWidth / v->resources->scale;
  465. X    v->height = v->absoluteHeight / v->resources->scale;
  466. X    }
  467. X}
  468. X
  469. X/*
  470. X * Allocate a virtual desktop for the given screen.
  471. X * See virtual.h for a definition of all the fields in the returned structure.
  472. X *
  473. X * This doesn't deal with the window stuff, just with the fields.  The
  474. X * window is actually created and the colors set etc. below in MakeVDM
  475. X *
  476. X */
  477. X
  478. Xstatic VirtualDesktop *
  479. XallocVirtualDesktop(dpy, screen, rsc)
  480. X    Display        *dpy;
  481. X    int            screen;
  482. X    VirtualResources    *rsc;
  483. X
  484. X{
  485. X    VirtualDesktop    *v;
  486. X
  487. X    v = (VirtualDesktop *) MemAlloc(sizeof(VirtualDesktop));
  488. X    v->resources = rsc;
  489. X    v->offsetX = 0;
  490. X    v->offsetY = 0;
  491. X    v->screenX = 0;
  492. X    v->screenY = 0;
  493. X    calculateVirtualDesktopSize(dpy, screen, v);
  494. X    return v;
  495. X}
  496. X
  497. Xstatic void
  498. XconstrainOutline(dpy, stuff, x, y, snap)
  499. X    Display    *dpy;
  500. X    VDMstuff    *stuff;
  501. X    int        x, y, snap;
  502. X{
  503. Xint    dw = DisplayWidth(dpy, stuff->vdm->client->screen);
  504. Xint    dh = DisplayHeight(dpy, stuff->vdm->client->screen);
  505. X
  506. X    if (snap) {
  507. X    stuff->vdm->screenX = (((x * stuff->vdm->resources->scale) / dw) * dw) /
  508. X                        stuff->vdm->resources->scale;
  509. X    stuff->vdm->screenY = (((y * stuff->vdm->resources->scale) / dh) * dh) /
  510. X                        stuff->vdm->resources->scale;
  511. X    }
  512. X    else {
  513. X    stuff->vdm->screenX = x - stuff->pointerX + stuff->initX;
  514. X    stuff->vdm->screenY = y - stuff->pointerY + stuff->initY;
  515. X    }
  516. X
  517. X    if (stuff->vdm->screenX < 0)
  518. X    stuff->vdm->screenX = 0;
  519. X    else if (stuff->vdm->screenX + stuff->vdm->screenWidth >
  520. X            stuff->vdm->width + stuff->vdm->resources->scale)
  521. X    stuff->vdm->screenX = (stuff->vdm->absoluteWidth - dw) /
  522. X                    stuff->vdm->resources->scale;
  523. X
  524. X    if (stuff->vdm->screenY < 0)
  525. X    stuff->vdm->screenY = 0;
  526. X    else if (stuff->vdm->screenY + stuff->vdm->screenHeight >
  527. X            stuff->vdm->height + stuff->vdm->resources->scale)
  528. X    stuff->vdm->screenY = (stuff->vdm->absoluteHeight - dh) /
  529. X                    stuff->vdm->resources->scale;
  530. X}
  531. X
  532. X/*
  533. X * ==========================================================================
  534. X *  Interposition functions for mouse dragging
  535. X */
  536. X
  537. Xstatic
  538. XvdmMoveUpdate(ev, stuff)
  539. X    XEvent    *ev;
  540. X    VDMstuff    *stuff;
  541. X{
  542. X    XDrawRectangle(stuff->vdm->client->dpy, PANEWINOFCLIENT(stuff->vdm->client),
  543. X           stuff->gc, stuff->vdm->screenX, stuff->vdm->screenY,
  544. X           stuff->vdm->screenWidth + 1, stuff->vdm->screenHeight);
  545. X    constrainOutline(stuff->vdm->client->dpy, stuff,
  546. X             ev->xmotion.x, ev->xmotion.y,
  547. X             (stuff->vdm->resources->grid) ?
  548. X            !(ev->xbutton.state & ControlMask) :
  549. X                  (ev->xbutton.state & ControlMask));
  550. X    XDrawRectangle(stuff->vdm->client->dpy, PANEWINOFCLIENT(stuff->vdm->client),
  551. X           stuff->gc, stuff->vdm->screenX, stuff->vdm->screenY,
  552. X           stuff->vdm->screenWidth + 1, stuff->vdm->screenHeight);
  553. X    stuff->numMoves++;
  554. X}
  555. X
  556. Xstatic
  557. XvdmMoveDone(ev, stuff)
  558. X    XEvent    *ev;
  559. X    VDMstuff    *stuff;
  560. X{
  561. Xstruct deltas    deltas;
  562. Xint        dw = DisplayWidth(stuff->vdm->client->dpy,
  563. X                  stuff->vdm->client->screen);
  564. Xint        dh = DisplayHeight(stuff->vdm->client->dpy,
  565. X                   stuff->vdm->client->screen);
  566. X
  567. X    UninstallInterposer();
  568. X    XDrawRectangle(stuff->vdm->client->dpy, PANEWINOFCLIENT(stuff->vdm->client),
  569. X           stuff->gc, stuff->vdm->screenX, stuff->vdm->screenY,
  570. X           stuff->vdm->screenWidth + 1, stuff->vdm->screenHeight);
  571. X    if (ev->xbutton.time - lastSelectTime <= GRV.DoubleClickTime) {
  572. X    translateVirtualCoords(stuff->vdm,
  573. X                   &ev->xbutton.x_root, &ev->xbutton.y_root,
  574. X                   &ev->xbutton.x, &ev->xbutton.y);
  575. X    VDMMoveTo(stuff->vdm->client->dpy, stuff->vdm->client,
  576. X          ev->xbutton.x_root, ev->xbutton.y_root);
  577. X    return;
  578. X    }
  579. X    lastSelectTime = ev->xbutton.time;
  580. X    if (!stuff->numMoves)
  581. X    return;
  582. X    constrainOutline(stuff->vdm->client->dpy, stuff,
  583. X             ev->xmotion.x, ev->xmotion.y,
  584. X             (stuff->vdm->resources->grid) ?
  585. X                !(ev->xbutton.state & ControlMask) :
  586. X                 (ev->xbutton.state & ControlMask));
  587. X    drawVDMGrid(stuff->vdm->client->dpy, stuff->vdm);
  588. X    deltas.delta_x = (stuff->vdm->screenX - stuff->initX) *
  589. X        stuff->vdm->resources->scale + stuff->vdm->resources->scale;
  590. X    deltas.delta_y = (stuff->vdm->screenY - stuff->initY) *
  591. X        stuff->vdm->resources->scale + stuff->vdm->resources->scale;
  592. X    if ((stuff->vdm->resources->grid && !(ev->xbutton.state & ControlMask)) ||
  593. X    (!stuff->vdm->resources->grid && (ev->xbutton.state & ControlMask))) {
  594. X    deltas.delta_x =
  595. X        (((int) (deltas.delta_x - stuff->vdm->offsetX) / dw) * dw) +
  596. X                stuff->vdm->offsetX;
  597. X    deltas.delta_y =
  598. X        (((int) (deltas.delta_y - stuff->vdm->offsetY) / dh) * dh) +
  599. X                stuff->vdm->offsetY;
  600. X    }
  601. X    moveDesktop(stuff->vdm->client->dpy, &deltas, stuff->vdm);
  602. X}
  603. X
  604. Xstatic Bool
  605. XvdmInterposer(dpy, event, w, stuff)
  606. X    Display    *dpy;
  607. X    XEvent    *event;
  608. X    WinGeneric    *w;
  609. X    VDMstuff    *stuff;
  610. X{
  611. XXEvent        nextevent;
  612. XSemanticAction    action;
  613. X
  614. X    switch(event->type) {
  615. X    case ButtonRelease:
  616. X        if (AllButtonsUp(event)) {
  617. X        vdmMoveDone(event, stuff);
  618. X        }
  619. X        break;
  620. X    case MotionNotify:
  621. X        if (!event->xmotion.same_screen)
  622. X        break;
  623. X        if (XEventsQueued(dpy, QueuedAfterReading) > 0 &&
  624. X        XPeekEvent(dpy, &nextevent), nextevent.type == MotionNotify)
  625. X        /* Ignore this event, there's another one coming */
  626. X        break;
  627. X        vdmMoveUpdate(event, stuff);
  628. X        break;
  629. X    case Expose:
  630. X        return DISPOSE_DISPATCH;
  631. X    case KeyPress:
  632. X        action = FindKeyboardAction(dpy, event);
  633. X        if (action == ACTION_STOP) {
  634. X        event->xany.type = ButtonRelease;
  635. X        event->xbutton.time = 0;
  636. X        stuff->numMoves = 0;
  637. X        vdmMoveDone(event, stuff);
  638. X        }
  639. X        else return DISPOSE_DEFER;
  640. X        break;
  641. X    default:
  642. X        return DISPOSE_DEFER;
  643. X    }
  644. X    return DISPOSE_USED;
  645. X}
  646. X
  647. X/*
  648. X * ===========================================================================
  649. X *
  650. X * Event functions for the VDM
  651. X */
  652. Xstatic
  653. XvdmExpose(dpy, event, winInfo)
  654. X    Display    *dpy;
  655. X    XEvent    *event;
  656. X    WinGeneric    *winInfo;
  657. X{
  658. XXEvent    dummy;
  659. X
  660. X    if (event->xexpose.count)
  661. X    return;
  662. X    drawVDMGrid(dpy, winInfo->core.client->scrInfo->vdm);
  663. X    while (XCheckTypedWindowEvent(dpy, event->xany.window, Expose, &dummy))
  664. X    ;    /* empty */
  665. X}
  666. X
  667. Xstatic
  668. XvdmKeyPress(dpy, ev, winInfo)
  669. X    Display    *dpy;
  670. X    XEvent    *ev;
  671. X    WinGeneric    *winInfo;
  672. X{
  673. X    if (!KeyMoveVDM(dpy, ev))
  674. X    if (GRV.Beep == BeepAlways)
  675. X        NoFocusEventBeep(dpy, ev, winInfo);
  676. X}
  677. X
  678. Xstatic
  679. XvdmConfigure(dpy, event, winInfo)
  680. X    Display        *dpy;
  681. X    XConfigureEvent    *event;
  682. X    WinVirtual        *winInfo;
  683. X{
  684. XVirtualDesktop    *vdm;
  685. Xint        dw, dh;
  686. XBool        doit;
  687. Xstruct deltas    deltas;
  688. X
  689. X    vdm = winInfo->core.client->scrInfo->vdm;
  690. X    dw = DisplayWidth(dpy, winInfo->core.client->screen);
  691. X    dh = DisplayHeight(dpy, winInfo->core.client->screen);
  692. X    vdm->width = event->width;
  693. X    vdm->height = event->height;
  694. X    if (vdm->resources->grid) {
  695. X        vdm->absoluteHeight = (vdm->height - 3) * vdm->resources->scale;
  696. X        vdm->absoluteHeight = ((vdm->absoluteHeight - 1) / dh + 1) * dh;
  697. X        vdm->absoluteWidth = (vdm->width - 3) * vdm->resources->scale;
  698. X        vdm->absoluteWidth = ((vdm->absoluteWidth - 1) / dw + 1) * dw;
  699. X        vdm->rows = ceil((double) vdm->absoluteHeight / dh);
  700. X        vdm->columns = ceil((double) vdm->absoluteWidth / dw);
  701. X    }
  702. X    else {
  703. X        vdm->absoluteHeight = vdm->height * vdm->resources->scale;
  704. X        vdm->absoluteWidth = vdm->width * vdm->resources->scale;
  705. X        vdm->rows = ceil((double) vdm->absoluteHeight / dh);
  706. X        vdm->columns = ceil((double) vdm->absoluteWidth / dw);
  707. X    }
  708. X    doit = False;
  709. X    deltas.delta_x = deltas.delta_y = 0;
  710. X    if (vdm->screenX + vdm->screenWidth > vdm->width) {
  711. X    doit = True;
  712. X    deltas.delta_x = (vdm->width - vdm->screenWidth - vdm->screenX) *
  713. X                vdm->resources->scale;
  714. X    }
  715. X    if (vdm->screenY + vdm->screenHeight > vdm->height) {
  716. X    doit = True;
  717. X    deltas.delta_y = (vdm->height - vdm->screenHeight - vdm->screenY) *
  718. X                vdm->resources->scale;
  719. X    }
  720. X    if (doit) {
  721. X    if (deltas.delta_x < 0)
  722. X        deltas.delta_x = ((int) (deltas.delta_x - vdm->resources->scale) / dw) * dw;
  723. X    else deltas.delta_x = ((int) (deltas.delta_x + vdm->resources->scale) / dw) * dw;
  724. X    if (deltas.delta_y < 0)
  725. X        deltas.delta_y = ((int) (deltas.delta_y - vdm->resources->scale) / dh) * dh;
  726. X    else deltas.delta_y = ((int) (deltas.delta_y + vdm->resources->scale) / dh) * dh;
  727. X    moveDesktop(dpy, &deltas, vdm);
  728. X    }
  729. X}
  730. X
  731. Xstatic
  732. XvdmNewConfigure(winInfo, pxcre)
  733. X    WinVirtual            *winInfo;
  734. X    XConfigureRequestEvent    *pxcre;
  735. X{
  736. Xint    oldWidth, oldHeight, oldX, oldY;
  737. XClient    *cli = winInfo->core.client;
  738. XWinPaneFrame    *winFrame = cli->framewin;
  739. X
  740. X    if (!pxcre)
  741. X    return winInfo->core.dirtyconfig;
  742. X    WinRootPos(winInfo, &oldX, &oldY);
  743. X    oldWidth = winInfo->core.width;
  744. X    oldHeight = winInfo->core.height;
  745. X
  746. X    if ((pxcre->value_mask & CWHeight) && (pxcre->height != oldHeight)) {
  747. X    winInfo->core.height = pxcre->height;
  748. X    winInfo->core.dirtyconfig |= CWHeight;
  749. X    }
  750. X    if ((pxcre->value_mask & CWWidth) && (pxcre->width != oldWidth)) {
  751. X    winInfo->core.width = pxcre->width;
  752. X    winInfo->core.dirtyconfig |= CWWidth;
  753. X    }
  754. X    /*if (pxcre->value_mask & CWBorderWidth)
  755. X    winFrame->pcore.oldBorderWidth = pxcre->border_width;*/
  756. X    if (pxcre->value_mask & (CWX|CWY))
  757. X    FrameSetPosAbsolute(winFrame,
  758. X                (pxcre->value_mask & CWX) ? (pxcre->x) : oldX,
  759. X                (pxcre->value_mask & CWY) ? (pxcre->y) : oldY);
  760. X    if (pxcre->value_mask & (CWStackMode | CWSibling))
  761. X    GFrameSetStack(winFrame, pxcre->value_mask, pxcre->detail, pxcre->above);
  762. X    return winInfo->core.dirtyconfig;
  763. X}
  764. X    
  765. Xstatic
  766. XvdmButtonPress(dpy, event, winInfo)
  767. X    Display    *dpy;
  768. X    XEvent    *event;
  769. X    WinGeneric    *winInfo;
  770. X{
  771. Xstatic VDMstuff    stuff;
  772. XSemanticAction    a;
  773. XScreenInfo    *scrInfo = winInfo->core.client->scrInfo;
  774. X
  775. X    a = ResolveMouseBinding(dpy, event, ModMaskMap[MOD_CONSTRAIN] |
  776. X                    ModMaskMap[MOD_INVERT] |
  777. X                    ModMaskMap[MOD_REDUCE]);
  778. X    switch(a) {
  779. X    case ACTION_SELECT:
  780. X            stuff.vdm = scrInfo->vdm;
  781. X            stuff.pointerX = event->xbutton.x;
  782. X            stuff.pointerY = event->xbutton.y;
  783. X            stuff.gc = scrInfo->gc[ROOT_GC];
  784. X            stuff.initX = scrInfo->vdm->screenX;
  785. X            stuff.initY = scrInfo->vdm->screenY;
  786. X            stuff.numMoves = 0;
  787. X            XDrawRectangle(stuff.vdm->client->dpy,
  788. X               PANEWINOFCLIENT(stuff.vdm->client),
  789. X                  stuff.gc, stuff.vdm->screenX, stuff.vdm->screenY,
  790. X                  stuff.vdm->screenWidth + 1, stuff.vdm->screenHeight);
  791. X            InstallInterposer(vdmInterposer, &stuff);
  792. X        break;
  793. X    case ACTION_MENU:
  794. X        MenuShowSync(dpy, winInfo, scrInfo->menuTable[MENU_VDM],
  795. X             event, NULL, NULL, False, False);
  796. X        break;
  797. X    }
  798. X}
  799. X
  800. Xstatic
  801. XvdmRedraw(dpy, win)
  802. X    Display    *dpy;
  803. X    WinGeneric    *win;
  804. X{
  805. X    drawVDMGrid(win->core.client->dpy, win->core.client->scrInfo->vdm);
  806. X}
  807. X
  808. Xstatic
  809. XvdmExit()
  810. X{
  811. X    fprintf(stderr, "VDM destroy\n");
  812. X}
  813. X
  814. Xstatic
  815. XvdmButtonRelease()
  816. X{
  817. X/*
  818. X * Need this for middle button presses
  819. X */
  820. X}
  821. X
  822. Xstatic
  823. XvdmSetConfigure(dpy, winInfo)
  824. X    Display    *dpy;
  825. X    WinVirtual    *winInfo;
  826. X{
  827. XXConfigureEvent    ce;
  828. XXWindowChanges    xwc;
  829. X
  830. X    if (winInfo->core.dirtyconfig) {
  831. X    xwc.x = winInfo->core.x;
  832. X    xwc.y = winInfo->core.y;
  833. X    xwc.width = winInfo->core.width;
  834. X    xwc.height = winInfo->core.height;
  835. X    ConfigureWindow(dpy, winInfo,
  836. X             winInfo->core.dirtyconfig, &xwc);
  837. X    winInfo->core.dirtyconfig &= ~(CWX|CWY|CWWidth|CWHeight);
  838. X    }
  839. X    ce.type = ConfigureNotify;
  840. X    ce.serial = 0L;
  841. X    ce.event = winInfo->core.self;
  842. X    ce.window = winInfo->core.self;
  843. X    WinRootPos(winInfo, &ce.x, &ce.y);
  844. X    ce.width = winInfo->core.width;
  845. X    ce.height = winInfo->core.height;
  846. X    ce.border_width = 0;
  847. X    ce.above = None;
  848. X    ce.override_redirect = False;
  849. X    /* 
  850. X     * Elsewhere, we send a configure event to the client, but since the
  851. X     * client is us, let's just call that function directly . . .
  852. X     */
  853. X    vdmConfigure(dpy, &ce, winInfo);
  854. X}
  855. X
  856. Xstatic
  857. XvdmButtonMotion()
  858. X{
  859. X/*
  860. X * Need this for middle button presses
  861. X */
  862. X}
  863. X
  864. Xstatic vdmNewpos(win, x, y)
  865. X    WinVirtual    *win;
  866. X    int        x, y;
  867. X{
  868. X    if (win->core.x != x) {
  869. X    win->core.x = x;
  870. X    win->core.dirtyconfig |= CWX;
  871. X    }
  872. X    if (win->core.y != y) {
  873. X    win->core.y = y;
  874. X    win->core.dirtyconfig |= CWY;
  875. X    }
  876. X    return win->core.dirtyconfig;
  877. X}
  878. X
  879. Xstatic vdmSelect()
  880. X{
  881. X}
  882. X
  883. Xstatic
  884. XwinIntNullFunc()
  885. X{
  886. X    fprintf(stderr, "WinIntNULL!\n");
  887. X}
  888. X
  889. X 
  890. X/*
  891. X * setsizePane - set the pane to a particular size, and initiate a reconfigure
  892. X */
  893. Xstatic int
  894. XvdmSetSize(win,w,h)
  895. XWinVirtual *win;
  896. Xint w, h;
  897. X{
  898. X    if (win->core.width != w) {
  899. X    win->core.width = w;
  900. X    win->core.dirtyconfig |= CWWidth;
  901. X    }
  902. X
  903. X    if (win->core.height != h) {
  904. X    win->core.height = h;
  905. X    win->core.dirtyconfig |= CWHeight;
  906. X    }
  907. X}   
  908. X
  909. X/*
  910. X * Callback function when VDM frame is mapped
  911. X */
  912. Xstatic
  913. XvdmSetupFrame(win, cli, frame)
  914. X    WinGeneric        *win;
  915. X    Client        *cli;
  916. X    WinGenericFrame    *frame;
  917. X{
  918. X    frame->fcore.panewin = (WinGenericPane *) win;
  919. X    cli->scrInfo->vdm->client = cli;
  920. X    cli->sticky = True;
  921. X    cli->flags |= CLOlwmOwned;
  922. X    win->core.parent = (WinGeneric *) frame;
  923. X    WinAddChild(frame, win);
  924. X    XReparentWindow(cli->dpy, win->core.self, frame->core.self,
  925. X            win->core.x, win->core.y);
  926. X    cli->wmHints->icon_pixmap = XCreateBitmapFromData(cli->dpy,
  927. X                RootWindow(cli->dpy, cli->screen), vdm_bits,
  928. X                vdm_width, vdm_height);
  929. X    cli->wmHints->icon_mask = XCreateBitmapFromData(cli->dpy,
  930. X                RootWindow(cli->dpy, cli->screen), vdmmask_bits,
  931. X                vdmmask_width, vdmmask_height);
  932. X}
  933. X
  934. Xstatic
  935. XvdmComputeWidth(dpy, event, winInfo)
  936. X    Display    *dpy;
  937. X    XEvent    *event;
  938. X    WinGeneric    *winInfo;
  939. X{
  940. X}
  941. X
  942. Xstatic
  943. XvdmComputeHeight(dpy, event, winInfo)
  944. X    Display    *dpy;
  945. X    XEvent    *event;
  946. X    WinGeneric    *winInfo;
  947. X{
  948. X}
  949. X
  950. X/*
  951. X * =======================================================================
  952. X * VDM Service Functions
  953. X */
  954. X
  955. XRedrawVDM(vdm)
  956. X    VirtualDesktop    *vdm;
  957. X{
  958. X    drawVDMGrid(vdm->client->dpy, vdm);
  959. X}
  960. X
  961. XVirtualInit(dpy)
  962. X    Display    *dpy;
  963. X
  964. X{
  965. X    classVirtualPane.core.kind = WIN_VIRTUAL;
  966. X    classVirtualPane.core.xevents[KeyPress] = vdmKeyPress;
  967. X    classVirtualPane.core.xevents[ButtonPress] = vdmButtonPress;
  968. X    classVirtualPane.core.xevents[ButtonRelease] = vdmButtonRelease;
  969. X    classVirtualPane.core.xevents[MotionNotify] = vdmButtonMotion;
  970. X    classVirtualPane.core.xevents[ConfigureNotify] = vdmConfigure;
  971. X    classVirtualPane.core.xevents[Expose] = vdmExpose;
  972. X    classVirtualPane.core.focusfunc = NULL;
  973. X    classVirtualPane.core.drawfunc = vdmRedraw;
  974. X    classVirtualPane.core.destroyfunc = vdmExit;
  975. X    classVirtualPane.core.selectfunc = vdmSelect;
  976. X    classVirtualPane.core.newconfigfunc = vdmNewConfigure;
  977. X    classVirtualPane.core.newposfunc = vdmNewpos;
  978. X    classVirtualPane.core.setconfigfunc = vdmSetConfigure;
  979. X    classVirtualPane.core.createcallback = vdmSetupFrame;
  980. X    classVirtualPane.core.heightfunc = vdmComputeHeight;
  981. X    classVirtualPane.core.widthfunc = vdmComputeWidth;
  982. X    classVirtualPane.pcore.setsizefunc = vdmSetSize;
  983. X}
  984. X
  985. X/*
  986. X * Create an instance of the VDM -- this creates the logical virtual desktop
  987. X * and then creates the VDM representation of it.
  988. X */
  989. X
  990. XMakeVDM(dpy, scrInfo, client, rsc)
  991. X    Display        *dpy;
  992. X    ScreenInfo        *scrInfo;
  993. X    Client        *client;
  994. X    VirtualResources    *rsc;
  995. X
  996. X{
  997. Xstatic XTextProperty    wName = {(unsigned char *) "Virtual Desktop",
  998. X                    XA_STRING, 8, 15 };
  999. Xstatic XTextProperty    iName = {(unsigned char *) "Desktop",
  1000. X                    XA_STRING, 8, 7 };
  1001. X    XSetWindowAttributes attr;
  1002. X    XSizeHints *sizeHints;
  1003. X    XWMHints *wmHints;
  1004. X    XClassHint *classHints;
  1005. X    unsigned attrMask;
  1006. X    int    win;
  1007. X    WinVirtual        *w;
  1008. X    VirtualDesktop    *v;
  1009. X    char    title[20];
  1010. X    Button    *vdmButtons[9];
  1011. X
  1012. X    v = allocVirtualDesktop(dpy, scrInfo->screen, rsc);
  1013. X    w = MemNew(WinVirtual);
  1014. X
  1015. X    sizeHints = XAllocSizeHints();
  1016. X    sizeHints->flags = PBaseSize;
  1017. X    sizeHints->base_width = v->width;
  1018. X    sizeHints->base_height = v->height;
  1019. X    sizeHints->min_width = v->screenWidth;
  1020. X    sizeHints->min_height = v->screenHeight;
  1021. X    if (rsc->grid) {
  1022. X    sizeHints->flags = PMinSize | PResizeInc;
  1023. X        sizeHints->width_inc = v->screenWidth;
  1024. X        sizeHints->height_inc = v->screenHeight;
  1025. X    }
  1026. X    else sizeHints->flags = PMinSize;
  1027. X
  1028. X    /* REMIND Add an icon file attrbute */
  1029. X    wmHints = XAllocWMHints();
  1030. X    if (GRV.VirtualIconic)
  1031. X    wmHints->initial_state = IconicState;
  1032. X    else wmHints->initial_state = NormalState;
  1033. X    wmHints->flags = StateHint | InputHint | IconWindowHint;
  1034. X    wmHints->input = False;
  1035. X
  1036. X    wmHints->icon_window = XCreateSimpleWindow(dpy,
  1037. X                RootWindow(dpy, scrInfo->screen),
  1038. X                0, 0, vdm_width, vdm_height, 0, 0,
  1039. X                scrInfo->colorInfo.workspaceRootPixel);
  1040. X
  1041. X    classHints = XAllocClassHint();
  1042. X    classHints->res_name = "virtualDesktop";
  1043. X    classHints->res_class = "olvwm";
  1044. X 
  1045. X    attrMask = CWEventMask;
  1046. X
  1047. X    if (DefaultDepth(dpy, scrInfo->screen) == 1) {
  1048. X        attrMask |= CWBackPixmap;
  1049. X        attr.background_pixmap = XCreatePixmapFromBitmapData(dpy,
  1050. X            RootWindow(dpy, scrInfo->screen),
  1051. X            pixdata, 8, 2,
  1052. X            scrInfo->colorInfo.fgColor, scrInfo->colorInfo.bgColor,
  1053. X            1);
  1054. X    }
  1055. X    else if (!rsc->background) {
  1056. X        attrMask |= CWBackPixel;
  1057. X        attr.background_pixel = scrInfo->colorInfo.virtualBgColor;
  1058. X    }
  1059. X    else {
  1060. X    attrMask |= CWBackPixmap;
  1061. X    attr.background_pixmap = VirtualGetPixmap(dpy, scrInfo, rsc->background);
  1062. X    }
  1063. X    attr.event_mask = ExposureMask | ButtonPressMask | ButtonReleaseMask |
  1064. X              ButtonMotionMask | KeyPressMask;
  1065. X
  1066. X    w->class = &classVirtualPane;
  1067. X    w->core.kind = WIN_VIRTUAL;
  1068. X    w->core.children = NULL;
  1069. X    w->core.client = client;
  1070. X    w->core.x = sizeHints->x;
  1071. X    w->core.y = sizeHints->y;
  1072. X    w->core.width = sizeHints->base_width;
  1073. X    w->core.height = sizeHints->base_height;
  1074. X    w->core.dirtyconfig = CWX | CWY | CWWidth | CWHeight;
  1075. X    w->core.exposures = NULL;
  1076. X    w->core.helpstring = "olvwm:VDM";
  1077. X    w->core.colormap = NULL;        /* initialized in callback */
  1078. X
  1079. X    w->core.self = XCreateWindow(dpy, RootWindow(dpy, scrInfo->screen),
  1080. X                    sizeHints->x, sizeHints->y,
  1081. X                        sizeHints->base_width, sizeHints->base_height,
  1082. X                0,
  1083. X            /* REMIND olwm visual affects this? */
  1084. X                        DefaultDepth(dpy, scrInfo->screen), InputOutput,
  1085. X                        CopyFromParent, attrMask, &attr);
  1086. X    XSetWMProperties(dpy, w->core.self, &wName, &iName, NULL, 0,
  1087. X                 sizeHints, wmHints, classHints);
  1088. X
  1089. X    WIInstallInfo((WinGeneric *)w);
  1090. X    scrInfo->vdm = v;
  1091. X    v->client = StateNew(dpy, RootWindow(dpy, scrInfo->screen), w->core.self, False, w);
  1092. X    /*
  1093. X     * Sigh -- the call back was called before the icon frame was created
  1094. X     * so we can't do this there like we'd like to.  And it was called
  1095. X     * after StateNew processes the wmHints . . .
  1096. X     */
  1097. X    ((WinIconPane *) v->client->iconwin->fcore.panewin)->iconPixmap =
  1098. X                    v->client->wmHints->icon_pixmap;
  1099. X    ((WinIconPane *) v->client->iconwin->fcore.panewin)->iconMask =
  1100. X                    v->client->wmHints->icon_mask;
  1101. X    VirtualSetGeometry(v->client->framewin,
  1102. X               v->client->scrInfo->vdm->resources->geometry);
  1103. X    VirtualSetGeometry(v->client->iconwin,
  1104. X               v->client->scrInfo->vdm->resources->iconGeometry);
  1105. X
  1106. X    /*
  1107. X     * Make the VDMs menu
  1108. X     */
  1109. X    sprintf(title, "OLVWM 3.%0d", PATCHLEVELv3);
  1110. X    vdmButtons[0] = MakeUpLeftButton(dpy, scrInfo);
  1111. X    vdmButtons[1] = MakeLeftButton(dpy, scrInfo);
  1112. X    vdmButtons[2] = MakeDownLeftButton(dpy, scrInfo);
  1113. X    vdmButtons[3] = MakeUpButton(dpy, scrInfo);
  1114. X    vdmButtons[4] = MakeHomeButton(dpy, scrInfo);
  1115. X    vdmButtons[5] = MakeDownButton(dpy, scrInfo);
  1116. X    vdmButtons[6] = MakeUpRightButton(dpy, scrInfo);
  1117. X    vdmButtons[7] = MakeRightButton(dpy, scrInfo);
  1118. X    vdmButtons[8] = MakeDownRightButton(dpy, scrInfo);
  1119. X    scrInfo->menuTable[MENU_VDM] = CreateMenu(strdup(title), vdmButtons,
  1120. X                sizeof(vdmButtons)/sizeof(vdmButtons[0]),
  1121. X                True, "olvwm:MotionMenu");
  1122. X    scrInfo->menuTable[MENU_VDM]->prefColSize = 3;
  1123. X    scrInfo->menuTable[MENU_VDM]->buttonDefault = 4;
  1124. X    (void) MenuInfoCreate(scrInfo->menuCache, scrInfo->rootwin,
  1125. X                  scrInfo->menuTable[MENU_VDM], 1);
  1126. X
  1127. X    XFree(sizeHints);
  1128. X    XFree(wmHints);
  1129. X    XFree(classHints);
  1130. X}
  1131. X
  1132. X/*
  1133. X * Create the virtual representation of the client's frame and icon
  1134. X */
  1135. XMakeVirtual(cli)
  1136. X    Client    *cli;
  1137. X
  1138. X{
  1139. Xint    width, height;
  1140. Xint    x, y;
  1141. XWindow    virtual;
  1142. X
  1143. X    /*
  1144. X     * Subtract 1 for those window borders
  1145. X     */
  1146. X    width = cli->framewin->core.width / cli->scrInfo->vdm->resources->scale - 1;
  1147. X    height = cli->framewin->core.height / cli->scrInfo->vdm->resources->scale-1;
  1148. X
  1149. X    x = cli->framewin->core.x / cli->scrInfo->vdm->resources->scale +
  1150. X            cli->scrInfo->vdm->screenX;
  1151. X    y = cli->framewin->core.y / cli->scrInfo->vdm->resources->scale +
  1152. X            cli->scrInfo->vdm->screenY;
  1153. X
  1154. X    if (width <= 0)
  1155. X    width = 1;
  1156. X    if (height <= 0)
  1157. X    height = 1;
  1158. X    virtual = XCreateSimpleWindow(cli->dpy,
  1159. X        PANEWINOFCLIENT(cli->scrInfo->vdm->client),
  1160. X        x, y, width, height, 1, cli->scrInfo->colorInfo.borderColor,
  1161. X        cli->scrInfo->colorInfo.virtualFgColor);
  1162. X    if (PANEWINOFCLIENT(cli) != PANEWINOFCLIENT(cli->scrInfo->vdm->client))
  1163. X        XSelectInput(cli->dpy, virtual, VDMSelectMask);
  1164. X    else XSelectInput(cli->dpy, virtual, ExposureMask);
  1165. X    cli->framewin->core.virtual = virtual;
  1166. X    VInstallInfo(cli->framewin);
  1167. X    MakeVirtualIcon(cli);
  1168. X}
  1169. X
  1170. XMakeVirtualIcon(cli)
  1171. X    Client    *cli;
  1172. X
  1173. X{
  1174. Xint    width, height;
  1175. Xint    x, y;
  1176. X
  1177. X    width = cli->iconwin->core.width / cli->scrInfo->vdm->resources->scale;
  1178. X    height = cli->iconwin->core.height / cli->scrInfo->vdm->resources->scale;
  1179. X
  1180. X    x = cli->iconwin->core.x / cli->scrInfo->vdm->resources->scale +
  1181. X            cli->scrInfo->vdm->screenX;
  1182. X    y = cli->iconwin->core.y / cli->scrInfo->vdm->resources->scale +
  1183. X            cli->scrInfo->vdm->screenY;
  1184. X
  1185. X    if (width <= 0)
  1186. X    width = 1;
  1187. X    if (height <= 0)
  1188. X    height = 1;
  1189. X    cli->iconwin->core.virtual = XCreateSimpleWindow(cli->dpy,
  1190. X                    PANEWINOFCLIENT(cli->scrInfo->vdm->client),
  1191. X                    x, y, width, height, 1,
  1192. X                    cli->scrInfo->colorInfo.borderColor,
  1193. X                    cli->scrInfo->colorInfo.virtualFgColor);
  1194. X    XSelectInput(cli->dpy, cli->iconwin->core.virtual, VDMSelectMask);
  1195. X    VInstallInfo(cli->iconwin);
  1196. X}
  1197. X
  1198. X/*
  1199. X * Call to set/unset the focus of the given window
  1200. X */
  1201. XVirtualChangeFocus(win, focus)
  1202. X    WinGenericFrame    *win;
  1203. X    Bool        focus;
  1204. X{
  1205. Xint    length;
  1206. X
  1207. X    switch(win->core.kind) {
  1208. X    case WIN_ICON:
  1209. X        length = ((WinIconFrame *) win)->nameLength;
  1210. X        break;
  1211. X    case WIN_FRAME:
  1212. X        length = ((WinPaneFrame *) win)->nameLength;
  1213. X        break;
  1214. X    default:
  1215. X        return;
  1216. X    }
  1217. X    if (focus)
  1218. X    XSetWindowBackground(win->core.client->dpy, win->core.virtual,
  1219. X            win->core.client->scrInfo->colorInfo.virtualInputColor);
  1220. X    else XSetWindowBackground(win->core.client->dpy, win->core.virtual,
  1221. X            win->core.client->scrInfo->colorInfo.virtualFgColor);
  1222. X    XClearWindow(win->core.client->dpy, win->core.virtual);
  1223. X    XDrawImageString(win->core.client->dpy, win->core.virtual,
  1224. X             (focus) ? win->core.client->scrInfo->gc[VDM_INPUT_GC] :
  1225. X                   win->core.client->scrInfo->gc[VDM_GC],
  1226. X             1, win->core.client->scrInfo->vdm->max_ascent + 1,
  1227. X             win->fcore.name, length);
  1228. X}
  1229. X
  1230. X/*
  1231. X * Refresh the window's virtual representation
  1232. X */
  1233. XPaintVirtualWindow(win)
  1234. X    WinGenericFrame    *win;
  1235. X{
  1236. XClient    *cli = win->core.client;
  1237. Xint    length;
  1238. X
  1239. X    switch(win->core.kind) {
  1240. X    case WIN_ICON:
  1241. X        length = ((WinIconFrame *) win)->nameLength;
  1242. X        break;
  1243. X    case WIN_FRAME:
  1244. X        length = ((WinPaneFrame *) win)->nameLength;
  1245. X        break;
  1246. X    default:
  1247. X        return;
  1248. X    }
  1249. X    XClearArea(cli->dpy, win->core.virtual, 0, 0, 0, 0, False);
  1250. X    XDrawImageString(cli->dpy, win->core.virtual,
  1251. X             (cli->isFocus) ? cli->scrInfo->gc[VDM_INPUT_GC] :
  1252. X                   cli->scrInfo->gc[VDM_GC],
  1253. X             1, cli->scrInfo->vdm->max_ascent + 1,
  1254. X             win->fcore.name, length);
  1255. X}
  1256. X
  1257. X/*
  1258. X * Dispatch the event to its virtual window if it belongs to a virtual window
  1259. X */
  1260. XDispatchVirtual(dpy, event)
  1261. X    Display    *dpy;
  1262. X    XEvent    *event;
  1263. X{
  1264. XWinGeneric    *win, *VGetInfo();
  1265. Xstatic SemanticAction    currentVDMAction;
  1266. Xunsigned int    ignoremask;
  1267. X
  1268. X    if (event->xany.type == KeymapNotify || event->xany.type == MappingNotify)
  1269. X    return False;
  1270. X    win = VGetInfo(event->xany.window);
  1271. X    if (!win)
  1272. X    return False;
  1273. X    switch(event->xany.type) {
  1274. X    case Expose:
  1275. X        PaintVirtualWindow(win);
  1276. X        break;
  1277. X
  1278. X    /*
  1279. X     * For mouse events, we generally try to pretend that the mouse event
  1280. X     * happened on the frame instead of on the virtual window.
  1281. X     * We pretend that adjust and select events occured on the frame
  1282. X     * and just pass them to the frame's routine (after translating
  1283. X     * the root coordinates).  But we don't translate root coordinates
  1284. X     * for menus because we want the menu to come up where the mouse
  1285. X     * was
  1286. X     */
  1287. X    case ButtonPress:
  1288. X            ignoremask = ModMaskMap[MOD_CONSTRAIN] |
  1289. X                 ModMaskMap[MOD_INVERT] |
  1290. X                ModMaskMap[MOD_REDUCE];
  1291. X        currentVDMAction = ResolveMouseBinding(dpy, event, ignoremask);
  1292. X        if (currentVDMAction == ACTION_NONE)
  1293. X        return True;
  1294. X        if ((currentVDMAction == ACTION_SELECT) &&
  1295. X        (event->xbutton.time - lastSelectTime <= GRV.DoubleClickTime)) {
  1296. X        /*
  1297. X         * We have a double click in the VDM.  This is an exception to
  1298. X         * the above rule:  if we pass this to the frame, then the
  1299. X         * frame will go full size, which is not very interesting.
  1300. X         * So for this one we pretend it's a double click in the
  1301. X         * VDM itself
  1302. X         */
  1303. X            translateVirtualCoords(win->core.client->scrInfo->vdm,
  1304. X                &event->xmotion.x_root, &event->xmotion.y_root,
  1305. X                &event->xmotion.x, &event->xmotion.y);
  1306. X        VDMMoveTo(win->core.client->dpy, win->core.client,
  1307. X              event->xbutton.x_root, event->xbutton.y_root);
  1308. X        return True;
  1309. X        }
  1310. X        if (currentVDMAction == ACTION_MENU)
  1311. X            translateVirtualCoords(win->core.client->scrInfo->vdm,
  1312. X                       NULL, NULL,
  1313. X                       &event->xmotion.x, &event->xmotion.y);
  1314. X        else translateVirtualCoords(win->core.client->scrInfo->vdm,
  1315. X                &event->xmotion.x_root, &event->xmotion.y_root,
  1316. X                &event->xmotion.x, &event->xmotion.y);
  1317. X        GFrameEventButtonPress(dpy, event, win);
  1318. X        break;
  1319. X    
  1320. X    case MotionNotify:
  1321. X        translateVirtualCoords(win->core.client->scrInfo->vdm,
  1322. X                &event->xmotion.x_root, &event->xmotion.y_root,
  1323. X                &event->xmotion.x, &event->xmotion.y);
  1324. X        GFrameEventMotionNotify(dpy, event, win);
  1325. X        break;
  1326. X
  1327. X    case ButtonRelease:
  1328. X        if (currentVDMAction == ACTION_NONE)
  1329. X        return True;
  1330. X        if (currentVDMAction == ACTION_MENU)
  1331. X            translateVirtualCoords(win->core.client->scrInfo->vdm,
  1332. X                       NULL, NULL,
  1333. X                       &event->xmotion.x, &event->xmotion.y);
  1334. X        else translateVirtualCoords(win->core.client->scrInfo->vdm,
  1335. X                &event->xmotion.x_root, &event->xmotion.y_root,
  1336. X                &event->xmotion.x, &event->xmotion.y);
  1337. X        GFrameEventButtonRelease(dpy, event, win);
  1338. X        if (currentVDMAction == ACTION_SELECT)
  1339. X        lastSelectTime = event->xbutton.time;
  1340. X        currentVDMAction = ACTION_NONE;
  1341. X        break;
  1342. X
  1343. X    default:
  1344. X        fprintf(stderr, "unwanted %d event\n", event->xany.type);
  1345. X        break;
  1346. X    }
  1347. X    return True;
  1348. X}
  1349. X
  1350. XMakeSticky(cli, sticky)
  1351. X    Client    *cli;
  1352. X    Bool    sticky;
  1353. X
  1354. X{
  1355. Xint    dw, dh, x, y;
  1356. X    /*
  1357. X     * Can't unstick the VDM
  1358. X     */
  1359. X    if (cli->groupid == PANEWINOFCLIENT(cli->scrInfo->vdm->client) && !sticky)
  1360. X    return !NULL;
  1361. X    cli->sticky = sticky;
  1362. X    dw = DisplayWidth(cli->dpy, cli->screen);
  1363. X    dh = DisplayHeight(cli->dpy, cli->screen);
  1364. X    if (cli->sticky) {
  1365. X    x = cli->framewin->core.x;
  1366. X    y = cli->framewin->core.y;
  1367. X    cli->framewin->core.dirtyconfig |= CWX;
  1368. X    GFrameSetConfig(cli->framewin, x, y,
  1369. X            cli->framewin->core.width, cli->framewin->core.height);
  1370. X
  1371. X    x = cli->iconwin->core.x;
  1372. X    y = cli->iconwin->core.y;
  1373. X    cli->iconwin->core.dirtyconfig |= CWX;
  1374. X    IconSetPos(cli->iconwin, x + ICON_HORZBORDER, y + ICON_VERTBORDER);
  1375. X    WinCallConfig(cli->dpy, cli->iconwin, NULL);
  1376. X    }
  1377. X    return NULL;
  1378. X}
  1379. X
  1380. X/*
  1381. X * Return true if the given key action should affect the VDM
  1382. X */
  1383. XKeyMoveVDM(dpy, ev)
  1384. X    Display *dpy;
  1385. X    XEvent  *ev;
  1386. X{
  1387. XVirtualDesktop    *vdm;
  1388. XWinGeneric    *root;
  1389. XSemanticAction    a;
  1390. X
  1391. X    if (ev->xany.type != KeyPress)
  1392. X    /* Root window uses same function for Up and Down events */
  1393. X    return False;
  1394. X
  1395. X    root = WIGetInfo(ev->xkey.root);
  1396. X    if (!root) {
  1397. X    fprintf(stderr, "NO ROOT\n");
  1398. X    return False;
  1399. X    }
  1400. X    if (!root->core.client) {
  1401. X    fprintf(stderr, "NO CLIENT\n");
  1402. X    return False;
  1403. X    }
  1404. X    if (!root->core.client->scrInfo) {
  1405. X    fprintf(stderr, "NO SCRINFO\n");
  1406. X    return False;
  1407. X    }
  1408. X    vdm = root->core.client->scrInfo->vdm;
  1409. X
  1410. X    a = FindNewKeyboardAction(dpy, ev);
  1411. X    if (a == ACTION_NONE)
  1412. X    return False;
  1413. X    if (a == ACTION_VIRTUAL)
  1414. X    return CheckForKeyProg(dpy, ev);
  1415. X
  1416. X    return vdmPerformAction(dpy, vdm, a);
  1417. X}
  1418. X
  1419. X/*
  1420. X * Update the selection state of the given window's virtual representation
  1421. X */
  1422. XVirtualSelect(win, sel)
  1423. X    WinGeneric    *win;
  1424. X    Bool    sel;
  1425. X
  1426. X{
  1427. X    if (win->core.virtual)
  1428. X    XSetWindowBorderWidth(win->core.client->dpy,
  1429. X                  win->core.virtual, (sel) ? 2 : 1);
  1430. X}
  1431. X
  1432. X/*
  1433. X * Move to point x, y and save the desktop; we do this when save workspace
  1434. X * is called so that all the coordinates will be correct for startup
  1435. X * position
  1436. X */
  1437. XVirtualSaveDesktops(dpy, x, y)
  1438. X    Display    *dpy;
  1439. X    int        x, y;
  1440. X{
  1441. Xstruct deltas    deltas;
  1442. XScreenInfo    *si;
  1443. XList        *l = ScreenInfoList;
  1444. X
  1445. X    for (si = ListEnum(&l); si; si = ListEnum(&l)) {
  1446. X        si->vdm->saveX = si->vdm->offsetX;
  1447. X        si->vdm->saveY = si->vdm->offsetY;
  1448. X        deltas.delta_x = si->vdm->offsetX - x;
  1449. X        deltas.delta_y = si->vdm->offsetY - y;
  1450. X        moveDesktop(dpy, &deltas, si->vdm);
  1451. X    }
  1452. X}
  1453. X
  1454. XVirtualRestoreDesktops(dpy)
  1455. X    Display    *dpy;
  1456. X{
  1457. Xstruct deltas    deltas;
  1458. XScreenInfo    *si;
  1459. XList        *l = ScreenInfoList;
  1460. X
  1461. X    for (si = ListEnum(&l); si; si = ListEnum(&l)) {
  1462. X        deltas.delta_x = -si->vdm->saveX;
  1463. X        deltas.delta_y = -si->vdm->saveY;
  1464. X        moveDesktop(dpy, &deltas, si->vdm);
  1465. X    }
  1466. X}
  1467. X
  1468. XVirtualCleanup(dpy)
  1469. X    Display    *dpy;
  1470. X
  1471. X{
  1472. X    VirtualSaveDesktops(dpy, 0, 0);
  1473. X}
  1474. X
  1475. XResizeVDM(vdm, size)
  1476. X    VirtualDesktop    *vdm;
  1477. X    char        *size;
  1478. X{
  1479. XWinGenericFrame    *win;
  1480. X
  1481. X    win = (WinGenericFrame *) vdm->client->framewin;
  1482. X    if (vdm->resources->size)
  1483. X    free(vdm->resources->size);
  1484. X    vdm->resources->size = strdup(size);
  1485. X    calculateVirtualDesktopSize(vdm->client->dpy, vdm->client->screen, vdm);
  1486. X    GFrameSetConfig(win, win->core.x, win->core.y,
  1487. X        vdm->width + (WinFunc(win,fcore.widthleft))(win) +
  1488. X                 (WinFunc(win,fcore.widthright))(win),
  1489. X        vdm->height + (WinFunc(win,fcore.heighttop))(win) +
  1490. X                 (WinFunc(win,fcore.heightbottom))(win));
  1491. X}
  1492. X
  1493. X/*
  1494. X *============================================================================
  1495. X *
  1496. X * Functions to reflect resources changes
  1497. X */
  1498. X
  1499. Xstatic void *
  1500. XremakeVirtual(cli)
  1501. X    Client    *cli;
  1502. X{
  1503. XDisplay    *dpy = cli->dpy;
  1504. X
  1505. X    if (cli->framewin) {
  1506. X    VIUninstallInfo(cli->framewin->core.virtual);
  1507. X    VIUninstallInfo(cli->iconwin->core.virtual);
  1508. X    XDestroyWindow(dpy, cli->framewin->core.virtual);
  1509. X    XDestroyWindow(dpy, cli->iconwin->core.virtual);
  1510. X    MakeVirtual(cli);
  1511. X    XMapWindow(dpy, (cli->wmState == IconicState) ?
  1512. X                cli->iconwin->core.virtual :
  1513. X                cli->framewin->core.virtual);
  1514. X    }
  1515. X    return NULL;
  1516. X}
  1517. X
  1518. Xstatic void *
  1519. XupdateVirtualWindow(cli)
  1520. X    Client    *cli;
  1521. X
  1522. X{
  1523. XDisplay    *dpy = cli->dpy;
  1524. X
  1525. X    if (cli->framewin) {
  1526. X    XSetWindowBackground(dpy, cli->framewin->core.virtual,
  1527. X                cli->scrInfo->colorInfo.virtualFgColor);
  1528. X    XSetWindowBackground(dpy, cli->iconwin->core.virtual,
  1529. X                cli->scrInfo->colorInfo.virtualFgColor);
  1530. X    }
  1531. X}
  1532. X
  1533. X/*
  1534. X * Resize the VDM with the new scale
  1535. X */
  1536. XRescaleVDM(vdm, scale)
  1537. X    VirtualDesktop    *vdm;
  1538. X    int            scale;
  1539. X
  1540. X{
  1541. Xint    orig_scale;
  1542. XWinGenericFrame    *win;
  1543. X
  1544. X    orig_scale = vdm->resources->scale;
  1545. X    vdm->resources->scale = scale;
  1546. X    calculateVirtualDesktopSize(vdm->client->dpy, vdm->client->screen, vdm);
  1547. X    vdm->screenX = (vdm->screenX * orig_scale) / scale;
  1548. X    vdm->screenY = (vdm->screenY * orig_scale) / scale;
  1549. X    vdm->client->normHints->width_inc = vdm->screenWidth;
  1550. X    vdm->client->normHints->height_inc = vdm->screenHeight;
  1551. X    win = (WinGenericFrame *) vdm->client->framewin;
  1552. X    GFrameSetConfig(win, win->core.x, win->core.y,
  1553. X        vdm->width + (WinFunc(win,fcore.widthleft))(win) +
  1554. X                     (WinFunc(win,fcore.widthright))(win),
  1555. X        vdm->height + (WinFunc(win,fcore.heighttop))(win) +
  1556. X                      (WinFunc(win,fcore.heightbottom))(win));
  1557. X    ListApply(ActiveClientList, remakeVirtual, 0);
  1558. X}
  1559. X
  1560. XVirtualUpdateVirtualWindows(cli)
  1561. X    Client    *cli;
  1562. X{
  1563. X    ListApply(ActiveClientList, updateVirtualWindow, 0);
  1564. X    ClientRefresh(cli);
  1565. X}
  1566. X
  1567. X/*
  1568. X * Size the VDM with the new geometry
  1569. X */
  1570. XVirtualSetGeometry(win, geom)
  1571. X    WinGeneric    *win;
  1572. X    char    *geom;
  1573. X{
  1574. Xint    changed;
  1575. Xint    newx, newy, x, y, w, h;
  1576. XDisplay    *dpy = win->core.client->dpy;
  1577. XScreenInfo    *scrInfo = win->core.client->scrInfo;
  1578. X
  1579. X        changed = XParseGeometry(geom, &x, &y, &w, &h);
  1580. X        if (changed & (XValue | YValue)) {
  1581. X            if (changed & XValue)
  1582. X                if (changed & XNegative)
  1583. X                    newx = DisplayWidth(dpy, scrInfo->screen) + x;
  1584. X                else newx = x;
  1585. X            else newx = win->core.x;
  1586. X        w = win->core.width;
  1587. X            if (newx > DisplayWidth(dpy, scrInfo->screen) - w)
  1588. X                newx = DisplayWidth(dpy, scrInfo->screen) - w;
  1589. X            if (changed & YValue)
  1590. X                if (changed & YNegative)
  1591. X                    newy = DisplayHeight(dpy, scrInfo->screen) + y;
  1592. X                else newy = y;
  1593. X            else newy = win->core.y;
  1594. X        h = win->core.height;
  1595. X            if (newy > DisplayHeight(dpy, scrInfo->screen) - h)
  1596. X                newy = DisplayHeight(dpy, scrInfo->screen) - h;
  1597. X            GFrameSetConfig(win, newx, newy, win->core.width, win->core.height);           
  1598. X        }
  1599. X}
  1600. X
  1601. X/*
  1602. X * Get a background pixmap for the VDM with the VDM colors
  1603. X */
  1604. XPixmap
  1605. XVirtualGetPixmap(dpy, scrInfo, name)
  1606. X    Display    *dpy;
  1607. X    ScreenInfo    *scrInfo;
  1608. X    char    *name;
  1609. X
  1610. X{
  1611. XPixmap    read, write;
  1612. Xint    w, h, dummy;
  1613. XXGCValues    gcv;
  1614. XGC    gc;
  1615. X
  1616. X    if (XReadBitmapFile(dpy, scrInfo->rootid, name,
  1617. X            &w, &h, &read, &dummy, &dummy) == BitmapSuccess) {
  1618. X    write = XCreatePixmap(dpy, scrInfo->rootid, w, h, scrInfo->depth);
  1619. X    gcv.function = GXcopy;
  1620. X    gc = XCreateGC(dpy, scrInfo->rootid, GCFunction, &gcv);
  1621. X    XSetForeground(dpy, gc, scrInfo->colorInfo.virtualPixmapColor);
  1622. X    XSetBackground(dpy, gc, scrInfo->colorInfo.virtualBgColor);
  1623. X    XCopyPlane(dpy, read, write, gc, 0, 0, w, h, 0, 0, 1);
  1624. X    XFreePixmap(dpy, read);
  1625. X    XFreeGC(dpy, gc);
  1626. X    return write;
  1627. X    }
  1628. X    else {
  1629. X    ErrorWarning(gettext("An invalid bitmap file was named as the virtual background"));
  1630. X    return None;
  1631. X    }
  1632. X}
  1633. X
  1634. X/*
  1635. X * Perform an action from the VDM menu
  1636. X */
  1637. Xint
  1638. XVDMMenuAction(dpy, winInfo, menuInfo, btn)
  1639. X    Display    *dpy;
  1640. X    WinPinMenu    *winInfo;
  1641. X    MenuInfo    *menuInfo;
  1642. X    int        btn;
  1643. X
  1644. X{
  1645. X
  1646. X    if (!vdmPerformAction(dpy, winInfo->core.client->scrInfo->vdm,
  1647. X                vdmButtonActions[btn]) && GRV.Beep == BeepAlways)
  1648. X    XBell(dpy, 100);
  1649. X}
  1650. X
  1651. X/*
  1652. X * Move to the logical screen on the desktop containing point x, y
  1653. X *
  1654. X * This move is constrained to a logical screen, even if the grid is
  1655. X * off.
  1656. X */
  1657. XVDMMoveTo(dpy, client, x, y)
  1658. X    Display    *dpy;
  1659. X    Client    *client;
  1660. X    int        x, y;
  1661. X{
  1662. Xint    dw, dh;
  1663. Xstruct deltas    deltas;
  1664. X
  1665. X    dw = DisplayWidth(dpy, client->screen);
  1666. X    dh = DisplayHeight(dpy, client->screen);
  1667. X    deltas.delta_x = ((x - client->scrInfo->vdm->offsetX) / dw) * dw
  1668. X            + client->scrInfo->vdm->offsetX;
  1669. X    deltas.delta_y = ((y - client->scrInfo->vdm->offsetY) / dh) * dh
  1670. X            + client->scrInfo->vdm->offsetY;
  1671. X    constrainDeltas(dpy, client->scrInfo->vdm, &deltas);
  1672. X    moveDesktop(dpy, &deltas, client->scrInfo->vdm);
  1673. X}
  1674. X
  1675. X/*
  1676. X * Goto logical screen passed 
  1677. X */
  1678. X
  1679. XVDMGoto(dpy, client, screen)
  1680. X    Display    *dpy;
  1681. X    Client    *client;
  1682. X    int        screen;
  1683. X{
  1684. Xint    dw, dh;
  1685. X
  1686. X    screen--;
  1687. X    dw = DisplayWidth(dpy, client->screen);
  1688. X    dh = DisplayHeight(dpy, client->screen);
  1689. X    VDMMoveTo(dpy, client, dw * (screen % client->scrInfo->vdm->rows) +
  1690. X                    client->scrInfo->vdm->offsetX,
  1691. X        dh * (screen / client->scrInfo->vdm->rows) +
  1692. X                    client->scrInfo->vdm->offsetY);
  1693. X}
  1694. X
  1695. X/*
  1696. X *==========================================================================
  1697. X *
  1698. X * Utility functions to replace window mapping, configuring, etc.; these
  1699. X * functions work just like their X counterparts but affect both the
  1700. X * X window and its virtual representation.
  1701. X */
  1702. X
  1703. XMapWindow(win)
  1704. X    WinGeneric    *win;
  1705. X{
  1706. X    XSetWindowBorderWidth(win->core.client->dpy,
  1707. X        win->core.virtual, (win->core.client->isSelected) ? 2 : 1);
  1708. X    XMapWindow(win->core.client->dpy, win->core.self);
  1709. X    XMapWindow(win->core.client->dpy, win->core.virtual);
  1710. X    if (GRV.VirtualRaiseVDM && win->core.client->scrInfo->vdm->client)
  1711. X    RaiseWindow(win->core.client->scrInfo->vdm->client->framewin);
  1712. X}
  1713. X
  1714. XUnmapWindow(win)
  1715. X    WinGeneric    *win;
  1716. X{
  1717. X    XUnmapWindow(win->core.client->dpy, win->core.self);
  1718. X    XUnmapWindow(win->core.client->dpy, win->core.virtual);
  1719. X}
  1720. X
  1721. XMapRaised(win)
  1722. X    WinGeneric    *win;
  1723. X{
  1724. X    XSetWindowBorderWidth(win->core.client->dpy,
  1725. X        win->core.virtual, (win->core.client->isSelected) ? 2 : 1);
  1726. X    XMapRaised(win->core.client->dpy, win->core.self);
  1727. X    XMapRaised(win->core.client->dpy, win->core.virtual);
  1728. X    if (GRV.VirtualRaiseVDM && win->core.client->scrInfo->vdm->client)
  1729. X    RaiseWindow(win->core.client->scrInfo->vdm->client->framewin);
  1730. X}
  1731. X
  1732. XRaiseWindow(win)
  1733. X    WinGeneric    *win;
  1734. X{
  1735. X    XRaiseWindow(win->core.client->dpy, win->core.self);
  1736. X    XRaiseWindow(win->core.client->dpy, win->core.virtual);
  1737. X    if (GRV.VirtualRaiseVDM &&
  1738. X    win->core.client->scrInfo->vdm->client &&
  1739. X    win->core.client->scrInfo->vdm->client &&
  1740. X  win->core.self != win->core.client->scrInfo->vdm->client->framewin->core.self)
  1741. X    RaiseWindow(win->core.client->scrInfo->vdm->client->framewin);
  1742. X}
  1743. X
  1744. XLowerWindow(win)
  1745. X    WinGeneric    *win;
  1746. X{
  1747. X    XLowerWindow(win->core.client->dpy, win->core.self);
  1748. X    XLowerWindow(win->core.client->dpy, win->core.virtual);
  1749. X    if (GRV.VirtualRaiseVDM)
  1750. X    RaiseWindow(win->core.client->scrInfo->vdm->client->framewin);
  1751. X}
  1752. X
  1753. XDestroyWindow(win)
  1754. X    WinGeneric    *win;
  1755. X{
  1756. X    XDestroyWindow(win->core.client->dpy, win->core.self);
  1757. X    WIUninstallInfo(win->core.self);
  1758. X    if (win->core.virtual)
  1759. X        XDestroyWindow(win->core.client->dpy, win->core.virtual);
  1760. X}
  1761. X
  1762. XDeleteProperty(dpy, win, atom)
  1763. X    Display        *dpy;
  1764. X    WinGenericFrame    *win;
  1765. X    Atom        atom;
  1766. X
  1767. X{
  1768. X    XDeleteProperty(dpy, win->core.self, atom);
  1769. X    if (win->core.virtual)
  1770. X        XDeleteProperty(dpy, win->core.virtual, atom);
  1771. X}
  1772. X
  1773. XChangeProperty(dpy, win, property, type, format, mode, data, nelements)
  1774. X   Display        *dpy;
  1775. X   WinGenericFrame    *win;
  1776. X   Atom            property, type;
  1777. X   int            format;
  1778. X   int            mode;
  1779. X   unsigned char    *data;
  1780. X   int            nelements;
  1781. X{
  1782. X    XChangeProperty(dpy, win->core.self, property, type, format,
  1783. X            mode, data, nelements);
  1784. X    if (win->core.virtual)
  1785. X        XChangeProperty(dpy, win->core.virtual, property, type, format,
  1786. X            mode, data, nelements);
  1787. X}
  1788. X
  1789. XConfigureWindow(dpy, win, mask, values)
  1790. X    Display    *dpy;
  1791. X    WinGeneric    *win;
  1792. X    int        mask;
  1793. X    XWindowChanges    *values;
  1794. X
  1795. X{
  1796. Xint    scale;
  1797. XWinGeneric    *tmp;
  1798. X
  1799. X    XConfigureWindow(dpy, win->core.self, mask, values);
  1800. X    scale = win->core.client->scrInfo->vdm->resources->scale;
  1801. X    if (mask & CWX)
  1802. X    values->x = (win->core.x - win->core.client->scrInfo->vdm->offsetX) /
  1803. X            scale;
  1804. X    if (mask & CWY)
  1805. X    values->y = (win->core.y - win->core.client->scrInfo->vdm->offsetY) /
  1806. X            scale;
  1807. X    if (mask & CWWidth)
  1808. X    values->width = win->core.width / scale;
  1809. X    if (mask & CWHeight)
  1810. X    values->height = win->core.height / scale;
  1811. X    if (mask & CWSibling) {
  1812. X    tmp = WIGetInfo(values->sibling);
  1813. X    if (tmp)
  1814. X        values->sibling = tmp->core.virtual;
  1815. X    else mask |= ~(CWSibling|CWStackMode);
  1816. X    }
  1817. X    XConfigureWindow(dpy, win->core.virtual, mask, values);
  1818. X    if (GRV.VirtualRaiseVDM)
  1819. X    RaiseWindow(win->core.client->scrInfo->vdm->client->framewin);
  1820. X}
  1821. X
  1822. X/*
  1823. X * Menu generation function for DIRMENU
  1824. X *
  1825. X */
  1826. XGenDirMenuFunc(dpy, menuInfo, bindex, cache, winInfo, depth)
  1827. X    Display    *dpy;
  1828. X    MenuInfo    *menuInfo;
  1829. X    int        bindex;
  1830. X    MenuCache    *cache;
  1831. X    WinGeneric    *winInfo;
  1832. X    int        depth;
  1833. X
  1834. X{
  1835. XMenu    *menu;
  1836. XDIR    *dir;
  1837. Xstruct dirent    *ent;
  1838. XButton    *b;
  1839. Xchar    s[256], *dirname;
  1840. Xextern int AppMenuFunc();
  1841. X
  1842. X    MenuInfoDestroy(menuInfo->buttons[bindex].subMenu);
  1843. X    menu = (Menu *) MemAlloc(sizeof(Menu));
  1844. X    menu->buttons = NULL;
  1845. X    menu->buttonCount = 0;
  1846. X    menu->buttonDefault = NOBUTTON;
  1847. X    menu->hasPushPin = False;
  1848. X    menu->menudirty = True;
  1849. X    menu->btnPerCol = 0;
  1850. X    menu->maxLabWidth = 0;
  1851. X    menu->prefColSize = 0;
  1852. X
  1853. X    dirname = (char *) menuInfo->menu->buttons[bindex]->generate_args;
  1854. X    if (!(dir = opendir(dirname))) {
  1855. X    menuInfo->buttons[bindex].subMenu =
  1856. X                MenuInfoCreate(cache, winInfo, menu, depth);
  1857. X    return;
  1858. X    }
  1859. X    while (ent = readdir(dir)) {
  1860. X    if (ent->d_name[0] == '.')
  1861. X        continue;
  1862. X    b = (Button *) MemAlloc(sizeof(Button));
  1863. X    if (!menu->buttonCount++)
  1864. X        menu->buttons = (Button **) MemAlloc(sizeof(Button *));
  1865. X    else menu->buttons = (Button **)
  1866. X        MemRealloc(menu->buttons, menu->buttonCount * sizeof(Button *));
  1867. X    menu->buttons[menu->buttonCount - 1] = b;
  1868. X    b->label[0].kind = StringLabel;
  1869. X    b->label[1].kind = NoType;
  1870. X    sprintf(s, "exec %s/%s", dirname, ent->d_name);
  1871. X    b->label[0].string = MemNewString(ent->d_name);
  1872. X    b->label[1].string = NULL;
  1873. X    b->helpstring[0] = b->helpstring[1] = NULL;
  1874. X    b->which = 0;
  1875. X    b->stacked = False;
  1876. X    b->enabled = True;
  1877. X    b->visible = True;
  1878. X    b->action.callback = AppMenuFunc;
  1879. X    b->action.submenu = (void *) MemNewString(s);
  1880. X    b->generate_func = NULL;
  1881. X    }
  1882. X    closedir(dir);
  1883. X    menuInfo->buttons[bindex].subMenu =
  1884. X                MenuInfoCreate(cache, winInfo, menu, depth);
  1885. X}
  1886. END_OF_FILE
  1887. if test 51849 -ne `wc -c <'virtual.c'`; then
  1888.     echo shar: \"'virtual.c'\" unpacked with wrong size!
  1889. fi
  1890. # end of 'virtual.c'
  1891. fi
  1892. echo shar: End of archive 2 \(of 21\).
  1893. cp /dev/null ark2isdone
  1894. MISSING=""
  1895. 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
  1896.     if test ! -f ark${I}isdone ; then
  1897.     MISSING="${MISSING} ${I}"
  1898.     fi
  1899. done
  1900. if test "${MISSING}" = "" ; then
  1901.     echo You have unpacked all 21 archives.
  1902.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1903. else
  1904.     echo You still need to unpack the following archives:
  1905.     echo "        " ${MISSING}
  1906. fi
  1907. ##  End of shell archive.
  1908. exit 0
  1909. --
  1910. Molecular Simulations, Inc.             mail: dcmartin@postgres.berkeley.edu
  1911. 796 N. Pastoria Avenue                  uucp: uwvax!ucbvax!dcmartin
  1912. Sunnyvale, California 94086             at&t: 408/522-9236
  1913.