git.oblomov.eu Git - wine/blob - dlls/comctl32/tab.c

   1 /*
   2  * Tab control
   3  *
   4  * Copyright 1998 Anders Carlsson
   5  * Copyright 1999 Alex Priem <alexp@sci.kun.nl>
   6  * Copyright 1999 Francis Beaudet
   7  *
   8  * TODO:
   9  *  Image list support
  10  *  Multiline support
  11  *  Unicode support
  12  */
  13
  14 #include <string.h>
  15
  16 #include "winbase.h"
  17 #include "commctrl.h"
  18 #include "tab.h"
  19 #include "debugtools.h"
  20 #include "cache.h"
  21 #include "win.h"
  22
  23 DEFAULT_DEBUG_CHANNEL(tab)
  24
  25 /******************************************************************************
  26  * Positioning constants
  27  */
  28 #define SELECTED_TAB_OFFSET     2
  29 #define HORIZONTAL_ITEM_PADDING 5
  30 #define VERTICAL_ITEM_PADDING   3
  31 #define ROUND_CORNER_SIZE       2
  32 #define FOCUS_RECT_HOFFSET      2
  33 #define FOCUS_RECT_VOFFSET      1
  34 #define DISPLAY_AREA_PADDINGX   2
  35 #define DISPLAY_AREA_PADDINGY   2
  36 #define CONTROL_BORDER_SIZEX    2
  37 #define CONTROL_BORDER_SIZEY    2
  38 #define BUTTON_SPACINGX         10
  39 #define DEFAULT_TAB_WIDTH       96
  40
  41 #define TAB_GetInfoPtr(hwnd) ((TAB_INFO *)GetWindowLongA(hwnd,0))
  42
  43 /******************************************************************************
  44  * Prototypes
  45  */
  46 static void TAB_Refresh (HWND hwnd, HDC hdc);
  47 static void TAB_InvalidateTabArea(HWND      hwnd, TAB_INFO* infoPtr);
  48 static void TAB_EnsureSelectionVisible(HWND hwnd, TAB_INFO* infoPtr);
  49
  50 static BOOL
  51 TAB_SendSimpleNotify (HWND hwnd, UINT code)
  52 {
  53     NMHDR nmhdr;
  54
  55     nmhdr.hwndFrom = hwnd;
  56     nmhdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
  57     nmhdr.code = code;
  58
  59     return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
  60             (WPARAM) nmhdr.idFrom, (LPARAM) &nmhdr);
  61 }
  62
  63
  64 static VOID
  65 TAB_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg,
  66             WPARAM wParam, LPARAM lParam)
  67 {
  68     MSG msg;
  69
  70     msg.hwnd = hwndMsg;
  71     msg.message = uMsg;
  72     msg.wParam = wParam;
  73     msg.lParam = lParam;
  74     msg.time = GetMessageTime ();
  75     msg.pt.x = LOWORD(GetMessagePos ());
  76     msg.pt.y = HIWORD(GetMessagePos ());
  77
  78     SendMessageA (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
  79 }
  80
  81
  82
  83 static LRESULT
  84 TAB_GetCurSel (HWND hwnd)
  85 {
  86     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
  87
  88     return infoPtr->iSelected;
  89 }
  90
  91 static LRESULT
  92 TAB_GetCurFocus (HWND hwnd)
  93 {
  94     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
  95
  96     return infoPtr->uFocus;
  97 }
  98
  99 static LRESULT
 100 TAB_GetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
 101 {
 102     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 103
 104     if (infoPtr == NULL) return 0;
 105     return infoPtr->hwndToolTip;
 106 }
 107
 108
 109 static LRESULT
 110 TAB_SetCurSel (HWND hwnd,WPARAM wParam)
 111 {
 112     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 113   INT iItem=(INT) wParam;
 114   INT prevItem;
 115
 116   prevItem=-1;
 117   if ((iItem >= 0) && (iItem < infoPtr->uNumItem)) {
 118     prevItem=infoPtr->iSelected;
 119       infoPtr->iSelected=iItem;
 120       TAB_EnsureSelectionVisible(hwnd, infoPtr);
 121       TAB_InvalidateTabArea(hwnd, infoPtr);
 122   }
 123   return prevItem;
 124 }
 125
 126 static LRESULT
 127 TAB_SetCurFocus (HWND hwnd,WPARAM wParam)
 128 {
 129   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 130   INT iItem=(INT) wParam;
 131
 132   if ((iItem < 0) || (iItem >= infoPtr->uNumItem)) return 0;
 133
 134   infoPtr->uFocus=iItem;
 135   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BUTTONS) {
 136     FIXME("Should set input focus\n");
 137   } else {
 138     if (infoPtr->iSelected != iItem) {
 139       if (TAB_SendSimpleNotify(hwnd, TCN_SELCHANGING)!=TRUE)  {
 140         infoPtr->iSelected = iItem;
 141         TAB_SendSimpleNotify(hwnd, TCN_SELCHANGE);
 142
 143         TAB_EnsureSelectionVisible(hwnd, infoPtr);
 144         TAB_InvalidateTabArea(hwnd, infoPtr);
 145       }
 146     }
 147   }
 148   return 0;
 149 }
 150
 151 static LRESULT
 152 TAB_SetToolTips (HWND hwnd, WPARAM wParam, LPARAM lParam)
 153 {
 154     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 155
 156     if (infoPtr == NULL) return 0;
 157     infoPtr->hwndToolTip = (HWND)wParam;
 158     return 0;
 159 }
 160
 161 /******************************************************************************
 162  * TAB_InternalGetItemRect
 163  *
 164  * This method will calculate the rectangle representing a given tab item in
 165  * client coordinates. This method takes scrolling into account.
 166  *
 167  * This method returns TRUE if the item is visible in the window and FALSE
 168  * if it is completely outside the client area.
 169  */
 170 static BOOL TAB_InternalGetItemRect(
 171   HWND        hwnd,
 172   TAB_INFO*   infoPtr,
 173   INT         itemIndex,
 174   RECT*       itemRect,
 175   RECT*       selectedRect)
 176 {
 177   RECT tmpItemRect;
 178
 179   /*
 180    * Perform a sanity check and a trivial visibility check.
 181    */
 182   if ( (infoPtr->uNumItem <=0) ||
 183        (itemIndex >= infoPtr->uNumItem) ||
 184        (itemIndex < infoPtr->leftmostVisible) )
 185     return FALSE;
 186
 187   /*
 188    * Avoid special cases in this procedure by assigning the "out"
 189    * parameters if the caller didn't supply them
 190    */
 191   if (itemRect==NULL)
 192     itemRect = &tmpItemRect;
 193
 194   /*
 195    * Retrieve the unmodified item rect.
 196    */
 197   *itemRect = infoPtr->items[itemIndex].rect;
 198
 199   /*
 200    * "scroll" it to make sure the item at the very left of the
 201    * tab control is the leftmost visible tab.
 202    */
 203   OffsetRect(itemRect,
 204              -infoPtr->items[infoPtr->leftmostVisible].rect.left,
 205              0);
 206
 207   /*
 208    * Move the rectangle so the first item is slightly offset from
 209    * the left of the tab control.
 210    */
 211   OffsetRect(itemRect,
 212              SELECTED_TAB_OFFSET,
 213              0);
 214
 215
 216   /*
 217    * Now, calculate the position of the item as if it were selected.
 218    */
 219   if (selectedRect!=NULL)
 220   {
 221     CopyRect(selectedRect, itemRect);
 222
 223     /*
 224      * The rectangle of a selected item is a bit wider.
 225      */
 226     InflateRect(selectedRect, SELECTED_TAB_OFFSET, 0);
 227
 228     /*
 229      * If it also a bit higher.
 230      */
 231     if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
 232     {
 233       selectedRect->top    -=2; /* the border is thicker on the bottom */
 234       selectedRect->bottom +=SELECTED_TAB_OFFSET;
 235     }
 236     else
 237     {
 238       selectedRect->top   -=SELECTED_TAB_OFFSET;
 239       selectedRect->bottom+=1;
 240     }
 241   }
 242
 243   return TRUE;
 244 }
 245
 246 static BOOL TAB_GetItemRect(HWND hwnd, WPARAM wParam, LPARAM lParam)
 247 {
 248   return TAB_InternalGetItemRect(hwnd, TAB_GetInfoPtr(hwnd), (INT)wParam,
 249                                  (LPRECT)lParam, (LPRECT)NULL);
 250 }
 251
 252 /******************************************************************************
 253  * TAB_KeyUp
 254  *
 255  * This method is called to handle keyboard input
 256  */
 257 static LRESULT TAB_KeyUp(
 258   HWND   hwnd,
 259   WPARAM keyCode)
 260 {
 261   TAB_INFO* infoPtr = TAB_GetInfoPtr(hwnd);
 262   int       newItem = -1;
 263
 264   switch (keyCode)
 265   {
 266     case VK_LEFT:
 267       newItem = infoPtr->uFocus-1;
 268       break;
 269     case VK_RIGHT:
 270       newItem = infoPtr->uFocus+1;
 271       break;
 272   }
 273
 274   /*
 275    * If we changed to a valid item, change the selection
 276    */
 277   if ( (newItem >= 0) &&
 278        (newItem < infoPtr->uNumItem) &&
 279        (infoPtr->uFocus != newItem) )
 280   {
 281     if (!TAB_SendSimpleNotify(hwnd, TCN_SELCHANGING))
 282     {
 283       infoPtr->iSelected = newItem;
 284       infoPtr->uFocus    = newItem;
 285       TAB_SendSimpleNotify(hwnd, TCN_SELCHANGE);
 286
 287       TAB_EnsureSelectionVisible(hwnd, infoPtr);
 288       TAB_InvalidateTabArea(hwnd, infoPtr);
 289     }
 290   }
 291
 292   return 0;
 293 }
 294
 295 /******************************************************************************
 296  * TAB_FocusChanging
 297  *
 298  * This method is called whenever the focus goes in or out of this control
 299  * it is used to update the visual state of the control.
 300  */
 301 static LRESULT TAB_FocusChanging(
 302   HWND   hwnd,
 303   UINT   uMsg,
 304   WPARAM wParam,
 305   LPARAM lParam)
 306 {
 307   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 308   RECT      selectedRect;
 309   BOOL      isVisible;
 310
 311   /*
 312    * Get the rectangle for the item.
 313    */
 314   isVisible = TAB_InternalGetItemRect(hwnd,
 315                                       infoPtr,
 316                                       infoPtr->uFocus,
 317                                       NULL,
 318                                       &selectedRect);
 319
 320   /*
 321    * If the rectangle is not completely invisible, invalidate that
 322    * portion of the window.
 323    */
 324   if (isVisible)
 325   {
 326     InvalidateRect(hwnd, &selectedRect, TRUE);
 327   }
 328
 329   /*
 330    * Don't otherwise disturb normal behavior.
 331    */
 332   return DefWindowProcA (hwnd, uMsg, wParam, lParam);
 333 }
 334
 335 static HWND TAB_InternalHitTest (
 336   HWND      hwnd,
 337   TAB_INFO* infoPtr,
 338   POINT     pt,
 339   UINT*     flags)
 340
 341 {
 342   RECT rect;
 343   int iCount;
 344
 345   for (iCount = 0; iCount < infoPtr->uNumItem; iCount++)
 346   {
 347     TAB_InternalGetItemRect(hwnd,
 348                             infoPtr,
 349                             iCount,
 350                             &rect,
 351                             NULL);
 352
 353     if (PtInRect (&rect, pt))
 354     {
 355       *flags = TCHT_ONITEM;
 356       return iCount;
 357     }
 358   }
 359
 360   *flags=TCHT_NOWHERE;
 361   return -1;
 362 }
 363
 364 static LRESULT
 365 TAB_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
 366 {
 367   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 368   LPTCHITTESTINFO lptest=(LPTCHITTESTINFO) lParam;
 369
 370   return TAB_InternalHitTest (hwnd, infoPtr,lptest->pt,&lptest->flags);
 371 }
 372
 373
 374 static LRESULT
 375 TAB_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 376 {
 377   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 378   POINT pt;
 379   INT newItem,dummy;
 380
 381   if (infoPtr->hwndToolTip)
 382     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
 383                     WM_LBUTTONDOWN, wParam, lParam);
 384
 385   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_FOCUSONBUTTONDOWN ) {
 386     SetFocus (hwnd);
 387   }
 388
 389   if (infoPtr->hwndToolTip)
 390     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
 391                     WM_LBUTTONDOWN, wParam, lParam);
 392
 393   pt.x = (INT)LOWORD(lParam);
 394   pt.y = (INT)HIWORD(lParam);
 395
 396   newItem=TAB_InternalHitTest (hwnd, infoPtr,pt,&dummy);
 397
 398   TRACE("On Tab, item %d\n", newItem);
 399
 400   if ( (newItem!=-1) &&
 401        (infoPtr->iSelected != newItem) )
 402   {
 403     if (TAB_SendSimpleNotify(hwnd, TCN_SELCHANGING)!=TRUE)
 404     {
 405       infoPtr->iSelected = newItem;
 406       infoPtr->uFocus    = newItem;
 407       TAB_SendSimpleNotify(hwnd, TCN_SELCHANGE);
 408
 409       TAB_EnsureSelectionVisible(hwnd, infoPtr);
 410
 411       TAB_InvalidateTabArea(hwnd, infoPtr);
 412     }
 413   }
 414   return 0;
 415 }
 416
 417 static LRESULT
 418 TAB_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 419 {
 420   TAB_SendSimpleNotify(hwnd, NM_CLICK);
 421
 422   return 0;
 423 }
 424
 425 static LRESULT
 426 TAB_RButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 427 {
 428   TAB_SendSimpleNotify(hwnd, NM_RCLICK);
 429   return 0;
 430 }
 431
 432 static LRESULT
 433 TAB_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
 434 {
 435   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 436
 437   if (infoPtr->hwndToolTip)
 438     TAB_RelayEvent (infoPtr->hwndToolTip, hwnd,
 439                     WM_LBUTTONDOWN, wParam, lParam);
 440   return 0;
 441 }
 442
 443 /******************************************************************************
 444  * TAB_AdjustRect
 445  *
 446  * Calculates the tab control's display area given the windows rectangle or
 447  * the window rectangle given the requested display rectangle.
 448  */
 449 static LRESULT TAB_AdjustRect(
 450   HWND   hwnd,
 451   WPARAM fLarger,
 452   LPRECT prc)
 453 {
 454   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 455
 456   if (fLarger)
 457   {
 458     /*
 459      * Go from display rectangle
 460      */
 461
 462     /*
 463      * Add the height of the tabs.
 464      */
 465     if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
 466       prc->bottom += infoPtr->tabHeight;
 467     else
 468       prc->top -= infoPtr->tabHeight;
 469
 470     /*
 471      * Inflate the rectangle for the padding
 472      */
 473     InflateRect(prc, DISPLAY_AREA_PADDINGX, DISPLAY_AREA_PADDINGY);
 474
 475     /*
 476      * Inflate for the border
 477      */
 478     InflateRect(prc, CONTROL_BORDER_SIZEX, CONTROL_BORDER_SIZEX);
 479   }
 480   else
 481   {
 482     /*
 483      * Go from window rectangle.
 484      */
 485
 486     /*
 487      * Deflate the rectangle for the border
 488      */
 489     InflateRect(prc, -CONTROL_BORDER_SIZEX, -CONTROL_BORDER_SIZEX);
 490
 491     /*
 492      * Deflate the rectangle for the padding
 493      */
 494     InflateRect(prc, -DISPLAY_AREA_PADDINGX, -DISPLAY_AREA_PADDINGY);
 495
 496     /*
 497      * Remove the height of the tabs.
 498      */
 499     if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
 500       prc->bottom -= infoPtr->tabHeight;
 501     else
 502       prc->top += infoPtr->tabHeight;
 503
 504   }
 505
 506   return 0;
 507 }
 508
 509 /******************************************************************************
 510  * TAB_OnHScroll
 511  *
 512  * This method will handle the notification from the scroll control and
 513  * perform the scrolling operation on the tab control.
 514  */
 515 static LRESULT TAB_OnHScroll(
 516   HWND    hwnd,
 517   int     nScrollCode,
 518   int     nPos,
 519   HWND    hwndScroll)
 520 {
 521   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 522
 523   if(nScrollCode == SB_THUMBPOSITION && nPos != infoPtr->leftmostVisible)
 524   {
 525      if(nPos < infoPtr->leftmostVisible)
 526         infoPtr->leftmostVisible--;
 527      else
 528         infoPtr->leftmostVisible++;
 529
 530      TAB_InvalidateTabArea(hwnd, infoPtr);
 531      SendMessageA(infoPtr->hwndUpDown, UDM_SETPOS, 0,
 532                    MAKELONG(infoPtr->leftmostVisible, 0));
 533    }
 534
 535    return 0;
 536 }
 537
 538 /******************************************************************************
 539  * TAB_SetupScroling
 540  *
 541  * This method will check the current scrolling state and make sure the
 542  * scrolling control is displayed (or not).
 543  */
 544 static void TAB_SetupScrolling(
 545   HWND        hwnd,
 546   TAB_INFO*   infoPtr,
 547   const RECT* clientRect)
 548 {
 549   INT maxRange = 0;
 550   if (infoPtr->needsScrolling)
 551   {
 552     RECT controlPos;
 553     INT vsize, tabwidth;
 554
 555     /*
 556      * Calculate the position of the scroll control.
 557      */
 558     controlPos.right = clientRect->right;
 559     controlPos.left  = controlPos.right - 2*GetSystemMetrics(SM_CXHSCROLL);
 560
 561     if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
 562     {
 563       controlPos.top    = clientRect->bottom - infoPtr->tabHeight;
 564       controlPos.bottom = controlPos.top + GetSystemMetrics(SM_CYHSCROLL);
 565     }
 566     else
 567     {
 568       controlPos.bottom = clientRect->top + infoPtr->tabHeight;
 569       controlPos.top    = controlPos.bottom - GetSystemMetrics(SM_CYHSCROLL);
 570     }
 571
 572     /*
 573      * If we don't have a scroll control yet, we want to create one.
 574      * If we have one, we want to make sure it's positioned right.
 575      */
 576     if (infoPtr->hwndUpDown==0)
 577     {
 578       infoPtr->hwndUpDown = CreateWindowA("msctls_updown32",
 579                                           "",
 580                                           WS_VISIBLE | WS_CHILD | UDS_HORZ,
 581                                           controlPos.left, controlPos.top,
 582                                           controlPos.right - controlPos.left,
 583                                           controlPos.bottom - controlPos.top,
 584                                           hwnd,
 585                                           (HMENU)NULL,
 586                                           (HINSTANCE)NULL,
 587                                           NULL);
 588     }
 589     else
 590     {
 591       SetWindowPos(infoPtr->hwndUpDown,
 592                    (HWND)NULL,
 593                    controlPos.left, controlPos.top,
 594                    controlPos.right - controlPos.left,
 595                    controlPos.bottom - controlPos.top,
 596                    SWP_SHOWWINDOW | SWP_NOZORDER);
 597     }
 598
 599     /* Now calculate upper limit of the updown control range.
 600      * We do this by calculating how many tabs will be offscreen when the
 601      * last tab is visible.
 602      */
 603     if(infoPtr->uNumItem)
 604     {
 605        vsize = clientRect->right - (controlPos.right - controlPos.left + 1);
 606        maxRange = infoPtr->uNumItem;
 607        tabwidth = infoPtr->items[maxRange-1].rect.right;
 608
 609        for(; maxRange > 0; maxRange--)
 610        {
 611           if(tabwidth - infoPtr->items[maxRange - 1].rect.left > vsize)
 612              break;
 613        }
 614
 615        if(maxRange == infoPtr->uNumItem)
 616           maxRange--;
 617     }
 618   }
 619   else
 620   {
 621     /*
 622      * If we once had a scroll control... hide it.
 623      */
 624     if (infoPtr->hwndUpDown!=0)
 625     {
 626       ShowWindow(infoPtr->hwndUpDown, SW_HIDE);
 627     }
 628   }
 629   if (infoPtr->hwndUpDown)
 630      SendMessageA(infoPtr->hwndUpDown, UDM_SETRANGE32, 0, maxRange);
 631 }
 632
 633 /******************************************************************************
 634  * TAB_SetItemBounds
 635  *
 636  * This method will calculate the position rectangles of all the items in the
 637  * control. The rectangle calculated starts at 0 for the first item in the
 638  * list and ignores scrolling and selection.
 639  * It also uses the current font to determine the height of the tab row and
 640  * it checks if all the tabs fit in the client area of the window. If they
 641  * dont, a scrolling control is added.
 642  */
 643 static void TAB_SetItemBounds (HWND hwnd)
 644 {
 645   TAB_INFO*   infoPtr = TAB_GetInfoPtr(hwnd);
 646   LONG        lStyle  = GetWindowLongA(hwnd, GWL_STYLE);
 647   TEXTMETRICA fontMetrics;
 648   INT         curItem;
 649   INT         curItemLeftPos;
 650   HFONT       hFont, hOldFont;
 651   HDC         hdc;
 652   RECT        clientRect;
 653   SIZE        size;
 654
 655   /*
 656    * We need to get text information so we need a DC and we need to select
 657    * a font.
 658    */
 659   hdc = GetDC(hwnd);
 660
 661   hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
 662   hOldFont = SelectObject (hdc, hFont);
 663
 664   /*
 665    * We will base the rectangle calculations on the client rectangle
 666    * of the control.
 667    */
 668   GetClientRect(hwnd, &clientRect);
 669
 670   /*
 671    * The leftmost item will be "0" aligned
 672    */
 673   curItemLeftPos = 0;
 674
 675   if ( !(lStyle & TCS_FIXEDWIDTH) && !((lStyle & TCS_OWNERDRAWFIXED) && infoPtr->fSizeSet) )
 676   {
 677     int item_height;
 678     int icon_height = 0;
 679
 680     /*
 681      * Use the current font to determine the height of a tab.
 682      */
 683     GetTextMetricsA(hdc, &fontMetrics);
 684
 685     /*
 686      * Get the icon height
 687      */
 688     if (infoPtr->himl)
 689       ImageList_GetIconSize(infoPtr->himl, 0, &icon_height);
 690
 691     /*
 692      * Take the highest between font or icon
 693      */
 694     if (fontMetrics.tmHeight > icon_height)
 695       item_height = fontMetrics.tmHeight;
 696     else
 697       item_height = icon_height;
 698
 699     /*
 700      * Make sure there is enough space for the letters + icon + growing the
 701      * selected item + extra space for the selected item.
 702      */
 703     infoPtr->tabHeight = item_height + 2*VERTICAL_ITEM_PADDING +
 704       SELECTED_TAB_OFFSET;
 705   }
 706
 707   for (curItem = 0; curItem < infoPtr->uNumItem; curItem++)
 708   {
 709     /*
 710      * Calculate the vertical position of the tab
 711      */
 712     if (lStyle & TCS_BOTTOM)
 713     {
 714       infoPtr->items[curItem].rect.bottom = clientRect.bottom -
 715                                             SELECTED_TAB_OFFSET;
 716       infoPtr->items[curItem].rect.top = clientRect.bottom -
 717                                          infoPtr->tabHeight;
 718     }
 719     else
 720     {
 721       infoPtr->items[curItem].rect.top = clientRect.top +
 722                                          SELECTED_TAB_OFFSET;
 723       infoPtr->items[curItem].rect.bottom = clientRect.top +
 724                                             infoPtr->tabHeight;
 725     }
 726
 727     /*
 728      * Set the leftmost position of the tab.
 729      */
 730     infoPtr->items[curItem].rect.left = curItemLeftPos;
 731
 732     if ( (lStyle & TCS_FIXEDWIDTH) || ((lStyle & TCS_OWNERDRAWFIXED) && infoPtr->fSizeSet))
 733     {
 734       infoPtr->items[curItem].rect.right = infoPtr->items[curItem].rect.left +
 735                                            infoPtr->tabWidth +
 736                                            2*HORIZONTAL_ITEM_PADDING;
 737     }
 738     else
 739     {
 740       int icon_width  = 0;
 741       int num = 2;
 742
 743       /*
 744        * Calculate how wide the tab is depending on the text it contains
 745        */
 746       GetTextExtentPoint32A(hdc, infoPtr->items[curItem].pszText,
 747                             lstrlenA(infoPtr->items[curItem].pszText), &size);
 748
 749       /*
 750        * Add the icon width
 751        */
 752       if (infoPtr->himl)
 753       {
 754         ImageList_GetIconSize(infoPtr->himl, &icon_width, 0);
 755         num++;
 756       }
 757
 758       infoPtr->items[curItem].rect.right = infoPtr->items[curItem].rect.left +
 759                                            size.cx + icon_width +
 760                                            num*HORIZONTAL_ITEM_PADDING;
 761     }
 762
 763     TRACE("TextSize: %i\n ", size.cx);
 764     TRACE("Rect: T %i, L %i, B %i, R %i\n",
 765           infoPtr->items[curItem].rect.top,
 766           infoPtr->items[curItem].rect.left,
 767           infoPtr->items[curItem].rect.bottom,
 768           infoPtr->items[curItem].rect.right);
 769
 770     /*
 771      * The leftmost position of the next item is the rightmost position
 772      * of this one.
 773      */
 774     if (lStyle & TCS_BUTTONS)
 775       curItemLeftPos = infoPtr->items[curItem].rect.right + BUTTON_SPACINGX;
 776     else
 777       curItemLeftPos = infoPtr->items[curItem].rect.right;
 778   }
 779
 780   /*
 781    * Check if we need a scrolling control.
 782    */
 783   infoPtr->needsScrolling = (curItemLeftPos + (2*SELECTED_TAB_OFFSET) >
 784                              clientRect.right);
 785
 786   TAB_SetupScrolling(hwnd, infoPtr, &clientRect);
 787
 788   /*
 789    * Cleanup
 790    */
 791   SelectObject (hdc, hOldFont);
 792   ReleaseDC (hwnd, hdc);
 793 }
 794
 795 /******************************************************************************
 796  * TAB_DrawItem
 797  *
 798  * This method is used to draw a single tab into the tab control.
 799  */
 800 static void TAB_DrawItem(
 801   HWND hwnd,
 802   HDC  hdc,
 803   INT  iItem)
 804 {
 805   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
 806   LONG      lStyle  = GetWindowLongA(hwnd, GWL_STYLE);
 807   RECT      itemRect;
 808   RECT      selectedRect;
 809   BOOL      isVisible;
 810   RECT      r;
 811
 812   /*
 813    * Get the rectangle for the item.
 814    */
 815   isVisible = TAB_InternalGetItemRect(hwnd,
 816                                       infoPtr,
 817                                       iItem,
 818                                       &itemRect,
 819                                       &selectedRect);
 820
 821   if (isVisible)
 822   {
 823     HBRUSH hbr       = CreateSolidBrush (GetSysColor(COLOR_BTNFACE));
 824     HPEN   hwPen     = GetSysColorPen (COLOR_3DHILIGHT);
 825     HPEN   hbPen     = GetSysColorPen (COLOR_BTNSHADOW);
 826     HPEN   hsdPen    = GetSysColorPen (COLOR_BTNTEXT);
 827     HPEN   hfocusPen = CreatePen(PS_DOT, 1, GetSysColor(COLOR_BTNTEXT));
 828     HPEN   holdPen;
 829     INT    oldBkMode;
 830     INT    cx,cy;
 831     BOOL   deleteBrush = TRUE;
 832
 833     if (lStyle & TCS_BUTTONS)
 834     {
 835       /*
 836        * Get item rectangle.
 837        */
 838       r = itemRect;
 839
 840       holdPen = SelectObject (hdc, hwPen);
 841
 842       if (iItem == infoPtr->iSelected)
 843       {
 844         /*
 845          * Background color.
 846          */
 847         if (!((lStyle & TCS_OWNERDRAWFIXED) && infoPtr->fSizeSet))
 848         {
 849               COLORREF bk = GetSysColor(COLOR_3DHILIGHT);
 850           DeleteObject(hbr);
 851               hbr = GetSysColorBrush(COLOR_SCROLLBAR);
 852               SetTextColor(hdc, GetSysColor(COLOR_3DFACE));
 853               SetBkColor(hdc, bk);
 854
 855               /* if COLOR_WINDOW happens to be the same as COLOR_3DHILIGHT
 856                * we better use 0x55aa bitmap brush to make scrollbar's background
 857                * look different from the window background.
 858                */
 859               if (bk == GetSysColor(COLOR_WINDOW))
 860                   hbr = CACHE_GetPattern55AABrush();
 861
 862               deleteBrush = FALSE;
 863         }
 864
 865         /*
 866          * Erase the background.
 867          */
 868         FillRect(hdc, &r, hbr);
 869
 870         /*
 871          * Draw the tab now.
 872          * The rectangles calculated exclude the right and bottom
 873          * borders of the rectangle. To simply the following code, those
 874          * borders are shaved-off beforehand.
 875          */
 876         r.right--;
 877         r.bottom--;
 878
 879         /* highlight */
 880         MoveToEx (hdc, r.left, r.bottom, NULL);
 881         LineTo   (hdc, r.right, r.bottom);
 882         LineTo   (hdc, r.right, r.top);
 883
 884         /* shadow */
 885         SelectObject(hdc, hbPen);
 886         LineTo  (hdc, r.left, r.top);
 887         LineTo  (hdc, r.left, r.bottom);
 888       }
 889       else
 890       {
 891         /*
 892          * Erase the background.
 893          */
 894         FillRect(hdc, &r, hbr);
 895
 896         /* highlight */
 897         MoveToEx (hdc, r.left, r.bottom, NULL);
 898         LineTo   (hdc, r.left, r.top);
 899         LineTo   (hdc, r.right, r.top);
 900
 901         /* shadow */
 902         SelectObject(hdc, hbPen);
 903         LineTo  (hdc, r.right, r.bottom);
 904         LineTo  (hdc, r.left, r.bottom);
 905       }
 906     }
 907     else
 908     {
 909       /*
 910        * Background color.
 911        */
 912       DeleteObject(hbr);
 913       hbr = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
 914
 915       /*
 916        * We draw a rectangle of different sizes depending on the selection
 917        * state.
 918        */
 919       if (iItem == infoPtr->iSelected)
 920         r = selectedRect;
 921       else
 922         r = itemRect;
 923
 924       /*
 925        * Erase the background.
 926        * This is necessary when drawing the selected item since it is larger
 927        * than the others, it might overlap with stuff already drawn by the
 928        * other tabs
 929        */
 930       FillRect(hdc, &r, hbr);
 931
 932       /*
 933        * Draw the tab now.
 934        * The rectangles calculated exclude the right and bottom
 935        * borders of the rectangle. To simply the following code, those
 936        * borders are shaved-off beforehand.
 937        */
 938       r.right--;
 939       r.bottom--;
 940
 941       holdPen = SelectObject (hdc, hwPen);
 942
 943       if (lStyle & TCS_BOTTOM)
 944       {
 945         /* highlight */
 946         MoveToEx (hdc, r.left, r.top, NULL);
 947         LineTo   (hdc, r.left, r.bottom - ROUND_CORNER_SIZE);
 948         LineTo   (hdc, r.left + ROUND_CORNER_SIZE, r.bottom);
 949
 950         /* shadow */
 951         SelectObject(hdc, hbPen);
 952         LineTo  (hdc, r.right - ROUND_CORNER_SIZE, r.bottom);
 953         LineTo  (hdc, r.right, r.bottom - ROUND_CORNER_SIZE);
 954         LineTo  (hdc, r.right, r.top);
 955       }
 956       else
 957       {
 958         /* highlight */
 959         MoveToEx (hdc, r.left, r.bottom, NULL);
 960         LineTo   (hdc, r.left, r.top + ROUND_CORNER_SIZE);
 961         LineTo   (hdc, r.left + ROUND_CORNER_SIZE, r.top);
 962         LineTo   (hdc, r.right - ROUND_CORNER_SIZE, r.top);
 963
 964         /* shadow */
 965         SelectObject(hdc, hbPen);
 966         LineTo (hdc, r.right,  r.top + ROUND_CORNER_SIZE);
 967         LineTo (hdc, r.right,  r.bottom);
 968       }
 969     }
 970
 971     /*
 972      * Text pen
 973      */
 974     SelectObject(hdc, hsdPen);
 975
 976     oldBkMode = SetBkMode(hdc, TRANSPARENT);
 977     SetTextColor (hdc, COLOR_BTNTEXT);
 978
 979     /*
 980      * Deflate the rectangle to acount for the padding
 981      */
 982     InflateRect(&r, -HORIZONTAL_ITEM_PADDING, -VERTICAL_ITEM_PADDING);
 983
 984     /*
 985      * if owner draw, tell the owner to draw
 986      */
 987     if ( (lStyle & TCS_OWNERDRAWFIXED) && GetParent(hwnd) )
 988     {
 989         DRAWITEMSTRUCT dis;
 990         WND *pwndPtr;
 991         UINT id;
 992
 993         /*
 994          * get the control id
 995          */
 996         pwndPtr = WIN_FindWndPtr( hwnd );
 997         id = pwndPtr->wIDmenu;
 998         WIN_ReleaseWndPtr(pwndPtr);
 999
1000         /*
1001          * put together the DRAWITEMSTRUCT
1002          */
1003         dis.CtlType    = ODT_TAB;
1004         dis.CtlID      = id;
1005         dis.itemID     = iItem;
1006         dis.itemAction = ODA_DRAWENTIRE;
1007         if ( iItem == infoPtr->iSelected )
1008             dis.itemState = ODS_SELECTED;
1009         else
1010             dis.itemState = 0;
1011         dis.hwndItem = hwnd;            /* */
1012         dis.hDC      = hdc;
1013         dis.rcItem   = r;               /* */
1014         dis.itemData = infoPtr->items[iItem].lParam;
1015
1016         /*
1017          * send the draw message
1018          */
1019         SendMessageA( GetParent(hwnd), WM_DRAWITEM, (WPARAM)id, (LPARAM)&dis );
1020     }
1021     else
1022     {
1023         /*
1024          * If not owner draw, then do the drawing ourselves.
1025          *
1026      * Draw the icon.
1027      */
1028     if (infoPtr->himl && (infoPtr->items[iItem].mask & TCIF_IMAGE) )
1029     {
1030       ImageList_Draw (infoPtr->himl, infoPtr->items[iItem].iImage, hdc,
1031                       r.left, r.top+1, ILD_NORMAL);
1032       ImageList_GetIconSize (infoPtr->himl, &cx, &cy);
1033       r.left+=(cx + HORIZONTAL_ITEM_PADDING);
1034     }
1035
1036     /*
1037      * Draw the text;
1038      */
1039     DrawTextA(hdc,
1040               infoPtr->items[iItem].pszText,
1041               lstrlenA(infoPtr->items[iItem].pszText),
1042               &r,
1043               DT_LEFT|DT_SINGLELINE|DT_VCENTER);
1044     }
1045
1046     /*
1047      * Draw the focus rectangle
1048      */
1049     if (((lStyle & TCS_FOCUSNEVER) == 0) &&
1050          (GetFocus() == hwnd) &&
1051          (iItem == infoPtr->uFocus) )
1052     {
1053       InflateRect(&r, FOCUS_RECT_HOFFSET, FOCUS_RECT_VOFFSET);
1054
1055       SelectObject(hdc, hfocusPen);
1056
1057       MoveToEx (hdc, r.left,    r.top, NULL);
1058       LineTo   (hdc, r.right-1, r.top);
1059       LineTo   (hdc, r.right-1, r.bottom -1);
1060       LineTo   (hdc, r.left,    r.bottom -1);
1061       LineTo   (hdc, r.left,    r.top);
1062     }
1063
1064     /*
1065      * Cleanup
1066      */
1067     SetBkMode(hdc, oldBkMode);
1068     SelectObject(hdc, holdPen);
1069     DeleteObject(hfocusPen);
1070     if (deleteBrush) DeleteObject(hbr);
1071   }
1072 }
1073
1074 /******************************************************************************
1075  * TAB_DrawBorder
1076  *
1077  * This method is used to draw the raised border around the tab control
1078  * "content" area.
1079  */
1080 static void TAB_DrawBorder (HWND hwnd, HDC hdc)
1081 {
1082   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1083   HPEN htmPen;
1084   HPEN hwPen  = GetSysColorPen (COLOR_3DHILIGHT);
1085   HPEN hbPen  = GetSysColorPen (COLOR_3DDKSHADOW);
1086   HPEN hShade = GetSysColorPen (COLOR_BTNSHADOW);
1087   RECT rect;
1088
1089   GetClientRect (hwnd, &rect);
1090
1091   /*
1092    * Adjust for the style
1093    */
1094   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
1095   {
1096     rect.bottom -= infoPtr->tabHeight;
1097   }
1098   else
1099   {
1100     rect.top += infoPtr->tabHeight;
1101   }
1102
1103   /*
1104    * Shave-off the right and bottom margins (exluded in the
1105    * rect)
1106    */
1107   rect.right--;
1108   rect.bottom--;
1109
1110   /* highlight */
1111   htmPen = SelectObject (hdc, hwPen);
1112
1113   MoveToEx (hdc, rect.left, rect.bottom, NULL);
1114   LineTo (hdc, rect.left, rect.top);
1115   LineTo (hdc, rect.right, rect.top);
1116
1117   /* Dark Shadow */
1118   SelectObject (hdc, hbPen);
1119   LineTo (hdc, rect.right, rect.bottom );
1120   LineTo (hdc, rect.left, rect.bottom);
1121
1122   /* shade */
1123   SelectObject (hdc, hShade );
1124   MoveToEx (hdc, rect.right-1, rect.top, NULL);
1125   LineTo   (hdc, rect.right-1, rect.bottom-1);
1126   LineTo   (hdc, rect.left,    rect.bottom-1);
1127
1128   SelectObject(hdc, htmPen);
1129 }
1130
1131 /******************************************************************************
1132  * TAB_Refresh
1133  *
1134  * This method repaints the tab control..
1135  */
1136 static void TAB_Refresh (HWND hwnd, HDC hdc)
1137 {
1138   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1139   HFONT hOldFont;
1140   INT i;
1141
1142   if (!infoPtr->DoRedraw)
1143     return;
1144
1145   hOldFont = SelectObject (hdc, infoPtr->hFont);
1146
1147   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BUTTONS)
1148   {
1149     for (i = 0; i < infoPtr->uNumItem; i++)
1150     {
1151         TAB_DrawItem (hwnd, hdc, i);
1152     }
1153   }
1154   else
1155   {
1156     /*
1157      * Draw all the non selected item first.
1158      */
1159     for (i = 0; i < infoPtr->uNumItem; i++)
1160     {
1161       if (i != infoPtr->iSelected)
1162         TAB_DrawItem (hwnd, hdc, i);
1163     }
1164
1165     /*
1166      * Now, draw the border, draw it before the selected item
1167      * since the selected item overwrites part of the border.
1168      */
1169     TAB_DrawBorder (hwnd, hdc);
1170
1171     /*
1172      * Then, draw the selected item
1173      */
1174     TAB_DrawItem (hwnd, hdc, infoPtr->iSelected);
1175   }
1176
1177   SelectObject (hdc, hOldFont);
1178 }
1179
1180 static LRESULT
1181 TAB_SetRedraw (HWND hwnd, WPARAM wParam)
1182 {
1183     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1184
1185   infoPtr->DoRedraw=(BOOL) wParam;
1186   return 0;
1187 }
1188
1189 static LRESULT TAB_EraseBackground(
1190   HWND hwnd,
1191   HDC  givenDC)
1192 {
1193   HDC  hdc;
1194   RECT clientRect;
1195
1196   HBRUSH brush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
1197
1198   hdc = givenDC ? givenDC : GetDC(hwnd);
1199
1200   GetClientRect(hwnd, &clientRect);
1201
1202   FillRect(hdc, &clientRect, brush);
1203
1204   if (givenDC==0)
1205     ReleaseDC(hwnd, hdc);
1206
1207   DeleteObject(brush);
1208
1209   return 0;
1210 }
1211
1212 /******************************************************************************
1213  * TAB_EnsureSelectionVisible
1214  *
1215  * This method will make sure that the current selection is completely
1216  * visible by scrolling until it is.
1217  */
1218 static void TAB_EnsureSelectionVisible(
1219   HWND      hwnd,
1220   TAB_INFO* infoPtr)
1221 {
1222   INT iSelected = infoPtr->iSelected;
1223
1224   /*
1225    * Do the trivial cases first.
1226    */
1227   if ( (!infoPtr->needsScrolling) ||
1228        (infoPtr->hwndUpDown==0) )
1229     return;
1230
1231   if (infoPtr->leftmostVisible >= iSelected)
1232   {
1233     infoPtr->leftmostVisible = iSelected;
1234   }
1235   else
1236   {
1237      RECT r;
1238      INT  width, i;
1239      /*
1240       * Calculate the part of the client area that is visible.
1241       */
1242      GetClientRect(hwnd, &r);
1243      width = r.right;
1244
1245      GetClientRect(infoPtr->hwndUpDown, &r);
1246      width -= r.right;
1247
1248      if ((infoPtr->items[iSelected].rect.right -
1249           infoPtr->items[iSelected].rect.left) >= width )
1250      {
1251         /* Special case: width of selected item is greater than visible
1252          * part of control.
1253          */
1254         infoPtr->leftmostVisible = iSelected;
1255      }
1256      else
1257      {
1258         for (i = infoPtr->leftmostVisible; i < infoPtr->uNumItem; i++)
1259         {
1260            if ((infoPtr->items[iSelected].rect.right -
1261                 infoPtr->items[i].rect.left) < width)
1262               break;
1263         }
1264         infoPtr->leftmostVisible = i;
1265      }
1266   }
1267
1268   SendMessageA(infoPtr->hwndUpDown, UDM_SETPOS, 0,
1269                MAKELONG(infoPtr->leftmostVisible, 0));
1270 }
1271
1272 /******************************************************************************
1273  * TAB_InvalidateTabArea
1274  *
1275  * This method will invalidate the portion of the control that contains the
1276  * tabs. It is called when the state of the control changes and needs
1277  * to be redisplayed
1278  */
1279 static void TAB_InvalidateTabArea(
1280   HWND      hwnd,
1281   TAB_INFO* infoPtr)
1282 {
1283   RECT clientRect;
1284
1285   GetClientRect(hwnd, &clientRect);
1286
1287   if (GetWindowLongA(hwnd, GWL_STYLE) & TCS_BOTTOM)
1288   {
1289     clientRect.top = clientRect.bottom - (infoPtr->tabHeight + 3);
1290   }
1291   else
1292   {
1293     clientRect.bottom = clientRect.top + (infoPtr->tabHeight + 1);
1294   }
1295
1296   InvalidateRect(hwnd, &clientRect, TRUE);
1297 }
1298
1299 static LRESULT
1300 TAB_Paint (HWND hwnd, WPARAM wParam)
1301 {
1302   HDC hdc;
1303   PAINTSTRUCT ps;
1304
1305   hdc = wParam== 0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1306   TAB_Refresh (hwnd, hdc);
1307
1308   if(!wParam)
1309     EndPaint (hwnd, &ps);
1310
1311   return 0;
1312 }
1313
1314 static LRESULT
1315 TAB_InsertItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
1316 {
1317   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1318   TCITEMA *pti;
1319   INT iItem, len;
1320   RECT rect;
1321
1322   GetClientRect (hwnd, &rect);
1323   TRACE("Rect: %x T %i, L %i, B %i, R %i\n", hwnd,
1324         rect.top, rect.left, rect.bottom, rect.right);
1325
1326   pti = (TCITEMA *)lParam;
1327   iItem = (INT)wParam;
1328
1329   if (iItem < 0) return -1;
1330   if (iItem > infoPtr->uNumItem)
1331     iItem = infoPtr->uNumItem;
1332
1333   if (infoPtr->uNumItem == 0) {
1334     infoPtr->items = COMCTL32_Alloc (sizeof (TAB_ITEM));
1335     infoPtr->uNumItem++;
1336     infoPtr->iSelected = 0;
1337   }
1338   else {
1339     TAB_ITEM *oldItems = infoPtr->items;
1340
1341     infoPtr->uNumItem++;
1342     infoPtr->items = COMCTL32_Alloc (sizeof (TAB_ITEM) * infoPtr->uNumItem);
1343
1344     /* pre insert copy */
1345     if (iItem > 0) {
1346       memcpy (&infoPtr->items[0], &oldItems[0],
1347               iItem * sizeof(TAB_ITEM));
1348     }
1349
1350     /* post insert copy */
1351     if (iItem < infoPtr->uNumItem - 1) {
1352       memcpy (&infoPtr->items[iItem+1], &oldItems[iItem],
1353               (infoPtr->uNumItem - iItem - 1) * sizeof(TAB_ITEM));
1354
1355     }
1356
1357     if (iItem <= infoPtr->iSelected)
1358       infoPtr->iSelected++;
1359
1360     COMCTL32_Free (oldItems);
1361   }
1362
1363   infoPtr->items[iItem].mask = pti->mask;
1364   if (pti->mask & TCIF_TEXT) {
1365     len = lstrlenA (pti->pszText);
1366     infoPtr->items[iItem].pszText = COMCTL32_Alloc (len+1);
1367     lstrcpyA (infoPtr->items[iItem].pszText, pti->pszText);
1368     infoPtr->items[iItem].cchTextMax = pti->cchTextMax;
1369   }
1370
1371   if (pti->mask & TCIF_IMAGE)
1372     infoPtr->items[iItem].iImage = pti->iImage;
1373
1374   if (pti->mask & TCIF_PARAM)
1375     infoPtr->items[iItem].lParam = pti->lParam;
1376
1377   TAB_InvalidateTabArea(hwnd, infoPtr);
1378
1379   TRACE("[%04x]: added item %d '%s'\n",
1380         hwnd, iItem, infoPtr->items[iItem].pszText);
1381
1382   TAB_SetItemBounds(hwnd);
1383   return iItem;
1384 }
1385
1386 static LRESULT
1387 TAB_SetItemSize (HWND hwnd, WPARAM wParam, LPARAM lParam)
1388 {
1389   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1390   LONG lStyle = GetWindowLongA(hwnd, GWL_STYLE);
1391   LONG lResult = 0;
1392
1393   if ((lStyle & TCS_FIXEDWIDTH) || (lStyle & TCS_OWNERDRAWFIXED))
1394   {
1395     lResult = MAKELONG(infoPtr->tabWidth, infoPtr->tabHeight);
1396     infoPtr->tabWidth = (INT)LOWORD(lParam);
1397     infoPtr->tabHeight = (INT)HIWORD(lParam);
1398   }
1399   infoPtr->fSizeSet = TRUE;
1400
1401   return lResult;
1402 }
1403
1404 static LRESULT
1405 TAB_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1406 {
1407   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1408   TCITEMA *tabItem;
1409   TAB_ITEM *wineItem;
1410   INT    iItem,len;
1411
1412   iItem=(INT) wParam;
1413   tabItem=(LPTCITEMA ) lParam;
1414   TRACE("%d %p\n",iItem, tabItem);
1415   if ((iItem<0) || (iItem>=infoPtr->uNumItem)) return FALSE;
1416
1417   wineItem=& infoPtr->items[iItem];
1418
1419   if (tabItem->mask & TCIF_IMAGE)
1420     wineItem->iImage=tabItem->iImage;
1421
1422   if (tabItem->mask & TCIF_PARAM)
1423     wineItem->lParam=tabItem->lParam;
1424
1425   if (tabItem->mask & TCIF_RTLREADING)
1426     FIXME("TCIF_RTLREADING\n");
1427
1428   if (tabItem->mask & TCIF_STATE)
1429     wineItem->dwState=tabItem->dwState;
1430
1431   if (tabItem->mask & TCIF_TEXT) {
1432    len=lstrlenA (tabItem->pszText);
1433    if (len>wineItem->cchTextMax)
1434      wineItem->pszText= COMCTL32_ReAlloc (wineItem->pszText, len+1);
1435    lstrcpyA (wineItem->pszText, tabItem->pszText);
1436   }
1437
1438   /*
1439    * Update and repaint tabs.
1440    */
1441   TAB_SetItemBounds(hwnd);
1442   TAB_InvalidateTabArea(hwnd,infoPtr);
1443
1444   return TRUE;
1445 }
1446
1447 static LRESULT
1448 TAB_GetItemCount (HWND hwnd, WPARAM wParam, LPARAM lParam)
1449 {
1450    TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1451
1452    return infoPtr->uNumItem;
1453 }
1454
1455
1456 static LRESULT
1457 TAB_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1458 {
1459    TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1460    TCITEMA *tabItem;
1461    TAB_ITEM *wineItem;
1462    INT    iItem;
1463
1464   iItem=(INT) wParam;
1465   tabItem=(LPTCITEMA) lParam;
1466   TRACE("\n");
1467   if ((iItem<0) || (iItem>=infoPtr->uNumItem)) return FALSE;
1468
1469   wineItem=& infoPtr->items[iItem];
1470
1471   if (tabItem->mask & TCIF_IMAGE)
1472     tabItem->iImage=wineItem->iImage;
1473
1474   if (tabItem->mask & TCIF_PARAM)
1475     tabItem->lParam=wineItem->lParam;
1476
1477   if (tabItem->mask & TCIF_RTLREADING)
1478     FIXME("TCIF_RTLREADING\n");
1479
1480   if (tabItem->mask & TCIF_STATE)
1481     tabItem->dwState=wineItem->dwState;
1482
1483   if (tabItem->mask & TCIF_TEXT)
1484    lstrcpynA (tabItem->pszText, wineItem->pszText, tabItem->cchTextMax);
1485
1486   return TRUE;
1487 }
1488
1489 static LRESULT
1490 TAB_DeleteItem (HWND hwnd, WPARAM wParam, LPARAM lParam)
1491 {
1492   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1493   INT iItem = (INT) wParam;
1494   BOOL bResult = FALSE;
1495
1496   if ((iItem >= 0) && (iItem < infoPtr->uNumItem))
1497   {
1498     TAB_ITEM *oldItems = infoPtr->items;
1499
1500     infoPtr->uNumItem--;
1501     infoPtr->items = COMCTL32_Alloc(sizeof (TAB_ITEM) * infoPtr->uNumItem);
1502
1503     if (iItem > 0)
1504       memcpy(&infoPtr->items[0], &oldItems[0], iItem * sizeof(TAB_ITEM));
1505
1506     if (iItem < infoPtr->uNumItem)
1507       memcpy(&infoPtr->items[iItem], &oldItems[iItem + 1],
1508               (infoPtr->uNumItem - iItem) * sizeof(TAB_ITEM));
1509
1510     COMCTL32_Free (oldItems);
1511
1512     /*
1513      * Readjust the selected index.
1514      */
1515     if ((iItem == infoPtr->iSelected) && (iItem > 0))
1516       infoPtr->iSelected--;
1517
1518     if (iItem < infoPtr->iSelected)
1519       infoPtr->iSelected--;
1520
1521     if (infoPtr->uNumItem == 0)
1522       infoPtr->iSelected = -1;
1523
1524     /*
1525      * Reposition and repaint tabs.
1526      */
1527     TAB_SetItemBounds(hwnd);
1528     TAB_InvalidateTabArea(hwnd,infoPtr);
1529
1530     bResult = TRUE;
1531   }
1532
1533   return bResult;
1534 }
1535
1536 static LRESULT
1537 TAB_DeleteAllItems (HWND hwnd, WPARAM wParam, LPARAM lParam)
1538 {
1539    TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1540
1541   COMCTL32_Free (infoPtr->items);
1542   infoPtr->uNumItem = 0;
1543   infoPtr->iSelected = -1;
1544
1545   TAB_SetItemBounds(hwnd);
1546   TAB_InvalidateTabArea(hwnd,infoPtr);
1547   return TRUE;
1548 }
1549
1550
1551 static LRESULT
1552 TAB_GetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1553 {
1554   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1555
1556   TRACE("\n");
1557   return (LRESULT)infoPtr->hFont;
1558 }
1559
1560 static LRESULT
1561 TAB_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1562
1563 {
1564   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1565
1566   TRACE("%x %lx\n",wParam, lParam);
1567
1568   infoPtr->hFont = (HFONT)wParam;
1569
1570   TAB_SetItemBounds(hwnd);
1571
1572   TAB_InvalidateTabArea(hwnd, infoPtr);
1573
1574   return 0;
1575 }
1576
1577
1578 static LRESULT
1579 TAB_GetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1580 {
1581   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1582
1583   TRACE("\n");
1584   return (LRESULT)infoPtr->himl;
1585 }
1586
1587 static LRESULT
1588 TAB_SetImageList (HWND hwnd, WPARAM wParam, LPARAM lParam)
1589 {
1590     TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1591     HIMAGELIST himlPrev;
1592
1593     TRACE("\n");
1594     himlPrev = infoPtr->himl;
1595     infoPtr->himl= (HIMAGELIST)lParam;
1596     return (LRESULT)himlPrev;
1597 }
1598
1599
1600 static LRESULT
1601 TAB_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1602
1603 {
1604 /* I'm not really sure what the following code was meant to do.
1605    This is what it is doing:
1606    When WM_SIZE is sent with SIZE_RESTORED, the control
1607    gets positioned in the top left corner.
1608
1609   RECT parent_rect;
1610   HWND parent;
1611   UINT uPosFlags,cx,cy;
1612
1613   uPosFlags=0;
1614   if (!wParam) {
1615     parent = GetParent (hwnd);
1616     GetClientRect(parent, &parent_rect);
1617     cx=LOWORD (lParam);
1618     cy=HIWORD (lParam);
1619     if (GetWindowLongA(hwnd, GWL_STYLE) & CCS_NORESIZE)
1620         uPosFlags |= (SWP_NOSIZE | SWP_NOMOVE);
1621
1622     SetWindowPos (hwnd, 0, parent_rect.left, parent_rect.top,
1623             cx, cy, uPosFlags | SWP_NOZORDER);
1624   } else {
1625     FIXME (tab,"WM_SIZE flag %x %lx not handled\n", wParam, lParam);
1626   } */
1627
1628   /*
1629    * Recompute the size/position of the tabs.
1630    */
1631   TAB_SetItemBounds (hwnd);
1632
1633   /*
1634    * Force a repaint of the control.
1635    */
1636   InvalidateRect(hwnd, NULL, TRUE);
1637
1638   return 0;
1639 }
1640
1641
1642 static LRESULT
1643 TAB_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1644 {
1645   TAB_INFO *infoPtr;
1646   TEXTMETRICA fontMetrics;
1647   HDC hdc;
1648   HFONT hOldFont;
1649   DWORD dwStyle;
1650
1651   infoPtr = (TAB_INFO *)COMCTL32_Alloc (sizeof(TAB_INFO));
1652
1653   SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
1654
1655   infoPtr->uNumItem        = 0;
1656   infoPtr->hFont           = 0;
1657   infoPtr->items           = 0;
1658   infoPtr->hcurArrow       = LoadCursorA (0, IDC_ARROWA);
1659   infoPtr->iSelected       = -1;
1660   infoPtr->uFocus          = 0;
1661   infoPtr->hwndToolTip     = 0;
1662   infoPtr->DoRedraw        = TRUE;
1663   infoPtr->needsScrolling  = FALSE;
1664   infoPtr->hwndUpDown      = 0;
1665   infoPtr->leftmostVisible = 0;
1666   infoPtr->fSizeSet        = FALSE;
1667
1668   TRACE("Created tab control, hwnd [%04x]\n", hwnd);
1669
1670   /* The tab control always has the WS_CLIPSIBLINGS style. Even
1671      if you don't specify in CreateWindow. This is necesary in
1672      order for paint to work correctly. This follows windows behaviour. */
1673   dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1674   SetWindowLongA(hwnd, GWL_STYLE, dwStyle|WS_CLIPSIBLINGS);
1675
1676   if (dwStyle & TCS_TOOLTIPS) {
1677     /* Create tooltip control */
1678     infoPtr->hwndToolTip =
1679       CreateWindowExA (0, TOOLTIPS_CLASSA, NULL, 0,
1680                        CW_USEDEFAULT, CW_USEDEFAULT,
1681                        CW_USEDEFAULT, CW_USEDEFAULT,
1682                        hwnd, 0, 0, 0);
1683
1684     /* Send NM_TOOLTIPSCREATED notification */
1685     if (infoPtr->hwndToolTip) {
1686       NMTOOLTIPSCREATED nmttc;
1687
1688       nmttc.hdr.hwndFrom = hwnd;
1689       nmttc.hdr.idFrom = GetWindowLongA(hwnd, GWL_ID);
1690       nmttc.hdr.code = NM_TOOLTIPSCREATED;
1691       nmttc.hwndToolTips = infoPtr->hwndToolTip;
1692
1693       SendMessageA (GetParent (hwnd), WM_NOTIFY,
1694                     (WPARAM)GetWindowLongA(hwnd, GWL_ID), (LPARAM)&nmttc);
1695     }
1696   }
1697
1698   /*
1699    * We need to get text information so we need a DC and we need to select
1700    * a font.
1701    */
1702   hdc = GetDC(hwnd);
1703   hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
1704
1705   /*
1706    * Use the system font to determine the initial height of a tab.
1707    */
1708   GetTextMetricsA(hdc, &fontMetrics);
1709
1710   /*
1711    * Make sure there is enough space for the letters + growing the
1712    * selected item + extra space for the selected item.
1713    */
1714   infoPtr->tabHeight = fontMetrics.tmHeight + 2*VERTICAL_ITEM_PADDING +
1715                        SELECTED_TAB_OFFSET;
1716
1717   /*
1718    * Initialize the width of a tab.
1719    */
1720   infoPtr->tabWidth = DEFAULT_TAB_WIDTH;
1721
1722   SelectObject (hdc, hOldFont);
1723   ReleaseDC(hwnd, hdc);
1724
1725   return 0;
1726 }
1727
1728 static LRESULT
1729 TAB_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1730 {
1731   TAB_INFO *infoPtr = TAB_GetInfoPtr(hwnd);
1732   INT iItem;
1733
1734   if (!infoPtr)
1735       return 0;
1736
1737   if (infoPtr->items) {
1738     for (iItem = 0; iItem < infoPtr->uNumItem; iItem++) {
1739       if (infoPtr->items[iItem].pszText)
1740         COMCTL32_Free (infoPtr->items[iItem].pszText);
1741     }
1742     COMCTL32_Free (infoPtr->items);
1743   }
1744
1745   if (infoPtr->hwndToolTip)
1746     DestroyWindow (infoPtr->hwndToolTip);
1747
1748   if (infoPtr->hwndUpDown)
1749     DestroyWindow(infoPtr->hwndUpDown);
1750
1751   COMCTL32_Free (infoPtr);
1752   return 0;
1753 }
1754
1755 static LRESULT WINAPI
1756 TAB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1757 {
1758     switch (uMsg)
1759     {
1760     case TCM_GETIMAGELIST:
1761       return TAB_GetImageList (hwnd, wParam, lParam);
1762
1763     case TCM_SETIMAGELIST:
1764       return TAB_SetImageList (hwnd, wParam, lParam);
1765
1766     case TCM_GETITEMCOUNT:
1767       return TAB_GetItemCount (hwnd, wParam, lParam);
1768
1769     case TCM_GETITEMA:
1770       return TAB_GetItemA (hwnd, wParam, lParam);
1771
1772     case TCM_GETITEMW:
1773       FIXME("Unimplemented msg TCM_GETITEMW\n");
1774       return 0;
1775
1776     case TCM_SETITEMA:
1777       return TAB_SetItemA (hwnd, wParam, lParam);
1778
1779     case TCM_SETITEMW:
1780       FIXME("Unimplemented msg TCM_SETITEMW\n");
1781       return 0;
1782
1783     case TCM_DELETEITEM:
1784       return TAB_DeleteItem (hwnd, wParam, lParam);
1785
1786     case TCM_DELETEALLITEMS:
1787      return TAB_DeleteAllItems (hwnd, wParam, lParam);
1788
1789     case TCM_GETITEMRECT:
1790      return TAB_GetItemRect (hwnd, wParam, lParam);
1791
1792     case TCM_GETCURSEL:
1793       return TAB_GetCurSel (hwnd);
1794
1795     case TCM_HITTEST:
1796       return TAB_HitTest (hwnd, wParam, lParam);
1797
1798     case TCM_SETCURSEL:
1799       return TAB_SetCurSel (hwnd, wParam);
1800
1801     case TCM_INSERTITEMA:
1802       return TAB_InsertItem (hwnd, wParam, lParam);
1803
1804     case TCM_INSERTITEMW:
1805       FIXME("Unimplemented msg TCM_INSERTITEMW\n");
1806       return 0;
1807
1808     case TCM_SETITEMEXTRA:
1809       FIXME("Unimplemented msg TCM_SETITEMEXTRA\n");
1810       return 0;
1811
1812     case TCM_ADJUSTRECT:
1813       return TAB_AdjustRect (hwnd, (BOOL)wParam, (LPRECT)lParam);
1814
1815     case TCM_SETITEMSIZE:
1816       return TAB_SetItemSize (hwnd, wParam, lParam);
1817
1818     case TCM_REMOVEIMAGE:
1819       FIXME("Unimplemented msg TCM_REMOVEIMAGE\n");
1820       return 0;
1821
1822     case TCM_SETPADDING:
1823       FIXME("Unimplemented msg TCM_SETPADDING\n");
1824       return 0;
1825
1826     case TCM_GETROWCOUNT:
1827       FIXME("Unimplemented msg TCM_GETROWCOUNT\n");
1828       return 0;
1829
1830     case TCM_GETUNICODEFORMAT:
1831       FIXME("Unimplemented msg TCM_GETUNICODEFORMAT\n");
1832       return 0;
1833
1834     case TCM_SETUNICODEFORMAT:
1835       FIXME("Unimplemented msg TCM_SETUNICODEFORMAT\n");
1836       return 0;
1837
1838     case TCM_HIGHLIGHTITEM:
1839       FIXME("Unimplemented msg TCM_HIGHLIGHTITEM\n");
1840       return 0;
1841
1842     case TCM_GETTOOLTIPS:
1843       return TAB_GetToolTips (hwnd, wParam, lParam);
1844
1845     case TCM_SETTOOLTIPS:
1846       return TAB_SetToolTips (hwnd, wParam, lParam);
1847
1848     case TCM_GETCURFOCUS:
1849       return TAB_GetCurFocus (hwnd);
1850
1851     case TCM_SETCURFOCUS:
1852       return TAB_SetCurFocus (hwnd, wParam);
1853
1854     case TCM_SETMINTABWIDTH:
1855       FIXME("Unimplemented msg TCM_SETMINTABWIDTH\n");
1856       return 0;
1857
1858     case TCM_DESELECTALL:
1859       FIXME("Unimplemented msg TCM_DESELECTALL\n");
1860       return 0;
1861
1862     case TCM_GETEXTENDEDSTYLE:
1863       FIXME("Unimplemented msg TCM_GETEXTENDEDSTYLE\n");
1864       return 0;
1865
1866     case TCM_SETEXTENDEDSTYLE:
1867       FIXME("Unimplemented msg TCM_SETEXTENDEDSTYLE\n");
1868       return 0;
1869
1870     case WM_GETFONT:
1871       return TAB_GetFont (hwnd, wParam, lParam);
1872
1873     case WM_SETFONT:
1874       return TAB_SetFont (hwnd, wParam, lParam);
1875
1876     case WM_CREATE:
1877       return TAB_Create (hwnd, wParam, lParam);
1878
1879     case WM_NCDESTROY:
1880       return TAB_Destroy (hwnd, wParam, lParam);
1881
1882     case WM_GETDLGCODE:
1883       return DLGC_WANTARROWS | DLGC_WANTCHARS;
1884
1885     case WM_LBUTTONDOWN:
1886       return TAB_LButtonDown (hwnd, wParam, lParam);
1887
1888     case WM_LBUTTONUP:
1889       return TAB_LButtonUp (hwnd, wParam, lParam);
1890
1891     case WM_RBUTTONDOWN:
1892       return TAB_RButtonDown (hwnd, wParam, lParam);
1893
1894     case WM_MOUSEMOVE:
1895       return TAB_MouseMove (hwnd, wParam, lParam);
1896
1897     case WM_ERASEBKGND:
1898       return TAB_EraseBackground (hwnd, (HDC)wParam);
1899
1900     case WM_PAINT:
1901       return TAB_Paint (hwnd, wParam);
1902
1903     case WM_SIZE:
1904       return TAB_Size (hwnd, wParam, lParam);
1905
1906     case WM_SETREDRAW:
1907       return TAB_SetRedraw (hwnd, wParam);
1908
1909     case WM_HSCROLL:
1910       return TAB_OnHScroll(hwnd, (int)LOWORD(wParam), (int)HIWORD(wParam), (HWND)lParam);
1911
1912     case WM_STYLECHANGED:
1913       TAB_SetItemBounds (hwnd);
1914       InvalidateRect(hwnd, NULL, TRUE);
1915       return 0;
1916
1917     case WM_KILLFOCUS:
1918     case WM_SETFOCUS:
1919       return TAB_FocusChanging(hwnd, uMsg, wParam, lParam);
1920
1921     case WM_KEYUP:
1922       return TAB_KeyUp(hwnd, wParam);
1923
1924     default:
1925       if (uMsg >= WM_USER)
1926         ERR("unknown msg %04x wp=%08x lp=%08lx\n",
1927              uMsg, wParam, lParam);
1928       return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1929     }
1930
1931     return 0;
1932 }
1933
1934
1935 VOID
1936 TAB_Register (void)
1937 {
1938   WNDCLASSA wndClass;
1939
1940   ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1941   wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
1942   wndClass.lpfnWndProc   = (WNDPROC)TAB_WindowProc;
1943   wndClass.cbClsExtra    = 0;
1944   wndClass.cbWndExtra    = sizeof(TAB_INFO *);
1945   wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
1946   wndClass.hbrBackground = (HBRUSH)NULL;
1947   wndClass.lpszClassName = WC_TABCONTROLA;
1948
1949   RegisterClassA (&wndClass);
1950 }
1951
1952
1953 VOID
1954 TAB_Unregister (void)
1955 {
1956     UnregisterClassA (WC_TABCONTROLA, (HINSTANCE)NULL);
1957 }
1958