tab.c 96.2 KB
Newer Older
Alexandre Julliard's avatar
Alexandre Julliard committed
1 2 3 4
/*
 * Tab control
 *
 * Copyright 1998 Anders Carlsson
Alex Priem's avatar
Alex Priem committed
5
 * Copyright 1999 Alex Priem <alexp@sci.kun.nl>
Francis Beaudet's avatar
Francis Beaudet committed
6
 * Copyright 1999 Francis Beaudet
7
 * Copyright 2003 Vitaliy Margolen
Alexandre Julliard's avatar
Alexandre Julliard committed
8
 *
9 10 11 12 13 14 15 16 17 18 19 20
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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
 *
James Hawkins's avatar
James Hawkins committed
23 24 25 26 27 28 29 30 31
 * NOTES
 *
 * This code was audited for completeness against the documented features
 * of Comctl32.dll version 6.0 on May. 20, 2005, by James Hawkins.
 *
 * Unless otherwise noted, we believe this code to be complete, as per
 * the specification mentioned above.
 * If you discover missing features, or bugs, please note them below.
 *
Alexandre Julliard's avatar
Alexandre Julliard committed
32
 * TODO:
33
 *
34
 *  Styles:
35
 *   TCS_MULTISELECT - implement for VK_SPACE selection
James Hawkins's avatar
James Hawkins committed
36 37 38 39
 *   TCS_RIGHT
 *   TCS_RIGHTJUSTIFY
 *   TCS_SCROLLOPPOSITE
 *   TCS_SINGLELINE
40 41
 *   TCIF_RTLREADING
 *
James Hawkins's avatar
James Hawkins committed
42 43 44 45 46 47 48 49 50 51 52
 *  Extended Styles:
 *   TCS_EX_REGISTERDROP
 *
 *  Notifications:
 *   NM_RELEASEDCAPTURE
 *   TCN_FOCUSCHANGE
 *   TCN_GETOBJECT
 *
 *  Macros:
 *   TabCtrl_AdjustRect
 *
Alexandre Julliard's avatar
Alexandre Julliard committed
53 54
 */

55
#include <assert.h>
56
#include <stdarg.h>
57 58
#include <string.h>

59
#include "windef.h"
60
#include "winbase.h"
61 62 63
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
Alexandre Julliard's avatar
Alexandre Julliard committed
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>
Alexandre Julliard's avatar
Alexandre Julliard committed
70

71
WINE_DEFAULT_DEBUG_CHANNEL(tab);
72 73 74 75

typedef struct
{
  DWORD  dwState;
76
  LPWSTR pszText;
77
  INT    iImage;
78 79 80 81
  RECT   rect;      /* bounding rectangle of the item relative to the
                     * leftmost item (the leftmost item, 0, would have a
                     * "left" member of 0 in this rectangle)
                     *
82
                     * additionally the top member holds the row number
83 84
                     * and bottom is unused and should be 0 */
  BYTE   extra[1];  /* Space for caller supplied info, variable size */
85 86
} TAB_ITEM;

87 88 89 90
/* The size of a tab item depends on how much extra data is requested.
   TCM_INSERTITEM always stores at least LPARAM sized data. */
#define EXTRA_ITEM_SIZE(infoPtr) (max((infoPtr)->cbInfo, sizeof(LPARAM)))
#define TAB_ITEM_SIZE(infoPtr) FIELD_OFFSET(TAB_ITEM, extra[EXTRA_ITEM_SIZE(infoPtr)])
91

92 93
typedef struct
{
94
  HWND       hwnd;            /* Tab control window */
95
  HWND       hwndNotify;      /* notification window (parent) */
96 97 98 99
  UINT       uNumItem;        /* number of tab items */
  UINT       uNumRows;	      /* number of tab rows */
  INT        tabHeight;       /* height of the tab row */
  INT        tabWidth;        /* width of tabs */
100
  INT        tabMinWidth;     /* minimum width of items */
101 102
  USHORT     uHItemPadding;   /* amount of horizontal padding, in pixels */
  USHORT     uVItemPadding;   /* amount of vertical padding, in pixels */
103 104
  USHORT     uHItemPadding_s; /* Set amount of horizontal padding, in pixels */
  USHORT     uVItemPadding_s; /* Set amount of vertical padding, in pixels */
105 106
  HFONT      hFont;           /* handle to the current font */
  HCURSOR    hcurArrow;       /* handle to the current cursor */
107
  HIMAGELIST himl;            /* handle to an image list (may be 0) */
108 109
  HWND       hwndToolTip;     /* handle to tab's tooltip */
  INT        leftmostVisible; /* Used for scrolling, this member contains
110
                               * the index of the first visible item */
111 112 113 114
  INT        iSelected;       /* the currently selected item */
  INT        iHotTracked;     /* the highlighted item under the mouse */
  INT        uFocus;          /* item which has the focus */
  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 123

  DWORD      exStyle;         /* Extended style used, currently:
                                 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

Francis Beaudet's avatar
Francis Beaudet committed
129 130 131
/******************************************************************************
 * Positioning constants
 */
132
#define SELECTED_TAB_OFFSET     2
Francis Beaudet's avatar
Francis Beaudet committed
133
#define ROUND_CORNER_SIZE       2
Alexandre Julliard's avatar
Alexandre Julliard committed
134 135
#define DISPLAY_AREA_PADDINGX   2
#define DISPLAY_AREA_PADDINGY   2
136 137
#define CONTROL_BORDER_SIZEX    2
#define CONTROL_BORDER_SIZEY    2
138
#define BUTTON_SPACINGX         3
139
#define BUTTON_SPACINGY         3
140
#define FLAT_BTN_SPACINGX       8
141 142 143
#define DEFAULT_MIN_TAB_WIDTH   54
#define DEFAULT_PADDING_X       6
#define EXTRA_ICON_PADDING      3
Alexandre Julliard's avatar
Alexandre Julliard committed
144

145
#define TAB_GetInfoPtr(hwnd) ((TAB_INFO *)GetWindowLongPtrW(hwnd,0))
146

147 148
#define GET_DEFAULT_MIN_TAB_WIDTH(infoPtr) (DEFAULT_MIN_TAB_WIDTH - (DEFAULT_PADDING_X - (infoPtr)->uHItemPadding) * 2)

149 150 151 152 153 154
/******************************************************************************
 * Hot-tracking timer constants
 */
#define TAB_HOTTRACK_TIMER            1
#define TAB_HOTTRACK_TIMER_INTERVAL   100   /* milliseconds */

155
static const WCHAR themeClass[] = L"Tab";
156

157 158 159 160 161 162
static inline TAB_ITEM* TAB_GetItem(const TAB_INFO *infoPtr, INT i)
{
    assert(i >= 0 && i < infoPtr->uNumItem);
    return DPA_GetPtr(infoPtr->items, i);
}

Francis Beaudet's avatar
Francis Beaudet committed
163 164 165
/******************************************************************************
 * Prototypes
 */
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)
Alexandre Julliard's avatar
Alexandre Julliard committed
174 175 176
{
    NMHDR nmhdr;

177 178
    nmhdr.hwndFrom = infoPtr->hwnd;
    nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwnd, GWLP_ID);
Alexandre Julliard's avatar
Alexandre Julliard committed
179 180
    nmhdr.code = code;

181
    return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
182
            nmhdr.idFrom, (LPARAM) &nmhdr);
Alexandre Julliard's avatar
Alexandre Julliard committed
183 184
}

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
185
static void
186 187
TAB_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
            WPARAM wParam, LPARAM lParam)
Alex Priem's avatar
Alex Priem committed
188
{
189
    MSG msg;
Alex Priem's avatar
Alex Priem committed
190 191 192 193 194 195

    msg.hwnd = hwndMsg;
    msg.message = uMsg;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.time = GetMessageTime ();
196 197
    msg.pt.x = (short)LOWORD(GetMessagePos ());
    msg.pt.y = (short)HIWORD(GetMessagePos ());
Alex Priem's avatar
Alex Priem committed
198

199
    SendMessageW (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
Alex Priem's avatar
Alex Priem committed
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 208
	      iItem, pti->mask, pti->dwState, pti->dwStateMask, pti->cchTextMax);
	TRACE("external tab %d,   iImage=%d, lParam=0x%08lx, pszTextW=%s\n",
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
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 220
	TRACE("tab %d, dwState=0x%08x, pszText=%s, iImage=%d\n",
	      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 227
/* RETURNS
 *   the index of the selected tab, or -1 if no tab is selected. */
228
static inline LRESULT TAB_GetCurSel (const TAB_INFO *infoPtr)
Alexandre Julliard's avatar
Alexandre Julliard committed
229
{
230
    TRACE("(%p)\n", infoPtr);
Alexandre Julliard's avatar
Alexandre Julliard committed
231 232 233
    return infoPtr->iSelected;
}

234
/* RETURNS
235
 *   the index of the tab item that has the focus. */
236 237
static inline LRESULT
TAB_GetCurFocus (const TAB_INFO *infoPtr)
Alex Priem's avatar
Alex Priem committed
238
{
239
    TRACE("(%p)\n", infoPtr);
Alex Priem's avatar
Alex Priem committed
240 241 242
    return infoPtr->uFocus;
}

243
static inline LRESULT TAB_GetToolTips (const TAB_INFO *infoPtr)
Alex Priem's avatar
Alex Priem committed
244
{
245
    TRACE("(%p)\n", infoPtr);
246
    return (LRESULT)infoPtr->hwndToolTip;
Alex Priem's avatar
Alex Priem committed
247 248
}

249
static inline LRESULT TAB_SetCurSel (TAB_INFO *infoPtr, INT iItem)
250
{
251
  INT prevItem = infoPtr->iSelected;
252

253 254
  TRACE("(%p %d)\n", infoPtr, iItem);

255
  if (iItem >= (INT)infoPtr->uNumItem)
256
      return -1;
257

258 259 260 261 262 263 264
  if (prevItem != iItem) {
      if (prevItem != -1)
          TAB_GetItem(infoPtr, prevItem)->dwState &= ~TCIS_BUTTONPRESSED;

      if (iItem >= 0)
      {
          TAB_GetItem(infoPtr, iItem)->dwState |= TCIS_BUTTONPRESSED;
265 266
          infoPtr->iSelected = iItem;
          infoPtr->uFocus = iItem;
267
      }
268 269 270 271 272 273 274 275
      else
      {
          infoPtr->iSelected = -1;
          infoPtr->uFocus = -1;
      }

      TAB_EnsureSelectionVisible(infoPtr);
      TAB_InvalidateTabArea(infoPtr);
Francis Beaudet's avatar
Francis Beaudet committed
276
  }
277

Francis Beaudet's avatar
Francis Beaudet committed
278
  return prevItem;
279 280
}

281
static LRESULT TAB_SetCurFocus (TAB_INFO *infoPtr, INT iItem)
Alex Priem's avatar
Alex Priem committed
282
{
283 284
  TRACE("(%p %d)\n", infoPtr, iItem);

285
  if (iItem < 0) {
286
      infoPtr->uFocus = -1;
287 288 289 290 291 292
      if (infoPtr->iSelected != -1) {
          infoPtr->iSelected = -1;
          TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
          TAB_InvalidateTabArea(infoPtr);
      }
  }
293
  else if (iItem < infoPtr->uNumItem) {
294
    if (infoPtr->dwStyle & TCS_BUTTONS) {
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
      /* set focus to new item, leave selection as is */
      if (infoPtr->uFocus != iItem) {
        INT prev_focus = infoPtr->uFocus;
        RECT r;

        infoPtr->uFocus = iItem;

        if (prev_focus != infoPtr->iSelected) {
          if (TAB_InternalGetItemRect(infoPtr, prev_focus, &r, NULL))
            InvalidateRect(infoPtr->hwnd, &r, FALSE);
        }

        if (TAB_InternalGetItemRect(infoPtr, iItem, &r, NULL))
            InvalidateRect(infoPtr->hwnd, &r, FALSE);

        TAB_SendSimpleNotify(infoPtr, TCN_FOCUSCHANGE);
      }
312
    } else {
313
      INT oldFocus = infoPtr->uFocus;
314 315 316 317 318 319 320 321 322 323 324
      if (infoPtr->iSelected != iItem || oldFocus == -1 ) {
        infoPtr->uFocus = iItem;
        if (oldFocus != -1) {
          if (!TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))  {
            infoPtr->iSelected = iItem;
            TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
          }
          else
            infoPtr->iSelected = iItem;
          TAB_EnsureSelectionVisible(infoPtr);
          TAB_InvalidateTabArea(infoPtr);
325
        }
Francis Beaudet's avatar
Francis Beaudet committed
326 327 328
      }
    }
  }
Alex Priem's avatar
Alex Priem committed
329 330 331
  return 0;
}

332 333
static inline LRESULT
TAB_SetToolTips (TAB_INFO *infoPtr, HWND hwndToolTip)
Alex Priem's avatar
Alex Priem committed
334
{
335
    TRACE("%p %p\n", infoPtr, hwndToolTip);
336
    infoPtr->hwndToolTip = hwndToolTip;
Alex Priem's avatar
Alex Priem committed
337 338 339
    return 0;
}

340 341
static inline LRESULT
TAB_SetPadding (TAB_INFO *infoPtr, LPARAM lParam)
342
{
343 344 345 346
    TRACE("(%p %d %d)\n", infoPtr, LOWORD(lParam), HIWORD(lParam));
    infoPtr->uHItemPadding_s = LOWORD(lParam);
    infoPtr->uVItemPadding_s = HIWORD(lParam);

347 348 349
    return 0;
}

Francis Beaudet's avatar
Francis Beaudet committed
350 351 352 353 354 355 356 357 358 359
/******************************************************************************
 * TAB_InternalGetItemRect
 *
 * This method will calculate the rectangle representing a given tab item in
 * client coordinates. This method takes scrolling into account.
 *
 * This method returns TRUE if the item is visible in the window and FALSE
 * if it is completely outside the client area.
 */
static BOOL TAB_InternalGetItemRect(
360
  const TAB_INFO* infoPtr,
Francis Beaudet's avatar
Francis Beaudet committed
361 362 363 364
  INT         itemIndex,
  RECT*       itemRect,
  RECT*       selectedRect)
{
365
  RECT tmpItemRect,clientRect;
366

367 368
  /* Perform a sanity check and a trivial visibility check. */
  if ( (infoPtr->uNumItem <= 0) ||
Francis Beaudet's avatar
Francis Beaudet committed
369
       (itemIndex >= infoPtr->uNumItem) ||
370 371
       (!(((infoPtr->dwStyle & TCS_MULTILINE) || (infoPtr->dwStyle & TCS_VERTICAL))) &&
         (itemIndex < infoPtr->leftmostVisible)))
372 373
    {
        TRACE("Not Visible\n");
374 375
        SetRect(itemRect, 0, 0, 0, infoPtr->tabHeight);
        SetRectEmpty(selectedRect);
376 377
        return FALSE;
    }
Francis Beaudet's avatar
Francis Beaudet committed
378 379 380 381 382

  /*
   * Avoid special cases in this procedure by assigning the "out"
   * parameters if the caller didn't supply them
   */
383
  if (itemRect == NULL)
Francis Beaudet's avatar
Francis Beaudet committed
384
    itemRect = &tmpItemRect;
385

386
  /* Retrieve the unmodified item rect. */
387
  *itemRect = TAB_GetItem(infoPtr,itemIndex)->rect;
Francis Beaudet's avatar
Francis Beaudet committed
388

389
  /* calculate the times bottom and top based on the row */
390
  GetClientRect(infoPtr->hwnd, &clientRect);
391

392
  if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
393
  {
394
    itemRect->right  = clientRect.right - SELECTED_TAB_OFFSET - itemRect->left * infoPtr->tabHeight -
395
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
396
    itemRect->left   = itemRect->right - infoPtr->tabHeight;
397
  }
398
  else if (infoPtr->dwStyle & TCS_VERTICAL)
399
  {
400
    itemRect->left   = clientRect.left + SELECTED_TAB_OFFSET + itemRect->left * infoPtr->tabHeight +
401
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
402
    itemRect->right  = itemRect->left + infoPtr->tabHeight;
403
  }
404
  else if (infoPtr->dwStyle & TCS_BOTTOM)
405
  {
406
    itemRect->bottom = clientRect.bottom - itemRect->top * infoPtr->tabHeight -
407
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
408
    itemRect->top    = itemRect->bottom - infoPtr->tabHeight;
409
  }
410
  else /* not TCS_BOTTOM and not TCS_VERTICAL */
411
  {
412
    itemRect->top    = clientRect.top + itemRect->top * infoPtr->tabHeight +
413
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
414
    itemRect->bottom = itemRect->top + infoPtr->tabHeight;
415 416
 }

Francis Beaudet's avatar
Francis Beaudet committed
417
  /*
418
   * "scroll" it to make sure the item at the very left of the
Francis Beaudet's avatar
Francis Beaudet committed
419 420
   * tab control is the leftmost visible tab.
   */
421
  if(infoPtr->dwStyle & TCS_VERTICAL)
422 423 424
  {
    OffsetRect(itemRect,
	     0,
425
	     -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.top);
426 427 428 429 430 431 432

    /*
     * Move the rectangle so the first item is slightly offset from
     * the bottom of the tab control.
     */
    OffsetRect(itemRect,
	     0,
433
	     SELECTED_TAB_OFFSET);
434 435 436 437

  } else
  {
    OffsetRect(itemRect,
438
	     -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.left,
Francis Beaudet's avatar
Francis Beaudet committed
439 440
	     0);

441 442 443 444 445
    /*
     * Move the rectangle so the first item is slightly offset from
     * the left of the tab control.
     */
    OffsetRect(itemRect,
Francis Beaudet's avatar
Francis Beaudet committed
446 447
	     SELECTED_TAB_OFFSET,
	     0);
448
  }
449 450
  TRACE("item %d tab h=%d, rect=(%s)\n",
        itemIndex, infoPtr->tabHeight, wine_dbgstr_rect(itemRect));
Francis Beaudet's avatar
Francis Beaudet committed
451

452
  /* Now, calculate the position of the item as if it were selected. */
Francis Beaudet's avatar
Francis Beaudet committed
453 454
  if (selectedRect!=NULL)
  {
455
    *selectedRect = *itemRect;
Francis Beaudet's avatar
Francis Beaudet committed
456

457
    /* The rectangle of a selected item is a bit wider. */
458
    if(infoPtr->dwStyle & TCS_VERTICAL)
459 460 461
      InflateRect(selectedRect, 0, SELECTED_TAB_OFFSET);
    else
      InflateRect(selectedRect, SELECTED_TAB_OFFSET, 0);
Francis Beaudet's avatar
Francis Beaudet committed
462

463
    /* If it also a bit higher. */
464
    if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
465
    {
466 467
      selectedRect->left   -= 2; /* the border is thicker on the right */
      selectedRect->right  += SELECTED_TAB_OFFSET;
468
    }
469
    else if (infoPtr->dwStyle & TCS_VERTICAL)
470
    {
471 472
      selectedRect->left   -= SELECTED_TAB_OFFSET;
      selectedRect->right  += 1;
473
    }
474
    else if (infoPtr->dwStyle & TCS_BOTTOM)
475
    {
476
      selectedRect->bottom += SELECTED_TAB_OFFSET;
Francis Beaudet's avatar
Francis Beaudet committed
477
    }
478
    else /* not TCS_BOTTOM and not TCS_VERTICAL */
Francis Beaudet's avatar
Francis Beaudet committed
479
    {
480
      selectedRect->top    -= SELECTED_TAB_OFFSET;
481
      selectedRect->bottom -= 1;
Francis Beaudet's avatar
Francis Beaudet committed
482 483 484
    }
  }

485
  /* Check for visibility */
486
  if (infoPtr->dwStyle & TCS_VERTICAL)
487 488 489
    return (itemRect->top < clientRect.bottom) && (itemRect->bottom > clientRect.top);
  else
    return (itemRect->left < clientRect.right) && (itemRect->right > clientRect.left);
Francis Beaudet's avatar
Francis Beaudet committed
490 491
}

492
static inline BOOL
493
TAB_GetItemRect(const TAB_INFO *infoPtr, INT item, RECT *rect)
494
{
495 496
  TRACE("(%p, %d, %p)\n", infoPtr, item, rect);
  return TAB_InternalGetItemRect(infoPtr, item, rect, NULL);
497 498
}

Francis Beaudet's avatar
Francis Beaudet committed
499
/******************************************************************************
500
 * TAB_KeyDown
Francis Beaudet's avatar
Francis Beaudet committed
501 502 503
 *
 * This method is called to handle keyboard input
 */
504
static LRESULT TAB_KeyDown(TAB_INFO* infoPtr, WPARAM keyCode, LPARAM lParam)
Francis Beaudet's avatar
Francis Beaudet committed
505
{
506
  INT newItem = -1;
507 508 509 510 511 512 513 514 515
  NMTCKEYDOWN nm;

  /* TCN_KEYDOWN notification sent always */
  nm.hdr.hwndFrom = infoPtr->hwnd;
  nm.hdr.idFrom = GetWindowLongPtrW(infoPtr->hwnd, GWLP_ID);
  nm.hdr.code = TCN_KEYDOWN;
  nm.wVKey = keyCode;
  nm.flags = lParam;
  SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nm.hdr.idFrom, (LPARAM)&nm);
Francis Beaudet's avatar
Francis Beaudet committed
516 517 518 519

  switch (keyCode)
  {
    case VK_LEFT:
520
      newItem = infoPtr->uFocus - 1;
Francis Beaudet's avatar
Francis Beaudet committed
521 522
      break;
    case VK_RIGHT:
523
      newItem = infoPtr->uFocus + 1;
Francis Beaudet's avatar
Francis Beaudet committed
524 525
      break;
  }
526

527 528 529
  /* If we changed to a valid item, change focused item */
  if (newItem >= 0 && newItem < infoPtr->uNumItem && infoPtr->uFocus != newItem)
      TAB_SetCurFocus(infoPtr, newItem);
Francis Beaudet's avatar
Francis Beaudet committed
530 531 532 533

  return 0;
}

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
/*
 * WM_KILLFOCUS handler
 */
static void TAB_KillFocus(TAB_INFO *infoPtr)
{
  /* clear current focused item back to selected for TCS_BUTTONS */
  if ((infoPtr->dwStyle & TCS_BUTTONS) && (infoPtr->uFocus != infoPtr->iSelected))
  {
    RECT r;

    if (TAB_InternalGetItemRect(infoPtr, infoPtr->uFocus, &r, NULL))
      InvalidateRect(infoPtr->hwnd, &r, FALSE);

    infoPtr->uFocus = infoPtr->iSelected;
  }
}

Francis Beaudet's avatar
Francis Beaudet committed
551 552 553 554 555 556
/******************************************************************************
 * TAB_FocusChanging
 *
 * This method is called whenever the focus goes in or out of this control
 * it is used to update the visual state of the control.
 */
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
557
static void TAB_FocusChanging(const TAB_INFO *infoPtr)
Francis Beaudet's avatar
Francis Beaudet committed
558 559 560 561 562 563 564
{
  RECT      selectedRect;
  BOOL      isVisible;

  /*
   * Get the rectangle for the item.
   */
565
  isVisible = TAB_InternalGetItemRect(infoPtr,
Francis Beaudet's avatar
Francis Beaudet committed
566 567 568
				      infoPtr->uFocus,
				      NULL,
				      &selectedRect);
569

Francis Beaudet's avatar
Francis Beaudet committed
570 571 572 573 574 575
  /*
   * If the rectangle is not completely invisible, invalidate that
   * portion of the window.
   */
  if (isVisible)
  {
576
    TRACE("invalidate (%s)\n", wine_dbgstr_rect(&selectedRect));
577
    InvalidateRect(infoPtr->hwnd, &selectedRect, TRUE);
Francis Beaudet's avatar
Francis Beaudet committed
578 579
  }
}
Alex Priem's avatar
Alex Priem committed
580

581
static INT TAB_InternalHitTest (const TAB_INFO *infoPtr, POINT pt, UINT *flags)
Alex Priem's avatar
Alex Priem committed
582
{
583
  RECT rect;
584
  INT iCount;
585

586
  for (iCount = 0; iCount < infoPtr->uNumItem; iCount++)
Francis Beaudet's avatar
Francis Beaudet committed
587
  {
588
    TAB_InternalGetItemRect(infoPtr, iCount, &rect, NULL);
Francis Beaudet's avatar
Francis Beaudet committed
589

590
    if (PtInRect(&rect, pt))
Francis Beaudet's avatar
Francis Beaudet committed
591 592 593 594 595 596
    {
      *flags = TCHT_ONITEM;
      return iCount;
    }
  }

597
  *flags = TCHT_NOWHERE;
Alex Priem's avatar
Alex Priem committed
598 599 600
  return -1;
}

601
static inline LRESULT
602
TAB_HitTest (const TAB_INFO *infoPtr, LPTCHITTESTINFO lptest)
Alex Priem's avatar
Alex Priem committed
603
{
604
  TRACE("(%p, %p)\n", infoPtr, lptest);
605
  return TAB_InternalHitTest (infoPtr, lptest->pt, &lptest->flags);
Alex Priem's avatar
Alex Priem committed
606 607
}

608 609 610 611 612 613 614 615 616 617 618 619
/******************************************************************************
 * TAB_NCHitTest
 *
 * Napster v2b5 has a tab control for its main navigation which has a client
 * area that covers the whole area of the dialog pages.
 * That's why it receives all msgs for that area and the underlying dialog ctrls
 * are dead.
 * So I decided that we should handle WM_NCHITTEST here and return
 * HTTRANSPARENT if we don't hit the tab control buttons.
 * FIXME: WM_NCHITTEST handling correct ? Fix it if you know that Windows
 * doesn't do it that way. Maybe depends on tab control styles ?
 */
620
static inline LRESULT
621
TAB_NCHitTest (const TAB_INFO *infoPtr, LPARAM lParam)
622 623 624 625
{
  POINT pt;
  UINT dummyflag;

626 627
  pt.x = (short)LOWORD(lParam);
  pt.y = (short)HIWORD(lParam);
628
  ScreenToClient(infoPtr->hwnd, &pt);
629

630
  if (TAB_InternalHitTest(infoPtr, pt, &dummyflag) == -1)
631 632 633 634
    return HTTRANSPARENT;
  else
    return HTCLIENT;
}
Alex Priem's avatar
Alex Priem committed
635 636

static LRESULT
637
TAB_LButtonDown (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
Alex Priem's avatar
Alex Priem committed
638
{
639
  POINT pt;
Mike McCormack's avatar
Mike McCormack committed
640 641
  INT newItem;
  UINT dummy;
Alex Priem's avatar
Alex Priem committed
642

Francis Beaudet's avatar
Francis Beaudet committed
643
  if (infoPtr->hwndToolTip)
644
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
Francis Beaudet's avatar
Francis Beaudet committed
645
		    WM_LBUTTONDOWN, wParam, lParam);
Alex Priem's avatar
Alex Priem committed
646

647
  if (!(infoPtr->dwStyle & TCS_FOCUSNEVER)) {
648
    SetFocus (infoPtr->hwnd);
Francis Beaudet's avatar
Francis Beaudet committed
649
  }
Alex Priem's avatar
Alex Priem committed
650

Francis Beaudet's avatar
Francis Beaudet committed
651
  if (infoPtr->hwndToolTip)
652
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
Francis Beaudet's avatar
Francis Beaudet committed
653
		    WM_LBUTTONDOWN, wParam, lParam);
654

655 656
  pt.x = (short)LOWORD(lParam);
  pt.y = (short)HIWORD(lParam);
657

658
  newItem = TAB_InternalHitTest (infoPtr, pt, &dummy);
659

660
  TRACE("On Tab, item %d\n", newItem);
661

662
  if ((newItem != -1) && (infoPtr->iSelected != newItem))
Francis Beaudet's avatar
Francis Beaudet committed
663
  {
664
    if ((infoPtr->dwStyle & TCS_BUTTONS) && (infoPtr->dwStyle & TCS_MULTISELECT) &&
665
        (wParam & MK_CONTROL))
Francis Beaudet's avatar
Francis Beaudet committed
666
    {
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
      RECT r;

      /* toggle multiselection */
      TAB_GetItem(infoPtr, newItem)->dwState ^= TCIS_BUTTONPRESSED;
      if (TAB_InternalGetItemRect (infoPtr, newItem, &r, NULL))
        InvalidateRect (infoPtr->hwnd, &r, TRUE);
    }
    else
    {
      INT i;
      BOOL pressed = FALSE;

      /* any button pressed ? */
      for (i = 0; i < infoPtr->uNumItem; i++)
        if ((TAB_GetItem (infoPtr, i)->dwState & TCIS_BUTTONPRESSED) &&
            (infoPtr->iSelected != i))
        {
          pressed = TRUE;
          break;
        }

688 689
      if (TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))
        return 0;
690 691 692 693

      if (pressed)
        TAB_DeselectAll (infoPtr, FALSE);
      else
694
        TAB_SetCurSel(infoPtr, newItem);
695

696
      TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
Francis Beaudet's avatar
Francis Beaudet committed
697 698
    }
  }
