xref: /reactos/dll/cpl/desk/monslctl.c (revision 1734f297) 
1 #include "desk.h"
2 
3 static const TCHAR szMonitorSelWndClass[] = TEXT("MONITORSELWNDCLASS");
4 
5 typedef struct _MONSL_MON
6 {
7     RECT rc;
8     HFONT hFont;
9     TCHAR szCaption[12];
10 } MONSL_MON, *PMONSL_MON;
11 
12 typedef struct _MONITORSELWND
13 {
14     HWND hSelf;
15     HWND hNotify;
16     HFONT hFont;
17     SIZE ClientSize;
18     DWORD UIState;
19     union
20     {
21         DWORD dwInternalFlags;
22         struct
23         {
24             UINT Enabled : 1;
25             UINT HasFocus : 1;
26             UINT CanDisplay : 1;
27             UINT LeftBtnDown : 1;
28             UINT IsDraggingMonitor : 1;
29         };
30     };
31     DWORD ControlExStyle;
32     DWORD MonitorsCount;
33     INT SelectedMonitor;
34     INT DraggingMonitor;
35     RECT rcDragging;
36     POINT ptDrag, ptDragBegin;
37     SIZE DraggingMargin;
38     PMONSL_MONINFO MonitorInfo;
39     PMONSL_MON Monitors;
40     RECT rcExtent;
41     RECT rcMonitors;
42     RECT rcOldMonitors;
43     POINT ScrollPos;
44     SIZE Margin;
45     SIZE SelectionFrame;
46     HBITMAP hbmDisabledPattern;
47     HBRUSH hbrDisabled;
48 } MONITORSELWND, *PMONITORSELWND;
49 
50 static LRESULT
51 MonSelNotify(IN PMONITORSELWND infoPtr,
52              IN UINT code,
53              IN OUT PVOID data)
54 {
55     LRESULT Ret = 0;
56 
57     if (infoPtr->hNotify != NULL)
58     {
59         LPNMHDR pnmh = (LPNMHDR)data;
60 
61         pnmh->hwndFrom = infoPtr->hSelf;
62         pnmh->idFrom = GetWindowLongPtr(infoPtr->hSelf,
63                                         GWLP_ID);
64         pnmh->code = code;
65 
66         Ret = SendMessage(infoPtr->hNotify,
67                           WM_NOTIFY,
68                           (WPARAM)pnmh->idFrom,
69                           (LPARAM)pnmh);
70     }
71 
72     return Ret;
73 }
74 
75 static LRESULT
76 MonSelNotifyMonitor(IN PMONITORSELWND infoPtr,
77                     IN UINT code,
78                     IN INT Index,
79                     IN OUT PMONSL_MONNMHDR pmonnmh)
80 {
81     pmonnmh->Index = Index;
82 
83     if (Index >= 0)
84     {
85         pmonnmh->MonitorInfo = infoPtr->MonitorInfo[Index];
86     }
87     else
88     {
89         ZeroMemory(&pmonnmh->MonitorInfo,
90                    sizeof(pmonnmh->MonitorInfo));
91     }
92 
93     return MonSelNotify(infoPtr,
94                         code,
95                         pmonnmh);
96 }
97 
98 static HFONT
99 MonSelChangeFont(IN OUT PMONITORSELWND infoPtr,
100                  IN HFONT hFont,
101                  IN BOOL Redraw)
102 {
103     HFONT hOldFont = infoPtr->hFont;
104     infoPtr->hFont = hFont;
105 
106     if (Redraw)
107     {
108         InvalidateRect(infoPtr->hSelf,
109                        NULL,
110                        TRUE);
111     }
112 
113     return hOldFont;
114 }
115 
116 static VOID
117 MonSelRectToScreen(IN PMONITORSELWND infoPtr,
118                    IN const RECT *prc,
119                    OUT PRECT prcOnScreen)
120 {
121     *prcOnScreen = *prc;
122     OffsetRect(prcOnScreen,
123                -infoPtr->ScrollPos.x,
124                -infoPtr->ScrollPos.y);
125 }
126 
127 static VOID
128 MonSelScreenToPt(IN PMONITORSELWND infoPtr,
129                  IN const POINT *pptOnScreen,
130                  OUT PPOINT ppt)
131 {
132     ppt->x = pptOnScreen->x + infoPtr->ScrollPos.x;
133     ppt->y = pptOnScreen->y + infoPtr->ScrollPos.y;
134 }
135 
136 static VOID
137 MonSelMonInfoToRect(IN const MONSL_MONINFO *pMonInfo,
138                     OUT PRECT prc)
139 {
140     prc->left = pMonInfo->Position.x;
141     prc->top = pMonInfo->Position.y;
142     prc->right = pMonInfo->Position.x + pMonInfo->Size.cx;
143     prc->bottom = pMonInfo->Position.y + pMonInfo->Size.cy;
144 }
145 
146 static INT
147 MonSelHitTest(IN PMONITORSELWND infoPtr,
148               IN const POINT *ppt)
149 {
150     POINT pt;
151     INT Index, Ret = -1;
152 
153     if (infoPtr->CanDisplay)
154     {
155         MonSelScreenToPt(infoPtr,
156                          ppt,
157                          &pt);
158 
159         for (Index = 0; Index < (INT)infoPtr->MonitorsCount; Index++)
160         {
161             if (PtInRect(&infoPtr->Monitors[Index].rc,
162                          pt))
163             {
164                 Ret = Index;
165                 break;
166             }
167         }
168     }
169 
170     return Ret;
171 }
172 
173 static VOID
174 MonSelUpdateExtent(IN OUT PMONITORSELWND infoPtr)
175 {
176     DWORD Index;
177     RECT rcMonitor;
178 
179     /* NOTE: This routine calculates the extent of all monitor coordinates.
180              These are not control coordinates! */
181     if (infoPtr->MonitorsCount > 0)
182     {
183         MonSelMonInfoToRect(&infoPtr->MonitorInfo[0],
184                             &infoPtr->rcExtent);
185 
186         for (Index = 1; Index < infoPtr->MonitorsCount; Index++)
187         {
188             MonSelMonInfoToRect(&infoPtr->MonitorInfo[Index],
189                                 &rcMonitor);
190 
191             UnionRect(&infoPtr->rcExtent,
192                       &infoPtr->rcExtent,
193                       &rcMonitor);
194         }
195     }
196     else
197     {
198         ZeroMemory(&infoPtr->rcExtent,
199                    sizeof(infoPtr->rcExtent));
200     }
201 }
202 
203 static VOID
204 MonSelScaleRectRelative(IN const RECT *prcBaseFrom,
205                         IN const RECT *prcFrom,
206                         IN const RECT *prcBaseTo,
207                         OUT PRECT prcTo)
208 {
209     SIZE BaseFrom, BaseTo, From;
210 
211     BaseFrom.cx = prcBaseFrom->right - prcBaseFrom->left;
212     BaseFrom.cy = prcBaseFrom->bottom - prcBaseFrom->top;
213     BaseTo.cx = prcBaseTo->right - prcBaseTo->left;
214     BaseTo.cy = prcBaseTo->bottom - prcBaseTo->top;
215     From.cx = prcFrom->right - prcFrom->left;
216     From.cy = prcFrom->bottom - prcFrom->top;
217 
218     prcTo->left = prcBaseTo->left + (((prcFrom->left - prcBaseFrom->left) * BaseTo.cx) / BaseFrom.cx);
219     prcTo->top = prcBaseTo->top + (((prcFrom->top - prcBaseFrom->top) * BaseTo.cy) / BaseFrom.cy);
220     prcTo->right = prcTo->left + ((From.cx * BaseTo.cx) / BaseFrom.cx);
221     prcTo->bottom = prcTo->top + ((From.cy * BaseTo.cy) / BaseFrom.cy);
222 }
223 
224 static VOID
225 ScaleRectSizeFit(IN const RECT *prcContainerRect,
226                  IN OUT PRECT prcRectToScale)
227 {
228     SIZE ContainerSize, RectSize;
229 
230     ContainerSize.cx = prcContainerRect->right - prcContainerRect->left;
231     ContainerSize.cy = prcContainerRect->bottom - prcContainerRect->top;
232     RectSize.cx = prcRectToScale->right - prcRectToScale->left;
233     RectSize.cy = prcRectToScale->bottom - prcRectToScale->top;
234 
235     if (((RectSize.cx * 0xFFF) / RectSize.cy) < ((ContainerSize.cx * 0xFFF) / ContainerSize.cy))
236     {
237         RectSize.cx = (RectSize.cx * ((ContainerSize.cy * 0xFFF) / RectSize.cy)) / 0xFFF;
238         RectSize.cy = ContainerSize.cy;
239     }
240     else
241     {
242         RectSize.cy = (RectSize.cy * ((ContainerSize.cx * 0xFFF) / RectSize.cx)) / 0xFFF;
243         RectSize.cx = ContainerSize.cx;
244     }
245 
246     prcRectToScale->right = prcRectToScale->left + RectSize.cx;
247     prcRectToScale->bottom = prcRectToScale->top + RectSize.cy;
248 
249     OffsetRect(prcRectToScale,
250                prcContainerRect->left + ((ContainerSize.cx - RectSize.cx) / 2),
251                prcContainerRect->top + ((ContainerSize.cy - RectSize.cy) / 2));
252 }
253 
254 static VOID
255 MonSelRepaint(IN PMONITORSELWND infoPtr)
256 {
257     RECT rc;
258 
259     MonSelRectToScreen(infoPtr,
260                        &infoPtr->rcMonitors,
261                        &rc);
262     InvalidateRect(infoPtr->hSelf,
263                    &rc,
264                    TRUE);
265 
266     if (!EqualRect(&infoPtr->rcMonitors, &infoPtr->rcOldMonitors) &&
267         infoPtr->rcOldMonitors.right != infoPtr->rcOldMonitors.left)
268     {
269         MonSelRectToScreen(infoPtr, &infoPtr->rcOldMonitors, &rc);
270         InvalidateRect(infoPtr->hSelf, &rc, TRUE);
271         infoPtr->rcOldMonitors = infoPtr->rcMonitors;
272     }
273 }
274 
275 static VOID
276 MonSelRepaintMonitor(IN PMONITORSELWND infoPtr,
277                      IN DWORD Index)
278 {
279     RECT rc;
280     BOOL NoRepaint = FALSE;
281 
282     if (Index < infoPtr->MonitorsCount)
283     {
284         if (Index == (DWORD)infoPtr->DraggingMonitor)
285         {
286             if (infoPtr->IsDraggingMonitor)
287             {
288                 MonSelRectToScreen(infoPtr,
289                                    &infoPtr->rcDragging,
290                                    &rc);
291             }
292             else
293                 NoRepaint = TRUE;
294         }
295         else
296         {
297             MonSelRectToScreen(infoPtr,
298                                &infoPtr->Monitors[Index].rc,
299                                &rc);
300         }
301 
302         if (!NoRepaint)
303         {
304             InvalidateRect(infoPtr->hSelf,
305                            &rc,
306                            TRUE);
307         }
308     }
309 }
310 
311 static VOID
312 MonSelRepaintSelected(IN PMONITORSELWND infoPtr)
313 {
314     if (infoPtr->SelectedMonitor >= 0)
315     {
316         MonSelRepaintMonitor(infoPtr,
317                              (DWORD)infoPtr->SelectedMonitor);
318     }
319 }
320 
321 static VOID
322 MonSelResetMonitors(IN OUT PMONITORSELWND infoPtr)
323 {
324     DWORD Index;
325 
326     for (Index = 0; Index < infoPtr->MonitorsCount; Index++)
327     {
328         if (infoPtr->Monitors[Index].hFont != NULL)
329         {
330             DeleteObject(infoPtr->Monitors[Index].hFont);
331             infoPtr->Monitors[Index].hFont = NULL;
332         }
333     }
334 }
335 
336 
337 static VOID
338 MonSelUpdateMonitorsInfo(IN OUT PMONITORSELWND infoPtr,
339                          IN BOOL bRepaint)
340 {
341     RECT rcExtSurface, rcExtDisplay;
342     DWORD Index;
343 
344     /* Recalculate rcExtent */
345     MonSelUpdateExtent(infoPtr);
346 
347     infoPtr-> CanDisplay = infoPtr->MonitorsCount != 0 &&
348                            (infoPtr->ClientSize.cx > (2 * (infoPtr->Margin.cx + infoPtr->SelectionFrame.cx))) &&
349                            (infoPtr->ClientSize.cy > (2 * (infoPtr->Margin.cy + infoPtr->SelectionFrame.cy)));
350 
351     if (infoPtr->CanDisplay)
352     {
353         /* Calculate the rectangle on the control in which may be painted */
354         rcExtSurface.left = infoPtr->Margin.cx;
355         rcExtSurface.top = infoPtr->Margin.cy;
356         rcExtSurface.right = rcExtSurface.left + infoPtr->ClientSize.cx - (2 * infoPtr->Margin.cx);
357         rcExtSurface.bottom = rcExtSurface.top + infoPtr->ClientSize.cy - (2 * infoPtr->Margin.cy);
358 
359         /* Calculate the rectangle on the control that is actually painted on */
360         rcExtDisplay.left = rcExtDisplay.top = 0;
361         rcExtDisplay.right = infoPtr->rcExtent.right - infoPtr->rcExtent.left;
362         rcExtDisplay.bottom = infoPtr->rcExtent.bottom - infoPtr->rcExtent.top;
363 
364         ScaleRectSizeFit(&rcExtSurface,
365                          &rcExtDisplay);
366 
367         infoPtr->rcOldMonitors = infoPtr->rcMonitors;
368         infoPtr->rcMonitors = rcExtDisplay;
369 
370         /* Now that we know in which area all monitors are located,
371            calculate the monitors selection rectangles on the screen */
372 
373         for (Index = 0; Index < infoPtr->MonitorsCount; Index++)
374         {
375             MonSelMonInfoToRect(&infoPtr->MonitorInfo[Index],
376                                 &rcExtDisplay);
377 
378             MonSelScaleRectRelative(&infoPtr->rcExtent,
379                                     &rcExtDisplay,
380                                     &infoPtr->rcMonitors,
381                                     &infoPtr->Monitors[Index].rc);
382         }
383 
384         MonSelResetMonitors(infoPtr);
385 
386         if (bRepaint)
387             MonSelRepaint(infoPtr);
388     }
389     else if (bRepaint)
390     {
391         InvalidateRect(infoPtr->hSelf,
392                        NULL,
393                        TRUE);
394     }
395 }
396 
397 static BOOL
398 MonSelSetMonitorsInfo(IN OUT PMONITORSELWND infoPtr,
399                       IN DWORD dwMonitors,
400                       IN const MONSL_MONINFO *MonitorsInfo)
401 {
402     DWORD Index;
403     BOOL Ret = TRUE;
404 
405     if (infoPtr->DraggingMonitor >= 0)
406         return FALSE;
407 
408     if (infoPtr->MonitorInfo != NULL)
409     {
410         LocalFree((HLOCAL)infoPtr->MonitorInfo);
411         infoPtr->MonitorInfo = NULL;
412 
413         MonSelResetMonitors(infoPtr);
414 
415         LocalFree((HLOCAL)infoPtr->Monitors);
416         infoPtr->Monitors = NULL;
417 
418         infoPtr->MonitorsCount = 0;
419     }
420 
421     if (dwMonitors != 0)
422     {
423         infoPtr->MonitorInfo = (PMONSL_MONINFO)LocalAlloc(LMEM_FIXED,
424                                                           dwMonitors * sizeof(MONSL_MONINFO));
425         if (infoPtr->MonitorInfo != NULL)
426         {
427             infoPtr->Monitors = (PMONSL_MON)LocalAlloc(LMEM_FIXED,
428                                                        dwMonitors * sizeof(MONSL_MON));
429             if (infoPtr->Monitors != NULL)
430             {
431                 CopyMemory(infoPtr->MonitorInfo,
432                            MonitorsInfo,
433                            dwMonitors * sizeof(MONSL_MONINFO));
434                 ZeroMemory(infoPtr->Monitors,
435                            dwMonitors * sizeof(MONSL_MON));
436 
437                 for (Index = 0; Index < dwMonitors; Index++)
438                 {
439                     _stprintf(infoPtr->Monitors[Index].szCaption,
440                               _T("%u"),
441                               Index + 1);
442                 }
443 
444                 infoPtr->MonitorsCount = dwMonitors;
445 
446                 if (infoPtr->SelectedMonitor >= (INT)infoPtr->MonitorsCount)
447                     infoPtr->SelectedMonitor = -1;
448 
449                 if (!(infoPtr->ControlExStyle & MSLM_EX_ALLOWSELECTNONE) && infoPtr->SelectedMonitor < 0)
450                     infoPtr->SelectedMonitor = 0;
451 
452                 MonSelUpdateMonitorsInfo(infoPtr,
453                                          TRUE);
454             }
455             else
456             {
457                 LocalFree((HLOCAL)infoPtr->MonitorInfo);
458                 infoPtr->MonitorInfo = NULL;
459 
460                 Ret = FALSE;
461             }
462         }
463         else
464             Ret = FALSE;
465     }
466 
467     if (!Ret)
468         infoPtr->SelectedMonitor = -1;
469 
470     if (!Ret || dwMonitors == 0)
471     {
472         InvalidateRect(infoPtr->hSelf,
473                        NULL,
474                        TRUE);
475     }
476 
477     return Ret;
478 }
479 
480 static DWORD
481 MonSelGetMonitorsInfo(IN PMONITORSELWND infoPtr,
482                       IN DWORD dwMonitors,
483                       IN OUT PMONSL_MONINFO MonitorsInfo)
484 {
485     if (dwMonitors != 0)
486     {
487         if (dwMonitors > infoPtr->MonitorsCount)
488             dwMonitors = infoPtr->MonitorsCount;
489 
490         CopyMemory(MonitorsInfo,
491                    infoPtr->MonitorInfo,
492                    dwMonitors * sizeof(MONSL_MONINFO));
493         return dwMonitors;
494     }
495     else
496         return infoPtr->MonitorsCount;
497 }
498 
499 static BOOL
500 MonSelSetMonitorInfo(IN OUT PMONITORSELWND infoPtr,
501                      IN INT Index,
502                      IN const MONSL_MONINFO *MonitorsInfo)
503 {
504     if (infoPtr->DraggingMonitor < 0 &&
505         Index >= 0 && Index < (INT)infoPtr->MonitorsCount)
506     {
507         CopyMemory(&infoPtr->MonitorInfo[Index],
508                    MonitorsInfo,
509                    sizeof(MONSL_MONINFO));
510 
511         MonSelUpdateMonitorsInfo(infoPtr,
512                                  TRUE);
513         return TRUE;
514     }
515 
516     return FALSE;
517 }
518 
519 static BOOL
520 MonSelGetMonitorInfo(IN PMONITORSELWND infoPtr,
521                      IN INT Index,
522                      IN OUT PMONSL_MONINFO MonitorsInfo)
523 {
524     if (Index >= 0 && Index < (INT)infoPtr->MonitorsCount)
525     {
526         CopyMemory(MonitorsInfo,
527                    &infoPtr->MonitorInfo[Index],
528                    sizeof(MONSL_MONINFO));
529         return TRUE;
530     }
531 
532     return FALSE;
533 }
534 
535 static INT
536 MonSelGetMonitorRect(IN OUT PMONITORSELWND infoPtr,
537                      IN INT Index,
538                      OUT PRECT prc)
539 {
540     RECT rc, rcClient;
541 
542     if (Index < 0 || (UINT)Index >= infoPtr->MonitorsCount)
543         return -1;
544 
545     if (!infoPtr->CanDisplay)
546         return 0;
547 
548     MonSelRectToScreen(infoPtr,
549                        &infoPtr->Monitors[Index].rc,
550                        prc);
551 
552     rcClient.left = rcClient.top = 0;
553     rcClient.right = infoPtr->ClientSize.cx;
554     rcClient.bottom = infoPtr->ClientSize.cy;
555 
556     return IntersectRect(&rc,
557                          &rcClient,
558                          prc) != FALSE;
559 }
560 
561 static BOOL
562 MonSelSetCurSelMonitor(IN OUT PMONITORSELWND infoPtr,
563                        IN INT Index,
564                        IN BOOL bNotify)
565 {
566     INT PrevSel;
567     BOOL PreventSelect = FALSE;
568     BOOL Ret = FALSE;
569 
570     if (infoPtr->DraggingMonitor < 0 &&
571         (Index == -1 || Index < (INT)infoPtr->MonitorsCount))
572     {
573         if (Index != infoPtr->SelectedMonitor)
574         {
575             if ((infoPtr->MonitorInfo[Index].Flags & MSL_MIF_DISABLED) &&
576                 !(infoPtr->ControlExStyle & MSLM_EX_ALLOWSELECTDISABLED))
577             {
578                 PreventSelect = TRUE;
579             }
580 
581             if (!PreventSelect && bNotify)
582             {
583                 MONSL_MONNMMONITORCHANGING nmi;
584 
585                 nmi.PreviousSelected = infoPtr->SelectedMonitor;
586                 nmi.AllowChanging = TRUE;
587 
588                 MonSelNotifyMonitor(infoPtr,
589                                     MSLN_MONITORCHANGING,
590                                     Index,
591                                     &nmi.hdr);
592 
593                 PreventSelect = (nmi.AllowChanging == FALSE);
594             }
595 
596             if (!PreventSelect)
597             {
598                 PrevSel = infoPtr->SelectedMonitor;
599                 infoPtr->SelectedMonitor = Index;
600 
601                 if (PrevSel >= 0)
602                 {
603                     MonSelRepaintMonitor(infoPtr,
604                                          PrevSel);
605                 }
606 
607                 if (infoPtr->SelectedMonitor >= 0)
608                     MonSelRepaintSelected(infoPtr);
609 
610                 if (bNotify)
611                 {
612                     MONSL_MONNMHDR nm;
613 
614                     MonSelNotifyMonitor(infoPtr,
615                                         MSLN_MONITORCHANGED,
616                                         Index,
617                                         &nm);
618                 }
619             }
620         }
621 
622         Ret = TRUE;
623     }
624 
625     return Ret;
626 }
627 
628 static VOID
629 MonSelCreate(IN OUT PMONITORSELWND infoPtr)
630 {
631     infoPtr->SelectionFrame.cx = infoPtr->SelectionFrame.cy = 4;
632     infoPtr->Margin.cx = infoPtr->Margin.cy = 20;
633     infoPtr->SelectedMonitor = -1;
634     infoPtr->DraggingMonitor = -1;
635     infoPtr->ControlExStyle = MSLM_EX_ALLOWSELECTDISABLED | MSLM_EX_HIDENUMBERONSINGLE |
636         MSLM_EX_SELECTONRIGHTCLICK | MSLM_EX_SELECTBYARROWKEY;
637     return;
638 }
639 
640 static VOID
641 MonSelDestroy(IN OUT PMONITORSELWND infoPtr)
642 {
643     /* Free all monitors */
644     MonSelSetMonitorsInfo(infoPtr,
645                           0,
646                           NULL);
647 
648     if (infoPtr->hbrDisabled != NULL)
649     {
650         DeleteObject(infoPtr->hbrDisabled);
651         infoPtr->hbrDisabled = NULL;
652     }
653 
654     if (infoPtr->hbmDisabledPattern != NULL)
655     {
656         DeleteObject(infoPtr->hbmDisabledPattern);
657         infoPtr->hbmDisabledPattern = NULL;
658     }
659 }
660 
661 static BOOL
662 MonSelSetExtendedStyle(IN OUT PMONITORSELWND infoPtr,
663                        IN DWORD dwExtendedStyle)
664 {
665     if (infoPtr->DraggingMonitor >= 0)
666         return FALSE;
667 
668     if (dwExtendedStyle != infoPtr->ControlExStyle)
669     {
670         infoPtr->ControlExStyle = dwExtendedStyle;
671 
672         /* Repaint the control */
673         InvalidateRect(infoPtr->hSelf,
674                        NULL,
675                        TRUE);
676     }
677 
678     return TRUE;
679 }
680 
681 static DWORD
682 MonSelGetExtendedStyle(IN PMONITORSELWND infoPtr)
683 {
684     return infoPtr->ControlExStyle;
685 }
686 
687 static HFONT
688 MonSelGetMonitorFont(IN OUT PMONITORSELWND infoPtr,
689                      IN HDC hDC,
690                      IN INT Index)
691 {
692     TEXTMETRIC tm;
693     SIZE rcsize;
694     LOGFONT lf;
695     HFONT hPrevFont, hFont;
696     //INT len;
697 
698     hFont = infoPtr->Monitors[Index].hFont;
699     if (hFont == NULL &&
700         GetObject(infoPtr->hFont,
701                   sizeof(lf),
702                   &lf) != 0)
703     {
704         rcsize.cx = infoPtr->Monitors[Index].rc.right - infoPtr->Monitors[Index].rc.left -
705                     (2 * infoPtr->SelectionFrame.cx) - 2;
706         rcsize.cy = infoPtr->Monitors[Index].rc.bottom - infoPtr->Monitors[Index].rc.top -
707                     (2 * infoPtr->SelectionFrame.cy) - 2;
708         rcsize.cy = (rcsize.cy * 60) / 100;
709 
710         //len = _tcslen(infoPtr->Monitors[Index].szCaption);
711 
712         hPrevFont = SelectObject(hDC,
713                                  infoPtr->hFont);
714 
715         if (GetTextMetrics(hDC,
716                            &tm))
717         {
718             lf.lfWeight = FW_SEMIBOLD;
719             lf.lfHeight = -MulDiv(rcsize.cy - tm.tmExternalLeading,
720                                   GetDeviceCaps(hDC,
721                                                 LOGPIXELSY),
722                                   72);
723 
724             hFont = CreateFontIndirect(&lf);
725             if (hFont != NULL)
726                 infoPtr->Monitors[Index].hFont = hFont;
727         }
728 
729         SelectObject(hDC,
730                      hPrevFont);
731     }
732 
733     return hFont;
734 }
735 
736 static BOOL
737 MonSelDrawDisabledRect(IN OUT PMONITORSELWND infoPtr,
738                        IN HDC hDC,
739                        IN const RECT *prc)
740 {
741     BOOL Ret = FALSE;
742 
743     if (infoPtr->hbrDisabled == NULL)
744     {
745         static const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
746 
747         if (infoPtr->hbmDisabledPattern == NULL)
748         {
749             infoPtr->hbmDisabledPattern = CreateBitmap(8,
750                                                        8,
751                                                        1,
752                                                        1,
753                                                        Pattern);
754         }
755 
756         if (infoPtr->hbmDisabledPattern != NULL)
757             infoPtr->hbrDisabled = CreatePatternBrush(infoPtr->hbmDisabledPattern);
758     }
759 
760     if (infoPtr->hbrDisabled != NULL)
761     {
762         /* FIXME: Implement */
763     }
764 
765     return Ret;
766 }
767 
768 static VOID
769 MonSelPaintMonitor(IN OUT PMONITORSELWND infoPtr,
770                    IN HDC hDC,
771                    IN DWORD Index,
772                    IN OUT PRECT prc,
773                    IN COLORREF crDefFontColor,
774                    IN BOOL bHideNumber)
775 {
776     HFONT hFont, hPrevFont;
777     COLORREF crPrevText;
778 
779     if ((INT)Index == infoPtr->SelectedMonitor)
780     {
781         FillRect(hDC,
782                  prc,
783                  (HBRUSH)(COLOR_HIGHLIGHT + 1));
784 
785         if (infoPtr->HasFocus && !(infoPtr->UIState & UISF_HIDEFOCUS))
786         {
787             /* NOTE: We need to switch the text color to the default, because
788                      DrawFocusRect draws a solid line if the text is white! */
789 
790             crPrevText = SetTextColor(hDC,
791                                       crDefFontColor);
792 
793             DrawFocusRect(hDC,
794                           prc);
795 
796             SetTextColor(hDC,
797                          crPrevText);
798         }
799     }
800 
801     InflateRect(prc,
802                 -infoPtr->SelectionFrame.cx,
803                 -infoPtr->SelectionFrame.cy);
804 
805     Rectangle(hDC,
806               prc->left,
807               prc->top,
808               prc->right,
809               prc->bottom);
810 
811     InflateRect(prc,
812                 -1,
813                 -1);
814 
815     if (!bHideNumber)
816     {
817         hFont = MonSelGetMonitorFont(infoPtr,
818                                      hDC,
819                                      Index);
820         if (hFont != NULL)
821         {
822             hPrevFont = SelectObject(hDC,
823                                      hFont);
824 
825             DrawText(hDC,
826                      infoPtr->Monitors[Index].szCaption,
827                      -1,
828                      prc,
829                      DT_VCENTER | DT_CENTER | DT_NOPREFIX | DT_SINGLELINE);
830 
831             SelectObject(hDC,
832                          hPrevFont);
833         }
834     }
835 
836     if (infoPtr->MonitorInfo[Index].Flags & MSL_MIF_DISABLED)
837     {
838         InflateRect(prc,
839                     1,
840                     1);
841 
842         MonSelDrawDisabledRect(infoPtr,
843                                hDC,
844                                prc);
845     }
846 }
847 
848 static VOID
849 MonSelPaint(IN OUT PMONITORSELWND infoPtr,
850             IN HDC hDC,
851             IN const RECT *prcUpdate)
852 {
853     COLORREF crPrevText;
854     HBRUSH hbBk, hbOldBk;
855     HPEN hpFg, hpOldFg;
856     DWORD Index;
857     RECT rc, rctmp;
858     INT iPrevBkMode;
859     BOOL bHideNumber;
860 
861     bHideNumber = (infoPtr->ControlExStyle & MSLM_EX_HIDENUMBERS) ||
862         ((infoPtr->MonitorsCount == 1) && (infoPtr->ControlExStyle & MSLM_EX_HIDENUMBERONSINGLE));
863 
864     hbBk = GetSysColorBrush(COLOR_BACKGROUND);
865     hpFg = CreatePen(PS_SOLID,
866                      0,
867                      GetSysColor(COLOR_HIGHLIGHTTEXT));
868 
869     hbOldBk = SelectObject(hDC,
870                            hbBk);
871     hpOldFg = SelectObject(hDC,
872                            hpFg);
873     iPrevBkMode = SetBkMode(hDC,
874                             TRANSPARENT);
875     crPrevText = SetTextColor(hDC,
876                               GetSysColor(COLOR_HIGHLIGHTTEXT));
877 
878     for (Index = 0; Index < infoPtr->MonitorsCount; Index++)
879     {
880         if (infoPtr->IsDraggingMonitor &&
881             (DWORD)infoPtr->DraggingMonitor == Index)
882         {
883             continue;
884         }
885 
886         MonSelRectToScreen(infoPtr,
887                            &infoPtr->Monitors[Index].rc,
888                            &rc);
889 
890         if (IntersectRect(&rctmp,
891                           &rc,
892                           prcUpdate))
893         {
894             MonSelPaintMonitor(infoPtr,
895                                hDC,
896                                Index,
897                                &rc,
898                                crPrevText,
899                                bHideNumber);
900         }
901     }
902 
903     /* Paint the dragging monitor last */
904     if (infoPtr->IsDraggingMonitor &&
905         infoPtr->DraggingMonitor >= 0)
906     {
907         MonSelRectToScreen(infoPtr,
908                            &infoPtr->rcDragging,
909                            &rc);
910 
911         if (IntersectRect(&rctmp,
912                           &rc,
913                           prcUpdate))
914         {
915             MonSelPaintMonitor(infoPtr,
916                                hDC,
917                                (DWORD)infoPtr->DraggingMonitor,
918                                &rc,
919                                crPrevText,
920                                bHideNumber);
921         }
922     }
923 
924     SetTextColor(hDC,
925                  crPrevText);
926     SetBkMode(hDC,
927               iPrevBkMode);
928     SelectObject(hDC,
929                  hpOldFg);
930     SelectObject(hDC,
931                  hbOldBk);
932 
933     DeleteObject(hpFg);
934 }
935 
936 static VOID
937 MonSelContextMenu(IN OUT PMONITORSELWND infoPtr,
938                   IN SHORT x,
939                   IN SHORT y)
940 {
941     MONSL_MONNMBUTTONCLICKED nm;
942     INT Index;
943 
944     if (!infoPtr->HasFocus)
945         SetFocus(infoPtr->hSelf);
946 
947     nm.pt.x = x;
948     nm.pt.y = y;
949 
950     Index = MonSelHitTest(infoPtr,
951                           &nm.pt);
952 
953     MonSelNotifyMonitor(infoPtr,
954                         MSLN_RBUTTONUP,
955                         Index,
956                         (PMONSL_MONNMHDR)&nm);
957 
958     /* Send a WM_CONTEXTMENU notification */
959     MapWindowPoints(infoPtr->hSelf,
960                     NULL,
961                     &nm.pt,
962                     1);
963 
964     SendMessage(infoPtr->hSelf,
965                 WM_CONTEXTMENU,
966                 (WPARAM)infoPtr->hSelf,
967                 MAKELPARAM(nm.pt.x,
968                            nm.pt.y));
969 }
970 
971 static VOID
972 MonSelApplyCursorClipping(IN PMONITORSELWND infoPtr,
973                           IN BOOL bClip)
974 {
975     RECT rc;
976 
977     if (bClip)
978     {
979         rc.left = rc.top = 0;
980         rc.right = infoPtr->ClientSize.cx;
981         rc.bottom = infoPtr->ClientSize.cy;
982 
983         if (MapWindowPoints(infoPtr->hSelf,
984                             NULL,
985                             (LPPOINT)&rc,
986                             2))
987         {
988             ClipCursor(&rc);
989         }
990     }
991     else
992     {
993         ClipCursor(NULL);
994     }
995 }
996 
997 static VOID
998 MonSelMoveDragRect(IN OUT PMONITORSELWND infoPtr,
999                    IN PPOINT ppt)
1000 {
1001     RECT rcPrev, rcUpdate, *prc;
1002     HRGN hRgnPrev;
1003     HDC hDC;
1004 
1005     if (infoPtr->CanDisplay)
1006     {
1007         hDC = GetDC(infoPtr->hSelf);
1008         if (hDC != NULL)
1009         {
1010             if (infoPtr->ptDrag.x != ppt->x ||
1011                 infoPtr->ptDrag.y != ppt->y)
1012             {
1013                 infoPtr->ptDrag = *ppt;
1014 
1015                 rcPrev = infoPtr->rcDragging;
1016 
1017                 /* Calculate updated dragging rectangle */
1018                 prc = &infoPtr->Monitors[infoPtr->DraggingMonitor].rc;
1019                 infoPtr->rcDragging.left = ppt->x - infoPtr->DraggingMargin.cx;
1020                 infoPtr->rcDragging.top = ppt->y - infoPtr->DraggingMargin.cy;
1021                 infoPtr->rcDragging.right = infoPtr->rcDragging.left + (prc->right - prc->left);
1022                 infoPtr->rcDragging.bottom = infoPtr->rcDragging.top + (prc->bottom - prc->top);
1023 
1024                 hRgnPrev = CreateRectRgn(rcPrev.left,
1025                                          rcPrev.top,
1026                                          rcPrev.right,
1027                                          rcPrev.bottom);
1028 
1029                 if (hRgnPrev != NULL)
1030                 {
1031                     if (!ScrollDC(hDC,
1032                                   infoPtr->rcDragging.left - rcPrev.left,
1033                                   infoPtr->rcDragging.top - rcPrev.top,
1034                                   &rcPrev,
1035                                   NULL,
1036                                   hRgnPrev,
1037                                   &rcUpdate) ||
1038                         !InvalidateRgn(infoPtr->hSelf,
1039                                        hRgnPrev,
1040                                        TRUE))
1041                     {
1042                         DeleteObject(hRgnPrev);
1043                         goto InvRects;
1044                     }
1045 
1046                     DeleteObject(hRgnPrev);
1047                 }
1048                 else
1049                 {
1050 InvRects:
1051                     InvalidateRect(infoPtr->hSelf,
1052                                    &rcPrev,
1053                                    TRUE);
1054                     InvalidateRect(infoPtr->hSelf,
1055                                    &infoPtr->rcDragging,
1056                                    TRUE);
1057                 }
1058             }
1059 
1060             ReleaseDC(infoPtr->hSelf,
1061                       hDC);
1062         }
1063     }
1064 }
1065 
1066 static VOID
1067 MonSelCancelDragging(IN OUT PMONITORSELWND infoPtr)
1068 {
1069     DWORD Index;
1070 
1071     if (infoPtr->DraggingMonitor >= 0)
1072     {
1073         MonSelMoveDragRect(infoPtr,
1074                            &infoPtr->ptDragBegin);
1075 
1076         Index = (DWORD)infoPtr->DraggingMonitor;
1077         infoPtr->DraggingMonitor = -1;
1078 
1079         if (infoPtr->CanDisplay)
1080         {
1081             /* Repaint the area where the monitor was last dragged */
1082             MonSelRepaintMonitor(infoPtr,
1083                                  Index);
1084 
1085             infoPtr->IsDraggingMonitor = FALSE;
1086 
1087             /* Repaint the area where the monitor is located */
1088             MonSelRepaintMonitor(infoPtr,
1089                                  Index);
1090         }
1091         else
1092             infoPtr->IsDraggingMonitor = FALSE;
1093 
1094         ReleaseCapture();
1095 
1096         MonSelApplyCursorClipping(infoPtr,
1097                                   FALSE);
1098     }
1099 }
1100 
1101 static VOID
1102 MonSelInitDragging(IN OUT PMONITORSELWND infoPtr,
1103                    IN DWORD Index,
1104                    IN PPOINT ppt)
1105 {
1106     POINT pt;
1107 
1108     MonSelCancelDragging(infoPtr);
1109     infoPtr->IsDraggingMonitor = FALSE;
1110 
1111     MonSelScreenToPt(infoPtr,
1112                      ppt,
1113                      &pt);
1114 
1115     infoPtr->ptDrag = infoPtr->ptDragBegin = pt;
1116     infoPtr->DraggingMonitor = (INT)Index;
1117 
1118     infoPtr->DraggingMargin.cx = ppt->x - infoPtr->Monitors[Index].rc.left;
1119     infoPtr->DraggingMargin.cy = ppt->y - infoPtr->Monitors[Index].rc.top;
1120     infoPtr->rcDragging = infoPtr->Monitors[Index].rc;
1121 
1122     MonSelApplyCursorClipping(infoPtr,
1123                               TRUE);
1124 }
1125 
1126 static VOID
1127 MonSelDrag(IN OUT PMONITORSELWND infoPtr,
1128            IN PPOINT ppt)
1129 {
1130     SIZE szDrag;
1131     POINT pt;
1132     RECT rcDrag;
1133 
1134     if (infoPtr->DraggingMonitor >= 0)
1135     {
1136         MonSelScreenToPt(infoPtr,
1137                          ppt,
1138                          &pt);
1139 
1140         if (!infoPtr->IsDraggingMonitor)
1141         {
1142             szDrag.cx = GetSystemMetrics(SM_CXDRAG);
1143             szDrag.cy = GetSystemMetrics(SM_CYDRAG);
1144 
1145             rcDrag.left = infoPtr->Monitors[infoPtr->DraggingMonitor].rc.left + infoPtr->DraggingMargin.cx - (szDrag.cx / 2);
1146             rcDrag.top = infoPtr->Monitors[infoPtr->DraggingMonitor].rc.top + infoPtr->DraggingMargin.cy - (szDrag.cy / 2);
1147             rcDrag.right = rcDrag.left + szDrag.cx;
1148             rcDrag.bottom = rcDrag.top + szDrag.cy;
1149 
1150             if (!PtInRect(&rcDrag,
1151                           pt))
1152             {
1153                 /* The user started moving around the mouse: Begin dragging */
1154                 infoPtr->IsDraggingMonitor = TRUE;
1155                 MonSelMoveDragRect(infoPtr,
1156                                    &pt);
1157             }
1158         }
1159         else
1160         {
1161             MonSelMoveDragRect(infoPtr,
1162                                &pt);
1163         }
1164     }
1165 }
1166 
1167 static LRESULT CALLBACK
1168 MonitorSelWndProc(IN HWND hwnd,
1169                   IN UINT uMsg,
1170                   IN WPARAM wParam,
1171                   IN LPARAM lParam)
1172 {
1173     PMONITORSELWND infoPtr;
1174     LRESULT Ret = 0;
1175 
1176     infoPtr = (PMONITORSELWND)GetWindowLongPtrW(hwnd,
1177                                                 0);
1178 
1179     if (infoPtr == NULL && uMsg != WM_CREATE)
1180     {
1181         goto HandleDefaultMessage;
1182     }
1183 
1184     switch (uMsg)
1185     {
1186         case WM_PAINT:
1187         case WM_PRINTCLIENT:
1188         {
1189             PAINTSTRUCT ps;
1190             HDC hDC;
1191 
1192             if (wParam != 0)
1193             {
1194                 if (!GetUpdateRect(hwnd,
1195                                    &ps.rcPaint,
1196                                    TRUE))
1197                 {
1198                     break;
1199                 }
1200                 hDC = (HDC)wParam;
1201             }
1202             else
1203             {
1204                 hDC = BeginPaint(hwnd,
1205                                  &ps);
1206                 if (hDC == NULL)
1207                 {
1208                     break;
1209                 }
1210             }
1211 
1212             if (infoPtr->CanDisplay)
1213             {
1214                 MonSelPaint(infoPtr,
1215                             hDC,
1216                             &ps.rcPaint);
1217             }
1218 
1219             if (wParam == 0)
1220             {
1221                 EndPaint(hwnd,
1222                          &ps);
1223             }
1224             break;
1225         }
1226 
1227         case WM_MOUSEMOVE:
1228         {
1229             POINT pt;
1230 
1231             if (!(wParam & MK_LBUTTON))
1232             {
1233                 MonSelCancelDragging(infoPtr);
1234                 break;
1235             }
1236 
1237             if (infoPtr->LeftBtnDown)
1238             {
1239                 pt.x = (LONG)LOWORD(lParam);
1240                 pt.y = (LONG)HIWORD(lParam);
1241 
1242                 MonSelDrag(infoPtr,
1243                            &pt);
1244             }
1245 
1246             break;
1247         }
1248 
1249         case WM_RBUTTONDOWN:
1250         {
1251             if (!(infoPtr->ControlExStyle & MSLM_EX_SELECTONRIGHTCLICK))
1252                 break;
1253 
1254             /* Fall through */
1255         }
1256 
1257         case WM_LBUTTONDBLCLK:
1258         case WM_LBUTTONDOWN:
1259         {
1260             INT Index;
1261             POINT pt;
1262 
1263             if (!infoPtr->HasFocus)
1264                 SetFocus(infoPtr->hSelf);
1265 
1266             pt.x = (LONG)LOWORD(lParam);
1267             pt.y = (LONG)HIWORD(lParam);
1268 
1269             Index = MonSelHitTest(infoPtr,
1270                                   &pt);
1271             if (Index >= 0 || (infoPtr->ControlExStyle & MSLM_EX_ALLOWSELECTNONE))
1272             {
1273                 MonSelSetCurSelMonitor(infoPtr,
1274                                        Index,
1275                                        TRUE);
1276             }
1277 
1278             if (Index >= 0 && (uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK))
1279             {
1280                 infoPtr->LeftBtnDown = TRUE;
1281                 MonSelInitDragging(infoPtr,
1282                                    (DWORD)Index,
1283                                    &pt);
1284             }
1285 
1286             /* Fall through */
1287         }
1288 
1289         case WM_MBUTTONDOWN:
1290         {
1291             if (!infoPtr->HasFocus)
1292                 SetFocus(hwnd);
1293             break;
1294         }
1295 
1296         case WM_RBUTTONUP:
1297         {
1298             MonSelContextMenu(infoPtr,
1299                               (SHORT)LOWORD(lParam),
1300                               (SHORT)HIWORD(lParam));
1301             break;
1302         }
1303 
1304         case WM_LBUTTONUP:
1305         {
1306             MonSelCancelDragging(infoPtr);
1307             infoPtr->LeftBtnDown = FALSE;
1308             break;
1309         }
1310 
1311         case WM_GETDLGCODE:
1312         {
1313             INT virtKey;
1314 
1315             virtKey = (lParam != 0 ? (INT)((LPMSG)lParam)->wParam : 0);
1316             switch (virtKey)
1317             {
1318                 case VK_TAB:
1319                 {
1320                     /* Change the UI status */
1321                     SendMessage(GetAncestor(hwnd,
1322                                             GA_PARENT),
1323                                 WM_CHANGEUISTATE,
1324                                 MAKEWPARAM(UIS_INITIALIZE,
1325                                            0),
1326                                 0);
1327                     break;
1328                 }
1329             }
1330 
1331             Ret |= DLGC_WANTARROWS;
1332 
1333             if (infoPtr->ControlExStyle & MSLM_EX_SELECTBYNUMKEY)
1334                 Ret |= DLGC_WANTCHARS;
1335             break;
1336         }
1337 
1338         case WM_SETFOCUS:
1339         {
1340             infoPtr->HasFocus = TRUE;
1341             MonSelRepaintSelected(infoPtr);
1342             break;
1343         }
1344 
1345         case WM_KILLFOCUS:
1346         {
1347             infoPtr->HasFocus = FALSE;
1348             MonSelCancelDragging(infoPtr);
1349             MonSelRepaintSelected(infoPtr);
1350             break;
1351         }
1352 
1353         case WM_UPDATEUISTATE:
1354         {
1355             DWORD OldUIState;
1356 
1357             Ret = DefWindowProcW(hwnd,
1358                                  uMsg,
1359                                  wParam,
1360                                  lParam);
1361 
1362             OldUIState = infoPtr->UIState;
1363             switch (LOWORD(wParam))
1364             {
1365                 case UIS_SET:
1366                     infoPtr->UIState |= HIWORD(wParam);
1367                     break;
1368 
1369                 case UIS_CLEAR:
1370                     infoPtr->UIState &= ~HIWORD(wParam);
1371                     break;
1372             }
1373 
1374             if (infoPtr->UIState != OldUIState)
1375                 MonSelRepaintSelected(infoPtr);
1376             break;
1377         }
1378 
1379         case WM_SETFONT:
1380         {
1381             Ret = (LRESULT)MonSelChangeFont(infoPtr,
1382                                             (HFONT)wParam,
1383                                             (BOOL)LOWORD(lParam));
1384             break;
1385         }
1386 
1387         case WM_SIZE:
1388         {
1389             infoPtr->ClientSize.cx = LOWORD(lParam);
1390             infoPtr->ClientSize.cy = HIWORD(lParam);
1391 
1392             /* Don't let MonSelUpdateMonitorsInfo repaint the control
1393                because this won't work properly in case the control
1394                was sized down! */
1395             MonSelUpdateMonitorsInfo(infoPtr,
1396                                      FALSE);
1397             InvalidateRect(infoPtr->hSelf,
1398                            NULL,
1399                            TRUE);
1400             break;
1401         }
1402 
1403         case WM_GETFONT:
1404         {
1405             Ret = (LRESULT)infoPtr->hFont;
1406             break;
1407         }
1408 
1409         case WM_ENABLE:
1410         {
1411             infoPtr->Enabled = ((BOOL)wParam != FALSE);
1412             MonSelRepaint(infoPtr);
1413             break;
1414         }
1415 
1416         case WM_STYLECHANGED:
1417         {
1418             if (wParam == GWL_STYLE)
1419             {
1420                 unsigned int OldEnabled = infoPtr->Enabled;
1421                 infoPtr->Enabled = !(((LPSTYLESTRUCT)lParam)->styleNew & WS_DISABLED);
1422 
1423                 if (OldEnabled != infoPtr->Enabled)
1424                     MonSelRepaint(infoPtr);
1425             }
1426             break;
1427         }
1428 
1429         case WM_KEYDOWN:
1430         {
1431             INT Index;
1432 
1433             if (infoPtr->ControlExStyle & MSLM_EX_SELECTBYARROWKEY)
1434             {
1435                 switch (wParam)
1436                 {
1437                     case VK_UP:
1438                     case VK_LEFT:
1439                     {
1440                         Index = infoPtr->SelectedMonitor;
1441 
1442                         if (infoPtr->MonitorsCount != 0)
1443                         {
1444                             if (Index < 0)
1445                                 Index = 0;
1446                             else if (Index > 0)
1447                                 Index--;
1448                         }
1449 
1450                         if (Index >= 0)
1451                         {
1452                             MonSelSetCurSelMonitor(infoPtr,
1453                                                    Index,
1454                                                    TRUE);
1455                         }
1456                         break;
1457                     }
1458 
1459                     case VK_DOWN:
1460                     case VK_RIGHT:
1461                     {
1462                         Index = infoPtr->SelectedMonitor;
1463 
1464                         if (infoPtr->MonitorsCount != 0)
1465                         {
1466                             if (Index < 0)
1467                                 Index = (INT)infoPtr->MonitorsCount - 1;
1468                             else if (Index < (INT)infoPtr->MonitorsCount - 1)
1469                                 Index++;
1470                         }
1471 
1472                         if (infoPtr->SelectedMonitor < (INT)infoPtr->MonitorsCount)
1473                         {
1474                             MonSelSetCurSelMonitor(infoPtr,
1475                                                    Index,
1476                                                    TRUE);
1477                         }
1478                         break;
1479                     }
1480                 }
1481             }
1482             break;
1483         }
1484 
1485         case WM_CHAR:
1486         {
1487             if ((infoPtr->ControlExStyle & MSLM_EX_SELECTBYNUMKEY) &&
1488                 wParam >= '1' && wParam <= '9')
1489             {
1490                 INT Index = (INT)(wParam - '1');
1491                 if (Index < (INT)infoPtr->MonitorsCount)
1492                 {
1493                     MonSelSetCurSelMonitor(infoPtr,
1494                                            Index,
1495                                            TRUE);
1496                 }
1497             }
1498             break;
1499         }
1500 
1501         case MSLM_SETMONITORSINFO:
1502         {
1503             Ret = MonSelSetMonitorsInfo(infoPtr,
1504                                         (DWORD)wParam,
1505                                         (const MONSL_MONINFO *)lParam);
1506             break;
1507         }
1508 
1509         case MSLM_GETMONITORSINFO:
1510         {
1511             Ret = MonSelGetMonitorsInfo(infoPtr,
1512                                         (DWORD)wParam,
1513                                         (PMONSL_MONINFO)lParam);
1514             break;
1515         }
1516 
1517         case MSLM_GETMONITORINFOCOUNT:
1518         {
1519             Ret = infoPtr->MonitorsCount;
1520             break;
1521         }
1522 
1523         case MSLM_HITTEST:
1524         {
1525             Ret = MonSelHitTest(infoPtr,
1526                                 (const POINT *)wParam);
1527             break;
1528         }
1529 
1530         case MSLM_SETCURSEL:
1531         {
1532             Ret = MonSelSetCurSelMonitor(infoPtr,
1533                                          (INT)wParam,
1534                                          FALSE);
1535             break;
1536         }
1537 
1538         case MSLM_GETCURSEL:
1539         {
1540             Ret = infoPtr->SelectedMonitor;
1541             break;
1542         }
1543 
1544         case MSLM_SETMONITORINFO:
1545         {
1546             Ret = MonSelSetMonitorInfo(infoPtr,
1547                                        (INT)wParam,
1548                                        (const MONSL_MONINFO *)lParam);
1549             break;
1550         }
1551 
1552         case MSLM_GETMONITORINFO:
1553         {
1554             Ret = MonSelGetMonitorInfo(infoPtr,
1555                                        (INT)wParam,
1556                                        (PMONSL_MONINFO)lParam);
1557             break;
1558         }
1559 
1560         case MSLM_SETEXSTYLE:
1561         {
1562             Ret = MonSelSetExtendedStyle(infoPtr,
1563                                          (DWORD)lParam);
1564             break;
1565         }
1566 
1567         case MSLM_GETEXSTYLE:
1568         {
1569             Ret = MonSelGetExtendedStyle(infoPtr);
1570             break;
1571         }
1572 
1573         case MSLM_GETMONITORRECT:
1574         {
1575             Ret = (LRESULT)MonSelGetMonitorRect(infoPtr,
1576                                                 (INT)wParam,
1577                                                 (PRECT)lParam);
1578             break;
1579         }
1580 
1581         case WM_CREATE:
1582         {
1583             infoPtr = (PMONITORSELWND)HeapAlloc(GetProcessHeap(),
1584                                                 0,
1585                                                 sizeof(MONITORSELWND));
1586             if (infoPtr == NULL)
1587             {
1588                 Ret = (LRESULT)-1;
1589                 break;
1590             }
1591 
1592             ZeroMemory(infoPtr,
1593                        sizeof(MONITORSELWND));
1594             infoPtr->hSelf = hwnd;
1595             infoPtr->hNotify = ((LPCREATESTRUCTW)lParam)->hwndParent;
1596             infoPtr->Enabled = !(((LPCREATESTRUCTW)lParam)->style & WS_DISABLED);
1597             infoPtr->UIState = SendMessage(hwnd,
1598                                            WM_QUERYUISTATE,
1599                                            0,
1600                                            0);
1601 
1602             SetWindowLongPtrW(hwnd,
1603                               0,
1604                               (LONG_PTR)infoPtr);
1605 
1606             MonSelCreate(infoPtr);
1607             break;
1608         }
1609 
1610         case WM_DESTROY:
1611         {
1612             MonSelDestroy(infoPtr);
1613 
1614             HeapFree(GetProcessHeap(),
1615                      0,
1616                      infoPtr);
1617             SetWindowLongPtrW(hwnd,
1618                               0,
1619                               (DWORD_PTR)NULL);
1620             break;
1621         }
1622 
1623         default:
1624         {
1625 HandleDefaultMessage:
1626             Ret = DefWindowProcW(hwnd,
1627                                  uMsg,
1628                                  wParam,
1629                                  lParam);
1630             break;
1631         }
1632     }
1633 
1634     return Ret;
1635 }
1636 
1637 BOOL
1638 RegisterMonitorSelectionControl(IN HINSTANCE hInstance)
1639 {
1640     WNDCLASS wc = {0};
1641 
1642     wc.style = CS_DBLCLKS;
1643     wc.lpfnWndProc = MonitorSelWndProc;
1644     wc.cbWndExtra = sizeof(PMONITORSELWND);
1645     wc.hInstance = hInstance;
1646     wc.hCursor = LoadCursorW(NULL,
1647                              (LPWSTR)IDC_ARROW);
1648     wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE + 1);
1649     wc.lpszClassName = szMonitorSelWndClass;
1650 
1651     return RegisterClass(&wc) != 0;
1652 }
1653 
1654 VOID
1655 UnregisterMonitorSelectionControl(IN HINSTANCE hInstance)
1656 {
1657     UnregisterClassW(szMonitorSelWndClass,
1658                      hInstance);
1659 }
1660