winspool.drv: Add GetPrintProcessorDirectoryW.
[wine] / dlls / comctl32 / syslink.c
1 /*
2  * SysLink control
3  *
4  * Copyright 2004 - 2006 Thomas Weidenmueller <w3seek@reactos.com>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * NOTES
21  *
22  * This code was audited for completeness against the documented features
23  * of Comctl32.dll version 6.0 on Apr. 4, 2005, by Dimitrie O. Paun.
24  * 
25  * Unless otherwise noted, we believe this code to be complete, as per
26  * the specification mentioned above.
27  * If you discover missing features, or bugs, please note them below.
28  */
29
30 #include <stdarg.h>
31 #include <string.h>
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "winnls.h"
37 #include "commctrl.h"
38 #include "comctl32.h"
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(progress);
43
44 INT WINAPI StrCmpNIW(LPCWSTR,LPCWSTR,INT);
45
46 typedef struct
47 {
48     int nChars;
49     int nSkip;
50     RECT rc;
51 } DOC_TEXTBLOCK, *PDOC_TEXTBLOCK;
52
53 #define LIF_FLAGSMASK   (LIF_STATE | LIF_ITEMID | LIF_URL)
54 #define LIS_MASK        (LIS_FOCUSED | LIS_ENABLED | LIS_VISITED)
55
56 typedef enum
57 {
58     slText = 0,
59     slLink
60 } SL_ITEM_TYPE;
61
62 typedef struct _DOC_ITEM
63 {
64     struct _DOC_ITEM *Next; /* Address to the next item */
65     UINT nText;             /* Number of characters of the text */
66     SL_ITEM_TYPE Type;      /* type of the item */
67     PDOC_TEXTBLOCK Blocks;  /* Array of text blocks */
68     union
69     {
70         struct
71         {
72             UINT state;     /* Link state */
73             WCHAR *szID;    /* Link ID string */
74             WCHAR *szUrl;   /* Link URL string */
75         } Link;
76         struct
77         {
78             UINT Dummy;
79         } Text;
80     } u;
81     WCHAR Text[1];          /* Text of the document item */
82 } DOC_ITEM, *PDOC_ITEM;
83
84 typedef struct
85 {
86     HWND      Self;         /* The window handle for this control */
87     HWND      Notify;       /* The parent handle to receive notifications */
88     DWORD     Style;        /* Styles for this control */
89     PDOC_ITEM Items;        /* Address to the first document item */
90     BOOL      HasFocus;     /* Whether the control has the input focus */
91     int       MouseDownID;  /* ID of the link that the mouse button first selected */
92     HFONT     Font;         /* Handle to the font for text */
93     HFONT     LinkFont;     /* Handle to the font for links */
94     COLORREF  TextColor;    /* Color of the text */
95     COLORREF  LinkColor;    /* Color of links */
96     COLORREF  VisitedColor; /* Color of visited links */
97     WCHAR     BreakChar;    /* Break Character for the current font */
98 } SYSLINK_INFO;
99
100 static const WCHAR SL_LINKOPEN[] =  { '<','a', 0 };
101 static const WCHAR SL_HREF[] =      { 'h','r','e','f','=','\"',0 };
102 static const WCHAR SL_ID[] =        { 'i','d','=','\"',0 };
103 static const WCHAR SL_LINKCLOSE[] = { '<','/','a','>',0 };
104
105 /* Control configuration constants */
106
107 #define SL_LEFTMARGIN   (0)
108 #define SL_TOPMARGIN    (0)
109 #define SL_RIGHTMARGIN  (0)
110 #define SL_BOTTOMMARGIN (0)
111
112 /***********************************************************************
113  * SYSLINK_FreeDocItem
114  * Frees all data and gdi objects associated with a document item
115  */
116 static VOID SYSLINK_FreeDocItem (PDOC_ITEM DocItem)
117 {
118     if(DocItem->Type == slLink)
119     {
120         if (DocItem->u.Link.szID != NULL)
121         {
122             Free(DocItem->u.Link.szID);
123         }
124         if (DocItem->u.Link.szUrl != NULL)
125         {
126             Free(DocItem->u.Link.szUrl);
127         }
128     }
129
130     /* we don't free Text because it's just a pointer to a character in the
131        entire window text string */
132
133     Free(DocItem);
134 }
135
136 /***********************************************************************
137  * SYSLINK_AppendDocItem
138  * Create and append a new document item.
139  */
140 static PDOC_ITEM SYSLINK_AppendDocItem (SYSLINK_INFO *infoPtr, LPCWSTR Text, UINT textlen,
141                                         SL_ITEM_TYPE type, PDOC_ITEM LastItem)
142 {
143     PDOC_ITEM Item;
144
145     textlen = min(textlen, lstrlenW(Text));
146     Item = Alloc(FIELD_OFFSET(DOC_ITEM, Text[textlen + 1]));
147     if(Item == NULL)
148     {
149         ERR("Failed to alloc DOC_ITEM structure!\n");
150         return NULL;
151     }
152
153     Item->Next = NULL;
154     Item->nText = textlen;
155     Item->Type = type;
156     Item->Blocks = NULL;
157     
158     if(LastItem != NULL)
159     {
160         LastItem->Next = Item;
161     }
162     else
163     {
164         infoPtr->Items = Item;
165     }
166     
167     lstrcpynW(Item->Text, Text, textlen + 1);
168     
169     return Item;
170 }
171
172 /***********************************************************************
173  * SYSLINK_ClearDoc
174  * Clears the document tree
175  */
176 static VOID SYSLINK_ClearDoc (SYSLINK_INFO *infoPtr)
177 {
178     PDOC_ITEM Item, Next;
179     
180     Item = infoPtr->Items;
181     while(Item != NULL)
182     {
183         Next = Item->Next;
184         SYSLINK_FreeDocItem(Item);
185         Item = Next;
186     }
187     
188     infoPtr->Items = NULL;
189 }
190
191 /***********************************************************************
192  * SYSLINK_ParseText
193  * Parses the window text string and creates a document. Returns the
194  * number of document items created.
195  */
196 static UINT SYSLINK_ParseText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
197 {
198     LPCWSTR current, textstart = NULL, linktext = NULL, firsttag = NULL;
199     int taglen = 0, textlen = 0, linklen = 0, docitems = 0;
200     PDOC_ITEM Last = NULL;
201     SL_ITEM_TYPE CurrentType = slText;
202     LPCWSTR lpID, lpUrl;
203     UINT lenId, lenUrl;
204
205     for(current = Text; *current != 0;)
206     {
207         if(*current == '<')
208         {
209             if(!StrCmpNIW(current, SL_LINKOPEN, 2) && (CurrentType == slText))
210             {
211                 BOOL ValidParam = FALSE, ValidLink = FALSE;
212
213                 if(*(current + 2) == '>')
214                 {
215                     /* we just have to deal with a <a> tag */
216                     taglen = 3;
217                     ValidLink = TRUE;
218                     ValidParam = TRUE;
219                     firsttag = current;
220                     linklen = 0;
221                     lpID = NULL;
222                     lpUrl = NULL;
223                 }
224                 else if(*(current + 2) == infoPtr->BreakChar)
225                 {
226                     /* we expect parameters, parse them */
227                     LPCWSTR *CurrentParameter = NULL, tmp;
228                     UINT *CurrentParameterLen = NULL;
229
230                     taglen = 3;
231                     tmp = current + taglen;
232                     lpID = NULL;
233                     lpUrl = NULL;
234                     
235 CheckParameter:
236                     /* compare the current position with all known parameters */
237                     if(!StrCmpNIW(tmp, SL_HREF, 6))
238                     {
239                         taglen += 6;
240                         ValidParam = TRUE;
241                         CurrentParameter = &lpUrl;
242                         CurrentParameterLen = &lenUrl;
243                     }
244                     else if(!StrCmpNIW(tmp, SL_ID, 4))
245                     {
246                         taglen += 4;
247                         ValidParam = TRUE;
248                         CurrentParameter = &lpID;
249                         CurrentParameterLen = &lenId;
250                     }
251                     else
252                     {
253                         ValidParam = FALSE;
254                     }
255                     
256                     if(ValidParam)
257                     {
258                         /* we got a known parameter, now search until the next " character.
259                            If we can't find a " character, there's a syntax error and we just assume it's text */
260                         ValidParam = FALSE;
261                         *CurrentParameter = current + taglen;
262                         *CurrentParameterLen = 0;
263
264                         for(tmp = *CurrentParameter; *tmp != 0; tmp++)
265                         {
266                             taglen++;
267                             if(*tmp == '\"')
268                             {
269                                 ValidParam = TRUE;
270                                 tmp++;
271                                 break;
272                             }
273                             (*CurrentParameterLen)++;
274                         }
275                     }
276                     if(ValidParam)
277                     {
278                         /* we're done with this parameter, now there are only 2 possibilities:
279                          * 1. another parameter is coming, so expect a ' ' (space) character
280                          * 2. the tag is being closed, so expect a '<' character
281                          */
282                         if(*tmp == infoPtr->BreakChar)
283                         {
284                             /* we expect another parameter, do the whole thing again */
285                             taglen++;
286                             tmp++;
287                             goto CheckParameter;
288                         }
289                         else if(*tmp == '>')
290                         {
291                             /* the tag is being closed, we're done */
292                             ValidLink = TRUE;
293                             taglen++;
294                         }
295                         else
296                             tmp++;
297                     }
298                 }
299                 
300                 if(ValidLink && ValidParam)
301                 {
302                     /* the <a ...> tag appears to be valid. save all information
303                        so we can add the link if we find a valid </a> tag later */
304                     CurrentType = slLink;
305                     linktext = current + taglen;
306                     linklen = 0;
307                     firsttag = current;
308                 }
309                 else
310                 {
311                     taglen = 1;
312                     lpID = NULL;
313                     lpUrl = NULL;
314                     if(textstart == NULL)
315                     {
316                         textstart = current;
317                     }
318                 }
319             }
320             else if(!StrCmpNIW(current, SL_LINKCLOSE, 4) && (CurrentType == slLink) && firsttag)
321             {
322                 /* there's a <a...> tag opened, first add the previous text, if present */
323                 if(textstart != NULL && textlen > 0 && firsttag > textstart)
324                 {
325                     Last = SYSLINK_AppendDocItem(infoPtr, textstart, firsttag - textstart, slText, Last);
326                     if(Last == NULL)
327                     {
328                         ERR("Unable to create new document item!\n");
329                         return docitems;
330                     }
331                     docitems++;
332                     textstart = NULL;
333                     textlen = 0;
334                 }
335                 
336                 /* now it's time to add the link to the document */
337                 current += 4;
338                 if(linktext != NULL && linklen > 0)
339                 {
340                     Last = SYSLINK_AppendDocItem(infoPtr, linktext, linklen, slLink, Last);
341                     if(Last == NULL)
342                     {
343                         ERR("Unable to create new document item!\n");
344                         return docitems;
345                     }
346                     docitems++;
347                     if(CurrentType == slLink)
348                     {
349                         int nc;
350
351                         if(!(infoPtr->Style & WS_DISABLED))
352                         {
353                             Last->u.Link.state |= LIS_ENABLED;
354                         }
355                         /* Copy the tag parameters */
356                         if(lpID != NULL)
357                         {
358                             nc = min(lenId, strlenW(lpID));
359                             nc = min(nc, MAX_LINKID_TEXT - 1);
360                             Last->u.Link.szID = Alloc((nc + 1) * sizeof(WCHAR));
361                             if(Last->u.Link.szID != NULL)
362                             {
363                                 lstrcpynW(Last->u.Link.szID, lpID, nc + 1);
364                             }
365                         }
366                         else
367                             Last->u.Link.szID = NULL;
368                         if(lpUrl != NULL)
369                         {
370                             nc = min(lenUrl, strlenW(lpUrl));
371                             nc = min(nc, L_MAX_URL_LENGTH - 1);
372                             Last->u.Link.szUrl = Alloc((nc + 1) * sizeof(WCHAR));
373                             if(Last->u.Link.szUrl != NULL)
374                             {
375                                 lstrcpynW(Last->u.Link.szUrl, lpUrl, nc + 1);
376                             }
377                         }
378                         else
379                             Last->u.Link.szUrl = NULL;
380                     }
381                     linktext = NULL;
382                 }
383                 CurrentType = slText;
384                 firsttag = NULL;
385                 textstart = NULL;
386                 continue;
387             }
388             else
389             {
390                 /* we don't know what tag it is, so just continue */
391                 taglen = 1;
392                 linklen++;
393                 if(CurrentType == slText && textstart == NULL)
394                 {
395                     textstart = current;
396                 }
397             }
398             
399             textlen += taglen;
400             current += taglen;
401         }
402         else
403         {
404             textlen++;
405             linklen++;
406
407             /* save the pointer of the current text item if we couldn't find a tag */
408             if(textstart == NULL && CurrentType == slText)
409             {
410                 textstart = current;
411             }
412             
413             current++;
414         }
415     }
416     
417     if(textstart != NULL && textlen > 0)
418     {
419         Last = SYSLINK_AppendDocItem(infoPtr, textstart, textlen, CurrentType, Last);
420         if(Last == NULL)
421         {
422             ERR("Unable to create new document item!\n");
423             return docitems;
424         }
425         if(CurrentType == slLink)
426         {
427             int nc;
428
429             if(!(infoPtr->Style & WS_DISABLED))
430             {
431                 Last->u.Link.state |= LIS_ENABLED;
432             }
433             /* Copy the tag parameters */
434             if(lpID != NULL)
435             {
436                 nc = min(lenId, strlenW(lpID));
437                 nc = min(nc, MAX_LINKID_TEXT - 1);
438                 Last->u.Link.szID = Alloc((nc + 1) * sizeof(WCHAR));
439                 if(Last->u.Link.szID != NULL)
440                 {
441                     lstrcpynW(Last->u.Link.szID, lpID, nc + 1);
442                 }
443             }
444             else
445                 Last->u.Link.szID = NULL;
446             if(lpUrl != NULL)
447             {
448                 nc = min(lenUrl, strlenW(lpUrl));
449                 nc = min(nc, L_MAX_URL_LENGTH - 1);
450                 Last->u.Link.szUrl = Alloc((nc + 1) * sizeof(WCHAR));
451                 if(Last->u.Link.szUrl != NULL)
452                 {
453                     lstrcpynW(Last->u.Link.szUrl, lpUrl, nc + 1);
454                 }
455             }
456             else
457                 Last->u.Link.szUrl = NULL;
458         }
459         docitems++;
460     }
461
462     if(linktext != NULL && linklen > 0)
463     {
464         /* we got an unclosed link, just display the text */
465         Last = SYSLINK_AppendDocItem(infoPtr, linktext, linklen, slText, Last);
466         if(Last == NULL)
467         {
468             ERR("Unable to create new document item!\n");
469             return docitems;
470         }
471         docitems++;
472     }
473
474     return docitems;
475 }
476
477 /***********************************************************************
478  * SYSLINK_RepaintLink
479  * Repaints a link.
480  */
481 static VOID SYSLINK_RepaintLink (SYSLINK_INFO *infoPtr, PDOC_ITEM DocItem)
482 {
483     PDOC_TEXTBLOCK bl;
484     int n;
485
486     if(DocItem->Type != slLink)
487     {
488         ERR("DocItem not a link!\n");
489         return;
490     }
491     
492     bl = DocItem->Blocks;
493     if (bl != NULL)
494     {
495         n = DocItem->nText;
496         
497         while(n > 0)
498         {
499             InvalidateRect(infoPtr->Self, &bl->rc, TRUE);
500             n -= bl->nChars + bl->nSkip;
501             bl++;
502         }
503     }
504 }
505
506 /***********************************************************************
507  * SYSLINK_GetLinkItemByIndex
508  * Retrieves a document link by its index
509  */
510 static PDOC_ITEM SYSLINK_GetLinkItemByIndex (SYSLINK_INFO *infoPtr, int iLink)
511 {
512     PDOC_ITEM Current = infoPtr->Items;
513
514     while(Current != NULL)
515     {
516         if((Current->Type == slLink) && (iLink-- <= 0))
517         {
518             return Current;
519         }
520         Current = Current->Next;
521     }
522     return NULL;
523 }
524
525 /***********************************************************************
526  * SYSLINK_GetFocusLink
527  * Retrieves the link that has the LIS_FOCUSED bit
528  */
529 static PDOC_ITEM SYSLINK_GetFocusLink (SYSLINK_INFO *infoPtr, int *LinkId)
530 {
531     PDOC_ITEM Current = infoPtr->Items;
532     int id = 0;
533
534     while(Current != NULL)
535     {
536         if((Current->Type == slLink))
537         {
538             if(Current->u.Link.state & LIS_FOCUSED)
539             {
540                 if(LinkId != NULL)
541                     *LinkId = id;
542                 return Current;
543             }
544             id++;
545         }
546         Current = Current->Next;
547     }
548     return NULL;
549 }
550
551 /***********************************************************************
552  * SYSLINK_GetNextLink
553  * Gets the next link
554  */
555 static PDOC_ITEM SYSLINK_GetNextLink (SYSLINK_INFO *infoPtr, PDOC_ITEM Current)
556 {
557     for(Current = (Current != NULL ? Current->Next : infoPtr->Items);
558         Current != NULL;
559         Current = Current->Next)
560     {
561         if(Current->Type == slLink)
562         {
563             return Current;
564         }
565     }
566     return NULL;
567 }
568
569 /***********************************************************************
570  * SYSLINK_GetPrevLink
571  * Gets the previous link
572  */
573 static PDOC_ITEM SYSLINK_GetPrevLink (SYSLINK_INFO *infoPtr, PDOC_ITEM Current)
574 {
575     if(Current == NULL)
576     {
577         /* returns the last link */
578         PDOC_ITEM Last = NULL;
579         
580         for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
581         {
582             if(Current->Type == slLink)
583             {
584                 Last = Current;
585             }
586         }
587         return Last;
588     }
589     else
590     {
591         /* returns the previous link */
592         PDOC_ITEM Cur, Prev = NULL;
593         
594         for(Cur = infoPtr->Items; Cur != NULL; Cur = Cur->Next)
595         {
596             if(Cur == Current)
597             {
598                 break;
599             }
600             if(Cur->Type == slLink)
601             {
602                 Prev = Cur;
603             }
604         }
605         return Prev;
606     }
607 }
608
609 /***********************************************************************
610  * SYSLINK_WrapLine
611  * Tries to wrap a line.
612  */
613 static BOOL SYSLINK_WrapLine (HDC hdc, LPWSTR Text, WCHAR BreakChar, int *LineLen,
614                              int nFit, LPSIZE Extent, int Width)
615 {
616     WCHAR *Current;
617
618     if(nFit == *LineLen)
619     {
620         return FALSE;
621     }
622
623     *LineLen = nFit;
624
625     Current = Text + nFit;
626     
627     /* check if we're in the middle of a word */
628     if((*Current) != BreakChar)
629     {
630         /* search for the beginning of the word */
631         while(Current > Text && (*(Current - 1)) != BreakChar)
632         {
633             Current--;
634             (*LineLen)--;
635         }
636         
637         if((*LineLen) == 0)
638         {
639             Extent->cx = 0;
640             Extent->cy = 0;
641         }
642         return TRUE;
643     }
644
645     return TRUE;
646 }
647
648 /***********************************************************************
649  * SYSLINK_Render
650  * Renders the document in memory
651  */
652 static VOID SYSLINK_Render (SYSLINK_INFO *infoPtr, HDC hdc)
653 {
654     RECT rc;
655     PDOC_ITEM Current;
656     HGDIOBJ hOldFont;
657     int x, y, LineHeight;
658     
659     GetClientRect(infoPtr->Self, &rc);
660     rc.right -= SL_RIGHTMARGIN;
661     rc.bottom -= SL_BOTTOMMARGIN;
662     
663     if(rc.right - SL_LEFTMARGIN < 0 || rc.bottom - SL_TOPMARGIN < 0) return;
664     
665     hOldFont = SelectObject(hdc, infoPtr->Font);
666     
667     x = SL_LEFTMARGIN;
668     y = SL_TOPMARGIN;
669     LineHeight = 0;
670     
671     for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
672     {
673         int n, nBlocks;
674         LPWSTR tx;
675         PDOC_TEXTBLOCK bl, cbl;
676         INT nFit;
677         SIZE szDim;
678         
679         if(Current->nText == 0)
680         {
681             continue;
682         }
683         
684         tx = Current->Text;
685         n = Current->nText;
686
687         if (Current->Blocks != NULL)
688         {
689             Free(Current->Blocks);
690             Current->Blocks = NULL;
691         }
692         bl = NULL;
693         nBlocks = 0;
694         
695         if(Current->Type == slText)
696         {
697             SelectObject(hdc, infoPtr->Font);
698         }
699         else if(Current->Type == slLink)
700         {
701             SelectObject(hdc, infoPtr->LinkFont);
702         }
703         
704         while(n > 0)
705         {
706             int SkipChars = 0;
707
708             /* skip break characters unless they're the first of the doc item */
709             if(tx != Current->Text || x == SL_LEFTMARGIN)
710             {
711                 while(n > 0 && (*tx) == infoPtr->BreakChar)
712                 {
713                     tx++;
714                     SkipChars++;
715                     n--;
716                 }
717             }
718
719             if((n == 0 && SkipChars != 0) ||
720                GetTextExtentExPointW(hdc, tx, n, rc.right - x, &nFit, NULL, &szDim))
721             {
722                 int LineLen = n;
723                 BOOL Wrap = FALSE;
724                 
725                 if(n != 0)
726                 {
727                     Wrap = SYSLINK_WrapLine(hdc, tx, infoPtr->BreakChar, &LineLen, nFit, &szDim, rc.right - x);
728
729                     if(LineLen == 0)
730                     {
731                         if(x > SL_LEFTMARGIN)
732                         {
733                             /* move one line down, the word didn't fit into the line */
734                             x = SL_LEFTMARGIN;
735                             y += LineHeight;
736                             LineHeight = 0;
737                             continue;
738                         }
739                         else
740                         {
741                             /* the word starts at the beginning of the line and doesn't
742                                fit into the line, so break it at the last character that fits */
743                             LineLen = max(nFit, 1);
744                         }
745                     }
746
747                     if(LineLen != n)
748                     {
749                         if(!GetTextExtentExPointW(hdc, tx, LineLen, rc.right - x, NULL, NULL, &szDim))
750                         {
751                             if(bl != NULL)
752                             {
753                                 Free(bl);
754                                 bl = NULL;
755                                 nBlocks = 0;
756                             }
757                             break;
758                         }
759                     }
760                 }
761                 
762                 if(bl != NULL)
763                 {
764                     PDOC_TEXTBLOCK nbl = ReAlloc(bl, (nBlocks + 1) * sizeof(DOC_TEXTBLOCK));
765                     if (nbl != NULL)
766                     {
767                         bl = nbl;
768                         nBlocks++;
769                     }
770                     else
771                     {
772                         Free(bl);
773                         bl = NULL;
774                         nBlocks = 0;
775                     }
776                 }
777                 else
778                 {
779                     bl = Alloc(sizeof(DOC_TEXTBLOCK));
780                     if (bl != NULL)
781                         nBlocks++;
782                 }
783                 
784                 if(bl != NULL)
785                 {
786                     cbl = bl + nBlocks - 1;
787                     
788                     cbl->nChars = LineLen;
789                     cbl->nSkip = SkipChars;
790                     cbl->rc.left = x;
791                     cbl->rc.top = y;
792                     cbl->rc.right = x + szDim.cx;
793                     cbl->rc.bottom = y + szDim.cy;
794                     
795                     if(LineLen != 0)
796                     {
797                         x += szDim.cx;
798                         LineHeight = max(LineHeight, szDim.cy);
799
800                         if(Wrap)
801                         {
802                             x = SL_LEFTMARGIN;
803                             y += LineHeight;
804                             LineHeight = 0;
805                         }
806                     }
807                 }
808                 else
809                 {
810                     ERR("Failed to alloc DOC_TEXTBLOCK structure!\n");
811                     break;
812                 }
813                 n -= LineLen;
814                 tx += LineLen;
815             }
816             else
817             {
818                 n--;
819             }
820         }
821
822         if(nBlocks != 0)
823         {
824             Current->Blocks = bl;
825         }
826     }
827     
828     SelectObject(hdc, hOldFont);
829 }
830
831 /***********************************************************************
832  * SYSLINK_Draw
833  * Draws the SysLink control.
834  */
835 static LRESULT SYSLINK_Draw (SYSLINK_INFO *infoPtr, HDC hdc)
836 {
837     RECT rc;
838     PDOC_ITEM Current;
839     HFONT hOldFont;
840     COLORREF OldTextColor, OldBkColor;
841
842     hOldFont = SelectObject(hdc, infoPtr->Font);
843     OldTextColor = SetTextColor(hdc, infoPtr->TextColor);
844     OldBkColor = SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
845     
846     GetClientRect(infoPtr->Self, &rc);
847     rc.right -= SL_RIGHTMARGIN + SL_LEFTMARGIN;
848     rc.bottom -= SL_BOTTOMMARGIN + SL_TOPMARGIN;
849
850     if(rc.right < 0 || rc.bottom < 0) return 0;
851
852     for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
853     {
854         int n;
855         LPWSTR tx;
856         PDOC_TEXTBLOCK bl;
857         
858         bl = Current->Blocks;
859         if(bl != NULL)
860         {
861             tx = Current->Text;
862             n = Current->nText;
863
864             if(Current->Type == slText)
865             {
866                  SelectObject(hdc, infoPtr->Font);
867                  SetTextColor(hdc, infoPtr->TextColor);
868             }
869             else
870             {
871                  SelectObject(hdc, infoPtr->LinkFont);
872                  SetTextColor(hdc, (!(Current->u.Link.state & LIS_VISITED) ? infoPtr->LinkColor : infoPtr->VisitedColor));
873             }
874
875             while(n > 0)
876             {
877                 tx += bl->nSkip;
878                 ExtTextOutW(hdc, bl->rc.left, bl->rc.top, ETO_OPAQUE | ETO_CLIPPED, &bl->rc, tx, bl->nChars, NULL);
879                 if((Current->Type == slLink) && (Current->u.Link.state & LIS_FOCUSED) && infoPtr->HasFocus)
880                 {
881                     COLORREF PrevTextColor;
882                     PrevTextColor = SetTextColor(hdc, infoPtr->TextColor);
883                     DrawFocusRect(hdc, &bl->rc);
884                     SetTextColor(hdc, PrevTextColor);
885                 }
886                 tx += bl->nChars;
887                 n -= bl->nChars + bl->nSkip;
888                 bl++;
889             }
890         }
891     }
892
893     SetBkColor(hdc, OldBkColor);
894     SetTextColor(hdc, OldTextColor);
895     SelectObject(hdc, hOldFont);
896     
897     return 0;
898 }
899
900
901 /***********************************************************************
902  * SYSLINK_Paint
903  * Handles the WM_PAINT message.
904  */
905 static LRESULT SYSLINK_Paint (SYSLINK_INFO *infoPtr, HDC hdcParam)
906 {
907     HDC hdc;
908     PAINTSTRUCT ps;
909
910     hdc = hdcParam ? hdcParam : BeginPaint (infoPtr->Self, &ps);
911     if (hdc)
912     {
913         SYSLINK_Draw (infoPtr, hdc);
914         if (!hdcParam) EndPaint (infoPtr->Self, &ps);
915     }
916     return 0;
917 }
918
919
920 /***********************************************************************
921  *           SYSLINK_SetFont
922  * Set new Font for the SysLink control.
923  */
924 static HFONT SYSLINK_SetFont (SYSLINK_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
925 {
926     HDC hdc;
927     LOGFONTW lf;
928     TEXTMETRICW tm;
929     HFONT hOldFont = infoPtr->Font;
930     infoPtr->Font = hFont;
931     
932     /* free the underline font */
933     if(infoPtr->LinkFont != NULL)
934     {
935         DeleteObject(infoPtr->LinkFont);
936         infoPtr->LinkFont = NULL;
937     }
938
939     /* Render text position and word wrapping in memory */
940     hdc = GetDC(infoPtr->Self);
941     if(hdc != NULL)
942     {
943         /* create a new underline font */
944         if(GetTextMetricsW(hdc, &tm) &&
945            GetObjectW(infoPtr->Font, sizeof(LOGFONTW), &lf))
946         {
947             lf.lfUnderline = TRUE;
948             infoPtr->LinkFont = CreateFontIndirectW(&lf);
949             infoPtr->BreakChar = tm.tmBreakChar;
950         }
951         else
952         {
953             ERR("Failed to create link font!\n");
954         }
955
956         SYSLINK_Render(infoPtr, hdc);
957         ReleaseDC(infoPtr->Self, hdc);
958     }
959     
960     if(bRedraw)
961     {
962         RedrawWindow(infoPtr->Self, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
963     }
964     
965     return hOldFont;
966 }
967
968 /***********************************************************************
969  *           SYSLINK_SetText
970  * Set new text for the SysLink control.
971  */
972 static LRESULT SYSLINK_SetText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
973 {
974     int textlen;
975
976     /* clear the document */
977     SYSLINK_ClearDoc(infoPtr);
978     
979     if(Text == NULL || (textlen = lstrlenW(Text)) == 0)
980     {
981         return TRUE;
982     }
983     
984     /* let's parse the string and create a document */
985     if(SYSLINK_ParseText(infoPtr, Text) > 0)
986     {
987         /* Render text position and word wrapping in memory */
988         HDC hdc = GetDC(infoPtr->Self);
989         if (hdc != NULL)
990         {
991             SYSLINK_Render(infoPtr, hdc);
992             ReleaseDC(infoPtr->Self, hdc);
993
994             InvalidateRect(infoPtr->Self, NULL, TRUE);
995         }
996     }
997     
998     return TRUE;
999 }
1000
1001 /***********************************************************************
1002  *           SYSLINK_SetFocusLink
1003  * Updates the focus status bits and focusses the specified link.
1004  * If no document item is specified, the focus bit will be removed from all links.
1005  * Returns the previous focused item.
1006  */
1007 static PDOC_ITEM SYSLINK_SetFocusLink (SYSLINK_INFO *infoPtr, PDOC_ITEM DocItem)
1008 {
1009     PDOC_ITEM Current, PrevFocus = NULL;
1010     
1011     for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1012     {
1013         if(Current->Type == slLink)
1014         {
1015             if((PrevFocus == NULL) && (Current->u.Link.state & LIS_FOCUSED))
1016             {
1017                 PrevFocus = Current;
1018             }
1019             
1020             if(Current == DocItem)
1021             {
1022                 Current->u.Link.state |= LIS_FOCUSED;
1023             }
1024             else
1025             {
1026                 Current->u.Link.state &= ~LIS_FOCUSED;
1027             }
1028         }
1029     }
1030     
1031     return PrevFocus;
1032 }
1033
1034 /***********************************************************************
1035  *           SYSLINK_SetItem
1036  * Sets the states and attributes of a link item.
1037  */
1038 static LRESULT SYSLINK_SetItem (SYSLINK_INFO *infoPtr, PLITEM Item)
1039 {
1040     PDOC_ITEM di;
1041     int nc;
1042     PWSTR szId = NULL;
1043     PWSTR szUrl = NULL;
1044     BOOL Repaint = FALSE;
1045
1046     if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
1047     {
1048         ERR("Invalid Flags!\n");
1049         return FALSE;
1050     }
1051
1052     di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
1053     if(di == NULL)
1054     {
1055         ERR("Link %d couldn't be found\n", Item->iLink);
1056         return FALSE;
1057     }
1058
1059     if(Item->mask & LIF_ITEMID)
1060     {
1061         nc = min(lstrlenW(Item->szID), MAX_LINKID_TEXT - 1);
1062         szId = Alloc((nc + 1) * sizeof(WCHAR));
1063         if(szId)
1064         {
1065             lstrcpynW(szId, Item->szID, nc + 1);
1066         }
1067         else
1068         {
1069             ERR("Unable to allocate memory for link id\n");
1070             return FALSE;
1071         }
1072     }
1073
1074     if(Item->mask & LIF_URL)
1075     {
1076         nc = min(lstrlenW(Item->szUrl), L_MAX_URL_LENGTH - 1);
1077         szUrl = Alloc((nc + 1) * sizeof(WCHAR));
1078         if(szUrl)
1079         {
1080             lstrcpynW(szUrl, Item->szUrl, nc + 1);
1081         }
1082         else
1083         {
1084             if (szId)
1085             {
1086                 Free(szId);
1087             }
1088
1089             ERR("Unable to allocate memory for link url\n");
1090             return FALSE;
1091         }
1092     }
1093
1094     if(Item->mask & LIF_ITEMID)
1095     {
1096         if(di->u.Link.szID)
1097         {
1098             Free(di->u.Link.szID);
1099         }
1100         di->u.Link.szID = szId;
1101     }
1102
1103     if(Item->mask & LIF_URL)
1104     {
1105         if(di->u.Link.szUrl)
1106         {
1107             Free(di->u.Link.szUrl);
1108         }
1109         di->u.Link.szUrl = szUrl;
1110     }
1111
1112     if(Item->mask & LIF_STATE)
1113     {
1114         UINT oldstate = di->u.Link.state;
1115         /* clear the masked bits */
1116         di->u.Link.state &= ~(Item->stateMask & LIS_MASK);
1117         /* copy the bits */
1118         di->u.Link.state |= (Item->state & Item->stateMask) & LIS_MASK;
1119         Repaint = (oldstate != di->u.Link.state);
1120         
1121         /* update the focus */
1122         SYSLINK_SetFocusLink(infoPtr, ((di->u.Link.state & LIS_FOCUSED) ? di : NULL));
1123     }
1124     
1125     if(Repaint)
1126     {
1127         SYSLINK_RepaintLink(infoPtr, di);
1128     }
1129     
1130     return TRUE;
1131 }
1132
1133 /***********************************************************************
1134  *           SYSLINK_GetItem
1135  * Retrieves the states and attributes of a link item.
1136  */
1137 static LRESULT SYSLINK_GetItem (SYSLINK_INFO *infoPtr, PLITEM Item)
1138 {
1139     PDOC_ITEM di;
1140     
1141     if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
1142     {
1143         ERR("Invalid Flags!\n");
1144         return FALSE;
1145     }
1146     
1147     di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
1148     if(di == NULL)
1149     {
1150         ERR("Link %d couldn't be found\n", Item->iLink);
1151         return FALSE;
1152     }
1153     
1154     if(Item->mask & LIF_STATE)
1155     {
1156         Item->state = (di->u.Link.state & Item->stateMask);
1157         if(!infoPtr->HasFocus)
1158         {
1159             /* remove the LIS_FOCUSED bit if the control doesn't have focus */
1160             Item->state &= ~LIS_FOCUSED;
1161         }
1162     }
1163     
1164     if(Item->mask & LIF_ITEMID)
1165     {
1166         if(di->u.Link.szID)
1167         {
1168             lstrcpyW(Item->szID, di->u.Link.szID);
1169         }
1170         else
1171         {
1172             Item->szID[0] = 0;
1173         }
1174     }
1175     
1176     if(Item->mask & LIF_URL)
1177     {
1178         if(di->u.Link.szUrl)
1179         {
1180             lstrcpyW(Item->szUrl, di->u.Link.szUrl);
1181         }
1182         else
1183         {
1184             Item->szUrl[0] = 0;
1185         }
1186     }
1187     
1188     return TRUE;
1189 }
1190
1191 /***********************************************************************
1192  *           SYSLINK_PtInDocItem
1193  * Determines if a point is in the region of a document item
1194  */
1195 static BOOL SYSLINK_PtInDocItem (PDOC_ITEM DocItem, POINT pt)
1196 {
1197     PDOC_TEXTBLOCK bl;
1198     int n;
1199
1200     bl = DocItem->Blocks;
1201     if (bl != NULL)
1202     {
1203         n = DocItem->nText;
1204
1205         while(n > 0)
1206         {
1207             if (PtInRect(&bl->rc, pt))
1208             {
1209                 return TRUE;
1210             }
1211             n -= bl->nChars + bl->nSkip;
1212             bl++;
1213         }
1214     }
1215     
1216     return FALSE;
1217 }
1218
1219 /***********************************************************************
1220  *           SYSLINK_HitTest
1221  * Determines the link the user clicked on.
1222  */
1223 static LRESULT SYSLINK_HitTest (SYSLINK_INFO *infoPtr, PLHITTESTINFO HitTest)
1224 {
1225     PDOC_ITEM Current;
1226     int id = 0;
1227
1228     for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1229     {
1230         if(Current->Type == slLink)
1231         {
1232             if(SYSLINK_PtInDocItem(Current, HitTest->pt))
1233             {
1234                 HitTest->item.mask = 0;
1235                 HitTest->item.iLink = id;
1236                 HitTest->item.state = 0;
1237                 HitTest->item.stateMask = 0;
1238                 if(Current->u.Link.szID)
1239                 {
1240                     lstrcpyW(HitTest->item.szID, Current->u.Link.szID);
1241                 }
1242                 else
1243                 {
1244                     HitTest->item.szID[0] = 0;
1245                 }
1246                 if(Current->u.Link.szUrl)
1247                 {
1248                     lstrcpyW(HitTest->item.szUrl, Current->u.Link.szUrl);
1249                 }
1250                 else
1251                 {
1252                     HitTest->item.szUrl[0] = 0;
1253                 }
1254                 return TRUE;
1255             }
1256             id++;
1257         }
1258     }
1259     
1260     return FALSE;
1261 }
1262
1263 /***********************************************************************
1264  *           SYSLINK_GetIdealHeight
1265  * Returns the preferred height of a link at the current control's width.
1266  */
1267 static LRESULT SYSLINK_GetIdealHeight (SYSLINK_INFO *infoPtr)
1268 {
1269     HDC hdc = GetDC(infoPtr->Self);
1270     if(hdc != NULL)
1271     {
1272         LRESULT height;
1273         TEXTMETRICW tm;
1274         HGDIOBJ hOldFont = SelectObject(hdc, infoPtr->Font);
1275         
1276         if(GetTextMetricsW(hdc, &tm))
1277         {
1278             height = tm.tmHeight;
1279         }
1280         else
1281         {
1282             height = 0;
1283         }
1284         SelectObject(hdc, hOldFont);
1285         ReleaseDC(infoPtr->Self, hdc);
1286         
1287         return height;
1288     }
1289     return 0;
1290 }
1291
1292 /***********************************************************************
1293  *           SYSLINK_SendParentNotify
1294  * Sends a WM_NOTIFY message to the parent window.
1295  */
1296 static LRESULT SYSLINK_SendParentNotify (SYSLINK_INFO *infoPtr, UINT code, PDOC_ITEM Link, int iLink)
1297 {
1298     NMLINK nml;
1299
1300     nml.hdr.hwndFrom = infoPtr->Self;
1301     nml.hdr.idFrom = GetWindowLongPtrW(infoPtr->Self, GWLP_ID);
1302     nml.hdr.code = code;
1303
1304     nml.item.mask = 0;
1305     nml.item.iLink = iLink;
1306     nml.item.state = 0;
1307     nml.item.stateMask = 0;
1308     if(Link->u.Link.szID)
1309     {
1310         lstrcpyW(nml.item.szID, Link->u.Link.szID);
1311     }
1312     else
1313     {
1314         nml.item.szID[0] = 0;
1315     }
1316     if(Link->u.Link.szUrl)
1317     {
1318         lstrcpyW(nml.item.szUrl, Link->u.Link.szUrl);
1319     }
1320     else
1321     {
1322         nml.item.szUrl[0] = 0;
1323     }
1324
1325     return SendMessageW(infoPtr->Notify, WM_NOTIFY, (WPARAM)nml.hdr.idFrom, (LPARAM)&nml);
1326 }
1327
1328 /***********************************************************************
1329  *           SYSLINK_SetFocus
1330  * Handles receiving the input focus.
1331  */
1332 static LRESULT SYSLINK_SetFocus (SYSLINK_INFO *infoPtr, HWND PrevFocusWindow)
1333 {
1334     PDOC_ITEM Focus;
1335     
1336     infoPtr->HasFocus = TRUE;
1337
1338     /* We always select the first link, even if we activated the control using
1339        SHIFT+TAB. This is the default behavior */
1340     Focus = SYSLINK_GetNextLink(infoPtr, NULL);
1341     if(Focus != NULL)
1342     {
1343         SYSLINK_SetFocusLink(infoPtr, Focus);
1344     }
1345     
1346     SYSLINK_RepaintLink(infoPtr, Focus);
1347     
1348     return 0;
1349 }
1350
1351 /***********************************************************************
1352  *           SYSLINK_KillFocus
1353  * Handles losing the input focus.
1354  */
1355 static LRESULT SYSLINK_KillFocus (SYSLINK_INFO *infoPtr, HWND NewFocusWindow)
1356 {
1357     PDOC_ITEM Focus;
1358     
1359     infoPtr->HasFocus = FALSE;
1360     Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
1361     
1362     if(Focus != NULL)
1363     {
1364         SYSLINK_RepaintLink(infoPtr, Focus);
1365     }
1366
1367     return 0;
1368 }
1369
1370 /***********************************************************************
1371  *           SYSLINK_LinkAtPt
1372  * Returns a link at the specified position
1373  */
1374 static PDOC_ITEM SYSLINK_LinkAtPt (SYSLINK_INFO *infoPtr, POINT *pt, int *LinkId, BOOL MustBeEnabled)
1375 {
1376     PDOC_ITEM Current;
1377     int id = 0;
1378
1379     for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1380     {
1381         if((Current->Type == slLink) && SYSLINK_PtInDocItem(Current, *pt) &&
1382            (!MustBeEnabled || (MustBeEnabled && (Current->u.Link.state & LIS_ENABLED))))
1383         {
1384             if(LinkId != NULL)
1385             {
1386                 *LinkId = id;
1387             }
1388             return Current;
1389         }
1390         id++;
1391     }
1392
1393     return NULL;
1394 }
1395
1396 /***********************************************************************
1397  *           SYSLINK_LButtonDown
1398  * Handles mouse clicks
1399  */
1400 static LRESULT SYSLINK_LButtonDown (SYSLINK_INFO *infoPtr, DWORD Buttons, POINT *pt)
1401 {
1402     PDOC_ITEM Current, Old;
1403     int id;
1404
1405     Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
1406     if(Current != NULL)
1407     {
1408       SetFocus(infoPtr->Self);
1409
1410       Old = SYSLINK_SetFocusLink(infoPtr, Current);
1411       if(Old != NULL && Old != Current)
1412       {
1413           SYSLINK_RepaintLink(infoPtr, Old);
1414       }
1415       infoPtr->MouseDownID = id;
1416       SYSLINK_RepaintLink(infoPtr, Current);
1417     }
1418
1419     return 0;
1420 }
1421
1422 /***********************************************************************
1423  *           SYSLINK_LButtonUp
1424  * Handles mouse clicks
1425  */
1426 static LRESULT SYSLINK_LButtonUp (SYSLINK_INFO *infoPtr, DWORD Buttons, POINT *pt)
1427 {
1428     if(infoPtr->MouseDownID > -1)
1429     {
1430         PDOC_ITEM Current;
1431         int id;
1432         
1433         Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
1434         if((Current != NULL) && (Current->u.Link.state & LIS_FOCUSED) && (infoPtr->MouseDownID == id))
1435         {
1436             SYSLINK_SendParentNotify(infoPtr, NM_CLICK, Current, id);
1437         }
1438     }
1439
1440     infoPtr->MouseDownID = -1;
1441
1442     return 0;
1443 }
1444
1445 /***********************************************************************
1446  *           SYSLINK_OnEnter
1447  * Handles ENTER key events
1448  */
1449 static BOOL SYSLINK_OnEnter (SYSLINK_INFO *infoPtr)
1450 {
1451     if(infoPtr->HasFocus)
1452     {
1453         PDOC_ITEM Focus;
1454         int id;
1455         
1456         Focus = SYSLINK_GetFocusLink(infoPtr, &id);
1457         if(Focus != NULL)
1458         {
1459             SYSLINK_SendParentNotify(infoPtr, NM_RETURN, Focus, id);
1460             return TRUE;
1461         }
1462     }
1463     return FALSE;
1464 }
1465
1466 /***********************************************************************
1467  *           SYSKEY_SelectNextPrevLink
1468  * Changes the currently focused link
1469  */
1470 static BOOL SYSKEY_SelectNextPrevLink (SYSLINK_INFO *infoPtr, BOOL Prev)
1471 {
1472     if(infoPtr->HasFocus)
1473     {
1474         PDOC_ITEM Focus;
1475         int id;
1476
1477         Focus = SYSLINK_GetFocusLink(infoPtr, &id);
1478         if(Focus != NULL)
1479         {
1480             PDOC_ITEM NewFocus, OldFocus;
1481
1482             if(Prev)
1483                 NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
1484             else
1485                 NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
1486
1487             if(NewFocus != NULL)
1488             {
1489                 OldFocus = SYSLINK_SetFocusLink(infoPtr, NewFocus);
1490
1491                 if(OldFocus != NewFocus)
1492                 {
1493                     SYSLINK_RepaintLink(infoPtr, OldFocus);
1494                 }
1495                 SYSLINK_RepaintLink(infoPtr, NewFocus);
1496                 return TRUE;
1497             }
1498         }
1499     }
1500     return FALSE;
1501 }
1502
1503 /***********************************************************************
1504  *           SYSKEY_SelectNextPrevLink
1505  * Determines if there's a next or previous link to decide whether the control
1506  * should capture the tab key message
1507  */
1508 static BOOL SYSLINK_NoNextLink (SYSLINK_INFO *infoPtr, BOOL Prev)
1509 {
1510     PDOC_ITEM Focus, NewFocus;
1511
1512     Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
1513     if(Prev)
1514         NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
1515     else
1516         NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
1517
1518     return NewFocus == NULL;
1519 }
1520
1521 /***********************************************************************
1522  *           SysLinkWindowProc
1523  */
1524 static LRESULT WINAPI SysLinkWindowProc(HWND hwnd, UINT message,
1525                                         WPARAM wParam, LPARAM lParam)
1526 {
1527     SYSLINK_INFO *infoPtr;
1528
1529     TRACE("hwnd=%p msg=%04x wparam=%x lParam=%lx\n", hwnd, message, wParam, lParam);
1530
1531     infoPtr = (SYSLINK_INFO *)GetWindowLongPtrW(hwnd, 0);
1532
1533     if (!infoPtr && message != WM_CREATE)
1534         goto HandleDefaultMessage;
1535
1536     switch(message) {
1537     case WM_PRINTCLIENT:
1538     case WM_PAINT:
1539         return SYSLINK_Paint (infoPtr, (HDC)wParam);
1540
1541     case WM_SETCURSOR:
1542     {
1543         LHITTESTINFO ht;
1544         DWORD mp = GetMessagePos();
1545         
1546         ht.pt.x = (short)LOWORD(mp);
1547         ht.pt.y = (short)HIWORD(mp);
1548         
1549         ScreenToClient(infoPtr->Self, &ht.pt);
1550         if(SYSLINK_HitTest (infoPtr, &ht))
1551         {
1552             SetCursor(LoadCursorW(0, (LPCWSTR)IDC_HAND));
1553             return TRUE;
1554         }
1555         /* let the default window proc handle this message */
1556         goto HandleDefaultMessage;
1557     }
1558
1559     case WM_SIZE:
1560     {
1561         HDC hdc = GetDC(infoPtr->Self);
1562         if(hdc != NULL)
1563         {
1564           SYSLINK_Render(infoPtr, hdc);
1565           ReleaseDC(infoPtr->Self, hdc);
1566         }
1567         return 0;
1568     }
1569
1570     case WM_GETFONT:
1571         return (LRESULT)infoPtr->Font;
1572
1573     case WM_SETFONT:
1574         return (LRESULT)SYSLINK_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
1575
1576     case WM_SETTEXT:
1577         SYSLINK_SetText(infoPtr, (LPWSTR)lParam);
1578         goto HandleDefaultMessage;
1579
1580     case WM_LBUTTONDOWN:
1581     {
1582         POINT pt;
1583         pt.x = LOWORD(lParam);
1584         pt.y = HIWORD(lParam);
1585         return SYSLINK_LButtonDown(infoPtr, wParam, &pt);
1586     }
1587     case WM_LBUTTONUP:
1588     {
1589         POINT pt;
1590         pt.x = LOWORD(lParam);
1591         pt.y = HIWORD(lParam);
1592         return SYSLINK_LButtonUp(infoPtr, wParam, &pt);
1593     }
1594     
1595     case WM_KEYDOWN:
1596     {
1597         switch(wParam)
1598         {
1599         case VK_RETURN:
1600             SYSLINK_OnEnter(infoPtr);
1601             return 0;
1602         case VK_TAB:
1603         {
1604             BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
1605             SYSKEY_SelectNextPrevLink(infoPtr, shift);
1606             return 0;
1607         }
1608         }
1609         goto HandleDefaultMessage;
1610     }
1611     
1612     case WM_GETDLGCODE:
1613     {
1614         LRESULT Ret = DLGC_HASSETSEL;
1615         int vk = (lParam != 0 ? (int)((LPMSG)lParam)->wParam : 0);
1616         switch(vk)
1617         {
1618         case VK_RETURN:
1619             Ret |= DLGC_WANTMESSAGE;
1620             break;
1621         case VK_TAB:
1622         {
1623             BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
1624             if(!SYSLINK_NoNextLink(infoPtr, shift))
1625             {
1626                 Ret |= DLGC_WANTTAB;
1627             }
1628             else
1629             {
1630                 Ret |= DLGC_WANTCHARS;
1631             }
1632             break;
1633         }
1634         }
1635         return Ret;
1636     }
1637     
1638     case WM_NCHITTEST:
1639     {
1640         POINT pt;
1641         RECT rc;
1642         pt.x = LOWORD(lParam);
1643         pt.y = HIWORD(lParam);
1644         
1645         GetClientRect(infoPtr->Self, &rc);
1646         ScreenToClient(infoPtr->Self, &pt);
1647         if(pt.x < 0 || pt.y < 0 || pt.x > rc.right || pt.y > rc.bottom)
1648         {
1649             return HTNOWHERE;
1650         }
1651
1652         if(SYSLINK_LinkAtPt(infoPtr, &pt, NULL, FALSE))
1653         {
1654             return HTCLIENT;
1655         }
1656         
1657         return HTTRANSPARENT;
1658     }
1659
1660     case LM_HITTEST:
1661         return SYSLINK_HitTest(infoPtr, (PLHITTESTINFO)lParam);
1662
1663     case LM_SETITEM:
1664         return SYSLINK_SetItem(infoPtr, (PLITEM)lParam);
1665
1666     case LM_GETITEM:
1667         return SYSLINK_GetItem(infoPtr, (PLITEM)lParam);
1668
1669     case LM_GETIDEALHEIGHT:
1670         return SYSLINK_GetIdealHeight(infoPtr);
1671
1672     case WM_SETFOCUS:
1673         return SYSLINK_SetFocus(infoPtr, (HWND)wParam);
1674
1675     case WM_KILLFOCUS:
1676         return SYSLINK_KillFocus(infoPtr, (HWND)wParam);
1677
1678     case WM_ENABLE:
1679         infoPtr->Style &= ~WS_DISABLED;
1680         infoPtr->Style |= (wParam ? 0 : WS_DISABLED);
1681         InvalidateRect (infoPtr->Self, NULL, FALSE);
1682         return 0;
1683
1684     case WM_STYLECHANGED:
1685         if (wParam == GWL_STYLE)
1686         {
1687             infoPtr->Style = ((LPSTYLESTRUCT)lParam)->styleNew;
1688
1689             InvalidateRect(infoPtr->Self, NULL, TRUE);
1690         }
1691         return 0;
1692
1693     case WM_CREATE:
1694         /* allocate memory for info struct */
1695         infoPtr = Alloc (sizeof(SYSLINK_INFO));
1696         if (!infoPtr) return -1;
1697         SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1698
1699         /* initialize the info struct */
1700         infoPtr->Self = hwnd;
1701         infoPtr->Notify = ((LPCREATESTRUCTW)lParam)->hwndParent;
1702         infoPtr->Style = ((LPCREATESTRUCTW)lParam)->style;
1703         infoPtr->Font = 0;
1704         infoPtr->LinkFont = 0;
1705         infoPtr->Items = NULL;
1706         infoPtr->HasFocus = FALSE;
1707         infoPtr->MouseDownID = -1;
1708         infoPtr->TextColor = GetSysColor(COLOR_WINDOWTEXT);
1709         infoPtr->LinkColor = GetSysColor(COLOR_HIGHLIGHT);
1710         infoPtr->VisitedColor = GetSysColor(COLOR_HIGHLIGHT);
1711         infoPtr->BreakChar = ' ';
1712         TRACE("SysLink Ctrl creation, hwnd=%p\n", hwnd);
1713         SYSLINK_SetText(infoPtr, ((LPCREATESTRUCTW)lParam)->lpszName);
1714         return 0;
1715
1716     case WM_DESTROY:
1717         TRACE("SysLink Ctrl destruction, hwnd=%p\n", hwnd);
1718         SYSLINK_ClearDoc(infoPtr);
1719         if(infoPtr->Font != 0) DeleteObject(infoPtr->Font);
1720         if(infoPtr->LinkFont != 0) DeleteObject(infoPtr->LinkFont);
1721         SetWindowLongPtrW(hwnd, 0, 0);
1722         Free (infoPtr);
1723         return 0;
1724
1725     default:
1726 HandleDefaultMessage:
1727         if ((message >= WM_USER) && (message < WM_APP))
1728         {
1729                 ERR("unknown msg %04x wp=%04x lp=%08lx\n", message, wParam, lParam );
1730         }
1731         return DefWindowProcW(hwnd, message, wParam, lParam);
1732     }
1733 }
1734
1735
1736 /***********************************************************************
1737  * SYSLINK_Register [Internal]
1738  *
1739  * Registers the SysLink window class.
1740  */
1741 VOID SYSLINK_Register (void)
1742 {
1743     WNDCLASSW wndClass;
1744
1745     ZeroMemory (&wndClass, sizeof(wndClass));
1746     wndClass.style         = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
1747     wndClass.lpfnWndProc   = SysLinkWindowProc;
1748     wndClass.cbClsExtra    = 0;
1749     wndClass.cbWndExtra    = sizeof (SYSLINK_INFO *);
1750     wndClass.hCursor       = LoadCursorW (0, (LPWSTR)IDC_ARROW);
1751     wndClass.lpszClassName = WC_LINK;
1752
1753     RegisterClassW (&wndClass);
1754 }
1755
1756
1757 /***********************************************************************
1758  * SYSLINK_Unregister [Internal]
1759  *
1760  * Unregisters the SysLink window class.
1761  */
1762 VOID SYSLINK_Unregister (void)
1763 {
1764     UnregisterClassW (WC_LINK, NULL);
1765 }