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