699

700 701 702
  return 0;
}

703 704
static inline LRESULT
TAB_LButtonUp (const TAB_INFO *infoPtr)
705
{
706
  TAB_SendSimpleNotify(infoPtr, NM_CLICK);
Francis Beaudet's avatar
Francis Beaudet committed
707 708

  return 0;
Alexandre Julliard's avatar
Alexandre Julliard committed
709 710
}

711
static inline void
712
TAB_RButtonUp (const TAB_INFO *infoPtr)
Alex Priem's avatar
Alex Priem committed
713
{
714
  TAB_SendSimpleNotify(infoPtr, NM_RCLICK);
Alex Priem's avatar
Alex Priem committed
715 716
}

717 718 719 720 721 722 723 724 725
/******************************************************************************
 * TAB_DrawLoneItemInterior
 *
 * This calls TAB_DrawItemInterior.  However, TAB_DrawItemInterior is normally
 * called by TAB_DrawItem which is normally called by TAB_Refresh which sets
 * up the device context and font.  This routine does the same setup but
 * only calls TAB_DrawItemInterior for the single specified item.
 */
static void
726
TAB_DrawLoneItemInterior(const TAB_INFO* infoPtr, int iItem)
727
{
728
  HDC hdc = GetDC(infoPtr->hwnd);
729 730
  RECT r, rC;

731 732 733
  /* Clip UpDown control to not draw over it */
  if (infoPtr->needsScrolling)
  {
734
    GetWindowRect(infoPtr->hwnd, &rC);
735 736 737
    GetWindowRect(infoPtr->hwndUpDown, &r);
    ExcludeClipRect(hdc, r.left - rC.left, r.top - rC.top, r.right - rC.left, r.bottom - rC.top);
  }
738 739
  TAB_DrawItemInterior(infoPtr, hdc, iItem, NULL);
  ReleaseDC(infoPtr->hwnd, hdc);
740 741
}

742 743
/* update a tab after hottracking - invalidate it or just redraw the interior,
 * based on whether theming is used or not */
744
static inline void hottrack_refresh(const TAB_INFO *infoPtr, int tabIndex)
745 746 747 748 749 750 751 752 753 754 755 756 757
{
    if (tabIndex == -1) return;

    if (GetWindowTheme (infoPtr->hwnd))
    {
        RECT rect;
        TAB_InternalGetItemRect(infoPtr, tabIndex, &rect, NULL);
        InvalidateRect (infoPtr->hwnd, &rect, FALSE);
    }
    else
        TAB_DrawLoneItemInterior(infoPtr, tabIndex);
}

758 759 760 761 762 763 764 765 766 767 768
/******************************************************************************
 * TAB_HotTrackTimerProc
 *
 * When a mouse-move event causes a tab to be highlighted (hot-tracking), a
 * timer is setup so we can check if the mouse is moved out of our window.
 * (We don't get an event when the mouse leaves, the mouse-move events just
 * stop being delivered to our window and just start being delivered to
 * another window.)  This function is called when the timer triggers so
 * we can check if the mouse has left our window.  If so, we un-highlight
 * the hot-tracked tab.
 */
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
769
static void CALLBACK
770 771
TAB_HotTrackTimerProc
  (
772 773
  HWND hwnd,    /* handle of window for timer messages */
  UINT uMsg,    /* WM_TIMER message */
Frank Richter's avatar
Frank Richter committed
774
  UINT_PTR idEvent, /* timer identifier */
775
  DWORD dwTime  /* current system time */
776 777 778 779 780 781 782 783 784 785 786 787 788 789
  )
{
  TAB_INFO* infoPtr = TAB_GetInfoPtr(hwnd);

  if (infoPtr != NULL && infoPtr->iHotTracked >= 0)
  {
    POINT pt;

    /*
    ** If we can't get the cursor position, or if the cursor is outside our
    ** window, we un-highlight the hot-tracked tab.  Note that the cursor is
    ** "outside" even if it is within our bounding rect if another window
    ** overlaps.  Note also that the case where the cursor stayed within our
    ** window but has moved off the hot-tracked tab will be handled by the
790
    ** WM_MOUSEMOVE event.
791 792 793
    */
    if (!GetCursorPos(&pt) || WindowFromPoint(pt) != hwnd)
    {
794
      /* Redraw iHotTracked to look normal */
795 796
      INT iRedraw = infoPtr->iHotTracked;
      infoPtr->iHotTracked = -1;
797
      hottrack_refresh (infoPtr, iRedraw);
798

799
      /* Kill this timer */
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
      KillTimer(hwnd, TAB_HOTTRACK_TIMER);
    }
  }
}

/******************************************************************************
 * TAB_RecalcHotTrack
 *
 * If a tab control has the TCS_HOTTRACK style, then the tab under the mouse
 * should be highlighted.  This function determines which tab in a tab control,
 * if any, is under the mouse and records that information.  The caller may
 * supply output parameters to receive the item number of the tab item which
 * was highlighted but isn't any longer and of the tab item which is now
 * highlighted but wasn't previously.  The caller can use this information to
 * selectively redraw those tab items.
 *
 * If the caller has a mouse position, it can supply it through the pos
 * parameter.  For example, TAB_MouseMove does this.  Otherwise, the caller
 * supplies NULL and this function determines the current mouse position
 * itself.
 */
static void
TAB_RecalcHotTrack
  (
824
  TAB_INFO*       infoPtr,
825 826 827 828 829 830 831 832 833 834 835 836 837
  const LPARAM*   pos,
  int*            out_redrawLeave,
  int*            out_redrawEnter
  )
{
  int item = -1;


  if (out_redrawLeave != NULL)
    *out_redrawLeave = -1;
  if (out_redrawEnter != NULL)
    *out_redrawEnter = -1;

838
  if ((infoPtr->dwStyle & TCS_HOTTRACK) || GetWindowTheme(infoPtr->hwnd))
839 840 841 842 843 844 845
  {
    POINT pt;
    UINT  flags;

    if (pos == NULL)
    {
      GetCursorPos(&pt);
846
      ScreenToClient(infoPtr->hwnd, &pt);
847 848 849
    }
    else
    {
850 851
      pt.x = (short)LOWORD(*pos);
      pt.y = (short)HIWORD(*pos);
852 853
    }

854
    item = TAB_InternalHitTest(infoPtr, pt, &flags);
855 856 857 858 859 860
  }

  if (item != infoPtr->iHotTracked)
  {
    if (infoPtr->iHotTracked >= 0)
    {
861
      /* Mark currently hot-tracked to be redrawn to look normal */
862 863 864 865 866
      if (out_redrawLeave != NULL)
        *out_redrawLeave = infoPtr->iHotTracked;

      if (item < 0)
      {
867
        /* Kill timer which forces recheck of mouse pos */
868
        KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
869 870 871 872
      }
    }
    else
    {
873
      /* Start timer so we recheck mouse pos */
874 875
      UINT timerID = SetTimer
        (
876
        infoPtr->hwnd,
877 878 879 880 881 882 883 884 885 886 887 888 889
        TAB_HOTTRACK_TIMER,
        TAB_HOTTRACK_TIMER_INTERVAL,
        TAB_HotTrackTimerProc
        );

      if (timerID == 0)
        return; /* Hot tracking not available */
    }

    infoPtr->iHotTracked = item;

    if (item >= 0)
    {
890
	/* Mark new hot-tracked to be redrawn to look highlighted */
891 892 893 894 895 896 897 898 899 900 901
      if (out_redrawEnter != NULL)
        *out_redrawEnter = item;
    }
  }
}

/******************************************************************************
 * TAB_MouseMove
 *
 * Handles the mouse-move event.  Updates tooltips.  Updates hot-tracking.
 */
Alex Priem's avatar
Alex Priem committed
902
static LRESULT
903
TAB_MouseMove (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
Alex Priem's avatar
Alex Priem committed
904
{
905 906 907
  int redrawLeave;
  int redrawEnter;

Francis Beaudet's avatar
Francis Beaudet committed
908
  if (infoPtr->hwndToolTip)
909
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
Francis Beaudet's avatar
Francis Beaudet committed
910
		    WM_LBUTTONDOWN, wParam, lParam);
911 912 913

  /* Determine which tab to highlight.  Redraw tabs which change highlight
  ** status. */
914
  TAB_RecalcHotTrack(infoPtr, &lParam, &redrawLeave, &redrawEnter);
915

916 917
  hottrack_refresh (infoPtr, redrawLeave);
  hottrack_refresh (infoPtr, redrawEnter);
918

Francis Beaudet's avatar
Francis Beaudet committed
919
  return 0;
Alex Priem's avatar
Alex Priem committed
920
}
921

922 923 924
/******************************************************************************
 * TAB_AdjustRect
 *
Andreas Mohr's avatar
Andreas Mohr committed
925
 * Calculates the tab control's display area given the window rectangle or
926 927
 * the window rectangle given the requested display rectangle.
 */
