tab.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winnls.h"
#include "commctrl.h"
#include "comctl32.h"
#include "uxtheme.h"
#include "vssym32.h"
#include "wine/debug.h"
#include <math.h>

Include dependency graph for tab.c:

Go to the source code of this file.

Classes
struct	TAB_ITEM
struct	TAB_INFO

Macros
#define	EXTRA_ITEM_SIZE(infoPtr)   (max((infoPtr)->cbInfo, sizeof(LPARAM)))
#define	TAB_ITEM_SIZE(infoPtr)   FIELD_OFFSET(TAB_ITEM, extra[EXTRA_ITEM_SIZE(infoPtr)])
#define	SELECTED_TAB_OFFSET   2
#define	ROUND_CORNER_SIZE   2
#define	DISPLAY_AREA_PADDINGX   2
#define	DISPLAY_AREA_PADDINGY   2
#define	CONTROL_BORDER_SIZEX   2
#define	CONTROL_BORDER_SIZEY   2
#define	BUTTON_SPACINGX   3
#define	BUTTON_SPACINGY   3
#define	FLAT_BTN_SPACINGX   8
#define	DEFAULT_MIN_TAB_WIDTH   54
#define	DEFAULT_PADDING_X   6
#define	EXTRA_ICON_PADDING   3
#define	TAB_GetInfoPtr(hwnd)   ((TAB_INFO *)GetWindowLongPtrW(hwnd,0))
#define	GET_DEFAULT_MIN_TAB_WIDTH(infoPtr)   (DEFAULT_MIN_TAB_WIDTH - (DEFAULT_PADDING_X - (infoPtr)->uHItemPadding) * 2)
#define	TAB_HOTTRACK_TIMER   1
#define	TAB_HOTTRACK_TIMER_INTERVAL   100 /* milliseconds */

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (tab)
static TAB_ITEM *	TAB_GetItem (const TAB_INFO *infoPtr, INT i)
static void	TAB_InvalidateTabArea (const TAB_INFO *)
static void	TAB_EnsureSelectionVisible (TAB_INFO *)
static void	TAB_DrawItemInterior (const TAB_INFO *, HDC, INT, RECT *)
static LRESULT	TAB_DeselectAll (TAB_INFO *, BOOL)
static BOOL	TAB_InternalGetItemRect (const TAB_INFO *, INT, RECT *, RECT *)
static BOOL	TAB_SendSimpleNotify (const TAB_INFO *infoPtr, UINT code)
static void	TAB_RelayEvent (HWND hwndTip, HWND hwndMsg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static void	TAB_DumpItemExternalT (const TCITEMW *pti, UINT iItem, BOOL isW)
static void	TAB_DumpItemInternal (const TAB_INFO *infoPtr, UINT iItem)
static LRESULT	TAB_GetCurSel (const TAB_INFO *infoPtr)
static LRESULT	TAB_GetCurFocus (const TAB_INFO *infoPtr)
static LRESULT	TAB_GetToolTips (const TAB_INFO *infoPtr)
static LRESULT	TAB_SetCurSel (TAB_INFO *infoPtr, INT iItem)
static LRESULT	TAB_SetCurFocus (TAB_INFO *infoPtr, INT iItem)
static LRESULT	TAB_SetToolTips (TAB_INFO *infoPtr, HWND hwndToolTip)
static LRESULT	TAB_SetPadding (TAB_INFO *infoPtr, LPARAM lParam)
static BOOL	TAB_GetItemRect (const TAB_INFO *infoPtr, INT item, RECT *rect)
static LRESULT	TAB_KeyDown (TAB_INFO *infoPtr, WPARAM keyCode, LPARAM lParam)
static void	TAB_KillFocus (TAB_INFO *infoPtr)
static void	TAB_FocusChanging (const TAB_INFO *infoPtr)
static INT	TAB_InternalHitTest (const TAB_INFO *infoPtr, POINT pt, UINT *flags)
static LRESULT	TAB_HitTest (const TAB_INFO *infoPtr, LPTCHITTESTINFO lptest)
static LRESULT	TAB_NCHitTest (const TAB_INFO *infoPtr, LPARAM lParam)
static LRESULT	TAB_LButtonDown (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
static LRESULT	TAB_LButtonUp (const TAB_INFO *infoPtr)
static void	TAB_RButtonUp (const TAB_INFO *infoPtr)
static void	TAB_DrawLoneItemInterior (const TAB_INFO *infoPtr, int iItem)
static void	hottrack_refresh (const TAB_INFO *infoPtr, int tabIndex)
static void CALLBACK	TAB_HotTrackTimerProc (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
static void	TAB_RecalcHotTrack (TAB_INFO *infoPtr, const LPARAM *pos, int *out_redrawLeave, int *out_redrawEnter)
static LRESULT	TAB_MouseMove (TAB_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
static LRESULT	TAB_AdjustRect (const TAB_INFO *infoPtr, WPARAM fLarger, LPRECT prc)
static LRESULT	TAB_OnHScroll (TAB_INFO *infoPtr, int nScrollCode, int nPos)
static void	TAB_SetupScrolling (TAB_INFO *infoPtr, const RECT *clientRect)
static void	TAB_SetItemBounds (TAB_INFO *infoPtr)
static void	TAB_EraseTabInterior (const TAB_INFO *infoPtr, HDC hdc, INT iItem, const RECT *drawRect)
static void	TAB_DrawItem (const TAB_INFO *infoPtr, HDC hdc, INT iItem)
static void	TAB_DrawBorder (const TAB_INFO *infoPtr, HDC hdc)
static void	TAB_Refresh (const TAB_INFO *infoPtr, HDC hdc)
static DWORD	TAB_GetRowCount (const TAB_INFO *infoPtr)
static LRESULT	TAB_SetRedraw (TAB_INFO *infoPtr, BOOL doRedraw)
static LRESULT	TAB_Paint (TAB_INFO *infoPtr, HDC hdcPaint)
static LRESULT	TAB_InsertItemT (TAB_INFO *infoPtr, INT iItem, const TCITEMW *pti, BOOL bUnicode)
static LRESULT	TAB_SetItemSize (TAB_INFO *infoPtr, INT cx, INT cy)
static LRESULT	TAB_SetMinTabWidth (TAB_INFO *infoPtr, INT cx)
static LRESULT	TAB_HighlightItem (TAB_INFO *infoPtr, INT iItem, BOOL fHighlight)
static LRESULT	TAB_SetItemT (TAB_INFO *infoPtr, INT iItem, LPTCITEMW tabItem, BOOL bUnicode)
static LRESULT	TAB_GetItemCount (const TAB_INFO *infoPtr)
static LRESULT	TAB_GetItemT (TAB_INFO *infoPtr, INT iItem, LPTCITEMW tabItem, BOOL bUnicode)
static LRESULT	TAB_DeleteItem (TAB_INFO *infoPtr, INT iItem)
static LRESULT	TAB_DeleteAllItems (TAB_INFO *infoPtr)
static LRESULT	TAB_GetFont (const TAB_INFO *infoPtr)
static LRESULT	TAB_SetFont (TAB_INFO *infoPtr, HFONT hNewFont)
static LRESULT	TAB_GetImageList (const TAB_INFO *infoPtr)
static LRESULT	TAB_SetImageList (TAB_INFO *infoPtr, HIMAGELIST himlNew)
static LRESULT	TAB_GetUnicodeFormat (const TAB_INFO *infoPtr)
static LRESULT	TAB_SetUnicodeFormat (TAB_INFO *infoPtr, BOOL bUnicode)
static LRESULT	TAB_Size (TAB_INFO *infoPtr)
static LRESULT	TAB_Create (HWND hwnd, LPARAM lParam)
static LRESULT	TAB_Destroy (TAB_INFO *infoPtr)
static LRESULT	theme_changed (const TAB_INFO *infoPtr)
static LRESULT	TAB_NCCalcSize (WPARAM wParam)
static LRESULT	TAB_SetItemExtra (TAB_INFO *infoPtr, INT cbInfo)
static LRESULT	TAB_RemoveImage (TAB_INFO *infoPtr, INT image)
static LRESULT	TAB_SetExtendedStyle (TAB_INFO *infoPtr, DWORD exMask, DWORD exStyle)
static LRESULT	TAB_GetExtendedStyle (const TAB_INFO *infoPtr)
static INT	TAB_StyleChanged (TAB_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
static LRESULT WINAPI	TAB_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
void	TAB_Register (void)
void	TAB_Unregister (void)

Variables
static const WCHAR	themeClass [] = { 'T','a','b',0 }

Macro Definition Documentation

BUTTON_SPACINGX

#define BUTTON_SPACINGX   3

Definition at line 138 of file tab.c.

BUTTON_SPACINGY

#define BUTTON_SPACINGY   3

Definition at line 139 of file tab.c.

CONTROL_BORDER_SIZEX

#define CONTROL_BORDER_SIZEX   2

Definition at line 136 of file tab.c.

CONTROL_BORDER_SIZEY

#define CONTROL_BORDER_SIZEY   2

Definition at line 137 of file tab.c.

DEFAULT_MIN_TAB_WIDTH

#define DEFAULT_MIN_TAB_WIDTH   54

Definition at line 141 of file tab.c.

DEFAULT_PADDING_X

#define DEFAULT_PADDING_X   6

Definition at line 142 of file tab.c.

DISPLAY_AREA_PADDINGX

#define DISPLAY_AREA_PADDINGX   2

Definition at line 134 of file tab.c.

DISPLAY_AREA_PADDINGY

#define DISPLAY_AREA_PADDINGY   2

Definition at line 135 of file tab.c.

EXTRA_ICON_PADDING

#define EXTRA_ICON_PADDING   3

Definition at line 143 of file tab.c.

EXTRA_ITEM_SIZE

#define EXTRA_ITEM_SIZE

(

infoPtr

)

(max((infoPtr)->cbInfo, sizeof(LPARAM)))

Definition at line 89 of file tab.c.

FLAT_BTN_SPACINGX

#define FLAT_BTN_SPACINGX   8

Definition at line 140 of file tab.c.

GET_DEFAULT_MIN_TAB_WIDTH

#define GET_DEFAULT_MIN_TAB_WIDTH

(

infoPtr

)

(DEFAULT_MIN_TAB_WIDTH - (DEFAULT_PADDING_X - (infoPtr)->uHItemPadding) * 2)

Definition at line 147 of file tab.c.

ROUND_CORNER_SIZE

#define ROUND_CORNER_SIZE   2

Definition at line 133 of file tab.c.

SELECTED_TAB_OFFSET

#define SELECTED_TAB_OFFSET   2

Definition at line 132 of file tab.c.

TAB_GetInfoPtr

#define TAB_GetInfoPtr

(

hwnd

)

((TAB_INFO *)GetWindowLongPtrW(hwnd,0))

Definition at line 145 of file tab.c.

TAB_HOTTRACK_TIMER

#define TAB_HOTTRACK_TIMER   1

Definition at line 152 of file tab.c.

TAB_HOTTRACK_TIMER_INTERVAL

#define TAB_HOTTRACK_TIMER_INTERVAL   100 /* milliseconds */

Definition at line 153 of file tab.c.

TAB_ITEM_SIZE

#define TAB_ITEM_SIZE

(

infoPtr

)

FIELD_OFFSET(TAB_ITEM, extra[EXTRA_ITEM_SIZE(infoPtr)])

Definition at line 90 of file tab.c.

Function Documentation

hottrack_refresh()

static void hottrack_refresh ( const TAB_INFO *  infoPtr, int  tabIndex  )

inlinestatic

Definition at line 757 of file tab.c.

{
    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);
}

Referenced by TAB_HotTrackTimerProc(), and TAB_MouseMove().

TAB_AdjustRect()

static LRESULT TAB_AdjustRect ( const TAB_INFO *  infoPtr, WPARAM  fLarger, LPRECT  prc  )

static

Definition at line 941 of file tab.c.

{
    LONG *iRightBottom, *iLeftTop;

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

    if (!prc) return -1;

    if(infoPtr->dwStyle & TCS_VERTICAL)
    {
    iRightBottom = &(prc->right);
    iLeftTop     = &(prc->left);
    }
    else
    {
    iRightBottom = &(prc->bottom);
    iLeftTop     = &(prc->top);
    }

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

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

    /* Inflate for the border */
    InflateRect(prc, CONTROL_BORDER_SIZEX, CONTROL_BORDER_SIZEY);
    }
    else /* Go from window rectangle. */
    {
    /* Deflate the rectangle for the border */
    InflateRect(prc, -CONTROL_BORDER_SIZEX, -CONTROL_BORDER_SIZEY);

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

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

  return 0;
}

Referenced by TAB_InvalidateTabArea(), and TAB_WindowProc().

TAB_Create()

static LRESULT TAB_Create ( HWND  hwnd, LPARAM  lParam  )

static

Definition at line 3004 of file tab.c.

{
  TAB_INFO *infoPtr;
  TEXTMETRICW fontMetrics;
  HDC hdc;
  HFONT hOldFont;
  DWORD style;

  infoPtr = Alloc (sizeof(TAB_INFO));

  SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)infoPtr);

  infoPtr->hwnd            = hwnd;
  infoPtr->hwndNotify      = ((LPCREATESTRUCTW)lParam)->hwndParent;
  infoPtr->uNumItem        = 0;
  infoPtr->uNumRows        = 0;
  infoPtr->uHItemPadding   = 6;
  infoPtr->uVItemPadding   = 3;
  infoPtr->uHItemPadding_s = 6;
  infoPtr->uVItemPadding_s = 3;
  infoPtr->hFont           = 0;
  infoPtr->items           = DPA_Create(8);
  infoPtr->hcurArrow       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
  infoPtr->iSelected       = -1;
  infoPtr->iHotTracked     = -1;
  infoPtr->uFocus          = -1;
  infoPtr->hwndToolTip     = 0;
  infoPtr->DoRedraw        = TRUE;
  infoPtr->needsScrolling  = FALSE;
  infoPtr->hwndUpDown      = 0;
  infoPtr->leftmostVisible = 0;
  infoPtr->fHeightSet      = FALSE;
  infoPtr->bUnicode        = IsWindowUnicode (hwnd);
  infoPtr->cbInfo          = sizeof(LPARAM);

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

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

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

  if (infoPtr->dwStyle & TCS_TOOLTIPS) {
    /* Create tooltip control */
    infoPtr->hwndToolTip =
      CreateWindowExW (0, TOOLTIPS_CLASSW, NULL, WS_POPUP,
               CW_USEDEFAULT, CW_USEDEFAULT,
               CW_USEDEFAULT, CW_USEDEFAULT,
               hwnd, 0, 0, 0);

    /* Send NM_TOOLTIPSCREATED notification */
    if (infoPtr->hwndToolTip) {
      NMTOOLTIPSCREATED nmttc;

      nmttc.hdr.hwndFrom = hwnd;
      nmttc.hdr.idFrom = GetWindowLongPtrW(hwnd, GWLP_ID);
      nmttc.hdr.code = NM_TOOLTIPSCREATED;
      nmttc.hwndToolTips = infoPtr->hwndToolTip;

      SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
                    GetWindowLongPtrW(hwnd, GWLP_ID), (LPARAM)&nmttc);
    }
  }

  OpenThemeData (infoPtr->hwnd, themeClass);
  
  /*
   * We need to get text information so we need a DC and we need to select
   * a font.
   */
  hdc = GetDC(hwnd);
  hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));

  /* Use the system font to determine the initial height of a tab. */
  GetTextMetricsW(hdc, &fontMetrics);

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

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

  infoPtr->tabMinWidth = -1;

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

  SelectObject (hdc, hOldFont);
  ReleaseDC(hwnd, hdc);

  return 0;
}

