The Ecere SDK - sdk/blob - ecere/src/gui/controls/DropBox.ec

   1 namespace gui::controls;
   2
   3 import "Window"
   4
   5 #include <stdarg.h>
   6
   7 //#define BTN_WIDTH       20
   8 #define BTN_WIDTH       16
   9 #define ROW_HEIGHT      listBox.rowHeight /*16*/
  10
  11 default:
  12 extern int __ecereVMethodID_class_OnDisplay;
  13 extern int __ecereVMethodID_class_OnGetString;
  14
  15 private:
  16
  17 class DropBoxBits { bool noHighlight:1, noStipple:1, editText:1, activeColor:1, showNone:1, changeContents:1; };
  18
  19 public class DropBox : CommonControl
  20 {
  21    tabCycle = true;
  22    borderStyle = deep;
  23    style.activeColor = true;
  24
  25    class_property(icon) = "<:ecere>controls/dropBox.png";
  26
  27    watch(foreground)
  28    {
  29       listBox.foreground = foreground;
  30    };
  31    watch(background)
  32    {
  33       listBox.background = background;
  34    };
  35
  36 public:
  37    property bool activeStipple
  38    {
  39       property_category $"Appearance"
  40       set
  41       {
  42          style.noStipple = !value;
  43          Update(null);
  44       }
  45       get { return !style.noStipple; }
  46    };
  47    property bool showButton
  48    {
  49       property_category $"Appearance"
  50       set
  51       {
  52          button.visible = value;
  53          listBox.borderStyle = value ? contour : none;
  54       }
  55       get { return button.visible; }
  56    };
  57    property Alignment alignment
  58    {
  59       property_category $"Appearance"
  60       set
  61       {
  62          alignment = value;
  63          if(field)
  64             field.alignment = value;
  65       }
  66       get { return alignment; }
  67    };
  68    property bool noHighlight
  69    {
  70       property_category $"Appearance"
  71       set
  72       {
  73          if(this)
  74          {
  75             style.noHighlight = value;
  76             listBox.fullRowSelect = !value;
  77             Update(null);
  78          }
  79       }
  80       get { return style.noHighlight; }
  81    };
  82    property bool activeColor
  83    {
  84       property_category $"Appearance"
  85       set
  86       {
  87          if(this)
  88          {
  89             style.activeColor = value;
  90             Update(null);
  91          }
  92       }
  93       get { return style.activeColor; }
  94    };
  95    property DataRow currentRow
  96    {
  97       property_category $"Private"
  98       set
  99       {
 100          if(this)
 101          {
 102             currentRow = value;
 103             listBox.currentRow = value ? value : (style.showNone ? noneRow : null);
 104             if(style.editText && style.changeContents)
 105             {
 106                char tempString[4096];
 107                if(currentRow)
 108                   editBox.contents = ((char *(*)(void *, void *, char *, void *, bool *))(void *)dataType._vTbl[__ecereVMethodID_class_OnGetString])(dataType, currentRow.GetData(null), tempString, null, null);
 109                else
 110                   editBox.contents = "";
 111             }
 112             Update(null);
 113             if(style.editText)
 114             {
 115                if(editBox.modifiedDocument)
 116                {
 117                   NotifyTextEntry(master, this, editBox.contents, false);
 118                   editBox.modifiedDocument = false;
 119                }
 120                // editBox.Deactivate();
 121             }
 122          }
 123       }
 124       get { return currentRow; }
 125    };
 126    property DataRow firstRow { get { return this ? listBox.firstRow : null; } };
 127    property char * contents { property_category $"Data" set { if(editBox) editBox.contents = value; } get { return editBox ? editBox.contents : null; } };
 128    property bool editText
 129    {
 130       property_category $"Behavior"
 131       set
 132       {
 133          if(this)
 134          {
 135             if(value)
 136             {
 137                if(!editBox)
 138                {
 139                   editBox = EditBox
 140                   {
 141                      this, textHorzScroll = true, borderStyle = 0;
 142                      anchor = Anchor { left = 0, top = 0, right = BTN_WIDTH, bottom = 0 };
 143                      // visible = false, modifyVirtualArea = false;
 144                   };
 145                   incref editBox;
 146                   editBox.Create();
 147                   button.inactive = false;
 148                }
 149                style.editText = true;
 150                tabCycle = false;
 151             }
 152             else
 153             {
 154                if(editBox)
 155                {
 156                   editBox.Destroy(0);
 157                   delete editBox;
 158                   button.inactive = true;
 159                }
 160                style.editText = false;
 161             }
 162          }
 163       }
 164       get { return style.editText; }
 165    };
 166    property EditBox editBox { get { return editBox; } }
 167    property Seconds typingTimeout { property_category $"Behavior" set { listBox.typingTimeout = value; } get { return listBox.typingTimeout; } };
 168    property int rowHeight { property_category $"Appearance" set { listBox.rowHeight = value; } get { return listBox.rowHeight; } };
 169    property int maxShown
 170    {
 171       property_category $"Behavior"
 172       set
 173       {
 174          listBoxMaxShown = value;
 175          OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 176       }
 177       get { return listBoxMaxShown; }
 178    };
 179    property Window pullDown
 180    {
 181       get { return pulledWindow; }
 182    }
 183    property bool showNone
 184    {
 185       set
 186       {
 187          if(value != style.showNone)
 188          {
 189             if(style.showNone)
 190             {
 191                listBox.DeleteRow(noneRow);
 192                noneRow = null;
 193             }
 194             style.showNone = value;
 195             if(value)
 196             {
 197                noneRow = listBox.AddRowNone();
 198             }
 199          }
 200       }
 201       get { return style.showNone; }
 202    }
 203    property Color selectionColor { set { selectionColor = value; } get { return selectionColor; } isset { return selectionColor ? true : false; } };
 204    property bool changeContents
 205    {
 206       set { style.changeContents = value; }
 207       get { return style.changeContents; }
 208    }
 209
 210    property ListBox listBox { get { return listBox; } }
 211
 212    // Notifications
 213    virtual bool Window::NotifySelect(DropBox dropBox, DataRow row, Modifiers mods);
 214    virtual bool Window::NotifyClose(DropBox dropBox);
 215    virtual bool Window::NotifyHighlight(DropBox dropBox, DataRow row, Modifiers mods);
 216    virtual bool Window::NotifyTextEntry(DropBox dropBox, char * string, bool confirmed);
 217
 218    virtual Window OnDropDown()
 219    {
 220       // NASTY BUG ON WINDOWS IN PROPERTIES SHEET IF WE DON'T RECREATE THE LISTBOX HERE
 221       // To reproduce, comment out, select borderStyle property, alt-tab to another program, come back, drop down
 222       // The listBox goes annoyingly to 0, 0
 223       listBox.Destroy(0);
 224       listBox.Create();
 225
 226       ResizeListbox();
 227       // listBox.visible = true;
 228       return listBox;
 229    }
 230
 231    virtual void OnCloseDropDown(Window pullDown)
 232    {
 233       listBox.visible = false;
 234       if(style.editText)
 235       {
 236          editBox.ActivateEx(true, false, false, false, null, null);
 237          editBox.SelectAll();
 238       }
 239    }
 240
 241    // Methods
 242    DataRow AddStringf(char * format, ...)
 243    {
 244       if(this)
 245       {
 246          DataRow row;
 247
 248          char string[MAX_F_STRING];
 249          va_list args;
 250
 251          va_start(args, format);
 252          vsnprintf(string, sizeof(string), format, args);
 253          string[sizeof(string)-1] = 0;
 254          va_end(args);
 255
 256          row = AddRow();
 257          row.SetData(null, string);
 258          return row;
 259       }
 260       return null;
 261    }
 262
 263    DataRow AddString(char * string)
 264    {
 265       if(this)
 266       {
 267          DataRow row;
 268          row = AddRow();
 269          row.SetData(null, string);
 270          return row;
 271       }
 272       return null;
 273    }
 274
 275    void DeleteRow(DataRow row)
 276    {
 277       if(!row) row = currentRow;
 278       listBox.DeleteRow(row);
 279       /*
 280       if(row == currentRow)
 281          currentRow = null;*/
 282       Update(null);
 283    }
 284
 285    // Convenience function using current rows
 286    int64 GetTag()
 287    {
 288       return currentRow.tag;
 289    }
 290
 291    void * SetData(DataField field, any_object data)
 292    {
 293       if(this)
 294       {
 295          if(currentRow)
 296             return currentRow.SetData(field, data);
 297       }
 298       return null;
 299    }
 300
 301    any_object GetData(DataField field)
 302    {
 303       if(this)
 304       {
 305          // TODO: Fix this shouldn't be required (memguard?)
 306          return (void *)currentRow.GetData(field);
 307       }
 308       return null;
 309    }
 310
 311    void Sort(DataField field, int order)
 312    {
 313       listBox.Sort(field, order);
 314    }
 315
 316    void AddField(DataField field)
 317    {
 318       if(this)
 319       {
 320          if(!field)
 321             field = DataField { alignment = alignment };
 322
 323          listBox.AddField(field);
 324          this.field = listBox.firstField;
 325          dataType = this.field.dataType;
 326       }
 327    }
 328
 329    DataRow AddRow()
 330    {
 331       DataRow row = null;
 332       if(this)
 333       {
 334          row = listBox.AddRow();
 335          OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 336       }
 337       return row;
 338    }
 339
 340    DataRow AddRowAfter(DataRow after)
 341    {
 342       DataRow row = null;
 343       if(this)
 344       {
 345          row = listBox.AddRowAfter(after);
 346          OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 347       }
 348       return row;
 349    }
 350
 351    int GetRowCount()
 352    {
 353       return listBox.rowCount;
 354    }
 355
 356    void Clear()
 357    {
 358       if(this)
 359       {
 360          Window master = this.master;
 361          listBox.Clear();
 362
 363          if(currentRow && master)
 364          {
 365             currentRow = null;
 366             NotifySelect(master, this, null, 0);
 367          }
 368          currentRow = null;
 369          if(style.editText && style.changeContents)
 370             editBox.contents = "";
 371          Update(null);
 372          if(style.showNone)
 373             noneRow = listBox.AddRowNone();
 374       }
 375    }
 376
 377    DataRow FindRow(int64 tag)
 378    {
 379       if(this)
 380       {
 381          return listBox.FindRow(tag);
 382       }
 383       return null;
 384    }
 385
 386    DataRow FindSubRow(int64 tag)
 387    {
 388       if(this)
 389       {
 390          return listBox.FindSubRow(tag);
 391       }
 392       return null;
 393    }
 394
 395    // Drop Box Specific
 396    void SelectRow(DataRow row)
 397    {
 398       if(this)
 399       {
 400          currentRow = row;
 401          if(style.editText && style.changeContents)
 402          {
 403             char tempString[4096];
 404             if(currentRow)
 405                editBox.contents = ((char *(*)(void *, void *, char *, void *, bool *))(void *)dataType._vTbl[__ecereVMethodID_class_OnGetString])(dataType, currentRow.GetData(null), tempString, null, null);
 406             else
 407                editBox.contents = "";
 408          }
 409          listBox.SelectRow(currentRow ? currentRow : (style.showNone ? noneRow : null));
 410
 411          Update(null);
 412       }
 413    }
 414
 415    bool Save()
 416    {
 417       if(editBox && editBox.modifiedDocument)
 418       {
 419          NotifyTextEntry(master, this, editBox.contents, true);
 420          if(editBox)
 421             editBox.modifiedDocument = false;
 422          return true;
 423       }
 424       return false;
 425    }
 426
 427 private:
 428    DropBox()
 429    {
 430       listBoxMaxShown = 1000;
 431       field = listBox.firstField;
 432       dataType = field.dataType;
 433       style.changeContents = true;
 434       return true;
 435    }
 436
 437    ~DropBox()
 438    {
 439       delete editBox;
 440    }
 441
 442    void ResizeListbox()
 443    {
 444       int rowCount = Min(listBox.rowCount, listBoxMaxShown);
 445       int height = rowCount * ROW_HEIGHT;
 446       listBox.clientSize = { clientSize.w, height };
 447    }
 448
 449    void OnPosition(int x, int y, int width, int height)
 450    {
 451       if(pulledWindow)
 452       {
 453          int lx = absPosition.x - guiApp.desktop.absPosition.x;
 454          int ly = absPosition.y - guiApp.desktop.absPosition.y;
 455          int availHeight = pulledWindow.parent.clientSize.h;
 456          int height = pulledWindow.clientSize.h;
 457
 458          // If it won't fit below but fits above, place it above...
 459          if(ly + size.h + height > availHeight && height < ly)
 460             ly -= height;
 461          else
 462          {
 463             ly += size.h;
 464             if(ly + height > availHeight)
 465                height = ((availHeight - ly) / ROW_HEIGHT) * ROW_HEIGHT;
 466          }
 467
 468          if(!pulledWindow.initSize.w)
 469             pulledWindow.size.w = size.w;
 470          else
 471             // Align it to the right (pull down button)
 472             lx -= pulledWindow.size.w - size.w;
 473          pulledWindow.position = { lx, ly };
 474          pulledWindow.clientSize = { pulledWindow.clientSize.w, height };
 475       }
 476    }
 477
 478    bool OnKeyDown(Key key, unichar ch)
 479    {
 480       switch(key)
 481       {
 482          case hotKey:
 483          case space:
 484          case right:
 485          case escape:
 486             // ADDED THIS CHECK HERE TO NAVIGATE THROUGH GRID LISTBOX
 487             if(key == right)
 488             {
 489                if(eClass_IsDerived(master._class, class(DataBox)))
 490                {
 491                   if(eClass_IsDerived(master.master._class, class(ListBox)))
 492                      return true;
 493                }
 494                else if(eClass_IsDerived(master._class, class(ListBox)))
 495                   return true;
 496             }
 497             if(key == escape && !pulledWindow)
 498             {
 499                //if(editBox) button.Deactivate();
 500                //if(editBox) button.Activate();
 501                if(style.editText)
 502                {
 503                   if(editBox.modifiedDocument)
 504                   {
 505                      NotifyTextEntry(master, this, editBox.contents, false);
 506                      editBox.modifiedDocument = false;
 507                   }
 508                   //editBox.Deactivate();
 509                }
 510                break;
 511             }
 512             if(style.editText && (key == space || key == right))
 513                break;
 514
 515             if(pulledWindow)
 516             {
 517                OnCloseDropDown(pulledWindow);
 518                pulledWindow = null;
 519                button.checked = false;
 520                NotifyClose(master, this);
 521
 522                if(style.editText)
 523                {
 524                   if(editBox.modifiedDocument)
 525                   {
 526                      NotifyTextEntry(master, this, editBox.contents, false);
 527                      editBox.modifiedDocument = false;
 528                   }
 529                   editBox.Activate();
 530                }
 531             }
 532             else
 533             {
 534                listBox.currentRow = currentRow ? currentRow : (style.showNone ? noneRow : null);
 535                pulledWindow = OnDropDown();
 536                OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 537                if(pulledWindow) pulledWindow.visible = true;
 538                button.checked = true;
 539             }
 540             Update(null);
 541             return false;
 542          case enter:
 543          case keyPadEnter:
 544             if(!pulledWindow)
 545             {
 546                if(style.editText)
 547                {
 548                   if(editBox.modifiedDocument)
 549                   {
 550                      NotifyTextEntry(master, this, editBox.contents, true);
 551                      editBox.modifiedDocument = false;
 552                      //editBox.Deactivate();
 553                   }
 554
 555                   // Add code to look through listbox and set current row if listbox is used
 556                }
 557                break;
 558             }
 559             else
 560             {
 561                incref this;
 562
 563                OnCloseDropDown(pulledWindow);
 564                pulledWindow = null;
 565                button.checked = false;
 566                Update(null);
 567
 568                if(!NotifyClose(master, this))
 569                {
 570                   delete this;
 571                   return false;
 572                }
 573
 574                // Moved this from below NotifySelect
 575                currentRow = listBox.currentRow;
 576                if(currentRow && currentRow.noneRow) currentRow = null;
 577                if(style.editText && style.changeContents)
 578                {
 579                   char tempString[4096];
 580                   if(currentRow)
 581                      editBox.contents = ((char *(*)(void *, void *, char *, void *, bool *))(void *)dataType._vTbl[__ecereVMethodID_class_OnGetString])(dataType, currentRow.GetData(null), tempString, null, null);
 582                   else
 583                      editBox.contents = "";
 584                }
 585
 586                NotifySelect(master, this, currentRow, key.modifiers | { closingDropDown = true });
 587
 588                delete this;
 589                return false;
 590             }
 591             return false;
 592          //default:
 593          //   return listBox.OnKeyDown(key, ch);
 594       }
 595       return true;
 596    }
 597
 598    void OnApplyGraphics()
 599    {
 600       button.anchor = { right = 0, top = 0, bottom = 0 };
 601       button.size = { guiApp.textMode ? 8 : BTN_WIDTH, 0 };
 602    }
 603
 604    /*Timer timer
 605    {
 606       window = this, delay = 0.01;
 607
 608       bool DelayExpired()
 609       {
 610          background = active ? red : lime;
 611          parent.parent.background = parent.parent.active ? red : lime;
 612          guiApp.desktop.Update(null);
 613          return true;
 614       }
 615    };*/
 616
 617    void OnRedraw(Surface surface)
 618    {
 619       //timer.started = true;
 620       if(!style.editText)
 621       {
 622          if(active && !pulledWindow/*listBox.visible*/)
 623          {
 624             if(style.activeColor)
 625             {
 626                surface.SetBackground(selectionColor ? selectionColor : SELECTION_COLOR);
 627                if(!style.noHighlight || !currentRow)
 628                {
 629                   surface.Area(0,0, clientSize.w-1,clientSize.h-1);
 630                }
 631             }
 632          }
 633          if(!isEnabled)
 634             surface.SetForeground(Color { 85,85,85 } );
 635          else
 636             surface.SetForeground((active && style.activeColor && !pulledWindow /*listBox.visible*/) ? SELECTION_TEXT : foreground);
 637          surface.TextOpacity(true);
 638
 639          if(currentRow)
 640          {
 641             DataDisplayFlags displayFlags { active = active, current = true, dropBox = true, selected = true, fullRow = true };
 642             ((void (*)(void *, void *, void *, int, int, int, void *, uint, uint))(void *)dataType._vTbl[__ecereVMethodID_class_OnDisplay])(dataType, currentRow.GetData(null), surface, 3,
 643                1+(clientSize.h - listBox.rowHeight) / 2, clientSize.w - (button.visible ? button.size.w : 0) - 3,
 644                field.userData, alignment, displayFlags);
 645          }
 646          else
 647             surface.WriteText(2,2, "(none)", 6);
 648
 649          if(!style.noStipple && (!style.noHighlight || !currentRow))
 650          {
 651             surface.SetForeground(0xFFFFFF80);
 652             if(active && !pulledWindow /*listBox.visible*/)
 653             {
 654                surface.Rectangle(0,0,clientSize.w-1-BTN_WIDTH,clientSize.h-1);
 655                surface.SetForeground(black);
 656                surface.LineStipple(0xAAAA);
 657                surface.Rectangle(0,0,clientSize.w-1-BTN_WIDTH,clientSize.h-1);
 658                surface.LineStipple(0);
 659             }
 660          }
 661       }
 662    }
 663
 664    bool OnResizing(int *width, int *height)
 665    {
 666       int rowHeight = 0;
 667
 668       display.FontExtent(fontObject, "W", 1, null, &rowHeight);
 669       rowHeight = Max(rowHeight, 16);
 670
 671       if(!*width) *width = Max(*width, rowHeight * 100 / 16);
 672
 673       //if(!*width) *width = Max(*width, 100);
 674       //if(!*height) *height = Max(*height, 20);
 675       if(!*height) *height = Max(*height, rowHeight * 20 / 16);
 676
 677       return true;
 678    }
 679
 680    /*
 681    watch(font)
 682    {
 683       SetInitSize(initSize);
 684    };
 685    */
 686
 687    bool OnLeftButtonDown(int x, int y, Modifiers mods)
 688    {
 689       Update(null);
 690       if(pulledWindow)
 691       {
 692          OnCloseDropDown(pulledWindow);
 693          button.checked = false;
 694          pulledWindow = null;
 695
 696          if(!NotifyClose(master, this))
 697             return false;
 698       }
 699       else
 700       {
 701          listBox.currentRow = currentRow ? currentRow : (style.showNone ? noneRow : null);
 702          pulledWindow = OnDropDown();
 703          OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 704          if(pulledWindow) pulledWindow.visible = true;
 705          if(listBox.freeSelect)
 706             pulledWindow.OnLeftButtonDown(-2,-2, 0);
 707          button.checked = true;
 708       }
 709       return true;
 710    }
 711
 712    bool OnKeyHit(Key key, unichar ch)
 713    {
 714       DataRow currentRow = this.currentRow;
 715
 716       if(!pulledWindow /*listBox.visible*/)
 717       {
 718          int c;
 719          if(style.showNone && !currentRow) currentRow = noneRow;
 720
 721          switch(key)
 722          {
 723             case wheelDown:
 724             case down: currentRow = currentRow ? currentRow.next : null; break;
 725             case wheelUp:
 726             case up:   currentRow = currentRow ? currentRow.prev : null; break;
 727             case pageDown:
 728                for(c = 0; c<listBoxMaxShown && currentRow && currentRow.next; c++, currentRow = currentRow.next);
 729                break;
 730             case pageUp:
 731                for(c = 0; c<listBoxMaxShown && currentRow && currentRow.prev; c++, currentRow = currentRow.prev);
 732                break;
 733             case end:
 734                for(; currentRow && currentRow.next; currentRow = currentRow.next);
 735                break;
 736             case home:
 737                for(; currentRow && currentRow.prev; currentRow = currentRow.prev);
 738                break;
 739             default:
 740                if(!editBox || button.active || !editBox.active || editBox.OnKeyHit(key, ch))
 741                {
 742                   return listBox.OnKeyHit(key, ch);
 743                }
 744                else
 745                   return false;
 746          }
 747          if(currentRow)
 748          {
 749             if(currentRow.noneRow) currentRow = null;
 750             property::currentRow = currentRow;
 751             //return
 752                NotifySelect(master, this, currentRow, key.modifiers);
 753             //return false;
 754          }
 755          return false;
 756       }
 757       else
 758       {
 759          if(listBox.vertScroll)
 760          {
 761             if(key == wheelUp)
 762                listBox.vertScroll.Action(up, 0, key);
 763             else if(key == wheelDown)
 764                listBox.vertScroll.Action(down, 0, key);
 765          }
 766          return listBox.OnKeyHit(key, ch);
 767       }
 768       return true;
 769    }
 770
 771    bool OnActivate(bool active, Window swap, bool * goOnWithActivation, bool direct)
 772    {
 773       // WAS !active JUST MISSING HERE ?
 774       if(!active && style.editText)
 775       {
 776          if(editBox.modifiedDocument)
 777          {
 778             if(editBox) editBox.modifiedDocument = false;
 779             NotifyTextEntry(master, this, editBox.contents, true); //false);
 780             // MOVED THIS ABOVE TO AVOID INFINITE RECURSION
 781             // if(editBox) editBox.modifiedDocument = false;
 782          }
 783          //editBox.Deactivate();
 784       }
 785       Update(null);
 786       return true;
 787    }
 788
 789    public Button button
 790    {
 791       this, toggle = true, bevel = true, inactive = true,
 792       anchor = Anchor { right = 0, top = 0, bottom = 0 },
 793       size = Size { BTN_WIDTH, 0 },
 794       symbol = 25;
 795       bitmap = { "<:ecere>elements/arrowDown.png" };
 796
 797       bool NotifyPushed(Button control, int x, int y, Modifiers mods)
 798       {
 799          if(pulledWindow)
 800          {
 801             OnCloseDropDown(pulledWindow);
 802             pulledWindow = null;
 803             button.checked = false;
 804             NotifyClose(master, this);
 805          }
 806          else
 807          {
 808             incref this;
 809             if(editBox && editBox.modifiedDocument)
 810             {
 811                NotifyTextEntry(master, this, editBox.contents, true);
 812                editBox.modifiedDocument = false;
 813             }
 814             pulledWindow = OnDropDown();
 815             if(pulledWindow)
 816             {
 817                OnPosition(position.x, position.y, clientSize.w, clientSize.h);
 818                if(listBox.freeSelect)
 819                   pulledWindow.OnLeftButtonDown(-2,-2, 0);
 820                button.checked = true;
 821                pulledWindow.visible = true;
 822             }
 823             delete this;
 824          }
 825          Update(null);
 826          return true;
 827       }
 828    };
 829
 830    ListBox listBox
 831    {
 832       master = this, fullRowSelect = true, freeSelect = true, /* noHighlight = style.noHighlight , */
 833       interim = true, hasVertScroll = true, borderStyle = contour, position = { absPosition.x, absPosition.y + size.h },
 834       size.w = size.w, visible = false;
 835
 836       bool NotifyActivate(Window control, bool active, Window swap)
 837       {
 838          if(!active)
 839          {
 840             Update(null);
 841             if(swap != button && swap != this)
 842             {
 843                if(editBox && editBox.modifiedDocument)
 844                {
 845                   NotifyTextEntry(master, this, editBox.contents, true);
 846                   editBox.modifiedDocument = false;
 847                }
 848
 849                OnCloseDropDown(pulledWindow);
 850                pulledWindow = null;
 851                button.checked = false;
 852                NotifyClose(master, this);
 853             }
 854          }
 855          return true;
 856       }
 857
 858       bool NotifySelect(ListBox listBox, DataRow row, Modifiers mods)
 859       {
 860          Update(null);
 861
 862          // Add code to set text to list box contents if it has an editbox
 863
 864          if(pulledWindow)
 865          {
 866             OnCloseDropDown(pulledWindow);
 867             pulledWindow = null;
 868             button.checked = false;
 869             mods.closingDropDown = true;
 870             if(!NotifyClose(master, this))
 871                return false;
 872          }
 873          currentRow = (row && !row.noneRow) ? row : null;
 874          if(style.editText && style.changeContents)
 875          {
 876             char tempString[4096];
 877             if(currentRow)
 878                editBox.contents = ((char *(*)(void *, void *, char *, void *, bool *))(void *)dataType._vTbl[__ecereVMethodID_class_OnGetString])(dataType, currentRow.GetData(null), tempString, null, null);
 879             else
 880                editBox.contents = "";
 881             if(active)
 882                editBox.SelectAll();
 883          }
 884          button.Deactivate();
 885          return NotifySelect(master, this, currentRow, mods);
 886       }
 887
 888       bool NotifyHighlight(ListBox control, DataRow row, Modifiers mods)
 889       {
 890          return NotifyHighlight(master, this, row, mods);
 891       }
 892
 893       bool NotifyKeyDown(ListBox listBox, DataRow selection, Key key, unichar ch)
 894       {
 895          return OnKeyDown(key, ch);
 896          //return true;
 897       }
 898    };
 899
 900    bool OnPostCreate()
 901    {
 902       if(font)
 903          listBox.font = { font.faceName, font.size };
 904       return true;
 905    }
 906
 907    DropBoxBits style;
 908    Window pulledWindow;
 909    DataRow currentRow;
 910    int listBoxMaxShown;
 911    Class dataType;
 912    DataField field;
 913    EditBox editBox;
 914    Alignment alignment;
 915    DataRow noneRow;
 916    Color selectionColor;
 917 };