?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Writes to stdout and VGA_WriteChars routine now update both VGA
[wine/wine64.git] / dlls / comctl32 / pager.c
blobc1c1577a03f43993949b82be9d6ac6800527ca1c
1 /*
2 * Pager control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * NOTES
21 * Tested primarily with the controlspy Pager application.
22 * Susan Farley (susan@codeweavers.com)
23 *
24 * TODO:
25 * Implement repetitive button press.
26 * Adjust arrow size relative to size of button.
27 * Allow border size changes.
28 * Implement drag and drop style.
29 */
30
31 #include <string.h>
32 #include "winbase.h"
33 #include "commctrl.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(pager);
37
38 typedef struct
39 {
40 HWND hwndChild; /* handle of the contained wnd */
41 BOOL bNoResize; /* set when created with CCS_NORESIZE */
42 COLORREF clrBk; /* background color */
43 INT nBorder; /* border size for the control */
44 INT nButtonSize;/* size of the pager btns */
45 INT nPos; /* scroll position */
46 INT nWidth; /* from child wnd's response to PGN_CALCSIZE */
47 INT nHeight; /* from child wnd's response to PGN_CALCSIZE */
48 BOOL bForward; /* forward WM_MOUSEMOVE msgs to the contained wnd */
49 INT TLbtnState; /* state of top or left btn */
50 INT BRbtnState; /* state of bottom or right btn */
51 INT direction; /* direction of the scroll, (e.g. PGF_SCROLLUP) */
52 } PAGER_INFO;
53
54 #define PAGER_GetInfoPtr(hwnd) ((PAGER_INFO *)GetWindowLongA(hwnd, 0))
55 #define PAGER_IsHorizontal(hwnd) ((GetWindowLongA (hwnd, GWL_STYLE) & PGS_HORZ))
56
57 #define MIN_ARROW_WIDTH 8
58 #define MIN_ARROW_HEIGHT 5
59
60 #define TIMERID1 1
61 #define TIMERID2 2
62 #define INITIAL_DELAY 500
63 #define REPEAT_DELAY 50
64
65 /* the horizontal arrows are:
66 *
67 * 01234 01234
68 * 1 * *
69 * 2 ** **
70 * 3*** ***
71 * 4*** ***
72 * 5 ** **
73 * 6 * *
74 * 7
75 *
76 */
77 static void
78 PAGER_DrawHorzArrow (HDC hdc, RECT r, INT colorRef, BOOL left)
79 {
80 INT x, y, w, h;
81 HPEN hOldPen;
82
83 w = r.right - r.left + 1;
84 h = r.bottom - r.top + 1;
85 if ((h < MIN_ARROW_WIDTH) || (w < MIN_ARROW_HEIGHT))
86 return; /* refuse to draw partial arrow */
87
88 hOldPen = SelectObject ( hdc, GetSysColorPen (colorRef));
89 if (left)
90 {
91 x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 3;
92 y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
93 MoveToEx (hdc, x, y, NULL);
94 LineTo (hdc, x--, y+5); y++;
95 MoveToEx (hdc, x, y, NULL);
96 LineTo (hdc, x--, y+3); y++;
97 MoveToEx (hdc, x, y, NULL);
98 LineTo (hdc, x, y+1);
99 }
100 else
101 {
102 x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
103 y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
104 MoveToEx (hdc, x, y, NULL);
105 LineTo (hdc, x++, y+5); y++;
106 MoveToEx (hdc, x, y, NULL);
107 LineTo (hdc, x++, y+3); y++;
108 MoveToEx (hdc, x, y, NULL);
109 LineTo (hdc, x, y+1);
110 }
111
112 SelectObject( hdc, hOldPen );
113 }
114
115 /* the vertical arrows are:
116 *
117 * 01234567 01234567
118 * 1****** **
119 * 2 **** ****
120 * 3 ** ******
121 * 4
122 *
123 */
124 static void
125 PAGER_DrawVertArrow (HDC hdc, RECT r, INT colorRef, BOOL up)
126 {
127 INT x, y, w, h;
128 HPEN hOldPen;
129
130 w = r.right - r.left + 1;
131 h = r.bottom - r.top + 1;
132 if ((h < MIN_ARROW_WIDTH) || (w < MIN_ARROW_HEIGHT))
133 return; /* refuse to draw partial arrow */
134
135 hOldPen = SelectObject ( hdc, GetSysColorPen (colorRef));
136 if (up)
137 {
138 x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
139 y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 3;
140 MoveToEx (hdc, x, y, NULL);
141 LineTo (hdc, x+5, y--); x++;
142 MoveToEx (hdc, x, y, NULL);
143 LineTo (hdc, x+3, y--); x++;
144 MoveToEx (hdc, x, y, NULL);
145 LineTo (hdc, x+1, y);
146 }
147 else
148 {
149 x = r.left + ((w - MIN_ARROW_HEIGHT) / 2) + 1;
150 y = r.top + ((h - MIN_ARROW_WIDTH) / 2) + 1;
151 MoveToEx (hdc, x, y, NULL);
152 LineTo (hdc, x+5, y++); x++;
153 MoveToEx (hdc, x, y, NULL);
154 LineTo (hdc, x+3, y++); x++;
155 MoveToEx (hdc, x, y, NULL);
156 LineTo (hdc, x+1, y);
157 }
158
159 SelectObject( hdc, hOldPen );
160 }
161
162 static void
163 PAGER_DrawButton(HDC hdc, COLORREF clrBk, RECT arrowRect,
164 BOOL horz, BOOL topLeft, INT btnState)
165 {
166 HBRUSH hBrush, hOldBrush;
167 RECT rc = arrowRect;
168
169 if (!btnState) /* PGF_INVISIBLE */
170 return;
171
172 if ((rc.right - rc.left <= 0) || (rc.bottom - rc.top <= 0))
173 return;
174
175 hBrush = CreateSolidBrush(clrBk);
176 hOldBrush = (HBRUSH)SelectObject(hdc, hBrush);
177
178 FillRect(hdc, &rc, hBrush);
179
180 if (btnState == PGF_HOT)
181 {
182 DrawEdge( hdc, &rc, BDR_RAISEDINNER, BF_RECT);
183 if (horz)
184 PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
185 else
186 PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
187 }
188 else if (btnState == PGF_NORMAL)
189 {
190 DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
191 if (horz)
192 PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
193 else
194 PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
195 }
196 else if (btnState == PGF_DEPRESSED)
197 {
198 DrawEdge( hdc, &rc, BDR_SUNKENOUTER, BF_RECT);
199 if (horz)
200 PAGER_DrawHorzArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
201 else
202 PAGER_DrawVertArrow(hdc, rc, COLOR_WINDOWFRAME, topLeft);
203 }
204 else if (btnState == PGF_GRAYED)
205 {
206 DrawEdge (hdc, &rc, BDR_OUTER, BF_FLAT);
207 if (horz)
208 {
209 PAGER_DrawHorzArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft);
210 rc.left++, rc.top++; rc.right++, rc.bottom++;
211 PAGER_DrawHorzArrow(hdc, rc, COLOR_3DSHADOW, topLeft);
212 }
213 else
214 {
215 PAGER_DrawVertArrow(hdc, rc, COLOR_3DHIGHLIGHT, topLeft);
216 rc.left++, rc.top++; rc.right++, rc.bottom++;
217 PAGER_DrawVertArrow(hdc, rc, COLOR_3DSHADOW, topLeft);
218 }
219 }
220
221 SelectObject( hdc, hOldBrush );
222 DeleteObject(hBrush);
223 }
224
225 /* << PAGER_GetDropTarget >> */
226
227 static inline LRESULT
228 PAGER_ForwardMouse (HWND hwnd, WPARAM wParam)
229 {
230 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
231 TRACE("[%04x]\n", hwnd);
232
233 infoPtr->bForward = (BOOL)wParam;
234
235 return 0;
236 }
237
238 static inline LRESULT
239 PAGER_GetButtonState (HWND hwnd, WPARAM wParam, LPARAM lParam)
240 {
241 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
242 LRESULT btnState = PGF_INVISIBLE;
243 INT btn = (INT)lParam;
244 TRACE("[%04x]\n", hwnd);
245
246 if (btn == PGB_TOPORLEFT)
247 btnState = infoPtr->TLbtnState;
248 else if (btn == PGB_BOTTOMORRIGHT)
249 btnState = infoPtr->BRbtnState;
250
251 return btnState;
252 }
253
254
255 static inline LRESULT
256 PAGER_GetPos(HWND hwnd)
257 {
258 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
259 TRACE("[%04x] returns %d\n", hwnd, infoPtr->nPos);
260 return (LRESULT)infoPtr->nPos;
261 }
262
263 static inline LRESULT
264 PAGER_GetButtonSize(HWND hwnd)
265 {
266 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
267 TRACE("[%04x] returns %d\n", hwnd, infoPtr->nButtonSize);
268 return (LRESULT)infoPtr->nButtonSize;
269 }
270
271 static inline LRESULT
272 PAGER_GetBorder(HWND hwnd)
273 {
274 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
275 TRACE("[%04x] returns %d\n", hwnd, infoPtr->nBorder);
276 return (LRESULT)infoPtr->nBorder;
277 }
278
279 static inline LRESULT
280 PAGER_GetBkColor(HWND hwnd)
281 {
282 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
283 TRACE("[%04x] returns %06lx\n", hwnd, infoPtr->clrBk);
284 return (LRESULT)infoPtr->clrBk;
285 }
286
287 static void
288 PAGER_CalcSize (HWND hwnd, INT* size, BOOL getWidth)
289 {
290 NMPGCALCSIZE nmpgcs;
291 ZeroMemory (&nmpgcs, sizeof (NMPGCALCSIZE));
292 nmpgcs.hdr.hwndFrom = hwnd;
293 nmpgcs.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
294 nmpgcs.hdr.code = PGN_CALCSIZE;
295 nmpgcs.dwFlag = getWidth ? PGF_CALCWIDTH : PGF_CALCHEIGHT;
296 nmpgcs.iWidth = getWidth ? *size : 0;
297 nmpgcs.iHeight = getWidth ? 0 : *size;
298 SendMessageA (GetParent (hwnd), WM_NOTIFY,
299 (WPARAM)nmpgcs.hdr.idFrom, (LPARAM)&nmpgcs);
300
301 *size = getWidth ? nmpgcs.iWidth : nmpgcs.iHeight;
302
303 TRACE("[%04x] PGN_CALCSIZE returns %s=%d\n", hwnd,
304 getWidth ? "width" : "height", *size);
305 }
306
307 static void
308 PAGER_PositionChildWnd(HWND hwnd, PAGER_INFO* infoPtr)
309 {
310 if (infoPtr->hwndChild)
311 {
312 RECT rcClient;
313 int nPos = infoPtr->nPos;
314
315 /* compensate for a grayed btn, which will soon become invisible */
316 if (infoPtr->TLbtnState == PGF_GRAYED)
317 nPos += infoPtr->nButtonSize;
318
319 GetClientRect(hwnd, &rcClient);
320
321 if (PAGER_IsHorizontal(hwnd))
322 {
323 int wndSize = max(0, rcClient.right - rcClient.left);
324 if (infoPtr->nWidth < wndSize)
325 infoPtr->nWidth = wndSize;
326
327 TRACE("[%04x] SWP %dx%d at (%d,%d)\n", hwnd,
328 infoPtr->nWidth, infoPtr->nHeight,
329 -nPos, 0);
330 SetWindowPos(infoPtr->hwndChild, 0,
331 -nPos, 0,
332 infoPtr->nWidth, infoPtr->nHeight,
333 SWP_NOZORDER);
334 }
335 else
336 {
337 int wndSize = max(0, rcClient.bottom - rcClient.top);
338 if (infoPtr->nHeight < wndSize)
339 infoPtr->nHeight = wndSize;
340
341 TRACE("[%04x] SWP %dx%d at (%d,%d)\n", hwnd,
342 infoPtr->nWidth, infoPtr->nHeight,
343 0, -nPos);
344 SetWindowPos(infoPtr->hwndChild, 0,
345 0, -nPos,
346 infoPtr->nWidth, infoPtr->nHeight,
347 SWP_NOZORDER);
348 }
349
350 InvalidateRect(infoPtr->hwndChild, NULL, TRUE);
351 }
352 }
353
354 static INT
355 PAGER_GetScrollRange(HWND hwnd, PAGER_INFO* infoPtr)
356 {
357 INT scrollRange = 0;
358
359 if (infoPtr->hwndChild)
360 {
361 INT wndSize, childSize;
362 RECT wndRect;
363 GetWindowRect(hwnd, &wndRect);
364
365 if (PAGER_IsHorizontal(hwnd))
366 {
367 wndSize = wndRect.right - wndRect.left;
368 PAGER_CalcSize(hwnd, &infoPtr->nWidth, TRUE);
369 childSize = infoPtr->nWidth;
370 }
371 else
372 {
373 wndSize = wndRect.bottom - wndRect.top;
374 PAGER_CalcSize(hwnd, &infoPtr->nHeight, FALSE);
375 childSize = infoPtr->nHeight;
376 }
377
378 TRACE("childSize = %d, wndSize = %d\n", childSize, wndSize);
379 if (childSize > wndSize)
380 scrollRange = childSize - wndSize + infoPtr->nButtonSize;
381 }
382
383 TRACE("[%04x] returns %d\n", hwnd, scrollRange);
384 return scrollRange;
385 }
386
387 static void
388 PAGER_GrayAndRestoreBtns(PAGER_INFO* infoPtr, INT scrollRange,
389 BOOL* needsResize, BOOL* needsRepaint)
390 {
391 if (infoPtr->nPos > 0)
392 {
393 *needsResize |= !infoPtr->TLbtnState; /* PGF_INVISIBLE */
394 if (infoPtr->TLbtnState != PGF_DEPRESSED)
395 infoPtr->TLbtnState = PGF_NORMAL;
396 }
397 else
398 {
399 *needsRepaint |= (infoPtr->TLbtnState != PGF_GRAYED);
400 infoPtr->TLbtnState = PGF_GRAYED;
401 }
402
403 if (scrollRange <= 0)
404 {
405 *needsRepaint |= (infoPtr->TLbtnState != PGF_GRAYED);
406 infoPtr->TLbtnState = PGF_GRAYED;
407 *needsRepaint |= (infoPtr->BRbtnState != PGF_GRAYED);
408 infoPtr->BRbtnState = PGF_GRAYED;
409 }
410 else if (infoPtr->nPos < scrollRange)
411 {
412 *needsResize |= !infoPtr->BRbtnState; /* PGF_INVISIBLE */
413 if (infoPtr->BRbtnState != PGF_DEPRESSED)
414 infoPtr->BRbtnState = PGF_NORMAL;
415 }
416 else
417 {
418 *needsRepaint |= (infoPtr->BRbtnState != PGF_GRAYED);
419 infoPtr->BRbtnState = PGF_GRAYED;
420 }
421 }
422
423
424 static void
425 PAGER_NormalizeBtns(PAGER_INFO* infoPtr, BOOL* needsRepaint)
426 {
427 if (infoPtr->TLbtnState & (PGF_HOT | PGF_DEPRESSED))
428 {
429 infoPtr->TLbtnState = PGF_NORMAL;
430 *needsRepaint = TRUE;
431 }
432
433 if (infoPtr->BRbtnState & (PGF_HOT | PGF_DEPRESSED))
434 {
435 infoPtr->BRbtnState = PGF_NORMAL;
436 *needsRepaint = TRUE;
437 }
438 }
439
440 static void
441 PAGER_HideGrayBtns(PAGER_INFO* infoPtr, BOOL* needsResize)
442 {
443 if (infoPtr->TLbtnState == PGF_GRAYED)
444 {
445 infoPtr->TLbtnState = PGF_INVISIBLE;
446 *needsResize = TRUE;
447 }
448
449 if (infoPtr->BRbtnState == PGF_GRAYED)
450 {
451 infoPtr->BRbtnState = PGF_INVISIBLE;
452 *needsResize = TRUE;
453 }
454 }
455
456 static void
457 PAGER_UpdateBtns(HWND hwnd, PAGER_INFO *infoPtr,
458 INT scrollRange, BOOL hideGrayBtns)
459 {
460 BOOL resizeClient = FALSE;
461 BOOL repaintBtns = FALSE;
462
463 if (scrollRange < 0)
464 PAGER_NormalizeBtns(infoPtr, &repaintBtns);
465 else
466 PAGER_GrayAndRestoreBtns(infoPtr, scrollRange, &resizeClient, &repaintBtns);
467
468 if (hideGrayBtns)
469 PAGER_HideGrayBtns(infoPtr, &resizeClient);
470
471 if (resizeClient) /* initiate NCCalcSize to resize client wnd */ {
472 SetWindowPos(hwnd, 0,0,0,0,0,
473 SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
474 SWP_NOZORDER | SWP_NOACTIVATE);
475 }
476
477 if (repaintBtns)
478 SendMessageA(hwnd, WM_NCPAINT, 0, 0);
479 }
480
481 static LRESULT
482 PAGER_SetPos(HWND hwnd, INT newPos, BOOL fromBtnPress)
483 {
484 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
485 INT scrollRange = PAGER_GetScrollRange(hwnd, infoPtr);
486 INT oldPos = infoPtr->nPos;
487
488 if ((scrollRange <= 0) || (newPos < 0))
489 infoPtr->nPos = 0;
490 else if (newPos > scrollRange)
491 infoPtr->nPos = scrollRange;
492 else
493 infoPtr->nPos = newPos;
494
495 TRACE("[%04x] pos=%d\n", hwnd, infoPtr->nPos);
496
497 if (infoPtr->nPos != oldPos)
498 {
499 /* gray and restore btns, and if from WM_SETPOS, hide the gray btns */
500 PAGER_UpdateBtns(hwnd, infoPtr, scrollRange, !fromBtnPress);
501 PAGER_PositionChildWnd(hwnd, infoPtr);
502 }
503
504 return 0;
505 }
506
507 static LRESULT
508 PAGER_HandleWindowPosChanging(HWND hwnd, WPARAM wParam, WINDOWPOS *winpos)
509 {
510 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
511
512 if (infoPtr->bNoResize && !(winpos->flags & SWP_NOSIZE))
513 {
514 /* don't let the app resize the nonscrollable dimension of a control
515 * that was created with CCS_NORESIZE style
516 * (i.e. height for a horizontal pager, or width for a vertical one) */
517
518 /* except if the current dimension is 0 and app is setting for
519 * first time, then save amount as dimension. - GA 8/01 */
520
521 if (PAGER_IsHorizontal(hwnd))
522 if (!infoPtr->nHeight && winpos->cy)
523 infoPtr->nHeight = winpos->cy;
524 else
525 winpos->cy = infoPtr->nHeight;
526 else
527 if (!infoPtr->nWidth && winpos->cx)
528 infoPtr->nWidth = winpos->cx;
529 else
530 winpos->cx = infoPtr->nWidth;
531 return 0;
532 }
533
534 DefWindowProcA (hwnd, WM_WINDOWPOSCHANGING, wParam, (LPARAM)winpos);
535
536 return 1;
537 }
538
539 static INT
540 PAGER_SetFixedWidth(HWND hwnd, PAGER_INFO* infoPtr)
541 {
542 /* Must set the non-scrollable dimension to be less than the full height/width
543 * so that NCCalcSize is called. The Msoft docs mention 3/4 factor for button
544 * size, and experimentation shows that affect is almost right. */
545
546 RECT wndRect;
547 INT delta, h;
548 GetWindowRect(hwnd, &wndRect);
549
550 /* see what the app says for btn width */
551 PAGER_CalcSize(hwnd, &infoPtr->nWidth, TRUE);
552
553 if (infoPtr->bNoResize)
554 {
555 delta = wndRect.right - wndRect.left - infoPtr->nWidth;
556 if (delta > infoPtr->nButtonSize)
557 infoPtr->nWidth += 4 * infoPtr->nButtonSize / 3;
558 else if (delta > 0)
559 infoPtr->nWidth += infoPtr->nButtonSize / 3;
560 }
561
562 h = wndRect.bottom - wndRect.top + infoPtr->nButtonSize;
563
564 TRACE("[%04x] infoPtr->nWidth set to %d\n",
565 hwnd, infoPtr->nWidth);
566
567 return h;
568 }
569
570 static INT
571 PAGER_SetFixedHeight(HWND hwnd, PAGER_INFO* infoPtr)
572 {
573 /* Must set the non-scrollable dimension to be less than the full height/width
574 * so that NCCalcSize is called. The Msoft docs mention 3/4 factor for button
575 * size, and experimentation shows that affect is almost right. */
576
577 RECT wndRect;
578 INT delta, w;
579 GetWindowRect(hwnd, &wndRect);
580
581 /* see what the app says for btn height */
582 PAGER_CalcSize(hwnd, &infoPtr->nHeight, FALSE);
583
584 if (infoPtr->bNoResize)
585 {
586 delta = wndRect.bottom - wndRect.top - infoPtr->nHeight;
587 if (delta > infoPtr->nButtonSize)
588 infoPtr->nHeight += infoPtr->nButtonSize;
589 else if (delta > 0)
590 infoPtr->nHeight += infoPtr->nButtonSize / 3;
591 }
592
593 w = wndRect.right - wndRect.left + infoPtr->nButtonSize;
594
595 TRACE("[%04x] infoPtr->nHeight set to %d\n",
596 hwnd, infoPtr->nHeight);
597
598 return w;
599 }
600
601 /******************************************************************
602 * For the PGM_RECALCSIZE message (but not the other uses in *
603 * this module), the native control does only the following: *
604 * *
605 * if (some condition) *
606 * PostMessageA(hwnd, EM_FMTLINES, 0, 0); *
607 * return DefWindowProcA(hwnd, PGM_RECALCSIZE, 0, 0); *
608 * *
609 * When we figure out what the "some condition" is we will *
610 * implement that for the message processing. *
611 ******************************************************************/
612
613 static LRESULT
614 PAGER_RecalcSize(HWND hwnd)
615 {
616 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
617
618 TRACE("[%04x]\n", hwnd);
619
620 if (infoPtr->hwndChild)
621 {
622 INT scrollRange = PAGER_GetScrollRange(hwnd, infoPtr);
623
624 if (scrollRange <= 0)
625 {
626 infoPtr->nPos = -1;
627 PAGER_SetPos(hwnd, 0, FALSE);
628 }
629 else
630 {
631 PAGER_UpdateBtns(hwnd, infoPtr, scrollRange, TRUE);
632 PAGER_PositionChildWnd(hwnd, infoPtr);
633 }
634 }
635
636 return 1;
637 }
638
639
640 static LRESULT
641 PAGER_SetBkColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
642 {
643 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
644 COLORREF clrTemp = infoPtr->clrBk;
645
646 infoPtr->clrBk = (COLORREF)lParam;
647 TRACE("[%04x] %06lx\n", hwnd, infoPtr->clrBk);
648
649 /* the native control seems to do things this way */
650 SetWindowPos(hwnd, 0,0,0,0,0,
651 SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
652 SWP_NOZORDER | SWP_NOACTIVATE);
653
654 RedrawWindow(hwnd, 0, 0, RDW_ERASE | RDW_INVALIDATE);
655
656 return (LRESULT)clrTemp;
657 }
658
659
660 static LRESULT
661 PAGER_SetBorder (HWND hwnd, WPARAM wParam, LPARAM lParam)
662 {
663 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
664 INT nTemp = infoPtr->nBorder;
665
666 infoPtr->nBorder = (INT)lParam;
667 TRACE("[%04x] %d\n", hwnd, infoPtr->nBorder);
668
669 PAGER_RecalcSize(hwnd);
670
671 return (LRESULT)nTemp;
672 }
673
674
675 static LRESULT
676 PAGER_SetButtonSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
677 {
678 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
679 INT nTemp = infoPtr->nButtonSize;
680
681 infoPtr->nButtonSize = (INT)lParam;
682 TRACE("[%04x] %d\n", hwnd, infoPtr->nButtonSize);
683
684 PAGER_RecalcSize(hwnd);
685
686 return (LRESULT)nTemp;
687 }
688
689
690 static LRESULT
691 PAGER_SetChild (HWND hwnd, WPARAM wParam, LPARAM lParam)
692 {
693 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
694 INT hw;
695
696 infoPtr->hwndChild = IsWindow ((HWND)lParam) ? (HWND)lParam : 0;
697
698 if (infoPtr->hwndChild)
699 {
700 TRACE("[%04x] hwndChild=%04x\n", hwnd, infoPtr->hwndChild);
701
702 if (PAGER_IsHorizontal(hwnd)) {
703 hw = PAGER_SetFixedHeight(hwnd, infoPtr);
704 /* adjust non-scrollable dimension to fit the child */
705 SetWindowPos(hwnd, 0, 0,0, hw, infoPtr->nHeight,
706 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER |
707 SWP_NOSIZE | SWP_NOACTIVATE);
708 }
709 else {
710 hw = PAGER_SetFixedWidth(hwnd, infoPtr);
711 /* adjust non-scrollable dimension to fit the child */
712 SetWindowPos(hwnd, 0, 0,0, infoPtr->nWidth, hw,
713 SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOZORDER |
714 SWP_NOSIZE | SWP_NOACTIVATE);
715 }
716
717 /* position child within the page scroller */
718 SetWindowPos(infoPtr->hwndChild, HWND_TOP,
719 0,0,0,0,
720 SWP_SHOWWINDOW | SWP_NOSIZE); /* native is 0 */
721
722 infoPtr->nPos = -1;
723 PAGER_SetPos(hwnd, 0, FALSE);
724 }
725
726 return 0;
727 }
728
729 static void
730 PAGER_Scroll(HWND hwnd, INT dir)
731 {
732 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
733 NMPGSCROLL nmpgScroll;
734 RECT rcWnd;
735
736 if (infoPtr->hwndChild)
737 {
738 ZeroMemory (&nmpgScroll, sizeof (NMPGSCROLL));
739 nmpgScroll.hdr.hwndFrom = hwnd;
740 nmpgScroll.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
741 nmpgScroll.hdr.code = PGN_SCROLL;
742
743 GetWindowRect(hwnd, &rcWnd);
744 GetClientRect(hwnd, &nmpgScroll.rcParent);
745 nmpgScroll.iXpos = nmpgScroll.iYpos = 0;
746 nmpgScroll.iDir = dir;
747
748 if (PAGER_IsHorizontal(hwnd))
749 {
750 nmpgScroll.iScroll = rcWnd.right - rcWnd.left;
751 nmpgScroll.iXpos = infoPtr->nPos;
752 }
753 else
754 {
755 nmpgScroll.iScroll = rcWnd.bottom - rcWnd.top;
756 nmpgScroll.iYpos = infoPtr->nPos;
757 }
758 nmpgScroll.iScroll -= 2*infoPtr->nButtonSize;
759
760 SendMessageA (hwnd, WM_NOTIFY,
761 (WPARAM)nmpgScroll.hdr.idFrom, (LPARAM)&nmpgScroll);
762
763 TRACE("[%04x] PGN_SCROLL returns iScroll=%d\n", hwnd, nmpgScroll.iScroll);
764
765 if (nmpgScroll.iScroll > 0)
766 {
767 infoPtr->direction = dir;
768
769 if (dir == PGF_SCROLLLEFT || dir == PGF_SCROLLUP)
770 PAGER_SetPos(hwnd, infoPtr->nPos - nmpgScroll.iScroll, TRUE);
771 else
772 PAGER_SetPos(hwnd, infoPtr->nPos + nmpgScroll.iScroll, TRUE);
773 }
774 else
775 infoPtr->direction = -1;
776 }
777 }
778
779 static LRESULT
780 PAGER_FmtLines(HWND hwnd)
781 {
782 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
783
784 /* initiate NCCalcSize to resize client wnd and get size */
785 SetWindowPos(hwnd, 0, 0,0,0,0,
786 SWP_FRAMECHANGED | SWP_NOSIZE | SWP_NOMOVE |
787 SWP_NOZORDER | SWP_NOACTIVATE);
788
789 SetWindowPos(infoPtr->hwndChild, 0,
790 0,0,infoPtr->nWidth,infoPtr->nHeight,
791 0);
792
793 return DefWindowProcA (hwnd, EM_FMTLINES, 0, 0);
794 }
795
796 static LRESULT
797 PAGER_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
798 {
799 PAGER_INFO *infoPtr;
800 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
801
802 /* allocate memory for info structure */
803 infoPtr = (PAGER_INFO *)COMCTL32_Alloc (sizeof(PAGER_INFO));
804 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
805
806 /* set default settings */
807 infoPtr->hwndChild = (HWND)NULL;
808 infoPtr->bNoResize = dwStyle & CCS_NORESIZE;
809 infoPtr->clrBk = GetSysColor(COLOR_BTNFACE);
810 infoPtr->nBorder = 0;
811 infoPtr->nButtonSize = 12;
812 infoPtr->nPos = 0;
813 infoPtr->nWidth = 0;
814 infoPtr->nHeight = 0;
815 infoPtr->bForward = FALSE;
816 infoPtr->TLbtnState = PGF_INVISIBLE;
817 infoPtr->BRbtnState = PGF_INVISIBLE;
818 infoPtr->direction = -1;
819
820 if (dwStyle & PGS_AUTOSCROLL)
821 FIXME("[%04x] Autoscroll style is not implemented yet.\n", hwnd);
822 if (dwStyle & PGS_DRAGNDROP)
823 FIXME("[%04x] Drag and Drop style is not implemented yet.\n", hwnd);
824 /*
825 * If neither horizontal nor vertical style specified, default to vertical.
826 * This is probably not necessary, since the style may be set later on as
827 * the control is initialized, but just in case it isn't, set it here.
828 */
829 if (!(dwStyle & PGS_HORZ) && !(dwStyle & PGS_VERT))
830 {
831 dwStyle |= PGS_VERT;
832 SetWindowLongA(hwnd, GWL_STYLE, dwStyle);
833 }
834
835 return 0;
836 }
837
838
839 static LRESULT
840 PAGER_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
841 {
842 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
843 /* free pager info data */
844 COMCTL32_Free (infoPtr);
845 SetWindowLongA (hwnd, 0, 0);
846 return 0;
847 }
848
849 static LRESULT
850 PAGER_NCCalcSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
851 {
852 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
853 LPRECT lpRect = (LPRECT)lParam;
854 RECT rcChildw, rcmyw, wnrc, lbrc, rbrc;
855 POINT cursor;
856 BOOL resizeClient = FALSE;
857 BOOL repaintBtns = FALSE;
858 INT scrollRange;
859
860 /*
861 * lParam points to a RECT struct. On entry, the struct
862 * contains the proposed wnd rectangle for the window.
863 * On exit, the struct should contain the screen
864 * coordinates of the corresponding window's client area.
865 */
866
867 DefWindowProcA (hwnd, WM_NCCALCSIZE, wParam, lParam);
868
869 TRACE("orig rect=(%d,%d)-(%d,%d)\n",
870 lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
871
872 if (PAGER_IsHorizontal(hwnd))
873 {
874 infoPtr->nWidth = lpRect->right - lpRect->left;
875 PAGER_CalcSize (hwnd, &infoPtr->nWidth, TRUE);
876 GetWindowRect (infoPtr->hwndChild, &rcChildw);
877 MapWindowPoints (0, hwnd, (LPPOINT)&rcChildw, 2);
878 GetCursorPos (&cursor);
879 GetWindowRect (hwnd, &rcmyw);
880
881 /* Reset buttons and hide any grey ones */
882 scrollRange = infoPtr->nWidth - (rcmyw.right - rcmyw.left);
883
884 TRACE("nPos=%d, scrollrange=%d, nWidth=%d, myw=(%d,%d)-(%d,%d)\n",
885 infoPtr->nPos, scrollRange, infoPtr->nWidth,
886 rcmyw.left, rcmyw.top, rcmyw.right, rcmyw.bottom);
887 PAGER_GrayAndRestoreBtns(infoPtr, scrollRange, &resizeClient, &repaintBtns);
888 PAGER_HideGrayBtns(infoPtr, &resizeClient);
889
890 if (PtInRect (&rcmyw, cursor)) {
891 GetWindowRect (hwnd, &wnrc);
892 lbrc = wnrc;
893 lbrc.right = lbrc.left + infoPtr->nButtonSize;
894 rbrc = wnrc;
895 rbrc.left = rbrc.right - infoPtr->nButtonSize;
896 TRACE("horz lb rect=(%d,%d)-(%d,%d), rb rect=(%d,%d)-(%d,%d)\n",
897 lbrc.left, lbrc.top, lbrc.right, lbrc.bottom,
898 rbrc.left, rbrc.top, rbrc.right, rbrc.bottom);
899 if (PtInRect (&lbrc, cursor) && infoPtr->TLbtnState)
900 RedrawWindow (hwnd, 0, 0, RDW_INVALIDATE | RDW_ERASE);
901 if (PtInRect (&rbrc, cursor) && infoPtr->BRbtnState)
902 RedrawWindow (hwnd, 0, 0, RDW_INVALIDATE | RDW_ERASE);
903 }
904 if (infoPtr->TLbtnState && (lpRect->left + infoPtr->nButtonSize < lpRect->right))
905 lpRect->left += infoPtr->nButtonSize;
906 if (infoPtr->BRbtnState && (lpRect->right - infoPtr->nButtonSize > lpRect->left))
907 lpRect->right -= infoPtr->nButtonSize;
908 }
909 else
910 {
911 /* native does: (from trace of IE4 opening "Favorites" frame)
912 * DefWindowProc
913 * WM_NOITFY PGN_CALCSIZE w/ dwFlag=2
914 * GetWindowRect (child, &rc)
915 * MapWindowPoints (0, syspager, &rc, 2)
916 * GetCursorPos( &cur )
917 * GetWindowRect (syspager, &rc2)
918 * PtInRect (&rc2, cur.x, cur.y) rtns 0
919 * returns with rect empty
920 */
921 infoPtr->nHeight = lpRect->bottom - lpRect->top;
922 PAGER_CalcSize (hwnd, &infoPtr->nHeight, FALSE);
923 GetWindowRect (infoPtr->hwndChild, &rcChildw);
924 MapWindowPoints (0, hwnd, (LPPOINT)&rcChildw, 2);
925 GetCursorPos (&cursor);
926 GetWindowRect (hwnd, &rcmyw);
927
928 /* Reset buttons and hide any grey ones */
929 scrollRange = infoPtr->nHeight - (rcmyw.bottom - rcmyw.top);
930
931 TRACE("nPos=%d, scrollrange=%d, nHeigth=%d, myw=(%d,%d)-(%d,%d)\n",
932 infoPtr->nPos, scrollRange, infoPtr->nHeight,
933 rcmyw.left, rcmyw.top,
934 rcmyw.right, rcmyw.bottom);
935 PAGER_GrayAndRestoreBtns(infoPtr, scrollRange, &resizeClient, &repaintBtns);
936 PAGER_HideGrayBtns(infoPtr, &resizeClient);
937
938 if (PtInRect (&rcmyw, cursor)) {
939
940 /* native does:
941 * GetWindowRect(pager, &rc)
942 * PtInRect(btn-left????, cur.x, cur.y)
943 * if true -> ???
944 * PtInRect(btn-right????, cur.x, cur.y)
945 * if true
946 * RedrawWindow(pager, 0, 0, 5)
947 * return TRUE
948 */
949
950 GetWindowRect (hwnd, &wnrc);
951 lbrc = wnrc;
952 lbrc.right = lbrc.left + infoPtr->nButtonSize;
953 rbrc = wnrc;
954 rbrc.left = rbrc.right - infoPtr->nButtonSize;
955 TRACE("vert lb rect=(%d,%d)-(%d,%d), rb rect=(%d,%d)-(%d,%d)\n",
956 lbrc.left, lbrc.top, lbrc.right, lbrc.bottom,
957 rbrc.left, rbrc.top, rbrc.right, rbrc.bottom);
958 if (PtInRect (&lbrc, cursor) && infoPtr->TLbtnState)
959 RedrawWindow (hwnd, 0, 0, RDW_INVALIDATE | RDW_ERASE);
960 if (PtInRect (&rbrc, cursor) && infoPtr->BRbtnState)
961 RedrawWindow (hwnd, 0, 0, RDW_INVALIDATE | RDW_ERASE);
962 }
963 if (infoPtr->TLbtnState && (lpRect->top + infoPtr->nButtonSize < lpRect->bottom))
964 lpRect->top += infoPtr->nButtonSize;
965 if (infoPtr->BRbtnState && (lpRect->bottom - infoPtr->nButtonSize > lpRect->top))
966 lpRect->bottom -= infoPtr->nButtonSize;
967 /* ???? */
968 if ((lpRect->bottom < 0) || (lpRect->bottom > infoPtr->nHeight))
969 lpRect->bottom = infoPtr->nHeight;
970 }
971
972 TRACE("[%04x] client rect set to %dx%d at (%d,%d) BtnState[%d,%d]\n",
973 hwnd, lpRect->right-lpRect->left, lpRect->bottom-lpRect->top,
974 lpRect->left, lpRect->top,
975 infoPtr->TLbtnState, infoPtr->BRbtnState);
976
977 return 0;
978 }
979
980 static LRESULT
981 PAGER_NCPaint (HWND hwnd, WPARAM wParam, LPARAM lParam)
982 {
983 PAGER_INFO* infoPtr = PAGER_GetInfoPtr(hwnd);
984 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
985 RECT rcWindow, rcBottomRight, rcTopLeft;
986 HDC hdc;
987 BOOL bHorizontal = PAGER_IsHorizontal(hwnd);
988
989 if (dwStyle & WS_MINIMIZE)
990 return 0;
991
992 DefWindowProcA (hwnd, WM_NCPAINT, wParam, lParam);
993
994 if (!(hdc = GetDCEx (hwnd, 0, DCX_USESTYLE | DCX_WINDOW)))
995 return 0;
996
997 GetWindowRect (hwnd, &rcWindow);
998 OffsetRect (&rcWindow, -rcWindow.left, -rcWindow.top);
999
1000 rcTopLeft = rcBottomRight = rcWindow;
1001 if (bHorizontal)
1002 {
1003 rcTopLeft.right = rcTopLeft.left + infoPtr->nButtonSize;
1004 rcBottomRight.left = rcBottomRight.right - infoPtr->nButtonSize;
1005 }
1006 else
1007 {
1008 rcTopLeft.bottom = rcTopLeft.top + infoPtr->nButtonSize;
1009 rcBottomRight.top = rcBottomRight.bottom - infoPtr->nButtonSize;
1010 }
1011
1012 PAGER_DrawButton(hdc, infoPtr->clrBk, rcTopLeft,
1013 bHorizontal, TRUE, infoPtr->TLbtnState);
1014 PAGER_DrawButton(hdc, infoPtr->clrBk, rcBottomRight,
1015 bHorizontal, FALSE, infoPtr->BRbtnState);
1016
1017 ReleaseDC( hwnd, hdc );
1018 return 0;
1019 }
1020
1021 static INT
1022 PAGER_HitTest (HWND hwnd, LPPOINT pt)
1023 {
1024 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1025 RECT clientRect;
1026 BOOL bHorizontal = PAGER_IsHorizontal(hwnd);
1027
1028 GetClientRect (hwnd, &clientRect);
1029
1030 if (PtInRect(&clientRect, *pt))
1031 {
1032 /* TRACE("HTCLIENT\n"); */
1033 return HTCLIENT;
1034 }
1035
1036 if (infoPtr->TLbtnState && infoPtr->TLbtnState != PGF_GRAYED)
1037 {
1038 if (bHorizontal)
1039 {
1040 if (pt->x < clientRect.left)
1041 {
1042 /* TRACE("HTLEFT\n"); */
1043 return HTLEFT;
1044 }
1045 }
1046 else
1047 {
1048 if (pt->y < clientRect.top)
1049 {
1050 /* TRACE("HTTOP\n"); */
1051 return HTTOP;
1052 }
1053 }
1054 }
1055
1056 if (infoPtr->BRbtnState && infoPtr->BRbtnState != PGF_GRAYED)
1057 {
1058 if (bHorizontal)
1059 {
1060 if (pt->x > clientRect.right)
1061 {
1062 /* TRACE("HTRIGHT\n"); */
1063 return HTRIGHT;
1064 }
1065 }
1066 else
1067 {
1068 if (pt->y > clientRect.bottom)
1069 {
1070 /* TRACE("HTBOTTOM\n"); */
1071 return HTBOTTOM;
1072 }
1073 }
1074 }
1075
1076 /* TRACE("HTNOWHERE\n"); */
1077 return HTNOWHERE;
1078 }
1079
1080 static LRESULT
1081 PAGER_NCHitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
1082 {
1083 POINT pt = { SLOWORD(lParam), SHIWORD(lParam) };
1084 ScreenToClient (hwnd, &pt);
1085 return PAGER_HitTest(hwnd, &pt);
1086 }
1087
1088 static LRESULT
1089 PAGER_SetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1090 {
1091 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1092 BOOL notCaptured = FALSE;
1093
1094 switch(LOWORD(lParam))
1095 {
1096 case HTLEFT:
1097 case HTTOP:
1098 if ((notCaptured = infoPtr->TLbtnState != PGF_HOT))
1099 infoPtr->TLbtnState = PGF_HOT;
1100 break;
1101 case HTRIGHT:
1102 case HTBOTTOM:
1103 if ((notCaptured = infoPtr->BRbtnState != PGF_HOT))
1104 infoPtr->BRbtnState = PGF_HOT;
1105 break;
1106 default:
1107 return FALSE;
1108 }
1109
1110 if (notCaptured)
1111 {
1112 TRACKMOUSEEVENT trackinfo;
1113
1114 TRACE("[%04x] SetCapture\n", hwnd);
1115 SetCapture(hwnd);
1116
1117 trackinfo.cbSize = sizeof(TRACKMOUSEEVENT);
1118 trackinfo.dwFlags = TME_QUERY;
1119 trackinfo.hwndTrack = hwnd;
1120 trackinfo.dwHoverTime = HOVER_DEFAULT;
1121
1122 /* call _TrackMouseEvent to see if we are currently tracking for this hwnd */
1123 _TrackMouseEvent(&trackinfo);
1124
1125 /* Make sure tracking is enabled so we receive a WM_MOUSELEAVE message */
1126 if(!(trackinfo.dwFlags & TME_LEAVE)) {
1127 trackinfo.dwFlags = TME_LEAVE; /* notify upon leaving */
1128
1129 /* call TRACKMOUSEEVENT so we receive a WM_MOUSELEAVE message */
1130 /* and can properly deactivate the hot button */
1131 _TrackMouseEvent(&trackinfo);
1132 }
1133
1134 SendMessageA(hwnd, WM_NCPAINT, 0, 0);
1135 }
1136
1137 return TRUE;
1138 }
1139
1140 static LRESULT
1141 PAGER_MouseLeave (HWND hwnd, WPARAM wParam, LPARAM lParam)
1142 {
1143 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1144
1145 KillTimer (hwnd, TIMERID1);
1146 KillTimer (hwnd, TIMERID2);
1147
1148 TRACE("[%04x] ReleaseCapture\n", hwnd);
1149 ReleaseCapture();
1150
1151 /* Notify parent of released mouse capture */
1152 {
1153 NMHDR nmhdr;
1154 ZeroMemory (&nmhdr, sizeof (NMHDR));
1155 nmhdr.hwndFrom = hwnd;
1156 nmhdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
1157 nmhdr.code = NM_RELEASEDCAPTURE;
1158 SendMessageA (GetParent(hwnd), WM_NOTIFY,
1159 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1160 }
1161
1162 /* make HOT btns NORMAL and hide gray btns */
1163 PAGER_UpdateBtns(hwnd, infoPtr, -1, TRUE);
1164
1165 return TRUE;
1166 }
1167
1168 static LRESULT
1169 PAGER_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
1170 {
1171 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1172 BOOL repaintBtns = FALSE;
1173 POINT pt = { SLOWORD(lParam), SHIWORD(lParam) };
1174 INT hit;
1175
1176 TRACE("[%04x]\n", hwnd);
1177
1178 hit = PAGER_HitTest(hwnd, &pt);
1179
1180 /* put btn in DEPRESSED state */
1181 if (hit == HTLEFT || hit == HTTOP)
1182 {
1183 repaintBtns = infoPtr->TLbtnState != PGF_DEPRESSED;
1184 infoPtr->TLbtnState = PGF_DEPRESSED;
1185 SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
1186 }
1187 else if (hit == HTRIGHT || hit == HTBOTTOM)
1188 {
1189 repaintBtns = infoPtr->BRbtnState != PGF_DEPRESSED;
1190 infoPtr->BRbtnState = PGF_DEPRESSED;
1191 SetTimer(hwnd, TIMERID1, INITIAL_DELAY, 0);
1192 }
1193
1194 if (repaintBtns)
1195 SendMessageA(hwnd, WM_NCPAINT, 0, 0);
1196
1197 switch(hit)
1198 {
1199 case HTLEFT:
1200 TRACE("[%04x] PGF_SCROLLLEFT\n", hwnd);
1201 PAGER_Scroll(hwnd, PGF_SCROLLLEFT);
1202 break;
1203 case HTTOP:
1204 TRACE("[%04x] PGF_SCROLLUP\n", hwnd);
1205 PAGER_Scroll(hwnd, PGF_SCROLLUP);
1206 break;
1207 case HTRIGHT:
1208 TRACE("[%04x] PGF_SCROLLRIGHT\n", hwnd);
1209 PAGER_Scroll(hwnd, PGF_SCROLLRIGHT);
1210 break;
1211 case HTBOTTOM:
1212 TRACE("[%04x] PGF_SCROLLDOWN\n", hwnd);
1213 PAGER_Scroll(hwnd, PGF_SCROLLDOWN);
1214 break;
1215 default:
1216 break;
1217 }
1218
1219 return TRUE;
1220 }
1221
1222 static LRESULT
1223 PAGER_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1224 {
1225 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1226 TRACE("[%04x]\n", hwnd);
1227
1228 KillTimer (hwnd, TIMERID1);
1229 KillTimer (hwnd, TIMERID2);
1230
1231 /* make PRESSED btns NORMAL but don't hide gray btns */
1232 PAGER_UpdateBtns(hwnd, infoPtr, -1, FALSE);
1233
1234 return 0;
1235 }
1236
1237 static LRESULT
1238 PAGER_EraseBackground (HWND hwnd, WPARAM wParam, LPARAM lParam)
1239 {
1240 POINT pt, ptorig;
1241 HDC hdc = (HDC)wParam;
1242 HWND parent;
1243
1244 /* native does:
1245 * parent = GetParent(pager)
1246 * pt.x=0; pt.y=0; ?????
1247 * MapWindowPoints(pager, parent, &pt, 1)
1248 * OffsetWindowOrgEx(hdc, pt.x, pt.y, &ptorg)
1249 * SendMessageA(parent, WM_ERASEBKGND, hdc, 0)
1250 * SetWindowOrgEx(hdc, 0, 0, 0)
1251 */
1252
1253 pt.x = 0;
1254 pt.y = 0;
1255 parent = GetParent(hwnd);
1256 MapWindowPoints(hwnd, parent, &pt, 1);
1257 OffsetWindowOrgEx (hdc, pt.x, pt.y, &ptorig);
1258 SendMessageA (parent, WM_ERASEBKGND, wParam, lParam);
1259 SetWindowOrgEx (hdc, ptorig.x, ptorig.y, 0);
1260
1261
1262 #if 0
1263 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1264 HBRUSH hBrush = CreateSolidBrush(infoPtr->clrBk);
1265 RECT rect;
1266
1267 GetClientRect (hwnd, &rect);
1268 FillRect ((HDC)wParam, &rect, hBrush);
1269
1270 /* background color of the child should be the same as the pager */
1271 if (infoPtr->hwndChild)
1272 {
1273 GetClientRect (infoPtr->hwndChild, &rect);
1274 FillRect ((HDC)wParam, &rect, hBrush);
1275 }
1276
1277 DeleteObject (hBrush);
1278 #endif
1279
1280 return TRUE;
1281 }
1282
1283
1284 static LRESULT
1285 PAGER_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1286 {
1287 /* note that WM_SIZE is sent whenever NCCalcSize resizes the client wnd */
1288
1289 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1290 TRACE("[%04x] %dx%d\n", hwnd, LOWORD(lParam), HIWORD(lParam));
1291
1292 if (PAGER_IsHorizontal(hwnd))
1293 infoPtr->nHeight = HIWORD(lParam);
1294 else
1295 infoPtr->nWidth = LOWORD(lParam);
1296
1297 return PAGER_RecalcSize(hwnd);
1298 }
1299
1300
1301 static LRESULT WINAPI
1302 PAGER_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1303 {
1304 PAGER_INFO *infoPtr = PAGER_GetInfoPtr (hwnd);
1305
1306 if (!infoPtr && (uMsg != WM_CREATE))
1307 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1308
1309 switch (uMsg)
1310 {
1311 case EM_FMTLINES:
1312 return PAGER_FmtLines(hwnd);
1313
1314 case PGM_FORWARDMOUSE:
1315 return PAGER_ForwardMouse (hwnd, wParam);
1316
1317 case PGM_GETBKCOLOR:
1318 return PAGER_GetBkColor(hwnd);
1319
1320 case PGM_GETBORDER:
1321 return PAGER_GetBorder(hwnd);
1322
1323 case PGM_GETBUTTONSIZE:
1324 return PAGER_GetButtonSize(hwnd);
1325
1326 case PGM_GETPOS:
1327 return PAGER_GetPos(hwnd);
1328
1329 case PGM_GETBUTTONSTATE:
1330 return PAGER_GetButtonState (hwnd, wParam, lParam);
1331
1332 /* case PGM_GETDROPTARGET: */
1333
1334 case PGM_RECALCSIZE:
1335 return PAGER_RecalcSize(hwnd);
1336
1337 case PGM_SETBKCOLOR:
1338 return PAGER_SetBkColor (hwnd, wParam, lParam);
1339
1340 case PGM_SETBORDER:
1341 return PAGER_SetBorder (hwnd, wParam, lParam);
1342
1343 case PGM_SETBUTTONSIZE:
1344 return PAGER_SetButtonSize (hwnd, wParam, lParam);
1345
1346 case PGM_SETCHILD:
1347 return PAGER_SetChild (hwnd, wParam, lParam);
1348
1349 case PGM_SETPOS:
1350 return PAGER_SetPos(hwnd, (INT)lParam, FALSE);
1351
1352 case WM_CREATE:
1353 return PAGER_Create (hwnd, wParam, lParam);
1354
1355 case WM_DESTROY:
1356 return PAGER_Destroy (hwnd, wParam, lParam);
1357
1358 case WM_SIZE:
1359 return PAGER_Size (hwnd, wParam, lParam);
1360
1361 case WM_NCPAINT:
1362 return PAGER_NCPaint (hwnd, wParam, lParam);
1363
1364 case WM_WINDOWPOSCHANGING:
1365 return PAGER_HandleWindowPosChanging (hwnd, wParam, (WINDOWPOS*)lParam);
1366
1367 case WM_NCCALCSIZE:
1368 return PAGER_NCCalcSize (hwnd, wParam, lParam);
1369
1370 case WM_NCHITTEST:
1371 return PAGER_NCHitTest (hwnd, wParam, lParam);
1372
1373 case WM_SETCURSOR:
1374 {
1375 if (hwnd == (HWND)wParam)
1376 return PAGER_SetCursor(hwnd, wParam, lParam);
1377 else /* its for the child */
1378 return 0;
1379 }
1380
1381 case WM_MOUSEMOVE:
1382 if (infoPtr->bForward && infoPtr->hwndChild)
1383 PostMessageA(infoPtr->hwndChild, WM_MOUSEMOVE, wParam, lParam);
1384 return TRUE;
1385
1386 case WM_MOUSELEAVE:
1387 return PAGER_MouseLeave (hwnd, wParam, lParam);
1388
1389 case WM_LBUTTONDOWN:
1390 return PAGER_LButtonDown (hwnd, wParam, lParam);
1391
1392 case WM_LBUTTONUP:
1393 return PAGER_LButtonUp (hwnd, wParam, lParam);
1394
1395 case WM_ERASEBKGND:
1396 return PAGER_EraseBackground (hwnd, wParam, lParam);
1397 /*
1398 case WM_PAINT:
1399 return PAGER_Paint (hwnd, wParam);
1400 */
1401 case WM_TIMER:
1402 /* if initial timer, kill it and start the repeat timer */
1403 if (wParam == TIMERID1)
1404 {
1405 KillTimer(hwnd, TIMERID1);
1406 SetTimer(hwnd, TIMERID2, REPEAT_DELAY, 0);
1407 }
1408
1409 KillTimer(hwnd, TIMERID2);
1410 if (infoPtr->direction > 0)
1411 {
1412 PAGER_Scroll(hwnd, infoPtr->direction);
1413 SetTimer(hwnd, TIMERID2, REPEAT_DELAY, 0);
1414 }
1415 break;
1416
1417 case WM_NOTIFY:
1418 case WM_COMMAND:
1419 return SendMessageA (GetParent (hwnd), uMsg, wParam, lParam);
1420
1421 default:
1422 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1423 }
1424
1425 return 0;
1426 }
1427
1428
1429 VOID
1430 PAGER_Register (void)
1431 {
1432 WNDCLASSA wndClass;
1433
1434 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1435 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_SAVEBITS;
1436 wndClass.lpfnWndProc = (WNDPROC)PAGER_WindowProc;
1437 wndClass.cbClsExtra = 0;
1438 wndClass.cbWndExtra = sizeof(PAGER_INFO *);
1439 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
1440 wndClass.hbrBackground = 0;
1441 wndClass.lpszClassName = WC_PAGESCROLLERA;
1442
1443 RegisterClassA (&wndClass);
1444 }
1445
1446
1447 VOID
1448 PAGER_Unregister (void)
1449 {
1450 UnregisterClassA (WC_PAGESCROLLERA, (HINSTANCE)NULL);
1451 }
1452