Referenced by TAB_WindowProc().

TAB_DeleteAllItems()

static LRESULT TAB_DeleteAllItems ( TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2907 of file tab.c.

{
    TRACE("(%p)\n", infoPtr);
    while (infoPtr->uNumItem)
      TAB_DeleteItem (infoPtr, 0);
    return TRUE;
}

Referenced by TAB_WindowProc().

TAB_DeleteItem()

static LRESULT TAB_DeleteItem ( TAB_INFO *  infoPtr, INT  iItem  )

static

Definition at line 2861 of file tab.c.

{
    TAB_ITEM *item;

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

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

    TAB_InvalidateTabArea(infoPtr);
    item = TAB_GetItem(infoPtr, iItem);
    Free(item->pszText);
    Free(item);
    infoPtr->uNumItem--;
    DPA_DeletePtr(infoPtr->items, iItem);

    if (infoPtr->uNumItem == 0)
    {
        if (infoPtr->iHotTracked >= 0)
        {
            KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
            infoPtr->iHotTracked = -1;
        }

        infoPtr->iSelected = -1;
    }
    else
    {
        if (iItem <= infoPtr->iHotTracked)
        {
            /* When tabs move left/up, the hot track item may change */
            FIXME("Recalc hot track\n");
        }
    }

    /* adjust the selected index */
    if (iItem == infoPtr->iSelected)
        infoPtr->iSelected = -1;
    else if (iItem < infoPtr->iSelected)
        infoPtr->iSelected--;

    /* reposition and repaint tabs */
    TAB_SetItemBounds(infoPtr);

    return TRUE;
}

Referenced by TAB_DeleteAllItems(), and TAB_WindowProc().

TAB_DeselectAll()

static LRESULT TAB_DeselectAll ( TAB_INFO *  infoPtr, BOOL  excludesel  )

static

Definition at line 3234 of file tab.c.

{
  BOOL paint = FALSE;
  INT i, selected = infoPtr->iSelected;

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

  if (!(infoPtr->dwStyle & TCS_BUTTONS))
    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;
}

Referenced by TAB_LButtonDown(), and TAB_WindowProc().

TAB_Destroy()

static LRESULT TAB_Destroy ( TAB_INFO *  infoPtr )

static

Definition at line 3109 of file tab.c.

{
  INT iItem;

  SetWindowLongPtrW(infoPtr->hwnd, 0, 0);

  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);
  }
  DPA_Destroy(infoPtr->items);
  infoPtr->items = NULL;

  if (infoPtr->hwndToolTip)
    DestroyWindow (infoPtr->hwndToolTip);

  if (infoPtr->hwndUpDown)
    DestroyWindow(infoPtr->hwndUpDown);

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

  CloseThemeData (GetWindowTheme (infoPtr->hwnd));

  Free (infoPtr);
  return 0;
}

Referenced by TAB_WindowProc().

TAB_DrawBorder()

