ReactOS  0.4.14-dev-554-g2f8d847
monslctl.c
Go to the documentation of this file.
1 #include "desk.h"
2 
3 static const TCHAR szMonitorSelWndClass[] = TEXT("MONITORSELWNDCLASS");
4 
5 typedef struct _MONSL_MON
6 {
11 
12 typedef struct _MONITORSELWND
13 {
19  union
20  {
22  struct
23  {
29  };
30  };
47  HBRUSH hbrDisabled;
49 
50 static LRESULT
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
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
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
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
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
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
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
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
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
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
313 {
314  if (infoPtr->SelectedMonitor >= 0)
315  {
316  MonSelRepaintMonitor(infoPtr,
317  (DWORD)infoPtr->SelectedMonitor);
318  }
319 }
320 
321 static VOID
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
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
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
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
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
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
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
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  {
584 
585  nmi.PreviousSelected = infoPtr->SelectedMonitor;
586  nmi.AllowChanging = TRUE;
587 
588  MonSelNotifyMonitor(infoPtr,
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,
616  Index,
617  &nm);
618  }
619  }
620  }
621 
622  Ret = TRUE;
623  }
624 
625  return Ret;
626 }
627 
628 static VOID
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 |
637  return;
638 }
639 
640 static VOID
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
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
683 {
684  return infoPtr->ControlExStyle;
685 }
686 
687 static HFONT
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,
721  LOGPIXELSY),
722  72);
723 
724  hFont = CreateFontIndirect(&lf);
725  if (hFont != NULL)
726  infoPtr->Monitors[Index].hFont = hFont;
727  }
728 
730  hPrevFont);
731  }
732 
733  return hFont;
734 }
735 
736 static BOOL
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
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 
794  prc);
795 
797  crPrevText);
798  }
799  }
800 
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 
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,
830 
832  hPrevFont);
833  }
834  }
835 
836  if (infoPtr->MonitorInfo[Index].Flags & MSL_MIF_DISABLED)
837  {
839  1,
840  1);
841 
842  MonSelDrawDisabledRect(infoPtr,
843  hDC,
844  prc);
845  }
846 }
847 
848 static VOID
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 
865  hpFg = CreatePen(PS_SOLID,
866  0,
868 
869  hbOldBk = SelectObject(hDC,
870  hbBk);
871  hpOldFg = SelectObject(hDC,
872  hpFg);
873  iPrevBkMode = SetBkMode(hDC,
874  TRANSPARENT);
875  crPrevText = SetTextColor(hDC,
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 
925  crPrevText);
926  SetBkMode(hDC,
927  iPrevBkMode);
929  hpOldFg);
931  hbOldBk);
932 
933  DeleteObject(hpFg);
934 }
935 
936 static VOID
938  IN SHORT x,
939  IN SHORT y)
940 {
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,
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,
966  (WPARAM)infoPtr->hSelf,
967  MAKELPARAM(nm.pt.x,
968  nm.pt.y));
969 }
970 
971 static VOID
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
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
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
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
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
1169  IN UINT uMsg,
1170  IN WPARAM wParam,
1171  IN LPARAM lParam)
1172 {
1173  PMONITORSELWND infoPtr;
1174  LRESULT Ret = 0;
1175 
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 */
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 
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,
1514  break;
1515  }
1516 
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,
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  {
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 
1603  0,
1604  (LONG_PTR)infoPtr);
1605 
1606  MonSelCreate(infoPtr);
1607  break;
1608  }
1609 
1610  case WM_DESTROY:
1611  {
1612  MonSelDestroy(infoPtr);
1613 
1615  0,
1616  infoPtr);
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
1639 {
1640  WNDCLASS wc = {0};
1641 
1642  wc.style = CS_DBLCLKS;
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);
1650 
1651  return RegisterClass(&wc) != 0;
1652 }
1653 
1654 VOID
1656 {
1658  hInstance);
1659 }
DWORD MonitorsCount
Definition: monslctl.c:32
static DWORD MonSelGetMonitorsInfo(IN PMONITORSELWND infoPtr, IN DWORD dwMonitors, IN OUT PMONSL_MONINFO MonitorsInfo)
Definition: monslctl.c:481
#define MSLM_GETMONITORINFOCOUNT
Definition: monslctl.h:109
static INT MonSelGetMonitorRect(IN OUT PMONITORSELWND infoPtr, IN INT Index, OUT PRECT prc)
Definition: monslctl.c:536
#define WS_DISABLED
Definition: pedump.c:621
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define IN
Definition: typedefs.h:38
HWND WINAPI GetAncestor(_In_ HWND, _In_ UINT)
BOOL WINAPI InflateRect(_Inout_ LPRECT, _In_ int, _In_ int)
#define TRUE
Definition: types.h:120
struct _MONSL_MONINFO * PMONSL_MONINFO
#define MAKEWPARAM(l, h)
Definition: winuser.h:3984
#define DLGC_WANTCHARS
Definition: winuser.h:2593
HPEN WINAPI CreatePen(_In_ int, _In_ int, _In_ COLORREF)
static DWORD MonSelGetExtendedStyle(IN PMONITORSELWND infoPtr)
Definition: monslctl.c:682
#define COLOR_HIGHLIGHT
Definition: winuser.h:916
#define MSLM_EX_SELECTONRIGHTCLICK
Definition: monslctl.h:8
#define MSLM_SETMONITORSINFO
Definition: monslctl.h:89
long y
Definition: polytest.cpp:48
#define WM_GETDLGCODE
Definition: winuser.h:1671
#define MSLM_GETEXSTYLE
Definition: monslctl.h:198
#define WM_CONTEXTMENU
Definition: richedit.h:64
int WINAPI MapWindowPoints(_In_opt_ HWND hWndFrom, _In_opt_ HWND hWndTo, _Inout_updates_(cPoints) LPPOINT lpPoints, _In_ UINT cPoints)
#define WM_CHAR
Definition: winuser.h:1699
#define WM_LBUTTONDOWN
Definition: winuser.h:1758
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)
BOOL WINAPI ClipCursor(_In_opt_ LPCRECT)
#define MK_LBUTTON
Definition: winuser.h:2342
long x
Definition: polytest.cpp:48
HDC WINAPI GetDC(_In_opt_ HWND)
BOOL WINAPI Rectangle(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int)
SIZE ClientSize
Definition: monslctl.c:17
#define pt(x, y)
Definition: drawing.c:79
static VOID MonSelPaint(IN OUT PMONITORSELWND infoPtr, IN HDC hDC, IN const RECT *prcUpdate)
Definition: monslctl.c:849
DWORD dwInternalFlags
Definition: monslctl.c:21
#define MSLM_SETMONITORINFO
Definition: monslctl.h:150
#define MAKELPARAM(l, h)
Definition: winuser.h:3983
BOOL WINAPI DrawFocusRect(_In_ HDC, _In_ LPCRECT)
#define MSLM_EX_ALLOWSELECTDISABLED
Definition: monslctl.h:5
#define INT
Definition: polytest.cpp:20
static HDC
Definition: imagelist.c:92
#define CALLBACK
Definition: compat.h:27
DWORD UIState
Definition: monslctl.c:18
static VOID MonSelApplyCursorClipping(IN PMONITORSELWND infoPtr, IN BOOL bClip)
Definition: monslctl.c:972
LONG top
Definition: windef.h:307
static BOOL MonSelSetMonitorsInfo(IN OUT PMONITORSELWND infoPtr, IN DWORD dwMonitors, IN const MONSL_MONINFO *MonitorsInfo)
Definition: monslctl.c:398
#define VK_LEFT
Definition: winuser.h:2199
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1497
static VOID MonSelScreenToPt(IN PMONITORSELWND infoPtr, IN const POINT *pptOnScreen, OUT PPOINT ppt)
Definition: monslctl.c:128
#define ZeroMemory
Definition: winbase.h:1642
BOOL WINAPI DeleteObject(_In_ HGDIOBJ)
#define MSLM_EX_SELECTBYNUMKEY
Definition: monslctl.h:9
SIZE SelectionFrame
Definition: monslctl.c:45
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define COLOR_APPWORKSPACE
Definition: winuser.h:915
HWND WINAPI SetFocus(_In_opt_ HWND)
struct _MONITORSELWND MONITORSELWND
static VOID MonSelRepaintSelected(IN PMONITORSELWND infoPtr)
Definition: monslctl.c:312
static BOOL MonSelSetMonitorInfo(IN OUT PMONITORSELWND infoPtr, IN INT Index, IN const MONSL_MONINFO *MonitorsInfo)
Definition: monslctl.c:500
UINT_PTR WPARAM
Definition: windef.h:207
#define VK_TAB
Definition: winuser.h:2174
#define VK_DOWN
Definition: winuser.h:2202
HBRUSH hbrBackground
Definition: winuser.h:3145
UINT HasFocus
Definition: monslctl.c:25
#define GetWindowLongPtrW
Definition: winuser.h:4804
LONG left
Definition: windef.h:306
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
#define GetTextMetrics
Definition: wingdi.h:4473
static VOID MonSelRectToScreen(IN PMONITORSELWND infoPtr, IN const RECT *prc, OUT PRECT prcOnScreen)
Definition: monslctl.c:117
LONG right
Definition: windef.h:308
#define MSLM_SETCURSEL
Definition: monslctl.h:130
static VOID MonSelScaleRectRelative(IN const RECT *prcBaseFrom, IN const RECT *prcFrom, IN const RECT *prcBaseTo, OUT PRECT prcTo)
Definition: monslctl.c:204
#define DT_NOPREFIX
Definition: winuser.h:537
#define BOOL
Definition: nt_native.h:43
#define DWORD
Definition: nt_native.h:44
int32_t INT
Definition: typedefs.h:56
DWORD WINAPI GetSysColor(_In_ int)
WPARAM wParam
Definition: combotst.c:138
SIZE DraggingMargin
Definition: monslctl.c:37
HFONT hFont
Definition: main.c:53
struct tagNMHDR * LPNMHDR
#define WM_ENABLE
Definition: winuser.h:1597
#define WM_PRINTCLIENT
Definition: richedit.h:70
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define DrawText
Definition: winuser.h:5746
static INT MonSelHitTest(IN PMONITORSELWND infoPtr, IN const POINT *ppt)
Definition: monslctl.c:147
HWND hNotify
Definition: monslctl.c:15
UINT code
Definition: winuser.h:3134
static HFONT MonSelChangeFont(IN OUT PMONITORSELWND infoPtr, IN HFONT hFont, IN BOOL Redraw)
Definition: monslctl.c:99
#define MSLM_GETMONITORRECT
Definition: monslctl.h:212
static VOID MonSelDestroy(IN OUT PMONITORSELWND infoPtr)
Definition: monslctl.c:641
#define PS_SOLID
Definition: wingdi.h:585
static VOID MonSelContextMenu(IN OUT PMONITORSELWND infoPtr, IN SHORT x, IN SHORT y)
Definition: monslctl.c:937
int WINAPI SetBkMode(_In_ HDC, _In_ int)
Definition: dc.c:1032
int cbWndExtra
Definition: winuser.h:3141
HINSTANCE hInstance
Definition: charmap.c:20
POINT ptDragBegin
Definition: monslctl.c:36
#define MSLM_EX_HIDENUMBERS
Definition: monslctl.h:7
#define VK_UP
Definition: winuser.h:2200
static VOID MonSelRepaint(IN PMONITORSELWND infoPtr)
Definition: monslctl.c:255
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define GA_PARENT
Definition: winuser.h:2763
short SHORT
Definition: pedump.c:59
LONG lfHeight
Definition: dimm.idl:42
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)
UINT_PTR idFrom
Definition: winuser.h:3133
struct _MONSL_MON MONSL_MON
PMONSL_MON Monitors
Definition: monslctl.c:39
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
MONSL_MONNMHDR hdr
Definition: monslctl.h:41
HCURSOR hCursor
Definition: winuser.h:3144
#define TRANSPARENT
Definition: wingdi.h:949
LONG lfWeight
Definition: dimm.idl:46
smooth NULL
Definition: ftsmooth.c:416
#define WM_GETFONT
Definition: winuser.h:1633
static const TCHAR szMonitorSelWndClass[]
Definition: monslctl.c:3
static BOOL MonSelDrawDisabledRect(IN OUT PMONITORSELWND infoPtr, IN HDC hDC, IN const RECT *prc)
Definition: monslctl.c:737
static LRESULT CALLBACK MonitorSelWndProc(IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
Definition: monslctl.c:1168
DWORD ControlExStyle
Definition: monslctl.c:31
LONG cx
Definition: windef.h:334
#define WM_KEYDOWN
Definition: winuser.h:1697
LONG_PTR LPARAM
Definition: windef.h:208
#define SM_CXDRAG
Definition: winuser.h:1018
#define MSLN_RBUTTONUP
Definition: monslctl.h:78
static VOID MonSelDrag(IN OUT PMONITORSELWND infoPtr, IN PPOINT ppt)
Definition: monslctl.c:1127
VOID UnregisterMonitorSelectionControl(IN HINSTANCE hInstance)
Definition: monslctl.c:1655
#define DT_VCENTER
Definition: winuser.h:543
#define MSL_MIF_DISABLED
Definition: monslctl.h:13
#define COLOR_HIGHLIGHTTEXT
Definition: winuser.h:917
#define MSLM_EX_SELECTBYARROWKEY
Definition: monslctl.h:10
BOOL WINAPI InvalidateRgn(_In_ HWND, _In_opt_ HRGN, _In_ BOOL)
#define WM_DESTROY
Definition: winuser.h:1591
BOOL WINAPI ScrollDC(_In_ HDC, _In_ int, _In_ int, _In_opt_ LPCRECT, _In_opt_ LPCRECT, _In_opt_ HRGN, _Out_opt_ LPRECT)
struct _MONSL_MON * PMONSL_MON
#define MSLN_MONITORCHANGING
Definition: monslctl.h:56
static BOOL MonSelSetExtendedStyle(IN OUT PMONITORSELWND infoPtr, IN DWORD dwExtendedStyle)
Definition: monslctl.c:662
#define WM_RBUTTONDOWN
Definition: winuser.h:1761
HRGN WINAPI CreateRectRgn(_In_ int, _In_ int, _In_ int, _In_ int)
#define LMEM_FIXED
Definition: winbase.h:349
HBRUSH WINAPI CreatePatternBrush(_In_ HBITMAP)
#define MSLM_EX_ALLOWSELECTNONE
Definition: monslctl.h:4
struct tagSTYLESTRUCT * LPSTYLESTRUCT
char TCHAR
Definition: xmlstorage.h:189
HFONT hFont
Definition: monslctl.c:16
#define _T(x)
Definition: vfdio.h:22
#define WM_KILLFOCUS
Definition: winuser.h:1596
#define FW_SEMIBOLD
Definition: wingdi.h:375
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
PMONSL_MONINFO MonitorInfo
Definition: monslctl.c:38
static VOID MonSelCancelDragging(IN OUT PMONITORSELWND infoPtr)
Definition: monslctl.c:1067
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define WM_SIZE
Definition: winuser.h:1593
DWORD COLORREF
Definition: windef.h:300
#define MSLM_EX_HIDENUMBERONSINGLE
Definition: monslctl.h:6
#define CopyMemory
Definition: winbase.h:1640
BOOL WINAPI InvalidateRect(_In_opt_ HWND, _In_opt_ LPCRECT, _In_ BOOL)
static const UCHAR Index[8]
Definition: usbohci.c:18
int WINAPI GetSystemMetrics(_In_ int)
unsigned long DWORD
Definition: ntddk_ex.h:95
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2074
BOOL WINAPI UnionRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
#define MSLM_GETCURSEL
Definition: monslctl.h:139
static VOID MonSelMoveDragRect(IN OUT PMONITORSELWND infoPtr, IN PPOINT ppt)
Definition: monslctl.c:998
#define WM_RBUTTONUP
Definition: winuser.h:1762
#define GetObject
Definition: wingdi.h:4467
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define WM_PAINT
Definition: winuser.h:1602
static VOID MonSelUpdateExtent(IN OUT PMONITORSELWND infoPtr)
Definition: monslctl.c:174
RECT rcDragging
Definition: monslctl.c:35
RECT rc
Definition: monslctl.c:7
int WINAPI GetDeviceCaps(_In_opt_ HDC, _In_ int)
BOOL WINAPI GetUpdateRect(_In_ HWND, _Out_opt_ LPRECT, _In_ BOOL)
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1760
#define LRESULT
Definition: ole.h:14
#define CS_DBLCLKS
Definition: winuser.h:646
Definition: time.h:76
LPCSTR lpszClassName
Definition: winuser.h:3147
HWND hwndFrom
Definition: winuser.h:3132
uint32_t DWORD_PTR
Definition: typedefs.h:63
BOOL WINAPI IntersectRect(_Out_ LPRECT, _In_ LPCRECT, _In_ LPCRECT)
int code
Definition: i386-dis.c:3591
RECT rcExtent
Definition: monslctl.c:40
POINT ptDrag
Definition: monslctl.c:36
static VOID ScaleRectSizeFit(IN const RECT *prcContainerRect, IN OUT PRECT prcRectToScale)
Definition: monslctl.c:225
#define VK_RIGHT
Definition: winuser.h:2201
UINT style
Definition: winuser.h:3138
INT DraggingMonitor
Definition: monslctl.c:34
#define GWL_STYLE
Definition: winuser.h:846
#define _stprintf
Definition: utility.h:124
COLORREF WINAPI SetTextColor(_In_ HDC, _In_ COLORREF)
Definition: text.c:888
static HDC hDC
Definition: 3dtext.c:33
#define DT_SINGLELINE
Definition: winuser.h:540
#define TEXT(s)
Definition: k32.h:26
UINT IsDraggingMonitor
Definition: monslctl.c:28
BOOL WINAPI EqualRect(_In_ LPCRECT, _In_ LPCRECT)
static BOOL MonSelGetMonitorInfo(IN PMONITORSELWND infoPtr, IN INT Index, IN OUT PMONSL_MONINFO MonitorsInfo)
Definition: monslctl.c:520
HINSTANCE hInstance
Definition: winuser.h:3142
static VOID MonSelRepaintMonitor(IN PMONITORSELWND infoPtr, IN DWORD Index)
Definition: monslctl.c:276
HFONT hFont
Definition: monslctl.c:8
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
static VOID MonSelCreate(IN OUT PMONITORSELWND infoPtr)
Definition: monslctl.c:629
#define WM_LBUTTONUP
Definition: winuser.h:1759
RECT rcOldMonitors
Definition: monslctl.c:42
struct tagCREATESTRUCTW * LPCREATESTRUCTW
#define WM_MBUTTONDOWN
Definition: winuser.h:1764
INT SelectedMonitor
Definition: monslctl.c:33
HBITMAP hbmDisabledPattern
Definition: monslctl.c:46
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define CreateFontIndirect
Definition: wingdi.h:4443
unsigned int UINT
Definition: ndis.h:50
#define WM_MOUSEMOVE
Definition: winuser.h:1757
static HFONT MonSelGetMonitorFont(IN OUT PMONITORSELWND infoPtr, IN HDC hDC, IN INT Index)
Definition: monslctl.c:688
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
static VOID MonSelInitDragging(IN OUT PMONITORSELWND infoPtr, IN DWORD Index, IN PPOINT ppt)
Definition: monslctl.c:1102
#define MSLN_MONITORCHANGED
Definition: monslctl.h:66
#define WM_SETFONT
Definition: winuser.h:1632
WNDPROC lpfnWndProc
Definition: winuser.h:3139
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
BOOL WINAPI PtInRect(_In_ LPCRECT, _In_ POINT)
#define IDC_ARROW
Definition: winuser.h:682
BOOL WINAPI ReleaseCapture(void)
Definition: message.c:2888
#define SendMessage
Definition: winuser.h:5818
#define OUT
Definition: typedefs.h:39
static VOID MonSelMonInfoToRect(IN const MONSL_MONINFO *pMonInfo, OUT PRECT prc)
Definition: monslctl.c:137
#define WM_CREATE
Definition: winuser.h:1590
RECT rcMonitors
Definition: monslctl.c:41
UINT CanDisplay
Definition: monslctl.c:26
#define MSLM_HITTEST
Definition: monslctl.h:120
#define HIWORD(l)
Definition: typedefs.h:246
struct _MONITORSELWND * PMONITORSELWND
LONG bottom
Definition: windef.h:309
static VOID MonSelPaintMonitor(IN OUT PMONITORSELWND infoPtr, IN HDC hDC, IN DWORD Index, IN OUT PRECT prc, IN COLORREF crDefFontColor, IN BOOL bHideNumber)
Definition: monslctl.c:769
#define DT_CENTER
Definition: winuser.h:527
#define LOGPIXELSY
Definition: wingdi.h:718
#define MSLM_SETEXSTYLE
Definition: monslctl.h:189
UINT Enabled
Definition: monslctl.c:24
#define SM_CYDRAG
Definition: winuser.h:1019
#define SetWindowLongPtrW
Definition: winuser.h:5321
TCHAR szCaption[12]
Definition: monslctl.c:9
#define COLOR_BACKGROUND
Definition: hardware.h:164
struct tagRECT * PRECT
UINT LeftBtnDown
Definition: monslctl.c:27
static HBITMAP
Definition: button.c:44
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
#define RegisterClass
Definition: winuser.h:5811
static VOID MonSelResetMonitors(IN OUT PMONITORSELWND infoPtr)
Definition: monslctl.c:322
#define GetWindowLongPtr
Definition: treelist.c:73
#define WM_SETFOCUS
Definition: winuser.h:1595
WCHAR * LPWSTR
Definition: xmlstorage.h:184
LONG_PTR LRESULT
Definition: windef.h:209
HBRUSH hbrDisabled
Definition: monslctl.c:47
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
#define MSLM_GETMONITORSINFO
Definition: monslctl.h:100
_Out_ LPRECT prc
Definition: ntgdi.h:1658
HBRUSH WINAPI GetSysColorBrush(_In_ int)
LONG cy
Definition: windef.h:335
#define MSLM_GETMONITORINFO
Definition: monslctl.h:161
LPARAM lParam
Definition: combotst.c:139
static LRESULT MonSelNotifyMonitor(IN PMONITORSELWND infoPtr, IN UINT code, IN INT Index, IN OUT PMONSL_MONNMHDR pmonnmh)
Definition: monslctl.c:76
static VOID MonSelUpdateMonitorsInfo(IN OUT PMONITORSELWND infoPtr, IN BOOL bRepaint)
Definition: monslctl.c:338
#define LOWORD(l)
Definition: pedump.c:82
#define HeapFree(x, y, z)
Definition: compat.h:402
#define GWLP_ID
Definition: winuser.h:854
#define MulDiv(x, y, z)
Definition: gdifloat.h:86
#define DLGC_WANTARROWS
Definition: winuser.h:2585
#define WM_NOTIFY
Definition: richedit.h:61
static LRESULT MonSelNotify(IN PMONITORSELWND infoPtr, IN UINT code, IN OUT PVOID data)
Definition: monslctl.c:51
static BOOL MonSelSetCurSelMonitor(IN OUT PMONITORSELWND infoPtr, IN INT Index, IN BOOL bNotify)
Definition: monslctl.c:562
BOOL RegisterMonitorSelectionControl(IN HINSTANCE hInstance)
Definition: monslctl.c:1638
HBITMAP WINAPI CreateBitmap(_In_ INT cx, _In_ INT cy, _In_ UINT cPlanes, _In_ UINT cBitsPerPel, _In_opt_ const VOID *pvBits)
POINT ScrollPos
Definition: monslctl.c:43