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