mdw@git.distorted.org.uk Git - ssr/blob - StraySrc/Glass/!Glass/h/_window

   1 /*
   2  * _window.h
   3  *
   4  * Private window definitions
   5  *
   6  * © 1994-1998 Straylight
   7  */
   8
   9 /*----- Licensing note ----------------------------------------------------*
  10  *
  11  * This file is part of Straylight's Glass.
  12  *
  13  * Glass is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2, or (at your option)
  16  * any later version.
  17  *
  18  * Glass is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with Glass.  If not, write to the Free Software Foundation,
  25  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  */
  27
  28 #ifndef ___window_h
  29 #define ___window_h
  30
  31 #ifndef __gPrefs_h
  32   #include "gPrefs.h"
  33 #endif
  34
  35 #ifndef __gStruct
  36   #include "gStruct.h"
  37 #endif
  38
  39 /*----- Common macros -----------------------------------------------------*/
  40
  41 /*
  42  * Macros describing parts of icons (as returned by window__pointerInfo)
  43  */
  44
  45 /*
  46  * These have been redefined to be a bitfield (24/5/93):
  47  * And then re-redefined to be a different bitfield (3/2/98):
  48  *
  49  *  bit 24 set == drag moves top of icon
  50  *  bit 25 set == drag moves bottom of icon
  51  *  bit 26 set == drag moves left of icon
  52  *  bit 27 set == drag moves right of icon
  53  *
  54  * The values 3, b and c are not defined - They may be used for future
  55  *  expansion, but I doubt it somehow.  d and e are used to describe
  56  *  guidelines - the magic number is ORred with the guide number.
  57  */
  58
  59 #define window__TOP         0x01000000 /* The top edge drag box            */
  60 #define window__BOTTOM      0x02000000 /* The bottom edge drag box         */
  61 #define window__LEFT        0x04000000 /* The left edge drag box           */
  62 #define window__RIGHT       0x08000000 /* The right edge drag box          */
  63 #define window__MAIN        0x0f000000 /* The main part of the icon        */
  64 #define window__TOPLEFT     0x05000000 /* The top left corner drag box     */
  65 #define window__TOPRIGHT    0x09000000 /* The top right corner drag box    */
  66 #define window__BOTTOMLEFT  0x06000000 /* The bottom left corner drag box  */
  67 #define window__BOTTOMRIGHT 0x0a000000 /* The bottom right corner drag box */
  68
  69 #define window__HORGUIDE    0x0d000000 /* A horizontal guide               */
  70 #define window__VERGUIDE    0x0e000000 /* A vertical guide                 */
  71 #define window__GRABICON    0x07000000 /* This is a drag of a grabbed icon */
  72 #define window__SELECT      0x00000000 /* This is a drag to select icons   */
  73
  74 #define window__ZONEMASK    0x0F000000 /* Mask for drag zones              */
  75 #define window__ICONMASK    0x00FFFFFF /* Mask for icon numbers            */
  76
  77 /*
  78  * Colours for things
  79  */
  80
  81 #define window__SELBOXCOL (gPrefs_current()->sBColour)
  82 #define window__HANDCOL (gPrefs_current()->sHColour)
  83 #define window__MSELBOXCOL (gPrefs_current()->sSColour)
  84 #define window__DRAGCOL 0x0b
  85 #define window__GUIDECOL (gPrefs_current()->gGdeCol)
  86 #define window__GDESELCOL (gPrefs_current()->gGdeSelCol)
  87
  88 /*
  89  * Other things
  90  */
  91
  92 #define window__HANDLEWIDTH gPrefs_current()->sHandSize
  93 #define window__SNAPDIST 16
  94 #define window__DRAGTIME 0
  95
  96 #define max2(a,b) ((a)>(b) ? (a) : (b))
  97 #define min2(a,b) ((a)<(b) ? (a) : (b))
  98
  99 /*----- Low level graphics handling ---------------------------------------*/
 100
 101 /*
 102  * void window__colourChange(int col1,int col2)
 103  *
 104  * Use
 105  *  Sets up the current foreground colour so that when plotted over colour
 106  *  col1 it looks like col2 and vice-versa.  The effects of plotting over
 107  *  other colours is defined to be psychedelically interesting, but not
 108  *  pretty.
 109  *
 110  *  Basically, all it does is suss out what the colours really mean and XOR
 111  *  them together.
 112  *
 113  * Parameters
 114  *  int col1,int col2 == the Wimp colour numbers to swap between
 115  */
 116
 117 void window__colourChange(int col1,int col2);
 118
 119 /*
 120  * void window__setXORColour(glass_windPointer *w,int col)
 121  *
 122  * Use
 123  *  Sets up the current foreground colour so that it appears to be WIMP
 124  *  colour col on the specified window background.  Lots of tedious
 125  *  ColourTransing to do on this, with no real reward, but at least it will
 126  *  look vaguely right in 256 colour modes.
 127  *
 128  * Parameters
 129  *  glass_windPointer *w == the window in which to set the colour
 130  *  int col == the colour to set
 131  */
 132
 133 void window__setXORColour(glass_windPointer *w,int col);
 134
 135 /*
 136  * void window__makeDashPattern(int ptn)
 137  *
 138  * Use
 139  *  Sets the OS dash pattern to the given pattern (only the lowest byte
 140  *  is considered).
 141  *
 142  * Parameters
 143  *  int ptn == the LSB of this word contains the dash pattern as a bit
 144  *   pattern
 145  */
 146
 147 void window__makeDashPattern(int ptn);
 148
 149 /*
 150  * void window__setDash(void)
 151  *
 152  * Use
 153  *  Sets the dashed pattern so that it looks as if a 'rotating' box is being
 154  *  dragged, like the WIMP's, only better...  The box is set up so that a
 155  *  SINGLE exclusive-or plot will move the dash round.
 156  */
 157
 158 void window__setDash(void);
 159
 160 /*
 161  * void window__rotate(int by)
 162  *
 163  * Use
 164  *  Rotates the current rotating-dash pattern by a given amount.  This is
 165  *  used to rotate the dash box while the box is moving.
 166  *
 167  * Parameters
 168  *  int by == the number of steps to rotate the dash pattern.
 169  */
 170
 171 void window__rotate(int by);
 172
 173 /*
 174  * void window__rectangle(int x,int y,int w,int h)
 175  *
 176  * Use
 177  *  Draws a rectangle, using the current dotted line pattern
 178  *
 179  * Parameters
 180  *  int x == the left side of the rectangle
 181  *  int y == the right side of the rectangle
 182  *  int w == the width of the rectangle (may be <0)
 183  *  int h == the height of the rectangle (may be <0)
 184  */
 185
 186 void window__rectangle(int x,int y,int w,int h);
 187
 188 /*----- Redrawing windows -------------------------------------------------*/
 189
 190 /*
 191  * void window__drawSelectBox(glass_windPointer *w,
 192  *                            int icon,
 193  *                            BOOL makesi,
 194  *                            wimp_redrawstr *r)
 195  *
 196  * Use
 197  *  Draws the selection box around an icon
 198  *
 199  * Parameters
 200  *  glass_windPointer *w == the window
 201  *  int icon == the icon
 202  *  BOOL makesi == whether we're going between a selected and main selected
 203  *    icon.
 204  *  wimp_redrawstr *r == the redraw structure
 205  */
 206
 207 void window__drawSelectBox(glass_windPointer *w,
 208                            int icon,
 209                            BOOL makesi,
 210                            wimp_redrawstr *r);
 211
 212 /*
 213  * void window__redrawDragBox(glass_windPointer *w,
 214  *                            wimp_redrawstr *r,
 215  *                            int x,
 216  *                            int y)
 217  *
 218  * Use
 219  *  Redraws the screen during a drag operation, either to update the window
 220  *  during the drag, or to redraw the window should something silly happen
 221  *  to it.
 222  *
 223  * Parameters
 224  *  glass_windPointer *w == pointer to the window owning drag
 225  *  wimp_redrawstr *r == pointer to current redraw
 226  *  int x,int y == coordinates to draw drag relative to...
 227  */
 228
 229 void window__redrawDragBox(glass_windPointer *w,wimp_redrawstr *r,
 230                            int x,int y);
 231
 232 /*
 233  * void window__redraw(glass_windPointer *w,wimp_redrawstr *r,BOOL *more)
 234  *
 235  * Use
 236  *  Redraws a window following a call to Wimp_UpdateWindow or
 237  *  Wimp_RedrawWindow.
 238  *
 239  * Parameters
 240  *  glass_windPointer *w == the window to draw
 241  *  wimp_redrawstr *r == stuff about the redraw
 242  *  BOOL *more == whether there is more to do
 243  */
 244
 245 void window__redraw(glass_windPointer *w,wimp_redrawstr *r,BOOL *more);
 246
 247 /*
 248  * void window__redrawGuide(glass_windPointer *w,int guide)
 249  *
 250  * Use
 251  *  Forces a redraw of the specified guideline.
 252  *
 253  * Parameters
 254  *  glass_windPointer *w == the window containing the guideline
 255  *  int guide == the number of the guideline.
 256  */
 257
 258 void window__redrawGuide(glass_windPointer *w,int guide);
 259
 260 /*----- Grabbing icons ----------------------------------------------------*/
 261
 262 /*
 263  * void window__grabIcon(wimp_mousestr *m,void *handle)
 264  *
 265  * Use
 266  *  Grabs an icon from another application.
 267  *
 268  * Parameters
 269  *  wimp_mousestr *m == pointer to info about which icon to get
 270  *  void *handle == pointer to destination window
 271  */
 272
 273 void window__grabIcon(wimp_mousestr *m,void *handle);
 274
 275 /*
 276  * void window__doGrabIcon(wimp_box *b,glass_windPointer *w)
 277  *
 278  * Use
 279  *  Actually does a window grab job after all the pallaver.
 280  *
 281  * Parameters
 282  *  wimp_box *b == the box in which the icon is contained
 283  *  glass_windPointer *w == the window into which the icon is to be created
 284  *
 285  * Returns
 286  *  TRUE if the evtn has been successfully handled.
 287  */
 288
 289 void window__doGrabIcon(wimp_box *b,glass_windPointer *w);
 290
 291 /*
 292  * wimp_icon *window__qGrabbedIcon(void)
 293  *
 294  * Use
 295  *  Returns a pointer to the icon being grabbed
 296  */
 297
 298 wimp_icon *window__qGrabbedIcon(void);
 299
 300 /*----- Dragging icons around ---------------------------------------------*/
 301
 302 /*
 303  * void window__align(glass_windPointer *w,int *x,int *y)
 304  *
 305  * Use
 306  *  Aligns the given point to the *nearest* grid point.  The point is
 307  *  fiddled in-situ.  It does the Right Thing with negative points.
 308  *
 309  * Parameters
 310  *  glass_windPointer *w == the window we're using
 311  *  int *x == pass-by-reference x coord of point
 312  *  int *y == pass-by-reference y coord of point
 313  */
 314
 315 void window__align(glass_windPointer *w,int *x,int *y);
 316
 317 /*
 318  * void window__startDrag(int type,
 319  *                        wimp_box *box,
 320  *                        glass_windPointer *w,
 321  *                        int x,int y)
 322  *
 323  * Use
 324  *  Starts a drag operation in the specified window
 325  *
 326  * Parameters
 327  *  int type == what sort of drag this is
 328  *  wimp_box *box == the bounding box of the object we're dragging
 329  *  glass_windPointer *w == the window in which the drag is taking place
 330  *  int x,int y == the mouse position the drag will start from
 331  */
 332
 333 void window__startDrag(int type,
 334                        wimp_box *box,
 335                        glass_windPointer *w,
 336                        int x,int y);
 337
 338 /*
 339  * glass_windPointer *window__dragWind(void)
 340  *
 341  * Use
 342  *  Returns the current dragging window
 343  */
 344
 345 glass_windPointer *window__dragWind(void);
 346
 347 /*
 348  * void window__setDragWind(glass_windPointer *w)
 349  *
 350  * Use
 351  *  Claims the current drag operation for the given window
 352  */
 353
 354 void window__setDragWind(glass_windPointer *w);
 355
 356 /*
 357  * int window__qDragType(void)
 358  *
 359  * Use
 360  *  Returns the current drag type
 361  */
 362
 363 int window__qDragType(void);
 364
 365 /*
 366  * wimp_box window__qDragBox(void)
 367  *
 368  * Use
 369  *  Returns the bounding box of the things being dragged
 370  */
 371
 372 wimp_box window__qDragBox(void);
 373
 374 /*
 375  * void window__dragCoords(int *x,int *y)
 376  *
 377  * Use
 378  *  Returns the current drag position
 379  */
 380
 381 void window__dragCoords(int *x,int *y);
 382
 383 /*
 384  * void window__dragStart(int *x,int *y)
 385  *
 386  * Use
 387  *  Returns the initial drag position
 388  */
 389
 390 void window__dragStart(int *x,int *y);
 391
 392 /*----- Mouse pointer shape and position ----------------------------------*/
 393
 394 /*
 395  * int window__pointerInfo(glass_windPointer *w,int from,BOOL zones)
 396  *
 397  * Use
 398  *  Returns the icon number of the icon which the pointer is over.  Guides
 399  *  are also checked for.
 400  *
 401  * Parameters
 402  *  glass_windPointer *w == the window to use info from
 403  *  int from == number to search down from (or -1 for the top).  This is
 404  *   useful for selection, multiple clicks moving down overlapping icons.
 405  *  BOOL zones == search for drag zones.  If this is set, the routine
 406  *   searches for selected icons only.  If it is clear, zones are not
 407  *   checked.
 408  *
 409  * Returns
 410  *  An icon number, or -1 for the background.
 411  */
 412
 413 int window__pointerInfo(glass_windPointer *w,int from,BOOL zones);
 414
 415 /*
 416  * BOOL window__pointerOverIcon(glass_windPointer *w,int icon)
 417  *
 418  * Use
 419  *  Informs the caller if the pointer is over the bounding box of the icon
 420  *  specified.
 421  *
 422  * Parameters
 423  *  glass_windPointer *w == window containing icon
 424  *  int icon == icon to check for
 425  */
 426
 427 BOOL window__pointerOverIcon(glass_windPointer *w,int icon);
 428
 429 /*
 430  * void window__setPtrShape(int icon)
 431  *
 432  * Use
 433  *  Sets the pointer shape accoding to the 'drag zone' part of the given
 434  *  icon number.
 435  *
 436  * Parameters
 437  *  int icon == the icon number
 438  */
 439
 440 void window__setPtrShape(int icon);
 441
 442 /*----- Selection handling ------------------------------------------------*/
 443
 444 /*
 445  * void window__select(glass_windPointer *w,int icon,BOOL sel)
 446  *
 447  * Use
 448  *  Selects or deselects the given icon.
 449  *
 450  * Parameters
 451  *  glass_windPointer *w == the window we're talking about
 452  *  int icon == the icon to select (or not)
 453  *  BOOL sel == TRUE to select, FALSE to deslect
 454  */
 455
 456 void window__select(glass_windPointer *w,int icon,BOOL sel);
 457
 458 /*
 459  * void window__setSelectedIcon(int i)
 460  *
 461  * Use
 462  *  Makes the specified icon in the current selection owner highlighted.
 463  *
 464  * Parameters
 465  *  int i == the icon number to highlight
 466  */
 467
 468 void window__setSelectedIcon(int i);
 469
 470 /*
 471  * void window__setSelectedIconDeselecting(int i)
 472  *
 473  * Use
 474  *  Sets up the currently selected icon, deselecting the old one.
 475  *
 476  * Parameters
 477  *  int i == the new icon to select
 478  */
 479
 480 void window__setSelectedIconDeselecting(int i);
 481
 482 /*
 483  * int window__lowestSelected(glass_windPointer *w)
 484  *
 485  * Use
 486  *  Returns the selected icon with the lowest number in the specified window.
 487  */
 488
 489 int window__lowestSelected(glass_windPointer *w);
 490
 491 /*
 492  * void window__gainSelection(glass_windPointer *w)
 493  *
 494  * Use
 495  *  Gives the specified window the input focus, tool and info bars, and the
 496  *  selection.  If 0 is specified, then the tool bars are taken down, and no
 497  *  selection is set.
 498  *
 499  * Parameters
 500  *  glass_windPointer *w == the new selection owner
 501  */
 502
 503 void window__gainSelection(glass_windPointer *w);
 504
 505 /*
 506  * int window__selectedIcon(void)
 507  *
 508  * Use
 509  *  Returns the currently selected icon
 510  */
 511
 512 int window__selectedIcon(void);
 513
 514 /*
 515  * void window__renumberSelectedIcon(int nsel)
 516  *
 517  * Use
 518  *  To be called when the selected icon is renumbered.
 519  */
 520
 521 void window__renumberSelectedIcon(int nsel);
 522
 523 /*----- Icon manipulation -------------------------------------------------*/
 524
 525 /*
 526  * void window__bound(wimp_icon *i,wimp_box *box,BOOL force)
 527  *
 528  * Use
 529  *  Works out the bounding box (including 3D border) of the given pseudoicon.
 530  *
 531  * Parameters
 532  *  wimp_icon *i == pointer to an icon definition
 533  *  wimp_box *box == where to put the result
 534  *  BOOL force == force reading of the border, even if disabled in prefs
 535  */
 536
 537 void window__bound(wimp_icon *i,wimp_box *box,BOOL force);
 538
 539 /*
 540  * void window__removeTrailingDeleted(glass_windPointer *w)
 541  *
 542  * Use
 543  *  Removes trailing deleted icons from a window (i.e. ones that can be
 544  *  safely deleted properly without messing up icon numbers).
 545  *
 546  * Parameters
 547  *  glass_windPointer *w == the window to blitz
 548  */
 549
 550 void window__removeTrailingDeleted(glass_windPointer *w);
 551
 552 /*
 553  * int window__createIcon(glass_windPointer *w)
 554  *
 555  * Use
 556  *  Creates a slot for an icon in the window specified, according to current
 557  *  preferences.  The contents of the icon array are unspecified (and
 558  *  probably not too useful).
 559  *
 560  * Parameters
 561  *  glass_windPointer *w == the window to create the icon in
 562  *
 563  * Returns
 564  *  Icon number that can be used, or -1 if the operation failed.
 565  */
 566
 567 int window__createIcon(glass_windPointer *w);
 568
 569 /*
 570  * void window__renumber(glass_windPointer *w,BOOL renum)
 571  *
 572  * Use
 573  *  Sets the renumber flag of the given window to the given state.
 574  *  Everything is set up properly according to the new state.
 575  *
 576  * Parameters
 577  *  glass_windPointer *w == the window to renumber
 578  *  BOOL renum == the new state of the flag
 579  */
 580
 581 void window__renumber(glass_windPointer *w,BOOL renum);
 582
 583 /*
 584  * void window__copyIcons(glass_windPointer *w)
 585  *
 586  * Use
 587  *  Copies the selected icons into the given window.  If the icons are
 588  *  already in the given window, they are duplicated and offset by a small
 589  *  quantity.  If the icons are in a different window, then they are
 590  *  centred over the current visible area.
 591  *
 592  * Parameters
 593  *  glass_windPointer *w == the window to put the icons
 594  */
 595
 596 void window__copyIcons(glass_windPointer *w);
 597
 598 /*
 599  * void window__nudgeIcons(glass_windPointer *w,wimp_box *nudge)
 600  *
 601  * Use
 602  *  Nudges the selected icons in the specified window, by adding the box
 603  *  given to each icon's bounding box.  The nudge box is multiplied either by
 604  *  the current grid size (if grid lock is enabled) or by the pixel size (if
 605  *  it isn't) before addition.  A nudge is considered to be a single
 606  *  alteration for the purposes of autosave-counting.  If no icons are moved
 607  *  then the selected guidelines are moved instead.
 608  *
 609  * Parameters
 610  *  glass_windPointer *w == the window containing the icons to nudge
 611  *  wimp_box *nudge == the box to add to the coordinates of the icons
 612  */
 613
 614 void window__nudgeIcons(glass_windPointer *w,wimp_box *nudge);
 615
 616 /*----- Window manipulation -----------------------------------------------*/
 617
 618 /*
 619  * wimp_w window__recreate(glass_windPointer *w)
 620  *
 621  * Use
 622  *  Recreates a window, getting all the fiddly bits right.
 623  *
 624  * Parameters
 625  *  glass_windPointer *w == the window
 626  *
 627  * Returns
 628  *  The window handle, or 0 for failure
 629  */
 630
 631 wimp_w window__recreate(glass_windPointer *w);
 632
 633 /*
 634  * void window__nudgeScroll(glass_windPointer *w,int x,int y)
 635  *
 636  * Use
 637  *  Scrolls the window a bit, by adding the x and y values given to the
 638  *  scroll offsets of the window.  The values are multiplied up to give a
 639  *  sensible sized scroll.
 640  *
 641  * Parameters
 642  *  glass_windPointer *w == the window to scroll
 643  *  int x == the x scroll offset to add
 644  *  int y == the y scroll offset to add
 645  */
 646
 647 void window__nudgeScroll(glass_windPointer *w,int x,int y);
 648
 649 /*----- The main menu -----------------------------------------------------*/
 650
 651 /*
 652  * glass_windPointer *window__menuOwner(void)
 653  *
 654  * Use
 655  *  Returns which window currently owns the menu.
 656  *
 657  * Returns
 658  *  A pointer to the window's anchor block.
 659  */
 660
 661 glass_windPointer *window__menuOwner(void);
 662
 663 /*
 664  * void window__updateMenu(glass_windPointer *w)
 665  *
 666  * Use
 667  *  Updates the menu attached to the main window.
 668  *
 669  * Parameters
 670  *  glass_windPointer *w == pointer to owning menu
 671  */
 672
 673 void window__updateMenu(glass_windPointer *w);
 674
 675 /*
 676  * void window__simMenu(glass_windPointer *w,int hit1,int hit2)
 677  *
 678  * Use
 679  *  Simulates a menu hit on the specified item.  Gives a beep if the item
 680  *  is unavailable.  Otherwise, the hit is sent to the current selection
 681  *  owner.  [fixed to allow which window is used rather than only the
 682  *  selection owner, 1 November 1993]
 683  *
 684  * Use
 685  *  glass_windPointer *w == the window in which to simulate the event
 686  *  int hit1 == first hit in the sequence
 687  *  int hit2 == second hit in the sequence
 688  */
 689
 690 void window__simMenu(glass_windPointer *w,int hit1,int hit2);
 691
 692 /*
 693  * void window__showMenu(int x,int y,glass_windPointer *w)
 694  *
 695  * Use
 696  *  Displays the Template Window Menu
 697  *
 698  * Parameters
 699  *  int x,int y == the (window) position to display the menu
 700  *  glass_windPointer *w == the window to display the menu for
 701  */
 702
 703 void window__showMenu(int x,int y,glass_windPointer *w);
 704
 705 /*
 706  * void window__menuInit(void)
 707  *
 708  * Use
 709  *  Initialises the create icon menu
 710  */
 711
 712 void window__menuInit(void);
 713
 714 /*----- Handling the toolbars ---------------------------------------------*/
 715
 716 /*
 717  * void window__setToolBarPositions(wimp_openstr *o)
 718  *
 719  * Use
 720  *  Displays the tool and info bars according to current settings etc.
 721  *
 722  * Parameters
 723  *  wimp_openstr *o == the position of the selection owner window, or 0.
 724  *    This is updated to put the window somewhere nice without flicker.
 725  */
 726
 727 void window__setToolBarPositions(wimp_openstr *o);
 728
 729 /*
 730  * void window__updateInfoBar(void)
 731  *
 732  * Use
 733  *  Updates the settings on the info bar.  If a setting hasn't changed, then
 734  *  it isn't updated (reducing flicker).
 735  *
 736  * Parameters
 737  *  BOOL force == whether to force an update of everything.
 738  */
 739
 740 void window__updateInfoBar(BOOL force);
 741
 742 /*
 743  * void window__toggleRenumber(glass_windPointer *w)
 744  *
 745  * Use
 746  *  Updates the info bar after entering or leaving renumber-mode.  w is
 747  *  the currently selected window.
 748  */
 749
 750 void window__toggleRenumber(glass_windPointer *w);
 751
 752 /*
 753  * void window__toggleTest(glass_windPointer *w)
 754  *
 755  * Use
 756  *  Updates the info bar after entering or leaving test-mode.  w is the
 757  *  currently selected window.
 758  */
 759
 760 #ifndef glass_DEMO
 761 void window__toggleTest(glass_windPointer *w);
 762 #endif
 763
 764 /*
 765  * void window__updateInfoName(char *newname)
 766  *
 767  * Use
 768  *  Updates the name in the info bar
 769  */
 770
 771 void window__updateInfoName(char *newname);
 772
 773 /*
 774  * void window__nextRenumber(glass_windPointer *w)
 775  *
 776  * Use
 777  *  Updates the next renumber icon number display.
 778  */
 779
 780 void window__nextRenumber(glass_windPointer *w);
 781
 782 /*
 783  * void window__moveToolbars(glass_windPointer *w)
 784  *
 785  * Use
 786  *  Moves the toolbars and attaches them to a new window
 787  *
 788  * Parameters
 789  *  glass_windPointer *w == the window to attach the bars to
 790  */
 791
 792 void window__moveToolbars(glass_windPointer *w);
 793
 794 /*
 795  * void window__tbarInit(void)
 796  *
 797  * Use
 798  *  Initialises the toolbar system
 799  */
 800
 801 void window__tbarInit(void);
 802
 803 /*----- The icon palette --------------------------------------------------*/
 804
 805 /*
 806  * void window__showPalette(void)
 807  *
 808  * Use
 809  *  Displays the palette window, as set up in the Defaults template file.
 810  */
 811
 812 void window__showPalette(void);
 813
 814 /*----- The main event handlers -------------------------------------------*/
 815
 816 /*
 817  * void window__winIdles(void *handle)
 818  *
 819  * Use
 820  *  Changes the pointer shape to something appropriate for what its over.
 821  *
 822  * Parameters
 823  *  void *handle == pointer to window containing pointer
 824  */
 825
 826 void window__winIdles(void *handle);
 827
 828 /*
 829  * void window__testEvents(wimp_eventstr *e,void *handle)
 830  *
 831  * Use
 832  *  Handles all events for windows running in Test mode.  Events handled
 833  *  are:
 834  *
 835  *  Redraw   Redraws the window using Interface/hatch pattern as requested.
 836  *  Open     Moves the window around.
 837  *  Close    Closes the window(!)
 838  *  Leave    Ignored
 839  *  Enter    Turn off STEEL pointer changing
 840  *  Click    Handled by WIMP or Interface, except for menu, which opens
 841  *           the menu(!)
 842  *  Key      Handled by WIMP, WimpExtension, or ignored
 843  *
 844  * Parameters
 845  *  wimp_eventstr *e == the event
 846  *  void *handle == pointer to window info
 847  */
 848
 849 #ifndef glass_DEMO
 850 void window__testEvents(wimp_eventstr *e,void *handle);
 851 #endif
 852
 853 /*
 854  * void window__events(wimp_eventstr *e,void *handle)
 855  *
 856  * Use
 857  *  Handles all events for template windows (this is the first chance I've
 858  *  had to get my fingers *REALLY* mucky on this whole project!)
 859  *
 860  * Parameters
 861  *  wimp_eventstr *e == the event that I am meant to be inerested in
 862  *  void *handle == a pointer to the structural information for this window
 863  */
 864
 865 void window__events(wimp_eventstr *e,void *handle);
 866
 867 /*----- THE END -----------------------------------------------------------*/
 868
 869 #endif