xref: /reactos/base/applications/charmap/map.c (revision 98e8827a) 
1 /*
2  * PROJECT:     ReactOS Character Map
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        base/applications/charmap/map.c
5  * PURPOSE:     class implementation for painting glyph region
6  * COPYRIGHT:   Copyright 2007 Ged Murphy <gedmurphy@reactos.org>
7  *
8  */
9 
10 #include "precomp.h"
11 
12 #include <stdlib.h>
13 #include <winnls.h>
14 
15 static const WCHAR szMapWndClass[] = L"FontMapWnd";
16 static const WCHAR szLrgCellWndClass[] = L"LrgCellWnd";
17 
18 #define MAX_ROWS (0xFFFF / XCELLS) + 1 - YCELLS
19 
20 
21 static
22 VOID
23 SetGrid(PMAP infoPtr)
24 {
25     INT x, y;
26 
27     for (y = 0; y < YCELLS; y++)
28     for (x = 0; x < XCELLS; x++)
29     {
30         infoPtr->Cells[y][x].CellExt.left = x * infoPtr->CellSize.cx + 1;
31         infoPtr->Cells[y][x].CellExt.top = y * infoPtr->CellSize.cy + 1;
32         infoPtr->Cells[y][x].CellExt.right = (x + 1) * infoPtr->CellSize.cx + 2;
33         infoPtr->Cells[y][x].CellExt.bottom = (y + 1) * infoPtr->CellSize.cy + 2;
34 
35         CopyRect(&infoPtr->Cells[y][x].CellInt,
36                  &infoPtr->Cells[y][x].CellExt);
37 
38         InflateRect(&infoPtr->Cells[y][x].CellInt,
39                     -1,
40                     -1);
41     }
42 }
43 
44 
45 static
46 VOID
47 DrawActiveCell(PMAP infoPtr,
48                HDC hdc)
49 {
50     Rectangle(hdc,
51               infoPtr->pActiveCell->CellInt.left,
52               infoPtr->pActiveCell->CellInt.top,
53               infoPtr->pActiveCell->CellInt.right,
54               infoPtr->pActiveCell->CellInt.bottom);
55 
56 }
57 
58 
59 static
60 VOID
61 DrawGrid(PMAP infoPtr,
62          PAINTSTRUCT *ps)
63 {
64     INT x, y;
65     RECT rc;
66     PCELL Cell;
67 
68     for (y = 0; y < YCELLS; y++)
69     for (x = 0; x < XCELLS; x++)
70     {
71         Cell = &infoPtr->Cells[y][x];
72 
73         if (!IntersectRect(&rc,
74                            &ps->rcPaint,
75                            &Cell->CellExt))
76         {
77             continue;
78         }
79 
80         Rectangle(ps->hdc,
81                   Cell->CellExt.left,
82                   Cell->CellExt.top,
83                   Cell->CellExt.right,
84                   Cell->CellExt.bottom);
85 
86         if (infoPtr->pActiveCell == Cell)
87         {
88             DrawActiveCell(infoPtr, ps->hdc);
89         }
90     }
91 }
92 
93 
94 static
95 VOID
96 FillGrid(PMAP infoPtr,
97          PAINTSTRUCT *ps)
98 {
99     HFONT hOldFont;
100     WCHAR ch;
101     INT x, y;
102     RECT rc;
103     PCELL Cell;
104     INT i, added;
105 
106     hOldFont = SelectObject(ps->hdc,
107                             infoPtr->hFont);
108 
109     i = XCELLS * infoPtr->iYStart;
110 
111     added = 0;
112 
113     for (y = 0; y < YCELLS; y++)
114     for (x = 0; x < XCELLS; x++)
115     {
116         if (i >= infoPtr->NumValidGlyphs) break;
117 
118         ch = (WCHAR)infoPtr->ValidGlyphs[i];
119 
120         Cell = &infoPtr->Cells[y][x];
121 
122         if (IntersectRect(&rc,
123                             &ps->rcPaint,
124                             &Cell->CellExt))
125         {
126             Cell->ch = ch;
127 
128             DrawTextW(ps->hdc,
129                         &ch,
130                         1,
131                         &Cell->CellInt,
132                         DT_CENTER | DT_VCENTER | DT_SINGLELINE);
133 
134             added++;
135         }
136 
137         i++;
138         ch = (WCHAR)i;
139     }
140     SelectObject(ps->hdc,
141                  hOldFont);
142 }
143 
144 
145 static
146 BOOL
147 CreateLargeCell(PMAP infoPtr)
148 {
149     RECT rLarge;
150 
151     CopyRect(&rLarge,
152              &infoPtr->pActiveCell->CellExt);
153 
154     MapWindowPoints(infoPtr->hMapWnd,
155                     infoPtr->hParent,
156                     (VOID*)&rLarge,
157                     2);
158 
159     InflateRect(&rLarge,
160                 XLARGE - XCELLS,
161                 YLARGE - YCELLS);
162 
163     infoPtr->hLrgWnd = CreateWindowExW(0,
164                                        szLrgCellWndClass,
165                                        NULL,
166                                        WS_CHILDWINDOW | WS_VISIBLE,
167                                        rLarge.left,
168                                        rLarge.top,
169                                        rLarge.right - rLarge.left,
170                                        rLarge.bottom - rLarge.top,
171                                        infoPtr->hParent,
172                                        NULL,
173                                        hInstance,
174                                        infoPtr);
175     if (!infoPtr->hLrgWnd)
176         return FALSE;
177 
178     return TRUE;
179 }
180 
181 
182 static
183 VOID
184 MoveLargeCell(PMAP infoPtr)
185 {
186     RECT rLarge;
187 
188     CopyRect(&rLarge,
189              &infoPtr->pActiveCell->CellExt);
190 
191     MapWindowPoints(infoPtr->hMapWnd,
192                     infoPtr->hParent,
193                     (VOID*)&rLarge,
194                     2);
195 
196     InflateRect(&rLarge,
197                 XLARGE - XCELLS,
198                 YLARGE - YCELLS);
199 
200     MoveWindow(infoPtr->hLrgWnd,
201                rLarge.left,
202                rLarge.top,
203                rLarge.right - rLarge.left,
204                rLarge.bottom - rLarge.top,
205                TRUE);
206 
207     InvalidateRect(infoPtr->hLrgWnd,
208                    NULL,
209                    TRUE);
210 }
211 
212 
213 static
214 VOID
215 GetPossibleCharacters(WCHAR* ch, INT chLen, INT codePageIdx)
216 {
217     INT i, j;
218 
219     memset(ch, 0, sizeof(ch[0]) * chLen);
220 
221     if (codePageIdx <= 0 || codePageIdx > SIZEOF(codePages))
222     {
223         /* this is unicode, so just load up the first MAX_GLYPHS characters
224            start at 0x21 to bypass whitespace characters */
225         INT len = min(MAX_GLYPHS, chLen);
226         for (i = 0x21, j = 0; i < len; i++)
227             ch[j++] = (WCHAR)i;
228     }
229     else
230     {
231         /* This is a codepage, so use NLS to translate the first 256 characters */
232         CHAR multiByteString[256] = { 0 };
233         for (i = 0x21; i < SIZEOF(multiByteString); i++)
234             multiByteString[i] = (CHAR)i;
235 
236         if (!MultiByteToWideChar(codePages[codePageIdx - 1], 0, multiByteString, sizeof(multiByteString), ch, chLen))
237         {
238             /* Failed for some reason, so clear the array */
239             memset(ch, 0, sizeof(ch[0]) * chLen);
240         }
241     }
242 }
243 
244 
245 static
246 VOID
247 SetFont(PMAP infoPtr,
248         LPWSTR lpFontName)
249 {
250     HDC hdc;
251     WCHAR ch[MAX_GLYPHS];
252     WORD out[MAX_GLYPHS];
253     DWORD i, j;
254 
255     /* Destroy Zoom window, since it was created with older font */
256     DestroyWindow(infoPtr->hLrgWnd);
257     infoPtr->hLrgWnd = NULL;
258 
259     if (infoPtr->hFont)
260         DeleteObject(infoPtr->hFont);
261 
262     ZeroMemory(&infoPtr->CurrentFont,
263                sizeof(LOGFONTW));
264 
265     hdc = GetDC(infoPtr->hMapWnd);
266     infoPtr->CurrentFont.lfHeight = GetDeviceCaps(hdc, LOGPIXELSY) / 5;
267 
268     infoPtr->CurrentFont.lfCharSet =  DEFAULT_CHARSET;
269     lstrcpynW(infoPtr->CurrentFont.lfFaceName,
270               lpFontName,
271               SIZEOF(infoPtr->CurrentFont.lfFaceName));
272 
273     infoPtr->hFont = CreateFontIndirectW(&infoPtr->CurrentFont);
274 
275     InvalidateRect(infoPtr->hMapWnd,
276                    NULL,
277                    TRUE);
278 
279     if (infoPtr->pActiveCell)
280         infoPtr->pActiveCell->bActive = FALSE;
281     infoPtr->pActiveCell = &infoPtr->Cells[0][0];
282     infoPtr->pActiveCell->bActive = TRUE;
283 
284     // Get all the valid glyphs in this font
285 
286     SelectObject(hdc, infoPtr->hFont);
287 
288     // Get the code page associated with the selected 'character set'
289     GetPossibleCharacters(ch, MAX_GLYPHS, infoPtr->CharMap);
290 
291     if (GetGlyphIndicesW(hdc,
292                          ch,
293                          MAX_GLYPHS,
294                          out,
295                          GGI_MARK_NONEXISTING_GLYPHS) != GDI_ERROR)
296     {
297         j = 0;
298         for (i = 0; i < MAX_GLYPHS; i++)
299         {
300             if (out[i] != 0xffff && out[i] != 0x0000 && ch[i] != 0x0000)
301             {
302                 infoPtr->ValidGlyphs[j] = ch[i];
303                 j++;
304             }
305         }
306         infoPtr->NumValidGlyphs = j;
307     }
308 
309     ReleaseDC(infoPtr->hMapWnd, hdc);
310 
311     infoPtr->NumRows = infoPtr->NumValidGlyphs / XCELLS;
312     if (infoPtr->NumValidGlyphs % XCELLS)
313         infoPtr->NumRows += 1;
314     infoPtr->NumRows = (infoPtr->NumRows > YCELLS) ? infoPtr->NumRows - YCELLS : 0;
315 
316     SetScrollRange(infoPtr->hMapWnd, SB_VERT, 0, infoPtr->NumRows, FALSE);
317     SetScrollPos(infoPtr->hMapWnd, SB_VERT, 0, TRUE);
318     infoPtr->iYStart = 0;
319 }
320 
321 
322 static
323 LRESULT
324 NotifyParentOfSelection(PMAP infoPtr,
325                         UINT code,
326                         WCHAR ch)
327 {
328     LRESULT Ret = 0;
329 
330     if (infoPtr->hParent != NULL)
331     {
332         DWORD dwIdc = GetWindowLongPtr(infoPtr->hMapWnd, GWLP_ID);
333         /*
334          * Push directly into the event queue instead of waiting
335          * the parent to be unlocked.
336          * High word of LPARAM is still available for future needs...
337          */
338         Ret = PostMessage(infoPtr->hParent,
339                           WM_COMMAND,
340                           MAKELPARAM((WORD)dwIdc, (WORD)code),
341                           (LPARAM)LOWORD(ch));
342     }
343 
344     return Ret;
345 }
346 
347 
348 static
349 VOID
350 OnClick(PMAP infoPtr,
351         WORD ptx,
352         WORD pty)
353 {
354     INT x, y, i;
355 
356     /*
357      * Find the cell the mouse pointer is over.
358      * Since each cell is the same size, this can be done quickly using CellSize.
359      * Clamp to XCELLS - 1 and YCELLS - 1 because the map can sometimes be slightly
360      * larger than infoPtr.CellSize * XCELLS , due to the map size being a non integer
361      * multiple of infoPtr.CellSize .
362      */
363     x = min(XCELLS - 1, ptx / max(1, infoPtr->CellSize.cx));
364     y = min(YCELLS - 1, pty / max(1, infoPtr->CellSize.cy));
365 
366     /* Make sure the mouse is within a valid glyph */
367     i = XCELLS * infoPtr->iYStart + y * XCELLS + x;
368     if (i >= infoPtr->NumValidGlyphs)
369     {
370         if (infoPtr->pActiveCell)
371             infoPtr->pActiveCell->bActive = FALSE;
372         infoPtr->pActiveCell = NULL;
373         return;
374     }
375 
376     /* if the cell is not already active */
377     if (!infoPtr->Cells[y][x].bActive)
378     {
379         /* set previous active cell to inactive */
380         if (infoPtr->pActiveCell)
381         {
382             /* invalidate normal cells, required when
383              * moving a small active cell via keyboard */
384             if (!infoPtr->pActiveCell->bLarge)
385             {
386                 InvalidateRect(infoPtr->hMapWnd,
387                                &infoPtr->pActiveCell->CellInt,
388                                TRUE);
389             }
390 
391             infoPtr->pActiveCell->bActive = FALSE;
392             infoPtr->pActiveCell->bLarge = FALSE;
393         }
394 
395         /* set new cell to active */
396         infoPtr->pActiveCell = &infoPtr->Cells[y][x];
397         infoPtr->pActiveCell->bActive = TRUE;
398         infoPtr->pActiveCell->bLarge = TRUE;
399         if (infoPtr->hLrgWnd)
400             MoveLargeCell(infoPtr);
401         else
402             CreateLargeCell(infoPtr);
403     }
404 }
405 
406 
407 static
408 BOOL
409 MapOnCreate(PMAP infoPtr,
410             HWND hwnd,
411             HWND hParent)
412 {
413     RECT rc;
414     BOOL Ret = FALSE;
415 
416     infoPtr = HeapAlloc(GetProcessHeap(),
417                         0,
418                         sizeof(MAP));
419     if (infoPtr)
420     {
421         SetLastError(0);
422         SetWindowLongPtrW(hwnd,
423                           0,
424                           (DWORD_PTR)infoPtr);
425         if (GetLastError() == 0)
426         {
427             ZeroMemory(infoPtr,
428                        sizeof(MAP));
429 
430             infoPtr->hMapWnd = hwnd;
431             infoPtr->hParent = hParent;
432 
433             GetClientRect(hwnd, &rc);
434             infoPtr->ClientSize.cx = rc.right;
435             infoPtr->ClientSize.cy = rc.bottom;
436             infoPtr->CellSize.cx = infoPtr->ClientSize.cx / XCELLS;
437             infoPtr->CellSize.cy = infoPtr->ClientSize.cy / YCELLS;
438 
439             infoPtr->pActiveCell = NULL;
440 
441             SetGrid(infoPtr);
442 
443             SetScrollPos(infoPtr->hParent, SB_VERT, 0, TRUE);
444 
445             Ret = TRUE;
446         }
447     }
448 
449     return Ret;
450 }
451 
452 
453 static
454 VOID
455 OnVScroll(PMAP infoPtr,
456           INT Value,
457           INT Pos)
458 {
459     INT iYDiff, iOldYStart = infoPtr->iYStart;
460 
461     switch (Value)
462     {
463         case SB_LINEUP:
464             infoPtr->iYStart -=  1;
465             break;
466 
467         case SB_LINEDOWN:
468             infoPtr->iYStart +=  1;
469             break;
470 
471         case SB_PAGEUP:
472             infoPtr->iYStart -= YCELLS;
473             break;
474 
475         case SB_PAGEDOWN:
476             infoPtr->iYStart += YCELLS;
477             break;
478 
479         case SB_THUMBTRACK:
480             infoPtr->iYStart = Pos;
481             break;
482 
483        default:
484             break;
485        }
486 
487     infoPtr->iYStart = max(0, infoPtr->iYStart);
488     infoPtr->iYStart = min(infoPtr->iYStart, infoPtr->NumRows);
489 
490     iYDiff = iOldYStart - infoPtr->iYStart;
491     if (iYDiff)
492     {
493         if (infoPtr->hLrgWnd != NULL)
494         {
495             ShowWindow(infoPtr->hLrgWnd, SW_HIDE);
496         }
497 
498         SetScrollPos(infoPtr->hMapWnd,
499                      SB_VERT,
500                      infoPtr->iYStart,
501                      TRUE);
502 
503         if (abs(iYDiff) < YCELLS)
504         {
505             RECT rect;
506 
507             /* Invalidate the rect around the active cell since a new cell will become active */
508             if (infoPtr->pActiveCell && infoPtr->pActiveCell->bActive)
509             {
510                 InvalidateRect(infoPtr->hMapWnd,
511                                &infoPtr->pActiveCell->CellExt,
512                                TRUE);
513             }
514 
515             GetClientRect(infoPtr->hMapWnd, &rect);
516             rect.top += 2;
517             rect.bottom -= 2;
518             ScrollWindowEx(infoPtr->hMapWnd,
519                            0,
520                            iYDiff * infoPtr->CellSize.cy,
521                            &rect,
522                            &rect,
523                            NULL,
524                            NULL,
525                            SW_INVALIDATE);
526         }
527         else
528         {
529             InvalidateRect(infoPtr->hMapWnd,
530                            NULL,
531                            TRUE);
532         }
533 
534         if (infoPtr->hLrgWnd != NULL)
535         {
536             ShowWindow(infoPtr->hLrgWnd, SW_SHOW);
537         }
538     }
539 }
540 
541 
542 static
543 VOID
544 OnPaint(PMAP infoPtr,
545         WPARAM wParam)
546 {
547     PAINTSTRUCT ps;
548     HDC hdc;
549 
550 
551     if (wParam != 0)
552     {
553         if (!GetUpdateRect(infoPtr->hMapWnd,
554                            &ps.rcPaint,
555                            TRUE))
556         {
557             return;
558         }
559         ps.hdc = (HDC)wParam;
560     }
561     else
562     {
563         hdc = BeginPaint(infoPtr->hMapWnd,
564                          &ps);
565         if (hdc == NULL)
566         {
567             return;
568         }
569     }
570 
571     DrawGrid(infoPtr, &ps);
572 
573     FillGrid(infoPtr, &ps);
574 
575     if (wParam == 0)
576     {
577         EndPaint(infoPtr->hMapWnd,
578                  &ps);
579     }
580 }
581 
582 
583 LRESULT
584 CALLBACK
585 MapWndProc(HWND hwnd,
586            UINT uMsg,
587            WPARAM wParam,
588            LPARAM lParam)
589 {
590     PMAP infoPtr;
591     LRESULT Ret = 0;
592     WCHAR lfFaceName[LF_FACESIZE];
593 
594     infoPtr = (PMAP)GetWindowLongPtrW(hwnd,
595                                       0);
596 
597     switch (uMsg)
598     {
599         case WM_CREATE:
600         {
601             if (!MapOnCreate(infoPtr,
602                              hwnd,
603                              ((LPCREATESTRUCTW)lParam)->hwndParent))
604             {
605                 return (LRESULT)-1;
606             }
607 
608             break;
609         }
610 
611         case WM_LBUTTONDOWN:
612         {
613             OnClick(infoPtr,
614                     LOWORD(lParam),
615                     HIWORD(lParam));
616 
617             break;
618         }
619 
620         case WM_MOUSEMOVE:
621         {
622             if (wParam & MK_LBUTTON)
623             {
624                 OnClick(infoPtr,
625                         LOWORD(lParam),
626                         HIWORD(lParam));
627             }
628             break;
629         }
630 
631         case WM_LBUTTONDBLCLK:
632         {
633             if (!infoPtr->pActiveCell)
634                 break;
635 
636             NotifyParentOfSelection(infoPtr,
637                                     FM_SETCHAR,
638                                     infoPtr->pActiveCell->ch);
639 
640             if (infoPtr->pActiveCell->bLarge)
641             {
642                 DestroyWindow(infoPtr->hLrgWnd);
643                 infoPtr->hLrgWnd = NULL;
644             }
645 
646             infoPtr->pActiveCell->bLarge = FALSE;
647 
648             break;
649         }
650 
651         case WM_VSCROLL:
652         {
653             OnVScroll(infoPtr,
654                       LOWORD(wParam),
655                       HIWORD(wParam));
656 
657             break;
658         }
659 
660         case FM_SETCHARMAP:
661             infoPtr->CharMap = LOWORD(wParam);
662             wcsncpy(lfFaceName,
663                     infoPtr->CurrentFont.lfFaceName,
664                     SIZEOF(lfFaceName));
665             SetFont(infoPtr, lfFaceName);
666             break;
667 
668         case FM_SETFONT:
669             SetFont(infoPtr, (LPWSTR)lParam);
670             break;
671 
672         case FM_GETCHAR:
673         {
674             if (!infoPtr->pActiveCell) return 0;
675             return infoPtr->pActiveCell->ch;
676         }
677 
678         case FM_GETHFONT:
679             return (LRESULT)infoPtr->hFont;
680 
681         case WM_PAINT:
682         {
683             OnPaint(infoPtr,
684                     wParam);
685             break;
686         }
687 
688         case WM_DESTROY:
689         {
690             DeleteObject(infoPtr->hFont);
691             HeapFree(GetProcessHeap(),
692                      0,
693                      infoPtr);
694             SetWindowLongPtrW(hwnd,
695                               0,
696                               (DWORD_PTR)NULL);
697             break;
698         }
699 
700         default:
701         {
702             Ret = DefWindowProcW(hwnd,
703                                  uMsg,
704                                  wParam,
705                                  lParam);
706             break;
707         }
708     }
709 
710     return Ret;
711 }
712 
713 
714 BOOL
715 RegisterMapClasses(HINSTANCE hInstance)
716 {
717     WNDCLASSW wc = {0};
718 
719     wc.style = CS_DBLCLKS;
720     wc.lpfnWndProc = MapWndProc;
721     wc.cbWndExtra = sizeof(PMAP);
722     wc.hInstance = hInstance;
723     wc.hCursor = LoadCursorW(NULL,
724                             (LPWSTR)IDC_ARROW);
725     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
726     wc.lpszClassName = szMapWndClass;
727 
728     if (RegisterClassW(&wc))
729     {
730         wc.lpfnWndProc = LrgCellWndProc;
731         wc.cbWndExtra = 0;
732         wc.lpszClassName = szLrgCellWndClass;
733 
734         return RegisterClassW(&wc) != 0;
735     }
736 
737     return FALSE;
738 }
739 
740 VOID
741 UnregisterMapClasses(HINSTANCE hInstance)
742 {
743     UnregisterClassW(szMapWndClass,
744                     hInstance);
745 
746     UnregisterClassW(szLrgCellWndClass,
747                     hInstance);
748 }
749