static void TAB_DrawBorder ( const TAB_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 2337 of file tab.c.

{
  RECT rect;
  HTHEME theme = GetWindowTheme (infoPtr->hwnd);

  GetClientRect (infoPtr->hwnd, &rect);

  /*
   * Adjust for the style
   */

  if (infoPtr->uNumItem)
  {
    if ((infoPtr->dwStyle & TCS_BOTTOM) && !(infoPtr->dwStyle & TCS_VERTICAL))
      rect.bottom -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
    else if((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
      rect.right  -= infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
    else if(infoPtr->dwStyle & TCS_VERTICAL)
      rect.left   += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
    else /* not TCS_VERTICAL and not TCS_BOTTOM */
      rect.top    += infoPtr->tabHeight * infoPtr->uNumRows + CONTROL_BORDER_SIZEX;
  }

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

  if (theme)
      DrawThemeBackground (theme, hdc, TABP_PANE, 0, &rect, NULL);
  else
      DrawEdge(hdc, &rect, EDGE_RAISED, BF_SOFT|BF_RECT);
}

Referenced by TAB_Refresh().

TAB_DrawItem()

static void TAB_DrawItem ( const TAB_INFO *  infoPtr, HDC  hdc, INT  iItem  )

static

Definition at line 1990 of file tab.c.

{
  RECT      itemRect;
  RECT      selectedRect;
  BOOL      isVisible;
  RECT      r, fillRect, r1;
  INT       clRight = 0;
  INT       clBottom = 0;
  COLORREF  bkgnd, corner;
  HTHEME    theme;

  /*
   * Get the rectangle for the item.
   */
  isVisible = TAB_InternalGetItemRect(infoPtr,
                      iItem,
                      &itemRect,
                      &selectedRect);

  if (isVisible)
  {
    RECT rUD, rC;

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

    /* If you need to see what the control is doing,
     * then override these variables. They will change what
     * fill colors are used for filling the tabs, and the
     * corners when drawing the edge.
     */
    bkgnd = comctl32_color.clrBtnFace;
    corner = comctl32_color.clrBtnFace;

    if (infoPtr->dwStyle & TCS_BUTTONS)
    {
      /* Get item rectangle */
      r = itemRect;

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

      if (iItem == infoPtr->iSelected)
      {
    DrawEdge(hdc, &r, EDGE_SUNKEN, BF_SOFT|BF_RECT);
    
    OffsetRect(&r, 1, 1);
      }
      else  /* ! selected */
      {
        DWORD state = TAB_GetItem(infoPtr, iItem)->dwState;

        if ((state & TCIS_BUTTONPRESSED) || (iItem == infoPtr->uFocus))
          DrawEdge(hdc, &r, EDGE_SUNKEN, BF_SOFT|BF_RECT);
        else
          if (!(infoPtr->dwStyle & TCS_FLATBUTTONS))
            DrawEdge(hdc, &r, EDGE_RAISED, BF_SOFT|BF_RECT);
      }
    }
    else /* !TCS_BUTTONS */
    {
      /* We draw a rectangle of different sizes depending on the selection
       * state. */
      if (iItem == infoPtr->iSelected) {
    RECT rect;
    GetClientRect (infoPtr->hwnd, &rect);
    clRight = rect.right;
    clBottom = rect.bottom;
        r = selectedRect;
      }
      else
        r = itemRect;

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

      /* 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)) 
          && ((infoPtr->dwStyle & (TCS_VERTICAL | TCS_BOTTOM)) == 0))
      {
          static const int partIds[8] = {
              /* 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. */
          GetClientRect(infoPtr->hwnd, &r1);
          if(selectedRect.left == 0)
              partIndex += 1;
          if(selectedRect.right == r1.right)
              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);
      }
      else if(infoPtr->dwStyle & TCS_VERTICAL)
      {
    /* These are for adjusting the drawing of a Selected tab      */
    /* The initial values are for the normal case of non-Selected */
    int ZZ = 1;   /* Do not stretch if selected */
    if (iItem == infoPtr->iSelected) {
        ZZ = 0;

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

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

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

      /* Clear interior */
      SetBkColor(hdc, bkgnd);
      ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);

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

      /* Now erase the top corner and draw diagonal edge */
      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;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.right--;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);

      /* Now erase the bottom corner and draw diagonal edge */
      r1.left = r.right - ROUND_CORNER_SIZE - 1;
      r1.bottom = r.bottom;
      r1.right = r.right;
      r1.top = r1.bottom - ROUND_CORNER_SIZE;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      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);
      }

        }
        else
        {
          TRACE("<left> item=%d, fill=(%s), edge=(%s)\n",
                iItem, wine_dbgstr_rect(&fillRect), wine_dbgstr_rect(&r));

      /* Clear interior */
      SetBkColor(hdc, bkgnd);
      ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);

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

      /* Now erase the top corner and draw diagonal edge */
      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;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.left++;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);

      /* Now erase the bottom corner and draw diagonal edge */
      r1.left = r.left;
      r1.bottom = r.bottom;
      r1.right = r1.left + ROUND_CORNER_SIZE + 1;
      r1.top = r1.bottom - ROUND_CORNER_SIZE;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.left++;
      DrawEdge(hdc, &r1, EDGE_SUNKEN, BF_DIAGONAL_ENDTOPLEFT);
        }
      }
      else  /* ! TCS_VERTICAL */
      {
    /* 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)
        fillRect.left += CONTROL_BORDER_SIZEX;
        /* if rightmost draw the line longer */
        if(selectedRect.right == clRight)
        fillRect.right -= CONTROL_BORDER_SIZEX;
    }

        if (infoPtr->dwStyle & TCS_BOTTOM)
        {
      /* Adjust both rectangles for topmost row */
      if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
      {
        fillRect.top -= 2;
        r.top -= 1;
      }

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

      /* Clear interior */
      SetBkColor(hdc, bkgnd);
      ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);

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

      /* Now erase the righthand corner and draw diagonal edge */
      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;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.bottom--;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMLEFT);

      /* Now erase the lefthand corner and draw diagonal edge */
      r1.left = r.left;
      r1.bottom = r.bottom;
      r1.right = r1.left + ROUND_CORNER_SIZE;
      r1.top = r1.bottom - ROUND_CORNER_SIZE - 1;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.bottom--;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPLEFT);

      if (iItem == infoPtr->iSelected)
      {
        r.top += 2;
        r.left += 1;
        if (selectedRect.left == 0)
        {
          r1 = r;
          r1.bottom = r1.top;
          r1.top--;
          DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_LEFT);
        }
      }

        }
        else
        {
      /* Adjust both rectangles for bottommost row */
      if (TAB_GetItem(infoPtr, iItem)->rect.top == infoPtr->uNumRows-1)
      {
        fillRect.bottom += 3;
        r.bottom += 2;
      }

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

      /* Clear interior */
      SetBkColor(hdc, bkgnd);
      ExtTextOutW(hdc, 0, 0, 2, &fillRect, NULL, 0, 0);

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

      /* Now erase the righthand corner and draw diagonal edge */
      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;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.top++;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDBOTTOMRIGHT);

      /* Now erase the lefthand corner and draw diagonal edge */
      r1.left = r.left;
      r1.top = r.top;
      r1.right = r1.left + ROUND_CORNER_SIZE;
      r1.bottom = r1.top + ROUND_CORNER_SIZE + 1;
      ExtTextOutW(hdc, 0, 0, 2, &r1, NULL, 0, 0);
      r1.top++;
      DrawEdge(hdc, &r1, EDGE_RAISED, BF_SOFT|BF_DIAGONAL_ENDTOPRIGHT);
        }
      }
    }

    TAB_DumpItemInternal(infoPtr, iItem);

    /* This modifies r to be the text rectangle. */
    TAB_DrawItemInterior(infoPtr, hdc, iItem, &r);
  }
}

Referenced by TAB_Refresh().

TAB_DrawItemInterior()

static void TAB_DrawItemInterior ( const TAB_INFO *  infoPtr, HDC  hdc, INT  iItem, RECT *  drawRect  )

static

Definition at line 1556 of file tab.c.

