Return to uniput.c CVS log

Up to [WindowsNT SDKs] / q_a / samples / uniput

Annotation of q_a/samples/uniput/uniput.c, revision 1.1

1.1     ! root        1: 
        !             2: /******************************************************************************\
        !             3: *       This is a part of the Microsoft Source Code Samples. 
        !             4: *       Copyright (C) 1993 Microsoft Corporation.
        !             5: *       All rights reserved. 
        !             6: *       This source code is only intended as a supplement to 
        !             7: *       Microsoft Development Tools and/or WinHelp documentation.
        !             8: *       See these sources for detailed information regarding the 
        !             9: *       Microsoft samples programs.
        !            10: \******************************************************************************/
        !            11: 
        !            12: /**************************************************************************\
        !            13: * uniput.c -- input of unicode characters.
        !            14: \**************************************************************************/
        !            15: #define UNICODE
        !            16: 
        !            17: #include <windows.h>
        !            18: #include <commdlg.h>
        !            19: #include "uniput.h"
        !            20: 
        !            21: 
        !            22: /* Misc. defines for size, color, and appearance of drawing. */
        !            23: #define GRIDCOLOR  PALETTEINDEX (6)
        !            24: #define TICKSPACE  20
        !            25: #define FWW_STEPS  40
        !            26: 
        !            27: 
        !            28: HANDLE hFile = INVALID_HANDLE_VALUE;
        !            29: 
        !            30: HANDLE OpenNewFile(HWND);
        !            31: 
        !            32: 
        !            33: TCHAR szHelpPathName[] = TEXT("uniput.HLP");
        !            34: 
        !            35: HANDLE hInst;
        !            36: HWND   hwndMain;
        !            37: HWND   hwndClient;
        !            38: HWND   hwndStatus;
        !            39: 
        !            40: int gShowhex, gShowNames;
        !            41: 
        !            42: #define STATUSHEIGHT (UCFONTHEIGHT/2 + 3*SBORDER)
        !            43: 
        !            44: 
        !            45: /**************************************************************************\
        !            46: *
        !            47: *  function:  WinMain()
        !            48: *
        !            49: *  input parameters:  c.f. generic sample
        !            50: *
        !            51: \**************************************************************************/
        !            52: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
        !            53:                      LPSTR lpCmdLine, int nCmdShow)
        !            54: {
        !            55:     MSG    msg;
        !            56:     CLIENTCREATESTRUCT clientcreate;
        !            57:     WNDCLASS  wc;
        !            58: 
        !            59: 
        !            60:     UNREFERENCED_PARAMETER( lpCmdLine );
        !            61:     UNREFERENCED_PARAMETER(  nCmdShow );
        !            62:     hInst = hInstance;
        !            63: 
        !            64: 
        !            65:     /* Check for previous instance.  If none, then register class. */
        !            66:     if (!hPrevInstance) {
        !            67: 
        !            68:       wc.style = 0;
        !            69:       wc.lpfnWndProc = (WNDPROC)MainWndProc;
        !            70: 
        !            71:       wc.cbClsExtra = 0;
        !            72:       wc.cbWndExtra = 0;
        !            73:       wc.hInstance = hInstance;
        !            74:       wc.hIcon = LoadIcon(hInstance, TEXT("uniputIcon"));
        !            75:       wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        !            76:       wc.hbrBackground = NULL;
        !            77:       wc.lpszMenuName =  TEXT("uniputMenu");
        !            78:       wc.lpszClassName = TEXT("uniput");
        !            79: 
        !            80:       if (!RegisterClass(&wc)) return (FALSE);
        !            81: 
        !            82:     }  /* class registered o.k. */
        !            83: 
        !            84: 
        !            85:     /* Create the main window.  Return false if CreateWindow() fails */
        !            86:     hwndMain = CreateWindow(
        !            87:         TEXT("uniput"),
        !            88:         TEXT("Input unicode characters"),
        !            89:         WS_OVERLAPPEDWINDOW,
        !            90:         CW_USEDEFAULT,
        !            91:         CW_USEDEFAULT,
        !            92:         CW_USEDEFAULT,
        !            93:         CW_USEDEFAULT,
        !            94:         NULL, NULL, hInst, NULL);
        !            95: 
        !            96:     if (!hwndMain) return (FALSE);
        !            97: 
        !            98: 
        !            99:     /* create the MDI "client" window. */
        !           100:     clientcreate.hWindowMenu  = GetSubMenu(GetMenu(hwndMain),1);
        !           101:     clientcreate.idFirstChild = 1;
        !           102:     hwndClient = CreateWindow(
        !           103:         TEXT("MDICLIENT"),
        !           104:         NULL,
        !           105:         WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | MDIS_ALLCHILDSTYLES,
        !           106:         0,0,0,0,
        !           107:         hwndMain, NULL, hInst, (LPVOID)&clientcreate);
        !           108:     if (!hwndClient) return (FALSE);
        !           109: 
        !           110: 
        !           111: 
        !           112:     /* create status bar */
        !           113:     wc.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC;
        !           114:     wc.lpfnWndProc = (WNDPROC)StatusWndProc;
        !           115:     wc.cbClsExtra = 0;
        !           116:     wc.cbWndExtra = 0;
        !           117:     wc.hInstance = hInst;
        !           118:     wc.hIcon = NULL;
        !           119:     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        !           120:     wc.hbrBackground = GetStockObject (LTGRAY_BRUSH);
        !           121:     wc.lpszMenuName = NULL;
        !           122:     wc.lpszClassName = TEXT("status");
        !           123:     if (!RegisterClass(&wc)) return (FALSE);
        !           124: 
        !           125:     hwndStatus = CreateWindow(
        !           126:         TEXT("status"),
        !           127:         TEXT("status"),
        !           128:         WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | WS_BORDER,
        !           129:         0,0,
        !           130:         GetSystemMetrics(SM_CXFULLSCREEN),
        !           131:         STATUSHEIGHT,
        !           132:         hwndMain, NULL, hInst, 0);
        !           133:     if (!hwndStatus) return (FALSE);
        !           134: 
        !           135: 
        !           136:     ShowWindow(hwndMain, SW_SHOWDEFAULT);
        !           137:     SetCursor (LoadCursor (NULL, IDC_WAIT));
        !           138: 
        !           139: 
        !           140:     /* Register display window class, and do class initialization. */
        !           141:     if (!openDisplay()) return (FALSE);
        !           142: 
        !           143:     /* set the menus to be correct */
        !           144:     SendMessage (hwndMain, WM_COMMAND, IDM_SHOWHEX,0);
        !           145:     SendMessage (hwndMain, WM_COMMAND, IDM_SHOWNAMES,0);
        !           146: 
        !           147: 
        !           148: 
        !           149:     /* Create one MDI child window to get started */
        !           150:     SendMessage (hwndMain, WM_COMMAND, IDM_NEWWINDOW, 0);
        !           151: 
        !           152:     SetCursor (LoadCursor (NULL, IDC_ARROW));
        !           153: 
        !           154: 
        !           155: 
        !           156:     /* Loop getting messages and dispatching them. */
        !           157:     while (GetMessage(&msg,NULL, 0,0)) {
        !           158:         TranslateMessage(&msg);
        !           159:         DispatchMessage(&msg);
        !           160:     }
        !           161: 
        !           162:     closeDisplay();
        !           163:     return (msg.wParam);
        !           164: }
        !           165: 
        !           166: 
        !           167: 
        !           168: /**************************************************************************\
        !           169: *
        !           170: *  function:  MainWndProc()
        !           171: *
        !           172: *  input parameters:  normal window procedure parameters.
        !           173: *
        !           174: \**************************************************************************/
        !           175: LRESULT CALLBACK MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
        !           176: {
        !           177: HWND hwndActive;
        !           178: 
        !           179:   switch (message) {
        !           180: 
        !           181:     /**********************************************************************\
        !           182:     *  WM_CREATE
        !           183:     \**********************************************************************/
        !           184:     case WM_CREATE: {
        !           185: 
        !           186:     }
        !           187: 
        !           188: 
        !           189:     /**********************************************************************\
        !           190:     *  WM_SIZE
        !           191:     *
        !           192:     * When the frame is sized, then change the size of the MDI client,
        !           193:     *  excluding the status bar, and change the size and position of the
        !           194:     *  status bar.
        !           195:     \**********************************************************************/
        !           196:     case WM_SIZE: {
        !           197: 
        !           198:       RECT r;
        !           199:       GetClientRect (hwnd, &r);
        !           200:       r.bottom -= STATUSHEIGHT;
        !           201: 
        !           202:       SetWindowPos (hwndClient, HWND_BOTTOM,
        !           203:                     r.left, r.top, r.right, r.bottom, 0);
        !           204: 
        !           205:       /* size & position status bar: left, right, & top just out of view */
        !           206:       SetWindowPos (hwndStatus, HWND_TOP,
        !           207:         r.left-1, r.bottom,
        !           208:         r.right+2, STATUSHEIGHT+1, 0);
        !           209: 
        !           210: 
        !           211:       return TRUE;
        !           212: 
        !           213:     } break;
        !           214: 
        !           215: 
        !           216: 
        !           217:     /**********************************************************************\
        !           218:     *  WMU_CHARACTER
        !           219:     *
        !           220:     * global variable: hFile
        !           221:     *
        !           222:     * user message sent to main window when user hits a glyph square.
        !           223:     *  if the main window has a file open, then write this unicode
        !           224:     *  character to that file.
        !           225:     \**********************************************************************/
        !           226:     case WMU_CHARACTER: {
        !           227:         DWORD nBytes;
        !           228:         WCHAR tChar;
        !           229: 
        !           230:       tChar = (WCHAR)lParam;
        !           231: 
        !           232:       /* show it on the status bar */
        !           233:       SendMessage (hwndStatus, WMU_CHARACTER, 0, lParam);
        !           234: 
        !           235:       if (hFile != INVALID_HANDLE_VALUE)
        !           236:         WriteFile (hFile, &tChar, sizeof(WCHAR), &nBytes, NULL);
        !           237: 
        !           238:     } break;
        !           239: 
        !           240: 
        !           241: 
        !           242:     /**********************************************************************\
        !           243:     *  WM_COMMAND
        !           244:     *
        !           245:     \**********************************************************************/
        !           246:     case WM_COMMAND: {
        !           247: 
        !           248:       switch (LOWORD(wParam)) {
        !           249: 
        !           250:         /******************************************************************\
        !           251:         *  WM_COMMAND, IDM_NEWWINDOW
        !           252:         *
        !           253:         * global - hwndClient, hInst
        !           254:         *
        !           255:         * Simply create a new MDI child window.
        !           256:         \******************************************************************/
        !           257:         case IDM_NEWWINDOW: {
        !           258:           HWND hwndDisplay;
        !           259: 
        !           260:           hwndDisplay = CreateMDIWindow(
        !           261:               DISPLAYCLASS,
        !           262:               TEXT("Display"),
        !           263:               WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE |
        !           264:                          WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_HSCROLL,
        !           265:               CW_USEDEFAULT,
        !           266:               CW_USEDEFAULT,
        !           267:               CW_USEDEFAULT,
        !           268:               CW_USEDEFAULT,
        !           269:               hwndClient, hInst, 0);
        !           270:         } break;
        !           271: 
        !           272: 
        !           273:         /******************************************************************\
        !           274:         *  WM_COMMAND, IDM_NEWFILE
        !           275:         *
        !           276:         * global - hFile.
        !           277:         \******************************************************************/
        !           278:         case IDM_NEWFILE: {
        !           279:           DWORD nBytes;
        !           280: 
        !           281:           hFile = OpenNewFile (hwnd);
        !           282:           /* Write the unicode byte order mark */
        !           283:           WriteFile (hFile, "\xFE\xFF", 2, &nBytes, NULL);
        !           284:         } break;
        !           285: 
        !           286: 
        !           287:         /******************************************************************\
        !           288:         *  WM_COMMAND, IDM_CLOSEFILE
        !           289:         *
        !           290:         * global - hFile.
        !           291:         \******************************************************************/
        !           292:         case IDM_CLOSEFILE:
        !           293:           CloseHandle (hFile);
        !           294:           hFile = INVALID_HANDLE_VALUE;
        !           295:           SendMessage (hwndStatus, WMU_SETTARGETNAME, 0, (LPARAM)NULL);
        !           296:         break;
        !           297: 
        !           298: 
        !           299:         case IDM_HELP:
        !           300:           WinHelp( hwnd, szHelpPathName, HELP_INDEX, (DWORD) NULL );
        !           301:         break;
        !           302: 
        !           303: 
        !           304:         case IDM_ABOUT:
        !           305:           DialogBox (hInst, TEXT("aboutBox"), hwnd, (DLGPROC) About);
        !           306:         break;
        !           307: 
        !           308: 
        !           309: 
        !           310:         /******************************************************************\
        !           311:         *  WM_COMMAND, IDM_SHOWHEX
        !           312:         *
        !           313:         * Check menu on and off.  Set global value: gShowHex
        !           314:         \******************************************************************/
        !           315:         case IDM_SHOWHEX:
        !           316:           if (GetMenuState (GetMenu (hwnd),IDM_SHOWHEX, MF_BYCOMMAND)
        !           317:                 == MF_CHECKED) {
        !           318:             CheckMenuItem(GetMenu (hwnd), LOWORD(wParam) , MF_UNCHECKED);
        !           319:             gShowhex = FALSE;
        !           320:             RedrawWindow (hwnd, NULL, NULL, RDW_INVALIDATE |RDW_ALLCHILDREN);
        !           321:           } else {
        !           322:             CheckMenuItem(GetMenu (hwnd), LOWORD(wParam) , MF_CHECKED);
        !           323:             gShowhex = TRUE;
        !           324:             RedrawWindow (hwnd, NULL, NULL, RDW_INVALIDATE |RDW_ALLCHILDREN);
        !           325:           }
        !           326:         break;
        !           327: 
        !           328: 
        !           329:         /******************************************************************\
        !           330:         *  WM_COMMAND, IDM_SHOWNAMES
        !           331:         *
        !           332:         * Check menu on and off.  Set global value: gShowNames
        !           333:         \******************************************************************/
        !           334:         case IDM_SHOWNAMES:
        !           335:           if (GetMenuState (GetMenu (hwnd),IDM_SHOWNAMES, MF_BYCOMMAND)
        !           336:                 == MF_CHECKED) {
        !           337:             CheckMenuItem(GetMenu (hwnd), LOWORD(wParam) , MF_UNCHECKED);
        !           338:             gShowNames = FALSE;
        !           339:           } else {
        !           340:             CheckMenuItem(GetMenu (hwnd), LOWORD(wParam) , MF_CHECKED);
        !           341:             gShowNames = TRUE;
        !           342:           }
        !           343:           // PROBLEM:  Need to send message to all child windows.
        !           344: 
        !           345:           hwndActive = (HWND)SendMessage (hwndClient, WM_MDIGETACTIVE, 0,0);
        !           346:           SendMessage (hwndActive, WMU_NEWRANGE, 0,0);
        !           347:           InvalidateRect (hwndActive, NULL, TRUE);
        !           348: 
        !           349:         break;
        !           350: 
        !           351: 
        !           352:         /******************************************************************\
        !           353:         *  WM_COMMAND, IDM_CHAR*
        !           354:         *
        !           355:         * manage mutually exclusive menu indicating number of chars per line
        !           356:         \******************************************************************/
        !           357:         case IDM_CHAR10:
        !           358:         case IDM_CHAR16:
        !           359:         case IDM_CHAR20:
        !           360:         case IDM_CHAR32:
        !           361:         case IDM_CHAR40:
        !           362:         case IDM_CHAR64:
        !           363: 
        !           364:         { HMENU hMenu;
        !           365:           int nCharPerLine;
        !           366: 
        !           367:           hMenu = GetMenu (hwnd);
        !           368: 
        !           369:           CheckMenuItem(hMenu, IDM_CHAR10, MF_UNCHECKED);
        !           370:           CheckMenuItem(hMenu, IDM_CHAR16, MF_UNCHECKED);
        !           371:           CheckMenuItem(hMenu, IDM_CHAR20, MF_UNCHECKED);
        !           372:           CheckMenuItem(hMenu, IDM_CHAR32, MF_UNCHECKED);
        !           373:           CheckMenuItem(hMenu, IDM_CHAR40, MF_UNCHECKED);
        !           374:           CheckMenuItem(hMenu, IDM_CHAR64, MF_UNCHECKED);
        !           375: 
        !           376:           CheckMenuItem(hMenu, LOWORD(wParam), MF_CHECKED);
        !           377: 
        !           378:           /* notice the value is coded into the menu i.d. */
        !           379:           nCharPerLine = LOWORD(wParam)-IDM_CHARBASE;
        !           380:           hwndActive = (HWND)SendMessage (hwndClient, WM_MDIGETACTIVE, 0,0);
        !           381:           SendMessage (hwndActive, WMU_SETNCHAR, nCharPerLine ,0);
        !           382:           InvalidateRect (hwndActive, NULL, TRUE);
        !           383: 
        !           384:         } break;
        !           385: 
        !           386: 
        !           387: 
        !           388:         /******************************************************************\
        !           389:         *  WM_COMMAND, IDM_FONT*
        !           390:         *
        !           391:         * manage mutually exclusive menu indicating font height
        !           392:         \******************************************************************/
        !           393:         case IDM_FONT18:
        !           394:         case IDM_FONT36:
        !           395:         case IDM_FONT72:
        !           396: 
        !           397:         { HMENU hMenu;
        !           398:           int Width, Height;
        !           399:           hMenu = GetMenu (hwnd);
        !           400: 
        !           401:           CheckMenuItem(hMenu, IDM_FONT18, MF_UNCHECKED);
        !           402:           CheckMenuItem(hMenu, IDM_FONT36, MF_UNCHECKED);
        !           403:           CheckMenuItem(hMenu, IDM_FONT72, MF_UNCHECKED);
        !           404: 
        !           405:           CheckMenuItem(hMenu, LOWORD(wParam), MF_CHECKED);
        !           406: 
        !           407:           /* notice the value is coded into the menu i.d. */
        !           408:           Height = LOWORD(wParam)-IDM_FONTBASE;
        !           409:           /* scale the width proportionately */
        !           410:           Width = Height * UCFONTWIDTH/UCFONTHEIGHT;
        !           411: 
        !           412:           hwndActive = (HWND)SendMessage (hwndClient, WM_MDIGETACTIVE, 0,0);
        !           413:           SendMessage (hwndActive, WMU_NEWFONT, (WPARAM)Width,(LPARAM)Height);
        !           414:           InvalidateRect (hwndActive, NULL, TRUE);
        !           415: 
        !           416:         } break;
        !           417: 
        !           418: 
        !           419: 
        !           420:         /******************************************************************\
        !           421:         *  WM_COMMAND, IDM_MDI*
        !           422:         *
        !           423:         * misc. MDI responsibilities.  hwndClient does real work.
        !           424:         \******************************************************************/
        !           425:         case IDM_MDICASCADE: SendMessage (hwndClient, WM_MDICASCADE, 0,0); break;
        !           426:         case IDM_MDITILE:    SendMessage (hwndClient, WM_MDITILE, MDITILE_HORIZONTAL,0); break;
        !           427:         break;
        !           428: 
        !           429: 
        !           430: 
        !           431: 
        !           432:       } /* end switch */
        !           433:     } break;  /* end WM_COMMAND */
        !           434: 
        !           435: 
        !           436: 
        !           437: 
        !           438: 
        !           439:     /**********************************************************************\
        !           440:     *  WM_DESTROY
        !           441:     \**********************************************************************/
        !           442:     case WM_DESTROY:
        !           443:       WinHelp( hwnd, szHelpPathName, (UINT) HELP_QUIT, (DWORD) NULL );
        !           444:       PostQuitMessage(0);
        !           445:     break;
        !           446: 
        !           447: 
        !           448:   } /* end switch */
        !           449:   return (DefFrameProc(hwnd, hwndClient, message, wParam, lParam));
        !           450: }
        !           451: 
        !           452: 
        !           453: 
        !           454: /***************************************************************************\
        !           455: *    FUNCTION: About
        !           456: \***************************************************************************/
        !           457: LRESULT CALLBACK About(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
        !           458: {
        !           459:   if ((message == WM_COMMAND) && (LOWORD(wParam) == IDOK)) {
        !           460:     EndDialog (hwnd, TRUE);
        !           461:     return TRUE;
        !           462:   }
        !           463:   if ((message == WM_SYSCOMMAND) && (wParam == SC_CLOSE)) {
        !           464:     EndDialog (hwnd, TRUE);
        !           465:     return TRUE;
        !           466:   }
        !           467:   return FALSE;
        !           468: }
        !           469: 
        !           470: 
        !           471: 
        !           472: 
        !           473: 
        !           474: 
        !           475: 
        !           476: /***************************************************************************\
        !           477: *
        !           478: *    FUNCTION: OpenNewFile(HWND)
        !           479: *
        !           480: *    PURPOSE:  Invokes common dialog function to open a file and opens it.
        !           481: *
        !           482: \***************************************************************************/
        !           483: HANDLE OpenNewFile( HWND hwnd )
        !           484: {
        !           485:    TCHAR szFile[MAX_PATH],szFileTitle[MAX_PATH];
        !           486:    OPENFILENAME OpenFileName;
        !           487: 
        !           488: 
        !           489:    wsprintf (szFile, TEXT(""));
        !           490:    wsprintf (szFileTitle, TEXT(""));
        !           491: 
        !           492:    OpenFileName.lStructSize       = sizeof(OPENFILENAME);
        !           493:    OpenFileName.hwndOwner         = hwnd;
        !           494:    OpenFileName.hInstance         = (HANDLE) hInst;
        !           495:    OpenFileName.lpstrFilter       = NULL;
        !           496:    OpenFileName.lpstrCustomFilter = NULL;
        !           497:    OpenFileName.nMaxCustFilter    = 0L;
        !           498:    OpenFileName.nFilterIndex      = 1L;
        !           499:    OpenFileName.lpstrFile         = szFile;
        !           500:    OpenFileName.nMaxFile          = sizeof(szFile);
        !           501:    OpenFileName.lpstrFileTitle    = szFileTitle;
        !           502:    OpenFileName.nMaxFileTitle     = sizeof(szFileTitle);
        !           503:    OpenFileName.lpstrInitialDir   = NULL;
        !           504:    OpenFileName.lpstrTitle        = TEXT("Open a File");
        !           505: 
        !           506:    OpenFileName.nFileOffset       = 0;
        !           507:    OpenFileName.nFileExtension    = 0;
        !           508:    OpenFileName.lpstrDefExt       = NULL;
        !           509: 
        !           510:    OpenFileName.lCustData         = 0;
        !           511: 
        !           512:    OpenFileName.Flags = OFN_HIDEREADONLY;
        !           513: 
        !           514:    if (!GetOpenFileName(&OpenFileName)) return INVALID_HANDLE_VALUE;
        !           515: 
        !           516:    /* update status bar with the file title. */
        !           517:    SendMessage (hwndStatus, WMU_SETTARGETNAME, 0, (LPARAM)OpenFileName.lpstrFileTitle);
        !           518: 
        !           519:    return (CreateFile(OpenFileName.lpstrFile,
        !           520:                       GENERIC_WRITE,
        !           521:                       0,
        !           522:                       NULL,
        !           523:                       CREATE_ALWAYS,
        !           524:                       FILE_ATTRIBUTE_NORMAL,
        !           525:                       NULL));
        !           526: }

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