syslink.c File Reference

#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 "wine/unicode.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for syslink.c:

Go to the source code of this file.

Classes
struct	DOC_TEXTBLOCK
struct	_DOC_ITEM
struct	SYSLINK_INFO

Macros
#define	LIF_FLAGSMASK   (LIF_STATE | LIF_ITEMID | LIF_URL)
#define	LIS_MASK   (LIS_FOCUSED | LIS_ENABLED | LIS_VISITED)
#define	SL_LEFTMARGIN   (0)
#define	SL_TOPMARGIN   (0)
#define	SL_RIGHTMARGIN   (0)
#define	SL_BOTTOMMARGIN   (0)

Typedefs
typedef struct DOC_TEXTBLOCK *	PDOC_TEXTBLOCK
typedef struct _DOC_ITEM	DOC_ITEM
typedef struct _DOC_ITEM *	PDOC_ITEM

Enumerations
enum	SL_ITEM_TYPE { slText = 0 , slLink }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (syslink)
static VOID	SYSLINK_FreeDocItem (PDOC_ITEM DocItem)
static PDOC_ITEM	SYSLINK_AppendDocItem (SYSLINK_INFO *infoPtr, LPCWSTR Text, UINT textlen, SL_ITEM_TYPE type, PDOC_ITEM LastItem)
static VOID	SYSLINK_ClearDoc (SYSLINK_INFO *infoPtr)
static UINT	SYSLINK_ParseText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
static VOID	SYSLINK_RepaintLink (const SYSLINK_INFO *infoPtr, const DOC_ITEM *DocItem)
static PDOC_ITEM	SYSLINK_GetLinkItemByIndex (const SYSLINK_INFO *infoPtr, int iLink)
static PDOC_ITEM	SYSLINK_GetFocusLink (const SYSLINK_INFO *infoPtr, int *LinkId)
static PDOC_ITEM	SYSLINK_GetNextLink (const SYSLINK_INFO *infoPtr, PDOC_ITEM Current)
static PDOC_ITEM	SYSLINK_GetPrevLink (const SYSLINK_INFO *infoPtr, PDOC_ITEM Current)
static BOOL	SYSLINK_WrapLine (LPWSTR Text, WCHAR BreakChar, int x, int *LineLen, int nFit, LPSIZE Extent)
static VOID	SYSLINK_Render (const SYSLINK_INFO *infoPtr, HDC hdc, PRECT pRect)
static LRESULT	SYSLINK_Draw (const SYSLINK_INFO *infoPtr, HDC hdc)
static LRESULT	SYSLINK_Paint (const SYSLINK_INFO *infoPtr, HDC hdcParam)
static HFONT	SYSLINK_SetFont (SYSLINK_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
static LRESULT	SYSLINK_SetText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
static PDOC_ITEM	SYSLINK_SetFocusLink (const SYSLINK_INFO *infoPtr, const DOC_ITEM *DocItem)
static LRESULT	SYSLINK_SetItem (const SYSLINK_INFO *infoPtr, const LITEM *Item)
static LRESULT	SYSLINK_GetItem (const SYSLINK_INFO *infoPtr, PLITEM Item)
static BOOL	SYSLINK_PtInDocItem (const DOC_ITEM *DocItem, POINT pt)
static LRESULT	SYSLINK_HitTest (const SYSLINK_INFO *infoPtr, PLHITTESTINFO HitTest)
static LRESULT	SYSLINK_GetIdealHeight (const SYSLINK_INFO *infoPtr)
static LRESULT	SYSLINK_SendParentNotify (const SYSLINK_INFO *infoPtr, UINT code, const DOC_ITEM *Link, int iLink)
static LRESULT	SYSLINK_SetFocus (SYSLINK_INFO *infoPtr)
static LRESULT	SYSLINK_KillFocus (SYSLINK_INFO *infoPtr)
static PDOC_ITEM	SYSLINK_LinkAtPt (const SYSLINK_INFO *infoPtr, const POINT *pt, int *LinkId, BOOL MustBeEnabled)
static LRESULT	SYSLINK_LButtonDown (SYSLINK_INFO *infoPtr, const POINT *pt)
static LRESULT	SYSLINK_LButtonUp (SYSLINK_INFO *infoPtr, const POINT *pt)
static BOOL	SYSLINK_OnEnter (const SYSLINK_INFO *infoPtr)
static BOOL	SYSKEY_SelectNextPrevLink (const SYSLINK_INFO *infoPtr, BOOL Prev)
static BOOL	SYSLINK_NoNextLink (const SYSLINK_INFO *infoPtr, BOOL Prev)
static LONG	SYSLINK_GetIdealSize (const SYSLINK_INFO *infoPtr, int cxMaxWidth, SIZE *lpSize)
static LRESULT WINAPI	SysLinkWindowProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
VOID	SYSLINK_Register (void)
VOID	SYSLINK_Unregister (void)

Macro Definition Documentation

LIF_FLAGSMASK

#define LIF_FLAGSMASK   (LIF_STATE | LIF_ITEMID | LIF_URL)

Definition at line 43 of file syslink.c.

LIS_MASK

#define LIS_MASK   (LIS_FOCUSED | LIS_ENABLED | LIS_VISITED)

Definition at line 44 of file syslink.c.

SL_BOTTOMMARGIN

#define SL_BOTTOMMARGIN   (0)

Definition at line 96 of file syslink.c.

SL_LEFTMARGIN

#define SL_LEFTMARGIN   (0)

Definition at line 93 of file syslink.c.

SL_RIGHTMARGIN

#define SL_RIGHTMARGIN   (0)

Definition at line 95 of file syslink.c.

SL_TOPMARGIN

#define SL_TOPMARGIN   (0)

Definition at line 94 of file syslink.c.

Typedef Documentation

DOC_ITEM

typedef struct _DOC_ITEM DOC_ITEM

PDOC_ITEM

typedef struct _DOC_ITEM * PDOC_ITEM

PDOC_TEXTBLOCK

typedef struct DOC_TEXTBLOCK * PDOC_TEXTBLOCK

Enumeration Type Documentation

SL_ITEM_TYPE

enum SL_ITEM_TYPE

Enumerator
slText
slLink

Definition at line 46 of file syslink.c.

{
    slText = 0,
    slLink
} SL_ITEM_TYPE;

Function Documentation

SYSKEY_SelectNextPrevLink()

static BOOL SYSKEY_SelectNextPrevLink ( const SYSLINK_INFO *  infoPtr, BOOL  Prev  )

static

Definition at line 1413 of file syslink.c.

{
    if(infoPtr->HasFocus)
    {
        PDOC_ITEM Focus;
        int id;
 
        Focus = SYSLINK_GetFocusLink(infoPtr, &id);
        if(Focus != NULL)
        {
            PDOC_ITEM NewFocus, OldFocus;
 
            if(Prev)
                NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
            else
                NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
 
            if(NewFocus != NULL)
            {
                OldFocus = SYSLINK_SetFocusLink(infoPtr, NewFocus);
 
                if(OldFocus && OldFocus != NewFocus)
                {
                    SYSLINK_RepaintLink(infoPtr, OldFocus);
                }
                SYSLINK_RepaintLink(infoPtr, NewFocus);
                return TRUE;
            }
        }
    }
    return FALSE;
}

Referenced by SysLinkWindowProc().

SYSLINK_AppendDocItem()

static PDOC_ITEM SYSLINK_AppendDocItem ( SYSLINK_INFO *  infoPtr, LPCWSTR  Text, UINT  textlen, SL_ITEM_TYPE  type, PDOC_ITEM  LastItem  )

static

Definition at line 122 of file syslink.c.

{
    PDOC_ITEM Item;
 
    textlen = min(textlen, strlenW(Text));
    Item = Alloc(FIELD_OFFSET(DOC_ITEM, Text[textlen + 1]));
    if(Item == NULL)
    {
        ERR("Failed to alloc DOC_ITEM structure!\n");
        return NULL;
    }
 
    Item->nText = textlen;
    Item->Type = type;
    Item->Blocks = NULL;
    lstrcpynW(Item->Text, Text, textlen + 1);
    if (LastItem)
        list_add_after(&LastItem->entry, &Item->entry);
    else
        list_add_tail(&infoPtr->Items, &Item->entry);
 
    return Item;
}

Referenced by SYSLINK_ParseText().

SYSLINK_ClearDoc()

static VOID SYSLINK_ClearDoc ( SYSLINK_INFO *  infoPtr )

static

Definition at line 151 of file syslink.c.

{
    DOC_ITEM *Item, *Item2;
 
    LIST_FOR_EACH_ENTRY_SAFE(Item, Item2, &infoPtr->Items, DOC_ITEM, entry)
    {
        list_remove(&Item->entry);
        SYSLINK_FreeDocItem(Item);
    }
}

Referenced by SYSLINK_SetText(), and SysLinkWindowProc().

SYSLINK_Draw()

static LRESULT SYSLINK_Draw ( const SYSLINK_INFO *  infoPtr, HDC  hdc  )

static

Definition at line 767 of file syslink.c.

{
    RECT rc;
    PDOC_ITEM Current;
    HFONT hOldFont;
    COLORREF OldTextColor, OldBkColor;
    HBRUSH hBrush;
    UINT text_flags = ETO_CLIPPED;
    UINT mode = GetBkMode( hdc );
 
    hOldFont = SelectObject(hdc, infoPtr->Font);
    OldTextColor = SetTextColor(hdc, infoPtr->TextColor);
    OldBkColor = SetBkColor(hdc, comctl32_color.clrWindow);
 
    GetClientRect(infoPtr->Self, &rc);
    rc.right -= SL_RIGHTMARGIN + SL_LEFTMARGIN;
    rc.bottom -= SL_BOTTOMMARGIN + SL_TOPMARGIN;
 
    if(rc.right < 0 || rc.bottom < 0) return 0;
 
    hBrush = (HBRUSH)SendMessageW(infoPtr->Notify, WM_CTLCOLORSTATIC,
                                  (WPARAM)hdc, (LPARAM)infoPtr->Self);
    if (!(infoPtr->Style & LWS_TRANSPARENT))
    {
        FillRect(hdc, &rc, hBrush);
        if (GetBkMode( hdc ) == OPAQUE) text_flags |= ETO_OPAQUE;
    }
    else SetBkMode( hdc, TRANSPARENT );
 
#ifndef __REACTOS__
    DeleteObject(hBrush);
#endif
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        int n;
        LPWSTR tx;
        PDOC_TEXTBLOCK bl;
        
        bl = Current->Blocks;
        if(bl != NULL)
        {
            tx = Current->Text;
            n = Current->nText;
 
            if(Current->Type == slText)
            {
                 SelectObject(hdc, infoPtr->Font);
                 SetTextColor(hdc, infoPtr->TextColor);
            }
            else
            {
                 SelectObject(hdc, infoPtr->LinkFont);
                 SetTextColor(hdc, (!(Current->u.Link.state & LIS_VISITED) ? infoPtr->LinkColor : infoPtr->VisitedColor));
            }
 
            while(n > 0)
            {
                tx += bl->nSkip;
                ExtTextOutW(hdc, bl->rc.left, bl->rc.top, text_flags, &bl->rc, tx, bl->nChars, NULL);
                if((Current->Type == slLink) && (Current->u.Link.state & LIS_FOCUSED) && infoPtr->HasFocus)
                {
                    COLORREF PrevTextColor;
                    PrevTextColor = SetTextColor(hdc, infoPtr->TextColor);
                    DrawFocusRect(hdc, &bl->rc);
                    SetTextColor(hdc, PrevTextColor);
                }
                tx += bl->nChars;
                n -= bl->nChars + bl->nSkip;
                bl++;
            }
        }
    }
 
    SetBkColor(hdc, OldBkColor);
    SetTextColor(hdc, OldTextColor);
    SelectObject(hdc, hOldFont);
    SetBkMode(hdc, mode);
    return 0;
}

