able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/comctl32/v6/markup.cpp

2058 lines
59 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//-------------------------------------------------------------------------//
// markup.cpp - implementation of CMarkup
//
#include <ctlspriv.h>
#include <shpriv.h>
#include <markup.h>
#include <oleacc.h>
#define DllAddRef()
#define DllRelease()
typedef WCHAR TUCHAR, *PTUCHAR;
#define IS_LINK(pBlock) ((pBlock) && (pBlock)->iLink != INVALID_LINK_INDEX)
#ifndef POINTSPERRECT
#define POINTSPERRECT (sizeof(RECT)/sizeof(POINT))
#endif
#ifndef MIN
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif
#define TESTKEYSTATE(vk) ((GetKeyState(vk) & 0x8000)!=0)
#define LINKCOLOR_ENABLED GetSysColor(COLOR_HOTLIGHT)
#define LINKCOLOR_DISABLED GetSysColor(COLOR_GRAYTEXT)
#define SZ_ATTRIBUTE_HREF TEXT("HREF")
#define SZ_ATTRIBUTE_ID TEXT("ID")
#define LINKTAG1 TEXT("<A")
#define cchLINKTAG1 (ARRAYSIZE(LINKTAG1) - 1)
#define CH_ENDTAG TEXT('>')
#define LINKTAG2 TEXT("</A>")
#define cchLINKTAG2 (ARRAYSIZE(LINKTAG2) - 1)
#define Markup_DestroyMarkup(hMarkup)\
((IUnknown*)hMarkup)->Release();
struct RECTLISTENTRY // rect list member
{
RECT rc;
UINT uCharStart;
UINT uCharCount;
UINT uLineNumber;
RECTLISTENTRY* next;
};
struct TEXTBLOCK // text segment data
{
friend class CMarkup;
int iLink; // index of link (INVALID_LINK_INDEX if static text)
DWORD state; // state bits
TCHAR szID[MAX_LINKID_TEXT]; // link identifier.
TEXTBLOCK* next; // next block
RECTLISTENTRY* rgrle; // list of bounding rectangle(s)
TCHAR* pszText; // text
TCHAR* pszUrl; // URL.
TEXTBLOCK();
~TEXTBLOCK();
void AddRect(const RECT& rc, UINT uMyCharStart = 0, UINT uMyCharCount = 0, UINT uMyLineNumber = 0);
void FreeRects();
};
class CMarkup : IControlMarkup
{
public:
// API
friend HRESULT Markup_Create(IMarkupCallback *pMarkupCallback, HFONT hf, HFONT hfu, REFIID riid, void **ppv);
// IControlMarkup
STDMETHODIMP SetCallback(IUnknown* punk);
STDMETHODIMP GetCallback(REFIID riid, void** ppvUnk);
STDMETHODIMP SetFonts(HFONT hFont, HFONT hFontUnderline);
STDMETHODIMP GetFonts(HFONT* phFont, HFONT* phFontUnderline);
STDMETHODIMP SetText(LPCWSTR pwszText);
STDMETHODIMP GetText(BOOL bRaw, LPWSTR pwszText, DWORD *pdwCch);
STDMETHODIMP SetLinkText(int iLink, UINT uMarkupLinkText, LPCWSTR pwszText);
STDMETHODIMP GetLinkText(int iLink, UINT uMarkupLinkText, LPWSTR pwszText, DWORD *pdwCch);
STDMETHODIMP SetRenderFlags(UINT uDT);
STDMETHODIMP GetRenderFlags(UINT *puDT, HTHEME *phTheme, int *piPartId, int *piStateIdNormal, int *piStateIdLink);
STDMETHODIMP SetThemeRenderFlags(UINT uDT, HTHEME hTheme, int iPartId, int iStateIdNormal, int iStateIdLink);
STDMETHODIMP GetState(int iLink, UINT uStateMask, UINT* puState);
STDMETHODIMP SetState(int iLink, UINT uStateMask, UINT uState);
STDMETHODIMP DrawText(HDC hdcClient, LPCRECT prcClient);
STDMETHODIMP SetLinkCursor();
STDMETHODIMP CalcIdealSize(HDC hdc, UINT uMarkUpCalc, RECT* prc);
STDMETHODIMP SetFocus();
STDMETHODIMP KillFocus();
STDMETHODIMP IsTabbable();
STDMETHODIMP OnButtonDown(POINT pt);
STDMETHODIMP OnButtonUp(POINT pt);
STDMETHODIMP OnKeyDown(UINT uVitKey);
STDMETHODIMP HitTest(POINT pt, UINT* pidLink);
// commented out of IControlMarkup?
STDMETHODIMP HandleEvent(BOOL keys, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
// IUnknown
STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
STDMETHODIMP_(ULONG) AddRef();
STDMETHODIMP_(ULONG) Release();
private:
// private constructor
CMarkup(IMarkupCallback *pMarkupCallback);
CMarkup();
~CMarkup();
friend struct TEXTBLOCK;
HCURSOR GetLinkCursor();
BOOL IsMarkupState(UINT uState)
{
return _pMarkupCallback && _pMarkupCallback->GetState(uState) == S_OK;
}
BOOL IsFocused()
{
return IsMarkupState(MARKUPSTATE_FOCUSED);
}
BOOL IsMarkupAllowed()
{
return IsMarkupState(MARKUPSTATE_ALLOWMARKUP);
}
void Parse(LPCTSTR pszText);
BOOL Add(TEXTBLOCK* pAdd);
TEXTBLOCK* FindLink(int iLink) const;
void FreeBlocks();
void DoNotify(int nCode, int iLink);
int ThemedDrawText(HDC hdc, LPCTSTR lpString, int nCount, LPRECT lpRect, UINT uFormat, BOOL bLink);
void Paint(HDC hdc, IN OPTIONAL LPCRECT prcClient = NULL, BOOL bDraw = TRUE);
BOOL WantTab(int* biFocus = NULL) const;
void AssignTabFocus(int nDirection);
int GetNextEnabledLink(int iStart, int nDir) const;
int StateCount(DWORD dwStateMask, DWORD dwState) const;
HRESULT _GetNextAnchorTag(LPCTSTR * ppszBlock, int * pcBlocks, LPTSTR pszURL, int cchSize, LPTSTR pszID, int cchID);
static TEXTBLOCK* CreateBlock(LPCTSTR pszStart, LPCTSTR pszEnd, int iLink);
// Data
BOOL _bButtonDown; // true when button is clicked on a link but not yet released
TEXTBLOCK* _rgBlocks; // linked list of text blocks
int _cBlocks; // block count
int _Markups; // link count
int _iFocus; // index of focus link
int _cyIdeal;
int _cxIdeal;
LPTSTR _pszCaption;
HFONT _hfStatic,
_hfLink;
HCURSOR _hcurHand;
IMarkupCallback *_pMarkupCallback;
LONG _cRef;
UINT _uDrawTextFlags;
BOOL _bRefreshText;
RECT _rRefreshRect;
HTHEME _hTheme; // these 3 for theme compatible drawing
int _iThemePartId;
int _iThemeStateIdNormal;
int _iThemeStateIdLink;
// static helper methods
static LPTSTR SkipWhite(LPTSTR);
static BOOL _AssignBit(const DWORD , DWORD& , const DWORD);
static BOOL IsStringAlphaNumeric(LPCTSTR);
static HRESULT _GetNextValueDataPair(LPTSTR * , LPTSTR , int , LPTSTR , int);
static int _IsLineBreakChar(LPCTSTR , int , TCHAR , OUT BOOL* , BOOL fIgnoreSpace);
BOOL static _FindLastBreakChar(IN LPCTSTR , IN int , IN TCHAR , OUT int* , OUT BOOL*);
BOOL _FindFirstLineBreak(IN LPCTSTR pszText, IN int cchText, OUT int* piLast, OUT int* piLineBreakSize);
};
CMarkup::CMarkup() :
_cRef(1),
_iFocus(INVALID_LINK_INDEX),
_uDrawTextFlags(DT_LEFT | DT_WORDBREAK),
_bRefreshText(TRUE),
_iThemeStateIdLink(1)
{
}
CMarkup::~CMarkup()
{
FreeBlocks();
SetText(NULL);
if (_pMarkupCallback)
{
_pMarkupCallback->Release();
_pMarkupCallback = NULL;
}
}
inline void MakePoint(LPARAM lParam, OUT LPPOINT ppt)
{
POINTS pts = MAKEPOINTS(lParam);
ppt->x = pts.x;
ppt->y = pts.y;
}
STDAPI Markup_Create(IMarkupCallback *pMarkupCallback, HFONT hf, HFONT hfUnderline, REFIID riid, void **ppv)
{
// Create CMarkup
HRESULT hr = E_FAIL;
CMarkup* pThis = new CMarkup();
if (pThis)
{
pThis->SetCallback(pMarkupCallback);
// init fonts
pThis->SetFonts(hf, hfUnderline);
// COM stuff
hr = pThis->QueryInterface(riid, ppv);
pThis->Release();
}
return hr;
}
HRESULT CMarkup::QueryInterface(REFIID riid, void **ppv)
{
static const QITAB qit[] =
{
QITABENT(CMarkup, IControlMarkup),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
ULONG CMarkup::AddRef()
{
return InterlockedIncrement(&_cRef);
}
ULONG CMarkup::Release()
{
if (InterlockedDecrement(&_cRef))
{
return _cRef;
}
delete this;
return 0;
}
STDMETHODIMP CMarkup::SetCallback(IUnknown* punk)
{
if (_pMarkupCallback)
{
_pMarkupCallback->Release();
_pMarkupCallback = NULL;
}
if (punk)
return punk->QueryInterface(IID_PPV_ARG(IMarkupCallback, &_pMarkupCallback));
// To break reference, pass NULL.
return S_OK;
}
STDMETHODIMP CMarkup::GetCallback(REFIID riid, void** ppvUnk)
{
if (_pMarkupCallback)
return _pMarkupCallback->QueryInterface(riid, ppvUnk);
return E_NOINTERFACE;
}
// IControlMarkup interface implementation
STDMETHODIMP CMarkup::SetFocus()
{
AssignTabFocus(0);
_pMarkupCallback->InvalidateRect(NULL);
return S_OK;
}
STDMETHODIMP CMarkup::KillFocus()
{
// Reset the focus position on request
_iFocus=INVALID_LINK_INDEX;
_pMarkupCallback->InvalidateRect(NULL);
return S_OK;
}
STDMETHODIMP CMarkup::IsTabbable()
{
HRESULT hr = S_FALSE;
int nDir = TESTKEYSTATE(VK_SHIFT) ? -1 : 1;
if (GetNextEnabledLink(_iFocus, nDir) != INVALID_LINK_INDEX)
{
hr = S_OK;
}
return hr;
}
//bugs: calculating ideal 'width' returns bogus valuez
STDMETHODIMP CMarkup::CalcIdealSize(HDC hdc, UINT uMarkUpCalc, RECT* prc)
{
// prc is changed (prc.height or prc.width) only if hr = S_OK
/* currently:
MARKUPSIZE_CALCHEIGHT: takes an initial max width (right-left) and calculates
and ideal height (bottom=ideal_height+top) and the actual width used, which
is always less than the maximum (right=width_used+left).
MARKUPSIZE_CALCWIDTH: doesn't do anything correctly. don't try it. */
HRESULT hr = E_FAIL;
BOOL bQuitNow = FALSE;
if (prc == NULL)
return E_INVALIDARG;
if (NULL != _rgBlocks && 0 != _cBlocks)
{
int cyRet = -1;
SIZE sizeDC;
RECT rc;
if (uMarkUpCalc == MARKUPSIZE_CALCWIDTH)
{
// Come up with a conservative estimate for the new width.
sizeDC.cx = MulDiv(prc->right-prc->left, 1, prc->top-prc->bottom) * 2;
sizeDC.cy = prc->bottom - prc->top;
if (sizeDC.cy < 0)
{
bQuitNow = TRUE;
}
}
if (uMarkUpCalc == MARKUPSIZE_CALCHEIGHT)
{
// Come up with a conservative estimate for the new height.
sizeDC.cy = MulDiv(prc->top-prc->bottom, 1, prc->right-prc->left) * 2;
sizeDC.cx = prc->right-prc->left;
if (sizeDC.cx < 0)
{
bQuitNow = TRUE;
}
// If no x size is specified, make a big estimate
// (i.e. the estimate is the x size of the unparsed text)
if (sizeDC.cx == 0)
{
if (!_hTheme)
{
GetTextExtentPoint(hdc, _pszCaption, lstrlen(_pszCaption), &sizeDC);
}
if (_hTheme)
{
// Get theme font size estimate for the larger part-font type
RECT rcTemp;
GetThemeTextExtent(_hTheme, hdc, _iThemePartId, _iThemeStateIdNormal, _pszCaption, -1, 0, NULL, &rcTemp);
sizeDC.cx = rcTemp.right - rcTemp.left;
GetThemeTextExtent(_hTheme, hdc, _iThemePartId, _iThemeStateIdLink, _pszCaption, -1, 0, NULL, &rcTemp);
if ((rcTemp.right - rcTemp.left) > sizeDC.cx)
{
sizeDC.cx = rcTemp.right - rcTemp.left;
}
}
}
}
hr = E_FAIL;
if (!bQuitNow)
{
int cyPrev = _cyIdeal; // push ideal
int cxPrev = _cxIdeal;
SetRect(&rc, 0, 0, sizeDC.cx, sizeDC.cy);
Paint(hdc, &rc, FALSE);
// save the result
hr = S_OK;
if (uMarkUpCalc == MARKUPSIZE_CALCHEIGHT)
{
prc->bottom = prc->top + _cyIdeal;
prc->right = prc->left + _cxIdeal;
}
if (uMarkUpCalc == MARKUPSIZE_CALCWIDTH)
{
// not implemented -- need to do
}
_cyIdeal = cyPrev; // pop ideal
_cxIdeal = cxPrev;
}
}
if (FAILED(hr))
{
SetRect(prc, 0, 0, 0, 0);
}
return hr;
}
STDMETHODIMP CMarkup::SetLinkCursor()
{
SetCursor(GetLinkCursor());
return S_OK;
}
STDMETHODIMP CMarkup::GetFonts(HFONT* phFont, HFONT* phFontUnderline)
{
ASSERTMSG(IsBadWritePtr(phFont, sizeof(*phFont)), "Invalid phFont passed to CMarkup::GetFont");
HRESULT hr = E_FAIL;
*phFont = NULL;
*phFontUnderline = NULL;
if (_hfStatic)
{
LOGFONT lf;
if (GetObject(_hfStatic, sizeof(lf), &lf))
{
*phFont = CreateFontIndirect(&lf);
if (GetObject(_hfLink, sizeof(lf), &lf))
*phFontUnderline = CreateFontIndirect(&lf);
hr = S_OK;
}
}
return hr;
}
HRESULT CMarkup::SetFonts(HFONT hFont, HFONT hFontUnderline)
{
HRESULT hr = S_FALSE;
_bRefreshText = TRUE;
_hfStatic = hFont;
_hfLink = hFontUnderline;
if (_hfLink != NULL && _hfStatic != NULL)
{
hr = S_OK;
}
return hr;
}
STDMETHODIMP CMarkup::HandleEvent(BOOL keys, HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
/* this function handles:
WM_KEYDOWN
WM_BUTTONDOWN
WM_BUTTONUP
WM_MOUSEMOVE
pass it:
keys - TRUE if you want to handle WM_KEYDOWN
others - the params from the WndProc
returns: S_OK if event handled, S_FALSE if no event handled */
HRESULT hr = S_FALSE;
if (!hwnd)
{
hr = E_INVALIDARG;
}
else
{
switch (uMsg)
{
case WM_KEYDOWN:
{
if (keys==TRUE)
{
OnKeyDown((UINT)wParam);
hr = S_OK;
}
break;
}
case WM_LBUTTONDOWN:
{
POINT pt;
MakePoint(lParam, &pt);
OnButtonDown(pt);
hr = S_OK;
break;
}
case WM_LBUTTONUP:
{
POINT pt;
MakePoint(lParam, &pt);
OnButtonUp(pt);
hr = S_OK;
break;
}
case WM_MOUSEMOVE:
{
POINT pt;
UINT pidLink;
MakePoint(lParam, &pt);
if (HitTest(pt, &pidLink) == S_OK)
{
SetLinkCursor();
}
hr = S_OK;
break;
}
}
}
return hr;
}
STDMETHODIMP CMarkup::DrawText(HDC hdcClient, LPCRECT prcClient)
{
HRESULT hr = E_INVALIDARG;
if (prcClient != NULL && hdcClient != NULL)
{
Paint(hdcClient, prcClient);
hr = S_OK;
}
return hr;
}
STDMETHODIMP CMarkup::GetText(BOOL bRaw, LPWSTR pwszText, DWORD *pcchText)
{
// if passed pwszText==NULL, return the number of characters needed in pcchText
if (!pwszText)
{
// for now, always return raw text, as it will always be larger than necessary
*pcchText = lstrlen(_pszCaption)+1;
}
else
{
*pwszText = 0;
if (bRaw)
{
if (_pszCaption)
{
lstrcpyn(pwszText, _pszCaption, *pcchText);
}
}
else
{
for (TEXTBLOCK* pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
if (pBlock->pszText)
StrCatBuff(pwszText, pBlock->pszText, *pcchText);
}
}
*pcchText = lstrlen(pwszText);
}
return S_OK;
}
STDMETHODIMP CMarkup::SetText(LPCWSTR pwszText)
{
// Note: we don't reparse in the case of same strings
if (pwszText && 0 == lstrcmp(pwszText, _pszCaption))
{
return S_FALSE; // nothing to do.
}
// set the text
_bRefreshText = TRUE;
if (_pszCaption)
{
LocalFree(_pszCaption);
_pszCaption = NULL;
}
_iFocus = INVALID_LINK_INDEX;
if (pwszText && *pwszText)
{
_pszCaption = StrDup(pwszText); // StrDup gets free'd with LocalFree
if (_pszCaption)
{
Parse(pwszText);
}
else
return E_OUTOFMEMORY;
}
return S_OK;
}
STDMETHODIMP CMarkup::SetRenderFlags(UINT uDT)
{
HRESULT hr = E_INVALIDARG;
_bRefreshText = TRUE;
// Set drawtext flags, but filter out unsupported modes
_uDrawTextFlags = uDT;
_uDrawTextFlags &= ~(DT_CALCRECT | DT_INTERNAL | DT_NOCLIP | DT_NOFULLWIDTHCHARBREAK | DT_EDITCONTROL);
// Turn off themedraw
_hTheme = NULL;
hr = S_OK;
return hr;
}
STDMETHODIMP CMarkup::SetThemeRenderFlags(UINT uDT, HTHEME hTheme, int iPartId, int iStateIdNormal, int iStateIdLink)
{
HRESULT hr = SetRenderFlags(uDT);
if (hr == S_OK)
{
// Turn on themedraw
_hTheme = hTheme;
_iThemePartId = iPartId;
_iThemeStateIdNormal = iStateIdNormal;
_iThemeStateIdLink = iStateIdLink;
}
return hr;
}
HRESULT CMarkup::GetRenderFlags(UINT *puDT, HTHEME *phTheme, int *piPartId, int *piStateIdNormal, int *piStateIdLink)
{
*puDT = _uDrawTextFlags;
*phTheme = _hTheme;
*piPartId = _iThemePartId;
*piStateIdNormal = _iThemeStateIdNormal;
*piStateIdLink = _iThemeStateIdLink;
return S_OK;
}
// WM_KEYDOWN handler - exposed as COM
STDMETHODIMP CMarkup::OnKeyDown(UINT virtKey)
{
// returns: S_FALSE unless key handled, then S_OK
// (so if you pass a VK_TAB and it isn't handled, pass on focus)
HRESULT hr = S_FALSE;
switch(virtKey)
{
case VK_TAB:
if (WantTab(&_iFocus))
{
hr = S_OK;
}
_pMarkupCallback->InvalidateRect(NULL);
break;
case VK_RETURN:
case VK_SPACE:
{
TEXTBLOCK * pBlock = FindLink(_iFocus);
if (pBlock)
{
DoNotify (MARKUPMESSAGE_KEYEXECUTE, _iFocus);
hr = S_OK;
}
}
break;
}
return hr;
}
HRESULT CMarkup::OnButtonDown(const POINT pt)
{
// returns: S_FALSE unless button down on link, then S_OK
// note: OnButtonDown no longer turns on capturing all mouse events. Not sure if this will have any negative effect.
HRESULT hr = S_FALSE;
UINT iLink;
if (HitTest(pt, &iLink) == S_OK)
{
hr = S_OK;
SetLinkCursor();
_iFocus = iLink;
_bButtonDown = TRUE;
if (! (IsFocused()))
{
/* this is our way of telling the host we want focus. */
DoNotify (MARKUPMESSAGE_WANTFOCUS, _iFocus);
}
_pMarkupCallback->InvalidateRect(NULL);
}
return hr;
}
HRESULT CMarkup::OnButtonUp(const POINT pt)
{
// returns: S_FALSE unless notification sent, then S_OK
HRESULT hr = S_FALSE;
if (_bButtonDown == TRUE)
{
_bButtonDown = FALSE;
// if the focus link contains the point, we can
// notify the callback of a click event.
INT iHit;
HitTest(pt, (UINT*) &iHit);
TEXTBLOCK* pBlock = FindLink(_iFocus);
if (pBlock &&
(pBlock->state & LIS_ENABLED) != 0 &&
_iFocus == iHit)
{
hr = S_OK;
DoNotify (MARKUPMESSAGE_CLICKEXECUTE, _iFocus);
}
}
return hr;
}
HRESULT CMarkup::HitTest(const POINT pt, UINT* pidLink)
{
// returns S_OK only if pidLink is not INVALID_LINK_INDEX
HRESULT hr = S_FALSE;
*pidLink = INVALID_LINK_INDEX;
// Walk blocks until we find a link rect that contains the point
TEXTBLOCK* pBlock;
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
if (IS_LINK(pBlock) && (pBlock->state & LIS_ENABLED)!=0)
{
RECTLISTENTRY* prce;
for(prce = pBlock->rgrle; prce; prce = prce->next)
{
if (PtInRect(&prce->rc, pt))
{
hr = S_OK;
*pidLink = pBlock->iLink;
}
}
}
}
return hr;
}
HRESULT CMarkup::SetLinkText(int iLink, UINT uMarkupLinkText, LPCWSTR pwszText)
{
HRESULT hr = E_INVALIDARG;
TEXTBLOCK* pBlock = FindLink(iLink);
if (pBlock)
{
hr = S_OK;
switch (uMarkupLinkText)
{
case MARKUPLINKTEXT_ID:
lstrcpyn(pBlock->szID, pwszText, ARRAYSIZE(pBlock->szID));
break;
case MARKUPLINKTEXT_URL:
Str_SetPtr(&pBlock->pszUrl, pwszText);
break;
case MARKUPLINKTEXT_TEXT:
Str_SetPtr(&pBlock->pszText, pwszText);
break;
default:
hr = S_FALSE;
break;
}
}
return hr;
}
HRESULT CMarkup::GetLinkText(int iLink, UINT uMarkupLinkText, LPWSTR pwszText, DWORD *pdwCch)
{
HRESULT hr = E_INVALIDARG;
TEXTBLOCK* pBlock = FindLink(iLink);
if (pBlock)
{
LPCTSTR pszSource;
switch (uMarkupLinkText)
{
case MARKUPLINKTEXT_ID:
pszSource = pBlock->szID;
hr = S_OK;
break;
case MARKUPLINKTEXT_URL:
pszSource = pBlock->pszUrl;
hr = S_OK;
break;
case MARKUPLINKTEXT_TEXT:
pszSource = pBlock->pszText;
hr = S_OK;
break;
}
if (hr == S_OK)
{
if (pwszText)
{
if (pszSource == NULL)
pszSource = TEXT("");
lstrcpyn(pwszText, pszSource, *pdwCch);
*pdwCch = lstrlen(pwszText); // fill in number of characters actually copied
}
else
*pdwCch = lstrlen(pszSource)+1; // fill in number of characters needed, including NULL
}
}
return hr;
}
#define MARKUPSTATE_VALID (MARKUPSTATE_ENABLED | MARKUPSTATE_VISITED | MARKUPSTATE_FOCUSED)
HRESULT CMarkup::SetState(int iLink, UINT uStateMask, UINT uState)
{
BOOL bRedraw = FALSE;
HRESULT hr = E_FAIL;
TEXTBLOCK* pBlock = FindLink(iLink);
if (uStateMask & ~MARKUPSTATE_VALID)
return E_INVALIDARG;
if (pBlock)
{
hr = S_OK;
if (uStateMask & MARKUPSTATE_ENABLED)
{
bRedraw |= _AssignBit(MARKUPSTATE_ENABLED, pBlock->state, uState);
int cEnabledLinks = StateCount(MARKUPSTATE_ENABLED, MARKUPSTATE_ENABLED);
}
if (uStateMask & MARKUPSTATE_VISITED)
{
bRedraw |= _AssignBit(MARKUPSTATE_VISITED, pBlock->state, uState);
}
if (uStateMask & MARKUPSTATE_FOCUSED)
{
// Focus assignment is handled differently;
// one and only one link can have focus...
if (uState & MARKUPSTATE_FOCUSED)
{
bRedraw |= (_iFocus != iLink);
_iFocus = iLink;
}
else
{
bRedraw |= (_iFocus == iLink);
_iFocus = INVALID_LINK_INDEX;
}
}
}
if (bRedraw)
{
_pMarkupCallback->InvalidateRect(NULL);
}
return hr;
}
HRESULT CMarkup::GetState(int iLink, UINT uStateMask, UINT* puState)
{
HRESULT hr = E_FAIL;
TEXTBLOCK* pBlock = FindLink(iLink);
if (pBlock && puState != NULL)
{
hr = S_FALSE;
*puState = 0;
if (uStateMask & MARKUPSTATE_FOCUSED)
{
if (_iFocus == iLink)
*puState |= MARKUPSTATE_FOCUSED;
hr = S_OK;
}
if (uStateMask & MARKUPSTATE_ENABLED)
{
if (pBlock->state & MARKUPSTATE_ENABLED)
*puState |= MARKUPSTATE_ENABLED;
hr = S_OK;
}
if (uStateMask & MARKUPSTATE_VISITED)
{
if (pBlock->state & MARKUPSTATE_VISITED)
*puState |= MARKUPSTATE_VISITED;
hr = S_OK;
}
}
return hr;
}
//-------------------------------------------------------------------------//
// CMarkup internal implementation
//-------------------------------------------------------------------------//
void CMarkup::FreeBlocks()
{
for(TEXTBLOCK* pBlock = _rgBlocks; pBlock; )
{
TEXTBLOCK* pNext = pBlock->next;
delete pBlock;
pBlock = pNext;
}
_rgBlocks = NULL;
_cBlocks = _Markups = 0;
}
TEXTBLOCK* CMarkup::CreateBlock(LPCTSTR pszStart, LPCTSTR pszEnd, int iLink)
{
TEXTBLOCK* pBlock = NULL;
int cch = (int)(pszEnd - pszStart) + 1;
if (cch > 0)
{
pBlock = new TEXTBLOCK;
if (pBlock)
{
pBlock->pszText = new TCHAR[cch];
if (pBlock->pszText == NULL)
{
delete pBlock;
pBlock = NULL;
}
else
{
lstrcpyn(pBlock->pszText, pszStart, cch);
pBlock->iLink = iLink;
}
}
}
return pBlock;
}
HCURSOR CMarkup::GetLinkCursor()
{
if (!_hcurHand)
{
_hcurHand = LoadCursor(NULL, IDC_HAND);
}
return _hcurHand;
}
HRESULT CMarkup::_GetNextAnchorTag(LPCTSTR * ppszBlock, int * pcBlocks, LPTSTR pszURL, int cchSize, LPTSTR pszID, int cchID)
{
HRESULT hr = E_FAIL;
LPTSTR pszStartOfTag;
LPTSTR pszIterate = (LPTSTR)*ppszBlock;
LPTSTR pszStartTry = (LPTSTR)*ppszBlock; // We start looking for "<A" at the beginning.
pszURL[0] = 0;
pszID[0] = 0;
// While we find a possible start of a tag.
while ((pszStartOfTag = StrStrI(pszStartTry, LINKTAG1)) != NULL)
{
// See if the rest of the string completes the tag.
pszIterate = pszStartOfTag;
pszStartTry = CharNext(pszStartOfTag); // Do this so the while loop will end when we finish don't find any more "<A".
if (pszIterate[0])
{
pszIterate += cchLINKTAG1; // Skip past the start of the tag.
// Walk thru the Value/Data pairs in the tag
TCHAR szValue[MAX_PATH];
TCHAR szData[L_MAX_URL_LENGTH];
pszIterate = SkipWhite(pszIterate); // SkipWhiteSpace
while ((CH_ENDTAG != pszIterate[0]) &&
SUCCEEDED(_GetNextValueDataPair(&pszIterate, szValue, ARRAYSIZE(szValue), szData, ARRAYSIZE(szData))))
{
if (0 == StrCmpI(szValue, SZ_ATTRIBUTE_HREF))
{
StrCpyN(pszURL, szData, cchSize);
}
else if (0 == StrCmpI(szValue, SZ_ATTRIBUTE_ID))
{
StrCpyN(pszID, szData, cchID);
}
else
{
// We ignore other pairs in order to be back-compat with future
// supported attributes.
}
pszIterate = SkipWhite(pszIterate);
}
if (CH_ENDTAG == pszIterate[0])
{
hr = S_OK;
}
}
if (SUCCEEDED(hr))
{
// Add run between psz1 and pszBlock as static text
if (pszStartOfTag > *ppszBlock)
{
TEXTBLOCK * pBlock = CreateBlock(*ppszBlock, pszStartOfTag, INVALID_LINK_INDEX);
if (NULL != pBlock)
{
Add(pBlock);
(*pcBlocks)++;
}
}
*ppszBlock = CharNext(pszIterate); // Skip past the tag's ">"
// We found an entire tag. Stop looking.
break;
}
else
{
// The "<A" we tried wasn't a valid tag. Are we at the end of the string?
// If not, let's keep looking for other "<A" that may be valid.
}
}
return hr;
}
void CMarkup::Parse(LPCTSTR pszText)
{
TEXTBLOCK* pBlock;
int cBlocks = 0, Markups = 0;
LPCTSTR psz1, psz2, pszBlock;
LPTSTR pszBuf = NULL;
FreeBlocks(); // free existing blocks
pszBuf = (LPTSTR)pszText;
if (!(pszBuf && *pszBuf))
{
goto exit;
}
for(pszBlock = pszBuf; pszBlock && *pszBlock;)
{
TCHAR szURL[L_MAX_URL_LENGTH];
TCHAR szID[MAX_LINKID_TEXT];
// Search for "<a>" tag
if (IsMarkupAllowed() &&
SUCCEEDED(_GetNextAnchorTag(&pszBlock, &cBlocks, szURL, ARRAYSIZE(szURL), szID, ARRAYSIZE(szID))))
{
psz1 = pszBlock; // After _GetNextAnchorTag(), pszBlock points to the char after the start tag.
if (psz1 && *psz1)
{
if ((psz2 = StrStrI(pszBlock, LINKTAG2)) != NULL)
{
if ((pBlock = CreateBlock(psz1, psz2, Markups)) != NULL)
{
if (szURL[0])
{
Str_SetPtr(&pBlock->pszUrl, szURL);
}
if (szID[0])
{
StrCpyN(pBlock->szID, szID, ARRAYSIZE(pBlock->szID));
}
Add(pBlock);
cBlocks++;
Markups++;
}
// safe-skip over tag
for(int i = 0;
i < cchLINKTAG2 && psz2 && *psz2;
i++, psz2 = CharNext(psz2));
pszBlock = psz2;
}
else // syntax error; mark trailing run is static text.
{
psz2 = pszBlock + lstrlen(pszBlock);
if ((pBlock = CreateBlock(psz1, psz2, INVALID_LINK_INDEX)) != NULL)
{
Add(pBlock);
cBlocks++;
}
pszBlock = psz2;
}
}
}
else // no more tags. Mark the last run of static text
{
psz2 = pszBlock + lstrlen(pszBlock);
if ((pBlock = CreateBlock(pszBlock, psz2, INVALID_LINK_INDEX)) != NULL)
{
Add(pBlock);
cBlocks++;
}
pszBlock = psz2;
}
}
ASSERT(cBlocks == _cBlocks);
ASSERT(Markups == _Markups);
exit:
if (!pszText && pszBuf) // delete text buffer if we had alloc'd it.
{
delete [] pszBuf;
}
}
BOOL CMarkup::Add(TEXTBLOCK* pAdd)
{
BOOL bAdded = FALSE;
pAdd->next = NULL;
if (!_rgBlocks)
{
_rgBlocks = pAdd;
bAdded = TRUE;
}
else
{
for(TEXTBLOCK* pBlock = _rgBlocks; pBlock && !bAdded; pBlock = pBlock->next)
{
if (!pBlock->next)
{
pBlock->next = pAdd;
bAdded = TRUE;
}
}
}
if (bAdded)
{
_cBlocks++;
if (IS_LINK(pAdd))
{
_Markups++;
}
}
return bAdded;
}
TEXTBLOCK* CMarkup::FindLink(int iLink) const
{
if (iLink == INVALID_LINK_INDEX)
{
return NULL;
}
for(TEXTBLOCK* pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
if (IS_LINK(pBlock) && pBlock->iLink == iLink)
return pBlock;
}
return NULL;
}
// NOTE: optimizatation! skip drawing loop when called for calcrect!
void CMarkup::Paint(HDC hdcClient, LPCRECT prcClient, BOOL bDraw)
{
HDC hdc = hdcClient;
COLORREF rgbOld = GetTextColor(hdc); // save text color
HFONT hFontOld = (HFONT) GetCurrentObject(hdc, OBJ_FONT);
TEXTBLOCK* pBlock;
BOOL fFocus = IsFocused();
if (_cBlocks == 1)
{
pBlock = _rgBlocks;
HFONT hFont = _hfStatic;
pBlock->FreeRects(); // free hit/focus rects; we're going to recompute.
if (IS_LINK(pBlock))
{
SetTextColor(hdc, (pBlock->state & LIS_ENABLED) ? LINKCOLOR_ENABLED : LINKCOLOR_DISABLED);
hFont = _hfLink;
}
if (hFont)
{
SelectObject(hdc, hFont);
}
RECT rc = *prcClient;
int cch = lstrlen(pBlock->pszText);
ThemedDrawText(hdc, pBlock->pszText, cch, &rc, _uDrawTextFlags | DT_CALCRECT, IS_LINK(pBlock));
pBlock->AddRect(rc, 0, cch, 0);
_cyIdeal = RECTHEIGHT(rc);
_cxIdeal = RECTWIDTH(rc);
if (bDraw)
{
ThemedDrawText(hdc, pBlock->pszText, cch, &rc, _uDrawTextFlags, IS_LINK(pBlock));
if (fFocus)
{
SetTextColor(hdc, rgbOld); // restore text color
DrawFocusRect(hdc, &rc);
}
}
}
else
{
TEXTMETRIC tm;
int iLineWidth[255]; // line index offset
int iLine = 0, // current line index
cyLine = 0, // line height.
cyLeading = 0, // internal leading
_cchOldDrawn = 1; // get out of infinite loop if window too small t-jklann
RECT rcDraw = *prcClient; // initialize line rect
_cxIdeal = 0;
// Initialize iLineWidth (just index 0, others init on use)
iLineWidth[0]=0;
// Get font metrics into cyLeading
if (!_hTheme)
{
SelectObject(hdc, _hfLink);
GetTextMetrics(hdc, &tm);
if (tm.tmExternalLeading > cyLeading)
{
cyLeading = tm.tmExternalLeading;
}
SelectObject(hdc, _hfStatic);
GetTextMetrics(hdc, &tm);
if (tm.tmExternalLeading > cyLeading)
{
cyLeading = tm.tmExternalLeading;
}
}
else
{
GetThemeTextMetrics(_hTheme, hdc, _iThemePartId, _iThemeStateIdNormal, &tm);
if (tm.tmExternalLeading > cyLeading)
{
cyLeading = tm.tmExternalLeading;
}
GetThemeTextMetrics(_hTheme, hdc, _iThemePartId, _iThemeStateIdLink, &tm);
if (tm.tmExternalLeading > cyLeading)
{
cyLeading = tm.tmExternalLeading;
}
}
// Save us a lot of time if text hasn't changed...
if (_bRefreshText == TRUE || !EqualRect(&_rRefreshRect, prcClient))
{
UINT uDrawTextCalc = _uDrawTextFlags | DT_CALCRECT | DT_SINGLELINE;
uDrawTextCalc &= ~(DT_CENTER | DT_LEFT | DT_RIGHT | DT_VCENTER | DT_BOTTOM);
BOOL bKillingLine = FALSE;
// For each block of text (calculation loop)...
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
// font select (so text will draw correctly)
if (!_hTheme)
{
BOOL bLink = IS_LINK(pBlock);
HFONT hFont = bLink ? _hfLink : _hfStatic;
if (hFont)
{
SelectObject(hdc, hFont);
}
}
int cchDraw = lstrlen(pBlock->pszText); // chars to draw, this block
int cchDrawn = 0; // chars to draw, this block
LPTSTR pszText = &pBlock->pszText[cchDrawn];
LPTSTR pszTextOriginal = &pBlock->pszText[cchDrawn];
pBlock->FreeRects(); // free hit/focus rects; we're going to recompute.
// while text remains in this block...
_cchOldDrawn = 1;
while(cchDraw > 0 && !((_uDrawTextFlags & DT_SINGLELINE) && (iLine>0)))
{
// compute line height and maximum text width to rcBlock
RECT rcBlock;
int cchTry = cchDraw;
int cchTrySave = cchTry;
int cchBreak = 0;
int iLineBreakSize;
BOOL bRemoveBreak = FALSE;
BOOL bRemoveLineBreak = FALSE;
RECT rcCalc;
CopyRect(&rcCalc, &rcDraw);
// support multiline text phrases
bRemoveLineBreak = _FindFirstLineBreak(pszText, cchTry, &cchBreak, &iLineBreakSize);
if (bRemoveLineBreak)
{
cchTry = cchBreak;
}
// find out how much we can fit on this line within the rectangle
// calc rect breaking at breakpoints (or -1 char) until rectangle fits inside drawing rect.
for(;;)
{
// choose codepath: themes or normal drawtext (no exttextout path)
// now we use drawtext to preserve formatting options (tabs/underlines)
ThemedDrawText(hdc, pszText, cchTry, &rcCalc, uDrawTextCalc, IS_LINK(pBlock));
cyLine = RECTHEIGHT(rcCalc);
// special case: support \n as only character on line (we need a valid line width & length)
if (cchTry == 0 && bRemoveLineBreak==TRUE)
{
// these two lines adjust drawing to within a valid range when the \n is barely cut off
rcCalc.left = prcClient->left;
rcCalc.right = prcClient->right;
cyLine = ThemedDrawText(hdc, TEXT("a"), 1, &rcCalc, uDrawTextCalc, IS_LINK(pBlock));
// the "a" could be any text. It exists because passing "\n" to DrawText doesn't return a valid line height.
rcCalc.right = rcCalc.left;
}
if (RECTWIDTH(rcCalc) > RECTWIDTH(rcDraw))
{
// too big
cchTrySave = cchTry;
BOOL fBreak = _FindLastBreakChar(pszText, cchTry, tm.tmBreakChar, &cchTry, &bRemoveBreak);
// case that our strings ends with a valid break char
if (cchTrySave == cchTry && cchTry > 0)
{
cchTry--;
}
// this code allows character wrapping instead of just word wrapping.
// keep it in case we want to change the behavior.
if (!fBreak && prcClient->left == rcDraw.left)
{
// no break character found, so force a break if we can.
if (cchTrySave > 0)
{
cchTry = cchTrySave - 1;
}
}
if (cchTry > 0)
{
continue;
}
}
break;
}
// if our line break got clipped, turn off line break..
if (bRemoveLineBreak && cchBreak > cchTry)
{
bRemoveLineBreak = FALSE;
}
// Count the # chars drawn, account for clipping
cchDrawn = cchTry;
if ((cchTry < cchDraw) && bRemoveLineBreak)
{
cchDrawn+=iLineBreakSize;
}
// DT_WORDBREAK off support
// Kill this line if bKillingLine is true; i.e. pretend we drew it, but do nothing
if (bKillingLine)
{
pszText += cchDrawn;
}
else
{
// initialize drawing rectangle and block rectangle
SetRect(&rcBlock, rcCalc.left , 0, rcCalc.right , RECTHEIGHT(rcCalc));
rcDraw.right = min(rcDraw.left + RECTWIDTH(rcBlock), prcClient->right);
rcDraw.bottom = rcDraw.top + cyLine;
// Add rectangle to block's list and update line width and ideal x width
// (Only if we're actually going to draw this line, though)
if (cchTry)
{
// DT_SINGLELINE support
if (!((_uDrawTextFlags & DT_SINGLELINE) == DT_SINGLELINE) || (iLine == 0))
{
pBlock->AddRect(rcDraw, (UINT) (pszText-pszTextOriginal), cchDrawn, iLine);
}
iLineWidth[iLine] = max(iLineWidth[iLine], rcDraw.left - prcClient->left + RECTWIDTH(rcBlock));
_cxIdeal = max(_cxIdeal, iLineWidth[iLine]);
}
if (cchTry < cchDraw) // we got clipped
{
if (bRemoveBreak)
{
cchDrawn++;
}
pszText += cchDrawn;
// advance to next line and init next linewidth
iLine++;
iLineWidth[iLine]=0;
// t-jklann 6/00: added support for line wrap in displaced text (left&top)
rcDraw.left = prcClient->left;
if (!(_uDrawTextFlags & DT_SINGLELINE))
{
rcDraw.top = prcClient->top + iLine * cyLine;
}
else
{
rcDraw.top = prcClient->top;
}
rcDraw.bottom = rcDraw.top + cyLine + cyLeading;
rcDraw.right = prcClient->right;
}
else // we were able to draw the entire text
{
// adjust drawing rectangle
rcDraw.left += RECTWIDTH(rcBlock);
rcDraw.right = prcClient->right;
}
// Update ideal y width
_cyIdeal = rcDraw.bottom - prcClient->top;
}
// support for: DT_WORDBREAK turned off
// Kill the next line if we got clipped and there's no wordbreak
if (((_uDrawTextFlags & DT_WORDBREAK) != DT_WORDBREAK))
{
if (cchTry < cchDraw )
{
bKillingLine = TRUE;
}
if (bRemoveLineBreak)
{
bKillingLine = FALSE;
}
}
// Update calculation of chars drawn
cchDraw -= cchDrawn;
// bug catch: get out if we really can't draw
if (_cchOldDrawn == 0 && cchDrawn == 0)
{
iLine--;
rcDraw.top = prcClient->top + iLine * cyLine;
cchDraw = 0;
}
_cchOldDrawn = cchDrawn;
}
}
// Handle justification issues (DT_VCENTER, DT_TOP, DT_BOTTOM)
if (((_uDrawTextFlags & DT_SINGLELINE) == DT_SINGLELINE) &&
((_uDrawTextFlags & (DT_VCENTER | DT_BOTTOM)) > 0))
{
// Calc offset
int cyOffset = 0;
if ((_uDrawTextFlags & DT_VCENTER) == DT_VCENTER)
{
cyOffset = (RECTHEIGHT(*prcClient) - _cyIdeal)/2;
}
if ((_uDrawTextFlags & DT_BOTTOM) == DT_BOTTOM)
{
cyOffset = (RECTHEIGHT(*prcClient) - _cyIdeal);
}
// Offset every rectangle
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
for(RECTLISTENTRY* prce = pBlock->rgrle; prce; prce = prce->next)
{
prce->rc.top += cyOffset;
prce->rc.bottom += cyOffset;
}
}
}
// Handle justification issues (DT_CENTER, DT_LEFT, DT_RIGHT)
if (((_uDrawTextFlags & DT_CENTER) == DT_CENTER) || ((_uDrawTextFlags & DT_RIGHT) == DT_RIGHT))
{
// Step 1: turn iLineWidth into an offset vector
for (int i = 0; i <= iLine; i++)
{
if (RECTWIDTH(*prcClient) > iLineWidth[i])
{
if ((_uDrawTextFlags & DT_CENTER) == DT_CENTER)
{
iLineWidth[i] = (RECTWIDTH(*prcClient)-iLineWidth[i])/2;
}
if ((_uDrawTextFlags & DT_RIGHT) == DT_RIGHT)
{
iLineWidth[i] = (RECTWIDTH(*prcClient)-iLineWidth[i]);
}
}
else
{
iLineWidth[i] = 0;
}
}
// Step 2: offset every rect-angle
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
for(RECTLISTENTRY* prce = pBlock->rgrle; prce; prce = prce->next)
{
prce->rc.left += iLineWidth[prce->uLineNumber];
prce->rc.right += iLineWidth[prce->uLineNumber];
}
}
}
CopyRect(&_rRefreshRect, prcClient);
_bRefreshText = FALSE;
}
if (bDraw)
{
// For each block of text (drawing loop)...
UINT uDrawTextDraw = _uDrawTextFlags | DT_SINGLELINE;
uDrawTextDraw &= ~(DT_CENTER | DT_LEFT | DT_RIGHT | DT_CALCRECT | DT_VCENTER | DT_BOTTOM);
LRESULT dwCustomDraw=0;
_pMarkupCallback->OnCustomDraw(CDDS_PREPAINT, hdc, prcClient, 0, 0, &dwCustomDraw);
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
BOOL bLink = IS_LINK(pBlock);
BOOL bEnabled = pBlock->state & LIS_ENABLED;
// font select
if (!_hTheme)
{
HFONT hFont = bLink ? _hfLink : _hfStatic;
if (hFont)
{
SelectObject(hdc, hFont);
}
}
// initialize foreground color
if (!_hTheme)
{
if (bLink)
{
SetTextColor(hdc, bEnabled ? LINKCOLOR_ENABLED : LINKCOLOR_DISABLED);
}
else
{
SetTextColor(hdc, rgbOld); // restore text color
}
}
if (dwCustomDraw & CDRF_NOTIFYITEMDRAW)
{
_pMarkupCallback->OnCustomDraw(CDDS_ITEMPREPAINT, hdc, NULL, pBlock->iLink, bEnabled ? CDIS_DEFAULT : CDIS_DISABLED, NULL);
}
// draw the text
LPTSTR pszText = pBlock->pszText;
LPTSTR pszTextOriginal = pBlock->pszText;
for(RECTLISTENTRY* prce = pBlock->rgrle; prce; prce = prce->next)
{
RECT rc = prce->rc;
pszText = pszTextOriginal + prce->uCharStart;
ThemedDrawText(hdc, pszText, prce->uCharCount, &rc, uDrawTextDraw, IS_LINK(pBlock));
}
// Draw focus rect(s)
if (fFocus && pBlock->iLink == _iFocus && IS_LINK(pBlock))
{
SetTextColor(hdc, rgbOld); // restore text color
for(RECTLISTENTRY* prce = pBlock->rgrle; prce; prce = prce->next)
{
DrawFocusRect(hdc, &prce->rc);
}
}
if (dwCustomDraw & CDRF_NOTIFYITEMDRAW)
{
_pMarkupCallback->OnCustomDraw(CDDS_ITEMPOSTPAINT, hdc, NULL, pBlock->iLink, bEnabled ? CDIS_DEFAULT : CDIS_DISABLED, NULL);
}
}
if (dwCustomDraw & CDRF_NOTIFYPOSTPAINT)
{
_pMarkupCallback->OnCustomDraw(CDDS_POSTPAINT, hdc, NULL, 0, 0, NULL);
}
}
}
SetTextColor(hdc, rgbOld); // restore text color
if (hFontOld)
{
SelectObject(hdc, hFontOld);
}
}
int CMarkup::GetNextEnabledLink(int iStart, int nDir) const
{
ASSERT(-1 == nDir || 1 == nDir);
if (_Markups > 0)
{
if (INVALID_LINK_INDEX == iStart)
{
iStart = nDir > 0 ? -1 : _Markups;
}
for(iStart += nDir; iStart >= 0; iStart += nDir)
{
TEXTBLOCK* pBlock = FindLink(iStart);
if (!pBlock)
{
return INVALID_LINK_INDEX;
}
if (pBlock->state & LIS_ENABLED)
{
ASSERT(iStart == pBlock->iLink);
return iStart;
}
}
}
return INVALID_LINK_INDEX;
}
int CMarkup::StateCount(DWORD dwStateMask, DWORD dwState) const
{
TEXTBLOCK* pBlock;
int cnt = 0;
for(pBlock = _rgBlocks; pBlock; pBlock = pBlock->next)
{
if (IS_LINK(pBlock) &&
(pBlock->state & dwStateMask) == dwState)
{
cnt++;
}
}
return cnt;
}
BOOL CMarkup::WantTab(int* biFocus) const
{
int nDir = TESTKEYSTATE(VK_SHIFT) ? -1 : 1;
int iFocus = GetNextEnabledLink(_iFocus, nDir);
if (INVALID_LINK_INDEX != iFocus)
{
if (biFocus)
{
*biFocus = iFocus;
}
return TRUE;
}
else
{
// if we can't handle the focus, prepare for the next round
//iFocus = GetNextEnabledLink(-1, nDir);
*biFocus = -1;
return FALSE;
}
}
void CMarkup::AssignTabFocus(int nDirection)
{
if (_Markups)
{
if (0 == nDirection)
{
if (INVALID_LINK_INDEX != _iFocus)
{
return;
}
nDirection = 1;
}
_iFocus = GetNextEnabledLink(_iFocus, nDirection);
}
}
//-------------------------------------------------------------------------//
TEXTBLOCK::TEXTBLOCK()
: iLink(INVALID_LINK_INDEX),
next(NULL),
state(LIS_ENABLED),
pszText(NULL),
pszUrl(NULL),
rgrle(NULL)
{
*szID = 0;
}
TEXTBLOCK::~TEXTBLOCK()
{
// free block text
Str_SetPtr(&pszText, NULL);
Str_SetPtr(&pszUrl, NULL);
// free rectangle(s)
FreeRects();
}
void TEXTBLOCK::AddRect(const RECT& rc, UINT uMyCharStart, UINT uMyCharCount, UINT uMyLineNumber)
{
RECTLISTENTRY* prce;
if ((prce = new RECTLISTENTRY) != NULL)
{
CopyRect(&(prce->rc), &rc);
prce->next = NULL;
prce->uCharStart = uMyCharStart;
prce->uCharCount = uMyCharCount;
prce->uLineNumber = uMyLineNumber;
}
if (rgrle == NULL)
{
rgrle = prce;
}
else
{
for(RECTLISTENTRY* p = rgrle; p; p = p->next)
{
if (p->next == NULL)
{
p->next = prce;
break;
}
}
}
}
void TEXTBLOCK::FreeRects()
{
for(RECTLISTENTRY* p = rgrle; p;)
{
RECTLISTENTRY* next = p->next;
delete p;
p = next;
}
rgrle = NULL;
}
//-------------------------------------------------------------------------//
// t-jklann 6/00: added these formerly global methods to the CMarkup class
// Returns a pointer to the first non-whitespace character in a string.
LPTSTR CMarkup::SkipWhite(LPTSTR lpsz)
{
/* prevent sign extension in case of DBCS */
while (*lpsz && (TUCHAR)*lpsz <= TEXT(' '))
lpsz++;
return(lpsz);
}
BOOL CMarkup::_AssignBit(const DWORD dwBit, DWORD& dwDest, const DWORD dwSrc) // returns TRUE if changed
{
if (((dwSrc & dwBit) != 0) != ((dwDest & dwBit) != 0))
{
if (((dwSrc & dwBit) != 0))
{
dwDest |= dwBit;
}
else
{
dwDest &= ~dwBit;
}
return TRUE;
}
return FALSE;
}
BOOL CMarkup::IsStringAlphaNumeric(LPCTSTR pszString)
{
while (pszString[0])
{
if (!IsCharAlphaNumeric(pszString[0]))
{
return FALSE;
}
pszString = CharNext(pszString);
}
return TRUE;
}
// We are looking for the next value/data pair. Formated like this:
// VALUE="<data>"
HRESULT CMarkup::_GetNextValueDataPair(LPTSTR * ppszBlock, LPTSTR pszValue, int cchValue, LPTSTR pszData, int cchData)
{
HRESULT hr = E_FAIL;
LPCTSTR pszIterate = *ppszBlock;
LPCTSTR pszEquals = StrStr(pszIterate, TEXT("=\""));
if (pszEquals)
{
cchValue = MIN(cchValue, (pszEquals - *ppszBlock + 1));
StrCpyN(pszValue, *ppszBlock, cchValue);
pszEquals += 2; // Skip past the ="
if (IsStringAlphaNumeric(pszValue))
{
LPTSTR pszEndOfData = StrChr(pszEquals, TEXT('\"'));
if (pszEndOfData)
{
cchData = MIN(cchData, (pszEndOfData - pszEquals + 1));
StrCpyN(pszData, pszEquals, cchData);
*ppszBlock = CharNext(pszEndOfData);
hr = S_OK;
}
}
}
return hr;
}
//-------------------------------------------------------------------------
//
// IsFEChar - Detects East Asia FullWidth character.
// borrowed from UserIsFullWidth in ntuser\rtl\drawtext.c
//
BOOL IsFEChar(WCHAR wChar)
{
static struct
{
WCHAR wchStart;
WCHAR wchEnd;
} rgFullWidthUnicodes[] =
{
{ 0x4E00, 0x9FFF }, // CJK_UNIFIED_IDOGRAPHS
{ 0x3040, 0x309F }, // HIRAGANA
{ 0x30A0, 0x30FF }, // KATAKANA
{ 0xAC00, 0xD7A3 } // HANGUL
};
BOOL fRet = FALSE;
//
// Early out for ASCII. If the character < 0x0080, it should be a halfwidth character.
//
if (wChar >= 0x0080)
{
int i;
//
// Scan FullWdith definition table... most of FullWidth character is
// defined here... this is faster than call NLS API.
//
for (i = 0; i < ARRAYSIZE(rgFullWidthUnicodes); i++)
{
if ((wChar >= rgFullWidthUnicodes[i].wchStart) &&
(wChar <= rgFullWidthUnicodes[i].wchEnd))
{
fRet = TRUE;
break;
}
}
}
return fRet;
}
//-------------------------------------------------------------------------
BOOL IsFEString(IN LPCTSTR psz, IN int cchText)
{
for(int i=0; i < cchText; i++)
{
if (IsFEChar(psz[i]))
{
return TRUE;
}
}
return FALSE;
}
//-------------------------------------------------------------------------
int CMarkup::_IsLineBreakChar(LPCTSTR psz, int ich, TCHAR chBreak, OUT BOOL* pbRemove, BOOL fIgnoreSpace)
{
LPTSTR pch;
*pbRemove = FALSE;
ASSERT(psz != NULL)
ASSERT(psz[ich] != 0);
// Try caller-provided break character (assumed a 'remove' break char).
if (!(fIgnoreSpace && (chBreak == 0x20)) && (psz[ich] == chBreak))
{
*pbRemove = TRUE;
return ich;
}
#define MAX_LINEBREAK_RESOURCE 128
static TCHAR _szBreakRemove [MAX_LINEBREAK_RESOURCE] = {0};
static TCHAR _szBreakPreserve [MAX_LINEBREAK_RESOURCE] = {0};
#define LOAD_BREAKCHAR_RESOURCE(nIDS, buff) \
if (0==*buff) { LoadString(HINST_THISDLL, nIDS, buff, ARRAYSIZE(buff)); }
// Try 'remove' break chars
LOAD_BREAKCHAR_RESOURCE(IDS_LINEBREAK_REMOVE, _szBreakRemove);
for (pch = _szBreakRemove; *pch; pch = CharNext(pch))
{
if (!(fIgnoreSpace && (*pch == 0x20)) && (psz[ich] == *pch))
{
*pbRemove = TRUE;
return ich;
}
}
// Try 'preserve prior' break chars:
LOAD_BREAKCHAR_RESOURCE(IDS_LINEBREAK_PRESERVE, _szBreakPreserve);
for(pch = _szBreakPreserve; *pch; pch = CharNext(pch))
{
if (!(fIgnoreSpace && (*pch == 0x20)) && (psz[ich] == *pch))
{
return ++ich;
}
}
return -1;
}
//-------------------------------------------------------------------------
BOOL CMarkup::_FindLastBreakChar(
IN LPCTSTR pszText,
IN int cchText,
IN TCHAR chBreak, // official break char (from TEXTMETRIC).
OUT int* piLast,
OUT BOOL* pbRemove)
{
*piLast = 0;
*pbRemove = FALSE;
// 338710: Far East writing doesn't use the space character to separate
// words, ignore the space char as a possible line delimiter.
BOOL fIgnoreSpace = IsFEString(pszText, cchText);
for(int i = cchText-1; i >= 0; i--)
{
int ich = _IsLineBreakChar(pszText, i, chBreak, pbRemove, fIgnoreSpace);
if (ich >= 0)
{
*piLast = ich;
return TRUE;
}
}
return FALSE;
}
BOOL CMarkup::_FindFirstLineBreak(
IN LPCTSTR pszText,
IN int cchText,
OUT int* piLast,
OUT int* piLineBreakSize)
{
*piLast = 0;
*piLineBreakSize = 0;
// Searches for \n, \r, or \r\n
for(int i = 0; i < cchText; i++)
{
if ((*(pszText+i)=='\n') || (*(pszText+i)=='\r'))
{
*piLast = i;
if ((*(pszText+i)=='\r') && (*(pszText+i+1)=='\n'))
{
*piLineBreakSize = 2;
}
else
{
*piLineBreakSize = 1;
}
return TRUE;
}
}
return FALSE;
}
void CMarkup::DoNotify(int nCode, int iLink)
{
_pMarkupCallback->Notify(nCode, iLink);
}
int CMarkup::ThemedDrawText(HDC hdc, LPCTSTR lpString, int nCount, LPRECT lpRect, UINT uFormat, BOOL bLink)
{
if (!_hTheme)
{
// NORMAL DRAWTEXT
return ::DrawText(hdc, lpString, nCount, lpRect, uFormat);
}
else
{
int iThemeStateId;
iThemeStateId = bLink ? _iThemeStateIdLink : _iThemeStateIdNormal;
if (uFormat & DT_CALCRECT)
{
// THEME CALC RECT SUPPORT
LPRECT lpBoundRect = lpRect;
if (RECTWIDTH(*lpRect)==0 && RECTHEIGHT(*lpRect)==0)
{
lpBoundRect = NULL;
}
GetThemeTextExtent(_hTheme, hdc, _iThemePartId, iThemeStateId, lpString, nCount, uFormat, lpBoundRect, lpRect);
}
else
{
// THEME DRAW SUPPORT
DrawThemeText(_hTheme, hdc, _iThemePartId, iThemeStateId, lpString, nCount, uFormat, 0, lpRect);
}
return (RECTHEIGHT(*lpRect));
}
}
Reference in a new issue Copy permalink