![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / uniput|
Return to display.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / uniput |
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: * display.c -- module to support the main MDI child windows. ! 14: * ! 15: * This module contains Window Procedure, openDisplay() and closeDisplay() ! 16: * routines. Call openDisplay() one time per process before creating the ! 17: * first window, and call closeDisplay() one time at process termination. ! 18: * ! 19: * windows are created in main frame window procedure. ! 20: * ! 21: * design: We have one window procedure here for potentially multiple ! 22: * MDI child windows. The nCharPerLine, SqrHeight, and SqrWidth are ! 23: * stored on a per window basis. Also, the window class is registered ! 24: * with the style CS_OWNDC. For this reason, it is possible to select ! 25: * a logical font into the HDC, and it will be there each time you get ! 26: * the DC new for the window. In this way we have a log font for each ! 27: * window without actually doing any work in this module. ! 28: * ! 29: * Some of the data is global, and works for all of the windows. The ! 30: * startcount & endcount arrays are a good example. These are computed ! 31: * once when the font is created, but the values remain the same for each ! 32: * window. Thus we have the following assumption: ! 33: * ! 34: * 1. No fonts will be installed or removed while program is running. ! 35: * (CountUCSegments values remain valid for run time duration). ! 36: * ! 37: * ! 38: * There are WM_USER+ messages to set values for this window, and to ! 39: * notify it of global changes. Looking at the create time, user message ! 40: * stream is helpful. On the WM_CREATE message, we send ourselves a ! 41: * WMU_NEWFONT message to create a logical font and count the number of ! 42: * character ranges (segments). Before returning from this message, we ! 43: * send ourselves a WMU_NEWRANGE message to set the title, and the ! 44: * horizontal scroll bar correctly. ! 45: * ! 46: * ! 47: \**************************************************************************/ ! 48: #define UNICODE ! 49: ! 50: #include <windows.h> ! 51: #include "uniput.h" ! 52: #include "display.h" ! 53: ! 54: ! 55: /* global variables store the start and end codepoints for UC ranges. */ ! 56: #define MAXSEGMENTS 100 ! 57: USHORT *endCount= NULL; ! 58: USHORT *startCount= NULL; ! 59: ! 60: int CountUCSegments (HDC); ! 61: /* error return value from CountUCSegments */ ! 62: #define SEGMENTERROR -1 ! 63: ! 64: ! 65: /* conversion between (x,y) pairs and rectangle index */ ! 66: int transXYtoIndex (int, int, int, int, int); ! 67: int transIndextoRect (int, PRECT, int, int, int); ! 68: ! 69: ! 70: /* window extra bytes for use to store window specific data (see register class) */ ! 71: #define GWLU_NCHAR 0 ! 72: #define GWLU_SQRHEIGHT 4 ! 73: #define GWLU_SQRWIDTH 8 ! 74: ! 75: ! 76: ! 77: ! 78: ! 79: /* Global logfont. Used for CreateFontIndirect(). ! 80: * also regerenced in the uniput.c file. ! 81: */ ! 82: LOGFONT logfont = { ! 83: UCFONTHEIGHT , ! 84: UCFONTWIDTH , ! 85: 0 , ! 86: 0 , ! 87: 400 , ! 88: 0 , ! 89: 0 , ! 90: 0 , ! 91: UNICODE_CHARSET , ! 92: 0 , ! 93: 0 , ! 94: 2 , ! 95: 2 , ! 96: TEXT("Lucida Sans Unicode")}; ! 97: ! 98: ! 99: /* Global, class specific data. ! 100: * ought to allocate once per class, and free once at app exit time. ! 101: */ ! 102: HDC hdcMemXOR; ! 103: HBITMAP hbmMemXOR; ! 104: PVOID pbitsXOR, pbitsAND; ! 105: ! 106: int FontWidth, FontHeight; ! 107: int nSegments; ! 108: ! 109: /**************************************************************************\ ! 110: * ! 111: * function: openDisplay() ! 112: * ! 113: * Global variables: ! 114: * HDC hdcMemXOR; ! 115: * HBITMAP hbmMemXOR; ! 116: * PVOID pbitsXOR, pbitsAND; ! 117: * int FontWidth, FontHeight; ! 118: * int nSegments; ! 119: * ! 120: * returns: TRUE - if success, FALSE - if fail. ! 121: * ! 122: * essential side effect: ! 123: * Registers window class, and initial global variables. ! 124: \**************************************************************************/ ! 125: int openDisplay(VOID ) ! 126: { ! 127: WNDCLASS wc; ! 128: static int cxCursor, cyCursor; ! 129: HFONT hfont; ! 130: ! 131: /* Register the window class*/ ! 132: wc.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC; ! 133: wc.lpfnWndProc = (WNDPROC)DisplayWndProc; ! 134: wc.cbClsExtra = 0; ! 135: wc.cbWndExtra = 12; ! 136: wc.hInstance = hInst; ! 137: wc.hIcon = LoadIcon(hInst, TEXT("uniputIcon")); ! 138: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 139: wc.hbrBackground = GetStockObject (WHITE_BRUSH); ! 140: wc.lpszMenuName = NULL; ! 141: wc.lpszClassName = DISPLAYCLASS; ! 142: ! 143: if (!RegisterClass(&wc)) return (FALSE); ! 144: ! 145: cxCursor = GetSystemMetrics (SM_CXCURSOR); ! 146: cyCursor = GetSystemMetrics (SM_CYCURSOR); ! 147: ! 148: /* get pointer to 0-init memory */ ! 149: pbitsAND = (PVOID) LocalAlloc (LPTR, cxCursor*cyCursor/8); ! 150: ! 151: /* Create a memory DC to draw into for creating cursors. */ ! 152: hdcMemXOR = CreateCompatibleDC (NULL); ! 153: hbmMemXOR = CreateBitmap (cxCursor,cyCursor,1,4,NULL); ! 154: SelectObject (hdcMemXOR, hbmMemXOR); ! 155: ! 156: /* set text modes for the memory HDC */ ! 157: SetBkMode (hdcMemXOR, TRANSPARENT); ! 158: SetTextAlign (hdcMemXOR, TA_CENTER | TA_TOP); ! 159: ! 160: /* set a unicode font into the memory DC */ ! 161: logfont.lfHeight = cyCursor *2/3; // HACK.. scale down Y ! 162: logfont.lfWidth = cxCursor *2/3; ! 163: hfont = CreateFontIndirect (&logfont); ! 164: SelectObject (hdcMemXOR, hfont); ! 165: ! 166: /* get pointer to be used later as pointer to bitmap bits */ ! 167: pbitsXOR = (PVOID) LocalAlloc (LPTR, cxCursor*cyCursor/2); ! 168: ! 169: /* Assume that we got a unicode font. ! 170: * Count the number of segments, and fill in the proper global ! 171: * variables specifying the code point ranges covered. ! 172: */ ! 173: nSegments = CountUCSegments (hdcMemXOR); /* slow computation */ ! 174: ! 175: ! 176: /* verify that we have SOME ranges to work with */ ! 177: if (nSegments == SEGMENTERROR) return FALSE; ! 178: ! 179: /* warn the user if we can't find the right font */ ! 180: if (nSegments < 30) ! 181: MessageBox (NULL, ! 182: TEXT("Working with limited codepoint coverage. \n Install uclucida.ttf"), ! 183: TEXT("Warning: Lucida Sans Unicode font not found."), MB_OK); ! 184: ! 185: ! 186: ! 187: FontWidth = UCFONTWIDTH; ! 188: FontHeight = UCFONTHEIGHT; ! 189: ! 190: return TRUE; ! 191: } ! 192: ! 193: /**************************************************************************\ ! 194: * ! 195: * function: closeDisplay() ! 196: * ! 197: * Global variables: ! 198: * HDC hdcMemXOR; ! 199: * HBITMAP hbmMemXOR; ! 200: * PVOID pbitsXOR, pbitsAND; ! 201: * ! 202: * essential side effect: ! 203: * Frees global variables. ! 204: \**************************************************************************/ ! 205: int closeDisplay(VOID) ! 206: { ! 207: HFONT hfont; ! 208: ! 209: hfont = SelectObject (hdcMemXOR, GetStockObject(SYSTEM_FONT)); ! 210: DeleteObject (hfont); ! 211: DeleteDC (hdcMemXOR); ! 212: DeleteObject (hbmMemXOR); ! 213: ! 214: LocalFree (LocalHandle (pbitsXOR)); ! 215: LocalFree (LocalHandle (pbitsAND)); ! 216: return TRUE; ! 217: } ! 218: ! 219: ! 220: /**************************************************************************\ ! 221: * ! 222: * function: DisplayWndProc() ! 223: * ! 224: * input parameters: normal window procedure parameters. ! 225: * ! 226: \**************************************************************************/ ! 227: LRESULT CALLBACK DisplayWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) ! 228: { ! 229: static HFONT hfont, hfontOld; ! 230: ! 231: static HDC hdc; ! 232: static RECT rect; ! 233: static int iSeg; ! 234: static TCHAR buffer[100]; ! 235: ! 236: /* rDown and index used as the user points to a square. */ ! 237: static RECT rDown; ! 238: static int index; ! 239: ! 240: static WCHAR DragDropChar; ! 241: static HICON hIcon; ! 242: ! 243: ! 244: ! 245: switch (message) { ! 246: ! 247: /**********************************************************************\ ! 248: * WM_CREATE ! 249: * ! 250: * Set up the LOGFONT in the HDC for this window. ! 251: \**********************************************************************/ ! 252: case WM_CREATE: ! 253: SendMessage (hwnd, WMU_SETNCHAR, 16, 0); ! 254: SendMessage (hwnd, WMU_NEWFONT, FontWidth, FontHeight); ! 255: break; ! 256: ! 257: ! 258: /**********************************************************************\ ! 259: * WM_DESTROY ! 260: * ! 261: * Get rid of the logical font we create for each display window. ! 262: * relying here on CS_ONWDC ! 263: \**********************************************************************/ ! 264: case WM_DESTROY: ! 265: hdc = GetDC (hwnd); ! 266: hfont = SelectObject (hdc, GetStockObject(SYSTEM_FONT)); ! 267: DeleteObject (hfont); ! 268: ReleaseDC (hwnd, hdc); ! 269: ! 270: if (startCount != NULL) LocalFree (LocalHandle (startCount)); ! 271: if (endCount != NULL) LocalFree (LocalHandle (endCount)); ! 272: ! 273: break; ! 274: ! 275: ! 276: ! 277: ! 278: ! 279: /**********************************************************************\ ! 280: * WMU_SETNCHAR ! 281: * ! 282: * wParam - nCharPerLine ! 283: * ! 284: \**********************************************************************/ ! 285: case WMU_SETNCHAR: ! 286: SetWindowLong (hwnd, GWLU_NCHAR, (int) wParam); ! 287: InvalidateRect (hwnd, NULL, TRUE); ! 288: break; ! 289: ! 290: /**********************************************************************\ ! 291: * WMU_NEWFONT ! 292: * ! 293: * wParam - Width ! 294: * lParam - Height ! 295: * ! 296: * Create font, select it into the HDC, and reset ranges. ! 297: \**********************************************************************/ ! 298: case WMU_NEWFONT: { ! 299: ! 300: hdc = GetDC(hwnd); ! 301: ! 302: FontWidth = (int) wParam; ! 303: FontHeight = (int) lParam; ! 304: logfont.lfHeight = FontHeight; ! 305: logfont.lfWidth = FontWidth; ! 306: ! 307: hfont = CreateFontIndirect (&logfont); ! 308: hfontOld = SelectObject (hdc, hfont); ! 309: DeleteObject (hfontOld); ! 310: ! 311: ReleaseDC (hwnd, hdc); ! 312: ! 313: ! 314: SetScrollRange (hwnd, SB_HORZ, 0, (nSegments-1), TRUE); ! 315: SetScrollPos (hwnd, SB_HORZ, 0, TRUE); ! 316: ! 317: SendMessage (hwnd, WMU_NEWRANGE, 0,0); ! 318: ! 319: } return TRUE; ! 320: ! 321: ! 322: /**********************************************************************\ ! 323: * WMU_NEWRANGE ! 324: * ! 325: * ! 326: * Range changes, or font size changes, or title status changes. ! 327: \**********************************************************************/ ! 328: case WMU_NEWRANGE: { ! 329: int sqrHeight, sqrWidth; ! 330: TEXTMETRIC tm; ! 331: int i; ! 332: ! 333: hdc = GetDC(hwnd); ! 334: GetTextMetrics (hdc, &tm); ! 335: ReleaseDC (hwnd, hdc); ! 336: ! 337: /* index into the start, end arrays stored in scroll bar */ ! 338: iSeg = GetScrollPos (hwnd, SB_HORZ); ! 339: ! 340: /* Set the window title text to show display range. */ ! 341: wsprintf (buffer, TEXT("[%04x, %04x]"), ! 342: (int)startCount[iSeg], ! 343: (int)endCount[iSeg]); ! 344: ! 345: /* if we are supposed to look up the character range name, ! 346: * then step through the ranges stored in the RangeName ! 347: * table. Find the correct one, and reset the buffer string. ! 348: */ ! 349: if (gShowNames) { ! 350: for (i = 0; i< NRANGE; i++) { ! 351: if ((RangeName[i].start <= startCount[iSeg]) && ! 352: ( startCount[iSeg] <= RangeName[i].end)) ! 353: ! 354: wsprintf (buffer, TEXT("%s [%04x, %04x]"), ! 355: RangeName[i].String, ! 356: (int)startCount[iSeg], ! 357: (int)endCount[iSeg]); ! 358: ! 359: } ! 360: } ! 361: SetWindowText (hwnd, buffer); ! 362: ! 363: sqrHeight = tm.tmHeight + tm.tmExternalLeading; ! 364: sqrWidth = tm.tmMaxCharWidth; ! 365: ! 366: SetWindowLong (hwnd, GWLU_SQRHEIGHT,sqrHeight); ! 367: SetWindowLong (hwnd, GWLU_SQRWIDTH, sqrWidth ); ! 368: ! 369: } return TRUE; ! 370: ! 371: ! 372: ! 373: ! 374: ! 375: ! 376: ! 377: ! 378: ! 379: /**********************************************************************\ ! 380: * WM_LBUTTONDOWN ! 381: * ! 382: * Static, shared variables set in WM_LBUTTONDOWN: ! 383: * rDown, hIcon, DragDropChar ! 384: * ! 385: \**********************************************************************/ ! 386: case WM_LBUTTONDOWN: { ! 387: int x,y; ! 388: int nCharPerLine; ! 389: int sqrHeight, sqrWidth; ! 390: nCharPerLine = GetWindowLong (hwnd, GWLU_NCHAR); ! 391: sqrHeight = GetWindowLong (hwnd, GWLU_SQRHEIGHT); ! 392: sqrWidth = GetWindowLong (hwnd, GWLU_SQRWIDTH ); ! 393: ! 394: ! 395: ! 396: x = (int)LOWORD (lParam); ! 397: y = (int)HIWORD (lParam); ! 398: ! 399: index = transXYtoIndex (x,y, sqrWidth, sqrHeight, nCharPerLine); ! 400: ! 401: /* verify that the index is within the shown segment range */ ! 402: iSeg= GetScrollPos (hwnd, SB_HORZ); ! 403: if (index > (endCount[iSeg]- startCount[iSeg])) return 0; ! 404: ! 405: DragDropChar = index + startCount[iSeg]; ! 406: ! 407: transIndextoRect (index, &rDown, sqrWidth, sqrHeight, nCharPerLine); ! 408: ! 409: hdc = GetDC (hwnd); ! 410: InvertRect (hdc, &rDown); ! 411: ReleaseDC (hwnd, hdc); ! 412: ! 413: ! 414: /* Create a cursor which represents the character. ! 415: * Global variables used: ! 416: * HDC hdcMemXOR; ! 417: * HBITMAP hbmMemXOR; ! 418: * PVOID pbitsXOR, pbitsAND; ! 419: */ ! 420: { ! 421: int cxCursor, cyCursor; ! 422: RECT rect; ! 423: ! 424: cxCursor = GetSystemMetrics (SM_CXCURSOR); ! 425: cyCursor = GetSystemMetrics (SM_CYCURSOR); ! 426: ! 427: rect.left = rect.top = 0; ! 428: rect.right = cxCursor; rect.bottom = cyCursor; ! 429: ! 430: ! 431: FrameRect (hdcMemXOR, &rect, GetStockObject (BLACK_BRUSH)); ! 432: InflateRect (&rect, -1, -1); ! 433: FillRect (hdcMemXOR, &rect, GetStockObject (LTGRAY_BRUSH)); ! 434: FrameRect (hdcMemXOR, &rect, GetStockObject (GRAY_BRUSH)); ! 435: InflateRect (&rect, -1, -1); ! 436: SelectObject (hdcMemXOR, GetStockObject (WHITE_PEN)); ! 437: MoveToEx (hdcMemXOR, rect.right, rect.top, NULL); ! 438: LineTo (hdcMemXOR,rect.left, rect.top); ! 439: LineTo (hdcMemXOR,rect.left, rect.bottom); ! 440: ! 441: ExtTextOut(hdcMemXOR, cxCursor/2,0, ETO_CLIPPED, &rect, ! 442: (LPCWSTR)&DragDropChar, 1, NULL); ! 443: ! 444: GetBitmapBits (hbmMemXOR, cxCursor*cyCursor/2, pbitsXOR); ! 445: ! 446: hIcon = CreateIcon( GetModuleHandle(NULL), ! 447: cxCursor,cyCursor, 1,4, ! 448: pbitsAND, ! 449: pbitsXOR); ! 450: ! 451: SetCursor ((HCURSOR)hIcon); ! 452: } ! 453: ! 454: ! 455: ! 456: GdiFlush (); ! 457: SetCapture (hwnd); ! 458: } break; ! 459: ! 460: /**********************************************************************\ ! 461: * WM_LBUTTONUP ! 462: * ! 463: * Static, shared variables set in WM_LBUTTONDOWN: ! 464: * rDown, hIcon, DragDropChar ! 465: * ! 466: \**********************************************************************/ ! 467: case WM_LBUTTONUP: { ! 468: POINT p; ! 469: HWND hwndTarget, hwndTitle; ! 470: #define NUMCHARS 255 ! 471: TCHAR buffer[NUMCHARS]; ! 472: ! 473: ! 474: if (GetCapture() == hwnd) { ! 475: ! 476: p.x = (int)(short)LOWORD (lParam); ! 477: p.y = (int)(short)HIWORD (lParam); ! 478: ! 479: ClientToScreen (hwnd, &p); ! 480: hwndTarget = WindowFromPoint (p); ! 481: ! 482: if ((GetWindowThreadProcessId (hwnd, NULL)) != ! 483: (GetWindowThreadProcessId (hwndTarget, NULL))) { ! 484: ! 485: /* hack. unipad has a client window which gets the chars, ! 486: * but we want to display the frame windows text (title bar), ! 487: * so try to get the parent of the target for Title purposes. ! 488: */ ! 489: hwndTitle = (GetParent(hwndTarget)) ? GetParent(hwndTarget) : hwndTarget; ! 490: GetWindowText (hwndTitle, buffer, NUMCHARS); ! 491: ! 492: SendMessage (hwndTarget, WM_CHAR, (WPARAM) DragDropChar, 0); ! 493: SendMessage (hwndStatus, WMU_CHARACTER, ! 494: (WPARAM) DragDropChar, (LPARAM)hwndTarget); ! 495: SendMessage (hwndStatus, WMU_SETTARGETNAME, ! 496: (WPARAM) IsWindowUnicode (hwndTarget), (LPARAM)buffer); ! 497: } /* end different process */ ! 498: ! 499: Beep (40,40); ! 500: ! 501: hdc = GetDC (hwnd); ! 502: InvertRect (hdc, &rDown); ! 503: ReleaseDC (hwnd, hdc); ! 504: GdiFlush (); ! 505: ReleaseCapture (); ! 506: SetCursor ((HCURSOR)LoadCursor (NULL, IDC_ARROW)); ! 507: DestroyIcon (hIcon); ! 508: } ! 509: } break; ! 510: ! 511: ! 512: ! 513: /**********************************************************************\ ! 514: * WM_HSCROLL ! 515: * ! 516: * Step through the character ranges. ! 517: * In every case, inform the window the range has changed, ! 518: * and invalidate it to force a repaint. ! 519: \**********************************************************************/ ! 520: case WM_HSCROLL: ! 521: ! 522: switch (LOWORD(wParam)){ ! 523: int OldPos, NewPos; ! 524: ! 525: case SB_PAGEDOWN: ! 526: case SB_LINEDOWN: ! 527: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 528: SetScrollPos (hwnd, SB_HORZ, (OldPos+1), TRUE); ! 529: SendMessage (hwnd,WMU_NEWRANGE, 0,0); ! 530: InvalidateRect (hwnd, NULL, TRUE); ! 531: break; ! 532: ! 533: case SB_PAGEUP: ! 534: case SB_LINEUP: ! 535: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 536: SetScrollPos (hwnd, SB_HORZ, (OldPos-1), TRUE); ! 537: SendMessage (hwnd,WMU_NEWRANGE, 0,0); ! 538: InvalidateRect (hwnd, NULL, TRUE); ! 539: break; ! 540: ! 541: case SB_THUMBPOSITION: ! 542: OldPos = GetScrollPos (hwnd, SB_HORZ); ! 543: NewPos = HIWORD (wParam); ! 544: SetScrollPos (hwnd, SB_HORZ, NewPos, TRUE); ! 545: SendMessage (hwnd,WMU_NEWRANGE, 0,0); ! 546: InvalidateRect (hwnd, NULL, TRUE); ! 547: break; ! 548: ! 549: } ! 550: ! 551: break; ! 552: ! 553: ! 554: ! 555: ! 556: ! 557: ! 558: ! 559: /**********************************************************************\ ! 560: * WM_SIZE ! 561: * ! 562: \**********************************************************************/ ! 563: case WM_SIZE: ! 564: /* make sure that scroll metrics are ok */ ! 565: SendMessage (hwnd, WMU_NEWRANGE, 0,0); ! 566: ! 567: break; /* fall through to MDIChildProc */ ! 568: ! 569: ! 570: /**********************************************************************\ ! 571: * WM_PAINT ! 572: * ! 573: \**********************************************************************/ ! 574: case WM_PAINT: { ! 575: HDC hdc; ! 576: PAINTSTRUCT ps; ! 577: RECT rect; ! 578: POINT point; ! 579: int i; ! 580: USHORT start, end; ! 581: WCHAR outChar; ! 582: USHORT codepoint; ! 583: int nCharPerLine; ! 584: int sqrHeight, sqrWidth; ! 585: nCharPerLine = GetWindowLong (hwnd, GWLU_NCHAR); ! 586: sqrHeight = GetWindowLong (hwnd, GWLU_SQRHEIGHT); ! 587: sqrWidth = GetWindowLong (hwnd, GWLU_SQRWIDTH ); ! 588: ! 589: ! 590: hdc = BeginPaint(hwnd, &ps); ! 591: SetBkMode (hdc, TRANSPARENT); ! 592: ! 593: iSeg= GetScrollPos (hwnd, SB_HORZ); ! 594: start = startCount[iSeg]; ! 595: end = endCount[iSeg]; ! 596: ! 597: /* ensure that we are in a valid range... some fonts have problems */ ! 598: if (start != 0xffff) ! 599: ! 600: for (codepoint = start, i=0; codepoint<=end; codepoint++,i++) { ! 601: ! 602: /* paint box and frame it */ ! 603: transIndextoRect (i, &rect, sqrWidth, sqrHeight, nCharPerLine); ! 604: InflateRect (&rect, -1, -1); ! 605: FillRect (hdc, &rect, GetStockObject (LTGRAY_BRUSH)); ! 606: InflateRect (&rect, 1, 1); ! 607: FrameRect (hdc, &rect, GetStockObject (GRAY_BRUSH)); ! 608: InflateRect (&rect, -1, -1); ! 609: SelectObject (hdc, GetStockObject (WHITE_PEN)); ! 610: MoveToEx (hdc, rect.right, rect.top, NULL); ! 611: LineTo (hdc,rect.left, rect.top); ! 612: LineTo (hdc,rect.left, rect.bottom); ! 613: ! 614: ! 615: ! 616: /* set point that we will draw glyph at */ ! 617: point.x = (rect.right + rect.left)/2; ! 618: point.y = rect.top; ! 619: SetTextAlign (hdc, TA_CENTER | TA_TOP); ! 620: SetTextColor (hdc, PALETTEINDEX (0)); ! 621: ! 622: ! 623: /* special case the non-spacing diacritic marks. U+0300 -> U+036F ! 624: * Write a space first, for them to 'modify.' ! 625: */ ! 626: if ( (0x0300 <= codepoint) && (codepoint <= 0x036F) ) { ! 627: outChar = (WCHAR) 0x0020; ! 628: TextOutW (hdc, 0,0, &outChar, 1); ! 629: } ! 630: ! 631: outChar = (WCHAR) codepoint; ! 632: ExtTextOut(hdc, point.x, point.y, ETO_CLIPPED, &rect, (LPCWSTR)&outChar, 1, NULL); ! 633: ! 634: ! 635: ! 636: /* fill in unicode code point in hex */ ! 637: if (gShowhex) { ! 638: int nchar; ! 639: HANDLE hfonttemp; ! 640: ! 641: nchar = wsprintf (buffer, TEXT("%04x"), (int) codepoint); ! 642: hfonttemp = SelectObject (hdc,GetStockObject (SYSTEM_FIXED_FONT)); ! 643: ! 644: point.y = rect.bottom; ! 645: SetTextAlign (hdc, TA_CENTER | TA_BOTTOM); ! 646: SetTextColor (hdc, PALETTEINDEX (5)); ! 647: ! 648: TextOut( hdc, point.x, point.y, ! 649: buffer, nchar); ! 650: SelectObject (hdc,hfonttemp); ! 651: } ! 652: ! 653: ! 654: } /* end for */ ! 655: ! 656: EndPaint (hwnd, &ps); ! 657: } return FALSE; /* end WM_PAINT */ ! 658: ! 659: ! 660: ! 661: ! 662: } /* end switch */ ! 663: ! 664: return (DefMDIChildProc(hwnd, message, wParam, lParam)); ! 665: } ! 666: ! 667: ! 668: ! 669: ! 670: /**************************************************************************\ ! 671: * ! 672: * Need a mapping between the (x,y) pair, and the index of the square on ! 673: * the window. Two routines provide this... one for each direction. ! 674: * ! 675: \**************************************************************************/ ! 676: ! 677: /**********************************************************************\ ! 678: * transXYtoIndex ! 679: * ! 680: * Given x & y values, return the index. ! 681: * ! 682: \**********************************************************************/ ! 683: int transXYtoIndex (int x, int y, ! 684: int sqrWidth, int sqrHeight, int nCharPerLine) ! 685: { ! 686: x /= sqrWidth; ! 687: if (x < 0) x = 0; ! 688: if (x >= nCharPerLine) x = nCharPerLine-1; ! 689: ! 690: y /= sqrHeight; ! 691: if (y < 0) y = 0; ! 692: ! 693: return ( (y * nCharPerLine) + x); ! 694: } ! 695: ! 696: ! 697: /**********************************************************************\ ! 698: * transIndextoRect ! 699: * ! 700: * Given an index, i.e. the number of one of the squares on the display ! 701: * window, fill in the rectangle structure. ! 702: * ! 703: \**********************************************************************/ ! 704: int transIndextoRect (int index, PRECT pr, ! 705: int sqrWidth, int sqrHeight, int nCharPerLine) ! 706: { ! 707: int x,y; ! 708: ! 709: x = index % nCharPerLine; ! 710: y = index / nCharPerLine; ! 711: ! 712: pr->left = x*sqrWidth; ! 713: pr->top = y*sqrHeight; ! 714: pr->right = pr->left +sqrWidth; ! 715: pr->bottom = pr->top +sqrHeight; ! 716: ! 717: return TRUE; ! 718: } ! 719: ! 720: ! 721: ! 722: ! 723: ! 724: ! 725: /**************************************************************************\ ! 726: * ! 727: * All of the code below is used for parsing 'font data.' It will only ! 728: * make sense if you have a copy of the True Type font spec. In short, ! 729: * we grab the 'cmap' table, look through it for a subtable, and then ! 730: * get two parallel arrays from the subtable. Complications arise because ! 731: * the true type data is 'BIG ENDIAN' and NT is being run 'little endian.' ! 732: * For this reason, once we locate the short or long, we call Swap* to ! 733: * change the byte ordering. ! 734: * ! 735: \**************************************************************************/ ! 736: ! 737: ! 738: VOID SwapShort (PUSHORT); ! 739: VOID SwapULong (PULONG); ! 740: ! 741: ! 742: ! 743: typedef struct tagTABLE{ ! 744: USHORT platformID; ! 745: USHORT encodingID; ! 746: ULONG offset; ! 747: } TABLE, *PTABLE; ! 748: ! 749: typedef struct tagSUBTABLE{ ! 750: USHORT format; ! 751: USHORT length; ! 752: USHORT version; ! 753: USHORT segCountX2; ! 754: USHORT searchRange; ! 755: USHORT entrySelector; ! 756: USHORT rangeShift; ! 757: } SUBTABLE, *PSUBTABLE; ! 758: ! 759: ! 760: /* 'cmap' is passed in by value in a DWORD */ ! 761: #define CMAPHEX 0x70616d63 ! 762: #define NBYTES 256 ! 763: #define OFFSETERROR 0 ! 764: ! 765: ! 766: ! 767: /**************************************************************************\ ! 768: * ! 769: * function: CountUCSegments() ! 770: * ! 771: * input parameters: ! 772: * hdc - with the logical font set into it. ! 773: * prect - pointer to client rectangle. ! 774: * ! 775: * Global variables: ! 776: * startCount ! 777: * endCount ! 778: * ! 779: * returns: ! 780: * number of UC segments or ! 781: * SEGMENTERROR if there is some kind of error. ! 782: * ! 783: * essential side effect: ! 784: * Fills in global startCount, endCount arrays. ! 785: \**************************************************************************/ ! 786: int CountUCSegments (HDC hdc) ! 787: { ! 788: DWORD cbData; ! 789: USHORT aShort[2]; ! 790: DWORD nBytes; ! 791: USHORT i, nTables; ! 792: PTABLE pTable; ! 793: PSUBTABLE pSubTable; ! 794: ULONG offset,offsetFormat4; ! 795: USHORT segCount; ! 796: BYTE buffer[NBYTES]; ! 797: ! 798: ! 799: ! 800: ! 801: /* find number of "subtables", second long in cmap */ ! 802: nBytes=GetFontData (hdc, CMAPHEX, 0, aShort, 4); ! 803: if (nBytes == GDI_ERROR) { ! 804: MessageBox (NULL, MBGETFONTDATAERR,MBERROR , MBERRORFLAGS); ! 805: return SEGMENTERROR; ! 806: } ! 807: if (nBytes == 0) { ! 808: MessageBox (NULL, TEXT("No 'cmap' table."),MBERROR , MBERRORFLAGS); ! 809: return SEGMENTERROR; ! 810: } ! 811: nTables = aShort[1]; ! 812: SwapShort (&nTables); ! 813: ! 814: ! 815: cbData = nTables * sizeof(TABLE); ! 816: if (cbData >NBYTES) { ! 817: MessageBox (NULL, TEXT("cbData >NBYTES"),MBERROR , MBERRORFLAGS); ! 818: return SEGMENTERROR; ! 819: } ! 820: ! 821: /* get array of subtables information. Check each one for 3,1*/ ! 822: nBytes=GetFontData (hdc, CMAPHEX, 4, buffer, cbData); ! 823: pTable = (PTABLE)buffer; ! 824: offsetFormat4 = OFFSETERROR; ! 825: for (i = 0; i< nTables; i++) { ! 826: ! 827: SwapShort (&(pTable->encodingID)); ! 828: SwapShort (&(pTable->platformID)); ! 829: ! 830: if ((pTable->platformID == 3)&&(pTable->encodingID == 1)) { ! 831: offsetFormat4 = pTable->offset; ! 832: SwapULong (&offsetFormat4); ! 833: break; ! 834: } ! 835: pTable++; ! 836: } ! 837: ! 838: /* verify that we got the correct offset to the FORMAT 4 subtable */ ! 839: if (offsetFormat4 == OFFSETERROR){ ! 840: MessageBox (NULL, TEXT("Can not find 3,1 subtable"),MBERROR , MBERRORFLAGS); ! 841: return SEGMENTERROR; ! 842: } ! 843: ! 844: /* Get the beginning of the subtable, especially the segment count */ ! 845: nBytes=GetFontData (hdc, CMAPHEX, offsetFormat4, buffer, sizeof(SUBTABLE)); ! 846: pSubTable = (PSUBTABLE) buffer; ! 847: SwapShort (&(pSubTable->format)); ! 848: SwapShort (&(pSubTable->segCountX2)); ! 849: ! 850: if (pSubTable->format != 4){ ! 851: MessageBox (NULL, TEXT("format !=4"), MBERROR, MBERRORFLAGS); ! 852: return SEGMENTERROR; ! 853: } ! 854: ! 855: segCount = pSubTable->segCountX2 / 2; ! 856: ! 857: /* Now that we know how many segments that the font contains, ! 858: * free up the old memory, and realloc. the two global arrays. ! 859: */ ! 860: if (startCount != NULL) LocalFree (LocalHandle (startCount)); ! 861: if (endCount != NULL) LocalFree (LocalHandle (endCount)); ! 862: startCount = LocalAlloc (LPTR, segCount * sizeof(USHORT)); ! 863: endCount = LocalAlloc (LPTR, segCount * sizeof(USHORT)); ! 864: ! 865: if ((startCount == NULL) || (endCount == NULL)) { ! 866: MessageBox (NULL, TEXT("LocalAlloc failed"), MBERROR, MBERRORFLAGS); ! 867: return SEGMENTERROR; ! 868: } ! 869: ! 870: /* read in the array of endCount values */ ! 871: offset = offsetFormat4 ! 872: + (7 * sizeof (USHORT)); /* skip constant # bytes in subtable */ ! 873: cbData = segCount * sizeof (USHORT); ! 874: nBytes=GetFontData (hdc, CMAPHEX, offset, endCount, cbData ); ! 875: for (i = 0; i<segCount; i++) ! 876: SwapShort (& (endCount[i])); ! 877: ! 878: /* read in the array of startCount values */ ! 879: offset = offsetFormat4 ! 880: + (7 * sizeof (USHORT)) /* skip constant # bytes in subtable */ ! 881: + (segCount * sizeof (USHORT)) /* skip endCount array */ ! 882: + sizeof (USHORT); /* skip reservedPad */ ! 883: cbData = segCount * sizeof (USHORT); ! 884: nBytes=GetFontData (hdc, CMAPHEX, offset, startCount, cbData ); ! 885: for (i = 0; i<segCount; i++) ! 886: SwapShort (& (startCount[i])); ! 887: ! 888: ! 889: return segCount; ! 890: } ! 891: ! 892: ! 893: ! 894: ! 895: ! 896: ! 897: ! 898: ! 899: ! 900: ! 901: VOID SwapShort (PUSHORT p) ! 902: { ! 903: SHORT temp; ! 904: ! 905: temp =(SHORT)( HIBYTE (*p) + (LOBYTE(*p) << 8)); ! 906: *p = temp; ! 907: } ! 908: ! 909: ! 910: ! 911: VOID SwapULong (PULONG p) ! 912: { ! 913: ULONG temp; ! 914: ! 915: temp = (LONG) ((BYTE) *p); ! 916: temp <<= 8; ! 917: *p >>=8; ! 918: ! 919: temp += (LONG) ((BYTE) *p); ! 920: temp <<= 8; ! 921: *p >>=8; ! 922: ! 923: temp += (LONG) ((BYTE) *p); ! 924: temp <<= 8; ! 925: *p >>=8; ! 926: ! 927: temp += (LONG) ((BYTE) *p); ! 928: *p = temp; ! 929: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.