Referenced by SYSLINK_Paint().

SYSLINK_FreeDocItem()

static VOID SYSLINK_FreeDocItem ( PDOC_ITEM  DocItem )

static

Definition at line 102 of file syslink.c.

{
    if(DocItem->Type == slLink)
    {
        Free(DocItem->u.Link.szID);
        Free(DocItem->u.Link.szUrl);
    }
 
    Free(DocItem->Blocks);
 
    /* we don't free Text because it's just a pointer to a character in the
       entire window text string */
 
    Free(DocItem);
}

Referenced by SYSLINK_ClearDoc().

SYSLINK_GetFocusLink()

static PDOC_ITEM SYSLINK_GetFocusLink ( const SYSLINK_INFO *  infoPtr, int *  LinkId  )

static

Definition at line 501 of file syslink.c.

{
    DOC_ITEM *Current;
    int id = 0;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        if(Current->Type == slLink)
        {
            if(Current->u.Link.state & LIS_FOCUSED)
            {
                if(LinkId != NULL)
                    *LinkId = id;
                return Current;
            }
            id++;
        }
    }
 
    return NULL;
}

Referenced by SYSKEY_SelectNextPrevLink(), SYSLINK_KillFocus(), SYSLINK_NoNextLink(), and SYSLINK_OnEnter().

SYSLINK_GetIdealHeight()

static LRESULT SYSLINK_GetIdealHeight ( const SYSLINK_INFO *  infoPtr )

static

Definition at line 1212 of file syslink.c.