{
  RECT localRect;

  HPEN   htextPen;
  HPEN   holdPen;
  INT    oldBkMode;
  HFONT  hOldFont;
#ifdef __REACTOS__
HTHEME    theme = GetWindowTheme (infoPtr->hwnd);
#endif
  
/*  if (drawRect == NULL) */
  {
    BOOL isVisible;
    RECT itemRect;
    RECT selectedRect;

    /*
     * Get the rectangle for the item.
     */
    isVisible = TAB_InternalGetItemRect(infoPtr, iItem, &itemRect, &selectedRect);
    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.
     */
    if (iItem == infoPtr->iSelected)
      *drawRect = selectedRect;
    else
      *drawRect = itemRect;
        
    if (infoPtr->dwStyle & TCS_BUTTONS)
    {
      if (iItem == infoPtr->iSelected)
      {
    drawRect->left   += 4;
    drawRect->top    += 4;
    drawRect->right  -= 4;

    if (infoPtr->dwStyle & TCS_VERTICAL)
    {
      if (!(infoPtr->dwStyle & TCS_BOTTOM)) drawRect->right  += 1;
      drawRect->bottom   -= 4;
    }
    else
    {
      if (infoPtr->dwStyle & TCS_BOTTOM)
      {
        drawRect->top    -= 2;
        drawRect->bottom -= 4;
      }
      else
        drawRect->bottom -= 1;
    }
      }
      else
        InflateRect(drawRect, -2, -2);
    }
    else
    {
      if ((infoPtr->dwStyle & TCS_VERTICAL) && (infoPtr->dwStyle & TCS_BOTTOM))
      {
        if (iItem != infoPtr->iSelected)
    {
      drawRect->left   += 2;
          InflateRect(drawRect, 0, -2);
    }
      }
      else if (infoPtr->dwStyle & TCS_VERTICAL)
      {
        if (iItem == infoPtr->iSelected)
    {
      drawRect->right  += 1;
    }
    else
    {
      drawRect->right  -= 2;
          InflateRect(drawRect, 0, -2);
    }
      }
      else if (infoPtr->dwStyle & TCS_BOTTOM)
      {
        if (iItem == infoPtr->iSelected)
    {
      drawRect->top    -= 2;
    }
    else
    {
      InflateRect(drawRect, -2, -2);
          drawRect->bottom += 2;
    }
      }
      else
      {
        if (iItem == infoPtr->iSelected)
    {
      drawRect->bottom += 3;
    }
    else
    {
      drawRect->bottom -= 2;
      InflateRect(drawRect, -2, 0);
    }
      }
    }
  }
  TRACE("drawRect=(%s)\n", wine_dbgstr_rect(drawRect));

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

  /* Draw the focus rectangle */
  if (!(infoPtr->dwStyle & TCS_FOCUSNEVER) &&
      (GetFocus() == infoPtr->hwnd) &&
      (iItem == infoPtr->uFocus) )
  {
    RECT rFocus = *drawRect;

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

    /* focus should stay on selected item for TCS_BUTTONS style */
    if (!((infoPtr->dwStyle & TCS_BUTTONS) && (infoPtr->iSelected != iItem)))
      DrawFocusRect(hdc, &rFocus);
  }

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

  /*
   * Setup for text output
  */
  oldBkMode = SetBkMode(hdc, TRANSPARENT);
  if (!GetWindowTheme (infoPtr->hwnd) || (infoPtr->dwStyle & TCS_BUTTONS))
  {
    if ((infoPtr->dwStyle & TCS_HOTTRACK) && (iItem == infoPtr->iHotTracked) &&
        !(infoPtr->dwStyle & TCS_FLATBUTTONS))
      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);
  }

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

    drawRect->top += 2;
    drawRect->right -= 1;
    if ( iItem == infoPtr->iSelected )
        InflateRect(drawRect, -1, 0);

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

    /* fill DRAWITEMSTRUCT */
    dis.CtlType    = ODT_TAB;
    dis.CtlID      = id;
    dis.itemID     = iItem;
    dis.itemAction = ODA_DRAWENTIRE;
    dis.itemState = 0;
    if ( iItem == infoPtr->iSelected )
      dis.itemState |= ODS_SELECTED;
    if (infoPtr->uFocus == iItem) 
      dis.itemState |= ODS_FOCUS;
    dis.hwndItem = infoPtr->hwnd;
    dis.hDC      = hdc;
    dis.rcItem = *drawRect;

    /* 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 */
        dis.itemData = 0;
        memcpy(&dis.itemData, (ULONG_PTR*)TAB_GetItem(infoPtr, iItem)->extra, 4);
    }

    /* draw notification */
    SendMessageW( infoPtr->hwndNotify, WM_DRAWITEM, id, (LPARAM)&dis );
  }
  else
  {
    TAB_ITEM *item = TAB_GetItem(infoPtr, iItem);
    RECT rcTemp;
    RECT rcImage;

    /* used to center the icon and text in the tab */
    RECT rcText;
    INT center_offset_h, center_offset_v;

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

    rcTemp = *drawRect;
    SetRectEmpty(&rcText);

    /* get the rectangle that the text fits in */
    if (item->pszText)
    {
      DrawTextW(hdc, item->pszText, -1, &rcText, DT_CALCRECT);
    }
    /*
     * If not owner draw, then do the drawing ourselves.
     *
     * Draw the icon.
     */
    if (infoPtr->himl && item->iImage != -1)
    {
      INT cx;
      INT cy;
      
      ImageList_GetIconSize(infoPtr->himl, &cx, &cy);

      if(infoPtr->dwStyle & TCS_VERTICAL)
      {
        center_offset_h = ((drawRect->bottom - drawRect->top) - (cy + infoPtr->uHItemPadding + (rcText.right  - rcText.left))) / 2;
        center_offset_v = ((drawRect->right - drawRect->left) - cx) / 2;
      }
      else
      {
        center_offset_h = ((drawRect->right - drawRect->left) - (cx + infoPtr->uHItemPadding + (rcText.right  - rcText.left))) / 2;
        center_offset_v = ((drawRect->bottom - drawRect->top) - cy) / 2;
      }

      /* 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;

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

      if (center_offset_h < 2)
        center_offset_h = 2;
    
      if (center_offset_v < 0)
        center_offset_v = 0;
    
      TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%s), textlen=%d\n",
      debugstr_w(item->pszText), center_offset_h, center_offset_v,
          wine_dbgstr_rect(drawRect), (rcText.right-rcText.left));

      if((infoPtr->dwStyle & TCS_VERTICAL) && (infoPtr->dwStyle & TCS_BOTTOM))
      {
        rcImage.top = drawRect->top + center_offset_h;
    /* 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;
        drawRect->top += cy + infoPtr->uHItemPadding;
      }
      else if(infoPtr->dwStyle & TCS_VERTICAL)
      {
        rcImage.top  = drawRect->bottom - cy - center_offset_h;
    rcImage.left = drawRect->left + center_offset_v;
        drawRect->bottom -= cy + infoPtr->uHItemPadding;
      }
      else /* normal style, whether TCS_BOTTOM or not */
      {
        rcImage.left = drawRect->left + center_offset_h;
    rcImage.top = drawRect->top + center_offset_v;
        drawRect->left += cx + infoPtr->uHItemPadding;
      }

      TRACE("drawing image=%d, left=%d, top=%d\n",
        item->iImage, rcImage.left, rcImage.top-1);
      ImageList_Draw
        (
        infoPtr->himl,
        item->iImage,
        hdc,
        rcImage.left,
        rcImage.top,
        ILD_NORMAL
        );
    }

    /* Now position text */
    if (infoPtr->dwStyle & TCS_FIXEDWIDTH && infoPtr->dwStyle & TCS_FORCELABELLEFT)
      center_offset_h = infoPtr->uHItemPadding;
    else
      if(infoPtr->dwStyle & TCS_VERTICAL)
        center_offset_h = ((drawRect->bottom - drawRect->top) - (rcText.right - rcText.left)) / 2;
      else
        center_offset_h = ((drawRect->right - drawRect->left) - (rcText.right - rcText.left)) / 2;

    if(infoPtr->dwStyle & TCS_VERTICAL)
    {
      if(infoPtr->dwStyle & TCS_BOTTOM)
        drawRect->top+=center_offset_h;
      else
        drawRect->bottom-=center_offset_h;

      center_offset_v = ((drawRect->right - drawRect->left) - (rcText.bottom - rcText.top)) / 2;
    }
    else
    {
      drawRect->left += center_offset_h;
      center_offset_v = ((drawRect->bottom - drawRect->top) - (rcText.bottom - rcText.top)) / 2;
    }

    /* 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;

    if (center_offset_v < 0)
      center_offset_v = 0;

    if(infoPtr->dwStyle & TCS_VERTICAL)
      drawRect->left += center_offset_v;
    else
      drawRect->top += center_offset_v;

    /* Draw the text */
    if(infoPtr->dwStyle & TCS_VERTICAL) /* if we are vertical rotate the text and each character */
    {
      LOGFONTW logfont;
      HFONT hFont;
      INT nEscapement = 900;
      INT nOrientation = 900;

      if(infoPtr->dwStyle & TCS_BOTTOM)
      {
        nEscapement = -900;
        nOrientation = -900;
      }

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

      logfont.lfEscapement = nEscapement;
      logfont.lfOrientation = nOrientation;
      hFont = CreateFontIndirectW(&logfont);
      SelectObject(hdc, hFont);

      if (item->pszText)
      {
        ExtTextOutW(hdc,
        (infoPtr->dwStyle & TCS_BOTTOM) ? drawRect->right : drawRect->left,
        (!(infoPtr->dwStyle & TCS_BOTTOM)) ? drawRect->bottom : drawRect->top,
        ETO_CLIPPED,
        drawRect,
        item->pszText,
        lstrlenW(item->pszText),
        0);
      }

      DeleteObject(hFont);
    }
    else
    {
      TRACE("for <%s>, c_o_h=%d, c_o_v=%d, draw=(%s), textlen=%d\n",
      debugstr_w(item->pszText), center_offset_h, center_offset_v,
          wine_dbgstr_rect(drawRect), (rcText.right-rcText.left));
#ifdef __REACTOS__
      if (theme && item->pszText)
      {
          int partIndex = iItem == infoPtr->iSelected ? TABP_TABITEM : TABP_TOPTABITEM;
          int stateId = TIS_NORMAL;

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

          DrawThemeText(theme, 
                        hdc, 
                        partIndex, 
                        stateId,
                        item->pszText, 
                        lstrlenW(item->pszText), 
                        DT_LEFT | DT_SINGLELINE, 0, drawRect);
      }
      else
#endif
      if (item->pszText)
      {
        DrawTextW
        (
          hdc,
          item->pszText,
          lstrlenW(item->pszText),
          drawRect,
          DT_LEFT | DT_SINGLELINE
        );
      }
    }

    *drawRect = rcTemp; /* restore drawRect */
  }

  /*
  * Cleanup
  */
  SelectObject(hdc, hOldFont);
  SetBkMode(hdc, oldBkMode);
  SelectObject(hdc, holdPen);
  DeleteObject( htextPen );
}

