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