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