{
    HDC hdc = GetDC(infoPtr->Self);
    if(hdc != NULL)
    {
        LRESULT height;
        TEXTMETRICW tm;
        HGDIOBJ hOldFont = SelectObject(hdc, infoPtr->Font);
        
        if(GetTextMetricsW(hdc, &tm))
        {
            height = tm.tmHeight;
        }
        else
        {
            height = 0;
        }
        SelectObject(hdc, hOldFont);
        ReleaseDC(infoPtr->Self, hdc);
        
        return height;
    }
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_GetIdealSize()

static LONG SYSLINK_GetIdealSize ( const SYSLINK_INFO *  infoPtr, int  cxMaxWidth, SIZE *  lpSize  )

static

Definition at line 1468 of file syslink.c.

{
    RECT rc;
    HDC hdc;
 
    rc.left = rc.top = rc.bottom = 0;
    rc.right = cxMaxWidth;
 
    hdc = GetDC(infoPtr->Self);
    if (hdc != NULL)
    {
        HGDIOBJ hOldFont = SelectObject(hdc, infoPtr->Font);
 
        SYSLINK_Render(infoPtr, hdc, &rc);
 
        SelectObject(hdc, hOldFont);
        ReleaseDC(infoPtr->Self, hdc);
 
        lpSize->cx = rc.right;
        lpSize->cy = rc.bottom;
    }
 
    return rc.bottom;
}

Referenced by SysLinkWindowProc().

SYSLINK_GetItem()

static LRESULT SYSLINK_GetItem ( const SYSLINK_INFO *  infoPtr, PLITEM  Item  )

static

Definition at line 1082 of file syslink.c.

{
    PDOC_ITEM di;
    
    if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
    {
        ERR("Invalid Flags!\n");
        return FALSE;
    }
    
    di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
    if(di == NULL)
    {
        ERR("Link %d couldn't be found\n", Item->iLink);
        return FALSE;
    }
    
    if(Item->mask & LIF_STATE)
    {
        Item->state = (di->u.Link.state & Item->stateMask);
        if(!infoPtr->HasFocus)
        {
            /* remove the LIS_FOCUSED bit if the control doesn't have focus */
            Item->state &= ~LIS_FOCUSED;
        }
    }
    
    if(Item->mask & LIF_ITEMID)
    {
        if(di->u.Link.szID)
        {
            lstrcpyW(Item->szID, di->u.Link.szID);
        }
        else
        {
            Item->szID[0] = 0;
        }
    }
    
    if(Item->mask & LIF_URL)
    {
        if(di->u.Link.szUrl)
        {
            lstrcpyW(Item->szUrl, di->u.Link.szUrl);
        }
        else
        {
            Item->szUrl[0] = 0;
        }
    }
    
    return TRUE;
}

Referenced by SysLinkWindowProc().

SYSLINK_GetLinkItemByIndex()

static PDOC_ITEM SYSLINK_GetLinkItemByIndex ( const SYSLINK_INFO *  infoPtr, int  iLink  )

static

Definition at line 485 of file syslink.c.

{
    DOC_ITEM *Current;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        if ((Current->Type == slLink) && (iLink-- <= 0))
            return Current;
    }
    return NULL;
}

Referenced by SYSLINK_GetItem(), and SYSLINK_SetItem().

SYSLINK_GetNextLink()

static PDOC_ITEM SYSLINK_GetNextLink ( const SYSLINK_INFO *  infoPtr, PDOC_ITEM  Current  )

static

Definition at line 527 of file syslink.c.

{
    DOC_ITEM *Next;
 
    LIST_FOR_EACH_ENTRY(Next, Current ? &Current->entry : &infoPtr->Items, DOC_ITEM, entry)
    {
        if (Next->Type == slLink)
        {
            return Next;
        }
    }
    return NULL;
}

Referenced by SYSKEY_SelectNextPrevLink(), SYSLINK_NoNextLink(), and SYSLINK_SetFocus().

SYSLINK_GetPrevLink()

static PDOC_ITEM SYSLINK_GetPrevLink ( const SYSLINK_INFO *  infoPtr, PDOC_ITEM  Current  )

static

Definition at line 545 of file syslink.c.

{
    DOC_ITEM *Prev;
 
    LIST_FOR_EACH_ENTRY_REV(Prev, Current ? &Current->entry : list_tail(&infoPtr->Items), DOC_ITEM, entry)
    {
        if (Prev->Type == slLink)
        {
            return Prev;
        }
    }
 
    return NULL;
}

Referenced by SYSKEY_SelectNextPrevLink(), and SYSLINK_NoNextLink().

SYSLINK_HitTest()

static LRESULT SYSLINK_HitTest ( const SYSLINK_INFO *  infoPtr, PLHITTESTINFO  HitTest  )

static

Definition at line 1168 of file syslink.c.

{
    PDOC_ITEM Current;
    int id = 0;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        if(Current->Type == slLink)
        {
            if(SYSLINK_PtInDocItem(Current, HitTest->pt))
            {
                HitTest->item.mask = 0;
                HitTest->item.iLink = id;
                HitTest->item.state = 0;
                HitTest->item.stateMask = 0;
                if(Current->u.Link.szID)
                {
                    lstrcpyW(HitTest->item.szID, Current->u.Link.szID);
                }
                else
                {
                    HitTest->item.szID[0] = 0;
                }
                if(Current->u.Link.szUrl)
                {
                    lstrcpyW(HitTest->item.szUrl, Current->u.Link.szUrl);
                }
                else
                {
                    HitTest->item.szUrl[0] = 0;
                }
                return TRUE;
            }
            id++;
        }
    }
    
    return FALSE;
}

Referenced by SysLinkWindowProc().

SYSLINK_KillFocus()

static LRESULT SYSLINK_KillFocus ( SYSLINK_INFO *  infoPtr )

static

Definition at line 1298 of file syslink.c.

