src/creaImageIOWxTreeView.cpp

   1 /*
   2 # ---------------------------------------------------------------------
   3 #
   4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   5 #                        pour la Santé)
   6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   9 #
  10 #  This software is governed by the CeCILL-B license under French law and
  11 #  abiding by the rules of distribution of free software. You can  use,
  12 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  13 #  license as circulated by CEA, CNRS and INRIA at the following URL
  14 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  15 #  or in the file LICENSE.txt.
  16 #
  17 #  As a counterpart to the access to the source code and  rights to copy,
  18 #  modify and redistribute granted by the license, users are provided only
  19 #  with a limited warranty  and the software's author,  the holder of the
  20 #  economic rights,  and the successive licensors  have only  limited
  21 #  liability.
  22 #
  23 #  The fact that you are presently reading this means that you have had
  24 #  knowledge of the CeCILL-B license and that you accept its terms.
  25 # ------------------------------------------------------------------------
  26 */
  27
  28 #include <creaImageIOWxTreeView.h>
  29 #include <creaImageIOGimmickView.h>
  30 #include <wx/splitter.h>
  31 #include <wx/gdicmn.h>
  32 #include <boost/date_time/gregorian/gregorian.hpp>
  33 #include <creaImageIOGimmick.h>
  34 #ifdef _DEBUG
  35 #define new DEBUG_NEW
  36 #endif
  37 //=====================================================================
  38 namespace creaImageIO
  39 {
  40
  41   //=====================================================================
  42 }
  43 //=====================================================================
  44
  45 //=====================================================================
  46 ///Comparing function for ordering algorithm. Takes parameters as strings.
  47 int wxCALLBACK CompareFunctionStrings(long item1, long item2, long sortData)
  48 {
  49   creaImageIO::ItemData* data1 = (creaImageIO::ItemData*)item1;
  50   creaImageIO::ItemData* data2 = (creaImageIO::ItemData*)item2;
  51
  52   const std::string& s1(*(data1->attr));
  53   const std::string& s2(*(data2->attr));
  54
  55   if(sortData==1)
  56     {
  57       // inverse the order
  58       if (s1 < s2)
  59         return 1;
  60       if (s1 > s2)
  61         return -1;
  62
  63       return 0;
  64     }
  65   else
  66     {
  67       if (s1 < s2)
  68         return -1;
  69       if (s1 > s2)
  70         return 1;
  71
  72       return 0;
  73
  74     }
  75 }
  76 //=====================================================================
  77
  78 //=====================================================================
  79 ///Comparing function for ordering algorithm. Takes parameters as ints.
  80 int wxCALLBACK CompareFunctionInts(long item1, long item2, long sortData)
  81 {
  82   creaImageIO::ItemData* data1 = (creaImageIO::ItemData*)item1;
  83   creaImageIO::ItemData* data2 = (creaImageIO::ItemData*)item2;
  84
  85   const std::string& s1(*(data1->attr));
  86   const std::string& s2(*(data2->attr));
  87
  88   int val1=atoi(s1.c_str());
  89   int val2=atoi(s2.c_str());
  90
  91   if(sortData==1)
  92     {
  93       // inverse the order
  94       if (val1 < val2)
  95         return 1;
  96       if (val1 > val2)
  97         return -1;
  98
  99       return 0;
 100     }
 101   else
 102     {
 103       if (val1 < val2)
 104         return -1;
 105       if (val1 > val2)
 106         return 1;
 107
 108       return 0;
 109
 110     }
 111
 112 }
 113
 114 //=====================================================================
 115
 116
 117 //=====================================================================
 118 namespace creaImageIO
 119 {
 120   //=====================================================================
 121   // CTor
 122   WxTreeView::WxTreeView(TreeHandler* handler,
 123                          GimmickView* gimmick,
 124                          wxWindow* parent,
 125                          const wxWindowID id)
 126     : wxPanel(parent,id),
 127       TreeView(handler, gimmick)
 128   {
 129     GimmickDebugMessage(1,"WxTreeView::WxTreeView"<<std::endl);
 130
 131     // Split part below toolbar into notebook for views and panel
 132     // for preview, messages...
 133     // TO DO : Splitter
 134     //    mSplitter = new wxSplitterWindow( this , -1);
 135
 136     // Global sizer
 137     msizer                      = new wxBoxSizer(wxHORIZONTAL);
 138     int ctrl_style      = wxLC_REPORT | wxLC_VRULES;
 139     int col_style       = wxLIST_FORMAT_LEFT;
 140     // Creating the ListCtrl for the levels > 0 (not for Root level)
 141     for (int i = 0;i < handler->GetTree().GetNumberOfLevels() -1; ++i)
 142     {
 143                 GimmickDebugMessage(5,"Creating view for level "<<i <<std::endl);
 144                 LevelType level;
 145                 level.SelectedUpToDate  = true;
 146                 level.SortColumn                = 0;
 147
 148                 // If the first level : parent = this
 149                 wxWindow* sparent               = this;
 150                 // else parent = last splitter
 151                 if (i>0)
 152                 {
 153                         sparent = mLevelList[i-1].wxSplitter;
 154                 } // if
 155                 level.wxSplitter = new wxSplitterWindow( sparent , -1);
 156                 if(i!=0)
 157                 {
 158                         level.wxSplitter->Show(false);
 159                 } // if
 160                 //          level.wxSplitter->SetMinimumPaneSize(100);
 161
 162                 wxListCtrl* ctrl = new wxListCtrl(level.wxSplitter,
 163
 164 // EED1 2018-08-16
 165 //                                                i,
 166                                                   wxID_ANY,
 167
 168                                                   wxDefaultPosition,
 169                                                   wxDefaultSize,
 170                                                   ctrl_style);
 171                 level.wxCtrl = ctrl;
 172                 level.wxSplitter->Initialize(ctrl);
 173
 174                 // Create the columns : one for each attribute of the level
 175                 int col = 0;
 176                 std::string title;
 177
 178                 tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
 179                 for (a  = handler->GetTree().GetAttributeDescriptorList(i+1).begin();
 180                          a != handler->GetTree().GetAttributeDescriptorList(i+1).end();
 181                          ++a)
 182                 {
 183                         GimmickDebugMessage(5,"Creating column "<<col<<" : " <<a->GetName() <<std::endl);
 184                         if(a->GetFlags()!=creaImageIO::tree::AttributeDescriptor::PRIVATE)
 185                         {
 186                                 if(a->GetName()=="UNKNOWN")
 187                                 {
 188                                         title = "#";
 189                                         title += handler->GetTree().GetLevelDescriptor(i+1).GetName();
 190                                         if (title[title.size()-1]!='s')
 191                                         {
 192                                                 title += "s";
 193                                         } // if
 194                                 } else {
 195                                         title=a->GetName();
 196                                 } // if a
 197                                 std::string temp = a->GetKey();
 198                                 if (temp.compare("ID") != 0)
 199                                 {
 200                                         ctrl->InsertColumn(col,crea::std2wx(title),col_style);
 201                                         col++;
 202                                 } // if temp
 203                                         level.key.push_back(a->GetKey());
 204                         } // if
 205
 206                 } // for a
 207                 mLevelList.push_back(level);
 208       } //  for i
 209
 210 #if wxUSE_MENUS
 211
 212          // Column Menu
 213     menu =new wxMenu();
 214         wxMenuItem* m1=menu->Append(wxID_ANY, _T("&Sort ascending"));
 215         wxMenuItem* m2=menu->Append(wxID_ANY, _T("&Sort descending"));
 216         wxMenuItem* m3=menu->Append(wxID_ANY, _T("&Filter"));
 217         mAscendingID=m1->GetId();
 218         mDescendingID=m2->GetId();
 219         mFilterID=m3->GetId();
 220         Connect( mAscendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
 221         Connect( mDescendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
 222         Connect( mFilterID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupFilter) );
 223
 224
 225         ////SubMenuItem EXPORT
 226         subExportMenu = new wxMenu();
 227         wxMenuItem *subExp1 = subExportMenu->Append(wxID_ANY, _T("&Export to Storage"));
 228         Connect( subExp1->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnExportToStorage) );
 229
 230         //ItemMenu
 231         menuItem =new wxMenu();
 232
 233         wxMenuItem* m2Item=menuItem->Append(wxID_ANY, _T("&Local Copy"));
 234         wxMenuItem* m3Item=menuItem->Append(wxID_ANY, _T("&Edit Fields"));
 235         wxMenuItem* m4Item=menuItem->Append(wxID_ANY, _T("&Display Dicom Tags"));
 236         menuItem->AppendSubMenu(subExportMenu, wxT("&Export"));
 237
 238         wxMenuItem* m1Item=menuItem->Append(wxID_ANY, _T("&Anonymize"));
 239         mAnonymizingID=m1Item->GetId();
 240         Connect( mAnonymizingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnAnonymizer) );
 241
 242         mLocalCopyID=m2Item->GetId();
 243         mEditFieldID=m3Item->GetId();
 244         mDumpID=m4Item->GetId();
 245
 246         Connect( mLocalCopyID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnLocalCopy) );
 247         Connect( mEditFieldID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnEditField) );
 248         Connect( mDumpID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnDumpTags) );
 249
 250 #endif // wxUSE_MENUS
 251         /// Initialize the first level splitter
 252
 253         msizer->Add( mLevelList[0].wxSplitter ,1, wxGROW  ,0);
 254         //      mColumnSelected = 1;
 255         mLastSelected           = 0;
 256         mLastLevel                      = 0;
 257         //      mDirection              = true;
 258
 259         mIgnoreSelectedChanged = false;
 260
 261         //CreateColorPalette();
 262     UpdateLevel(1);
 263
 264     SetSizer( msizer );
 265     SetAutoLayout(true);
 266     Layout();
 267   }
 268   //=====================================================================
 269
 270   //=====================================================================
 271   /// Destructor
 272   WxTreeView::~WxTreeView()
 273   {
 274     GimmickDebugMessage(1,"WxTreeView::~WxTreeView"<<std::endl);
 275         delete menu;
 276         delete menuItem;
 277   }
 278   //=====================================================================
 279
 280   //=====================================================================
 281   const std::vector<tree::Node*>& WxTreeView::GetSelected(int level)
 282   {
 283           std::vector<tree::Node*>& sel = mLevelList[0].Selected;
 284     //  if (GetSelectedUpToDate(level))
 285     int l = level - 1;
 286     // the selection of upper level
 287         if(mLevelList.size() == level -1)
 288         {
 289                 sel = mLevelList.back().Selected;
 290         } else {
 291                 sel=  mLevelList[l].Selected;
 292         }
 293         if (sel.size() > 0)
 294         {
 295                 sel.clear();
 296         }
 297         if (level == 1)
 298     {
 299                 sel.push_back( GetTreeHandler()->GetTree().GetTree() );
 300     } else if (level < mLevelList.size()+2 ) {
 301                 long item = -1;
 302                 for ( ;; )
 303                 {
 304                 item = GetCtrl(l-1)->GetNextItem(item,
 305                                                                                  wxLIST_NEXT_ALL,
 306                                                                                  wxLIST_STATE_SELECTED);
 307                         if ( item == -1 )
 308                         {
 309                                 break;
 310                         }
 311 //                      long adr = (long)GetCtrl(l-1)->GetItemData(item);
 312                         ItemData* adr = (ItemData*)GetCtrl(l-1)->GetItemData(item);
 313 //                      tree::Node* n = ((ItemData*)adr)->node;
 314                         tree::Node* n = adr->node;
 315                         /* FCY 18-04-2011: don't understand the real purpose of these lines,
 316                          if uncomment add last frame in first place
 317                                 if(mLastSelected==item)
 318                         {
 319                                 std::vector<tree::Node*>::iterator it;
 320                                 it = sel.begin();
 321                                 it = sel.insert ( it , n );
 322                         }
 323                         else
 324                         {*/
 325                                 sel.push_back(n);
 326                         //}
 327
 328                 } // for
 329                 /*int n = GetCtrl(l-1)->GetItemCount();
 330                 for (int i = 0; i<n; i++)
 331                 {
 332                         std::cout<<GetCtrl(l-1)->GetItemState(i,wxLIST_STATE_SELECTED)<<std::endl;
 333                         if ( GetCtrl(l-1)->GetItemState(i,wxLIST_STATE_SELECTED))
 334                         {
 335                                 long adr = GetCtrl(l-1)->GetItemData(i);
 336                                 tree::Node* n = ((ItemData*)adr)->node;
 337                                 if(mLastSelected==i)
 338                                 {
 339                                         std::vector<tree::Node*>::iterator it;
 340                                         it = sel.begin();
 341                                         it = sel.insert ( it , n );
 342                                 }
 343                                 else
 344                                 {
 345
 346                                         sel.push_back(n);
 347                                 }
 348                         }
 349               }*/
 350           } else {
 351                 // NOTHING
 352         }
 353
 354     //    return mLevelList[level-1].Selected;
 355     return sel;
 356   }
 357
 358   //=====================================================================
 359
 360   //=====================================================================
 361   ///Removes selected nodes on last selected level
 362    // NOT SPECIFIC
 363   void WxTreeView::RemoveSelected(std::string &i_save)
 364   {
 365          bool erase=false;
 366
 367          unsigned int tempLevel = mLastLevel;
 368     mLastLevel+=1;
 369     const std::vector<tree::Node*>& sel=GetSelected(mLastLevel+1);
 370         // if no selection, no remove action.
 371     if(sel.size() != 0)
 372         {
 373             std::stringstream out;
 374             std::string levelName=GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName();
 375             out<<"Delete ";
 376             out<<sel.size();
 377             if(sel.size()>1&&levelName.at(levelName.size()-1)!='s')
 378               {
 379                 out<<" "<<levelName;
 380                 out<<"s?";
 381               }
 382             else
 383               {
 384                 out<<" "<<GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName()<<"?";
 385               }
 386             if (wxMessageBox(crea::std2wx(out.str()),
 387                              _T("Remove Files"),
 388                              wxYES_NO,this ) == wxYES)
 389               {
 390                 erase = true;
 391               }
 392             if(erase)
 393                   {
 394             GetGimmickView()->modifyValidationSignal(false);
 395                     bool needRefresh=false;
 396                     std::vector<tree::Node*>::const_iterator i;
 397                     for (i=sel.begin(); i!=sel.end(); ++i)
 398                       {
 399                         GimmickMessage(1,"deleting '" << (*i)->GetLabel() << "'" << mLastLevel << std::endl );
 400                         if((*i)->GetParent()->GetNumberOfChildren()<2)
 401                           {
 402                             needRefresh=true;
 403                           }
 404                           //tree::Node* n = new (tree::Node*)(*i);
 405                           GetTreeHandler()->LoadChildren((*i),4);
 406                           GetGimmickView()->AddIgnoreFile(*i);
 407                           GetTreeHandler()->Remove(*i);
 408                       }
 409
 410                     if(needRefresh && mLastLevel>1)
 411                     {
 412                                 UpdateLevel(mLastLevel-2);
 413                     } else if(mLastLevel>1) {
 414                                 UpdateLevel(mLastLevel-1);
 415                     } else {
 416                                 UpdateLevel(mLastLevel);
 417                     } // if needRefresh
 418                   } // if erase
 419         } else {
 420                 // no need to incremente level
 421                 mLastLevel = tempLevel;
 422         }
 423
 424         if (erase && mLastLevel == 1 && i_save == "0")
 425         {
 426
 427                 RemoveAlertDlg *dial = new RemoveAlertDlg(this,  crea::std2wx("Remove files"), wxSize(450,300));
 428                 //dial->ShowModal();
 429                 if (dial->ShowModal() == wxID_OK)
 430                 {
 431                         i_save = dial->isChecked() == false? "0" : "1";
 432                 }
 433
 434         }
 435   }
 436
 437
 438   //=====================================================================
 439   /// Updates a level of the view (adds or removes children, etc.)
 440   void WxTreeView::UpdateLevel( int level )
 441   {
 442         GimmickDebugMessage(1,
 443                         GetTreeHandler()->GetTree().GetLabel()
 444                         <<"WxTreeView::UpdateLevel(level "
 445                         <<level
 446                         <<")"
 447                         <<std::endl);
 448
 449     wxBusyCursor busy;
 450     RecursiveUpdateLevel(level);
 451     int i;
 452     for (i=0; i<level-1; i++)
 453     {
 454                 if (!GetSplitter(i)->IsSplit())
 455                 {
 456                         GetSplitter(i)->SplitVertically(  GetCtrl(i), GetSplitter(i+1),100 );
 457                 } // if
 458       } // for
 459     if (GetSplitter(i)->IsSplit())
 460         {
 461                 GetSplitter(i)->Unsplit();
 462         }
 463
 464   }
 465   //=====================================================================
 466
 467   //=====================================================================
 468   /// Recursive method called upon by UpdateLevel to refresh all windows
 469   void WxTreeView::RecursiveUpdateLevel( int level )
 470   {
 471     GimmickDebugMessage(1,
 472                         GetTreeHandler()->GetTree().GetLabel()
 473                         <<"WxTreeView::RecursiveUpdateLevel(level "
 474                         <<level
 475                         <<")"<<std::endl);
 476
 477     int l = level - 1;
 478     const std::vector<tree::Node*>& sel(GetSelected(level));
 479
 480
 481     // to speed up inserting we hide the control temporarily
 482     GetCtrl(l)->Hide();
 483     GetCtrl(l)->DeleteAllItems();
 484
 485     std::vector<tree::Node*>::const_iterator i;
 486
 487     for (i=sel.begin(); i!=sel.end(); ++i)
 488     {
 489         GimmickDebugMessage(1,
 490                             "adding children of '"
 491                             <<(*i)->GetLabel()
 492                             <<"'"
 493                             <<std::endl);
 494         int _id=0;
 495
 496         //Adds items and sets their attributes
 497
 498         GetTreeHandler()->LoadChildren(*i,1);
 499         tree::Node::ChildrenListType::reverse_iterator j;
 500         for (j = (*i)->GetChildrenList().rbegin();
 501              j!= (*i)->GetChildrenList().rend();
 502              ++j)
 503           {
 504             GimmickDebugMessage(1,
 505                                 "adding children "
 506                                 <<(*j)->GetLabel()
 507                                 <<"'"
 508                                 <<std::endl);
 509
 510             wxListItem item;
 511             item.SetMask(wxLIST_MASK_STATE |
 512                          wxLIST_MASK_TEXT |
 513                          //                      wxLIST_MASK_IMAGE |
 514                          wxLIST_MASK_DATA |
 515                          //                      wxLIST_MASK_WIDTH |
 516                          wxLIST_MASK_FORMAT
 517                          );
 518
 519                 ItemData* data  = new ItemData();
 520             data->node          = *j;
 521             data->id            = _id;
 522
 523             item.SetId(_id);
 524             item.SetData(data);
 525
 526             _id++;
 527             GetCtrl(l)->InsertItem(item);
 528
 529             //Setting attributes
 530             for (int k=0; k<GetCtrl(l)->GetColumnCount(); ++k)
 531             {
 532                         std::string val;
 533                         //  Temporary correction : it works but no explanation about the problem FCY
 534                         if(k==0 && level <3)
 535                         {
 536                                 val = (*j)->GetAttribute("NumberOfChildren");
 537                         } else {
 538                                 val = (*j)->GetAttribute(mLevelList[l].key[k]);
 539                         }
 540                         if(((*j)->GetAttributeDescriptor(mLevelList[l].key[k])).isDateEntry()) // Date
 541                         {
 542                                 //                                        std::cout << "["<<val<< "]" << std::endl;
 543                                 std::string valtmp(val);
 544                                 try
 545                                 {
 546                                         boost::gregorian::date d1(boost::gregorian::from_undelimited_string(val));
 547                                         val = to_iso_extended_string(d1);
 548                                 } catch (...) {
 549                                         val =  valtmp;
 550                                 }
 551                                 //                                        std::cout << "["<<val<< "]" << std::endl;
 552                         } else if(((*j)->GetAttributeDescriptor(mLevelList[l].key[k])).isTimeEntry()) // Time
 553                         {
 554                                 if ((val.size()>6) && (val != "" || val != " "))
 555                                 {
 556                                         val = val.substr(0,2) + " : " + val.substr(2,2) + " : " + val.substr(4,2);
 557                                 }
 558                         } else {
 559                                 if (val.size()==0)
 560                                 {
 561                                         val = "?";
 562                                 }
 563                         } // if j
 564                         if (val.size()==0)
 565                         {
 566                                 val = "X";
 567                         }
 568                         item.SetText( crea::std2wx(val));
 569                         item.SetColumn(k);
 570
 571                         GetCtrl(l)->SetItem(item);
 572                 } // for k
 573                 item.Clear();
 574
 575           } // for j
 576       }  // for i
 577
 578     SortLevel(l);
 579     GetCtrl(l)->Show();
 580   }
 581   //=====================================================================
 582
 583
 584   //================================================================
 585   void WxTreeView::OnItemDeSelected(wxListEvent& event)
 586   {
 587     GimmickDebugMessage(1,
 588                         GetTreeHandler()->GetTree().GetLabel()
 589                         <<" WxTreeView::OnItemDeselected"<<std::endl);
 590     // retrieve the level
 591     wxObject* obj = event.GetEventObject();
 592     unsigned int level = 0;
 593     for (level = 0; level<mLevelList.size(); ++level)
 594       {
 595         if ( GetCtrl(level) == obj ) break;
 596       }
 597     SetSelectedUpToDate(level,false);
 598     // to allow a first selection in images TreeView
 599     if (level==mLevelList.size()-1)
 600       OnItemSelected(event);
 601   }
 602   //================================================================
 603
 604   //================================================================
 605   void WxTreeView::OnItemSelected(wxListEvent& event)
 606   {
 607     GimmickDebugMessage(1,GetTreeHandler()->GetTree().GetLabel()<<" WxTreeView::OnItemSelected"<<std::endl);
 608
 609     if (mIgnoreSelectedChanged)
 610     {
 611                 GimmickDebugMessage(1, " mIgnoreSelectedChanged true: returning"<<std::endl);
 612                 return;
 613     }
 614
 615     wxListItem info;
 616     info.m_itemId = event.m_itemIndex;
 617     mLastSelected = event.m_itemIndex;
 618     // retrieve the level
 619     wxObject* obj = event.GetEventObject();
 620     unsigned int level = 0;
 621     for (level = 0; level<mLevelList.size(); ++level)
 622     {
 623                 if ( GetCtrl(level) == obj ) break;
 624     }
 625         mLastLevel=level;
 626     GimmickDebugMessage(1," Level "<<level+1<<std::endl);
 627
 628     // Update the children level (if selection not at last level)
 629     if (level<mLevelList.size()-1)
 630     {
 631                 UpdateLevel( level + 2 );
 632                 // Reset the viewer setting the default image
 633                 GetGimmickView()->ClearSelection();
 634     }
 635     // Select all images if the selection is at series level
 636     if (level==mLevelList.size()-2)
 637         {
 638                 SelectAll(level+1);
 639         }
 640     // Validate selected images if the selection is at image level
 641     if (level==(mLevelList.size()-1)) //&&mProcess)
 642     {
 643                 if(event.GetEventType()==wxEVT_COMMAND_LIST_ITEM_SELECTED)
 644                 {
 645                   ValidateSelectedImages (true);
 646                 } else {
 647                   ValidateSelectedImages (false);
 648                 }
 649     } // if
 650   }
 651   //================================================================
 652
 653   //================================================================
 654   void WxTreeView::SelectAll(int level)
 655   {
 656     long item = -1;
 657     //    int level=mLevelList.size()-1;
 658     for ( ;; )
 659     {
 660                 item = GetCtrl(level)->GetNextItem(item,wxLIST_NEXT_ALL);
 661                 if ( item == -1 )
 662                 {
 663                         break;
 664                 }
 665                 if(item==(GetCtrl(level)->GetItemCount()-1))
 666                 {
 667                         mIgnoreSelectedChanged = false;//mProcess=true;
 668                 } else {
 669                         mIgnoreSelectedChanged = true;//        mProcess=false;
 670                 }
 671                 GetCtrl(level)->SetItemState(item,wxLIST_STATE_SELECTED, wxLIST_MASK_STATE
 672                                                  | wxLIST_MASK_TEXT |wxLIST_MASK_IMAGE | wxLIST_MASK_DATA | wxLIST_MASK_WIDTH | wxLIST_MASK_FORMAT);
 673     } // for
 674   }
 675
 676   //================================================================
 677   //================================================================
 678
 679   void WxTreeView::OnColClick(wxListEvent& event)
 680   {
 681     mColumnSelected = event.m_col;
 682     wxPoint clientpt;
 683     clientpt.x = wxGetMousePosition().x - this->GetScreenPosition().x;
 684     clientpt.y = wxGetMousePosition().y - this->GetScreenPosition().y;
 685     senderCtrl = event.GetEventObject();
 686     unsigned int level = 0;
 687     for (level = 0; level<mLevelList.size(); ++level)
 688       {
 689         if ( GetCtrl(level) == senderCtrl ) break;
 690       }
 691     PopupMenu(menu, clientpt);
 692
 693   }
 694
 695    //================================================================
 696   //================================================================
 697
 698   void WxTreeView::OnItemMenu(wxListEvent &event)
 699   {
 700          wxPoint clientpt;
 701     clientpt.x = wxGetMousePosition().x - this->GetScreenPosition().x;
 702     clientpt.y = wxGetMousePosition().y - this->GetScreenPosition().y;
 703     senderCtrl = event.GetEventObject();
 704     unsigned int level = 0;
 705     for (level = 0; level<mLevelList.size(); ++level)
 706       {
 707                 if ( GetCtrl(level) == senderCtrl ) break;
 708       }
 709           long* ptr=0;
 710           int flag;
 711           mLastRightLevel=level;
 712           mLastRightSelected=GetCtrl(level)->HitTest(wxPoint(0,clientpt.y-8),flag,ptr);
 713     PopupMenu(menuItem, clientpt);
 714
 715   }
 716
 717   //================================================================
 718   //================================================================
 719
 720   void WxTreeView::OnPopupFilter(wxCommandEvent& event)
 721   {
 722     wxBusyCursor busy;
 723     GimmickDebugMessage(7,
 724                         "WxTreeView::OnEndLabelEdit"
 725                         <<std::endl);
 726     unsigned int level = 0;
 727     for (level = 0; level<mLevelList.size(); ++level)
 728       {
 729         if ( GetCtrl(level) == senderCtrl ) break;
 730       }
 731     std::string filter = crea::wx2std(wxGetTextFromUser(_T("Enter the filter to apply"), _T("Filter On Column")));
 732
 733     std::string att;
 734
 735     long it = -1;
 736     UpdateLevel(level+1);
 737
 738     std::vector<long> items;
 739     bool in=false;
 740     int del=0;
 741     for ( ;; )
 742       {
 743         it = GetCtrl(level)->GetNextItem(it,
 744                                          wxLIST_NEXT_ALL);
 745         if ( it == -1 )
 746           break;
 747
 748         long adr = (long)GetCtrl(level)->GetItemData(it);
 749         tree::Node* nod = ((ItemData*)adr)->node;
 750         att=(*nod).GetAttribute(mLevelList[level].key[mColumnSelected]);
 751
 752
 753         if(att.find(filter)>900)
 754           {
 755
 756             if(!in)
 757               {
 758                 in=true;
 759               }
 760             else
 761               {
 762                 del+=1;
 763               }
 764
 765             items.push_back(it-del);
 766           }
 767
 768       }
 769     std::vector<long>::iterator iter;
 770     for(iter=items.begin();iter!=items.end();++iter)
 771       {
 772         GetCtrl(level)->DeleteItem(*iter);
 773       }
 774     GetGimmickView()->ClearSelection();
 775   }
 776   //================================================================
 777
 778   //================================================================
 779   void WxTreeView::OnPopupSort(wxCommandEvent& event)
 780   {
 781     wxBusyCursor busy;
 782     unsigned int level = 0;
 783     for (level = 0; level<mLevelList.size(); ++level)
 784       {
 785         if ( GetCtrl(level) == senderCtrl ) break;
 786       }
 787     mLevelList[level].SortColumn = mColumnSelected;
 788
 789     if(event.GetId()==mAscendingID)
 790       {
 791         mLevelList[level].SortAscending = true;
 792       }
 793     else if(event.GetId()==mDescendingID)
 794       {
 795         mLevelList[level].SortAscending = false;
 796       }
 797
 798     SortLevel(level);
 799   }
 800   //================================================================
 801
 802   void WxTreeView::OnAnonymizer(wxCommandEvent &event)
 803   {
 804            wxBusyCursor busy;
 805            std::vector<std::string> filesname;
 806            std::vector<tree::Node*> nodes;
 807            nodes.push_back(((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node);
 808            if(nodes.size() != 0)
 809            {
 810                    GetFilenamesAsString(nodes,filesname);
 811                    GetGimmickView()->Anonymize(filesname,0);
 812            }
 813
 814   }
 815
 816   //================================================================
 817   void WxTreeView::OnLocalCopy(wxCommandEvent& event)
 818   {
 819     wxBusyCursor busy;
 820
 821         unsigned int tempLevel = mLastLevel;
 822     mLastLevel+=1;
 823     const std::vector<tree::Node*>& sel=GetSelected(mLastLevel+1);
 824
 825     if(sel.size() != 0)
 826         {
 827             bool copy=false;
 828             std::stringstream out;
 829             std::string levelName=GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName();
 830             out<<"Copy ";
 831             out<<sel.size();
 832             if(sel.size()>1&&levelName.at(levelName.size()-1)!='s')
 833               {
 834                 out<<" "<<levelName;
 835                 out<<"s to .creaImageIO?";
 836               }
 837             else
 838               {
 839                 out<<" "<<GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName()<<" to .creaImageIO?";
 840               }
 841             if (wxMessageBox(crea::std2wx(out.str()),
 842                              _T("Remove Files"),
 843                              wxYES_NO,this ) == wxYES)
 844               {
 845                 copy = true;
 846               }
 847             if(copy)
 848                   {
 849                         std::vector<std::string> s;
 850                         GetFilenamesAsString(sel,s);
 851             GetGimmickView()->CopyFiles(s);
 852                   }
 853         }
 854         else
 855         {
 856                 mLastLevel = tempLevel;
 857         }
 858
 859
 860   }
 861   //================================================================
 862
 863    //================================================================
 864   void WxTreeView::OnEditField(wxCommandEvent& event)
 865   {
 866         if(mLastRightSelected!=-1)
 867         {
 868     tree::Node* node=((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node;
 869         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
 870         std::vector<std::string> names;
 871         std::vector<std::string> keys;
 872         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).begin();
 873              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).end();
 874              ++a)
 875         {
 876                 if(a->GetFlags()==creaImageIO::tree::AttributeDescriptor::EDITABLE)
 877             {
 878                         names.push_back(a->GetName());
 879                         keys.push_back(a->GetKey());
 880                 }
 881         }
 882         GetGimmickView()->CreateEditFieldsDialog(node,names,keys);
 883         }
 884   }
 885
 886   //================================================================
 887
 888   //================================================================
 889
 890   void WxTreeView::OnExportToStorage(wxCommandEvent &event)
 891   {
 892         std::vector<std::string> filesname;
 893         std::vector<tree::Node*> nodes;
 894         nodes.push_back(((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node);
 895         GetFilenamesAsString(nodes,filesname);
 896         GetGimmickView()->ExportToStorage(filesname);
 897   }
 898
 899   //================================================================
 900
 901   //================================================================
 902
 903   void WxTreeView::OnDumpTags(wxCommandEvent &event)
 904   {
 905           if(mLastRightSelected!=-1)
 906         {
 907                 tree::Node* node=((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node;
 908                 tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
 909                 std::vector<std::string> names;
 910                 std::vector<std::string> keys;
 911                 for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).begin();
 912                          a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).end();
 913                          ++a)
 914                         {
 915                                 if(a->GetKey()=="FullFileName")
 916                                 {
 917                                         GetGimmickView()->DumpTags(node->GetAttribute("FullFileName"));
 918                                         return;
 919                                 }
 920                         }
 921           }
 922   }
 923
 924
 925   //================================================================
 926
 927   //================================================================
 928   void WxTreeView::SortLevel(int level)
 929   {
 930     GimmickDebugMessage(1,
 931                         "WxTreeView::SortLevel("
 932                         <<level<<")"
 933                         <<std::endl);
 934     //Obtain the column name and the level that needs to be organized
 935
 936     //    int l = level - 1;
 937     //Sets the data for the items to be sorted
 938     //    std::string att;
 939     unsigned int ty=0;
 940     int nbselected = 0;
 941     int n = GetCtrl(level)->GetItemCount();
 942     for (int i = 0; i < n; i++)
 943     {
 944                 //Gets current item data
 945                 ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(i);
 946                 //Extracts the node and the type of attribute
 947                 tree::Node* nod = data->node;
 948                 if(i==0)
 949                   {
 950                         (*nod).GetAttributeDescriptor
 951                           (mLevelList[level].key[mLevelList[level].SortColumn])
 952                           .DecodeType( ty );
 953                   } // if i
 954                 //Obtains the organizing attribute
 955                 data->attr = & (*nod).GetAttribute(mLevelList[level].key[mLevelList[level].SortColumn]);
 956                 //Selected ?
 957                 data->selected = false;
 958                 if (GetCtrl(level)->GetItemState(i,wxLIST_STATE_SELECTED)>0)
 959                 {
 960                         data->selected = true;
 961                         nbselected++;
 962                 } // if
 963     }// for
 964
 965     GimmickDebugMessage(1,
 966                         "WxTreeView::OnSort : "
 967                         <<nbselected<<" selected before sorting"
 968                         <<std::endl);
 969
 970     mIgnoreSelectedChanged = true;
 971     //
 972     if (mLevelList[level].SortAscending)
 973     {
 974                 if(ty==1)
 975                 {
 976                         GetCtrl(level)->SortItems(CompareFunctionInts, 0);
 977                 } else {
 978                         GetCtrl(level)->SortItems(CompareFunctionStrings, 0);
 979                 } // if ty
 980     } else {
 981                 if(ty==1)
 982                 {
 983                         GetCtrl(level)->SortItems(CompareFunctionInts, 1);
 984                 } else {
 985                         GetCtrl(level)->SortItems(CompareFunctionStrings, 1);
 986                 } // if ty
 987     } //mLevelList
 988
 989     // Reselects the unselected
 990     n = GetCtrl(level)->GetItemCount();
 991     int after = 0;
 992     for (int i = 0; i < n; i++)
 993     {
 994                 //Gets current item data
 995                 ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(i);
 996                 //  long item = -1;
 997                 //    for ( ;; )
 998                 //      {
 999                 //      item = GetCtrl(level)->GetNextItem(item,wxLIST_NEXT_ALL);
1000                 //      if ( item == -1 ) break;
1001                 //Gets current item data
1002                 //      ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(item);
1003                 // was selected ?
1004
1005                 if (data->selected)
1006                 {
1007                         nbselected--;
1008                         if (nbselected==0)
1009                         {
1010                                 // if it is the last one we must process the selection
1011                                 mIgnoreSelectedChanged = false;
1012                         }
1013                         GetCtrl(level)->SetItemState(i,
1014                                                  wxLIST_STATE_SELECTED,
1015                                                  wxLIST_MASK_STATE
1016                                                  | wxLIST_MASK_TEXT
1017                                                  | wxLIST_MASK_IMAGE
1018                                                  | wxLIST_MASK_DATA
1019                                                  | wxLIST_MASK_WIDTH
1020                                                  | wxLIST_MASK_FORMAT);
1021                 } // if data
1022                 if (GetCtrl(level)->GetItemState(i,wxLIST_STATE_SELECTED)>0)
1023                 {
1024                         after++;
1025                 }
1026
1027
1028     } // for
1029     mIgnoreSelectedChanged = false;
1030     GimmickDebugMessage(1,
1031                         "WxTreeView::SortLevel : "
1032                         <<after<<" selected after sorting"
1033                         <<std::endl);
1034     }
1035   //================================================================
1036
1037
1038   //================================================================
1039   void WxTreeView::ValidateSelectedImages(bool isSelection)
1040   {
1041     GimmickDebugMessage(7,
1042                         "WxTreeView::ValidateSelectedImages"
1043                         <<std::endl);
1044     const std::vector<tree::Node*>& sel(GetSelected((int)mLevelList.size()+1));
1045     GetGimmickView()->OnSelectionChange(sel,
1046                                         isSelection,(mLastSelected-1),
1047                                         !mIgnoreSelectedChanged);
1048
1049   }
1050   //================================================================
1051
1052
1053   //================================================================
1054   void WxTreeView::GetNodes(std::vector<tree::Node*>& nodes, bool direction)
1055   {
1056         long item = mLastSelected;
1057         int level=(int)mLevelList.size()-1;
1058         //Gets current item data
1059         long adr = (long)GetCtrl(level)->GetItemData(item);
1060         //Extracts the node
1061         tree::Node* nod = ((ItemData*)adr)->node;
1062     for ( ;; )
1063     {
1064                 if(direction)
1065                 {
1066                         item = GetCtrl(level)->GetNextItem(item,
1067                                      wxLIST_NEXT_ABOVE);
1068                 }
1069                 else
1070                 {
1071                         item = GetCtrl(level)->GetNextItem(item,
1072                                      wxLIST_NEXT_BELOW);
1073                 }
1074         if ( item == -1 || item==0  )
1075                 {
1076             break;
1077                 }
1078                 if(GetCtrl(level)->GetItemState(item, wxLIST_STATE_SELECTED)==0 )
1079                 {
1080
1081                         adr = (long)GetCtrl(level)->GetItemData(item);
1082                         nod = ((ItemData*)adr)->node;
1083                         nodes.push_back(nod);
1084                 }
1085     }
1086
1087   }
1088   //================================================================
1089    //=================================================
1090   void WxTreeView::OnKeyDown(wxListEvent &event)
1091   {
1092           if(event.GetKeyCode() == WXK_DELETE)
1093           {
1094                    wxBusyCursor busy;
1095                    std::string temp = "0";
1096                    RemoveSelected(temp);
1097                    GetGimmickView()->ClearSelection();
1098           }
1099
1100   }
1101   //================================================================
1102
1103   //================================================================
1104   // Should be in another place : not specific !
1105   void WxTreeView::GetSelectedAsString(std::vector<std::string>&s)
1106   {
1107     int level= (int)mLevelList.size();
1108     const std::vector<tree::Node*>& sel=GetSelected(level+1);
1109     std::vector<tree::Node*>::const_iterator i;
1110
1111     for (i=sel.begin(); i!=sel.end(); ++i)
1112       {
1113         std::string filename=(*i)->GetAttribute("FullFileName");
1114         s.push_back(filename);
1115       }
1116   }
1117
1118
1119
1120   //================================================================
1121   void WxTreeView::GetFilenamesAsString(const std::vector<tree::Node*>& nodes, std::vector<std::string>&s)
1122   {
1123     std::vector<tree::Node*>::const_iterator i;
1124
1125     for (i=nodes.begin(); i!=nodes.end(); ++i)
1126       {
1127                   if((*i)->GetLevel()<mLevelList.size())
1128                   {
1129                          GetTreeHandler()->LoadChildren(*i,0);
1130                          GetFilenamesAsString((*i)->GetChildrenList(),s);
1131                   }
1132                   else
1133                   {
1134                         std::string filename=(*i)->GetAttribute("FullFileName");
1135                         s.push_back(filename);
1136                   }
1137       }
1138   }
1139
1140    //================================================================
1141
1142    //================================================================
1143   void WxTreeView::GetAttributes(std::vector<std::string>& areShown, std::vector<std::string>& notShown, int level)
1144   {
1145           areShown.clear();
1146           notShown.clear();
1147         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
1148         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(level).begin();
1149              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(level).end();
1150              ++a)
1151         {
1152                 if(a->GetFlags()==creaImageIO::tree::AttributeDescriptor::EDITABLE && IsAttributeVisible(a->GetName(),level))
1153             {
1154                         areShown.push_back(a->GetName());
1155                 }
1156         }
1157         notShown=mLevelList[level-1].notShownAtts;
1158   }
1159
1160   //================================================================
1161   void WxTreeView::SetNonVisibleAttributes(const std::vector<std::string>& notShown, int nlevel)
1162   {
1163         mLevelList[nlevel].notShownAtts=notShown;
1164   }
1165
1166   //================================================================
1167    void WxTreeView::CreateCtrl(std::vector<std::string>& notShown, int nlevel)
1168   {
1169         int ctrl_style = wxLC_REPORT | wxLC_VRULES;
1170     int col_style = wxLIST_FORMAT_LEFT;
1171         LevelType level;
1172         mLevelList[nlevel].SelectedUpToDate = true;
1173         mLevelList[nlevel].SortColumn = 0;
1174         mLevelList[nlevel].key.clear();
1175
1176         mLevelList[nlevel].wxCtrl = new wxListCtrl(mLevelList[nlevel].wxSplitter,
1177                                           nlevel,
1178                                           wxDefaultPosition,
1179                                           wxDefaultSize,
1180                                           ctrl_style);
1181         wxWindow* oldWin=mLevelList[nlevel].wxSplitter->GetWindow1();
1182         mLevelList[nlevel].wxSplitter->ReplaceWindow(oldWin,mLevelList[nlevel].wxCtrl);
1183         mLevelList[nlevel].wxSplitter->Initialize(mLevelList[nlevel].wxCtrl);
1184
1185         // Create the columns : one for each attribute of the level
1186         int col = 0;
1187         std::string title;
1188
1189         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
1190         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(nlevel+1).begin();
1191              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(nlevel+1).end();
1192              ++a)
1193
1194         {
1195             if(a->GetFlags()!=creaImageIO::tree::AttributeDescriptor::PRIVATE && IsAttributeVisible(a->GetName(),nlevel+1))
1196               {
1197                   title=a->GetName();
1198                   std::string temp = a->GetKey();
1199                   if (temp.compare("ID") != 0)
1200                   {
1201                         mLevelList[nlevel].wxCtrl->InsertColumn(col,
1202                                         crea::std2wx(title),
1203                                         col_style);
1204                         col++;
1205                   }
1206                 mLevelList[nlevel].key.push_back(a->GetKey());
1207               }
1208
1209           }
1210         oldWin->Destroy();
1211         UpdateLevel(1);
1212         }
1213
1214    //================================================================
1215   bool WxTreeView::IsAttributeVisible(const std::string& val, int level)
1216   {
1217           std::vector<std::string> ns=mLevelList[level-1].notShownAtts;
1218           std::vector<std::string>::iterator it;
1219           bool found=false;
1220           for(it=ns.begin();it!=ns.end()&&!found;++it)
1221           {
1222                   if(val.compare(*it)==0)
1223                   {
1224                           found=true;
1225                   }
1226           }
1227           return !found;
1228   }
1229  //================================================================
1230   //================================================================
1231
1232         RemoveAlertDlg::RemoveAlertDlg(wxWindow *parent,
1233                                        wxString title,
1234                                        const wxSize& size)
1235  :   wxDialog( parent,
1236                   wxID_ANY,
1237                   title,
1238                   wxDefaultPosition,
1239                   size,
1240                   wxDEFAULT_DIALOG_STYLE)
1241         {
1242             wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
1243
1244                 //std::string out("To reload deleted patient, you should synchronize your database before.");  // JPR
1245                 //wxTextCtrl *text = new wxTextCtrl(this, wxID_ANY,crea::std2wx(out),wxDefaultPosition, wxSize(500,20));
1246                 wxTextCtrl *text = new wxTextCtrl(this, wxID_ANY,
1247                                         _T("To reload deleted patient, you should synchronize your database before."),
1248                                         wxDefaultPosition, wxSize(650,20));  // 650 vs 500 ? // JPRx
1249                 mcheck = new wxCheckBox(this, 5478, _T("Do not display this warning again!"));
1250                 Connect( mcheck->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &RemoveAlertDlg::onCheck );
1251                 wxSizer* buttonsSizer = this->CreateSeparatedButtonSizer(wxOK|wxCANCEL);
1252
1253                 topsizer->Add(text);
1254                 topsizer->Add(mcheck,0,wxGROW);
1255                 topsizer->Add(buttonsSizer,0,wxGROW);
1256                 SetSizer(topsizer, true);
1257                 mSave = false;
1258                 Layout();
1259         }
1260         RemoveAlertDlg::~RemoveAlertDlg(){};
1261         bool RemoveAlertDlg::isChecked()
1262         {
1263                 return mSave;
1264         }
1265         void RemoveAlertDlg::onCheck(wxCommandEvent &Event)
1266         {
1267                 mSave = mcheck->IsChecked();
1268         }
1269
1270
1271   //================================================================
1272   //================================================================
1273   BEGIN_EVENT_TABLE(WxTreeView, wxPanel)
1274   /*
1275     EVT_SIZE(MyFrame::OnSize)
1276
1277     EVT_MENU(LIST_QUIT, MyFrame::OnQuit)
1278     EVT_MENU(LIST_ABOUT, MyFrame::OnAbout)
1279     EVT_MENU(LIST_LIST_VIEW, MyFrame::OnListView)
1280     EVT_MENU(LIST_REPORT_VIEW, MyFrame::OnReportView)
1281     EVT_MENU(LIST_ICON_VIEW, MyFrame::OnIconView)
1282     EVT_MENU(LIST_ICON_TEXT_VIEW, MyFrame::OnIconTextView)
1283     EVT_MENU(LIST_SMALL_ICON_VIEW, MyFrame::OnSmallIconView)
1284     EVT_MENU(LIST_SMALL_ICON_TEXT_VIEW, MyFrame::OnSmallIconTextView)
1285     EVT_MENU(LIST_VIRTUAL_VIEW, MyFrame::OnVirtualView)
1286     EVT_MENU(LIST_SMALL_VIRTUAL_VIEW, MyFrame::OnSmallVirtualView)
1287
1288     EVT_MENU(LIST_FOCUS_LAST, MyFrame::OnFocusLast)
1289     EVT_MENU(LIST_TOGGLE_FIRST, MyFrame::OnToggleFirstSel)
1290     EVT_MENU(LIST_DESELECT_ALL, MyFrame::OnDeselectAll)
1291     EVT_MENU(LIST_SELECT_ALL, MyFrame::OnSelectAll)
1292     EVT_MENU(LIST_DELETE, MyFrame::OnDelete)
1293     EVT_MENU(LIST_ADD, MyFrame::OnAdd)
1294     EVT_MENU(LIST_EDIT, MyFrame::OnEdit)
1295     EVT_MENU(LIST_DELETE_ALL, MyFrame::OnDeleteAll)
1296     EVT_MENU(LIST_SORT, MyFrame::OnSort)
1297     EVT_MENU(LIST_SET_FG_COL, MyFrame::OnSetFgColour)
1298     EVT_MENU(LIST_SET_BG_COL, MyFrame::OnSetBgColour)
1299     EVT_MENU(LIST_TOGGLE_MULTI_SEL, MyFrame::OnToggleMultiSel)
1300     EVT_MENU(LIST_SHOW_COL_INFO, MyFrame::OnShowColInfo)
1301     EVT_MENU(LIST_SHOW_SEL_INFO, MyFrame::OnShowSelInfo)
1302     EVT_MENU(LIST_FREEZE, MyFrame::OnFreeze)
1303     EVT_MENU(LIST_THAW, MyFrame::OnThaw)
1304     EVT_MENU(LIST_TOGGLE_LINES, MyFrame::OnToggleLines)
1305     EVT_MENU(LIST_MAC_USE_GENERIC, MyFrame::OnToggleMacUseGeneric)
1306
1307     EVT_UPDATE_UI(LIST_SHOW_COL_INFO, MyFrame::OnUpdateShowColInfo)
1308     EVT_UPDATE_UI(LIST_TOGGLE_MULTI_SEL, MyFrame::OnUpdateToggleMultiSel)
1309 END_EVENT_TABLE()
1310
1311 BEGIN_EVENT_TABLE(MyListCtrl, wxListCtrl)
1312     EVT_LIST_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnBeginDrag)
1313     EVT_LIST_BEGIN_RDRAG(LIST_CTRL, MyListCtrl::OnBeginRDrag)
1314
1315     EVT_LIST_BEGIN_LABEL_EDIT(-1, WxTreeView::OnBeginLabelEdit)
1316     EVT_LIST_END_LABEL_EDIT(-1, WxTreeView::OnEndLabelEdit)
1317
1318     EVT_LIST_DELETE_ITEM(LIST_CTRL, MyListCtrl::OnDeleteItem)
1319     EVT_LIST_DELETE_ALL_ITEMS(LIST_CTRL, MyListCtrl::OnDeleteAllItems)
1320 #if WXWIN_COMPATIBILITY_2_4
1321     EVT_LIST_GET_INFO(LIST_CTRL, MyListCtrl::OnGetInfo)
1322     EVT_LIST_SET_INFO(LIST_CTRL, MyListCtrl::OnSetInfo)
1323 #endif
1324   */
1325     EVT_LIST_KEY_DOWN(-1, WxTreeView::OnKeyDown)
1326     EVT_LIST_ITEM_SELECTED(-1, WxTreeView::OnItemSelected)
1327         EVT_LIST_ITEM_RIGHT_CLICK(-1, WxTreeView::OnItemMenu)
1328     EVT_LIST_ITEM_DESELECTED(-1, WxTreeView::OnItemDeSelected)
1329         /*
1330     EVT_LIST_KEY_DOWN(LIST_CTRL, MyListCtrl::OnListKeyDown)
1331     EVT_LIST_ITEM_ACTIVATED(LIST_CTRL, MyListCtrl::OnActivated)
1332     EVT_LIST_ITEM_FOCUSED(LIST_CTRL, MyListCtrl::OnFocused)
1333 */
1334     EVT_LIST_COL_RIGHT_CLICK(-1, WxTreeView::OnColClick)
1335
1336     EVT_LIST_COL_CLICK(-1, WxTreeView::OnColClick)
1337
1338         //EVT_LEFT_DOWN(WxTreeView::OnMouseClick)
1339         /*
1340     EVT_LIST_COL_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnColBeginDrag)
1341     EVT_LIST_COL_DRAGGING(LIST_CTRL, MyListCtrl::OnColDragging)
1342     EVT_LIST_COL_END_DRAG(LIST_CTRL, MyListCtrl::OnColEndDrag)
1343
1344     EVT_LIST_CACHE_HINT(LIST_CTRL, MyListCtrl::OnCacheHint)
1345
1346 #if USE_CONTEXT_MENU
1347     EVT_CONTEXT_MENU(MyListCtrl::OnContextMenu)
1348 #endif
1349     EVT_CHAR(MyListCtrl::OnChar)
1350
1351     EVT_RIGHT_DOWN(MyListCtrl::OnRightClick)
1352   */
1353 END_EVENT_TABLE()
1354
1355 } // EO namespace creaImageIO
1356