Return to jigsaw.c CVS log

Up to [OS/2 SDKs] / pmsdk / samples / jigsaw

Annotation of pmsdk/samples/jigsaw/jigsaw.c, revision 1.1

1.1     ! root        1: /********************************** Jigsaw  ***********************************/
        !             2: /*                                                                            */
        !             3: /* Created 1988, Microsoft Corporation.                                      */
        !             4: /*                                                                            */
        !             5: /* Purpose:  To illustrate the use of Gpi retained segments.                 */
        !             6: /*                                                                            */
        !             7: /* Summary:  This program provides a jigsaw puzzle, based on a decomposition  */
        !             8: /*   of an arbitrary bitmap loaded from a file.  The user can jumble the      */
        !             9: /*   pieces, then drag them individually by means of the mouse.  The image    */
        !            10: /*   can be zoomed in and out and scrolled up/down and left/right.           */
        !            11: /*                                                                            */
        !            12: /*   Each piece of the puzzle is a retained segment.  When a piece is        */
        !            13: /*   selected for dragging, it is made dynamic.  A menu option allows the     */
        !            14: /*   selected piece to be dragged as an outline or as a normal-looking piece. */
        !            15: /*                                                                            */
        !            16: /*   Individual pieces are made to "move" by changing their model transforms. */
        !            17: /*   Scrolling and zooming of the whole picture is done by changing the       */
        !            18: /*   default viewing transform.                                              */
        !            19: /*                                                                            */
        !            20: /* Optimizations:  While it is possible to implement this puzzle using a very */
        !            21: /*   naive approach, this is liable to lead to a rather slowly-operating      */
        !            22: /*   program.  The following optimizations dramatically improve program       */
        !            23: /*   performance:                                                            */
        !            24: /*                                                                            */
        !            25: /*   1> BitBlt only as much of the bitmap through a clip path as necessary.   */
        !            26: /*   Each piece of the puzzle is drawn by defining a clip path, blitting      */
        !            27: /*   through the path, and drawing an outline on the same path.  The naive    */
        !            28: /*   approach is to blit the whole bitmap through the clip path.  A more      */
        !            29: /*   clever approach is to compute the piece's bounding box and only use      */
        !            30: /*   the source and destination rectangles which correspond to this box.      */
        !            31: /*   This leads to an order-of-magnitude speedup in the time to draw one      */
        !            32: /*   piece.                                                                  */
        !            33: /*                                                                            */
        !            34: /*   2> Make the source and target rectangles for BitBlt the same size       */
        !            35: /*   in device coordinates.  A BitBlt in a retained segment must be done      */
        !            36: /*   with GpiWCBitBlt and the target rectangle must be specified in world     */
        !            37: /*   coordinates, so you must use GpiConvert (taking into account that in     */
        !            38: /*   world space rectangles are inclusive-inclusive while in device space     */
        !            39: /*   rectangles are inclusive-exclusive) to compute what target world space   */
        !            40: /*   rectangle will be converted to the desired device space rectangle.       */
        !            41: /*   Making the sizes of the source and converted target rectangles differ    */
        !            42: /*   by even one pel will cause strectching or compression to occur, with     */
        !            43: /*   a dramatic loss in speed. Unfortunately, due to rounding effects, it is */
        !            44: /*   not always possible to guarantee that adding an offset to the           */
        !            45: /*   transformation applied to a segment will leave the size of the          */
        !            46: /*   rectangle defined by the orders in the segment unchanged.               */
        !            47: /*                                                                            */
        !            48: /*   3> Use auxiliary information to reduce the number of segments which      */
        !            49: /*   must be checked for correlation.  The naive approach to hit-testing is   */
        !            50: /*   to test the whole chain, even though generally only a small fraction of  */
        !            51: /*   the segments in the chain could possibly get a hit.  A more clever       */
        !            52: /*   approach is to take the bounding box for each segment and only include   */
        !            53: /*   the segment in the correlation check if the box contains the correlation */
        !            54: /*   point.  eg.                                                             */
        !            55: /*    a> Edit the chain by adjusting the ATTR_CHAINED attribute of each       */
        !            56: /*    segment to reflect candidacy for being hit.  Afterwards, fix up by      */
        !            57: /*    adding back removed segments to the chain.                             */
        !            58: /*    b> Even faster is to keep an auxiliary data structure which records     */
        !            59: /*    the priority of the segments (placed in the SEGLIST chain).  Run       */
        !            60: /*    through the priority list from high-priority to low-priority and do a   */
        !            61: /*    correlation test on each segment which passes the bounding-box test.    */
        !            62: /*                                                                            */
        !            63: /*   4> When repainting through a clip region, only draw those segments which */
        !            64: /*   overlap the clip region.  The naive approach is to set up the clip       */
        !            65: /*   region and do a GpiDrawChain on the whole chain.  The drawback to this   */
        !            66: /*   is that much time will be spent running through the orders in segments   */
        !            67: /*   which are not visible through the clip region.  Very often, most of the  */
        !            68: /*   segments in the picture can be eliminated from needing to be drawn by    */
        !            69: /*   recognizing that there is no overlap between the bounding boxes of the   */
        !            70: /*   segment and the clip region.                                            */
        !            71: /*                                                                            */
        !            72: /*   5> Do WinScrollWindow horizontally in multiples of 8 pels when possible. */
        !            73: /*   For example, horizontal scrolls by 7 or 9 pels are much slower than a    */
        !            74: /*   a horizontal scroll by 8 pels.                                          */
        !            75: /*                                                                            */
        !            76: /******************************************************************************/
        !            77: 
        !            78: #define INCL_BITMAPFILEFORMAT
        !            79:  
        !            80: #define INCL_DOSPROCESS
        !            81: #define INCL_DOSSEMAPHORES
        !            82: #define INCL_DOSMEMMGR
        !            83: 
        !            84: #define INCL_DEV
        !            85: 
        !            86: #define INCL_WINWINDOWMGR
        !            87: #define INCL_WINMESSAGEMGR
        !            88: #define INCL_WININPUT
        !            89: #define INCL_WINRECTANGLES
        !            90: #define INCL_WINPOINTERS
        !            91: #define INCL_WINMENUS
        !            92: #define INCL_WINSCROLLBARS
        !            93: #define INCL_WINFRAMEMGR
        !            94: #define INCL_WINSWITCHLIST
        !            95: #define INCL_WINSYS
        !            96: 
        !            97: #define INCL_GPIBITMAPS
        !            98: #define INCL_GPICONTROL
        !            99: #define INCL_GPITRANSFORMS
        !           100: #define INCL_GPIPRIMITIVES
        !           101: #define INCL_GPIMETAFILES
        !           102: #define INCL_GPIPATHS
        !           103: #define INCL_GPIREGIONS
        !           104: #define INCL_GPISEGMENTS
        !           105: #define INCL_GPISEGEDITING
        !           106: #define INCL_GPICORRELATION
        !           107: #define INCL_GPILCIDS
        !           108:  
        !           109: #define INCL_ERRORS
        !           110:  
        !           111: #include <os2.h>
        !           112: #include <stdlib.h>
        !           113: #include <stdio.h>
        !           114: #include <string.h>
        !           115: #include <opendlg.h>
        !           116: #include "jigsaw.h"
        !           117:  
        !           118:  
        !           119:  
        !           120: /*----------------------- inter-thread messages ------------------------------*/
        !           121:  
        !           122: #define UM_DIE       WM_USER+1        /* instruct async thread to terminate  */
        !           123: #define UM_DRAW       WM_USER+2        /* draw the current picture           */
        !           124: #define UM_VSCROLL    WM_USER+3        /* perform scroll by recalculating the */
        !           125:                                        /* default viewing transform           */
        !           126: #define UM_HSCROLL    WM_USER+4        /* perform scroll by recalculating the */
        !           127:                                        /* default viewing transform           */
        !           128: #define UM_SIZING     WM_USER+5        /* perform sizing by recalculating the */
        !           129:                                        /* default viewing transform           */
        !           130: #define UM_ZOOM_IN    WM_USER+6        /* zoom the picture by recalculating   */
        !           131:                                        /* the default viewing transform       */
        !           132: #define UM_ZOOM_OUT   WM_USER+7        /* zoom the picture by recalculating   */
        !           133:                                        /* the default viewing transform       */
        !           134: #define UM_REDRAW     WM_USER+8
        !           135: #define UM_JUMBLE     WM_USER+9
        !           136: #define UM_LOAD       WM_USER+10
        !           137: #define UM_DUMMY      WM_USER+11       /* all commands not forcing redraw     */
        !           138:                                        /* must come after this one            */
        !           139:  
        !           140: #define UM_LEFTDOWN   WM_USER+12       /* mouse button down in the client area*/
        !           141:                                       /* perform a correlation on the current*/
        !           142:                                       /* picture, setting any picked segment */
        !           143:                                       /* to dynamic                          */
        !           144: #define UM_MOUSEMOVE  WM_USER+13       /* mousemove command, remove, repositon*/
        !           145:                                       /* and redraw any dynamic sements      */
        !           146: #define UM_LEFTUP     WM_USER+14       /* mouse button up in the client area  */
        !           147:                                        /* set any dynamic segment to normal   */
        !           148: #define UM_FASTDRAG   WM_USER+15       /* toggle fast-drag (outline) mode     */
        !           149: #define UM_DRAWDONE   WM_USER+16       /* Async DrawChain has completed       */
        !           150: #define UM_FLUSH      WM_USER+17
        !           151:  
        !           152:  
        !           153: /*------------------------ element label values  -----------------------------*/
        !           154:  
        !           155: #define FILLPATH       222L
        !           156: #define BITBLT_TOP     232L
        !           157: #define BITBLT_BOTTOM  233L
        !           158:  
        !           159:  
        !           160: /*------------------------- correlation parameters ---------------------------*/
        !           161:  
        !           162: #define HITS   1L                     /* maximum number of hits to return    */
        !           163: #define DEPTH  2L                     /* max depth of seg calls to return    */
        !           164:  
        !           165:  
        !           166: /*-------------------------- general definitions -----------------------------*/
        !           167:  
        !           168:  
        !           169: HAB    habMain=NULL;                  /* main thread anchor block handle     */
        !           170: HMQ    hmqMain=NULL;                  /* main thread queue handle            */
        !           171: HWND    hwndFrame=NULL;                /* frame control handle                */
        !           172: HWND   hwndClient=NULL;               /* client area handle                  */
        !           173: HDC    hdcClient=NULL;                /* window dc handle                    */
        !           174: HPS    hpsClient=NULL;                /* client area Gpi ps handle           */
        !           175: SIZEL  sizlMaxClient;                 /* max client area size                */
        !           176: HPS     hpsPaint=NULL;                 /* ps for use in Main Thread           */
        !           177: HRGN   hrgnInvalid = NULL;            /* handle to the invalid region        */
        !           178:  
        !           179: HAB    habAsync=NULL;                 /* async thread anchor block handle    */
        !           180: HMQ    hmqAsync=NULL;                 /* async thread queue handle           */
        !           181: TID     tidAsync;                      /* async thread id                     */
        !           182: SEL    selStack;                      /* async thread stack selector         */
        !           183: #define STACKSIZE  4096               /* async thread stack size             */
        !           184: SHORT  sPrty = -1;                    /* async thread priority               */
        !           185:  
        !           186: HWND   hwndHorzScroll=NULL;           /* horizontal scroll bar window        */
        !           187: HWND   hwndVertScroll=NULL;           /* vertical scroll bar window          */
        !           188: POINTS ptsScrollPos, ptsOldScrollPos;
        !           189: POINTS ptsScrollMax, ptsHalfScrollMax;
        !           190: POINTS ptsScrollLine = { 8, 8};
        !           191: POINTS ptsScrollPage = { 64, 64};
        !           192:  
        !           193: #define UNITY         65536L
        !           194: MATRIXLF matlfIdentity = { UNITY, 0, 0, 0, UNITY, 0, 0, 0, 1 };
        !           195: LONG   lScale = 0;                    /* current zoom level                  */
        !           196: #define ZOOM_MAX       8
        !           197: #define ZOOM_IN_ARG    1
        !           198: #define ZOOM_OUT_ARG   -1
        !           199:  
        !           200: #define CALLSEG_BASE   1000
        !           201: POINTL ptlOffset;
        !           202: POINTL ptlBotLeft  = { 0, 0};
        !           203: POINTL ptlTopRight = { 300, 300};
        !           204: LONG   lLastSegId;                    /* last segment id assigned to a piece */
        !           205: LONG   lPickedSeg;                    /* seg id of piece selected for drag   */
        !           206: RECTL  rclBounds;                     /* pict bounding box in model coords.  */
        !           207: POINTL ptlOldMouse = {0L, 0L};        /* current mouse posn                  */
        !           208: BOOL   fButtonDown = FALSE;           /* only drag if mouse down             */
        !           209: BOOL   fFastDrag = FALSE;             /* show only outline of dragging piece */
        !           210: 
        !           211: 
        !           212: /*-------------------------- segment list ------------------------------------*/
        !           213: 
        !           214: typedef struct _SEGLIST {             /* sl                                  */
        !           215:     LONG                 lSegId;
        !           216:     struct _SEGLIST FAR * pslPrev;
        !           217:     struct _SEGLIST FAR * pslNext;
        !           218:     POINTL               ptlLocation; /* piece location, world coordinates   */
        !           219:     RECTL                rclCurrent;  /* segment bounding box, model coords  */
        !           220:     RECTL                rclBitBlt;   /* segment bounding box, world coords  */
        !           221: } SEGLIST ;
        !           222: typedef SEGLIST FAR *PSEGLIST;        /* psl                                 */
        !           223: typedef PSEGLIST FAR *PPSEGLIST;       /* ppsl                               */
        !           224: PSEGLIST pslHead = NULL;              /* head of the list                    */
        !           225: PSEGLIST pslTail = NULL;              /* tail of the list                    */
        !           226: PSEGLIST pslPicked = NULL;            /* picked segment's list member        */
        !           227: #define   ADD_HEAD_SEG  1
        !           228: #define   ADD_TAIL_SEG  2
        !           229: #define        DEL_SEG  3
        !           230:  
        !           231: /*-------------------------- bitmap-related data -----------------------------*/
        !           232: 
        !           233: typedef struct _LOADINFO {            /* li                                  */
        !           234:     HFILE   hf;
        !           235:     CHAR    szFileName[MAX_FNAME_LEN];
        !           236: } LOADINFO ;
        !           237: typedef LOADINFO FAR *PLOADINFO;       /* pli                                */
        !           238: 
        !           239: HPS               hpsBitmapFile=NULL, hpsBitmapTemp=NULL, hpsBitmapDrag=NULL;
        !           240: HDC               hdcBitmapFile=NULL, hdcBitmapTemp=NULL, hdcBitmapDrag=NULL;
        !           241: HBITMAP           hbmBitmapFile=NULL, hbmBitmapTemp=NULL, hbmBitmapDrag=NULL;
        !           242: BITMAPINFOHEADER   bmpBitmapFile   = {12L, 0, 0, 0, 0};
        !           243: BITMAPINFOHEADER   bmpBitmapTemp   = {12L, 0, 0, 0, 0};
        !           244: BITMAPINFOHEADER   bmpBitmapDrag   = {12L, 0, 0, 0, 0};
        !           245: BITMAPINFO        bmiBitmap       = {12L, 0, 0, 0, 0, {{0, 0, 0}}};
        !           246: static DEVOPENSTRUC dop = { NULL
        !           247:                          , "DISPLAY"
        !           248:                          , NULL
        !           249:                          , NULL
        !           250:                          , NULL
        !           251:                          , NULL
        !           252:                          , NULL
        !           253:                          , NULL
        !           254:                          , NULL };
        !           255: 
        !           256: 
        !           257: /*-------------------------- old-style bitmap header -------------------------*/
        !           258: 
        !           259: typedef struct {
        !           260:     USHORT    wType;
        !           261:     ULONG     dwSize;
        !           262:     int       xHotspot;
        !           263:     int       yHotspot;
        !           264:     ULONG     dwBitsOffset;
        !           265:     USHORT    bmWidth;
        !           266:     USHORT    bmHeight;
        !           267:     USHORT    bmPlanes;
        !           268:     USHORT    bmBitcount;
        !           269: } RCBITMAP;
        !           270: typedef RCBITMAP FAR *PRCBITMAP;
        !           271: 
        !           272: 
        !           273: /*--------------------------- Miscellaneous ----------------------------------*/
        !           274:  
        !           275: ULONG  ulTerminateSem = 0;            /* main thread blocks while async dies */
        !           276: HSEM   hsemTerminate  = &ulTerminateSem;
        !           277: 
        !           278: ULONG  ulSzFmt   = 0;                 /* serializes access to sprintf()      */
        !           279: HSEM   hsemSzFmt = &ulSzFmt;
        !           280: CHAR   szFmt[50];                     /* buffer used by sprintf()            */
        !           281: 
        !           282: SWCNTRL swctl = { 0, 0, 0, 0, 0, SWL_VISIBLE, SWL_JUMPABLE, NULL, 0 };
        !           283: HSWITCH hsw;                          /* handle to a switch list entry       */
        !           284: char   szTitle[80];                   /* Title bar text                      */
        !           285: 
        !           286: BOOL   fErrMem = FALSE;               /* set if alloc async stack fails      */
        !           287:  
        !           288:  
        !           289: /*------------------------- Function Prototypes ------------------------------*/
        !           290: 
        !           291: VOID    CalcBounds( VOID);
        !           292: VOID    CalcTransform( HWND);
        !           293: MRESULT CALLBACK ClientWndProc( HWND, USHORT, MPARAM, MPARAM);
        !           294: BOOL    CreateBitmapHdcHps( HDC, HPS);
        !           295: BOOL    CreateThread( VOID);
        !           296: BOOL    CreatePicture( VOID);
        !           297: VOID    DestroyThread( VOID);
        !           298: BOOL    DoDraw( HRGN);
        !           299: VOID    DoHorzScroll( VOID);
        !           300: VOID    DoVertScroll( VOID);
        !           301: BOOL    DumpPicture( VOID);
        !           302: VOID    Finalize( VOID);
        !           303: BOOL    Initialize( VOID);
        !           304: VOID    Jumble( VOID);
        !           305: VOID    LeftDown( MPARAM);
        !           306: VOID    LeftUp( VOID);
        !           307: VOID    Load( PLOADINFO);
        !           308: VOID cdecl main( VOID);
        !           309: VOID    MessageInt( HWND, INT, PCH);
        !           310: VOID    MouseMove( MPARAM);
        !           311: VOID    MyMessageBox( HWND, PSZ);
        !           312: VOID FAR NewThread( VOID);
        !           313: BOOL    PrepareBitmap( VOID);
        !           314: BOOL    ReadBitmap( HFILE);
        !           315: VOID    Redraw( VOID);
        !           316: VOID    ReportError( HAB);
        !           317: BOOL    SegListCheck( INT);
        !           318: PSEGLIST SegListGet( LONG);
        !           319: BOOL    SegListUpdate( USHORT, PSEGLIST);
        !           320: BOOL    SendCommand( USHORT, ULONG);
        !           321: VOID    SetDVTransform( FIXED, FIXED, FIXED, FIXED, LONG, LONG, LONG);
        !           322: VOID    SetRect( PSEGLIST);
        !           323: VOID    ToggleFastDrag( VOID);
        !           324: VOID    Translate( PSEGLIST, PPOINTL);
        !           325: MRESULT  WndProcCommand( HWND, USHORT, MPARAM, MPARAM);
        !           326: MRESULT  WndProcCreate( HWND);
        !           327: MRESULT  WndProcPaint( VOID);
        !           328: MRESULT  WndProcSize( MPARAM, MPARAM);
        !           329: VOID    Zoom( SHORT);
        !           330: VOID    ZoomMenuItems( VOID);
        !           331: 
        !           332:  
        !           333: /******************************************************************************/
        !           334: /*                                                                           */
        !           335: /*  MyMessageBox                                                             */
        !           336: /*                                                                           */
        !           337: /*  Displays a message box with the given string.  To simplify matters,       */
        !           338: /*  the box will always have the same title ("Jigsaw"), will always          */
        !           339: /*  have a single button ("Ok"), will always have an exclamation point       */
        !           340: /*  icon, and will always be application modal.                              */
        !           341: /*                                                                           */
        !           342: /******************************************************************************/
        !           343: VOID
        !           344: MyMessageBox( hWnd, psz)
        !           345: 
        !           346: HWND  hWnd;
        !           347: PSZ   psz;
        !           348: {
        !           349:     WinMessageBox( HWND_DESKTOP
        !           350:                 , hWnd
        !           351:                 , psz
        !           352:                 , szTitle
        !           353:                 , NULL
        !           354:                 , MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL );
        !           355: }
        !           356: 
        !           357: /******************************************************************************/
        !           358: /*                                                                            */
        !           359: /* Main thread will initialize the process for PM services and process       */
        !           360: /* the application message queue until a WM_QUIT message is received. It will */
        !           361: /* then destroy all PM resources and terminate. Any error during             */
        !           362: /* initialization will be reported and the process terminated.                */
        !           363: /*                                                                            */
        !           364: /******************************************************************************/
        !           365: VOID cdecl
        !           366: main()
        !           367: {
        !           368:   QMSG qmsg;
        !           369:  
        !           370:   if( Initialize())
        !           371:       while( WinGetMsg( habMain, &qmsg, NULL, NULL, NULL))
        !           372:          WinDispatchMsg( habMain, &qmsg);
        !           373:   else
        !           374:       ReportError( habMain);
        !           375:   Finalize();
        !           376: }
        !           377:  
        !           378:  
        !           379: /******************************************************************************/
        !           380: /*                                                                            */
        !           381: /* The Initialize function will initialize the PM interface,                 */
        !           382: /* create an application message queue, a standard frame window and a new     */
        !           383: /* thread to control drawing operations.  It will also initialize static      */
        !           384: /* strings.                                                                   */
        !           385: /*                                                                            */
        !           386: /******************************************************************************/
        !           387: BOOL
        !           388: Initialize()
        !           389: {
        !           390:   ULONG   flCreate;
        !           391:   PID    pid;
        !           392:   TID    tid;
        !           393:  
        !           394:   WinShowPointer( HWND_DESKTOP, TRUE);
        !           395:   habMain = WinInitialize( NULL);
        !           396:   if( !habMain)
        !           397:       return( FALSE);
        !           398:  
        !           399:   hmqMain = WinCreateMsgQueue( habMain,0);
        !           400:   if( !hmqMain)
        !           401:       return( FALSE);
        !           402:  
        !           403:   WinLoadString( habMain, NULL, TITLEBAR, sizeof(szTitle), szTitle);
        !           404:   if( !WinRegisterClass( habMain
        !           405:                       , (PCH)szTitle
        !           406:                       , (PFNWP)ClientWndProc
        !           407:                       , CS_SIZEREDRAW
        !           408:                       , 0 ))
        !           409:       return( FALSE);
        !           410:  
        !           411:   flCreate =   (FCF_STANDARD | FCF_VERTSCROLL | FCF_HORZSCROLL)
        !           412:             & ~(ULONG)FCF_TASKLIST;
        !           413:   hwndFrame = WinCreateStdWindow( HWND_DESKTOP
        !           414:                                , WS_VISIBLE
        !           415:                                , &flCreate
        !           416:                                , szTitle
        !           417:                                , szTitle
        !           418:                                , WS_VISIBLE
        !           419:                                , NULL
        !           420:                                , APPMENU
        !           421:                                , &hwndClient);
        !           422:   if( !hwndFrame)
        !           423:       return( FALSE);
        !           424: 
        !           425:   WinQueryWindowProcess( hwndFrame, &pid, &tid);
        !           426:   swctl.hwnd     = hwndFrame;
        !           427:   swctl.idProcess = pid;
        !           428:   lstrcpy( swctl.szSwtitle, szTitle);
        !           429:   hsw = WinAddSwitchEntry( &swctl);
        !           430: 
        !           431:   if( !CreateThread())               /* create async thread                 */
        !           432:       return ( FALSE);
        !           433:   if( !CreateBitmapHdcHps( &hdcBitmapFile, &hpsBitmapFile))
        !           434:       return( FALSE);
        !           435:   if( !CreateBitmapHdcHps( &hdcBitmapTemp, &hpsBitmapTemp))
        !           436:       return( FALSE);
        !           437:   if( !CreateBitmapHdcHps( &hdcBitmapDrag, &hpsBitmapDrag))
        !           438:       return( FALSE);
        !           439:  
        !           440:   return( TRUE);
        !           441: }
        !           442:  
        !           443: /******************************************************************************/
        !           444: /*                                                                            */
        !           445: /* Finalize will destroy the asynchronous drawing thread, all Presentation    */
        !           446: /* Manager resources, and terminate the process.                              */
        !           447: /*                                                                            */
        !           448: /******************************************************************************/
        !           449: VOID
        !           450: Finalize()
        !           451: {
        !           452:   DestroyThread();
        !           453: 
        !           454:   while( pslHead != NULL )
        !           455:       SegListUpdate( DEL_SEG, pslHead);
        !           456:   if( hrgnInvalid)
        !           457:       GpiDestroyRegion( hpsClient, hrgnInvalid);
        !           458:   if( hpsClient)
        !           459:       GpiAssociate( hpsClient, NULL);
        !           460:   if( hpsPaint)
        !           461:       GpiAssociate( hpsPaint, NULL);
        !           462:   if( hpsBitmapFile)
        !           463:       GpiAssociate( hpsBitmapFile, NULL);
        !           464:   if( hpsBitmapTemp)
        !           465:       GpiAssociate( hpsBitmapTemp, NULL);
        !           466:   if( hpsBitmapDrag)
        !           467:       GpiAssociate( hpsBitmapDrag, NULL);
        !           468:   if( hwndFrame)
        !           469:       WinDestroyWindow( hwndFrame);
        !           470:   if( hmqMain)
        !           471:       WinDestroyMsgQueue( hmqMain);
        !           472:   if( habMain)
        !           473:       WinTerminate( habMain);
        !           474: 
        !           475:   DosExit( EXIT_PROCESS, 0);
        !           476: }
        !           477:  
        !           478:  
        !           479: /******************************************************************************/
        !           480: /*                                                                            */
        !           481: /* ReportError will display the latest error information for the required    */
        !           482: /* thread. No resources to be loaded if out of memory error.                  */
        !           483: /*                                                                            */
        !           484: /******************************************************************************/
        !           485: VOID
        !           486: ReportError( hab)
        !           487: 
        !           488: HAB hab;
        !           489: {
        !           490:   PERRINFO  perriBlk;
        !           491:   PSZ      pszErrMsg;
        !           492:   USHORT *  TempPtr;
        !           493:  
        !           494:   if( !hwndFrame)
        !           495:       return;
        !           496:   if( !fErrMem)
        !           497:   {
        !           498:       perriBlk = WinGetErrorInfo(hab);
        !           499:       if( !perriBlk)
        !           500:           return;
        !           501:       SELECTOROF( pszErrMsg) = SELECTOROF(perriBlk);
        !           502:       SELECTOROF( TempPtr)   = SELECTOROF(perriBlk);
        !           503:       OFFSETOF( TempPtr)     = perriBlk->offaoffszMsg;
        !           504:       OFFSETOF( pszErrMsg)   = *TempPtr;
        !           505:       WinMessageBox( HWND_DESKTOP
        !           506:                   , hwndFrame
        !           507:                   , pszErrMsg
        !           508:                   , szTitle
        !           509:                   , 0
        !           510:                   , MB_CUACRITICAL | MB_ENTER);
        !           511:       WinFreeErrorInfo( perriBlk);
        !           512:   } else
        !           513:       WinMessageBox( HWND_DESKTOP
        !           514:                   , hwndFrame
        !           515:                   , "ERROR - Out Of Memory"
        !           516:                   , szTitle
        !           517:                   , 0
        !           518:                   , MB_CUACRITICAL | MB_ENTER);
        !           519: }
        !           520:  
        !           521:  
        !           522: /******************************************************************************/
        !           523: /*                                                                            */
        !           524: /* CreateThread  creates the asynchronous drawing thread. It will allocate    */
        !           525: /* stack space and create the thread.                                         */
        !           526: /*                                                                            */
        !           527: /******************************************************************************/
        !           528: BOOL
        !           529: CreateThread()
        !           530: {
        !           531:   PBYTE pbAsyncStack;                /* long pointer to stack for new thread */
        !           532:  
        !           533:  
        !           534:   if( DosAllocSeg( STACKSIZE, (PSEL)&selStack, 0 ))
        !           535:   {
        !           536:       fErrMem = TRUE;
        !           537:       return( FALSE);
        !           538:   }
        !           539:   OFFSETOF(pbAsyncStack) = STACKSIZE-2;
        !           540:   SELECTOROF(pbAsyncStack) = selStack;
        !           541:   if( DosCreateThread( (PFNTHREAD)NewThread, &tidAsync, pbAsyncStack ))
        !           542:       return( FALSE);
        !           543:   return( TRUE);
        !           544: }
        !           545:  
        !           546:  
        !           547: /******************************************************************************/
        !           548: /*                                                                            */
        !           549: /* DestroyThread  will send a message  to the asynchronous drawing thread     */
        !           550: /* commanding it to terminate itself. If the send is successful it will wait  */
        !           551: /* until the async thread has terminated. It will then release any stack space*/
        !           552: /* used by that thread.                                                       */
        !           553: /*                                                                            */
        !           554: /******************************************************************************/
        !           555: VOID
        !           556: DestroyThread()
        !           557: {
        !           558:   if( tidAsync)
        !           559:   {
        !           560:       DosSemSet( hsemTerminate);
        !           561:       if( SendCommand( (USHORT)UM_DIE, (ULONG)NULL))
        !           562:          DosSemWait( hsemTerminate, SEM_INDEFINITE_WAIT);
        !           563:   }
        !           564:   if( selStack)
        !           565:       DosFreeSeg( selStack);
        !           566: }
        !           567:  
        !           568:  
        !           569: /******************************************************************************/
        !           570: /*                                                                            */
        !           571: /* SendCommand will attempt to post the required command and parameters to   */
        !           572: /* the asynchronous drawing thread's message queue. The command will only     */
        !           573: /* be posted if the queue exists.                                            */
        !           574: /*                                                                            */
        !           575: /******************************************************************************/
        !           576: BOOL
        !           577: SendCommand( usCommand, ulInfo)
        !           578: 
        !           579: USHORT usCommand;
        !           580: ULONG  ulInfo;
        !           581: {
        !           582:   if( !hmqAsync)
        !           583:       return( FALSE);
        !           584: 
        !           585:   switch( usCommand)
        !           586:   {
        !           587:     case UM_DIE:
        !           588:     case UM_LEFTDOWN:
        !           589:     case UM_LEFTUP:
        !           590:     case UM_MOUSEMOVE:
        !           591:     case UM_DRAW:
        !           592:     case UM_HSCROLL:
        !           593:     case UM_VSCROLL:
        !           594:     case UM_ZOOM_IN:
        !           595:     case UM_ZOOM_OUT:
        !           596:     case UM_REDRAW:
        !           597:     case UM_SIZING:
        !           598:     case UM_FASTDRAG:
        !           599:     case UM_JUMBLE:
        !           600:     case UM_LOAD:
        !           601:  
        !           602:        return( WinPostQueueMsg( hmqAsync
        !           603:                               , usCommand
        !           604:                               , MPFROMLONG( ulInfo)
        !           605:                               , MPFROMLONG( NULL  ) ) );
        !           606:        break;
        !           607: 
        !           608:     default:
        !           609:        return( TRUE);
        !           610:   }
        !           611: }
        !           612:  
        !           613:  
        !           614: /******************************************************************************/
        !           615: /*                                                                            */
        !           616: /* ClientWndProd is the window procedure associated with the client window.   */
        !           617: /*                                                                            */
        !           618: /******************************************************************************/
        !           619: MRESULT CALLBACK
        !           620: ClientWndProc( hwnd, msg, mp1, mp2)
        !           621: 
        !           622: HWND   hwnd;
        !           623: USHORT  msg;
        !           624: MPARAM mp1;
        !           625: MPARAM mp2;
        !           626: {
        !           627:   CHAR  szTemp[128];
        !           628:  
        !           629:   switch( msg)
        !           630:   {
        !           631:     case WM_CREATE:
        !           632:       return( WndProcCreate( hwnd));
        !           633:       break;
        !           634:  
        !           635:     case WM_CLOSE:
        !           636:       WinLoadString( habMain, NULL, TERMINATE, sizeof(szTemp), (PSZ)szTemp );
        !           637:       if( WinMessageBox( HWND_DESKTOP
        !           638:                       , hwndFrame
        !           639:                       , szTemp
        !           640:                       , szTitle
        !           641:                       , 0
        !           642:                       , MB_CUAWARNING | MB_YESNO | MB_DEFBUTTON2)
        !           643:               == MBID_YES)
        !           644:          WinPostMsg( hwnd, WM_QUIT, NULL, NULL);
        !           645:       break;
        !           646:  
        !           647:     case WM_PAINT:
        !           648:       return( WndProcPaint());
        !           649:       break;
        !           650:  
        !           651:     /**************************************************************************/
        !           652:     /*                                                                       */
        !           653:     /**************************************************************************/
        !           654:     case WM_ERASEBACKGROUND:
        !           655:       WinFillRect( (HPS)mp1, (PRECTL)mp2, CLR_BACKGROUND);
        !           656:       return( FALSE);
        !           657:       break;
        !           658:  
        !           659:     /**************************************************************************/
        !           660:     /*                                                                       */
        !           661:     /**************************************************************************/
        !           662:     case WM_MINMAXFRAME:
        !           663:       if( (((PSWP)mp1)->fs & SWP_RESTORE)  ||
        !           664:          (((PSWP)mp1)->fs & SWP_MAXIMIZE) )
        !           665:        SendCommand( (USHORT)UM_SIZING, 0L);
        !           666:       break;
        !           667:  
        !           668:     /**************************************************************************/
        !           669:     /* Process menu item commands, and commands generated from the keyboard   */
        !           670:     /* via the accelerator table. Most are handled by the async thread        */
        !           671:     /**************************************************************************/
        !           672:     case WM_COMMAND:
        !           673:       return( WndProcCommand( hwnd, msg, mp1, mp2));
        !           674:       break;
        !           675:  
        !           676:     /**************************************************************************/
        !           677:     /* Scrolling is handled by the async drawing thread. Simply pass on the   */
        !           678:     /* command and parameters                                                 */
        !           679:     /**************************************************************************/
        !           680:     case WM_HSCROLL:
        !           681:       SendCommand( (USHORT)UM_HSCROLL, LONGFROMMP(mp2));
        !           682:       break;
        !           683:  
        !           684:     case WM_VSCROLL:
        !           685:       SendCommand( (USHORT)UM_VSCROLL, LONGFROMMP(mp2));
        !           686:       break;
        !           687:  
        !           688:     /************************************************************************/
        !           689:     /* The client area is being resized.                                    */
        !           690:     /************************************************************************/
        !           691:     case WM_SIZE:
        !           692:       return( WndProcSize( mp1, mp2));
        !           693:       break;
        !           694:  
        !           695:     /**************************************************************************/
        !           696:     /* Mouse commands are handled by the async thread. Simply send on the     */
        !           697:     /* command and parameters.                                                */
        !           698:     /**************************************************************************/
        !           699:     case WM_BUTTON1DBLCLK:
        !           700:     case WM_BUTTON1DOWN:
        !           701:       if( hwnd != WinQueryFocus( HWND_DESKTOP, FALSE))
        !           702:          WinSetFocus( HWND_DESKTOP, hwnd);
        !           703:       if( !fButtonDown)
        !           704:       {
        !           705:          fButtonDown = TRUE;
        !           706:          SendCommand( (USHORT)UM_LEFTDOWN, LONGFROMMP(mp1));
        !           707:       }
        !           708:       return( TRUE);
        !           709:       break;
        !           710:  
        !           711:     case WM_BUTTON1UP:
        !           712:       if( !fButtonDown)
        !           713:          return( TRUE);
        !           714:       if( SendCommand( (USHORT)UM_LEFTUP, LONGFROMMP(mp1)))
        !           715:           fButtonDown = FALSE;
        !           716:       else
        !           717:          WinAlarm( HWND_DESKTOP, WA_WARNING);
        !           718:       return( TRUE);
        !           719:       break;
        !           720:  
        !           721:     case WM_MOUSEMOVE:
        !           722:       if( fButtonDown && (pslPicked != NULL))
        !           723:          SendCommand( (USHORT)UM_MOUSEMOVE, LONGFROMMP(mp1));
        !           724:       return( WinDefWindowProc( hwnd, msg, mp1, mp2));
        !           725:       break;
        !           726: 
        !           727:     /**************************************************************************/
        !           728:     /* Default for the rest                                                  */
        !           729:     /**************************************************************************/
        !           730:     default:
        !           731:       return( WinDefWindowProc( hwnd, msg, mp1, mp2));
        !           732:   }
        !           733:  
        !           734:   return( FALSE);
        !           735: }
        !           736:  
        !           737: /******************************************************************************/
        !           738: /*                                                                           */
        !           739: /* Get the maximum client area size.  Create a window DC for the client       */
        !           740: /* area and a normal GPI Presentation Space and associate the two.  The GPI   */
        !           741: /* PS will be the maximum client area size and be in pels.                   */
        !           742: /*                                                                           */
        !           743: /******************************************************************************/
        !           744: MRESULT
        !           745: WndProcCreate( hwnd)
        !           746: 
        !           747: HWND  hwnd;
        !           748: {
        !           749:   SIZEL sizlPickApp;                 /* pick aperture size                   */
        !           750:  
        !           751:   sizlMaxClient.cx = WinQuerySysValue( HWND_DESKTOP, SV_CXFULLSCREEN);
        !           752:   sizlMaxClient.cy = WinQuerySysValue( HWND_DESKTOP, SV_CYFULLSCREEN);
        !           753:  
        !           754:   hdcClient = WinOpenWindowDC( hwnd);
        !           755:   hpsClient = GpiCreatePS( habMain
        !           756:                         , hdcClient
        !           757:                         , &sizlMaxClient
        !           758:                         , GPIA_ASSOC | PU_PELS );
        !           759:   if( !hpsClient)
        !           760:       return( TRUE);
        !           761:   GpiSetAttrMode( hpsClient, AM_PRESERVE);
        !           762: 
        !           763:   hwndHorzScroll = WinWindowFromID( WinQueryWindow( hwnd, QW_PARENT, FALSE)
        !           764:                                  , FID_HORZSCROLL);
        !           765: 
        !           766:   hwndVertScroll = WinWindowFromID( WinQueryWindow( hwnd, QW_PARENT, FALSE)
        !           767:                                  , FID_VERTSCROLL);
        !           768: 
        !           769:   hpsPaint = GpiCreatePS( habMain, NULL, &sizlMaxClient, PU_PELS);
        !           770:  
        !           771:   hrgnInvalid = GpiCreateRegion( hpsClient, 0L, NULL);
        !           772:  
        !           773:   sizlPickApp.cx = sizlPickApp.cy = 1;
        !           774:   GpiSetPickApertureSize( hpsClient, PICKAP_REC, &sizlPickApp);
        !           775:   return( FALSE);
        !           776: }
        !           777:  
        !           778:  
        !           779: /*******************************************************************************/
        !           780: /*                                                                            */
        !           781: /* WM_PAINT message                                                           */
        !           782: /*                                                                            */
        !           783: /*******************************************************************************/
        !           784: MRESULT
        !           785: WndProcPaint()
        !           786: 
        !           787: {
        !           788:   HRGN  hrgnUpdt;
        !           789:   SHORT  sRgnType;
        !           790:  
        !           791:   hrgnUpdt = GpiCreateRegion( hpsPaint, 0L, NULL);
        !           792:   sRgnType = WinQueryUpdateRegion( hwndClient, hrgnUpdt);
        !           793:   WinValidateRegion( hwndClient, hrgnUpdt, FALSE);
        !           794:   SendCommand( UM_DRAW, (ULONG)hrgnUpdt);
        !           795:   return( FALSE);
        !           796: }
        !           797:  
        !           798: /******************************************************************************/
        !           799: /* Process menu item commands, and commands generated from the keyboard via   */
        !           800: /* the accelerator table.  Most are handled by the async thread              */
        !           801: /******************************************************************************/
        !           802: MRESULT
        !           803: WndProcCommand( hwnd, msg, mp1, mp2)
        !           804: 
        !           805: HWND   hwnd;
        !           806: USHORT  msg;
        !           807: MPARAM mp1, mp2;
        !           808: {
        !           809:   CHAR     szTemp[128];
        !           810:   DLF      dlf;
        !           811:   SEL      sel;
        !           812:   PLOADINFO pli;
        !           813:   PSZ      pszError, psz1, psz2;
        !           814:  
        !           815:   switch( SHORT1FROMMP(mp1))
        !           816:   {
        !           817:     case MENU_JUMBLE:
        !           818:        SendCommand( UM_JUMBLE, 0L);
        !           819:        break;
        !           820: 
        !           821:     case MENU_LOAD:
        !           822:        DosAllocSeg( sizeof( LOADINFO), &sel, 0);
        !           823:        pli = MAKEP( sel, 0);
        !           824: 
        !           825:        dlf.rgbAction       = DLG_OPENDLG;
        !           826:        dlf.rgbFlags        = ATTRDIRLIST;
        !           827:        dlf.phFile          = &(pli->hf);
        !           828:        dlf.pszExt          = (PSZ)"\\*.bmp";
        !           829:        dlf.pszAppName      = szTitle;
        !           830:        dlf.pszTitle        = "Load Bitmap";
        !           831:        dlf.pszInstructions = NULL;
        !           832:        dlf.szFileName[0]   = '\0';
        !           833:        dlf.szOpenFile[0]   = '\0';
        !           834:        pszError            = "Error reading file.";
        !           835: 
        !           836:        switch( DlgFile( hwnd, &dlf))
        !           837:        {
        !           838:          case TDF_ERRMEM:
        !           839:          case TDF_INVALID:
        !           840:              MyMessageBox( hwnd, pszError);
        !           841:              break;
        !           842: 
        !           843:          case TDF_NOOPEN:
        !           844:              break;
        !           845: 
        !           846:          default:
        !           847:              for( psz1 = dlf.szFileName, psz2 = pli->szFileName
        !           848:                 ; *psz2++ = *psz1++
        !           849:                 ; )
        !           850:                  ;
        !           851:              SendCommand( UM_LOAD, (LONG)pli);
        !           852:              break;
        !           853:        }
        !           854:        break;
        !           855:     /**********************************************************************/
        !           856:     /* EXIT command, menu item or F3 key pressed. Give the operator a    */
        !           857:     /* second chance, if confirmed post a WM_QUIT msg to the application  */
        !           858:     /* msg queue. This will force the MAIN thread to terminate.           */
        !           859:     /**********************************************************************/
        !           860:     case MENU_EXIT:
        !           861:       WinLoadString( habMain, NULL, TERMINATE, sizeof(szTemp), szTemp);
        !           862:       if( WinMessageBox( HWND_DESKTOP
        !           863:                       , hwndFrame
        !           864:                       , szTemp
        !           865:                       , szTitle
        !           866:                       , 0
        !           867:                       , MB_CUAWARNING | MB_YESNO | MB_DEFBUTTON2)
        !           868:            == MBID_YES)
        !           869:        WinPostMsg( hwnd, WM_QUIT, NULL, NULL);
        !           870:       break;
        !           871:  
        !           872:     /**********************************************************************/
        !           873:     /* Pass on the rest to the async thread.                             */
        !           874:     /**********************************************************************/
        !           875:     case MENU_ZOOMIN:
        !           876:       SendCommand( UM_ZOOM_IN, 0L);
        !           877:       break;
        !           878:  
        !           879:     case MENU_ZOOMOUT:
        !           880:       SendCommand( UM_ZOOM_OUT, 0L);
        !           881:       break;
        !           882: 
        !           883:     case MENU_FASTDRAG:
        !           884:       SendCommand( UM_FASTDRAG, 0L);
        !           885:       break;
        !           886:  
        !           887:     /**********************************************************************/
        !           888:     /* Unrecognised => default                                           */
        !           889:     /**********************************************************************/
        !           890:     default:
        !           891:       return( WinDefWindowProc(hwnd, msg, mp1, mp2));
        !           892:   }
        !           893:   return( FALSE);
        !           894: }
        !           895:  
        !           896: /******************************************************************************/
        !           897: /* Load a bitmap                                                             */
        !           898: /******************************************************************************/
        !           899: VOID
        !           900: Load( pli)
        !           901: 
        !           902: PLOADINFO  pli;
        !           903: {
        !           904:     PSZ     pszError;
        !           905:     RECTL   rclClient;
        !           906: 
        !           907:     pszError = (PSZ)"Error reading file.";
        !           908: 
        !           909:     DumpPicture();
        !           910:     if( !ReadBitmap( pli->hf) )
        !           911:     {
        !           912:       MyMessageBox( hwndClient, pszError);
        !           913:       return;
        !           914:     }
        !           915:     if( !PrepareBitmap() )
        !           916:     {
        !           917:       MyMessageBox( hwndClient, pszError);
        !           918:       return;
        !           919:     }
        !           920: 
        !           921:     lstrcpy( swctl.szSwtitle, szTitle);
        !           922:     lstrcat( swctl.szSwtitle, ": ");
        !           923:     lstrcat( swctl.szSwtitle, pli->szFileName);
        !           924:     WinChangeSwitchEntry( hsw, &swctl);
        !           925:     WinSetWindowText( hwndFrame, swctl.szSwtitle);
        !           926: 
        !           927:     CreatePicture();
        !           928:     lScale = 0;
        !           929: 
        !           930:     WinQueryWindowRect( hwndClient, &rclClient);
        !           931:     ptsScrollMax.x = (SHORT)(rclClient.xRight - rclClient.xLeft);
        !           932:     ptsHalfScrollMax.x = ptsScrollMax.x >> 1;
        !           933:     ptsScrollPos.x = ptsHalfScrollMax.x;
        !           934:     ptsOldScrollPos.x = ptsHalfScrollMax.x;
        !           935:     WinSendMsg( hwndHorzScroll
        !           936:              , SBM_SETSCROLLBAR
        !           937:              , MPFROMSHORT( ptsScrollPos.x)
        !           938:              , MPFROM2SHORT( 1, ptsScrollMax.x) );
        !           939:     ptsScrollMax.y = (SHORT)(rclClient.yTop - rclClient.yBottom);
        !           940:     ptsHalfScrollMax.y = ptsScrollMax.y >> 1;
        !           941:     ptsScrollPos.y = ptsHalfScrollMax.y;
        !           942:     ptsOldScrollPos.y = ptsHalfScrollMax.y;
        !           943:     WinSendMsg( hwndVertScroll
        !           944:              , SBM_SETSCROLLBAR
        !           945:              , MPFROMSHORT( ptsScrollPos.y)
        !           946:              , MPFROM2SHORT( 1, ptsScrollMax.y) );
        !           947: 
        !           948:     CalcBounds();
        !           949:     CalcTransform( hwndClient);
        !           950:     DosFreeSeg( SELECTOROF( pli));
        !           951: }
        !           952: /******************************************************************************/
        !           953: /* Throw the pieces around the screen.                                       */
        !           954: /******************************************************************************/
        !           955: VOID
        !           956: Jumble()
        !           957: {
        !           958:   LONG     lWidth, lHeight;
        !           959:   DATETIME  date;
        !           960:   POINTL    ptl;
        !           961:   RECTL     rclClient;
        !           962:   PSEGLIST  psl;
        !           963: 
        !           964:   if( WinQueryWindowRect( hwndClient, &rclClient) )
        !           965:   {
        !           966:     lWidth  = rclClient.xRight - rclClient.xLeft;
        !           967:     lHeight = rclClient.yTop   - rclClient.yBottom;
        !           968:     if( (lWidth > 0) && (lHeight > 0) )
        !           969:     {
        !           970:       DosGetDateTime( &date);
        !           971:       srand( (USHORT)date.hundredths);
        !           972:       for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !           973:       {
        !           974:        ptl.x = rclClient.xLeft   + (rand() % lWidth);
        !           975:        ptl.y = rclClient.yBottom + (rand() % lHeight);
        !           976:        Translate( psl, &ptl);
        !           977:        SetRect( psl);
        !           978:       }
        !           979:     }
        !           980:   }
        !           981: }
        !           982: 
        !           983: /******************************************************************************/
        !           984: /* The client area is being resized.  The current scroll bar thumb position   */
        !           985: /* and scroll bar range must be recalculated prior to recalculating the       */
        !           986: /* default viewing transform for the picture.  Wait for subsequent WM_PAINT   */
        !           987: /* to do any drawing.                                                        */
        !           988: /******************************************************************************/
        !           989: MRESULT
        !           990: WndProcSize( mp1, mp2)
        !           991: 
        !           992: MPARAM mp1, mp2;
        !           993: {
        !           994:   HWND hwndFrameTemp;
        !           995: 
        !           996:   if( hwndFrame)
        !           997:     hwndFrameTemp = hwndFrame;
        !           998:   else
        !           999:     hwndFrameTemp = WinQueryWindow( hwndClient, QW_PARENT, FALSE);
        !          1000: 
        !          1001:   ptsScrollMax.y = SHORT2FROMMP( mp2);
        !          1002:   ptsHalfScrollMax.y = ptsScrollMax.y >> 1;
        !          1003:   if( mp1)
        !          1004:   {
        !          1005:       ptsScrollPos.y = (SHORT)(((LONG)ptsScrollPos.y * (LONG)SHORT2FROMMP(mp2))/(LONG)SHORT2FROMMP(mp1));
        !          1006:       ptsOldScrollPos.y = (SHORT)(((LONG)ptsOldScrollPos.y * (LONG)SHORT2FROMMP(mp2))/(LONG)SHORT2FROMMP(mp1));
        !          1007:   } else
        !          1008:   {
        !          1009:       ptsScrollPos.y = ptsHalfScrollMax.y;     /* first sizing after window creation  */
        !          1010:       ptsOldScrollPos.y = ptsHalfScrollMax.y;
        !          1011:   }
        !          1012:   WinSendMsg( hwndVertScroll
        !          1013:            , SBM_SETSCROLLBAR
        !          1014:            , MPFROMSHORT( ptsScrollPos.y)
        !          1015:            , MPFROM2SHORT( 1, ptsScrollMax.y) );
        !          1016: 
        !          1017: 
        !          1018:   ptsScrollMax.x = SHORT1FROMMP( mp2);
        !          1019:   ptsHalfScrollMax.x = ptsScrollMax.x >> 1;
        !          1020:   if( mp1)
        !          1021:   {
        !          1022:       ptsScrollPos.x = (SHORT)(((LONG)ptsScrollPos.x * (LONG)SHORT1FROMMP(mp2))/(LONG)SHORT1FROMMP(mp1));
        !          1023:       ptsOldScrollPos.x = (SHORT)(((LONG)ptsOldScrollPos.x * (LONG)SHORT1FROMMP(mp2))/(LONG)SHORT1FROMMP(mp1));
        !          1024:   } else
        !          1025:   {
        !          1026:       ptsScrollPos.x = ptsHalfScrollMax.x;     /* first sizing after window creation  */
        !          1027:       ptsOldScrollPos.x = ptsHalfScrollMax.x;
        !          1028:   }
        !          1029:   WinSendMsg( hwndHorzScroll
        !          1030:            , SBM_SETSCROLLBAR
        !          1031:            , MPFROMSHORT( ptsScrollPos.x)
        !          1032:            , MPFROM2SHORT( 1, ptsScrollMax.x) );
        !          1033: 
        !          1034: 
        !          1035:   SendCommand( UM_SIZING, 0L);
        !          1036:   return( FALSE);
        !          1037: }
        !          1038:  
        !          1039: /******************************************************************************/
        !          1040: /*                                                                            */
        !          1041: /* NewThread is the asynchronous drawing thread. It is responsible for all    */
        !          1042: /* drawing.  It will initialize its PM interface and create an application    */
        !          1043: /* message queue.  It will then monitor its message queue and process any     */
        !          1044: /* commands received.                                                        */
        !          1045: /*                                                                            */
        !          1046: /******************************************************************************/
        !          1047: VOID FAR
        !          1048: NewThread()
        !          1049: {
        !          1050:   QMSG   qmsgAsync, qmsgPeek;
        !          1051:   BOOL   fDone;
        !          1052:  
        !          1053:   /****************************************************************************/
        !          1054:   /* Initialize the PM interface.  If it fails, terminate both threads.       */
        !          1055:   /****************************************************************************/
        !          1056:   habAsync = WinInitialize( NULL);
        !          1057:   if( !habAsync)
        !          1058:   {
        !          1059:       WinPostMsg( hwndClient, WM_QUIT, NULL, NULL);
        !          1060:       DosExit( EXIT_THREAD, 0);
        !          1061:   }
        !          1062:  
        !          1063:   /****************************************************************************/
        !          1064:   /* Create a message queue.  If it fails, terminate both threads.           */
        !          1065:   /****************************************************************************/
        !          1066:   hmqAsync = WinCreateMsgQueue( habAsync, 80);
        !          1067:   if( !hmqAsync)
        !          1068:   {
        !          1069:       WinPostMsg( hwndClient, WM_QUIT, NULL, NULL);
        !          1070:       WinTerminate( habAsync);
        !          1071:       DosExit( EXIT_THREAD, 0);
        !          1072:   }
        !          1073:  
        !          1074:   DosSetPrty( PRTYS_THREAD, PRTYC_NOCHANGE, sPrty, (TID)NULL);
        !          1075:  
        !          1076:  
        !          1077:   while( TRUE)
        !          1078:   {
        !          1079:     WinGetMsg( habAsync, &qmsgAsync, NULL, 0, 0);
        !          1080:  
        !          1081:     /**************************************************************************/
        !          1082:     /* process the commands                                                   */
        !          1083:     /**************************************************************************/
        !          1084:     switch( qmsgAsync.msg)
        !          1085:     {
        !          1086:  
        !          1087:       /************************************************************************/
        !          1088:       /************************************************************************/
        !          1089:       case UM_LOAD:
        !          1090:        Load( (PLOADINFO)qmsgAsync.mp1);
        !          1091:        Redraw();
        !          1092:        break;
        !          1093: 
        !          1094:       /************************************************************************/
        !          1095:       case UM_JUMBLE:
        !          1096:        Jumble();
        !          1097:        Redraw();
        !          1098:        break;
        !          1099: 
        !          1100:       /************************************************************************/
        !          1101:       case UM_REDRAW:
        !          1102:        Redraw();
        !          1103:        break;
        !          1104: 
        !          1105:       /************************************************************************/
        !          1106:       /* DRAW will use the passed region containing the invalidated area of   */
        !          1107:       /* the screen, repaint it and then destroy the region.                 */
        !          1108:       /************************************************************************/
        !          1109:       case UM_DRAW:
        !          1110:        DoDraw( (HRGN)qmsgAsync.mp1);
        !          1111:        if( qmsgAsync.mp1)
        !          1112:            GpiDestroyRegion( hpsClient, (HRGN)qmsgAsync.mp1);
        !          1113:         break;
        !          1114:  
        !          1115:  
        !          1116:       /************************************************************************/
        !          1117:       /* Get new scroll posn from command ( i.e. +/-1 +/-page) or new        */
        !          1118:       /* absolute position from parameter, update scroll posn, change the     */
        !          1119:       /* transform and update the thumb posn.  Finally update the window.     */
        !          1120:       /************************************************************************/
        !          1121:       case UM_HSCROLL:
        !          1122:        switch( SHORT2FROMMP( qmsgAsync.mp1) )
        !          1123:        {
        !          1124:             case SB_LINEUP:
        !          1125:                ptsScrollPos.x -= ptsScrollLine.x;
        !          1126:                 break;
        !          1127:             case SB_LINEDOWN:
        !          1128:                ptsScrollPos.x += ptsScrollLine.x;
        !          1129:                 break;
        !          1130:            case SB_SLIDERTRACK:
        !          1131:             case SB_SLIDERPOSITION:
        !          1132:                for( fDone = FALSE; !fDone ;)
        !          1133:                {
        !          1134:                  if( WinPeekMsg( habAsync
        !          1135:                                , &qmsgPeek
        !          1136:                                , NULL
        !          1137:                                , UM_HSCROLL
        !          1138:                                , UM_HSCROLL
        !          1139:                                , PM_NOREMOVE))
        !          1140:                      if(   (SHORT2FROMMP( qmsgPeek.mp1) == SB_SLIDERTRACK)
        !          1141:                          ||(SHORT2FROMMP( qmsgPeek.mp1) == SB_SLIDERPOSITION) )
        !          1142:                          WinPeekMsg( habAsync
        !          1143:                                    , &qmsgAsync
        !          1144:                                    , NULL
        !          1145:                                    , UM_HSCROLL
        !          1146:                                    , UM_HSCROLL
        !          1147:                                    , PM_REMOVE);
        !          1148:                      else
        !          1149:                          fDone = TRUE;
        !          1150:                  else
        !          1151:                      fDone = TRUE;
        !          1152:                }
        !          1153:                ptsScrollPos.x = SHORT1FROMMP( qmsgAsync.mp1);
        !          1154:                 break;
        !          1155:             case SB_PAGEUP:
        !          1156:                ptsScrollPos.x -= ptsScrollPage.x;
        !          1157:                 break;
        !          1158:             case SB_PAGEDOWN:
        !          1159:                ptsScrollPos.x += ptsScrollPage.x;
        !          1160:                 break;
        !          1161:             case SB_ENDSCROLL:
        !          1162:                 break;
        !          1163:             default:
        !          1164:                 break;
        !          1165:        }
        !          1166:        DoHorzScroll();
        !          1167:         break;
        !          1168:  
        !          1169:       case UM_VSCROLL:
        !          1170:        switch( SHORT2FROMMP( qmsgAsync.mp1) )
        !          1171:        {
        !          1172:             case SB_LINEUP:
        !          1173:                ptsScrollPos.y -= ptsScrollLine.y;
        !          1174:                 break;
        !          1175:             case SB_LINEDOWN:
        !          1176:                ptsScrollPos.y += ptsScrollLine.y;
        !          1177:                 break;
        !          1178:            case SB_SLIDERTRACK:
        !          1179:             case SB_SLIDERPOSITION:
        !          1180:                for( fDone = FALSE; !fDone ;)
        !          1181:                {
        !          1182:                  if( WinPeekMsg( habAsync
        !          1183:                                , &qmsgPeek
        !          1184:                                , NULL
        !          1185:                                , UM_VSCROLL
        !          1186:                                , UM_VSCROLL
        !          1187:                                , PM_NOREMOVE))
        !          1188:                      if(   (SHORT2FROMMP( qmsgPeek.mp1) == SB_SLIDERTRACK)
        !          1189:                          ||(SHORT2FROMMP( qmsgPeek.mp1) == SB_SLIDERPOSITION) )
        !          1190:                          WinPeekMsg( habAsync
        !          1191:                                    , &qmsgAsync
        !          1192:                                    , NULL
        !          1193:                                    , UM_VSCROLL
        !          1194:                                    , UM_VSCROLL
        !          1195:                                    , PM_REMOVE);
        !          1196:                      else
        !          1197:                          fDone = TRUE;
        !          1198:                  else
        !          1199:                      fDone = TRUE;
        !          1200:                }
        !          1201:                ptsScrollPos.y = SHORT1FROMMP( qmsgAsync.mp1);
        !          1202:                 break;
        !          1203:             case SB_PAGEUP:
        !          1204:                ptsScrollPos.y -= ptsScrollPage.y;
        !          1205:                 break;
        !          1206:             case SB_PAGEDOWN:
        !          1207:                ptsScrollPos.y += ptsScrollPage.y;
        !          1208:                 break;
        !          1209:             case SB_ENDSCROLL:
        !          1210:                 break;
        !          1211:             default:
        !          1212:                 break;
        !          1213:        }
        !          1214:        DoVertScroll();
        !          1215:         break;
        !          1216:  
        !          1217:       /************************************************************************/
        !          1218:       /* recalc the picture transform                                         */
        !          1219:       /************************************************************************/
        !          1220:       case UM_SIZING:
        !          1221:        CalcBounds();
        !          1222:        CalcTransform( hwndClient);
        !          1223:         break;
        !          1224:  
        !          1225:       /************************************************************************/
        !          1226:       /* adjust zoom factor                                                   */
        !          1227:       /************************************************************************/
        !          1228:       case UM_ZOOM_IN:
        !          1229:        Zoom( ZOOM_IN_ARG);
        !          1230:         break;
        !          1231:  
        !          1232:       case UM_ZOOM_OUT:
        !          1233:        Zoom( ZOOM_OUT_ARG);
        !          1234:         break;
        !          1235: 
        !          1236:       /************************************************************************/
        !          1237:       /* toggle fast-drag                                                    */
        !          1238:       /************************************************************************/
        !          1239:       case UM_FASTDRAG:
        !          1240:        ToggleFastDrag();
        !          1241:        break;
        !          1242:  
        !          1243:       /************************************************************************/
        !          1244:       /* Button down will cause a correlate on the picture to test for a hit. */
        !          1245:       /* Any selected segment will be highlighted and redrawn as dynamic.     */
        !          1246:       /************************************************************************/
        !          1247:       case UM_LEFTDOWN:
        !          1248:        LeftDown( qmsgAsync.mp1);
        !          1249:         break;
        !          1250:  
        !          1251:       /************************************************************************/
        !          1252:       /* if a segment is being dragged it will be redrawn in a new posn       */
        !          1253:       /************************************************************************/
        !          1254:       case UM_MOUSEMOVE:
        !          1255:        for( fDone = FALSE; !fDone ;)
        !          1256:        {
        !          1257:          if( WinPeekMsg( habAsync
        !          1258:                        , &qmsgPeek
        !          1259:                        , NULL
        !          1260:                        , UM_MOUSEMOVE
        !          1261:                        , UM_LEFTUP
        !          1262:                        , PM_NOREMOVE))
        !          1263:              if( qmsgPeek.msg == UM_MOUSEMOVE)
        !          1264:                  WinPeekMsg( habAsync
        !          1265:                            , &qmsgAsync
        !          1266:                            , NULL
        !          1267:                            , UM_MOUSEMOVE
        !          1268:                            , UM_MOUSEMOVE
        !          1269:                            , PM_REMOVE);
        !          1270:              else
        !          1271:                  fDone = TRUE;
        !          1272:          else
        !          1273:              fDone = TRUE;
        !          1274:        }
        !          1275:        MouseMove( qmsgAsync.mp1);
        !          1276:         break;
        !          1277:  
        !          1278:       /************************************************************************/
        !          1279:       /* if a segment is being dragged it will be redrawn as normal          */
        !          1280:       /************************************************************************/
        !          1281:       case UM_LEFTUP:
        !          1282:        LeftUp();
        !          1283:         break;
        !          1284:  
        !          1285:       /************************************************************************/
        !          1286:       /* destroy resources and terminate                                    */
        !          1287:       /************************************************************************/
        !          1288:       case UM_DIE:
        !          1289:        WinDestroyMsgQueue( hmqAsync);
        !          1290:        WinTerminate( habAsync);
        !          1291:        DosEnterCritSec();
        !          1292:        DosSemClear( hsemTerminate);
        !          1293:         DosExit( EXIT_THREAD, 0);
        !          1294:         break;
        !          1295:  
        !          1296:       /************************************************************************/
        !          1297:       /* finish flush of commands from queue                                 */
        !          1298:       /************************************************************************/
        !          1299:       case UM_FLUSH:
        !          1300:         break;
        !          1301:  
        !          1302:       default:
        !          1303:         break;
        !          1304:     }
        !          1305:   }
        !          1306: }
        !          1307:  
        !          1308: /******************************************************************************/
        !          1309: /* button down will cause one segment to be indicated and made dynamic       */
        !          1310: /******************************************************************************/
        !          1311: VOID
        !          1312: LeftDown( mp)
        !          1313: 
        !          1314: MPARAM  mp;
        !          1315: {
        !          1316:   HRGN     hrgnUpdt;
        !          1317:   LONG     alSegTag[HITS][DEPTH][2];
        !          1318:   POINTL    ptl, aptl[4];
        !          1319:   RECTL     rcl;
        !          1320:   MATRIXLF  matlf;
        !          1321:   LONG     lOffset;
        !          1322:   BYTE     bBuff[128];
        !          1323:   CHAR     pszMsg[40];
        !          1324:   PSZ      psz1, psz2;
        !          1325: 
        !          1326:   ptl.x = (LONG)(SHORT)SHORT1FROMMP( mp);
        !          1327:   ptl.y = (LONG)(SHORT)SHORT2FROMMP( mp);
        !          1328: 
        !          1329:   /****************************************************************************/
        !          1330:   /****************************************************************************/
        !          1331:   for( pslPicked = pslTail; pslPicked != NULL; pslPicked = pslPicked->pslPrev)
        !          1332:   {
        !          1333:     rcl = pslPicked->rclCurrent;
        !          1334:     GpiConvert( hpsClient, CVTC_MODEL, CVTC_DEVICE, 2L, (PPOINTL)&rcl);
        !          1335:     rcl.xRight++;
        !          1336:     rcl.yTop++;
        !          1337:     if( WinPtInRect( habAsync, &rcl, &ptl))
        !          1338:     {
        !          1339:        LONG lRet;
        !          1340: 
        !          1341:        GpiSetEditMode( hpsClient, SEGEM_INSERT);
        !          1342:        GpiOpenSegment( hpsClient, pslPicked->lSegId);
        !          1343:        GpiSetElementPointerAtLabel( hpsClient, FILLPATH);
        !          1344:        GpiFillPath( hpsClient, 1L, 0L);
        !          1345:        GpiCloseSegment( hpsClient);
        !          1346:        lRet = GpiCorrelateSegment( hpsClient
        !          1347:                                  , pslPicked->lSegId
        !          1348:                                  , PICKSEL_VISIBLE
        !          1349:                                  , &ptl
        !          1350:                                  , HITS
        !          1351:                                  , DEPTH
        !          1352:                                  , (PLONG)alSegTag );
        !          1353:        GpiOpenSegment( hpsClient, pslPicked->lSegId);
        !          1354:        GpiSetElementPointerAtLabel( hpsClient, FILLPATH);
        !          1355:        GpiOffsetElementPointer( hpsClient, 1L);
        !          1356:        GpiDeleteElement( hpsClient);
        !          1357:        GpiCloseSegment( hpsClient);
        !          1358: 
        !          1359:        if( lRet > 0)
        !          1360:            break;
        !          1361:     }
        !          1362:   }
        !          1363:   if( pslPicked)
        !          1364:     lPickedSeg  = pslPicked->lSegId;
        !          1365:   else
        !          1366:   {
        !          1367:     fButtonDown = FALSE;
        !          1368:     return;
        !          1369:   }
        !          1370:   if( (lPickedSeg < 1) || (lPickedSeg > lLastSegId) )
        !          1371:   {
        !          1372:     DosSemRequest( hsemSzFmt, SEM_INDEFINITE_WAIT);
        !          1373:     sprintf( szFmt, "Segment id out of range: %x", lPickedSeg);
        !          1374:     for( psz1 = szFmt, psz2 = pszMsg; *psz2++ = *psz1++; )
        !          1375:        ;
        !          1376:     DosSemClear( hsemSzFmt);
        !          1377:     MyMessageBox( hwndClient, pszMsg);
        !          1378:     fButtonDown = FALSE;
        !          1379:     return;
        !          1380:   }
        !          1381: 
        !          1382:   /****************************************************************************/
        !          1383:   hrgnUpdt = GpiCreateRegion( hpsClient, 1L, &rcl);
        !          1384:   GpiSetSegmentAttrs( hpsClient, lPickedSeg, ATTR_VISIBLE, ATTR_OFF);
        !          1385: 
        !          1386:   GpiQuerySegmentTransformMatrix( hpsClient
        !          1387:                                , lPickedSeg
        !          1388:                                , 9L
        !          1389:                                , &matlf );
        !          1390:   GpiBeginPath( hpsClient, 1L);
        !          1391:   GpiCallSegmentMatrix( hpsClient
        !          1392:                      , lPickedSeg + CALLSEG_BASE
        !          1393:                      , 9L
        !          1394:                      , &matlf
        !          1395:                      , TRANSFORM_REPLACE );
        !          1396:   GpiEndPath( hpsClient);
        !          1397:   GpiSetClipPath( hpsClient, 1L, SCP_AND);
        !          1398:   DoDraw( hrgnUpdt);
        !          1399:   GpiSetClipPath( hpsClient, 0L, SCP_RESET);
        !          1400:   GpiDestroyRegion( hpsClient, hrgnUpdt);
        !          1401: 
        !          1402:   /****************************************************************************/
        !          1403:   ptlOffset = ptlBotLeft;
        !          1404:   GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 1L, &ptlOffset);
        !          1405: 
        !          1406:   aptl[0].x = pslPicked->rclBitBlt.xLeft;
        !          1407:   aptl[0].y = pslPicked->rclBitBlt.yBottom;
        !          1408:   aptl[1].x = pslPicked->rclBitBlt.xRight;
        !          1409:   aptl[1].y = pslPicked->rclBitBlt.yTop;
        !          1410:   aptl[2] = aptl[0];
        !          1411:   aptl[3] = aptl[1];
        !          1412:   GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 2L, &aptl[2]);
        !          1413:   aptl[2].x -= ptlOffset.x;
        !          1414:   aptl[2].y -= ptlOffset.y;
        !          1415:   aptl[3].x -= ptlOffset.x - 1;
        !          1416:   aptl[3].y -= ptlOffset.y - 1;
        !          1417:   GpiSetEditMode( hpsClient, SEGEM_INSERT);
        !          1418: 
        !          1419:   for( lOffset = 0L; GpiGetData( hpsClient
        !          1420:                               , lPickedSeg
        !          1421:                               , &lOffset
        !          1422:                               , DFORM_NOCONV
        !          1423:                               , (LONG)sizeof( bBuff)
        !          1424:                               , bBuff) > 0; )
        !          1425:       ;
        !          1426: 
        !          1427:   GpiOpenSegment( hpsClient, lPickedSeg);
        !          1428:   GpiDeleteElementsBetweenLabels( hpsClient, BITBLT_TOP, BITBLT_BOTTOM);
        !          1429:   if( !fFastDrag)
        !          1430:       GpiWCBitBlt( hpsClient
        !          1431:                 , hbmBitmapDrag
        !          1432:                 , 4L
        !          1433:                 , aptl
        !          1434:                 , ROP_SRCCOPY
        !          1435:                 , BBO_IGNORE );
        !          1436:   GpiCloseSegment( hpsClient);
        !          1437: 
        !          1438:   for( lOffset = 0L; GpiGetData( hpsClient
        !          1439:                               , lPickedSeg
        !          1440:                               , &lOffset
        !          1441:                               , DFORM_NOCONV
        !          1442:                               , (LONG)sizeof( bBuff)
        !          1443:                               , bBuff) > 0; )
        !          1444:       ;
        !          1445: 
        !          1446:   /****************************************************************************/
        !          1447:   GpiSetSegmentAttrs( hpsClient, lPickedSeg, ATTR_VISIBLE, ATTR_ON);
        !          1448:   GpiSetSegmentAttrs( hpsClient, lPickedSeg, ATTR_DYNAMIC, ATTR_ON);
        !          1449:   GpiSetDrawControl( hpsClient, DCTL_DYNAMIC, DCTL_ON);
        !          1450:   GpiDrawSegment( hpsClient, lPickedSeg);
        !          1451: 
        !          1452:   WinSetCapture( HWND_DESKTOP, hwndClient);
        !          1453: }
        !          1454: 
        !          1455: 
        !          1456: 
        !          1457:  
        !          1458: /******************************************************************************/
        !          1459: /*                                                                            */
        !          1460: /* move the segment                                                          */
        !          1461: /*                                                                            */
        !          1462: /******************************************************************************/
        !          1463: VOID
        !          1464: MouseMove( mp)
        !          1465: 
        !          1466: MPARAM  mp;
        !          1467: {
        !          1468:   RECTL   rcl;
        !          1469:   POINTL  ptl, ptlModel;
        !          1470:  
        !          1471:   ptl.x = (LONG)(SHORT)SHORT1FROMMP( mp);
        !          1472:   ptl.y = (LONG)(SHORT)SHORT2FROMMP( mp);
        !          1473: 
        !          1474:   ptlModel = ptl;
        !          1475:   GpiConvert( hpsClient, CVTC_DEVICE, CVTC_MODEL, 1L, &ptlModel);
        !          1476:   ptlModel.x = 5 * (ptlModel.x / 5);
        !          1477:   ptlModel.y = 5 * (ptlModel.y / 5);
        !          1478:   if( (ptlModel.x == ptlOldMouse.x) && (ptlModel.y == ptlOldMouse.y))
        !          1479:     return;
        !          1480:   ptlOldMouse.x = ptlModel.x;
        !          1481:   ptlOldMouse.y = ptlModel.y;
        !          1482: 
        !          1483:   /****************************************************************************/
        !          1484:   /* clip mouse coords to client window                                      */
        !          1485:   /****************************************************************************/
        !          1486:   WinQueryWindowRect(hwndClient, &rcl);
        !          1487:   if (rcl.xLeft > ptl.x)
        !          1488:     ptl.x = rcl.xLeft;
        !          1489:   if (rcl.xRight <= ptl.x)
        !          1490:     ptl.x = rcl.xRight;
        !          1491:   if (rcl.yBottom > ptl.y)
        !          1492:     ptl.y = rcl.yBottom;
        !          1493:   if (rcl.yTop <= ptl.y)
        !          1494:     ptl.y = rcl.yTop;
        !          1495: 
        !          1496:   GpiRemoveDynamics( hpsClient, lPickedSeg, lPickedSeg);
        !          1497:   Translate( pslPicked, &ptl);
        !          1498:   GpiDrawDynamics( hpsClient);
        !          1499: }
        !          1500:  
        !          1501:  
        !          1502: /******************************************************************************/
        !          1503: /*                                                                           */
        !          1504: /* The dragged segment is being unselected.  Return it to its normal state.   */
        !          1505: /*                                                                           */
        !          1506: /******************************************************************************/
        !          1507: VOID
        !          1508: LeftUp()
        !          1509: {
        !          1510:   SEGLIST    sl;
        !          1511:   POINTL     aptl[4];
        !          1512: 
        !          1513:   if( !lPickedSeg)
        !          1514:     return;
        !          1515:   GpiRemoveDynamics( hpsClient, lPickedSeg, lPickedSeg);
        !          1516:   GpiSetSegmentAttrs( hpsClient, lPickedSeg, ATTR_DYNAMIC, ATTR_OFF);
        !          1517: 
        !          1518:   /****************************************************************************/
        !          1519:   ptlOffset = ptlBotLeft;
        !          1520:   GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 1L, &ptlOffset);
        !          1521: 
        !          1522:   aptl[0].x = pslPicked->rclBitBlt.xLeft;
        !          1523:   aptl[0].y = pslPicked->rclBitBlt.yBottom;
        !          1524:   aptl[1].x = pslPicked->rclBitBlt.xRight;
        !          1525:   aptl[1].y = pslPicked->rclBitBlt.yTop;
        !          1526:   aptl[2] = aptl[0];
        !          1527:   aptl[3] = aptl[1];
        !          1528:   GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 2L, &aptl[2]);
        !          1529:   aptl[2].x -= ptlOffset.x;
        !          1530:   aptl[2].y -= ptlOffset.y;
        !          1531:   aptl[3].x -= ptlOffset.x - 1;
        !          1532:   aptl[3].y -= ptlOffset.y - 1;
        !          1533:   GpiSetEditMode( hpsClient, SEGEM_INSERT);
        !          1534:   GpiOpenSegment( hpsClient, lPickedSeg);
        !          1535:   GpiDeleteElementsBetweenLabels( hpsClient, BITBLT_TOP, BITBLT_BOTTOM);
        !          1536:   GpiWCBitBlt( hpsClient
        !          1537:             , hbmBitmapTemp
        !          1538:             , 4L
        !          1539:             , aptl
        !          1540:             , ROP_SRCCOPY
        !          1541:             , BBO_IGNORE );
        !          1542:   GpiCloseSegment( hpsClient);
        !          1543: 
        !          1544:   /****************************************************************************/
        !          1545:   GpiDrawSegment( hpsClient, lPickedSeg);
        !          1546:   GpiSetSegmentPriority( hpsClient, lPickedSeg, 0L, LOWER_PRI); /* highest    */
        !          1547:   SetRect( pslPicked);
        !          1548: 
        !          1549:   sl = *pslPicked;
        !          1550:   SegListUpdate( DEL_SEG, pslPicked);
        !          1551:   SegListUpdate( ADD_TAIL_SEG, &sl);       /* at tail => highest priority    */
        !          1552:   pslPicked = NULL;
        !          1553: 
        !          1554:   WinSetCapture( HWND_DESKTOP, (HWND)NULL);
        !          1555: }
        !          1556:  
        !          1557:  
        !          1558: /******************************************************************************/
        !          1559: /*                                                                            */
        !          1560: /* DoHorzScroll will horizontally scroll the current contents of             */
        !          1561: /* the client area and redraw the invalidated area                           */
        !          1562: /*                                                                            */
        !          1563: /******************************************************************************/
        !          1564: VOID
        !          1565: DoHorzScroll()
        !          1566: {
        !          1567:   RECTL     rcl;
        !          1568:   HRGN     hrgn;
        !          1569:   MATRIXLF  matlf;
        !          1570:  
        !          1571:   if( ptsScrollPos.x > ptsScrollMax.x)
        !          1572:       ptsScrollPos.x = ptsScrollMax.x;
        !          1573:   if( ptsScrollPos.x < 0)
        !          1574:       ptsScrollPos.x = 0;
        !          1575:  
        !          1576:   if( ptsOldScrollPos.x != ptsScrollPos.x)
        !          1577:       WinSendMsg( hwndHorzScroll
        !          1578:                , SBM_SETPOS
        !          1579:                , MPFROM2SHORT( ptsScrollPos.x, 0)
        !          1580:                , MPFROMLONG( NULL));
        !          1581:  
        !          1582:   /****************************************************************************/
        !          1583:   /* Scroll the window the reqd amount, using bitblt'ing (ScrollWindow)       */
        !          1584:   /* if any of the screen still in view, and paint into uncovered region;     */
        !          1585:   /* else repaint the whole client area.                                     */
        !          1586:   /****************************************************************************/
        !          1587:   hrgn = GpiCreateRegion( hpsClient, 0L, NULL);
        !          1588:   if( abs( ptsScrollPos.x - ptsOldScrollPos.x) <= ptsScrollMax.x)
        !          1589:   {
        !          1590:       WinScrollWindow( hwndClient
        !          1591:                     , ptsOldScrollPos.x - ptsScrollPos.x
        !          1592:                     , 0
        !          1593:                     , NULL
        !          1594:                     , NULL
        !          1595:                     , hrgn
        !          1596:                     , &rcl
        !          1597:                     , 0);
        !          1598:   } else
        !          1599:   {
        !          1600:       WinQueryWindowRect( hwndClient, &rcl);
        !          1601:       GpiSetRegion( hpsClient, hrgn, 1L, &rcl);
        !          1602:   }
        !          1603:   GpiQueryDefaultViewMatrix( hpsClient, 9L, &matlf );
        !          1604:   matlf.lM31 -= ptsScrollPos.x - ptsOldScrollPos.x;
        !          1605:   GpiSetDefaultViewMatrix( hpsClient, 9L, &matlf, TRANSFORM_REPLACE);
        !          1606: 
        !          1607:   DoDraw( hrgn);
        !          1608:   ptsOldScrollPos.x = ptsScrollPos.x;
        !          1609:   GpiDestroyRegion( hpsClient, hrgn);
        !          1610: }
        !          1611:  
        !          1612: /******************************************************************************/
        !          1613: /*                                                                            */
        !          1614: /* DoVertScroll will vertically scroll the current contents of               */
        !          1615: /* the client area and redraw the invalidated area                           */
        !          1616: /*                                                                            */
        !          1617: /******************************************************************************/
        !          1618: VOID
        !          1619: DoVertScroll()
        !          1620: {
        !          1621:   RECTL     rcl;
        !          1622:   HRGN     hrgn;
        !          1623:   MATRIXLF  matlf;
        !          1624:  
        !          1625:   if( ptsScrollPos.y > ptsScrollMax.y)
        !          1626:       ptsScrollPos.y = ptsScrollMax.y;
        !          1627:   if( ptsScrollPos.y < 0)
        !          1628:       ptsScrollPos.y = 0;
        !          1629:  
        !          1630:   if( ptsOldScrollPos.y != ptsScrollPos.y)
        !          1631:       WinSendMsg( hwndVertScroll
        !          1632:                , SBM_SETPOS
        !          1633:                , MPFROM2SHORT( ptsScrollPos.y, 0)
        !          1634:                , MPFROMLONG( NULL));
        !          1635:  
        !          1636:   /****************************************************************************/
        !          1637:   /* Scroll the window the reqd amount, using bitblt'ing (ScrollWindow)       */
        !          1638:   /* if any of the screen still in view, and paint into uncovered region;     */
        !          1639:   /* else repaint the whole client area.                                     */
        !          1640:   /****************************************************************************/
        !          1641:   hrgn = GpiCreateRegion( hpsClient, 0L, NULL);
        !          1642:   if( abs( ptsScrollPos.y - ptsOldScrollPos.y) <= ptsScrollMax.y)
        !          1643:   {
        !          1644:       WinScrollWindow( hwndClient
        !          1645:                     , 0
        !          1646:                     , ptsScrollPos.y - ptsOldScrollPos.y
        !          1647:                     , NULL
        !          1648:                     , NULL
        !          1649:                     , hrgn
        !          1650:                     , &rcl
        !          1651:                     , 0);
        !          1652:   } else
        !          1653:   {
        !          1654:       WinQueryWindowRect( hwndClient, &rcl);
        !          1655:       GpiSetRegion( hpsClient, hrgn, 1L, &rcl);
        !          1656:   }
        !          1657:   GpiQueryDefaultViewMatrix( hpsClient, 9L, &matlf );
        !          1658:   matlf.lM32 += ptsScrollPos.y - ptsOldScrollPos.y;
        !          1659:   GpiSetDefaultViewMatrix( hpsClient, 9L, &matlf, TRANSFORM_REPLACE);
        !          1660: 
        !          1661:   DoDraw( hrgn);
        !          1662:   ptsOldScrollPos.y = ptsScrollPos.y;
        !          1663:   GpiDestroyRegion( hpsClient, hrgn);
        !          1664: }
        !          1665:  
        !          1666: /******************************************************************************/
        !          1667: /*                                                                            */
        !          1668: /* Redraw the entire client window.                                          */
        !          1669: /*                                                                            */
        !          1670: /******************************************************************************/
        !          1671: VOID
        !          1672: Redraw()
        !          1673: {
        !          1674:   RECTL   rclInvalid;
        !          1675:   HRGN   hrgnUpdt;
        !          1676:  
        !          1677:   WinQueryWindowRect( hwndClient, &rclInvalid);
        !          1678:   hrgnUpdt = GpiCreateRegion( hpsClient, 1L, &rclInvalid);
        !          1679:   DoDraw( hrgnUpdt);
        !          1680:   GpiDestroyRegion( hpsClient, hrgnUpdt);
        !          1681: }
        !          1682: 
        !          1683: 
        !          1684: /******************************************************************************/
        !          1685: /*                                                                            */
        !          1686: /* toggle the fast-drag flag and update the menu check-box                   */
        !          1687: /*                                                                            */
        !          1688: /******************************************************************************/
        !          1689: VOID
        !          1690: ToggleFastDrag()
        !          1691: {
        !          1692:   MENUITEM mi;
        !          1693:   HWND    hwndMenu, hwndOptions;
        !          1694: 
        !          1695:   hwndMenu = WinWindowFromID( hwndFrame, FID_MENU);
        !          1696:   WinSendMsg( hwndMenu
        !          1697:            , MM_QUERYITEM
        !          1698:            , MPFROM2SHORT( SM_OPTIONS, FALSE)
        !          1699:            , MPFROMP( (PMENUITEM)&mi));
        !          1700:   hwndOptions = mi.hwndSubMenu;
        !          1701: 
        !          1702:   if( fFastDrag)
        !          1703:   {
        !          1704:     fFastDrag = FALSE;
        !          1705:     WinSendMsg( hwndOptions
        !          1706:              , MM_SETITEMATTR
        !          1707:              , MPFROM2SHORT( MENU_FASTDRAG, TRUE)
        !          1708:              , MPFROM2SHORT( MIA_CHECKED, ~MIA_CHECKED) );
        !          1709:   }
        !          1710:   else
        !          1711:   {
        !          1712:     fFastDrag = TRUE;
        !          1713:     WinSendMsg( hwndOptions
        !          1714:              , MM_SETITEMATTR
        !          1715:              , MPFROM2SHORT( MENU_FASTDRAG, TRUE)
        !          1716:              , MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED) );
        !          1717:   }
        !          1718: }
        !          1719: 
        !          1720: /******************************************************************************/
        !          1721: /*                                                                            */
        !          1722: /* adjust zoom factor and recalc the picture transform, then do a redraw of   */
        !          1723: /* whole screen                                                              */
        !          1724: /*                                                                            */
        !          1725: /******************************************************************************/
        !          1726: VOID
        !          1727: Zoom( sInOrOut)
        !          1728: 
        !          1729: SHORT sInOrOut;
        !          1730: {
        !          1731:   LONG  lScaleOld;
        !          1732: 
        !          1733:   lScaleOld = lScale;
        !          1734:   lScale += sInOrOut;
        !          1735:   if( lScale > ZOOM_MAX)
        !          1736:     lScale = ZOOM_MAX;
        !          1737:   else
        !          1738:     if( lScale < -ZOOM_MAX)
        !          1739:       lScale = -ZOOM_MAX;
        !          1740:   if( lScale != lScaleOld)
        !          1741:   {
        !          1742:       ZoomMenuItems();
        !          1743:       CalcBounds();
        !          1744:       CalcTransform( hwndClient);
        !          1745:       Redraw();
        !          1746:   }
        !          1747: }
        !          1748:  
        !          1749: /******************************************************************************/
        !          1750: /*                                                                            */
        !          1751: /* enable/disable zoom menu items depending on scaling                        */
        !          1752: /*                                                                            */
        !          1753: /******************************************************************************/
        !          1754: VOID
        !          1755: ZoomMenuItems()
        !          1756: {
        !          1757:   MENUITEM  mi;
        !          1758:   HWND     hwndMenu, hwndOptions;
        !          1759:  
        !          1760:   hwndMenu = WinWindowFromID( hwndFrame, FID_MENU);
        !          1761:   WinSendMsg( hwndMenu
        !          1762:            , MM_QUERYITEM
        !          1763:            , MPFROM2SHORT( SM_OPTIONS, FALSE)
        !          1764:            , MPFROMP( (PMENUITEM)&mi));
        !          1765:   hwndOptions = mi.hwndSubMenu;
        !          1766:  
        !          1767:   if( lScale >= ZOOM_MAX)
        !          1768:   {
        !          1769:       WinSendMsg( hwndOptions
        !          1770:                , MM_SETITEMATTR
        !          1771:                , MPFROM2SHORT( MENU_ZOOMIN, TRUE)
        !          1772:                , MPFROM2SHORT( MIA_DISABLED, MIA_DISABLED));
        !          1773:       WinSendMsg( hwndOptions
        !          1774:                , MM_SETITEMATTR
        !          1775:                , MPFROM2SHORT( MENU_ZOOMOUT, TRUE)
        !          1776:                , MPFROM2SHORT( MIA_DISABLED, ~MIA_DISABLED));
        !          1777:   } else
        !          1778:   {
        !          1779:       if( lScale <= - ZOOM_MAX)
        !          1780:       {
        !          1781:          WinSendMsg( hwndOptions
        !          1782:                    , MM_SETITEMATTR
        !          1783:                    , MPFROM2SHORT( MENU_ZOOMOUT, TRUE)
        !          1784:                    , MPFROM2SHORT( MIA_DISABLED, MIA_DISABLED));
        !          1785:          WinSendMsg( hwndOptions
        !          1786:                    , MM_SETITEMATTR
        !          1787:                    , MPFROM2SHORT( MENU_ZOOMIN, TRUE)
        !          1788:                    , MPFROM2SHORT( MIA_DISABLED, ~MIA_DISABLED));
        !          1789:       } else
        !          1790:       {
        !          1791:          WinSendMsg( hwndOptions
        !          1792:                    , MM_SETITEMATTR
        !          1793:                    , MPFROM2SHORT( MENU_ZOOMOUT, TRUE)
        !          1794:                    , MPFROM2SHORT( MIA_DISABLED, ~MIA_DISABLED));
        !          1795:          WinSendMsg( hwndOptions
        !          1796:                    , MM_SETITEMATTR
        !          1797:                    , MPFROM2SHORT( MENU_ZOOMIN, TRUE)
        !          1798:                    , MPFROM2SHORT( MIA_DISABLED, ~MIA_DISABLED));
        !          1799:       }
        !          1800:   }
        !          1801: }
        !          1802:  
        !          1803: /******************************************************************************/
        !          1804: /*                                                                            */
        !          1805: /* Determine the bounding rect of a segment.                                 */
        !          1806: /*                                                                            */
        !          1807: /******************************************************************************/
        !          1808: VOID
        !          1809: SetRect( psl)
        !          1810: 
        !          1811: PSEGLIST  psl;
        !          1812: {
        !          1813:   GpiResetBoundaryData( hpsClient);
        !          1814:   GpiSetDrawControl( hpsClient, DCTL_DISPLAY, DCTL_OFF);
        !          1815:   GpiSetDrawControl( hpsClient, DCTL_BOUNDARY, DCTL_ON);
        !          1816:   GpiDrawSegment( hpsClient, psl->lSegId);
        !          1817:   GpiSetDrawControl( hpsClient, DCTL_DISPLAY, DCTL_ON);
        !          1818:   GpiSetDrawControl( hpsClient, DCTL_BOUNDARY, DCTL_OFF);
        !          1819:   GpiQueryBoundaryData( hpsClient, &(psl->rclCurrent));
        !          1820: }
        !          1821:  
        !          1822: /******************************************************************************/
        !          1823: /*                                                                            */
        !          1824: /* Translate a segment                                                       */
        !          1825: /*                                                                            */
        !          1826: /******************************************************************************/
        !          1827: VOID
        !          1828: Translate( psl, pptlNew)
        !          1829: 
        !          1830: PSEGLIST  psl;
        !          1831: PPOINTL   pptlNew;
        !          1832: {
        !          1833:   POINTL    ptl;
        !          1834:   MATRIXLF  matlf;
        !          1835: 
        !          1836:   ptl = *pptlNew;
        !          1837:   GpiConvert( hpsClient, CVTC_DEVICE, CVTC_MODEL, 1L, &ptl);
        !          1838:   ptl.x = (ptl.x / 5) * 5;
        !          1839:   ptl.y = (ptl.y / 5) * 5;
        !          1840:   ptl.x -= 25;
        !          1841:   ptl.y -= 25;
        !          1842: 
        !          1843:   GpiQuerySegmentTransformMatrix( hpsClient
        !          1844:                                , psl->lSegId
        !          1845:                                , 9L
        !          1846:                                , &matlf);
        !          1847:   matlf.lM31 = ptl.x - (psl->ptlLocation).x;
        !          1848:   matlf.lM32 = ptl.y - (psl->ptlLocation).y;
        !          1849:   GpiSetSegmentTransformMatrix( hpsClient
        !          1850:                              , psl->lSegId
        !          1851:                              , 9L
        !          1852:                              , &matlf
        !          1853:                              , TRANSFORM_REPLACE);
        !          1854: }
        !          1855:  
        !          1856:  
        !          1857: /******************************************************************************/
        !          1858: /*                                                                            */
        !          1859: /* set the default viewing transform                                         */
        !          1860: /*                                                                            */
        !          1861: /******************************************************************************/
        !          1862: VOID
        !          1863: SetDVTransform( fx11, fx12, fx21, fx22, l31, l32, lType)
        !          1864: 
        !          1865: FIXED  fx11, fx12, fx21, fx22;
        !          1866: LONG   l31, l32, lType;
        !          1867: {
        !          1868:   MATRIXLF  matlf;
        !          1869: 
        !          1870:   matlf.fxM11 = fx11;
        !          1871:   matlf.fxM12 = fx12;
        !          1872:   matlf.lM13  = 0L;
        !          1873:   matlf.fxM21 = fx21;
        !          1874:   matlf.fxM22 = fx22;
        !          1875:   matlf.lM23  = 0L;
        !          1876:   matlf.lM31  = l31;
        !          1877:   matlf.lM32  = l32;
        !          1878:   matlf.lM33  = 1L;
        !          1879:   GpiSetDefaultViewMatrix( hpsClient, 9L, &matlf, lType);
        !          1880: }
        !          1881: 
        !          1882: /******************************************************************************/
        !          1883: /*                                                                            */
        !          1884: /* get bounding rect of whole picture in model coordinates                   */
        !          1885: /*                                                                            */
        !          1886: /******************************************************************************/
        !          1887: VOID
        !          1888: CalcBounds()
        !          1889: {
        !          1890:   PSEGLIST  psl;
        !          1891:   RECTL     rcl;
        !          1892: 
        !          1893:   if( !pslHead)
        !          1894:     return;
        !          1895:   rclBounds = pslHead->rclCurrent;
        !          1896:   for( psl = pslHead->pslNext; psl != NULL; psl = psl->pslNext)
        !          1897:   {
        !          1898:     rcl = psl->rclCurrent;
        !          1899:     if( rcl.xLeft < rclBounds.xLeft)
        !          1900:       rclBounds.xLeft = rcl.xLeft;
        !          1901:     if( rcl.xRight > rclBounds.xRight)
        !          1902:       rclBounds.xRight = rcl.xRight;
        !          1903:     if( rcl.yTop > rclBounds.yTop)
        !          1904:       rclBounds.yTop = rcl.yTop;
        !          1905:     if( rcl.yBottom < rclBounds.yBottom)
        !          1906:       rclBounds.yBottom = rcl.yBottom;
        !          1907:   }
        !          1908: }
        !          1909: 
        !          1910: /******************************************************************************/
        !          1911: /*                                                                            */
        !          1912: /* Calculate and set the default viewing transform based on zoom and scroll   */
        !          1913: /*                                                                            */
        !          1914: /******************************************************************************/
        !          1915: VOID
        !          1916: CalcTransform( hwnd)
        !          1917: 
        !          1918: HWND hwnd;
        !          1919: {
        !          1920:   RECTL     rclClient;
        !          1921:   POINTL    ptlCenter, ptlTrans, ptlScale, aptl[4];
        !          1922:   HRGN     hrgn;
        !          1923:   PSEGLIST  psl;
        !          1924:  
        !          1925:   /****************************************************************************/
        !          1926:   /* from bounding rect of picture get center of picture                     */
        !          1927:   /****************************************************************************/
        !          1928:   ptlCenter.x = (rclBounds.xLeft   + rclBounds.xRight) / 2;
        !          1929:   ptlCenter.y = (rclBounds.yBottom + rclBounds.yTop  ) / 2;
        !          1930:  
        !          1931:   /****************************************************************************/
        !          1932:   /* translate center of picture to origin                                   */
        !          1933:   /****************************************************************************/
        !          1934:   SetDVTransform( (FIXED)UNITY
        !          1935:                , (FIXED)0
        !          1936:                , (FIXED)0
        !          1937:                , (FIXED)UNITY
        !          1938:                , -ptlCenter.x
        !          1939:                , -ptlCenter.y
        !          1940:                , TRANSFORM_REPLACE);
        !          1941:  
        !          1942:   /****************************************************************************/
        !          1943:   /* scale down to 60% of max client area                                    */
        !          1944:   /****************************************************************************/
        !          1945:   ptlScale.x = (6 * UNITY * sizlMaxClient.cx) /
        !          1946:               (10 * (ptlTopRight.x - ptlBotLeft.x));
        !          1947:   ptlScale.y = (6 * UNITY * sizlMaxClient.cy) /
        !          1948:               (10 * (ptlTopRight.y - ptlBotLeft.y));
        !          1949:  
        !          1950:   /****************************************************************************/
        !          1951:   /* add in zoom scale                                                       */
        !          1952:   /****************************************************************************/
        !          1953:   ptlScale.x += ptlScale.x * lScale / (ZOOM_MAX + 1);
        !          1954:   ptlScale.y += ptlScale.y * lScale / (ZOOM_MAX + 1);
        !          1955: 
        !          1956:   SetDVTransform( (FIXED)ptlScale.x
        !          1957:                , (FIXED)0
        !          1958:                , (FIXED)0
        !          1959:                , (FIXED)ptlScale.y
        !          1960:                , 0L
        !          1961:                , 0L
        !          1962:                , TRANSFORM_ADD);
        !          1963:  
        !          1964:   /****************************************************************************/
        !          1965:   /* translate center of picture to center of client window                  */
        !          1966:   /****************************************************************************/
        !          1967:   WinQueryWindowRect( hwnd, &rclClient);
        !          1968:   ptlTrans.x = (rclClient.xRight - rclClient.xLeft)   / 2;
        !          1969:   ptlTrans.y = (rclClient.yTop  - rclClient.yBottom) / 2;
        !          1970:  
        !          1971:   /****************************************************************************/
        !          1972:   /* add in horizontal and vertical scrolling factors                        */
        !          1973:   /****************************************************************************/
        !          1974:   ptlTrans.x += ptsScrollPos.x - ptsHalfScrollMax.x;
        !          1975:   ptlTrans.y += ptsScrollPos.y - ptsHalfScrollMax.y;
        !          1976:   SetDVTransform( (FIXED)UNITY
        !          1977:                , (FIXED)0
        !          1978:                , (FIXED)0
        !          1979:                , (FIXED)UNITY
        !          1980:                , ptlTrans.x
        !          1981:                , ptlTrans.y
        !          1982:                , TRANSFORM_ADD);
        !          1983: 
        !          1984:   /****************************************************************************/
        !          1985:   /* create a shadow bitmap of the original, sized to the current output size */
        !          1986:   /****************************************************************************/
        !          1987:   aptl[0] = ptlBotLeft;
        !          1988:   aptl[1] = ptlTopRight;
        !          1989:   GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 2L, aptl);
        !          1990:   ptlOffset = aptl[0];
        !          1991: 
        !          1992:   aptl[0].x -= ptlOffset.x;
        !          1993:   aptl[0].y -= ptlOffset.y;
        !          1994:   aptl[1].x -= ptlOffset.x - 1;
        !          1995:   aptl[1].y -= ptlOffset.y - 1;
        !          1996:   aptl[2].x = 0L;
        !          1997:   aptl[2].y = 0L;
        !          1998:   aptl[3].x = bmpBitmapFile.cx;
        !          1999:   aptl[3].y = bmpBitmapFile.cy;
        !          2000:   GpiSetBitmap( hpsBitmapTemp, hbmBitmapTemp);
        !          2001:   GpiBitBlt( hpsBitmapTemp
        !          2002:           , hpsBitmapFile
        !          2003:           , 4L
        !          2004:           , aptl
        !          2005:           , ROP_SRCCOPY
        !          2006:           , BBO_IGNORE);
        !          2007:   GpiSetBitmap( hpsBitmapTemp, NULL);
        !          2008: 
        !          2009:   /****************************************************************************/
        !          2010:   /* create a copy of the shadow bitmap, adjusted to appear normal when       */
        !          2011:   /* bitblt'd in XOR mode onto a CLR_BACKGROUND background (dynamic segment)  */
        !          2012:   /****************************************************************************/
        !          2013:   GpiSetBitmap( hpsBitmapDrag, hbmBitmapDrag);
        !          2014:   GpiSetColor( hpsBitmapDrag, CLR_BACKGROUND);
        !          2015:   hrgn = GpiCreateRegion( hpsBitmapDrag, 1L, (PRECTL)aptl);
        !          2016:   GpiPaintRegion( hpsBitmapDrag, hrgn);
        !          2017:   GpiDestroyRegion( hpsBitmapDrag, hrgn);
        !          2018:   GpiBitBlt( hpsBitmapDrag
        !          2019:           , hpsBitmapFile
        !          2020:           , 4L
        !          2021:           , aptl
        !          2022:           , ROP_SRCINVERT
        !          2023:           , BBO_IGNORE);
        !          2024:   GpiSetBitmap( hpsBitmapDrag, NULL);
        !          2025: 
        !          2026:   for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !          2027:   {
        !          2028:     aptl[0].x = psl->rclBitBlt.xLeft;
        !          2029:     aptl[0].y = psl->rclBitBlt.yBottom;
        !          2030:     aptl[1].x = psl->rclBitBlt.xRight;
        !          2031:     aptl[1].y = psl->rclBitBlt.yTop;
        !          2032:     aptl[2] = aptl[0];
        !          2033:     aptl[3] = aptl[1];
        !          2034:     GpiConvert( hpsClient, CVTC_WORLD, CVTC_DEVICE, 2L, &aptl[2]);
        !          2035:     aptl[2].x -= ptlOffset.x;
        !          2036:     aptl[2].y -= ptlOffset.y;
        !          2037:     aptl[3].x -= ptlOffset.x - 1;
        !          2038:     aptl[3].y -= ptlOffset.y - 1;
        !          2039:     GpiSetEditMode( hpsClient, SEGEM_INSERT);
        !          2040:     GpiOpenSegment( hpsClient, psl->lSegId);
        !          2041:     GpiDeleteElementsBetweenLabels( hpsClient, BITBLT_TOP, BITBLT_BOTTOM);
        !          2042:     GpiWCBitBlt( hpsClient
        !          2043:               , hbmBitmapTemp
        !          2044:               , 4L
        !          2045:               , aptl
        !          2046:               , ROP_SRCCOPY
        !          2047:               , BBO_IGNORE );
        !          2048:     GpiCloseSegment( hpsClient);
        !          2049:   }
        !          2050: }
        !          2051:  
        !          2052:  
        !          2053: /******************************************************************************/
        !          2054: /*                                                                            */
        !          2055: /* Draw the picture, using the passed region for clipping.                   */
        !          2056: /* Test each segment to see if its bounding box intersects the bounding box   */
        !          2057: /* of the clipping region.  Draw only if there is an intersection.           */
        !          2058: /*                                                                            */
        !          2059: /******************************************************************************/
        !          2060: BOOL
        !          2061: DoDraw( hrgn)
        !          2062: 
        !          2063: HRGN   hrgn;
        !          2064: {
        !          2065:   HRGN     hrgnOld;
        !          2066:   RECTL     rcl, rclRegion, rclDst;
        !          2067:   PSEGLIST  psl;
        !          2068: 
        !          2069:   GpiSetColor( hpsClient, CLR_BACKGROUND);
        !          2070:   GpiPaintRegion( hpsClient, hrgn);
        !          2071: 
        !          2072:   GpiQueryRegionBox( hpsClient, hrgn, &rclRegion);
        !          2073:   GpiSetClipRegion( hpsClient, hrgn, &hrgnOld);
        !          2074:   for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !          2075:   {
        !          2076:     rcl = psl->rclCurrent;
        !          2077:     GpiConvert( hpsClient, CVTC_MODEL, CVTC_DEVICE, 2L, (PPOINTL)&rcl);
        !          2078:     rcl.xRight++;
        !          2079:     rcl.yTop++;
        !          2080:     if( WinIntersectRect( habAsync, &rclDst, &rcl, &rclRegion))
        !          2081:        GpiDrawSegment( hpsClient, psl->lSegId);
        !          2082:   }
        !          2083:   GpiSetClipRegion( hpsClient, NULL, &hrgnOld);
        !          2084: 
        !          2085:   return( TRUE);
        !          2086: }
        !          2087:  
        !          2088: /******************************************************************************/
        !          2089: /*                                                                            */
        !          2090: /* Return a pointer to a segment list member, based on segment id.           */
        !          2091: /*                                                                            */
        !          2092: /******************************************************************************/
        !          2093: PSEGLIST
        !          2094: SegListGet( lSeg)
        !          2095: 
        !          2096: LONG      lSeg;
        !          2097: {
        !          2098:   PSEGLIST  psl;
        !          2099: 
        !          2100:   for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !          2101:     if( psl->lSegId == lSeg)
        !          2102:       return( psl);
        !          2103:   return( NULL);
        !          2104: }
        !          2105: 
        !          2106: /******************************************************************************/
        !          2107: /*                                                                            */
        !          2108: /* Check the segment list for obvious errors.                                */
        !          2109: /*                                                                           */
        !          2110: /******************************************************************************/
        !          2111: BOOL
        !          2112: SegListCheck( iLoc)
        !          2113: 
        !          2114: INT   iLoc;
        !          2115: {
        !          2116:   PSEGLIST   psl;
        !          2117:   CHAR      pszMsg[50];
        !          2118:   PSZ       psz1, psz2;
        !          2119: 
        !          2120:   pszMsg[0] = '\0';
        !          2121:   for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !          2122:     if( (psl->lSegId < 1) || (psl->lSegId > lLastSegId) )
        !          2123:     {
        !          2124:       DosSemRequest( hsemSzFmt, SEM_INDEFINITE_WAIT);
        !          2125:       sprintf( szFmt, "Bad head segment list, location %d", iLoc);
        !          2126:       for( psz1 = szFmt, psz2 = pszMsg; *psz2++ = *psz1++; )
        !          2127:          ;
        !          2128:       DosSemClear( hsemSzFmt);
        !          2129:       MyMessageBox( hwndClient, pszMsg);
        !          2130:       return( FALSE);
        !          2131:     }
        !          2132:   for( psl = pslTail; psl != NULL; psl = psl->pslPrev)
        !          2133:     if( (psl->lSegId < 1) || (psl->lSegId > lLastSegId) )
        !          2134:     {
        !          2135:       DosSemRequest( hsemSzFmt, SEM_INDEFINITE_WAIT);
        !          2136:       sprintf( szFmt, "Bad head segment list, location %d", iLoc);
        !          2137:       for( psz1 = szFmt, psz2 = pszMsg; *psz2++ = *psz1++; )
        !          2138:          ;
        !          2139:       DosSemClear( hsemSzFmt);
        !          2140:       MyMessageBox( hwndClient, pszMsg);
        !          2141:       return( FALSE);
        !          2142:     }
        !          2143:   return( TRUE);
        !          2144: }
        !          2145: /******************************************************************************/
        !          2146: /*                                                                            */
        !          2147: /* Add (at head or tail) or delete a specified segment list member.          */
        !          2148: /*                                                                            */
        !          2149: /******************************************************************************/
        !          2150: BOOL
        !          2151: SegListUpdate( usOperation, pslUpdate)
        !          2152: 
        !          2153: USHORT  usOperation;
        !          2154: PSEGLIST pslUpdate;
        !          2155: {
        !          2156:   PSEGLIST psl;
        !          2157:   SEL     sel;
        !          2158: 
        !          2159:   switch( usOperation)
        !          2160:   {
        !          2161:     case ADD_HEAD_SEG:
        !          2162:       DosAllocSeg( sizeof( SEGLIST), &sel, 0);
        !          2163:       if( pslHead == NULL)
        !          2164:       {
        !          2165:        pslHead = MAKEP( sel, 0);
        !          2166:        if( pslHead == NULL)
        !          2167:          return( FALSE);
        !          2168:        *pslHead = *pslUpdate;
        !          2169:        pslHead->pslPrev = NULL;
        !          2170:        pslHead->pslNext = NULL;
        !          2171:        pslTail = pslHead;
        !          2172:       } else
        !          2173:       {
        !          2174:        psl = MAKEP( sel, 0);
        !          2175:        if( psl == NULL)
        !          2176:          return( FALSE);
        !          2177:        *psl = *pslUpdate;
        !          2178:        pslHead->pslPrev = psl;
        !          2179:        psl->pslNext = pslHead;
        !          2180:        psl->pslPrev = NULL;
        !          2181:        pslHead = psl;
        !          2182:       }
        !          2183:       return( TRUE);
        !          2184:       break;
        !          2185: 
        !          2186:     case ADD_TAIL_SEG:
        !          2187:       DosAllocSeg( sizeof( SEGLIST), &sel, 0);
        !          2188:       if( pslTail == NULL)
        !          2189:       {
        !          2190:        pslHead = MAKEP( sel, 0);
        !          2191:        if( pslHead == NULL)
        !          2192:          return( FALSE);
        !          2193:        *pslHead = *pslUpdate;
        !          2194:        pslHead->pslPrev = NULL;
        !          2195:        pslHead->pslNext = NULL;
        !          2196:        pslTail = pslHead;
        !          2197:       } else
        !          2198:       {
        !          2199:        psl = MAKEP( sel, 0);
        !          2200:        if( psl == NULL)
        !          2201:          return( FALSE);
        !          2202:        *psl = *pslUpdate;
        !          2203:        pslTail->pslNext = psl;
        !          2204:        psl->pslPrev = pslTail;
        !          2205:        psl->pslNext = NULL;
        !          2206:        pslTail = psl;
        !          2207:       }
        !          2208:       return( TRUE);
        !          2209:       break;
        !          2210: 
        !          2211:     case DEL_SEG:
        !          2212:       for( psl = pslHead; psl != NULL; psl = psl->pslNext)
        !          2213:       {
        !          2214:        if( psl->lSegId == pslUpdate->lSegId)
        !          2215:        {
        !          2216:          if( psl == pslHead)
        !          2217:          {
        !          2218:            pslHead = psl->pslNext;
        !          2219:            if( pslHead == NULL)
        !          2220:              pslTail = NULL;
        !          2221:            else
        !          2222:              pslHead->pslPrev = NULL;
        !          2223:          }else if( psl == pslTail)
        !          2224:          {
        !          2225:            pslTail = psl->pslPrev;
        !          2226:            pslTail->pslNext = NULL;
        !          2227:          } else
        !          2228:          {
        !          2229:            (psl->pslPrev)->pslNext = psl->pslNext;
        !          2230:            (psl->pslNext)->pslPrev = psl->pslPrev;
        !          2231:          }
        !          2232:          DosFreeSeg( SELECTOROF(psl));
        !          2233:          return( TRUE);
        !          2234:          break;
        !          2235:        }
        !          2236:       }
        !          2237:       return( FALSE);
        !          2238:       break;
        !          2239: 
        !          2240:     default:
        !          2241:       return( FALSE);
        !          2242:   }
        !          2243: }
        !          2244: 
        !          2245: 
        !          2246: 
        !          2247: /******************************************************************************/
        !          2248: /*                                                                            */
        !          2249: /* DumpPicture will free the list and segment store for the picture          */
        !          2250: /*                                                                            */
        !          2251: /******************************************************************************/
        !          2252: BOOL
        !          2253: DumpPicture()
        !          2254: {
        !          2255:   while( pslHead != NULL )
        !          2256:     SegListUpdate( DEL_SEG, pslHead);
        !          2257:   GpiDeleteSegments( hpsClient, 1L, CALLSEG_BASE + lLastSegId);
        !          2258:   GpiSetBitmap( hpsBitmapFile, NULL);
        !          2259:   if( hbmBitmapFile)
        !          2260:       GpiDeleteBitmap( hbmBitmapFile);
        !          2261:   GpiSetBitmap( hpsBitmapTemp, NULL);
        !          2262:   if( hbmBitmapTemp)
        !          2263:       GpiDeleteBitmap( hbmBitmapTemp);
        !          2264:   GpiSetBitmap( hpsBitmapDrag, NULL);
        !          2265:   if( hbmBitmapDrag)
        !          2266:       GpiDeleteBitmap( hbmBitmapDrag);
        !          2267: 
        !          2268:   return( TRUE);
        !          2269: }
        !          2270:  
        !          2271: /******************************************************************************/
        !          2272: /*                                                                            */
        !          2273: /* Draw the picture into segment store.                                      */
        !          2274: /*                                                                            */
        !          2275: /******************************************************************************/
        !          2276: BOOL
        !          2277: CreatePicture()
        !          2278: {
        !          2279:  
        !          2280:   POINTL    ptl, aptlSides[12], aptlControl[12];
        !          2281:   SEGLIST   sl;
        !          2282:   LONG     lCallSegId, l;
        !          2283: 
        !          2284:   /****************************************************************************/
        !          2285:   /* reset the default viewing transform to identity                         */
        !          2286:   /****************************************************************************/
        !          2287:   SetDVTransform( (FIXED)UNITY
        !          2288:                , (FIXED)0
        !          2289:                , (FIXED)0
        !          2290:                , (FIXED)UNITY
        !          2291:                , 0L
        !          2292:                , 0L
        !          2293:                , TRANSFORM_REPLACE);
        !          2294: 
        !          2295:   /****************************************************************************/
        !          2296:   /* set to store mode                                                       */
        !          2297:   /****************************************************************************/
        !          2298:   GpiSetDrawingMode( hpsClient, DM_RETAIN);
        !          2299:  
        !          2300:   /****************************************************************************/
        !          2301:   /* chaining and detectability off, fastchaining off                        */
        !          2302:   /****************************************************************************/
        !          2303:   GpiSetInitialSegmentAttrs( hpsClient, ATTR_CHAINED, ATTR_OFF);
        !          2304:   GpiSetInitialSegmentAttrs( hpsClient, ATTR_DETECTABLE, ATTR_OFF);
        !          2305:   GpiSetInitialSegmentAttrs( hpsClient, ATTR_FASTCHAIN, ATTR_OFF);
        !          2306:  
        !          2307:   /****************************************************************************/
        !          2308:   /* draw the pieces                                                         */
        !          2309:   /****************************************************************************/
        !          2310:   lLastSegId = 0;
        !          2311:   lCallSegId = CALLSEG_BASE;
        !          2312:   for( ptl.x = ptlBotLeft.x; ptl.x < ptlTopRight.x; ptl.x += 50)
        !          2313:   {
        !          2314:     for( ptl.y = ptlBotLeft.y; ptl.y < ptlTopRight.y; ptl.y += 50)
        !          2315:     {
        !          2316:       /************************************************************************/
        !          2317:       /* compute the piece outline control points                            */
        !          2318:       /************************************************************************/
        !          2319:       aptlControl[0].x = 10L;
        !          2320:       aptlControl[0].y = 10L;
        !          2321:       aptlControl[1].x = 40L;
        !          2322:       aptlControl[1].y = -10L;
        !          2323:       aptlControl[2].x = 50L;
        !          2324:       aptlControl[2].y = 0L;
        !          2325: 
        !          2326:       aptlControl[3].x = 40L;
        !          2327:       aptlControl[3].y = 10L;
        !          2328:       aptlControl[4].x = 60L;
        !          2329:       aptlControl[4].y = 40L;
        !          2330:       aptlControl[5].x = 50L;
        !          2331:       aptlControl[5].y = 50L;
        !          2332: 
        !          2333:       aptlControl[6].x = 40L;
        !          2334:       aptlControl[6].y = 40L;
        !          2335:       aptlControl[7].x = 10L;
        !          2336:       aptlControl[7].y = 60L;
        !          2337:       aptlControl[8].x = 0L;
        !          2338:       aptlControl[8].y = 50L;
        !          2339: 
        !          2340:       aptlControl[9].x = 10L;
        !          2341:       aptlControl[9].y = 40L;
        !          2342:       aptlControl[10].x = -10L;
        !          2343:       aptlControl[10].y = 10L;
        !          2344:       aptlControl[11].x = 0L;
        !          2345:       aptlControl[11].y = 0L;
        !          2346: 
        !          2347:       if( ptl.y == ptlBotLeft.y)
        !          2348:       {
        !          2349:        aptlControl[0].y = 0L;
        !          2350:        aptlControl[1].y = 0L;
        !          2351:       }
        !          2352: 
        !          2353:       if( (ptl.x + 50) == ptlTopRight.x)
        !          2354:       {
        !          2355:        aptlControl[3].x = 50L;
        !          2356:        aptlControl[4].x = 50L;
        !          2357:       }
        !          2358: 
        !          2359:       if( (ptl.y + 50) == ptlTopRight.y)
        !          2360:       {
        !          2361:        aptlControl[6].y = 50L;
        !          2362:        aptlControl[7].y = 50L;
        !          2363:       }
        !          2364: 
        !          2365:       if( ptl.x == ptlBotLeft.x)
        !          2366:       {
        !          2367:        aptlControl[ 9].x = 0L;
        !          2368:        aptlControl[10].x = 0L;
        !          2369:       }
        !          2370: 
        !          2371:       for( l=0; l<12; l++)
        !          2372:       {
        !          2373:        aptlSides[l].x = ptl.x + aptlControl[l].x;
        !          2374:        aptlSides[l].y = ptl.y + aptlControl[l].y;
        !          2375:       }
        !          2376: 
        !          2377:       GpiOpenSegment( hpsClient, ++lCallSegId);
        !          2378:       GpiMove( hpsClient, &ptl);
        !          2379:       GpiPolyLine( hpsClient, 12L, aptlSides);
        !          2380:       GpiCloseSegment( hpsClient);
        !          2381: 
        !          2382:       /************************************************************************/
        !          2383:       /* draw the root segment                                               */
        !          2384:       /************************************************************************/
        !          2385:       GpiOpenSegment( hpsClient, ++lLastSegId);
        !          2386:       GpiSetTag( hpsClient, lLastSegId);
        !          2387: 
        !          2388:       /************************************************************************/
        !          2389:       /* store the piece location                                            */
        !          2390:       /************************************************************************/
        !          2391:       sl.ptlLocation = ptl;
        !          2392: 
        !          2393:       /************************************************************************/
        !          2394:       /* compute the dimensions of the matching rects for BitBlt             */
        !          2395:       /************************************************************************/
        !          2396:       sl.rclBitBlt.xLeft   = ptl.x - 10;
        !          2397:       sl.rclBitBlt.yBottom = ptl.y - 10;
        !          2398:       sl.rclBitBlt.xRight  = ptl.x + 60;
        !          2399:       sl.rclBitBlt.yTop    = ptl.y + 60;
        !          2400:       if( ptl.x == ptlBotLeft.x)
        !          2401:        sl.rclBitBlt.xLeft += 10;
        !          2402:       if( ptl.y == ptlBotLeft.y)
        !          2403:        sl.rclBitBlt.yBottom += 10;
        !          2404:       if( (ptl.x + 50) == ptlTopRight.x)
        !          2405:        sl.rclBitBlt.xRight -= 10;
        !          2406:       if( (ptl.y + 50) == ptlTopRight.y)
        !          2407:        sl.rclBitBlt.yTop -= 10;
        !          2408: 
        !          2409:       /************************************************************************/
        !          2410:       /* draw one piece                                                      */
        !          2411:       /************************************************************************/
        !          2412:       GpiBeginPath( hpsClient, 1L);
        !          2413:       GpiMove( hpsClient, &ptl);
        !          2414:       GpiPolyLine( hpsClient, 12L, aptlSides);
        !          2415:       GpiEndPath( hpsClient);
        !          2416:       GpiSetColor( hpsClient, CLR_BLACK);
        !          2417:       GpiLabel( hpsClient, FILLPATH);
        !          2418: 
        !          2419:       GpiSetClipPath( hpsClient, 0L, SCP_RESET);
        !          2420:       GpiBeginPath( hpsClient, 1L);
        !          2421:       GpiMove( hpsClient, &ptl);
        !          2422:       GpiPolyLine( hpsClient, 12L, aptlSides);
        !          2423:       GpiEndPath( hpsClient);
        !          2424:       GpiSetClipPath( hpsClient, 1L, SCP_AND);
        !          2425:       GpiLabel( hpsClient, BITBLT_TOP);
        !          2426:       GpiLabel( hpsClient, BITBLT_BOTTOM);
        !          2427: 
        !          2428:       GpiSetClipPath( hpsClient, 0L, SCP_RESET);
        !          2429:       GpiSetColor( hpsClient, CLR_RED);
        !          2430:       GpiMove( hpsClient, &ptl);
        !          2431:       GpiPolyLine( hpsClient, 12L, aptlSides);
        !          2432: 
        !          2433:       GpiCloseSegment( hpsClient);
        !          2434:       GpiSetSegmentAttrs( hpsClient, lLastSegId, ATTR_CHAINED, ATTR_ON);
        !          2435:       GpiSetSegmentAttrs( hpsClient, lLastSegId, ATTR_DETECTABLE, ATTR_ON);
        !          2436: 
        !          2437:       sl.lSegId = lLastSegId;
        !          2438:       sl.pslNext = NULL;
        !          2439:       sl.pslPrev = NULL;
        !          2440:       SetRect( &sl);
        !          2441:       SegListUpdate( ADD_TAIL_SEG, &sl);
        !          2442:     }
        !          2443:   }
        !          2444:   return( TRUE);
        !          2445: }
        !          2446:  
        !          2447: /******************************************************************************/
        !          2448: /*                                                                            */
        !          2449: /* Create the Temp and Drag bitmaps.                                         */
        !          2450: /*                                                                            */
        !          2451: /******************************************************************************/
        !          2452: BOOL
        !          2453: PrepareBitmap()
        !          2454: {
        !          2455:   bmpBitmapTemp    = bmpBitmapFile;
        !          2456:   bmpBitmapTemp.cx = LOUSHORT( (sizlMaxClient.cx * 6L) / 5L);
        !          2457:   bmpBitmapTemp.cy = LOUSHORT( (sizlMaxClient.cy * 6L) / 5L);
        !          2458:   hbmBitmapTemp    = GpiCreateBitmap( hpsBitmapTemp
        !          2459:                                    , &bmpBitmapTemp
        !          2460:                                    , 0L
        !          2461:                                    , NULL
        !          2462:                                    , NULL);
        !          2463:   if( !hbmBitmapTemp)
        !          2464:     return( FALSE);
        !          2465: 
        !          2466:   bmpBitmapDrag    = bmpBitmapFile;
        !          2467:   bmpBitmapDrag.cx = LOUSHORT( (sizlMaxClient.cx * 6L) / 5L);
        !          2468:   bmpBitmapDrag.cy = LOUSHORT( (sizlMaxClient.cy * 6L) / 5L);
        !          2469:   hbmBitmapDrag    = GpiCreateBitmap( hpsBitmapDrag
        !          2470:                                    , &bmpBitmapDrag
        !          2471:                                    , 0L
        !          2472:                                    , NULL
        !          2473:                                    , NULL);
        !          2474:   if( !hbmBitmapDrag)
        !          2475:     return( FALSE);
        !          2476:   return( TRUE);
        !          2477: }
        !          2478: 
        !          2479: /******************************************************************************/
        !          2480: /*                                                                            */
        !          2481: /* Create a memory DC and an associated PS.                                  */
        !          2482: /*                                                                            */
        !          2483: /******************************************************************************/
        !          2484: BOOL
        !          2485: CreateBitmapHdcHps( phdc, phps)
        !          2486: 
        !          2487: PHDC  phdc;
        !          2488: PHPS  phps;
        !          2489: {
        !          2490:   SIZEL    sizl;
        !          2491:   HDC     hdc;
        !          2492:   HPS     hps;
        !          2493: 
        !          2494:   hdc = DevOpenDC( habMain, OD_MEMORY, "*", 3L, (PDEVOPENDATA)&dop, NULL);
        !          2495:   if( !hdc)
        !          2496:     return( FALSE);
        !          2497: 
        !          2498:   sizl.cx = sizl.cy = 0L;
        !          2499:   hps = GpiCreatePS( habMain
        !          2500:                   , hdc
        !          2501:                   , &sizl
        !          2502:                   , PU_PELS | GPIA_ASSOC );
        !          2503:   if( !hps)
        !          2504:     return( FALSE);
        !          2505: 
        !          2506:   *phdc = hdc;
        !          2507:   *phps = hps;
        !          2508:   return( TRUE);
        !          2509: }
        !          2510: 
        !          2511: /******************************************************************************/
        !          2512: /*                                                                           */
        !          2513: /* Get the bitmap from disk.                                                 */
        !          2514: /* Note that there are 2 formats for bitmap files, one of which is archaic.   */
        !          2515: /* Both formats are supported here.  All new bitmaps should follow the format */
        !          2516: /* in BITMAPFILEHEADER.                                                      */
        !          2517: /*                                                                           */
        !          2518: /******************************************************************************/
        !          2519: BOOL
        !          2520: ReadBitmap( hfile)
        !          2521: 
        !          2522: HFILE  hfile;
        !          2523: {
        !          2524:     ULONG cScans;
        !          2525:     ULONG ulSize;       /* Number of bytes occupied by bitmap bits.          */
        !          2526:     USHORT cSegs;       /* Number of 64K segments in ulSize.                 */
        !          2527:     USHORT cbExtra;     /* Bytes in last segment of ulSize.                  */
        !          2528:     SEL sel;            /* Base selector to file data.                       */
        !          2529:     USHORT hugeshift;   /* Segment index shift value.                        */
        !          2530:     USHORT cbRead1;     /* Number of bytes to read first call to DosRead     */
        !          2531:     USHORT cbRead2;     /* Number of bytes to read second call to DosRead    */
        !          2532:     USHORT cbRead;      /* Number of bytes read by DosRead.                  */
        !          2533:     BOOL fRet = FALSE;  /* Function return code.                             */
        !          2534:     INT  i;             /* Generic loop index.                               */
        !          2535:     FILESTATUS fsts;
        !          2536:     PBITMAPFILEHEADER pbfh;
        !          2537:     PRCBITMAP  rb;
        !          2538:     PBYTE pImage;
        !          2539: 
        !          2540: 
        !          2541:     /**************************************************************************/
        !          2542:     /* Find out how big the file is so we can read the whole thing in.       */
        !          2543:     /**************************************************************************/
        !          2544: 
        !          2545:     if( DosQFileInfo( hfile, 1, &fsts, sizeof(FILESTATUS)) != 0)
        !          2546:        goto ReadBitmap_close_file;
        !          2547: 
        !          2548:     ulSize  = fsts.cbFile;
        !          2549:     cSegs   = (USHORT)(ulSize/0x10000L);
        !          2550:     cbExtra = (USHORT)(ulSize%0x10000L);
        !          2551:     if (DosAllocHuge(cSegs, cbExtra, (PSEL)&sel, 0, 0))
        !          2552:        goto ReadBitmap_close_file;
        !          2553:     if (DosGetHugeShift( &hugeshift))
        !          2554:        goto ReadBitmap_free_bits;
        !          2555: 
        !          2556:     pImage = (PBYTE)MAKEP(sel, 0);
        !          2557:     rb    = (PRCBITMAP)pImage;
        !          2558:     pbfh   = (PBITMAPFILEHEADER)pImage;
        !          2559: 
        !          2560: 
        !          2561:     /**************************************************************************/
        !          2562:     /* Read the bits in from the file. The DosRead function allows a         */
        !          2563:     /* maximum of 64K-1 bytes read at a time.  We get around this            */
        !          2564:     /* by reading two 32K chunks for each 64K segment, and reading the       */
        !          2565:     /* last segment in one piece.                                            */
        !          2566:     /**************************************************************************/
        !          2567: 
        !          2568:     for (i = 0; i <= cSegs; ++i)
        !          2569:     {
        !          2570:        if (i < cSegs)
        !          2571:        {
        !          2572:            /* This segment is 64K bytes long, so split it up. */
        !          2573:            cbRead1 = 0x8000;
        !          2574:            cbRead2 = 0x8000;
        !          2575:        }
        !          2576:        else
        !          2577:        {
        !          2578:            /* This segment is less than 64K bytes long, so read it all. */
        !          2579:            cbRead1 = cbExtra;
        !          2580:            cbRead2 = 0;
        !          2581:        }
        !          2582: 
        !          2583:        /* There's a possibility that cbExtra will be 0, so check
        !          2584:         * to avoid an unnecessary system call.
        !          2585:         */
        !          2586:        if (cbRead1 > 0)
        !          2587:        {
        !          2588:            if (DosRead( hfile
        !          2589:                       , (PVOID)MAKEP(sel+(i<<hugeshift), 0)
        !          2590:                       , cbRead1
        !          2591:                       , &cbRead))
        !          2592:                goto ReadBitmap_free_bits;
        !          2593:            if (cbRead1 != cbRead)
        !          2594:                goto ReadBitmap_free_bits;
        !          2595:        }
        !          2596: 
        !          2597:        /* This will always be skipped on the last partial segment. */
        !          2598:        if (cbRead2 > 0)
        !          2599:        {
        !          2600:            if (DosRead( hfile
        !          2601:                       , (PVOID)MAKEP(sel+(i<<hugeshift), cbRead1)
        !          2602:                       , cbRead2
        !          2603:                       , &cbRead))
        !          2604:                goto ReadBitmap_free_bits;
        !          2605:            if (cbRead2 != cbRead)
        !          2606:                goto ReadBitmap_free_bits;
        !          2607:        }
        !          2608:     }
        !          2609: 
        !          2610: 
        !          2611:     /**************************************************************************/
        !          2612:     /* Tell GPI to put the bits into the thread's PS. The function returns    */
        !          2613:     /* the number of scan lines of the bitmap that were copied.  We want      */
        !          2614:     /* all of them at once.                                                  */
        !          2615:     /**************************************************************************/
        !          2616: 
        !          2617:     if (pbfh->bmp.cbFix != sizeof(BITMAPINFOHEADER))
        !          2618:     {
        !          2619:        bmpBitmapFile.cx        = rb->bmWidth;
        !          2620:        bmpBitmapFile.cy        = rb->bmHeight;
        !          2621:        bmpBitmapFile.cPlanes   = rb->bmPlanes;
        !          2622:        bmpBitmapFile.cBitCount = rb->bmBitcount;
        !          2623:        hbmBitmapFile = GpiCreateBitmap( hpsBitmapFile
        !          2624:                                       , &bmpBitmapFile
        !          2625:                                       , 0L
        !          2626:                                       , NULL
        !          2627:                                       , NULL);
        !          2628:        if( !hbmBitmapFile)
        !          2629:            goto ReadBitmap_free_bits;
        !          2630:        GpiSetBitmap( hpsBitmapFile, hbmBitmapFile);
        !          2631: 
        !          2632:         pImage += rb->dwBitsOffset;
        !          2633:         rb->dwBitsOffset = sizeof(BITMAPINFOHEADER);
        !          2634:        cScans = GpiSetBitmapBits( hpsBitmapFile
        !          2635:                                 , 0L
        !          2636:                                 , (LONG)rb->bmHeight
        !          2637:                                 , pImage
        !          2638:                                 , (PBITMAPINFO)&(rb->dwBitsOffset));
        !          2639:        if (cScans != (LONG)rb->bmHeight)  /* original number of scans ? */
        !          2640:            goto ReadBitmap_free_bits;
        !          2641:     }
        !          2642:     else
        !          2643:     {
        !          2644:        bmpBitmapFile.cx        = pbfh->bmp.cx;
        !          2645:        bmpBitmapFile.cy        = pbfh->bmp.cy;
        !          2646:        bmpBitmapFile.cPlanes   = pbfh->bmp.cPlanes;
        !          2647:        bmpBitmapFile.cBitCount = pbfh->bmp.cBitCount;
        !          2648:        hbmBitmapFile = GpiCreateBitmap( hpsBitmapFile
        !          2649:                                       , &bmpBitmapFile
        !          2650:                                       , 0L
        !          2651:                                       , NULL
        !          2652:                                       , NULL);
        !          2653:        if( !hbmBitmapFile)
        !          2654:            goto ReadBitmap_free_bits;
        !          2655:        GpiSetBitmap( hpsBitmapFile, hbmBitmapFile);
        !          2656: 
        !          2657:        cScans = GpiSetBitmapBits( hpsBitmapFile
        !          2658:                                 , 0L
        !          2659:                                 , (LONG)pbfh->bmp.cy
        !          2660:                                 , pImage + pbfh->offBits
        !          2661:                                 , (PBITMAPINFO)&(pbfh->bmp));
        !          2662:        if (cScans != (LONG)pbfh->bmp.cy)  /* original number of scans ? */
        !          2663:            goto ReadBitmap_free_bits;
        !          2664:     }
        !          2665: 
        !          2666:     fRet = TRUE;     /* okey-dokey */
        !          2667: 
        !          2668: 
        !          2669:     /**************************************************************************/
        !          2670:     /* Close the file, free the buffer space and leave.  This is a           */
        !          2671:     /* common exit point from the function.  Since the same cleanup          */
        !          2672:     /* operations need to be performed for such a large number of            */
        !          2673:     /* possible error conditions, this is concise way to do the right        */
        !          2674:     /* thing.                                                                */
        !          2675:     /**************************************************************************/
        !          2676: 
        !          2677: ReadBitmap_free_bits:
        !          2678:     DosFreeSeg( sel);
        !          2679: ReadBitmap_close_file:
        !          2680:     DosClose( hfile);
        !          2681:     return fRet;
        !          2682: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.