controls/oldlbox.c

   1 /*
   2  * Listbox controls
   3  *
   4  * Copyright  Martin Ayotte, 1993
   5  *            Constantine Sapuntzakis, 1995
   6  *            Alex Korobka, 1995, 1996
   7  *
   8  */
   9
  10  /*
  11   * FIXME:
  12   * - proper scrolling for multicolumn style
  13   * - anchor and caret for LBS_EXTENDEDSEL
  14   * - proper selection with keyboard
  15   * - how to handle (LBS_EXTENDEDSEL | LBS_MULTIPLESEL) style
  16   * - support for LBS_NOINTEGRALHEIGHT and LBS_OWNERDRAWVARIABLE styles
  17   */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <ctype.h>
  23 #include "windows.h"
  24 #include "win.h"
  25 #include "gdi.h"
  26 #include "msdos.h"
  27 #include "listbox.h"
  28 #include "dos_fs.h"
  29 #include "drive.h"
  30 #include "file.h"
  31 #include "heap.h"
  32 #include "stddebug.h"
  33 #include "debug.h"
  34 #include "xmalloc.h"
  35
  36 #define LIST_HEAP_ALLOC(lphl,f,size) \
  37     LOCAL_Alloc( lphl->HeapSel, LMEM_FIXED, (size) )
  38 #define LIST_HEAP_FREE(lphl,handle) \
  39     LOCAL_Free( lphl->HeapSel, (handle) )
  40 #define LIST_HEAP_ADDR(lphl,handle)  \
  41     ((handle) ? PTR_SEG_OFF_TO_LIN(lphl->HeapSel, (handle)) : NULL)
  42
  43 #define LIST_HEAP_SIZE 0x10000
  44
  45 #define LBMM_EDGE   4    /* distance inside box which is same as moving mouse
  46                             outside box, to trigger scrolling of LB */
  47
  48 #define MATCH_SUBSTR            2
  49 #define MATCH_EXACT             1
  50 #define MATCH_NEAREST           0
  51
  52 static void ListBoxInitialize(LPHEADLIST lphl)
  53 {
  54   lphl->lpFirst        = NULL;
  55   lphl->ItemsCount     = 0;
  56   lphl->ItemsVisible   = 0;
  57   lphl->FirstVisible   = 0;
  58   lphl->ColumnsVisible = 1;
  59   lphl->ItemsPerColumn = 0;
  60   lphl->ItemFocused    = -1;
  61   lphl->PrevFocused    = -1;
  62 }
  63
  64 void CreateListBoxStruct(HWND hwnd, WORD CtlType, LONG styles, HWND parent)
  65 {
  66   LPHEADLIST lphl;
  67   HDC32         hdc;
  68
  69   lphl = (LPHEADLIST)xmalloc(sizeof(HEADLIST));
  70   SetWindowLong32A(hwnd, 0, (LONG)lphl);
  71   ListBoxInitialize(lphl);
  72   lphl->DrawCtlType    = CtlType;
  73   lphl->CtlID          = GetWindowWord(hwnd,GWW_ID);
  74   lphl->bRedrawFlag    = TRUE;
  75   lphl->iNumStops      = 0;
  76   lphl->TabStops       = NULL;
  77   lphl->hFont          = GetStockObject32(SYSTEM_FONT);
  78   lphl->hSelf          = hwnd;
  79   if (CtlType==ODT_COMBOBOX)              /* use the "faked" style for COMBOLBOX */
  80                                           /* LBS_SORT instead CBS_SORT e.g.      */
  81     lphl->dwStyle   = MAKELONG(LOWORD(styles),HIWORD(GetWindowLong32A(hwnd,GWL_STYLE)));
  82   else
  83     lphl->dwStyle   = GetWindowLong32A(hwnd,GWL_STYLE); /* use original style dword */
  84   lphl->hParent        = parent;
  85   lphl->StdItemHeight  = 15; /* FIXME: should get the font height */
  86   lphl->OwnerDrawn     = styles & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE);
  87   lphl->HasStrings     = (styles & LBS_HASSTRINGS) || !lphl->OwnerDrawn;
  88
  89   /* create dummy hdc to set text height */
  90   if ((hdc = GetDC32(0)))
  91   {
  92       TEXTMETRIC16 tm;
  93       GetTextMetrics16( hdc, &tm );
  94       lphl->StdItemHeight = tm.tmHeight;
  95       dprintf_listbox(stddeb,"CreateListBoxStruct:  font height %d\n",
  96                       lphl->StdItemHeight);
  97       ReleaseDC32( 0, hdc );
  98   }
  99
 100   if (lphl->OwnerDrawn)
 101   {
 102     LISTSTRUCT dummyls;
 103
 104     lphl->needMeasure = TRUE;
 105     dummyls.mis.CtlType    = lphl->DrawCtlType;
 106     dummyls.mis.CtlID      = lphl->CtlID;
 107     dummyls.mis.itemID     = -1;
 108     dummyls.mis.itemWidth  = 0; /* ignored */
 109     dummyls.mis.itemData   = 0;
 110
 111     ListBoxAskMeasure(lphl,&dummyls);
 112   }
 113
 114   lphl->HeapSel = GlobalAlloc16(GMEM_FIXED,LIST_HEAP_SIZE);
 115   LocalInit( lphl->HeapSel, 0, LIST_HEAP_SIZE-1);
 116 }
 117
 118 /* Send notification "code" as part of a WM_COMMAND-message if hwnd
 119    has the LBS_NOTIFY style */
 120 void ListBoxSendNotification(LPHEADLIST lphl, WORD code)
 121 {
 122   if (lphl->dwStyle & LBS_NOTIFY)
 123       SendMessage32A( lphl->hParent, WM_COMMAND,
 124                       MAKEWPARAM( lphl->CtlID, code), (LPARAM)lphl->hSelf );
 125 }
 126
 127
 128 /* get the maximum value of lphl->FirstVisible */
 129 int ListMaxFirstVisible(LPHEADLIST lphl)
 130 {
 131     int m = lphl->ItemsCount-lphl->ItemsVisible;
 132     return (m < 0) ? 0 : m;
 133 }
 134
 135
 136 /* Returns: 0 if nothing needs to be changed */
 137 /*          1 if FirstVisible changed */
 138
 139 int ListBoxScrollToFocus(LPHEADLIST lphl)
 140 {
 141   short       end;
 142
 143   if (lphl->ItemsCount == 0) return 0;
 144   if (lphl->ItemFocused == -1) return 0;
 145
 146   end = lphl->FirstVisible + lphl->ItemsVisible - 1;
 147
 148   if (lphl->ItemFocused < lphl->FirstVisible ) {
 149     lphl->FirstVisible = lphl->ItemFocused;
 150     return 1;
 151   } else {
 152     if (lphl->ItemFocused > end) {
 153       WORD maxFirstVisible = ListMaxFirstVisible(lphl);
 154
 155       lphl->FirstVisible = lphl->ItemFocused;
 156
 157       if (lphl->FirstVisible > maxFirstVisible) {
 158         lphl->FirstVisible = maxFirstVisible;
 159       }
 160       return 1;
 161     }
 162   }
 163   return 0;
 164 }
 165
 166
 167 LPLISTSTRUCT ListBoxGetItem(LPHEADLIST lphl, UINT uIndex)
 168 {
 169   LPLISTSTRUCT lpls;
 170   UINT         Count = 0;
 171
 172   if (uIndex >= lphl->ItemsCount) return NULL;
 173
 174   lpls = lphl->lpFirst;
 175   while (Count++ < uIndex) lpls = lpls->lpNext;
 176   return lpls;
 177 }
 178
 179
 180 void ListBoxDrawItem(HWND hwnd, LPHEADLIST lphl, HDC16 hdc, LPLISTSTRUCT lpls,
 181                      RECT16 *rect, WORD itemAction, WORD itemState)
 182 {
 183     if (lphl->OwnerDrawn)
 184     {
 185         DRAWITEMSTRUCT32 dis;
 186
 187         dis.CtlID      = lpls->mis.CtlID;
 188         dis.CtlType    = lpls->mis.CtlType;
 189         dis.itemID     = lpls->mis.itemID;
 190         dis.hDC        = hdc;
 191         dis.hwndItem   = hwnd;
 192         dis.itemData   = lpls->mis.itemData;
 193         dis.itemAction = itemAction;
 194         dis.itemState  = itemState;
 195         CONV_RECT16TO32( rect, &dis.rcItem );
 196         SendMessage32A( lphl->hParent, WM_DRAWITEM, dis.CtlID, (LPARAM)&dis );
 197         return;
 198     }
 199     if (itemAction == ODA_DRAWENTIRE || itemAction == ODA_SELECT) {
 200       int       OldBkMode;
 201       DWORD     dwOldTextColor = 0;
 202
 203       OldBkMode = SetBkMode32(hdc, TRANSPARENT);
 204
 205       if (itemState != 0) {
 206         dwOldTextColor = SetTextColor(hdc, 0x00FFFFFFL);
 207         FillRect16(hdc, rect, GetStockObject32(BLACK_BRUSH));
 208       }
 209
 210       if (lphl->dwStyle & LBS_USETABSTOPS) {
 211         TabbedTextOut(hdc, rect->left + 5, rect->top + 2,
 212                       (char *)lpls->itemText, strlen((char *)lpls->itemText),
 213                       lphl->iNumStops, lphl->TabStops, 0);
 214       } else {
 215         TextOut16(hdc, rect->left + 5, rect->top + 2,
 216                   (char *)lpls->itemText, strlen((char *)lpls->itemText));
 217       }
 218
 219       if (itemState != 0) {
 220         SetTextColor(hdc, dwOldTextColor);
 221       }
 222
 223       SetBkMode32(hdc, OldBkMode);
 224     }
 225     else DrawFocusRect16(hdc, rect);
 226 }
 227
 228
 229 int ListBoxFindMouse(LPHEADLIST lphl, int X, int Y)
 230 {
 231   LPLISTSTRUCT lpls = lphl->lpFirst;
 232   int          i, j;
 233   POINT16      point;
 234
 235   point.x = X; point.y = Y;
 236   if (lphl->ItemsCount == 0) return LB_ERR;
 237
 238   for(i = 0; i < lphl->FirstVisible; i++) {
 239     if (lpls == NULL) return LB_ERR;
 240     lpls = lpls->lpNext;
 241   }
 242   for(j = 0; j < lphl->ItemsVisible; i++, j++) {
 243     if (lpls == NULL) return LB_ERR;
 244     if (PtInRect16(&lpls->itemRect,point)) {
 245       return i;
 246     }
 247     lpls = lpls->lpNext;
 248   }
 249   dprintf_listbox(stddeb,"ListBoxFindMouse: not found\n");
 250   return LB_ERR;
 251 }
 252
 253 BOOL32 lbDeleteItemNotify(LPHEADLIST lphl, LPLISTSTRUCT lpls)
 254 {
 255     /* called only for owner drawn listboxes */
 256     BOOL32 ret;
 257     DELETEITEMSTRUCT16 *delItem = SEGPTR_NEW(DELETEITEMSTRUCT16);
 258     if (!delItem) return FALSE;
 259
 260     delItem->CtlType  = lphl->DrawCtlType;
 261     delItem->CtlID    = lphl->CtlID;
 262     delItem->itemID   = lpls->mis.itemID;
 263     delItem->hwndItem = lphl->hSelf;
 264     delItem->itemData = lpls->mis.itemData;
 265
 266     ret = SendMessage16( lphl->hParent, WM_DELETEITEM, (WPARAM16)lphl->CtlID,
 267                          (LPARAM)SEGPTR_GET(delItem) );
 268     SEGPTR_FREE(delItem);
 269     return ret;
 270 }
 271
 272 /* -------------------- strings and item data ---------------------- */
 273
 274 void ListBoxAskMeasure(LPHEADLIST lphl, LPLISTSTRUCT lpls)
 275 {
 276     MEASUREITEMSTRUCT16 *lpmeasure = SEGPTR_NEW(MEASUREITEMSTRUCT16);
 277     if (!lpmeasure) return;
 278     *lpmeasure = lpls->mis;
 279     lpmeasure->itemHeight = lphl->StdItemHeight;
 280     SendMessage16( lphl->hParent, WM_MEASUREITEM, lphl->CtlID,
 281                    (LPARAM)SEGPTR_GET(lpmeasure) );
 282
 283     if (lphl->dwStyle & LBS_OWNERDRAWFIXED)
 284     {
 285         if (lpmeasure->itemHeight > lphl->StdItemHeight)
 286             lphl->StdItemHeight = lpmeasure->itemHeight;
 287         lpls->mis.itemHeight = lpmeasure->itemHeight;
 288     }
 289     SEGPTR_FREE(lpmeasure);
 290 }
 291
 292 static LPLISTSTRUCT ListBoxCreateItem(LPHEADLIST lphl, int id)
 293 {
 294   LPLISTSTRUCT lplsnew = (LPLISTSTRUCT)malloc(sizeof(LISTSTRUCT));
 295
 296   if (lplsnew == NULL) return NULL;
 297
 298   lplsnew->itemState      = 0;
 299   lplsnew->mis.CtlType    = lphl->DrawCtlType;
 300   lplsnew->mis.CtlID      = lphl->CtlID;
 301   lplsnew->mis.itemID     = id;
 302   lplsnew->mis.itemHeight = lphl->StdItemHeight;
 303   lplsnew->mis.itemWidth  = 0; /* ignored */
 304   lplsnew->mis.itemData   = 0;
 305   SetRectEmpty16( &lplsnew->itemRect );
 306
 307   return lplsnew;
 308 }
 309
 310 static int ListBoxAskCompare(LPHEADLIST lphl, int startItem, SEGPTR matchData, BOOL exactMatch )
 311 {
 312  /*  Do binary search for sorted listboxes. Linked list item storage sort of
 313   *  defeats the purpose ( forces to traverse item list all the time ) but M$ does it this way...
 314   *
 315   *  MATCH_NEAREST (0) - return position for insertion - for all styles
 316   *  MATCH_EXACT   (1) - search for an item, return index or LB_ERR
 317   *  MATCH_SUBSTR  (2) - same as exact match but with strncmp for string comparision
 318   */
 319
 320  COMPAREITEMSTRUCT16   *itemCmp;
 321  LPLISTSTRUCT           currentItem = NULL;
 322  LPCSTR                 matchStr = (lphl->HasStrings)?(LPCSTR)PTR_SEG_TO_LIN(matchData):NULL;
 323  int                    head, pos = -1, tail, loop = 1;
 324  short                  b = 0, s_length = 0;
 325
 326  /* check if empty */
 327
 328  if( !lphl->ItemsCount )
 329     return (exactMatch)? LB_ERR: 0;
 330
 331  /* set up variables */
 332
 333  if( exactMatch == MATCH_NEAREST )
 334      startItem = 0;
 335  else if( ++startItem )
 336    {
 337      loop = 2;
 338      if( startItem >= lphl->ItemsCount ) startItem = lphl->ItemsCount - 1;
 339    }
 340
 341  if( exactMatch == MATCH_SUBSTR && lphl->HasStrings )
 342    {
 343      s_length = strlen( matchStr );
 344      if( !s_length ) return 0;                  /* head of the list - empty string */
 345    }
 346
 347  head = startItem; tail = lphl->ItemsCount - 1;
 348
 349  dprintf_listbox(stddeb,"AskCompare: head = %i, tail = %i, data = %08x\n", head, tail, (unsigned)matchData );
 350
 351  if (!(itemCmp = SEGPTR_NEW(COMPAREITEMSTRUCT16))) return 0;
 352  itemCmp->CtlType        = lphl->DrawCtlType;
 353  itemCmp->CtlID          = lphl->CtlID;
 354  itemCmp->hwndItem       = lphl->hSelf;
 355
 356  /* search from startItem */
 357
 358  while ( loop-- )
 359   {
 360     while( head <= tail )
 361      {
 362        pos = (tail + head)/2;
 363        currentItem = ListBoxGetItem( lphl, pos );
 364
 365        if( lphl->HasStrings )
 366          {
 367            b = ( s_length )? lstrncmpi32A( currentItem->itemText, matchStr, s_length)
 368                            : lstrcmpi32A( currentItem->itemText, matchStr);
 369          }
 370        else
 371          {
 372            itemCmp->itemID1      = pos;
 373            itemCmp->itemData1    = currentItem->mis.itemData;
 374            itemCmp->itemID2      = -1;
 375            itemCmp->itemData2    = matchData;
 376
 377            b = SendMessage16( lphl->hParent, WM_COMPAREITEM,
 378                               (WPARAM16)lphl->CtlID,
 379                               (LPARAM)SEGPTR_GET(itemCmp) );
 380          }
 381
 382        if( b == 0 )
 383        {
 384            SEGPTR_FREE(itemCmp);
 385            return pos;  /* found exact match */
 386        }
 387        else
 388          if( b < 0 ) head = ++pos;
 389          else
 390            if( b > 0 ) tail = pos - 1;
 391      }
 392
 393     /* reset to search from the first item */
 394     head = 0; tail = startItem - 1;
 395   }
 396
 397  dprintf_listbox(stddeb,"\t-> pos = %i\n", pos );
 398  SEGPTR_FREE(itemCmp);
 399
 400  /* if we got here match is not exact */
 401
 402  if( pos < 0 ) pos = 0;
 403  else if( pos > lphl->ItemsCount ) pos = lphl->ItemsCount;
 404
 405  return (exactMatch)? LB_ERR: pos;
 406 }
 407
 408 int ListBoxInsertString(LPHEADLIST lphl, UINT uIndex, LPCSTR newstr)
 409 {
 410   LPLISTSTRUCT *lppls, lplsnew, lpls;
 411   HANDLE16 hStr;
 412   LPSTR str;
 413   UINT  Count;
 414
 415   dprintf_listbox(stddeb,"ListBoxInsertString(%d, %p);\n", uIndex, newstr);
 416
 417   if (!newstr) return -1;
 418
 419   if (uIndex == (UINT)-1)
 420     uIndex = lphl->ItemsCount;
 421
 422   lppls = &lphl->lpFirst;
 423   for(Count = 0; Count < uIndex; Count++) {
 424     if (*lppls == NULL) return LB_ERR;
 425     lppls = (LPLISTSTRUCT *) &(*lppls)->lpNext;
 426   }
 427
 428   lplsnew = ListBoxCreateItem(lphl, Count);
 429
 430   if (lplsnew == NULL) {
 431     fprintf(stdnimp,"ListBoxInsertString() out of memory !\n");
 432     return LB_ERRSPACE;
 433   }
 434
 435   lplsnew->lpNext = *lppls;
 436   *lppls = lplsnew;
 437   lphl->ItemsCount++;
 438
 439   hStr = 0;
 440   if (lphl->HasStrings) {
 441     dprintf_listbox(stddeb,"  string: %s\n", newstr);
 442     hStr = LIST_HEAP_ALLOC(lphl, LMEM_MOVEABLE, strlen(newstr) + 1);
 443     str = (LPSTR)LIST_HEAP_ADDR(lphl, hStr);
 444     if (str == NULL) return LB_ERRSPACE;
 445     strcpy(str, newstr);
 446     lplsnew->itemText = str;
 447     /* I'm not so sure about the next one */
 448     lplsnew->mis.itemData = 0;
 449   } else {
 450     lplsnew->itemText = NULL;
 451     lplsnew->mis.itemData = (DWORD)newstr;
 452   }
 453
 454   lplsnew->mis.itemID = uIndex;
 455   lplsnew->hData = hStr;
 456
 457   /* adjust the itemID field of the following entries */
 458   for(lpls = lplsnew->lpNext; lpls != NULL; lpls = lpls->lpNext) {
 459       lpls->mis.itemID++;
 460   }
 461
 462   if (lphl->needMeasure) {
 463     ListBoxAskMeasure(lphl, lplsnew);
 464   }
 465
 466   dprintf_listbox(stddeb,"ListBoxInsertString // count=%d\n", lphl->ItemsCount);
 467   return uIndex;
 468 }
 469
 470
 471 int ListBoxAddString(LPHEADLIST lphl, SEGPTR itemData)
 472 {
 473     UINT        pos = (UINT) -1;
 474     LPCSTR      newstr = (lphl->HasStrings)?(LPCSTR)PTR_SEG_TO_LIN(itemData):(LPCSTR)itemData;
 475
 476     if ( lphl->dwStyle & LBS_SORT )
 477          pos = ListBoxAskCompare( lphl, -1, itemData, MATCH_NEAREST );
 478
 479     return ListBoxInsertString(lphl, pos, newstr);
 480 }
 481
 482
 483 int ListBoxGetText(LPHEADLIST lphl, UINT uIndex, LPSTR OutStr)
 484 {
 485   LPLISTSTRUCT lpls;
 486
 487   if (!OutStr) {
 488     dprintf_listbox(stddeb, "ListBoxGetText // OutStr==NULL\n");
 489     return 0;
 490   }
 491   *OutStr = '\0';
 492   lpls = ListBoxGetItem (lphl, uIndex);
 493   if (lpls == NULL) return LB_ERR;
 494
 495   if (!lphl->HasStrings) {
 496     *((long *)OutStr) = lpls->mis.itemData;
 497     return 4;
 498   }
 499
 500   strcpy(OutStr, lpls->itemText);
 501   return strlen(OutStr);
 502 }
 503
 504
 505 DWORD ListBoxGetItemData(LPHEADLIST lphl, UINT uIndex)
 506 {
 507   LPLISTSTRUCT lpls;
 508
 509   lpls = ListBoxGetItem (lphl, uIndex);
 510   if (lpls == NULL) return LB_ERR;
 511   return lpls->mis.itemData;
 512 }
 513
 514
 515 int ListBoxSetItemData(LPHEADLIST lphl, UINT uIndex, DWORD ItemData)
 516 {
 517   LPLISTSTRUCT lpls = ListBoxGetItem(lphl, uIndex);
 518
 519   if (lpls == NULL) return LB_ERR;
 520   lpls->mis.itemData = ItemData;
 521   return 1;
 522 }
 523
 524
 525 int ListBoxDeleteString(LPHEADLIST lphl, UINT uIndex)
 526 {
 527   LPLISTSTRUCT lpls, lpls2;
 528   UINT  Count;
 529
 530   if (uIndex >= lphl->ItemsCount) return LB_ERR;
 531
 532   lpls = lphl->lpFirst;
 533   if (lpls == NULL) return LB_ERR;
 534
 535   if (uIndex == 0)
 536   {
 537     if( lphl->OwnerDrawn )
 538         lbDeleteItemNotify( lphl, lpls);
 539     lphl->lpFirst = lpls->lpNext;
 540   }
 541   else
 542   {
 543     LPLISTSTRUCT lpls2 = NULL;
 544     for(Count = 0; Count < uIndex; Count++) {
 545       if (lpls->lpNext == NULL) return LB_ERR;
 546
 547       lpls2 = lpls;
 548       lpls = (LPLISTSTRUCT)lpls->lpNext;
 549     }
 550     if( lphl->OwnerDrawn )
 551         lbDeleteItemNotify( lphl, lpls);
 552     lpls2->lpNext = lpls->lpNext;
 553   }
 554
 555   /* adjust the itemID field of the following entries */
 556   for(lpls2 = lpls->lpNext; lpls2 != NULL; lpls2 = lpls2->lpNext) {
 557       lpls2->mis.itemID--;
 558   }
 559
 560   lphl->ItemsCount--;
 561
 562   if (lpls->hData != 0) LIST_HEAP_FREE(lphl, lpls->hData);
 563   free(lpls);
 564
 565   return lphl->ItemsCount;
 566 }
 567
 568 static int lbFindString(LPHEADLIST lphl, UINT nFirst, SEGPTR MatchStr, BOOL match)
 569 {
 570   /*  match is either MATCH_SUBSTR or MATCH_EXACT */
 571
 572   LPLISTSTRUCT lpls;
 573   UINT         Count;
 574   UINT         First      = nFirst + 1;
 575   int          s_length   = 0;
 576   LPSTR        lpMatchStr = (LPSTR)MatchStr;
 577
 578   if (First > lphl->ItemsCount) return LB_ERR;
 579
 580   if (lphl->dwStyle & LBS_SORT )
 581       return ListBoxAskCompare( lphl, nFirst, MatchStr, match );
 582
 583   if (lphl->HasStrings )
 584   {
 585     lpMatchStr = PTR_SEG_TO_LIN(MatchStr);
 586
 587     if( match == MATCH_SUBSTR )
 588     {
 589       s_length = strlen(lpMatchStr);
 590       if( !s_length ) return (lphl->ItemsCount)?0:LB_ERR;
 591     }
 592   }
 593
 594   lpls = ListBoxGetItem(lphl, First);
 595   Count = 0;
 596   while(lpls != NULL)
 597   {
 598     if (lphl->HasStrings)
 599     {
 600       if ( ( s_length )? !lstrncmpi32A(lpls->itemText, lpMatchStr, s_length)
 601                        : !lstrcmpi32A(lpls->itemText, lpMatchStr)  ) return Count;
 602     }
 603     else
 604       if ( lpls->mis.itemData == (DWORD)lpMatchStr ) return Count;
 605
 606     lpls = lpls->lpNext;
 607     Count++;
 608   }
 609
 610   /* Start over at top */
 611   Count = 0;
 612   lpls = lphl->lpFirst;
 613
 614   while (Count < First)
 615   {
 616     if (lphl->HasStrings)
 617     {
 618       if ( ( s_length )? !lstrncmpi32A(lpls->itemText, lpMatchStr, s_length)
 619                        : !lstrcmpi32A(lpls->itemText, lpMatchStr)  ) return Count;
 620     }
 621     else
 622       if ( lpls->mis.itemData == (DWORD)lpMatchStr ) return Count;
 623
 624     lpls = lpls->lpNext;
 625     Count++;
 626   }
 627
 628   return LB_ERR;
 629 }
 630
 631 int ListBoxFindString(LPHEADLIST lphl, UINT nFirst, SEGPTR MatchStr)
 632 {
 633   return lbFindString(lphl, nFirst, MatchStr, MATCH_SUBSTR );
 634 }
 635
 636 int ListBoxFindStringExact(LPHEADLIST lphl, UINT nFirst, SEGPTR MatchStr)
 637 {
 638   return lbFindString(lphl, nFirst, MatchStr, MATCH_EXACT );
 639 }
 640
 641 int ListBoxResetContent(LPHEADLIST lphl)
 642 {
 643     LPLISTSTRUCT lpls;
 644     int i;
 645
 646     if (lphl->ItemsCount == 0) return 0;
 647
 648     dprintf_listbox(stddeb, "ListBoxResetContent // ItemCount = %d\n",
 649         lphl->ItemsCount);
 650
 651     for(i = 0; i < lphl->ItemsCount; i++) {
 652       lpls = lphl->lpFirst;
 653       if (lpls == NULL) return LB_ERR;
 654
 655       if (lphl->OwnerDrawn) lbDeleteItemNotify(lphl, lpls);
 656
 657       lphl->lpFirst = lpls->lpNext;
 658       if (lpls->hData != 0) LIST_HEAP_FREE(lphl, lpls->hData);
 659       free(lpls);
 660     }
 661     ListBoxInitialize(lphl);
 662
 663     return TRUE;
 664 }
 665
 666 /* --------------------- selection ------------------------- */
 667
 668 int ListBoxSetCurSel(LPHEADLIST lphl, WORD wIndex)
 669 {
 670   LPLISTSTRUCT lpls;
 671
 672   /* use ListBoxSetSel instead */
 673   if (lphl->dwStyle & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL) ) return 0;
 674
 675   /* unselect previous item */
 676   if (lphl->ItemFocused != -1) {
 677     lphl->PrevFocused = lphl->ItemFocused;
 678     lpls = ListBoxGetItem(lphl, lphl->ItemFocused);
 679     if (lpls == 0) return LB_ERR;
 680     lpls->itemState = 0;
 681   }
 682
 683   if ((wIndex != (UINT)-1) && (wIndex < lphl->ItemsCount))
 684   {
 685     lphl->ItemFocused = wIndex;
 686     lpls = ListBoxGetItem(lphl, wIndex);
 687     if (lpls == 0) return LB_ERR;
 688     lpls->itemState = ODS_SELECTED | ODS_FOCUS;
 689
 690     return 0;
 691   }
 692
 693   return LB_ERR;
 694 }
 695
 696
 697
 698 /* ------------------------- dir listing ------------------------ */
 699
 700 LONG ListBoxDirectory(LPHEADLIST lphl, UINT attrib, LPCSTR filespec)
 701 {
 702     char        mask[13];
 703     char*       temp = NULL;
 704     const char* ptr;
 705     int         skip, count;
 706     LONG        ret;
 707     DOS_DIRENT  entry;
 708     char *path, *p;
 709
 710     dprintf_listbox(stddeb, "ListBoxDirectory: '%s' %04x\n", filespec, attrib);
 711     if (!filespec) return LB_ERR;
 712     if (!(ptr = DOSFS_GetUnixFileName( filespec, FALSE ))) return LB_ERR;
 713     path = xstrdup(ptr);
 714     p = strrchr( path, '/' );
 715     *p++ = '\0';
 716     if (!(ptr = DOSFS_ToDosFCBFormat( p )) ||
 717         !(temp = SEGPTR_ALLOC( sizeof(char) * 16 )) )
 718     {
 719         free( path );
 720         return LB_ERR;
 721     }
 722
 723     strcpy( mask, ptr );
 724
 725     dprintf_listbox(stddeb, "ListBoxDirectory: path=%s mask=%s\n", path, mask);
 726
 727     skip = ret = 0;
 728     attrib &= ~FA_LABEL;
 729     while ((count = DOSFS_FindNext( path, mask, NULL, 0,
 730                                     attrib, skip, &entry )) > 0)
 731     {
 732         skip += count;
 733         if (entry.attr & FA_DIRECTORY)
 734         {
 735             if ((attrib & DDL_DIRECTORY) && strcmp(entry.name, ".          "))
 736             {
 737                 sprintf(temp, "[%s]", DOSFS_ToDosDTAFormat( entry.name ) );
 738                 AnsiLower( temp );
 739                 if ((ret = ListBoxAddString(lphl, SEGPTR_GET(temp))) == LB_ERR) break;
 740             }
 741         }
 742         else  /* not a directory */
 743         {
 744             if (!(attrib & DDL_EXCLUSIVE) ||
 745                 ((attrib & (FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_ARCHIVE)) ==
 746                  (entry.attr & (FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_ARCHIVE))))
 747             {
 748                 strcpy( temp, DOSFS_ToDosDTAFormat( entry.name ) );
 749                 AnsiLower( temp );
 750                 if ((ret = ListBoxAddString(lphl, SEGPTR_GET(temp))) == LB_ERR) break;
 751             }
 752         }
 753
 754         dprintf_listbox(stddeb,"\tn - %i, file '%s'\n", count, temp);
 755     }
 756     if (attrib & DDL_DRIVES)
 757     {
 758         int x;
 759         DWORD oldstyle = lphl->dwStyle;
 760
 761         lphl->dwStyle &= ~LBS_SORT;
 762         strcpy( temp, "[-a-]" );
 763         for (x = 0; x < MAX_DOS_DRIVES; x++, temp[2]++)
 764         {
 765             if (DRIVE_IsValid(x))
 766                 if ((ret = ListBoxAddString(lphl, SEGPTR_GET(temp))) == LB_ERR) break;
 767         }
 768         lphl->dwStyle = oldstyle;
 769     }
 770
 771     free( path );
 772     SEGPTR_FREE( temp );
 773
 774     return ret;
 775 }
 776
 777 /* ------------------------- dimensions ------------------------- */
 778
 779 int ListBoxGetItemRect(LPHEADLIST lphl, WORD wIndex, LPRECT16 lprect)
 780 {
 781   LPLISTSTRUCT lpls = ListBoxGetItem(lphl,wIndex);
 782
 783   dprintf_listbox(stddeb,"ListBox LB_GETITEMRECT %i %p", wIndex,lpls);
 784   if (lpls == NULL)
 785   {
 786     if (lphl->dwStyle & LBS_OWNERDRAWVARIABLE)
 787       return LB_ERR;
 788     else
 789     {
 790      GetClientRect16(lphl->hSelf,lprect);
 791      lprect->bottom=lphl->StdItemHeight;
 792      if (lprect->right<0) lprect->right=0;
 793     }
 794   }
 795   else
 796    *lprect = lpls->itemRect;
 797   dprintf_listbox(stddeb," = %d,%d  %d,%d\n", lprect->left,lprect->top,
 798                                               lprect->right,lprect->bottom);
 799   return 0;
 800 }
 801
 802
 803 int ListBoxSetItemHeight(LPHEADLIST lphl, WORD wIndex, long height)
 804 {
 805   LPLISTSTRUCT lpls;
 806
 807   if (!(lphl->dwStyle & LBS_OWNERDRAWVARIABLE)) {
 808     lphl->StdItemHeight = (short)height;
 809     return 0;
 810   }
 811
 812   lpls = ListBoxGetItem(lphl, wIndex);
 813   if (lpls == NULL) return LB_ERR;
 814
 815   lpls->mis.itemHeight = height;
 816   return 0;
 817 }
 818
 819 /* -------------------------- string search ------------------------ */
 820
 821 int ListBoxFindNextMatch(LPHEADLIST lphl, WORD wChar)
 822 {
 823   LPLISTSTRUCT lpls;
 824   UINT         count,first;
 825
 826   if ((char)wChar < ' ') return LB_ERR;
 827   if (!lphl->HasStrings) return LB_ERR;
 828
 829   lpls = lphl->lpFirst;
 830
 831   for (count = 0; lpls != NULL; lpls = lpls->lpNext, count++) {
 832     if (tolower(*lpls->itemText) == tolower((char)wChar)) break;
 833   }
 834   if (lpls == NULL) return LB_ERR;
 835   first = count;
 836   for(; lpls != NULL; lpls = lpls->lpNext, count++) {
 837     if (*lpls->itemText != (char)wChar)
 838       break;
 839     if ((short) count > lphl->ItemFocused)
 840       return count;
 841   }
 842   return first;
 843 }