{
    PDOC_ITEM Focus;
    
    infoPtr->HasFocus = FALSE;
    Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
    
    if(Focus != NULL)
    {
        SYSLINK_RepaintLink(infoPtr, Focus);
    }
 
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_LButtonDown()

static LRESULT SYSLINK_LButtonDown ( SYSLINK_INFO *  infoPtr, const POINT *  pt  )

static

Definition at line 1343 of file syslink.c.

{
    PDOC_ITEM Current, Old;
    int id;
 
    Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
    if(Current != NULL)
    {
      SetFocus(infoPtr->Self);
 
      Old = SYSLINK_SetFocusLink(infoPtr, Current);
      if(Old != NULL && Old != Current)
      {
          SYSLINK_RepaintLink(infoPtr, Old);
      }
      infoPtr->MouseDownID = id;
      SYSLINK_RepaintLink(infoPtr, Current);
    }
 
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_LButtonUp()

static LRESULT SYSLINK_LButtonUp ( SYSLINK_INFO *  infoPtr, const POINT *  pt  )

static

Definition at line 1369 of file syslink.c.

{
    if(infoPtr->MouseDownID > -1)
    {
        PDOC_ITEM Current;
        int id;
        
        Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
        if((Current != NULL) && (Current->u.Link.state & LIS_FOCUSED) && (infoPtr->MouseDownID == id))
        {
            SYSLINK_SendParentNotify(infoPtr, NM_CLICK, Current, id);
        }
    }
 
    infoPtr->MouseDownID = -1;
 
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_LinkAtPt()

static PDOC_ITEM SYSLINK_LinkAtPt ( const SYSLINK_INFO *  infoPtr, const POINT *  pt, int *  LinkId, BOOL  MustBeEnabled  )

static

Definition at line 1317 of file syslink.c.

{
    PDOC_ITEM Current;
    int id = 0;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        if((Current->Type == slLink) && SYSLINK_PtInDocItem(Current, *pt) &&
           (!MustBeEnabled || (Current->u.Link.state & LIS_ENABLED)))
        {
            if(LinkId != NULL)
            {
                *LinkId = id;
            }
            return Current;
        }
        id++;
    }
 
    return NULL;
}

Referenced by SYSLINK_LButtonDown(), SYSLINK_LButtonUp(), and SysLinkWindowProc().

SYSLINK_NoNextLink()

static BOOL SYSLINK_NoNextLink ( const SYSLINK_INFO *  infoPtr, BOOL  Prev  )

static

Definition at line 1451 of file syslink.c.

{
    PDOC_ITEM Focus, NewFocus;
 
    Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
    if(Prev)
        NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
    else
        NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
 
    return NewFocus == NULL;
}

Referenced by SysLinkWindowProc().

SYSLINK_OnEnter()

static BOOL SYSLINK_OnEnter ( const SYSLINK_INFO *  infoPtr )

static

Definition at line 1392 of file syslink.c.

{
    if(infoPtr->HasFocus && !infoPtr->IgnoreReturn)
    {
        PDOC_ITEM Focus;
        int id;
        
        Focus = SYSLINK_GetFocusLink(infoPtr, &id);
        if(Focus)
        {
            SYSLINK_SendParentNotify(infoPtr, NM_RETURN, Focus, id);
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by SysLinkWindowProc().

SYSLINK_Paint()

static LRESULT SYSLINK_Paint ( const SYSLINK_INFO *  infoPtr, HDC  hdcParam  )

static

Definition at line 853 of file syslink.c.

{
    HDC hdc;
    PAINTSTRUCT ps;
 
    hdc = hdcParam ? hdcParam : BeginPaint (infoPtr->Self, &ps);
    if (hdc)
    {
        SYSLINK_Draw (infoPtr, hdc);
        if (!hdcParam) EndPaint (infoPtr->Self, &ps);
    }
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_ParseText()

static UINT SYSLINK_ParseText ( SYSLINK_INFO *  infoPtr, LPCWSTR  Text  )

static

Definition at line 167 of file syslink.c.

{
    static const WCHAR SL_LINKOPEN[] =  { '<','a' };
    static const WCHAR SL_HREF[] =      { 'h','r','e','f','=','\"' };
    static const WCHAR SL_ID[] =        { 'i','d','=','\"' };
    static const WCHAR SL_LINKCLOSE[] = { '<','/','a','>' };
    LPCWSTR current, textstart = NULL, linktext = NULL, firsttag = NULL;
    int taglen = 0, textlen = 0, linklen = 0, docitems = 0;
    PDOC_ITEM Last = NULL;
    SL_ITEM_TYPE CurrentType = slText;
    LPCWSTR lpID, lpUrl;
    UINT lenId, lenUrl;
 
    TRACE("(%p %s)\n", infoPtr, debugstr_w(Text));
 
    for(current = Text; *current != 0;)
    {
        if(*current == '<')
        {
            if(!strncmpiW(current, SL_LINKOPEN, ARRAY_SIZE(SL_LINKOPEN)) && (CurrentType == slText))
            {
                BOOL ValidParam = FALSE, ValidLink = FALSE;
 
                if(*(current + 2) == '>')
                {
                    /* we just have to deal with a <a> tag */
                    taglen = 3;
                    ValidLink = TRUE;
                    ValidParam = TRUE;
                    firsttag = current;
                    linklen = 0;
                    lpID = NULL;
                    lpUrl = NULL;
                }
                else if(*(current + 2) == infoPtr->BreakChar)
                {
                    /* we expect parameters, parse them */
                    LPCWSTR *CurrentParameter = NULL, tmp;
                    UINT *CurrentParameterLen = NULL;
 
                    taglen = 3;
                    tmp = current + taglen;
                    lpID = NULL;
                    lpUrl = NULL;
                    
CheckParameter:
                    /* compare the current position with all known parameters */
                    if(!strncmpiW(tmp, SL_HREF, ARRAY_SIZE(SL_HREF)))
                    {
                        taglen += 6;
                        ValidParam = TRUE;
                        CurrentParameter = &lpUrl;
                        CurrentParameterLen = &lenUrl;
                    }
                    else if(!strncmpiW(tmp, SL_ID, ARRAY_SIZE(SL_ID)))
                    {
                        taglen += 4;
                        ValidParam = TRUE;
                        CurrentParameter = &lpID;
                        CurrentParameterLen = &lenId;
                    }
                    else
                    {
                        ValidParam = FALSE;
                    }
                    
                    if(ValidParam)
                    {
                        /* we got a known parameter, now search until the next " character.
                           If we can't find a " character, there's a syntax error and we just assume it's text */
                        ValidParam = FALSE;
                        *CurrentParameter = current + taglen;
                        *CurrentParameterLen = 0;
 
                        for(tmp = *CurrentParameter; *tmp != 0; tmp++)
                        {
                            taglen++;
                            if(*tmp == '\"')
                            {
                                ValidParam = TRUE;
                                tmp++;
                                break;
                            }
                            (*CurrentParameterLen)++;
                        }
                    }
                    if(ValidParam)
                    {
                        /* we're done with this parameter, now there are only 2 possibilities:
                         * 1. another parameter is coming, so expect a ' ' (space) character
                         * 2. the tag is being closed, so expect a '<' character
                         */
                        if(*tmp == infoPtr->BreakChar)
                        {
                            /* we expect another parameter, do the whole thing again */
                            taglen++;
                            tmp++;
                            goto CheckParameter;
                        }
                        else if(*tmp == '>')
                        {
                            /* the tag is being closed, we're done */
                            ValidLink = TRUE;
                            taglen++;
                        }
                    }
                }
                
                if(ValidLink && ValidParam)
                {
                    /* the <a ...> tag appears to be valid. save all information
                       so we can add the link if we find a valid </a> tag later */
                    CurrentType = slLink;
                    linktext = current + taglen;
                    linklen = 0;
                    firsttag = current;
                }
                else
                {
                    taglen = 1;
                    lpID = NULL;
                    lpUrl = NULL;
                    if(textstart == NULL)
                    {
                        textstart = current;
                    }
                }
            }
            else if(!strncmpiW(current, SL_LINKCLOSE, ARRAY_SIZE(SL_LINKCLOSE)) && (CurrentType == slLink) && firsttag)
            {
                /* there's a <a...> tag opened, first add the previous text, if present */
                if(textstart != NULL && textlen > 0 && firsttag > textstart)
                {
                    Last = SYSLINK_AppendDocItem(infoPtr, textstart, firsttag - textstart, slText, Last);
                    if(Last == NULL)
                    {
                        ERR("Unable to create new document item!\n");
                        return docitems;
                    }
                    docitems++;
                    textstart = NULL;
                    textlen = 0;
                }
                
                /* now it's time to add the link to the document */
                current += 4;
                if(linktext != NULL && linklen > 0)
                {
                    Last = SYSLINK_AppendDocItem(infoPtr, linktext, linklen, slLink, Last);
                    if(Last == NULL)
                    {
                        ERR("Unable to create new document item!\n");
                        return docitems;
                    }
                    docitems++;
                    if(CurrentType == slLink)
                    {
                        int nc;
 
                        if(!(infoPtr->Style & WS_DISABLED))
                        {
                            Last->u.Link.state |= LIS_ENABLED;
                        }
                        /* Copy the tag parameters */
                        if(lpID != NULL)
                        {
                            nc = min(lenId, strlenW(lpID));
                            nc = min(nc, MAX_LINKID_TEXT - 1);
                            Last->u.Link.szID = Alloc((nc + 1) * sizeof(WCHAR));
                            if(Last->u.Link.szID != NULL)
                            {
                                lstrcpynW(Last->u.Link.szID, lpID, nc + 1);
                            }
                        }
                        else
                            Last->u.Link.szID = NULL;
                        if(lpUrl != NULL)
                        {
                            nc = min(lenUrl, strlenW(lpUrl));
                            nc = min(nc, L_MAX_URL_LENGTH - 1);
                            Last->u.Link.szUrl = Alloc((nc + 1) * sizeof(WCHAR));
                            if(Last->u.Link.szUrl != NULL)
                            {
                                lstrcpynW(Last->u.Link.szUrl, lpUrl, nc + 1);
                            }
                        }
                        else
                            Last->u.Link.szUrl = NULL;
                    }
                    linktext = NULL;
                }
                CurrentType = slText;
                firsttag = NULL;
                textstart = NULL;
                continue;
            }
            else
            {
                /* we don't know what tag it is, so just continue */
                taglen = 1;
                linklen++;
                if(CurrentType == slText && textstart == NULL)
                {
                    textstart = current;
                }
            }
            
            textlen += taglen;
            current += taglen;
        }
        else
        {
            textlen++;
            linklen++;
 
            /* save the pointer of the current text item if we couldn't find a tag */
            if(textstart == NULL && CurrentType == slText)
            {
                textstart = current;
            }
            
            current++;
        }
    }
    
    if(textstart != NULL && textlen > 0)
    {
        Last = SYSLINK_AppendDocItem(infoPtr, textstart, textlen, CurrentType, Last);
        if(Last == NULL)
        {
            ERR("Unable to create new document item!\n");
            return docitems;
        }
        if(CurrentType == slLink)
        {
            int nc;
 
            if(!(infoPtr->Style & WS_DISABLED))
            {
                Last->u.Link.state |= LIS_ENABLED;
            }
            /* Copy the tag parameters */
            if(lpID != NULL)
            {
                nc = min(lenId, strlenW(lpID));
                nc = min(nc, MAX_LINKID_TEXT - 1);
                Last->u.Link.szID = Alloc((nc + 1) * sizeof(WCHAR));
                if(Last->u.Link.szID != NULL)
                {
                    lstrcpynW(Last->u.Link.szID, lpID, nc + 1);
                }
            }
            else
                Last->u.Link.szID = NULL;
            if(lpUrl != NULL)
            {
                nc = min(lenUrl, strlenW(lpUrl));
                nc = min(nc, L_MAX_URL_LENGTH - 1);
                Last->u.Link.szUrl = Alloc((nc + 1) * sizeof(WCHAR));
                if(Last->u.Link.szUrl != NULL)
                {
                    lstrcpynW(Last->u.Link.szUrl, lpUrl, nc + 1);
                }
            }
            else
                Last->u.Link.szUrl = NULL;
        }
        docitems++;
    }
 
    if(linktext != NULL && linklen > 0)
    {
        /* we got an unclosed link, just display the text */
        Last = SYSLINK_AppendDocItem(infoPtr, linktext, linklen, slText, Last);
        if(Last == NULL)
        {
            ERR("Unable to create new document item!\n");
            return docitems;
        }
        docitems++;
    }
 
    return docitems;
}

Referenced by SYSLINK_SetText().

SYSLINK_PtInDocItem()

static BOOL SYSLINK_PtInDocItem ( const DOC_ITEM *  DocItem, POINT  pt  )

static

Definition at line 1140 of file syslink.c.

{
    PDOC_TEXTBLOCK bl;
    int n;
 
    bl = DocItem->Blocks;
    if (bl != NULL)
    {
        n = DocItem->nText;
 
        while(n > 0)
        {
            if (PtInRect(&bl->rc, pt))
            {
                return TRUE;
            }
            n -= bl->nChars + bl->nSkip;
            bl++;
        }
    }
    
    return FALSE;
}

Referenced by SYSLINK_HitTest(), and SYSLINK_LinkAtPt().

SYSLINK_Register()

VOID SYSLINK_Register

(

void

)

Definition at line 1742 of file syslink.c.

{
    WNDCLASSW wndClass;
 
    ZeroMemory (&wndClass, sizeof(wndClass));
    wndClass.style         = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
    wndClass.lpfnWndProc   = SysLinkWindowProc;
    wndClass.cbClsExtra    = 0;
    wndClass.cbWndExtra    = sizeof (SYSLINK_INFO *);
    wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
    wndClass.lpszClassName = WC_LINK;
 
    RegisterClassW (&wndClass);
}

Referenced by DllMain().

SYSLINK_Render()

static VOID SYSLINK_Render ( const SYSLINK_INFO *  infoPtr, HDC  hdc, PRECT  pRect  )

static

Definition at line 594 of file syslink.c.

{
    RECT rc;
    PDOC_ITEM Current;
    HGDIOBJ hOldFont;
    int x, y, LineHeight;
    SIZE szDoc;
    TEXTMETRICW tm;
 
    szDoc.cx = szDoc.cy = 0;
 
    rc = *pRect;
    rc.right -= SL_RIGHTMARGIN;
    rc.bottom -= SL_BOTTOMMARGIN;
 
    if(rc.right - SL_LEFTMARGIN < 0)
        rc.right = MAXLONG;
    if (rc.bottom - SL_TOPMARGIN < 0)
        rc.bottom = MAXLONG;
    
    hOldFont = SelectObject(hdc, infoPtr->Font);
    
    x = SL_LEFTMARGIN;
    y = SL_TOPMARGIN;
    GetTextMetricsW( hdc, &tm );
    LineHeight = tm.tmHeight + tm.tmExternalLeading;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        int n, nBlocks;
        LPWSTR tx;
        PDOC_TEXTBLOCK bl, cbl;
        INT nFit;
        SIZE szDim;
        int SkipChars = 0;
 
        if(Current->nText == 0)
        {
            continue;
        }
 
        tx = Current->Text;
        n = Current->nText;
 
        Free(Current->Blocks);
        Current->Blocks = NULL;
        bl = NULL;
        nBlocks = 0;
 
        if(Current->Type == slText)
        {
            SelectObject(hdc, infoPtr->Font);
        }
        else if(Current->Type == slLink)
        {
            SelectObject(hdc, infoPtr->LinkFont);
        }
        
        while(n > 0)
        {
            /* skip break characters unless they're the first of the doc item */
            if(tx != Current->Text || x == SL_LEFTMARGIN)
            {
                if (n && *tx == '\n')
                {
                    tx++;
                    SkipChars++;
                    n--;
                }
                while(n > 0 && (*tx) == infoPtr->BreakChar)
                {
                    tx++;
                    SkipChars++;
                    n--;
                }
            }
 
            if((n == 0 && SkipChars != 0) ||
               GetTextExtentExPointW(hdc, tx, n, rc.right - x, &nFit, NULL, &szDim))
            {
                int LineLen = n;
                BOOL Wrap = FALSE;
                PDOC_TEXTBLOCK nbl;
                
                if(n != 0)
                {
                    Wrap = SYSLINK_WrapLine(tx, infoPtr->BreakChar, x, &LineLen, nFit, &szDim);
 
                    if(LineLen == 0)
                    {
                        /* move one line down, the word didn't fit into the line */
                        x = SL_LEFTMARGIN;
                        y += LineHeight;
                        continue;
                    }
 
                    if(LineLen != n)
                    {
                        if(!GetTextExtentExPointW(hdc, tx, LineLen, rc.right - x, NULL, NULL, &szDim))
                        {
                            if(bl != NULL)
                            {
                                Free(bl);
                                bl = NULL;
                                nBlocks = 0;
                            }
                            break;
                        }
                    }
                }
                
                nbl = ReAlloc(bl, (nBlocks + 1) * sizeof(DOC_TEXTBLOCK));
                if (nbl != NULL)
                {
                    bl = nbl;
                    nBlocks++;
 
                    cbl = bl + nBlocks - 1;
                    
                    cbl->nChars = LineLen;
                    cbl->nSkip = SkipChars;
                    SetRect(&cbl->rc, x, y, x + szDim.cx, y + szDim.cy);
 
                    if (cbl->rc.right > szDoc.cx)
                        szDoc.cx = cbl->rc.right;
                    if (cbl->rc.bottom > szDoc.cy)
                        szDoc.cy = cbl->rc.bottom;
 
                    if(LineLen != 0)
                    {
                        x += szDim.cx;
                        if(Wrap)
                        {
                            x = SL_LEFTMARGIN;
                            y += LineHeight;
                        }
                    }
                }
                else
                {
                    Free(bl);
                    bl = NULL;
                    nBlocks = 0;
 
                    ERR("Failed to alloc DOC_TEXTBLOCK structure!\n");
                    break;
                }
                n -= LineLen;
                tx += LineLen;
                SkipChars = 0;
            }
            else
            {
                n--;
            }
        }
 
        if(nBlocks != 0)
        {
            Current->Blocks = bl;
        }
    }
    
    SelectObject(hdc, hOldFont);
 
    pRect->right = pRect->left + szDoc.cx;
    pRect->bottom = pRect->top + szDoc.cy;
}

Referenced by SYSLINK_GetIdealSize(), SYSLINK_SetFont(), SYSLINK_SetText(), and SysLinkWindowProc().

SYSLINK_RepaintLink()

static VOID SYSLINK_RepaintLink ( const SYSLINK_INFO *  infoPtr, const DOC_ITEM *  DocItem  )

static

Definition at line 456 of file syslink.c.

{
    PDOC_TEXTBLOCK bl;
    int n;
 
    if(DocItem->Type != slLink)
    {
        ERR("DocItem not a link!\n");
        return;
    }
    
    bl = DocItem->Blocks;
    if (bl != NULL)
    {
        n = DocItem->nText;
        
        while(n > 0)
        {
            InvalidateRect(infoPtr->Self, &bl->rc, TRUE);
            n -= bl->nChars + bl->nSkip;
            bl++;
        }
    }
}

Referenced by SYSKEY_SelectNextPrevLink(), SYSLINK_KillFocus(), SYSLINK_LButtonDown(), SYSLINK_SetFocus(), and SYSLINK_SetItem().

SYSLINK_SendParentNotify()

static LRESULT SYSLINK_SendParentNotify ( const SYSLINK_INFO *  infoPtr, UINT  code, const DOC_ITEM *  Link, int  iLink  )

static

Definition at line 1241 of file syslink.c.

{
    NMLINK nml;
 
    nml.hdr.hwndFrom = infoPtr->Self;
    nml.hdr.idFrom = GetWindowLongPtrW(infoPtr->Self, GWLP_ID);
    nml.hdr.code = code;
 
    nml.item.mask = 0;
    nml.item.iLink = iLink;
    nml.item.state = 0;
    nml.item.stateMask = 0;
    if(Link->u.Link.szID)
    {
        lstrcpyW(nml.item.szID, Link->u.Link.szID);
    }
    else
    {
        nml.item.szID[0] = 0;
    }
    if(Link->u.Link.szUrl)
    {
        lstrcpyW(nml.item.szUrl, Link->u.Link.szUrl);
    }
    else
    {
        nml.item.szUrl[0] = 0;
    }
 
    return SendMessageW(infoPtr->Notify, WM_NOTIFY, nml.hdr.idFrom, (LPARAM)&nml);
}

Referenced by SYSLINK_LButtonUp(), and SYSLINK_OnEnter().

SYSLINK_SetFocus()

static LRESULT SYSLINK_SetFocus ( SYSLINK_INFO *  infoPtr )

static

Definition at line 1277 of file syslink.c.

{
    PDOC_ITEM Focus;
    
    infoPtr->HasFocus = TRUE;
 
    /* We always select the first link, even if we activated the control using
       SHIFT+TAB. This is the default behavior */
    Focus = SYSLINK_GetNextLink(infoPtr, NULL);
    if(Focus != NULL)
    {
        SYSLINK_SetFocusLink(infoPtr, Focus);
        SYSLINK_RepaintLink(infoPtr, Focus);
    }
    return 0;
}

Referenced by SysLinkWindowProc().

SYSLINK_SetFocusLink()

static PDOC_ITEM SYSLINK_SetFocusLink ( const SYSLINK_INFO *  infoPtr, const DOC_ITEM *  DocItem  )

static

Definition at line 961 of file syslink.c.

{
    PDOC_ITEM Current, PrevFocus = NULL;
 
    LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry)
    {
        if(Current->Type == slLink)
        {
            if((PrevFocus == NULL) && (Current->u.Link.state & LIS_FOCUSED))
            {
                PrevFocus = Current;
            }
            
            if(Current == DocItem)
            {
                Current->u.Link.state |= LIS_FOCUSED;
            }
            else
            {
                Current->u.Link.state &= ~LIS_FOCUSED;
            }
        }
    }
    
    return PrevFocus;
}

Referenced by SYSKEY_SelectNextPrevLink(), SYSLINK_LButtonDown(), SYSLINK_SetFocus(), and SYSLINK_SetItem().

SYSLINK_SetFont()

static HFONT SYSLINK_SetFont ( SYSLINK_INFO *  infoPtr, HFONT  hFont, BOOL  bRedraw  )

static

Definition at line 871 of file syslink.c.

{
    HDC hdc;
    LOGFONTW lf;
    TEXTMETRICW tm;
    RECT rcClient;
    HFONT hOldFont = infoPtr->Font;
    infoPtr->Font = hFont;
    
    /* free the underline font */
    if(infoPtr->LinkFont != NULL)
    {
        DeleteObject(infoPtr->LinkFont);
        infoPtr->LinkFont = NULL;
    }
 
    /* Render text position and word wrapping in memory */
    if (GetClientRect(infoPtr->Self, &rcClient))
    {
        hdc = GetDC(infoPtr->Self);
        if(hdc != NULL)
        {
            /* create a new underline font */
            if(GetTextMetricsW(hdc, &tm) &&
               GetObjectW(infoPtr->Font, sizeof(LOGFONTW), &lf))
            {
                lf.lfUnderline = TRUE;
                infoPtr->LinkFont = CreateFontIndirectW(&lf);
                infoPtr->BreakChar = tm.tmBreakChar;
            }
            else
            {
                ERR("Failed to create link font!\n");
            }
 
            SYSLINK_Render(infoPtr, hdc, &rcClient);
            ReleaseDC(infoPtr->Self, hdc);
        }
    }
    
    if(bRedraw)
    {
        RedrawWindow(infoPtr->Self, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
    }
    
    return hOldFont;
}

Referenced by SysLinkWindowProc().

SYSLINK_SetItem()

static LRESULT SYSLINK_SetItem ( const SYSLINK_INFO *  infoPtr, const LITEM *  Item  )

static

Definition at line 992 of file syslink.c.

{
    PDOC_ITEM di;
    int nc;
    PWSTR szId = NULL;
    PWSTR szUrl = NULL;
    BOOL Repaint = FALSE;
 
    if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
    {
        ERR("Invalid Flags!\n");
        return FALSE;
    }
 
    di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
    if(di == NULL)
    {
        ERR("Link %d couldn't be found\n", Item->iLink);
        return FALSE;
    }
 
    if(Item->mask & LIF_ITEMID)
    {
        nc = min(lstrlenW(Item->szID), MAX_LINKID_TEXT - 1);
        szId = Alloc((nc + 1) * sizeof(WCHAR));
        if(szId)
        {
            lstrcpynW(szId, Item->szID, nc + 1);
        }
        else
        {
            ERR("Unable to allocate memory for link id\n");
            return FALSE;
        }
    }
 
    if(Item->mask & LIF_URL)
    {
        nc = min(lstrlenW(Item->szUrl), L_MAX_URL_LENGTH - 1);
        szUrl = Alloc((nc + 1) * sizeof(WCHAR));
        if(szUrl)
        {
            lstrcpynW(szUrl, Item->szUrl, nc + 1);
        }
        else
        {
            Free(szId);
 
            ERR("Unable to allocate memory for link url\n");
            return FALSE;
        }
    }
 
    if(Item->mask & LIF_ITEMID)
    {
        Free(di->u.Link.szID);
        di->u.Link.szID = szId;
    }
 
    if(Item->mask & LIF_URL)
    {
        Free(di->u.Link.szUrl);
        di->u.Link.szUrl = szUrl;
    }
 
    if(Item->mask & LIF_STATE)
    {
        UINT oldstate = di->u.Link.state;
        /* clear the masked bits */
        di->u.Link.state &= ~(Item->stateMask & LIS_MASK);
        /* copy the bits */
        di->u.Link.state |= (Item->state & Item->stateMask) & LIS_MASK;
        Repaint = (oldstate != di->u.Link.state);
        
        /* update the focus */
        SYSLINK_SetFocusLink(infoPtr, ((di->u.Link.state & LIS_FOCUSED) ? di : NULL));
    }
    
    if(Repaint)
    {
        SYSLINK_RepaintLink(infoPtr, di);
    }
    
    return TRUE;
}

Referenced by SysLinkWindowProc().

SYSLINK_SetText()

static LRESULT SYSLINK_SetText ( SYSLINK_INFO *  infoPtr, LPCWSTR  Text  )

static

Definition at line 923 of file syslink.c.

{
    /* clear the document */
    SYSLINK_ClearDoc(infoPtr);
 
    if(Text == NULL || *Text == 0)
    {
        return TRUE;
    }
 
    /* let's parse the string and create a document */
    if(SYSLINK_ParseText(infoPtr, Text) > 0)
    {
        RECT rcClient;
 
        /* Render text position and word wrapping in memory */
        if (GetClientRect(infoPtr->Self, &rcClient))
        {
            HDC hdc = GetDC(infoPtr->Self);
            if (hdc != NULL)
            {
                SYSLINK_Render(infoPtr, hdc, &rcClient);
                ReleaseDC(infoPtr->Self, hdc);
 
                InvalidateRect(infoPtr->Self, NULL, TRUE);
            }
        }
    }
    
    return TRUE;
}

Referenced by SysLinkWindowProc().

SYSLINK_Unregister()

VOID SYSLINK_Unregister

(

void

)

Definition at line 1763 of file syslink.c.

{
    UnregisterClassW (WC_LINK, NULL);
}

Referenced by DllMain().

SYSLINK_WrapLine()

static BOOL SYSLINK_WrapLine ( LPWSTR  Text, WCHAR  BreakChar, int  x, int *  LineLen, int  nFit, LPSIZE  Extent  )

static

Definition at line 564 of file syslink.c.

{
    int i;
 
    for (i = 0; i < nFit; i++) if (Text[i] == '\n') break;
 
    if (i == *LineLen) return FALSE;
 
    /* check if we're in the middle of a word */
    if (Text[i] != '\n' && Text[i] != BreakChar)
    {
        /* search for the beginning of the word */
        while (i && Text[i - 1] != BreakChar) i--;
 
        if (i == 0)
        {
            Extent->cx = 0;
            Extent->cy = 0;
            if (x == SL_LEFTMARGIN) i = max( nFit, 1 );
        }
    }
    *LineLen = i;
    return TRUE;
}

Referenced by SYSLINK_Render().

SysLinkWindowProc()

static LRESULT WINAPI SysLinkWindowProc ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1496 of file syslink.c.

{
    SYSLINK_INFO *infoPtr;
 
    TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
 
    infoPtr = (SYSLINK_INFO *)GetWindowLongPtrW(hwnd, 0);
 
    if (!infoPtr && message != WM_CREATE)
        return DefWindowProcW(hwnd, message, wParam, lParam);
 
    switch(message) {
    case WM_PRINTCLIENT:
    case WM_PAINT:
        return SYSLINK_Paint (infoPtr, (HDC)wParam);
 
    case WM_ERASEBKGND:
        if (!(infoPtr->Style & LWS_TRANSPARENT))
        {
            HDC hdc = (HDC)wParam;
            HBRUSH brush = CreateSolidBrush( comctl32_color.clrWindow );
            RECT rect;
 
            GetClipBox( hdc, &rect );
            FillRect( hdc, &rect, brush );
            DeleteObject( brush );
            return 1;
        }
        return 0;
 
    case WM_SETCURSOR:
    {
        LHITTESTINFO ht;
        DWORD mp = GetMessagePos();
        
        ht.pt.x = (short)LOWORD(mp);
        ht.pt.y = (short)HIWORD(mp);
        
        ScreenToClient(infoPtr->Self, &ht.pt);
        if(SYSLINK_HitTest (infoPtr, &ht))
        {
            SetCursor(LoadCursorW(0, (LPCWSTR)IDC_HAND));
            return TRUE;
        }
 
        return DefWindowProcW(hwnd, message, wParam, lParam);
    }
 
    case WM_SIZE:
    {
        RECT rcClient;
        if (GetClientRect(infoPtr->Self, &rcClient))
        {
            HDC hdc = GetDC(infoPtr->Self);
            if(hdc != NULL)
            {
                SYSLINK_Render(infoPtr, hdc, &rcClient);
                ReleaseDC(infoPtr->Self, hdc);
            }
        }
        return 0;
    }
 
    case WM_GETFONT:
        return (LRESULT)infoPtr->Font;
 
    case WM_SETFONT:
        return (LRESULT)SYSLINK_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
 
    case WM_SETTEXT:
        SYSLINK_SetText(infoPtr, (LPWSTR)lParam);
        return DefWindowProcW(hwnd, message, wParam, lParam);
 
    case WM_LBUTTONDOWN:
    {
        POINT pt;
        pt.x = (short)LOWORD(lParam);
        pt.y = (short)HIWORD(lParam);
        return SYSLINK_LButtonDown(infoPtr, &pt);
    }
    case WM_LBUTTONUP:
    {
        POINT pt;
        pt.x = (short)LOWORD(lParam);
        pt.y = (short)HIWORD(lParam);
        return SYSLINK_LButtonUp(infoPtr, &pt);
    }
    
    case WM_KEYDOWN:
    {
        switch(wParam)
        {
        case VK_RETURN:
            SYSLINK_OnEnter(infoPtr);
            return 0;
        case VK_TAB:
        {
            BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
            SYSKEY_SelectNextPrevLink(infoPtr, shift);
            return 0;
        }
        default:
            return DefWindowProcW(hwnd, message, wParam, lParam);
        }
    }
    
    case WM_GETDLGCODE:
    {
        LRESULT Ret = DLGC_HASSETSEL;
        int vk = (lParam != 0 ? (int)((LPMSG)lParam)->wParam : 0);
        switch(vk)
        {
        case VK_RETURN:
            Ret |= DLGC_WANTMESSAGE;
            break;
        case VK_TAB:
        {
            BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
            if(!SYSLINK_NoNextLink(infoPtr, shift))
            {
                Ret |= DLGC_WANTTAB;
            }
            else
            {
                Ret |= DLGC_WANTCHARS;
            }
            break;
        }
        }
        return Ret;
    }
    
    case WM_NCHITTEST:
    {
        POINT pt;
        RECT rc;
        pt.x = (short)LOWORD(lParam);
        pt.y = (short)HIWORD(lParam);
        
        GetClientRect(infoPtr->Self, &rc);
        ScreenToClient(infoPtr->Self, &pt);
        if(pt.x < 0 || pt.y < 0 || pt.x > rc.right || pt.y > rc.bottom)
        {
            return HTNOWHERE;
        }
 
        if(SYSLINK_LinkAtPt(infoPtr, &pt, NULL, FALSE))
        {
            return HTCLIENT;
        }
        
        return HTTRANSPARENT;
    }
 
    case LM_HITTEST:
        return SYSLINK_HitTest(infoPtr, (PLHITTESTINFO)lParam);
 
    case LM_SETITEM:
        return SYSLINK_SetItem(infoPtr, (PLITEM)lParam);
 
    case LM_GETITEM:
        return SYSLINK_GetItem(infoPtr, (PLITEM)lParam);
 
    case LM_GETIDEALHEIGHT:
        if (lParam)
            return SYSLINK_GetIdealSize(infoPtr, (int)wParam, (SIZE *)lParam);
        else
            return SYSLINK_GetIdealHeight(infoPtr);
 
    case WM_SETFOCUS:
        return SYSLINK_SetFocus(infoPtr);
 
    case WM_KILLFOCUS:
        return SYSLINK_KillFocus(infoPtr);
 
    case WM_ENABLE:
        infoPtr->Style &= ~WS_DISABLED;
        infoPtr->Style |= (wParam ? 0 : WS_DISABLED);
        InvalidateRect (infoPtr->Self, NULL, FALSE);
        return 0;
 
    case WM_STYLECHANGED:
        if (wParam == GWL_STYLE)
        {
            infoPtr->Style = ((LPSTYLESTRUCT)lParam)->styleNew;
 
            InvalidateRect(infoPtr->Self, NULL, TRUE);
        }
        return 0;
 
    case WM_CREATE:
    {
        CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
 
        /* allocate memory for info struct */
        infoPtr = Alloc (sizeof(SYSLINK_INFO));
        if (!infoPtr) return -1;
        SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
 
        /* initialize the info struct */
        infoPtr->Self = hwnd;
        infoPtr->Notify = cs->hwndParent;
        infoPtr->Style = cs->style;
        infoPtr->Font = 0;
        infoPtr->LinkFont = 0;
        list_init(&infoPtr->Items);
        infoPtr->HasFocus = FALSE;
        infoPtr->MouseDownID = -1;
        infoPtr->TextColor = comctl32_color.clrWindowText;
        infoPtr->LinkColor = comctl32_color.clrHighlight;
        infoPtr->VisitedColor = comctl32_color.clrHighlight;
        infoPtr->BreakChar = ' ';
        infoPtr->IgnoreReturn = infoPtr->Style & LWS_IGNORERETURN;
        TRACE("SysLink Ctrl creation, hwnd=%p\n", hwnd);
        SYSLINK_SetText(infoPtr, cs->lpszName);
        return 0;
    }
    case WM_DESTROY:
        TRACE("SysLink Ctrl destruction, hwnd=%p\n", hwnd);
        SYSLINK_ClearDoc(infoPtr);
        if(infoPtr->Font != 0) DeleteObject(infoPtr->Font);
        if(infoPtr->LinkFont != 0) DeleteObject(infoPtr->LinkFont);
        SetWindowLongPtrW(hwnd, 0, 0);
        Free (infoPtr);
        return 0;
 
    case WM_SYSCOLORCHANGE:
        COMCTL32_RefreshSysColors();
        return 0;
 
    default:
        if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
        {
            ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
        }
        return DefWindowProcW(hwnd, message, wParam, lParam);
    }
}

Referenced by SYSLINK_Register().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

syslink

)