928
static LRESULT TAB_AdjustRect(const TAB_INFO *infoPtr, WPARAM fLarger, LPRECT prc)
929
{
930
    LONG *iRightBottom, *iLeftTop;
931

932 933
    TRACE ("hwnd=%p fLarger=%ld (%s)\n", infoPtr->hwnd, fLarger,
           wine_dbgstr_rect(prc));
934

935 936
    if (!prc) return -1;

937
    if(infoPtr->dwStyle & TCS_VERTICAL)
938 939 940
    {
	iRightBottom = &(prc->right);
	iLeftTop     = &(prc->left);
941
    }
942
    else
943
    {
944 945
	iRightBottom = &(prc->bottom);
	iLeftTop     = &(prc->top);
946
    }
947

948 949
    if (fLarger) /* Go from display rectangle */
    {
950
        /* Add the height of the tabs. */
951
	if (infoPtr->dwStyle & TCS_BOTTOM)
952 953 954
	    *iRightBottom += infoPtr->tabHeight * infoPtr->uNumRows;
	else
	    *iLeftTop -= infoPtr->tabHeight * infoPtr->uNumRows +
955
			 ((infoPtr->dwStyle & TCS_BUTTONS)? 3 * (infoPtr->uNumRows - 1) : 0);
956

957 958
	/* Inflate the rectangle for the padding */
	InflateRect(prc, DISPLAY_AREA_PADDINGX, DISPLAY_AREA_PADDINGY); 
959

960 961
	/* Inflate for the border */
	InflateRect(prc, CONTROL_BORDER_SIZEX, CONTROL_BORDER_SIZEY);
962 963 964
    }
    else /* Go from window rectangle. */
    {
965 966
	/* Deflate the rectangle for the border */
	InflateRect(prc, -CONTROL_BORDER_SIZEX, -CONTROL_BORDER_SIZEY);
967

968 969
	/* Deflate the rectangle for the padding */
	InflateRect(prc, -DISPLAY_AREA_PADDINGX, -DISPLAY_AREA_PADDINGY);
970

971
	/* Remove the height of the tabs. */
972
	if (infoPtr->dwStyle & TCS_BOTTOM)
973 974 975
	    *iRightBottom -= infoPtr->tabHeight * infoPtr->uNumRows;
	else
	    *iLeftTop += (infoPtr->tabHeight) * infoPtr->uNumRows +
976
			 ((infoPtr->dwStyle & TCS_BUTTONS)? 3 * (infoPtr->uNumRows - 1) : 0);
977 978
    }

Francis Beaudet's avatar
Francis Beaudet committed
979
  return 0;
980 981
}

Francis Beaudet's avatar
Francis Beaudet committed
982 983 984 985 986 987
/******************************************************************************
 * TAB_OnHScroll
 *
 * This method will handle the notification from the scroll control and
 * perform the scrolling operation on the tab control.
 */
988
static LRESULT TAB_OnHScroll(TAB_INFO *infoPtr, int nScrollCode, int nPos)
Alexandre Julliard's avatar
Alexandre Julliard committed
989
{
Alexandre Julliard's avatar
Alexandre Julliard committed
990
  if(nScrollCode == SB_THUMBPOSITION && nPos != infoPtr->leftmostVisible)
Francis Beaudet's avatar
Francis Beaudet committed
991
  {
Alexandre Julliard's avatar
Alexandre Julliard committed
992 993 994 995
     if(nPos < infoPtr->leftmostVisible)
        infoPtr->leftmostVisible--;
     else
        infoPtr->leftmostVisible++;
Francis Beaudet's avatar
Francis Beaudet committed
996

997 998
     TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
     TAB_InvalidateTabArea(infoPtr);
999
     SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
Alexandre Julliard's avatar
Alexandre Julliard committed
1000 1001
                   MAKELONG(infoPtr->leftmostVisible, 0));
   }
Alexandre Julliard's avatar
Alexandre Julliard committed
1002

Alexandre Julliard's avatar
Alexandre Julliard committed
1003
   return 0;
Alexandre Julliard's avatar
Alexandre Julliard committed
1004
}
Francis Beaudet's avatar
Francis Beaudet committed
1005 1006

/******************************************************************************
Gerard Patel's avatar
Gerard Patel committed
1007
 * TAB_SetupScrolling
Francis Beaudet's avatar
Francis Beaudet committed
1008
 *
1009
 * This method will check the current scrolling state and make sure the
Francis Beaudet's avatar
Francis Beaudet committed
1010 1011 1012 1013 1014
 * scrolling control is displayed (or not).
 */
static void TAB_SetupScrolling(
  TAB_INFO*   infoPtr,
  const RECT* clientRect)
Alexandre Julliard's avatar
Alexandre Julliard committed
1015
{
Alexandre Julliard's avatar
Alexandre Julliard committed
1016
  INT maxRange = 0;
1017

Francis Beaudet's avatar
Francis Beaudet committed
1018 1019 1020
  if (infoPtr->needsScrolling)
  {
    RECT controlPos;
Alexandre Julliard's avatar
Alexandre Julliard committed
1021
    INT vsize, tabwidth;
1022

Francis Beaudet's avatar
Francis Beaudet committed
1023 1024 1025
    /*
     * Calculate the position of the scroll control.
     */
1026 1027
    controlPos.right = clientRect->right;
    controlPos.left  = controlPos.right - 2 * GetSystemMetrics(SM_CXHSCROLL);
1028

1029 1030 1031 1032
    if (infoPtr->dwStyle & TCS_BOTTOM)
    {
      controlPos.top    = clientRect->bottom - infoPtr->tabHeight;
      controlPos.bottom = controlPos.top + GetSystemMetrics(SM_CYHSCROLL);
Francis Beaudet's avatar
Francis Beaudet committed
1033 1034 1035
    }
    else
    {
1036 1037
      controlPos.bottom = clientRect->top + infoPtr->tabHeight;
      controlPos.top    = controlPos.bottom - GetSystemMetrics(SM_CYHSCROLL);
Francis Beaudet's avatar
Francis Beaudet committed
1038
    }
Alexandre Julliard's avatar
Alexandre Julliard committed
1039

Francis Beaudet's avatar
Francis Beaudet committed
1040 1041
    /*
     * If we don't have a scroll control yet, we want to create one.
1042
     * If we have one, we want to make sure it's positioned properly.
Francis Beaudet's avatar
Francis Beaudet committed
1043 1044 1045
     */
    if (infoPtr->hwndUpDown==0)
    {
1046
      infoPtr->hwndUpDown = CreateWindowW(UPDOWN_CLASSW, L"",
Alexandre Julliard's avatar
Alexandre Julliard committed
1047
					  WS_VISIBLE | WS_CHILD | UDS_HORZ,
Francis Beaudet's avatar
Francis Beaudet committed
1048 1049 1050
					  controlPos.left, controlPos.top,
					  controlPos.right - controlPos.left,
					  controlPos.bottom - controlPos.top,
1051
					  infoPtr->hwnd, NULL, NULL, NULL);
Francis Beaudet's avatar
Francis Beaudet committed
1052 1053 1054
    }
    else
    {
1055
      SetWindowPos(infoPtr->hwndUpDown,
1056
		   NULL,
Francis Beaudet's avatar
Francis Beaudet committed
1057 1058 1059
		   controlPos.left, controlPos.top,
		   controlPos.right - controlPos.left,
		   controlPos.bottom - controlPos.top,
1060
		   SWP_SHOWWINDOW | SWP_NOZORDER);
Francis Beaudet's avatar
Francis Beaudet committed
1061
    }
Alexandre Julliard's avatar
Alexandre Julliard committed
1062 1063 1064 1065 1066 1067 1068 1069 1070

    /* Now calculate upper limit of the updown control range.
     * We do this by calculating how many tabs will be offscreen when the
     * last tab is visible.
     */
    if(infoPtr->uNumItem)
    {
       vsize = clientRect->right - (controlPos.right - controlPos.left + 1);
       maxRange = infoPtr->uNumItem;
1071
       tabwidth = TAB_GetItem(infoPtr, infoPtr->uNumItem - 1)->rect.right;
Alexandre Julliard's avatar
Alexandre Julliard committed
1072 1073 1074

       for(; maxRange > 0; maxRange--)
       {
1075
          if(tabwidth - TAB_GetItem(infoPtr,maxRange - 1)->rect.left > vsize)
Alexandre Julliard's avatar
Alexandre Julliard committed
1076 1077 1078 1079 1080 1081
             break;
       }

       if(maxRange == infoPtr->uNumItem)
          maxRange--;
    }
Francis Beaudet's avatar
Francis Beaudet committed
1082 1083 1084
  }
  else
  {
1085
    /* If we once had a scroll control... hide it */
1086
    if (infoPtr->hwndUpDown)
Francis Beaudet's avatar
Francis Beaudet committed
1087 1088
      ShowWindow(infoPtr->hwndUpDown, SW_HIDE);
  }
Alexandre Julliard's avatar
Alexandre Julliard committed
1089
  if (infoPtr->hwndUpDown)
1090
     SendMessageW(infoPtr->hwndUpDown, UDM_SETRANGE32, 0, maxRange);
Francis Beaudet's avatar
Francis Beaudet committed
1091
}
Alexandre Julliard's avatar
Alexandre Julliard committed
1092

Francis Beaudet's avatar
Francis Beaudet committed
1093 1094 1095 1096 1097 1098 1099 1100
/******************************************************************************
 * TAB_SetItemBounds
 *
 * This method will calculate the position rectangles of all the items in the
 * control. The rectangle calculated starts at 0 for the first item in the
 * list and ignores scrolling and selection.
 * It also uses the current font to determine the height of the tab row and
 * it checks if all the tabs fit in the client area of the window. If they
1101
 * don't, a scrolling control is added.
Francis Beaudet's avatar
Francis Beaudet committed
1102
 */
1103
static void TAB_SetItemBounds (TAB_INFO *infoPtr)
Francis Beaudet's avatar
Francis Beaudet committed
1104
{
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
1105
  TEXTMETRICW fontMetrics;
1106
  UINT        curItem;
Francis Beaudet's avatar
Francis Beaudet committed
1107
  INT         curItemLeftPos;
1108
  INT         curItemRowCount;
Francis Beaudet's avatar
Francis Beaudet committed
1109 1110 1111
  HFONT       hFont, hOldFont;
  HDC         hdc;
  RECT        clientRect;
1112 1113 1114
  INT         iTemp;
  RECT*       rcItem;
  INT         iIndex;
1115
  INT         icon_width = 0;
Francis Beaudet's avatar
Francis Beaudet committed
1116 1117 1118 1119 1120

  /*
   * We need to get text information so we need a DC and we need to select
   * a font.
   */
1121
  hdc = GetDC(infoPtr->hwnd);
1122

Francis Beaudet's avatar
Francis Beaudet committed
1123 1124 1125 1126 1127 1128 1129
  hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
  hOldFont = SelectObject (hdc, hFont);

  /*
   * We will base the rectangle calculations on the client rectangle
   * of the control.
   */
1130
  GetClientRect(infoPtr->hwnd, &clientRect);
1131

Gerard Patel's avatar
Gerard Patel committed
1132
  /* if TCS_VERTICAL then swap the height and width so this code places the
1133
     tabs along the top of the rectangle and we can just rotate them after
Gerard Patel's avatar
Gerard Patel committed
1134
     rather than duplicate all of the below code */
1135
  if(infoPtr->dwStyle & TCS_VERTICAL)
1136 1137 1138 1139 1140 1141
  {
     iTemp = clientRect.bottom;
     clientRect.bottom = clientRect.right;
     clientRect.right = iTemp;
  }

1142 1143 1144 1145
  /* Now use hPadding and vPadding */
  infoPtr->uHItemPadding = infoPtr->uHItemPadding_s;
  infoPtr->uVItemPadding = infoPtr->uVItemPadding_s;
  
1146
  /* The leftmost item will be "0" aligned */
Francis Beaudet's avatar
Francis Beaudet committed
1147
  curItemLeftPos = 0;
Gerard Patel's avatar
Gerard Patel committed
1148
  curItemRowCount = infoPtr->uNumItem ? 1 : 0;
Francis Beaudet's avatar
Francis Beaudet committed
1149

1150
  if (!(infoPtr->fHeightSet))
1151
  {
1152
    int item_height;
1153
    INT icon_height = 0, cx;
1154

1155
    /* Use the current font to determine the height of a tab. */
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
1156
    GetTextMetricsW(hdc, &fontMetrics);
1157

1158
    /* Get the icon height */
1159
    if (infoPtr->himl)
1160
      ImageList_GetIconSize(infoPtr->himl, &cx, &icon_height);
1161

1162
    /* Take the highest between font or icon */
1163
    if (fontMetrics.tmHeight > icon_height)
1164
      item_height = fontMetrics.tmHeight + 2;
1165 1166 1167 1168
    else
      item_height = icon_height;

    /*
1169 1170
     * Make sure there is enough space for the letters + icon + growing the
     * selected item + extra space for the selected item.
1171
     */
1172
    infoPtr->tabHeight = item_height + 
1173
	                 ((infoPtr->dwStyle & TCS_BUTTONS) ? 2 : 1) *
1174
                          infoPtr->uVItemPadding;
1175

1176
    TRACE("tabH=%d, tmH=%d, iconh=%d\n",
1177
	  infoPtr->tabHeight, fontMetrics.tmHeight, icon_height);
1178 1179
  }

1180
  TRACE("client right=%d\n", clientRect.right);
1181

1182 1183 1184
  /* Get the icon width */
  if (infoPtr->himl)
  {
1185 1186 1187
    INT cy;

    ImageList_GetIconSize(infoPtr->himl, &icon_width, &cy);
1188

1189
    if (infoPtr->dwStyle & TCS_FIXEDWIDTH)
1190 1191 1192 1193 1194 1195
      icon_width += 4;
    else
      /* Add padding if icon is present */
      icon_width += infoPtr->uHItemPadding;
  }

Francis Beaudet's avatar
Francis Beaudet committed
1196 1197
  for (curItem = 0; curItem < infoPtr->uNumItem; curItem++)
  {
1198 1199
    TAB_ITEM *curr = TAB_GetItem(infoPtr, curItem);
	
1200
    /* Set the leftmost position of the tab. */
1201
    curr->rect.left = curItemLeftPos;
Francis Beaudet's avatar
Francis Beaudet committed
1202

1203
    if (infoPtr->dwStyle & TCS_FIXEDWIDTH)
1204
    {
1205
      curr->rect.right = curr->rect.left +
1206
        max(infoPtr->tabWidth, icon_width);
1207
    }
1208
    else if (!curr->pszText)
1209
    {
1210 1211 1212 1213 1214 1215
      /* If no text use minimum tab width including padding. */
      if (infoPtr->tabMinWidth < 0)
        curr->rect.right = curr->rect.left + GET_DEFAULT_MIN_TAB_WIDTH(infoPtr);
      else
      {
        curr->rect.right = curr->rect.left + infoPtr->tabMinWidth;
1216

1217 1218 1219 1220 1221 1222 1223 1224 1225
        /* Add extra padding if icon is present */
        if (infoPtr->himl && infoPtr->tabMinWidth > 0 && infoPtr->tabMinWidth < DEFAULT_MIN_TAB_WIDTH
            && infoPtr->uHItemPadding > 1)
          curr->rect.right += EXTRA_ICON_PADDING * (infoPtr->uHItemPadding-1);
      }
    }
    else
    {
      int tabwidth;
1226
      SIZE size;
1227
      /* Calculate how wide the tab is depending on the text it contains */
1228 1229
      GetTextExtentPoint32W(hdc, curr->pszText,
                            lstrlenW(curr->pszText), &size);
1230

1231 1232 1233 1234 1235 1236 1237 1238
      tabwidth = size.cx + icon_width + 2 * infoPtr->uHItemPadding;

      if (infoPtr->tabMinWidth < 0)
        tabwidth = max(tabwidth, GET_DEFAULT_MIN_TAB_WIDTH(infoPtr));
      else
        tabwidth = max(tabwidth, infoPtr->tabMinWidth);

      curr->rect.right = curr->rect.left + tabwidth;
1239
      TRACE("for <%s>, rect %s\n", debugstr_w(curr->pszText), wine_dbgstr_rect(&curr->rect));
1240
    }
Francis Beaudet's avatar
Francis Beaudet committed
1241

1242 1243 1244 1245
    /*
     * Check if this is a multiline tab control and if so
     * check to see if we should wrap the tabs
     *
1246
     * Wrap all these tabs. We will arrange them evenly later.
1247 1248 1249
     *
     */

1250
    if (((infoPtr->dwStyle & TCS_MULTILINE) || (infoPtr->dwStyle & TCS_VERTICAL)) &&
1251
        (curr->rect.right > 
1252
	(clientRect.right - CONTROL_BORDER_SIZEX - DISPLAY_AREA_PADDINGX)))
1253
    {
1254
        curr->rect.right -= curr->rect.left;
1255

1256
	curr->rect.left = 0;
1257
        curItemRowCount++;
1258
	TRACE("wrapping <%s>, rect %s\n", debugstr_w(curr->pszText), wine_dbgstr_rect(&curr->rect));
1259 1260
    }

1261 1262
    curr->rect.bottom = 0;
    curr->rect.top = curItemRowCount - 1;
1263

1264
    TRACE("Rect: %s\n", wine_dbgstr_rect(&curr->rect));
Francis Beaudet's avatar
Francis Beaudet committed
1265 1266 1267 1268 1269

    /*
     * The leftmost position of the next item is the rightmost position
     * of this one.
     */
1270
    if (infoPtr->dwStyle & TCS_BUTTONS)
1271
    {
1272
      curItemLeftPos = curr->rect.right + BUTTON_SPACINGX;
1273
      if (infoPtr->dwStyle & TCS_FLATBUTTONS)
1274 1275
        curItemLeftPos += FLAT_BTN_SPACINGX;
    }
1276
    else
1277
      curItemLeftPos = curr->rect.right;
Francis Beaudet's avatar
Francis Beaudet committed
1278 1279
  }

1280
  if (!((infoPtr->dwStyle & TCS_MULTILINE) || (infoPtr->dwStyle & TCS_VERTICAL)))
1281 1282 1283 1284
  {
    /*
     * Check if we need a scrolling control.
     */
1285
    infoPtr->needsScrolling = (curItemLeftPos + (2 * SELECTED_TAB_OFFSET) >
1286 1287
                               clientRect.right);

1288 1289
    /* Don't need scrolling, then update infoPtr->leftmostVisible */
    if(!infoPtr->needsScrolling)
1290
      infoPtr->leftmostVisible = 0;
1291
  }
1292 1293 1294 1295 1296 1297 1298 1299
  else
  {
    /*
     * No scrolling in Multiline or Vertical styles.
     */
    infoPtr->needsScrolling = FALSE;
    infoPtr->leftmostVisible = 0;
  }
1300
  TAB_SetupScrolling(infoPtr, &clientRect);
1301

1302
  /* Set the number of rows */
1303
  infoPtr->uNumRows = curItemRowCount;
Yuxi Zhang's avatar
Yuxi Zhang committed
1304

1305
  /* Arrange all tabs evenly if style says so */
1306 1307
   if (!(infoPtr->dwStyle & TCS_RAGGEDRIGHT) &&
       ((infoPtr->dwStyle & TCS_MULTILINE) || (infoPtr->dwStyle & TCS_VERTICAL)) &&
1308 1309
       (infoPtr->uNumItem > 0) &&
       (infoPtr->uNumRows > 1))
1310
   {
1311 1312
      INT tabPerRow,remTab,iRow;
      UINT iItm;
1313
      INT iCount=0;
1314 1315

      /*
1316
       * Ok windows tries to even out the rows. place the same
1317 1318 1319
       * number of tabs in each row. So lets give that a shot
       */

Gerard Patel's avatar
Gerard Patel committed
1320 1321
      tabPerRow = infoPtr->uNumItem / (infoPtr->uNumRows);
      remTab = infoPtr->uNumItem % (infoPtr->uNumRows);
1322 1323 1324 1325 1326

      for (iItm=0,iRow=0,iCount=0,curItemLeftPos=0;
           iItm<infoPtr->uNumItem;
           iItm++,iCount++)
      {
1327
          /* normalize the current rect */
1328 1329
          TAB_ITEM *curr = TAB_GetItem(infoPtr, iItm);
 
1330
          /* shift the item to the left side of the clientRect */
1331 1332
          curr->rect.right -= curr->rect.left;
          curr->rect.left = 0;
1333

1334
          TRACE("r=%d, cl=%d, cl.r=%d, iCount=%d, iRow=%d, uNumRows=%d, remTab=%d, tabPerRow=%d\n",
1335
	      curr->rect.right, curItemLeftPos, clientRect.right,
1336 1337 1338 1339 1340 1341
	      iCount, iRow, infoPtr->uNumRows, remTab, tabPerRow);

          /* if we have reached the maximum number of tabs on this row */
          /* move to the next row, reset our current item left position and */
          /* the count of items on this row */

1342
	  if (infoPtr->dwStyle & TCS_VERTICAL) {
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	      /* Vert: Add the remaining tabs in the *last* remainder rows */
	      if (iCount >= ((iRow>=(INT)infoPtr->uNumRows - remTab)?tabPerRow + 1:tabPerRow)) {
		  iRow++;
		  curItemLeftPos = 0;
		  iCount = 0;
	      }
	  } else {
	      /* Horz: Add the remaining tabs in the *first* remainder rows */
	      if (iCount >= ((iRow<remTab)?tabPerRow + 1:tabPerRow)) {
		  iRow++;
		  curItemLeftPos = 0;
		  iCount = 0;
	      }
1356
	  }
1357

1358
          /* shift the item to the right to place it as the next item in this row */
1359 1360 1361
          curr->rect.left += curItemLeftPos;
          curr->rect.right += curItemLeftPos;
          curr->rect.top = iRow;
1362
          if (infoPtr->dwStyle & TCS_BUTTONS)
1363
	  {
1364
            curItemLeftPos = curr->rect.right + 1;
1365
            if (infoPtr->dwStyle & TCS_FLATBUTTONS)
1366 1367
	      curItemLeftPos += FLAT_BTN_SPACINGX;
	  }
1368
          else
1369
            curItemLeftPos = curr->rect.right;
1370

1371
          TRACE("arranging <%s>, rect %s\n", debugstr_w(curr->pszText), wine_dbgstr_rect(&curr->rect));
1372
      }
1373

1374 1375 1376 1377
      /*
       * Justify the rows
       */
      {
1378 1379 1380
	INT widthDiff, iIndexStart=0, iIndexEnd=0;
	INT remainder;
	INT iCount=0;
1381

1382
        while(iIndexStart < infoPtr->uNumItem)
1383
        {
1384 1385
          TAB_ITEM *start = TAB_GetItem(infoPtr, iIndexStart);

1386
          /*
1387
           * find the index of the row
1388 1389 1390 1391
           */
          /* find the first item on the next row */
          for (iIndexEnd=iIndexStart;
              (iIndexEnd < infoPtr->uNumItem) &&
1392 1393
 	      (TAB_GetItem(infoPtr, iIndexEnd)->rect.top ==
                start->rect.top) ;
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
              iIndexEnd++)
          /* intentionally blank */;

          /*
           * we need to justify these tabs so they fill the whole given
           * client area
           *
           */
          /* find the amount of space remaining on this row */
          widthDiff = clientRect.right - (2 * SELECTED_TAB_OFFSET) -
1404
			TAB_GetItem(infoPtr, iIndexEnd - 1)->rect.right;
1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415

	  /* iCount is the number of tab items on this row */
	  iCount = iIndexEnd - iIndexStart;

	  if (iCount > 1)
	  {
	    remainder = widthDiff % iCount;
	    widthDiff = widthDiff / iCount;
	    /* add widthDiff/iCount, or extra space/items on row, to each item on this row */
	    for (iIndex=iIndexStart, iCount=0; iIndex < iIndexEnd; iIndex++, iCount++)
	    {
1416 1417 1418 1419
              TAB_ITEM *item = TAB_GetItem(infoPtr, iIndex);

	      item->rect.left += iCount * widthDiff;
	      item->rect.right += (iCount + 1) * widthDiff;
1420

1421
              TRACE("adjusting 1 <%s>, rect %s\n", debugstr_w(item->pszText), wine_dbgstr_rect(&item->rect));
1422

1423
	    }
1424
	    TAB_GetItem(infoPtr, iIndex - 1)->rect.right += remainder;
1425 1426 1427
	  }
	  else /* we have only one item on this row, make it take up the entire row */
	  {
1428 1429
	    start->rect.left = clientRect.left;
	    start->rect.right = clientRect.right - 4;
1430

1431
            TRACE("adjusting 2 <%s>, rect %s\n", debugstr_w(start->pszText), wine_dbgstr_rect(&start->rect));
1432
	  }
1433

1434 1435
	  iIndexStart = iIndexEnd;
	}
1436 1437 1438
      }
  }

1439
  /* if TCS_VERTICAL rotate the tabs so they are along the side of the clientRect */
1440
  if(infoPtr->dwStyle & TCS_VERTICAL)
1441 1442 1443 1444
  {
    RECT rcOriginal;
    for(iIndex = 0; iIndex < infoPtr->uNumItem; iIndex++)
    {
1445
      rcItem = &TAB_GetItem(infoPtr, iIndex)->rect;
1446 1447 1448

      rcOriginal = *rcItem;

1449 1450
      /* this is rotating the items by 90 degrees clockwise around the center of the control */
      rcItem->top = (rcOriginal.left - clientRect.left);
1451 1452 1453 1454 1455 1456
      rcItem->bottom = rcItem->top + (rcOriginal.right - rcOriginal.left);
      rcItem->left = rcOriginal.top;
      rcItem->right = rcOriginal.bottom;
    }
  }

1457 1458
  TAB_EnsureSelectionVisible(infoPtr);
  TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
1459 1460

  /* Cleanup */
Francis Beaudet's avatar
Francis Beaudet committed
1461
  SelectObject (hdc, hOldFont);
1462
  ReleaseDC (infoPtr->hwnd, hdc);
Francis Beaudet's avatar
Francis Beaudet committed
1463 1464
}

