src/propgrid/editors.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/propgrid/editors.cpp
   3 // Purpose:     wxPropertyGrid editors
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2007-04-14
   7 // RCS-ID:      $Id:
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx/wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_PROPGRID
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/defs.h"
  23     #include "wx/object.h"
  24     #include "wx/hash.h"
  25     #include "wx/string.h"
  26     #include "wx/log.h"
  27     #include "wx/event.h"
  28     #include "wx/window.h"
  29     #include "wx/panel.h"
  30     #include "wx/dc.h"
  31     #include "wx/dcclient.h"
  32     #include "wx/dcmemory.h"
  33     #include "wx/button.h"
  34     #include "wx/pen.h"
  35     #include "wx/brush.h"
  36     #include "wx/cursor.h"
  37     #include "wx/dialog.h"
  38     #include "wx/settings.h"
  39     #include "wx/msgdlg.h"
  40     #include "wx/choice.h"
  41     #include "wx/stattext.h"
  42     #include "wx/scrolwin.h"
  43     #include "wx/dirdlg.h"
  44     #include "wx/sizer.h"
  45     #include "wx/textdlg.h"
  46     #include "wx/filedlg.h"
  47     #include "wx/statusbr.h"
  48     #include "wx/intl.h"
  49     #include "wx/frame.h"
  50 #endif
  51
  52
  53 #include "wx/timer.h"
  54 #include "wx/dcbuffer.h"
  55 #include "wx/bmpbuttn.h"
  56
  57
  58 // This define is necessary to prevent macro clearing
  59 #define __wxPG_SOURCE_FILE__
  60
  61 #include <wx/propgrid/propgrid.h>
  62 #include <wx/propgrid/editors.h>
  63 #include <wx/propgrid/props.h>
  64
  65 #if wxPG_USE_RENDERER_NATIVE
  66     #include <wx/renderer.h>
  67 #endif
  68
  69 // How many pixels between textctrl and button
  70 #ifdef __WXMAC__
  71     #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        8
  72 #else
  73     #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        2
  74 #endif
  75
  76 #define wxPG_BUTTON_SIZEDEC                         0
  77
  78 #include <wx/odcombo.h>
  79
  80 #ifdef __WXMSW__
  81     #include <wx/msw/private.h>
  82 #endif
  83
  84 // -----------------------------------------------------------------------
  85
  86 #if defined(__WXMSW__)
  87     // tested
  88     #define wxPG_NAT_TEXTCTRL_BORDER_X          0 // Unremovable border of native textctrl.
  89     #define wxPG_NAT_TEXTCTRL_BORDER_Y          0 // Unremovable border of native textctrl.
  90
  91     #define wxPG_NAT_BUTTON_BORDER_ANY          1
  92     #define wxPG_NAT_BUTTON_BORDER_X            1
  93     #define wxPG_NAT_BUTTON_BORDER_Y            1
  94
  95     #define wxPG_CHECKMARK_XADJ                 1
  96     #define wxPG_CHECKMARK_YADJ                 (-1)
  97     #define wxPG_CHECKMARK_WADJ                 0
  98     #define wxPG_CHECKMARK_HADJ                 0
  99     #define wxPG_CHECKMARK_DEFLATE              0
 100
 101     #define wxPG_TEXTCTRLYADJUST                (m_spacingy+0)
 102
 103 #elif defined(__WXGTK__)
 104     // tested
 105     #define wxPG_CHECKMARK_XADJ                 0
 106     #define wxPG_CHECKMARK_YADJ                 0
 107     #define wxPG_CHECKMARK_WADJ                 (-1)
 108     #define wxPG_CHECKMARK_HADJ                 (-1)
 109     #define wxPG_CHECKMARK_DEFLATE              3
 110
 111     #define wxPG_NAT_TEXTCTRL_BORDER_X      3 // Unremovable border of native textctrl.
 112     #define wxPG_NAT_TEXTCTRL_BORDER_Y      3 // Unremovable border of native textctrl.
 113
 114     #define wxPG_NAT_BUTTON_BORDER_ANY      1
 115     #define wxPG_NAT_BUTTON_BORDER_X        1
 116     #define wxPG_NAT_BUTTON_BORDER_Y        1
 117
 118     #define wxPG_TEXTCTRLYADJUST            0
 119
 120 #elif defined(__WXMAC__)
 121     // *not* tested
 122     #define wxPG_CHECKMARK_XADJ                 0
 123     #define wxPG_CHECKMARK_YADJ                 0
 124     #define wxPG_CHECKMARK_WADJ                 0
 125     #define wxPG_CHECKMARK_HADJ                 0
 126     #define wxPG_CHECKMARK_DEFLATE              0
 127
 128     #define wxPG_NAT_TEXTCTRL_BORDER_X      0 // Unremovable border of native textctrl.
 129     #define wxPG_NAT_TEXTCTRL_BORDER_Y      0 // Unremovable border of native textctrl.
 130
 131     #define wxPG_NAT_BUTTON_BORDER_ANY      0
 132     #define wxPG_NAT_BUTTON_BORDER_X        0
 133     #define wxPG_NAT_BUTTON_BORDER_Y        0
 134
 135     #define wxPG_TEXTCTRLYADJUST            3
 136
 137 #else
 138     // defaults
 139     #define wxPG_CHECKMARK_XADJ                 0
 140     #define wxPG_CHECKMARK_YADJ                 0
 141     #define wxPG_CHECKMARK_WADJ                 0
 142     #define wxPG_CHECKMARK_HADJ                 0
 143     #define wxPG_CHECKMARK_DEFLATE              0
 144
 145     #define wxPG_NAT_TEXTCTRL_BORDER_X      0 // Unremovable border of native textctrl.
 146     #define wxPG_NAT_TEXTCTRL_BORDER_Y      0 // Unremovable border of native textctrl.
 147
 148     #define wxPG_NAT_BUTTON_BORDER_ANY      0
 149     #define wxPG_NAT_BUTTON_BORDER_X        0
 150     #define wxPG_NAT_BUTTON_BORDER_Y        0
 151
 152     #define wxPG_TEXTCTRLYADJUST            0
 153
 154 #endif
 155
 156 #if (!wxPG_NAT_TEXTCTRL_BORDER_X && !wxPG_NAT_TEXTCTRL_BORDER_Y)
 157     #define wxPG_ENABLE_CLIPPER_WINDOW      0
 158 #else
 159     #define wxPG_ENABLE_CLIPPER_WINDOW      1
 160 #endif
 161
 162
 163 // for odcombo
 164 #define wxPG_CHOICEXADJUST           0
 165 #define wxPG_CHOICEYADJUST           0
 166
 167 #define ODCB_CUST_PAINT_MARGIN               6  // Number added to image width for SetCustomPaintWidth
 168
 169 // Milliseconds to wait for two mouse-ups after focus inorder
 170 // to trigger a double-click.
 171 #define DOUBLE_CLICK_CONVERSION_TRESHOLD        500
 172
 173 // -----------------------------------------------------------------------
 174 // wxPGEditor
 175 // -----------------------------------------------------------------------
 176
 177 IMPLEMENT_ABSTRACT_CLASS(wxPGEditor, wxObject)
 178
 179
 180 wxPGEditor::~wxPGEditor()
 181 {
 182 }
 183
 184 void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& text ) const
 185 {
 186     if ( !property->IsValueUnspecified() )
 187         dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );
 188 }
 189
 190 bool wxPGEditor::GetValueFromControl( wxVariant&, wxPGProperty*, wxWindow* ) const
 191 {
 192     return false;
 193 }
 194
 195 void wxPGEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow*, const wxString& ) const
 196 {
 197 }
 198
 199
 200 void wxPGEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow*, int ) const
 201 {
 202 }
 203
 204
 205 int wxPGEditor::InsertItem( wxWindow*, const wxString&, int ) const
 206 {
 207     return -1;
 208 }
 209
 210
 211 void wxPGEditor::DeleteItem( wxWindow*, int ) const
 212 {
 213     return;
 214 }
 215
 216
 217 void wxPGEditor::OnFocus( wxPGProperty*, wxWindow* ) const
 218 {
 219 }
 220
 221
 222 bool wxPGEditor::CanContainCustomImage() const
 223 {
 224     return false;
 225 }
 226
 227 // -----------------------------------------------------------------------
 228 // wxPGClipperWindow
 229 // -----------------------------------------------------------------------
 230
 231
 232 #if wxPG_ENABLE_CLIPPER_WINDOW
 233
 234 //
 235 // Clipper window is used to "remove" borders from controls
 236 // which otherwise insist on having them despite of supplied
 237 // wxNO_BORDER window style.
 238 //
 239 class wxPGClipperWindow : public wxWindow
 240 {
 241     DECLARE_CLASS(wxPGClipperWindow)
 242 public:
 243
 244     wxPGClipperWindow()
 245         : wxWindow()
 246     {
 247         wxPGClipperWindow::Init();
 248     }
 249
 250     wxPGClipperWindow(wxWindow* parent,
 251                       wxWindowID id,
 252                       const wxPoint& pos = wxDefaultPosition,
 253                       const wxSize& size = wxDefaultSize)
 254     {
 255         Init();
 256         Create(parent,id,pos,size);
 257     }
 258
 259     void Create(wxWindow* parent,
 260                 wxWindowID id,
 261                 const wxPoint& pos = wxDefaultPosition,
 262                 const wxSize& size = wxDefaultSize);
 263
 264     virtual ~wxPGClipperWindow();
 265
 266     virtual bool ProcessEvent(wxEvent& event);
 267
 268     inline wxWindow* GetControl() const { return m_ctrl; }
 269
 270     // This is called before wxControl is constructed.
 271     void GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz );
 272
 273     // This is caleed after wxControl has been constructed.
 274     void SetControl( wxWindow* ctrl );
 275
 276     virtual void Refresh( bool eraseBackground = true,
 277                           const wxRect *rect = (const wxRect *) NULL );
 278     virtual void SetFocus();
 279
 280     virtual bool SetFont(const wxFont& font);
 281
 282     inline int GetXClip() const { return m_xadj; }
 283
 284     inline int GetYClip() const { return m_yadj; }
 285
 286 protected:
 287     wxWindow*       m_ctrl;
 288
 289     int             m_xadj; // Horizontal border clip.
 290
 291     int             m_yadj; // Vertical border clip.
 292
 293 private:
 294     void Init ()
 295     {
 296         m_ctrl = (wxWindow*) NULL;
 297     }
 298 };
 299
 300
 301 IMPLEMENT_CLASS(wxPGClipperWindow,wxWindow)
 302
 303
 304 // This is called before wxControl is constructed.
 305 void wxPGClipperWindow::GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz )
 306 {
 307     m_xadj = xadj;
 308     m_yadj = yadj;
 309     pt.x = -xadj;
 310     pt.y = -yadj;
 311     wxSize own_size = GetSize();
 312     sz.x = own_size.x+(xadj*2);
 313     sz.y = own_size.y+(yadj*2);
 314 }
 315
 316
 317 // This is caleed after wxControl has been constructed.
 318 void wxPGClipperWindow::SetControl( wxWindow* ctrl )
 319 {
 320     m_ctrl = ctrl;
 321
 322     // GTK requires this.
 323     ctrl->SetSizeHints(3,3);
 324
 325     // Correct size of this window to match the child.
 326     wxSize sz = GetSize();
 327     wxSize chsz = ctrl->GetSize();
 328
 329     int hei_adj = chsz.y - (sz.y+(m_yadj*2));
 330     if ( hei_adj )
 331         SetSize(sz.x,chsz.y-(m_yadj*2));
 332
 333 }
 334
 335
 336 void wxPGClipperWindow::Refresh( bool eraseBackground, const wxRect *rect )
 337 {
 338     wxWindow::Refresh(false,rect);
 339     if ( m_ctrl )
 340         m_ctrl->Refresh(eraseBackground);
 341 }
 342
 343
 344 // Pass focus to control
 345 void wxPGClipperWindow::SetFocus()
 346 {
 347     if ( m_ctrl )
 348         m_ctrl->SetFocus();
 349     else
 350         wxWindow::SetFocus();
 351 }
 352
 353
 354 bool wxPGClipperWindow::SetFont(const wxFont& font)
 355 {
 356     bool res = wxWindow::SetFont(font);
 357     if ( m_ctrl )
 358         return m_ctrl->SetFont(font);
 359     return res;
 360 }
 361
 362
 363 void wxPGClipperWindow::Create(wxWindow* parent,
 364                                wxWindowID id,
 365                                const wxPoint& pos,
 366                                const wxSize& size )
 367 {
 368     wxWindow::Create(parent,id,pos,size);
 369 }
 370
 371
 372 wxPGClipperWindow::~wxPGClipperWindow()
 373 {
 374 }
 375
 376
 377 bool wxPGClipperWindow::ProcessEvent(wxEvent& event)
 378 {
 379     if ( event.GetEventType() == wxEVT_SIZE )
 380     {
 381         if ( m_ctrl )
 382         {
 383             // Maintain correct size relationship.
 384             wxSize sz = GetSize();
 385             m_ctrl->SetSize(sz.x+(m_xadj*2),sz.y+(m_yadj*2));
 386             event.Skip();
 387             return false;
 388         }
 389     }
 390     return wxWindow::ProcessEvent(event);
 391 }
 392
 393 #endif // wxPG_ENABLE_CLIPPER_WINDOW
 394
 395 /*wxWindow* wxPropertyGrid::GetActualEditorControl( wxWindow* ctrl )
 396 {
 397 #if wxPG_ENABLE_CLIPPER_WINDOW
 398     // Pass real control instead of clipper window
 399     if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
 400     {
 401         return ((wxPGClipperWindow*)ctrl)->GetControl();
 402     }
 403 #else
 404     return ctrl;
 405 #endif
 406 }*/
 407
 408 // -----------------------------------------------------------------------
 409 // wxPGTextCtrlEditor
 410 // -----------------------------------------------------------------------
 411
 412 // Clipper window support macro (depending on whether it is used
 413 // for this editor or not)
 414 #if wxPG_NAT_TEXTCTRL_BORDER_X || wxPG_NAT_TEXTCTRL_BORDER_Y
 415     #define wxPG_NAT_TEXTCTRL_BORDER_ANY    1
 416 #else
 417     #define wxPG_NAT_TEXTCTRL_BORDER_ANY    0
 418 #endif
 419
 420 WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrl,wxPGTextCtrlEditor,wxPGEditor)
 421
 422
 423 wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
 424                                                    wxPGProperty* property,
 425                                                    const wxPoint& pos,
 426                                                    const wxSize& sz ) const
 427 {
 428     wxString text;
 429
 430     //
 431     // If has children, and limited editing is specified, then don't create.
 432     if ( (property->GetFlags() & wxPG_PROP_NOEDITOR) &&
 433          property->GetChildCount() )
 434         return (wxWindow*) NULL;
 435
 436     if ( !property->IsValueUnspecified() )
 437         text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
 438
 439     int flags = 0;
 440     if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
 441          property->IsKindOf(CLASSINFO(wxStringProperty)) )
 442         flags |= wxTE_PASSWORD;
 443
 444     wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,(wxWindow*)NULL,flags,
 445                                                      property->GetMaxLength());
 446
 447     return wnd;
 448 }
 449
 450 #if 0
 451 void wxPGTextCtrlEditor::DrawValue( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const
 452 {
 453     if ( !property->IsValueUnspecified() )
 454     {
 455         wxString drawStr = property->GetDisplayedString();
 456
 457         // Code below should no longer be needed, as the obfuscation
 458         // is now done in GetValueAsString.
 459         /*if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
 460              property->IsKindOf(WX_PG_CLASSINFO(wxStringProperty)) )
 461         {
 462             size_t a = drawStr.length();
 463             drawStr.Empty();
 464             drawStr.Append(wxS('*'),a);
 465         }*/
 466         dc.DrawText( drawStr, rect.x+wxPG_XBEFORETEXT, rect.y );
 467     }
 468 }
 469 #endif
 470
 471 void wxPGTextCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
 472 {
 473     wxTextCtrl* tc = wxDynamicCast(ctrl, wxTextCtrl);
 474     if (!tc) return;
 475
 476     wxString s;
 477
 478     if ( tc->HasFlag(wxTE_PASSWORD) )
 479         s = property->GetValueAsString(wxPG_FULL_VALUE);
 480     else
 481         s = property->GetDisplayedString();
 482
 483     tc->SetValue(s);
 484 }
 485
 486
 487 // Provided so that, for example, ComboBox editor can use the same code
 488 // (multiple inheritance would get way too messy).
 489 bool wxPGTextCtrlEditor::OnTextCtrlEvent( wxPropertyGrid* propGrid,
 490                                           wxPGProperty* WXUNUSED(property),
 491                                           wxWindow* ctrl,
 492                                           wxEvent& event )
 493 {
 494     if ( !ctrl )
 495         return false;
 496
 497     if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
 498     {
 499         if ( propGrid->IsEditorsValueModified() )
 500         {
 501             return true;
 502         }
 503     }
 504     else if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED )
 505     {
 506         //
 507         // Pass this event outside wxPropertyGrid so that,
 508         // if necessary, program can tell when user is editing
 509         // a textctrl.
 510         // FIXME: Is it safe to change event id in the middle of event
 511         //        processing (seems to work, but...)?
 512         event.Skip();
 513         event.SetId(propGrid->GetId());
 514
 515         propGrid->EditorsValueWasModified();
 516     }
 517     return false;
 518 }
 519
 520
 521 bool wxPGTextCtrlEditor::OnEvent( wxPropertyGrid* propGrid,
 522                                   wxPGProperty* property,
 523                                   wxWindow* ctrl,
 524                                   wxEvent& event ) const
 525 {
 526     return wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,ctrl,event);
 527 }
 528
 529
 530 bool wxPGTextCtrlEditor::GetTextCtrlValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl )
 531 {
 532     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
 533     wxString textVal = tc->GetValue();
 534
 535     if ( property->UsesAutoUnspecified() && !textVal.length() )
 536     {
 537         variant.MakeNull();
 538         return true;
 539     }
 540
 541     bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE);
 542
 543     // Changing unspecified always causes event (returning
 544     // true here should be enough to trigger it).
 545     // TODO: Move to propgrid.cpp
 546     if ( !res && variant.IsNull() )
 547         res = true;
 548
 549     return res;
 550 }
 551
 552
 553 bool wxPGTextCtrlEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
 554 {
 555     return wxPGTextCtrlEditor::GetTextCtrlValueFromControl(variant, property, ctrl);
 556 }
 557
 558
 559 void wxPGTextCtrlEditor::SetValueToUnspecified( wxPGProperty* property, wxWindow* ctrl ) const
 560 {
 561     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
 562
 563     wxPropertyGrid* pg = property->GetGrid();
 564     wxASSERT(pg);  // Really, property grid should exist if editor does
 565     if ( pg )
 566         tc->SetValue(wxEmptyString);
 567 }
 568
 569
 570 void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
 571 {
 572     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
 573
 574     wxPropertyGrid* pg = property->GetGrid();
 575     wxASSERT(pg);  // Really, property grid should exist if editor does
 576     if ( pg )
 577         tc->SetValue(txt);
 578 }
 579
 580
 581 void wxPGTextCtrlEditor::OnFocus( wxPGProperty*, wxWindow* wnd ) const
 582 {
 583     wxTextCtrl* tc = wxStaticCast(wnd, wxTextCtrl);
 584
 585     tc->SetSelection(-1,-1);
 586 }
 587
 588
 589 wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
 590
 591
 592 // -----------------------------------------------------------------------
 593 // wxPGChoiceEditor
 594 // -----------------------------------------------------------------------
 595
 596
 597 WX_PG_IMPLEMENT_EDITOR_CLASS(Choice,wxPGChoiceEditor,wxPGEditor)
 598
 599
 600 // This is a special enhanced double-click processor class.
 601 // In essence, it allows for double-clicks for which the
 602 // first click "created" the control.
 603 class wxPGDoubleClickProcessor : public wxEvtHandler
 604 {
 605 public:
 606
 607     wxPGDoubleClickProcessor( wxOwnerDrawnComboBox* combo, wxPGProperty* property )
 608         : wxEvtHandler()
 609     {
 610         m_timeLastMouseUp = 0;
 611         m_combo = combo;
 612         m_property = property;
 613         m_downReceived = false;
 614     }
 615
 616 protected:
 617
 618     void OnMouseEvent( wxMouseEvent& event )
 619     {
 620         wxLongLong t = ::wxGetLocalTimeMillis();
 621         int evtType = event.GetEventType();
 622
 623         if ( m_property->HasFlag(wxPG_PROP_USE_DCC) &&
 624              m_property->IsKindOf(CLASSINFO(wxBoolProperty)) &&
 625              !m_combo->IsPopupShown() )
 626         {
 627             // Just check that it is in the text area
 628             wxPoint pt = event.GetPosition();
 629             if ( m_combo->GetTextRect().Contains(pt) )
 630             {
 631                 if ( evtType == wxEVT_LEFT_DOWN )
 632                 {
 633                     // Set value to avoid up-events without corresponding downs
 634                     m_downReceived = true;
 635                 }
 636                 else if ( evtType == wxEVT_LEFT_DCLICK )
 637                 {
 638                     // We'll make our own double-clicks
 639                     event.SetEventType(0);
 640                     return;
 641                 }
 642                 else if ( evtType == wxEVT_LEFT_UP )
 643                 {
 644                     if ( m_downReceived || m_timeLastMouseUp == 1 )
 645                     {
 646                         wxLongLong timeFromLastUp = (t-m_timeLastMouseUp);
 647
 648                         if ( timeFromLastUp < DOUBLE_CLICK_CONVERSION_TRESHOLD )
 649                         {
 650                             event.SetEventType(wxEVT_LEFT_DCLICK);
 651                             m_timeLastMouseUp = 1;
 652                         }
 653                         else
 654                         {
 655                             m_timeLastMouseUp = t;
 656                         }
 657                     }
 658                 }
 659             }
 660         }
 661
 662         event.Skip();
 663     }
 664
 665     void OnSetFocus( wxFocusEvent& event )
 666     {
 667         m_timeLastMouseUp = ::wxGetLocalTimeMillis();
 668         event.Skip();
 669     }
 670
 671 private:
 672     wxLongLong                  m_timeLastMouseUp;
 673     wxOwnerDrawnComboBox*       m_combo;
 674     wxPGProperty*               m_property;  // Selected property
 675     bool                        m_downReceived;
 676
 677     DECLARE_EVENT_TABLE()
 678 };
 679
 680 BEGIN_EVENT_TABLE(wxPGDoubleClickProcessor, wxEvtHandler)
 681     EVT_MOUSE_EVENTS(wxPGDoubleClickProcessor::OnMouseEvent)
 682     EVT_SET_FOCUS(wxPGDoubleClickProcessor::OnSetFocus)
 683 END_EVENT_TABLE()
 684
 685
 686
 687 class wxPGComboBox : public wxOwnerDrawnComboBox
 688 {
 689 public:
 690
 691     wxPGComboBox()
 692         : wxOwnerDrawnComboBox()
 693     {
 694         m_dclickProcessor = (wxPGDoubleClickProcessor*) NULL;
 695         m_sizeEventCalled = false;
 696     }
 697
 698     ~wxPGComboBox()
 699     {
 700         if ( m_dclickProcessor )
 701         {
 702             RemoveEventHandler(m_dclickProcessor);
 703             delete m_dclickProcessor;
 704         }
 705     }
 706
 707     bool Create(wxWindow *parent,
 708                 wxWindowID id,
 709                 const wxString& value,
 710                 const wxPoint& pos,
 711                 const wxSize& size,
 712                 const wxArrayString& choices,
 713                 long style = 0,
 714                 const wxValidator& validator = wxDefaultValidator,
 715                 const wxString& name = wxS("wxOwnerDrawnComboBox"))
 716     {
 717         if ( !wxOwnerDrawnComboBox::Create( parent,
 718                                             id,
 719                                             value,
 720                                             pos,
 721                                             size,
 722                                             choices,
 723                                             style,
 724                                             validator,
 725                                             name ) )
 726             return false;
 727
 728         m_dclickProcessor = new wxPGDoubleClickProcessor(this, GetGrid()->GetSelection() );
 729
 730         PushEventHandler(m_dclickProcessor);
 731
 732         return true;
 733     }
 734
 735     virtual void OnDrawItem( wxDC& dc, const wxRect& rect, int item, int flags ) const
 736     {
 737         wxPropertyGrid* pg = GetGrid();
 738         pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,dc,(wxRect&)rect,flags);
 739     }
 740     virtual wxCoord OnMeasureItem( size_t item ) const
 741     {
 742         wxPropertyGrid* pg = GetGrid();
 743         wxRect rect;
 744         rect.x = -1;
 745         rect.width = 0;
 746         pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
 747         return rect.height;
 748     }
 749
 750     wxPropertyGrid* GetGrid() const
 751     {
 752         wxPropertyGrid* pg = wxDynamicCast(GetParent()->GetParent(),wxPropertyGrid);
 753         wxASSERT(pg);
 754         return pg;
 755     }
 756
 757     virtual wxCoord OnMeasureItemWidth( size_t item ) const
 758     {
 759         wxPropertyGrid* pg = GetGrid();
 760         wxRect rect;
 761         rect.x = -1;
 762         rect.width = -1;
 763         pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
 764         return rect.width;
 765     }
 766
 767     virtual void PositionTextCtrl( int WXUNUSED(textCtrlXAdjust), int WXUNUSED(textCtrlYAdjust) )
 768     {
 769         wxPropertyGrid* pg = GetGrid();
 770         wxOwnerDrawnComboBox::PositionTextCtrl(
 771             wxPG_TEXTCTRLXADJUST - (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
 772             pg->GetSpacingY() + 2
 773         );
 774     }
 775
 776 private:
 777     wxPGDoubleClickProcessor*   m_dclickProcessor;
 778     bool                        m_sizeEventCalled;
 779 };
 780
 781
 782 void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
 783                                        int item,
 784                                        wxDC& dc,
 785                                        wxRect& rect,
 786                                        int flags )
 787 {
 788     wxPGComboBox* pCb = (wxPGComboBox*)pCc;
 789
 790     // Sanity check
 791     wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
 792
 793     wxPGProperty* p = m_selected;
 794     wxString text;
 795
 796     const wxPGChoices& choices = p->GetChoices();
 797     const wxPGCommonValue* comVal = NULL;
 798     int comVals = p->GetDisplayedCommonValueCount();
 799     int comValIndex = -1;
 800
 801     int choiceCount = 0;
 802     if ( choices.IsOk() )
 803         choiceCount = choices.GetCount();
 804
 805     if ( item >= choiceCount && comVals > 0 )
 806     {
 807         comValIndex = item - choiceCount;
 808         comVal = GetCommonValue(comValIndex);
 809         if ( !p->IsValueUnspecified() )
 810             text = comVal->GetLabel();
 811     }
 812     else
 813     {
 814         if ( !(flags & wxODCB_PAINTING_CONTROL) )
 815         {
 816             text = pCb->GetString(item);
 817         }
 818         else
 819         {
 820             if ( !p->IsValueUnspecified() )
 821                 text = p->GetValueString(0);
 822         }
 823     }
 824
 825     if ( item < 0 )
 826         return;
 827
 828     wxSize cis;
 829
 830     const wxBitmap* itemBitmap = NULL;
 831
 832     if ( item >= 0 && choices.IsOk() && choices.Item(item).GetBitmap().Ok() && comValIndex == -1 )
 833         itemBitmap = &choices.Item(item).GetBitmap();
 834
 835     //
 836     // Decide what custom image size to use
 837     if ( itemBitmap )
 838     {
 839         cis.x = itemBitmap->GetWidth();
 840         cis.y = itemBitmap->GetHeight();
 841     }
 842     else
 843     {
 844         cis = GetImageSize(p, item);
 845     }
 846
 847     if ( rect.x < 0 )
 848     {
 849         // Default measure behaviour (no flexible, custom paint image only)
 850         if ( rect.width < 0 )
 851         {
 852             wxCoord x, y;
 853             GetTextExtent(text, &x, &y, 0, 0, &m_font);
 854             rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9 + x;
 855         }
 856
 857         rect.height = cis.y + 2;
 858         return;
 859     }
 860
 861     wxPGPaintData paintdata;
 862     paintdata.m_parent = NULL;
 863     paintdata.m_choiceItem = item;
 864
 865     // This is by the current (1.0.0b) spec - if painting control, item is -1
 866     if ( (flags & wxODCB_PAINTING_CONTROL) )
 867         paintdata.m_choiceItem = -1;
 868
 869     if ( &dc )
 870         dc.SetBrush(*wxWHITE_BRUSH);
 871
 872     if ( rect.x >= 0 )
 873     {
 874         //
 875         // DrawItem call
 876
 877         wxPoint pt(rect.x + wxPG_CONTROL_MARGIN - wxPG_CHOICEXADJUST - 1,
 878                    rect.y + 1);
 879
 880         int renderFlags = 0;
 881
 882         if ( flags & wxODCB_PAINTING_CONTROL )
 883             renderFlags |= wxPGCellRenderer::Control;
 884
 885         if ( flags & wxODCB_PAINTING_SELECTED )
 886             renderFlags |= wxPGCellRenderer::Selected;
 887
 888         if ( cis.x > 0 && (p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || !(flags & wxODCB_PAINTING_CONTROL)) &&
 889              ( !p->m_valueBitmap || item == pCb->GetSelection() ) &&
 890              ( item >= 0 || (flags & wxODCB_PAINTING_CONTROL) ) &&
 891              !itemBitmap
 892            )
 893         {
 894             pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
 895             wxRect r(pt.x,pt.y,cis.x,cis.y);
 896
 897             if ( flags & wxODCB_PAINTING_CONTROL )
 898             {
 899                 //r.width = cis.x;
 900                 r.height = wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight);
 901             }
 902
 903             paintdata.m_drawnWidth = r.width;
 904
 905             dc.SetPen(m_colPropFore);
 906             if ( comValIndex >= 0 )
 907             {
 908                 const wxPGCommonValue* cv = GetCommonValue(comValIndex);
 909                 wxPGCellRenderer* renderer = cv->GetRenderer();
 910                 r.width = rect.width;
 911                 renderer->Render( dc, r, this, p, m_selColumn, comValIndex, renderFlags );
 912                 return;
 913             }
 914             else if ( item >= 0 )
 915             {
 916                 p->OnCustomPaint( dc, r, paintdata );
 917             }
 918             else
 919             {
 920                 dc.DrawRectangle( r );
 921             }
 922
 923             pt.x += paintdata.m_drawnWidth + wxCC_CUSTOM_IMAGE_MARGIN2 - 1;
 924         }
 925         else
 926         {
 927             // TODO: This aligns text so that it seems to be horizontally
 928             //       on the same line as property values. Not really
 929             //       sure if its needed, but seems to not cause any harm.
 930             pt.x -= 1;
 931
 932             if ( item < 0 && (flags & wxODCB_PAINTING_CONTROL) )
 933                 item = pCb->GetSelection();
 934
 935             if ( choices.IsOk() && item >= 0 && comValIndex < 0 )
 936             {
 937                 const wxPGChoiceEntry& cell = choices.Item(item);
 938                 wxPGCellRenderer* renderer = wxPGGlobalVars->m_defaultRenderer;
 939                 int imageOffset = renderer->PreDrawCell( dc, rect, cell, renderFlags );
 940                 if ( imageOffset )
 941                     imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
 942                 pt.x += imageOffset;
 943             }
 944         }
 945
 946         //
 947         // Draw text
 948         //
 949
 950         pt.y += (rect.height-m_fontHeight)/2 - 1;
 951
 952         pt.x += 1;
 953
 954         dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );
 955     }
 956     else
 957     {
 958         //
 959         // MeasureItem call
 960
 961         p->OnCustomPaint( dc, rect, paintdata );
 962         rect.height = paintdata.m_drawnHeight + 2;
 963         rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9;
 964     }
 965 }
 966
 967 bool wxPGChoiceEditor_SetCustomPaintWidth( wxPropertyGrid* propGrid, wxPGComboBox* cb, int cmnVal )
 968 {
 969     wxPGProperty* property = propGrid->GetSelectedProperty();
 970     wxASSERT( property );
 971
 972     if ( cmnVal >= 0 )
 973     {
 974         // Yes, a common value is being selected
 975         property->SetCommonValue( cmnVal );
 976         wxSize imageSize = propGrid->GetCommonValue(cmnVal)->
 977                             GetRenderer()->GetImageSize(property, 1, cmnVal);
 978         if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
 979         cb->SetCustomPaintWidth( imageSize.x );
 980         return false;
 981     }
 982     else
 983     {
 984         wxSize imageSize = propGrid->GetImageSize(property, -1);
 985         if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
 986         cb->SetCustomPaintWidth( imageSize.x );
 987         return true;
 988     }
 989 }
 990
 991 // CreateControls calls this with CB_READONLY in extraStyle
 992 wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
 993                                                 wxPGProperty* property,
 994                                                 const wxPoint& pos,
 995                                                 const wxSize& sz,
 996                                                 long extraStyle ) const
 997 {
 998     const wxPGChoices& choices = property->GetChoices();
 999     wxString defString;
1000     int index = property->GetChoiceSelection();
1001
1002     bool isUnspecified = property->IsValueUnspecified();
1003
1004     if ( !isUnspecified )
1005         defString = property->GetDisplayedString();
1006
1007     wxArrayString labels = choices.GetLabels();
1008
1009     wxPGComboBox* cb;
1010
1011     wxPoint po(pos);
1012     wxSize si(sz);
1013     po.y += wxPG_CHOICEYADJUST;
1014     si.y -= (wxPG_CHOICEYADJUST*2);
1015
1016     po.x += wxPG_CHOICEXADJUST;
1017     si.x -= wxPG_CHOICEXADJUST;
1018     wxWindow* ctrlParent = propGrid->GetPanel();
1019
1020     int odcbFlags = extraStyle | wxNO_BORDER | wxTE_PROCESS_ENTER;
1021
1022     //
1023     // If common value specified, use appropriate index
1024     unsigned int cmnVals = property->GetDisplayedCommonValueCount();
1025     if ( cmnVals )
1026     {
1027         if ( !isUnspecified )
1028         {
1029             int cmnVal = property->GetCommonValue();
1030             if ( cmnVal >= 0 )
1031             {
1032                 index = labels.size() + cmnVal;
1033             }
1034         }
1035
1036         unsigned int i;
1037         for ( i=0; i<cmnVals; i++ )
1038             labels.Add(propGrid->GetCommonValueLabel(i));
1039     }
1040
1041     cb = new wxPGComboBox();
1042 #ifdef __WXMSW__
1043     cb->Hide();
1044 #endif
1045     cb->Create(ctrlParent,
1046                wxPG_SUBID1,
1047                wxString(),
1048                po,
1049                si,
1050                labels,
1051                odcbFlags);
1052
1053     cb->SetButtonPosition(si.y,0,wxRIGHT);
1054     cb->SetTextIndent(wxPG_XBEFORETEXT-1);
1055
1056     wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, property->GetCommonValue() );
1057
1058     if ( index >= 0 && index < (int)cb->GetCount() )
1059     {
1060         cb->SetSelection( index );
1061         if ( defString.length() )
1062             cb->SetText( defString );
1063     }
1064     else if ( !(extraStyle & wxCB_READONLY) && defString.length() )
1065         cb->SetValue( defString );
1066     else
1067         cb->SetSelection( -1 );
1068
1069     // Connect event handling
1070     wxWindowID id = cb->GetId();
1071     propGrid->Connect(id, wxEVT_COMMAND_COMBOBOX_SELECTED,
1072         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
1073     propGrid->Connect(id, wxEVT_COMMAND_TEXT_UPDATED,
1074         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
1075     propGrid->Connect(id, wxEVT_COMMAND_TEXT_ENTER,
1076         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
1077
1078 #ifdef __WXMSW__
1079     cb->Show();
1080 #endif
1081
1082     return (wxWindow*) cb;
1083 }
1084
1085
1086 void wxPGChoiceEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1087 {
1088     wxASSERT( ctrl );
1089     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1090     wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1091     int ind = property->GetChoiceSelection();
1092     cb->SetSelection(ind);
1093 }
1094
1095 wxPGWindowList wxPGChoiceEditor::CreateControls( wxPropertyGrid* propGrid, wxPGProperty* property,
1096         const wxPoint& pos, const wxSize& sz ) const
1097 {
1098     return CreateControlsBase(propGrid,property,pos,sz,wxCB_READONLY);
1099 }
1100
1101
1102 int wxPGChoiceEditor::InsertItem( wxWindow* ctrl, const wxString& label, int index ) const
1103 {
1104     wxASSERT( ctrl );
1105     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1106     wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1107
1108     if (index < 0)
1109         index = cb->GetCount();
1110
1111     return cb->Insert(label,index);
1112 }
1113
1114
1115 void wxPGChoiceEditor::DeleteItem( wxWindow* ctrl, int index ) const
1116 {
1117     wxASSERT( ctrl );
1118     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1119     wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1120
1121     cb->Delete(index);
1122 }
1123
1124 bool wxPGChoiceEditor::OnEvent( wxPropertyGrid* propGrid, wxPGProperty* property,
1125     wxWindow* ctrl, wxEvent& event ) const
1126 {
1127     if ( event.GetEventType() == wxEVT_COMMAND_COMBOBOX_SELECTED )
1128     {
1129         wxPGComboBox* cb = (wxPGComboBox*)ctrl;
1130         int index = cb->GetSelection();
1131         int cmnValIndex = -1;
1132         int cmnVals = property->GetDisplayedCommonValueCount();
1133         int items = cb->GetCount();
1134
1135         if ( index >= (items-cmnVals) )
1136         {
1137             // Yes, a common value is being selected
1138             cmnValIndex = index - (items-cmnVals);
1139             property->SetCommonValue( cmnValIndex );
1140
1141             // Truly set value to unspecified?
1142             if ( propGrid->GetUnspecifiedCommonValue() == cmnValIndex )
1143             {
1144                 if ( !property->IsValueUnspecified() )
1145                     propGrid->SetInternalFlag(wxPG_FL_VALUE_CHANGE_IN_EVENT);
1146                 property->SetValueToUnspecified();
1147                 if ( !cb->HasFlag(wxCB_READONLY) )
1148                     cb->GetTextCtrl()->SetValue(wxEmptyString);
1149                 return false;
1150             }
1151         }
1152         return wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, cmnValIndex );
1153     }
1154     return false;
1155 }
1156
1157
1158 bool wxPGChoiceEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1159 {
1160     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1161
1162     int index = cb->GetSelection();
1163
1164     if ( index != property->GetChoiceSelection() ||
1165         // Changing unspecified always causes event (returning
1166         // true here should be enough to trigger it).
1167          property->IsValueUnspecified()
1168        )
1169     {
1170         return property->IntToValue( variant, index, 0 );
1171     }
1172     return false;
1173 }
1174
1175
1176 void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, const wxString& txt ) const
1177 {
1178     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1179     wxASSERT( cb );
1180     cb->SetValue(txt);
1181 }
1182
1183
1184 void wxPGChoiceEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, int value ) const
1185 {
1186     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1187     wxASSERT( cb );
1188     cb->SetSelection(value);
1189 }
1190
1191
1192 void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
1193 {
1194     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1195     cb->SetSelection(-1);
1196 }
1197
1198
1199 bool wxPGChoiceEditor::CanContainCustomImage() const
1200 {
1201     return true;
1202 }
1203
1204
1205 wxPGChoiceEditor::~wxPGChoiceEditor() { }
1206
1207
1208 // -----------------------------------------------------------------------
1209 // wxPGComboBoxEditor
1210 // -----------------------------------------------------------------------
1211
1212
1213 WX_PG_IMPLEMENT_EDITOR_CLASS(ComboBox,wxPGComboBoxEditor,wxPGChoiceEditor)
1214
1215
1216 void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1217 {
1218     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1219     cb->SetValue(property->GetValueString(wxPG_EDITABLE_VALUE));
1220
1221     // TODO: If string matches any selection, then select that.
1222 }
1223
1224
1225 wxPGWindowList wxPGComboBoxEditor::CreateControls( wxPropertyGrid* propGrid,
1226                                                    wxPGProperty* property,
1227                                                    const wxPoint& pos,
1228                                                    const wxSize& sz ) const
1229 {
1230     return CreateControlsBase(propGrid,property,pos,sz,0);
1231 }
1232
1233
1234 bool wxPGComboBoxEditor::OnEvent( wxPropertyGrid* propGrid,
1235                                   wxPGProperty* property,
1236                                   wxWindow* ctrl,
1237                                   wxEvent& event ) const
1238 {
1239     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*) NULL;
1240     wxWindow* textCtrl = (wxWindow*) NULL;
1241
1242     if ( ctrl )
1243     {
1244         cb = (wxOwnerDrawnComboBox*)ctrl;
1245         textCtrl = cb->GetTextCtrl();
1246     }
1247
1248     if ( wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,textCtrl,event) )
1249         return true;
1250
1251     return wxPGChoiceEditor::OnEvent(propGrid,property,ctrl,event);
1252 }
1253
1254
1255 bool wxPGComboBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1256 {
1257     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1258     wxString textVal = cb->GetValue();
1259
1260     if ( property->UsesAutoUnspecified() && !textVal.length() )
1261     {
1262         variant.MakeNull();
1263         return true;
1264     }
1265
1266     bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE);
1267
1268     // Changing unspecified always causes event (returning
1269     // true here should be enough to trigger it).
1270     if ( !res && variant.IsNull() )
1271         res = true;
1272
1273     return res;
1274 }
1275
1276
1277 void wxPGComboBoxEditor::OnFocus( wxPGProperty*, wxWindow* ctrl ) const
1278 {
1279     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1280     cb->GetTextCtrl()->SetSelection(-1,-1);
1281 }
1282
1283
1284 wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
1285
1286
1287 // -----------------------------------------------------------------------
1288 // wxPGChoiceAndButtonEditor
1289 // -----------------------------------------------------------------------
1290
1291
1292 // This simpler implement_editor macro doesn't define class body.
1293 WX_PG_IMPLEMENT_EDITOR_CLASS(ChoiceAndButton,wxPGChoiceAndButtonEditor,wxPGChoiceEditor)
1294
1295
1296 wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
1297                                                           wxPGProperty* property,
1298                                                           const wxPoint& pos,
1299                                                           const wxSize& sz ) const
1300 {
1301     // Use one two units smaller to match size of the combo's dropbutton.
1302     // (normally a bigger button is used because it looks better)
1303     int bt_wid = sz.y;
1304     bt_wid -= 2;
1305     wxSize bt_sz(bt_wid,bt_wid);
1306
1307     // Position of button.
1308     wxPoint bt_pos(pos.x+sz.x-bt_sz.x,pos.y);
1309 #ifdef __WXMAC__
1310     bt_pos.y -= 1;
1311 #else
1312     bt_pos.y += 1;
1313 #endif
1314
1315     wxWindow* bt = propGrid->GenerateEditorButton( bt_pos, bt_sz );
1316
1317     // Size of choice.
1318     wxSize ch_sz(sz.x-bt->GetSize().x,sz.y);
1319
1320 #ifdef __WXMAC__
1321     ch_sz.x -= wxPG_TEXTCTRL_AND_BUTTON_SPACING;
1322 #endif
1323
1324     wxWindow* ch = wxPG_EDITOR(Choice)->CreateControls(propGrid,property,
1325         pos,ch_sz).m_primary;
1326
1327 #ifdef __WXMSW__
1328     bt->Show();
1329 #endif
1330
1331     return wxPGWindowList(ch, bt);
1332 }
1333
1334
1335 wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor() { }
1336
1337
1338 // -----------------------------------------------------------------------
1339 // wxPGTextCtrlAndButtonEditor
1340 // -----------------------------------------------------------------------
1341
1342
1343 // This simpler implement_editor macro doesn't define class body.
1344 WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrlAndButton,wxPGTextCtrlAndButtonEditor,wxPGTextCtrlEditor)
1345
1346
1347 wxPGWindowList wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
1348                                                             wxPGProperty* property,
1349                                                             const wxPoint& pos,
1350                                                             const wxSize& sz ) const
1351 {
1352     wxWindow* wnd2;
1353     wxWindow* wnd = propGrid->GenerateEditorTextCtrlAndButton( pos, sz, &wnd2,
1354         property->GetFlags() & wxPG_PROP_NOEDITOR, property);
1355
1356     return wxPGWindowList(wnd, wnd2);
1357 }
1358
1359
1360 wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
1361
1362
1363 // -----------------------------------------------------------------------
1364 // wxPGCheckBoxEditor
1365 // -----------------------------------------------------------------------
1366
1367 #if wxPG_INCLUDE_CHECKBOX
1368
1369 WX_PG_IMPLEMENT_EDITOR_CLASS(CheckBox,wxPGCheckBoxEditor,wxPGEditor)
1370
1371
1372 // state argument: 0x01 = set if checked
1373 //                 0x02 = set if rectangle should be bold
1374 static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei, int state, const wxColour& linecol )
1375 {
1376
1377     // Box rectangle.
1378     wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),box_hei,box_hei);
1379
1380     // Draw check mark first because it is likely to overdraw the
1381     // surrounding rectangle.
1382     if ( state & 1 )
1383     {
1384         wxRect r2(r.x+wxPG_CHECKMARK_XADJ,
1385                   r.y+wxPG_CHECKMARK_YADJ,
1386                   r.width+wxPG_CHECKMARK_WADJ,
1387                   r.height+wxPG_CHECKMARK_HADJ);
1388     #if wxPG_CHECKMARK_DEFLATE
1389         r2.Deflate(wxPG_CHECKMARK_DEFLATE);
1390     #endif
1391         dc.DrawCheckMark(r2);
1392
1393         // This would draw a simple cross check mark.
1394         // dc.DrawLine(r.x,r.y,r.x+r.width-1,r.y+r.height-1);
1395         // dc.DrawLine(r.x,r.y+r.height-1,r.x+r.width-1,r.y);
1396
1397     }
1398
1399     if ( !(state & 2) )
1400     {
1401         // Pen for thin rectangle.
1402         dc.SetPen(linecol);
1403     }
1404     else
1405     {
1406         // Pen for bold rectangle.
1407         wxPen linepen(linecol,2,wxSOLID);
1408         linepen.SetJoin(wxJOIN_MITER); // This prevents round edges.
1409         dc.SetPen(linepen);
1410         r.x++;
1411         r.y++;
1412         r.width--;
1413         r.height--;
1414     }
1415
1416     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1417
1418     dc.DrawRectangle(r);
1419     dc.SetPen(*wxTRANSPARENT_PEN);
1420 }
1421
1422 //
1423 // Real simple custom-drawn checkbox-without-label class.
1424 //
1425 class wxSimpleCheckBox : public wxControl
1426 {
1427 public:
1428
1429     void SetValue( int value );
1430
1431     wxSimpleCheckBox( wxWindow* parent,
1432                       wxWindowID id,
1433                       const wxPoint& pos = wxDefaultPosition,
1434                       const wxSize& size = wxDefaultSize )
1435         : wxControl(parent,id,pos,size,wxNO_BORDER|wxWANTS_CHARS)
1436     {
1437         // Due to SetOwnFont stuff necessary for GTK+ 1.2, we need to have this
1438         SetFont( parent->GetFont() );
1439
1440         m_state = 0;
1441         wxPropertyGrid* pg = (wxPropertyGrid*) parent->GetParent();
1442         wxASSERT( pg->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1443         m_boxHeight = pg->GetFontHeight();
1444         SetBackgroundStyle( wxBG_STYLE_COLOUR );
1445     }
1446
1447     virtual ~wxSimpleCheckBox();
1448
1449     virtual bool ProcessEvent(wxEvent& event);
1450
1451     int m_state;
1452     int m_boxHeight;
1453
1454     static wxBitmap* ms_doubleBuffer;
1455
1456 };
1457
1458 wxSimpleCheckBox::~wxSimpleCheckBox()
1459 {
1460     delete ms_doubleBuffer;
1461     ms_doubleBuffer = NULL;
1462 }
1463
1464
1465 wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = (wxBitmap*) NULL;
1466
1467 // value = 2 means toggle (sorry, too lazy to do constants)
1468 void wxSimpleCheckBox::SetValue( int value )
1469 {
1470     if ( value > 1 )
1471     {
1472         m_state++;
1473         if ( m_state > 1 ) m_state = 0;
1474     }
1475     else
1476     {
1477         m_state = value;
1478     }
1479     Refresh();
1480
1481     wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());
1482
1483     wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
1484     wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1485     propGrid->OnCustomEditorEvent(evt);
1486 }
1487
1488
1489 bool wxSimpleCheckBox::ProcessEvent(wxEvent& event)
1490 {
1491     wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
1492     wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1493
1494     if ( event.GetEventType() == wxEVT_NAVIGATION_KEY )
1495     {
1496         //wxLogDebug(wxT("wxEVT_NAVIGATION_KEY"));
1497         //SetFocusFromKbd();
1498         //event.Skip();
1499         //return wxControl::ProcessEvent(event);
1500     }
1501     else
1502     if ( ( (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK)
1503           && ((wxMouseEvent&)event).m_x > (wxPG_XBEFORETEXT-2)
1504           && ((wxMouseEvent&)event).m_x <= (wxPG_XBEFORETEXT-2+m_boxHeight) )
1505        )
1506     {
1507         SetValue(2);
1508         return true;
1509     }
1510     else if ( event.GetEventType() == wxEVT_PAINT )
1511     {
1512         wxSize clientSize = GetClientSize();
1513         wxPaintDC dc(this);
1514
1515         /*
1516         // Buffered paint DC doesn't seem to do much good
1517         if ( !ms_doubleBuffer ||
1518              clientSize.x > ms_doubleBuffer->GetWidth() ||
1519              clientSize.y > ms_doubleBuffer->GetHeight() )
1520         {
1521             delete ms_doubleBuffer;
1522             ms_doubleBuffer = new wxBitmap(clientSize.x+25,clientSize.y+25);
1523         }
1524
1525         wxBufferedPaintDC dc(this,*ms_doubleBuffer);
1526         */
1527
1528         wxRect rect(0,0,clientSize.x,clientSize.y);
1529         //rect.x -= 1;
1530         rect.y += 1;
1531         rect.width += 1;
1532
1533         m_boxHeight = propGrid->GetFontHeight();
1534
1535         wxColour bgcol = GetBackgroundColour();
1536         dc.SetBrush( bgcol );
1537         dc.SetPen( bgcol );
1538         dc.DrawRectangle( rect );
1539
1540         wxColour txcol = GetForegroundColour();
1541
1542         int state = m_state;
1543         if ( m_font.GetWeight() == wxBOLD )
1544             state |= 2;
1545
1546         DrawSimpleCheckBox(dc,rect,m_boxHeight,state,txcol);
1547
1548         // If focused, indicate it somehow.
1549         /*
1550         if ( wxWindow::FindFocus() == this )
1551         {
1552             rect.x += 1;
1553             rect.width -= 1;
1554
1555             wxPGDrawFocusRect(dc,rect);
1556         }
1557         */
1558
1559         return true;
1560     }
1561     else if ( event.GetEventType() == wxEVT_SIZE ||
1562               event.GetEventType() == wxEVT_SET_FOCUS ||
1563               event.GetEventType() == wxEVT_KILL_FOCUS
1564             )
1565     {
1566         Refresh();
1567     }
1568     else if ( event.GetEventType() == wxEVT_KEY_DOWN )
1569     {
1570         wxKeyEvent& keyEv = (wxKeyEvent&) event;
1571
1572         if ( keyEv.GetKeyCode() == WXK_TAB )
1573         {
1574             propGrid->SendNavigationKeyEvent( keyEv.ShiftDown()?0:1 );
1575             return true;
1576         }
1577         else
1578         if ( keyEv.GetKeyCode() == WXK_SPACE )
1579         {
1580             SetValue(2);
1581             return true;
1582         }
1583     }
1584     return wxControl::ProcessEvent(event);
1585 }
1586
1587
1588 wxPGWindowList wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
1589                                                    wxPGProperty* property,
1590                                                    const wxPoint& pos,
1591                                                    const wxSize& size ) const
1592 {
1593     wxPoint pt = pos;
1594     pt.x -= wxPG_XBEFOREWIDGET;
1595     wxSize sz = size;
1596     sz.x = propGrid->GetFontHeight() + (wxPG_XBEFOREWIDGET*2) + 4;
1597
1598     wxSimpleCheckBox* cb = new wxSimpleCheckBox(propGrid->GetPanel(),wxPG_SUBID1,pt,sz);
1599
1600     cb->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
1601
1602     cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DOWN,
1603             (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
1604             &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
1605
1606     cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DCLICK,
1607             (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
1608             &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
1609
1610     if ( property->GetChoiceSelection() > 0 &&
1611          !property->IsValueUnspecified() )
1612         cb->m_state = 1;
1613
1614     // If mouse cursor was on the item, toggle the value now.
1615     if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )
1616     {
1617         wxPoint pt = cb->ScreenToClient(::wxGetMousePosition());
1618         if ( pt.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
1619         {
1620             cb->m_state++;
1621
1622             if ( cb->m_state > 1 )
1623                 cb->m_state = 0;
1624
1625             // Makes sure wxPG_EVT_CHANGING etc. is sent for this initial click
1626             propGrid->ChangePropertyValue(property, wxPGVariant_Bool(cb->m_state));
1627         }
1628     }
1629
1630     propGrid->SetInternalFlag( wxPG_FL_FIXED_WIDTH_EDITOR );
1631
1632     return cb;
1633 }
1634
1635 /*
1636 class wxPGCheckBoxRenderer : public wxPGDefaultRenderer
1637 {
1638 public:
1639
1640     virtual void Render( wxDC& dc, const wxRect& rect,
1641                          const wxPropertyGrid* WXUNUSED(propertyGrid), wxPGProperty* property,
1642                          int WXUNUSED(column), int WXUNUSED(item), int WXUNUSED(flags) ) const
1643     {
1644         int state = 0;
1645         if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
1646         {
1647             state = ((wxPGProperty*)property)->GetChoiceInfo((wxPGChoiceInfo*)NULL);
1648             if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
1649         }
1650         DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
1651     }
1652
1653 protected:
1654 };
1655
1656 wxPGCheckBoxRenderer g_wxPGCheckBoxRenderer;
1657
1658 wxPGCellRenderer* wxPGCheckBoxEditor::GetCellRenderer() const
1659 {
1660     return &g_wxPGCheckBoxRenderer;
1661 }
1662 */
1663
1664 void wxPGCheckBoxEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& WXUNUSED(text) ) const
1665 {
1666     int state = 0;
1667     if ( !property->IsValueUnspecified() )
1668     {
1669         state = property->GetChoiceSelection();
1670         if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
1671     }
1672     DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
1673 }
1674
1675 void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1676 {
1677     wxASSERT( ctrl );
1678     ((wxSimpleCheckBox*)ctrl)->m_state = property->GetChoiceSelection();
1679     ctrl->Refresh();
1680 }
1681
1682
1683 bool wxPGCheckBoxEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
1684     wxWindow* WXUNUSED(ctrl), wxEvent& event ) const
1685 {
1686     if ( event.GetEventType() == wxEVT_COMMAND_CHECKBOX_CLICKED )
1687     {
1688         return true;
1689     }
1690     return false;
1691 }
1692
1693
1694 bool wxPGCheckBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1695 {
1696     wxSimpleCheckBox* cb = (wxSimpleCheckBox*)ctrl;
1697
1698     int index = cb->m_state;
1699
1700     if ( index != property->GetChoiceSelection() ||
1701          // Changing unspecified always causes event (returning
1702          // true here should be enough to trigger it).
1703          property->IsValueUnspecified()
1704        )
1705     {
1706         return property->IntToValue(variant, index, 0);
1707     }
1708     return false;
1709 }
1710
1711
1712 void wxPGCheckBoxEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, int value ) const
1713 {
1714     if ( value != 0 ) value = 1;
1715     ((wxSimpleCheckBox*)ctrl)->m_state = value;
1716     ctrl->Refresh();
1717 }
1718
1719
1720 void wxPGCheckBoxEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
1721 {
1722     ((wxSimpleCheckBox*)ctrl)->m_state = 0;
1723     ctrl->Refresh();
1724 }
1725
1726
1727 wxPGCheckBoxEditor::~wxPGCheckBoxEditor() { }
1728
1729
1730 #endif // wxPG_INCLUDE_CHECKBOX
1731
1732 // -----------------------------------------------------------------------
1733
1734 wxWindow* wxPropertyGrid::GetEditorControl() const
1735 {
1736     wxWindow* ctrl = m_wndEditor;
1737
1738     if ( !ctrl )
1739         return ctrl;
1740
1741     // If it's clipper window, return its child instead
1742 #if wxPG_ENABLE_CLIPPER_WINDOW
1743     if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
1744     {
1745         return ((wxPGClipperWindow*)ctrl)->GetControl();
1746     }
1747 #endif
1748
1749     return ctrl;
1750 }
1751
1752 // -----------------------------------------------------------------------
1753
1754 void wxPropertyGrid::CorrectEditorWidgetSizeX()
1755 {
1756     if ( m_selColumn == -1 )
1757         return;
1758
1759     int secWid = 0;
1760     int newSplitterx = m_pState->DoGetSplitterPosition(m_selColumn-1);
1761     int newWidth = newSplitterx + m_pState->m_colWidths[m_selColumn];
1762
1763     if ( m_wndEditor2 )
1764     {
1765         // if width change occurred, move secondary wnd by that amount
1766         wxRect r = m_wndEditor2->GetRect();
1767         secWid = r.width;
1768         r.x = newWidth - secWid;
1769
1770         m_wndEditor2->SetSize( r );
1771
1772         // if primary is textctrl, then we have to add some extra space
1773 #ifdef __WXMAC__
1774         if ( m_wndEditor )
1775 #else
1776         if ( m_wndEditor && m_wndEditor->IsKindOf(CLASSINFO(wxTextCtrl)) )
1777 #endif
1778             secWid += wxPG_TEXTCTRL_AND_BUTTON_SPACING;
1779     }
1780
1781     if ( m_wndEditor )
1782     {
1783         wxRect r = m_wndEditor->GetRect();
1784
1785         r.x = newSplitterx+m_ctrlXAdjust;
1786
1787         if ( !(m_iFlags & wxPG_FL_FIXED_WIDTH_EDITOR) )
1788             r.width = newWidth - r.x - secWid;
1789
1790         m_wndEditor->SetSize(r);
1791     }
1792
1793     if ( m_wndEditor2 )
1794         m_wndEditor2->Refresh();
1795 }
1796
1797 // -----------------------------------------------------------------------
1798
1799 void wxPropertyGrid::CorrectEditorWidgetPosY()
1800 {
1801     if ( m_selected && (m_wndEditor || m_wndEditor2) )
1802     {
1803         wxRect r = GetEditorWidgetRect(m_selected, m_selColumn);
1804
1805         if ( m_wndEditor )
1806         {
1807             wxPoint pos = m_wndEditor->GetPosition();
1808
1809             // Calculate y offset
1810             int offset = pos.y % m_lineHeight;
1811
1812             m_wndEditor->Move(pos.x, r.y + offset);
1813         }
1814
1815         if ( m_wndEditor2 )
1816         {
1817             wxPoint pos = m_wndEditor2->GetPosition();
1818
1819             m_wndEditor2->Move(pos.x, r.y);
1820         }
1821     }
1822 }
1823
1824 // -----------------------------------------------------------------------
1825
1826 bool wxPropertyGrid::AdjustPosForClipperWindow( wxWindow* topCtrlWnd, int* x, int* y )
1827 {
1828 #if wxPG_ENABLE_CLIPPER_WINDOW
1829     // Take clipper window into account
1830     if (topCtrlWnd->GetPosition().x < 1 &&
1831         !topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)))
1832     {
1833         topCtrlWnd = topCtrlWnd->GetParent();
1834         wxASSERT( topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)) );
1835         *x -= ((wxPGClipperWindow*)topCtrlWnd)->GetXClip();
1836         *y -= ((wxPGClipperWindow*)topCtrlWnd)->GetYClip();
1837         return true;
1838     }
1839 #else
1840     wxUnusedVar(topCtrlWnd);
1841     wxUnusedVar(x);
1842     wxUnusedVar(y);
1843 #endif
1844     return false;
1845 }
1846
1847 // -----------------------------------------------------------------------
1848
1849 // Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
1850 // fits into that category as well).
1851 void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl, const wxPoint& offset )
1852 {
1853     // Center the control vertically
1854     wxRect finalPos = ctrl->GetRect();
1855     int y_adj = (m_lineHeight - finalPos.height)/2 + wxPG_TEXTCTRLYADJUST;
1856
1857     // Prevent over-sized control
1858     int sz_dec = (y_adj + finalPos.height) - m_lineHeight;
1859     if ( sz_dec < 0 ) sz_dec = 0;
1860
1861     finalPos.y += y_adj;
1862     finalPos.height -= (y_adj+sz_dec);
1863
1864     const int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
1865
1866     finalPos.x += textCtrlXAdjust;
1867     finalPos.width -= textCtrlXAdjust;
1868
1869     finalPos.x += offset.x;
1870     finalPos.y += offset.y;
1871
1872     ctrl->SetSize(finalPos);
1873 }
1874
1875 // -----------------------------------------------------------------------
1876
1877 wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
1878                                                   const wxSize& sz,
1879                                                   const wxString& value,
1880                                                   wxWindow* secondary,
1881                                                   int extraStyle,
1882                                                   int maxLen )
1883 {
1884     wxWindowID id = wxPG_SUBID1;
1885     wxPGProperty* selected = m_selected;
1886     wxASSERT(selected);
1887
1888     int tcFlags = wxTE_PROCESS_ENTER | extraStyle;
1889
1890     if ( selected->HasFlag(wxPG_PROP_READONLY) )
1891         tcFlags |= wxTE_READONLY;
1892
1893     wxPoint p(pos.x,pos.y);
1894     wxSize s(sz.x,sz.y);
1895
1896    // Need to reduce width of text control on Mac
1897 #if defined(__WXMAC__)
1898    s.x -= 8;
1899 #endif
1900
1901      // Take button into acccount
1902     if ( secondary )
1903     {
1904         s.x -= (secondary->GetSize().x + wxPG_TEXTCTRL_AND_BUTTON_SPACING);
1905         m_iFlags &= ~(wxPG_FL_PRIMARY_FILLS_ENTIRE);
1906     }
1907
1908     // If the height is significantly higher, then use border, and fill the rect exactly.
1909     bool hasSpecialSize = false;
1910
1911     if ( (sz.y - m_lineHeight) > 5 )
1912         hasSpecialSize = true;
1913
1914 #if wxPG_NAT_TEXTCTRL_BORDER_ANY
1915
1916     // Create clipper window
1917     wxPGClipperWindow* wnd = new wxPGClipperWindow();
1918 #if defined(__WXMSW__)
1919     wnd->Hide();
1920 #endif
1921     wnd->Create(GetPanel(),id,p,s);
1922
1923     // This generates rect of the control inside the clipper window
1924     if ( !hasSpecialSize )
1925         wnd->GetControlRect(wxPG_NAT_TEXTCTRL_BORDER_X, wxPG_NAT_TEXTCTRL_BORDER_Y, p, s);
1926     else
1927         wnd->GetControlRect(0, 0, p, s);
1928
1929     wxWindow* ctrlParent = wnd;
1930
1931 #else
1932
1933     wxWindow* ctrlParent = GetPanel();
1934
1935     if ( !hasSpecialSize )
1936         tcFlags |= wxNO_BORDER;
1937
1938 #endif
1939
1940     wxTextCtrl* tc = new wxTextCtrl();
1941
1942 #if defined(__WXMSW__) && !wxPG_NAT_TEXTCTRL_BORDER_ANY
1943     tc->Hide();
1944 #endif
1945     SetupTextCtrlValue(value);
1946     tc->Create(ctrlParent,id,value, p, s,tcFlags);
1947
1948 #if wxPG_NAT_TEXTCTRL_BORDER_ANY
1949     wxWindow* ed = wnd;
1950     wnd->SetControl(tc);
1951 #else
1952     wxWindow* ed = tc;
1953 #endif
1954
1955     // Center the control vertically
1956     if ( !hasSpecialSize )
1957         FixPosForTextCtrl(ed);
1958
1959 #ifdef __WXMSW__
1960     ed->Show();
1961     if ( secondary )
1962         secondary->Show();
1963 #endif
1964
1965     // Set maximum length
1966     if ( maxLen > 0 )
1967         tc->SetMaxLength( maxLen );
1968
1969     // Connect event handling
1970     id = ed->GetId();
1971     this->Connect(id, wxEVT_COMMAND_TEXT_UPDATED,
1972         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
1973     this->Connect(id, wxEVT_COMMAND_TEXT_ENTER,
1974         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
1975
1976     return (wxWindow*) ed;
1977 }
1978
1979 // -----------------------------------------------------------------------
1980
1981 wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize& sz )
1982 {
1983     wxWindowID id = wxPG_SUBID2;
1984     wxPGProperty* selected = m_selected;
1985     wxASSERT(selected);
1986
1987 #ifdef __WXMAC__
1988    // Decorations are chunky on Mac, and we can't make the button square, so
1989    // do things a bit differently on this platform.
1990
1991    wxPoint p(pos.x+sz.x,
1992              pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
1993    wxSize s(25, -1);
1994
1995    wxButton* but = new wxButton();
1996    but->Create(GetPanel(),id,wxS("..."),p,s,wxWANTS_CHARS);
1997
1998    // Now that we know the size, move to the correct position
1999    p.x = pos.x + sz.x - but->GetSize().x - 2;
2000    but->Move(p);
2001
2002 #else
2003     wxSize s(sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2),
2004         sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2));
2005
2006     // Reduce button width to lineheight
2007     if ( s.x > m_lineHeight )
2008         s.x = m_lineHeight;
2009
2010 #ifdef __WXGTK__
2011     // On wxGTK, take fixed button margins into account
2012     if ( s.x < 25 )
2013         s.x = 25;
2014 #endif
2015
2016     wxPoint p(pos.x+sz.x-s.x,
2017         pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
2018
2019     wxButton* but = new wxButton();
2020   #ifdef __WXMSW__
2021     but->Hide();
2022   #endif
2023     but->Create(GetPanel(),id,wxS("..."),p,s,wxWANTS_CHARS);
2024
2025   #ifdef __WXGTK__
2026     wxFont font = GetFont();
2027     font.SetPointSize(font.GetPointSize()-2);
2028     but->SetFont(font);
2029   #else
2030     but->SetFont(GetFont());
2031   #endif
2032 #endif
2033
2034     if ( selected->HasFlag(wxPG_PROP_READONLY) )
2035         but->Disable();
2036
2037     // Connect event handling
2038     id = but->GetId();
2039     this->Connect(id, wxEVT_COMMAND_BUTTON_CLICKED,
2040         wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
2041
2042     return but;
2043 }
2044
2045 // -----------------------------------------------------------------------
2046
2047 wxWindow* wxPropertyGrid::GenerateEditorTextCtrlAndButton( const wxPoint& pos,
2048                                                            const wxSize& sz,
2049                                                            wxWindow** psecondary,
2050                                                            int limitedEditing,
2051                                                            wxPGProperty* property )
2052 {
2053     wxButton* but = (wxButton*)GenerateEditorButton(pos,sz);
2054     *psecondary = (wxWindow*)but;
2055
2056     if ( limitedEditing )
2057     {
2058     #ifdef __WXMSW__
2059         // There is button Show in GenerateEditorTextCtrl as well
2060         but->Show();
2061     #endif
2062         return (wxWindow*) NULL;
2063     }
2064
2065     wxString text;
2066
2067     if ( !property->IsValueUnspecified() )
2068         text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
2069
2070     return GenerateEditorTextCtrl(pos,sz,text,but,property->m_maxLen);
2071 }
2072
2073 // -----------------------------------------------------------------------
2074
2075 wxTextCtrl* wxPropertyGrid::GetEditorTextCtrl() const
2076 {
2077     wxWindow* wnd = GetEditorControl();
2078
2079     if ( !wnd )
2080         return NULL;
2081
2082     if ( wnd->IsKindOf(CLASSINFO(wxTextCtrl)) )
2083         return wxStaticCast(wnd, wxTextCtrl);
2084
2085     if ( wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
2086     {
2087         wxOwnerDrawnComboBox* cb = wxStaticCast(wnd, wxOwnerDrawnComboBox);
2088         return cb->GetTextCtrl();
2089     }
2090
2091     return NULL;
2092 }
2093
2094 // -----------------------------------------------------------------------
2095
2096 wxPGEditor* wxPropertyGridInterface::GetEditorByName( const wxString& editorName )
2097 {
2098     wxPGHashMapS2P::const_iterator it;
2099
2100     it = wxPGGlobalVars->m_mapEditorClasses.find(editorName);
2101     if ( it == wxPGGlobalVars->m_mapEditorClasses.end() )
2102         return NULL;
2103     return (wxPGEditor*) it->second;
2104 }
2105
2106 // -----------------------------------------------------------------------
2107 // wxPGEditorDialogAdapter
2108 // -----------------------------------------------------------------------
2109
2110 IMPLEMENT_ABSTRACT_CLASS(wxPGEditorDialogAdapter, wxObject)
2111
2112 bool wxPGEditorDialogAdapter::ShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
2113 {
2114     if ( !propGrid->EditorValidate() )
2115         return false;
2116
2117     bool res = DoShowDialog( propGrid, property );
2118
2119     if ( res )
2120     {
2121         propGrid->ValueChangeInEvent( m_value );
2122         return true;
2123     }
2124
2125     return false;
2126 }
2127
2128 // -----------------------------------------------------------------------
2129 // wxPGMultiButton
2130 // -----------------------------------------------------------------------
2131
2132 wxPGMultiButton::wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz )
2133     : wxWindow( pg->GetPanel(), wxPG_SUBID2, wxPoint(-100,-100), wxSize(0, sz.y) ),
2134       m_fullEditorSize(sz), m_buttonsWidth(0)
2135 {
2136     SetBackgroundColour(pg->GetCellBackgroundColour());
2137 }
2138
2139 void wxPGMultiButton::Finalize( wxPropertyGrid* propGrid, const wxPoint& pos )
2140 {
2141     Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );
2142
2143     // Connect event handling
2144     for ( int i=0; i<GetCount(); i++ )
2145     {
2146         wxWindowID id = GetButtonId(i);
2147         propGrid->Connect(id, wxEVT_COMMAND_BUTTON_CLICKED,
2148             wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
2149     }
2150 }
2151
2152 int wxPGMultiButton::GenId( int id ) const
2153 {
2154     if ( id < -1 )
2155     {
2156         if ( m_buttons.size() )
2157             id = GetButton(m_buttons.size()-1)->GetId() + 1;
2158         else
2159             id = wxPG_SUBID2;
2160     }
2161     return id;
2162 }
2163
2164 #if wxUSE_BMPBUTTON
2165 void wxPGMultiButton::Add( const wxBitmap& bitmap, int id )
2166 {
2167     id = GenId(id);
2168     wxSize sz = GetSize();
2169     wxButton* button = new wxBitmapButton( this, id, bitmap, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
2170     m_buttons.push_back(button);
2171     int bw = button->GetSize().x;
2172     SetSize(wxSize(sz.x+bw,sz.y));
2173     m_buttonsWidth += bw;
2174 }
2175 #endif
2176
2177 void wxPGMultiButton::Add( const wxString& label, int id )
2178 {
2179     id = GenId(id);
2180     wxSize sz = GetSize();
2181     wxButton* button = new wxButton( this, id, label, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
2182     m_buttons.push_back(button);
2183     int bw = button->GetSize().x;
2184     SetSize(wxSize(sz.x+bw,sz.y));
2185     m_buttonsWidth += bw;
2186 }
2187
2188 // -----------------------------------------------------------------------
2189
2190 #endif  // wxUSE_PROPGRID