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 COLORREF BackColor; /* Background color, set on creation */
98 WCHAR BreakChar; /* Break Character for the current font */
99 BOOL IgnoreReturn; /* (infoPtr->Style & LWS_IGNORERETURN) on creation */
100 } SYSLINK_INFO;
101
102 static const WCHAR SL_LINKOPEN[] = { '<','a', 0 };
103 static const WCHAR SL_HREF[] = { 'h','r','e','f','=','\"',0 };
104 static const WCHAR SL_ID[] = { 'i','d','=','\"',0 };
105 static const WCHAR SL_LINKCLOSE[] = { '<','/','a','>',0 };
106
107 /* Control configuration constants */
108
109 #define SL_LEFTMARGIN (0)
110 #define SL_TOPMARGIN (0)
111 #define SL_RIGHTMARGIN (0)
112 #define SL_BOTTOMMARGIN (0)
113
114 /***********************************************************************
115 * SYSLINK_FreeDocItem
116 * Frees all data and gdi objects associated with a document item
117 */
118 static VOID SYSLINK_FreeDocItem (PDOC_ITEM DocItem)
119 {
120 if(DocItem->Type == slLink)
121 {
122 Free(DocItem->u.Link.szID);
123 Free(DocItem->u.Link.szUrl);
124 }
125
126 /* we don't free Text because it's just a pointer to a character in the
127 entire window text string */
128
129 Free(DocItem);
130 }
131
132 /***********************************************************************
133 * SYSLINK_AppendDocItem
134 * Create and append a new document item.
135 */
136 static PDOC_ITEM SYSLINK_AppendDocItem (SYSLINK_INFO *infoPtr, LPCWSTR Text, UINT textlen,
137 SL_ITEM_TYPE type, PDOC_ITEM LastItem)
138 {
139 PDOC_ITEM Item;
140
141 textlen = min(textlen, strlenW(Text));
142 Item = Alloc(FIELD_OFFSET(DOC_ITEM, Text[textlen + 1]));
143 if(Item == NULL)
144 {
145 ERR("Failed to alloc DOC_ITEM structure!\n");
146 return NULL;
147 }
148
149 Item->Next = NULL;
150 Item->nText = textlen;
151 Item->Type = type;
152 Item->Blocks = NULL;
153
154 if(LastItem != NULL)
155 {
156 LastItem->Next = Item;
157 }
158 else
159 {
160 infoPtr->Items = Item;
161 }
162
163 lstrcpynW(Item->Text, Text, textlen + 1);
164
165 return Item;
166 }
167
168 /***********************************************************************
169 * SYSLINK_ClearDoc
170 * Clears the document tree
171 */
172 static VOID SYSLINK_ClearDoc (SYSLINK_INFO *infoPtr)
173 {
174 PDOC_ITEM Item, Next;
175
176 Item = infoPtr->Items;
177 while(Item != NULL)
178 {
179 Next = Item->Next;
180 SYSLINK_FreeDocItem(Item);
181 Item = Next;
182 }
183
184 infoPtr->Items = NULL;
185 }
186
187 /***********************************************************************
188 * SYSLINK_ParseText
189 * Parses the window text string and creates a document. Returns the
190 * number of document items created.
191 */
192 static UINT SYSLINK_ParseText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
193 {
194 LPCWSTR current, textstart = NULL, linktext = NULL, firsttag = NULL;
195 int taglen = 0, textlen = 0, linklen = 0, docitems = 0;
196 PDOC_ITEM Last = NULL;
197 SL_ITEM_TYPE CurrentType = slText;
198 LPCWSTR lpID, lpUrl;
199 UINT lenId, lenUrl;
200
201 for(current = Text; *current != 0;)
202 {
203 if(*current == '<')
204 {
205 if(!StrCmpNIW(current, SL_LINKOPEN, 2) && (CurrentType == slText))
206 {
207 BOOL ValidParam = FALSE, ValidLink = FALSE;
208
209 if(*(current + 2) == '>')
210 {
211 /* we just have to deal with a <a> tag */
212 taglen = 3;
213 ValidLink = TRUE;
214 ValidParam = TRUE;
215 firsttag = current;
216 linklen = 0;
217 lpID = NULL;
218 lpUrl = NULL;
219 }
220 else if(*(current + 2) == infoPtr->BreakChar)
221 {
222 /* we expect parameters, parse them */
223 LPCWSTR *CurrentParameter = NULL, tmp;
224 UINT *CurrentParameterLen = NULL;
225
226 taglen = 3;
227 tmp = current + taglen;
228 lpID = NULL;
229 lpUrl = NULL;
230
231 CheckParameter:
232 /* compare the current position with all known parameters */
233 if(!StrCmpNIW(tmp, SL_HREF, 6))
234 {
235 taglen += 6;
236 ValidParam = TRUE;
237 CurrentParameter = &lpUrl;
238 CurrentParameterLen = &lenUrl;
239 }
240 else if(!StrCmpNIW(tmp, SL_ID, 4))
241 {
242 taglen += 4;
243 ValidParam = TRUE;
244 CurrentParameter = &lpID;
245 CurrentParameterLen = &lenId;
246 }
247 else
248 {
249 ValidParam = FALSE;
250 }
251
252 if(ValidParam)
253 {
254 /* we got a known parameter, now search until the next " character.
255 If we can't find a " character, there's a syntax error and we just assume it's text */
256 ValidParam = FALSE;
257 *CurrentParameter = current + taglen;
258 *CurrentParameterLen = 0;
259
260 for(tmp = *CurrentParameter; *tmp != 0; tmp++)
261 {
262 taglen++;
263 if(*tmp == '\"')
264 {
265 ValidParam = TRUE;
266 tmp++;
267 break;
268 }
269 (*CurrentParameterLen)++;
270 }
271 }
272 if(ValidParam)
273 {
274 /* we're done with this parameter, now there are only 2 possibilities:
275 * 1. another parameter is coming, so expect a ' ' (space) character
276 * 2. the tag is being closed, so expect a '<' character
277 */
278 if(*tmp == infoPtr->BreakChar)
279 {
280 /* we expect another parameter, do the whole thing again */
281 taglen++;
282 tmp++;
283 goto CheckParameter;
284 }
285 else if(*tmp == '>')
286 {
287 /* the tag is being closed, we're done */
288 ValidLink = TRUE;
289 taglen++;
290 }
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 (LPWSTR Text, WCHAR BreakChar, int *LineLen,
608 int nFit, LPSIZE Extent)
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(tx, infoPtr->BreakChar, &LineLen, nFit, &szDim);
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, infoPtr->BackColor);
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 * SYSLINK_EraseBkgnd
913 * Handles the WM_ERASEBKGND message.
914 */
915 static LRESULT SYSLINK_EraseBkgnd (const SYSLINK_INFO *infoPtr, HDC hdc)
916 {
917 HBRUSH hbr;
918 RECT r;
919
920 GetClientRect(infoPtr->Self, &r);
921 hbr = CreateSolidBrush(infoPtr->BackColor);
922 FillRect(hdc, &r, hbr);
923 DeleteObject(hbr);
924
925 return 1;
926 }
927
928 /***********************************************************************
929 * SYSLINK_SetFont
930 * Set new Font for the SysLink control.
931 */
932 static HFONT SYSLINK_SetFont (SYSLINK_INFO *infoPtr, HFONT hFont, BOOL bRedraw)
933 {
934 HDC hdc;
935 LOGFONTW lf;
936 TEXTMETRICW tm;
937 RECT rcClient;
938 HFONT hOldFont = infoPtr->Font;
939 infoPtr->Font = hFont;
940
941 /* free the underline font */
942 if(infoPtr->LinkFont != NULL)
943 {
944 DeleteObject(infoPtr->LinkFont);
945 infoPtr->LinkFont = NULL;
946 }
947
948 /* Render text position and word wrapping in memory */
949 if (GetClientRect(infoPtr->Self, &rcClient))
950 {
951 hdc = GetDC(infoPtr->Self);
952 if(hdc != NULL)
953 {
954 /* create a new underline font */
955 if(GetTextMetricsW(hdc, &tm) &&
956 GetObjectW(infoPtr->Font, sizeof(LOGFONTW), &lf))
957 {
958 lf.lfUnderline = TRUE;
959 infoPtr->LinkFont = CreateFontIndirectW(&lf);
960 infoPtr->BreakChar = tm.tmBreakChar;
961 }
962 else
963 {
964 ERR("Failed to create link font!\n");
965 }
966
967 SYSLINK_Render(infoPtr, hdc, &rcClient);
968 ReleaseDC(infoPtr->Self, hdc);
969 }
970 }
971
972 if(bRedraw)
973 {
974 RedrawWindow(infoPtr->Self, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW);
975 }
976
977 return hOldFont;
978 }
979
980 /***********************************************************************
981 * SYSLINK_SetText
982 * Set new text for the SysLink control.
983 */
984 static LRESULT SYSLINK_SetText (SYSLINK_INFO *infoPtr, LPCWSTR Text)
985 {
986 /* clear the document */
987 SYSLINK_ClearDoc(infoPtr);
988
989 if(Text == NULL || *Text == 0)
990 {
991 return TRUE;
992 }
993
994 /* let's parse the string and create a document */
995 if(SYSLINK_ParseText(infoPtr, Text) > 0)
996 {
997 RECT rcClient;
998
999 /* Render text position and word wrapping in memory */
1000 if (GetClientRect(infoPtr->Self, &rcClient))
1001 {
1002 HDC hdc = GetDC(infoPtr->Self);
1003 if (hdc != NULL)
1004 {
1005 SYSLINK_Render(infoPtr, hdc, &rcClient);
1006 ReleaseDC(infoPtr->Self, hdc);
1007
1008 InvalidateRect(infoPtr->Self, NULL, TRUE);
1009 }
1010 }
1011 }
1012
1013 return TRUE;
1014 }
1015
1016 /***********************************************************************
1017 * SYSLINK_SetFocusLink
1018 * Updates the focus status bits and focusses the specified link.
1019 * If no document item is specified, the focus bit will be removed from all links.
1020 * Returns the previous focused item.
1021 */
1022 static PDOC_ITEM SYSLINK_SetFocusLink (const SYSLINK_INFO *infoPtr, const DOC_ITEM *DocItem)
1023 {
1024 PDOC_ITEM Current, PrevFocus = NULL;
1025
1026 for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1027 {
1028 if(Current->Type == slLink)
1029 {
1030 if((PrevFocus == NULL) && (Current->u.Link.state & LIS_FOCUSED))
1031 {
1032 PrevFocus = Current;
1033 }
1034
1035 if(Current == DocItem)
1036 {
1037 Current->u.Link.state |= LIS_FOCUSED;
1038 }
1039 else
1040 {
1041 Current->u.Link.state &= ~LIS_FOCUSED;
1042 }
1043 }
1044 }
1045
1046 return PrevFocus;
1047 }
1048
1049 /***********************************************************************
1050 * SYSLINK_SetItem
1051 * Sets the states and attributes of a link item.
1052 */
1053 static LRESULT SYSLINK_SetItem (const SYSLINK_INFO *infoPtr, const LITEM *Item)
1054 {
1055 PDOC_ITEM di;
1056 int nc;
1057 PWSTR szId = NULL;
1058 PWSTR szUrl = NULL;
1059 BOOL Repaint = FALSE;
1060
1061 if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
1062 {
1063 ERR("Invalid Flags!\n");
1064 return FALSE;
1065 }
1066
1067 di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
1068 if(di == NULL)
1069 {
1070 ERR("Link %d couldn't be found\n", Item->iLink);
1071 return FALSE;
1072 }
1073
1074 if(Item->mask & LIF_ITEMID)
1075 {
1076 nc = min(lstrlenW(Item->szID), MAX_LINKID_TEXT - 1);
1077 szId = Alloc((nc + 1) * sizeof(WCHAR));
1078 if(szId)
1079 {
1080 lstrcpynW(szId, Item->szID, nc + 1);
1081 }
1082 else
1083 {
1084 ERR("Unable to allocate memory for link id\n");
1085 return FALSE;
1086 }
1087 }
1088
1089 if(Item->mask & LIF_URL)
1090 {
1091 nc = min(lstrlenW(Item->szUrl), L_MAX_URL_LENGTH - 1);
1092 szUrl = Alloc((nc + 1) * sizeof(WCHAR));
1093 if(szUrl)
1094 {
1095 lstrcpynW(szUrl, Item->szUrl, nc + 1);
1096 }
1097 else
1098 {
1099 Free(szId);
1100
1101 ERR("Unable to allocate memory for link url\n");
1102 return FALSE;
1103 }
1104 }
1105
1106 if(Item->mask & LIF_ITEMID)
1107 {
1108 Free(di->u.Link.szID);
1109 di->u.Link.szID = szId;
1110 }
1111
1112 if(Item->mask & LIF_URL)
1113 {
1114 Free(di->u.Link.szUrl);
1115 di->u.Link.szUrl = szUrl;
1116 }
1117
1118 if(Item->mask & LIF_STATE)
1119 {
1120 UINT oldstate = di->u.Link.state;
1121 /* clear the masked bits */
1122 di->u.Link.state &= ~(Item->stateMask & LIS_MASK);
1123 /* copy the bits */
1124 di->u.Link.state |= (Item->state & Item->stateMask) & LIS_MASK;
1125 Repaint = (oldstate != di->u.Link.state);
1126
1127 /* update the focus */
1128 SYSLINK_SetFocusLink(infoPtr, ((di->u.Link.state & LIS_FOCUSED) ? di : NULL));
1129 }
1130
1131 if(Repaint)
1132 {
1133 SYSLINK_RepaintLink(infoPtr, di);
1134 }
1135
1136 return TRUE;
1137 }
1138
1139 /***********************************************************************
1140 * SYSLINK_GetItem
1141 * Retrieves the states and attributes of a link item.
1142 */
1143 static LRESULT SYSLINK_GetItem (const SYSLINK_INFO *infoPtr, PLITEM Item)
1144 {
1145 PDOC_ITEM di;
1146
1147 if(!(Item->mask & LIF_ITEMINDEX) || !(Item->mask & (LIF_FLAGSMASK)))
1148 {
1149 ERR("Invalid Flags!\n");
1150 return FALSE;
1151 }
1152
1153 di = SYSLINK_GetLinkItemByIndex(infoPtr, Item->iLink);
1154 if(di == NULL)
1155 {
1156 ERR("Link %d couldn't be found\n", Item->iLink);
1157 return FALSE;
1158 }
1159
1160 if(Item->mask & LIF_STATE)
1161 {
1162 Item->state = (di->u.Link.state & Item->stateMask);
1163 if(!infoPtr->HasFocus)
1164 {
1165 /* remove the LIS_FOCUSED bit if the control doesn't have focus */
1166 Item->state &= ~LIS_FOCUSED;
1167 }
1168 }
1169
1170 if(Item->mask & LIF_ITEMID)
1171 {
1172 if(di->u.Link.szID)
1173 {
1174 lstrcpyW(Item->szID, di->u.Link.szID);
1175 }
1176 else
1177 {
1178 Item->szID[0] = 0;
1179 }
1180 }
1181
1182 if(Item->mask & LIF_URL)
1183 {
1184 if(di->u.Link.szUrl)
1185 {
1186 lstrcpyW(Item->szUrl, di->u.Link.szUrl);
1187 }
1188 else
1189 {
1190 Item->szUrl[0] = 0;
1191 }
1192 }
1193
1194 return TRUE;
1195 }
1196
1197 /***********************************************************************
1198 * SYSLINK_PtInDocItem
1199 * Determines if a point is in the region of a document item
1200 */
1201 static BOOL SYSLINK_PtInDocItem (const DOC_ITEM *DocItem, POINT pt)
1202 {
1203 PDOC_TEXTBLOCK bl;
1204 int n;
1205
1206 bl = DocItem->Blocks;
1207 if (bl != NULL)
1208 {
1209 n = DocItem->nText;
1210
1211 while(n > 0)
1212 {
1213 if (PtInRect(&bl->rc, pt))
1214 {
1215 return TRUE;
1216 }
1217 n -= bl->nChars + bl->nSkip;
1218 bl++;
1219 }
1220 }
1221
1222 return FALSE;
1223 }
1224
1225 /***********************************************************************
1226 * SYSLINK_HitTest
1227 * Determines the link the user clicked on.
1228 */
1229 static LRESULT SYSLINK_HitTest (const SYSLINK_INFO *infoPtr, PLHITTESTINFO HitTest)
1230 {
1231 PDOC_ITEM Current;
1232 int id = 0;
1233
1234 for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1235 {
1236 if(Current->Type == slLink)
1237 {
1238 if(SYSLINK_PtInDocItem(Current, HitTest->pt))
1239 {
1240 HitTest->item.mask = 0;
1241 HitTest->item.iLink = id;
1242 HitTest->item.state = 0;
1243 HitTest->item.stateMask = 0;
1244 if(Current->u.Link.szID)
1245 {
1246 lstrcpyW(HitTest->item.szID, Current->u.Link.szID);
1247 }
1248 else
1249 {
1250 HitTest->item.szID[0] = 0;
1251 }
1252 if(Current->u.Link.szUrl)
1253 {
1254 lstrcpyW(HitTest->item.szUrl, Current->u.Link.szUrl);
1255 }
1256 else
1257 {
1258 HitTest->item.szUrl[0] = 0;
1259 }
1260 return TRUE;
1261 }
1262 id++;
1263 }
1264 }
1265
1266 return FALSE;
1267 }
1268
1269 /***********************************************************************
1270 * SYSLINK_GetIdealHeight
1271 * Returns the preferred height of a link at the current control's width.
1272 */
1273 static LRESULT SYSLINK_GetIdealHeight (const SYSLINK_INFO *infoPtr)
1274 {
1275 HDC hdc = GetDC(infoPtr->Self);
1276 if(hdc != NULL)
1277 {
1278 LRESULT height;
1279 TEXTMETRICW tm;
1280 HGDIOBJ hOldFont = SelectObject(hdc, infoPtr->Font);
1281
1282 if(GetTextMetricsW(hdc, &tm))
1283 {
1284 height = tm.tmHeight;
1285 }
1286 else
1287 {
1288 height = 0;
1289 }
1290 SelectObject(hdc, hOldFont);
1291 ReleaseDC(infoPtr->Self, hdc);
1292
1293 return height;
1294 }
1295 return 0;
1296 }
1297
1298 /***********************************************************************
1299 * SYSLINK_SendParentNotify
1300 * Sends a WM_NOTIFY message to the parent window.
1301 */
1302 static LRESULT SYSLINK_SendParentNotify (const SYSLINK_INFO *infoPtr, UINT code, const DOC_ITEM *Link, int iLink)
1303 {
1304 NMLINK nml;
1305
1306 nml.hdr.hwndFrom = infoPtr->Self;
1307 nml.hdr.idFrom = GetWindowLongPtrW(infoPtr->Self, GWLP_ID);
1308 nml.hdr.code = code;
1309
1310 nml.item.mask = 0;
1311 nml.item.iLink = iLink;
1312 nml.item.state = 0;
1313 nml.item.stateMask = 0;
1314 if(Link->u.Link.szID)
1315 {
1316 lstrcpyW(nml.item.szID, Link->u.Link.szID);
1317 }
1318 else
1319 {
1320 nml.item.szID[0] = 0;
1321 }
1322 if(Link->u.Link.szUrl)
1323 {
1324 lstrcpyW(nml.item.szUrl, Link->u.Link.szUrl);
1325 }
1326 else
1327 {
1328 nml.item.szUrl[0] = 0;
1329 }
1330
1331 return SendMessageW(infoPtr->Notify, WM_NOTIFY, nml.hdr.idFrom, (LPARAM)&nml);
1332 }
1333
1334 /***********************************************************************
1335 * SYSLINK_SetFocus
1336 * Handles receiving the input focus.
1337 */
1338 static LRESULT SYSLINK_SetFocus (SYSLINK_INFO *infoPtr)
1339 {
1340 PDOC_ITEM Focus;
1341
1342 infoPtr->HasFocus = TRUE;
1343
1344 /* We always select the first link, even if we activated the control using
1345 SHIFT+TAB. This is the default behavior */
1346 Focus = SYSLINK_GetNextLink(infoPtr, NULL);
1347 if(Focus != NULL)
1348 {
1349 SYSLINK_SetFocusLink(infoPtr, Focus);
1350 SYSLINK_RepaintLink(infoPtr, Focus);
1351 }
1352 return 0;
1353 }
1354
1355 /***********************************************************************
1356 * SYSLINK_KillFocus
1357 * Handles losing the input focus.
1358 */
1359 static LRESULT SYSLINK_KillFocus (SYSLINK_INFO *infoPtr)
1360 {
1361 PDOC_ITEM Focus;
1362
1363 infoPtr->HasFocus = FALSE;
1364 Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
1365
1366 if(Focus != NULL)
1367 {
1368 SYSLINK_RepaintLink(infoPtr, Focus);
1369 }
1370
1371 return 0;
1372 }
1373
1374 /***********************************************************************
1375 * SYSLINK_LinkAtPt
1376 * Returns a link at the specified position
1377 */
1378 static PDOC_ITEM SYSLINK_LinkAtPt (const SYSLINK_INFO *infoPtr, const POINT *pt, int *LinkId, BOOL MustBeEnabled)
1379 {
1380 PDOC_ITEM Current;
1381 int id = 0;
1382
1383 for(Current = infoPtr->Items; Current != NULL; Current = Current->Next)
1384 {
1385 if((Current->Type == slLink) && SYSLINK_PtInDocItem(Current, *pt) &&
1386 (!MustBeEnabled || (MustBeEnabled && (Current->u.Link.state & LIS_ENABLED))))
1387 {
1388 if(LinkId != NULL)
1389 {
1390 *LinkId = id;
1391 }
1392 return Current;
1393 }
1394 id++;
1395 }
1396
1397 return NULL;
1398 }
1399
1400 /***********************************************************************
1401 * SYSLINK_LButtonDown
1402 * Handles mouse clicks
1403 */
1404 static LRESULT SYSLINK_LButtonDown (SYSLINK_INFO *infoPtr, const POINT *pt)
1405 {
1406 PDOC_ITEM Current, Old;
1407 int id;
1408
1409 Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
1410 if(Current != NULL)
1411 {
1412 SetFocus(infoPtr->Self);
1413
1414 Old = SYSLINK_SetFocusLink(infoPtr, Current);
1415 if(Old != NULL && Old != Current)
1416 {
1417 SYSLINK_RepaintLink(infoPtr, Old);
1418 }
1419 infoPtr->MouseDownID = id;
1420 SYSLINK_RepaintLink(infoPtr, Current);
1421 }
1422
1423 return 0;
1424 }
1425
1426 /***********************************************************************
1427 * SYSLINK_LButtonUp
1428 * Handles mouse clicks
1429 */
1430 static LRESULT SYSLINK_LButtonUp (SYSLINK_INFO *infoPtr, const POINT *pt)
1431 {
1432 if(infoPtr->MouseDownID > -1)
1433 {
1434 PDOC_ITEM Current;
1435 int id;
1436
1437 Current = SYSLINK_LinkAtPt(infoPtr, pt, &id, TRUE);
1438 if((Current != NULL) && (Current->u.Link.state & LIS_FOCUSED) && (infoPtr->MouseDownID == id))
1439 {
1440 SYSLINK_SendParentNotify(infoPtr, NM_CLICK, Current, id);
1441 }
1442 }
1443
1444 infoPtr->MouseDownID = -1;
1445
1446 return 0;
1447 }
1448
1449 /***********************************************************************
1450 * SYSLINK_OnEnter
1451 * Handles ENTER key events
1452 */
1453 static BOOL SYSLINK_OnEnter (const SYSLINK_INFO *infoPtr)
1454 {
1455 if(infoPtr->HasFocus && !infoPtr->IgnoreReturn)
1456 {
1457 PDOC_ITEM Focus;
1458 int id;
1459
1460 Focus = SYSLINK_GetFocusLink(infoPtr, &id);
1461 if(Focus)
1462 {
1463 SYSLINK_SendParentNotify(infoPtr, NM_RETURN, Focus, id);
1464 return TRUE;
1465 }
1466 }
1467 return FALSE;
1468 }
1469
1470 /***********************************************************************
1471 * SYSKEY_SelectNextPrevLink
1472 * Changes the currently focused link
1473 */
1474 static BOOL SYSKEY_SelectNextPrevLink (const SYSLINK_INFO *infoPtr, BOOL Prev)
1475 {
1476 if(infoPtr->HasFocus)
1477 {
1478 PDOC_ITEM Focus;
1479 int id;
1480
1481 Focus = SYSLINK_GetFocusLink(infoPtr, &id);
1482 if(Focus != NULL)
1483 {
1484 PDOC_ITEM NewFocus, OldFocus;
1485
1486 if(Prev)
1487 NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
1488 else
1489 NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
1490
1491 if(NewFocus != NULL)
1492 {
1493 OldFocus = SYSLINK_SetFocusLink(infoPtr, NewFocus);
1494
1495 if(OldFocus && OldFocus != NewFocus)
1496 {
1497 SYSLINK_RepaintLink(infoPtr, OldFocus);
1498 }
1499 SYSLINK_RepaintLink(infoPtr, NewFocus);
1500 return TRUE;
1501 }
1502 }
1503 }
1504 return FALSE;
1505 }
1506
1507 /***********************************************************************
1508 * SYSKEY_SelectNextPrevLink
1509 * Determines if there's a next or previous link to decide whether the control
1510 * should capture the tab key message
1511 */
1512 static BOOL SYSLINK_NoNextLink (const SYSLINK_INFO *infoPtr, BOOL Prev)
1513 {
1514 PDOC_ITEM Focus, NewFocus;
1515
1516 Focus = SYSLINK_GetFocusLink(infoPtr, NULL);
1517 if(Prev)
1518 NewFocus = SYSLINK_GetPrevLink(infoPtr, Focus);
1519 else
1520 NewFocus = SYSLINK_GetNextLink(infoPtr, Focus);
1521
1522 return NewFocus == NULL;
1523 }
1524
1525 /***********************************************************************
1526 * SYSLINK_GetIdealSize
1527 * Calculates the ideal size of a link control at a given maximum width.
1528 */
1529 static VOID SYSLINK_GetIdealSize (const SYSLINK_INFO *infoPtr, int cxMaxWidth, LPSIZE lpSize)
1530 {
1531 RECT rc;
1532 HDC hdc;
1533
1534 rc.left = rc.top = rc.bottom = 0;
1535 rc.right = cxMaxWidth;
1536
1537 hdc = GetDC(infoPtr->Self);
1538 if (hdc != NULL)
1539 {
1540 HGDIOBJ hOldFont = SelectObject(hdc, infoPtr->Font);
1541
1542 SYSLINK_Render(infoPtr, hdc, &rc);
1543
1544 SelectObject(hdc, hOldFont);
1545 ReleaseDC(infoPtr->Self, hdc);
1546
1547 lpSize->cx = rc.right;
1548 lpSize->cy = rc.bottom;
1549 }
1550 }
1551
1552 /***********************************************************************
1553 * SysLinkWindowProc
1554 */
1555 static LRESULT WINAPI SysLinkWindowProc(HWND hwnd, UINT message,
1556 WPARAM wParam, LPARAM lParam)
1557 {
1558 SYSLINK_INFO *infoPtr;
1559
1560 TRACE("hwnd=%p msg=%04x wparam=%lx lParam=%lx\n", hwnd, message, wParam, lParam);
1561
1562 infoPtr = (SYSLINK_INFO *)GetWindowLongPtrW(hwnd, 0);
1563
1564 if (!infoPtr && message != WM_CREATE)
1565 goto HandleDefaultMessage;
1566
1567 switch(message) {
1568 case WM_PRINTCLIENT:
1569 case WM_PAINT:
1570 return SYSLINK_Paint (infoPtr, (HDC)wParam);
1571
1572 case WM_ERASEBKGND:
1573 return SYSLINK_EraseBkgnd(infoPtr, (HDC)wParam);
1574
1575 case WM_SETCURSOR:
1576 {
1577 LHITTESTINFO ht;
1578 DWORD mp = GetMessagePos();
1579
1580 ht.pt.x = (short)LOWORD(mp);
1581 ht.pt.y = (short)HIWORD(mp);
1582
1583 ScreenToClient(infoPtr->Self, &ht.pt);
1584 if(SYSLINK_HitTest (infoPtr, &ht))
1585 {
1586 SetCursor(LoadCursorW(0, (LPCWSTR)IDC_HAND));
1587 return TRUE;
1588 }
1589 /* let the default window proc handle this message */
1590 goto HandleDefaultMessage;
1591 }
1592
1593 case WM_SIZE:
1594 {
1595 RECT rcClient;
1596 if (GetClientRect(infoPtr->Self, &rcClient))
1597 {
1598 HDC hdc = GetDC(infoPtr->Self);
1599 if(hdc != NULL)
1600 {
1601 SYSLINK_Render(infoPtr, hdc, &rcClient);
1602 ReleaseDC(infoPtr->Self, hdc);
1603 }
1604 }
1605 return 0;
1606 }
1607
1608 case WM_GETFONT:
1609 return (LRESULT)infoPtr->Font;
1610
1611 case WM_SETFONT:
1612 return (LRESULT)SYSLINK_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
1613
1614 case WM_SETTEXT:
1615 SYSLINK_SetText(infoPtr, (LPWSTR)lParam);
1616 goto HandleDefaultMessage;
1617
1618 case WM_LBUTTONDOWN:
1619 {
1620 POINT pt;
1621 pt.x = (short)LOWORD(lParam);
1622 pt.y = (short)HIWORD(lParam);
1623 return SYSLINK_LButtonDown(infoPtr, &pt);
1624 }
1625 case WM_LBUTTONUP:
1626 {
1627 POINT pt;
1628 pt.x = (short)LOWORD(lParam);
1629 pt.y = (short)HIWORD(lParam);
1630 return SYSLINK_LButtonUp(infoPtr, &pt);
1631 }
1632
1633 case WM_KEYDOWN:
1634 {
1635 switch(wParam)
1636 {
1637 case VK_RETURN:
1638 SYSLINK_OnEnter(infoPtr);
1639 return 0;
1640 case VK_TAB:
1641 {
1642 BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
1643 SYSKEY_SelectNextPrevLink(infoPtr, shift);
1644 return 0;
1645 }
1646 }
1647 goto HandleDefaultMessage;
1648 }
1649
1650 case WM_GETDLGCODE:
1651 {
1652 LRESULT Ret = DLGC_HASSETSEL;
1653 int vk = (lParam != 0 ? (int)((LPMSG)lParam)->wParam : 0);
1654 switch(vk)
1655 {
1656 case VK_RETURN:
1657 Ret |= DLGC_WANTMESSAGE;
1658 break;
1659 case VK_TAB:
1660 {
1661 BOOL shift = GetKeyState(VK_SHIFT) & 0x8000;
1662 if(!SYSLINK_NoNextLink(infoPtr, shift))
1663 {
1664 Ret |= DLGC_WANTTAB;
1665 }
1666 else
1667 {
1668 Ret |= DLGC_WANTCHARS;
1669 }
1670 break;
1671 }
1672 }
1673 return Ret;
1674 }
1675
1676 case WM_NCHITTEST:
1677 {
1678 POINT pt;
1679 RECT rc;
1680 pt.x = (short)LOWORD(lParam);
1681 pt.y = (short)HIWORD(lParam);
1682
1683 GetClientRect(infoPtr->Self, &rc);
1684 ScreenToClient(infoPtr->Self, &pt);
1685 if(pt.x < 0 || pt.y < 0 || pt.x > rc.right || pt.y > rc.bottom)
1686 {
1687 return HTNOWHERE;
1688 }
1689
1690 if(SYSLINK_LinkAtPt(infoPtr, &pt, NULL, FALSE))
1691 {
1692 return HTCLIENT;
1693 }
1694
1695 return HTTRANSPARENT;
1696 }
1697
1698 case LM_HITTEST:
1699 return SYSLINK_HitTest(infoPtr, (PLHITTESTINFO)lParam);
1700
1701 case LM_SETITEM:
1702 return SYSLINK_SetItem(infoPtr, (PLITEM)lParam);
1703
1704 case LM_GETITEM:
1705 return SYSLINK_GetItem(infoPtr, (PLITEM)lParam);
1706
1707 case LM_GETIDEALHEIGHT:
1708 if (lParam)
1709 {
1710 /* LM_GETIDEALSIZE */
1711 SYSLINK_GetIdealSize(infoPtr, (int)wParam, (LPSIZE)lParam);
1712 }
1713 return SYSLINK_GetIdealHeight(infoPtr);
1714
1715 case WM_SETFOCUS:
1716 return SYSLINK_SetFocus(infoPtr);
1717
1718 case WM_KILLFOCUS:
1719 return SYSLINK_KillFocus(infoPtr);
1720
1721 case WM_ENABLE:
1722 infoPtr->Style &= ~WS_DISABLED;
1723 infoPtr->Style |= (wParam ? 0 : WS_DISABLED);
1724 InvalidateRect (infoPtr->Self, NULL, FALSE);
1725 return 0;
1726
1727 case WM_STYLECHANGED:
1728 if (wParam == GWL_STYLE)
1729 {
1730 infoPtr->Style = ((LPSTYLESTRUCT)lParam)->styleNew;
1731
1732 InvalidateRect(infoPtr->Self, NULL, TRUE);
1733 }
1734 return 0;
1735
1736 case WM_CREATE:
1737 /* allocate memory for info struct */
1738 infoPtr = Alloc (sizeof(SYSLINK_INFO));
1739 if (!infoPtr) return -1;
1740 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1741
1742 /* initialize the info struct */
1743 infoPtr->Self = hwnd;
1744 infoPtr->Notify = ((LPCREATESTRUCTW)lParam)->hwndParent;
1745 infoPtr->Style = ((LPCREATESTRUCTW)lParam)->style;
1746 infoPtr->Font = 0;
1747 infoPtr->LinkFont = 0;
1748 infoPtr->Items = NULL;
1749 infoPtr->HasFocus = FALSE;
1750 infoPtr->MouseDownID = -1;
1751 infoPtr->TextColor = comctl32_color.clrWindowText;
1752 infoPtr->LinkColor = comctl32_color.clrHighlight;
1753 infoPtr->VisitedColor = comctl32_color.clrHighlight;
1754 infoPtr->BackColor = infoPtr->Style & LWS_TRANSPARENT ?
1755 comctl32_color.clrWindow : comctl32_color.clrBtnFace;
1756 infoPtr->BreakChar = ' ';
1757 infoPtr->IgnoreReturn = infoPtr->Style & LWS_IGNORERETURN;
1758 TRACE("SysLink Ctrl creation, hwnd=%p\n", hwnd);
1759 SYSLINK_SetText(infoPtr, ((LPCREATESTRUCTW)lParam)->lpszName);
1760 return 0;
1761
1762 case WM_DESTROY:
1763 TRACE("SysLink Ctrl destruction, hwnd=%p\n", hwnd);
1764 SYSLINK_ClearDoc(infoPtr);
1765 if(infoPtr->Font != 0) DeleteObject(infoPtr->Font);
1766 if(infoPtr->LinkFont != 0) DeleteObject(infoPtr->LinkFont);
1767 SetWindowLongPtrW(hwnd, 0, 0);
1768 Free (infoPtr);
1769 return 0;
1770
1771 case WM_SYSCOLORCHANGE:
1772 COMCTL32_RefreshSysColors();
1773 if (infoPtr->Style & LWS_TRANSPARENT)
1774 infoPtr->BackColor = comctl32_color.clrWindow;
1775 return 0;
1776
1777 default:
1778 HandleDefaultMessage:
1779 if ((message >= WM_USER) && (message < WM_APP) && !COMCTL32_IsReflectedMessage(message))
1780 {
1781 ERR("unknown msg %04x wp=%04lx lp=%08lx\n", message, wParam, lParam );
1782 }
1783 return DefWindowProcW(hwnd, message, wParam, lParam);
1784 }
1785 }
1786
1787
1788 /***********************************************************************
1789 * SYSLINK_Register [Internal]
1790 *
1791 * Registers the SysLink window class.
1792 */
1793 VOID SYSLINK_Register (void)
1794 {
1795 WNDCLASSW wndClass;
1796
1797 ZeroMemory (&wndClass, sizeof(wndClass));
1798 wndClass.style = CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW;
1799 wndClass.lpfnWndProc = SysLinkWindowProc;
1800 wndClass.cbClsExtra = 0;
1801 wndClass.cbWndExtra = sizeof (SYSLINK_INFO *);
1802 wndClass.hCursor = LoadCursorW (0, (LPWSTR)IDC_ARROW);
1803 wndClass.lpszClassName = WC_LINK;
1804
1805 RegisterClassW (&wndClass);
1806 }
1807
1808
1809 /***********************************************************************
1810 * SYSLINK_Unregister [Internal]
1811 *
1812 * Unregisters the SysLink window class.
1813 */
1814 VOID SYSLINK_Unregister (void)
1815 {
1816 UnregisterClassW (WC_LINK, NULL);
1817 }
1818
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.