1465 1466

static void
1467
TAB_EraseTabInterior(const TAB_INFO *infoPtr, HDC hdc, INT iItem, const RECT *drawRect)
1468 1469 1470 1471 1472
{
    HBRUSH   hbr = CreateSolidBrush (comctl32_color.clrBtnFace);
    BOOL     deleteBrush = TRUE;
    RECT     rTemp = *drawRect;

1473
    if (infoPtr->dwStyle & TCS_BUTTONS)
1474 1475 1476 1477
    {
	if (iItem == infoPtr->iSelected)
	{
	    /* Background color */
1478
	    if (!(infoPtr->dwStyle & TCS_OWNERDRAWFIXED))
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
	    {
		DeleteObject(hbr);
		hbr = GetSysColorBrush(COLOR_SCROLLBAR);

		SetTextColor(hdc, comctl32_color.clr3dFace);
		SetBkColor(hdc, comctl32_color.clr3dHilight);

		/* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
		* we better use 0x55aa bitmap brush to make scrollbar's background
		* look different from the window background.
		*/
		if (comctl32_color.clr3dHilight == comctl32_color.clrWindow)
		    hbr = COMCTL32_hPattern55AABrush;

		deleteBrush = FALSE;
	    }
	    FillRect(hdc, &rTemp, hbr);
	}
	else  /* ! selected */
	{
1499
	    if (infoPtr->dwStyle & TCS_FLATBUTTONS)
1500
	    {
1501 1502
		InflateRect(&rTemp, 2, 2);
		FillRect(hdc, &rTemp, hbr);
1503 1504
		if (iItem == infoPtr->iHotTracked ||
                   (iItem != infoPtr->iSelected && iItem == infoPtr->uFocus))
1505
		    DrawEdge(hdc, &rTemp, BDR_RAISEDINNER, BF_RECT);
1506 1507 1508 1509 1510 1511 1512 1513
	    }
	    else
		FillRect(hdc, &rTemp, hbr);
	}

    }
    else /* !TCS_BUTTONS */
    {
1514
        InflateRect(&rTemp, -2, -2);
1515 1516
        if (!GetWindowTheme (infoPtr->hwnd))
	    FillRect(hdc, &rTemp, hbr);
1517 1518
    }

1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
    /* highlighting is drawn on top of previous fills */
    if (TAB_GetItem(infoPtr, iItem)->dwState & TCIS_HIGHLIGHTED)
    {
        if (deleteBrush)
        {
            DeleteObject(hbr);
            deleteBrush = FALSE;
        }
        hbr = GetSysColorBrush(COLOR_HIGHLIGHT);
        FillRect(hdc, &rTemp, hbr);
    }

1531 1532 1533 1534
    /* Cleanup */
    if (deleteBrush) DeleteObject(hbr);
}

1535 1536 1537 1538 1539
/******************************************************************************
 * TAB_DrawItemInterior
 *
 * This method is used to draw the interior (text and icon) of a single tab
 * into the tab control.
1540
 */
1541
static void
1542
TAB_DrawItemInterior(const TAB_INFO *infoPtr, HDC hdc, INT iItem, RECT *drawRect)
1543 1544 1545
{
  RECT localRect;

1546
  HPEN   htextPen;
1547 1548
  HPEN   holdPen;
  INT    oldBkMode;
1549 1550
  HFONT  hOldFont;
  
1551
/*  if (drawRect == NULL) */
1552 1553 1554 1555 1556 1557 1558 1559
  {
    BOOL isVisible;
    RECT itemRect;
    RECT selectedRect;

    /*
     * Get the rectangle for the item.
     */
1560
    isVisible = TAB_InternalGetItemRect(infoPtr, iItem, &itemRect, &selectedRect);
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
    if (!isVisible)
      return;

    /*
     * Make sure drawRect points to something valid; simplifies code.
     */
    drawRect = &localRect;

    /*
     * This logic copied from the part of TAB_DrawItem which draws
     * the tab background.  It's important to keep it in sync.  I
     * would have liked to avoid code duplication, but couldn't figure
     * out how without making spaghetti of TAB_DrawItem.
     */
1575 1576 1577 1578 1579
    if (iItem == infoPtr->iSelected)
      *drawRect = selectedRect;
    else
      *drawRect = itemRect;
        
1580
    if (infoPtr->dwStyle & TCS_BUTTONS)
1581 1582 1583
    {
      if (iItem == infoPtr->iSelected)
      {
1584 1585 1586
	drawRect->left   += 4;
	drawRect->top    += 4;
	drawRect->right  -= 4;
1587

1588
	if (infoPtr->dwStyle & TCS_VERTICAL)
1589
	{
1590
	  if (!(infoPtr->dwStyle & TCS_BOTTOM)) drawRect->right  += 1;
1591 1592 1593 1594
	  drawRect->bottom   -= 4;
	}
	else
	{
1595
	  if (infoPtr->dwStyle & TCS_BOTTOM)
1596 1597 1598 1599 1600 1601 1602
	  {
	    drawRect->top    -= 2;
	    drawRect->bottom -= 4;
	  }
	  else
	    drawRect->bottom -= 1;
	}
1603 1604
      }
      else
1605
        InflateRect(drawRect, -2, -2);
1606 1607 1608
    }
    else
    {
1609
      if ((infoPtr->dwStyle & TCS_VERTICAL) && (infoPtr->dwStyle & TCS_BOTTOM))
1610
      {
1611
        if (iItem != infoPtr->iSelected)
1612
	{
1613
	  drawRect->left   += 2;
1614
          InflateRect(drawRect, 0, -2);
1615 1616
	}
      }
1617
      else if (infoPtr->dwStyle & TCS_VERTICAL)
1618 1619 1620 1621 1622 1623 1624 1625
      {
        if (iItem == infoPtr->iSelected)
	{
	  drawRect->right  += 1;
	}
	else
	{
	  drawRect->right  -= 2;
1626
          InflateRect(drawRect, 0, -2);
1627 1628
	}
      }
1629
      else if (infoPtr->dwStyle & TCS_BOTTOM)
1630 1631 1632 1633 1634 1635 1636 1637 1638
      {
        if (iItem == infoPtr->iSelected)
	{
	  drawRect->top    -= 2;
	}
	else
	{
	  InflateRect(drawRect, -2, -2);
          drawRect->bottom += 2;
1639 1640
	}
      }
1641
      else
1642
      {
1643 1644 1645 1646 1647 1648
        if (iItem == infoPtr->iSelected)
	{
	  drawRect->bottom += 3;
	}
	else
	{
1649
	  drawRect->bottom -= 2;
1650 1651
	  InflateRect(drawRect, -2, 0);
	}
1652
      }
1653 1654
    }
  }
1655
  TRACE("drawRect=(%s)\n", wine_dbgstr_rect(drawRect));
1656 1657

  /* Clear interior */
1658
  TAB_EraseTabInterior (infoPtr, hdc, iItem, drawRect);
1659 1660

  /* Draw the focus rectangle */
1661
  if (!(infoPtr->dwStyle & TCS_FOCUSNEVER) &&
1662
      (GetFocus() == infoPtr->hwnd) &&
1663 1664 1665
      (iItem == infoPtr->uFocus) )
  {
    RECT rFocus = *drawRect;
1666 1667

    if (!(infoPtr->dwStyle & TCS_BUTTONS)) InflateRect(&rFocus, -3, -3);
1668
    if (infoPtr->dwStyle & TCS_BOTTOM && !(infoPtr->dwStyle & TCS_VERTICAL))
1669 1670
      rFocus.top -= 3;

1671 1672 1673
    /* focus should stay on selected item for TCS_BUTTONS style */
    if (!((infoPtr->dwStyle & TCS_BUTTONS) && (infoPtr->iSelected != iItem)))
      DrawFocusRect(hdc, &rFocus);
1674
  }
1675 1676 1677 1678

  /*
   * Text pen
   */
1679
  htextPen = CreatePen( PS_SOLID, 1, comctl32_color.clrBtnText );
1680 1681
  holdPen  = SelectObject(hdc, htextPen);
  hOldFont = SelectObject(hdc, infoPtr->hFont);
1682

1683 1684 1685
  /*
   * Setup for text output
  */
1686
  oldBkMode = SetBkMode(hdc, TRANSPARENT);
1687
  if (!GetWindowTheme (infoPtr->hwnd) || (infoPtr->dwStyle & TCS_BUTTONS))
1688
  {
1689 1690
    if ((infoPtr->dwStyle & TCS_HOTTRACK) && (iItem == infoPtr->iHotTracked) &&
        !(infoPtr->dwStyle & TCS_FLATBUTTONS))
1691 1692 1693 1694 1695 1696
      SetTextColor(hdc, comctl32_color.clrHighlight);
    else if (TAB_GetItem(infoPtr, iItem)->dwState & TCIS_HIGHLIGHTED)
      SetTextColor(hdc, comctl32_color.clrHighlightText);
    else
      SetTextColor(hdc, comctl32_color.clrBtnText);
  }
1697 1698 1699 1700

  /*
   * if owner draw, tell the owner to draw
   */
1701
  if ((infoPtr->dwStyle & TCS_OWNERDRAWFIXED) && IsWindow(infoPtr->hwndNotify))
1702 1703 1704 1705
  {
    DRAWITEMSTRUCT dis;
    UINT id;

1706 1707 1708
    drawRect->top += 2;
    drawRect->right -= 1;
    if ( iItem == infoPtr->iSelected )
1709
        InflateRect(drawRect, -1, 0);
1710

1711
    id = (UINT)GetWindowLongPtrW( infoPtr->hwnd, GWLP_ID );
1712

1713
    /* fill DRAWITEMSTRUCT */
1714 1715 1716 1717
    dis.CtlType    = ODT_TAB;
    dis.CtlID      = id;
    dis.itemID     = iItem;
    dis.itemAction = ODA_DRAWENTIRE;
1718
    dis.itemState = 0;
1719
    if ( iItem == infoPtr->iSelected )
1720 1721 1722
      dis.itemState |= ODS_SELECTED;
    if (infoPtr->uFocus == iItem) 
      dis.itemState |= ODS_FOCUS;
1723
    dis.hwndItem = infoPtr->hwnd;
1724
    dis.hDC      = hdc;
1725
    dis.rcItem = *drawRect;
1726

1727 1728 1729 1730 1731 1732 1733
    /* when extra data fits ULONG_PTR, store it directly */
    if (infoPtr->cbInfo > sizeof(LPARAM))
        dis.itemData =  (ULONG_PTR) TAB_GetItem(infoPtr, iItem)->extra;
    else
    {
        /* this could be considered broken on 64 bit, but that's how it works -
           only first 4 bytes are copied */
1734
        dis.itemData = 0;
1735 1736 1737 1738
        memcpy(&dis.itemData, (ULONG_PTR*)TAB_GetItem(infoPtr, iItem)->extra, 4);
    }

    /* draw notification */
1739
    SendMessageW( infoPtr->hwndNotify, WM_DRAWITEM, id, (LPARAM)&dis );
1740 1741 1742
  }
  else
  {
1743
    TAB_ITEM *item = TAB_GetItem(infoPtr, iItem);
1744 1745 1746 1747 1748
    RECT rcTemp;
    RECT rcImage;

    /* used to center the icon and text in the tab */
    RECT rcText;
1749
    INT center_offset_h, center_offset_v;
1750 1751 1752 1753 1754

    /* set rcImage to drawRect, we will use top & left in our ImageList_Draw call */
    rcImage = *drawRect;

    rcTemp = *drawRect;
1755
    SetRectEmpty(&rcText);
1756

1757
    /* get the rectangle that the text fits in */
1758
    if (item->pszText)
1759
    {
1760
      DrawTextW(hdc, item->pszText, -1, &rcText, DT_CALCRECT);
1761
    }
1762 1763 1764 1765 1766
    /*
     * If not owner draw, then do the drawing ourselves.
     *
     * Draw the icon.
     */
1767
    if (infoPtr->himl && item->iImage != -1)
1768
    {
1769 1770 1771
      INT cx;
      INT cy;
      
1772 1773
      ImageList_GetIconSize(infoPtr->himl, &cx, &cy);

1774
      if(infoPtr->dwStyle & TCS_VERTICAL)
1775 1776
      {
        center_offset_h = ((drawRect->bottom - drawRect->top) - (cy + infoPtr->uHItemPadding + (rcText.right  - rcText.left))) / 2;
1777
        center_offset_v = ((drawRect->right - drawRect->left) - cx) / 2;
1778
      }
1779
      else
1780 1781
      {
        center_offset_h = ((drawRect->right - drawRect->left) - (cx + infoPtr->uHItemPadding + (rcText.right  - rcText.left))) / 2;
1782
        center_offset_v = ((drawRect->bottom - drawRect->top) - cy) / 2;
1783 1784
      }

1785 1786 1787 1788 1789 1790
      /* if an item is selected, the icon is shifted up instead of down */
      if (iItem == infoPtr->iSelected)
        center_offset_v -= infoPtr->uVItemPadding / 2;
      else
        center_offset_v += infoPtr->uVItemPadding / 2;

1791
      if (infoPtr->dwStyle & TCS_FIXEDWIDTH && infoPtr->dwStyle & (TCS_FORCELABELLEFT | TCS_FORCEICONLEFT))
1792
	center_offset_h = infoPtr->uHItemPadding;
1793

1794 1795 1796
      if (center_offset_h < 2)
        center_offset_h = 2;
	
1797 1798 1799
      if (center_offset_v < 0)
        center_offset_v = 0;
	
1800
      TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%s), textlen=%d\n",
1801
	  debugstr_w(item->pszText), center_offset_h, center_offset_v,
1802
          wine_dbgstr_rect(drawRect), (rcText.right-rcText.left));
1803

1804
      if((infoPtr->dwStyle & TCS_VERTICAL) && (infoPtr->dwStyle & TCS_BOTTOM))
1805
      {
1806
        rcImage.top = drawRect->top + center_offset_h;
1807 1808 1809 1810
	/* if tab is TCS_VERTICAL and TCS_BOTTOM, the text is drawn from the */
	/* right side of the tab, but the image still uses the left as its x position */
	/* this keeps the image always drawn off of the same side of the tab */
        rcImage.left = drawRect->right - cx - center_offset_v;
1811
        drawRect->top += cy + infoPtr->uHItemPadding;
1812
      }
1813
      else if(infoPtr->dwStyle & TCS_VERTICAL)
1814
      {
1815 1816
        rcImage.top  = drawRect->bottom - cy - center_offset_h;
	rcImage.left = drawRect->left + center_offset_v;
1817
        drawRect->bottom -= cy + infoPtr->uHItemPadding;
1818 1819 1820
      }
      else /* normal style, whether TCS_BOTTOM or not */
      {
1821
        rcImage.left = drawRect->left + center_offset_h;
1822
	rcImage.top = drawRect->top + center_offset_v;
1823
        drawRect->left += cx + infoPtr->uHItemPadding;
1824
      }
1825

1826
      TRACE("drawing image=%d, left=%d, top=%d\n",
1827
	    item->iImage, rcImage.left, rcImage.top-1);
1828 1829 1830
      ImageList_Draw
        (
        infoPtr->himl,
1831
        item->iImage,
1832
        hdc,
1833
        rcImage.left,
1834
        rcImage.top,
1835 1836
        ILD_NORMAL
        );
1837
    }