Referenced by TAB_DrawItem(), and TAB_DrawLoneItemInterior().

TAB_DrawLoneItemInterior()

static void TAB_DrawLoneItemInterior ( const TAB_INFO *  infoPtr, int  iItem  )

static

Definition at line 739 of file tab.c.

{
  HDC hdc = GetDC(infoPtr->hwnd);
  RECT r, rC;

  /* Clip UpDown control to not draw over it */
  if (infoPtr->needsScrolling)
  {
    GetWindowRect(infoPtr->hwnd, &rC);
    GetWindowRect(infoPtr->hwndUpDown, &r);
    ExcludeClipRect(hdc, r.left - rC.left, r.top - rC.top, r.right - rC.left, r.bottom - rC.top);
  }
  TAB_DrawItemInterior(infoPtr, hdc, iItem, NULL);
  ReleaseDC(infoPtr->hwnd, hdc);
}

Referenced by hottrack_refresh().

TAB_DumpItemExternalT()

static void TAB_DumpItemExternalT ( const TCITEMW *  pti, UINT  iItem, BOOL  isW  )

static

Definition at line 203 of file tab.c.

{
    if (TRACE_ON(tab)) {
    TRACE("external tab %d, mask=0x%08x, dwState=0x%08x, dwStateMask=0x%08x, cchTextMax=0x%08x\n",
          iItem, pti->mask, pti->dwState, pti->dwStateMask, pti->cchTextMax);
    TRACE("external tab %d,   iImage=%d, lParam=0x%08lx, pszTextW=%s\n",
          iItem, pti->iImage, pti->lParam, isW ? debugstr_w(pti->pszText) : debugstr_a((LPSTR)pti->pszText));
    }
}

Referenced by TAB_GetItemT(), TAB_InsertItemT(), and TAB_SetItemT().

TAB_DumpItemInternal()

static void TAB_DumpItemInternal ( const TAB_INFO *  infoPtr, UINT  iItem  )

static

Definition at line 214 of file tab.c.

{
    if (TRACE_ON(tab)) {
    TAB_ITEM *ti = TAB_GetItem(infoPtr, iItem);

    TRACE("tab %d, dwState=0x%08x, pszText=%s, iImage=%d\n",
          iItem, ti->dwState, debugstr_w(ti->pszText), ti->iImage);
    TRACE("tab %d, rect.left=%d, rect.top(row)=%d\n",
          iItem, ti->rect.left, ti->rect.top);
    }
}

Referenced by TAB_DrawItem().

TAB_EnsureSelectionVisible()

static void TAB_EnsureSelectionVisible ( TAB_INFO *  infoPtr )

static

Definition at line 2426 of file tab.c.

