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