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