{
  INT iSelected = infoPtr->iSelected;
  INT iOrigLeftmostVisible = infoPtr->leftmostVisible;

  if (iSelected < 0)
    return;

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

      if(infoPtr->dwStyle & TCS_VERTICAL)
        newselected = selected->rect.left;
      else
        newselected = selected->rect.top;

      /* the target row is always (number of rows - 1)
         as row 0 is furthest from the clientRect */
      iTargetRow = infoPtr->uNumRows - 1;

      if (newselected != iTargetRow)
      {
         UINT i;
         if(infoPtr->dwStyle & TCS_VERTICAL)
         {
           for (i=0; i < infoPtr->uNumItem; i++)
           {
             /* move everything in the row of the selected item to the iTargetRow */
             TAB_ITEM *item = TAB_GetItem(infoPtr, i);

             if (item->rect.left == newselected )
                 item->rect.left = iTargetRow;
             else
             {
               if (item->rect.left > newselected)
                 item->rect.left-=1;
             }
           }
         }
         else
         {
           for (i=0; i < infoPtr->uNumItem; i++)
           {
             TAB_ITEM *item = TAB_GetItem(infoPtr, i);

             if (item->rect.top == newselected )
                 item->rect.top = iTargetRow;
             else
             {
               if (item->rect.top > newselected)
                 item->rect.top-=1;
             }
          }
        }
        TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
      }
  }

  /*
   * Do the trivial cases first.
   */
  if ( (!infoPtr->needsScrolling) ||
       (infoPtr->hwndUpDown==0) || (infoPtr->dwStyle & TCS_VERTICAL))
    return;

  if (infoPtr->leftmostVisible >= iSelected)
  {
    infoPtr->leftmostVisible = iSelected;
  }
  else
  {
     TAB_ITEM *selected = TAB_GetItem(infoPtr, iSelected);
     RECT r;
     INT width;
     UINT i;

     /* Calculate the part of the client area that is visible */
     GetClientRect(infoPtr->hwnd, &r);
     width = r.right;

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

     if ((selected->rect.right -
          selected->rect.left) >= width )
     {
        /* 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++)
        {
           if ((selected->rect.right - TAB_GetItem(infoPtr, i)->rect.left) < width)
              break;
        }
        infoPtr->leftmostVisible = i;
     }
  }

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

  SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
               MAKELONG(infoPtr->leftmostVisible, 0));
}

Referenced by TAB_SetCurFocus(), TAB_SetCurSel(), and TAB_SetItemBounds().

TAB_EraseTabInterior()

static void TAB_EraseTabInterior ( const TAB_INFO *  infoPtr, HDC  hdc, INT  iItem, const RECT *  drawRect  )

static

Definition at line 1481 of file tab.c.

{
    HBRUSH   hbr = CreateSolidBrush (comctl32_color.clrBtnFace);
    BOOL     deleteBrush = TRUE;
    RECT     rTemp = *drawRect;

    if (infoPtr->dwStyle & TCS_BUTTONS)
    {
    if (iItem == infoPtr->iSelected)
    {
        /* Background color */
        if (!(infoPtr->dwStyle & TCS_OWNERDRAWFIXED))
        {
        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 */
    {
        if (infoPtr->dwStyle & TCS_FLATBUTTONS)
        {
        InflateRect(&rTemp, 2, 2);
        FillRect(hdc, &rTemp, hbr);
        if (iItem == infoPtr->iHotTracked ||
                   (iItem != infoPtr->iSelected && iItem == infoPtr->uFocus))
            DrawEdge(hdc, &rTemp, BDR_RAISEDINNER, BF_RECT);
        }
        else
        FillRect(hdc, &rTemp, hbr);
    }

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

    /* 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);
    }

    /* Cleanup */
    if (deleteBrush) DeleteObject(hbr);
}

Referenced by TAB_DrawItemInterior().

TAB_FocusChanging()

static void TAB_FocusChanging ( const TAB_INFO *  infoPtr )

static

Definition at line 570 of file tab.c.

{
  RECT      selectedRect;
  BOOL      isVisible;

  /*
   * Get the rectangle for the item.
   */
  isVisible = TAB_InternalGetItemRect(infoPtr,
                      infoPtr->uFocus,
                      NULL,
                      &selectedRect);

  /*
   * If the rectangle is not completely invisible, invalidate that
   * portion of the window.
   */
  if (isVisible)
  {
    TRACE("invalidate (%s)\n", wine_dbgstr_rect(&selectedRect));
    InvalidateRect(infoPtr->hwnd, &selectedRect, TRUE);
  }
}

Referenced by TAB_WindowProc().

TAB_GetCurFocus()

static LRESULT TAB_GetCurFocus ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 237 of file tab.c.

{
    TRACE("(%p)\n", infoPtr);
    return infoPtr->uFocus;
}

Referenced by TAB_WindowProc().

TAB_GetCurSel()

static LRESULT TAB_GetCurSel ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 228 of file tab.c.

{
    TRACE("(%p)\n", infoPtr);
    return infoPtr->iSelected;
}

Referenced by TAB_WindowProc().

TAB_GetExtendedStyle()

static LRESULT TAB_GetExtendedStyle ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 3228 of file tab.c.

{
  return infoPtr->exStyle;
}

Referenced by TAB_WindowProc().

TAB_GetFont()

static LRESULT TAB_GetFont ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2916 of file tab.c.

{
  TRACE("(%p) returning %p\n", infoPtr, infoPtr->hFont);
  return (LRESULT)infoPtr->hFont;
}

Referenced by TAB_WindowProc().

TAB_GetImageList()

static LRESULT TAB_GetImageList ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2936 of file tab.c.

{
  TRACE("\n");
  return (LRESULT)infoPtr->himl;
}

Referenced by TAB_WindowProc().

TAB_GetItem()

static TAB_ITEM* TAB_GetItem ( const TAB_INFO *  infoPtr, INT  i  )

inlinestatic

Definition at line 157 of file tab.c.

{
    assert(i >= 0 && i < infoPtr->uNumItem);
    return DPA_GetPtr(infoPtr->items, i);
}

Referenced by TAB_DeleteItem(), TAB_DeselectAll(), TAB_Destroy(), TAB_DrawItem(), TAB_DrawItemInterior(), TAB_DumpItemInternal(), TAB_EnsureSelectionVisible(), TAB_EraseTabInterior(), TAB_GetItemT(), TAB_HighlightItem(), TAB_InternalGetItemRect(), TAB_LButtonDown(), TAB_RemoveImage(), TAB_SetCurFocus(), TAB_SetCurSel(), TAB_SetItemBounds(), TAB_SetItemT(), and TAB_SetupScrolling().

TAB_GetItemCount()

static LRESULT TAB_GetItemCount ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2808 of file tab.c.

{
  TRACE("\n");
  return infoPtr->uNumItem;
}

Referenced by TAB_WindowProc().

TAB_GetItemRect()

static BOOL TAB_GetItemRect ( const TAB_INFO *  infoPtr, INT  item, RECT *  rect  )

inlinestatic

Definition at line 506 of file tab.c.

{
  TRACE("(%p, %d, %p)\n", infoPtr, item, rect);
  return TAB_InternalGetItemRect(infoPtr, item, rect, NULL);
}

Referenced by TAB_WindowProc().

TAB_GetItemT()

static LRESULT TAB_GetItemT ( TAB_INFO *  infoPtr, INT  iItem, LPTCITEMW  tabItem, BOOL  bUnicode  )

static

Definition at line 2816 of file tab.c.

{
  TAB_ITEM *wineItem;

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

  if (!tabItem) return FALSE;

  if (iItem < 0 || iItem >= infoPtr->uNumItem)
  {
    /* 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;
    return FALSE;
  }

  wineItem = TAB_GetItem(infoPtr, iItem);

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

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

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

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

  if (tabItem->mask & TCIF_TEXT)
  {
    if (bUnicode)
      Str_GetPtrW (wineItem->pszText, tabItem->pszText, tabItem->cchTextMax);
    else
      Str_GetPtrWtoA (wineItem->pszText, (LPSTR)tabItem->pszText, tabItem->cchTextMax);
  }

  TAB_DumpItemExternalT(tabItem, iItem, bUnicode);

  return TRUE;
}

Referenced by TAB_WindowProc().

TAB_GetRowCount()

static DWORD TAB_GetRowCount ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2408 of file tab.c.

{
  TRACE("(%p)\n", infoPtr);
  return infoPtr->uNumRows;
}

Referenced by TAB_WindowProc().

TAB_GetToolTips()

static LRESULT TAB_GetToolTips ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 243 of file tab.c.

{
    TRACE("(%p)\n", infoPtr);
    return (LRESULT)infoPtr->hwndToolTip;
}

Referenced by TAB_WindowProc().

TAB_GetUnicodeFormat()

static LRESULT TAB_GetUnicodeFormat ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 2952 of file tab.c.

{
    TRACE("(%p)\n", infoPtr);
    return infoPtr->bUnicode;
}

Referenced by TAB_WindowProc().

TAB_HighlightItem()

static LRESULT TAB_HighlightItem ( TAB_INFO *  infoPtr, INT  iItem, BOOL  fHighlight  )

inlinestatic

Definition at line 2739 of file tab.c.

{
  LPDWORD lpState;
  DWORD oldState;
  RECT r;

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

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

  lpState = &TAB_GetItem(infoPtr, iItem)->dwState;
  oldState = *lpState;

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

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

  return TRUE;
}

Referenced by TAB_WindowProc().

TAB_HitTest()

static LRESULT TAB_HitTest ( const TAB_INFO *  infoPtr, LPTCHITTESTINFO  lptest  )

inlinestatic

Definition at line 615 of file tab.c.

{
  TRACE("(%p, %p)\n", infoPtr, lptest);
  return TAB_InternalHitTest (infoPtr, lptest->pt, &lptest->flags);
}

Referenced by TAB_WindowProc().

TAB_HotTrackTimerProc()

static void CALLBACK TAB_HotTrackTimerProc ( HWND  hwnd, UINT  uMsg, UINT_PTR  idEvent, DWORD  dwTime  )

static

Definition at line 784 of file tab.c.

{
  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
    ** WM_MOUSEMOVE event.
    */
    if (!GetCursorPos(&pt) || WindowFromPoint(pt) != hwnd)
    {
      /* Redraw iHotTracked to look normal */
      INT iRedraw = infoPtr->iHotTracked;
      infoPtr->iHotTracked = -1;
      hottrack_refresh (infoPtr, iRedraw);

      /* Kill this timer */
      KillTimer(hwnd, TAB_HOTTRACK_TIMER);
    }
  }
}

Referenced by TAB_RecalcHotTrack().

TAB_InsertItemT()

static LRESULT TAB_InsertItemT ( TAB_INFO *  infoPtr, INT  iItem, const TCITEMW *  pti, BOOL  bUnicode  )

static

Definition at line 2625 of file tab.c.

{
  TAB_ITEM *item;
  RECT rect;

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

  if (iItem < 0) return -1;
  if (iItem > infoPtr->uNumItem)
    iItem = infoPtr->uNumItem;

  TAB_DumpItemExternalT(pti, iItem, bUnicode);

  if (!(item = Alloc(TAB_ITEM_SIZE(infoPtr)))) return FALSE;
  if (DPA_InsertPtr(infoPtr->items, iItem, item) == -1)
  {
      Free(item);
      return FALSE;
  }

  if (infoPtr->uNumItem == 0)
      infoPtr->iSelected = 0;
  else if (iItem <= infoPtr->iSelected)
      infoPtr->iSelected++;

  infoPtr->uNumItem++;

  item->pszText = NULL;
  if (pti->mask & TCIF_TEXT)
  {
    if (bUnicode)
      Str_SetPtrW (&item->pszText, pti->pszText);
    else
      Str_SetPtrAtoW (&item->pszText, (LPSTR)pti->pszText);
  }

  if (pti->mask & TCIF_IMAGE)
    item->iImage = pti->iImage;
  else
    item->iImage = -1;

  if (pti->mask & TCIF_PARAM)
    memcpy(item->extra, &pti->lParam, EXTRA_ITEM_SIZE(infoPtr));
  else
    memset(item->extra, 0, EXTRA_ITEM_SIZE(infoPtr));

  TAB_SetItemBounds(infoPtr);
  if (infoPtr->uNumItem > 1)
    TAB_InvalidateTabArea(infoPtr);
  else
    InvalidateRect(infoPtr->hwnd, NULL, TRUE);

  TRACE("[%p]: added item %d %s\n",
        infoPtr->hwnd, iItem, debugstr_w(item->pszText));

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

  return iItem;
}

Referenced by TAB_WindowProc().

TAB_InternalGetItemRect()

static BOOL TAB_InternalGetItemRect ( const TAB_INFO *  infoPtr, INT  itemIndex, RECT *  itemRect, RECT *  selectedRect  )

static

Definition at line 372 of file tab.c.

{
  RECT tmpItemRect,clientRect;

  /* Perform a sanity check and a trivial visibility check. */
  if ( (infoPtr->uNumItem <= 0) ||
       (itemIndex >= infoPtr->uNumItem) ||
       (!(((infoPtr->dwStyle & TCS_MULTILINE) || (infoPtr->dwStyle & TCS_VERTICAL))) &&
         (itemIndex < infoPtr->leftmostVisible)))
    {
        TRACE("Not Visible\n");
        SetRect(itemRect, 0, 0, 0, infoPtr->tabHeight);
        SetRectEmpty(selectedRect);
        return FALSE;
    }

  /*
   * Avoid special cases in this procedure by assigning the "out"
   * parameters if the caller didn't supply them
   */
  if (itemRect == NULL)
    itemRect = &tmpItemRect;

  /* Retrieve the unmodified item rect. */
  *itemRect = TAB_GetItem(infoPtr,itemIndex)->rect;

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

  if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
  {
    itemRect->right  = clientRect.right - SELECTED_TAB_OFFSET - itemRect->left * infoPtr->tabHeight -
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
    itemRect->left   = itemRect->right - infoPtr->tabHeight;
  }
  else if (infoPtr->dwStyle & TCS_VERTICAL)
  {
    itemRect->left   = clientRect.left + SELECTED_TAB_OFFSET + itemRect->left * infoPtr->tabHeight +
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->left * BUTTON_SPACINGX : 0);
    itemRect->right  = itemRect->left + infoPtr->tabHeight;
  }
  else if (infoPtr->dwStyle & TCS_BOTTOM)
  {
    itemRect->bottom = clientRect.bottom - itemRect->top * infoPtr->tabHeight -
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
    itemRect->top    = itemRect->bottom - infoPtr->tabHeight;
  }
  else /* not TCS_BOTTOM and not TCS_VERTICAL */
  {
    itemRect->top    = clientRect.top + itemRect->top * infoPtr->tabHeight +
                       ((infoPtr->dwStyle & TCS_BUTTONS) ? itemRect->top * BUTTON_SPACINGY : SELECTED_TAB_OFFSET);
    itemRect->bottom = itemRect->top + infoPtr->tabHeight;
 }

  /*
   * "scroll" it to make sure the item at the very left of the
   * tab control is the leftmost visible tab.
   */
  if(infoPtr->dwStyle & TCS_VERTICAL)
  {
    OffsetRect(itemRect,
         0,
         -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.top);

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

  } else
  {
    OffsetRect(itemRect,
         -TAB_GetItem(infoPtr, infoPtr->leftmostVisible)->rect.left,
         0);

    /*
     * Move the rectangle so the first item is slightly offset from
     * the left of the tab control.
     */
    OffsetRect(itemRect,
         SELECTED_TAB_OFFSET,
         0);
  }
  TRACE("item %d tab h=%d, rect=(%s)\n",
        itemIndex, infoPtr->tabHeight, wine_dbgstr_rect(itemRect));

  /* Now, calculate the position of the item as if it were selected. */
  if (selectedRect!=NULL)
  {
    *selectedRect = *itemRect;

    /* The rectangle of a selected item is a bit wider. */
    if(infoPtr->dwStyle & TCS_VERTICAL)
      InflateRect(selectedRect, 0, SELECTED_TAB_OFFSET);
    else
      InflateRect(selectedRect, SELECTED_TAB_OFFSET, 0);

    /* If it also a bit higher. */
    if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
    {
      selectedRect->left   -= 2; /* the border is thicker on the right */
      selectedRect->right  += SELECTED_TAB_OFFSET;
    }
    else if (infoPtr->dwStyle & TCS_VERTICAL)
    {
      selectedRect->left   -= SELECTED_TAB_OFFSET;
      selectedRect->right  += 1;
    }
    else if (infoPtr->dwStyle & TCS_BOTTOM)
    {
      selectedRect->bottom += SELECTED_TAB_OFFSET;
    }
    else /* not TCS_BOTTOM and not TCS_VERTICAL */
    {
      selectedRect->top    -= SELECTED_TAB_OFFSET;
      selectedRect->bottom -= 1;
    }
  }

  /* Check for visibility */
  if (infoPtr->dwStyle & TCS_VERTICAL)
    return (itemRect->top < clientRect.bottom) && (itemRect->bottom > clientRect.top);
  else
    return (itemRect->left < clientRect.right) && (itemRect->right > clientRect.left);
}

Referenced by hottrack_refresh(), TAB_DrawItem(), TAB_DrawItemInterior(), TAB_FocusChanging(), TAB_GetItemRect(), TAB_HighlightItem(), TAB_InternalHitTest(), TAB_InvalidateTabArea(), TAB_KillFocus(), TAB_LButtonDown(), TAB_RemoveImage(), and TAB_SetCurFocus().

TAB_InternalHitTest()

static INT TAB_InternalHitTest ( const TAB_INFO *  infoPtr, POINT  pt, UINT *  flags  )

static

Definition at line 594 of file tab.c.

{
  RECT rect;
  INT iCount;

  for (iCount = 0; iCount < infoPtr->uNumItem; iCount++)
  {
    TAB_InternalGetItemRect(infoPtr, iCount, &rect, NULL);

    if (PtInRect(&rect, pt))
    {
      *flags = TCHT_ONITEM;
      return iCount;
    }
  }

  *flags = TCHT_NOWHERE;
  return -1;
}

Referenced by TAB_HitTest(), TAB_LButtonDown(), TAB_NCHitTest(), and TAB_RecalcHotTrack().

TAB_InvalidateTabArea()

static void TAB_InvalidateTabArea ( const TAB_INFO *  infoPtr )

static

Definition at line 2548 of file tab.c.

{
  RECT clientRect, rInvalidate, rAdjClient;
  INT lastRow = infoPtr->uNumRows - 1;
  RECT rect;

  if (lastRow < 0) return;

  GetClientRect(infoPtr->hwnd, &clientRect);
  rInvalidate = clientRect;
  rAdjClient = clientRect;

  TAB_AdjustRect(infoPtr, 0, &rAdjClient);

  TAB_InternalGetItemRect(infoPtr, infoPtr->uNumItem-1 , &rect, NULL);
  if ((infoPtr->dwStyle & TCS_BOTTOM) && (infoPtr->dwStyle & TCS_VERTICAL))
  {
    rInvalidate.left = rAdjClient.right;
    if (infoPtr->uNumRows == 1)
      rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
  }
  else if(infoPtr->dwStyle & TCS_VERTICAL)
  {
    rInvalidate.right = rAdjClient.left;
    if (infoPtr->uNumRows == 1)
      rInvalidate.bottom = clientRect.top + rect.bottom + 2 * SELECTED_TAB_OFFSET;
  }
  else if (infoPtr->dwStyle & TCS_BOTTOM)
  {
    rInvalidate.top = rAdjClient.bottom;
    if (infoPtr->uNumRows == 1)
      rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
  }
  else 
  {
    rInvalidate.bottom = rAdjClient.top;
    if (infoPtr->uNumRows == 1)
      rInvalidate.right = clientRect.left + rect.right + 2 * SELECTED_TAB_OFFSET;
  }
  
  /* Punch out the updown control */
  if (infoPtr->needsScrolling && (rInvalidate.right > 0)) {
    RECT r;
    GetClientRect(infoPtr->hwndUpDown, &r);
    if (rInvalidate.right > clientRect.right - r.left)
      rInvalidate.right = rInvalidate.right - (r.right - r.left);
    else
      rInvalidate.right = clientRect.right - r.left;
  }

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

  InvalidateRect(infoPtr->hwnd, &rInvalidate, TRUE);
}

Referenced by TAB_DeleteItem(), TAB_DeselectAll(), TAB_InsertItemT(), TAB_OnHScroll(), TAB_SetCurFocus(), TAB_SetCurSel(), TAB_SetExtendedStyle(), TAB_SetFont(), and TAB_SetItemT().

TAB_KeyDown()

static LRESULT TAB_KeyDown ( TAB_INFO *  infoPtr, WPARAM  keyCode, LPARAM  lParam  )

static

Definition at line 517 of file tab.c.

{
  INT newItem = -1;
  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);

  switch (keyCode)
  {
    case VK_LEFT:
      newItem = infoPtr->uFocus - 1;
      break;
    case VK_RIGHT:
      newItem = infoPtr->uFocus + 1;
      break;
  }

  /* If we changed to a valid item, change focused item */
  if (newItem >= 0 && newItem < infoPtr->uNumItem && infoPtr->uFocus != newItem)
      TAB_SetCurFocus(infoPtr, newItem);

  return 0;
}