1838 1839

    /* Now position text */
1840
    if (infoPtr->dwStyle & TCS_FIXEDWIDTH && infoPtr->dwStyle & TCS_FORCELABELLEFT)
1841 1842
      center_offset_h = infoPtr->uHItemPadding;
    else
1843
      if(infoPtr->dwStyle & TCS_VERTICAL)
1844
        center_offset_h = ((drawRect->bottom - drawRect->top) - (rcText.right - rcText.left)) / 2;
1845
      else
1846
        center_offset_h = ((drawRect->right - drawRect->left) - (rcText.right - rcText.left)) / 2;
1847

1848
    if(infoPtr->dwStyle & TCS_VERTICAL)
1849
    {
1850
      if(infoPtr->dwStyle & TCS_BOTTOM)
1851 1852 1853 1854
        drawRect->top+=center_offset_h;
      else
        drawRect->bottom-=center_offset_h;

1855
      center_offset_v = ((drawRect->right - drawRect->left) - (rcText.bottom - rcText.top)) / 2;
1856
    }
1857
    else
1858
    {
1859
      drawRect->left += center_offset_h;
1860
      center_offset_v = ((drawRect->bottom - drawRect->top) - (rcText.bottom - rcText.top)) / 2;
1861 1862
    }

1863 1864 1865 1866 1867 1868
    /* if an item is selected, the text is shifted up instead of down */
    if (iItem == infoPtr->iSelected)
        center_offset_v -= infoPtr->uVItemPadding / 2;
    else
        center_offset_v += infoPtr->uVItemPadding / 2;

1869 1870 1871
    if (center_offset_v < 0)
      center_offset_v = 0;

1872
    if(infoPtr->dwStyle & TCS_VERTICAL)
1873 1874 1875 1876
      drawRect->left += center_offset_v;
    else
      drawRect->top += center_offset_v;

1877
    /* Draw the text */
1878
    if(infoPtr->dwStyle & TCS_VERTICAL) /* if we are vertical rotate the text and each character */
1879
    {
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
1880
      LOGFONTW logfont;
1881
      HFONT hFont;
1882 1883 1884
      INT nEscapement = 900;
      INT nOrientation = 900;

1885
      if(infoPtr->dwStyle & TCS_BOTTOM)
1886 1887 1888 1889 1890
      {
        nEscapement = -900;
        nOrientation = -900;
      }

1891
      /* to get a font with the escapement and orientation we are looking for, we need to */
1892
      /* call CreateFontIndirect, which requires us to set the values of the logfont we pass in */
1893 1894
      if (!GetObjectW(infoPtr->hFont, sizeof(logfont), &logfont))
        GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(logfont), &logfont);
1895 1896 1897

      logfont.lfEscapement = nEscapement;
      logfont.lfOrientation = nOrientation;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
1898
      hFont = CreateFontIndirectW(&logfont);
1899
      SelectObject(hdc, hFont);
1900

1901
      if (item->pszText)
1902 1903
      {
        ExtTextOutW(hdc,
1904 1905
        (infoPtr->dwStyle & TCS_BOTTOM) ? drawRect->right : drawRect->left,
        (!(infoPtr->dwStyle & TCS_BOTTOM)) ? drawRect->bottom : drawRect->top,
1906 1907
        ETO_CLIPPED,
        drawRect,
1908 1909
        item->pszText,
        lstrlenW(item->pszText),
1910 1911
        0);
      }
1912 1913

      DeleteObject(hFont);
1914 1915 1916
    }
    else
    {
1917
      TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%s), textlen=%d\n",
1918
	  debugstr_w(item->pszText), center_offset_h, center_offset_v,
1919
          wine_dbgstr_rect(drawRect), (rcText.right-rcText.left));
1920
      if (item->pszText)
1921 1922 1923 1924
      {
        DrawTextW
        (
          hdc,
1925 1926
          item->pszText,
          lstrlenW(item->pszText),
1927 1928
          drawRect,
          DT_LEFT | DT_SINGLELINE
1929
        );
1930
      }
1931
    }
1932 1933

    *drawRect = rcTemp; /* restore drawRect */
1934 1935 1936 1937 1938
  }

  /*
  * Cleanup
  */
1939
  SelectObject(hdc, hOldFont);
1940 1941
  SetBkMode(hdc, oldBkMode);
  SelectObject(hdc, holdPen);
1942
  DeleteObject( htextPen );
1943 1944
}

Francis Beaudet's avatar
Francis Beaudet committed
1945 1946 1947 1948
/******************************************************************************
 * TAB_DrawItem
 *
 * This method is used to draw a single tab into the tab control.
1949
 */
1950
static void TAB_DrawItem(const TAB_INFO *infoPtr, HDC  hdc, INT  iItem)
Francis Beaudet's avatar
Francis Beaudet committed
1951 1952 1953 1954
{
  RECT      itemRect;
  RECT      selectedRect;
  BOOL      isVisible;
1955 1956 1957 1958
  RECT      r, fillRect, r1;
  INT       clRight = 0;
  INT       clBottom = 0;
  COLORREF  bkgnd, corner;
1959
  HTHEME    theme;
Francis Beaudet's avatar
Francis Beaudet committed
1960 1961 1962 1963

  /*
   * Get the rectangle for the item.
   */
1964
  isVisible = TAB_InternalGetItemRect(infoPtr,
Francis Beaudet's avatar
Francis Beaudet committed
1965 1966 1967 1968 1969 1970
				      iItem,
				      &itemRect,
				      &selectedRect);

  if (isVisible)
  {
1971 1972 1973
    RECT rUD, rC;

    /* Clip UpDown control to not draw over it */
1974 1975
    if (infoPtr->needsScrolling)
    {
1976
      GetWindowRect(infoPtr->hwnd, &rC);
1977 1978 1979
      GetWindowRect(infoPtr->hwndUpDown, &rUD);
      ExcludeClipRect(hdc, rUD.left - rC.left, rUD.top - rC.top, rUD.right - rC.left, rUD.bottom - rC.top);
    }
1980

1981 1982
    /* If you need to see what the control is doing,
     * then override these variables. They will change what
1983
     * fill colors are used for filling the tabs, and the
1984 1985 1986 1987
     * corners when drawing the edge.
     */
    bkgnd = comctl32_color.clrBtnFace;
    corner = comctl32_color.clrBtnFace;
Francis Beaudet's avatar
Francis Beaudet committed
1988

1989
    if (infoPtr->dwStyle & TCS_BUTTONS)
Francis Beaudet's avatar
Francis Beaudet committed
1990
    {
1991
      /* Get item rectangle */
1992 1993
      r = itemRect;

1994
      /* Separators between flat buttons */
1995
      if ((infoPtr->dwStyle & TCS_FLATBUTTONS) && (infoPtr->exStyle & TCS_EX_FLATSEPARATORS))
1996
      {
1997 1998 1999
	r1 = r;
	r1.right += (FLAT_BTN_SPACINGX -2);
	DrawEdge(hdc, &r1, EDGE_ETCHED, BF_RIGHT);
2000 2001
      }

2002 2003
      if (iItem == infoPtr->iSelected)
      {
2004
	DrawEdge(hdc, &r, EDGE_SUNKEN, BF_SOFT|BF_RECT);
2005 2006
	
	OffsetRect(&r, 1, 1);
2007
      }
2008
      else  /* ! selected */
2009
      {
2010
        DWORD state = TAB_GetItem(infoPtr, iItem)->dwState;
2011

2012
        if ((state & TCIS_BUTTONPRESSED) || (iItem == infoPtr->uFocus))
2013 2014
          DrawEdge(hdc, &r, EDGE_SUNKEN, BF_SOFT|BF_RECT);
        else
2015
          if (!(infoPtr->dwStyle & TCS_FLATBUTTONS))
2016
            DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_RECT);
2017
      }
Francis Beaudet's avatar
Francis Beaudet committed
2018
    }
2019
    else /* !TCS_BUTTONS */
Francis Beaudet's avatar
Francis Beaudet committed
2020
    {
2021 2022
      /* We draw a rectangle of different sizes depending on the selection
       * state. */
2023 2024
      if (iItem == infoPtr->iSelected) {
	RECT rect;
2025
	GetClientRect (infoPtr->hwnd, &rect);
2026 2027
	clRight = rect.right;
	clBottom = rect.bottom;
2028
        r = selectedRect;
2029
      }
2030 2031
      else
        r = itemRect;
Francis Beaudet's avatar
Francis Beaudet committed
2032

2033
      /*
2034
       * Erase the background. (Delay it but setup rectangle.)
2035 2036
       * This is necessary when drawing the selected item since it is larger
       * than the others, it might overlap with stuff already drawn by the
2037
       * other tabs
2038
       */
2039
      fillRect = r;
2040

2041 2042 2043 2044 2045
      /* Draw themed tabs - but only if they are at the top.
       * Windows draws even side or bottom tabs themed, with wacky results.
       * However, since in Wine apps may get themed that did not opt in via
       * a manifest avoid theming when we know the result will be wrong */
      if ((theme = GetWindowTheme (infoPtr->hwnd)) 
2046
          && ((infoPtr->dwStyle & (TCS_VERTICAL | TCS_BOTTOM)) == 0))
2047
      {
2048
          static const int partIds[8] = {
2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
              /* Normal item */
              TABP_TABITEM,
              TABP_TABITEMLEFTEDGE,
              TABP_TABITEMRIGHTEDGE,
              TABP_TABITEMBOTHEDGE,
              /* Selected tab */
              TABP_TOPTABITEM,
              TABP_TOPTABITEMLEFTEDGE,
              TABP_TOPTABITEMRIGHTEDGE,
              TABP_TOPTABITEMBOTHEDGE,
          };
          int partIndex = 0;
          int stateId = TIS_NORMAL;

          /* selected and unselected tabs have different parts */
          if (iItem == infoPtr->iSelected)
              partIndex += 4;
          /* The part also differs on the position of a tab on a line.
           * "Visually" determining the position works well enough. */
2068
          GetClientRect(infoPtr->hwnd, &r1);
2069 2070
          if(selectedRect.left == 0)
              partIndex += 1;
2071
          if(selectedRect.right == r1.right)
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
              partIndex += 2;

          if (iItem == infoPtr->iSelected)
              stateId = TIS_SELECTED;
          else if (iItem == infoPtr->iHotTracked)
              stateId = TIS_HOT;
          else if (iItem == infoPtr->uFocus)
              stateId = TIS_FOCUSED;

          /* Adjust rectangle for bottommost row */
          if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
            r.bottom += 3;

          DrawThemeBackground (theme, hdc, partIds[partIndex], stateId, &r, NULL);
          GetThemeBackgroundContentRect (theme, hdc, partIds[partIndex], stateId, &r, &r);
      }
2088
      else if(infoPtr->dwStyle & TCS_VERTICAL)
2089
      {
2090 2091
	/* These are for adjusting the drawing of a Selected tab      */
	/* The initial values are for the normal case of non-Selected */
2092
	int ZZ = 1;   /* Do not stretch if selected */
2093 2094 2095 2096 2097
	if (iItem == infoPtr->iSelected) {
	    ZZ = 0;

	    /* if leftmost draw the line longer */
	    if(selectedRect.top == 0)
2098
		fillRect.top += CONTROL_BORDER_SIZEY;
2099 2100
	    /* if rightmost draw the line longer */
	    if(selectedRect.bottom == clBottom)
2101
		fillRect.bottom -= CONTROL_BORDER_SIZEY;
2102 2103
	}

2104
        if (infoPtr->dwStyle & TCS_BOTTOM)
2105
        {
2106 2107 2108
	  /* Adjust both rectangles to match native */
	  r.left += (1-ZZ);

2109 2110
          TRACE("<right> item=%d, fill=(%s), edge=(%s)\n",
                iItem, wine_dbgstr_rect(&fillRect), wine_dbgstr_rect(&r));
2111 2112 2113

	  /* Clear interior */
	  SetBkColor(hdc, bkgnd);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2114
	  ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2115 2116 2117 2118

	  /* Draw rectangular edge around tab */
	  DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_RIGHT|BF_TOP|BF_BOTTOM);

2119
	  /* Now erase the top corner and draw diagonal edge */
2120 2121 2122 2123 2124
	  SetBkColor(hdc, corner);
	  r1.left = r.right - ROUND_CORNER_SIZE - 1;
	  r1.top = r.top;
	  r1.right = r.right;
	  r1.bottom = r1.top + ROUND_CORNER_SIZE;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2125
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2126 2127 2128
	  r1.right--;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);

2129
	  /* Now erase the bottom corner and draw diagonal edge */
2130 2131 2132 2133
	  r1.left = r.right - ROUND_CORNER_SIZE - 1;
	  r1.bottom = r.bottom;
	  r1.right = r.right;
	  r1.top = r1.bottom - ROUND_CORNER_SIZE;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2134
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
	  r1.right--;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMLEFT);

	  if ((iItem == infoPtr->iSelected) && (selectedRect.top == 0)) {
	      r1 = r;
	      r1.right = r1.left;
	      r1.left--;
	      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_TOP);
	  }

2145 2146 2147
        }
        else
        {
2148 2149
          TRACE("<left> item=%d, fill=(%s), edge=(%s)\n",
                iItem, wine_dbgstr_rect(&fillRect), wine_dbgstr_rect(&r));
2150 2151 2152

	  /* Clear interior */
	  SetBkColor(hdc, bkgnd);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2153
	  ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2154 2155 2156 2157

	  /* Draw rectangular edge around tab */
	  DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_TOP|BF_BOTTOM);

2158
	  /* Now erase the top corner and draw diagonal edge */
2159 2160 2161 2162 2163
	  SetBkColor(hdc, corner);
	  r1.left = r.left;
	  r1.top = r.top;
	  r1.right = r1.left + ROUND_CORNER_SIZE + 1;
	  r1.bottom = r1.top + ROUND_CORNER_SIZE;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2164
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2165 2166 2167
	  r1.left++;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);

2168
	  /* Now erase the bottom corner and draw diagonal edge */
2169 2170 2171 2172
	  r1.left = r.left;
	  r1.bottom = r.bottom;
	  r1.right = r1.left + ROUND_CORNER_SIZE + 1;
	  r1.top = r1.bottom - ROUND_CORNER_SIZE;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2173
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2174 2175
	  r1.left++;
	  DrawEdge(hdc, &r1, EDGE_SUNKEN, BF_DIAGONAL_ENDTOPLEFT);
2176
        }
2177
      }
2178
      else  /* ! TCS_VERTICAL */
2179
      {
2180 2181 2182 2183 2184
	/* These are for adjusting the drawing of a Selected tab      */
	/* The initial values are for the normal case of non-Selected */
	if (iItem == infoPtr->iSelected) {
	    /* if leftmost draw the line longer */
	    if(selectedRect.left == 0)
2185
		fillRect.left += CONTROL_BORDER_SIZEX;
2186 2187
	    /* if rightmost draw the line longer */
	    if(selectedRect.right == clRight)
2188
		fillRect.right -= CONTROL_BORDER_SIZEX;
2189 2190
	}

2191
        if (infoPtr->dwStyle & TCS_BOTTOM)
2192
        {
2193
	  /* Adjust both rectangles for topmost row */
2194
	  if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
2195 2196 2197 2198
	  {
	    fillRect.top -= 2;
	    r.top -= 1;
	  }
2199

2200 2201
          TRACE("<bottom> item=%d, fill=(%s), edge=(%s)\n",
                iItem, wine_dbgstr_rect(&fillRect), wine_dbgstr_rect(&r));
2202 2203 2204

	  /* Clear interior */
	  SetBkColor(hdc, bkgnd);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2205
	  ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2206 2207 2208 2209

	  /* Draw rectangular edge around tab */
	  DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_BOTTOM|BF_RIGHT);

2210
	  /* Now erase the righthand corner and draw diagonal edge */
2211 2212 2213 2214 2215
	  SetBkColor(hdc, corner);
	  r1.left = r.right - ROUND_CORNER_SIZE;
	  r1.bottom = r.bottom;
	  r1.right = r.right;
	  r1.top = r1.bottom - ROUND_CORNER_SIZE - 1;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2216
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2217 2218 2219
	  r1.bottom--;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMLEFT);

2220
	  /* Now erase the lefthand corner and draw diagonal edge */
