CMakeLua/Source/WXDialog/PropertyList.cpp

   1 /*=========================================================================
   2
   3   Program:   WXDialog - wxWidgets X-platform GUI Front-End for CMake
   4   Module:    $RCSfile: PropertyList.cpp,v $
   5   Language:  C++
   6   Date:      $Date: 2005/06/30 19:54:14 $
   7   Version:   $Revision: 1.1 $
   8
   9   Author:    Jorgen Bodde
  10
  11   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  12   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  13
  14      This software is distributed WITHOUT ANY WARRANTY; without even
  15      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  16      PURPOSE.  See the above copyright notices for more information.
  17
  18 =========================================================================*/
  19
  20 /* for compilers that support precompilation
  21    includes "wx/wx.h" */
  22
  23 #include "wx/wxprec.h"
  24
  25 #ifdef __BORLANDC__
  26     #pragma hdrstop
  27 #endif
  28
  29 #include "PropertyList.h"
  30 #include "app_resources.h"
  31
  32 #include "../cmCacheManager.h"
  33 #include "../cmSystemTools.h"
  34 #include "../cmake.h"
  35
  36 BEGIN_EVENT_TABLE( wxPropertyList, wxGrid )
  37     EVT_GRID_CELL_LEFT_CLICK( wxPropertyList::OnSelectCell )
  38     EVT_GRID_CELL_CHANGE( wxPropertyList::OnCellChange )
  39     EVT_GRID_CMD_CELL_RIGHT_CLICK( wxID_ANY, wxPropertyList::OnCellPopup )
  40     EVT_MENU ( ID_CACHE_DELETE, wxPropertyList::OnDeleteCache )
  41     EVT_MENU ( ID_CACHE_IGNORE, wxPropertyList::OnIgnoreCache )
  42     EVT_MENU ( ID_CACHE_BROWSE, wxPropertyList::OnBrowseItem )
  43     EVT_SIZE ( wxPropertyList::OnSizeGrid )
  44     EVT_CHAR ( wxPropertyList::OnKeyPressed )
  45 END_EVENT_TABLE()
  46
  47 #if 0
  48
  49 // ----------------------------------------------------------------------------
  50 // wxGridCellPathEditor
  51 // ----------------------------------------------------------------------------
  52
  53 wxGridCellPathEditor::wxGridCellPathEditor()
  54 {
  55     m_maxChars = 0;
  56 }
  57
  58 void wxGridCellPathEditor::Create(wxWindow* parent,
  59                                   wxWindowID id,
  60                                   wxEvtHandler* evtHandler)
  61 {
  62     m_control = new wxTextCtrl(parent, id, wxEmptyString,
  63                                wxDefaultPosition, wxDefaultSize
  64 #if defined(__WXMSW__)
  65                                , wxTE_PROCESS_TAB | wxTE_AUTO_SCROLL
  66 #endif
  67                               );
  68 //
  69 //  m_button = new wxButton(parent, id+1, _("..."),
  70 //                          wxDefaultPosition, wxDefaultSize);
  71 //
  72
  73     // set max length allowed in the textctrl, if the parameter was set
  74     if (m_maxChars != 0)
  75     {
  76         ((wxTextCtrl*)m_control)->SetMaxLength(m_maxChars);
  77     }
  78
  79     wxGridCellEditor::Create(parent, id, evtHandler);
  80 }
  81
  82 void wxGridCellPathEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
  83                                            wxGridCellAttr * WXUNUSED(attr))
  84 {
  85     // as we fill the entire client area, don't do anything here to minimize
  86     // flicker
  87 }
  88
  89 void wxGridCellPathEditor::SetSize(const wxRect& rectOrig)
  90 {
  91     wxRect rect(rectOrig);
  92
  93     // Make the edit control large enough to allow for internal
  94     // margins
  95     //
  96     // TODO: remove this if the text ctrl sizing is improved esp. for
  97     // unix
  98     //
  99 #if defined(__WXGTK__)
 100     if (rect.x != 0)
 101     {
 102         rect.x += 1;
 103         rect.y += 1;
 104         rect.width -= 1;
 105         rect.height -= 1;
 106     }
 107 #else // !GTK
 108     int extra_x = ( rect.x > 2 )? 2 : 1;
 109
 110 // MB: treat MSW separately here otherwise the caret doesn't show
 111 // when the editor is in the first row.
 112 #if defined(__WXMSW__)
 113     int extra_y = 2;
 114 #else
 115     int extra_y = ( rect.y > 2 )? 2 : 1;
 116 #endif // MSW
 117
 118 #if defined(__WXMOTIF__)
 119     extra_x *= 2;
 120     extra_y *= 2;
 121 #endif
 122     rect.SetLeft( wxMax(0, rect.x - extra_x) );
 123     rect.SetTop( wxMax(0, rect.y - extra_y) );
 124     rect.SetRight( rect.GetRight() + 2*extra_x );
 125     rect.SetBottom( rect.GetBottom() + 2*extra_y );
 126 #endif // GTK/!GTK
 127
 128     wxGridCellEditor::SetSize(rect);
 129 }
 130
 131 void wxGridCellPathEditor::BeginEdit(int row, int col, wxGrid* grid)
 132 {
 133     wxASSERT_MSG(m_control,
 134                  wxT("The wxGridCellEditor must be Created first!"));
 135
 136     m_startValue = grid->GetTable()->GetValue(row, col);
 137
 138     DoBeginEdit(m_startValue);
 139 }
 140
 141 void wxGridCellPathEditor::DoBeginEdit(const wxString& startValue)
 142 {
 143     Text()->SetValue(startValue);
 144     Text()->SetInsertionPointEnd();
 145     Text()->SetSelection(-1,-1);
 146     Text()->SetFocus();
 147 }
 148
 149 bool wxGridCellPathEditor::EndEdit(int row, int col,
 150                                    wxGrid* grid)
 151 {
 152     wxASSERT_MSG(m_control,
 153                  wxT("The wxGridCellEditor must be Created first!"));
 154
 155     bool changed = false;
 156     wxString value = Text()->GetValue();
 157     if (value != m_startValue)
 158         changed = true;
 159
 160     if (changed)
 161         grid->GetTable()->SetValue(row, col, value);
 162
 163     m_startValue = wxEmptyString;
 164     // No point in setting the text of the hidden control
 165     //Text()->SetValue(m_startValue);
 166
 167     return changed;
 168 }
 169
 170
 171 void wxGridCellPathEditor::Reset()
 172 {
 173     wxASSERT_MSG(m_control,
 174                  wxT("The wxGridCellEditor must be Created first!"));
 175
 176     DoReset(m_startValue);
 177 }
 178
 179 void wxGridCellPathEditor::DoReset(const wxString& startValue)
 180 {
 181     Text()->SetValue(startValue);
 182     Text()->SetInsertionPointEnd();
 183 }
 184
 185 bool wxGridCellPathEditor::IsAcceptedKey(wxKeyEvent& event)
 186 {
 187     return wxGridCellEditor::IsAcceptedKey(event);
 188 }
 189
 190 void wxGridCellPathEditor::StartingKey(wxKeyEvent& event)
 191 {
 192     // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
 193     // longer an appropriate way to get the character into the text control.
 194     // Do it ourselves instead.  We know that if we get this far that we have
 195     // a valid character, so not a whole lot of testing needs to be done.
 196
 197     wxTextCtrl* tc = Text();
 198     wxChar ch;
 199     long pos;
 200
 201 #if wxUSE_UNICODE
 202     ch = event.GetUnicodeKey();
 203     if (ch <= 127)
 204         ch = (wxChar)event.GetKeyCode();
 205 #else
 206     ch = (wxChar)event.GetKeyCode();
 207 #endif
 208     switch (ch)
 209     {
 210         case WXK_DELETE:
 211             // delete the character at the cursor
 212             pos = tc->GetInsertionPoint();
 213             if (pos < tc->GetLastPosition())
 214                 tc->Remove(pos, pos+1);
 215             break;
 216
 217         case WXK_BACK:
 218             // delete the character before the cursor
 219             pos = tc->GetInsertionPoint();
 220             if (pos > 0)
 221                 tc->Remove(pos-1, pos);
 222             break;
 223
 224         default:
 225             tc->WriteText(ch);
 226             break;
 227     }
 228 }
 229
 230 void wxGridCellPathEditor::HandleReturn( wxKeyEvent &event )
 231 {
 232 #if defined(__WXMOTIF__) || defined(__WXGTK__)
 233     // wxMotif needs a little extra help...
 234     size_t pos = (size_t)( Text()->GetInsertionPoint() );
 235     wxString s( Text()->GetValue() );
 236     s = s.Left(pos) + wxT("\n") + s.Mid(pos);
 237     Text()->SetValue(s);
 238     Text()->SetInsertionPoint( pos );
 239 #else
 240     // the other ports can handle a Return key press
 241     //
 242     event.Skip();
 243 #endif
 244 }
 245
 246 void wxGridCellPathEditor::SetParameters(const wxString& params)
 247 {
 248     if ( !params )
 249     {
 250         // reset to default
 251         m_maxChars = 0;
 252     }
 253     else
 254     {
 255         long tmp;
 256         if ( !params.ToLong(&tmp) )
 257         {
 258             wxLogDebug(_T("Invalid wxGridCellPathEditor parameter string '%s' ignored"), params.c_str());
 259         }
 260         else
 261         {
 262             m_maxChars = (size_t)tmp;
 263         }
 264     }
 265 }
 266
 267 // return the value in the text control
 268 wxString wxGridCellPathEditor::GetValue() const
 269 {
 270   return Text()->GetValue();
 271 }
 272
 273 #endif
 274
 275 /////////////////////////////////////////////////////////////////////////////
 276 // wxPropertyItem
 277
 278 // returns true when this property item is a filepath
 279 bool wxPropertyItem::IsFilePath()
 280 {
 281     return m_nItemType == wxPropertyList::FILE;
 282 }
 283
 284 // returns true when this property item is a dir path
 285 bool wxPropertyItem::IsDirPath()
 286 {
 287     return m_nItemType == wxPropertyList::PATH;
 288 }
 289
 290 /////////////////////////////////////////////////////////////////////////////
 291 // wxPropertyList
 292
 293 wxPropertyList::~wxPropertyList()
 294 {
 295     WX_CLEAR_ARRAY(m_PropertyItems);
 296 }
 297
 298 int wxPropertyList::AddItem(const wxString &txt)
 299 {
 300     // TODO: Add the item to the grid!
 301
 302     //int nIndex = AddString(txt);
 303     //return nIndex;
 304
 305     return 0;
 306 }
 307
 308 // order = 0 sorted (not supported yet)
 309 // order = 1 add to top
 310 // order = 2 add to bottom
 311 int wxPropertyList::AddPropItem(wxPropertyItem* pItem, int order)
 312 {
 313     m_PropertyItems.Add(pItem);
 314     if(pItem->GetAdvanced() && ! m_ShowAdvanced)
 315         return 0;
 316
 317     // disable in progress editing
 318     HideControls();
 319
 320     return AddPropertyToGrid(pItem, order);
 321 }
 322
 323 int wxPropertyList::AddPropertyToGrid(wxPropertyItem *pItem, int order)
 324 {
 325     int row = 0;
 326     if(order == 1)
 327         InsertRows(0,1);
 328     else
 329     {
 330         AppendRows(1);
 331         row = GetNumberRows() - 1;
 332     }
 333
 334     // initialise the type of renderer
 335     if(pItem->GetItemType() == wxPropertyList::CHECKBOX)
 336     {
 337         SetCellRenderer(row, 1, new wxGridCellBoolRenderer);
 338         SetCellEditor(row, 1, new wxGridCellBoolEditor);
 339     }
 340
 341 #ifdef __LINUX__
 342     // fix to make sure scrollbars are drawn properly
 343     wxGrid::AdjustScrollbars();
 344 #endif
 345
 346     // the property display is read only
 347     UpdatePropertyItem(pItem, row);
 348     return row;
 349 }
 350
 351 void wxPropertyList::AddProperty(const char* name, const char* value, const char* helpString,
 352                                 int type, const char* comboItems, bool reverseOrder, bool advanced)
 353 {
 354     wxPropertyItem* pItem = 0;
 355
 356     // add or update the property item
 357     for(size_t i = 0; i < m_PropertyItems.Count(); i++)
 358     {
 359         if(m_PropertyItems[i]->GetPropName().IsSameAs(name))
 360         {
 361             pItem = m_PropertyItems[i];
 362             if(!pItem->GetCurValue().IsSameAs(value))
 363             {
 364                 pItem->SetCurValue(value);
 365                 pItem->SetHelpString(helpString);
 366                 pItem->SetAdvanced(advanced);
 367
 368                 // update the property item
 369                 int row = FindProperty(pItem);
 370                 if(row != -1)
 371                     UpdatePropertyItem(pItem, row);
 372             }
 373             return;
 374         }
 375     }
 376
 377     // if it is not found, then create a new one
 378     if(!pItem)
 379     {
 380         pItem = new wxPropertyItem(name, value, helpString, type, comboItems);
 381         pItem->SetAdvanced(advanced);
 382
 383         AddPropItem(pItem, 1);
 384     }
 385 }
 386
 387 void wxPropertyList::UpdateGridView()
 388 {
 389     // make sure all items are shown, remove items that should not be shown
 390     bool keepItem;
 391     int row;
 392     for(size_t i = 0; i < m_PropertyItems.Count(); i++)
 393     {
 394         // to begin with, does this item fit the query?
 395         keepItem = m_strQuery.IsEmpty() || (m_PropertyItems[i]->GetPropName().Find(m_strQuery) != -1);
 396         if(keepItem)
 397         {
 398             // when advanced items are allowed to be shown, keep when ok
 399             if(!m_ShowAdvanced)
 400                 keepItem = !m_PropertyItems[i]->GetAdvanced();
 401         }
 402
 403         // find the item, if not present but keep is true, add, if
 404         // present but keep is false, remove
 405         row = -1;
 406         for(size_t j = 0; j < (size_t)GetNumberRows(); j++)
 407         {
 408             if(m_PropertyItems[i]->GetPropName().IsSameAs(GetCellValue(j, 0)))
 409             {
 410                 row = j;
 411                 break;
 412             }
 413         }
 414
 415         if(row == -1 && keepItem)
 416             AddPropertyToGrid(m_PropertyItems[i], (m_ShowAdvanced ? 2 : 0));
 417         else if(row != -1 && !keepItem)
 418             DeleteRows(row, 1);
 419     }
 420
 421 #ifdef __LINUX__
 422     // fix to make sure scrollbars are drawn properly
 423     wxGrid::AdjustScrollbars();
 424 #endif
 425 }
 426
 427 void wxPropertyList::HideControls()
 428 {
 429     DisableCellEditControl();
 430 }
 431
 432 void wxPropertyList::RemoveProperty(wxPropertyItem *pItem)
 433 {
 434     HideControls();
 435
 436     // look for property in grid, delete it when present
 437     for(size_t j = 0; j < (size_t)GetNumberRows(); j++)
 438     {
 439         if(pItem->GetPropName().IsSameAs(GetCellValue(j, 0), false))
 440         {
 441             DeleteRows(j, 1);
 442
 443 #ifdef __LINUX__
 444             // fix to make sure scrollbars are drawn properly
 445             wxGrid::AdjustScrollbars();
 446 #endif
 447              break;
 448         }
 449     }
 450
 451     // delete the item from the list
 452     m_PropertyItems.Remove(pItem);
 453     delete pItem;
 454 }
 455
 456 wxPropertyItem *wxPropertyList::FindPropertyByName(const wxString &name)
 457 {
 458     for(size_t i = 0; i < m_PropertyItems.Count(); i++)
 459     {
 460         // we have an advanced item, go through table and if not present, show it
 461         if(m_PropertyItems[i]->GetPropName().IsSameAs(name, true))
 462             return m_PropertyItems[i];
 463     }
 464
 465     return 0;
 466 }
 467
 468 /**
 469 void wxPropertyList::OnIgnore()
 470 {
 471   if(m_curSel == -1 || this->GetCount() <= 0)
 472     {
 473     return;
 474     }
 475   wxPropertyItem* pItem = (wxPropertyItem*) GetItemDataPtr(m_curSel);
 476   pItem->m_curValue = "IGNORE";
 477   InvalidateList();
 478 }
 479 */
 480
 481 /**
 482 void wxPropertyList::OnDelete()
 483 {
 484   if(m_curSel == -1 || this->GetCount() <= 0)
 485     {
 486     return;
 487     }
 488   wxPropertyItem* pItem = (wxPropertyItem*) GetItemDataPtr(m_curSel);
 489   m_CMakeSetupDialog->GetCMakeInstance()->GetCacheManager()->RemoveCacheEntry(pItem->m_propName);
 490   m_PropertyItems.erase(pItem);
 491   delete pItem;
 492   this->DeleteString(m_curSel);
 493   this->HideControls();
 494   this->SetTopIndex(0);
 495   InvalidateList();
 496 }
 497 */
 498
 499 /**
 500 void wxPropertyList::OnHelp()
 501 {
 502   if(m_curSel == -1 || this->GetCount() <= 0)
 503     {
 504     return;
 505     }
 506   wxPropertyItem* pItem = (wxPropertyItem*) GetItemDataPtr(m_curSel);
 507   MessageBox(pItem->m_HelpString, pItem->m_propName, MB_OK|MB_ICONINFORMATION);
 508 }
 509 */
 510
 511 void wxPropertyList::RemoveAll()
 512 {
 513     WX_CLEAR_ARRAY(m_PropertyItems);
 514     m_generatedProjects = false;
 515
 516     if(GetNumberRows() > 0)
 517         DeleteRows(0, GetNumberRows());
 518
 519     m_strQuery.Empty();
 520
 521 #ifdef __LINUX__
 522     // fix to make sure scrollbars are drawn properly
 523     wxGrid::AdjustScrollbars();
 524 #endif
 525 }
 526
 527 void wxPropertyList::ShowAdvanced()
 528 {
 529     // set flag in the control
 530     m_ShowAdvanced = true;
 531     UpdateGridView();
 532 }
 533
 534
 535 void wxPropertyList::HideAdvanced()
 536 {
 537     // set flag in the control
 538     m_ShowAdvanced = false;
 539     UpdateGridView();
 540 }
 541
 542 int wxPropertyList::FindProperty(wxPropertyItem *pItem)
 543 {
 544     if(GetNumberRows() > 0 && pItem != 0)
 545     {
 546         // find the property the traditional way
 547         for(size_t j = 0; j < (size_t)GetNumberRows(); j++)
 548         {
 549             if(pItem->GetPropName().IsSameAs(GetCellValue(j, 0)))
 550                 return j;
 551         }
 552     }
 553
 554     return -1;
 555 }
 556
 557 wxPropertyItem *wxPropertyList::GetPropertyItemFromRow(int row)
 558 {
 559     if(row < GetNumberRows() && row >= 0)
 560     {
 561         wxString str = GetCellValue(row, 0);
 562         // find the property the traditional way
 563         for(size_t i = 0; i < (size_t)m_PropertyItems.Count(); i++)
 564         {
 565             if(m_PropertyItems[i]->GetPropName().IsSameAs(str))
 566                 return m_PropertyItems[i];
 567         }
 568     }
 569
 570     return 0;
 571 }
 572
 573 bool wxPropertyList::UpdatePropertyItem(wxPropertyItem *pItem, int row)
 574 {
 575     wxCHECK(row < GetNumberRows(), false);
 576
 577     // reflect the property's state to match the grid row
 578
 579     SetReadOnly(row, 0);
 580     // TODO: Make this a UpdatePropItem where ADVANCED, and new edit values are reflected
 581     SetCellValue(row,0, pItem->GetPropName());
 582
 583     // boolean renderer
 584     if(pItem->GetItemType() == wxPropertyList::CHECKBOX)
 585     {
 586         // translate ON or TRUE (case insensitive to a checkbox)
 587         if(pItem->GetCurValue().IsSameAs(wxT("ON"), false) ||
 588            pItem->GetCurValue().IsSameAs(wxT("TRUE"), false))
 589             SetCellValue(row, 1, wxT("1"));
 590         else
 591             SetCellValue(row, 1, wxT("0"));
 592     }
 593     else
 594     {
 595         // for normal path values, give bold in cell when
 596         // the NOTFOUND is present, for emphasis
 597         wxString str = pItem->GetPropName() + wxT("-NOTFOUND");
 598         if(pItem->GetCurValue().IsSameAs(str))
 599         {
 600             wxFont fnt = GetCellFont(row, 0);
 601             fnt.SetWeight(wxFONTWEIGHT_BOLD);
 602             SetCellFont(row, 1, fnt);
 603         }
 604         else
 605             SetCellFont(row, 1, GetCellFont(row, 0));
 606
 607         SetCellValue(row,1, pItem->GetCurValue());
 608     }
 609
 610     if(pItem->GetCurValue().IsSameAs("IGNORE"))
 611     {
 612         // ignored cell is completely dimmed
 613         wxColour col(192,192,192);
 614         SetCellTextColour(row, 1, col);
 615     }
 616     else
 617     {
 618         // we colour paths blue, filenames green, all else black
 619         wxColour col;
 620         if(pItem->IsDirPath())
 621             col.Set(0,0,255);
 622         else if(pItem->IsFilePath())
 623             col.Set(0,128,0);
 624         else
 625             col = GetCellTextColour(row, 0);
 626
 627         SetCellTextColour(row, 1, col);
 628     }
 629
 630     if(pItem->GetNewValue())
 631     {
 632         // new cell is red
 633         wxColour col(255,100,100);
 634         SetCellBackgroundColour(row, 0, col);
 635     }
 636     else
 637     {
 638         // old cell is grey
 639         wxColour col(192, 192, 192);
 640         SetCellBackgroundColour(row, 0, col);
 641     }
 642
 643     return true;
 644 }
 645
 646 void wxPropertyList::OnSelectCell( wxGridEvent& event )
 647 {
 648     this->SetFocus();
 649     event.Skip();
 650 }
 651
 652 void wxPropertyList::OnCellChange( wxGridEvent& event )
 653 {
 654     int row = event.GetRow();
 655
 656     wxPropertyItem *pItem = GetPropertyItemFromRow(row);
 657     if(pItem && row != wxNOT_FOUND)
 658     {
 659         // write propery back, and set as new
 660         pItem->SetNewValue(true);
 661
 662         // write back bool
 663         if(pItem->GetItemType() == CHECKBOX)
 664         {
 665             if(GetCellValue(row, 1).IsSameAs("1"))
 666                 pItem->SetCurValue("ON");
 667             else
 668                 pItem->SetCurValue("OFF");
 669         }
 670         else
 671             pItem->SetCurValue(GetCellValue(row, 1));
 672
 673         UpdatePropertyItem(pItem, row);
 674         event.Skip();
 675     }
 676 }
 677
 678 void wxPropertyList::OnCellPopup( wxGridEvent& event )
 679 {
 680     wxPoint pt;
 681     int row = event.GetRow();
 682
 683     //pt = ::wxGetMousePosition();
 684     //ScreenToClient(pt);
 685
 686     //row = YToRow(pt.y);
 687     if(row != wxNOT_FOUND)
 688     {
 689         wxPropertyItem *pItem = GetPropertyItemFromRow(row);
 690
 691         if(pItem)
 692         {
 693             // select the row first if already in selection, don't
 694             // this will clear the previous selection
 695             if(!IsInSelection(row, 0))
 696                 SelectRow(row);
 697
 698             // show popup menu
 699             wxMenu *menu = AppResources::CreatePopupMenu();
 700
 701             // enable when it is browsable, and selected one only
 702             wxMenuItem *item = menu->FindItem(ID_CACHE_BROWSE);
 703             if(item)
 704                 item->Enable(IsSelectedItemBrowsable());
 705
 706             PopupMenu(menu);
 707
 708             delete menu;
 709         }
 710     }
 711 }
 712
 713 void wxPropertyList::OnIgnoreCache( wxCommandEvent& event )
 714 {
 715     HideControls();
 716
 717     // ignore all selected items
 718     for(size_t i = 0; i < (size_t)GetNumberRows(); i++)
 719     {
 720         if(IsInSelection(i, 0))
 721         {
 722             wxPropertyItem *pItem = GetPropertyItemFromRow(i);
 723             if(pItem)
 724             {
 725                 pItem->SetCurValue("IGNORE");
 726                 UpdatePropertyItem(pItem, i);
 727             }
 728         }
 729     }
 730 }
 731
 732 void wxPropertyList::OnDeleteCache( wxCommandEvent& event )
 733 {
 734     HideControls();
 735
 736     // convert selections to prop items
 737     wxArrayPtrVoid items;
 738     for(size_t i = 0; i < (size_t)GetNumberRows(); i++)
 739     {
 740         // if selected, query for removal
 741         if(IsInSelection(i, 0))
 742         {
 743             wxPropertyItem *pItem = GetPropertyItemFromRow(i);
 744             if(pItem)
 745                 items.Add((void *)pItem);
 746         }
 747     }
 748
 749     // now delete all prop items in cells
 750     for(size_t i = 0; i < items.Count(); i++)
 751         RemoveProperty((wxPropertyItem *)items[i]);
 752 }
 753
 754 void wxPropertyList::OnBrowseItem( wxCommandEvent& event )
 755 {
 756     BrowseSelectedItem();
 757 }
 758
 759 bool wxPropertyList::IsSelectedItemBrowsable(int row)
 760 {
 761     // when there is only one selection, and our current item
 762     // is browsable, make sure it can be selected.
 763     wxPropertyItem *pItem = 0;
 764
 765     size_t count = 0;
 766     for(size_t i = 0; i < (size_t)GetNumberRows() && (count < 2); i++)
 767     {
 768         if(IsInSelection(i, 0))
 769         {
 770             if(!pItem)
 771                 pItem = GetPropertyItemFromRow(i);
 772             count ++;
 773         }
 774     }
 775
 776     // if we found nothing, take row (because the event EVT_GRID_CELL_SELECTED
 777     // deselects the cells first before selecting the new one again
 778     if(row != -1 && !pItem)
 779     {
 780         pItem = GetPropertyItemFromRow(row);
 781         count ++; // needed because of next loop
 782     }
 783
 784     // only one item allowed to select
 785     if(pItem && count == 1)
 786     {
 787         if(pItem)
 788             return pItem->IsDirPath() || pItem->IsFilePath();
 789     }
 790
 791     return false;
 792 }
 793
 794
 795 void wxPropertyList::BrowseSelectedItem()
 796 {
 797     HideControls();
 798
 799     for(size_t i = 0; i < (size_t)GetNumberRows(); i++)
 800     {
 801         if(IsInSelection(i, 0))
 802         {
 803             // browse for file or directory
 804             wxPropertyItem *pItem = GetPropertyItemFromRow(i);
 805             if(pItem)
 806             {
 807                 wxString title;
 808                 wxString str = pItem->GetPropName() + _("-NOTFOUND");
 809                 if(pItem->GetCurValue().IsSameAs(str, true))
 810                     str.Empty();
 811                 else
 812                     str = pItem->GetCurValue();
 813
 814                 // browse the directory path
 815
 816                 if(pItem->IsDirPath())
 817                 {
 818                     title = _("Select path for ") + pItem->GetPropName();
 819                     str = ::wxDirSelector(title, str, 0, wxDefaultPosition, this);
 820                 }
 821                 else if(pItem->IsFilePath())
 822                 {
 823                     title = _("Select file for ") + pItem->GetPropName();
 824                     str = ::wxFileSelector(title, str, _(""), _(""), _(MC_DEFAULT_WILDCARD), wxFILE_MUST_EXIST, this);
 825                 }
 826                 else
 827                     str.Empty();
 828
 829                 if(!str.IsEmpty())
 830                 {
 831                     pItem->SetCurValue(str.c_str());
 832                     UpdatePropertyItem(pItem, i);
 833                 }
 834             }
 835
 836             // only allow one item to browse
 837             break;
 838         }
 839     }
 840 }
 841
 842 void wxPropertyList::OnSizeGrid( wxSizeEvent &event )
 843 {
 844     int width, height;
 845
 846     // make sure the grid's cells are equally adjusted
 847     GetClientSize(&width, &height);
 848     SetDefaultColSize(width / 2, true);
 849
 850     wxGrid::AdjustScrollbars();
 851 }
 852
 853 void wxPropertyList::OnKeyPressed( wxKeyEvent &event )
 854 {
 855     event.Skip();
 856 }