Referenced by TAB_WindowProc().

TAB_KillFocus()

static void TAB_KillFocus ( TAB_INFO *  infoPtr )

static

Definition at line 550 of file tab.c.

{
  /* 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;
  }
}

Referenced by TAB_WindowProc().

TAB_LButtonDown()

static LRESULT TAB_LButtonDown ( TAB_INFO *  infoPtr, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 650 of file tab.c.

{
  POINT pt;
  INT newItem;
  UINT dummy;

  if (infoPtr->hwndToolTip)
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
            WM_LBUTTONDOWN, wParam, lParam);

  if (!(infoPtr->dwStyle & TCS_FOCUSNEVER)) {
    SetFocus (infoPtr->hwnd);
  }

  if (infoPtr->hwndToolTip)
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
            WM_LBUTTONDOWN, wParam, lParam);

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

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

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

  if ((newItem != -1) && (infoPtr->iSelected != newItem))
  {
    if ((infoPtr->dwStyle & TCS_BUTTONS) && (infoPtr->dwStyle & TCS_MULTISELECT) &&
        (wParam & MK_CONTROL))
    {
      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;
        }

      if (TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))
        return 0;

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

      TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
    }
  }

  return 0;
}

Referenced by TAB_WindowProc().

TAB_LButtonUp()

static LRESULT TAB_LButtonUp ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 717 of file tab.c.

{
  TAB_SendSimpleNotify(infoPtr, NM_CLICK);

  return 0;
}

Referenced by TAB_WindowProc().

TAB_MouseMove()

static LRESULT TAB_MouseMove ( TAB_INFO *  infoPtr, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 916 of file tab.c.

{
  int redrawLeave;
  int redrawEnter;

  if (infoPtr->hwndToolTip)
    TAB_RelayEvent (infoPtr->hwndToolTip, infoPtr->hwnd,
            WM_LBUTTONDOWN, wParam, lParam);

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

  hottrack_refresh (infoPtr, redrawLeave);
  hottrack_refresh (infoPtr, redrawEnter);

  return 0;
}

Referenced by TAB_WindowProc().

TAB_NCCalcSize()

static LRESULT TAB_NCCalcSize ( WPARAM  wParam )

static

Definition at line 3152 of file tab.c.

{
  if (!wParam)
    return 0;
  return WVR_ALIGNTOP;
}

Referenced by TAB_WindowProc().

TAB_NCHitTest()

static LRESULT TAB_NCHitTest ( const TAB_INFO *  infoPtr, LPARAM  lParam  )

inlinestatic

Definition at line 634 of file tab.c.

{
  POINT pt;
  UINT dummyflag;

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

  if (TAB_InternalHitTest(infoPtr, pt, &dummyflag) == -1)
    return HTTRANSPARENT;
  else
    return HTCLIENT;
}

Referenced by TAB_WindowProc().

TAB_OnHScroll()

static LRESULT TAB_OnHScroll ( TAB_INFO *  infoPtr, int  nScrollCode, int  nPos  )

static

Definition at line 1001 of file tab.c.

{
  if(nScrollCode == SB_THUMBPOSITION && nPos != infoPtr->leftmostVisible)
  {
     if(nPos < infoPtr->leftmostVisible)
        infoPtr->leftmostVisible--;
     else
        infoPtr->leftmostVisible++;

     TAB_RecalcHotTrack(infoPtr, NULL, NULL, NULL);
     TAB_InvalidateTabArea(infoPtr);
     SendMessageW(infoPtr->hwndUpDown, UDM_SETPOS, 0,
                   MAKELONG(infoPtr->leftmostVisible, 0));
   }

   return 0;
}

Referenced by TAB_WindowProc().

TAB_Paint()

static LRESULT TAB_Paint ( TAB_INFO *  infoPtr, HDC  hdcPaint  )

inlinestatic

Definition at line 2603 of file tab.c.

{
  HDC hdc;
  PAINTSTRUCT ps;

  if (hdcPaint)
    hdc = hdcPaint;
  else
  {
    hdc = BeginPaint (infoPtr->hwnd, &ps);
    TRACE("erase %d, rect=(%s)\n", ps.fErase, wine_dbgstr_rect(&ps.rcPaint));
  }

  TAB_Refresh (infoPtr, hdc);

  if (!hdcPaint)
    EndPaint (infoPtr->hwnd, &ps);

  return 0;
}

Referenced by TAB_WindowProc().

TAB_RButtonUp()

static void TAB_RButtonUp ( const TAB_INFO *  infoPtr )

inlinestatic

Definition at line 725 of file tab.c.

{
  TAB_SendSimpleNotify(infoPtr, NM_RCLICK);
}

Referenced by TAB_WindowProc().

TAB_RecalcHotTrack()

static void TAB_RecalcHotTrack ( TAB_INFO *  infoPtr, const LPARAM *  pos, int *  out_redrawLeave, int *  out_redrawEnter  )

static

Definition at line 836 of file tab.c.

{
  int item = -1;


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

  if ((infoPtr->dwStyle & TCS_HOTTRACK) || GetWindowTheme(infoPtr->hwnd))
  {
    POINT pt;
    UINT  flags;

    if (pos == NULL)
    {
      GetCursorPos(&pt);
      ScreenToClient(infoPtr->hwnd, &pt);
    }
    else
    {
      pt.x = (short)LOWORD(*pos);
      pt.y = (short)HIWORD(*pos);
    }

    item = TAB_InternalHitTest(infoPtr, pt, &flags);
  }

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

      if (item < 0)
      {
        /* Kill timer which forces recheck of mouse pos */
        KillTimer(infoPtr->hwnd, TAB_HOTTRACK_TIMER);
      }
    }
    else
    {
      /* Start timer so we recheck mouse pos */
      UINT timerID = SetTimer
        (
        infoPtr->hwnd,
        TAB_HOTTRACK_TIMER,
        TAB_HOTTRACK_TIMER_INTERVAL,
        TAB_HotTrackTimerProc
        );

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

    infoPtr->iHotTracked = item;

    if (item >= 0)
    {
    /* Mark new hot-tracked to be redrawn to look highlighted */
      if (out_redrawEnter != NULL)
        *out_redrawEnter = item;
    }
  }
}

