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