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