Referenced by TAB_EnsureSelectionVisible(), TAB_MouseMove(), TAB_OnHScroll(), and TAB_SetItemBounds().

TAB_Refresh()

static void TAB_Refresh ( const TAB_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 2373 of file tab.c.

{
  HFONT hOldFont;
  INT i;

  if (!infoPtr->DoRedraw)
    return;

  hOldFont = SelectObject (hdc, infoPtr->hFont);

  if (infoPtr->dwStyle & TCS_BUTTONS)
  {
    for (i = 0; i < infoPtr->uNumItem; i++)
      TAB_DrawItem (infoPtr, hdc, i);
  }
  else
  {
    /* Draw all the non selected item first */
    for (i = 0; i < infoPtr->uNumItem; i++)
    {
      if (i != infoPtr->iSelected)
    TAB_DrawItem (infoPtr, hdc, i);
    }

    /* Now, draw the border, draw it before the selected item
     * since the selected item overwrites part of the border. */
    TAB_DrawBorder (infoPtr, hdc);

    /* Then, draw the selected item */
    TAB_DrawItem (infoPtr, hdc, infoPtr->iSelected);
  }

  SelectObject (hdc, hOldFont);
}

Referenced by TAB_Paint().

TAB_Register()

void TAB_Register

(

void

)

Definition at line 3476 of file tab.c.

{
  WNDCLASSW wndClass;

  ZeroMemory (&wndClass, sizeof(WNDCLASSW));
  wndClass.style         = CS_GLOBALCLASS | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  wndClass.lpfnWndProc   = TAB_WindowProc;
  wndClass.cbClsExtra    = 0;
  wndClass.cbWndExtra    = sizeof(TAB_INFO *);
  wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
  wndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
  wndClass.lpszClassName = WC_TABCONTROLW;

  RegisterClassW (&wndClass);
}

Referenced by DllMain().

TAB_RelayEvent()

static void TAB_RelayEvent ( HWND  hwndTip, HWND  hwndMsg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 186 of file tab.c.

{
    MSG msg;

    msg.hwnd = hwndMsg;
    msg.message = uMsg;
    msg.wParam = wParam;
    msg.lParam = lParam;
    msg.time = GetMessageTime ();
    msg.pt.x = (short)LOWORD(GetMessagePos ());
    msg.pt.y = (short)HIWORD(GetMessagePos ());

    SendMessageW (hwndTip, TTM_RELAYEVENT, 0, (LPARAM)&msg);
}

Referenced by TAB_LButtonDown(), and TAB_MouseMove().

TAB_RemoveImage()

static LRESULT TAB_RemoveImage ( TAB_INFO *  infoPtr, INT  image  )

static

Definition at line 3170 of file tab.c.

{
  TRACE("%p %d\n", infoPtr, image);

  if (ImageList_Remove (infoPtr->himl, image))
  {
    INT i, *idx;
    RECT r;

    /* shift indices, repaint items if needed */
    for (i = 0; i < infoPtr->uNumItem; i++)
    {
      idx = &TAB_GetItem(infoPtr, i)->iImage;
      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;
}

Referenced by TAB_WindowProc().

TAB_SendSimpleNotify()

static BOOL TAB_SendSimpleNotify ( const TAB_INFO *  infoPtr, UINT  code  )

static

Definition at line 173 of file tab.c.

{
    NMHDR nmhdr;

    nmhdr.hwndFrom = infoPtr->hwnd;
    nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwnd, GWLP_ID);
    nmhdr.code = code;

    return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
            nmhdr.idFrom, (LPARAM) &nmhdr);
}

Referenced by TAB_LButtonDown(), TAB_LButtonUp(), TAB_RButtonUp(), and TAB_SetCurFocus().

TAB_SetCurFocus()

static LRESULT TAB_SetCurFocus ( TAB_INFO *  infoPtr, INT  iItem  )

static

Definition at line 281 of file tab.c.

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

  if (iItem < 0) {
      infoPtr->uFocus = -1;
      if (infoPtr->iSelected != -1) {
#ifdef __REACTOS__
          TAB_GetItem(infoPtr, infoPtr->iSelected)->dwState &= ~TCIS_BUTTONPRESSED;
#endif
          infoPtr->iSelected = -1;
          TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
          TAB_InvalidateTabArea(infoPtr);
      }
  }
  else if (iItem < infoPtr->uNumItem) {
    if (infoPtr->dwStyle & TCS_BUTTONS) {
      /* 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);
      }
    } else {
#ifdef __REACTOS__
      INT oldItem = infoPtr->iSelected;
#endif
      INT oldFocus = infoPtr->uFocus;
      if (infoPtr->iSelected != iItem || oldFocus == -1 ) {
        infoPtr->uFocus = iItem;
        if (oldFocus != -1) {
          if (!TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGING))  {
#ifdef __REACTOS__
            if (oldItem != -1)
              TAB_GetItem(infoPtr, oldItem)->dwState &= ~TCIS_BUTTONPRESSED;
#endif
            infoPtr->iSelected = iItem;
#ifdef __REACTOS__
            TAB_GetItem(infoPtr, iItem)->dwState |= TCIS_BUTTONPRESSED;
#endif
            TAB_SendSimpleNotify(infoPtr, TCN_SELCHANGE);
          }
          else
            infoPtr->iSelected = iItem;
          TAB_EnsureSelectionVisible(infoPtr);
          TAB_InvalidateTabArea(infoPtr);
        }
      }
    }
  }
  return 0;
}

Referenced by TAB_InsertItemT(), TAB_KeyDown(), and TAB_WindowProc().

TAB_SetCurSel()

static LRESULT TAB_SetCurSel ( TAB_INFO *  infoPtr, INT  iItem  )

inlinestatic

Definition at line 249 of file tab.c.

{
  INT prevItem = infoPtr->iSelected;

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

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

  if (prevItem != iItem) {
      if (prevItem != -1)
          TAB_GetItem(infoPtr, prevItem)->dwState &= ~TCIS_BUTTONPRESSED;

      if (iItem >= 0)
      {
          TAB_GetItem(infoPtr, iItem)->dwState |= TCIS_BUTTONPRESSED;
          infoPtr->iSelected = iItem;
          infoPtr->uFocus = iItem;
      }
      else
      {
          infoPtr->iSelected = -1;
          infoPtr->uFocus = -1;
      }

      TAB_EnsureSelectionVisible(infoPtr);
      TAB_InvalidateTabArea(infoPtr);
  }

  return prevItem;
}

Referenced by TAB_LButtonDown(), and TAB_WindowProc().

TAB_SetExtendedStyle()

static LRESULT TAB_SetExtendedStyle ( TAB_INFO *  infoPtr, DWORD  exMask, DWORD  exStyle  )

static

Definition at line 3201 of file tab.c.

{
  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;
}

Referenced by TAB_WindowProc().

TAB_SetFont()

static LRESULT TAB_SetFont ( TAB_INFO *  infoPtr, HFONT  hNewFont  )

inlinestatic

Definition at line 2922 of file tab.c.

{
  TRACE("(%p,%p)\n", infoPtr, hNewFont);

  infoPtr->hFont = hNewFont;

  TAB_SetItemBounds(infoPtr);

  TAB_InvalidateTabArea(infoPtr);

  return 0;
}