2221 2222 2223 2224
	  r1.left = r.left;
	  r1.bottom = r.bottom;
	  r1.right = r1.left + ROUND_CORNER_SIZE;
	  r1.top = r1.bottom - ROUND_CORNER_SIZE - 1;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2225
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2226 2227 2228
	  r1.bottom--;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);

2229 2230 2231 2232 2233 2234
	  if (iItem == infoPtr->iSelected)
	  {
	    r.top += 2;
	    r.left += 1;
	    if (selectedRect.left == 0)
	    {
2235 2236 2237 2238
	      r1 = r;
	      r1.bottom = r1.top;
	      r1.top--;
	      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_LEFT);
2239
	    }
2240 2241
	  }

2242 2243 2244
        }
        else
        {
2245
	  /* Adjust both rectangles for bottommost row */
2246
	  if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
2247 2248 2249 2250
	  {
	    fillRect.bottom += 3;
	    r.bottom += 2;
	  }
2251

2252 2253
          TRACE("<top> item=%d, fill=(%s), edge=(%s)\n",
                iItem, wine_dbgstr_rect(&fillRect), wine_dbgstr_rect(&r));
2254 2255 2256

	  /* Clear interior */
	  SetBkColor(hdc, bkgnd);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2257
	  ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);
2258 2259 2260 2261

	  /* Draw rectangular edge around tab */
	  DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_LEFT|BF_TOP|BF_RIGHT);

2262
	  /* Now erase the righthand corner and draw diagonal edge */
2263 2264 2265 2266 2267
	  SetBkColor(hdc, corner);
	  r1.left = r.right - ROUND_CORNER_SIZE;
	  r1.top = r.top;
	  r1.right = r.right;
	  r1.bottom = r1.top + ROUND_CORNER_SIZE + 1;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2268
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2269 2270 2271
	  r1.top++;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMRIGHT);

2272
	  /* Now erase the lefthand corner and draw diagonal edge */
2273 2274 2275 2276
	  r1.left = r.left;
	  r1.top = r.top;
	  r1.right = r1.left + ROUND_CORNER_SIZE;
	  r1.bottom = r1.top + ROUND_CORNER_SIZE + 1;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2277
	  ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
2278 2279
	  r1.top++;
	  DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);
2280
        }
2281 2282
      }
    }
2283

2284 2285
    TAB_DumpItemInternal(infoPtr, iItem);

2286
    /* This modifies r to be the text rectangle. */
2287
    TAB_DrawItemInterior(infoPtr, hdc, iItem, &r);
Francis Beaudet's avatar
Francis Beaudet committed
2288
  }
Alexandre Julliard's avatar
Alexandre Julliard committed
2289 2290
}

Francis Beaudet's avatar
Francis Beaudet committed
2291 2292 2293 2294 2295
/******************************************************************************
 * TAB_DrawBorder
 *
 * This method is used to draw the raised border around the tab control
 * "content" area.
2296
 */
2297
static void TAB_DrawBorder(const TAB_INFO *infoPtr, HDC hdc)
Alexandre Julliard's avatar
Alexandre Julliard committed
2298
{
Francis Beaudet's avatar
Francis Beaudet committed
2299
  RECT rect;
2300
  HTHEME theme = GetWindowTheme (infoPtr->hwnd);
Alexandre Julliard's avatar
Alexandre Julliard committed
2301

2302
  GetClientRect (infoPtr->hwnd, &rect);
Alexandre Julliard's avatar
Alexandre Julliard committed
2303

Francis Beaudet's avatar
Francis Beaudet committed
2304 2305 2306
  /*
   * Adjust for the style
   */
Gerard Patel's avatar
Gerard Patel committed
2307 2308

  if (infoPtr->uNumItem)
Francis Beaudet's avatar
Francis Beaudet committed
2309
  {
2310
    if ((infoPtr->dwStyle & TCS_BOTTOM) && !(infoPtr->dwStyle & TCS_VERTICAL))
2311
      rect.bottom -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2312
    else if((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
2313
      rect.right  -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
2314
    else if(infoPtr->dwStyle & TCS_VERTICAL)
2315
      rect.left   += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
Gerard Patel's avatar
Gerard Patel committed
2316
    else /* not TCS_VERTICAL and not TCS_BOTTOM */
2317
      rect.top    += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
Francis Beaudet's avatar
Francis Beaudet committed
2318
  }
Alexandre Julliard's avatar
Alexandre Julliard committed
2319

2320
  TRACE("border=(%s)\n", wine_dbgstr_rect(&rect));
2321

2322 2323 2324 2325
  if (theme)
      DrawThemeBackground (theme, hdc, TABP_PANE, 0, &rect, NULL);
  else
      DrawEdge(hdc, &rect, EDGE_RAISED, BF_SOFT|BF_RECT);
Alexandre Julliard's avatar
Alexandre Julliard committed
2326 2327
}

Francis Beaudet's avatar
Francis Beaudet committed
2328 2329 2330 2331
/******************************************************************************
 * TAB_Refresh
 *
 * This method repaints the tab control..
2332
 */
2333
static void TAB_Refresh (const TAB_INFO *infoPtr, HDC hdc)
Alexandre Julliard's avatar
Alexandre Julliard committed
2334
{
Francis Beaudet's avatar
Francis Beaudet committed
2335 2336
  HFONT hOldFont;
  INT i;
Alexandre Julliard's avatar
Alexandre Julliard committed
2337

Francis Beaudet's avatar
Francis Beaudet committed
2338 2339
  if (!infoPtr->DoRedraw)
    return;
Alex Priem's avatar
Alex Priem committed
2340

Francis Beaudet's avatar
Francis Beaudet committed
2341
  hOldFont = SelectObject (hdc, infoPtr->hFont);
Alexandre Julliard's avatar
Alexandre Julliard committed
2342

2343
  if (infoPtr->dwStyle & TCS_BUTTONS)
Francis Beaudet's avatar
Francis Beaudet committed
2344
  {
2345
    for (i = 0; i < infoPtr->uNumItem; i++)
2346
      TAB_DrawItem (infoPtr, hdc, i);
Francis Beaudet's avatar
Francis Beaudet committed
2347
  }
2348 2349
  else
  {
2350
    /* Draw all the non selected item first */
2351
    for (i = 0; i < infoPtr->uNumItem; i++)
2352 2353
    {
      if (i != infoPtr->iSelected)
2354
	TAB_DrawItem (infoPtr, hdc, i);
2355
    }
Francis Beaudet's avatar
Francis Beaudet committed
2356

2357 2358
    /* Now, draw the border, draw it before the selected item
     * since the selected item overwrites part of the border. */
2359
    TAB_DrawBorder (infoPtr, hdc);
Francis Beaudet's avatar
Francis Beaudet committed
2360

2361
    /* Then, draw the selected item */
2362
    TAB_DrawItem (infoPtr, hdc, infoPtr->iSelected);
2363
  }
Francis Beaudet's avatar
Francis Beaudet committed
2364 2365

  SelectObject (hdc, hOldFont);
Alexandre Julliard's avatar
Alexandre Julliard committed
2366 2367
}

2368
static inline DWORD TAB_GetRowCount (const TAB_INFO *infoPtr)
2369
{
2370
  TRACE("(%p)\n", infoPtr);
2371 2372 2373
  return infoPtr->uNumRows;
}

2374
static inline LRESULT TAB_SetRedraw (TAB_INFO *infoPtr, BOOL doRedraw)
Alex Priem's avatar
Alex Priem committed
2375
{
2376
  infoPtr->DoRedraw = doRedraw;
Francis Beaudet's avatar
Francis Beaudet committed
2377
  return 0;
Alex Priem's avatar
Alex Priem committed
2378 2379
}

Francis Beaudet's avatar
Francis Beaudet committed
2380 2381 2382 2383 2384 2385 2386 2387
/******************************************************************************
 * TAB_EnsureSelectionVisible
 *
 * This method will make sure that the current selection is completely
 * visible by scrolling until it is.
 */
static void TAB_EnsureSelectionVisible(
  TAB_INFO* infoPtr)
Alexandre Julliard's avatar
Alexandre Julliard committed
2388
{
Alexandre Julliard's avatar
Alexandre Julliard committed
2389
  INT iSelected = infoPtr->iSelected;
2390 2391
  INT iOrigLeftmostVisible = infoPtr->leftmostVisible;

2392 2393 2394
  if (iSelected < 0)
    return;

2395 2396
  /* set the items row to the bottommost row or topmost row depending on
   * style */
2397
  if ((infoPtr->uNumRows > 1) && !(infoPtr->dwStyle & TCS_BUTTONS))
2398
  {
2399
      TAB_ITEM *selected = TAB_GetItem(infoPtr, iSelected);
2400
      INT newselected;
2401 2402
      INT iTargetRow;

2403
      if(infoPtr->dwStyle & TCS_VERTICAL)
2404
        newselected = selected->rect.left;
2405
      else
2406
        newselected = selected->rect.top;
2407

Gerard Patel's avatar
Gerard Patel committed
2408 2409 2410
      /* the target row is always (number of rows - 1)
         as row 0 is furthest from the clientRect */
      iTargetRow = infoPtr->uNumRows - 1;
2411 2412 2413

      if (newselected != iTargetRow)
      {
2414
         UINT i;
2415
         if(infoPtr->dwStyle & TCS_VERTICAL)
2416 2417 2418 2419
         {
           for (i=0; i < infoPtr->uNumItem; i++)
           {
             /* move everything in the row of the selected item to the iTargetRow */
2420 2421 2422 2423
             TAB_ITEM *item = TAB_GetItem(infoPtr, i);

             if (item->rect.left == newselected )
                 item->rect.left = iTargetRow;
2424 2425
             else
             {
2426 2427
               if (item->rect.left > newselected)
                 item->rect.left-=1;
2428 2429 2430 2431 2432 2433 2434
             }
           }
         }
         else
         {
           for (i=0; i < infoPtr->uNumItem; i++)
           {
2435 2436 2437 2438
             TAB_ITEM *item = TAB_GetItem(infoPtr, i);

             if (item->rect.top == newselected )
                 item->rect.top = iTargetRow;
2439 2440
             else
             {
2441 2442
               if (item->rect.top > newselected)
                 item->rect.top-=1;
2443 2444 2445
             }
          }
        }
2446
        TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
2447 2448 2449
      }
  }

Francis Beaudet's avatar
Francis Beaudet committed
2450 2451 2452 2453
  /*
   * Do the trivial cases first.
   */
  if ( (!infoPtr->needsScrolling) ||
2454
       (infoPtr->hwndUpDown==0) || (infoPtr->dwStyle & TCS_VERTICAL))
Francis Beaudet's avatar
Francis Beaudet committed
2455 2456
    return;

Alexandre Julliard's avatar
Alexandre Julliard committed
2457
  if (infoPtr->leftmostVisible >= iSelected)
Francis Beaudet's avatar
Francis Beaudet committed
2458
  {
2459
    infoPtr->leftmostVisible = iSelected;
Francis Beaudet's avatar
Francis Beaudet committed
2460
  }
Alexandre Julliard's avatar
Alexandre Julliard committed
2461
  else
Francis Beaudet's avatar
Francis Beaudet committed
2462
  {
2463
     TAB_ITEM *selected = TAB_GetItem(infoPtr, iSelected);
Alexandre Julliard's avatar
Alexandre Julliard committed
2464
     RECT r;
2465 2466
     INT width;
     UINT i;
2467 2468

     /* Calculate the part of the client area that is visible */
2469
     GetClientRect(infoPtr->hwnd, &r);
Alexandre Julliard's avatar
Alexandre Julliard committed
2470 2471 2472 2473 2474
     width = r.right;

     GetClientRect(infoPtr->hwndUpDown, &r);
     width -= r.right;

2475 2476
     if ((selected->rect.right -
          selected->rect.left) >= width )
Alexandre Julliard's avatar
Alexandre Julliard committed
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
     {
        /* Special case: width of selected item is greater than visible
         * part of control.
         */
        infoPtr->leftmostVisible = iSelected;
     }
     else
     {
        for (i = infoPtr->leftmostVisible; i < infoPtr->uNumItem; i++)
        {
2487
           if ((selected->rect.right - TAB_GetItem(infoPtr, i)->rect.left) < width)
Alexandre Julliard's avatar
Alexandre Julliard committed
2488 2489 2490 2491
              break;
        }
        infoPtr->leftmostVisible = i;
     }
Francis Beaudet's avatar
Francis Beaudet committed
2492
  }
Alexandre Julliard's avatar
Alexandre Julliard committed
2493

2494
  if (infoPtr->leftmostVisible != iOrigLeftmostVisible)
2495
    TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
2496

2497
  SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
Alexandre Julliard's avatar
Alexandre Julliard committed
2498
               MAKELONG(infoPtr->leftmostVisible, 0));
Francis Beaudet's avatar
Francis Beaudet committed
2499
}
Alexandre Julliard's avatar
Alexandre Julliard committed
2500

Francis Beaudet's avatar
Francis Beaudet committed
2501 2502 2503 2504 2505 2506 2507
/******************************************************************************
 * TAB_InvalidateTabArea
 *
 * This method will invalidate the portion of the control that contains the
 * tabs. It is called when the state of the control changes and needs
 * to be redisplayed
 */
2508
static void TAB_InvalidateTabArea(const TAB_INFO *infoPtr)
Francis Beaudet's avatar
Francis Beaudet committed
2509
{
2510
  RECT clientRect, rInvalidate, rAdjClient;
Gerard Patel's avatar
Gerard Patel committed
2511
  INT lastRow = infoPtr->uNumRows - 1;
2512
  RECT rect;
Gerard Patel's avatar
Gerard Patel committed
2513 2514

  if (lastRow < 0) return;
Alexandre Julliard's avatar
Alexandre Julliard committed
2515

2516
  GetClientRect(infoPtr->hwnd, &clientRect);
2517
  rInvalidate = clientRect;
2518 2519
  rAdjClient = clientRect;

2520
  TAB_AdjustRect(infoPtr, 0, &rAdjClient);
Alexandre Julliard's avatar
Alexandre Julliard committed
2521

2522
  TAB_InternalGetItemRect(infoPtr, infoPtr->uNumItem-1 , &rect, NULL);
2523
  if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
2524
  {
2525 2526 2527
    rInvalidate.left = rAdjClient.right;
    if (infoPtr->uNumRows == 1)
      rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
2528
  }
2529
  else if(infoPtr->dwStyle & TCS_VERTICAL)
2530
  {
2531 2532 2533
    rInvalidate.right = rAdjClient.left;
    if (infoPtr->uNumRows == 1)
      rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
2534
  }
2535
  else if (infoPtr->dwStyle & TCS_BOTTOM)
Francis Beaudet's avatar
Francis Beaudet committed
2536
  {
2537 2538 2539
    rInvalidate.top = rAdjClient.bottom;
    if (infoPtr->uNumRows == 1)
      rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
Francis Beaudet's avatar
Francis Beaudet committed
2540
  }
2541
  else 
Francis Beaudet's avatar
Francis Beaudet committed
2542
  {
2543 2544 2545
    rInvalidate.bottom = rAdjClient.top;
    if (infoPtr->uNumRows == 1)
      rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
Francis Beaudet's avatar
Francis Beaudet committed
2546
  }
2547 2548
  
  /* Punch out the updown control */
2549 2550
  if (infoPtr->needsScrolling && (rInvalidate.right > 0)) {
    RECT r;
2551
    GetClientRect(infoPtr->hwndUpDown, &r);
2552 2553 2554 2555
    if (rInvalidate.right > clientRect.right - r.left)
      rInvalidate.right = rInvalidate.right - (r.right - r.left);
    else
      rInvalidate.right = clientRect.right - r.left;
2556
  }
2557 2558 2559

  TRACE("invalidate (%s)\n", wine_dbgstr_rect(&rInvalidate));

2560
  InvalidateRect(infoPtr->hwnd, &rInvalidate, TRUE);
Francis Beaudet's avatar
Francis Beaudet committed
2561
}
Alexandre Julliard's avatar
Alexandre Julliard committed
2562

2563
static inline LRESULT TAB_Paint (TAB_INFO *infoPtr, HDC hdcPaint)
Francis Beaudet's avatar
Francis Beaudet committed
2564 2565 2566
{
  HDC hdc;
  PAINTSTRUCT ps;
2567

2568 2569 2570
  if (hdcPaint)
    hdc = hdcPaint;
  else
2571
  {
2572
    hdc = BeginPaint (infoPtr->hwnd, &ps);
2573
    TRACE("erase %d, rect=(%s)\n", ps.fErase, wine_dbgstr_rect(&ps.rcPaint));
2574
  }
2575

2576 2577 2578 2579
  TAB_Refresh (infoPtr, hdc);

  if (!hdcPaint)
    EndPaint (infoPtr->hwnd, &ps);
Alexandre Julliard's avatar
Alexandre Julliard committed
2580

Francis Beaudet's avatar
Francis Beaudet committed
2581 2582
  return 0;
}
Alexandre Julliard's avatar
Alexandre Julliard committed
2583

Francis Beaudet's avatar
Francis Beaudet committed
2584
static LRESULT
2585
TAB_InsertItemT (TAB_INFO *infoPtr, INT iItem, const TCITEMW *pti, BOOL bUnicode)
2586
{
2587
  TAB_ITEM *item;
Francis Beaudet's avatar
Francis Beaudet committed
2588
  RECT rect;
2589

2590
  GetClientRect (infoPtr->hwnd, &rect);
2591
  TRACE("Rect: %p %s\n", infoPtr->hwnd, wine_dbgstr_rect(&rect));
2592

Francis Beaudet's avatar
Francis Beaudet committed
2593 2594 2595
  if (iItem < 0) return -1;
  if (iItem > infoPtr->uNumItem)
    iItem = infoPtr->uNumItem;
2596

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2597
  TAB_DumpItemExternalT(pti, iItem, bUnicode);
2598

2599
  if (!(item = Alloc(TAB_ITEM_SIZE(infoPtr)))) return FALSE;
2600 2601 2602 2603
  if (DPA_InsertPtr(infoPtr->items, iItem, item) == -1)
  {
      Free(item);
      return FALSE;
Francis Beaudet's avatar
Francis Beaudet committed
2604
  }
2605

2606 2607 2608
  if (infoPtr->uNumItem == 0)
      infoPtr->iSelected = 0;
  else if (iItem <= infoPtr->iSelected)
2609 2610
      infoPtr->iSelected++;

2611
  infoPtr->uNumItem++;
2612

2613
  item->pszText = NULL;
2614
  if (pti->mask & TCIF_TEXT)
2615 2616
  {
    if (bUnicode)
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2617
      Str_SetPtrW (&item->pszText, pti->pszText);
2618
    else
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2619
      Str_SetPtrAtoW (&item->pszText, (LPSTR)pti->pszText);
2620
  }
2621

Francis Beaudet's avatar
Francis Beaudet committed
2622
  if (pti->mask & TCIF_IMAGE)
2623 2624 2625
    item->iImage = pti->iImage;
  else
    item->iImage = -1;
2626

Francis Beaudet's avatar
Francis Beaudet committed
2627
  if (pti->mask & TCIF_PARAM)
2628
    memcpy(item->extra, &pti->lParam, EXTRA_ITEM_SIZE(infoPtr));
2629
  else
2630 2631
    memset(item->extra, 0, EXTRA_ITEM_SIZE(infoPtr));

2632
  TAB_SetItemBounds(infoPtr);
2633
  if (infoPtr->uNumItem > 1)
2634
    TAB_InvalidateTabArea(infoPtr);
2635
  else
2636
    InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2637

2638
  TRACE("[%p]: added item %d %s\n",
2639
        infoPtr->hwnd, iItem, debugstr_w(item->pszText));
Alexandre Julliard's avatar
Alexandre Julliard committed
2640

2641 2642 2643 2644
  /* If we haven't set the current focus yet, set it now. */
  if (infoPtr->uFocus == -1)
    TAB_SetCurFocus(infoPtr, iItem);

Francis Beaudet's avatar
Francis Beaudet committed
2645
  return iItem;
Alexandre Julliard's avatar
Alexandre Julliard committed
2646 2647
}

2648
static LRESULT
2649
TAB_SetItemSize (TAB_INFO *infoPtr, INT cx, INT cy)
2650 2651
{
  LONG lResult = 0;
2652
  BOOL bNeedPaint = FALSE;
2653

2654 2655 2656
  lResult = MAKELONG(infoPtr->tabWidth, infoPtr->tabHeight);

  /* UNDOCUMENTED: If requested Width or Height is 0 this means that program wants to use auto size. */
2657
  if (infoPtr->dwStyle & TCS_FIXEDWIDTH && (infoPtr->tabWidth != cx))
2658
  {
2659
    infoPtr->tabWidth = cx;
2660
    bNeedPaint = TRUE;
2661 2662
  }

2663
  if (infoPtr->tabHeight != cy)
2664
  {
2665 2666
    if ((infoPtr->fHeightSet = (cy != 0)))
      infoPtr->tabHeight = cy;
2667 2668 2669 2670 2671 2672 2673 2674

    bNeedPaint = TRUE;
  }
  TRACE("was h=%d,w=%d, now h=%d,w=%d\n",
       HIWORD(lResult), LOWORD(lResult),
       infoPtr->tabHeight, infoPtr->tabWidth);

  if (bNeedPaint)
2675
  {
2676 2677
    TAB_SetItemBounds(infoPtr);
    RedrawWindow(infoPtr->hwnd, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW);
2678
  }
2679

2680 2681 2682
  return lResult;
}

2683
static inline LRESULT TAB_SetMinTabWidth (TAB_INFO *infoPtr, INT cx)
2684
{
2685 2686 2687
  INT oldcx = 0;

  TRACE("(%p,%d)\n", infoPtr, cx);
2688

2689 2690 2691 2692
  if (infoPtr->tabMinWidth < 0)
    oldcx = DEFAULT_MIN_TAB_WIDTH;
  else
    oldcx = infoPtr->tabMinWidth;
2693
  infoPtr->tabMinWidth = cx;
2694
  TAB_SetItemBounds(infoPtr);
2695 2696 2697
  return oldcx;
}

2698 2699
static inline LRESULT 
TAB_HighlightItem (TAB_INFO *infoPtr, INT iItem, BOOL fHighlight)
2700
{
2701
  LPDWORD lpState;
2702 2703
  DWORD oldState;
  RECT r;
2704

2705 2706
  TRACE("(%p,%d,%s)\n", infoPtr, iItem, fHighlight ? "true" : "false");

2707
  if (iItem < 0 || iItem >= infoPtr->uNumItem)
2708
    return FALSE;
2709

2710
  lpState = &TAB_GetItem(infoPtr, iItem)->dwState;
2711
  oldState = *lpState;
2712 2713 2714 2715 2716

  if (fHighlight)
    *lpState |= TCIS_HIGHLIGHTED;
  else
    *lpState &= ~TCIS_HIGHLIGHTED;
2717

2718 2719 2720
  if ((oldState != *lpState) && TAB_InternalGetItemRect (infoPtr, iItem, &r, NULL))
    InvalidateRect (infoPtr->hwnd, &r, TRUE);

2721 2722 2723
  return TRUE;
}

2724
static LRESULT
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2725
TAB_SetItemT (TAB_INFO *infoPtr, INT iItem, LPTCITEMW tabItem, BOOL bUnicode)
2726
{
2727
  TAB_ITEM *wineItem;
2728

2729
  TRACE("(%p,%d,%p,%s)\n", infoPtr, iItem, tabItem, bUnicode ? "true" : "false");
2730

2731 2732
  if (iItem < 0 || iItem >= infoPtr->uNumItem)
    return FALSE;
2733

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2734
  TAB_DumpItemExternalT(tabItem, iItem, bUnicode);
2735

2736
  wineItem = TAB_GetItem(infoPtr, iItem);
2737

2738
  if (tabItem->mask & TCIF_IMAGE)
2739
    wineItem->iImage = tabItem->iImage;
2740

2741
  if (tabItem->mask & TCIF_PARAM)
2742
    memcpy(wineItem->extra, &tabItem->lParam, infoPtr->cbInfo);
2743

2744
  if (tabItem->mask & TCIF_RTLREADING)
2745
    FIXME("TCIF_RTLREADING\n");
2746

2747
  if (tabItem->mask & TCIF_STATE)
2748 2749
    wineItem->dwState = (wineItem->dwState & ~tabItem->dwStateMask) |
                        ( tabItem->dwState &  tabItem->dwStateMask);
2750

2751
  if (tabItem->mask & TCIF_TEXT)
2752
  {
2753 2754
    Free(wineItem->pszText);
    wineItem->pszText = NULL;
2755
    if (bUnicode)
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2756
      Str_SetPtrW(&wineItem->pszText, tabItem->pszText);
2757
    else
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2758
      Str_SetPtrAtoW(&wineItem->pszText, (LPSTR)tabItem->pszText);
2759 2760
  }

2761
  /* Update and repaint tabs */
2762 2763
  TAB_SetItemBounds(infoPtr);
  TAB_InvalidateTabArea(infoPtr);
2764

Francis Beaudet's avatar
Francis Beaudet committed
2765
  return TRUE;
2766 2767
}

2768
static inline LRESULT TAB_GetItemCount (const TAB_INFO *infoPtr)
2769
{
2770 2771
  TRACE("\n");
  return infoPtr->uNumItem;
2772 2773 2774
}


2775
static LRESULT
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2776
TAB_GetItemT (TAB_INFO *infoPtr, INT iItem, LPTCITEMW tabItem, BOOL bUnicode)
2777
{
2778
  TAB_ITEM *wineItem;
2779

2780 2781
  TRACE("(%p,%d,%p,%s)\n", infoPtr, iItem, tabItem, bUnicode ? "true" : "false");

2782 2783
  if (!tabItem) return FALSE;

2784
  if (iItem < 0 || iItem >= infoPtr->uNumItem)
2785 2786 2787 2788 2789
  {
    /* init requested fields */
    if (tabItem->mask & TCIF_IMAGE) tabItem->iImage  = 0;
    if (tabItem->mask & TCIF_PARAM) tabItem->lParam  = 0;
    if (tabItem->mask & TCIF_STATE) tabItem->dwState = 0;
2790
    return FALSE;
2791
  }
2792

2793
  wineItem = TAB_GetItem(infoPtr, iItem);
2794 2795 2796 2797 2798

  if (tabItem->mask & TCIF_IMAGE)
    tabItem->iImage = wineItem->iImage;

  if (tabItem->mask & TCIF_PARAM)
2799
    memcpy(&tabItem->lParam, wineItem->extra, infoPtr->cbInfo);
2800 2801 2802 2803 2804

  if (tabItem->mask & TCIF_RTLREADING)
    FIXME("TCIF_RTLREADING\n");

  if (tabItem->mask & TCIF_STATE)
2805
    tabItem->dwState = wineItem->dwState & tabItem->dwStateMask;
2806 2807

  if (tabItem->mask & TCIF_TEXT)
2808 2809
  {
    if (bUnicode)
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2810
      Str_GetPtrW (wineItem->pszText, tabItem->pszText, tabItem->cchTextMax);
2811
    else
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2812
      Str_GetPtrWtoA (wineItem->pszText, (LPSTR)tabItem->pszText, tabItem->cchTextMax);
2813
  }
2814

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2815
  TAB_DumpItemExternalT(tabItem, iItem, bUnicode);
2816

2817 2818 2819 2820
  return TRUE;
}


2821
static LRESULT TAB_DeleteItem (TAB_INFO *infoPtr, INT iItem)
2822
{
2823
    TAB_ITEM *item;
2824

2825 2826
    TRACE("(%p, %d)\n", infoPtr, iItem);

2827 2828
    if (iItem < 0 || iItem >= infoPtr->uNumItem) return FALSE;

2829
    TAB_InvalidateTabArea(infoPtr);
2830 2831 2832 2833 2834
    item = TAB_GetItem(infoPtr, iItem);
    Free(item->pszText);
    Free(item);
    infoPtr->uNumItem--;
    DPA_DeletePtr(infoPtr->items, iItem);
2835

2836 2837 2838
    if (infoPtr->uNumItem == 0)
    {
        if (infoPtr->iHotTracked >= 0)
2839
        {
2840 2841
            KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
            infoPtr->iHotTracked = -1;
2842 2843
        }

2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
        infoPtr->iSelected = -1;
    }
    else
    {
        if (iItem <= infoPtr->iHotTracked)
        {
            /* When tabs move left/up, the hot track item may change */
            FIXME("Recalc hot track\n");
        }
    }
2854

2855 2856 2857 2858 2859
    /* adjust the selected index */
    if (iItem == infoPtr->iSelected)
        infoPtr->iSelected = -1;
    else if (iItem < infoPtr->iSelected)
        infoPtr->iSelected--;
2860

2861 2862
    /* reposition and repaint tabs */
    TAB_SetItemBounds(infoPtr);
2863

2864
    return TRUE;
2865
}
Alex Priem's avatar
Alex Priem committed
2866

2867
static inline LRESULT TAB_DeleteAllItems (TAB_INFO *infoPtr)
2868
{
2869
    TRACE("(%p)\n", infoPtr);
2870
    while (infoPtr->uNumItem)
2871
      TAB_DeleteItem (infoPtr, 0);
2872
    return TRUE;
2873 2874 2875
}


2876
static inline LRESULT TAB_GetFont (const TAB_INFO *infoPtr)
2877
{
2878
  TRACE("(%p) returning %p\n", infoPtr, infoPtr->hFont);
2879 2880 2881
  return (LRESULT)infoPtr->hFont;
}

2882
static inline LRESULT TAB_SetFont (TAB_INFO *infoPtr, HFONT hNewFont)
2883
{
2884
  TRACE("(%p,%p)\n", infoPtr, hNewFont);
2885

2886
  infoPtr->hFont = hNewFont;
2887

2888
  TAB_SetItemBounds(infoPtr);
2889

2890
  TAB_InvalidateTabArea(infoPtr);
2891

Francis Beaudet's avatar
Francis Beaudet committed
2892
  return 0;
2893 2894 2895
}


2896
static inline LRESULT TAB_GetImageList (const TAB_INFO *infoPtr)
2897
{
2898
  TRACE("\n");
2899 2900 2901
  return (LRESULT)infoPtr->himl;
}

2902
static inline LRESULT TAB_SetImageList (TAB_INFO *infoPtr, HIMAGELIST himlNew)
2903
{
2904
    HIMAGELIST himlPrev = infoPtr->himl;
2905
    TRACE("himl=%p\n", himlNew);
2906
    infoPtr->himl = himlNew;
2907 2908
    TAB_SetItemBounds(infoPtr);
    InvalidateRect(infoPtr->hwnd, NULL, TRUE);
2909 2910 2911
    return (LRESULT)himlPrev;
}

2912
static inline LRESULT TAB_GetUnicodeFormat (const TAB_INFO *infoPtr)
2913
{
2914
    TRACE("(%p)\n", infoPtr);
2915 2916 2917
    return infoPtr->bUnicode;
}

2918
static inline LRESULT TAB_SetUnicodeFormat (TAB_INFO *infoPtr, BOOL bUnicode)
2919 2920 2921
{
    BOOL bTemp = infoPtr->bUnicode;

2922
    TRACE("(%p %d)\n", infoPtr, bUnicode);
2923
    infoPtr->bUnicode = bUnicode;
2924 2925 2926

    return bTemp;
}
Alex Priem's avatar
Alex Priem committed
2927

2928
static inline LRESULT TAB_Size (TAB_INFO *infoPtr)
Alex Priem's avatar
Alex Priem committed
2929
{
2930 2931 2932 2933 2934
/* I'm not really sure what the following code was meant to do.
   This is what it is doing:
   When WM_SIZE is sent with SIZE_RESTORED, the control
   gets positioned in the top left corner.

2935 2936 2937
  RECT parent_rect;
  HWND parent;
  UINT uPosFlags,cx,cy;
Alex Priem's avatar
Alex Priem committed
2938 2939 2940

  uPosFlags=0;
  if (!wParam) {
Francis Beaudet's avatar
Francis Beaudet committed
2941 2942 2943 2944
    parent = GetParent (hwnd);
    GetClientRect(parent, &parent_rect);
    cx=LOWORD (lParam);
    cy=HIWORD (lParam);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2945
    if (GetWindowLongW(hwnd, GWL_STYLE) & CCS_NORESIZE)
Alex Priem's avatar
Alex Priem committed
2946 2947
        uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);

Francis Beaudet's avatar
Francis Beaudet committed
2948
    SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
Alex Priem's avatar
Alex Priem committed
2949
            cx, cy, uPosFlags | SWP_NOZORDER);
2950
  } else {
Andreas Mohr's avatar
Andreas Mohr committed
2951
    FIXME("WM_SIZE flag %x %lx not handled\n", wParam, lParam);
2952
  } */
Alex Priem's avatar
Alex Priem committed
2953

2954
  /* Recompute the size/position of the tabs. */
2955
  TAB_SetItemBounds (infoPtr);
Francis Beaudet's avatar
Francis Beaudet committed
2956

2957
  /* Force a repaint of the control. */
2958
  InvalidateRect(infoPtr->hwnd, NULL, TRUE);
Alex Priem's avatar
Alex Priem committed
2959 2960 2961 2962 2963

  return 0;
}


2964
static LRESULT TAB_Create (HWND hwnd, LPARAM lParam)
Alexandre Julliard's avatar
Alexandre Julliard committed
2965
{
Francis Beaudet's avatar
Francis Beaudet committed
2966
  TAB_INFO *infoPtr;
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2967
  TEXTMETRICW fontMetrics;
2968 2969
  HDC hdc;
  HFONT hOldFont;
2970
  DWORD style;
Alexandre Julliard's avatar
Alexandre Julliard committed
2971

2972
  infoPtr = Alloc (sizeof(TAB_INFO));
Francis Beaudet's avatar
Francis Beaudet committed
2973

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2974
  SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)infoPtr);
