?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Dump HeapWalk entries.
[wine/multimedia.git] / dlls / comctl32 / tab.c
blob799f83745ae0834be01b53fd277a44cf55f0cd47
1 /*
2 * Tab control
3 *
4 * Copyright 1998 Anders Carlsson
5 * Copyright 1999 Alex Priem <alexp@sci.kun.nl>
6 * Copyright 1999 Francis Beaudet
7 * Copyright 2003 Vitaliy Margolen
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * TODO:
24 * Unicode support (under construction)
25 *
26 * Styles:
27 * TCIF_RTLREADING
28 *
29 * Messages:
30 * TCM_REMOVEIMAGE
31 * TCM_DESELECTALL
32 * TCM_GETEXTENDEDSTYLE
33 * TCM_SETEXTENDEDSTYLE
34 *
35 */
36
37 #include <stdarg.h>
38 #include <string.h>
39
40 #include "windef.h"
41 #include "winbase.h"
42 #include "wingdi.h"
43 #include "winuser.h"
44 #include "winnls.h"
45 #include "commctrl.h"
46 #include "comctl32.h"
47 #include "wine/debug.h"
48 #include <math.h>
49
50 WINE_DEFAULT_DEBUG_CHANNEL(tab);
51
52 typedef struct
53 {
54 UINT mask;
55 DWORD dwState;
56 LPWSTR pszText;
57 INT iImage;
58 RECT rect; /* bounding rectangle of the item relative to the
59 * leftmost item (the leftmost item, 0, would have a
60 * "left" member of 0 in this rectangle)
61 *
62 * additionally the top member holds the row number
63 * and bottom is unused and should be 0 */
64 BYTE extra[1]; /* Space for caller supplied info, variable size */
65 } TAB_ITEM;
66
67 /* The size of a tab item depends on how much extra data is requested */
68 #define TAB_ITEM_SIZE(infoPtr) (sizeof(TAB_ITEM) - sizeof(BYTE) + infoPtr->cbInfo)
69
70 typedef struct
71 {
72 HWND hwnd; /* Tab control window */
73 HWND hwndNotify; /* notification window (parent) */
74 UINT uNumItem; /* number of tab items */
75 UINT uNumRows; /* number of tab rows */
76 INT tabHeight; /* height of the tab row */
77 INT tabWidth; /* width of tabs */
78 INT tabMinWidth; /* minimum width of items */
79 USHORT uHItemPadding; /* amount of horizontal padding, in pixels */
80 USHORT uVItemPadding; /* amount of vertical padding, in pixels */
81 USHORT uHItemPadding_s; /* Set amount of horizontal padding, in pixels */
82 USHORT uVItemPadding_s; /* Set amount of vertical padding, in pixels */
83 HFONT hFont; /* handle to the current font */
84 HCURSOR hcurArrow; /* handle to the current cursor */
85 HIMAGELIST himl; /* handle to a image list (may be 0) */
86 HWND hwndToolTip; /* handle to tab's tooltip */
87 INT leftmostVisible; /* Used for scrolling, this member contains
88 * the index of the first visible item */
89 INT iSelected; /* the currently selected item */
90 INT iHotTracked; /* the highlighted item under the mouse */
91 INT uFocus; /* item which has the focus */
92 TAB_ITEM* items; /* pointer to an array of TAB_ITEM's */
93 BOOL DoRedraw; /* flag for redrawing when tab contents is changed*/
94 BOOL needsScrolling; /* TRUE if the size of the tabs is greater than
95 * the size of the control */
96 BOOL fHeightSet; /* was the height of the tabs explicitly set? */
97 BOOL bUnicode; /* Unicode control? */
98 HWND hwndUpDown; /* Updown control used for scrolling */
99 INT cbInfo; /* Number of bytes of caller supplied info per tab */
100 } TAB_INFO;
101
102 /******************************************************************************
103 * Positioning constants
104 */
105 #define SELECTED_TAB_OFFSET 2
106 #define ROUND_CORNER_SIZE 2
107 #define DISPLAY_AREA_PADDINGX 2
108 #define DISPLAY_AREA_PADDINGY 2
109 #define CONTROL_BORDER_SIZEX 2
110 #define CONTROL_BORDER_SIZEY 2
111 #define BUTTON_SPACINGX 3
112 #define BUTTON_SPACINGY 3
113 #define FLAT_BTN_SPACINGX 8
114 #define DEFAULT_TAB_WIDTH 96
115
116 #define TAB_GetInfoPtr(hwnd) ((TAB_INFO *)GetWindowLongPtrW(hwnd,0))
117 /* Since items are variable sized, cannot directly access them */
118 #define TAB_GetItem(info,i) \
119 ((TAB_ITEM*)((LPBYTE)info->items + (i) * TAB_ITEM_SIZE(info)))
120
121 /******************************************************************************
122 * Hot-tracking timer constants
123 */
124 #define TAB_HOTTRACK_TIMER 1
125 #define TAB_HOTTRACK_TIMER_INTERVAL 100 /* milliseconds */
126
127 /******************************************************************************
128 * Prototypes
129 */
130 static void TAB_InvalidateTabArea(TAB_INFO *);
131 static void TAB_EnsureSelectionVisible(TAB_INFO *);
132 static void TAB_DrawItemInterior(TAB_INFO *, HDC, INT, RECT*);
133
134 static BOOL
135 TAB_SendSimpleNotify (const TAB_INFO *infoPtr, UINT code)
136 {
137 NMHDR nmhdr;
138
139 nmhdr.hwndFrom = infoPtr->hwnd;
140 nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwnd, GWLP_ID);
141 nmhdr.code = code;
142
143 return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
144 (WPARAM) nmhdr.idFrom, (LPARAM) &nmhdr);
145 }
146
147 static VOID
148 TAB_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
149 WPARAM wParam, LPARAM lParam)
150 {
151 MSG msg;
152
153 msg.hwnd = hwndMsg;
154 msg.message = uMsg;
155 msg.wParam = wParam;
156 msg.lParam = lParam;
157 msg.time = GetMessageTime ();
158 msg.pt.x = LOWORD(GetMessagePos ());
159 msg.pt.y = HIWORD(GetMessagePos ());
160
161 SendMessageW (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
162 }
163
164 static void
165 TAB_DumpItemExternalA(TCITEMA *pti, UINT iItem)
166 {
167 if (TRACE_ON(tab)) {
168 TRACE("external tab %d, mask=0x%08x, dwState=0x%08x, dwStateMask=0x%08x, cchTextMax=0x%08x\n",
169 iItem, pti->mask, pti->dwState, pti->dwStateMask, pti->cchTextMax);
170 TRACE("external tab %d, iImage=%d, lParam=0x%08lx, pszTextA=%s\n",
171 iItem, pti->iImage, pti->lParam, debugstr_a(pti->pszText));
172 }
173 }
174
175
176 static void
177 TAB_DumpItemExternalW(TCITEMW *pti, UINT iItem)
178 {
179 if (TRACE_ON(tab)) {
180 TRACE("external tab %d, mask=0x%08x, dwState=0x%08lx, dwStateMask=0x%08lx, cchTextMax=0x%08x\n",
181 iItem, pti->mask, pti->dwState, pti->dwStateMask, pti->cchTextMax);
182 TRACE("external tab %d, iImage=%d, lParam=0x%08lx, pszTextW=%s\n",
183 iItem, pti->iImage, pti->lParam, debugstr_w(pti->pszText));
184 }
185 }
186
187 static void
188 TAB_DumpItemInternal(TAB_INFO *infoPtr, UINT iItem)
189 {
190 if (TRACE_ON(tab)) {
191 TAB_ITEM *ti;
192
193 ti = TAB_GetItem(infoPtr, iItem);
194 TRACE("tab %d, mask=0x%08x, dwState=0x%08lx, pszText=%s, iImage=%d\n",
195 iItem, ti->mask, ti->dwState, debugstr_w(ti->pszText),
196 ti->iImage);
197 TRACE("tab %d, rect.left=%ld, rect.top(row)=%ld\n",
198 iItem, ti->rect.left, ti->rect.top);
199 }
200 }
201
202 /* RETURNS
203 * the index of the selected tab, or -1 if no tab is selected. */
204 static inline LRESULT TAB_GetCurSel (const TAB_INFO *infoPtr)
205 {
206 return infoPtr->iSelected;
207 }
208
209 /* RETURNS
210 * the index of the tab item that has the focus
211 * NOTE
212 * we have not to return negative value
213 * TODO
214 * test for windows */
215 static inline LRESULT
216 TAB_GetCurFocus (const TAB_INFO *infoPtr)
217 {
218 if (infoPtr->uFocus<0)
219 {
220 FIXME("we have not to return negative value");
221 return 0;
222 }
223 return infoPtr->uFocus;
224 }
225
226 static inline LRESULT TAB_GetToolTips (const TAB_INFO *infoPtr)
227 {
228 if (infoPtr == NULL) return 0;
229 return (LRESULT)infoPtr->hwndToolTip;
230 }
231
232 static inline LRESULT TAB_SetCurSel (TAB_INFO *infoPtr, INT iItem)
233 {
234 INT prevItem = -1;
235
236 if (iItem >= 0 && iItem < infoPtr->uNumItem) {
237 prevItem=infoPtr->iSelected;
238 infoPtr->iSelected=iItem;
239 TAB_EnsureSelectionVisible(infoPtr);
240 TAB_InvalidateTabArea(infoPtr);
241 }
242 return prevItem;
243 }
244
245 static LRESULT TAB_SetCurFocus (TAB_INFO *infoPtr, INT iItem)
246 {
247 if (iItem < 0 || iItem >= infoPtr->uNumItem) return 0;
248
249 if (GetWindowLongA(infoPtr->hwnd, GWL_STYLE) & TCS_BUTTONS) {
250 FIXME("Should set input focus\n");
251 } else {
252 int oldFocus = infoPtr->uFocus;
253 if (infoPtr->iSelected != iItem || oldFocus == -1 ) {
254 infoPtr->uFocus = iItem;
255 if (oldFocus != -1) {
256 if (!TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING)) {
257 infoPtr->iSelected = iItem;
258 TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
259 }
260 else
261 infoPtr->iSelected = iItem;
262 TAB_EnsureSelectionVisible(infoPtr);
263 TAB_InvalidateTabArea(infoPtr);
264 }
265 }
266 }
267 return 0;
268 }
269
270 static inline LRESULT
271 TAB_SetToolTips (TAB_INFO *infoPtr, HWND hwndToolTip)
272 {
273 if (infoPtr)
274 infoPtr->hwndToolTip = hwndToolTip;
275 return 0;
276 }
277
278 static inline LRESULT
279 TAB_SetPadding (TAB_INFO *infoPtr, LPARAM lParam)
280 {
281 if (infoPtr)
282 {
283 infoPtr->uHItemPadding_s=LOWORD(lParam);
284 infoPtr->uVItemPadding_s=HIWORD(lParam);
285 }
286 return 0;
287 }
288
289 /******************************************************************************
290 * TAB_InternalGetItemRect
291 *
292 * This method will calculate the rectangle representing a given tab item in
293 * client coordinates. This method takes scrolling into account.
294 *
295 * This method returns TRUE if the item is visible in the window and FALSE
296 * if it is completely outside the client area.
297 */
298 static BOOL TAB_InternalGetItemRect(
299 const TAB_INFO* infoPtr,
300 INT itemIndex,
301 RECT* itemRect,
302 RECT* selectedRect)
303 {
304 RECT tmpItemRect,clientRect;
305 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
306
307 /* Perform a sanity check and a trivial visibility check. */
308 if ( (infoPtr->uNumItem <= 0) ||
309 (itemIndex >= infoPtr->uNumItem) ||
310 (!((lStyle & TCS_MULTILINE) || (lStyle & TCS_VERTICAL)) && (itemIndex < infoPtr->leftmostVisible)) )
311 return FALSE;
312
313 /*
314 * Avoid special cases in this procedure by assigning the "out"
315 * parameters if the caller didn't supply them
316 */
317 if (itemRect == NULL)
318 itemRect = &tmpItemRect;
319
320 /* Retrieve the unmodified item rect. */
321 *itemRect = TAB_GetItem(infoPtr,itemIndex)->rect;
322
323 /* calculate the times bottom and top based on the row */
324 GetClientRect(infoPtr->hwnd, &clientRect);
325
326 if ((lStyle & TCS_BOTTOM) && (lStyle & TCS_VERTICAL))
327 {
328 itemRect->right = clientRect.right - SELECTED_TAB_OFFSET - itemRect->left * infoPtr->tabHeight -
329 ((lStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
330 itemRect->left = itemRect->right - infoPtr->tabHeight;
331 }
332 else if (lStyle & TCS_VERTICAL)
333 {
334 itemRect->left = clientRect.left + SELECTED_TAB_OFFSET + itemRect->left * infoPtr->tabHeight +
335 ((lStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
336 itemRect->right = itemRect->left + infoPtr->tabHeight;
337 }
338 else if (lStyle & TCS_BOTTOM)
339 {
340 itemRect->bottom = clientRect.bottom - itemRect->top * infoPtr->tabHeight -
341 ((lStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
342 itemRect->top = itemRect->bottom - infoPtr->tabHeight;
343 }
344 else /* not TCS_BOTTOM and not TCS_VERTICAL */
345 {
346 itemRect->top = clientRect.top + itemRect->top * infoPtr->tabHeight +
347 ((lStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
348 itemRect->bottom = itemRect->top + infoPtr->tabHeight;
349 }
350
351 /*
352 * "scroll" it to make sure the item at the very left of the
353 * tab control is the leftmost visible tab.
354 */
355 if(lStyle & TCS_VERTICAL)
356 {
357 OffsetRect(itemRect,
358 0,
359 -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.top);
360
361 /*
362 * Move the rectangle so the first item is slightly offset from
363 * the bottom of the tab control.
364 */
365 OffsetRect(itemRect,
366 0,
367 SELECTED_TAB_OFFSET);
368
369 } else
370 {
371 OffsetRect(itemRect,
372 -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.left,
373 0);
374
375 /*
376 * Move the rectangle so the first item is slightly offset from
377 * the left of the tab control.
378 */
379 OffsetRect(itemRect,
380 SELECTED_TAB_OFFSET,
381 0);
382 }
383 TRACE("item %d tab h=%d, rect=(%ld,%ld)-(%ld,%ld)\n",
384 itemIndex, infoPtr->tabHeight,
385 itemRect->left, itemRect->top, itemRect->right, itemRect->bottom);
386
387 /* Now, calculate the position of the item as if it were selected. */
388 if (selectedRect!=NULL)
389 {
390 CopyRect(selectedRect, itemRect);
391
392 /* The rectangle of a selected item is a bit wider. */
393 if(lStyle & TCS_VERTICAL)
394 InflateRect(selectedRect, 0, SELECTED_TAB_OFFSET);
395 else
396 InflateRect(selectedRect, SELECTED_TAB_OFFSET, 0);
397
398 /* If it also a bit higher. */
399 if ((lStyle & TCS_BOTTOM) && (lStyle & TCS_VERTICAL))
400 {
401 selectedRect->left -= 2; /* the border is thicker on the right */
402 selectedRect->right += SELECTED_TAB_OFFSET;
403 }
404 else if (lStyle & TCS_VERTICAL)
405 {
406 selectedRect->left -= SELECTED_TAB_OFFSET;
407 selectedRect->right += 1;
408 }
409 else if (lStyle & TCS_BOTTOM)
410 {
411 selectedRect->bottom += SELECTED_TAB_OFFSET;
412 }
413 else /* not TCS_BOTTOM and not TCS_VERTICAL */
414 {
415 selectedRect->top -= SELECTED_TAB_OFFSET;
416 selectedRect->bottom -= 1;
417 }
418 }
419
420 return TRUE;
421 }
422
423 static inline BOOL
424 TAB_GetItemRect(TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
425 {
426 return TAB_InternalGetItemRect(infoPtr, (INT)wParam, (LPRECT)lParam, (LPRECT)NULL);
427 }
428
429 /******************************************************************************
430 * TAB_KeyUp
431 *
432 * This method is called to handle keyboard input
433 */
434 static LRESULT TAB_KeyUp(TAB_INFO* infoPtr, WPARAM keyCode)
435 {
436 int newItem = -1;
437
438 switch (keyCode)
439 {
440 case VK_LEFT:
441 newItem = infoPtr->uFocus - 1;
442 break;
443 case VK_RIGHT:
444 newItem = infoPtr->uFocus + 1;
445 break;
446 }
447
448 /*
449 * If we changed to a valid item, change the selection
450 */
451 if (newItem >= 0 &&
452 newItem < infoPtr->uNumItem &&
453 infoPtr->uFocus != newItem)
454 {
455 if (!TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))
456 {
457 infoPtr->iSelected = newItem;
458 infoPtr->uFocus = newItem;
459 TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
460
461 TAB_EnsureSelectionVisible(infoPtr);
462 TAB_InvalidateTabArea(infoPtr);
463 }
464 }
465
466 return 0;
467 }
468
469 /******************************************************************************
470 * TAB_FocusChanging
471 *
472 * This method is called whenever the focus goes in or out of this control
473 * it is used to update the visual state of the control.
474 */
475 static VOID TAB_FocusChanging(const TAB_INFO *infoPtr)
476 {
477 RECT selectedRect;
478 BOOL isVisible;
479
480 /*
481 * Get the rectangle for the item.
482 */
483 isVisible = TAB_InternalGetItemRect(infoPtr,
484 infoPtr->uFocus,
485 NULL,
486 &selectedRect);
487
488 /*
489 * If the rectangle is not completely invisible, invalidate that
490 * portion of the window.
491 */
492 if (isVisible)
493 {
494 TRACE("invalidate (%ld,%ld)-(%ld,%ld)\n",
495 selectedRect.left,selectedRect.top,
496 selectedRect.right,selectedRect.bottom);
497 InvalidateRect(infoPtr->hwnd, &selectedRect, TRUE);
498 }
499 }
500
501 static INT TAB_InternalHitTest (
502 TAB_INFO* infoPtr,
503 POINT pt,
504 UINT* flags)
505
506 {
507 RECT rect;
508 INT iCount;
509
510 for (iCount = 0; iCount < infoPtr->uNumItem; iCount++)
511 {
512 TAB_InternalGetItemRect(infoPtr, iCount, &rect, NULL);
513
514 if (PtInRect(&rect, pt))
515 {
516 *flags = TCHT_ONITEM;
517 return iCount;
518 }
519 }
520
521 *flags = TCHT_NOWHERE;
522 return -1;
523 }
524
525 static inline LRESULT
526 TAB_HitTest (TAB_INFO *infoPtr, LPTCHITTESTINFO lptest)
527 {
528 return TAB_InternalHitTest (infoPtr, lptest->pt, &lptest->flags);
529 }
530
531 /******************************************************************************
532 * TAB_NCHitTest
533 *
534 * Napster v2b5 has a tab control for its main navigation which has a client
535 * area that covers the whole area of the dialog pages.
536 * That's why it receives all msgs for that area and the underlying dialog ctrls
537 * are dead.
538 * So I decided that we should handle WM_NCHITTEST here and return
539 * HTTRANSPARENT if we don't hit the tab control buttons.
540 * FIXME: WM_NCHITTEST handling correct ? Fix it if you know that Windows
541 * doesn't do it that way. Maybe depends on tab control styles ?
542 */
543 static inline LRESULT
544 TAB_NCHitTest (TAB_INFO *infoPtr, LPARAM lParam)
545 {
546 POINT pt;
547 UINT dummyflag;
548
549 pt.x = LOWORD(lParam);
550 pt.y = HIWORD(lParam);
551 ScreenToClient(infoPtr->hwnd, &pt);
552
553 if (TAB_InternalHitTest(infoPtr, pt, &dummyflag) == -1)
554 return HTTRANSPARENT;
555 else
556 return HTCLIENT;
557 }
558
559 static LRESULT
560 TAB_LButtonDown (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
561 {
562 POINT pt;
563 INT newItem, dummy;
564
565 if (infoPtr->hwndToolTip)
566 TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
567 WM_LBUTTONDOWN, wParam, lParam);
568
569 if (GetWindowLongA(infoPtr->hwnd, GWL_STYLE) & TCS_FOCUSONBUTTONDOWN ) {
570 SetFocus (infoPtr->hwnd);
571 }
572
573 if (infoPtr->hwndToolTip)
574 TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
575 WM_LBUTTONDOWN, wParam, lParam);
576
577 pt.x = (INT)LOWORD(lParam);
578 pt.y = (INT)HIWORD(lParam);
579
580 newItem = TAB_InternalHitTest (infoPtr, pt, &dummy);
581
582 TRACE("On Tab, item %d\n", newItem);
583
584 if (newItem != -1 && infoPtr->iSelected != newItem)
585 {
586 if (!TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))
587 {
588 infoPtr->iSelected = newItem;
589 infoPtr->uFocus = newItem;
590 TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
591
592 TAB_EnsureSelectionVisible(infoPtr);
593
594 TAB_InvalidateTabArea(infoPtr);
595 }
596 }
597 return 0;
598 }
599
600 static inline LRESULT
601 TAB_LButtonUp (const TAB_INFO *infoPtr)
602 {
603 TAB_SendSimpleNotify(infoPtr, NM_CLICK);
604
605 return 0;
606 }
607
608 static inline LRESULT
609 TAB_RButtonDown (const TAB_INFO *infoPtr)
610 {
611 TAB_SendSimpleNotify(infoPtr, NM_RCLICK);
612 return 0;
613 }
614
615 /******************************************************************************
616 * TAB_DrawLoneItemInterior
617 *
618 * This calls TAB_DrawItemInterior. However, TAB_DrawItemInterior is normally
619 * called by TAB_DrawItem which is normally called by TAB_Refresh which sets
620 * up the device context and font. This routine does the same setup but
621 * only calls TAB_DrawItemInterior for the single specified item.
622 */
623 static void
624 TAB_DrawLoneItemInterior(TAB_INFO* infoPtr, int iItem)
625 {
626 HDC hdc = GetDC(infoPtr->hwnd);
627 RECT r, rC;
628
629 /* Clip UpDown control to not draw over it */
630 if (infoPtr->needsScrolling)
631 {
632 GetWindowRect(infoPtr->hwnd, &rC);
633 GetWindowRect(infoPtr->hwndUpDown, &r);
634 ExcludeClipRect(hdc, r.left - rC.left, r.top - rC.top, r.right - rC.left, r.bottom - rC.top);
635 }
636 TAB_DrawItemInterior(infoPtr, hdc, iItem, NULL);
637 ReleaseDC(infoPtr->hwnd, hdc);
638 }
639
640 /******************************************************************************
641 * TAB_HotTrackTimerProc
642 *
643 * When a mouse-move event causes a tab to be highlighted (hot-tracking), a
644 * timer is setup so we can check if the mouse is moved out of our window.
645 * (We don't get an event when the mouse leaves, the mouse-move events just
646 * stop being delivered to our window and just start being delivered to
647 * another window.) This function is called when the timer triggers so
648 * we can check if the mouse has left our window. If so, we un-highlight
649 * the hot-tracked tab.
650 */
651 static VOID CALLBACK
652 TAB_HotTrackTimerProc
653 (
654 HWND hwnd, /* handle of window for timer messages */
655 UINT uMsg, /* WM_TIMER message */
656 UINT idEvent, /* timer identifier */
657 DWORD dwTime /* current system time */
658 )
659 {
660 TAB_INFO* infoPtr = TAB_GetInfoPtr(hwnd);
661
662 if (infoPtr != NULL && infoPtr->iHotTracked >= 0)
663 {
664 POINT pt;
665
666 /*
667 ** If we can't get the cursor position, or if the cursor is outside our
668 ** window, we un-highlight the hot-tracked tab. Note that the cursor is
669 ** "outside" even if it is within our bounding rect if another window
670 ** overlaps. Note also that the case where the cursor stayed within our
671 ** window but has moved off the hot-tracked tab will be handled by the
672 ** WM_MOUSEMOVE event.
673 */
674 if (!GetCursorPos(&pt) || WindowFromPoint(pt) != hwnd)
675 {
676 /* Redraw iHotTracked to look normal */
677 INT iRedraw = infoPtr->iHotTracked;
678 infoPtr->iHotTracked = -1;
679 TAB_DrawLoneItemInterior(infoPtr, iRedraw);
680
681 /* Kill this timer */
682 KillTimer(hwnd, TAB_HOTTRACK_TIMER);
683 }
684 }
685 }
686
687 /******************************************************************************
688 * TAB_RecalcHotTrack
689 *
690 * If a tab control has the TCS_HOTTRACK style, then the tab under the mouse
691 * should be highlighted. This function determines which tab in a tab control,
692 * if any, is under the mouse and records that information. The caller may
693 * supply output parameters to receive the item number of the tab item which
694 * was highlighted but isn't any longer and of the tab item which is now
695 * highlighted but wasn't previously. The caller can use this information to
696 * selectively redraw those tab items.
697 *
698 * If the caller has a mouse position, it can supply it through the pos
699 * parameter. For example, TAB_MouseMove does this. Otherwise, the caller
700 * supplies NULL and this function determines the current mouse position
701 * itself.
702 */
703 static void
704 TAB_RecalcHotTrack
705 (
706 TAB_INFO* infoPtr,
707 const LPARAM* pos,
708 int* out_redrawLeave,
709 int* out_redrawEnter
710 )
711 {
712 int item = -1;
713
714
715 if (out_redrawLeave != NULL)
716 *out_redrawLeave = -1;
717 if (out_redrawEnter != NULL)
718 *out_redrawEnter = -1;
719
720 if (GetWindowLongA(infoPtr->hwnd, GWL_STYLE) & TCS_HOTTRACK)
721 {
722 POINT pt;
723 UINT flags;
724
725 if (pos == NULL)
726 {
727 GetCursorPos(&pt);
728 ScreenToClient(infoPtr->hwnd, &pt);
729 }
730 else
731 {
732 pt.x = LOWORD(*pos);
733 pt.y = HIWORD(*pos);
734 }
735
736 item = TAB_InternalHitTest(infoPtr, pt, &flags);
737 }
738
739 if (item != infoPtr->iHotTracked)
740 {
741 if (infoPtr->iHotTracked >= 0)
742 {
743 /* Mark currently hot-tracked to be redrawn to look normal */
744 if (out_redrawLeave != NULL)
745 *out_redrawLeave = infoPtr->iHotTracked;
746
747 if (item < 0)
748 {
749 /* Kill timer which forces recheck of mouse pos */
750 KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
751 }
752 }
753 else
754 {
755 /* Start timer so we recheck mouse pos */
756 UINT timerID = SetTimer
757 (
758 infoPtr->hwnd,
759 TAB_HOTTRACK_TIMER,
760 TAB_HOTTRACK_TIMER_INTERVAL,
761 TAB_HotTrackTimerProc
762 );
763
764 if (timerID == 0)
765 return; /* Hot tracking not available */
766 }
767
768 infoPtr->iHotTracked = item;
769
770 if (item >= 0)
771 {
772 /* Mark new hot-tracked to be redrawn to look highlighted */
773 if (out_redrawEnter != NULL)
774 *out_redrawEnter = item;
775 }
776 }
777 }
778
779 /******************************************************************************
780 * TAB_MouseMove
781 *
782 * Handles the mouse-move event. Updates tooltips. Updates hot-tracking.
783 */
784 static LRESULT
785 TAB_MouseMove (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
786 {
787 int redrawLeave;
788 int redrawEnter;
789
790 if (infoPtr->hwndToolTip)
791 TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
792 WM_LBUTTONDOWN, wParam, lParam);
793
794 /* Determine which tab to highlight. Redraw tabs which change highlight
795 ** status. */
796 TAB_RecalcHotTrack(infoPtr, &lParam, &redrawLeave, &redrawEnter);
797
798 if (redrawLeave != -1)
799 TAB_DrawLoneItemInterior(infoPtr, redrawLeave);
800 if (redrawEnter != -1)
801 TAB_DrawLoneItemInterior(infoPtr, redrawEnter);
802
803 return 0;
804 }
805
806 /******************************************************************************
807 * TAB_AdjustRect
808 *
809 * Calculates the tab control's display area given the window rectangle or
810 * the window rectangle given the requested display rectangle.
811 */
812 static LRESULT TAB_AdjustRect(
813 TAB_INFO *infoPtr,
814 WPARAM fLarger,
815 LPRECT prc)
816 {
817 DWORD lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
818 LONG *iRightBottom, *iLeftTop;
819
820 TRACE ("hwnd=%p fLarger=%d (%ld,%ld)-(%ld,%ld)\n", infoPtr->hwnd, fLarger, prc->left, prc->top, prc->right, prc->bottom);
821
822 if(lStyle & TCS_VERTICAL)
823 {
824 iRightBottom = &(prc->right);
825 iLeftTop = &(prc->left);
826 }
827 else
828 {
829 iRightBottom = &(prc->bottom);
830 iLeftTop = &(prc->top);
831 }
832
833 if (fLarger) /* Go from display rectangle */
834 {
835 /* Add the height of the tabs. */
836 if (lStyle & TCS_BOTTOM)
837 *iRightBottom += infoPtr->tabHeight * infoPtr->uNumRows;
838 else
839 *iLeftTop -= infoPtr->tabHeight * infoPtr->uNumRows +
840 ((lStyle & TCS_BUTTONS)? 3 * (infoPtr->uNumRows - 1) : 0);
841
842 /* Inflate the rectangle for the padding */
843 InflateRect(prc, DISPLAY_AREA_PADDINGX, DISPLAY_AREA_PADDINGY);
844
845 /* Inflate for the border */
846 InflateRect(prc, CONTROL_BORDER_SIZEX, CONTROL_BORDER_SIZEY);
847 }
848 else /* Go from window rectangle. */
849 {
850 /* Deflate the rectangle for the border */
851 InflateRect(prc, -CONTROL_BORDER_SIZEX, -CONTROL_BORDER_SIZEY);
852
853 /* Deflate the rectangle for the padding */
854 InflateRect(prc, -DISPLAY_AREA_PADDINGX, -DISPLAY_AREA_PADDINGY);
855
856 /* Remove the height of the tabs. */
857 if (lStyle & TCS_BOTTOM)
858 *iRightBottom -= infoPtr->tabHeight * infoPtr->uNumRows;
859 else
860 *iLeftTop += (infoPtr->tabHeight) * infoPtr->uNumRows +
861 ((lStyle & TCS_BUTTONS)? 3 * (infoPtr->uNumRows - 1) : 0);
862 }
863
864 return 0;
865 }
866
867 /******************************************************************************
868 * TAB_OnHScroll
869 *
870 * This method will handle the notification from the scroll control and
871 * perform the scrolling operation on the tab control.
872 */
873 static LRESULT TAB_OnHScroll(
874 TAB_INFO *infoPtr,
875 int nScrollCode,
876 int nPos,
877 HWND hwndScroll)
878 {
879 if(nScrollCode == SB_THUMBPOSITION && nPos != infoPtr->leftmostVisible)
880 {
881 if(nPos < infoPtr->leftmostVisible)
882 infoPtr->leftmostVisible--;
883 else
884 infoPtr->leftmostVisible++;
885
886 TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
887 TAB_InvalidateTabArea(infoPtr);
888 SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
889 MAKELONG(infoPtr->leftmostVisible, 0));
890 }
891
892 return 0;
893 }
894
895 /******************************************************************************
896 * TAB_SetupScrolling
897 *
898 * This method will check the current scrolling state and make sure the
899 * scrolling control is displayed (or not).
900 */
901 static void TAB_SetupScrolling(
902 HWND hwnd,
903 TAB_INFO* infoPtr,
904 const RECT* clientRect)
905 {
906 INT maxRange = 0;
907 DWORD lStyle = GetWindowLongA(hwnd, GWL_STYLE);
908
909 if (infoPtr->needsScrolling)
910 {
911 RECT controlPos;
912 INT vsize, tabwidth;
913
914 /*
915 * Calculate the position of the scroll control.
916 */
917 if(lStyle & TCS_VERTICAL)
918 {
919 controlPos.right = clientRect->right;
920 controlPos.left = controlPos.right - 2 * GetSystemMetrics(SM_CXHSCROLL);
921
922 if (lStyle & TCS_BOTTOM)
923 {
924 controlPos.top = clientRect->bottom - infoPtr->tabHeight;
925 controlPos.bottom = controlPos.top + GetSystemMetrics(SM_CYHSCROLL);
926 }
927 else
928 {
929 controlPos.bottom = clientRect->top + infoPtr->tabHeight;
930 controlPos.top = controlPos.bottom - GetSystemMetrics(SM_CYHSCROLL);
931 }
932 }
933 else
934 {
935 controlPos.right = clientRect->right;
936 controlPos.left = controlPos.right - 2 * GetSystemMetrics(SM_CXHSCROLL);
937
938 if (lStyle & TCS_BOTTOM)
939 {
940 controlPos.top = clientRect->bottom - infoPtr->tabHeight;
941 controlPos.bottom = controlPos.top + GetSystemMetrics(SM_CYHSCROLL);
942 }
943 else
944 {
945 controlPos.bottom = clientRect->top + infoPtr->tabHeight;
946 controlPos.top = controlPos.bottom - GetSystemMetrics(SM_CYHSCROLL);
947 }
948 }
949
950 /*
951 * If we don't have a scroll control yet, we want to create one.
952 * If we have one, we want to make sure it's positioned properly.
953 */
954 if (infoPtr->hwndUpDown==0)
955 {
956 infoPtr->hwndUpDown = CreateWindowA("msctls_updown32",
957 "",
958 WS_VISIBLE | WS_CHILD | UDS_HORZ,
959 controlPos.left, controlPos.top,
960 controlPos.right - controlPos.left,
961 controlPos.bottom - controlPos.top,
962 hwnd,
963 NULL,
964 NULL,
965 NULL);
966 }
967 else
968 {
969 SetWindowPos(infoPtr->hwndUpDown,
970 NULL,
971 controlPos.left, controlPos.top,
972 controlPos.right - controlPos.left,
973 controlPos.bottom - controlPos.top,
974 SWP_SHOWWINDOW | SWP_NOZORDER);
975 }
976
977 /* Now calculate upper limit of the updown control range.
978 * We do this by calculating how many tabs will be offscreen when the
979 * last tab is visible.
980 */
981 if(infoPtr->uNumItem)
982 {
983 vsize = clientRect->right - (controlPos.right - controlPos.left + 1);
984 maxRange = infoPtr->uNumItem;
985 tabwidth = TAB_GetItem(infoPtr, infoPtr->uNumItem - 1)->rect.right;
986
987 for(; maxRange > 0; maxRange--)
988 {
989 if(tabwidth - TAB_GetItem(infoPtr,maxRange - 1)->rect.left > vsize)
990 break;
991 }
992
993 if(maxRange == infoPtr->uNumItem)
994 maxRange--;
995 }
996 }
997 else
998 {
999 /* If we once had a scroll control... hide it */
1000 if (infoPtr->hwndUpDown!=0)
1001 ShowWindow(infoPtr->hwndUpDown, SW_HIDE);
1002 }
1003 if (infoPtr->hwndUpDown)
1004 SendMessageW(infoPtr->hwndUpDown, UDM_SETRANGE32, 0, maxRange);
1005 }
1006
1007 /******************************************************************************
1008 * TAB_SetItemBounds
1009 *
1010 * This method will calculate the position rectangles of all the items in the
1011 * control. The rectangle calculated starts at 0 for the first item in the
1012 * list and ignores scrolling and selection.
1013 * It also uses the current font to determine the height of the tab row and
1014 * it checks if all the tabs fit in the client area of the window. If they
1015 * don't, a scrolling control is added.
1016 */
1017 static void TAB_SetItemBounds (TAB_INFO *infoPtr)
1018 {
1019 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
1020 TEXTMETRICA fontMetrics;
1021 UINT curItem;
1022 INT curItemLeftPos;
1023 INT curItemRowCount;
1024 HFONT hFont, hOldFont;
1025 HDC hdc;
1026 RECT clientRect;
1027 SIZE size;
1028 INT iTemp;
1029 RECT* rcItem;
1030 INT iIndex;
1031 INT icon_width = 0;
1032
1033 /*
1034 * We need to get text information so we need a DC and we need to select
1035 * a font.
1036 */
1037 hdc = GetDC(infoPtr->hwnd);
1038
1039 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
1040 hOldFont = SelectObject (hdc, hFont);
1041
1042 /*
1043 * We will base the rectangle calculations on the client rectangle
1044 * of the control.
1045 */
1046 GetClientRect(infoPtr->hwnd, &clientRect);
1047
1048 /* if TCS_VERTICAL then swap the height and width so this code places the
1049 tabs along the top of the rectangle and we can just rotate them after
1050 rather than duplicate all of the below code */
1051 if(lStyle & TCS_VERTICAL)
1052 {
1053 iTemp = clientRect.bottom;
1054 clientRect.bottom = clientRect.right;
1055 clientRect.right = iTemp;
1056 }
1057
1058 /* Now use hPadding and vPadding */
1059 infoPtr->uHItemPadding = infoPtr->uHItemPadding_s;
1060 infoPtr->uVItemPadding = infoPtr->uVItemPadding_s;
1061
1062 /* The leftmost item will be "0" aligned */
1063 curItemLeftPos = 0;
1064 curItemRowCount = infoPtr->uNumItem ? 1 : 0;
1065
1066 if (!(infoPtr->fHeightSet))
1067 {
1068 int item_height;
1069 int icon_height = 0;
1070
1071 /* Use the current font to determine the height of a tab. */
1072 GetTextMetricsA(hdc, &fontMetrics);
1073
1074 /* Get the icon height */
1075 if (infoPtr->himl)
1076 ImageList_GetIconSize(infoPtr->himl, 0, &icon_height);
1077
1078 /* Take the highest between font or icon */
1079 if (fontMetrics.tmHeight > icon_height)
1080 item_height = fontMetrics.tmHeight + 2;
1081 else
1082 item_height = icon_height;
1083
1084 /*
1085 * Make sure there is enough space for the letters + icon + growing the
1086 * selected item + extra space for the selected item.
1087 */
1088 infoPtr->tabHeight = item_height +
1089 ((lStyle & TCS_BUTTONS) ? 2 : 1) *
1090 infoPtr->uVItemPadding;
1091
1092 TRACE("tabH=%d, tmH=%ld, iconh=%d\n",
1093 infoPtr->tabHeight, fontMetrics.tmHeight, icon_height);
1094 }
1095
1096 TRACE("client right=%ld\n", clientRect.right);
1097
1098 /* Get the icon width */
1099 if (infoPtr->himl)
1100 {
1101 ImageList_GetIconSize(infoPtr->himl, &icon_width, 0);
1102
1103 if (lStyle & TCS_FIXEDWIDTH)
1104 icon_width += 4;
1105 else
1106 /* Add padding if icon is present */
1107 icon_width += infoPtr->uHItemPadding;
1108 }
1109
1110 for (curItem = 0; curItem < infoPtr->uNumItem; curItem++)
1111 {
1112 TAB_ITEM *curr = TAB_GetItem(infoPtr, curItem);
1113
1114 /* Set the leftmost position of the tab. */
1115 curr->rect.left = curItemLeftPos;
1116
1117 if ((lStyle & TCS_FIXEDWIDTH) || !curr->pszText)
1118 {
1119 curr->rect.right = curr->rect.left +
1120 max(infoPtr->tabWidth, icon_width);
1121 }
1122 else
1123 {
1124 int num = 2;
1125
1126 /* Calculate how wide the tab is depending on the text it contains */
1127 GetTextExtentPoint32W(hdc, curr->pszText,
1128 lstrlenW(curr->pszText), &size);
1129
1130 curr->rect.right = curr->rect.left + size.cx + icon_width +
1131 num * infoPtr->uHItemPadding;
1132 TRACE("for <%s>, l,r=%ld,%ld, num=%d\n",
1133 debugstr_w(curr->pszText), curr->rect.left, curr->rect.right, num);
1134 }
1135
1136 /*
1137 * Check if this is a multiline tab control and if so
1138 * check to see if we should wrap the tabs
1139 *
1140 * Wrap all these tabs. We will arrange them evenly later.
1141 *
1142 */
1143
1144 if (((lStyle & TCS_MULTILINE) || (lStyle & TCS_VERTICAL)) &&
1145 (curr->rect.right >
1146 (clientRect.right - CONTROL_BORDER_SIZEX - DISPLAY_AREA_PADDINGX)))
1147 {
1148 curr->rect.right -= curr->rect.left;
1149
1150 curr->rect.left = 0;
1151 curItemRowCount++;
1152 TRACE("wrapping <%s>, l,r=%ld,%ld\n", debugstr_w(curr->pszText),
1153 curr->rect.left, curr->rect.right);
1154 }
1155
1156 curr->rect.bottom = 0;
1157 curr->rect.top = curItemRowCount - 1;
1158
1159 TRACE("TextSize: %li\n", size.cx);
1160 TRACE("Rect: T %li, L %li, B %li, R %li\n", curr->rect.top,
1161 curr->rect.left, curr->rect.bottom, curr->rect.right);
1162
1163 /*
1164 * The leftmost position of the next item is the rightmost position
1165 * of this one.
1166 */
1167 if (lStyle & TCS_BUTTONS)
1168 {
1169 curItemLeftPos = curr->rect.right + BUTTON_SPACINGX;
1170 if (lStyle & TCS_FLATBUTTONS)
1171 curItemLeftPos += FLAT_BTN_SPACINGX;
1172 }
1173 else
1174 curItemLeftPos = curr->rect.right;
1175 }
1176
1177 if (!((lStyle & TCS_MULTILINE) || (lStyle & TCS_VERTICAL)))
1178 {
1179 /*
1180 * Check if we need a scrolling control.
1181 */
1182 infoPtr->needsScrolling = (curItemLeftPos + (2 * SELECTED_TAB_OFFSET) >
1183 clientRect.right);
1184
1185 /* Don't need scrolling, then update infoPtr->leftmostVisible */
1186 if(!infoPtr->needsScrolling)
1187 infoPtr->leftmostVisible = 0;
1188 }
1189 else
1190 {
1191 /*
1192 * No scrolling in Multiline or Vertical styles.
1193 */
1194 infoPtr->needsScrolling = FALSE;
1195 infoPtr->leftmostVisible = 0;
1196 }
1197 TAB_SetupScrolling(infoPtr->hwnd, infoPtr, &clientRect);
1198
1199 /* Set the number of rows */
1200 infoPtr->uNumRows = curItemRowCount;
1201
1202 /* Arrange all tabs evenly if style says so */
1203 if (!(lStyle & TCS_RAGGEDRIGHT) && ((lStyle & TCS_MULTILINE) || (lStyle & TCS_VERTICAL)) && (infoPtr->uNumItem > 0))
1204 {
1205 INT tabPerRow,remTab,iRow;
1206 UINT iItm;
1207 INT iCount=0;
1208
1209 /*
1210 * Ok windows tries to even out the rows. place the same
1211 * number of tabs in each row. So lets give that a shot
1212 */
1213
1214 tabPerRow = infoPtr->uNumItem / (infoPtr->uNumRows);
1215 remTab = infoPtr->uNumItem % (infoPtr->uNumRows);
1216
1217 for (iItm=0,iRow=0,iCount=0,curItemLeftPos=0;
1218 iItm<infoPtr->uNumItem;
1219 iItm++,iCount++)
1220 {
1221 /* normalize the current rect */
1222 TAB_ITEM *curr = TAB_GetItem(infoPtr, iItm);
1223
1224 /* shift the item to the left side of the clientRect */
1225 curr->rect.right -= curr->rect.left;
1226 curr->rect.left = 0;
1227
1228 TRACE("r=%ld, cl=%d, cl.r=%ld, iCount=%d, iRow=%d, uNumRows=%d, remTab=%d, tabPerRow=%d\n",
1229 curr->rect.right, curItemLeftPos, clientRect.right,
1230 iCount, iRow, infoPtr->uNumRows, remTab, tabPerRow);
1231
1232 /* if we have reached the maximum number of tabs on this row */
1233 /* move to the next row, reset our current item left position and */
1234 /* the count of items on this row */
1235
1236 if (lStyle & TCS_VERTICAL) {
1237 /* Vert: Add the remaining tabs in the *last* remainder rows */
1238 if (iCount >= ((iRow>=(INT)infoPtr->uNumRows - remTab)?tabPerRow + 1:tabPerRow)) {
1239 iRow++;
1240 curItemLeftPos = 0;
1241 iCount = 0;
1242 }
1243 } else {
1244 /* Horz: Add the remaining tabs in the *first* remainder rows */
1245 if (iCount >= ((iRow<remTab)?tabPerRow + 1:tabPerRow)) {
1246 iRow++;
1247 curItemLeftPos = 0;
1248 iCount = 0;
1249 }
1250 }
1251
1252 /* shift the item to the right to place it as the next item in this row */
1253 curr->rect.left += curItemLeftPos;
1254 curr->rect.right += curItemLeftPos;
1255 curr->rect.top = iRow;
1256 if (lStyle & TCS_BUTTONS)
1257 {
1258 curItemLeftPos = curr->rect.right + 1;
1259 if (lStyle & TCS_FLATBUTTONS)
1260 curItemLeftPos += FLAT_BTN_SPACINGX;
1261 }
1262 else
1263 curItemLeftPos = curr->rect.right;
1264
1265 TRACE("arranging <%s>, l,r=%ld,%ld, row=%ld\n",
1266 debugstr_w(curr->pszText), curr->rect.left,
1267 curr->rect.right, curr->rect.top);
1268 }
1269
1270 /*
1271 * Justify the rows
1272 */
1273 {
1274 INT widthDiff, iIndexStart=0, iIndexEnd=0;
1275 INT remainder;
1276 INT iCount=0;
1277
1278 while(iIndexStart < infoPtr->uNumItem)
1279 {
1280 TAB_ITEM *start = TAB_GetItem(infoPtr, iIndexStart);
1281
1282 /*
1283 * find the index of the row
1284 */
1285 /* find the first item on the next row */
1286 for (iIndexEnd=iIndexStart;
1287 (iIndexEnd < infoPtr->uNumItem) &&
1288 (TAB_GetItem(infoPtr, iIndexEnd)->rect.top ==
1289 start->rect.top) ;
1290 iIndexEnd++)
1291 /* intentionally blank */;
1292
1293 /*
1294 * we need to justify these tabs so they fill the whole given
1295 * client area
1296 *
1297 */
1298 /* find the amount of space remaining on this row */
1299 widthDiff = clientRect.right - (2 * SELECTED_TAB_OFFSET) -
1300 TAB_GetItem(infoPtr, iIndexEnd - 1)->rect.right;
1301
1302 /* iCount is the number of tab items on this row */
1303 iCount = iIndexEnd - iIndexStart;
1304
1305 if (iCount > 1)
1306 {
1307 remainder = widthDiff % iCount;
1308 widthDiff = widthDiff / iCount;
1309 /* add widthDiff/iCount, or extra space/items on row, to each item on this row */
1310 for (iIndex=iIndexStart, iCount=0; iIndex < iIndexEnd; iIndex++, iCount++)
1311 {
1312 TAB_ITEM *item = TAB_GetItem(infoPtr, iIndex);
1313
1314 item->rect.left += iCount * widthDiff;
1315 item->rect.right += (iCount + 1) * widthDiff;
1316
1317 TRACE("adjusting 1 <%s>, l,r=%ld,%ld\n",
1318 debugstr_w(item->pszText),
1319 item->rect.left, item->rect.right);
1320
1321 }
1322 TAB_GetItem(infoPtr, iIndex - 1)->rect.right += remainder;
1323 }
1324 else /* we have only one item on this row, make it take up the entire row */
1325 {
1326 start->rect.left = clientRect.left;
1327 start->rect.right = clientRect.right - 4;
1328
1329 TRACE("adjusting 2 <%s>, l,r=%ld,%ld\n",
1330 debugstr_w(start->pszText),
1331 start->rect.left, start->rect.right);
1332
1333 }
1334
1335
1336 iIndexStart = iIndexEnd;
1337 }
1338 }
1339 }
1340
1341 /* if TCS_VERTICAL rotate the tabs so they are along the side of the clientRect */
1342 if(lStyle & TCS_VERTICAL)
1343 {
1344 RECT rcOriginal;
1345 for(iIndex = 0; iIndex < infoPtr->uNumItem; iIndex++)
1346 {
1347 rcItem = &TAB_GetItem(infoPtr, iIndex)->rect;
1348
1349 rcOriginal = *rcItem;
1350
1351 /* this is rotating the items by 90 degrees clockwise around the center of the control */
1352 rcItem->top = (rcOriginal.left - clientRect.left);
1353 rcItem->bottom = rcItem->top + (rcOriginal.right - rcOriginal.left);
1354 rcItem->left = rcOriginal.top;
1355 rcItem->right = rcOriginal.bottom;
1356 }
1357 }
1358
1359 TAB_EnsureSelectionVisible(infoPtr);
1360 TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
1361
1362 /* Cleanup */
1363 SelectObject (hdc, hOldFont);
1364 ReleaseDC (infoPtr->hwnd, hdc);
1365 }
1366
1367
1368 static void
1369 TAB_EraseTabInterior
1370 (
1371 TAB_INFO* infoPtr,
1372 HDC hdc,
1373 INT iItem,
1374 RECT* drawRect
1375 )
1376 {
1377 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
1378 HBRUSH hbr = CreateSolidBrush (comctl32_color.clrBtnFace);
1379 BOOL deleteBrush = TRUE;
1380 RECT rTemp = *drawRect;
1381
1382 InflateRect(&rTemp, -2, -2);
1383 if (lStyle & TCS_BUTTONS)
1384 {
1385 if (iItem == infoPtr->iSelected)
1386 {
1387 /* Background color */
1388 if (!(lStyle & TCS_OWNERDRAWFIXED))
1389 {
1390 DeleteObject(hbr);
1391 hbr = GetSysColorBrush(COLOR_SCROLLBAR);
1392
1393 SetTextColor(hdc, comctl32_color.clr3dFace);
1394 SetBkColor(hdc, comctl32_color.clr3dHilight);
1395
1396 /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
1397 * we better use 0x55aa bitmap brush to make scrollbar's background
1398 * look different from the window background.
1399 */
1400 if (comctl32_color.clr3dHilight == comctl32_color.clrWindow)
1401 hbr = COMCTL32_hPattern55AABrush;
1402
1403 deleteBrush = FALSE;
1404 }
1405 FillRect(hdc, &rTemp, hbr);
1406 }
1407 else /* ! selected */
1408 {
1409 if (lStyle & TCS_FLATBUTTONS)
1410 {
1411 FillRect(hdc, drawRect, hbr);
1412 if (iItem == infoPtr->iHotTracked)
1413 DrawEdge(hdc, drawRect, EDGE_RAISED, BF_SOFT|BF_RECT);
1414 }
1415 else
1416 FillRect(hdc, &rTemp, hbr);
1417 }
1418
1419 }
1420 else /* !TCS_BUTTONS */
1421 {
1422 FillRect(hdc, &rTemp, hbr);
1423 }
1424
1425 /* Cleanup */
1426 if (deleteBrush) DeleteObject(hbr);
1427 }
1428
1429 /******************************************************************************
1430 * TAB_DrawItemInterior
1431 *
1432 * This method is used to draw the interior (text and icon) of a single tab
1433 * into the tab control.
1434 */
1435 static void
1436 TAB_DrawItemInterior
1437 (
1438 TAB_INFO* infoPtr,
1439 HDC hdc,
1440 INT iItem,
1441 RECT* drawRect
1442 )
1443 {
1444 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
1445
1446 RECT localRect;
1447
1448 HPEN htextPen;
1449 HPEN holdPen;
1450 INT oldBkMode;
1451 HFONT hOldFont;
1452
1453 /* if (drawRect == NULL) */
1454 {
1455 BOOL isVisible;
1456 RECT itemRect;
1457 RECT selectedRect;
1458
1459 /*
1460 * Get the rectangle for the item.
1461 */
1462 isVisible = TAB_InternalGetItemRect(infoPtr, iItem, &itemRect, &selectedRect);
1463 if (!isVisible)
1464 return;
1465
1466 /*
1467 * Make sure drawRect points to something valid; simplifies code.
1468 */
1469 drawRect = &localRect;
1470
1471 /*
1472 * This logic copied from the part of TAB_DrawItem which draws
1473 * the tab background. It's important to keep it in sync. I
1474 * would have liked to avoid code duplication, but couldn't figure
1475 * out how without making spaghetti of TAB_DrawItem.
1476 */
1477 if (iItem == infoPtr->iSelected)
1478 *drawRect = selectedRect;
1479 else
1480 *drawRect = itemRect;
1481
1482 if (lStyle & TCS_BUTTONS)
1483 {
1484 if (iItem == infoPtr->iSelected)
1485 {
1486 drawRect->left += 4;
1487 drawRect->top += 4;
1488 drawRect->right -= 4;
1489 drawRect->bottom -= 1;
1490 }
1491 else
1492 {
1493 drawRect->left += 2;
1494 drawRect->top += 2;
1495 drawRect->right -= 2;
1496 drawRect->bottom -= 2;
1497 }
1498 }
1499 else
1500 {
1501 if ((lStyle & TCS_VERTICAL) && (lStyle & TCS_BOTTOM))
1502 {
1503 if (iItem != infoPtr->iSelected)
1504 {
1505 drawRect->left += 2;
1506 drawRect->top += 2;
1507 drawRect->bottom -= 2;
1508 }
1509 }
1510 else if (lStyle & TCS_VERTICAL)
1511 {
1512 if (iItem == infoPtr->iSelected)
1513 {
1514 drawRect->right += 1;
1515 }
1516 else
1517 {
1518 drawRect->top += 2;
1519 drawRect->right -= 2;
1520 drawRect->bottom -= 2;
1521 }
1522 }
1523 else if (lStyle & TCS_BOTTOM)
1524 {
1525 if (iItem == infoPtr->iSelected)
1526 {
1527 drawRect->top -= 2;
1528 }
1529 else
1530 {
1531 InflateRect(drawRect, -2, -2);
1532 drawRect->bottom += 2;
1533 }
1534 }
1535 else
1536 {
1537 if (iItem == infoPtr->iSelected)
1538 {
1539 drawRect->bottom += 3;
1540 }
1541 else
1542 {
1543 drawRect->bottom -= 2;
1544 InflateRect(drawRect, -2, 0);
1545 }
1546 }
1547 }
1548 }
1549 TRACE("drawRect=(%ld,%ld)-(%ld,%ld)\n",
1550 drawRect->left, drawRect->top, drawRect->right, drawRect->bottom);
1551
1552 /* Clear interior */
1553 TAB_EraseTabInterior (infoPtr, hdc, iItem, drawRect);
1554
1555 /* Draw the focus rectangle */
1556 if (!(lStyle & TCS_FOCUSNEVER) &&
1557 (GetFocus() == infoPtr->hwnd) &&
1558 (iItem == infoPtr->uFocus) )
1559 {
1560 RECT rFocus = *drawRect;
1561 InflateRect(&rFocus, -3, -3);
1562 if (lStyle & TCS_BOTTOM && !(lStyle & TCS_VERTICAL))
1563 rFocus.top -= 3;
1564 if (lStyle & TCS_BUTTONS)
1565 {
1566 rFocus.left -= 3;
1567 rFocus.top -= 3;
1568 }
1569
1570 DrawFocusRect(hdc, &rFocus);
1571 }
1572
1573 /*
1574 * Text pen
1575 */
1576 htextPen = CreatePen( PS_SOLID, 1, GetSysColor(COLOR_BTNTEXT) );
1577 holdPen = SelectObject(hdc, htextPen);
1578 hOldFont = SelectObject(hdc, infoPtr->hFont);
1579
1580 /*
1581 * Setup for text output
1582 */
1583 oldBkMode = SetBkMode(hdc, TRANSPARENT);
1584 SetTextColor(hdc, (((iItem == infoPtr->iHotTracked) && !(lStyle & TCS_FLATBUTTONS)) |
1585 (TAB_GetItem(infoPtr, iItem)->dwState & TCIS_HIGHLIGHTED)) ?
1586 comctl32_color.clrHighlight : comctl32_color.clrBtnText);
1587
1588 /*
1589 * if owner draw, tell the owner to draw
1590 */
1591 if ((lStyle & TCS_OWNERDRAWFIXED) && GetParent(infoPtr->hwnd))
1592 {
1593 DRAWITEMSTRUCT dis;
1594 UINT id;
1595
1596 drawRect->top += 2;
1597 drawRect->right -= 1;
1598 if ( iItem == infoPtr->iSelected )
1599 {
1600 drawRect->right -= 1;
1601 drawRect->left += 1;
1602 }
1603
1604 /*
1605 * get the control id
1606 */
1607 id = (UINT)GetWindowLongPtrW( infoPtr->hwnd, GWLP_ID );
1608
1609 /*
1610 * put together the DRAWITEMSTRUCT
1611 */
1612 dis.CtlType = ODT_TAB;
1613 dis.CtlID = id;
1614 dis.itemID = iItem;
1615 dis.itemAction = ODA_DRAWENTIRE;
1616 dis.itemState = 0;
1617 if ( iItem == infoPtr->iSelected )
1618 dis.itemState |= ODS_SELECTED;
1619 if (infoPtr->uFocus == iItem)
1620 dis.itemState |= ODS_FOCUS;
1621 dis.hwndItem = infoPtr->hwnd;
1622 dis.hDC = hdc;
1623 CopyRect(&dis.rcItem,drawRect);
1624 dis.itemData = (ULONG_PTR)TAB_GetItem(infoPtr, iItem)->extra;
1625
1626 /*
1627 * send the draw message
1628 */
1629 SendMessageW( infoPtr->hwndNotify, WM_DRAWITEM, (WPARAM)id, (LPARAM)&dis );
1630 }
1631 else
1632 {
1633 TAB_ITEM *item = TAB_GetItem(infoPtr, iItem);
1634 RECT rcTemp;
1635 RECT rcImage;
1636
1637 /* used to center the icon and text in the tab */
1638 RECT rcText;
1639 INT center_offset_h, center_offset_v;
1640
1641 /* set rcImage to drawRect, we will use top & left in our ImageList_Draw call */
1642 rcImage = *drawRect;
1643
1644 rcTemp = *drawRect;
1645
1646 rcText.left = rcText.top = rcText.right = rcText.bottom = 0;
1647
1648 /* get the rectangle that the text fits in */
1649 if (item->pszText)
1650 {
1651 DrawTextW(hdc, item->pszText, -1, &rcText, DT_CALCRECT);
1652 }
1653 /*
1654 * If not owner draw, then do the drawing ourselves.
1655 *
1656 * Draw the icon.
1657 */
1658 if (infoPtr->himl && (item->mask & TCIF_IMAGE))
1659 {
1660 INT cx;
1661 INT cy;
1662
1663 ImageList_GetIconSize(infoPtr->himl, &cx, &cy);
1664
1665 if(lStyle & TCS_VERTICAL)
1666 {
1667 center_offset_h = ((drawRect->bottom - drawRect->top) - (cy + infoPtr->uHItemPadding + (rcText.right - rcText.left))) / 2;
1668 center_offset_v = ((drawRect->right - drawRect->left) - (cx + infoPtr->uVItemPadding)) / 2;
1669 }
1670 else
1671 {
1672 center_offset_h = ((drawRect->right - drawRect->left) - (cx + infoPtr->uHItemPadding + (rcText.right - rcText.left))) / 2;
1673 center_offset_v = ((drawRect->bottom - drawRect->top) - (cy + infoPtr->uVItemPadding)) / 2;
1674 }
1675
1676 if (lStyle & TCS_FIXEDWIDTH && lStyle & (TCS_FORCELABELLEFT | TCS_FORCEICONLEFT))
1677 center_offset_h = infoPtr->uHItemPadding;
1678
1679 if (center_offset_h < 2)
1680 center_offset_h = 2;
1681
1682 if (center_offset_v < 0)
1683 center_offset_v = 0;
1684
1685 TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%ld,%ld)-(%ld,%ld), textlen=%ld\n",
1686 debugstr_w(item->pszText), center_offset_h, center_offset_v,
1687 drawRect->left, drawRect->top, drawRect->right, drawRect->bottom,
1688 (rcText.right-rcText.left));
1689
1690 if((lStyle & TCS_VERTICAL) && (lStyle & TCS_BOTTOM))
1691 {
1692 rcImage.top = drawRect->top + center_offset_h;
1693 /* if tab is TCS_VERTICAL and TCS_BOTTOM, the text is drawn from the */
1694 /* right side of the tab, but the image still uses the left as its x position */
1695 /* this keeps the image always drawn off of the same side of the tab */
1696 rcImage.left = drawRect->right - cx - center_offset_v;
1697 drawRect->top += cy + infoPtr->uHItemPadding;
1698 }
1699 else if(lStyle & TCS_VERTICAL)
1700 {
1701 rcImage.top = drawRect->bottom - cy - center_offset_h;
1702 rcImage.left = drawRect->left + center_offset_v;
1703 drawRect->bottom -= cy + infoPtr->uHItemPadding;
1704 }
1705 else /* normal style, whether TCS_BOTTOM or not */
1706 {
1707 rcImage.left = drawRect->left + center_offset_h;
1708 rcImage.top = drawRect->top + center_offset_v;
1709 drawRect->left += cx + infoPtr->uHItemPadding;
1710 }
1711
1712 TRACE("drawing image=%d, left=%ld, top=%ld\n",
1713 item->iImage, rcImage.left, rcImage.top-1);
1714 ImageList_Draw
1715 (
1716 infoPtr->himl,
1717 item->iImage,
1718 hdc,
1719 rcImage.left,
1720 rcImage.top,
1721 ILD_NORMAL
1722 );
1723 }
1724
1725 /* Now position text */
1726 if (lStyle & TCS_FIXEDWIDTH && lStyle & TCS_FORCELABELLEFT)
1727 center_offset_h = infoPtr->uHItemPadding;
1728 else
1729 if(lStyle & TCS_VERTICAL)
1730 center_offset_h = ((drawRect->bottom - drawRect->top) - (rcText.right - rcText.left)) / 2;
1731 else
1732 center_offset_h = ((drawRect->right - drawRect->left) - (rcText.right - rcText.left)) / 2;
1733
1734 if(lStyle & TCS_VERTICAL)
1735 {
1736 if(lStyle & TCS_BOTTOM)
1737 drawRect->top+=center_offset_h;
1738 else
1739 drawRect->bottom-=center_offset_h;
1740
1741 center_offset_v = ((drawRect->right - drawRect->left) - ((rcText.bottom - rcText.top) + infoPtr->uVItemPadding)) / 2;
1742 }
1743 else
1744 {
1745 drawRect->left += center_offset_h;
1746 center_offset_v = ((drawRect->bottom - drawRect->top) - ((rcText.bottom - rcText.top) + infoPtr->uVItemPadding)) / 2;
1747 }
1748
1749 if (center_offset_v < 0)
1750 center_offset_v = 0;
1751
1752 if(lStyle & TCS_VERTICAL)
1753 drawRect->left += center_offset_v;
1754 else
1755 drawRect->top += center_offset_v;
1756
1757 /* Draw the text */
1758 if(lStyle & TCS_VERTICAL) /* if we are vertical rotate the text and each character */
1759 {
1760 LOGFONTA logfont;
1761 HFONT hFont = 0;
1762 INT nEscapement = 900;
1763 INT nOrientation = 900;
1764
1765 if(lStyle & TCS_BOTTOM)
1766 {
1767 nEscapement = -900;
1768 nOrientation = -900;
1769 }
1770
1771 /* to get a font with the escapement and orientation we are looking for, we need to */
1772 /* call CreateFontIndirectA, which requires us to set the values of the logfont we pass in */
1773 if (!GetObjectA((infoPtr->hFont) ?
1774 infoPtr->hFont : GetStockObject(SYSTEM_FONT),
1775 sizeof(LOGFONTA),&logfont))
1776 {
1777 INT iPointSize = 9;
1778
1779 lstrcpyA(logfont.lfFaceName, "Arial");
1780 logfont.lfHeight = -MulDiv(iPointSize, GetDeviceCaps(hdc, LOGPIXELSY),
1781 72);
1782 logfont.lfWeight = FW_NORMAL;
1783 logfont.lfItalic = 0;
1784 logfont.lfUnderline = 0;
1785 logfont.lfStrikeOut = 0;
1786 }
1787
1788 logfont.lfEscapement = nEscapement;
1789 logfont.lfOrientation = nOrientation;
1790 hFont = CreateFontIndirectA(&logfont);
1791 SelectObject(hdc, hFont);
1792
1793 if (item->pszText)
1794 {
1795 ExtTextOutW(hdc,
1796 (lStyle & TCS_BOTTOM) ? drawRect->right : drawRect->left,
1797 (!(lStyle & TCS_BOTTOM)) ? drawRect->bottom : drawRect->top,
1798 ETO_CLIPPED,
1799 drawRect,
1800 item->pszText,
1801 lstrlenW(item->pszText),
1802 0);
1803 }
1804
1805 DeleteObject(hFont);
1806 }
1807 else
1808 {
1809 TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%ld,%ld)-(%ld,%ld), textlen=%ld\n",
1810 debugstr_w(item->pszText), center_offset_h, center_offset_v,
1811 drawRect->left, drawRect->top, drawRect->right, drawRect->bottom,
1812 (rcText.right-rcText.left));
1813 if (item->pszText)
1814 {
1815 DrawTextW
1816 (
1817 hdc,
1818 item->pszText,
1819 lstrlenW(item->pszText),
1820 drawRect,
1821 DT_LEFT | DT_SINGLELINE
1822 );
1823 }
1824 }
1825
1826 *drawRect = rcTemp; /* restore drawRect */
1827 }
1828
1829 /*
1830 * Cleanup
1831 */
1832 SelectObject(hdc, hOldFont);
1833 SetBkMode(hdc, oldBkMode);
1834 SelectObject(hdc, holdPen);
1835 DeleteObject( htextPen );
1836 }
1837
1838 /******************************************************************************
1839 * TAB_DrawItem
1840 *
1841 * This method is used to draw a single tab into the tab control.
1842 */
1843 static void TAB_DrawItem(
1844 TAB_INFO *infoPtr,
1845 HDC hdc,
1846 INT iItem)
1847 {
1848 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
1849 RECT itemRect;
1850 RECT selectedRect;
1851 BOOL isVisible;
1852 RECT r, fillRect, r1;
1853 INT clRight = 0;
1854 INT clBottom = 0;
1855 COLORREF bkgnd, corner;
1856
1857 /*
1858 * Get the rectangle for the item.
1859 */
1860 isVisible = TAB_InternalGetItemRect(infoPtr,
1861 iItem,
1862 &itemRect,
1863 &selectedRect);
1864
1865 if (isVisible)
1866 {
1867 RECT rUD, rC;
1868
1869 /* Clip UpDown control to not draw over it */
1870 if (infoPtr->needsScrolling)
1871 {
1872 GetWindowRect(infoPtr->hwnd, &rC);
1873 GetWindowRect(infoPtr->hwndUpDown, &rUD);
1874 ExcludeClipRect(hdc, rUD.left - rC.left, rUD.top - rC.top, rUD.right - rC.left, rUD.bottom - rC.top);
1875 }
1876
1877 /* If you need to see what the control is doing,
1878 * then override these variables. They will change what
1879 * fill colors are used for filling the tabs, and the
1880 * corners when drawing the edge.
1881 */
1882 bkgnd = comctl32_color.clrBtnFace;
1883 corner = comctl32_color.clrBtnFace;
1884
1885 if (lStyle & TCS_BUTTONS)
1886 {
1887 /* Get item rectangle */
1888 r = itemRect;
1889
1890 /* Separators between flat buttons */
1891 if (lStyle & TCS_FLATBUTTONS)
1892 {
1893 r1 = r;
1894 r1.right += (FLAT_BTN_SPACINGX -2);
1895 DrawEdge(hdc, &r1, EDGE_ETCHED, BF_RIGHT);
1896 }
1897
1898 if (iItem == infoPtr->iSelected)
1899 {
1900 DrawEdge(hdc, &r, EDGE_SUNKEN, BF_SOFT|BF_RECT);
1901
1902 OffsetRect(&r, 1, 1);
1903 }
1904 else /* ! selected */
1905 {
1906 if (!(lStyle & TCS_FLATBUTTONS))
1907 DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_RECT);
1908 }
1909 }
1910 else /* !TCS_BUTTONS */
1911 {
1912 /* We draw a rectangle of different sizes depending on the selection
1913 * state. */
1914 if (iItem == infoPtr->iSelected) {
1915 RECT rect;
1916 GetClientRect (infoPtr->hwnd, &rect);
1917 clRight = rect.right;
1918 clBottom = rect.bottom;
1919 r = selectedRect;
1920 }
1921 else
1922 r = itemRect;
1923
1924 /*
1925 * Erase the background. (Delay it but setup rectangle.)
1926 * This is necessary when drawing the selected item since it is larger
1927 * than the others, it might overlap with stuff already drawn by the
1928 * other tabs
1929 */
1930 fillRect = r;
1931
1932 if(lStyle & TCS_VERTICAL)
1933 {
1934 /* These are for adjusting the drawing of a Selected tab */
1935 /* The initial values are for the normal case of non-Selected */
1936 int ZZ = 1; /* Do not strech if selected */
1937 if (iItem == infoPtr->iSelected) {
1938 ZZ = 0;
1939
1940 /* if leftmost draw the line longer */
1941 if(selectedRect.top == 0)
1942 fillRect.top += CONTROL_BORDER_SIZEY;
1943 /* if rightmost draw the line longer */
1944 if(selectedRect.bottom == clBottom)
1945 fillRect.bottom -= CONTROL_BORDER_SIZEY;
1946 }
1947
1948 if (lStyle & TCS_BOTTOM)
1949 {
1950 /* Adjust both rectangles to match native */
1951 r.left += (1-ZZ);
1952
1953 TRACE("<right> item=%d, fill=(%ld,%ld)-(%ld,%ld), edge=(%ld,%ld)-(%ld,%ld)\n",
1954 iItem,
1955 fillRect.left,fillRect.top,fillRect.right,fillRect.bottom,
1956 r.left,r.top,r.right,r.bottom);
1957
1958 /* Clear interior */
1959 SetBkColor(hdc, bkgnd);
1960 ExtTextOutA(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
1961
1962 /* Draw rectangular edge around tab */
1963 DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_RIGHT|BF_TOP|BF_BOTTOM);
1964
1965 /* Now erase the top corner and draw diagonal edge */
1966 SetBkColor(hdc, corner);
1967 r1.left = r.right - ROUND_CORNER_SIZE - 1;
1968 r1.top = r.top;
1969 r1.right = r.right;
1970 r1.bottom = r1.top + ROUND_CORNER_SIZE;
1971 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
1972 r1.right--;
1973 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);
1974
1975 /* Now erase the bottom corner and draw diagonal edge */
1976 r1.left = r.right - ROUND_CORNER_SIZE - 1;
1977 r1.bottom = r.bottom;
1978 r1.right = r.right;
1979 r1.top = r1.bottom - ROUND_CORNER_SIZE;
1980 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
1981 r1.right--;
1982 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMLEFT);
1983
1984 if ((iItem == infoPtr->iSelected) && (selectedRect.top == 0)) {
1985 r1 = r;
1986 r1.right = r1.left;
1987 r1.left--;
1988 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_TOP);
1989 }
1990
1991 }
1992 else
1993 {
1994 TRACE("<left> item=%d, fill=(%ld,%ld)-(%ld,%ld), edge=(%ld,%ld)-(%ld,%ld)\n",
1995 iItem,
1996 fillRect.left,fillRect.top,fillRect.right,fillRect.bottom,
1997 r.left,r.top,r.right,r.bottom);
1998
1999 /* Clear interior */
2000 SetBkColor(hdc, bkgnd);
2001 ExtTextOutA(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2002
2003 /* Draw rectangular edge around tab */
2004 DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_TOP|BF_BOTTOM);
2005
2006 /* Now erase the top corner and draw diagonal edge */
2007 SetBkColor(hdc, corner);
2008 r1.left = r.left;
2009 r1.top = r.top;
2010 r1.right = r1.left + ROUND_CORNER_SIZE + 1;
2011 r1.bottom = r1.top + ROUND_CORNER_SIZE;
2012 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2013 r1.left++;
2014 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);
2015
2016 /* Now erase the bottom corner and draw diagonal edge */
2017 r1.left = r.left;
2018 r1.bottom = r.bottom;
2019 r1.right = r1.left + ROUND_CORNER_SIZE + 1;
2020 r1.top = r1.bottom - ROUND_CORNER_SIZE;
2021 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2022 r1.left++;
2023 DrawEdge(hdc, &r1, EDGE_SUNKEN, BF_DIAGONAL_ENDTOPLEFT);
2024 }
2025 }
2026 else /* ! TCS_VERTICAL */
2027 {
2028 /* These are for adjusting the drawing of a Selected tab */
2029 /* The initial values are for the normal case of non-Selected */
2030 if (iItem == infoPtr->iSelected) {
2031 /* if leftmost draw the line longer */
2032 if(selectedRect.left == 0)
2033 fillRect.left += CONTROL_BORDER_SIZEX;
2034 /* if rightmost draw the line longer */
2035 if(selectedRect.right == clRight)
2036 fillRect.right -= CONTROL_BORDER_SIZEX;
2037 }
2038
2039 if (lStyle & TCS_BOTTOM)
2040 {
2041 /* Adjust both rectangles for topmost row */
2042 if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
2043 {
2044 fillRect.top -= 2;
2045 r.top -= 1;
2046 }
2047
2048 TRACE("<bottom> item=%d, fill=(%ld,%ld)-(%ld,%ld), edge=(%ld,%ld)-(%ld,%ld)\n",
2049 iItem,
2050 fillRect.left,fillRect.top,fillRect.right,fillRect.bottom,
2051 r.left,r.top,r.right,r.bottom);
2052
2053 /* Clear interior */
2054 SetBkColor(hdc, bkgnd);
2055 ExtTextOutA(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2056
2057 /* Draw rectangular edge around tab */
2058 DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_BOTTOM|BF_RIGHT);
2059
2060 /* Now erase the righthand corner and draw diagonal edge */
2061 SetBkColor(hdc, corner);
2062 r1.left = r.right - ROUND_CORNER_SIZE;
2063 r1.bottom = r.bottom;
2064 r1.right = r.right;
2065 r1.top = r1.bottom - ROUND_CORNER_SIZE - 1;
2066 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2067 r1.bottom--;
2068 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMLEFT);
2069
2070 /* Now erase the lefthand corner and draw diagonal edge */
2071 r1.left = r.left;
2072 r1.bottom = r.bottom;
2073 r1.right = r1.left + ROUND_CORNER_SIZE;
2074 r1.top = r1.bottom - ROUND_CORNER_SIZE - 1;
2075 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2076 r1.bottom--;
2077 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);
2078
2079 if (iItem == infoPtr->iSelected)
2080 {
2081 r.top += 2;
2082 r.left += 1;
2083 if (selectedRect.left == 0)
2084 {
2085 r1 = r;
2086 r1.bottom = r1.top;
2087 r1.top--;
2088 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_LEFT);
2089 }
2090 }
2091
2092 }
2093 else
2094 {
2095 /* Adjust both rectangles for bottommost row */
2096 if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
2097 {
2098 fillRect.bottom += 3;
2099 r.bottom += 2;
2100 }
2101
2102 TRACE("<top> item=%d, fill=(%ld,%ld)-(%ld,%ld), edge=(%ld,%ld)-(%ld,%ld)\n",
2103 iItem,
2104 fillRect.left,fillRect.top,fillRect.right,fillRect.bottom,
2105 r.left,r.top,r.right,r.bottom);
2106
2107 /* Clear interior */
2108 SetBkColor(hdc, bkgnd);
2109 ExtTextOutA(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2110
2111 /* Draw rectangular edge around tab */
2112 DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_TOP|BF_RIGHT);
2113
2114 /* Now erase the righthand corner and draw diagonal edge */
2115 SetBkColor(hdc, corner);
2116 r1.left = r.right - ROUND_CORNER_SIZE;
2117 r1.top = r.top;
2118 r1.right = r.right;
2119 r1.bottom = r1.top + ROUND_CORNER_SIZE + 1;
2120 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2121 r1.top++;
2122 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMRIGHT);
2123
2124 /* Now erase the lefthand corner and draw diagonal edge */
2125 r1.left = r.left;
2126 r1.top = r.top;
2127 r1.right = r1.left + ROUND_CORNER_SIZE;
2128 r1.bottom = r1.top + ROUND_CORNER_SIZE + 1;
2129 ExtTextOutA(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2130 r1.top++;
2131 DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);
2132 }
2133 }
2134 }
2135
2136 TAB_DumpItemInternal(infoPtr, iItem);
2137
2138 /* This modifies r to be the text rectangle. */
2139 TAB_DrawItemInterior(infoPtr, hdc, iItem, &r);
2140 }
2141 }
2142
2143 /******************************************************************************
2144 * TAB_DrawBorder
2145 *
2146 * This method is used to draw the raised border around the tab control
2147 * "content" area.
2148 */
2149 static void TAB_DrawBorder (TAB_INFO *infoPtr, HDC hdc)
2150 {
2151 RECT rect;
2152 DWORD lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
2153
2154 GetClientRect (infoPtr->hwnd, &rect);
2155
2156 /*
2157 * Adjust for the style
2158 */
2159
2160 if (infoPtr->uNumItem)
2161 {
2162 if ((lStyle & TCS_BOTTOM) && !(lStyle & TCS_VERTICAL))
2163 rect.bottom -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2164 else if((lStyle & TCS_BOTTOM) && (lStyle & TCS_VERTICAL))
2165 rect.right -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2166 else if(lStyle & TCS_VERTICAL)
2167 rect.left += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2168 else /* not TCS_VERTICAL and not TCS_BOTTOM */
2169 rect.top += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2170 }
2171
2172 TRACE("border=(%ld,%ld)-(%ld,%ld)\n",
2173 rect.left, rect.top, rect.right, rect.bottom);
2174
2175 DrawEdge(hdc, &rect, EDGE_RAISED, BF_SOFT|BF_RECT);
2176 }
2177
2178 /******************************************************************************
2179 * TAB_Refresh
2180 *
2181 * This method repaints the tab control..
2182 */
2183 static void TAB_Refresh (TAB_INFO *infoPtr, HDC hdc)
2184 {
2185 HFONT hOldFont;
2186 INT i;
2187
2188 if (!infoPtr->DoRedraw)
2189 return;
2190
2191 hOldFont = SelectObject (hdc, infoPtr->hFont);
2192
2193 if (GetWindowLongA(infoPtr->hwnd, GWL_STYLE) & TCS_BUTTONS)
2194 {
2195 for (i = 0; i < infoPtr->uNumItem; i++)
2196 TAB_DrawItem (infoPtr, hdc, i);
2197 }
2198 else
2199 {
2200 /* Draw all the non selected item first */
2201 for (i = 0; i < infoPtr->uNumItem; i++)
2202 {
2203 if (i != infoPtr->iSelected)
2204 TAB_DrawItem (infoPtr, hdc, i);
2205 }
2206
2207 /* Now, draw the border, draw it before the selected item
2208 * since the selected item overwrites part of the border. */
2209 TAB_DrawBorder (infoPtr, hdc);
2210
2211 /* Then, draw the selected item */
2212 TAB_DrawItem (infoPtr, hdc, infoPtr->iSelected);
2213
2214 /* If we haven't set the current focus yet, set it now.
2215 * Only happens when we first paint the tab controls */
2216 if (infoPtr->uFocus == -1)
2217 TAB_SetCurFocus(infoPtr, infoPtr->iSelected);
2218 }
2219
2220 SelectObject (hdc, hOldFont);
2221 }
2222
2223 static inline DWORD TAB_GetRowCount (const TAB_INFO *infoPtr)
2224 {
2225 return infoPtr->uNumRows;
2226 }
2227
2228 static inline LRESULT TAB_SetRedraw (TAB_INFO *infoPtr, BOOL doRedraw)
2229 {
2230 infoPtr->DoRedraw = doRedraw;
2231 return 0;
2232 }
2233
2234 /******************************************************************************
2235 * TAB_EnsureSelectionVisible
2236 *
2237 * This method will make sure that the current selection is completely
2238 * visible by scrolling until it is.
2239 */
2240 static void TAB_EnsureSelectionVisible(
2241 TAB_INFO* infoPtr)
2242 {
2243 INT iSelected = infoPtr->iSelected;
2244 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
2245 INT iOrigLeftmostVisible = infoPtr->leftmostVisible;
2246
2247 /* set the items row to the bottommost row or topmost row depending on
2248 * style */
2249 if ((infoPtr->uNumRows > 1) && !(lStyle & TCS_BUTTONS))
2250 {
2251 TAB_ITEM *selected = TAB_GetItem(infoPtr, iSelected);
2252 INT newselected;
2253 INT iTargetRow;
2254
2255 if(lStyle & TCS_VERTICAL)
2256 newselected = selected->rect.left;
2257 else
2258 newselected = selected->rect.top;
2259
2260 /* the target row is always (number of rows - 1)
2261 as row 0 is furthest from the clientRect */
2262 iTargetRow = infoPtr->uNumRows - 1;
2263
2264 if (newselected != iTargetRow)
2265 {
2266 UINT i;
2267 if(lStyle & TCS_VERTICAL)
2268 {
2269 for (i=0; i < infoPtr->uNumItem; i++)
2270 {
2271 /* move everything in the row of the selected item to the iTargetRow */
2272 TAB_ITEM *item = TAB_GetItem(infoPtr, i);
2273
2274 if (item->rect.left == newselected )
2275 item->rect.left = iTargetRow;
2276 else
2277 {
2278 if (item->rect.left > newselected)
2279 item->rect.left-=1;
2280 }
2281 }
2282 }
2283 else
2284 {
2285 for (i=0; i < infoPtr->uNumItem; i++)
2286 {
2287 TAB_ITEM *item = TAB_GetItem(infoPtr, i);
2288
2289 if (item->rect.top == newselected )
2290 item->rect.top = iTargetRow;
2291 else
2292 {
2293 if (item->rect.top > newselected)
2294 item->rect.top-=1;
2295 }
2296 }
2297 }
2298 TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
2299 }
2300 }
2301
2302 /*
2303 * Do the trivial cases first.
2304 */
2305 if ( (!infoPtr->needsScrolling) ||
2306 (infoPtr->hwndUpDown==0) || (lStyle & TCS_VERTICAL))
2307 return;
2308
2309 if (infoPtr->leftmostVisible >= iSelected)
2310 {
2311 infoPtr->leftmostVisible = iSelected;
2312 }
2313 else
2314 {
2315 TAB_ITEM *selected = TAB_GetItem(infoPtr, iSelected);
2316 RECT r;
2317 INT width;
2318 UINT i;
2319
2320 /* Calculate the part of the client area that is visible */
2321 GetClientRect(infoPtr->hwnd, &r);
2322 width = r.right;
2323
2324 GetClientRect(infoPtr->hwndUpDown, &r);
2325 width -= r.right;
2326
2327 if ((selected->rect.right -
2328 selected->rect.left) >= width )
2329 {
2330 /* Special case: width of selected item is greater than visible
2331 * part of control.
2332 */
2333 infoPtr->leftmostVisible = iSelected;
2334 }
2335 else
2336 {
2337 for (i = infoPtr->leftmostVisible; i < infoPtr->uNumItem; i++)
2338 {
2339 if ((selected->rect.right - TAB_GetItem(infoPtr, i)->rect.left) < width)
2340 break;
2341 }
2342 infoPtr->leftmostVisible = i;
2343 }
2344 }
2345
2346 if (infoPtr->leftmostVisible != iOrigLeftmostVisible)
2347 TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
2348
2349 SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
2350 MAKELONG(infoPtr->leftmostVisible, 0));
2351 }
2352
2353 /******************************************************************************
2354 * TAB_InvalidateTabArea
2355 *
2356 * This method will invalidate the portion of the control that contains the
2357 * tabs. It is called when the state of the control changes and needs
2358 * to be redisplayed
2359 */
2360 static void TAB_InvalidateTabArea(TAB_INFO* infoPtr)
2361 {
2362 RECT clientRect, rInvalidate, rAdjClient;
2363 DWORD lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
2364 INT lastRow = infoPtr->uNumRows - 1;
2365 RECT rect;
2366
2367 if (lastRow < 0) return;
2368
2369 GetClientRect(infoPtr->hwnd, &clientRect);
2370 rInvalidate = clientRect;
2371 rAdjClient = clientRect;
2372
2373 TAB_AdjustRect(infoPtr, 0, &rAdjClient);
2374
2375 TAB_InternalGetItemRect(infoPtr, infoPtr->uNumItem-1 , &rect, NULL);
2376 if ((lStyle & TCS_BOTTOM) && (lStyle & TCS_VERTICAL))
2377 {
2378 rInvalidate.left = rAdjClient.right;
2379 if (infoPtr->uNumRows == 1)
2380 rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
2381 }
2382 else if(lStyle & TCS_VERTICAL)
2383 {
2384 rInvalidate.right = rAdjClient.left;
2385 if (infoPtr->uNumRows == 1)
2386 rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
2387 }
2388 else if (lStyle & TCS_BOTTOM)
2389 {
2390 rInvalidate.top = rAdjClient.bottom;
2391 if (infoPtr->uNumRows == 1)
2392 rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
2393 }
2394 else
2395 {
2396 rInvalidate.bottom = rAdjClient.top;
2397 if (infoPtr->uNumRows == 1)
2398 rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
2399 }
2400
2401 /* Punch out the updown control */
2402 if (infoPtr->needsScrolling && (rInvalidate.right > 0)) {
2403 RECT r;
2404 GetClientRect(infoPtr->hwndUpDown, &r);
2405 if (rInvalidate.right > clientRect.right - r.left)
2406 rInvalidate.right = rInvalidate.right - (r.right - r.left);
2407 else
2408 rInvalidate.right = clientRect.right - r.left;
2409 }
2410
2411 TRACE("invalidate (%ld,%ld)-(%ld,%ld)\n",
2412 rInvalidate.left, rInvalidate.top,
2413 rInvalidate.right, rInvalidate.bottom);
2414
2415 InvalidateRect(infoPtr->hwnd, &rInvalidate, TRUE);
2416 }
2417
2418 static inline LRESULT TAB_Paint (TAB_INFO *infoPtr, HDC hdcPaint)
2419 {
2420 HDC hdc;
2421 PAINTSTRUCT ps;
2422
2423 if (hdcPaint)
2424 hdc = hdcPaint;
2425 else
2426 {
2427 hdc = BeginPaint (infoPtr->hwnd, &ps);
2428 TRACE("erase %d, rect=(%ld,%ld)-(%ld,%ld)\n",
2429 ps.fErase,
2430 ps.rcPaint.left,ps.rcPaint.top,ps.rcPaint.right,ps.rcPaint.bottom);
2431 }
2432
2433 TAB_Refresh (infoPtr, hdc);
2434
2435 if (!hdcPaint)
2436 EndPaint (infoPtr->hwnd, &ps);
2437
2438 return 0;
2439 }
2440
2441 static LRESULT
2442 TAB_InsertItemAW (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam, BOOL bUnicode)
2443 {
2444 TAB_ITEM *item;
2445 TCITEMA *pti;
2446 INT iItem;
2447 RECT rect;
2448
2449 GetClientRect (infoPtr->hwnd, &rect);
2450 TRACE("Rect: %p T %li, L %li, B %li, R %li\n", infoPtr->hwnd,
2451 rect.top, rect.left, rect.bottom, rect.right);
2452
2453 pti = (TCITEMA *)lParam;
2454 iItem = (INT)wParam;
2455
2456 if (iItem < 0) return -1;
2457 if (iItem > infoPtr->uNumItem)
2458 iItem = infoPtr->uNumItem;
2459
2460 if (bUnicode)
2461 TAB_DumpItemExternalW((TCITEMW*)pti, iItem);
2462 else
2463 TAB_DumpItemExternalA(pti, iItem);
2464
2465
2466 if (infoPtr->uNumItem == 0) {
2467 infoPtr->items = Alloc (TAB_ITEM_SIZE(infoPtr));
2468 infoPtr->uNumItem++;
2469 infoPtr->iSelected = 0;
2470 }
2471 else {
2472 LPBYTE oldItems = (LPBYTE)infoPtr->items;
2473
2474 infoPtr->uNumItem++;
2475 infoPtr->items = Alloc (TAB_ITEM_SIZE(infoPtr) * infoPtr->uNumItem);
2476
2477 /* pre insert copy */
2478 if (iItem > 0) {
2479 memcpy (infoPtr->items, oldItems,
2480 iItem * TAB_ITEM_SIZE(infoPtr));
2481 }
2482
2483 /* post insert copy */
2484 if (iItem < infoPtr->uNumItem - 1) {
2485 memcpy (TAB_GetItem(infoPtr, iItem + 1),
2486 oldItems + iItem * TAB_ITEM_SIZE(infoPtr),
2487 (infoPtr->uNumItem - iItem - 1) * TAB_ITEM_SIZE(infoPtr));
2488
2489 }
2490
2491 if (iItem <= infoPtr->iSelected)
2492 infoPtr->iSelected++;
2493
2494 Free (oldItems);
2495 }
2496
2497 item = TAB_GetItem(infoPtr, iItem);
2498
2499 item->mask = pti->mask;
2500 item->pszText = NULL;
2501
2502 if (pti->mask & TCIF_TEXT)
2503 {
2504 if (bUnicode)
2505 Str_SetPtrW (&item->pszText, (WCHAR*)pti->pszText);
2506 else
2507 Str_SetPtrAtoW (&item->pszText, pti->pszText);
2508 }
2509
2510 if (pti->mask & TCIF_IMAGE)
2511 item->iImage = pti->iImage;
2512 else
2513 item->iImage = -1;
2514
2515 if (pti->mask & TCIF_PARAM)
2516 memcpy(item->extra, &pti->lParam, infoPtr->cbInfo);
2517 else
2518 memset(item->extra, 0, infoPtr->cbInfo);
2519
2520 TAB_SetItemBounds(infoPtr);
2521 if (infoPtr->uNumItem > 1)
2522 TAB_InvalidateTabArea(infoPtr);
2523 else
2524 InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2525
2526 TRACE("[%p]: added item %d %s\n",
2527 infoPtr->hwnd, iItem, debugstr_w(item->pszText));
2528
2529 return iItem;
2530 }
2531
2532 static LRESULT
2533 TAB_SetItemSize (TAB_INFO *infoPtr, LPARAM lParam)
2534 {
2535 LONG lStyle = GetWindowLongA(infoPtr->hwnd, GWL_STYLE);
2536 LONG lResult = 0;
2537 BOOL bNeedPaint = FALSE;
2538
2539 lResult = MAKELONG(infoPtr->tabWidth, infoPtr->tabHeight);
2540
2541 /* UNDOCUMENTED: If requested Width or Height is 0 this means that program wants to use auto size. */
2542 if (lStyle & TCS_FIXEDWIDTH && (infoPtr->tabWidth != (INT)LOWORD(lParam)))
2543 {
2544 infoPtr->tabWidth = max((INT)LOWORD(lParam), infoPtr->tabMinWidth);
2545 bNeedPaint = TRUE;
2546 }
2547
2548 if (infoPtr->tabHeight != (INT)HIWORD(lParam))
2549 {
2550 if ((infoPtr->fHeightSet = ((INT)HIWORD(lParam) != 0)))
2551 infoPtr->tabHeight = (INT)HIWORD(lParam);
2552
2553 bNeedPaint = TRUE;
2554 }
2555 TRACE("was h=%d,w=%d, now h=%d,w=%d\n",
2556 HIWORD(lResult), LOWORD(lResult),
2557 infoPtr->tabHeight, infoPtr->tabWidth);
2558
2559 if (bNeedPaint)
2560 {
2561 TAB_SetItemBounds(infoPtr);
2562 RedrawWindow(infoPtr->hwnd, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
2563 }
2564
2565 return lResult;
2566 }
2567
2568 static inline LRESULT TAB_SetMinTabWidth (TAB_INFO *infoPtr, INT cx)
2569 {
2570 INT oldcx = 0;
2571
2572 TRACE("(%p,%d)\n", infoPtr, cx);
2573
2574 if (infoPtr) {
2575 oldcx = infoPtr->tabMinWidth;
2576 infoPtr->tabMinWidth = (cx==-1)?DEFAULT_TAB_WIDTH:cx;
2577 }
2578
2579 return oldcx;
2580 }
2581
2582 static inline LRESULT
2583 TAB_HighlightItem (TAB_INFO *infoPtr, INT iItem, BOOL fHighlight)
2584 {
2585 LPDWORD lpState;
2586
2587 TRACE("(%p,%d,%s)\n", infoPtr, iItem, fHighlight ? "true" : "false");
2588
2589 if (!infoPtr || iItem < 0 || iItem >= infoPtr->uNumItem)
2590 return FALSE;
2591
2592 lpState = &TAB_GetItem(infoPtr, iItem)->dwState;
2593
2594 if (fHighlight)
2595 *lpState |= TCIS_HIGHLIGHTED;
2596 else
2597 *lpState &= ~TCIS_HIGHLIGHTED;
2598
2599 return TRUE;
2600 }
2601
2602 static LRESULT
2603 TAB_SetItemAW (TAB_INFO *infoPtr, INT iItem, LPTCITEMA tabItem, BOOL bUnicode)
2604 {
2605 TAB_ITEM *wineItem;
2606
2607 TRACE("(%p,%d,%p,%s)\n", infoPtr, iItem, tabItem, bUnicode ? "true" : "false");
2608
2609 if (iItem < 0 || iItem >= infoPtr->uNumItem)
2610 return FALSE;
2611
2612 if (bUnicode)
2613 TAB_DumpItemExternalW((TCITEMW *)tabItem, iItem);
2614 else
2615 TAB_DumpItemExternalA(tabItem, iItem);
2616
2617 wineItem = TAB_GetItem(infoPtr, iItem);
2618
2619 if (tabItem->mask & TCIF_IMAGE)
2620 wineItem->iImage = tabItem->iImage;
2621
2622 if (tabItem->mask & TCIF_PARAM)
2623 memcpy(wineItem->extra, &tabItem->lParam, infoPtr->cbInfo);
2624
2625 if (tabItem->mask & TCIF_RTLREADING)
2626 FIXME("TCIF_RTLREADING\n");
2627
2628 if (tabItem->mask & TCIF_STATE)
2629 wineItem->dwState = tabItem->dwState;
2630
2631 if (tabItem->mask & TCIF_TEXT)
2632 {
2633 if (wineItem->pszText)
2634 {
2635 Free(wineItem->pszText);
2636 wineItem->pszText = NULL;
2637 }
2638 if (bUnicode)
2639 Str_SetPtrW(&wineItem->pszText, (WCHAR*)tabItem->pszText);
2640 else
2641 Str_SetPtrAtoW(&wineItem->pszText, tabItem->pszText);
2642 }
2643
2644 /* Update and repaint tabs */
2645 TAB_SetItemBounds(infoPtr);
2646 TAB_InvalidateTabArea(infoPtr);
2647
2648 return TRUE;
2649 }
2650
2651 static inline LRESULT TAB_GetItemCount (const TAB_INFO *infoPtr)
2652 {
2653 return infoPtr->uNumItem;
2654 }
2655
2656
2657 static LRESULT
2658 TAB_GetItemAW (TAB_INFO *infoPtr, INT iItem, LPTCITEMA tabItem, BOOL bUnicode)
2659 {
2660 TAB_ITEM *wineItem;
2661
2662 TRACE("(%p,%d,%p,%s)\n", infoPtr, iItem, tabItem, bUnicode ? "true" : "false");
2663
2664 if (iItem < 0 || iItem >= infoPtr->uNumItem)
2665 return FALSE;
2666
2667 wineItem = TAB_GetItem(infoPtr, iItem);
2668
2669 if (tabItem->mask & TCIF_IMAGE)
2670 tabItem->iImage = wineItem->iImage;
2671
2672 if (tabItem->mask & TCIF_PARAM)
2673 memcpy(&tabItem->lParam, wineItem->extra, infoPtr->cbInfo);
2674
2675 if (tabItem->mask & TCIF_RTLREADING)
2676 FIXME("TCIF_RTLREADING\n");
2677
2678 if (tabItem->mask & TCIF_STATE)
2679 tabItem->dwState = wineItem->dwState;
2680
2681 if (tabItem->mask & TCIF_TEXT)
2682 {
2683 if (bUnicode)
2684 Str_GetPtrW (wineItem->pszText, (WCHAR*)tabItem->pszText, tabItem->cchTextMax);
2685 else
2686 Str_GetPtrWtoA (wineItem->pszText, tabItem->pszText, tabItem->cchTextMax);
2687 }
2688
2689 if (bUnicode)
2690 TAB_DumpItemExternalW((TCITEMW*)tabItem, iItem);
2691 else
2692 TAB_DumpItemExternalA(tabItem, iItem);
2693
2694 return TRUE;
2695 }
2696
2697
2698 static LRESULT TAB_DeleteItem (TAB_INFO *infoPtr, INT iItem)
2699 {
2700 BOOL bResult = FALSE;
2701
2702 TRACE("(%p, %d)\n", infoPtr, iItem);
2703
2704 if ((iItem >= 0) && (iItem < infoPtr->uNumItem))
2705 {
2706 TAB_ITEM *item = TAB_GetItem(infoPtr, iItem);
2707 LPBYTE oldItems = (LPBYTE)infoPtr->items;
2708
2709 TAB_InvalidateTabArea(infoPtr);
2710
2711 if ((item->mask & TCIF_TEXT) && item->pszText)
2712 Free(item->pszText);
2713
2714 infoPtr->uNumItem--;
2715
2716 if (!infoPtr->uNumItem)
2717 {
2718 infoPtr->items = NULL;
2719 if (infoPtr->iHotTracked >= 0)
2720 {
2721 KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
2722 infoPtr->iHotTracked = -1;
2723 }
2724 }
2725 else
2726 {
2727 infoPtr->items = Alloc(TAB_ITEM_SIZE(infoPtr) * infoPtr->uNumItem);
2728
2729 if (iItem > 0)
2730 memcpy(infoPtr->items, oldItems, iItem * TAB_ITEM_SIZE(infoPtr));
2731
2732 if (iItem < infoPtr->uNumItem)
2733 memcpy(TAB_GetItem(infoPtr, iItem),
2734 oldItems + (iItem + 1) * TAB_ITEM_SIZE(infoPtr),
2735 (infoPtr->uNumItem - iItem) * TAB_ITEM_SIZE(infoPtr));
2736
2737 if (iItem <= infoPtr->iHotTracked)
2738 {
2739 /* When tabs move left/up, the hot track item may change */
2740 FIXME("Recalc hot track");
2741 }
2742 }
2743 Free(oldItems);
2744
2745 /* Readjust the selected index */
2746 if ((iItem == infoPtr->iSelected) && (iItem > 0))
2747 infoPtr->iSelected--;
2748
2749 if (iItem < infoPtr->iSelected)
2750 infoPtr->iSelected--;
2751
2752 if (infoPtr->uNumItem == 0)
2753 infoPtr->iSelected = -1;
2754
2755 /* Reposition and repaint tabs */
2756 TAB_SetItemBounds(infoPtr);
2757
2758 bResult = TRUE;
2759 }
2760
2761 return bResult;
2762 }
2763
2764 static inline LRESULT TAB_DeleteAllItems (TAB_INFO *infoPtr)
2765 {
2766 TRACE("(%p)\n", infoPtr);
2767 while (infoPtr->uNumItem)
2768 TAB_DeleteItem (infoPtr, 0);
2769 return TRUE;
2770 }
2771
2772
2773 static inline LRESULT TAB_GetFont (const TAB_INFO *infoPtr)
2774 {
2775 TRACE("(%p) returning %p\n", infoPtr, infoPtr->hFont);
2776 return (LRESULT)infoPtr->hFont;
2777 }
2778
2779 static inline LRESULT TAB_SetFont (TAB_INFO *infoPtr, HFONT hNewFont)
2780 {
2781 TRACE("(%p,%p)\n", infoPtr, hNewFont);
2782
2783 infoPtr->hFont = hNewFont;
2784
2785 TAB_SetItemBounds(infoPtr);
2786
2787 TAB_InvalidateTabArea(infoPtr);
2788
2789 return 0;
2790 }
2791
2792
2793 static inline LRESULT TAB_GetImageList (const TAB_INFO *infoPtr)
2794 {
2795 TRACE("\n");
2796 return (LRESULT)infoPtr->himl;
2797 }
2798
2799 static inline LRESULT TAB_SetImageList (TAB_INFO *infoPtr, HIMAGELIST himlNew)
2800 {
2801 HIMAGELIST himlPrev = infoPtr->himl;
2802 TRACE("\n");
2803 infoPtr->himl = himlNew;
2804 return (LRESULT)himlPrev;
2805 }
2806
2807 static inline LRESULT TAB_GetUnicodeFormat (const TAB_INFO *infoPtr)
2808 {
2809 return infoPtr->bUnicode;
2810 }
2811
2812 static inline LRESULT TAB_SetUnicodeFormat (TAB_INFO *infoPtr, BOOL bUnicode)
2813 {
2814 BOOL bTemp = infoPtr->bUnicode;
2815
2816 infoPtr->bUnicode = bUnicode;
2817
2818 return bTemp;
2819 }
2820
2821 static inline LRESULT TAB_Size (TAB_INFO *infoPtr)
2822 {
2823 /* I'm not really sure what the following code was meant to do.
2824 This is what it is doing:
2825 When WM_SIZE is sent with SIZE_RESTORED, the control
2826 gets positioned in the top left corner.
2827
2828 RECT parent_rect;
2829 HWND parent;
2830 UINT uPosFlags,cx,cy;
2831
2832 uPosFlags=0;
2833 if (!wParam) {
2834 parent = GetParent (hwnd);
2835 GetClientRect(parent, &parent_rect);
2836 cx=LOWORD (lParam);
2837 cy=HIWORD (lParam);
2838 if (GetWindowLongA(hwnd, GWL_STYLE) & CCS_NORESIZE)
2839 uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
2840
2841 SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
2842 cx, cy, uPosFlags | SWP_NOZORDER);
2843 } else {
2844 FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
2845 } */
2846
2847 /* Recompute the size/position of the tabs. */
2848 TAB_SetItemBounds (infoPtr);
2849
2850 /* Force a repaint of the control. */
2851 InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2852
2853 return 0;
2854 }
2855
2856
2857 static LRESULT TAB_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
2858 {
2859 TAB_INFO *infoPtr;
2860 TEXTMETRICA fontMetrics;
2861 HDC hdc;
2862 HFONT hOldFont;
2863 DWORD dwStyle;
2864
2865 infoPtr = (TAB_INFO *)Alloc (sizeof(TAB_INFO));
2866
2867 SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
2868
2869 infoPtr->hwnd = hwnd;
2870 infoPtr->hwndNotify = ((LPCREATESTRUCTW)lParam)->hwndParent;
2871 infoPtr->uNumItem = 0;
2872 infoPtr->uNumRows = 0;
2873 infoPtr->uHItemPadding = 6;
2874 infoPtr->uVItemPadding = 3;
2875 infoPtr->uHItemPadding_s = 6;
2876 infoPtr->uVItemPadding_s = 3;
2877 infoPtr->hFont = 0;
2878 infoPtr->items = 0;
2879 infoPtr->hcurArrow = LoadCursorA (0, (LPSTR)IDC_ARROW);
2880 infoPtr->iSelected = -1;
2881 infoPtr->iHotTracked = -1;
2882 infoPtr->uFocus = -1;
2883 infoPtr->hwndToolTip = 0;
2884 infoPtr->DoRedraw = TRUE;
2885 infoPtr->needsScrolling = FALSE;
2886 infoPtr->hwndUpDown = 0;
2887 infoPtr->leftmostVisible = 0;
2888 infoPtr->fHeightSet = FALSE;
2889 infoPtr->bUnicode = IsWindowUnicode (hwnd);
2890 infoPtr->cbInfo = sizeof(LPARAM);
2891
2892 TRACE("Created tab control, hwnd [%p]\n", hwnd);
2893
2894 /* The tab control always has the WS_CLIPSIBLINGS style. Even
2895 if you don't specify it in CreateWindow. This is necessary in
2896 order for paint to work correctly. This follows windows behaviour. */
2897 dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
2898 SetWindowLongA(hwnd, GWL_STYLE, dwStyle|WS_CLIPSIBLINGS);
2899
2900 if (dwStyle & TCS_TOOLTIPS) {
2901 /* Create tooltip control */
2902 infoPtr->hwndToolTip =
2903 CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
2904 CW_USEDEFAULT, CW_USEDEFAULT,
2905 CW_USEDEFAULT, CW_USEDEFAULT,
2906 hwnd, 0, 0, 0);
2907
2908 /* Send NM_TOOLTIPSCREATED notification */
2909 if (infoPtr->hwndToolTip) {
2910 NMTOOLTIPSCREATED nmttc;
2911
2912 nmttc.hdr.hwndFrom = hwnd;
2913 nmttc.hdr.idFrom = GetWindowLongPtrW(hwnd, GWLP_ID);
2914 nmttc.hdr.code = NM_TOOLTIPSCREATED;
2915 nmttc.hwndToolTips = infoPtr->hwndToolTip;
2916
2917 SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
2918 (WPARAM)GetWindowLongPtrW(hwnd, GWLP_ID), (LPARAM)&nmttc);
2919 }
2920 }
2921
2922 /*
2923 * We need to get text information so we need a DC and we need to select
2924 * a font.
2925 */
2926 hdc = GetDC(hwnd);
2927 hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
2928
2929 /* Use the system font to determine the initial height of a tab. */
2930 GetTextMetricsA(hdc, &fontMetrics);
2931
2932 /*
2933 * Make sure there is enough space for the letters + growing the
2934 * selected item + extra space for the selected item.
2935 */
2936 infoPtr->tabHeight = fontMetrics.tmHeight + SELECTED_TAB_OFFSET +
2937 ((dwStyle & TCS_BUTTONS) ? 2 : 1) *
2938 infoPtr->uVItemPadding;
2939
2940 /* Initialize the width of a tab. */
2941 infoPtr->tabWidth = DEFAULT_TAB_WIDTH;
2942 infoPtr->tabMinWidth = 0;
2943
2944 TRACE("tabH=%d, tabW=%d\n", infoPtr->tabHeight, infoPtr->tabWidth);
2945
2946 SelectObject (hdc, hOldFont);
2947 ReleaseDC(hwnd, hdc);
2948
2949 return 0;
2950 }
2951
2952 static LRESULT
2953 TAB_Destroy (TAB_INFO *infoPtr)
2954 {
2955 UINT iItem;
2956
2957 if (!infoPtr)
2958 return 0;
2959
2960 if (infoPtr->items) {
2961 for (iItem = 0; iItem < infoPtr->uNumItem; iItem++) {
2962 if (TAB_GetItem(infoPtr, iItem)->pszText)
2963 Free (TAB_GetItem(infoPtr, iItem)->pszText);
2964 }
2965 Free (infoPtr->items);
2966 }
2967
2968 if (infoPtr->hwndToolTip)
2969 DestroyWindow (infoPtr->hwndToolTip);
2970
2971 if (infoPtr->hwndUpDown)
2972 DestroyWindow(infoPtr->hwndUpDown);
2973
2974 if (infoPtr->iHotTracked >= 0)
2975 KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
2976
2977 Free (infoPtr);
2978 SetWindowLongA(infoPtr->hwnd, 0, 0);
2979 return 0;
2980 }
2981
2982 static inline LRESULT
2983 TAB_SetItemExtra (TAB_INFO *infoPtr, INT cbInfo)
2984 {
2985 if (!infoPtr || cbInfo <= 0)
2986 return FALSE;
2987
2988 if (infoPtr->uNumItem)
2989 {
2990 /* FIXME: MSDN says this is not allowed, but this hasn't been verified */
2991 return FALSE;
2992 }
2993
2994 infoPtr->cbInfo = cbInfo;
2995 return TRUE;
2996 }
2997
2998 static LRESULT WINAPI
2999 TAB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3000 {
3001 TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
3002
3003 TRACE("hwnd=%p msg=%x wParam=%x lParam=%lx\n", hwnd, uMsg, wParam, lParam);
3004 if (!infoPtr && (uMsg != WM_CREATE))
3005 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
3006
3007 switch (uMsg)
3008 {
3009 case TCM_GETIMAGELIST:
3010 return TAB_GetImageList (infoPtr);
3011
3012 case TCM_SETIMAGELIST:
3013 return TAB_SetImageList (infoPtr, (HIMAGELIST)lParam);
3014
3015 case TCM_GETITEMCOUNT:
3016 return TAB_GetItemCount (infoPtr);
3017
3018 case TCM_GETITEMA:
3019 case TCM_GETITEMW:
3020 return TAB_GetItemAW (infoPtr, (INT)wParam, (LPTCITEMA)lParam, uMsg == TCM_GETITEMW);
3021
3022 case TCM_SETITEMA:
3023 case TCM_SETITEMW:
3024 return TAB_SetItemAW (infoPtr, (INT)wParam, (LPTCITEMA)lParam, uMsg == TCM_SETITEMW);
3025
3026 case TCM_DELETEITEM:
3027 return TAB_DeleteItem (infoPtr, (INT)wParam);
3028
3029 case TCM_DELETEALLITEMS:
3030 return TAB_DeleteAllItems (infoPtr);
3031
3032 case TCM_GETITEMRECT:
3033 return TAB_GetItemRect (infoPtr, wParam, lParam);
3034
3035 case TCM_GETCURSEL:
3036 return TAB_GetCurSel (infoPtr);
3037
3038 case TCM_HITTEST:
3039 return TAB_HitTest (infoPtr, (LPTCHITTESTINFO)lParam);
3040
3041 case TCM_SETCURSEL:
3042 return TAB_SetCurSel (infoPtr, (INT)wParam);
3043
3044 case TCM_INSERTITEMA:
3045 case TCM_INSERTITEMW:
3046 return TAB_InsertItemAW (infoPtr, wParam, lParam, uMsg == TCM_INSERTITEMW);
3047
3048 case TCM_SETITEMEXTRA:
3049 return TAB_SetItemExtra (infoPtr, (int)wParam);
3050
3051 case TCM_ADJUSTRECT:
3052 return TAB_AdjustRect (infoPtr, (BOOL)wParam, (LPRECT)lParam);
3053
3054 case TCM_SETITEMSIZE:
3055 return TAB_SetItemSize (infoPtr, lParam);
3056
3057 case TCM_REMOVEIMAGE:
3058 FIXME("Unimplemented msg TCM_REMOVEIMAGE\n");
3059 return 0;
3060
3061 case TCM_SETPADDING:
3062 return TAB_SetPadding (infoPtr, lParam);
3063
3064 case TCM_GETROWCOUNT:
3065 return TAB_GetRowCount(infoPtr);
3066
3067 case TCM_GETUNICODEFORMAT:
3068 return TAB_GetUnicodeFormat (infoPtr);
3069
3070 case TCM_SETUNICODEFORMAT:
3071 return TAB_SetUnicodeFormat (infoPtr, (BOOL)wParam);
3072
3073 case TCM_HIGHLIGHTITEM:
3074 return TAB_HighlightItem (infoPtr, (INT)wParam, (BOOL)LOWORD(lParam));
3075
3076 case TCM_GETTOOLTIPS:
3077 return TAB_GetToolTips (infoPtr);
3078
3079 case TCM_SETTOOLTIPS:
3080 return TAB_SetToolTips (infoPtr, (HWND)wParam);
3081
3082 case TCM_GETCURFOCUS:
3083 return TAB_GetCurFocus (infoPtr);
3084
3085 case TCM_SETCURFOCUS:
3086 return TAB_SetCurFocus (infoPtr, (INT)wParam);
3087
3088 case TCM_SETMINTABWIDTH:
3089 return TAB_SetMinTabWidth(infoPtr, (INT)lParam);
3090
3091 case TCM_DESELECTALL:
3092 FIXME("Unimplemented msg TCM_DESELECTALL\n");
3093 return 0;
3094
3095 case TCM_GETEXTENDEDSTYLE:
3096 FIXME("Unimplemented msg TCM_GETEXTENDEDSTYLE\n");
3097 return 0;
3098
3099 case TCM_SETEXTENDEDSTYLE:
3100 FIXME("Unimplemented msg TCM_SETEXTENDEDSTYLE\n");
3101 return 0;
3102
3103 case WM_GETFONT:
3104 return TAB_GetFont (infoPtr);
3105
3106 case WM_SETFONT:
3107 return TAB_SetFont (infoPtr, (HFONT)wParam);
3108
3109 case WM_CREATE:
3110 return TAB_Create (hwnd, wParam, lParam);
3111
3112 case WM_NCDESTROY:
3113 return TAB_Destroy (infoPtr);
3114
3115 case WM_GETDLGCODE:
3116 return DLGC_WANTARROWS | DLGC_WANTCHARS;
3117
3118 case WM_LBUTTONDOWN:
3119 return TAB_LButtonDown (infoPtr, wParam, lParam);
3120
3121 case WM_LBUTTONUP:
3122 return TAB_LButtonUp (infoPtr);
3123
3124 case WM_NOTIFY:
3125 return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, wParam, lParam);
3126
3127 case WM_RBUTTONDOWN:
3128 return TAB_RButtonDown (infoPtr);
3129
3130 case WM_MOUSEMOVE:
3131 return TAB_MouseMove (infoPtr, wParam, lParam);
3132
3133 case WM_PAINT:
3134 return TAB_Paint (infoPtr, (HDC)wParam);
3135
3136 case WM_SIZE:
3137 return TAB_Size (infoPtr);
3138
3139 case WM_SETREDRAW:
3140 return TAB_SetRedraw (infoPtr, (BOOL)wParam);
3141
3142 case WM_HSCROLL:
3143 return TAB_OnHScroll(infoPtr, (int)LOWORD(wParam), (int)HIWORD(wParam), (HWND)lParam);
3144
3145 case WM_STYLECHANGED:
3146 TAB_SetItemBounds (infoPtr);
3147 InvalidateRect(hwnd, NULL, TRUE);
3148 return 0;
3149
3150 case WM_SYSCOLORCHANGE:
3151 COMCTL32_RefreshSysColors();
3152 return 0;
3153
3154 case WM_KILLFOCUS:
3155 case WM_SETFOCUS:
3156 TAB_FocusChanging(infoPtr);
3157 break; /* Don't disturb normal focus behavior */
3158
3159 case WM_KEYUP:
3160 return TAB_KeyUp(infoPtr, wParam);
3161 case WM_NCHITTEST:
3162 return TAB_NCHitTest(infoPtr, lParam);
3163
3164 default:
3165 if (uMsg >= WM_USER && uMsg < WM_APP)
3166 WARN("unknown msg %04x wp=%08x lp=%08lx\n",
3167 uMsg, wParam, lParam);
3168 break;
3169 }
3170 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
3171 }
3172
3173
3174 VOID
3175 TAB_Register (void)
3176 {
3177 WNDCLASSW wndClass;
3178
3179 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
3180 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
3181 wndClass.lpfnWndProc = TAB_WindowProc;
3182 wndClass.cbClsExtra = 0;
3183 wndClass.cbWndExtra = sizeof(TAB_INFO *);
3184 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
3185 wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
3186 wndClass.lpszClassName = WC_TABCONTROLW;
3187
3188 RegisterClassW (&wndClass);
3189 }
3190
3191
3192 VOID
3193 TAB_Unregister (void)
3194 {
3195 UnregisterClassW (WC_TABCONTROLW, NULL);
3196 }
Maarten's multimedia branch