home *** CD-ROM | disk | FTP | other *** search
/ Prima Shareware 3 / DuCom_Prima-Shareware-3_cd1.bin / PROGRAMO / C / CKTBL / SAMPLES / SDKDEMO / DEMO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-02  |  21.2 KB  |  818 lines
  1. /*------------------------------------------------------------------------------
  2.  *  DEMO.EXE    Demo Program for CKTBL Tabel Control using Windows SDK Api from C
  3.  *    
  4.  *  Copyright(C) 1994 by Christian Kratzer Software development and Consulting
  5.  *
  6.  *  File: Demo.c
  7.  *
  8.  *----------------------------------------------------------------------------*/
  9.  
  10. #include <windows.h>
  11. #include <commdlg.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include "demo.h"
  17. #include "cktbl.h"
  18.  
  19. HANDLE hInst;
  20. HANDLE hAccTable;          /*handle to accelerator table */
  21. HWND hTblWnd;              /* handle to table control */
  22. HWND hMainWnd;             /* handle to main window */
  23.  
  24.  
  25. CHOOSECOLOR    CC_Foreground;
  26. CHOOSECOLOR    CC_Background;
  27. COLORREF CC_Custom[16];
  28.  
  29. #define APPLICATION_NAME            "CKTBL16.DLL - Demo"
  30. #define APPLICATION_MENU            "MainMenu"
  31. #define APPLICATION_ACCELERATORS    "MainMenuAcc"
  32. #define APPLICATION_CLASS            "CKDemoWindow"
  33.  
  34. #define SIZEX 20
  35. #define SIZEY 200
  36.  
  37. #define LINESTYLE_MASK (CKTBL_SINGLELINE|CKTBL_SINGLELINE_BOTTOM|CKTBL_MULTILINE|CKTBL_MULTILINEBREAK)
  38.  
  39. /*------------------------------------------------------------------------------
  40. ------------------------------------------------------------------------------*/
  41. void InitChooseColor( CHOOSECOLOR * cc )
  42. {
  43.     COLORREF clr;
  44.     int i;
  45.  
  46.     for (i = 0; i < 16; i++) CC_Custom[i] = RGB(255, 255, 255);
  47.  
  48.     /* Initialize clr to black. */
  49.  
  50.     clr = RGB(0, 0, 0);
  51.  
  52.     /* Set all structure fields to zero. */
  53.  
  54.     memset(cc, 0, sizeof(CHOOSECOLOR));
  55.  
  56.     /* Initialize the necessary CHOOSECOLOR members. */
  57.  
  58.     cc->lStructSize = sizeof(CHOOSECOLOR);
  59.     cc->hwndOwner = hMainWnd;
  60.     cc->rgbResult = clr;
  61.  
  62.     cc->lpCustColors = CC_Custom;
  63.     cc->Flags = 0;
  64. }
  65.  
  66. /*------------------------------------------------------------------------------
  67. ------------------------------------------------------------------------------*/
  68. void DoInsertError()
  69. {
  70.     MessageBox( hMainWnd, "Please select exactly one row or column", APPLICATION_NAME, MB_OK );
  71. }
  72.  
  73.  
  74. void DoInsertRowColBeforeOrAfter( HWND hWnd, BOOL before )
  75. {
  76.     RECT    rect;
  77.     int        nSel;
  78.  
  79.     nSel = CKTBLGetSelectionSize( hWnd );
  80.     if(nSel!=1) {
  81.         DoInsertError();
  82.         return;
  83.     }
  84.     CKTBLGetSelection( hWnd, &rect, 1 );
  85.  
  86.     if(rect.left==0 && rect.top>0 ) {
  87.         if(rect.top==rect.bottom) {
  88.             if(before) rect.top--;
  89.             CKTBLInsertRowsAfter( hWnd, rect.top , 1);
  90.             return;
  91.         }
  92.     }
  93.  
  94.     if(rect.top==0 && rect.left>0 ) {
  95.         if(rect.left==rect.right) {
  96.             if(before) rect.left--;
  97.             CKTBLInsertColumnsAfter( hWnd, rect.left , 1);
  98.             return;
  99.         }
  100.     }
  101.  
  102.     DoInsertError();
  103. }
  104.  
  105. /*------------------------------------------------------------------------------
  106. ------------------------------------------------------------------------------*/
  107.  
  108. void DoDeleteError()
  109. {
  110.     MessageBox( hMainWnd, "Please select either rows or columns", APPLICATION_NAME, MB_OK );
  111. }
  112.  
  113.  
  114. void DoDeleteRowCol( HWND hWnd )
  115. {
  116.     BOOL    rows,columns;
  117.     RECT    rect;
  118.     int        nSel;
  119.  
  120.     nSel = CKTBLGetSelectionSize( hWnd );
  121.     if(nSel!=1) {
  122.         DoDeleteError();
  123.         return;
  124.     }
  125.  
  126.     /* check that we have either rows or columns */
  127.  
  128.     rows=columns=FALSE;
  129.     CKTBLGetSelection( hWnd, &rect, 1 );
  130.     if((rect.left==0 && rect.top==0)||(rect.left!=0 && rect.top!=0)) {
  131.         DoDeleteError();
  132.         return;
  133.     }
  134.     if(rect.left==0) rows=TRUE;
  135.     if(rect.top==0) columns=TRUE;
  136.     if(rows&&columns) {
  137.         DoDeleteError();
  138.         return;
  139.     }
  140.  
  141.     /* delete selected rows or columns */
  142.  
  143.     if(rows)     CKTBLRemoveRows( hWnd, rect.top , rect.bottom );
  144.     if(columns) CKTBLRemoveColumns( hWnd, rect.left ,rect.right );
  145. }
  146.  
  147. /*------------------------------------------------------------------------------
  148. ------------------------------------------------------------------------------*/
  149. void DoSetSelectionForeColor( HWND hWnd )
  150. {
  151.     CKTBL_ATTRIB   attrib;
  152.  
  153.     memset( &attrib, 0, sizeof(CKTBL_ATTRIB));
  154.  
  155.     if(!ChooseColor(&CC_Foreground)) return;
  156.     attrib.foreColor = CC_Foreground.rgbResult;
  157.  
  158.     CKTBLEndEdit( hWnd, TRUE );
  159.     CKTBLModifySelAttr( hWnd, &attrib, CKTBL_ATTR_FORECOLOR, 0 );
  160. }
  161.  
  162.  
  163. /*------------------------------------------------------------------------------
  164. ------------------------------------------------------------------------------*/
  165. void DoSetSelectionBackColor( HWND hWnd )
  166. {
  167.     CKTBL_ATTRIB   attrib;
  168.  
  169.     memset( &attrib, 0, sizeof(CKTBL_ATTRIB));
  170.  
  171.     if(!ChooseColor(&CC_Background)) return;
  172.     attrib.backColor = CC_Background.rgbResult;
  173.  
  174.     CKTBLEndEdit( hWnd, TRUE );
  175.     CKTBLModifySelAttr( hWnd, &attrib, CKTBL_ATTR_BACKCOLOR, 0 );
  176. }
  177.  
  178. /*------------------------------------------------------------------------------
  179.  * the most part of this function is spent filling out the CHOOSEFONT and
  180.  * associated LOGFONT structures so that we have a default font in the
  181.  * CommonDialog Box
  182.  *----------------------------------------------------------------------------*/
  183. void DoSetSelectionFont( HWND hWnd )
  184. {
  185.     CKTBL_ATTRIB    attrib;
  186.     RECT            rect;
  187.     LOGFONT         lf;
  188.     CHOOSEFONT         cf;
  189.     int                logpixelSY;
  190.     HDC                hDC;
  191.  
  192.     /* Set all structure fields to zero. */
  193.  
  194.     memset(&attrib, 0, sizeof(CKTBL_ATTRIB));
  195.     memset(&cf, 0, sizeof(CHOOSEFONT));
  196.     memset(&lf, 0, sizeof(LOGFONT));
  197.  
  198.     /* get default from left top cell in first rectangle of selection */
  199.  
  200.     CKTBLGetSelection( hWnd, &rect, 1 );
  201.     CKTBLGetAttr( hTblWnd, max(rect.top,1) , max(rect.left,1), &attrib );
  202.  
  203.  
  204.     /* set defaults */
  205.  
  206.     cf.lStructSize = sizeof(CHOOSEFONT);
  207.     cf.hwndOwner = hMainWnd;
  208.     cf.lpLogFont = &lf;
  209.     cf.Flags = CF_SCREENFONTS | CF_EFFECTS | CF_INITTOLOGFONTSTRUCT;
  210.     cf.rgbColors = attrib.foreColor;
  211.     cf.nFontType = SCREEN_FONTTYPE;
  212.     // cf.iPointSize = attrib.fontSize; // this is not used by ChooseFont()
  213.  
  214.     // default size is cumbersome beacause LOGFONT does not have a field for
  215.     // the size in points
  216.  
  217.     hDC = GetDC( hTblWnd );            // quick hack to get logpixelSY
  218.     logpixelSY = GetDeviceCaps( hDC, LOGPIXELSY );
  219.     ReleaseDC( hTblWnd, hDC );
  220.  
  221.     lf.lfHeight = - (int)((long)attrib.fontSize * logpixelSY / 720 );
  222.     lf.lfWidth  = 0;
  223.  
  224.     // rest is easy
  225.  
  226.     lf.lfWeight = (attrib.fontBold)?FW_BOLD:FW_NORMAL;         // why not a boolean ? :-)
  227.     lf.lfItalic = attrib.fontItalic;                        // why not an angle ? :-)
  228.     lf.lfUnderline = attrib.fontUnderline;
  229.     lf.lfStrikeOut = attrib.fontStrikeOut;
  230.     lf.lfOutPrecision    = OUT_DEFAULT_PRECIS;
  231.     lf.lfClipPrecision     = CLIP_DEFAULT_PRECIS;
  232.     lf.lfQuality         = PROOF_QUALITY;
  233.     lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
  234.  
  235.     strncpy( lf.lfFaceName, attrib.fontName, LF_FACESIZE );
  236.  
  237.     /* choose font */
  238.  
  239.     if(!ChooseFont(&cf)) return;
  240.     
  241.     /* create attrib from LOGFONT */
  242.  
  243.     attrib.fontName = lf.lfFaceName;
  244.     attrib.fontSize = cf.iPointSize;              // logfont does not have the size in points
  245.     attrib.fontBold = lf.lfWeight==FW_BOLD;
  246.     attrib.fontItalic = lf.lfItalic;
  247.     attrib.fontUnderline = lf.lfUnderline;
  248.     attrib.fontStrikeOut = lf.lfStrikeOut;
  249.     attrib.foreColor = cf.rgbColors;
  250.  
  251.     CKTBLEndEdit( hWnd, TRUE );
  252.     CKTBLModifySelAttr( hWnd, &attrib, CKTBL_ATTR_FONT|CKTBL_ATTR_FORECOLOR, 0 );
  253. }
  254.  
  255. /*------------------------------------------------------------------------------
  256. ------------------------------------------------------------------------------*/
  257.  
  258. BOOL InitApplication(hInstance)
  259. HANDLE hInstance;
  260. {
  261.     WNDCLASS  wc;
  262.  
  263.     wc.style = NULL;
  264.     wc.lpfnWndProc = MainWndProc;
  265.     wc.cbClsExtra = 0;
  266.     wc.cbWndExtra = 0;
  267.     wc.hInstance = hInstance;
  268.     wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(APPLICATION_ICON));
  269.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  270.     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
  271.     wc.lpszMenuName =  APPLICATION_MENU;
  272.     wc.lpszClassName = APPLICATION_CLASS;
  273.  
  274.     return (RegisterClass(&wc));
  275. }
  276.  
  277.  
  278. /*------------------------------------------------------------------------------
  279. ------------------------------------------------------------------------------*/
  280.  
  281. BOOL InitInstance(hInstance, nCmdShow )
  282. HANDLE  hInstance;
  283. int     nCmdShow;
  284. {
  285.     CKTBL_CREATE     cktbl;
  286.     RECT             rect;
  287.  
  288.  
  289.     hInst = hInstance;
  290.  
  291.     hAccTable = LoadAccelerators(hInst, APPLICATION_ACCELERATORS);
  292.  
  293.     hMainWnd = CreateWindow(
  294.           APPLICATION_CLASS,
  295.           APPLICATION_NAME,
  296.           WS_OVERLAPPEDWINDOW,
  297.           32,32,600,300,
  298.           NULL,
  299.           NULL,
  300.           hInstance,
  301.           NULL
  302.      );
  303.  
  304.      if (!hMainWnd) return (FALSE);
  305.  
  306.      GetClientRect(hMainWnd, (LPRECT) &rect);
  307.  
  308.      /* Create CKTBL window */
  309.  
  310.      memset( &cktbl, 0, sizeof(cktbl));
  311.      cktbl.flags = CKTBL_DEFAULT_FLAGS
  312.         |CKTBL_RESIZE_ROWS|CKTBL_RESIZE_COLUMNS
  313.         |CKTBL_EDIT_ROW_LABELS|CKTBL_EDIT_COLUMN_LABELS;
  314.  
  315.      cktbl.rows = 32;
  316.      cktbl.columns = 8;
  317.  
  318.      hTblWnd = CreateWindow(CKTBL_CLASS,
  319.           NULL,
  320.           WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL,
  321.           0,
  322.           0,
  323.           (rect.right-rect.left),
  324.           (rect.bottom-rect.top),
  325.           hMainWnd,
  326.           0,
  327.           hInst,
  328.           &cktbl);
  329.  
  330.     if (!hTblWnd) {
  331.         DestroyWindow(hMainWnd);
  332.         return (NULL);
  333.     }
  334.  
  335.     CKTBLSetColumnWidth( hTblWnd, 4, 180 );
  336.  
  337.     ShowWindow(hMainWnd, nCmdShow);
  338.     UpdateWindow(hMainWnd);
  339.  
  340.     return (TRUE);
  341.  
  342. }
  343.  
  344. /*------------------------------------------------------------------------------
  345. ------------------------------------------------------------------------------*/
  346.  
  347. CKTBL_ATTRIB FontAttribute;
  348.  
  349. void InitMenuFonts( HMENU hMenu )
  350. {
  351.     CKTBL_ATTRIB     attrib;
  352.     RECT             rect;
  353.     int                nSel;
  354.  
  355.     memset(&attrib, 0, sizeof(CKTBL_ATTRIB));
  356.  
  357.     nSel = CKTBLGetSelectionSize( hTblWnd );
  358.     if(nSel==0) {
  359.         rect.left = rect.right = CKTBLGetCurrentColumn( hTblWnd );
  360.         rect.top = rect.bottom = CKTBLGetCurrentRow( hTblWnd );
  361.     } else {
  362.         CKTBLGetSelection( hTblWnd, &rect, 1 );
  363.     }
  364.  
  365.     CKTBLGetAttr( hTblWnd, max(rect.top,1) , max(rect.left,1), &attrib );
  366.  
  367.     FontAttribute = attrib;
  368.  
  369.     CheckMenuItem( hMenu, IDM_FONTBOLD,     MF_BYCOMMAND | (attrib.fontBold ? MF_CHECKED : MF_UNCHECKED));
  370.     CheckMenuItem( hMenu, IDM_FONTITALIC,     MF_BYCOMMAND | (attrib.fontItalic ? MF_CHECKED : MF_UNCHECKED));
  371.     CheckMenuItem( hMenu, IDM_FONTUNDERLINE,MF_BYCOMMAND | (attrib.fontUnderline ? MF_CHECKED : MF_UNCHECKED));
  372. }
  373.  
  374. /*------------------------------------------------------------------------------
  375.  *----------------------------------------------------------------------------*/
  376.  
  377. void InitMenuFormats( HMENU hMenu )
  378. {
  379.     CKTBL_ATTRIB     attrib;
  380.     int                row, col;
  381.     BOOL            b1,b2,b3,b4;
  382.  
  383.     memset(&attrib, 0, sizeof(CKTBL_ATTRIB));
  384.  
  385.     // get attribute of current cell
  386.  
  387.     col = CKTBLGetCurrentColumn( hTblWnd );
  388.     row = CKTBLGetCurrentRow( hTblWnd );
  389.     CKTBLGetAttr( hTblWnd, max(row,1) , max(col,1), &attrib );
  390.  
  391.     // check menu items according to attribute
  392.  
  393.     b1 = (attrib.format & CKTBL_MASK_HALIGN) == CKTBL_FMT_LEFT;
  394.     b2 = (attrib.format & CKTBL_MASK_HALIGN) == CKTBL_FMT_RIGHT;
  395.     b3 = (attrib.format & CKTBL_MASK_HALIGN) == CKTBL_FMT_CENTER;
  396.     
  397.     CheckMenuItem( hMenu, IDM_FORMATLEFT,  MF_BYCOMMAND | (b1 ? MF_CHECKED : MF_UNCHECKED));
  398.     CheckMenuItem( hMenu, IDM_FORMATRIGHT, MF_BYCOMMAND | (b2 ? MF_CHECKED : MF_UNCHECKED));
  399.     CheckMenuItem( hMenu, IDM_FORMATCENTER,MF_BYCOMMAND | (b3 ? MF_CHECKED : MF_UNCHECKED));
  400.  
  401.     b1 = (attrib.format & LINESTYLE_MASK)==CKTBL_SINGLELINE;
  402.     b2 = (attrib.format & LINESTYLE_MASK)==CKTBL_SINGLELINE_BOTTOM;
  403.     b3 = (attrib.format & LINESTYLE_MASK)==CKTBL_MULTILINE;
  404.     b4 = (attrib.format & LINESTYLE_MASK)==CKTBL_MULTILINEBREAK;
  405.  
  406.     CheckMenuItem( hMenu, IDM_FORMATSINGLELINE,            MF_BYCOMMAND | (b1? MF_CHECKED : MF_UNCHECKED));
  407.     CheckMenuItem( hMenu, IDM_FORMATSINGLELINE_BOTTOM,    MF_BYCOMMAND | (b2? MF_CHECKED : MF_UNCHECKED));
  408.     CheckMenuItem( hMenu, IDM_FORMATMULTILINE,             MF_BYCOMMAND | (b3? MF_CHECKED : MF_UNCHECKED));
  409.     CheckMenuItem( hMenu, IDM_FORMATMULTILINE_BREAK,     MF_BYCOMMAND | (b4? MF_CHECKED : MF_UNCHECKED));
  410.  
  411. }
  412.  
  413. /*------------------------------------------------------------------------------
  414. ------------------------------------------------------------------------------*/
  415. void DoFileNew( HWND hWnd )
  416. {
  417.     CKTBLClear( hWnd );
  418.     CKTBLSetSize( hWnd, SIZEY, SIZEX );
  419.     InvalidateRect( hWnd, NULL, FALSE );
  420. }
  421.  
  422. /*------------------------------------------------------------------------------
  423. ------------------------------------------------------------------------------*/
  424.  
  425. #define MAX_SIZEY    16000
  426. #define LINESIZE    512
  427.  
  428. void InitTable( HWND hWnd, char * fileName )
  429. {
  430.     FILE     * f;
  431.     int       row, col, maxCol = 8;
  432.     char    line[LINESIZE+1];
  433.     char    *s1, *s2;
  434.  
  435.  
  436.     f = fopen( fileName, "r" );
  437.     if(!f) return;
  438.  
  439.     row = 0;
  440.  
  441.     CKTBLClear( hWnd );
  442.  
  443.     while( row<=MAX_SIZEY && !feof(f) ) {
  444.         line[0]=0;
  445.         fgets( line, LINESIZE, f );
  446.         line[LINESIZE] = 0;
  447.  
  448.         s1 = line;
  449.         col = 1;
  450.         while( *s1 ) {
  451.             s2 = s1;
  452.             while( *s2 && *s2!='\t' && *s2!='\n' ) s2++;
  453.             // if(*s2=='\n') *s2=0;
  454.             if(*s2) *s2++=0;
  455.  
  456.             CKTBLSetText( hWnd, row, col, s1 );
  457.             s1 = s2;
  458.             col++;
  459.         }
  460.         maxCol = max( maxCol, col-1 );
  461.  
  462.         row++;
  463.     }
  464.     row = max( row-1, 8 );
  465.     CKTBLSetSize( hWnd, row, maxCol );
  466.     fclose(f);
  467. }
  468.  
  469. /*------------------------------------------------------------------------------
  470. ------------------------------------------------------------------------------*/
  471.  
  472. void DoFileOpen( HWND hWnd )
  473. {
  474.     OPENFILENAME     ofn;
  475.     char             szFile[256], szFileTitle[256], szFilter[256];
  476.     UINT              i;
  477.     char              chReplace;    /* string separator for szFilter */
  478.  
  479.     /* Get the system directory name, and store in szDirName */
  480.  
  481.     szFile[0] = '\0';  
  482.     szFileTitle[0] = '\0';  
  483.     
  484.     strcpy( szFilter, "Text Files(*.TXT)!*.txt!All files(*.*)!*.*!" );
  485.     chReplace = '!';
  486.        for (i = 0; szFilter[i] != '\0'; i++) {
  487.         if (szFilter[i] == chReplace)
  488.            szFilter[i] = '\0';
  489.     }
  490.  
  491.     /* Set all structure members to zero. */
  492.  
  493.     memset(&ofn, 0, sizeof(OPENFILENAME));
  494.  
  495.     ofn.lStructSize = sizeof(OPENFILENAME);
  496.     ofn.hwndOwner = hMainWnd;
  497.     ofn.lpstrFilter = szFilter;
  498.     ofn.nFilterIndex = 1;
  499.     ofn.lpstrFile= szFile;
  500.     ofn.nMaxFile = sizeof(szFile);
  501.     ofn.lpstrFileTitle = szFileTitle;
  502.     ofn.nMaxFileTitle = sizeof(szFileTitle);
  503.     ofn.lpstrInitialDir = NULL;
  504.     ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
  505.  
  506.     if (GetOpenFileName(&ofn)) {
  507.         InitTable( hWnd, ofn.lpstrFile );
  508.         InvalidateRect( hWnd, NULL, FALSE );
  509.     }
  510. }
  511.  
  512. /*------------------------------------------------------------------------------
  513. ------------------------------------------------------------------------------*/
  514.  
  515. void DoFileSaveAs( HWND hWnd )
  516. {
  517.     OPENFILENAME     ofn;
  518.     char             szFile[256], szFileTitle[256];
  519.     UINT              i;
  520.     char              chReplace;    /* string separator for szFilter */
  521.     char              * szFilter;
  522.  
  523.     MessageBox( hMainWnd, "SaveAs not yet implemented !", "", MB_OK );
  524.     return;
  525.  
  526.     /* Get the system directory name, and store in szDirName */
  527.  
  528.     szFile[0] = '\0';
  529.     szFilter = "Text Files(*.TXT)!*.txt!All files(*.*)!*.*!";
  530.     chReplace = '!';
  531.  
  532.     for (i = 0; szFilter[i] != '\0'; i++) {
  533.         if (szFilter[i] == chReplace)
  534.             szFilter[i] = '\0';
  535.     }
  536.  
  537.     /* Set all structure members to zero. */
  538.  
  539.     memset(&ofn, 0, sizeof(OPENFILENAME));
  540.  
  541.     ofn.lStructSize = sizeof(OPENFILENAME);
  542.     ofn.hwndOwner = hMainWnd;
  543.     ofn.lpstrFilter = szFilter;
  544.     ofn.nFilterIndex = 1;
  545.     ofn.lpstrFile= szFile;
  546.     ofn.nMaxFile = sizeof(szFile);
  547.     ofn.lpstrFileTitle = szFileTitle;
  548.     ofn.nMaxFileTitle = sizeof(szFileTitle);
  549.     ofn.lpstrInitialDir = NULL;
  550.     ofn.Flags = OFN_PATHMUSTEXIST;
  551.  
  552.     if (GetSaveFileName(&ofn)) {
  553.         /*
  554.         InitTable( hWnd, ofn.lpstrFile );
  555.         InvalidateRect( hWnd, NULL, FALSE );
  556.         */
  557.     }
  558. }
  559.  
  560.  
  561.  
  562. /*------------------------------------------------------------------------------
  563. ------------------------------------------------------------------------------*/
  564.  
  565. BOOL FAR PASCAL DoAbout(hDlg, message, wParam, lParam)
  566. HWND hDlg;
  567. unsigned message;
  568. WORD wParam;
  569. LONG lParam;
  570. {
  571.     HWND hWnd;
  572.  
  573.     switch (message) {
  574.         case WM_INITDIALOG:
  575.             hWnd = GetDlgItem( hDlg, IDC_1 );
  576.             CKTBLSetSize( hWnd, 16, 16 );
  577.             CKTBLSetFlags( hWnd, CKTBL_DEFAULT_FLAGS );
  578.             CKTBLSetRowHeight( hWnd, 0, 20 );
  579.             CKTBLSetColumnWidth( hWnd, 0, 40 );
  580.             return (TRUE);
  581.  
  582.         case WM_COMMAND:
  583.             if (wParam == IDOK || wParam == IDCANCEL) {
  584.                  EndDialog(hDlg, TRUE);
  585.                  return (TRUE);
  586.             }
  587.             break;
  588.     }
  589.     return (FALSE);
  590. }
  591.  
  592.  
  593. /*------------------------------------------------------------------------------
  594.     DoCommand() handles the menu commands
  595. ------------------------------------------------------------------------------*/
  596.  
  597. LRESULT DoCommand( HWND hWnd, WPARAM wParam, LPARAM lParam )
  598. {
  599.     FARPROC         lpProcAbout;
  600.     LRESULT         result = 0;
  601.     CKTBL_ATTRIB    attrib;
  602.  
  603.     memset(&attrib, 0, sizeof(CKTBL_ATTRIB));
  604.  
  605.     switch (wParam) {
  606.  
  607.         /* file menu */
  608.  
  609.         case IDM_FILENEW:
  610.             DoFileNew( hTblWnd );
  611.             break;
  612.  
  613.         case IDM_FILEOPEN:
  614.             DoFileOpen( hTblWnd );
  615.             break;
  616.  
  617.         case IDM_FILESAVEAS:
  618.             DoFileSaveAs( hTblWnd );
  619.             break;
  620.  
  621.         case IDM_FILEABOUT:
  622.             lpProcAbout = MakeProcInstance(DoAbout, hInst);
  623.             DialogBox(hInst, "AboutBox", hWnd, lpProcAbout);
  624.             FreeProcInstance(lpProcAbout);
  625.             break;
  626.  
  627.         case IDM_FILEEXIT:
  628.             DestroyWindow(hWnd);
  629.             break;
  630.  
  631.         /* edit menu */
  632.  
  633.         case IDM_EDITINSERTBEFORE:
  634.             DoInsertRowColBeforeOrAfter( hTblWnd, TRUE );
  635.             break;
  636.  
  637.         case IDM_EDITINSERTAFTER:
  638.             DoInsertRowColBeforeOrAfter( hTblWnd, FALSE );
  639.             break;
  640.  
  641.         case IDM_EDITDELETE:
  642.             DoDeleteRowCol( hTblWnd );
  643.             break;
  644.  
  645.         /* color menu */
  646.  
  647.         case IDM_COLORFG:
  648.             DoSetSelectionForeColor( hTblWnd );
  649.             break;
  650.  
  651.         case IDM_COLORBG:
  652.             DoSetSelectionBackColor( hTblWnd );
  653.             break;
  654.  
  655.         /* font menu */
  656.  
  657.         case IDM_FONTCHOOSE:
  658.             DoSetSelectionFont( hTblWnd );
  659.             break;
  660.  
  661.         case IDM_FONTBOLD:
  662.             CKTBLEndEdit( hTblWnd, TRUE );
  663.             attrib.fontBold = ! FontAttribute.fontBold;
  664.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FONTBOLD, 0  );
  665.             break;
  666.  
  667.         case IDM_FONTITALIC:
  668.             CKTBLEndEdit( hTblWnd, TRUE );
  669.             attrib.fontItalic = ! FontAttribute.fontItalic;
  670.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FONTITALIC, 0 );
  671.             break;
  672.  
  673.         case IDM_FONTUNDERLINE:
  674.             CKTBLEndEdit( hTblWnd, TRUE );
  675.             attrib.fontUnderline = ! FontAttribute.fontUnderline;
  676.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FONTUNDERLINE, 0 );
  677.             break;
  678.  
  679.         /* format menu */
  680.  
  681.         case IDM_FORMATLEFT:
  682.             CKTBLEndEdit( hTblWnd, TRUE );
  683.             attrib.format = CKTBL_FMT_LEFT;
  684.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, CKTBL_MASK_HALIGN );
  685.             break;
  686.  
  687.         case IDM_FORMATRIGHT:
  688.             CKTBLEndEdit( hTblWnd, TRUE );
  689.             attrib.format = CKTBL_FMT_RIGHT;
  690.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, CKTBL_MASK_HALIGN );
  691.             break;
  692.  
  693.         case IDM_FORMATCENTER:
  694.             CKTBLEndEdit( hTblWnd, TRUE );
  695.             attrib.format = CKTBL_FMT_CENTER;
  696.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, CKTBL_MASK_HALIGN );
  697.             break;
  698.  
  699.         case IDM_FORMATSINGLELINE:
  700.             CKTBLEndEdit( hTblWnd, TRUE );
  701.             attrib.format = CKTBL_SINGLELINE;
  702.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, LINESTYLE_MASK);
  703.             break;
  704.  
  705.         case IDM_FORMATSINGLELINE_BOTTOM:
  706.             CKTBLEndEdit( hTblWnd, TRUE );
  707.             attrib.format = CKTBL_SINGLELINE_BOTTOM;
  708.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, LINESTYLE_MASK);
  709.             break;
  710.  
  711.         case IDM_FORMATMULTILINE:
  712.             CKTBLEndEdit( hTblWnd, TRUE );
  713.             attrib.format = CKTBL_MULTILINE;
  714.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, LINESTYLE_MASK);
  715.             break;
  716.  
  717.         case IDM_FORMATMULTILINE_BREAK:
  718.             CKTBLEndEdit( hTblWnd, TRUE );
  719.             attrib.format = CKTBL_MULTILINEBREAK;
  720.             CKTBLModifySelAttr( hTblWnd, &attrib, CKTBL_ATTR_FORMAT, LINESTYLE_MASK);
  721.             break;
  722.  
  723.     }
  724.     return result;
  725. }
  726.  
  727.  
  728. /*------------------------------------------------------------------------------
  729. ------------------------------------------------------------------------------*/
  730.  
  731.  
  732. long FAR PASCAL MainWndProc(HWND hWnd, unsigned message, WPARAM wParam, LPARAM lParam)
  733. {
  734.     LRESULT         result;
  735.  
  736.     switch (message) {
  737.             case WM_COMMAND:
  738.                 result = DoCommand(hWnd, wParam, lParam );
  739.                 break;
  740.  
  741.             case WM_SIZE:
  742.                 MoveWindow(hTblWnd, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);                break;
  743.  
  744.             case WM_SETFOCUS:
  745.                 PostMessage( hTblWnd, message, wParam, lParam );
  746.                 break;
  747.  
  748.             case WM_DESTROY:
  749.                 PostQuitMessage(0);
  750.                 break;
  751.  
  752.             case WM_INITMENUPOPUP:
  753.                 switch( LOWORD(lParam) ) {
  754.                     case 0 : break;                        /* File menu */
  755.                     case 1 : break;                         /* Edit menu */
  756.                     case 2 : break;                     /* Table menu */
  757.                     case 3 : InitMenuFonts( wParam ); break;
  758.                     case 4 : InitMenuFormats( wParam ); break;
  759.                 }
  760.                 break;
  761.  
  762.           default:
  763.             return (DefWindowProc(hWnd, message, wParam, lParam));
  764.     }
  765.     return result;
  766. }
  767. /*------------------------------------------------------------------------------
  768. ------------------------------------------------------------------------------*/
  769.  
  770. int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
  771. HANDLE hInstance;
  772. HANDLE hPrevInstance;
  773. LPSTR lpCmdLine;
  774. int nCmdShow;
  775. {
  776.     MSG msg;
  777.  
  778.     if (!hPrevInstance)
  779.         if (!InitApplication(hInstance))
  780.             return (FALSE);
  781.  
  782. #ifdef CKTBL_LIBRARY
  783.     if(!CKTBLInitLib(hInstance)) {
  784. #if 0
  785.         MessageBox( NULL, "Error initializing CKTBL", "error", MB_OK );
  786.         return FALSE;
  787. #endif
  788.     }
  789. #endif
  790.  
  791.     if(*lpCmdLine==0) lpCmdLine=NULL;
  792.  
  793.     if (!InitInstance(hInstance, nCmdShow))
  794.         return (FALSE);
  795.  
  796.     InitChooseColor( &CC_Foreground );
  797.     InitChooseColor( &CC_Background );
  798.     InvalidateRect( hTblWnd, NULL, FALSE );
  799.     InitTable( hTblWnd, lpCmdLine ? lpCmdLine : "a.txt"  );
  800.  
  801.     while (GetMessage(&msg, NULL, NULL, NULL)) {
  802.         /* Only translate message if it is not an accelerator message */
  803.  
  804.         if (!TranslateAccelerator(hMainWnd, hAccTable, &msg)) {
  805.             TranslateMessage(&msg);
  806.             DispatchMessage(&msg);
  807.         }
  808.      }
  809.  
  810. #ifdef CKTBL_LIBRARY
  811.     CKTBLExitLib();
  812. #endif
  813.  
  814.     return (msg.wParam);
  815. }
  816.  
  817. /*--end--*/
  818.