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