2975

2976
  infoPtr->hwnd            = hwnd;
2977
  infoPtr->hwndNotify      = ((LPCREATESTRUCTW)lParam)->hwndParent;
Francis Beaudet's avatar
Francis Beaudet committed
2978
  infoPtr->uNumItem        = 0;
2979
  infoPtr->uNumRows        = 0;
2980 2981
  infoPtr->uHItemPadding   = 6;
  infoPtr->uVItemPadding   = 3;
2982 2983
  infoPtr->uHItemPadding_s = 6;
  infoPtr->uVItemPadding_s = 3;
Francis Beaudet's avatar
Francis Beaudet committed
2984
  infoPtr->hFont           = 0;
2985
  infoPtr->items           = DPA_Create(8);
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
2986
  infoPtr->hcurArrow       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
2987
  infoPtr->iSelected       = -1;
2988
  infoPtr->iHotTracked     = -1;
2989
  infoPtr->uFocus          = -1;
Francis Beaudet's avatar
Francis Beaudet committed
2990 2991 2992 2993 2994
  infoPtr->hwndToolTip     = 0;
  infoPtr->DoRedraw        = TRUE;
  infoPtr->needsScrolling  = FALSE;
  infoPtr->hwndUpDown      = 0;
  infoPtr->leftmostVisible = 0;
2995
  infoPtr->fHeightSet      = FALSE;
2996 2997
  infoPtr->bUnicode        = IsWindowUnicode (hwnd);
  infoPtr->cbInfo          = sizeof(LPARAM);
Alexandre Julliard's avatar
Alexandre Julliard committed
2998

2999
  TRACE("Created tab control, hwnd [%p]\n", hwnd);
3000 3001 3002

  /* The tab control always has the WS_CLIPSIBLINGS style. Even
     if you don't specify it in CreateWindow. This is necessary in
Alexandre Julliard's avatar
Alexandre Julliard committed
3003
     order for paint to work correctly. This follows windows behaviour. */
3004 3005 3006 3007
  style = GetWindowLongW(hwnd, GWL_STYLE);
  if (style & TCS_VERTICAL) style |= TCS_MULTILINE;
  style |= WS_CLIPSIBLINGS;
  SetWindowLongW(hwnd, GWL_STYLE, style);
Alexandre Julliard's avatar
Alexandre Julliard committed
3008

3009 3010
  infoPtr->dwStyle = style;
  infoPtr->exStyle = (style & TCS_FLATBUTTONS) ? TCS_EX_FLATSEPARATORS : 0;
3011

3012
  if (infoPtr->dwStyle & TCS_TOOLTIPS) {
Alex Priem's avatar
Alex Priem committed
3013 3014
    /* Create tooltip control */
    infoPtr->hwndToolTip =
3015
      CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
Francis Beaudet's avatar
Francis Beaudet committed
3016 3017 3018
		       CW_USEDEFAULT, CW_USEDEFAULT,
		       CW_USEDEFAULT, CW_USEDEFAULT,
		       hwnd, 0, 0, 0);
3019

Alex Priem's avatar
Alex Priem committed
3020 3021
    /* Send NM_TOOLTIPSCREATED notification */
    if (infoPtr->hwndToolTip) {
Francis Beaudet's avatar
Francis Beaudet committed
3022
      NMTOOLTIPSCREATED nmttc;
3023

Francis Beaudet's avatar
Francis Beaudet committed
3024
      nmttc.hdr.hwndFrom = hwnd;
3025
      nmttc.hdr.idFrom = GetWindowLongPtrW(hwnd, GWLP_ID);
Francis Beaudet's avatar
Francis Beaudet committed
3026 3027
      nmttc.hdr.code = NM_TOOLTIPSCREATED;
      nmttc.hwndToolTips = infoPtr->hwndToolTip;
3028

3029
      SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
3030
                    GetWindowLongPtrW(hwnd, GWLP_ID), (LPARAM)&nmttc);
Alex Priem's avatar
Alex Priem committed
3031
    }
3032 3033
  }

3034 3035
  OpenThemeData (infoPtr->hwnd, themeClass);
  
3036 3037 3038 3039
  /*
   * We need to get text information so we need a DC and we need to select
   * a font.
   */
3040
  hdc = GetDC(hwnd);
3041 3042
  hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));

3043
  /* Use the system font to determine the initial height of a tab. */
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3044
  GetTextMetricsW(hdc, &fontMetrics);
