// XPTabCtrl.cpp : ±¸Çö ÆÄÀÏÀÔ´Ï´Ù.
|
//
|
|
#include "stdafx.h"
|
#include "XPTabCtrl.h"
|
|
|
// CXPTabCtrl
|
|
/***********************************************************************************************************/
|
// constant string definitions here (or you can put it into resource string table)
|
#define IDS_UTIL_TAB _T("TAB")
|
#define IDS_UTIL_UXTHEME _T("UxTheme.dll")
|
#define IDS_UTIL_THEMEACT _T("IsThemeActive")
|
#define IDS_UTIL_THEMEOPN _T("OpenThemeData")
|
#define IDS_UTIL_THEMEBCKG _T("DrawThemeBackground")
|
/***********************************************************************************************************/
|
|
IMPLEMENT_DYNAMIC(CXPTabCtrl, CTabCtrl)
|
|
CXPTabCtrl::CXPTabCtrl()
|
{
|
m_bTabExtended=TRUE; // default is to use extended tab (if it is Themes XP)
|
m_eTabOrientation=e_tabBottom; // default initial orientation is: bottom
|
m_ixSelOld=-1;
|
}
|
|
CXPTabCtrl::~CXPTabCtrl()
|
{
|
}
|
|
void CXPTabCtrl::InitImageList(UINT nBitmapID)
|
{
|
if(!::IsWindow(GetSafeHwnd()) || m_ilTabs.operator HIMAGELIST())
|
{ ASSERT(FALSE); return; } // tab control has to be created first and image list can be created only once
|
if(m_ilTabs.Create(nBitmapID, 16, 1, RGB(0xFF,0,0xFF))) // add an images list with appropriate background (transparent) color
|
SetImageList(&m_ilTabs);
|
}
|
|
BEGIN_MESSAGE_MAP(CXPTabCtrl, CTabCtrl)
|
ON_WM_PAINT()
|
ON_NOTIFY_REFLECT(TCN_SELCHANGING,OnTabSelChanging)
|
ON_NOTIFY_REFLECT(TCN_SELCHANGE, OnTabSelChanged)
|
END_MESSAGE_MAP()
|
|
|
// CXPTabCtrl ¸Þ½ÃÁö 󸮱âÀÔ´Ï´Ù.
|
//----------------------------------------------------------------------------------------------------------
|
void CXPTabCtrl::OnPaint()
|
{
|
if(!IsExtendedTabTheamedXP()) // if it is not XP or it is not Themes, behave as default
|
{ Default(); return; }
|
CPaintDC dc(this); // device context for painting
|
|
CRect rcClip; rcClip.SetRectEmpty();
|
dc.GetClipBox(rcClip);
|
|
// 1st paint the tab body
|
CRect rcPage,rcItem,rcClient;
|
GetClientRect(&rcPage);
|
rcClient=rcPage;
|
AdjustRect(FALSE,rcPage);
|
|
switch(m_eTabOrientation)
|
{ case e_tabTop: rcClient.top =rcPage.top -2; break;
|
case e_tabBottom: rcClient.bottom=rcPage.bottom+3; break;
|
case e_tabLeft: rcClient.left =rcPage.left -1; break;
|
case e_tabRight: rcClient.right =rcPage.right +3; break;
|
default: ASSERT(FALSE); return;
|
}
|
UINT uiVertBottm;
|
uiVertBottm =(m_eTabOrientation&1)? 8:0; // 8=bottom
|
uiVertBottm|=(m_eTabOrientation&2)?16:0; // 16=vertical
|
UINT uiFlags=1|uiVertBottm; // 1=body
|
DrawThemesXpTabItem(&dc, -1, rcClient,uiFlags); // TABP_PANE=9,0,'TAB'
|
|
int nTab=GetItemCount(); // paint the tabs first and then the borders
|
if(!nTab) return; // no tab pages added
|
|
// 2nd paint the inactive tabs
|
CRect ;
|
TCHITTESTINFO hti; hti.flags=0;
|
::GetCursorPos(&hti.pt); ScreenToClient(&hti.pt);
|
int ixHot=HitTest(&hti);
|
int ixSel=GetCurSel();
|
|
for(int ixTab=0; ixTab<nTab; ixTab++)
|
{ if(ixTab==ixSel)
|
continue;
|
VERIFY(GetItemRect(ixTab, &rcItem));
|
if(m_eTabOrientation==e_tabLeft) rcItem.right++;
|
uiFlags=uiVertBottm|(ixTab==ixHot?4:0); // 4= hot
|
DrawThemesXpTabItem(&dc,ixTab,rcItem,uiFlags);
|
}
|
// 3rd paint the active selected tab
|
VERIFY(GetItemRect(ixSel, &rcItem)); // now selected tab
|
rcItem.InflateRect(2,2);
|
if(m_eTabOrientation==e_tabTop) rcItem.bottom--;
|
uiFlags=uiVertBottm|2; // 2= selected
|
DrawThemesXpTabItem(&dc, ixSel, rcItem,uiFlags);
|
}
|
//----------------------------------------------------------------------------------------------------------
|
// This function draws Themes Tab control parts: a) Tab-Body and b) Tab-tabs
|
void CXPTabCtrl::DrawThemesXpTabItem(CDC* pDC, int ixItem, const CRect& rcItem, UINT uiFlag)
|
{ // uiFlag(1/0):1=Type(body/tab);2=Sel(y/n);4=Hot(y/n);8=bBottom(y/n);16=rotate(y/n)
|
BOOL bBody =(uiFlag& 1)?TRUE:FALSE;
|
BOOL bSel =(uiFlag& 2)?TRUE:FALSE;
|
BOOL bHot =(uiFlag& 4)?TRUE:FALSE;
|
BOOL bBottom=(uiFlag& 8)?TRUE:FALSE; // mirror
|
BOOL bVertic=(uiFlag&16)?TRUE:FALSE; // rotate
|
BOOL bLeftTab=!bBottom && bVertic && !bBody;
|
|
CSize szBmp=rcItem.Size();
|
if(bVertic) SwapVars(szBmp.cx,szBmp.cy);
|
// 1st draw background
|
CDC dcMem; dcMem .CreateCompatibleDC(pDC);
|
CBitmap bmpMem; bmpMem.CreateCompatibleBitmap(pDC,szBmp.cx,szBmp.cy);
|
CBitmap* pBmpOld=dcMem.SelectObject(&bmpMem);
|
CRect rcMem(CPoint(0,0),szBmp); if(bSel) rcMem.bottom++;
|
if(bBody)
|
DrawThemesPart(dcMem.GetSafeHdc(), 9, 0, (LPCSTR)IDS_UTIL_TAB, &rcMem); // TABP_PANE=9, 0, 'TAB'
|
else DrawThemesPart(dcMem.GetSafeHdc(), 1, bSel?3:(bHot?2:1), (LPCSTR)IDS_UTIL_TAB, &rcMem);
|
// TABP_TABITEM=1, TIS_SELECTED=3:TIS_HOT=2:TIS_NORMAL=1, 'TAB'
|
// 2nd init some extra parameters
|
BITMAPINFO biOut; ZeroMemory(&biOut,sizeof(BITMAPINFO)); // Fill local pixel arrays
|
BITMAPINFOHEADER& bihOut=biOut.bmiHeader;
|
bihOut.biSize =sizeof (BITMAPINFOHEADER);
|
bihOut.biCompression=BI_RGB;
|
bihOut.biPlanes=1; bihOut.biBitCount=24; // force as RGB: 3 bytes,24 bits -> good for rotating bitmap in any resolution
|
bihOut.biWidth =szBmp.cx; bihOut.biHeight=szBmp.cy;
|
|
int nBmpWdtPS=DWordAlign(szBmp.cx*3);
|
int nSzBuffPS=((nBmpWdtPS*szBmp.cy)/8+2)*8;
|
LPBYTE pcImg=NULL;
|
if(bBottom || bVertic) { pcImg=new BYTE[nSzBuffPS]; ASSERT(pcImg); }
|
int nStart=0,nLenSub=0;
|
if(bBody && bBottom && !bVertic) nStart=3,nLenSub=4; // if bottom oriented flip the body contest only (no shadows were flipped)
|
// 3rd if it is left oriented tab, draw tab context before mirroring or rotating (before GetDIBits)
|
if(bVertic)
|
{ if(bBody || !bBottom) bihOut.biHeight=-szBmp.cy;
|
if(!bBottom && !bBody && ixItem>=0) //
|
{ if(bSel) rcMem.bottom--;
|
DrawTabItem(&dcMem, ixItem, rcMem, uiFlag); ixItem=-1;
|
} } // rotate or mirror
|
// 4th get bits (for rotate) and mirror: body=(all except top) tab=(all except top)
|
if(bVertic || bBottom) // get bits:
|
{ GetDIBits(*pDC, bmpMem.operator HBITMAP(),nStart,szBmp.cy-nLenSub,pcImg,&biOut,DIB_RGB_COLORS);
|
if(bBottom) // mirror: body=(bottom and right) tab=(bottom and right)
|
{ bihOut.biHeight=-szBmp.cy; // to mirror bitmap is eough to use negative height between Get/SetDIBits
|
SetDIBits(*pDC, bmpMem.operator HBITMAP(),nStart,szBmp.cy-nLenSub,pcImg,&biOut,DIB_RGB_COLORS);
|
if(bBody && bVertic) // when it is right oriented body -> flip twice, first flip border shadows, than flip shaded inside body again
|
{ nStart=2; nLenSub=4; bihOut.biHeight=szBmp.cy;
|
GetDIBits(*pDC, bmpMem.operator HBITMAP(),nStart,szBmp.cy-nLenSub,pcImg,&biOut,DIB_RGB_COLORS);
|
bihOut.biHeight=-szBmp.cy; // to mirror bitmap is eough to use negative height between Get/SetDIBits
|
SetDIBits(*pDC, bmpMem.operator HBITMAP(),nStart,szBmp.cy-nLenSub,pcImg,&biOut,DIB_RGB_COLORS);
|
} } }
|
// 5th if it is bottom or right oriented tab, draw after mirroring background (do GetDIBits again)
|
if(!bBody && ixItem>=0) //
|
{ if(bSel) rcMem.bottom--;
|
DrawTabItem(&dcMem, ixItem, rcMem, uiFlag);
|
if(bVertic) // if it is right tab, do GetDIBits again
|
{ bihOut.biHeight=-szBmp.cy;
|
GetDIBits(*pDC, bmpMem.operator HBITMAP(),nStart,szBmp.cy-nLenSub,pcImg,&biOut,DIB_RGB_COLORS);
|
} }
|
// 6th: do rotate now, finaly
|
if(bVertic) // force rotating bitmap as RGB -> good for any resolution
|
{ SwapVars(szBmp.cx,szBmp.cy);
|
|
int nBmpWdtPD=DWordAlign(szBmp.cx*3);
|
int nPadD=nBmpWdtPD-szBmp.cx*3;
|
int nSzBuffPD=((nBmpWdtPD*szBmp.cy)/8+2)*8;
|
LPBYTE pcImgRotate=new BYTE[nSzBuffPD]; ASSERT(pcImgRotate);
|
int nWidth,nHeight=szBmp.cy,nHeight1=nHeight-1;
|
//====================================
|
//------------------------------------
|
// here is the example how to speed up lengthy repeatetive processing by using inline assembler
|
// #define __USE_MASM__ // the same processing is in C and in asm. To use C -> comment the beginning of this line
|
// Do the actual whole RGB bitmap rotating in C or assembler
|
#ifndef __USE_MASM__
|
LPBYTE pcImgS=pcImg;
|
LPBYTE pcImgD=pcImgRotate;
|
int ixHeight=0;
|
BOOL bLast=FALSE;
|
while(ixHeight<nHeight) // for all destination height lines
|
{ nWidth=szBmp.cx;
|
if(ixHeight==nHeight1) { bLast=TRUE; nWidth--; }
|
|
while(nWidth--)
|
{ *(PDWORD)pcImgD=*(PDWORD)pcImgS; // do all Rgb triplets read/write qicker as DWORD
|
pcImgS+=nBmpWdtPS; // increment source in padded source lines
|
pcImgD+=3; // increment destination in rgb triplets
|
}
|
if(bLast) // when the last line, the last pixel - colud be a problem if bitmap DWORD alligned
|
for(int c=3;c;c--) *pcImgD++=*pcImgS++; // (only last three bytes available->could not read/write DWORD)!!
|
else
|
{ ixHeight++;
|
pcImgD+=nPadD; // destination bitmap horizontal padding to DWORD
|
pcImgS=pcImg+(ixHeight*3); // reset the source to the begining of the next vertical line
|
} }
|
#else // __USE_MASM__
|
nBmpWdtPS-=4; // adjust esi increment (due to esi self-incrementing by movsd)
|
nWidth=szBmp.cx;
|
__asm
|
{ mov esi, pcImg // source index
|
mov edi, pcImgRotate // destination index
|
xor ebx, ebx // vertical counter
|
loop_height:
|
mov ecx, nWidth // horizontal counter
|
cmp ebx, nHeight1 // check is it the last line
|
jne loop_width
|
dec ecx // if it is decremnt for the last pixel
|
|
loop_width:
|
movsd // copies 4 bytes and increments source and destination by 4 (we need only 3 bytes copied 'one pixel' RGB triplet)
|
dec edi // adjust edi to 'as incremented by 3'
|
add esi,nBmpWdtPS // adjust esi to the next source line
|
loop loop_width // loop one hotizontal destination line
|
|
cmp ebx, nHeight1 // check is it the last line
|
je do_last // if not last, do incrementing here
|
|
inc ebx // increment vertical counter
|
add edi, nPadD // adjust destination index by possible padding to DWORD
|
mov esi, ebx // reset the source index: add vertical counter * 3
|
shl esi, 1 // (is the same as * 2 +1*)
|
add esi, ebx // +1*
|
add esi, pcImg // add to the beginning of the source
|
jmp loop_height // loop whole height
|
|
do_last: // the last pixel is done by
|
movsw // moving first two bytes
|
movsb // and than by moving the very last byte
|
}
|
#endif // __USE_MASM__
|
dcMem.SelectObject(pBmpOld); bmpMem.DeleteObject(); // recreate rotated bitmap
|
bmpMem.CreateCompatibleBitmap(pDC,szBmp.cx,szBmp.cy);
|
dcMem.SelectObject(&bmpMem);
|
bihOut.biWidth =szBmp.cx; bihOut.biHeight=bBody?-szBmp.cy:szBmp.cy;
|
SetDIBits(*pDC, bmpMem.operator HBITMAP(),0,szBmp.cy,pcImgRotate,&biOut,DIB_RGB_COLORS); // set rotated bitmap bits
|
delete pcImgRotate;
|
}
|
if(pcImg) delete pcImg;
|
// 6th blit mirrored/rotated image to the screen
|
pDC->BitBlt(rcItem.left,rcItem.top,szBmp.cx,szBmp.cy,&dcMem,0,0,SRCCOPY); //
|
dcMem.SelectObject(pBmpOld);
|
}
|
//----------------------------------------------------------------------------------------------------------
|
// draw tab item context: possible icon and text
|
void CXPTabCtrl::DrawTabItem(CDC* pDC, int ixItem, const CRect& rcItemC, UINT uiFlags)
|
{
|
TC_ITEM tci; CString sText;
|
tci.mask =TCIF_TEXT | TCIF_IMAGE;
|
tci.pszText =sText.GetBuffer(128);
|
tci.cchTextMax=127;
|
GetItem(ixItem,&tci);
|
sText.ReleaseBuffer();
|
|
BOOL bSel =(uiFlags&2)?TRUE:FALSE;
|
BOOL bBottom=(uiFlags&8)?TRUE:FALSE;
|
CRect rcItem=rcItemC;
|
if(bSel) rcItem.bottom -= 1;
|
else rcItem.bottom += 2;
|
rcItem.left+=(bBottom?3:6); // text & icon
|
rcItem.top +=(bBottom?3:2) + (bSel ? 1 : (bBottom?0:3));
|
|
int nOldMode=pDC->SetBkMode(TRANSPARENT);
|
HIMAGELIST hilTabs = (HIMAGELIST)TabCtrl_GetImageList(GetSafeHwnd()); // icon
|
if(hilTabs && tci.iImage>=0)
|
{ ImageList_Draw(hilTabs, tci.iImage, *pDC, rcItem.left+(bSel?2:0), rcItem.top+(bSel?0:-2), ILD_TRANSPARENT);
|
rcItem.left+=19;
|
}
|
else rcItem.OffsetRect(-2,0);
|
|
if(sText.GetLength())
|
{ CFont* pOldFont=pDC->SelectObject(GetFont()); // prepare dc
|
rcItem.right-=3; // text
|
CRect rect(0,0,rcItem.Width(),20);
|
::DrawText(pDC->GetSafeHdc(),sText.GetBuffer(sText.GetLength()+4),-1,rect,DT_CALCRECT|DT_SINGLELINE|DT_MODIFYSTRING|DT_END_ELLIPSIS);
|
sText.ReleaseBuffer();
|
|
rcItem.OffsetRect((bBottom?-1:0),(bSel?1:-1));
|
pDC->DrawText(sText, rcItem, DT_NOPREFIX|DT_CENTER);
|
pDC->SelectObject(pOldFont);
|
}
|
pDC->SetBkMode(nOldMode);
|
}
|
//----------------------------------------------------------------------------------------------------------
|
BOOL CXPTabCtrl::IsExtendedTabTheamedXP()
|
{
|
if(!m_bTabExtended || !::IsWindow(GetSafeHwnd()))
|
return FALSE;
|
DWORD dwStyle=GetStyle();
|
m_eTabOrientation=(dwStyle&TCS_BOTTOM)?e_tabBottom:e_tabTop;
|
if(dwStyle&TCS_VERTICAL)
|
m_eTabOrientation=(m_eTabOrientation==e_tabTop)?e_tabLeft:e_tabRight;
|
#ifdef USE_DEFAULT_XP_TOPTAB
|
if(m_eTabOrientation==e_tabTop) return FALSE;
|
#endif
|
return IsThemeActiveXP()?TRUE:FALSE;
|
}
|
//==========================================================================================================
|
// these two messages are necessary only to properly redraw deselected tab background, because
|
void CXPTabCtrl::OnTabSelChanging(NMHDR* pNMHDR, LRESULT* pResult) // selected rect was inflated by 2 points
|
{
|
UNUSED_ALWAYS(pNMHDR);
|
m_ixSelOld=GetCurSel();
|
*pResult=0L;
|
}
|
//----------------------------------------------------------------------------------------------------------
|
void CXPTabCtrl::OnTabSelChanged(NMHDR* pNMHDR, LRESULT* pResult)
|
{
|
UNUSED_ALWAYS(pNMHDR);
|
if(m_ixSelOld>=0 && m_ixSelOld!=GetCurSel() && IsExtendedTabTheamedXP()) // else
|
{ CWnd* pWndParent=GetParent();
|
if(pWndParent)
|
{ CRect rcOldSel; GetItemRect(m_ixSelOld, rcOldSel); rcOldSel.InflateRect(2,2);
|
ClientToScreen(&rcOldSel); pWndParent->ScreenToClient(&rcOldSel);
|
pWndParent->InvalidateRect(rcOldSel);
|
} }
|
*pResult=1L;
|
}
|
/***********************************************************************************************************/
|
// Helper functions
|
/***********************************************************************************************************/
|
int DWordAlign(int n)
|
{ const int rem=n%4; if(rem) n+=(4-rem); return n; }
|
//----------------------------------------------------------------------------------------------------------
|
BOOL IsThemeActiveEx()
|
{ // check theme activity always (could change during application running)
|
USES_CONVERSION;
|
|
HINSTANCE hDll=LoadLibrary(CString((LPCTSTR)IDS_UTIL_UXTHEME)); // 'UxTheme.dll'
|
if(hDll==NULL) return FALSE; // the DLL won't be available on anything except Windows XP
|
UINT (PASCAL *pfnIsThemeActive)();
|
|
#ifdef X
|
(FARPROC&)pfnIsThemeActive=GetProcAddress(hDll,W2A(IDS_UTIL_THEMEACT)); // 'IsThemeActive'
|
#else
|
(FARPROC&)pfnIsThemeActive=GetProcAddress(hDll,IDS_UTIL_THEMEACT); // 'IsThemeActive'
|
#endif
|
|
UINT uiThemeActive=0;
|
if(pfnIsThemeActive)
|
uiThemeActive=pfnIsThemeActive();
|
FreeLibrary(hDll);
|
return uiThemeActive?TRUE:FALSE;
|
}
|
//----------------------------------------------------------------------------------------------------------
|
#define PACKVERSION(major,minor) MAKELONG(minor,major)
|
DWORD GetWinVersion()
|
{
|
static DWORD c_dwWinVers=0; // check win version only once (will not change during application)
|
if(!c_dwWinVers)
|
{ OSVERSIONINFO osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); // Initialize the OSVERSIONINFO structure.
|
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
GetVersionEx(&osvi);
|
c_dwWinVers=PACKVERSION(osvi.dwMajorVersion,osvi.dwMinorVersion);
|
}
|
return c_dwWinVers;
|
}
|
//----------------------------------------------------------------------------------------------------------
|
BOOL IsWinXP() { return GetWinVersion()>=PACKVERSION(5,1)?TRUE:FALSE; }
|
//----------------------------------------------------------------------------------------------------------
|
BOOL IsThemeActiveXP() { return (IsWinXP() && IsThemeActiveEx())?TRUE:FALSE; }
|
//----------------------------------------------------------------------------------------------------------
|
|
#define WPART_NAME_SZ 128
|
HRESULT DrawThemesPart(HDC hDC, int iPartId, int iStateId, LPCSTR uiPartNameID, LPRECT prcBox)
|
{
|
USES_CONVERSION;
|
|
if(!IsWinXP()) return E_FAIL;
|
HINSTANCE hDll=LoadLibrary(CString((LPCTSTR)IDS_UTIL_UXTHEME)); // 'UxTheme.dll'
|
if(!hDll) return E_FAIL;
|
BOOL (PASCAL* pfnIsThemeActive)(); UINT hTheme=0;
|
|
#ifdef X
|
(FARPROC&)pfnIsThemeActive=GetProcAddress(hDll,W2A(IDS_UTIL_THEMEACT)); // 'IsThemeActive'
|
#else
|
(FARPROC&)pfnIsThemeActive=GetProcAddress(hDll,IDS_UTIL_THEMEACT); // 'IsThemeActive'
|
#endif
|
|
HRESULT hResult=E_FAIL;
|
if(pfnIsThemeActive && pfnIsThemeActive())
|
{ CString sPartName(uiPartNameID);
|
if(sPartName.GetLength()>0)
|
{ WCHAR swPartName[WPART_NAME_SZ];
|
|
#ifdef X
|
MultiByteToWideChar(CP_ACP,0,W2A(sPartName),-1,swPartName,sizeof(swPartName)/sizeof(WCHAR));
|
#else
|
MultiByteToWideChar(CP_ACP,0,sPartName,-1,swPartName,sizeof(swPartName)/sizeof(WCHAR));
|
#endif
|
|
UINT (PASCAL* pfnOpenThemeData)(HWND hwnd, LPCWSTR pszClassList);
|
|
|
#ifdef X
|
(FARPROC&)pfnOpenThemeData=GetProcAddress(hDll,W2A(IDS_UTIL_THEMEOPN));// 'OpenThemeData'
|
#else
|
(FARPROC&)pfnOpenThemeData=GetProcAddress(hDll,IDS_UTIL_THEMEOPN);// 'OpenThemeData'
|
#endif
|
|
if(pfnOpenThemeData && (hTheme=pfnOpenThemeData(NULL, swPartName))!=0)
|
{ UINT (PASCAL* pfnDrawThemeBackground)(UINT htheme,HDC hdc,int iPartID,int iStateID,const RECT* prcBx,const RECT* prcClip);
|
|
|
#ifdef X
|
(FARPROC&)pfnDrawThemeBackground=GetProcAddress(hDll,W2A(IDS_UTIL_THEMEBCKG)); // 'DrawThemeBackground'
|
#else
|
(FARPROC&)pfnDrawThemeBackground=GetProcAddress(hDll,IDS_UTIL_THEMEBCKG); // 'DrawThemeBackground'
|
#endif
|
|
if(pfnDrawThemeBackground)
|
hResult=pfnDrawThemeBackground(hTheme, hDC, iPartId, iStateId, prcBox, NULL);
|
} } }
|
FreeLibrary(hDll);
|
return hResult;
|
}
|
//----------------------------------------------------------------------------------------------------------
|
