开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
DIALOGS.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：21k
源码类别：

Windows编程

开发平台：

Visual C++

DIALOGS.C：源码内容
  1. /*************************************************************************
  2. **
  3. **    OLE 2 Sample Code
  4. **
  5. **    dialogs.c
  6. **
  7. **    This file contains dialog functions and support function
  8. **
  9. **    (c) Copyright Microsoft Corp. 1992 - 1996 All Rights Reserved
  10. **
  11. *************************************************************************/
  13. #include "outline.h"
  15. OLEDBGDATA
  17. extern LPOUTLINEAPP g_lpApp;
  19. static OLECHAR  g_szBuf[MAXSTRLEN+1];
  20. static LPSTR g_lpszDlgTitle;
  22. // REVIEW: should use string resource for messages
  23. static OLECHAR ErrMsgInvalidRange[] = OLESTR("Invalid Range entered!");
  24. static OLECHAR ErrMsgInvalidValue[] = OLESTR("Invalid Value entered!");
  25. static OLECHAR ErrMsgInvalidName[] = OLESTR("Invalid Name entered!");
  26. static OLECHAR ErrMsgNullName[] = OLESTR("NULL string disallowed!");
  27. static OLECHAR ErrMsgNameNotFound[] = OLESTR("Name doesn't exist!");
  29. /* InputTextDlg
  30.  * ------------
  31.  *
  32.  *      Put up a dialog box to allow the user to edit text
  33.  */
  34. BOOL InputTextDlg(HWND hWnd, LPSTR lpszText, LPSTR lpszDlgTitle)
  35. {
  36.    int nResult;
  38.    g_lpszDlgTitle = lpszDlgTitle;
  39.    A2W (lpszText, g_szBuf, MAXSTRLEN+1);  // preload dialog with input text
  41.    nResult = DialogBox(g_lpApp->m_hInst, (LPSTR)"AddEditLine", hWnd,
  42.                   (DLGPROC)AddEditDlgProc);
  43.    if (nResult) {
  44.       W2A(g_szBuf, lpszText, MAXSTRLEN+1);
  45.       return TRUE;
  46.    } else {
  47.       return FALSE;
  48.    }
  49. }
  53. /* AddEditDlgProc
  54.  * --------------
  55.  *
  56.  * This procedure is associated with the dialog box that is included in
  57.  * the function name of the procedure. It provides the service routines
  58.  * for the events (messages) that occur because the end user operates
  59.  * one of the dialog box's buttons, entry fields, or controls.
  60.  */
  61. BOOL CALLBACK EXPORT AddEditDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  62. {
  63.    HWND hEdit;
  64.    char szAnsiString[256];
  66.    switch(Message) {
  67.       case WM_INITDIALOG:
  68.          /* initialize working variables */
  69.          hEdit=GetDlgItem(hDlg,IDD_EDIT);
  70.          SendMessage(hEdit,EM_LIMITTEXT,(WPARAM)MAXSTRLEN,0L);
  71.          SetWindowText(hDlg, g_lpszDlgTitle);
  72.          W2A (g_szBuf, szAnsiString, 256);
  73.          SetDlgItemText(hDlg,IDD_EDIT, szAnsiString);
  74.          break; /* End of WM_INITDIALOG */
  76.       case WM_CLOSE:
  77.          /* Closing the Dialog behaves the same as Cancel */
  78.          PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0L);
  79.          break; /* End of WM_CLOSE */
  81.       case WM_COMMAND:
  82.          switch (wParam) {
  83.             case IDOK:
  84.                /* save data values entered into the controls
  85.                ** and dismiss the dialog box returning TRUE
  86.                */
  87.                GetDlgItemText(hDlg,IDD_EDIT,(LPSTR)g_szBuf,MAXSTRLEN+1);
  88.                EndDialog(hDlg, TRUE);
  89.                break;
  91.             case IDCANCEL:
  92.                /* ignore data values entered into the controls
  93.                ** and dismiss the dialog box returning FALSE
  94.                */
  95.                EndDialog(hDlg, FALSE);
  96.                break;
  97.          }
  98.          break;    /* End of WM_COMMAND */
  100.       default:
  101.          return FALSE;
  102.    }
  104.    return TRUE;
  105. } /* End of AddEditDlgProc */
  108. /* SetLineHeightDlgProc
  109.  * --------------------
  110.  *
  111.  *      Dialog procedure for set line height
  112.  */
  113. BOOL CALLBACK EXPORT SetLineHeightDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  114. {
  115.    BOOL    fTranslated;
  116.    BOOL    fEnable;
  117.    static LPINT    lpint;
  118.    int     nHeight;
  119.    static int nMaxHeight;
  121.    switch (Message) {
  122.       case WM_INITDIALOG:
  123.       {
  124.          char cBuf[80];
  126.          nMaxHeight = XformHeightInPixelsToHimetric(NULL,
  127.                         LISTBOX_HEIGHT_LIMIT);
  128.          lpint = (LPINT)lParam;
  129.          SetDlgItemInt(hDlg, IDD_EDIT, *lpint, FALSE);
  130.          wsprintf(cBuf, "Maximum value is %d units", nMaxHeight);
  131.          SetDlgItemText(hDlg, IDD_LIMIT, (LPSTR)cBuf);
  132.          break;
  133.       }
  135.       case WM_COMMAND:
  136.          switch (wParam) {
  137.             case IDOK:
  138.                if (IsDlgButtonChecked(hDlg, IDD_CHECK)) {
  139.                   *lpint = -1;
  140.                }
  141.                else {
  142.                   /* save the value in the edit control */
  143.                   nHeight = GetDlgItemInt(hDlg, IDD_EDIT,
  144.                         (BOOL FAR*)&fTranslated, FALSE);
  145.                   if (!fTranslated || !nHeight || (nHeight>nMaxHeight)){
  146.                      OutlineApp_ErrorMessage(g_lpApp,
  147.                            ErrMsgInvalidValue);
  148.                      break;
  149.                   }
  150.                   *lpint = nHeight;
  151.                }
  152.                EndDialog(hDlg, TRUE);
  153.                break;
  155.             case IDCANCEL:
  156.                *lpint = 0;
  157.                EndDialog(hDlg, FALSE);
  158.                break;
  161.             case IDD_CHECK:
  162.                fEnable = !IsDlgButtonChecked(hDlg, IDD_CHECK);
  163.                EnableWindow(GetDlgItem(hDlg, IDD_EDIT), fEnable);
  164.                EnableWindow(GetDlgItem(hDlg, IDD_TEXT), fEnable);
  165.                break;
  166.          }
  167.          break;  /* WM_COMMAND */
  169.       case WM_CLOSE:  /* Closing the Dialog behaves the same as Cancel */
  170.          PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0L);
  171.          break; /* End of WM_CLOSE */
  173.       default:
  174.          return FALSE;
  175.    }
  177.    return TRUE;
  179. } /* end of SetLineHeightProc */
  185. /* DefineNameDlgProc
  186.  * -----------------
  187.  *
  188.  *      Dialog procedure for define name
  189.  */
  190. BOOL CALLBACK EXPORT DefineNameDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  191. {
  192.    static HWND hCombo;
  193.    static LPOUTLINEDOC lpOutlineDoc = NULL;
  194.    static LPOUTLINENAMETABLE lpOutlineNameTable = NULL;
  195.    LPOUTLINENAME lpOutlineName = NULL;
  196.    UINT nIndex;
  197.    LINERANGE lrSel;
  198.    BOOL fTranslated;
  199.    char szAnsiString[256];
  201.    switch(Message) {
  202.       case WM_INITDIALOG:
  203.       /* initialize working variables */
  204.          hCombo=GetDlgItem(hDlg,IDD_COMBO);
  205.          lpOutlineDoc = (LPOUTLINEDOC) lParam;
  206.          lpOutlineNameTable = OutlineDoc_GetNameTable(lpOutlineDoc);
  208.          SendMessage(hCombo,CB_LIMITTEXT,(WPARAM)MAXNAMESIZE,0L);
  209.          NameDlg_LoadComboBox(lpOutlineNameTable, hCombo);
  211.          OutlineDoc_GetSel(lpOutlineDoc, (LPLINERANGE)&lrSel);
  212.          lpOutlineName = OutlineNameTable_FindNamedRange(
  213.                lpOutlineNameTable,
  214.                &lrSel
  215.          );
  217.          /* if current selection already has a name, hilight it */
  218.          if (lpOutlineName) {
  219.             nIndex = (int) SendMessage(
  220.                   hCombo,
  221.                   CB_FINDSTRINGEXACT,
  222.                   (WPARAM)0xffff,
  223.                   (LPARAM)(LPCSTR)lpOutlineName->m_szName
  224.             );
  225.             if (nIndex != CB_ERR) {
  226.                SendMessage(hCombo, CB_SETCURSEL, (WPARAM)nIndex, 0L);
  227.             }
  228.          }
  230.          SetDlgItemInt(hDlg, IDD_FROM, (UINT)lrSel.m_nStartLine+1,FALSE);
  231.          SetDlgItemInt(hDlg, IDD_TO, (UINT)lrSel.m_nEndLine+1, FALSE);
  233.          break; /* End of WM_INITDIALOG */
  235.       case WM_CLOSE:
  236.       /* Closing the Dialog behaves the same as Cancel */
  237.          PostMessage(hDlg, WM_COMMAND, IDD_CLOSE, 0L);
  238.          break; /* End of WM_CLOSE */
  240.       case WM_COMMAND:
  241.          switch(wParam) {
  242.             case IDOK:
  243.                GetDlgItemText(hDlg,IDD_COMBO,(LPSTR)g_szBuf,MAXNAMESIZE);
  244.                if(! SendMessage(hCombo,WM_GETTEXTLENGTH,0,0L)) {
  245.                   W2A (ErrMsgNullName, szAnsiString, 256);
  246.                   MessageBox(
  247.                         hDlg,
  248.                         szAnsiString,
  249.                         NULL,
  250.                         MB_ICONEXCLAMATION
  251.                   );
  252.                   break;
  253.                } else if(SendMessage(hCombo,CB_GETCURSEL,0,0L)==CB_ERR &&
  254.                      wcschr(g_szBuf, ' ')) {
  255.                   W2A (ErrMsgInvalidName, szAnsiString, 256);
  256.                   MessageBox(
  257.                         hDlg,
  258.                         szAnsiString,
  259.                         NULL,
  260.                         MB_ICONEXCLAMATION
  261.                   );
  262.                   break;
  263.                } else {
  264.                   nIndex = (int) SendMessage(hCombo,CB_FINDSTRINGEXACT,
  265.                      (WPARAM)0xffff,(LPARAM)(LPCSTR)g_szBuf);
  267.                   /* Line indices are 1 less than the number in
  268.                   **    the row heading
  269.                   */
  270.                   lrSel.m_nStartLine = GetDlgItemInt(hDlg, IDD_FROM,
  271.                         (BOOL FAR*)&fTranslated, FALSE) - 1;
  272.                   if(! fTranslated) {
  273.                      OutlineApp_ErrorMessage(g_lpApp,
  274.                            ErrMsgInvalidRange);
  275.                      break;
  276.                   }
  277.                   lrSel.m_nEndLine = GetDlgItemInt(hDlg, IDD_TO,
  278.                         (BOOL FAR*)&fTranslated, FALSE) - 1;
  279.                   if (!fTranslated ||
  280.                      (lrSel.m_nStartLine < 0) ||
  281.                      (lrSel.m_nEndLine < lrSel.m_nStartLine) ||
  282.                      (lrSel.m_nEndLine >= OutlineDoc_GetLineCount(
  283.                            lpOutlineDoc))) {
  284.                      OutlineApp_ErrorMessage(g_lpApp,
  285.                            ErrMsgInvalidRange);
  286.                      break;
  287.                   }
  289.                   if(nIndex != CB_ERR) {
  290.                      NameDlg_UpdateName(
  291.                            hCombo,
  292.                            lpOutlineDoc,
  293.                            nIndex,
  294.                            g_szBuf,
  295.                            &lrSel
  296.                      );
  297.                   } else {
  298.                      NameDlg_AddName(
  299.                            hCombo,
  300.                            lpOutlineDoc,
  301.                            g_szBuf,
  302.                            &lrSel
  303.                      );
  304.                   }
  305.                }
  306.                // fall through
  308.             case IDD_CLOSE:
  309.                /* Ignore data values entered into the controls */
  310.                /* and dismiss the dialog window returning FALSE */
  311.                EndDialog(hDlg,0);
  312.                break;
  314.             case IDD_DELETE:
  315.                GetDlgItemText(hDlg,IDD_COMBO,(LPSTR)szAnsiString,MAXNAMESIZE);
  316.                if((nIndex=(int)SendMessage(hCombo,CB_FINDSTRINGEXACT,
  317.                (WPARAM)0xffff,(LPARAM)(LPCSTR)szAnsiString))==CB_ERR) {
  318.                   W2A (ErrMsgNameNotFound, szAnsiString, 256);
  319.                   MessageBox(hDlg, szAnsiString, NULL, MB_ICONEXCLAMATION);
  320.                }
  321.                else {
  322.                   NameDlg_DeleteName(hCombo, lpOutlineDoc, nIndex);
  323.                }
  324.                break;
  326.             case IDD_COMBO:
  327.                if(HIWORD(lParam) == CBN_SELCHANGE) {
  328.                   nIndex=(int)SendMessage(hCombo, CB_GETCURSEL, 0, 0L);
  329.                   lpOutlineName = (LPOUTLINENAME)SendMessage(
  330.                         hCombo,
  331.                         CB_GETITEMDATA,
  332.                         (WPARAM)nIndex,
  333.                         0L
  334.                   );
  335.                   SetDlgItemInt(
  336.                         hDlg,
  337.                         IDD_FROM,
  338.                         (UINT) lpOutlineName->m_nStartLine + 1,
  339.                         FALSE
  340.                   );
  341.                   SetDlgItemInt(
  342.                         hDlg,
  343.                         IDD_TO,
  344.                         (UINT) lpOutlineName->m_nEndLine + 1,
  345.                         FALSE
  346.                   );
  347.                }
  348.          }
  349.          break;    /* End of WM_COMMAND */
  351.       default:
  352.          return FALSE;
  353.    }
  355.    return TRUE;
  356. } /* End of DefineNameDlgProc */
  359. /* GotoNameDlgProc
  360.  * ---------------
  361.  *
  362.  *      Dialog procedure for goto name
  363.  */
  364. BOOL CALLBACK EXPORT GotoNameDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  365. {
  366.    static HWND hLBName;
  367.    static LPOUTLINEDOC lpOutlineDoc = NULL;
  368.    static LPOUTLINENAMETABLE lpOutlineNameTable = NULL;
  369.    UINT nIndex;
  370.    LINERANGE lrLineRange;
  371.    LPOUTLINENAME lpOutlineName;
  373.    switch(Message) {
  374.       case WM_INITDIALOG:
  375.       /* initialize working variables */
  376.          lpOutlineDoc = (LPOUTLINEDOC) lParam;
  377.          lpOutlineNameTable = OutlineDoc_GetNameTable(lpOutlineDoc);
  379.          hLBName=GetDlgItem(hDlg,IDD_LINELISTBOX);
  380.          NameDlg_LoadListBox(lpOutlineNameTable, hLBName);
  382.          // highlight 1st item
  383.          SendMessage(hLBName, LB_SETCURSEL, 0, 0L);
  384.          // trigger to initialize edit control
  385.          SendMessage(hDlg, WM_COMMAND, (WPARAM)IDD_LINELISTBOX,
  386.             MAKELONG(hLBName, LBN_SELCHANGE));
  388.          break; /* End of WM_INITDIALOG */
  390.       case WM_CLOSE:
  391.       /* Closing the Dialog behaves the same as Cancel */
  392.          PostMessage(hDlg, WM_COMMAND, IDCANCEL, 0L);
  393.          break; /* End of WM_CLOSE */
  395.       case WM_COMMAND:
  396.          switch(wParam) {
  397.             case IDD_LINELISTBOX:
  398.                if(HIWORD(lParam) == LBN_SELCHANGE) {
  399.                   // update the line range display
  400.                   nIndex=(int)SendMessage(hLBName, LB_GETCURSEL, 0, 0L);
  401.                   lpOutlineName = (LPOUTLINENAME)SendMessage(hLBName, LB_GETITEMDATA,
  402.                                  (WPARAM)nIndex,0L);
  403.                   if (lpOutlineName) {
  404.                      SetDlgItemInt(
  405.                            hDlg,
  406.                            IDD_FROM,
  407.                            (UINT) lpOutlineName->m_nStartLine + 1,
  408.                            FALSE
  409.                      );
  410.                      SetDlgItemInt(
  411.                            hDlg,
  412.                            IDD_TO,
  413.                            (UINT) lpOutlineName->m_nEndLine + 1,
  414.                            FALSE
  415.                      );
  416.                   }
  417.                   break;
  418.                }
  419.                // double click will fall through
  420.                else if(HIWORD(lParam) != LBN_DBLCLK)
  421.                   break;
  423.             case IDOK:
  424.                nIndex=(int)SendMessage(hLBName,LB_GETCURSEL,0,0L);
  425.                if(nIndex!=LB_ERR) {
  426.                   lpOutlineName = (LPOUTLINENAME)SendMessage(hLBName,
  427.                         LB_GETITEMDATA, (WPARAM)nIndex, 0L);
  428.                   lrLineRange.m_nStartLine=lpOutlineName->m_nStartLine;
  429.                   lrLineRange.m_nEndLine = lpOutlineName->m_nEndLine;
  430.                   OutlineDoc_SetSel(lpOutlineDoc, &lrLineRange);
  431.                }   // fall through
  433.             case IDCANCEL:
  434.             /* Ignore data values entered into the controls */
  435.             /* and dismiss the dialog window returning FALSE */
  436.                EndDialog(hDlg,0);
  437.                break;
  439.          }
  440.          break;    /* End of WM_COMMAND */
  442.       default:
  443.          return FALSE;
  444.    }
  446.    return TRUE;
  447. } /* End of GotoNameDlgProc */
  451. /* NameDlg_LoadComboBox
  452.  * --------------------
  453.  *
  454.  *      Load defined names into combo box
  455.  */
  456. void NameDlg_LoadComboBox(LPOUTLINENAMETABLE lpOutlineNameTable,HWND hCombo)
  457. {
  458.    LPOUTLINENAME lpOutlineName;
  459.    int i, nIndex;
  460.    int nCount;
  462.    nCount=OutlineNameTable_GetCount((LPOUTLINENAMETABLE)lpOutlineNameTable);
  463.    if(!nCount) return;
  465.    SendMessage(hCombo,WM_SETREDRAW,(WPARAM)FALSE,0L);
  466.    for(i=0; i<nCount; i++) {
  467.       lpOutlineName=OutlineNameTable_GetName((LPOUTLINENAMETABLE)lpOutlineNameTable,i);
  468.       nIndex = (int)SendMessage(
  469.             hCombo,
  470.             CB_ADDSTRING,
  471.             0,
  472.             (LPARAM)(LPCSTR)lpOutlineName->m_szName
  473.       );
  474.       SendMessage(hCombo,CB_SETITEMDATA,(WPARAM)nIndex,(LPARAM)lpOutlineName);
  475.    }
  476.    SendMessage(hCombo,WM_SETREDRAW,(WPARAM)TRUE,0L);
  477. }
  480. /* NameDlg_LoadListBox
  481.  * -------------------
  482.  *
  483.  *      Load defined names into list box
  484.  */
  485. void NameDlg_LoadListBox(LPOUTLINENAMETABLE lpOutlineNameTable,HWND hListBox)
  486. {
  487.    int i;
  488.    int nCount;
  489.    int nIndex;
  490.    LPOUTLINENAME lpOutlineName;
  492.    nCount=OutlineNameTable_GetCount((LPOUTLINENAMETABLE)lpOutlineNameTable);
  494.    SendMessage(hListBox,WM_SETREDRAW,(WPARAM)FALSE,0L);
  495.    for(i=0; i<nCount; i++) {
  496.       lpOutlineName=OutlineNameTable_GetName((LPOUTLINENAMETABLE)lpOutlineNameTable,i);
  497.       nIndex = (int)SendMessage(
  498.             hListBox,
  499.             LB_ADDSTRING,
  500.             0,
  501.             (LPARAM)(LPCSTR)lpOutlineName->m_szName
  502.       );
  503.       SendMessage(hListBox,LB_SETITEMDATA,(WPARAM)nIndex,(LPARAM)lpOutlineName);
  504.    }
  505.    SendMessage(hListBox,WM_SETREDRAW,(WPARAM)TRUE,0L);
  506. }
  509. /* NameDlg_AddName
  510.  * ---------------
  511.  *
  512.  *      Add a name to the name table corresponding to the name dialog
  513.  *      combo box.
  514.  */
  515. void NameDlg_AddName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, LPOLESTR lpszName, LPLINERANGE lplrSel)
  516. {
  517.    LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
  518.    LPOUTLINENAME lpOutlineName;
  520.    lpOutlineName = OutlineApp_CreateName(lpOutlineApp);
  522.    if (lpOutlineName) {
  523.       OLESTRCPY(lpOutlineName->m_szName, lpszName);
  524.       lpOutlineName->m_nStartLine = lplrSel->m_nStartLine;
  525.       lpOutlineName->m_nEndLine = lplrSel->m_nEndLine;
  526.       OutlineDoc_AddName(lpOutlineDoc, lpOutlineName);
  527.    } else {
  528.       // REVIEW: do we need error message here?
  529.    }
  530. }
  533. /* NameDlg_UpdateName
  534.  * ------------------
  535.  *
  536.  *      Update a name in the name table corresponding to a name in
  537.  *      the name dialog combo box.
  538.  */
  539. void NameDlg_UpdateName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, int nIndex, LPOLESTR lpszName, LPLINERANGE lplrSel)
  540. {
  541.    LPOUTLINENAME lpOutlineName;
  543.    lpOutlineName = (LPOUTLINENAME)SendMessage(
  544.          hCombo,
  545.          CB_GETITEMDATA,
  546.          (WPARAM)nIndex,
  547.          0L
  548.    );
  550.    OutlineName_SetName(lpOutlineName, lpszName);
  551.    OutlineName_SetSel(lpOutlineName, lplrSel, TRUE /* name modified */);
  552.    OutlineDoc_SetModified(lpOutlineDoc, TRUE, FALSE, FALSE);
  553. }
  556. /* NameDlg_DeleteName
  557.  * ------------------
  558.  *
  559.  *      Delete a name from the name dialog combo box and corresponding
  560.  *      name table.
  561.  */
  562. void NameDlg_DeleteName(HWND hCombo, LPOUTLINEDOC lpOutlineDoc, UINT nIndex)
  563. {
  564.    SendMessage(hCombo,CB_DELETESTRING,(WPARAM)nIndex,0L);
  565.    OutlineDoc_DeleteName(lpOutlineDoc, nIndex);
  566. }
  568. /* PlaceBitmap
  569.  * -----------
  570.  *
  571.  *      Places a bitmap centered in the specified control in the dialog on the
  572.  *      specified DC.
  573.  *
  574.  */
  576. PlaceBitmap(HWND hDlg, int control, HDC hDC, HBITMAP hBitmap)
  577. {
  578.    BITMAP bm;
  579.    HDC hdcmem;
  580.    HBITMAP hbmOld;
  581.    RECT rcControl;     // Rect of dialog control
  582.    int width, height;
  584.    GetObject(hBitmap, sizeof(BITMAP), &bm);
  586.    hdcmem= CreateCompatibleDC(hDC);
  587.    hbmOld = SelectObject(hdcmem, hBitmap);
  589.    // Get rect of control in screen coords, and translate to our dialog
  590.    // box's coordinates
  591.    GetWindowRect(GetDlgItem(hDlg, control), &rcControl);
  592.    MapWindowPoints(NULL, hDlg, (LPPOINT)&rcControl, 2);
  594.    width  = rcControl.right - rcControl.left;
  595.    height = rcControl.bottom - rcControl.top;
  597.    BitBlt(hDC, rcControl.left + (width - bm.bmWidth) / 2,
  598.             rcControl.top + (height - bm.bmHeight) /2,
  599.             bm.bmWidth, bm.bmHeight,
  600.             hdcmem, 0, 0, SRCCOPY);
  602.    SelectObject(hdcmem, hbmOld);
  603.    DeleteDC(hdcmem);
  604.    return 1;
  605. }
  609. /* AboutDlgProc
  610.  * ------------
  611.  *
  612.  *      Dialog procedure for the About function
  613.  */
  614. BOOL CALLBACK EXPORT AboutDlgProc(HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
  615. {
  616.    int  narrVersion[2];
  617.    static HBITMAP hbmLogo;
  618.    char   szAnsiString[256];
  619.    char   szAppName[250];
  621.    switch(Message) {
  623.       case WM_INITDIALOG:
  624.          // get version number of app
  625.          W2A (APPNAME, szAppName, 250);
  626.          wsprintf(szAnsiString, "About %s", (LPSTR)szAppName);
  627.          SetWindowText(hDlg, (LPCSTR)szAnsiString);
  628.          OutlineApp_GetAppVersionNo(g_lpApp, narrVersion);
  629.          wsprintf(szAnsiString, "%s version %d.%d", (LPSTR) APPDESC,
  630.             narrVersion[0], narrVersion[1]);
  631.          SetDlgItemText(hDlg, IDD_APPTEXT, (LPCSTR)szAnsiString);
  633.          // Load bitmap for displaying later
  634.          hbmLogo = LoadBitmap(g_lpApp->m_hInst, "LogoBitmap");
  635.          TraceDebug(hDlg, IDD_BITMAPLOCATION);
  636.          ShowWindow(GetDlgItem(hDlg, IDD_BITMAPLOCATION), SW_HIDE);
  637.          break;
  639.       case WM_PAINT:
  640.          {
  641.          PAINTSTRUCT ps;
  642.          BeginPaint(hDlg, &ps);
  644.          // Display bitmap in IDD_BITMAPLOCATION control area
  645.          PlaceBitmap(hDlg, IDD_BITMAPLOCATION, ps.hdc, hbmLogo);
  646.          EndPaint(hDlg, &ps);
  647.          }
  648.          break;
  650.       case WM_CLOSE :
  651.          PostMessage(hDlg, WM_COMMAND, IDOK, 0L);
  652.          break;
  654.       case WM_COMMAND :
  655.          switch(wParam) {
  656.             case IDOK:
  657.             case IDCANCEL:
  658.                if (hbmLogo) DeleteObject(hbmLogo);
  659.                EndDialog(hDlg,0);
  660.                break;
  661.          }
  662.          break;
  664.       default :
  665.          return FALSE;
  667.    }
  668.    return TRUE;
  669. }