home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 4 Unleashed / Visual_Basic_4_Unleashed_SAMS_Publishing_1995.iso / repease / rep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-18  |  100.5 KB  |  2,612 lines
  1. /*==============================================================================
  2.    REP.C
  3.    ReportEase Plus - Window process and painting functions.
  4.  
  5.    ReportEase Plus
  6.    Version 2.0
  7.  
  8.    Sub Systems, Inc.
  9.    ReportEase Plus, Copyright (c) 1993, Sub Systems, Inc. All Rights Reserved.
  10.    159 Main Street, #8C, Stoneham,  MA 02180 
  11.    (617) 438-8901.
  12.  
  13.    Software License Agreement  (1993)              
  14.    ----------------------------------
  15.    This license agreement allows the purchaser the right to modify the 
  16.    source code to incorporate in their application.
  17.    The target application must not be distributed as a standalone report writer
  18.    or a mail merge product.
  19.    Sub Systems, Inc. reserves the right to prosecute anybody found to be 
  20.    making illegal copies of the executable software or compiling the source
  21.    code for the purpose of selling there after.
  22.  
  23. ===============================================================================*/
  24.  
  25. #include "windows.h"
  26.  
  27. #if defined (_WIN32)
  28.    #if !defined(WIN32)
  29.      #define WIN32
  30.    #endif
  31. #endif
  32. #if !defined(WIN32) 
  33.   #include "print.h"
  34. #endif
  35.  
  36. #include "stdio.h"
  37. #include "stdlib.h"
  38. #include "ctype.h"
  39. #include "dos.h"
  40. #include "fcntl.h"
  41. #include "io.h"
  42. #include "signal.h"
  43. #include "string.h"
  44. #include "malloc.h"
  45. #include "memory.h"
  46. #include "sys\types.h"
  47. #include "sys\stat.h"
  48. #include "setjmp.h"
  49.  
  50. #include "rep.h"
  51.  
  52. #define  PREFIX 
  53. #include "rep1.h"
  54.  
  55. /****************************************************************************
  56.    form:
  57.    This routine simply call FORM initialization routine.  The routine
  58.    returns a 0 if successful, otherwise it returns an error code. see
  59.    ERR_ in rew.h file.
  60. *****************************************************************************/
  61. int WINAPI _export form(struct StrForm far *ArgPtr)
  62. {
  63.    int result,WinVer;
  64.    
  65.    // prepare to return an error code
  66.    #if defined (WIN32)
  67.       if (setjmp(FrAbort)==-1) return ErrorCode; // Fatal error return location 
  68.    #else
  69.       if (Catch((LPCATCHBUF)&FrAbort)==-1) return ErrorCode; // Fatal error return location 
  70.    #endif
  71.  
  72.    SessionType='F';                    // form editor session 
  73.    FormArg=(*ArgPtr);
  74.  
  75.    //* Transfer the some input parameter variables to the global area *
  76.    strcpy(FrFileName,FormArg.file);    // current report file name 
  77.    FrShowHorBar=FormArg.ShowHorBar;    // show horizontal scroll bar 
  78.    FrShowVerBar=FormArg.ShowVerBar;    // show vertical scroll bar 
  79.  
  80.    //hFrInst=FormArg.hInst;           //  uncomment for STATIC linking
  81.    //hFrPrevInst=FormArg.hPrevInst;   //  uncomment for STATIC linking
  82.  
  83.    hFrParentWnd=FormArg.hParentWnd;    // Handle to the parent window 
  84.  
  85.    //************ initialize other variables **********
  86.    UseScreen=TRUE;
  87.    FormArg.modified =FALSE;
  88.  
  89.    //********************** assign the default font and point size *********
  90.    if (FormArg.FontTypeFace[0]==0) {
  91.       WinVer=(int)GetVersion();
  92.       if ((LOBYTE(WinVer))==3 && (HIBYTE(WinVer))==0) {    // windows 3.0 
  93.           lstrcpy(FormArg.FontTypeFace,"Helv");
  94.       }
  95.       else {                                               // windows 3.1 
  96.           lstrcpy(FormArg.FontTypeFace,"Arial");
  97.       }
  98.    }
  99.  
  100.    if (0!=(result=InitFr(FormArg.style,FormArg.x,FormArg.y,FormArg.width,FormArg.height))) return result;
  101.    
  102.    FormArg.open=TRUE;  // mark this window as open 
  103.    
  104.    (*ArgPtr)=FormArg;   // pass back the updated structure
  105.  
  106.    return 0;
  107. } 
  108.  
  109. /****************************************************************************
  110.    RepSetMsgCallback:
  111.    This function is called by the application to set a call back function to
  112.    receive the DLL messages.  This function is needed only by the application
  113.    which do not have the capability to receive Windows messages.
  114. *****************************************************************************/
  115. int WINAPI _export RepSetMsgCallback(MSG_CALLBACK funct)
  116. {
  117.    MsgCallback=funct;
  118.    return TRUE;
  119. }
  120.  
  121. /******************************************************************************
  122.    LibMain: Function to initialize DLL
  123. ******************************************************************************/
  124. #if defined (WIN32)
  125.    BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD reason, LPVOID reserved)
  126. #else
  127.    int CALLBACK LibMain(HINSTANCE hInstance, WORD wDataSeg, WORD cbHeapSize,  LPSTR lpszCmdLine)
  128. #endif
  129. {
  130.     // process the 'reason' flag for WIN32
  131.     #if defined (WIN32)
  132.        Win32=TRUE;
  133.        if (reason == DLL_PROCESS_DETACH) return WEP(0);
  134.        if (reason != DLL_PROCESS_ATTACH) return TRUE;
  135.     #else
  136.        Win32=FALSE;
  137.     #endif
  138.  
  139.     hFrInst=hInstance;
  140.     hFrPrevInst=0;
  141.  
  142.     return TRUE;
  143. }
  144.  
  145. /*****************************************************************************
  146.     WEP:
  147.     Library exit routine.
  148. ******************************************************************************/
  149. int CALLBACK _export WEP(int nParameter)
  150. {
  151.     return 1;
  152. }
  153.  
  154. /****************************************************************************
  155.     FrWndProc:
  156.     This routine process the messages coming to the main FORM window.
  157. ****************************************************************************/
  158.  
  159. LRESULT CALLBACK _export FrWndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
  160. {
  161.     int opt,i;
  162.  
  163.  
  164.     if (WindowBeingCreated) return (DefWindowProc(hWnd, message, wParam, lParam));
  165.  
  166.     //*********** translate accelerator ***********
  167.     if (FrTranslateAccelerator(hWnd,message,wParam,lParam)) return TRUE; // accelerator translated 
  168.  
  169.     switch (message) {
  170.         case WM_INITMENU:                     // initialize menu 
  171.             if ((GetMenu(hWnd)!=(HMENU)wParam)) break;
  172.             FrInitMenu((HMENU)wParam);break;
  173.  
  174.         case WM_VSCROLL:                      // vertical scroll bar commands 
  175.             switch (SCROLL_MSG(wParam,lParam)) {
  176.                 case SB_LINEDOWN:             // scroll window one line down 
  177.                    FrWinDown();break;
  178.                 case SB_LINEUP:               // scroll window one line up 
  179.                    FrWinUp();break;
  180.                 case SB_PAGEDOWN:             // next page 
  181.                    FrWinOrgY+=FrWinHeight/2;
  182.                    PaintFlag=PAINT_WIN;FrPaint();break;
  183.                 case SB_PAGEUP:               // previous page 
  184.                    FrWinOrgY-=FrWinHeight/2;
  185.                    PaintFlag=PAINT_WIN;FrPaint();break;
  186.                 case SB_THUMBTRACK:           // absolute line position as the thump moves
  187.                    FrWinOrgY=(int)(((long)FrHeight*THUMB_POS(wParam,lParam))/(VER_SCROLL_MAX-VER_SCROLL_MIN));
  188.                    PaintFlag=PAINT_WIN;FrPaint();break;
  189.                 default:
  190.                    break;
  191.             }
  192.             break;
  193.         case WM_HSCROLL:                      // horizontal scroll bar commands 
  194.             switch (SCROLL_MSG(wParam,lParam)) {
  195.                 case SB_LINEDOWN:             // scroll window one column toward right 
  196.                    FrWinRight();break;
  197.                 case SB_LINEUP:               // scroll window one column toward left 
  198.                    FrWinLeft();break;
  199.                 case SB_PAGEDOWN:             // next horizontal page 
  200.                    FrWinOrgX+=FrWinWidth/2;
  201.                    PaintFlag=PAINT_WIN;FrPaint();break;
  202.                 case SB_PAGEUP:               // previous horizontal page 
  203.                    FrWinOrgX-=FrWinWidth/2;
  204.                    PaintFlag=PAINT_WIN;FrPaint();break;
  205.                 case SB_THUMBTRACK:           // absolute column position as the thump moves
  206.                    FrWinOrgX=(int)(((long)FrWidth*THUMB_POS(wParam,lParam))/(HOR_SCROLL_MAX-HOR_SCROLL_MIN));
  207.                    PaintFlag=PAINT_WIN;FrPaint();break;
  208.                 default:
  209.                    break;
  210.             }
  211.             break;
  212.         case WM_COMMAND:
  213.             if (FrHelpWanted) {              // show contect sensitive help if requrested 
  214.                 WinHelp(hWnd,FrHelpFile,HELP_CONTEXT,wParam);
  215.                 FrHelpWanted=FALSE;
  216.                 break;
  217.             }
  218.             if (UndoItem && wParam!=ID_UNDO && wParam!=ID_DESC_WND) DiscardUndo();  // discard the previous undo data
  219.  
  220.             switch (COMMAND_ID(wParam,lParam)) {
  221.                 //*********************************************************
  222.                 // Navigation commands                                     
  223.                 //*********************************************************
  224.                 case ID_PGUP:                 // process page-up key 
  225.                     FrWinOrgY-=FrHeight/2;
  226.                     PaintFlag=PAINT_WIN;FrPaint();break;
  227.                 case ID_PGDN:                 // process page-down key 
  228.                     FrWinOrgY+=FrHeight/2;
  229.                     PaintFlag=PAINT_WIN;FrPaint();break;
  230.                 case ID_UP:                   // process the up arrow key 
  231.                     if (SelItem<0 || item[SelItem].type==SECTION) FrWinUp();
  232.                     else FrKeyMove(ID_UP);      // move the item
  233.                     break;
  234.                 case ID_DOWN:                 // process the down arrow key 
  235.                     if (SelItem<0 || item[SelItem].type==SECTION) FrWinDown();
  236.                     else FrKeyMove(ID_DOWN);      // move the item
  237.                     break;
  238.                 case ID_LEFT:                 // process the left arrow 
  239.                     if (SelItem<0 || item[SelItem].type==SECTION) FrWinLeft();
  240.                     else FrKeyMove(ID_LEFT);      // move the item
  241.                     break;
  242.                 case ID_RIGHT:                // process the right arrow 
  243.                     if (SelItem<0 || item[SelItem].type==SECTION) FrWinRight();
  244.                     else FrKeyMove(ID_RIGHT);      // move the item
  245.                     break;
  246.                 
  247.                 //*********************************************************
  248.                 // Edit functions                     
  249.                 //*********************************************************
  250.                 case ID_POS_ITEM:             // position the text inside the item 
  251.                     PosItem();break;
  252.                 case ID_ITEM_OUTLINE:         // edit the item outlines
  253.                     EditItemOutline();break;
  254.                 case ID_ITEM_BACKGROUND:      // edit the item background
  255.                     EditItemBackground();break;
  256.                 case ID_CENTER_ITEM:          // center an item horizontally
  257.                     CenterItem();break;
  258.                 case ID_DEL_ITEM:             // delete the selected item
  259.                     DeleteItem();break;
  260.                 case ID_FONTS:                // display fonts 
  261.                     FrFonts();break;
  262.  
  263.                 case ID_EXPAND_HORZ:         // insert space horizontally
  264.                     ExpandHorizontal();break;
  265.                 case ID_EXPAND_VERT:         // insert space vertically
  266.                     ExpandVertical();break;
  267.                 case ID_COMPRESS_HORZ:       // delete space horizontally
  268.                     CompressHorizontal();break;
  269.                 case ID_COMPRESS_VERT:       // delete space vertically
  270.                     CompressVertical();break;
  271.  
  272.  
  273.                 //*********************************************************
  274.                 // File Menu functions                                            
  275.                 //*********************************************************
  276.                 case  ID_SAVE:               // save the modified text 
  277.                     FrSave(FrFileName);break;
  278.                 case  ID_SAVEAS:             // save the modified text, as user for the file name
  279.                     FrSaveAs(FrFileName);break;
  280.                 case  ID_REP_PARAM:          // accepts report name, page layout, etc options from the users 
  281.                     FrRepParameters();break;
  282.                 case  ID_REP_FILTER:         // accepts record filter for the report 
  283.                     FrRepFilter();break;
  284.                 case  ID_PRINT_OPTIONS:      // accepts printer options from the users 
  285.                     FrPrintOptions();break;
  286.                 case  ID_QUIT:               // quit FORM session 
  287.                     CloseFr();break;
  288.  
  289.                 //********************************************************
  290.                 // Field Functions                                        
  291.                 //********************************************************
  292.                 case ID_INSERT_DATA:         // insert a data field 
  293.                 case ID_INSERT_CALC:         // insert a calculation field 
  294.                 case ID_INSERT_SYS:          // insert a system field 
  295.                 case ID_INSERT_DLG:          // insert a dialog field 
  296.                     InsertFieldPartI(wParam);// begin the field insertion process
  297.                     break;
  298.  
  299.                 case ID_EDIT_FLD:            // edit field attributes 
  300.                     ModifyField();break;
  301.  
  302.                 case ID_EDIT_FLD_EXP:        // edit calculation field expression 
  303.                     EditFieldExp();break;
  304.  
  305.                 case ID_DLG_CREATE:          // create a dialog field 
  306.                     CreateDlgField();break;
  307.                 case ID_DLG_MODIFY:          // modify a dialog field 
  308.                     ModifyDlgField();break;
  309.                 case ID_DLG_DELETE:          // delete a dialog field 
  310.                     DeleteDlgField();break;
  311.  
  312.                 //********************************************************
  313.                 // Section Functions                                      
  314.                 //********************************************************
  315.                 case ID_SEC_NEW:             // create new section 
  316.                     NewSection();break;
  317.                 case ID_SEC_EDIT:            // create new section 
  318.                     EditSection();break;
  319.  
  320.                 case ID_SEC_FILTER:          // Edit section selection crieteria 
  321.                     EditSectionFilter();break;
  322.  
  323.                 case ID_SEC_SORT:            // Edit section sort field 
  324.                     EditSectionSort();break;
  325.                 case ID_SEC_BREAK:           // Edit section break field 
  326.                     EditSectionBreak();break;
  327.  
  328.                 //*********************************************************
  329.                 // Line functions                     
  330.                 //*********************************************************
  331.                 case ID_INSERT_LINE:         // insert a line 
  332.                     InsertLinePartI();break;
  333.                 case ID_EDIT_LINE:           // edit line 
  334.                     EditLine();break;
  335.  
  336.                 //*********************************************************
  337.                 // Label functions                     
  338.                 //*********************************************************
  339.                 case ID_INSERT_LABEL:         // insert a label 
  340.                     InsertLabelPartI();break;
  341.                 case ID_EDIT_LABEL:           // edit a label 
  342.                     if (hDescWnd) {
  343.                        SetFocus(hDescWnd);
  344.                     }
  345.                     break;
  346.  
  347.                 //*********************************************************
  348.                 // Picture functions                     
  349.                 //*********************************************************
  350.                 case  ID_PICT_FROM_CB:        // copy a picture from clipboard 
  351.                 case  ID_PICT_FROM_FILE:      // insert a picture from a bitmap file 
  352.                     InsertPicturePartI(COMMAND_ID(wParam,lParam));break;
  353.                 
  354.                 //*********************************************************
  355.                 // Arrange Menu functions                                        
  356.                 //*********************************************************
  357.                 case ID_ALIGN_HORZ_TOP:      // Align at top edge
  358.                     AlignHorzTop();break;
  359.                 case ID_ALIGN_HORZ_BOT:      // Align at bottom edge
  360.                     AlignHorzBot();break;
  361.                 case ID_ALIGN_HORZ_CENTER:   // Align horizontal at center line.
  362.                     AlignHorzCenter();break;
  363.                 case ID_ALIGN_VERT_LEFT:     // Align at left edge
  364.                     AlignVertLeft();break;
  365.                 case ID_ALIGN_VERT_RIGHT:    // Align at right edge
  366.                     AlignVertRight();break;
  367.                 case ID_ALIGN_VERT_CENTER:   // Align at the vertical center line
  368.                     AlignVertCenter();break;
  369.                 
  370.                 case ID_EVEN_SPACE_HORZ:     // set the equal horizontal space between the items
  371.                     EvenSpaceHorz();break;
  372.                 case ID_EVEN_SPACE_VERT:     // set the equal vertical space between the items
  373.                     EvenSpaceVert();break;
  374.                 
  375.                 case ID_EVEN_SIZE_HORZ:      // set the same width for the selected items
  376.                     EvenSizeHorz();break;
  377.                 case ID_EVEN_SIZE_VERT:      // set the same height for the selected items
  378.                     EvenSizeVert();break;
  379.  
  380.                 case ID_UNDO:                // undo previous arrange command
  381.                     Undo();break;
  382.  
  383.                 //*********************************************************
  384.                 // Miscellaneous functions                                        
  385.                 //*********************************************************
  386.                 case  ID_HELP:               // display help on functions 
  387.                     WinHelp(hWnd,FrHelpFile,HELP_INDEX,0L);
  388.                     break;
  389.  
  390.                 case ID_DESC_WND:            // update label text
  391.                     if (NOTIFY_MSG(wParam,lParam)==EN_KILLFOCUS) UpdateLabelText();
  392.                     break;
  393.  
  394.                 default:
  395.                     return (DefWindowProc(hWnd, message, wParam, lParam));
  396.             }
  397.             break;
  398.  
  399.             //***************************************************************
  400.             // Mouse functions                                               
  401.             //***************************************************************
  402.         case WM_LBUTTONDOWN:                // position or select the object
  403.         case WM_MBUTTONDOWN:                // position or select the object
  404.         case WM_RBUTTONDOWN:                // position or select the object
  405.             FrMouseDown(wParam,lParam);
  406.             break;
  407.  
  408.         case WM_MOUSEMOVE:                   // set highlighted areas 
  409.             if (IgnoreMouseMove) FrSetCursorShape(lParam);
  410.             else FrMouseMove(wParam,lParam);
  411.             break;
  412.  
  413.         case WM_LBUTTONUP:                   // stop stretching highlighted area now 
  414.         case WM_RBUTTONUP: 
  415.         case WM_MBUTTONUP:
  416.             switch (CurCmd) {
  417.                case ID_MOVE_ITEM:
  418.                    MoveItem();break;      // move the selected item
  419.                case ID_SIZE_ITEM:
  420.                    SizeItem();            // resize the selected item
  421.                    DiscardUndo();         // discard unwanted undo
  422.                    break;
  423.                case ID_SELECT_MULTIPLE:   // select multiple items
  424.                    SelectGroupItemPartII();
  425.                    break;
  426.                default:
  427.                    if (CurCmd!=-1 || !DrawOptRect) break;
  428.  
  429.                    // check if any option rectangle has been selected
  430.                    opt=GetMouseOpt(lParam);
  431.                    if      (opt==OPT_LABEL)InsertLabelPartI();
  432.                    else if (opt==OPT_DATA) InsertFieldPartI(ID_INSERT_DATA);
  433.                    else if (opt==OPT_CALC) InsertFieldPartI(ID_INSERT_CALC);
  434.                    else if (opt==OPT_SYS)  InsertFieldPartI(ID_INSERT_SYS);
  435.                    else if (opt==OPT_DLG) {
  436.                       // check if any dialog field available
  437.                       for (i=0;i<MAX_DLGS;i++) if (DlgField[i].InUse) break;
  438.                       if (i<MAX_DLGS)      InsertFieldPartI(ID_INSERT_DLG);
  439.                       else                 CreateDlgField();   // create a dialog field in the dialog table
  440.                    }
  441.                    else if (opt==OPT_LINE) InsertLinePartI();
  442.                    else IgnoreMouseMove=TRUE;
  443.  
  444.                    break;
  445.             }
  446.             break;
  447.  
  448.         case WM_LBUTTONDBLCLK:
  449.             if (CurCmd==-1 && SelItem>=0) {  // modify items
  450.                 if      (item[SelItem].type==LABEL)   EditItemOutline();
  451.                 else if (item[SelItem].type==LINE)    EditLine();
  452.                 else if (item[SelItem].type==FIELD) {
  453.                    if (field[item[SelItem].field].type==TYPE_PICT) EditItemOutline();
  454.                    else                                            ModifyField();
  455.                 }
  456.                 else if (item[SelItem].type==SECTION) EditSection();
  457.             }
  458.             break;
  459.         
  460.         case WM_RBUTTONDBLCLK:
  461.             if (CurCmd==-1 && SelItem>=0) {  // modify items
  462.                 if      (item[SelItem].type==LABEL)   FrFonts();
  463.                 else if (item[SelItem].type==LINE)    EditItemBackground();     
  464.                 else if (item[SelItem].type==FIELD)   {
  465.                    if (field[item[SelItem].field].type==TYPE_PICT) EditItemBackground();
  466.                    else                                            FrFonts();
  467.                 }
  468.                 else if (item[SelItem].type==SECTION) FrRepParameters(); 
  469.             }
  470.             break;
  471.  
  472.         case WM_MBUTTONDBLCLK:               // edit field
  473.             if (CurCmd==-1 && SelItem>=0) EditItemBackground();
  474.             break;
  475.  
  476.         case WM_PAINT:
  477.             RepaintFr();
  478.             break;
  479.  
  480.         case WM_SETFOCUS:
  481.             PaintFlag=PAINT_WIN;                // next time paint the entire client area
  482.             break;
  483.  
  484.         case WM_ENTERIDLE:                      // check if context sensitive help is requested 
  485.             if ((wParam == MSGF_MENU) && (GetKeyState(VK_F1) & 0x8000)) {
  486.                 FrHelpWanted=TRUE;         
  487.                 PostMessage(hWnd,WM_KEYDOWN,VK_RETURN,0L); // generate a dummy <CR> key, cause selection of the menu item 
  488.             }
  489.             break;
  490.  
  491.         case WM_CLOSE:
  492.             CloseFr();
  493.             return (LRESULT)(NULL);
  494.  
  495.         case WM_QUERYENDSESSION:
  496.             return (CloseFr());
  497.  
  498.         case WM_DESTROY:
  499.             FormArg.open=FALSE;                   // mark this window as closed 
  500.             break;
  501.         
  502.         case WM_GETDLGCODE:
  503.             return (long)(DLGC_WANTMESSAGE|DLGC_WANTALLKEYS
  504.                          |DLGC_WANTARROWS|DLGC_WANTCHARS|DLGC_WANTTAB);  /* process all messages when REP used as a control */
  505.  
  506.         default:
  507.             return (DefWindowProc(hWnd, message, wParam, lParam));
  508.     }
  509.  
  510.     FormArg.modified=FrModified;         // pass the file status 
  511.  
  512.     return (LRESULT)(NULL);
  513. }
  514.  
  515. /****************************************************************************
  516.     FrEditSubclass:
  517.     This routine subclass the label input edit control to access the
  518.     carriage return key.
  519. ****************************************************************************/
  520. BOOL CALLBACK _export FrEditSubclass(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
  521. {
  522.  
  523.     if (message==WM_CHAR && wParam==VK_RETURN) {
  524.         UpdateLabelText();  // update the label text
  525.         SetFocus(hFrWnd);   // set the focus to the main window
  526.         return TRUE;
  527.     }
  528.     else return (BOOL) CallWindowProc(OrigEditProc,hWnd,message,wParam,lParam);
  529. }
  530.  
  531. /******************************************************************************
  532.     FrInitMenu:
  533.     Initialze the menu before displaying
  534. ******************************************************************************/
  535. FrInitMenu(HMENU hMenu)
  536. {
  537.     int i,CurSec,CurField;
  538.     BOOL DlgTableFull,DlgTableEmpty;
  539.  
  540.     if (SelItem>=0 && item[SelItem].type==FIELD) CurField=item[SelItem].field;
  541.     else                                         CurField=-1;
  542.  
  543.     //****** File Menu *****
  544.     EnableMenuItem(hMenu,ID_PRINT_OPTIONS,PrinterName[0]!=0 ? MF_ENABLED : MF_GRAYED);
  545.     EnableMenuItem(hMenu,ID_SAVE,FrModified ? MF_ENABLED : MF_GRAYED);
  546.  
  547.     //**** Edit Menu ***
  548.     EnableMenuItem(hMenu,ID_FONTS,SelItem>=0 && (item[SelItem].type==LABEL || (item[SelItem].type==FIELD && field[CurField].type!=TYPE_PICT)|| item[SelItem].type==GROUP) ? MF_ENABLED : MF_GRAYED);
  549.     EnableMenuItem(hMenu,ID_POS_ITEM,SelItem>=0 && (item[SelItem].type==LABEL || (item[SelItem].type==FIELD && field[CurField].type!=TYPE_PICT) || item[SelItem].type==GROUP) ? MF_ENABLED : MF_GRAYED);
  550.     EnableMenuItem(hMenu,ID_ITEM_OUTLINE,SelItem>=0 ? MF_ENABLED : MF_GRAYED);
  551.     EnableMenuItem(hMenu,ID_ITEM_BACKGROUND,SelItem>=0 && item[SelItem].type!=PICT? MF_ENABLED : MF_GRAYED);
  552.     EnableMenuItem(hMenu,ID_CENTER_ITEM,SelItem>=0 && item[SelItem].type!=SECTION ? MF_ENABLED : MF_GRAYED);
  553.     EnableMenuItem(hMenu,ID_DEL_ITEM,SelItem>=0 ? MF_ENABLED : MF_GRAYED);
  554.  
  555.     EnableMenuItem(hMenu,ID_EXPAND_HORZ,SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED : MF_GRAYED);
  556.     EnableMenuItem(hMenu,ID_EXPAND_VERT,SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED : MF_GRAYED);
  557.     EnableMenuItem(hMenu,ID_COMPRESS_HORZ,SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED : MF_GRAYED);
  558.     EnableMenuItem(hMenu,ID_COMPRESS_VERT,SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED : MF_GRAYED);
  559.  
  560.     //**** Field Menu ***
  561.     EnableMenuItem(hMenu,ID_EDIT_FLD    ,CurField>=0  && field[CurField].type!=TYPE_PICT ? MF_ENABLED : MF_GRAYED);
  562.     EnableMenuItem(hMenu,ID_EDIT_FLD_EXP,CurField>=0 && field[CurField].source==SRC_CALC ? MF_ENABLED : MF_GRAYED);
  563.  
  564.     //**** section menu Menu ***
  565.     if (SelItem>=0 && item[SelItem].type==SECTION) CurSec=item[SelItem].section;
  566.     else                                           CurSec=-1;        
  567.  
  568.     EnableMenuItem(hMenu,ID_SEC_EDIT,CurSec>=0 ? MF_ENABLED : MF_GRAYED);
  569.     EnableMenuItem(hMenu,ID_SEC_SORT,CurSec>=SEC_HDR_LVL1 && CurSec<=SEC_HDR_LVL9 ? MF_ENABLED : MF_GRAYED);
  570.     EnableMenuItem(hMenu,ID_SEC_BREAK,CurSec>=SEC_HDR_LVL1 && CurSec<=SEC_HDR_LVL9 ? MF_ENABLED : MF_GRAYED);
  571.     EnableMenuItem(hMenu,ID_SEC_FILTER,CurSec>=0 ? MF_ENABLED : MF_GRAYED);
  572.  
  573.     //**** Line Menu ***
  574.     EnableMenuItem(hMenu,ID_EDIT_LINE,SelItem>=0 && item[SelItem].type==LINE ? MF_ENABLED : MF_GRAYED);
  575.     
  576.     //**** Label Menu ***
  577.     EnableMenuItem(hMenu,ID_EDIT_LABEL,SelItem>=0 && item[SelItem].type==LABEL ? MF_ENABLED : MF_GRAYED);
  578.  
  579.     //**** Picture Menu ***
  580.     EnableMenuItem(hMenu,ID_PICT_FROM_CB, IsClipboardFormatAvailable(CF_BITMAP) ? MF_ENABLED : MF_GRAYED);
  581.  
  582.     //******* dialog field table options ******
  583.     DlgTableFull=TRUE;
  584.     DlgTableEmpty=TRUE;
  585.     for (i=0;i<MAX_DLGS;i++) {
  586.        if (DlgField[i].InUse) DlgTableEmpty=FALSE;
  587.        if (!DlgField[i].InUse) DlgTableFull=FALSE;
  588.     }
  589.     EnableMenuItem(hMenu,ID_INSERT_DLG , !DlgTableEmpty ? MF_ENABLED : MF_GRAYED);
  590.     EnableMenuItem(hMenu,ID_DLG_CREATE , !DlgTableFull ? MF_ENABLED : MF_GRAYED);
  591.     EnableMenuItem(hMenu,ID_DLG_MODIFY , !DlgTableEmpty ? MF_ENABLED : MF_GRAYED);
  592.     EnableMenuItem(hMenu,ID_DLG_DELETE , !DlgTableEmpty ? MF_ENABLED : MF_GRAYED);
  593.  
  594.     //**** Arrange Menu ***
  595.     EnableMenuItem(GetSubMenu(hMenu,MENU_ARRANGE),0, SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED|MF_BYPOSITION : MF_GRAYED|MF_BYPOSITION); // align
  596.     EnableMenuItem(GetSubMenu(hMenu,MENU_ARRANGE),1, SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED|MF_BYPOSITION : MF_GRAYED|MF_BYPOSITION); // even space
  597.     EnableMenuItem(GetSubMenu(hMenu,MENU_ARRANGE),2, SelItem>=0 && item[SelItem].type==GROUP? MF_ENABLED|MF_BYPOSITION : MF_GRAYED|MF_BYPOSITION); // even size
  598.     EnableMenuItem(hMenu,ID_UNDO, UndoItem ? MF_ENABLED : MF_GRAYED);
  599.  
  600.     return TRUE;
  601. }
  602.  
  603. /******************************************************************************
  604.    FrTranslateAccelerator:
  605.    Translates the accelerator keys for the form editor window
  606. ******************************************************************************/
  607. BOOL FrTranslateAccelerator(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
  608. {
  609.     MSG msg;
  610.  
  611.     if ( message==WM_NCHITTEST || message==WM_MOUSEMOVE 
  612.       || message==WM_SETCURSOR) return FALSE;
  613.  
  614.     if (!hFrAccTable) return FALSE;   // translation table not defined yet 
  615.  
  616.     msg.hwnd=hWnd;                    // fill the message structure 
  617.     msg.message=message;
  618.     msg.wParam=wParam;
  619.     msg.lParam=lParam;
  620.     msg.time=0;
  621.     msg.pt.x=msg.pt.y=0;
  622.  
  623.     if (TranslateAccelerator(hWnd,hFrAccTable,&msg)) {  // accelerator tranlated 
  624.        // remove any messages generated by the TranslateMessage function in WinMain 
  625.        while (PeekMessage(&msg,hWnd,WM_CHAR,WM_CHAR,PM_REMOVE|PM_NOYIELD)); 
  626.        while (PeekMessage(&msg,hWnd,WM_INITMENU,WM_INITMENUPOPUP,PM_REMOVE|PM_NOYIELD)); 
  627.        while (PeekMessage(&msg,hWnd,WM_MENUSELECT,WM_MENUCHAR,PM_REMOVE|PM_NOYIELD)); 
  628.        while (PeekMessage(&msg,hWnd,WM_SYSKEYDOWN,WM_SYSKEYDOWN,PM_REMOVE|PM_NOYIELD)); 
  629.        while (PeekMessage(&msg,hWnd,WM_SYSKEYUP,WM_SYSKEYUP,PM_REMOVE|PM_NOYIELD)); 
  630.        while (PeekMessage(&msg,hWnd,WM_SYSCOMMAND,WM_SYSCOMMAND,PM_REMOVE|PM_NOYIELD)); 
  631.        while (PeekMessage(&msg,hWnd,WM_SYSCHAR,WM_SYSCHAR,PM_REMOVE|PM_NOYIELD)); 
  632.        return TRUE;
  633.     }
  634.     else return FALSE;
  635. }
  636.  
  637. /******************************************************************************
  638.     SetScrollBars:
  639.     Set horizontal and vertical scroll bar positions 
  640. *******************************************************************************/
  641. SetScrollBars()
  642. {
  643.     int ScrollPos;
  644.     
  645.     if (!UseScreen || SessionType=='R') return TRUE;  // window not being used 
  646.  
  647.     if (FrShowVerBar) {   // check for any change in vertical bar status 
  648.        if (FrHeight==0) 
  649.             ScrollPos=0;
  650.        else ScrollPos=VER_SCROLL_MIN+(int)((long)FrWinOrgY*(VER_SCROLL_MAX-VER_SCROLL_MIN)/FrHeight);
  651.        if (ScrollPos!=VerScrollPos) { // redraw 
  652.           VerScrollPos=ScrollPos;
  653.           SetScrollPos(hFrWnd,SB_VERT,VerScrollPos,TRUE);
  654.        }
  655.     }
  656.     if (FrShowHorBar) {   // check for any change in horizontal bar status 
  657.        if (FrWidth==0)
  658.             ScrollPos=0;
  659.        else ScrollPos=HOR_SCROLL_MIN+(int)((long)FrWinOrgX*(HOR_SCROLL_MAX-HOR_SCROLL_MIN)/FrWidth);
  660.        if (ScrollPos!=HorScrollPos) { // redraw 
  661.           HorScrollPos=ScrollPos;
  662.           SetScrollPos(hFrWnd,SB_HORZ,HorScrollPos,TRUE);
  663.        }
  664.     }
  665.     return TRUE;
  666. }
  667.  
  668. /******************************************************************************
  669.     RepaintFr:
  670.     This routine is called when a paint message is received.
  671.     This routine repaint the entire client area.
  672. *******************************************************************************/
  673. RepaintFr()
  674. {
  675.     PAINTSTRUCT PaintData;
  676.  
  677.     BeginPaint(hFrWnd,&PaintData); 
  678.     EndPaint(hFrWnd,&PaintData); 
  679.  
  680.     if (WindowBeingCreated) return TRUE;
  681.  
  682.     GetWinDimension();     // get window dimensions 
  683.  
  684.     PaintFlag=PAINT_WIN;   // paint the entire window
  685.     FrPaint();
  686.     
  687.     return TRUE;
  688. }
  689.  
  690. /******************************************************************************
  691.     GetWinDimension:
  692.     The the following dimensions of the various screen areas.
  693. *******************************************************************************/
  694. void GetWinDimension()
  695. {
  696.     int width,height;
  697.     RECT rect;
  698.  
  699.     //****************** get window dimensions in logical units *********
  700.     GetClientRect(hFrWnd,(LPRECT) &rect);
  701.     width = PixToUnitX(rect.right);
  702.     height = PixToUnitY(rect.bottom);
  703.  
  704.     // *********** calculate input area coordinates *********************
  705.     InputRect.left=0;
  706.     InputRect.top=0; 
  707.     InputRect.right=width;
  708.     InputRect.bottom=InputRect.top+FrFont[DEFAULT_CFMT].height*2;
  709.  
  710.     // *********** calculate ruler area coordinates *********************
  711.     RulerRect.left=0;
  712.     RulerRect.top=InputRect.bottom; 
  713.     RulerRect.right=width;
  714.     if (FormHdr.RulerType==RULER_OFF) 
  715.          RulerRect.bottom=RulerRect.top;
  716.     else RulerRect.bottom=RulerRect.top+FrFont[DEFAULT_CFMT].height + RULER_MARK1_LEN;
  717.  
  718.     // *********** calculate form area coordinates *********************
  719.     FrWinRect.left=0;
  720.     FrWinRect.top=RulerRect.bottom; 
  721.     FrWinRect.right=width;
  722.     FrWinRect.bottom=height;
  723.     if (FrWinRect.bottom<FrWinRect.top) FrWinRect.bottom=FrWinRect.top;
  724.  
  725.     FrWinWidth=FrWinRect.right-FrWinRect.left+1;    // form window width 
  726.     FrWinHeight=FrWinRect.bottom-FrWinRect.top+1;   // form window height 
  727.  
  728.     // ********* calculate form area rectangle in pixel units 
  729.     FrRect.left=UnitToPixX(FrWinRect.left);
  730.     FrRect.right=rect.right;
  731.     FrRect.top=UnitToPixY(FrWinRect.top);
  732.     FrRect.bottom=rect.bottom;
  733.  
  734.     // ******* Create the memory device
  735.     if (hBM) { // delete current bitmap
  736.        SelectObject(hMemDC,hOldBM);
  737.        DeleteObject(hBM);
  738.     }
  739.     if (NULL==(hBM=CreateCompatibleBitmap(hFrDC,rect.right,rect.bottom)) ) {
  740.        AbortFr("Unable to create compatible DC",ERR_DISPLAY);
  741.     }
  742.     hOldBM=SelectObject(hMemDC,hBM);
  743.  
  744.     // set view port origin
  745.     SetViewportOrgEx(hFrDC,FrRect.left,FrRect.top,NULL);  // set view port origins 
  746.     SetViewportOrgEx(hMemDC,FrRect.left,FrRect.top,NULL); // set view port origins 
  747.  
  748. }
  749.  
  750. /******************************************************************************
  751.     FrSetViewWindow:
  752.     Set the portion of the form that will be visible in the view port.
  753. *******************************************************************************/
  754. void FrSetViewWindow()
  755. {
  756.     if (FrWinOrgX<0) FrWinOrgX=0;
  757.     if (FrWinOrgY<0) FrWinOrgY=0;
  758.  
  759.     if (SessionType=='F') {                     // check limit during editing
  760.        if (FrWinOrgX>FrWidth) FrWinOrgX=FrWidth;
  761.        if (FrWinOrgY>FrHeight) FrWinOrgY=FrHeight;
  762.     }
  763.     SetWindowOrgEx(hFrDC,FrWinOrgX,FrWinOrgY,NULL);    // set the logical window origin 
  764.     SetWindowOrgEx(hMemDC,FrWinOrgX,FrWinOrgY,NULL);   // set the logical window origin 
  765.  
  766. }
  767.  
  768. /******************************************************************************
  769.     FrPaint:
  770.     Main FORM window paint routine
  771. *******************************************************************************/
  772. void FrPaint()
  773. {
  774.     RECT rect,iRect;
  775.     HRGN rgn;
  776.     int i;
  777.     BOOL SaveFocusRectDrawn;
  778.  
  779.     if (!PaintEnabled) return;           // painting disabled 
  780.  
  781.     SaveFocusRectDrawn=FocusRectDrawn;   // save the status of the focus rectangle
  782.     FocusRectDrawn=FALSE;                // focus rectangle will be erased
  783.  
  784.     // promote the scope of painting when a section selected
  785.     if (SelItem>=0 && item[SelItem].type==SECTION && PaintFlag!=PAINT_WIN) PaintFlag=PAINT_PARTIAL_WIN;
  786.  
  787.     FrSetViewWindow();                   // set the window origin
  788.     
  789.     // clear the ruler and drawing area
  790.     SelectClipRgn(hMemDC,NULL);           // entire client are enabled for drawing
  791.  
  792.     rect.left=FrWinOrgX;                  // build the drawing area rectangle
  793.     rect.right=rect.left+FrWinWidth;
  794.     rect.top=FrWinOrgY;
  795.     rect.bottom=FrWinOrgY+FrWinHeight;
  796.  
  797.     if (PaintFlag==PAINT_WIN) {           // redraw the whole screen
  798.  
  799.         // clear the input area
  800.         iRect.left=FrWinOrgX;             // build the input area rectangle
  801.         iRect.right=iRect.left+FrWinWidth;
  802.         iRect.top=FrWinOrgY-FrWinRect.top;
  803.         iRect.bottom=iRect.top+(InputRect.bottom-InputRect.top);
  804.         FillRect(hMemDC,&iRect,hInputAreaBrush);
  805.  
  806.         // Clear the ruler and drawing area
  807.         rect.top-=(RulerRect.bottom-RulerRect.top);
  808.         FillRect(hMemDC,&rect,hBackBrush);
  809.  
  810.         rect.top=iRect.top;                // include the input area
  811.         DrawOptRects(hMemDC);              // draw option rectangles
  812.         DrawDividers(hMemDC);              // draw the divider lines
  813.         DrawTopRuler(hMemDC);              // draw the top ruler
  814.     }
  815.     else if (PaintFlag==PAINT_PARTIAL_WIN){// paint the ruler and the drawing area
  816.         rect.top-=(RulerRect.bottom-RulerRect.top);
  817.         FillRect(hMemDC,&rect,hBackBrush);
  818.         DrawDividers(hMemDC);              // draw the divider lines
  819.         DrawTopRuler(hMemDC);              // draw the ruler
  820.     }
  821.     else FillRect(hMemDC,&rect,hBackBrush);// paint just the drawing area
  822.  
  823.     // Set clipping region to include only the drawing area (default mode)
  824.     rgn=CreateRectRgn(FrRect.left,FrRect.top,FrRect.right,FrRect.bottom);
  825.     SelectClipRgn(hMemDC,rgn);
  826.  
  827.     // Draw screen items
  828.     for (i=0;i<TotalItems;i++) DrawItem(hMemDC,i);
  829.     
  830.     // Copy the memory bitmap to the device
  831.     SelectClipRgn(hFrDC,NULL);
  832.     BitBlt(hFrDC,rect.left,rect.top,rect.right-rect.left,rect.bottom-rect.top,hMemDC,rect.left,rect.top,SRCCOPY);
  833.     
  834.     SelectClipRgn(hFrDC,rgn);
  835.  
  836.     // highlight the selected item
  837.     if (SelItem>=0) SelectItem(SelItem);
  838.     if (SaveFocusRectDrawn || SelItem>=0) FrDrawFocusRect(hFrDC,&CursRect); // redraw the focus rectangle
  839.  
  840.     // reset flags  
  841.     PaintFlag=PAINT_PARTIAL_WIN;         // reset the paint flag
  842.     DeleteObject(rgn);                   // delete the temporary region
  843.     if (FrShowHorBar || FrShowVerBar) SetScrollBars();
  844.  
  845.     ValidateRect(hFrWnd,NULL);           // remove any pending paint messages
  846.  
  847. }
  848.  
  849. /******************************************************************************
  850.     DrawItem:
  851.     Draw the specified item
  852. *******************************************************************************/
  853. void DrawItem(HDC hDC,int CurItem)
  854. {
  855.     RECT rect;
  856.     HPEN hPen;
  857.     HBRUSH hBrush;
  858.  
  859.     //  Do not draw items that are outside the current window
  860.     if (item[CurItem].x>FrWinOrgX+FrWinWidth) return;
  861.     if (item[CurItem].x+item[CurItem].width<FrWinOrgX) return;
  862.     if (item[CurItem].y>FrWinOrgY+FrWinHeight) return;
  863.     if (item[CurItem].y+item[CurItem].height<FrWinOrgY) return;
  864.  
  865.     // build the rectangle
  866.     rect.left=item[CurItem].x;
  867.     rect.right=item[CurItem].x+item[CurItem].width;
  868.     rect.top=item[CurItem].y;
  869.     rect.bottom=item[CurItem].y+item[CurItem].height;
  870.  
  871.     // fill rectangle if needed
  872.     if (item[CurItem].flags&OFLAG_FILL && item[CurItem].type!=GROUP) { // fill rectangle
  873.        if (NULL!=(hBrush=CreateBrushIndirect(&(item[CurItem].brush)))) {
  874.           FillRect(hDC,&rect,hBrush);
  875.           DeleteObject(hBrush);           // delete the temporary brush
  876.        }
  877.     }
  878.  
  879.     // draw the bounding rectangle
  880.     if (item[CurItem].type==GROUP) {     // draw the multiple selection rectangle
  881.        if (CurItem==SelItem) {           // Group item selected
  882.           SelectObject(hDC,hSelectionPen);
  883.           FrDrawRect(hDC,&rect);
  884.        }
  885.     }
  886.     else if (item[CurItem].OutlineSelect) {// draw rectangle
  887.        if (NULL!=(hPen=CreatePen(item[CurItem].OutlineStyle,item[CurItem].OutlineWidth,item[CurItem].OutlineColor))) {
  888.           SelectObject(hDC,hPen);
  889.           FrDrawOutline(hDC,&rect,item[CurItem].OutlineSelect);
  890.           SelectObject(hDC,hFrPen);
  891.           DeleteObject(hPen);             // delete the temporary pen
  892.        }
  893.     }
  894.  
  895.     // draw the item interior
  896.     if (item[CurItem].type==SECTION)      DrawSection(hDC,CurItem);
  897.     else if (item[CurItem].type==LABEL)   DrawLabel(hDC,CurItem);
  898.     else if (item[CurItem].type==FIELD)   DrawField(hDC,CurItem);
  899.     else if (item[CurItem].type==LINE)    DrawLine(hDC,CurItem);
  900.     else if (item[CurItem].type==PICT)    DrawPicture(hDC,CurItem);
  901.  
  902.     // draw focus pen if this item is part of multiple selection item
  903.     if (InGroup(CurItem)) {
  904.        SelectObject(hDC,hFocusPen);
  905.        FrDrawRect(hDC,&rect);
  906.     }
  907.  
  908. }
  909.  
  910. /******************************************************************************
  911.     DrawLabel:
  912.     Draw a label
  913. *******************************************************************************/
  914. void DrawLabel(HDC hDC, int CurItem)
  915. {
  916.     RECT rect;
  917.     int  LabelWidth,LabelHeight,LabelLen,x,y,flags,font;
  918.  
  919.     // build the bounding rectangle
  920.     rect.left=item[CurItem].x;
  921.     rect.right=item[CurItem].x+item[CurItem].width;
  922.     rect.top=item[CurItem].y;
  923.     rect.bottom=item[CurItem].y+item[CurItem].height;
  924.  
  925.     // Get label dimension
  926.     font=item[CurItem].font;
  927.     LabelWidth=GetLabelLen(item[CurItem].label,font);
  928.     LabelHeight=FrFont[font].height;
  929.     LabelLen=lstrlen(item[CurItem].label);
  930.  
  931.     // Get the label position
  932.     flags=item[CurItem].flags;
  933.     if      (flags&OFLAG_HLEFT)  x=rect.left+DESC_MARGIN;
  934.     else if (flags&OFLAG_HRIGHT) x=rect.left+(item[CurItem].width-LabelWidth)-DESC_MARGIN;
  935.     else                         x=rect.left+(item[CurItem].width-LabelWidth)/2; // center
  936.     if      (flags&OFLAG_VTOP)   y=rect.top;
  937.     else if (flags&OFLAG_VBOTTOM)y=rect.top+(item[CurItem].height-LabelHeight);
  938.     else                         y=rect.top+(item[CurItem].height-LabelHeight)/2; // center
  939.     
  940.     // Draw the label
  941.     SetFont(hDC,(BYTE)font);
  942.     SetTextColor(hDC,item[CurItem].TextColor);
  943.     SetBkMode(hDC,TRANSPARENT);
  944.     if (LabelLen>0) ExtTextOut(hDC,x,y,ETO_CLIPPED,&rect,item[CurItem].label,LabelLen,NULL);
  945.  
  946. }
  947.  
  948. /******************************************************************************
  949.     DrawField:
  950.     Draw a field item
  951. *******************************************************************************/
  952. void DrawField(HDC hDC, int CurItem)
  953. {
  954.     RECT rect;
  955.     int  LabelWidth,LabelHeight,LabelLen,x,y,flags,font;
  956.     struct StrField huge *pField;
  957.     BOOL wrap=FALSE;
  958.  
  959.     pField=&(field[item[CurItem].field]);   // pointer to current field
  960.     
  961.     if (pField->type==TYPE_PICT) return;    // picture field is left empty
  962.     if (pField->type==TYPE_TEXT && (pField->flags)&(FLAG_WRAP|FLAG_WORD_WRAP)) wrap=TRUE;
  963.  
  964.     // build the bounding rectangle
  965.     rect.left=item[CurItem].x;
  966.     rect.right=item[CurItem].x+item[CurItem].width;
  967.     rect.top=item[CurItem].y;
  968.     rect.bottom=item[CurItem].y+item[CurItem].height;
  969.  
  970.     // Get label dimension
  971.     font=item[CurItem].font;
  972.     LabelWidth=GetLabelLen(item[CurItem].label,font);
  973.     LabelHeight=FrFont[font].height;
  974.     LabelLen=lstrlen(item[CurItem].label);
  975.     if (LabelLen==0) return;
  976.  
  977.     // Get the label X position
  978.     flags=item[CurItem].flags;
  979.     if      (flags&OFLAG_HLEFT)  x=rect.left+DESC_MARGIN;
  980.     else if (flags&OFLAG_HRIGHT) x=rect.left+(item[CurItem].width-LabelWidth)-DESC_MARGIN;
  981.     else                         x=rect.left+(item[CurItem].width-LabelWidth)/2; // center
  982.     
  983.     if (wrap) y=rect.top+(DEF_RECT_HEIGHT-CharHeight)/2-1;
  984.     else {
  985.       if      (flags&OFLAG_VTOP)   y=rect.top;
  986.       else if (flags&OFLAG_VBOTTOM)y=rect.top+(item[CurItem].height-LabelHeight);
  987.       else                         y=rect.top+(item[CurItem].height-LabelHeight)/2; // center
  988.     }
  989.     
  990.     // Draw the label
  991.     SetFont(hDC,(BYTE)font);
  992.     SetTextColor(hDC,item[CurItem].TextColor);
  993.     SetBkMode(hDC,TRANSPARENT);
  994.     if (wrap) {                    // print multiple lines
  995.        while (y+LabelHeight<rect.bottom) {
  996.           ExtTextOut(hDC,x,y,ETO_CLIPPED,&rect,item[CurItem].label,LabelLen,NULL);
  997.           y+=LabelHeight;          // position for the next line
  998.        }
  999.     }
  1000.     else ExtTextOut(hDC,x,y,ETO_CLIPPED,&rect,item[CurItem].label,LabelLen,NULL);
  1001.  
  1002. }
  1003.  
  1004. /******************************************************************************
  1005.     DrawLine:
  1006.     Draw a 'line' type item
  1007. *******************************************************************************/
  1008. void DrawLine(HDC hDC, int CurItem)
  1009. {
  1010.     int x1,y1,x2,y2;
  1011.     HPEN hPen;
  1012.  
  1013.     // build the line beginning and ending coordinates
  1014.     if (item[CurItem].LineAngle==ANGLE_HORZ) {        // horizontal line
  1015.        x1=item[CurItem].x;
  1016.        y1=item[CurItem].y+item[CurItem].height/2;
  1017.        x2=x1+item[CurItem].width;
  1018.        y2=y1;
  1019.     }
  1020.     else if (item[CurItem].LineAngle==ANGLE_VERT) {   // vertical line
  1021.        x1=item[CurItem].x+item[CurItem].width/2;
  1022.        y1=item[CurItem].y;
  1023.        x2=x1;
  1024.        y2=y1+item[CurItem].height;
  1025.     }
  1026.     else if (item[CurItem].LineAngle==ANGLE_FDIAG) {  // diagonal line
  1027.        x1=item[CurItem].x;
  1028.        y1=item[CurItem].y;
  1029.        x2=x1+item[CurItem].width;
  1030.        y2=y1+item[CurItem].height;
  1031.     }
  1032.     else {                                            // backword diagonal line
  1033.        x1=item[CurItem].x;
  1034.        y1=item[CurItem].y+item[CurItem].height;
  1035.        x2=x1+item[CurItem].width;
  1036.        y2=item[CurItem].y;
  1037.     }
  1038.  
  1039.     // create the line pen
  1040.     if (NULL!=(hPen=CreatePen(item[CurItem].LineStyle,item[CurItem].LineWidth,item[CurItem].LineColor))) {
  1041.        SelectObject(hDC,hPen);
  1042.  
  1043.        // draw the line
  1044.        MoveToEx(hDC,x1,y1,NULL);
  1045.        LineTo(hDC,x2,y2);
  1046.  
  1047.        SelectObject(hDC,hFrPen);
  1048.        DeleteObject(hPen);             // delete the temporary pen
  1049.     }
  1050.  
  1051. }
  1052.  
  1053. /******************************************************************************
  1054.     DrawPicture:
  1055.     Draw a picture bitmap
  1056. *******************************************************************************/
  1057. void DrawPicture(HDC hDC, int CurItem)
  1058. {
  1059.    HBITMAP hOldBM,hCurBM;
  1060.    int width,height,pict;
  1061.  
  1062.    pict=item[CurItem].font;             // index into the font structure
  1063.    width=FrFont[pict].CharWidth['_'];   // width and height of the picture 
  1064.    height=FrFont[pict].height;
  1065.  
  1066.    hCurBM=FrFont[pict].hBM;
  1067.    if (NULL!=(hOldBM=SelectObject(hPictDC,hCurBM))) {
  1068.       StretchBlt(hDC,item[CurItem].x,item[CurItem].y,item[CurItem].width,item[CurItem].height,hPictDC,0,0,width,height,SRCCOPY);
  1069.       SelectObject(hPictDC,hOldBM);         // deselect the bitmap 
  1070.    }
  1071. }
  1072.  
  1073. /******************************************************************************
  1074.     DrawSection:
  1075.     Draw the specified section boundaries
  1076. *******************************************************************************/
  1077. void DrawSection(HDC hDC,int CurItem)
  1078. {
  1079.     int CurSec,NameLen,NameX,CharCount;
  1080.     RECT rect;
  1081.  
  1082.  
  1083.     // Draw the bounding rectangle for visual aid if section does not have outlines
  1084.     if (!item[CurItem].OutlineSelect) {
  1085.         SelectObject(hDC,hFrPen);              // select default pen 
  1086.         MoveToEx(hDC,item[CurItem].x,item[CurItem].y,NULL);
  1087.         LineTo(hDC,item[CurItem].x+item[CurItem].width,item[CurItem].y);
  1088.         LineTo(hDC,item[CurItem].x+item[CurItem].width,item[CurItem].y+item[CurItem].height);
  1089.         LineTo(hDC,item[CurItem].x,item[CurItem].y+item[CurItem].height);
  1090.         LineTo(hDC,item[CurItem].x,item[CurItem].y);
  1091.     }
  1092.  
  1093.     // build the section banner rectangle
  1094.     CurSec=item[CurItem].section;
  1095.  
  1096.     rect.left=item[CurItem].x;
  1097.     rect.right=item[CurItem].x+item[CurItem].width;
  1098.     rect.top=item[CurItem].y;
  1099.     rect.bottom=item[CurItem].y+FormHdr.SecBannerHeight;
  1100.  
  1101.     if (rect.left<FrWinOrgX) rect.left=FrWinOrgX;
  1102.     if (rect.right>FrWinOrgX+FrWinWidth) rect.right=FrWinOrgX+FrWinWidth;
  1103.     if (rect.right<=rect.left) return;
  1104.     
  1105.     // center the section description
  1106.     NameLen=GetLabelLen(SectionName[CurSec],DEFAULT_CFMT);
  1107.     CharCount=lstrlen(SectionName[CurSec]);
  1108.     NameX=rect.left+(rect.right-rect.left-NameLen)/2;
  1109.     if (NameX<rect.left) CharCount=0;
  1110.     
  1111.     // Select font and print the label
  1112.     SetFont(hDC,DEFAULT_CFMT);
  1113.     SetTextColor(hDC,BackColor);
  1114.     SetBkColor(hDC,DrawColor);
  1115.     ExtTextOut(hDC,NameX,rect.top+(FormHdr.SecBannerHeight-CharHeight)/2,ETO_CLIPPED|ETO_OPAQUE,&rect,SectionName[CurSec],CharCount,NULL);
  1116.     SetTextColor(hDC,DrawColor);           // reset to regular colors
  1117.     SetBkColor(hDC,BackColor);
  1118.  
  1119.     // Draw the left and right rulers
  1120.     if (item[CurItem].x>FrWinOrgX) DrawSideRuler(hDC,TRUE,CurItem);
  1121.     if (item[CurItem].x+item[CurItem].width<FrWinOrgX+FrWinWidth) DrawSideRuler(hDC,FALSE,CurItem);
  1122. }
  1123.  
  1124. /******************************************************************************
  1125.     DrawDividers:
  1126.     Draw the dividers lines for the input and ruler areas
  1127. *******************************************************************************/
  1128. void DrawDividers(HDC hDC)
  1129. {
  1130.     int y;
  1131.  
  1132.     // ******************* select pen **************
  1133.     SelectObject(hDC,hFrPen);       // general purpose pen 
  1134.  
  1135.     // ***************** draw the line above the ruler ***********
  1136.     y=FrWinOrgY-(RulerRect.bottom-RulerRect.top);
  1137.     MoveToEx(hDC,FrWinOrgX,y,NULL);
  1138.     LineTo(hDC,FrWinOrgX+FrWinWidth,y);
  1139.  
  1140.     // ***************** draw the line below the ruler ***********
  1141.     y=FrWinOrgY;
  1142.     MoveToEx(hDC,FrWinOrgX,y,NULL);
  1143.     LineTo(hDC,FrWinOrgX+FrWinWidth,y);
  1144.  
  1145. }
  1146.  
  1147. /******************************************************************************
  1148.     DrawOptRects:
  1149.     Draw the option rectangles
  1150. *******************************************************************************/
  1151. void DrawOptRects(HDC hDC)
  1152. {
  1153.     int i,TotalWidth,LabelWidth,DataWidth,CalcWidth,SysWidth,DlgWidth,LineWidth,
  1154.         FieldWidth,x,TopY,BotY;
  1155.     HBRUSH hBrush;
  1156.  
  1157.  
  1158.     // Get the widths of the option rectangles
  1159.     LabelWidth=GetLabelLen(OPT_LBL_LABEL,DEFAULT_CFMT)+2*DESC_MARGIN;
  1160.     DataWidth=GetLabelLen(OPT_LBL_DATA,DEFAULT_CFMT)+2*DESC_MARGIN;
  1161.     CalcWidth=GetLabelLen(OPT_LBL_CALC,DEFAULT_CFMT)+2*DESC_MARGIN;
  1162.     SysWidth=GetLabelLen(OPT_LBL_SYS,DEFAULT_CFMT)+2*DESC_MARGIN;
  1163.     DlgWidth=GetLabelLen(OPT_LBL_DLG,DEFAULT_CFMT)+2*DESC_MARGIN;
  1164.     LineWidth=GetLabelLen(OPT_LBL_LINE,DEFAULT_CFMT)+2*DESC_MARGIN;
  1165.  
  1166.     FieldWidth=DataWidth+CalcWidth+SysWidth+DlgWidth;
  1167.     TotalWidth=LabelWidth+FieldWidth+LineWidth+CharHeight;
  1168.  
  1169.     // check if we have space for the option rectangle and the input control
  1170.     if (TotalWidth+DESC_WIDTH+CharHeight>FrWinWidth) {
  1171.        DrawOptRect=FALSE;
  1172.        return;
  1173.     }
  1174.     else DrawOptRect=TRUE;
  1175.  
  1176.     // calculate the dimension relative to the window top/left
  1177.     x=FrWinWidth-TotalWidth;       // beginning x position
  1178.     TopY=InputRect.top;
  1179.     BotY=InputRect.bottom;
  1180.  
  1181.     // label rectangle
  1182.     OptRect[OPT_LABEL].top=TopY;
  1183.     OptRect[OPT_LABEL].bottom=BotY;
  1184.     OptRect[OPT_LABEL].left=x;
  1185.     OptRect[OPT_LABEL].right=x=x+LabelWidth;
  1186.  
  1187.     // data field rectangle
  1188.     OptRect[OPT_DATA].top=TopY+CharHeight;
  1189.     OptRect[OPT_DATA].bottom=BotY;
  1190.     OptRect[OPT_DATA].left=x;
  1191.     OptRect[OPT_DATA].right=x=x+DataWidth;
  1192.  
  1193.     // calculation field rectangle
  1194.     OptRect[OPT_CALC].top=TopY+CharHeight;
  1195.     OptRect[OPT_CALC].bottom=BotY;
  1196.     OptRect[OPT_CALC].left=x;
  1197.     OptRect[OPT_CALC].right=x=x+CalcWidth;
  1198.  
  1199.     // system field rectangle
  1200.     OptRect[OPT_SYS].top=TopY+CharHeight;
  1201.     OptRect[OPT_SYS].bottom=BotY;
  1202.     OptRect[OPT_SYS].left=x;
  1203.     OptRect[OPT_SYS].right=x=x+SysWidth;
  1204.  
  1205.     // dialog field rectangle
  1206.     OptRect[OPT_DLG].top=TopY+CharHeight;
  1207.     OptRect[OPT_DLG].bottom=BotY;
  1208.     OptRect[OPT_DLG].left=x;
  1209.     OptRect[OPT_DLG].right=x=x+DlgWidth;
  1210.  
  1211.     // Line rectangle
  1212.     OptRect[OPT_LINE].top=TopY;
  1213.     OptRect[OPT_LINE].bottom=BotY;
  1214.     OptRect[OPT_LINE].left=x;
  1215.     OptRect[OPT_LINE].right=x+LineWidth;
  1216.  
  1217.     // Field label rectangle
  1218.     OptRect[OPT_FIELD].top=TopY;
  1219.     OptRect[OPT_FIELD].bottom=OptRect[OPT_DATA].top;
  1220.     OptRect[OPT_FIELD].left=OptRect[OPT_DATA].left;
  1221.     OptRect[OPT_FIELD].right=OptRect[OPT_DLG].right;
  1222.  
  1223.     // translate the rectangle dimensions to current window origin and draw
  1224.     hBrush=CreateSolidBrush(OptRectColor);
  1225.     SelectObject(hDC,hFrPen);
  1226.     for (i=0;i<MAX_OPTS;i++) {
  1227.        OptRect[i].top=FrWinOrgY+OptRect[i].top-FrWinRect.top;
  1228.        OptRect[i].bottom=FrWinOrgY+OptRect[i].bottom-FrWinRect.top;
  1229.        OptRect[i].left=FrWinOrgX+OptRect[i].left;
  1230.        OptRect[i].right=FrWinOrgX+OptRect[i].right;
  1231.        
  1232.        FillRect(hDC,&OptRect[i],hBrush);
  1233.        FrDrawRect(hDC,&OptRect[i]);
  1234.     }
  1235.     DeleteObject(hBrush);
  1236.  
  1237.     // write the option labels
  1238.     SetFont(hDC,(BYTE)DEFAULT_CFMT);
  1239.     SetTextColor(hDC,BackColor);
  1240.     SetBkMode(hDC,TRANSPARENT);
  1241.     
  1242.     // write the label text
  1243.     ExtTextOut(hDC,OptRect[OPT_LABEL].left+DESC_MARGIN,OptRect[OPT_LABEL].top+CharHeight,ETO_CLIPPED,&OptRect[OPT_LABEL],OPT_LBL_LABEL,lstrlen(OPT_LBL_LABEL),NULL);
  1244.     ExtTextOut(hDC,OptRect[OPT_DATA].left+DESC_MARGIN,OptRect[OPT_DATA].top,ETO_CLIPPED,&OptRect[OPT_DATA],OPT_LBL_DATA,lstrlen(OPT_LBL_DATA),NULL);
  1245.     ExtTextOut(hDC,OptRect[OPT_CALC].left+DESC_MARGIN,OptRect[OPT_CALC].top,ETO_CLIPPED,&OptRect[OPT_CALC],OPT_LBL_CALC,lstrlen(OPT_LBL_CALC),NULL);
  1246.     ExtTextOut(hDC,OptRect[OPT_SYS].left+DESC_MARGIN,OptRect[OPT_SYS].top,ETO_CLIPPED,&OptRect[OPT_SYS],OPT_LBL_SYS,lstrlen(OPT_LBL_SYS),NULL);
  1247.     ExtTextOut(hDC,OptRect[OPT_DLG].left+DESC_MARGIN,OptRect[OPT_DLG].top,ETO_CLIPPED,&OptRect[OPT_DLG],OPT_LBL_DLG,lstrlen(OPT_LBL_DLG),NULL);
  1248.     ExtTextOut(hDC,OptRect[OPT_LINE].left+DESC_MARGIN,OptRect[OPT_LINE].top+CharHeight,ETO_CLIPPED,&OptRect[OPT_LINE],OPT_LBL_LINE,lstrlen(OPT_LBL_LINE),NULL);
  1249.  
  1250.     // write the field header
  1251.     x=OptRect[OPT_FIELD].left+(FieldWidth-GetLabelLen(OPT_LBL_FIELD,DEFAULT_CFMT))/2;
  1252.     ExtTextOut(hDC,x,OptRect[OPT_FIELD].top,ETO_CLIPPED,&OptRect[OPT_FIELD],OPT_LBL_FIELD,lstrlen(OPT_LBL_FIELD),NULL);
  1253.  
  1254. }
  1255.  
  1256. /******************************************************************************
  1257.     DrawTopRuler:
  1258.     Draw the ruler on the top of the window
  1259. *******************************************************************************/
  1260. void DrawTopRuler(HDC hDC)
  1261. {
  1262.     int   y1,y2,count,len;
  1263.     float x,interval;
  1264.     char string[10];
  1265.  
  1266.     if (FormHdr.RulerType==RULER_OFF) return;
  1267.  
  1268.     // ******************* select pen, font, color etc **************
  1269.     SelectObject(hDC,hFrPen);       // general purpose pen 
  1270.     SetFont(hDC,DEFAULT_CFMT);      // use the default font
  1271.     SetTextColor(hDC,DrawColor);
  1272.     SetBkMode(hDC,TRANSPARENT);
  1273.  
  1274.     // ************ Print the ruler line *************************
  1275.     y1=FrWinOrgY-RULER_MARK1_LEN;
  1276.     MoveToEx(hDC,FrWinOrgX,y1,NULL);
  1277.     LineTo(hDC,FrWinOrgX+FrWinWidth,y1);
  1278.  
  1279.     // ***************** draw ruler marks *************************
  1280.     if (FormHdr.RulerType==RULER_INCH) {     // draw inch ruler
  1281.        // draw the inch marks
  1282.        interval=x=(float)UNITS_PER_INCH;
  1283.        y2=FrWinOrgY;
  1284.        count=1;                              // start with one inch
  1285.        while (x<=FrWidth) {
  1286.           MoveToEx(hDC,(int)x,y1,NULL);
  1287.           LineTo(hDC,(int)x,y2);
  1288.           
  1289.           // print inch label
  1290.           wsprintf(string,"%d",count);
  1291.           len=GetLabelLen(string,DEFAULT_CFMT);  // get the length of the label in logical units
  1292.           TextOut(hDC,(int)(x-len/2),y1-CharHeight,string,lstrlen(string));
  1293.  
  1294.           // increment to next inch
  1295.           x+=interval;
  1296.           count++;
  1297.        }
  1298.        // close the ruler
  1299.        MoveToEx(hDC,FrWidth,y1,NULL);
  1300.        LineTo(hDC,FrWidth,y2);
  1301.  
  1302.        // draw the half marks
  1303.        interval=x=(float)UNITS_PER_INCH/2;
  1304.        y2=y1+RULER_MARK2_LEN;
  1305.        while (x<FrWidth) {
  1306.           MoveToEx(hDC,(int)x,y1,NULL);
  1307.           LineTo(hDC,(int)x,y2);
  1308.           x+=interval;
  1309.        }
  1310.  
  1311.        // draw the 1/8 marks
  1312.        interval=x=(float)UNITS_PER_INCH/8;
  1313.        y2=y1+RULER_MARK3_LEN;
  1314.        while (x<FrWidth) {
  1315.           MoveToEx(hDC,(int)x,y1,NULL);
  1316.           LineTo(hDC,(int)x,y2);
  1317.           x+=interval;
  1318.        }
  1319.     }
  1320.     else {                           // draw centimeter ruler
  1321.        // draw the centimeter marks
  1322.        interval=x=((float)UNITS_PER_INCH*10)/25;
  1323.        y2=FrWinOrgY;
  1324.        count=1;                      // start with one cm
  1325.        while (x<=FrWidth) {
  1326.           MoveToEx(hDC,(int)x,y1,NULL);
  1327.           LineTo(hDC,(int)x,y2);
  1328.           
  1329.           // print inch label
  1330.           wsprintf(string,"%d",count);
  1331.           len=GetLabelLen(string,DEFAULT_CFMT);  // get the length of the label in logical units
  1332.           TextOut(hDC,(int)(x-len/2),y1-CharHeight,string,lstrlen(string));
  1333.  
  1334.           // increment to next cm
  1335.           x+=interval;
  1336.           count++;
  1337.        }
  1338.        // close the ruler
  1339.        MoveToEx(hDC,FrWidth,y1,NULL);
  1340.        LineTo(hDC,FrWidth,y2);
  1341.  
  1342.        // draw the half marks
  1343.        interval=x=((float)UNITS_PER_INCH*10)/50;
  1344.        y2=y1+RULER_MARK2_LEN;
  1345.        while (x<FrWidth) {
  1346.           MoveToEx(hDC,(int)x,y1,NULL);
  1347.           LineTo(hDC,(int)x,y2);
  1348.           x+=interval;
  1349.        }
  1350.  
  1351.        // draw the 1/10 marks
  1352.        interval=x=((float)UNITS_PER_INCH*10)/250;
  1353.        y2=y1+RULER_MARK3_LEN;
  1354.        while (x<FrWidth) {
  1355.           MoveToEx(hDC,(int)x,y1,NULL);
  1356.           LineTo(hDC,(int)x,y2);
  1357.           x+=interval;
  1358.        }
  1359.     }
  1360.     return;
  1361. }
  1362.  
  1363. /******************************************************************************
  1364.     DrawSideRuler:
  1365.     Draw the ruler on the left or right side of the given section
  1366. *******************************************************************************/
  1367. void DrawSideRuler(HDC hDC,BOOL left, int CurSec)
  1368. {
  1369.     int   y1,x1,x2,LastY,count,len;
  1370.     float y,interval;
  1371.     char string[10];
  1372.  
  1373.     if (FormHdr.RulerType==RULER_OFF) return;
  1374.  
  1375.     // ******************* select pen, font, color etc **************
  1376.     SelectObject(hDC,hFrPen);       // general purpose pen 
  1377.     SetFont(hDC,DEFAULT_CFMT);      // use the default font
  1378.     SetTextColor(hDC,DrawColor);
  1379.     SetBkMode(hDC,TRANSPARENT);
  1380.  
  1381.     // ************ Print the ruler line *************************
  1382.     if (left) x1=item[CurSec].x-RULER_MARK1_LEN;
  1383.     else      x1=item[CurSec].x+item[CurSec].width+RULER_MARK1_LEN;
  1384.     y1=item[CurSec].y+CharHeight;
  1385.     LastY=item[CurSec].y+item[CurSec].height;      // last y position
  1386.     MoveToEx(hDC,x1,y1,NULL);
  1387.     LineTo(hDC,x1,LastY);
  1388.  
  1389.     // ***************** draw ruler marks *************************
  1390.     if (FormHdr.RulerType==RULER_INCH) {// draw inch ruler
  1391.        // draw the inch marks
  1392.        interval=(float)UNITS_PER_INCH;
  1393.        if (left) x2=item[CurSec].x;  // ending x position
  1394.        else      x2=item[CurSec].x+item[CurSec].width;
  1395.        y=(float)y1;                  // starting y position
  1396.        count=0;                      // start with one inch
  1397.        while (y<=LastY) {
  1398.           MoveToEx(hDC,x1,(int)y,NULL);
  1399.           LineTo(hDC,x2,(int)y);
  1400.           
  1401.           // print inch label
  1402.           wsprintf(string,"%d",count);
  1403.           len=GetLabelLen(string,DEFAULT_CFMT);  // get the length of the label in logical units
  1404.           if (left) TextOut(hDC,x1-len,(int)(y-CharHeight/2),string,lstrlen(string));
  1405.           else      TextOut(hDC,x1,(int)(y-CharHeight/2),string,lstrlen(string));
  1406.  
  1407.           // increment to next inch
  1408.           y+=interval;
  1409.           count++;
  1410.        }
  1411.        // close the ruler
  1412.        MoveToEx(hDC,x1,LastY,NULL);
  1413.        LineTo(hDC,x2,LastY);
  1414.  
  1415.        // draw the half marks
  1416.        interval=(float)UNITS_PER_INCH/2;
  1417.        y=(float)y1+interval;              // starting y position
  1418.        if (left) x2=x1+RULER_MARK2_LEN;
  1419.        else      x2=x1-RULER_MARK2_LEN;
  1420.        while (y<=LastY) {
  1421.           MoveToEx(hDC,x1,(int)y,NULL);
  1422.           LineTo(hDC,x2,(int)y);
  1423.           y+=interval;
  1424.        }
  1425.  
  1426.        // draw the 1/8 marks
  1427.        interval=(float)UNITS_PER_INCH/8;
  1428.        y=(float)y1+interval;              // starting y position
  1429.        if (left) x2=x1+RULER_MARK3_LEN;
  1430.        else      x2=x1-RULER_MARK3_LEN;
  1431.        while (y<=LastY) {
  1432.           MoveToEx(hDC,x1,(int)y,NULL);
  1433.           LineTo(hDC,x2,(int)y);
  1434.           y+=interval;
  1435.        }
  1436.     }
  1437.     else {                           // draw centimeter ruler
  1438.        // draw the centimeter marks
  1439.        interval=((float)UNITS_PER_INCH*(float)10)/25;
  1440.        if (left) x2=item[CurSec].x;  // ending x position
  1441.        else      x2=item[CurSec].x+item[CurSec].width;
  1442.        y=(float)y1;                  // starting y position
  1443.        count=0;                      // start with one inch
  1444.        while (y<=LastY) {
  1445.           MoveToEx(hDC,x1,(int)y,NULL);
  1446.           LineTo(hDC,x2,(int)y);
  1447.           
  1448.           // print inch label
  1449.           wsprintf(string,"%d",count);
  1450.           len=GetLabelLen(string,DEFAULT_CFMT);  // get the length of the label in logical units
  1451.           if (left) TextOut(hDC,x1-len,(int)(y-CharHeight/2),string,lstrlen(string));
  1452.           else      TextOut(hDC,x1,(int)(y-CharHeight/2),string,lstrlen(string));
  1453.  
  1454.           // increment to next cm
  1455.           y+=interval;
  1456.           count++;
  1457.        }
  1458.        // close the ruler
  1459.        MoveToEx(hDC,x1,LastY,NULL);
  1460.        LineTo(hDC,x2,LastY);
  1461.  
  1462.        // draw the half marks
  1463.        interval=((float)UNITS_PER_INCH*(float)10)/50;
  1464.        y=(float)y1+interval;              // starting y position
  1465.        if (left) x2=x1+RULER_MARK2_LEN;
  1466.        else      x2=x1-RULER_MARK2_LEN;
  1467.        while (y<=LastY) {
  1468.           MoveToEx(hDC,x1,(int)y,NULL);
  1469.           LineTo(hDC,x2,(int)y);
  1470.           y+=interval;
  1471.        }
  1472.  
  1473.        // draw the 1/10 marks
  1474.        interval=((float)UNITS_PER_INCH*(float)10)/250;
  1475.        y=(float)y1+interval;              // starting y position
  1476.        if (left) x2=x1+RULER_MARK3_LEN;
  1477.        else      x2=x1-RULER_MARK3_LEN;
  1478.        while (y<=LastY) {
  1479.           MoveToEx(hDC,x1,(int)y,NULL);
  1480.           LineTo(hDC,x2,(int)y);
  1481.           y+=interval;
  1482.        }
  1483.     }
  1484.     return;
  1485. }
  1486.  
  1487. /******************************************************************************
  1488.    InGroup:
  1489.    This routine return TRUE if the specified item is included in the multiple
  1490.    selection group.
  1491. *******************************************************************************/
  1492. BOOL InGroup(int CurItem)
  1493. {
  1494.     RECT GroupRect,CurRect;
  1495.     BOOL inside=TRUE;
  1496.  
  1497.     if (SelItem<0 || item[SelItem].type!=GROUP) return FALSE;  // group not active
  1498.     if (item[CurItem].type==GROUP) return FALSE;  // exclude group item iteself
  1499.     if (item[CurItem].type==SECTION) return FALSE; // exclude the section type items
  1500.  
  1501.     // build the group rectangle
  1502.     GroupRect.left=item[SelItem].x;
  1503.     GroupRect.right=GroupRect.left+item[SelItem].width;
  1504.     GroupRect.top=item[SelItem].y;
  1505.     GroupRect.bottom=GroupRect.top+item[SelItem].height;
  1506.  
  1507.     // build the current item rectangle
  1508.     CurRect.left=item[CurItem].x;
  1509.     CurRect.right=CurRect.left+item[CurItem].width;
  1510.     CurRect.top=item[CurItem].y;
  1511.     CurRect.bottom=CurRect.top+item[CurItem].height;
  1512.  
  1513.     // check if the item falls withing the group rectangle
  1514.     if (CurRect.right<GroupRect.left) inside=FALSE;
  1515.     if (CurRect.left>GroupRect.right) inside=FALSE;
  1516.     if (CurRect.bottom<GroupRect.top) inside=FALSE;
  1517.     if (CurRect.top>GroupRect.bottom) inside=FALSE;
  1518.  
  1519.     if (item[CurItem].flags&OFLAG_SELECT_TOGGLE) inside=!inside;
  1520.  
  1521.     return inside;
  1522. }
  1523.  
  1524. /******************************************************************************
  1525.    SetFont:
  1526.    Select a suitable font for a character format into the display context
  1527. *******************************************************************************/
  1528. SetFont(HDC hDC,unsigned char font)
  1529. {
  1530.     HFONT hFont;
  1531.  
  1532.     if (FrFont[font].IsPict) return TRUE;  // not a true font 
  1533.  
  1534.     hFont=FrFont[font].hFont;
  1535.  
  1536.     SelectObject(hDC,hFont);
  1537.  
  1538.     return TRUE;
  1539. }
  1540.  
  1541. /******************************************************************************
  1542.     FrMouseDown:
  1543.     Select an object, or position a moving object.
  1544. *******************************************************************************/
  1545. FrMouseDown(WPARAM wParam,LPARAM lParam)
  1546. {
  1547.     int i,x,y,CurItem;
  1548.  
  1549.     // calculate logical mouse position 
  1550.     x=FrWinOrgX+PixToUnitX((int)(LOSHORT(lParam))-FrRect.left); 
  1551.     y=FrWinOrgY+PixToUnitY((int)(HISHORT(lParam))-FrRect.top);
  1552.  
  1553.     // check if mouse outside the drawing area
  1554.     if ( HISHORT(lParam)<FrRect.top || y>FrHeight+TAB_HEIGHT/2) { // went outside the drawing area
  1555.        SetCursor(hArrowCursor);
  1556.        CurCmd=-1;                       // no more command being served
  1557.        IgnoreMouseMove=TRUE;            // ignore mouse move now
  1558.        FrEraseFocusRect(hFrDC,&CursRect);
  1559.        FrPaint();
  1560.        return TRUE;
  1561.     }
  1562.  
  1563.     //  Process the command in progress
  1564.     switch (CurCmd) {
  1565.        case ID_INSERT_LABEL:            // insert a label at the current position
  1566.           InsertLabelPartII();          // finish the label creation process
  1567.           break;
  1568.  
  1569.        case ID_INSERT_LINE:             // insert a line at the current position
  1570.           InsertLinePartII();           // finish the line creation process
  1571.           break;
  1572.  
  1573.        case  ID_PICT_FROM_CB:           // insert the clipboard picture at the current position
  1574.        case  ID_PICT_FROM_FILE:         // insert the bitmap file picture at the current position
  1575.           InsertPicturePartII();        // finish the picture insertion process
  1576.           break;
  1577.  
  1578.        case  ID_INSERT_DATA:            // insert data field
  1579.        case  ID_INSERT_CALC:            // insert calculation field
  1580.        case  ID_INSERT_SYS:             // insert system field
  1581.        case  ID_INSERT_DLG:             // insert dialog field
  1582.           InsertFieldPartII();          // finish the field insertion process
  1583.           break;
  1584.  
  1585.        default:
  1586.           if (SelItem>=0) {                         // if on a selected item
  1587.              // Insert or remove this item form group selection
  1588.              if (item[SelItem].type==GROUP && GetKeyState(VK_SHIFT)&0x8000) {
  1589.                  CurItem=GetMouseItem(x,y);        // Get the item selected by the mouse
  1590.                  if (!(item[CurItem].type&(SECTION|GROUP))) {
  1591.                     if (item[CurItem].flags&OFLAG_SELECT_TOGGLE) 
  1592.                          item[CurItem].flags=ResetUintFlag(item[CurItem].flags,OFLAG_SELECT_TOGGLE);
  1593.                     else item[CurItem].flags|=OFLAG_SELECT_TOGGLE;
  1594.                     PaintFlag=PAINT_ITEMS;            // restricted painting
  1595.                     FrPaint();                        // repaint the screen
  1596.                  }
  1597.                  CurCmd=-1;
  1598.                  break;
  1599.              }
  1600.  
  1601.              // Check if a tab on a selected item is clicked
  1602.              for (i=0;i<TotalTabRects;i++) {
  1603.                 if (TabRect[i].left==TabRect[i].right) continue;  // tab not in use
  1604.                 if (  x>=TabRect[i].left && x<TabRect[i].right
  1605.                    && y>=TabRect[i].top  && y<TabRect[i].bottom) break;
  1606.              }
  1607.              if (i<TotalTabRects) {             // size the item
  1608.                  CurTab=i;
  1609.                  if      (CurTab==TAB_NORTH || CurTab==TAB_SOUTH) SetCursor(hVertCursor); 
  1610.                  else if (CurTab==TAB_WEST  || CurTab==TAB_EAST)  SetCursor(hHorzCursor); 
  1611.                  else if (CurTab==TAB_NE    || CurTab==TAB_SW)    SetCursor(hDiagCursor); 
  1612.                  else if (CurTab==TAB_NW    || CurTab==TAB_SE)    SetCursor(hDiagBackCursor); 
  1613.                  CurCmd=ID_SIZE_ITEM;           // initiate the sizing command
  1614.                  IgnoreMouseMove=FALSE;         // now monitor the mouse movement
  1615.              }
  1616.              else {                             // no tab selected
  1617.                  CurItem=GetMouseItem(x,y);     // Get the item selected by the mouse
  1618.                  if (CurItem!=SelItem) {        // new selection
  1619.                     DeselectItem();             // deselect the previous selection
  1620.                     SelItem=CurItem;
  1621.                     PaintFlag=PAINT_ITEMS;      // restricted painting
  1622.                     FrPaint();                  // repaint the screen
  1623.                  }
  1624.                  CurCmd=-1;                      // no command in progress
  1625.                  IgnoreMouseMove=FALSE;          // now monitor the mouse movement
  1626.              }
  1627.           }
  1628.           else {                                // find item to select
  1629.               SelItem=GetMouseItem(x,y);        // Get the item selected by the mouse
  1630.               PaintFlag=PAINT_ITEMS;            // restricted painting
  1631.               FrPaint();                        // repaint the screen
  1632.               CurCmd=-1;
  1633.               IgnoreMouseMove=FALSE;           // now monitor the mouse movement
  1634.           }
  1635.     }
  1636.  
  1637.     return TRUE;
  1638. }
  1639.  
  1640. /******************************************************************************
  1641.     GetMouseItem:
  1642.     This function returns the item number which enclosed the given x and
  1643.     y position.  When more than one item contain the given point, item
  1644.     with smallest area is selected
  1645. *******************************************************************************/
  1646. GetMouseItem(int x,int y)
  1647. {
  1648.    int i,CurItem;
  1649.    long MinArea,ItemArea;
  1650.  
  1651.    // save the mouse position
  1652.    MouseX=x;
  1653.    MouseY=y;
  1654.  
  1655.    // find the item where the mouse is positioned
  1656.    CurItem=-1;
  1657.  
  1658.    for (i=0;i<TotalItems;i++) {
  1659.       if (x<item[i].x || x>item[i].x+item[i].width)  continue;  // outside
  1660.       if (y<item[i].y || y>item[i].y+item[i].height) continue;  // outside
  1661.       if (item[i].type==GROUP && item[i].width<=DESC_MARGIN && item[i].height<=DESC_MARGIN) continue; //no selection
  1662.  
  1663.       // compare the item area
  1664.       ItemArea=(long)item[i].width*(long)item[i].height; // check right side
  1665.       if (ItemArea<0) ItemArea=-ItemArea;
  1666.  
  1667.       if (CurItem<0) {                            // no item selected yet
  1668.          CurItem=i;
  1669.          MinArea=ItemArea;
  1670.       }
  1671.       else if (ItemArea<=MinArea) {// compare with the previously selected item
  1672.          CurItem=i;
  1673.          MinArea=ItemArea;
  1674.       }
  1675.    }
  1676.    
  1677.    if (CurItem<0) CurItem=0;
  1678.    return CurItem;
  1679. }
  1680.  
  1681. /******************************************************************************
  1682.     GetMouseOpt:
  1683.     Get the option rectangle hit by the mouse
  1684. *******************************************************************************/
  1685. GetMouseOpt(DWORD lParam)
  1686. {
  1687.     int i,x,y;
  1688.     HRGN rgn;
  1689.  
  1690.     // calculate logical mouse position 
  1691.     x=FrWinOrgX+PixToUnitX((int)(LOSHORT(lParam))-FrRect.left); 
  1692.     y=FrWinOrgY+PixToUnitY((int)(HISHORT(lParam))-FrRect.top);
  1693.  
  1694.     // find the rectangle that is hit
  1695.     for (i=0;i<MAX_OPTS;i++) {
  1696.        if (x<OptRect[i].left || x>OptRect[i].right)  continue;  // outside
  1697.        if (y<OptRect[i].top || y>OptRect[i].bottom) continue;   // outside
  1698.        break;
  1699.     }
  1700.  
  1701.     // highlight rectangle if a valid option selected
  1702.     if (i<MAX_OPTS-1) {
  1703.        SelectClipRgn(hFrDC,NULL);
  1704.        
  1705.        BitBlt(hFrDC,OptRect[i].left,OptRect[i].top,
  1706.               OptRect[i].right-OptRect[i].left,OptRect[i].bottom-OptRect[i].top,
  1707.               NULL,0,0,DSTINVERT);
  1708.  
  1709.        // reset clipping region to include only the drawing area (default mode)
  1710.        rgn=CreateRectRgn(FrRect.left,FrRect.top,FrRect.right,FrRect.bottom);
  1711.        SelectClipRgn(hFrDC,rgn);
  1712.        DeleteObject(rgn);                   // delete the temporary region
  1713.     }
  1714.  
  1715.     return i;
  1716. }
  1717.  
  1718. /******************************************************************************
  1719.     FrMouseMove:
  1720.     Process the mouse movement.
  1721. *******************************************************************************/
  1722. FrMouseMove(WPARAM wParam,LPARAM lParam)
  1723. {
  1724.     int x,y,width,height;
  1725.     RECT NewRect;
  1726.     BOOL ButtonDown;
  1727.     MSG  msg;
  1728.  
  1729.     // calculate logical mouse position 
  1730.     x=FrWinOrgX+PixToUnitX((int)(LOSHORT(lParam))-FrRect.left); 
  1731.     y=FrWinOrgY+PixToUnitY((int)(HISHORT(lParam))-FrRect.top);
  1732.     ButtonDown=wParam&(MK_LBUTTON|MK_RBUTTON|MK_MBUTTON);  // True when one of the buttons are down
  1733.  
  1734.     // Begin the multiple item selection when mouse clicked in a 'section' type item
  1735.     if (CurCmd==-1) {
  1736.       if (ButtonDown && SelItem>=0) {
  1737.          if (item[SelItem].type==SECTION) return SelectGroupItemPartI(x,y);  // begin multiple item selection
  1738.          else {
  1739.             CurCmd=ID_MOVE_ITEM;             // start moving the selected item
  1740.             x=item[SelItem].x+item[SelItem].width/2;  // set the mouse position
  1741.             y=item[SelItem].y+item[SelItem].height/2; // set the mouse position
  1742.             FrSetCursor(x,y);
  1743.             // remove any pending mouse move messages
  1744.             while (PeekMessage(&msg,hFrWnd,WM_MOUSEMOVE,WM_MOUSEMOVE,PM_REMOVE|PM_NOYIELD)); 
  1745.             return TRUE;                     // move next time    
  1746.          }
  1747.       }
  1748.       else  return FrSetCursorShape(lParam);   // no action        
  1749.     }
  1750.  
  1751.     // check if mouse outside the drawing area
  1752.     if ( HISHORT(lParam)<FrRect.top) {               // went outside the drawing area
  1753.        SetCursor(hArrowCursor);
  1754.        return TRUE;
  1755.     }
  1756.  
  1757.     // check for any mouse action outside the window
  1758.     if (CurCmd==ID_MOVE_ITEM || CurCmd==ID_SIZE_ITEM || CurCmd==ID_SELECT_MULTIPLE) {
  1759.        if (!ButtonDown) {                           // mouse status not acceptable
  1760.           CurCmd=-1;                                // reset current command
  1761.           IgnoreMouseMove=TRUE;
  1762.           SetCursor(hArrowCursor);
  1763.           return TRUE;
  1764.        }
  1765.     }
  1766.  
  1767.     // Set cursor shape
  1768.     if (CurCmd==ID_SIZE_ITEM) {
  1769.        if      (CurTab==TAB_NORTH || CurTab==TAB_SOUTH) SetCursor(hVertCursor); 
  1770.        else if (CurTab==TAB_WEST  || CurTab==TAB_EAST)  SetCursor(hHorzCursor); 
  1771.        else if (CurTab==TAB_NE    || CurTab==TAB_SW)    SetCursor(hDiagCursor); 
  1772.        else if (CurTab==TAB_NW    || CurTab==TAB_SE)    SetCursor(hDiagBackCursor); 
  1773.     }
  1774.     else if (CurCmd==ID_SELECT_MULTIPLE) SetCursor(hArrowCursor);
  1775.     else SetCursor(hCrossCursor);
  1776.     
  1777.  
  1778.     // Calculate the new cursor position
  1779.     FarMove(&CursRect,&NewRect,sizeof(RECT));
  1780.     if (CurCmd==ID_SIZE_ITEM || CurCmd==ID_SELECT_MULTIPLE) {// object being sized
  1781.         if      (CurTab==TAB_NORTH) NewRect.top=y;
  1782.         else if (CurTab==TAB_SOUTH) NewRect.bottom=y;
  1783.         else if (CurTab==TAB_WEST)  NewRect.left=x;
  1784.         else if (CurTab==TAB_EAST)  NewRect.right=x;
  1785.         else if (CurTab==TAB_NW) {
  1786.            NewRect.left=x;
  1787.            NewRect.top=y;
  1788.         }
  1789.         else if (CurTab==TAB_NW) {
  1790.            NewRect.left=x;
  1791.            NewRect.top=y;
  1792.         }
  1793.         else if (CurTab==TAB_NE) {
  1794.            NewRect.right=x;
  1795.            NewRect.top=y;
  1796.         }
  1797.         else if (CurTab==TAB_SW) {
  1798.            NewRect.left=x;
  1799.            NewRect.bottom=y;
  1800.         }
  1801.         else if (CurTab==TAB_SE) {
  1802.            NewRect.right=x;
  1803.            NewRect.bottom=y;
  1804.         }
  1805.     }
  1806.     else {                                    // object being moved
  1807.         width=CursRect.right-CursRect.left;   // dimension of the current rectangle
  1808.         height=CursRect.bottom-CursRect.top;
  1809.         NewRect.left=x-width/2;
  1810.         NewRect.right=NewRect.left+width;
  1811.         NewRect.top=y-height/2;
  1812.         NewRect.bottom=NewRect.top+height;
  1813.     }
  1814.  
  1815.  
  1816.     // Check if the screen needs to scroll to show the new rectangle
  1817.     if (FrAdjustScroll(&NewRect)) FrSetCursor(x,y);  // set the new mouse poisition
  1818.  
  1819.     // Erase the old rectangle
  1820.     FrEraseFocusRect(hFrDC,&CursRect);
  1821.  
  1822.     // Draw the new focus rectangle
  1823.     FarMove(&NewRect,&CursRect,sizeof(RECT));
  1824.     FrDrawFocusRect(hFrDC,&CursRect);
  1825.  
  1826.     return TRUE;
  1827. }
  1828.  
  1829. /******************************************************************************
  1830.     FrKeyMove:
  1831.     Move the selected item as the arrow keys are pressed.
  1832. *******************************************************************************/
  1833. FrKeyMove(WPARAM wParam)
  1834. {
  1835.     int delta,CurSec,SecItem;
  1836.     RECT rect,SecRect;
  1837.     MSG  msg;
  1838.  
  1839.     if (SelItem<0 || item[SelItem].type==SECTION) return TRUE;
  1840.  
  1841.     // discard any addition key messages
  1842.     while (PeekMessage(&msg,hFrWnd,WM_KEYFIRST,WM_KEYLAST,PM_REMOVE|PM_NOYIELD));;
  1843.     
  1844.     delta=CharHeight/16;     // amount of movement
  1845.           
  1846.     // build the new item position
  1847.     rect.left=item[SelItem].x;
  1848.     rect.top=item[SelItem].y;
  1849.     if      (wParam==ID_UP)    rect.top-=delta;
  1850.     else if (wParam==ID_DOWN)  rect.top+=delta;
  1851.     else if (wParam==ID_LEFT)  rect.left-=delta;
  1852.     else if (wParam==ID_RIGHT) rect.left+=delta;
  1853.     rect.right=rect.left+item[SelItem].width;
  1854.     rect.bottom=rect.top+item[SelItem].height;
  1855.  
  1856.     // make sure that the item remains within the section
  1857.     CurSec=item[SelItem].section;
  1858.     SecItem=section[CurSec].ScrItem;
  1859.     SecRect.top=item[SecItem].y+FormHdr.SecBannerHeight;
  1860.     SecRect.bottom=item[SecItem].y+item[SecItem].height;
  1861.  
  1862.     if (rect.top<=SecRect.top)       return TRUE;  // item heading out
  1863.     if (rect.bottom>=SecRect.bottom) return TRUE;
  1864.  
  1865.     // scroll the screen if necessary
  1866.     FrEraseFocusRect(hFrDC,&CursRect);
  1867.     FarMove(&rect,&CursRect,sizeof(RECT));
  1868.     FrAdjustScroll(&CursRect);
  1869.     MoveItem();                      // move the item to the new location
  1870.  
  1871.     return TRUE;
  1872. }
  1873.  
  1874. /******************************************************************************
  1875.     FrSetCursorShape:
  1876.     The shape of the mouse cursor as it is being moved in the drawing area.
  1877. *******************************************************************************/
  1878. int FrSetCursorShape(DWORD lParam)
  1879. {
  1880.     int i,x,y,CurTab;
  1881.  
  1882.     if (SelItem<0) SetCursor(hArrowCursor);
  1883.     else {       // check if cursor positioned on a tab
  1884.        // calculate logical mouse position 
  1885.        x=FrWinOrgX+PixToUnitX((LOSHORT(lParam))-FrRect.left); 
  1886.        y=FrWinOrgY+PixToUnitY((HISHORT(lParam))-FrRect.top);
  1887.        for (i=0;i<TotalTabRects;i++) {
  1888.           if (TabRect[i].left==TabRect[i].right) continue;  // tab not in use
  1889.           if (  x>=TabRect[i].left && x<TabRect[i].right
  1890.              && y>=TabRect[i].top  && y<TabRect[i].bottom) break;
  1891.        }
  1892.        if (i<TotalTabRects) {             // size the item
  1893.            CurTab=i;
  1894.            if      (CurTab==TAB_NORTH || CurTab==TAB_SOUTH) SetCursor(hVertCursor); 
  1895.            else if (CurTab==TAB_WEST  || CurTab==TAB_EAST)  SetCursor(hHorzCursor); 
  1896.            else if (CurTab==TAB_NE    || CurTab==TAB_SW)    SetCursor(hDiagCursor); 
  1897.            else if (CurTab==TAB_NW    || CurTab==TAB_SE)    SetCursor(hDiagBackCursor); 
  1898.        }
  1899.        else SetCursor(hArrowCursor);
  1900.     }
  1901.     return TRUE;
  1902. }
  1903.  
  1904. /******************************************************************************
  1905.     FrSetCursor:
  1906.     Set the mouse cursor at the specified logical position (x and y).
  1907. *******************************************************************************/
  1908. int FrSetCursor(int x,int y)
  1909. {
  1910.     POINT pt;
  1911.  
  1912.     pt.x=UnitToPixX(x-FrWinOrgX)+FrRect.left;
  1913.     pt.y=UnitToPixY(y-FrWinOrgY)+FrRect.top;
  1914.     ClientToScreen(hFrWnd,&pt);
  1915.     SetCursorPos(pt.x,pt.y);
  1916.  
  1917.     return TRUE;
  1918. }
  1919.  
  1920. /******************************************************************************
  1921.     FrAdjustCursorRect:
  1922.     Adjust the cursor rectangle position such that it completely falls within
  1923.     as section. This function returns the section which contains the item.
  1924. *******************************************************************************/
  1925. int FrAdjustCursorRect()
  1926. {
  1927.     int height,i,SecItem,CurSec,SecTop,SecBottom,temp;
  1928.  
  1929.     // normalize cursor coordinates
  1930.     if (CursRect.top>CursRect.bottom) {
  1931.        temp=CursRect.top;
  1932.        CursRect.top=CursRect.bottom;
  1933.        CursRect.bottom=temp;
  1934.     }
  1935.     if (CursRect.left>CursRect.right) {
  1936.        temp=CursRect.left;
  1937.        CursRect.left=CursRect.right;
  1938.        CursRect.right=temp;
  1939.     }
  1940.  
  1941.     // calculate rectangle height
  1942.     height=CursRect.bottom-CursRect.top;
  1943.  
  1944.     // find the section that includes the cursor rectangle
  1945.     CurSec=-1;
  1946.     for (i=0;i<TotalItems;i++) {
  1947.        if (item[i].type!=SECTION) continue;
  1948.        if (CursRect.top  >=item[i].y && CursRect.top  <=item[i].y+item[i].height) {
  1949.           SecItem=i;
  1950.           CurSec=item[i].section;
  1951.        }
  1952.     }
  1953.     if (CurSec==-1) {        // select the first or the last section
  1954.        if (CursRect.top<0) {  // select the first section
  1955.           for (i=0;i<TotalItems;i++) if (item[i].type==SECTION) break;
  1956.        }
  1957.        else {                // select the last section
  1958.           for (i=TotalItems-1;i>=0;i--) if (item[i].type==SECTION) break;
  1959.        }
  1960.        if (i==TotalItems || i==-1) AbortFr("Error Section Selection",ERR_DISPLAY);
  1961.        SecItem=i;
  1962.        CurSec=item[i].section;
  1963.     }
  1964.  
  1965.     // do not try to fit the selection rectangle within a section
  1966.     if (CurCmd==ID_SELECT_MULTIPLE) return CurSec;
  1967.  
  1968.     // adjust the cursor rectangle if necessary
  1969.     SecTop=item[SecItem].y+FormHdr.SecBannerHeight;  // subtract the banner height
  1970.     SecBottom=item[SecItem].y+item[SecItem].height;
  1971.     
  1972.     if (CursRect.bottom>SecBottom) {
  1973.        CursRect.bottom=SecBottom;
  1974.        CursRect.top=CursRect.bottom-height;
  1975.     }
  1976.     if (CursRect.top<=SecTop) {
  1977.        CursRect.top=SecTop+1;
  1978.        CursRect.bottom=CursRect.top+height;
  1979.        if (CursRect.bottom>SecBottom) CursRect.bottom=SecBottom;
  1980.     }
  1981.  
  1982.     return CurSec;
  1983. }
  1984.  
  1985. /******************************************************************************
  1986.     FrFindItemSlot:
  1987.     This routine returns the sorted position of the cursor rectangle within
  1988.     the item array.  The calling function should provide the section placement
  1989.     of the cursor rectangle.
  1990. *******************************************************************************/
  1991. int FrFindItemSlot(int CurSec)
  1992. {
  1993.     int i;
  1994.  
  1995.     for (i=0;i<TotalItems;i++) {
  1996.        if (item[i].type==SECTION && item[i].section>CurSec) break;  // slot found
  1997.        if (item[i].y<CursRect.top) continue;
  1998.        if (item[i].y>CursRect.top) break;    // slot found
  1999.        if (item[i].x<CursRect.left) continue;
  2000.        break;                                // slot found   
  2001.     }
  2002.     return i;
  2003. }
  2004.  
  2005. /******************************************************************************
  2006.     FrAdjustScroll:
  2007.     If necessary scroll the drawing area to keep the cursor rectangle in view.
  2008.     The first parameter specifies the new location of the cursor rectangle.
  2009.     This function returns a TRUE value if the scrolling was adjusted.
  2010. *******************************************************************************/
  2011. int FrAdjustScroll(RECT far *rect)
  2012. {
  2013.     int width,height,SaveOrg;
  2014.     BOOL paint=FALSE;
  2015.  
  2016.     if (SelItem>=0 && item[SelItem].type==SECTION) return FALSE; // not applicable to sections
  2017.     if (CurCmd==ID_SIZE_ITEM) return FALSE;  
  2018.  
  2019.     // Check the horizontal direction
  2020.     if ( rect->right<=FrWinOrgX
  2021.       || rect->left>=FrWinOrgX+FrWinWidth) {
  2022.         width=rect->right-rect->left;
  2023.         if (width<FrWinWidth) {
  2024.            SaveOrg=FrWinOrgX;
  2025.            FrWinOrgX=rect->left-(FrWinWidth-width)/2;
  2026.            if (FrWinOrgX<0) FrWinOrgX=0;
  2027.            if (FrWinOrgX>FrWidth) FrWinOrgX=FrWidth;
  2028.            if (FrWinOrgX!=SaveOrg) paint=TRUE;
  2029.         }
  2030.     }
  2031.     
  2032.     // Check the vertical direction
  2033.     if ( rect->bottom<=FrWinOrgY
  2034.       || rect->top>=FrWinOrgY+FrWinHeight) {
  2035.          height=rect->bottom-rect->top;
  2036.          if (height<FrWinHeight) {
  2037.             SaveOrg=FrWinOrgY;
  2038.             FrWinOrgY=rect->top-(FrWinHeight-height)/2;
  2039.             if (FrWinOrgY<0) FrWinOrgY=0;
  2040.             if (FrWinOrgY!=SaveOrg) paint=TRUE;
  2041.          }
  2042.     }
  2043.  
  2044.     // refresh the screen
  2045.     if (paint) {
  2046.         PaintFlag=PAINT_WIN;
  2047.         FrPaint();
  2048.         if (FrShowHorBar || FrShowVerBar) SetScrollBars();
  2049.         return TRUE;
  2050.     }
  2051.     else return FALSE;
  2052. }
  2053.  
  2054. /******************************************************************************
  2055.     DeselectItem:
  2056.     Deselect the currently selected item.
  2057. *******************************************************************************/
  2058. int DeselectItem()
  2059. {
  2060.     int i;
  2061.  
  2062.     
  2063.     if (SelItem<0) return TRUE;   // no item selected
  2064.  
  2065.     if (item[SelItem].type==LABEL) UpdateLabelText();  // update the label text for the previous label
  2066.     
  2067.     FrEraseFocusRect(hFrDC,&CursRect); // turnoff the cursor rectangle
  2068.  
  2069.     // erase each tab rectangle
  2070.     for (i=0;i<TotalTabRects;i++) {
  2071.          if (TabRect[i].left==TabRect[i].right) continue; // tab not used
  2072.          FillRect(hFrDC,&TabRect[i],hBackBrush);
  2073.     }
  2074.  
  2075.     if (item[SelItem].type==GROUP) {         // shrink the group item as it is deselected
  2076.         item[SelItem].width=item[SelItem].height=0;
  2077.     }
  2078.  
  2079.     SelItem=-1;
  2080.     TotalTabRects=0;
  2081.  
  2082.     // erase the description window text
  2083.     if (hDescWnd) SetWindowText(hDescWnd,"");
  2084.  
  2085.     return TRUE;
  2086. }
  2087.  
  2088. /******************************************************************************
  2089.     SelectItem:
  2090.     Select the specified item.
  2091. *******************************************************************************/
  2092. int SelectItem(int CurItem)
  2093. {
  2094.    int i,x,y,width,height,fld;
  2095.  
  2096.  
  2097.    FrEraseFocusRect(hFrDC,&CursRect); // turnoff the cursor rectangle
  2098.  
  2099.    SelItem=CurItem;
  2100.    TotalTabRects=MAX_TABS;
  2101.  
  2102.    x=item[CurItem].x;              // item location
  2103.    y=item[CurItem].y;
  2104.    width=item[CurItem].width;      // item width and height
  2105.    height=item[CurItem].height;
  2106.  
  2107.    // Create north tab
  2108.    TabRect[TAB_NORTH].left=x+(width-TAB_WIDTH)/2;
  2109.    TabRect[TAB_NORTH].top=y-TAB_HEIGHT/2;
  2110.  
  2111.    // Create south tab
  2112.    TabRect[TAB_SOUTH].left=x+(width-TAB_WIDTH)/2;
  2113.    TabRect[TAB_SOUTH].top=y+height-TAB_HEIGHT/2;
  2114.  
  2115.    // Create west tab
  2116.    TabRect[TAB_WEST].left=x-TAB_WIDTH/2;
  2117.    TabRect[TAB_WEST].top=y+(height-TAB_HEIGHT)/2;
  2118.  
  2119.    // Create east tab
  2120.    TabRect[TAB_EAST].left=x+width-TAB_WIDTH/2;
  2121.    TabRect[TAB_EAST].top=y+(height-TAB_HEIGHT)/2;
  2122.  
  2123.    // Create north-west tab
  2124.    TabRect[TAB_NW].left=x-TAB_WIDTH/2;
  2125.    TabRect[TAB_NW].top=y-TAB_HEIGHT/2;
  2126.  
  2127.    // Create north-east tab
  2128.    TabRect[TAB_NE].left=x+width-TAB_WIDTH/2;
  2129.    TabRect[TAB_NE].top=y-TAB_HEIGHT/2;
  2130.  
  2131.    // Create south-west tab
  2132.    TabRect[TAB_SW].left=x-TAB_WIDTH/2;
  2133.    TabRect[TAB_SW].top=y+height-TAB_HEIGHT/2;
  2134.  
  2135.    // Create south-east tab
  2136.    TabRect[TAB_SE].left=x+width-TAB_WIDTH/2;
  2137.    TabRect[TAB_SE].top=y+height-TAB_HEIGHT/2;
  2138.  
  2139.    // set the right and bottom coordinates
  2140.    for (i=0;i<TotalTabRects;i++) {
  2141.       // calculate right and bottom coord for the tabs
  2142.       TabRect[i].right=TabRect[i].left+TAB_WIDTH;
  2143.       TabRect[i].bottom=TabRect[i].top+TAB_HEIGHT;
  2144.    } 
  2145.  
  2146.    // Modify tabs for a section item
  2147.    if (item[SelItem].type==SECTION) {
  2148.       for (i=0;i<TotalTabRects;i++) {
  2149.           // Move the north tab below the section banner
  2150.           if (i==TAB_NORTH) {
  2151.              TabRect[i].top=y+FormHdr.SecBannerHeight-TAB_HEIGHT/2;
  2152.              TabRect[i].bottom=TabRect[i].top+TAB_HEIGHT;
  2153.           }
  2154.           // disable all tabs other than north and south
  2155.           if (i!=TAB_NORTH && i!=TAB_SOUTH) {
  2156.             TabRect[i].right=TabRect[i].left;
  2157.             TabRect[i].bottom=TabRect[i].top;
  2158.           }
  2159.       }
  2160.     }
  2161.  
  2162.    // Draw each tab rectangle
  2163.    for (i=0;i<TotalTabRects;i++) {
  2164.         if (TabRect[i].left==TabRect[i].right) continue; // tab not used
  2165.         FillRect(hFrDC,&TabRect[i],hDrawBrush);
  2166.    }
  2167.  
  2168.    // show the selection rectangle
  2169.    CursRect.left=x;
  2170.    CursRect.right=x+width;
  2171.    CursRect.top=y;
  2172.    CursRect.bottom=y+height;
  2173.  
  2174.    // create the description window
  2175.    width=UnitToPixX(DESC_WIDTH);
  2176.    height=UnitToPixY(DESC_HEIGHT);
  2177.    y=UnitToPixY((InputRect.bottom-InputRect.top-DESC_HEIGHT)/2);
  2178.    x=UnitToPixX((InputRect.bottom-InputRect.top-DESC_HEIGHT)/2);
  2179.    if (item[SelItem].type==LABEL) {              // create an edit control
  2180.       if (hDescWnd && DescWndType!=DESC_EDIT) {  // delete the old control
  2181.          DestroyWindow(hDescWnd);
  2182.          hDescWnd=0;
  2183.       }
  2184.       
  2185.       if (!hDescWnd) {                           // create a new edit control window
  2186.          hDescWnd=CreateWindow("EDIT","",WS_CHILD|WS_BORDER|WS_VISIBLE|ES_AUTOHSCROLL,
  2187.          x,y,width,height,hFrWnd,(HMENU)ID_DESC_WND,hFrInst,NULL);
  2188.  
  2189.          // Subclass to access the carriage return key
  2190.          OrigEditProc=(WNDPROC)GetWindowLong(hDescWnd,GWL_WNDPROC);    // original control proceedure
  2191.          SetWindowLong(hDescWnd,GWL_WNDPROC,(DWORD)OurEditProc);
  2192.       }
  2193.  
  2194.       if (hDescWnd) {
  2195.          EnableWindow(hDescWnd,TRUE);
  2196.          DescWndType=DESC_EDIT;
  2197.          SetWindowText(hDescWnd,item[SelItem].label);
  2198.          SendMessage(hDescWnd,WM_PAINT,0,0L);
  2199.       }
  2200.    }
  2201.    else if (item[SelItem].type==FIELD) {         // create an static control
  2202.       if (hDescWnd && DescWndType!=DESC_STATIC) {// delete the old control
  2203.          DestroyWindow(hDescWnd);
  2204.          hDescWnd=0;
  2205.       }
  2206.       if (!hDescWnd) hDescWnd=CreateWindow("STATIC","",WS_CHILD|WS_BORDER|WS_VISIBLE,x,y,width,height,hFrWnd,(HMENU)ID_DESC_WND,hFrInst,NULL);
  2207.       if (hDescWnd) {
  2208.          EnableWindow(hDescWnd,TRUE);
  2209.          DescWndType=DESC_STATIC;
  2210.          fld=item[SelItem].field;
  2211.          SetWindowText(hDescWnd,field[fld].name);
  2212.          SendMessage(hDescWnd,WM_PAINT,0,0L);
  2213.       }
  2214.    }
  2215.    else {                                        // erase any description text
  2216.       if (hDescWnd) {
  2217.          SetWindowText(hDescWnd,"");
  2218.          SendMessage(hDescWnd,WM_PAINT,0,0L);
  2219.          EnableWindow(hDescWnd,FALSE);
  2220.       }
  2221.    }
  2222.  
  2223.    return TRUE;
  2224. }
  2225.  
  2226. /******************************************************************************
  2227.     FrDrawFocusRect:
  2228.     Draw a rectangle of the given dimension using the focus pen.
  2229. ******************************************************************************/
  2230. int FrDrawFocusRect(HDC hDC,RECT far *rect)
  2231. {
  2232.     int SaveRop;
  2233.  
  2234.     if (FocusRectDrawn) return TRUE;     // Focus rectangle already drawn
  2235.  
  2236.     SelectObject(hDC,hFocusPen);
  2237.  
  2238.     SaveRop=SetROP2(hDC,R2_NOTXORPEN);   // Use XOR drawing mode
  2239.     FrDrawRect(hDC,rect);                // draw the rectangle 
  2240.     SetROP2(hDC,SaveRop);                // reset the drawing mode
  2241.     FocusRectDrawn=TRUE;                 // focus rectangle drawn
  2242.  
  2243.     return TRUE;
  2244. }
  2245.  
  2246. /******************************************************************************
  2247.     FrEraseFocusRect:
  2248.     Erase the focus rectangle 
  2249. ******************************************************************************/
  2250. int FrEraseFocusRect(HDC hDC, RECT far *rect)
  2251. {
  2252.     int SaveRop;
  2253.  
  2254.     if (!FocusRectDrawn) return TRUE;
  2255.  
  2256.     SelectObject(hDC,hFocusPen);
  2257.  
  2258.     SaveRop=SetROP2(hDC,R2_NOTXORPEN);   // Use XOR drawing mode
  2259.     FrDrawRect(hDC,rect);                // draw the rectangle 
  2260.     SetROP2(hDC,SaveRop);                // reset the drawing mode
  2261.     FocusRectDrawn=FALSE;                // Focus rectangle no more visible
  2262.  
  2263.     return TRUE;
  2264. }
  2265.  
  2266. /******************************************************************************
  2267.     MarkGroupItems:
  2268.     Mark all the items in the current selection group.  The calling routine
  2269.     should eventually demark these items.
  2270. ******************************************************************************/
  2271. int MarkGroupItems()
  2272. {
  2273.     int i;
  2274.  
  2275.     for (i=0;i<TotalItems;i++) {
  2276.        if (InGroup(i)) item[i].InGroup=TRUE;
  2277.        else            item[i].InGroup=FALSE;
  2278.     }
  2279.     return TRUE;
  2280. }
  2281.  
  2282. /******************************************************************************
  2283.     NextGroupItem:
  2284.     This function return the next item from the selected group of items.
  2285.     The selected item is also excluded from the group.  This function returns
  2286.     -1 if no more items are found in the group
  2287. ******************************************************************************/
  2288. int NextGroupItem()
  2289. {
  2290.     int i;
  2291.  
  2292.     for (i=0;i<TotalItems;i++) if (item[i].InGroup) break;
  2293.     if (i<TotalItems) {
  2294.        item[i].InGroup=FALSE;
  2295.        return i;
  2296.     }
  2297.     else return -1;
  2298. }
  2299.  
  2300. /******************************************************************************
  2301.     LeftMostItem:
  2302.     This function return the left most item from the current group of items.
  2303.     The function return -1 if a group does not have any item.
  2304. ******************************************************************************/
  2305. int LeftMostItem()
  2306. {
  2307.    int i,CurItem,CompVal,MinVal=0;
  2308.  
  2309.    CurItem=-1;
  2310.    for (i=0;i<TotalItems;i++) {
  2311.       if (!item[i].InGroup) continue;
  2312.       CompVal=item[i].x;        // value to be compared
  2313.       if (CurItem<0 || CompVal<MinVal) {
  2314.          CurItem=i;
  2315.          MinVal=CompVal;
  2316.       }
  2317.    }
  2318.    return CurItem;
  2319. }
  2320.  
  2321. /******************************************************************************
  2322.     TopMostItem:
  2323.     This function return the top most item from the current group of items.
  2324.     The function return -1 if a group does not have any item.
  2325. ******************************************************************************/
  2326. int TopMostItem()
  2327. {
  2328.    int i,CurItem,CompVal,MinVal=0;
  2329.  
  2330.    CurItem=-1;
  2331.    for (i=0;i<TotalItems;i++) {
  2332.       if (!item[i].InGroup) continue;
  2333.       CompVal=item[i].y;        // value to be compared
  2334.       if (CurItem<0 || CompVal<MinVal) {
  2335.          CurItem=i;
  2336.          MinVal=CompVal;
  2337.       }
  2338.    }
  2339.    return CurItem;
  2340. }
  2341.  
  2342. /******************************************************************************
  2343.     FrDrawOutline:
  2344.     Draw the specified sides of the given rectangle
  2345. ******************************************************************************/
  2346. int FrDrawOutline(HDC hDC,RECT far *rect,int select)
  2347. {
  2348.     if (select&OUTLINE_LEFT) {    // draw the left side
  2349.        MoveToEx(hDC,rect->left,rect->bottom,NULL);
  2350.        LineTo(hDC,rect->left,rect->top);
  2351.     }
  2352.     if (select&OUTLINE_TOP) {     // draw the top side
  2353.        MoveToEx(hDC,rect->left,rect->top,NULL);
  2354.        LineTo(hDC,rect->right,rect->top);
  2355.     }
  2356.     if (select&OUTLINE_RIGHT) {   // draw the right side
  2357.        MoveToEx(hDC,rect->right,rect->top,NULL);
  2358.        LineTo(hDC,rect->right,rect->bottom);
  2359.     }
  2360.     if (select&OUTLINE_BOT) {     // draw the bottom side
  2361.        MoveToEx(hDC,rect->right,rect->bottom,NULL);
  2362.        LineTo(hDC,rect->left,rect->bottom);
  2363.     }
  2364.  
  2365.     return TRUE;
  2366. } 
  2367.  
  2368. /******************************************************************************
  2369.     FrDrawRect:
  2370.     Draw a rectangle of the given dimension using the selected pen.
  2371. ******************************************************************************/
  2372. int FrDrawRect(HDC hDC,RECT far *rect)
  2373. {
  2374.     POINT pt[5];
  2375.  
  2376.     // build points for the rectangle
  2377.     pt[0].x=rect->left;
  2378.     pt[0].y=rect->top;
  2379.     pt[1].x=rect->right;
  2380.     pt[1].y=rect->top;
  2381.     pt[2].x=rect->right;
  2382.     pt[2].y=rect->bottom;
  2383.     pt[3].x=rect->left;
  2384.     pt[3].y=rect->bottom;
  2385.     pt[4].x=rect->left;
  2386.     pt[4].y=rect->top;
  2387.  
  2388.     Polyline(hDC,pt,5);
  2389.     return TRUE;
  2390. } 
  2391.  
  2392. /******************************************************************************
  2393.     MakeRect:
  2394.     This routine simply converts x,y,width and height to the RECT structure.
  2395. ******************************************************************************/
  2396. MakeRect(RECT far *rect,int x,int y,int width, int height)
  2397. {
  2398.     rect->left=x;
  2399.     rect->right=x+width;
  2400.     rect->top=y;
  2401.     rect->bottom=y+height;
  2402.     return TRUE;
  2403. }
  2404.  
  2405. /******************************************************************************
  2406.     InitItem:
  2407.     Initialize the specified item structure.
  2408. ******************************************************************************/
  2409. int InitItem(struct StrItem huge *CurItem)
  2410. {
  2411.     CurItem->type=LABEL;            // screen item type: LABEL,FIELD,SECTION,LINE
  2412.     
  2413.     CurItem->x=0;                   // X position of the top/left corner of the object
  2414.     CurItem->y=0;                   // Y position of the top/left coner of the object
  2415.     CurItem->width=0;               // width of the object 
  2416.     CurItem->height=0;              // height of the object
  2417.  
  2418.     CurItem->flags=OFLAG_HLEFT|OFLAG_VCENTER; // Attributes, see OFLAG_ constants 
  2419.     
  2420.     CurItem->font=DEFAULT_CFMT;     // index into font structure for types LABEL or FIELD
  2421.     CurItem->field=0;               // index into 'field' array for type = FIELD
  2422.     CurItem->section=0;             // index into 'section' array for type = SECTION
  2423.     
  2424.     CurItem->label[0]=0;            // label text when type is LABEL
  2425.     CurItem->TextColor=RGB(0,0,0);  // text color
  2426.  
  2427.     CurItem->OutlineSelect=0;       // sides to draw
  2428.     CurItem->OutlineStyle=PS_SOLID; // line style of the bounding rectangle
  2429.     CurItem->OutlineWidth=0;        // line width of the bounding rectangle
  2430.     CurItem->OutlineColor=DrawColor;// line color of the bounding rectangle
  2431.  
  2432.     CurItem->LineAngle=ANGLE_HORZ;  // horizontal line
  2433.     CurItem->LineStyle=PS_SOLID;    // line style of the line type item
  2434.     CurItem->LineWidth=0;           // line width of the line type item
  2435.     CurItem->LineColor=DrawColor;   // line color of the line type item
  2436.  
  2437.     CurItem->brush.lbStyle=BS_SOLID; // brush to paint the bounding rectangle
  2438.     CurItem->brush.lbColor=BackColor;
  2439.     
  2440.     CurItem->sized=FALSE;           // TRUE when manually sized
  2441.  
  2442.     return TRUE;
  2443. }
  2444.  
  2445. /******************************************************************************
  2446.      GetLabelLen:
  2447.      This routine gets the length of a label in logical units.  The second
  2448.      argument specifies the chosen font.
  2449. ******************************************************************************/
  2450. int GetLabelLen(LPSTR label, int font)
  2451. {
  2452.     int len,count;
  2453.     int far *WidthTable,i;
  2454.  
  2455.     count = lstrlen(label);   // number of characters in the label
  2456.  
  2457.     WidthTable=FrFont[font].CharWidth;
  2458.     len=0;                   // length in logical units
  2459.     for (i=0;i<count;i++) len=len+WidthTable[(BYTE)(label[i])];
  2460.  
  2461.     return len;
  2462. }
  2463.  
  2464. /******************************************************************************
  2465.      TruncateText:
  2466.      This routine truncates the text (first argument) to fit within the
  2467.      the specified width. 
  2468. ******************************************************************************/
  2469. TruncateText(LPSTR text, int width, int font)
  2470. {
  2471.     int far *WidthTable,count,len;
  2472.  
  2473.     count = lstrlen(text);   // number of characters in the text
  2474.     WidthTable=FrFont[font].CharWidth;
  2475.  
  2476.     len=0;                   // text length in number of characters
  2477.     
  2478.     while (len<count) {
  2479.        width=width-WidthTable[(BYTE)(text[len])];
  2480.        if (width<0) break;
  2481.        len++;
  2482.     }
  2483.     text[len]=0;              // truncate the field
  2484.  
  2485.     return TRUE;
  2486. }
  2487.  
  2488. /******************************************************************************
  2489.     OurAlloc:
  2490.     Allocate a far memory object of given size. Lock the object, and return
  2491.     the far pointer to the object.
  2492. *******************************************************************************/
  2493. void far *OurAlloc(UINT size) 
  2494. {
  2495.     HGLOBAL hMem;
  2496.  
  2497.     if (NULL==(hMem=GlobalAlloc(GMEM_MOVEABLE, size+1))) AbortFr("Memory Allocation Error (OurAlloc)",1);
  2498.  
  2499.     return (void far *) GlobalLock(hMem);
  2500. }
  2501.  
  2502. /******************************************************************************
  2503.     OurRealloc:
  2504.     Realloc a far memory object to a given size. Lock the object, and return
  2505.     the far pointer to the object.
  2506. *******************************************************************************/
  2507. void far *OurRealloc(void far *pMem,UINT size) 
  2508. {
  2509.     HGLOBAL hMem;
  2510.  
  2511.     #if defined(WIN32)
  2512.        hMem=GlobalHandle(pMem);      // convert pointer to handle
  2513.     #else
  2514.        {
  2515.        DWORD temp=GlobalHandle((UINT)(((DWORD)pMem)>>16));
  2516.        hMem=(HGLOBAL)LOWORD(temp);
  2517.        }
  2518.     #endif
  2519.  
  2520.     GlobalUnlock(hMem);
  2521.  
  2522.     if (NULL==(hMem=GlobalReAlloc(hMem,size+1, 0))) AbortFr("Memory Allocation Error (OurAlloc)",1);
  2523.  
  2524.     return (void far *) GlobalLock(hMem);
  2525. }
  2526.  
  2527. /******************************************************************************
  2528.     OurFree:
  2529.     Free up the given memory object.  This object must have been allocated
  2530.     using the OurAlloc routine.
  2531. *******************************************************************************/
  2532. void OurFree(void far *pMem) 
  2533. {
  2534.     HGLOBAL hMem;
  2535.  
  2536.     if (pMem!=NULL) {
  2537.        #if defined(WIN32)
  2538.           hMem=GlobalHandle(pMem);      // convert pointer to handle
  2539.        #else
  2540.           {
  2541.           DWORD temp=GlobalHandle((UINT)(((DWORD)pMem)>>16));
  2542.           hMem=(HGLOBAL)LOWORD(temp);
  2543.           }
  2544.        #endif
  2545.        GlobalUnlock(hMem);
  2546.        GlobalFree(hMem);
  2547.     }
  2548. }
  2549.  
  2550. /******************************************************************************
  2551.     sAlloc:
  2552.     Replacement of the Winmem package routine. Simply allocates the memory, and 
  2553.     returns the handle as a 32 bit quantity.
  2554. *******************************************************************************/
  2555. DWORD sAlloc(UINT size) 
  2556. {
  2557.  
  2558.     HGLOBAL hMem;
  2559.  
  2560.     if (NULL==(hMem=GlobalAlloc(GMEM_MOVEABLE, size+1))) AbortFr("Memory Allocation Error (OurAlloc)",1);
  2561.  
  2562.     return (DWORD) ((LPSTR)hMem);
  2563. }
  2564.  
  2565. /******************************************************************************
  2566.     sReAlloc:
  2567.     Replacement of the Winmem package routine. Simply reallocates the memory, 
  2568.     and returns the handle as a 32 bit quantity.
  2569. *******************************************************************************/
  2570. DWORD sReAlloc(DWORD hMem,UINT size) 
  2571. {
  2572.     HGLOBAL hGlb;
  2573.  
  2574.     if (NULL==(hGlb=GlobalReAlloc((HGLOBAL)hMem,size+1, 0))) AbortFr("Memory Allocation Error (OurAlloc)",1);
  2575.  
  2576.     return (DWORD) ((LPSTR)hGlb);
  2577. }
  2578.  
  2579. /******************************************************************************
  2580.     sLock:
  2581.     Replacement of the Winmem package routine. Simply locks the global handle 
  2582.     and returns the far pointer.
  2583. *******************************************************************************/
  2584. void far * sLock(DWORD hMem) 
  2585. {
  2586.  
  2587.    return GlobalLock((HGLOBAL)hMem);
  2588. }
  2589.  
  2590. /******************************************************************************
  2591.     sUnlock:
  2592.     Replacement of the Winmem package routine. Simply unlocks the global handle. 
  2593. *******************************************************************************/
  2594. int sUnlock(DWORD hMem) 
  2595. {
  2596.  
  2597.    GlobalUnlock((HGLOBAL)hMem);
  2598.    return TRUE;
  2599. }
  2600.  
  2601. /******************************************************************************
  2602.     sFree:
  2603.     Replacement of the Winmem package routine. Simply frees the global handle.
  2604. *******************************************************************************/
  2605. int sFree(DWORD hMem) 
  2606. {
  2607.  
  2608.    GlobalFree((HGLOBAL)hMem);
  2609.    return TRUE;
  2610. }
  2611.  
  2612.