3045 3046

  /*
3047 3048
   * Make sure there is enough space for the letters + growing the
   * selected item + extra space for the selected item.
3049
   */
3050
  infoPtr->tabHeight = fontMetrics.tmHeight + SELECTED_TAB_OFFSET +
3051
	               ((infoPtr->dwStyle & TCS_BUTTONS) ? 2 : 1) *
3052
                        infoPtr->uVItemPadding;
3053

3054
  /* Initialize the width of a tab. */
3055
  if (infoPtr->dwStyle & TCS_FIXEDWIDTH)
3056
    infoPtr->tabWidth = GetDeviceCaps(hdc, LOGPIXELSX);
3057 3058

  infoPtr->tabMinWidth = -1;
3059

3060 3061
  TRACE("tabH=%d, tabW=%d\n", infoPtr->tabHeight, infoPtr->tabWidth);

3062 3063 3064
  SelectObject (hdc, hOldFont);
  ReleaseDC(hwnd, hdc);

Francis Beaudet's avatar
Francis Beaudet committed
3065
  return 0;
Alexandre Julliard's avatar
Alexandre Julliard committed
3066 3067 3068
}

static LRESULT
3069
TAB_Destroy (TAB_INFO *infoPtr)
Alexandre Julliard's avatar
Alexandre Julliard committed
3070
{
3071
  INT iItem;
Alexandre Julliard's avatar
Alexandre Julliard committed
3072

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3073 3074
  SetWindowLongPtrW(infoPtr->hwnd, 0, 0);

3075 3076 3077 3078 3079 3080 3081 3082 3083
  for (iItem = infoPtr->uNumItem - 1; iItem >= 0; iItem--)
  {
      TAB_ITEM *tab = TAB_GetItem(infoPtr, iItem);

      DPA_DeletePtr(infoPtr->items, iItem);
      infoPtr->uNumItem--;

      Free(tab->pszText);
      Free(tab);
Francis Beaudet's avatar
Francis Beaudet committed
3084
  }
3085 3086
  DPA_Destroy(infoPtr->items);
  infoPtr->items = NULL;
3087 3088

  if (infoPtr->hwndToolTip)
Francis Beaudet's avatar
Francis Beaudet committed
3089
    DestroyWindow (infoPtr->hwndToolTip);
3090

Francis Beaudet's avatar
Francis Beaudet committed
3091 3092
  if (infoPtr->hwndUpDown)
    DestroyWindow(infoPtr->hwndUpDown);
Alex Priem's avatar
Alex Priem committed
3093

3094
  if (infoPtr->iHotTracked >= 0)
3095
    KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
3096

3097
  CloseThemeData (GetWindowTheme (infoPtr->hwnd));
3098

3099
  Free (infoPtr);
Francis Beaudet's avatar
Francis Beaudet committed
3100
  return 0;
Alexandre Julliard's avatar
Alexandre Julliard committed
3101 3102
}

3103
/* update theme after a WM_THEMECHANGED message */
3104
static LRESULT theme_changed(const TAB_INFO *infoPtr)
3105 3106 3107 3108 3109 3110 3111
{
    HTHEME theme = GetWindowTheme (infoPtr->hwnd);
    CloseThemeData (theme);
    OpenThemeData (infoPtr->hwnd, themeClass);
    return 0;
}

3112
static LRESULT TAB_NCCalcSize(WPARAM wParam)
3113 3114 3115 3116 3117 3118
{
  if (!wParam)
    return 0;
  return WVR_ALIGNTOP;
}

3119 3120
static inline LRESULT
TAB_SetItemExtra (TAB_INFO *infoPtr, INT cbInfo)
3121
{
3122 3123
  TRACE("(%p %d)\n", infoPtr, cbInfo);

3124
  if (cbInfo < 0 || infoPtr->uNumItem) return FALSE;
3125 3126 3127 3128 3129

  infoPtr->cbInfo = cbInfo;
  return TRUE;
}

3130 3131
static LRESULT TAB_RemoveImage (TAB_INFO *infoPtr, INT image)
{
3132 3133
  TRACE("%p %d\n", infoPtr, image);

3134 3135 3136 3137 3138 3139 3140 3141
  if (ImageList_Remove (infoPtr->himl, image))
  {
    INT i, *idx;
    RECT r;

    /* shift indices, repaint items if needed */
    for (i = 0; i < infoPtr->uNumItem; i++)
    {
3142
      idx = &TAB_GetItem(infoPtr, i)->iImage;
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
      if (*idx >= image)
      {
        if (*idx == image)
          *idx = -1;
        else
          (*idx)--;

        /* repaint item */
        if (TAB_InternalGetItemRect (infoPtr, i, &r, NULL))
          InvalidateRect (infoPtr->hwnd, &r, TRUE);
      }
    }
  }

  return 0;
}

3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187
static LRESULT
TAB_SetExtendedStyle (TAB_INFO *infoPtr, DWORD exMask, DWORD exStyle)
{
  DWORD prevstyle = infoPtr->exStyle;

  /* zero mask means all styles */
  if (exMask == 0) exMask = ~0;

  if (exMask & TCS_EX_REGISTERDROP)
  {
    FIXME("TCS_EX_REGISTERDROP style unimplemented\n");
    exMask  &= ~TCS_EX_REGISTERDROP;
    exStyle &= ~TCS_EX_REGISTERDROP;
  }

  if (exMask & TCS_EX_FLATSEPARATORS)
  {
    if ((prevstyle ^ exStyle) & TCS_EX_FLATSEPARATORS)
    {
        infoPtr->exStyle ^= TCS_EX_FLATSEPARATORS;
        TAB_InvalidateTabArea(infoPtr);
    }
  }

  return prevstyle;
}

static inline LRESULT
3188
TAB_GetExtendedStyle (const TAB_INFO *infoPtr)
3189 3190 3191 3192
{
  return infoPtr->exStyle;
}

3193 3194 3195 3196 3197 3198
static LRESULT
TAB_DeselectAll (TAB_INFO *infoPtr, BOOL excludesel)
{
  BOOL paint = FALSE;
  INT i, selected = infoPtr->iSelected;

3199 3200
  TRACE("(%p, %d)\n", infoPtr, excludesel);

3201
  if (!(infoPtr->dwStyle & TCS_BUTTONS))
3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
    return 0;

  for (i = 0; i < infoPtr->uNumItem; i++)
  {
    if ((TAB_GetItem(infoPtr, i)->dwState & TCIS_BUTTONPRESSED) &&
        (selected != i))
    {
      TAB_GetItem(infoPtr, i)->dwState &= ~TCIS_BUTTONPRESSED;
      paint = TRUE;
    }
  }

  if (!excludesel && (selected != -1))
  {
    TAB_GetItem(infoPtr, selected)->dwState &= ~TCIS_BUTTONPRESSED;
    infoPtr->iSelected = -1;
    paint = TRUE;
  }

  if (paint)
    TAB_InvalidateTabArea (infoPtr);

  return 0;
}

3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
/***
 * DESCRIPTION:
 * Processes WM_STYLECHANGED messages.
 *
 * PARAMETER(S):
 * [I] infoPtr : valid pointer to the tab data structure
 * [I] wStyleType : window style type (normal or extended)
 * [I] lpss : window style information
 *
 * RETURN:
 * Zero
 */
static INT TAB_StyleChanged(TAB_INFO *infoPtr, WPARAM wStyleType,
                            const STYLESTRUCT *lpss)
{
    TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
          wStyleType, lpss->styleOld, lpss->styleNew);

    if (wStyleType != GWL_STYLE) return 0;

    infoPtr->dwStyle = lpss->styleNew;

    TAB_SetItemBounds (infoPtr);
    InvalidateRect(infoPtr->hwnd, NULL, TRUE);

    return 0;
}

3255
static LRESULT WINAPI
3256
TAB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Alexandre Julliard's avatar
Alexandre Julliard committed
3257
{
3258
    TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
3259

3260
    TRACE("hwnd=%p msg=%x wParam=%lx lParam=%lx\n", hwnd, uMsg, wParam, lParam);
3261
    if (!infoPtr && (uMsg != WM_CREATE))
3262
      return DefWindowProcW (hwnd, uMsg, wParam, lParam);
3263

Alexandre Julliard's avatar
Alexandre Julliard committed
3264 3265
    switch (uMsg)
    {
Francis Beaudet's avatar
Francis Beaudet committed
3266
    case TCM_GETIMAGELIST:
3267
      return TAB_GetImageList (infoPtr);
3268

Francis Beaudet's avatar
Francis Beaudet committed
3269
    case TCM_SETIMAGELIST:
3270
      return TAB_SetImageList (infoPtr, (HIMAGELIST)lParam);
3271

Francis Beaudet's avatar
Francis Beaudet committed
3272
    case TCM_GETITEMCOUNT:
3273
      return TAB_GetItemCount (infoPtr);
3274

Francis Beaudet's avatar
Francis Beaudet committed
3275 3276
    case TCM_GETITEMA:
    case TCM_GETITEMW:
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3277
      return TAB_GetItemT (infoPtr, (INT)wParam, (LPTCITEMW)lParam, uMsg == TCM_GETITEMW);
3278

Francis Beaudet's avatar
Francis Beaudet committed
3279 3280
    case TCM_SETITEMA:
    case TCM_SETITEMW:
Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3281
      return TAB_SetItemT (infoPtr, (INT)wParam, (LPTCITEMW)lParam, uMsg == TCM_SETITEMW);
3282

Francis Beaudet's avatar
Francis Beaudet committed
3283
    case TCM_DELETEITEM:
3284
      return TAB_DeleteItem (infoPtr, (INT)wParam);
3285

Francis Beaudet's avatar
Francis Beaudet committed
3286
    case TCM_DELETEALLITEMS:
3287
     return TAB_DeleteAllItems (infoPtr);
3288

Francis Beaudet's avatar
Francis Beaudet committed
3289
    case TCM_GETITEMRECT:
3290
     return TAB_GetItemRect (infoPtr, (INT)wParam, (LPRECT)lParam);
3291

Francis Beaudet's avatar
Francis Beaudet committed
3292
    case TCM_GETCURSEL:
3293
      return TAB_GetCurSel (infoPtr);
3294

Francis Beaudet's avatar
Francis Beaudet committed
3295
    case TCM_HITTEST:
3296
      return TAB_HitTest (infoPtr, (LPTCHITTESTINFO)lParam);
3297

Francis Beaudet's avatar
Francis Beaudet committed
3298
    case TCM_SETCURSEL:
3299
      return TAB_SetCurSel (infoPtr, (INT)wParam);
3300

Francis Beaudet's avatar
Francis Beaudet committed
3301 3302
    case TCM_INSERTITEMA:
    case TCM_INSERTITEMW:
3303
      return TAB_InsertItemT (infoPtr, (INT)wParam, (TCITEMW*)lParam, uMsg == TCM_INSERTITEMW);
3304

Francis Beaudet's avatar
Francis Beaudet committed
3305
    case TCM_SETITEMEXTRA:
3306
      return TAB_SetItemExtra (infoPtr, (INT)wParam);
3307

Francis Beaudet's avatar
Francis Beaudet committed
3308
    case TCM_ADJUSTRECT:
3309
      return TAB_AdjustRect (infoPtr, (BOOL)wParam, (LPRECT)lParam);
3310

Francis Beaudet's avatar
Francis Beaudet committed
3311
    case TCM_SETITEMSIZE:
3312
      return TAB_SetItemSize (infoPtr, (INT)LOWORD(lParam), (INT)HIWORD(lParam));
3313

Francis Beaudet's avatar
Francis Beaudet committed
3314
    case TCM_REMOVEIMAGE:
3315
      return TAB_RemoveImage (infoPtr, (INT)wParam);
3316

Francis Beaudet's avatar
Francis Beaudet committed
3317
    case TCM_SETPADDING:
3318
      return TAB_SetPadding (infoPtr, lParam);
3319

Francis Beaudet's avatar
Francis Beaudet committed
3320
    case TCM_GETROWCOUNT:
3321
      return TAB_GetRowCount(infoPtr);
3322 3323

    case TCM_GETUNICODEFORMAT:
3324
      return TAB_GetUnicodeFormat (infoPtr);
3325 3326

    case TCM_SETUNICODEFORMAT:
3327
      return TAB_SetUnicodeFormat (infoPtr, (BOOL)wParam);
3328 3329

    case TCM_HIGHLIGHTITEM:
3330
      return TAB_HighlightItem (infoPtr, (INT)wParam, (BOOL)LOWORD(lParam));
3331

Francis Beaudet's avatar
Francis Beaudet committed
3332
    case TCM_GETTOOLTIPS:
3333
      return TAB_GetToolTips (infoPtr);
3334

Francis Beaudet's avatar
Francis Beaudet committed
3335
    case TCM_SETTOOLTIPS:
3336
      return TAB_SetToolTips (infoPtr, (HWND)wParam);
3337

Francis Beaudet's avatar
Francis Beaudet committed
3338
    case TCM_GETCURFOCUS:
3339
      return TAB_GetCurFocus (infoPtr);
3340

Francis Beaudet's avatar
Francis Beaudet committed
3341
    case TCM_SETCURFOCUS:
3342
      return TAB_SetCurFocus (infoPtr, (INT)wParam);
3343

Alexandre Julliard's avatar
Alexandre Julliard committed
3344
    case TCM_SETMINTABWIDTH:
3345
      return TAB_SetMinTabWidth(infoPtr, (INT)lParam);
3346

Francis Beaudet's avatar
Francis Beaudet committed
3347
    case TCM_DESELECTALL:
3348
      return TAB_DeselectAll (infoPtr, (BOOL)wParam);
3349

3350
    case TCM_GETEXTENDEDSTYLE:
3351
      return TAB_GetExtendedStyle (infoPtr);
3352 3353

    case TCM_SETEXTENDEDSTYLE:
3354
      return TAB_SetExtendedStyle (infoPtr, wParam, lParam);
3355

Francis Beaudet's avatar
Francis Beaudet committed
3356
    case WM_GETFONT:
3357
      return TAB_GetFont (infoPtr);
3358

Francis Beaudet's avatar
Francis Beaudet committed
3359
    case WM_SETFONT:
3360
      return TAB_SetFont (infoPtr, (HFONT)wParam);
3361

Francis Beaudet's avatar
Francis Beaudet committed
3362
    case WM_CREATE:
3363
      return TAB_Create (hwnd, lParam);
3364

Francis Beaudet's avatar
Francis Beaudet committed
3365
    case WM_NCDESTROY:
3366
      return TAB_Destroy (infoPtr);
3367

3368
    case WM_GETDLGCODE:
Francis Beaudet's avatar
Francis Beaudet committed
3369
      return DLGC_WANTARROWS | DLGC_WANTCHARS;
3370

Francis Beaudet's avatar
Francis Beaudet committed
3371
    case WM_LBUTTONDOWN:
3372
      return TAB_LButtonDown (infoPtr, wParam, lParam);
3373

Francis Beaudet's avatar
Francis Beaudet committed
3374
    case WM_LBUTTONUP:
3375
      return TAB_LButtonUp (infoPtr);
3376

3377
    case WM_NOTIFY:
3378
      return SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, wParam, lParam);
3379

3380
    case WM_RBUTTONUP:
3381 3382
      TAB_RButtonUp (infoPtr);
      return DefWindowProcW (hwnd, uMsg, wParam, lParam);
3383

Francis Beaudet's avatar
Francis Beaudet committed
3384
    case WM_MOUSEMOVE:
3385
      return TAB_MouseMove (infoPtr, wParam, lParam);
3386

3387
    case WM_PRINTCLIENT:
Francis Beaudet's avatar
Francis Beaudet committed
3388
    case WM_PAINT:
3389
      return TAB_Paint (infoPtr, (HDC)wParam);
Francis Beaudet's avatar
Francis Beaudet committed
3390 3391

    case WM_SIZE:
3392
      return TAB_Size (infoPtr);
3393

Francis Beaudet's avatar
Francis Beaudet committed
3394
    case WM_SETREDRAW:
3395
      return TAB_SetRedraw (infoPtr, (BOOL)wParam);
Francis Beaudet's avatar
Francis Beaudet committed
3396 3397

    case WM_HSCROLL:
3398
      return TAB_OnHScroll(infoPtr, (int)LOWORD(wParam), (int)HIWORD(wParam));
Alexandre Julliard's avatar
Alexandre Julliard committed
3399 3400

    case WM_STYLECHANGED:
3401
      return TAB_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
3402 3403 3404 3405

    case WM_SYSCOLORCHANGE:
      COMCTL32_RefreshSysColors();
      return 0;
3406

3407 3408 3409
    case WM_THEMECHANGED:
      return theme_changed (infoPtr);

Francis Beaudet's avatar
Francis Beaudet committed
3410
    case WM_KILLFOCUS:
3411
      TAB_KillFocus(infoPtr);
Francis Beaudet's avatar
Francis Beaudet committed
3412
    case WM_SETFOCUS:
3413 3414
      TAB_FocusChanging(infoPtr);
      break;   /* Don't disturb normal focus behavior */
Francis Beaudet's avatar
Francis Beaudet committed
3415

3416
    case WM_KEYDOWN:
3417
      return TAB_KeyDown(infoPtr, wParam, lParam);
3418

3419
    case WM_NCHITTEST:
3420
      return TAB_NCHitTest(infoPtr, lParam);
Francis Beaudet's avatar
Francis Beaudet committed
3421

3422
    case WM_NCCALCSIZE:
3423
      return TAB_NCCalcSize(wParam);
3424

Francis Beaudet's avatar
Francis Beaudet committed
3425
    default:
3426
      if (uMsg >= WM_USER && uMsg < WM_APP && !COMCTL32_IsReflectedMessage(uMsg))
3427
	WARN("unknown msg %04x wp=%08lx lp=%08lx\n",
Francis Beaudet's avatar
Francis Beaudet committed
3428
	     uMsg, wParam, lParam);
3429
      break;
Alexandre Julliard's avatar
Alexandre Julliard committed
3430
    }
3431
    return DefWindowProcW(hwnd, uMsg, wParam, lParam);
Alexandre Julliard's avatar
Alexandre Julliard committed
3432 3433 3434
}


Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3435
void
3436
TAB_Register (void)
Alexandre Julliard's avatar
Alexandre Julliard committed
3437
{
3438
  WNDCLASSW wndClass;
Francis Beaudet's avatar
Francis Beaudet committed
3439

3440
  ZeroMemory (&wndClass, sizeof(WNDCLASSW));
3441
  wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
3442
  wndClass.lpfnWndProc   = TAB_WindowProc;
Francis Beaudet's avatar
Francis Beaudet committed
3443 3444
  wndClass.cbClsExtra    = 0;
  wndClass.cbWndExtra    = sizeof(TAB_INFO *);
3445 3446 3447
  wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
  wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
  wndClass.lpszClassName = WC_TABCONTROLW;
3448

3449
  RegisterClassW (&wndClass);
Alexandre Julliard's avatar
Alexandre Julliard committed
3450 3451
}

3452

Dimitrie O. Paun's avatar
Dimitrie O. Paun committed
3453
void
3454
TAB_Unregister (void)
3455
{
3456
    UnregisterClassW (WC_TABCONTROLW, NULL);
3457
}