controls/listbox.c

   1 /*
   2  * Listbox controls
   3  *
   4  * Copyright  Martin Ayotte, 1993
   5  *            Constantine Sapuntzakis, 1995
   6  *            Alex Korobka, 1995
   7  *
   8  */
   9
  10  /*
  11   * FIXME:
  12   * - check if multi-column listboxes work
  13   * - implement more messages and styles
  14   * - implement caret for LBS_EXTENDEDSEL
  15   */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #include "windows.h"
  22 #include "user.h"
  23 #include "win.h"
  24 #include "gdi.h"
  25 #include "msdos.h"
  26 #include "listbox.h"
  27 #include "dos_fs.h"
  28 #include "drive.h"
  29 #include "file.h"
  30 #include "heap.h"
  31 #include "stddebug.h"
  32 #include "debug.h"
  33 #include "xmalloc.h"
  34
  35 #if 0
  36 #define LIST_HEAP_ALLOC(lphl,f,size) ((int)HEAP_Alloc(&lphl->Heap,f,size) & 0xffff)
  37 #define LIST_HEAP_FREE(lphl,handle) (HEAP_Free(&lphl->Heap,LIST_HEAP_ADDR(lphl,handle)))
  38 #define LIST_HEAP_ADDR(lphl,handle) \
  39     ((void *)((handle) ? ((handle) | ((int)lphl->Heap & 0xffff0000)) : 0))
  40 #else
  41 /* FIXME: shouldn't each listbox have its own heap? */
  42 #if 0
  43 #define LIST_HEAP_ALLOC(lphl,f,size) USER_HEAP_ALLOC(size)
  44 #define LIST_HEAP_FREE(lphl,handle)  USER_HEAP_FREE(handle)
  45 #define LIST_HEAP_ADDR(lphl,handle)  USER_HEAP_LIN_ADDR(handle)
  46 #define LIST_HEAP_SEG_ADDR(lphl,handle) USER_HEAP_SEG_ADDR(handle)
  47 #else
  48 /* Something like this maybe ? */
  49 #define LIST_HEAP_ALLOC(lphl,f,size) \
  50             LOCAL_Alloc( lphl->HeapSel, LMEM_FIXED, (size) )
  51 #if 0
  52 #define LIST_HEAP_REALLOC(handle,size) \
  53             LOCAL_ReAlloc( USER_HeapSel, (handle), (size), LMEM_FIXED )
  54 #endif
  55 #define LIST_HEAP_FREE(lphl,handle) \
  56             LOCAL_Free( lphl->HeapSel, (handle) )
  57 #define LIST_HEAP_ADDR(lphl,handle)  \
  58             ((handle) ? PTR_SEG_OFF_TO_LIN(lphl->HeapSel, (handle)) : NULL)
  59 #define LIST_HEAP_SEG_ADDR(lphl,handle)  \
  60             ((handle) ? MAKELONG((handle), lphl->HeapSel) : 0)
  61 #endif
  62 #endif
  63
  64 #define LIST_HEAP_SIZE 0x10000
  65
  66 #define LBMM_EDGE   4    /* distance inside box which is same as moving mouse
  67                             outside box, to trigger scrolling of LB */
  68
  69 static void ListBoxInitialize(LPHEADLIST lphl)
  70 {
  71   lphl->lpFirst        = NULL;
  72   lphl->ItemsCount     = 0;
  73   lphl->ItemsVisible   = 0;
  74   lphl->FirstVisible   = 0;
  75   lphl->ColumnsVisible = 1;
  76   lphl->ItemsPerColumn = 0;
  77   lphl->ItemFocused    = -1;
  78   lphl->PrevFocused    = -1;
  79 }
  80
  81 void CreateListBoxStruct(HWND hwnd, WORD CtlType, LONG styles, HWND parent)
  82 {
  83   LPHEADLIST lphl;
  84   HDC         hdc;
  85
  86   lphl = (LPHEADLIST)xmalloc(sizeof(HEADLIST));
  87   SetWindowLong32A(hwnd, 0, (LONG)lphl);
  88   ListBoxInitialize(lphl);
  89   lphl->DrawCtlType    = CtlType;
  90   lphl->CtlID          = GetWindowWord(hwnd,GWW_ID);
  91   lphl->bRedrawFlag    = TRUE;
  92   lphl->iNumStops      = 0;
  93   lphl->TabStops       = NULL;
  94   lphl->hFont          = GetStockObject(SYSTEM_FONT);
  95   lphl->hSelf          = hwnd;
  96   if (CtlType==ODT_COMBOBOX)              /* use the "faked" style for COMBOLBOX */
  97                                           /* LBS_SORT instead CBS_SORT e.g.      */
  98     lphl->dwStyle   = MAKELONG(LOWORD(styles),HIWORD(GetWindowLong(hwnd,GWL_STYLE)));
  99   else
 100     lphl->dwStyle   = GetWindowLong(hwnd,GWL_STYLE); /* use original style dword */
 101   lphl->hParent        = parent;
 102   lphl->StdItemHeight  = 15; /* FIXME: should get the font height */
 103   lphl->OwnerDrawn     = styles & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE);
 104   lphl->HasStrings     = (styles & LBS_HASSTRINGS) || !lphl->OwnerDrawn;
 105
 106   /* create dummy hdc to set text height */
 107   if ((hdc = GetDC(0)))
 108   {
 109       TEXTMETRIC tm;
 110       GetTextMetrics( hdc, &tm );
 111       lphl->StdItemHeight = tm.tmHeight;
 112       dprintf_listbox(stddeb,"CreateListBoxStruct:  font height %d\n",
 113                       lphl->StdItemHeight);
 114       ReleaseDC( 0, hdc );
 115   }
 116
 117   if (lphl->OwnerDrawn)
 118   {
 119     LISTSTRUCT dummyls;
 120
 121     lphl->needMeasure = TRUE;
 122     dummyls.mis.CtlType    = lphl->DrawCtlType;
 123     dummyls.mis.CtlID      = lphl->CtlID;
 124     dummyls.mis.itemID     = -1;
 125     dummyls.mis.itemWidth  = 0; /* ignored */
 126     dummyls.mis.itemData   = 0;
 127
 128     ListBoxAskMeasure(lphl,&dummyls);
 129   }
 130
 131 /* WINELIBS list boxes do not operate on local heaps */
 132 #ifndef WINELIB
 133   lphl->HeapSel = GlobalAlloc16(GMEM_FIXED,LIST_HEAP_SIZE);
 134   LocalInit( lphl->HeapSel, 0, LIST_HEAP_SIZE-1);
 135 #else
 136   lphl->HeapSel = 0;
 137 #endif
 138 }
 139
 140 void DestroyListBoxStruct(LPHEADLIST lphl)
 141 {
 142   /* XXX need to free lphl->Heap */
 143   GlobalFree16(lphl->HeapSel);
 144   free(lphl);
 145 }
 146
 147 static LPHEADLIST ListBoxGetStorageHeader(HWND hwnd)
 148 {
 149     return (LPHEADLIST)GetWindowLong(hwnd,0);
 150 }
 151
 152 /* Send notification "code" as part of a WM_COMMAND-message if hwnd
 153    has the LBS_NOTIFY style */
 154 void ListBoxSendNotification(LPHEADLIST lphl, WORD code)
 155 {
 156   if (lphl->dwStyle & LBS_NOTIFY)
 157 #ifdef WINELIB32
 158     SendMessage32A(lphl->hParent, WM_COMMAND,
 159                    MAKEWPARAM(lphl->CtlID,code), (LPARAM)lphl->hSelf);
 160 #else
 161     SendMessage16(lphl->hParent, WM_COMMAND,
 162                   lphl->CtlID, MAKELONG(lphl->hSelf, code));
 163 #endif
 164 }
 165
 166
 167 /* get the maximum value of lphl->FirstVisible */
 168 int ListMaxFirstVisible(LPHEADLIST lphl)
 169 {
 170     int m = lphl->ItemsCount-lphl->ItemsVisible;
 171     return (m < 0) ? 0 : m;
 172 }
 173
 174
 175 void ListBoxUpdateWindow(HWND hwnd, LPHEADLIST lphl, BOOL repaint)
 176 {
 177   WND *wndPtr = WIN_FindWndPtr(hwnd);
 178
 179   if (wndPtr->dwStyle & WS_VSCROLL)
 180     SetScrollRange(hwnd, SB_VERT, 0, ListMaxFirstVisible(lphl), TRUE);
 181   if ((wndPtr->dwStyle & WS_HSCROLL) && (lphl->ItemsPerColumn != 0))
 182     SetScrollRange(hwnd, SB_HORZ, 1, lphl->ItemsVisible /
 183                    lphl->ItemsPerColumn + 1, TRUE);
 184
 185   if (repaint && lphl->bRedrawFlag) InvalidateRect32( hwnd, NULL, TRUE );
 186 }
 187
 188 /* Returns: 0 if nothing needs to be changed */
 189 /*          1 if FirstVisible changed */
 190
 191 int ListBoxScrollToFocus(LPHEADLIST lphl)
 192 {
 193   short       end;
 194
 195   if (lphl->ItemsCount == 0) return 0;
 196   if (lphl->ItemFocused == -1) return 0;
 197
 198   end = lphl->FirstVisible + lphl->ItemsVisible - 1;
 199
 200   if (lphl->ItemFocused < lphl->FirstVisible ) {
 201     lphl->FirstVisible = lphl->ItemFocused;
 202     return 1;
 203   } else {
 204     if (lphl->ItemFocused > end) {
 205       WORD maxFirstVisible = ListMaxFirstVisible(lphl);
 206
 207       lphl->FirstVisible = lphl->ItemFocused;
 208
 209       if (lphl->FirstVisible > maxFirstVisible) {
 210         lphl->FirstVisible = maxFirstVisible;
 211       }
 212       return 1;
 213     }
 214   }
 215   return 0;
 216 }
 217
 218
 219 LPLISTSTRUCT ListBoxGetItem(LPHEADLIST lphl, UINT uIndex)
 220 {
 221   LPLISTSTRUCT lpls;
 222   UINT         Count = 0;
 223
 224   if (uIndex >= lphl->ItemsCount) return NULL;
 225
 226   lpls = lphl->lpFirst;
 227   while (Count++ < uIndex) lpls = lpls->lpNext;
 228   return lpls;
 229 }
 230
 231
 232 void ListBoxDrawItem (HWND hwnd, LPHEADLIST lphl, HDC hdc, LPLISTSTRUCT lpls,
 233                       RECT16 *rect, WORD itemAction, WORD itemState)
 234 {
 235     if (lphl->OwnerDrawn)
 236     {
 237         DRAWITEMSTRUCT32 dis;
 238
 239         dis.CtlID      = lpls->mis.CtlID;
 240         dis.CtlType    = lpls->mis.CtlType;
 241         dis.itemID     = lpls->mis.itemID;
 242         dis.hDC        = hdc;
 243         dis.hwndItem   = hwnd;
 244         dis.itemData   = lpls->mis.itemData;
 245         dis.itemAction = itemAction;
 246         dis.itemState  = itemState;
 247         CONV_RECT16TO32( rect, &dis.rcItem );
 248         SendMessage32A( lphl->hParent, WM_DRAWITEM, 0, (LPARAM)&dis );
 249         return;
 250     }
 251     if (itemAction == ODA_DRAWENTIRE || itemAction == ODA_SELECT) {
 252       int       OldBkMode;
 253       DWORD     dwOldTextColor = 0;
 254
 255       OldBkMode = SetBkMode(hdc, TRANSPARENT);
 256
 257       if (itemState != 0) {
 258         dwOldTextColor = SetTextColor(hdc, 0x00FFFFFFL);
 259         FillRect16(hdc, rect, GetStockObject(BLACK_BRUSH));
 260       }
 261
 262       if (lphl->dwStyle & LBS_USETABSTOPS) {
 263         TabbedTextOut(hdc, rect->left + 5, rect->top + 2,
 264                       (char *)lpls->itemText, strlen((char *)lpls->itemText),
 265                       lphl->iNumStops, lphl->TabStops, 0);
 266       } else {
 267         TextOut16(hdc, rect->left + 5, rect->top + 2,
 268                   (char *)lpls->itemText, strlen((char *)lpls->itemText));
 269       }
 270
 271       if (itemState != 0) {
 272         SetTextColor(hdc, dwOldTextColor);
 273       }
 274
 275       SetBkMode(hdc, OldBkMode);
 276     }
 277     else DrawFocusRect16(hdc, rect);
 278 }
 279
 280
 281 int ListBoxFindMouse(LPHEADLIST lphl, int X, int Y)
 282 {
 283   LPLISTSTRUCT lpls = lphl->lpFirst;
 284   int          i, j;
 285   POINT16      point;
 286
 287   point.x = X; point.y = Y;
 288   if (lphl->ItemsCount == 0) return LB_ERR;
 289
 290   for(i = 0; i < lphl->FirstVisible; i++) {
 291     if (lpls == NULL) return LB_ERR;
 292     lpls = lpls->lpNext;
 293   }
 294   for(j = 0; j < lphl->ItemsVisible; i++, j++) {
 295     if (lpls == NULL) return LB_ERR;
 296     if (PtInRect16(&lpls->itemRect,point)) {
 297       return i;
 298     }
 299     lpls = lpls->lpNext;
 300   }
 301   dprintf_listbox(stddeb,"ListBoxFindMouse: not found\n");
 302   return LB_ERR;
 303 }
 304
 305
 306 void ListBoxAskMeasure(LPHEADLIST lphl, LPLISTSTRUCT lpls)
 307 {
 308   HANDLE hTemp = USER_HEAP_ALLOC( sizeof(MEASUREITEMSTRUCT) );
 309   MEASUREITEMSTRUCT *lpmeasure = (MEASUREITEMSTRUCT *) USER_HEAP_LIN_ADDR(hTemp);
 310
 311   if (lpmeasure == NULL) {
 312     fprintf(stdnimp,"ListBoxAskMeasure() out of memory !\n");
 313     return;
 314   }
 315
 316   *lpmeasure = lpls->mis;
 317   lpmeasure->itemHeight = lphl->StdItemHeight;
 318   SendMessage16(lphl->hParent, WM_MEASUREITEM, 0, (LPARAM)USER_HEAP_SEG_ADDR(hTemp));
 319
 320   if (lphl->dwStyle & LBS_OWNERDRAWFIXED) {
 321     if (lpmeasure->itemHeight > lphl->StdItemHeight)
 322       lphl->StdItemHeight = lpmeasure->itemHeight;
 323     lpls->mis.itemHeight = lpmeasure->itemHeight;
 324   }
 325
 326   USER_HEAP_FREE(hTemp);
 327 }
 328
 329 /* -------------------- strings and item data ---------------------- */
 330
 331 LPLISTSTRUCT ListBoxCreateItem(LPHEADLIST lphl, int id)
 332 {
 333   LPLISTSTRUCT lplsnew = (LPLISTSTRUCT)malloc(sizeof(LISTSTRUCT));
 334
 335   if (lplsnew == NULL) return NULL;
 336
 337   lplsnew->itemState      = 0;
 338   lplsnew->mis.CtlType    = lphl->DrawCtlType;
 339   lplsnew->mis.CtlID      = lphl->CtlID;
 340   lplsnew->mis.itemID     = id;
 341   lplsnew->mis.itemHeight = lphl->StdItemHeight;
 342   lplsnew->mis.itemWidth  = 0; /* ignored */
 343   lplsnew->mis.itemData   = 0;
 344   SetRectEmpty16( &lplsnew->itemRect );
 345
 346   return lplsnew;
 347 }
 348
 349
 350
 351 int ListBoxInsertString(LPHEADLIST lphl, UINT uIndex, LPCSTR newstr)
 352 {
 353   LPLISTSTRUCT *lppls, lplsnew, lpls;
 354   HANDLE       hStr;
 355   LPSTR str;
 356   UINT  Count;
 357
 358   dprintf_listbox(stddeb,"ListBoxInsertString(%d, %p);\n", uIndex, newstr);
 359
 360   if (!newstr) return -1;
 361
 362   if (uIndex == (UINT)-1)
 363     uIndex = lphl->ItemsCount;
 364
 365   lppls = &lphl->lpFirst;
 366   for(Count = 0; Count < uIndex; Count++) {
 367     if (*lppls == NULL) return LB_ERR;
 368     lppls = (LPLISTSTRUCT *) &(*lppls)->lpNext;
 369   }
 370
 371   lplsnew = ListBoxCreateItem(lphl, Count);
 372
 373   if (lplsnew == NULL) {
 374     fprintf(stdnimp,"ListBoxInsertString() out of memory !\n");
 375     return LB_ERRSPACE;
 376   }
 377
 378   lplsnew->lpNext = *lppls;
 379   *lppls = lplsnew;
 380   lphl->ItemsCount++;
 381
 382   hStr = 0;
 383   if (lphl->HasStrings) {
 384     dprintf_listbox(stddeb,"  string: %s\n", newstr);
 385     hStr = LIST_HEAP_ALLOC(lphl, LMEM_MOVEABLE, strlen(newstr) + 1);
 386     str = (LPSTR)LIST_HEAP_ADDR(lphl, hStr);
 387     if (str == NULL) return LB_ERRSPACE;
 388     strcpy(str, newstr);
 389     lplsnew->itemText = str;
 390     /* I'm not so sure about the next one */
 391     lplsnew->mis.itemData = 0;
 392   } else {
 393     lplsnew->itemText = NULL;
 394     lplsnew->mis.itemData = (DWORD)newstr;
 395   }
 396
 397   lplsnew->mis.itemID = uIndex;
 398   lplsnew->hData = hStr;
 399
 400   /* adjust the itemID field of the following entries */
 401   for(lpls = lplsnew->lpNext; lpls != NULL; lpls = lpls->lpNext) {
 402       lpls->mis.itemID++;
 403   }
 404
 405   if (lphl->needMeasure) {
 406     ListBoxAskMeasure(lphl, lplsnew);
 407   }
 408
 409   dprintf_listbox(stddeb,"ListBoxInsertString // count=%d\n", lphl->ItemsCount);
 410   return uIndex;
 411 }
 412
 413
 414 int ListBoxAddString(LPHEADLIST lphl, LPCSTR newstr)
 415 {
 416     UINT pos = (UINT) -1;
 417
 418     if (lphl->HasStrings && (lphl->dwStyle & LBS_SORT)) {
 419         LPLISTSTRUCT lpls = lphl->lpFirst;
 420         for (pos = 0; lpls != NULL; lpls = lpls->lpNext, pos++)
 421             if (strcmp(lpls->itemText, newstr) >= 0)
 422                 break;
 423     }
 424     return ListBoxInsertString(lphl, pos, newstr);
 425 }
 426
 427
 428 int ListBoxGetText(LPHEADLIST lphl, UINT uIndex, LPSTR OutStr)
 429 {
 430   LPLISTSTRUCT lpls;
 431
 432   if (!OutStr) {
 433     dprintf_listbox(stddeb, "ListBoxGetText // OutStr==NULL\n");
 434     return 0;
 435   }
 436   *OutStr = '\0';
 437   lpls = ListBoxGetItem (lphl, uIndex);
 438   if (lpls == NULL) return LB_ERR;
 439
 440   if (!lphl->HasStrings) {
 441     *((long *)OutStr) = lpls->mis.itemData;
 442     return 4;
 443   }
 444
 445   strcpy(OutStr, lpls->itemText);
 446   return strlen(OutStr);
 447 }
 448
 449
 450 DWORD ListBoxGetItemData(LPHEADLIST lphl, UINT uIndex)
 451 {
 452   LPLISTSTRUCT lpls;
 453
 454   lpls = ListBoxGetItem (lphl, uIndex);
 455   if (lpls == NULL) return LB_ERR;
 456   return lpls->mis.itemData;
 457 }
 458
 459
 460 int ListBoxSetItemData(LPHEADLIST lphl, UINT uIndex, DWORD ItemData)
 461 {
 462   LPLISTSTRUCT lpls = ListBoxGetItem(lphl, uIndex);
 463
 464   if (lpls == NULL) return LB_ERR;
 465   lpls->mis.itemData = ItemData;
 466   return 1;
 467 }
 468
 469
 470 int ListBoxDeleteString(LPHEADLIST lphl, UINT uIndex)
 471 {
 472   LPLISTSTRUCT lpls, lpls2;
 473   UINT  Count;
 474
 475   if (uIndex >= lphl->ItemsCount) return LB_ERR;
 476
 477   lpls = lphl->lpFirst;
 478   if (lpls == NULL) return LB_ERR;
 479
 480   if (uIndex == 0)
 481     lphl->lpFirst = lpls->lpNext;
 482   else {
 483     LPLISTSTRUCT lpls2 = NULL;
 484     for(Count = 0; Count < uIndex; Count++) {
 485       if (lpls->lpNext == NULL) return LB_ERR;
 486
 487       lpls2 = lpls;
 488       lpls = (LPLISTSTRUCT)lpls->lpNext;
 489     }
 490     lpls2->lpNext = lpls->lpNext;
 491   }
 492
 493   /* adjust the itemID field of the following entries */
 494   for(lpls2 = lpls->lpNext; lpls2 != NULL; lpls2 = lpls2->lpNext) {
 495       lpls2->mis.itemID--;
 496   }
 497
 498   lphl->ItemsCount--;
 499
 500   if (lpls->hData != 0) LIST_HEAP_FREE(lphl, lpls->hData);
 501   free(lpls);
 502
 503   return lphl->ItemsCount;
 504 }
 505
 506
 507 int ListBoxFindString(LPHEADLIST lphl, UINT nFirst, SEGPTR MatchStr)
 508 {
 509   LPLISTSTRUCT lpls;
 510   UINT         Count;
 511   UINT         First = nFirst + 1;
 512   LPSTR        lpMatchStr = (LPSTR)MatchStr;
 513
 514   if (First > lphl->ItemsCount) return LB_ERR;
 515
 516   if (lphl->HasStrings) lpMatchStr = PTR_SEG_TO_LIN(MatchStr);
 517
 518   lpls = ListBoxGetItem(lphl, First);
 519   Count = 0;
 520   while(lpls != NULL) {
 521     if (lphl->HasStrings) {
 522       if (strstr(lpls->itemText, lpMatchStr) == lpls->itemText) return Count;
 523     } else if (lphl->dwStyle & LBS_SORT) {
 524       /* XXX Do a compare item */
 525     }
 526     else
 527       if (lpls->mis.itemData == (DWORD)lpMatchStr) return Count;
 528
 529     lpls = lpls->lpNext;
 530     Count++;
 531   }
 532
 533   /* Start over at top */
 534   Count = 0;
 535   lpls = lphl->lpFirst;
 536
 537   while (Count < First) {
 538     if (lphl->HasStrings) {
 539       if (strstr(lpls->itemText, lpMatchStr) == lpls->itemText) return Count;
 540     } else if (lphl->dwStyle & LBS_SORT) {
 541       /* XXX Do a compare item */
 542     } else {
 543       if (lpls->mis.itemData == (DWORD)lpMatchStr) return Count;
 544     }
 545     lpls = lpls->lpNext;
 546     Count++;
 547   }
 548
 549   return LB_ERR;
 550 }
 551
 552
 553 int ListBoxResetContent(LPHEADLIST lphl)
 554 {
 555     LPLISTSTRUCT lpls;
 556     int i;
 557
 558     if (lphl->ItemsCount == 0) return 0;
 559
 560     dprintf_listbox(stddeb, "ListBoxResetContent // ItemCount = %d\n",
 561         lphl->ItemsCount);
 562
 563     for(i = 0; i < lphl->ItemsCount; i++) {
 564       lpls = lphl->lpFirst;
 565       if (lpls == NULL) return LB_ERR;
 566
 567       lphl->lpFirst = lpls->lpNext;
 568       if (lpls->hData != 0) LIST_HEAP_FREE(lphl, lpls->hData);
 569       free(lpls);
 570     }
 571     ListBoxInitialize(lphl);
 572
 573     return TRUE;
 574 }
 575
 576 /* --------------------- selection ------------------------- */
 577
 578 int ListBoxSetCurSel(LPHEADLIST lphl, WORD wIndex)
 579 {
 580   LPLISTSTRUCT lpls;
 581
 582   /* use ListBoxSetSel instead */
 583   if (lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL) ) return 0;
 584
 585   /* unselect previous item */
 586   if (lphl->ItemFocused != -1) {
 587     lphl->PrevFocused = lphl->ItemFocused;
 588     lpls = ListBoxGetItem(lphl, lphl->ItemFocused);
 589     if (lpls == 0) return LB_ERR;
 590     lpls->itemState = 0;
 591   }
 592
 593   if ((wIndex != (UINT)-1) && (wIndex < lphl->ItemsCount))
 594   {
 595     lphl->ItemFocused = wIndex;
 596     lpls = ListBoxGetItem(lphl, wIndex);
 597     if (lpls == 0) return LB_ERR;
 598     lpls->itemState = ODS_SELECTED | ODS_FOCUS;
 599
 600     return 0;
 601   }
 602
 603   return LB_ERR;
 604 }
 605
 606
 607 int ListBoxSetSel(LPHEADLIST lphl, WORD wIndex, WORD state)
 608 {
 609   LPLISTSTRUCT  lpls;
 610   int           n = 0;
 611
 612   if (!(lphl->dwStyle &  (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)  ))
 613         return LB_ERR;
 614
 615   if (wIndex == (UINT)-1) {
 616     for (lpls = lphl->lpFirst; lpls != NULL; lpls = lpls->lpNext) {
 617       if( lpls->itemState & ODS_SELECTED) n++;
 618       lpls->itemState = state? lpls->itemState |  ODS_SELECTED
 619                              : lpls->itemState & ~ODS_SELECTED;
 620     }
 621     return n;
 622   }
 623
 624   if (wIndex >= lphl->ItemsCount) return LB_ERR;
 625
 626   lpls = ListBoxGetItem(lphl, wIndex);
 627   lpls->itemState = state? lpls->itemState |  ODS_SELECTED
 628                          : lpls->itemState & ~ODS_SELECTED;
 629
 630   return 0;
 631 }
 632
 633
 634 int ListBoxGetSel(LPHEADLIST lphl, WORD wIndex)
 635 {
 636   LPLISTSTRUCT lpls = ListBoxGetItem(lphl, wIndex);
 637
 638   if (lpls == NULL) return LB_ERR;
 639   return lpls->itemState & ODS_SELECTED;
 640 }
 641
 642 /* ------------------------- dir listing ------------------------ */
 643
 644 LONG ListBoxDirectory(LPHEADLIST lphl, UINT attrib, LPCSTR filespec)
 645 {
 646     char temp[16], mask[13];
 647     char *path, *p;
 648     const char *ptr;
 649     int skip, count;
 650     LONG ret;
 651     DOS_DIRENT entry;
 652
 653     dprintf_listbox(stddeb, "ListBoxDirectory: '%s' %04x\n", filespec, attrib);
 654     if (!filespec) return LB_ERR;
 655     if (!(ptr = DOSFS_GetUnixFileName( filespec, FALSE ))) return LB_ERR;
 656     path = xstrdup(ptr);
 657     p = strrchr( path, '/' );
 658     *p++ = '\0';
 659     if (!(ptr = DOSFS_ToDosFCBFormat( p )))
 660     {
 661         free( path );
 662         return LB_ERR;
 663     }
 664     strcpy( mask, ptr );
 665
 666     dprintf_listbox(stddeb, "ListBoxDirectory: path=%s mask=%s\n", path, mask);
 667
 668     skip = ret = 0;
 669     attrib &= ~FA_LABEL;
 670     while ((count = DOSFS_FindNext( path, mask, 0, attrib, skip, &entry )) > 0)
 671     {
 672         skip += count;
 673         if (entry.attr & FA_DIRECTORY)
 674         {
 675             if ((attrib & DDL_DIRECTORY) && strcmp(entry.name, ".          "))
 676             {
 677                 sprintf(temp, "[%s]", DOSFS_ToDosDTAFormat( entry.name ) );
 678                 AnsiLower( temp );
 679                 if ((ret = ListBoxAddString(lphl, temp)) == LB_ERR) break;
 680             }
 681         }
 682         else  /* not a directory */
 683         {
 684             if (!(attrib & DDL_EXCLUSIVE) ||
 685                 ((attrib & (FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_ARCHIVE)) ==
 686                  (entry.attr & (FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_ARCHIVE))))
 687             {
 688                 strcpy( temp, DOSFS_ToDosDTAFormat( entry.name ) );
 689                 AnsiLower( temp );
 690                 if ((ret = ListBoxAddString(lphl, temp)) == LB_ERR) break;
 691             }
 692         }
 693     }
 694     if (attrib & DDL_DRIVES)
 695     {
 696         int x;
 697         strcpy( temp, "[-a-]" );
 698         for (x = 0; x < MAX_DOS_DRIVES; x++, temp[2]++)
 699         {
 700             if (DRIVE_IsValid(x))
 701                 if ((ret = ListBoxAddString(lphl, temp)) == LB_ERR) break;
 702         }
 703     }
 704     free( path );
 705     return ret;
 706 }
 707
 708 /* ------------------------- dimensions ------------------------- */
 709
 710 int ListBoxGetItemRect(LPHEADLIST lphl, WORD wIndex, LPRECT16 lprect)
 711 {
 712   LPLISTSTRUCT lpls = ListBoxGetItem(lphl,wIndex);
 713
 714   if (lpls == NULL) return LB_ERR;
 715   *lprect = lpls->itemRect;
 716   return 0;
 717 }
 718
 719
 720 int ListBoxSetItemHeight(LPHEADLIST lphl, WORD wIndex, long height)
 721 {
 722   LPLISTSTRUCT lpls;
 723
 724   if (!(lphl->dwStyle & LBS_OWNERDRAWVARIABLE)) {
 725     lphl->StdItemHeight = (short)height;
 726     return 0;
 727   }
 728
 729   lpls = ListBoxGetItem(lphl, wIndex);
 730   if (lpls == NULL) return LB_ERR;
 731
 732   lpls->mis.itemHeight = height;
 733   return 0;
 734 }
 735
 736 /* -------------------------- string search ------------------------ */
 737
 738 int ListBoxFindNextMatch(LPHEADLIST lphl, WORD wChar)
 739 {
 740   LPLISTSTRUCT lpls;
 741   UINT         count,first;
 742
 743   if ((char)wChar < ' ') return LB_ERR;
 744   if (!lphl->HasStrings) return LB_ERR;
 745
 746   lpls = lphl->lpFirst;
 747
 748   for (count = 0; lpls != NULL; lpls = lpls->lpNext, count++) {
 749     if (tolower(*lpls->itemText) == tolower((char)wChar)) break;
 750   }
 751   if (lpls == NULL) return LB_ERR;
 752   first = count;
 753   for(; lpls != NULL; lpls = lpls->lpNext, count++) {
 754     if (*lpls->itemText != (char)wChar)
 755       break;
 756     if ((short) count > lphl->ItemFocused)
 757       return count;
 758   }
 759   return first;
 760 }
 761
 762 /***********************************************************************
 763  *           LBCreate
 764  */
 765 static LONG LBCreate(HWND hwnd, WORD wParam, LONG lParam)
 766 {
 767   LPHEADLIST   lphl;
 768   LONG         dwStyle = GetWindowLong(hwnd,GWL_STYLE);
 769   RECT16 rect;
 770
 771   CreateListBoxStruct(hwnd, ODT_LISTBOX, dwStyle, GetParent(hwnd));
 772   lphl = ListBoxGetStorageHeader(hwnd);
 773   dprintf_listbox(stddeb,"ListBox created: lphl = %p dwStyle = %04x:%04x\n",
 774                           lphl, HIWORD(dwStyle), LOWORD(dwStyle));
 775
 776   GetClientRect16(hwnd,&rect);
 777   lphl->ColumnsWidth = rect.right - rect.left;
 778
 779   if (dwStyle & WS_VSCROLL)
 780     SetScrollRange(hwnd, SB_VERT, 0, ListMaxFirstVisible(lphl), TRUE);
 781   if (dwStyle & WS_HSCROLL)
 782     SetScrollRange(hwnd, SB_HORZ, 1, 1, TRUE);
 783
 784   return 0;
 785 }
 786
 787
 788 /***********************************************************************
 789  *           LBDestroy
 790  */
 791 static LONG LBDestroy(HWND hwnd, WORD wParam, LONG lParam)
 792 {
 793   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
 794
 795   ListBoxResetContent(lphl);
 796
 797   DestroyListBoxStruct(lphl);
 798   dprintf_listbox(stddeb,"ListBox destroyed: lphl = %p\n",lphl);
 799   return 0;
 800 }
 801
 802 /***********************************************************************
 803  *           LBVScroll
 804  */
 805 static LONG LBVScroll(HWND hwnd, WORD wParam, LONG lParam)
 806 {
 807   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
 808   int  y;
 809
 810   dprintf_listbox(stddeb,"ListBox WM_VSCROLL w=%04X l=%08lX !\n",
 811                   wParam, lParam);
 812   y = lphl->FirstVisible;
 813
 814   switch(wParam) {
 815   case SB_LINEUP:
 816     if (lphl->FirstVisible > 0)
 817       lphl->FirstVisible--;
 818     break;
 819
 820   case SB_LINEDOWN:
 821     lphl->FirstVisible++;
 822     break;
 823
 824   case SB_PAGEUP:
 825     if (lphl->FirstVisible > lphl->ItemsVisible) {
 826       lphl->FirstVisible -= lphl->ItemsVisible;
 827     } else {
 828       lphl->FirstVisible = 0;
 829     }
 830     break;
 831
 832   case SB_PAGEDOWN:
 833     lphl->FirstVisible += lphl->ItemsVisible;
 834     break;
 835
 836   case SB_THUMBTRACK:
 837     lphl->FirstVisible = LOWORD(lParam);
 838     break;
 839   }
 840
 841   if (lphl->FirstVisible > ListMaxFirstVisible(lphl))
 842     lphl->FirstVisible = ListMaxFirstVisible(lphl);
 843
 844   if (y != lphl->FirstVisible) {
 845     SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
 846     InvalidateRect32( hwnd, NULL, TRUE );
 847   }
 848   return 0;
 849 }
 850
 851 /***********************************************************************
 852  *           LBHScroll
 853  */
 854 static LONG LBHScroll(HWND hwnd, WORD wParam, LONG lParam)
 855 {
 856   LPHEADLIST lphl;
 857   int        y;
 858
 859   dprintf_listbox(stddeb,"ListBox WM_HSCROLL w=%04X l=%08lX !\n",
 860                   wParam, lParam);
 861   lphl = ListBoxGetStorageHeader(hwnd);
 862   y = lphl->FirstVisible;
 863   switch(wParam) {
 864   case SB_LINEUP:
 865     if (lphl->FirstVisible > lphl->ItemsPerColumn) {
 866       lphl->FirstVisible -= lphl->ItemsPerColumn;
 867     } else {
 868       lphl->FirstVisible = 0;
 869     }
 870     break;
 871   case SB_LINEDOWN:
 872     lphl->FirstVisible += lphl->ItemsPerColumn;
 873     break;
 874   case SB_PAGEUP:
 875     if (lphl->ItemsPerColumn != 0) {
 876       int lbsub = lphl->ItemsVisible / lphl->ItemsPerColumn * lphl->ItemsPerColumn;
 877       if (lphl->FirstVisible > lbsub) {
 878         lphl->FirstVisible -= lbsub;
 879       } else {
 880         lphl->FirstVisible = 0;
 881       }
 882     }
 883     break;
 884   case SB_PAGEDOWN:
 885     if (lphl->ItemsPerColumn != 0)
 886       lphl->FirstVisible += lphl->ItemsVisible /
 887         lphl->ItemsPerColumn * lphl->ItemsPerColumn;
 888     break;
 889   case SB_THUMBTRACK:
 890     lphl->FirstVisible = lphl->ItemsPerColumn * LOWORD(lParam);
 891     break;
 892   }
 893   if (lphl->FirstVisible > ListMaxFirstVisible(lphl))
 894     lphl->FirstVisible = ListMaxFirstVisible(lphl);
 895
 896   if (lphl->ItemsPerColumn != 0) {
 897     lphl->FirstVisible = lphl->FirstVisible /
 898       lphl->ItemsPerColumn * lphl->ItemsPerColumn + 1;
 899     if (y != lphl->FirstVisible) {
 900       SetScrollPos(hwnd, SB_HORZ, lphl->FirstVisible /
 901                    lphl->ItemsPerColumn + 1, TRUE);
 902       InvalidateRect32( hwnd, NULL, TRUE );
 903     }
 904   }
 905   return 0;
 906 }
 907
 908 /***********************************************************************
 909  *           LBLButtonDown
 910  */
 911 static LONG LBLButtonDown(HWND hwnd, WORD wParam, LONG lParam)
 912 {
 913   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
 914   WORD       wRet;
 915   int        y,n;
 916   RECT16     rectsel;
 917
 918   SetFocus(hwnd);
 919   SetCapture(hwnd);
 920
 921   lphl->PrevFocused = lphl->ItemFocused;
 922
 923   y = ListBoxFindMouse(lphl, LOWORD(lParam), HIWORD(lParam));
 924
 925   if (y == -1) return 0;
 926
 927   if (lphl->dwStyle & LBS_NOTIFY && y!= LB_ERR )
 928      if( SendMessage16(lphl->hParent, WM_LBTRACKPOINT, y, lParam) )
 929          return 0;
 930
 931
 932   switch( lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL) )
 933    {
 934         case LBS_MULTIPLESEL:
 935                 lphl->ItemFocused = y;
 936                 wRet = ListBoxGetSel(lphl, y);
 937                 ListBoxSetSel(lphl, y, !wRet);
 938                 break;
 939         case LBS_EXTENDEDSEL:
 940                 /* should handle extended mode here and in kbd handler
 941                  */
 942
 943                 if ( lphl->PrevFocused != y && y!= LB_ERR)
 944                  {
 945                    LPLISTSTRUCT lpls = ListBoxGetItem( lphl, lphl->ItemFocused = y );
 946                    n = ListBoxSetSel(lphl,-1,FALSE);
 947
 948                    lpls->itemState = ODS_FOCUS | ODS_SELECTED;
 949
 950                    if( n > 1 && n != LB_ERR )
 951                      InvalidateRect32( hwnd,NULL,TRUE );
 952                  }
 953                 else
 954                        return 0;
 955
 956                 break;
 957         case 0:
 958                 if( y!=lphl->ItemFocused )
 959                   ListBoxSetCurSel(lphl, y);
 960                 else
 961                   return 0;
 962                 break;
 963         default:
 964                 fprintf(stdnimp,"Listbox: LBS_MULTIPLESEL and LBS_EXTENDEDSEL are on!\n");
 965                 return 0;
 966    }
 967
 968  /* invalidate changed items */
 969  if( lphl->dwStyle & LBS_MULTIPLESEL || y!=lphl->PrevFocused )
 970    {
 971      ListBoxGetItemRect(lphl, y, &rectsel);
 972      InvalidateRect16( hwnd, &rectsel, TRUE );
 973    }
 974  if( lphl->PrevFocused!=-1 && y!=lphl->PrevFocused )
 975    {
 976      ListBoxGetItemRect(lphl, lphl->PrevFocused, &rectsel);
 977      InvalidateRect16( hwnd, &rectsel, TRUE );
 978    }
 979
 980 #ifndef WINELIB
 981   if (GetWindowLong(lphl->hSelf,GWL_EXSTYLE) & WS_EX_DRAGDETECT)
 982      if( DragDetect(lphl->hSelf,MAKEPOINT16(lParam)) )
 983          SendMessage16(lphl->hParent, WM_BEGINDRAG,0,0L);
 984 #endif
 985   return 0;
 986 }
 987
 988 /***********************************************************************
 989  *           LBLButtonUp
 990  */
 991 static LONG LBLButtonUp(HWND hwnd, WORD wParam, LONG lParam)
 992 {
 993   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
 994
 995   if (GetCapture() == hwnd) ReleaseCapture();
 996
 997   if (lphl->PrevFocused != lphl->ItemFocused)
 998     ListBoxSendNotification(lphl, LBN_SELCHANGE);
 999
1000   return 0;
1001 }
1002
1003 /***********************************************************************
1004  *           LBRButtonUp
1005  */
1006 static LONG LBRButtonUp(HWND hwnd, WORD wParam, LONG lParam)
1007 {
1008   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1009
1010 #ifdef WINELIB32
1011   SendMessage32A(lphl->hParent, WM_COMMAND,
1012                  MAKEWPARAM(GetWindowWord(hwnd,GWW_ID),LBN_DBLCLK),
1013                  (LPARAM)hwnd);
1014 #else
1015   SendMessage16(lphl->hParent, WM_COMMAND, GetWindowWord(hwnd,GWW_ID),
1016                 MAKELONG(hwnd, LBN_DBLCLK));
1017 #endif
1018
1019   return 0;
1020 }
1021
1022 /***********************************************************************
1023  *           LBMouseMove
1024  */
1025 static LONG LBMouseMove(HWND hwnd, WORD wParam, LONG lParam)
1026 {
1027   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1028   int  y,redraw_prev = 0;
1029   int  iRet;
1030   RECT16 rect, rectsel;   /* XXX Broken */
1031
1032   dprintf_listbox(stddeb,"LBMouseMove %d %d\n",SLOWORD(lParam),SHIWORD(lParam));
1033   if ((wParam & MK_LBUTTON) != 0) {
1034     y = SHIWORD(lParam);
1035     if (y < LBMM_EDGE) {
1036       if (lphl->FirstVisible > 0) {
1037         lphl->FirstVisible--;
1038         SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1039         InvalidateRect32( hwnd, NULL, TRUE );
1040         return 0;
1041       }
1042     }
1043     GetClientRect16(hwnd, &rect);
1044     if (y >= (rect.bottom-LBMM_EDGE)) {
1045       if (lphl->FirstVisible < ListMaxFirstVisible(lphl)) {
1046         lphl->FirstVisible++;
1047         SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1048         InvalidateRect32( hwnd, NULL, TRUE );
1049         return 0;
1050       }
1051       }
1052     if ((y > 0) && (y < (rect.bottom - LBMM_EDGE))) {
1053       if ((y < rectsel.top) || (y > rectsel.bottom)) {
1054         iRet = ListBoxFindMouse(lphl, LOWORD(lParam), HIWORD(lParam));
1055         if (iRet == lphl->ItemFocused || iRet == -1)  {
1056           return 0;
1057         }
1058         if (lphl->dwStyle & LBS_MULTIPLESEL) {
1059           lphl->ItemFocused = iRet;
1060           ListBoxSendNotification(lphl, LBN_SELCHANGE);
1061         } else if ( lphl->dwStyle & LBS_EXTENDEDSEL )
1062                   {
1063                      /* Fixme: extended selection mode */
1064                      ListBoxSetSel( lphl, lphl->ItemFocused, 0);
1065                      lphl->PrevFocused = lphl->ItemFocused;
1066                      lphl->ItemFocused = iRet;
1067                      ListBoxSetSel( lphl, iRet, TRUE);
1068                      redraw_prev = 1;
1069                   }
1070                else
1071                   {
1072                      ListBoxSetCurSel(lphl, (WORD)iRet);
1073                      redraw_prev = 1;
1074                   }
1075         if( lphl->PrevFocused!=-1 && redraw_prev )
1076           {
1077             ListBoxGetItemRect(lphl, lphl->PrevFocused, &rectsel);
1078             InvalidateRect16( hwnd, &rectsel, TRUE );
1079           }
1080         ListBoxGetItemRect(lphl, iRet, &rectsel);
1081         InvalidateRect16( hwnd, &rectsel, TRUE );
1082       }
1083     }
1084   }
1085
1086   return 0;
1087   }
1088
1089 /***********************************************************************
1090  *           LBKeyDown
1091  *
1092  * Doesn't yet handle properly VK_SHIFT with LB_EXTENDEDSEL
1093  */
1094 static LONG LBKeyDown(HWND hwnd, WORD wParam, LONG lParam)
1095 {
1096   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1097   WORD       newFocused = 0xFFFF;
1098   RECT16     rect;
1099
1100   ListBoxGetItemRect(lphl,lphl->ItemFocused,&rect);
1101   switch(wParam)
1102     {
1103         case VK_HOME:
1104         case VK_END:
1105         case VK_LEFT:
1106         case VK_RIGHT:
1107         case VK_UP:
1108         case VK_DOWN:
1109         case VK_PRIOR:
1110         case VK_NEXT:
1111              if ( lphl->dwStyle & LBS_WANTKEYBOARDINPUT )
1112                 {
1113                   newFocused = (WORD)(INT)SendMessage16(lphl->hParent,WM_VKEYTOITEM,
1114                                                         wParam,MAKELPARAM(lphl->ItemFocused,hwnd));
1115                   if ( newFocused == 0xFFFE ) return 0L;
1116                 }
1117              if ( newFocused == 0xFFFF )
1118                 {
1119                   newFocused = lphl->ItemFocused;
1120
1121                   /* nested switch */
1122                   switch(wParam)
1123                     {
1124                         case VK_HOME:
1125                           newFocused = 0;
1126                           break;
1127                         case VK_END:
1128                           newFocused = lphl->ItemsCount - 1;
1129                           break;
1130                         case VK_LEFT:
1131                           if (lphl->dwStyle & LBS_MULTICOLUMN) {
1132                             if (newFocused >= lphl->ItemsPerColumn) {
1133                                 newFocused -= lphl->ItemsPerColumn;
1134                             } else {
1135                                 newFocused = 0;
1136                             }
1137                           }
1138                           break;
1139                         case VK_UP:
1140                           if (newFocused > 0) newFocused--;
1141                           break;
1142                         case VK_RIGHT:
1143                           if (lphl->dwStyle & LBS_MULTICOLUMN)
1144                              newFocused += lphl->ItemsPerColumn;
1145                           break;
1146                         case VK_DOWN:
1147                           newFocused++;
1148                           break;
1149                         case VK_PRIOR:
1150                           if (newFocused > lphl->ItemsVisible)
1151                               newFocused -= lphl->ItemsVisible;
1152                             else  newFocused = 0;
1153                             break;
1154                         case VK_NEXT:
1155                           newFocused += lphl->ItemsVisible;
1156                           break;
1157                         default:
1158                           return 0;
1159                     }
1160                   /* end of nested switch */
1161                 }
1162              break;
1163         case VK_SPACE:
1164              if (lphl->dwStyle & LBS_MULTIPLESEL)
1165                 {
1166                  WORD wRet = ListBoxGetSel(lphl, lphl->ItemFocused);
1167                  ListBoxSetSel(lphl, lphl->ItemFocused, !wRet);
1168                  }
1169              return 0;
1170
1171         /* chars are handled in LBChar */
1172         default:
1173              return 0;
1174     }
1175
1176   /* at this point newFocused is set up */
1177
1178   if (newFocused >= lphl->ItemsCount)
1179     newFocused = lphl->ItemsCount - 1;
1180
1181   if (!(lphl->dwStyle & LBS_MULTIPLESEL))
1182      {
1183         ListBoxSetCurSel(lphl, newFocused);
1184         ListBoxSendNotification(lphl, LBN_SELCHANGE);
1185      }
1186
1187   lphl->ItemFocused = newFocused;
1188
1189   if( ListBoxScrollToFocus(lphl) || (lphl->dwStyle &
1190                           (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) )
1191   InvalidateRect32( hwnd, NULL, TRUE );
1192   else
1193     {
1194         InvalidateRect16( hwnd, &rect, TRUE );
1195         if( newFocused < 0x8000 )
1196           {
1197            ListBoxGetItemRect(lphl, newFocused, &rect);
1198            InvalidateRect16( hwnd, &rect, TRUE );
1199           }
1200     }
1201
1202   SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1203
1204   return 0;
1205 }
1206
1207 /***********************************************************************
1208  *           LBChar
1209  */
1210 static LONG LBChar(HWND hwnd, WORD wParam, LONG lParam)
1211 {
1212   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1213   WORD       newFocused = 0xFFFF;
1214
1215   if ( (lphl->dwStyle & LBS_WANTKEYBOARDINPUT) && !(lphl->HasStrings))
1216        {
1217         newFocused = (WORD)(INT)SendMessage16(lphl->hParent,WM_CHARTOITEM,
1218                                               wParam,MAKELPARAM(lphl->ItemFocused,hwnd));
1219         if ( newFocused == 0xFFFE ) return 0L;
1220        }
1221
1222   if (newFocused == 0xFFFF )
1223   newFocused = ListBoxFindNextMatch(lphl, wParam);
1224
1225   if (newFocused == (WORD)LB_ERR) return 0;
1226
1227   if (newFocused >= lphl->ItemsCount)
1228     newFocused = lphl->ItemsCount - 1;
1229
1230   if (!(lphl->dwStyle & LBS_MULTIPLESEL))
1231      {
1232     ListBoxSetCurSel(lphl, newFocused);
1233         ListBoxSendNotification(lphl, LBN_SELCHANGE);
1234   }
1235
1236   lphl->ItemFocused = newFocused;
1237   ListBoxScrollToFocus(lphl);
1238   SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1239
1240   InvalidateRect32( hwnd, NULL, TRUE );
1241
1242   return 0;
1243 }
1244
1245 /***********************************************************************
1246  *           LBSetRedraw
1247  */
1248 static LONG LBSetRedraw(HWND hwnd, WORD wParam, LONG lParam)
1249 {
1250   LPHEADLIST  lphl = ListBoxGetStorageHeader(hwnd);
1251
1252   dprintf_listbox(stddeb,"ListBox WM_SETREDRAW hWnd=%04x w=%04x !\n",
1253                   hwnd, wParam);
1254   lphl->bRedrawFlag = wParam;
1255
1256   return 0;
1257 }
1258
1259 /***********************************************************************
1260  *           LBSetFont
1261  */
1262 static LONG LBSetFont(HWND hwnd, WPARAM wParam, LPARAM lParam)
1263 {
1264   LPHEADLIST  lphl = ListBoxGetStorageHeader(hwnd);
1265   HDC hdc;
1266
1267   if (wParam == 0)
1268     lphl->hFont = GetStockObject(SYSTEM_FONT);
1269   else
1270     lphl->hFont = (HFONT) wParam;
1271
1272   /* a new font means possible new text height */
1273   /* does this mean the height of each entry must be separately changed? */
1274   /* or are we guaranteed to get a LBSetFont before the first insert/add? */
1275   if ((hdc = GetDC(0)))
1276   {
1277       TEXTMETRIC tm;
1278       GetTextMetrics( hdc, &tm );
1279       lphl->StdItemHeight = tm.tmHeight;
1280       dprintf_listbox(stddeb,"LBSetFont:  new font %d with height %d\n",
1281                       lphl->hFont, lphl->StdItemHeight);
1282       ReleaseDC( 0, hdc );
1283   }
1284
1285   return 0;
1286 }
1287
1288 /***********************************************************************
1289  *           LBPaint
1290  */
1291 static LONG LBPaint(HWND hwnd, WORD wParam, LONG lParam)
1292 {
1293   LPHEADLIST   lphl = ListBoxGetStorageHeader(hwnd);
1294   LPLISTSTRUCT lpls;
1295   PAINTSTRUCT16 ps;
1296   HBRUSH       hBrush;
1297   HFONT        hOldFont;
1298   HDC16 hdc    = BeginPaint16( hwnd, &ps );
1299   DC    *dc    = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
1300   RECT16  rect, paintRect, scratchRect;
1301   int   i, top, height, maxwidth, ipc;
1302
1303   top = 0;
1304
1305   if (!IsWindowVisible(hwnd) || !lphl->bRedrawFlag) {
1306     EndPaint16(hwnd, &ps);
1307     return 0;
1308   }
1309
1310   GetRgnBox16(dc->w.hGCClipRgn,&paintRect);
1311   GetClientRect16(hwnd, &rect);
1312   IntersectRect16(&paintRect,&rect,&paintRect);
1313
1314   hOldFont = SelectObject(hdc, lphl->hFont);
1315
1316 #ifdef WINELIB32
1317   hBrush = (HBRUSH) SendMessage16(lphl->hParent, WM_CTLCOLORLISTBOX, (WPARAM)hdc,
1318                                   (LPARAM)hwnd);
1319 #else
1320   hBrush = SendMessage16(lphl->hParent, WM_CTLCOLOR, hdc,
1321                          MAKELONG(hwnd, CTLCOLOR_LISTBOX));
1322 #endif
1323
1324   if (hBrush == 0) hBrush = GetStockObject(WHITE_BRUSH);
1325
1326   FillRect16(hdc, &rect, hBrush);
1327
1328   maxwidth = rect.right;
1329   if (lphl->dwStyle & LBS_MULTICOLUMN) {
1330     rect.right = lphl->ColumnsWidth;
1331   }
1332   lpls = lphl->lpFirst;
1333
1334   lphl->ItemsVisible = 0;
1335   lphl->ItemsPerColumn = ipc = 0;
1336
1337   for(i = 0; i < lphl->ItemsCount; i++) {
1338     if (lpls == NULL) break;
1339
1340     if (i >= lphl->FirstVisible) {
1341       height = lpls->mis.itemHeight;
1342
1343       if (top > (rect.bottom-height+1)) {
1344         if (lphl->dwStyle & LBS_MULTICOLUMN) {
1345           lphl->ItemsPerColumn = MAX(lphl->ItemsPerColumn, ipc);
1346           ipc = 0;
1347           top = 0;
1348           rect.left += lphl->ColumnsWidth;
1349           rect.right += lphl->ColumnsWidth;
1350           if (rect.left > maxwidth) break;
1351         } else {
1352           break;
1353         }
1354       }
1355
1356       lpls->itemRect.top    = top;
1357       lpls->itemRect.bottom = top + height;
1358       lpls->itemRect.left   = rect.left;
1359       lpls->itemRect.right  = rect.right;
1360
1361       if( IntersectRect16(&scratchRect,&paintRect,&lpls->itemRect) )
1362        {
1363         dprintf_listbox(stddeb,"LBPaint: drawing item: %d %d %d %d %d\n",
1364                         rect.left,top,rect.right,top+height,lpls->itemState);
1365
1366         if (lphl->OwnerDrawn && (lphl->ItemFocused == i) && GetFocus() == hwnd)
1367            {
1368              ListBoxDrawItem (hwnd, lphl, hdc, lpls, &lpls->itemRect, ODA_FOCUS,
1369                                                       lpls->itemState & ~ODS_FOCUS);
1370              ListBoxDrawItem (hwnd, lphl, hdc, lpls, &lpls->itemRect, ODA_DRAWENTIRE,
1371                                                       lpls->itemState & ~ODS_FOCUS);
1372              ListBoxDrawItem (hwnd, lphl, hdc, lpls, &lpls->itemRect, ODA_FOCUS, lpls->itemState);
1373            }
1374         else
1375             ListBoxDrawItem (hwnd, lphl, hdc, lpls, &lpls->itemRect, ODA_DRAWENTIRE,
1376                                                      lpls->itemState);
1377        }
1378
1379       top += height;
1380       lphl->ItemsVisible++;
1381       ipc++;
1382     }
1383
1384     lpls = lpls->lpNext;
1385   }
1386   ListBoxUpdateWindow(hwnd,lphl,FALSE);
1387   SelectObject(hdc,hOldFont);
1388   EndPaint16( hwnd, &ps );
1389   return 0;
1390 }
1391
1392 /***********************************************************************
1393  *           LBSetFocus
1394  */
1395 static LONG LBSetFocus(HWND hwnd, WORD wParam, LONG lParam)
1396 {
1397   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1398
1399   dprintf_listbox(stddeb,"ListBox WM_SETFOCUS for %04x\n",hwnd);
1400   if(!(lphl->dwStyle & LBS_MULTIPLESEL) )
1401        if( lphl->ItemsCount && lphl->ItemFocused != -1)
1402          {
1403            HDC          hDC = GetDC(hwnd);
1404            HFONT        hOldFont = SelectObject(hDC, lphl->hFont);
1405            LPLISTSTRUCT lpls;
1406
1407            lpls = ListBoxGetItem(lphl,lphl->ItemFocused);
1408            lpls->itemState |= ODS_FOCUS;
1409
1410            ListBoxDrawItem(hwnd,lphl,hDC,lpls,&lpls->itemRect, ODA_FOCUS, lpls->itemState);
1411            SelectObject(hDC, hOldFont);
1412            ReleaseDC(hwnd,hDC);
1413          }
1414
1415   ListBoxSendNotification(lphl, LBN_SETFOCUS);
1416
1417   return 0;
1418 }
1419
1420 /***********************************************************************
1421  *           LBKillFocus
1422  */
1423 static LONG LBKillFocus(HWND hwnd, WORD wParam, LONG lParam)
1424 {
1425   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1426
1427   dprintf_listbox(stddeb,"ListBox WM_KILLFOCUS for %04x\n",hwnd);
1428   if (!(lphl->dwStyle & LBS_MULTIPLESEL))
1429      {
1430        if( lphl->ItemsCount )
1431            if( lphl->ItemFocused != -1 )
1432              {
1433               HDC          hDC = GetDC(hwnd);
1434               HFONT        hOldFont = SelectObject(hDC, lphl->hFont);
1435               LPLISTSTRUCT lpls;
1436
1437               lpls = ListBoxGetItem(lphl,lphl->ItemFocused);
1438               lpls->itemState &= ~ODS_FOCUS;
1439
1440               ListBoxDrawItem(hwnd,lphl,hDC,lpls,&lpls->itemRect, ODA_FOCUS, lpls->itemState);
1441               SelectObject(hDC, hOldFont);
1442               ReleaseDC(hwnd,hDC);
1443              }
1444            else
1445              dprintf_listbox(stddeb,"LBKillFocus: no focused item!\n");
1446      }
1447   else
1448      InvalidateRect32( hwnd, NULL, TRUE );
1449
1450   ListBoxSendNotification(lphl, LBN_KILLFOCUS);
1451
1452   return 0;
1453 }
1454
1455 /***********************************************************************
1456  *           LBResetContent
1457  */
1458 static LONG LBResetContent(HWND hwnd, WORD wParam, LONG lParam)
1459 {
1460   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1461
1462   dprintf_listbox(stddeb,"ListBox LB_RESETCONTENT !\n");
1463   ListBoxResetContent(lphl);
1464   ListBoxUpdateWindow(hwnd, lphl, TRUE);
1465   return 0;
1466 }
1467
1468 /***********************************************************************
1469  *           LBDir
1470  */
1471 static LONG LBDir(HWND hwnd, WORD wParam, LONG lParam)
1472 {
1473     LONG ret;
1474     LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1475     dprintf_listbox(stddeb,"ListBox LB_DIR !\n");
1476
1477     ret = ListBoxDirectory(lphl, wParam, (LPSTR)PTR_SEG_TO_LIN(lParam));
1478     ListBoxUpdateWindow(hwnd, lphl, TRUE);
1479     return ret;
1480 }
1481
1482 /***********************************************************************
1483  *           LBAddString
1484  */
1485 static LONG LBAddString(HWND hwnd, WORD wParam, LONG lParam)
1486 {
1487   WORD  wRet;
1488   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1489
1490   if (lphl->HasStrings)
1491     wRet = ListBoxAddString(lphl, (LPCSTR)PTR_SEG_TO_LIN(lParam));
1492   else
1493     wRet = ListBoxAddString(lphl, (LPCSTR)lParam);
1494
1495   ListBoxUpdateWindow(hwnd,lphl,TRUE);
1496   return wRet;
1497 }
1498
1499 /***********************************************************************
1500  *           LBGetText
1501  */
1502 static LONG LBGetText(HWND hwnd, WORD wParam, LONG lParam)
1503 {
1504   LONG   wRet;
1505   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1506
1507   dprintf_listbox(stddeb, "LB_GETTEXT  wParam=%d\n",wParam);
1508   wRet = ListBoxGetText(lphl, wParam, (LPSTR)PTR_SEG_TO_LIN(lParam));
1509
1510   return wRet;
1511 }
1512
1513 /***********************************************************************
1514  *           LBInsertString
1515  */
1516 static LONG LBInsertString(HWND hwnd, WORD wParam, LONG lParam)
1517 {
1518   WORD  wRet;
1519   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1520
1521   if (lphl->HasStrings)
1522     wRet = ListBoxInsertString(lphl, wParam, (LPCSTR)PTR_SEG_TO_LIN(lParam));
1523   else
1524     wRet = ListBoxInsertString(lphl, wParam, (LPCSTR)lParam);
1525
1526   ListBoxUpdateWindow(hwnd,lphl,TRUE);
1527   return wRet;
1528 }
1529
1530 /***********************************************************************
1531  *           LBDeleteString
1532  */
1533 static LONG LBDeleteString(HWND hwnd, WORD wParam, LONG lParam)
1534 {
1535   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1536   LONG lRet = ListBoxDeleteString(lphl,wParam);
1537
1538   ListBoxUpdateWindow(hwnd,lphl,TRUE);
1539   return lRet;
1540 }
1541
1542 /***********************************************************************
1543  *           LBFindString
1544  */
1545 static LONG LBFindString(HWND hwnd, WORD wParam, LONG lParam)
1546 {
1547   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1548   return ListBoxFindString(lphl, wParam, (SEGPTR)lParam);
1549 }
1550
1551 /***********************************************************************
1552  *           LBGetCaretIndex
1553  */
1554 static LONG LBGetCaretIndex(HWND hwnd, WORD wParam, LONG lParam)
1555 {
1556   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1557   return lphl->ItemFocused;
1558 }
1559
1560 /***********************************************************************
1561  *           LBGetCount
1562  */
1563 static LONG LBGetCount(HWND hwnd, WORD wParam, LONG lParam)
1564 {
1565   LPHEADLIST  lphl;
1566
1567   lphl = ListBoxGetStorageHeader(hwnd);
1568   return lphl->ItemsCount;
1569 }
1570
1571 /***********************************************************************
1572  *           LBGetCurSel
1573  */
1574 static LONG LBGetCurSel(HWND hwnd, WORD wParam, LONG lParam)
1575 {
1576   LPHEADLIST  lphl;
1577
1578   lphl = ListBoxGetStorageHeader(hwnd);
1579   dprintf_listbox(stddeb,"ListBox LB_GETCURSEL %i !\n",
1580                   lphl->ItemFocused);
1581   return lphl->ItemFocused;
1582 }
1583
1584 /***********************************************************************
1585  *           LBGetHorizontalExtent
1586  */
1587 static LONG LBGetHorizontalExtent(HWND hwnd, WORD wParam, LONG lParam)
1588 {
1589   return 0;
1590 }
1591
1592 /***********************************************************************
1593  *           LBGetItemHeight
1594  */
1595 static LONG LBGetItemHeight(HWND hwnd, WORD wParam, LONG lParam)
1596 {
1597   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1598   LPLISTSTRUCT lpls = ListBoxGetItem (lphl, wParam);
1599
1600   if (lpls == NULL) return LB_ERR;
1601   return lpls->mis.itemHeight;
1602 }
1603
1604 /***********************************************************************
1605  *           LBGetItemRect
1606  */
1607 static LONG LBGetItemRect(HWND hwnd, WORD wParam, LONG lParam)
1608 {
1609   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1610   return ListBoxGetItemRect(lphl, wParam, PTR_SEG_TO_LIN(lParam));
1611 }
1612
1613 /***********************************************************************
1614  *           LBGetSel
1615  */
1616 static LONG LBGetSel(HWND hwnd, WORD wParam, LONG lParam)
1617 {
1618   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1619   int        iSel = ListBoxGetSel(lphl, wParam);
1620
1621   dprintf_listbox(stdnimp,"LBGetSel: item %u - %i\n",wParam,iSel);
1622
1623   return (iSel)? 1 : 0;
1624 }
1625
1626 /***********************************************************************
1627  *           LBGetSelCount
1628  */
1629 static LONG LBGetSelCount(HWND hwnd, WORD wParam, LONG lParam)
1630 {
1631   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1632   LPLISTSTRUCT lpls;
1633   int          cnt = 0;
1634   int          items = 0;
1635
1636   if (!(lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)  ))
1637          return LB_ERR;
1638
1639   for( lpls = lphl->lpFirst;
1640        lpls;
1641        lpls = lpls->lpNext )
1642         {
1643            items++;
1644            if (lpls->itemState )
1645                cnt++;
1646   }
1647
1648   return cnt;
1649 }
1650
1651 /***********************************************************************
1652  *           LBGetSelItems
1653  */
1654 static LONG LBGetSelItems(HWND hwnd, WORD wParam, LONG lParam)
1655 {
1656   LPHEADLIST  lphl = ListBoxGetStorageHeader(hwnd);
1657   LPLISTSTRUCT lpls;
1658   int cnt, idx;
1659   int *lpItems = PTR_SEG_TO_LIN(lParam);
1660
1661   if (!(lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)  ))
1662         return LB_ERR;
1663
1664   if (wParam == 0) return 0;
1665
1666   lpls = lphl->lpFirst;
1667   cnt = 0; idx = 0;
1668
1669   while (lpls != NULL) {
1670     if (lpls->itemState > 0) lpItems[cnt++] = idx;
1671
1672     if (cnt == wParam) break;
1673     idx++;
1674     lpls = lpls->lpNext;
1675   }
1676
1677   return cnt;
1678 }
1679
1680 /***********************************************************************
1681  *           LBGetTextLen
1682  */
1683 static LONG LBGetTextLen(HWND hwnd, WORD wParam, LONG lParam)
1684 {
1685   LPHEADLIST   lphl = ListBoxGetStorageHeader(hwnd);
1686   LPLISTSTRUCT lpls = ListBoxGetItem(lphl,wParam);
1687
1688   if (lpls == NULL || !lphl->HasStrings) return LB_ERR;
1689   return strlen(lpls->itemText);
1690 }
1691
1692 /***********************************************************************
1693  *           LBGetDlgCode
1694  */
1695 static LONG LBGetDlgCode(HWND hwnd, WORD wParam, LONG lParam)
1696 {
1697   return DLGC_WANTARROWS | DLGC_WANTCHARS;
1698 }
1699
1700 /***********************************************************************
1701  *           LBGetTopIndex
1702  */
1703 static LONG LBGetTopIndex(HWND hwnd, WORD wParam, LONG lParam)
1704 {
1705   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1706
1707   return lphl->FirstVisible;
1708 }
1709
1710
1711 /***********************************************************************
1712  *           LBSelectString
1713  */
1714 static LONG LBSelectString(HWND hwnd, WORD wParam, LONG lParam)
1715 {
1716   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1717   INT  iRet;
1718
1719   iRet = ListBoxFindString(lphl, wParam, (SEGPTR)lParam);
1720
1721   if( iRet != LB_ERR)
1722     {
1723       if( lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL) )
1724          ListBoxSetSel(lphl,iRet,TRUE);
1725       else
1726          ListBoxSetCurSel(lphl,iRet);
1727
1728       lphl->ItemFocused = iRet;
1729       InvalidateRect32( hwnd, 0, TRUE );
1730     }
1731   return iRet;
1732 }
1733
1734 /***********************************************************************
1735  *           LBSelItemRange
1736  */
1737 static LONG LBSelItemRange(HWND hwnd, WORD wParam, LONG lParam)
1738 {
1739   LPHEADLIST   lphl = ListBoxGetStorageHeader(hwnd);
1740   LPLISTSTRUCT lpls;
1741   WORD         cnt;
1742   WORD         first = LOWORD(lParam);
1743   WORD         last = HIWORD(lParam);
1744   BOOL         select = wParam;
1745
1746   if (!(lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)  ))
1747         return LB_ERR;
1748
1749   if (first >= lphl->ItemsCount ||
1750       last >= lphl->ItemsCount) return LB_ERR;
1751
1752   lpls = lphl->lpFirst;
1753   cnt = 0;
1754
1755   while (lpls != NULL) {
1756     if (cnt++ >= first)
1757       lpls->itemState = select ? lpls->itemState | ODS_SELECTED : 0;
1758
1759     if (cnt > last)
1760       break;
1761
1762     lpls = lpls->lpNext;
1763   }
1764
1765   return 0;
1766 }
1767
1768 /***********************************************************************
1769  *           LBSetCaretIndex
1770  */
1771 static LONG LBSetCaretIndex(HWND hwnd, WORD wParam, LONG lParam)
1772 {
1773   LPHEADLIST   lphl = ListBoxGetStorageHeader(hwnd);
1774   int          i;
1775
1776   if (!(lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL) )) return 0;
1777
1778   dprintf_listbox(stddeb,"LBSetCaretIndex: hwnd %04x n=%i\n",hwnd,wParam);
1779
1780   if (wParam >= lphl->ItemsCount) return LB_ERR;
1781
1782   lphl->ItemFocused = wParam;
1783   i = ListBoxScrollToFocus (lphl);
1784
1785   SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1786   if(i)
1787     InvalidateRect32( hwnd, NULL, TRUE );
1788
1789   return 1;
1790 }
1791
1792 /***********************************************************************
1793  *           LBSetColumnWidth
1794  */
1795 static LONG LBSetColumnWidth(HWND hwnd, WORD wParam, LONG lParam)
1796 {
1797   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1798   lphl->ColumnsWidth = wParam;
1799   InvalidateRect32( hwnd, NULL, TRUE );
1800   return 0;
1801 }
1802
1803 /***********************************************************************
1804  *           LBSetHorizontalExtent
1805  */
1806 static LONG LBSetHorizontalExtent(HWND hwnd, WORD wParam, LONG lParam)
1807 {
1808   return 0;
1809 }
1810
1811 /***********************************************************************
1812  *           LBGetItemData
1813  */
1814 static LONG LBGetItemData(HWND hwnd, WORD wParam, LONG lParam)
1815 {
1816   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1817   dprintf_listbox(stddeb, "LB_GETITEMDATA wParam=%x\n", wParam);
1818   return ListBoxGetItemData(lphl, wParam);
1819 }
1820
1821 /***********************************************************************
1822  *           LBSetItemData
1823  */
1824 static LONG LBSetItemData(HWND hwnd, WORD wParam, LONG lParam)
1825 {
1826   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1827   dprintf_listbox(stddeb, "LB_SETITEMDATA  wParam=%x  lParam=%lx\n", wParam, lParam);
1828   return ListBoxSetItemData(lphl, wParam, lParam);
1829 }
1830
1831 /***********************************************************************
1832  *           LBSetTabStops
1833  */
1834 static LONG LBSetTabStops(HWND hwnd, WORD wParam, LONG lParam)
1835 {
1836   LPHEADLIST  lphl;
1837
1838   lphl = ListBoxGetStorageHeader(hwnd);
1839
1840   if (lphl->TabStops != NULL) {
1841     lphl->iNumStops = 0;
1842     free (lphl->TabStops);
1843   }
1844
1845   lphl->TabStops = malloc (wParam * sizeof (short));
1846   if (lphl->TabStops) {
1847     lphl->iNumStops = wParam;
1848     memcpy (lphl->TabStops, PTR_SEG_TO_LIN(lParam), wParam * sizeof (short));
1849     return TRUE;
1850   }
1851
1852   return FALSE;
1853 }
1854
1855 /***********************************************************************
1856  *           LBSetCurSel
1857  */
1858 static LONG LBSetCurSel(HWND hwnd, WORD wParam, LONG lParam)
1859 {
1860   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1861   WORD  wRet;
1862
1863   dprintf_listbox(stddeb,"ListBox LB_SETCURSEL wParam=%x !\n",
1864                   wParam);
1865
1866   wRet = ListBoxSetCurSel(lphl, wParam);
1867
1868   SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1869   InvalidateRect32( hwnd, NULL, TRUE );
1870
1871   return wRet;
1872 }
1873
1874 /***********************************************************************
1875  *           LBSetSel
1876  */
1877 static LONG LBSetSel(HWND hwnd, WORD wParam, LONG lParam)
1878 {
1879   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1880   RECT16 rect;
1881   int iRet;
1882
1883   dprintf_listbox(stddeb,"ListBox LB_SETSEL wParam=%x lParam=%lX !\n", wParam, lParam);
1884
1885   iRet = ListBoxSetSel(lphl, LOWORD(lParam), wParam);
1886
1887   if( iRet > 1 ) InvalidateRect32( hwnd, NULL, TRUE );
1888   else if( iRet != LB_ERR )
1889       {
1890         if( lphl->dwStyle & LBS_EXTENDEDSEL &&
1891             lphl->ItemFocused != LOWORD(lParam) )
1892           {
1893             ListBoxGetItemRect(lphl, lphl->ItemFocused , &rect);
1894             InvalidateRect16( hwnd, &rect, TRUE );
1895             lphl->ItemFocused = LOWORD(lParam);
1896           }
1897         ListBoxGetItemRect(lphl,LOWORD(lParam),&rect);
1898         InvalidateRect16( hwnd, &rect, TRUE );
1899       }
1900
1901   return (iRet == (WORD)LB_ERR)? LB_ERR: 0;
1902 }
1903
1904 /***********************************************************************
1905  *           LBSetTopIndex
1906  */
1907 static LONG LBSetTopIndex(HWND hwnd, WORD wParam, LONG lParam)
1908 {
1909   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1910
1911   dprintf_listbox(stddeb,"ListBox LB_SETTOPINDEX wParam=%x !\n",
1912                   wParam);
1913   lphl->FirstVisible = wParam;
1914   SetScrollPos(hwnd, SB_VERT, lphl->FirstVisible, TRUE);
1915
1916   InvalidateRect32( hwnd, NULL, TRUE );
1917
1918   return 0;
1919 }
1920
1921 /***********************************************************************
1922  *           LBSetItemHeight
1923  */
1924 static LONG LBSetItemHeight(HWND hwnd, WORD wParam, LONG lParam)
1925 {
1926   LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
1927   WORD wRet;
1928
1929   dprintf_listbox(stddeb,"ListBox LB_SETITEMHEIGHT wParam=%x lParam=%lX !\n", wParam, lParam);
1930   wRet = ListBoxSetItemHeight(lphl, wParam, lParam);
1931   InvalidateRect32( hwnd, NULL, TRUE );
1932   return wRet;
1933 }
1934
1935 /***********************************************************************
1936  *           LBPassToParent
1937  */
1938 static LRESULT LBPassToParent(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1939 {
1940   WND* ptrWnd = WIN_FindWndPtr(hwnd);
1941
1942   if( ptrWnd )
1943       if( /* !(ptrWnd->dwExStyle & WS_EX_NOPARENTNOTIFY) && */
1944           ptrWnd->parent )
1945           return SendMessage16(ptrWnd->parent->hwndSelf,message,wParam,lParam);
1946   return 0;
1947 }
1948
1949 /***********************************************************************
1950  *           ListBoxWndProc
1951  */
1952 LRESULT ListBoxWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1953 {
1954     switch (message) {
1955      case WM_CREATE: return LBCreate(hwnd, wParam, lParam);
1956      case WM_DESTROY: return LBDestroy(hwnd, wParam, lParam);
1957      case WM_GETDLGCODE: return LBGetDlgCode(hwnd, wParam, lParam);
1958      case WM_VSCROLL: return LBVScroll(hwnd, wParam, lParam);
1959      case WM_HSCROLL: return LBHScroll(hwnd, wParam, lParam);
1960      case WM_LBUTTONDOWN: return LBLButtonDown(hwnd, wParam, lParam);
1961      case WM_LBUTTONUP: return LBLButtonUp(hwnd, wParam, lParam);
1962      case WM_RBUTTONUP: return LBRButtonUp(hwnd, wParam, lParam);
1963      case WM_LBUTTONDBLCLK: return LBRButtonUp(hwnd, wParam, lParam);
1964      case WM_MOUSEMOVE: return LBMouseMove(hwnd, wParam, lParam);
1965      case WM_KEYDOWN: return LBKeyDown(hwnd, wParam, lParam);
1966      case WM_CHAR: return LBChar(hwnd, wParam, lParam);
1967      case WM_SETFONT: return LBSetFont(hwnd, wParam, lParam);
1968      case WM_SETREDRAW: return LBSetRedraw(hwnd, wParam, lParam);
1969      case WM_PAINT: return LBPaint(hwnd, wParam, lParam);
1970      case WM_SETFOCUS: return LBSetFocus(hwnd, wParam, lParam);
1971      case WM_KILLFOCUS: return LBKillFocus(hwnd, wParam, lParam);
1972      case LB_RESETCONTENT: return LBResetContent(hwnd, wParam, lParam);
1973      case LB_DIR: return LBDir(hwnd, wParam, lParam);
1974      case LB_ADDSTRING: return LBAddString(hwnd, wParam, lParam);
1975      case LB_INSERTSTRING: return LBInsertString(hwnd, wParam, lParam);
1976      case LB_DELETESTRING: return LBDeleteString(hwnd, wParam, lParam);
1977      case LB_FINDSTRING: return LBFindString(hwnd, wParam, lParam);
1978      case LB_GETCARETINDEX: return LBGetCaretIndex(hwnd, wParam, lParam);
1979      case LB_GETCOUNT: return LBGetCount(hwnd, wParam, lParam);
1980      case LB_GETCURSEL: return LBGetCurSel(hwnd, wParam, lParam);
1981      case LB_GETHORIZONTALEXTENT: return LBGetHorizontalExtent(hwnd, wParam, lParam);
1982      case LB_GETITEMDATA: return LBGetItemData(hwnd, wParam, lParam);
1983      case LB_GETITEMHEIGHT: return LBGetItemHeight(hwnd, wParam, lParam);
1984      case LB_GETITEMRECT: return LBGetItemRect(hwnd, wParam, lParam);
1985      case LB_GETSEL: return LBGetSel(hwnd, wParam, lParam);
1986      case LB_GETSELCOUNT: return LBGetSelCount(hwnd, wParam, lParam);
1987      case LB_GETSELITEMS: return LBGetSelItems(hwnd, wParam, lParam);
1988      case LB_GETTEXT: return LBGetText(hwnd, wParam, lParam);
1989      case LB_GETTEXTLEN: return LBGetTextLen(hwnd, wParam, lParam);
1990      case LB_GETTOPINDEX: return LBGetTopIndex(hwnd, wParam, lParam);
1991      case LB_SELECTSTRING: return LBSelectString(hwnd, wParam, lParam);
1992      case LB_SELITEMRANGE: return LBSelItemRange(hwnd, wParam, lParam);
1993      case LB_SETCARETINDEX: return LBSetCaretIndex(hwnd, wParam, lParam);
1994      case LB_SETCOLUMNWIDTH: return LBSetColumnWidth(hwnd, wParam, lParam);
1995      case LB_SETHORIZONTALEXTENT: return LBSetHorizontalExtent(hwnd, wParam, lParam);
1996      case LB_SETITEMDATA: return LBSetItemData(hwnd, wParam, lParam);
1997      case LB_SETTABSTOPS: return LBSetTabStops(hwnd, wParam, lParam);
1998      case LB_SETCURSEL: return LBSetCurSel(hwnd, wParam, lParam);
1999      case LB_SETSEL: return LBSetSel(hwnd, wParam, lParam);
2000      case LB_SETTOPINDEX: return LBSetTopIndex(hwnd, wParam, lParam);
2001      case LB_SETITEMHEIGHT: return LBSetItemHeight(hwnd, wParam, lParam);
2002
2003      case WM_DROPFILES: return LBPassToParent(hwnd, message, wParam, lParam);
2004
2005      /* these will have to be implemented for proper LBS_EXTENDEDSEL -
2006       *
2007       * anchor item is an item that with caret (focused) item defines a
2008       * range of currently selected items when listbox is in the extended
2009       * selection mode.
2010       */
2011      case LB_SETANCHORINDEX: return LB_SETANCHORINDEX; /* that's what Windows returns */
2012      case LB_GETANCHORINDEX: return 0;
2013
2014         case WM_DROPOBJECT:
2015         case WM_QUERYDROPOBJECT:
2016         case WM_DRAGSELECT:
2017         case WM_DRAGMOVE:
2018                 {
2019                  LPDRAGINFO lpDragInfo = (LPDRAGINFO) PTR_SEG_TO_LIN((SEGPTR)lParam);
2020                  LPHEADLIST lphl = ListBoxGetStorageHeader(hwnd);
2021
2022                  lpDragInfo->l = ListBoxFindMouse(lphl,lpDragInfo->pt.x,
2023                                                        lpDragInfo->pt.y);
2024
2025                  return LBPassToParent(hwnd, message, wParam, lParam);
2026                 }
2027     }
2028
2029     return DefWindowProc16(hwnd, message, wParam, lParam);
2030 }
2031
2032
2033 /**********************************************************************
2034  *          DlgDirSelect    (USER.99)
2035  */
2036 BOOL DlgDirSelect( HWND hDlg, LPSTR lpStr, INT id )
2037 {
2038     char *buffer;
2039     INT i;
2040
2041     dprintf_listbox( stddeb, "DlgDirSelect: %04x '%s' %d\n", hDlg, lpStr, id );
2042     if ((i = SendDlgItemMessage16( hDlg, id, LB_GETCURSEL, 0, 0 )) == LB_ERR)
2043         return FALSE;
2044     if (!(buffer = SEGPTR_ALLOC( 20 * sizeof(char) ))) return FALSE;
2045     SendDlgItemMessage16(hDlg, id, LB_GETTEXT, i, (LPARAM)SEGPTR_GET(buffer) );
2046     if (buffer[0] == '[')  /* drive or directory */
2047     {
2048         if (buffer[1] == '-')  /* drive */
2049         {
2050             lpStr[0] = buffer[2];
2051             lpStr[1] = ':';
2052             lpStr[2] = '\0';
2053             dprintf_listbox( stddeb, "Returning drive '%s'\n", lpStr );
2054             SEGPTR_FREE(buffer);
2055             return TRUE;
2056         }
2057         strcpy( lpStr, buffer + 1 );
2058         lpStr[strlen(lpStr)-1] = '\\';
2059         dprintf_listbox( stddeb, "Returning directory '%s'\n", lpStr );
2060         SEGPTR_FREE(buffer);
2061         return TRUE;
2062     }
2063     strcpy( lpStr, buffer );
2064     dprintf_listbox( stddeb, "Returning file '%s'\n", lpStr );
2065     SEGPTR_FREE(buffer);
2066     return FALSE;
2067 }
2068
2069
2070 /**********************************************************************
2071  *          DlgDirList    (USER.100)
2072  */
2073 INT DlgDirList( HWND hDlg, SEGPTR spec, INT idLBox, INT idStatic, UINT attrib )
2074 {
2075     char *filespec = (char *)PTR_SEG_TO_LIN( spec );
2076     int drive;
2077     HWND hwnd;
2078
2079 #define SENDMSG(msg,wparam,lparam) \
2080     ((attrib & DDL_POSTMSGS) ? PostMessage( hwnd, msg, wparam, lparam ) \
2081                              : SendMessage16( hwnd, msg, wparam, lparam ))
2082
2083     dprintf_listbox( stddeb, "DlgDirList: %04x '%s' %d %d %04x\n",
2084                      hDlg, filespec ? filespec : "NULL",
2085                      idLBox, idStatic, attrib );
2086
2087     if (filespec && filespec[0] && (filespec[1] == ':'))
2088     {
2089         drive = toupper( filespec[0] ) - 'A';
2090         filespec += 2;
2091         if (!DRIVE_SetCurrentDrive( drive )) return FALSE;
2092     }
2093     else drive = DRIVE_GetCurrentDrive();
2094
2095     if (idLBox && ((hwnd = GetDlgItem( hDlg, idLBox )) != 0))
2096     {
2097         char mask[20];
2098
2099         if (!filespec[0]) strcpy( mask, "*.*" );
2100         else
2101         {
2102             /* If the path exists and is a directory, chdir to it */
2103             if (DRIVE_Chdir( drive, filespec )) strcpy( mask, "*.*" );
2104             else
2105             {
2106                 char *p, *p2;
2107                 p = filespec;
2108                 if ((p2 = strrchr( p, '\\' ))) p = p2 + 1;
2109                 if ((p2 = strrchr( p, '/' ))) p = p2 + 1;
2110                 lstrcpyn( mask, p, sizeof(mask) );
2111                 if (p != filespec)
2112                 {
2113                     p[-1] = '\0';
2114                     if (!DRIVE_Chdir( drive, filespec )) return FALSE;
2115                 }
2116             }
2117         }
2118
2119         strcpy( (char *)PTR_SEG_TO_LIN(spec), mask );
2120
2121         dprintf_listbox(stddeb, "ListBoxDirectory: path=%c:\\%s mask=%s\n",
2122                         'A' + drive, DRIVE_GetDosCwd(drive), mask);
2123
2124         SENDMSG( LB_RESETCONTENT, 0, 0 );
2125         if ((attrib & DDL_DIRECTORY) && !(attrib & DDL_EXCLUSIVE))
2126         {
2127             char *temp;
2128             if (SENDMSG( LB_DIR, attrib & ~(DDL_DIRECTORY | DDL_DRIVES),
2129                          (LPARAM)spec ) == LB_ERR) return FALSE;
2130             if (!(temp = SEGPTR_ALLOC( 4*sizeof(char) ))) return FALSE;
2131             strcpy( temp, "*.*" );
2132             /* FIXME: this won't work with PostMessage(), as temp will */
2133             /* have been freed by the time we do a DispatchMessage().  */
2134             if (SENDMSG( LB_DIR, (attrib & (DDL_DIRECTORY | DDL_DRIVES)) | DDL_EXCLUSIVE,
2135                          (LPARAM)SEGPTR_GET(temp) ) == LB_ERR)
2136             {
2137                 SEGPTR_FREE(temp);
2138                 return FALSE;
2139             }
2140             SEGPTR_FREE(temp);
2141         }
2142         else
2143         {
2144             if (SENDMSG( LB_DIR, attrib, (LPARAM)spec) == LB_ERR) return FALSE;
2145         }
2146     }
2147
2148     if (idStatic && ((hwnd = GetDlgItem( hDlg, idStatic )) != 0))
2149     {
2150         char temp[512];
2151         int drive = DRIVE_GetCurrentDrive();
2152         strcpy( temp, "A:\\" );
2153         temp[0] += drive;
2154         lstrcpyn( temp + 3, DRIVE_GetDosCwd(drive), sizeof(temp)-3 );
2155         AnsiLower( temp );
2156         /* Can't use PostMessage() here, because the string is on the stack */
2157         SetDlgItemText32A( hDlg, idStatic, temp );
2158     }
2159     return TRUE;
2160 #undef SENDMSG
2161 }