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