creaImageIOWxTreeView.cpp

Go to the documentation of this file.
00001 #include <creaImageIOWxTreeView.h>
00002 #include <creaImageIOGimmickView.h>
00003 #include <creaImageIOSystem.h>
00004 #include <wx/splitter.h>
00005 #include <wx/gdicmn.h>
00006 #include <boost/date_time/gregorian/gregorian.hpp>
00007 #include <creaImageIOGimmick.h>
00008 #ifdef _DEBUG
00009 #define new DEBUG_NEW
00010 #endif
00011 //=====================================================================
00012 namespace creaImageIO
00013 {
00014 
00015   //=====================================================================
00016 }
00017 //=====================================================================
00018 
00019 //=====================================================================
00021 int wxCALLBACK CompareFunctionStrings(long item1, long item2, long sortData)
00022 {       
00023   creaImageIO::ItemData* data1 = (creaImageIO::ItemData*)item1;
00024   creaImageIO::ItemData* data2 = (creaImageIO::ItemData*)item2;
00025 
00026   const std::string& s1(*(data1->attr));
00027   const std::string& s2(*(data2->attr));
00028   if(sortData==1)
00029     {
00030       // inverse the order
00031       if (s1 < s2)
00032         return 1;
00033       if (s1 > s2)
00034         return -1;
00035       
00036       return 0;
00037     }
00038   else
00039     {
00040       if (s1 < s2)
00041         return -1;
00042       if (s1 > s2)
00043         return 1;
00044       
00045       return 0;
00046       
00047     }
00048 }
00049 //=====================================================================
00050 
00051 //=====================================================================
00053 int wxCALLBACK CompareFunctionInts(long item1, long item2, long sortData)
00054 {       
00055   creaImageIO::ItemData* data1 = (creaImageIO::ItemData*)item1;
00056   creaImageIO::ItemData* data2 = (creaImageIO::ItemData*)item2;
00057 
00058   const std::string& s1(*(data1->attr));
00059   const std::string& s2(*(data2->attr));
00060 
00061   int val1=atoi(s1.c_str());
00062   int val2=atoi(s2.c_str());
00063 
00064   if(sortData==1)
00065     {
00066       // inverse the order
00067       if (val1 < val2)
00068         return 1;
00069       if (val1 > val2)
00070         return -1;
00071       
00072       return 0;
00073     }
00074   else
00075     {
00076       if (val1 < val2)
00077         return -1;
00078       if (val1 > val2)
00079         return 1;
00080 
00081       return 0;
00082       
00083     }
00084   
00085 }
00086 
00087 //=====================================================================
00088 
00089 
00090 //=====================================================================
00091 namespace creaImageIO
00092 {
00093   //=====================================================================
00094   // CTor
00095   WxTreeView::WxTreeView(TreeHandler* handler,
00096                          GimmickView* gimmick,
00097                          wxWindow* parent,
00098                          const wxWindowID id)
00099     : wxPanel(parent,id),
00100       TreeView(handler, gimmick)
00101   {
00102     GimmickDebugMessage(1,"WxTreeView::WxTreeView"
00103                         <<std::endl);
00104 
00105     
00106     // Split part below toolbar into notebook for views and panel
00107     // for preview, messages...
00108     // TO DO : Splitter
00109     //    mSplitter = new wxSplitterWindow( this , -1);
00110 
00111     // Global sizer
00112     msizer = new wxBoxSizer(wxHORIZONTAL);
00113     
00114     int ctrl_style = wxLC_REPORT | wxLC_VRULES;
00115     int col_style = wxLIST_FORMAT_LEFT;
00116 
00117     // Creating the ListCtrl for the levels > 0 (not for Root level)
00118     for (int i = 0;
00119          i < handler->GetTree().GetNumberOfLevels() -1;
00120          ++i)
00121       {
00122         GimmickDebugMessage(5,"Creating view for level "<<i
00123                             <<std::endl);
00124         LevelType level;
00125         level.SelectedUpToDate = true;
00126         level.SortColumn = 0;
00127 
00128         // If the first level : parent = this
00129         wxWindow* sparent = this;
00130         // else parent = last splitter
00131         if (i>0) 
00132                 sparent = mLevelList[i-1].wxSplitter;
00133 
00134         level.wxSplitter = new wxSplitterWindow( sparent , -1);
00135         if(i!=0)
00136         {
00137         level.wxSplitter->Show(false);
00138         }
00139         //          level.wxSplitter->SetMinimumPaneSize(100);
00140         
00141         wxListCtrl* ctrl = new wxListCtrl(level.wxSplitter,
00142                                           i,
00143                                           wxDefaultPosition, 
00144                                           wxDefaultSize,
00145                                           ctrl_style);
00146         level.wxCtrl = ctrl;
00147         level.wxSplitter->Initialize(ctrl);
00148    
00149         // Create the columns : one for each attribute of the level
00150         int col = 0;
00151         std::string title;
00152 
00153         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
00154         for (a  = handler->GetTree().GetAttributeDescriptorList(i+1).begin();
00155              a != handler->GetTree().GetAttributeDescriptorList(i+1).end();
00156              ++a)
00157 
00158 {
00159         
00160             GimmickDebugMessage(5,"Creating column "<<col<<" : "
00161                                 <<a->GetName()
00162                                 <<std::endl);
00163             
00164             if(a->GetFlags()!=creaImageIO::tree::AttributeDescriptor::PRIVATE)
00165               {
00166                 
00167                 if(a->GetName()=="UNKNOWN")
00168                   {
00169                     title = "#";
00170                     title += handler->GetTree().GetLevelDescriptor(i+1).GetName();
00171                     if (title[title.size()-1]!='s')
00172                       title += "s";
00173                     
00174                   }
00175                 else
00176                   {
00177                     title=a->GetName();
00178                   }
00179                   std::string temp = a->GetKey();
00180                   if (temp.compare("ID") != 0)
00181                   {
00182                 
00183                 ctrl->InsertColumn(col, 
00184                                    crea::std2wx(title),
00185                                    col_style);
00186                 col++;
00187                   }
00188                 level.key.push_back(a->GetKey());
00189               }
00190                 
00191           }
00192           
00193         mLevelList.push_back(level);
00194       }
00195     
00196 #if wxUSE_MENUS
00197 
00198          // Column Menu
00199     menu =new wxMenu;
00200         wxMenuItem* m1=menu->Append(wxID_ANY, _T("&Sort ascending"));
00201         wxMenuItem* m2=menu->Append(wxID_ANY, _T("&Sort descending"));
00202         wxMenuItem* m3=menu->Append(wxID_ANY, _T("&Filter"));
00203         mAscendingID=m1->GetId();
00204         mDescendingID=m2->GetId();
00205         mFilterID=m3->GetId();
00206         Connect( mAscendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
00207         Connect( mDescendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
00208         Connect( mFilterID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupFilter) );
00209 
00210 
00212         subExportMenu = new wxMenu;
00213         wxMenuItem *subExp1 = subExportMenu->Append(wxID_ANY, _T("&Export to Storage"));
00214         Connect( subExp1->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnExportToStorage) );
00215 
00216         //ItemMenu
00217         menuItem =new wxMenu;
00218 
00219 
00220         wxMenuItem* m2Item=menuItem->Append(wxID_ANY, _T("&Local Copy"));
00221         wxMenuItem* m3Item=menuItem->Append(wxID_ANY, _T("&Edit Fields"));
00222         wxMenuItem* m4Item=menuItem->Append(wxID_ANY, _T("&Display Dicom Tags"));
00223         menuItem->AppendSubMenu(subExportMenu, wxT("&Export"));
00224 
00225 #if defined(USE_GDCM_ANOM)
00226         wxMenuItem* m1Item=menuItem->Append(wxID_ANY, _T("&Anonymize"));
00227         mAnonymizingID=m1Item->GetId();
00228         Connect( mAnonymizingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnAnonymize) );
00229 #endif
00230         mLocalCopyID=m2Item->GetId();
00231         mEditFieldID=m3Item->GetId();
00232         mDumpID=m4Item->GetId();
00233         
00234         
00235         Connect( mLocalCopyID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnLocalCopy) );
00236         Connect( mEditFieldID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnEditField) );
00237         Connect( mDumpID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnDumpTags) );
00238         
00239 
00240         
00241 #endif // wxUSE_MENUS
00242 
00243           
00244         msizer->Add( mLevelList[0].wxSplitter ,1, wxGROW  ,0);
00245         //      mColumnSelected=1;
00246         mLastSelected=0;
00247         mLastLevel=0;
00248         //      mDirection=true;
00249 
00250         mIgnoreSelectedChanged = false;
00251 
00252         //CreateColorPalette();
00253     UpdateLevel(1);
00254 
00255     SetSizer( msizer );     
00256     SetAutoLayout(true);
00257     Layout();
00258 
00259   }
00260   //=====================================================================
00261 
00262   //=====================================================================
00264   WxTreeView::~WxTreeView()
00265   {
00266     GimmickDebugMessage(1,"WxTreeView::~WxTreeView"
00267                         <<std::endl);
00268         delete menu;
00269         delete menuItem;
00270 
00271   }
00272   //=====================================================================
00273   
00274   
00275   
00276   //=====================================================================
00277   const std::vector<tree::Node*>& WxTreeView::GetSelected(int level)
00278   {
00279           std::vector<tree::Node*>& sel = mLevelList[0].Selected;
00280     //  if (GetSelectedUpToDate(level)) 
00281     int l = level - 1;
00282     // the selection of upper level
00283         if(mLevelList.size() == level -1)
00284                  sel = mLevelList.back().Selected;
00285         else
00286                   sel=  mLevelList[l].Selected;
00287         if (sel.size() > 0)
00288         {
00289                 sel.clear();
00290         }
00291           if (level == 1) 
00292       {
00293         sel.push_back(GetTreeHandler()->GetTree().GetTree());
00294       }
00295           else if (level < mLevelList.size()+2 ) 
00296     {
00297                 long item = -1;
00298                 for ( ;; )
00299                 {
00300                         item = GetCtrl(l-1)->GetNextItem(item,
00301                                                                                  wxLIST_NEXT_ALL,
00302                                                                                  wxLIST_STATE_SELECTED);
00303                         if ( item == -1 )
00304                                 break;
00305                         long adr = GetCtrl(l-1)->GetItemData(item);
00306                         tree::Node* n = ((ItemData*)adr)->node;
00307                         /* FCY 18-04-2011: don't understand the real purpose of these lines,
00308                          if uncomment add last frame in first place 
00309                                 if(mLastSelected==item)
00310                         {
00311                                 std::vector<tree::Node*>::iterator it;
00312                                 it = sel.begin();
00313                                 it = sel.insert ( it , n );
00314                         }
00315                         else
00316                         {*/
00317                                 
00318                                 sel.push_back(n);
00319                         //}                     
00320                         
00321                 }
00322                 /*int n = GetCtrl(l-1)->GetItemCount();
00323                 for (int i = 0; i<n; i++)
00324                 {
00325                         std::cout<<GetCtrl(l-1)->GetItemState(i,wxLIST_STATE_SELECTED)<<std::endl;
00326                         if ( GetCtrl(l-1)->GetItemState(i,wxLIST_STATE_SELECTED))
00327                         {
00328                                 long adr = GetCtrl(l-1)->GetItemData(i);
00329                                 tree::Node* n = ((ItemData*)adr)->node;
00330                                 if(mLastSelected==i)
00331                                 {
00332                                         std::vector<tree::Node*>::iterator it;
00333                                         it = sel.begin();
00334                                         it = sel.insert ( it , n );
00335                                 }
00336                                 else
00337                                 {
00338                                         
00339                                         sel.push_back(n);
00340                                 }
00341                         }
00342               }*/
00343           }
00344         else
00345         {
00346                 // NOTHING
00347         }   
00348          
00349     //    return mLevelList[level-1].Selected;
00350     return sel;
00351   }
00352 
00353   //=====================================================================
00354   
00355   //=====================================================================
00357    // NOT SPECIFIC 
00358   void WxTreeView::RemoveSelected(std::string &i_save)
00359   {
00360          bool erase=false;
00361          
00362          unsigned int tempLevel = mLastLevel;
00363     mLastLevel+=1;
00364     const std::vector<tree::Node*>& sel=GetSelected(mLastLevel+1);
00365         // if no selection, no remove action.
00366     if(sel.size() != 0)
00367         {
00368         
00369             std::stringstream out;
00370             std::string levelName=GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName();
00371             out<<"Delete ";
00372             out<<sel.size();
00373             if(sel.size()>1&&levelName.at(levelName.size()-1)!='s')
00374               {
00375                 out<<" "<<levelName;
00376                 out<<"s?";
00377               }
00378             else
00379               {
00380                 out<<" "<<GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName()<<"?";
00381               }
00382             if (wxMessageBox(crea::std2wx(out.str()),
00383                              _T("Remove Files"),
00384                              wxYES_NO,this ) == wxYES)
00385               {
00386                 erase = true;
00387               }
00388             if(erase)
00389                   {
00390             GetGimmickView()->modifyValidationSignal(false);
00391                     bool needRefresh=false;
00392                     std::vector<tree::Node*>::const_iterator i;
00393                     for (i=sel.begin(); i!=sel.end(); ++i)
00394                       {
00395                         GimmickMessage(1,
00396                                        "deleting '"
00397                                        <<(*i)->GetLabel()
00398                                        <<"'"<<mLastLevel
00399                                        <<std::endl);
00400                         if((*i)->GetParent()->GetNumberOfChildren()<2)
00401                           {
00402                             needRefresh=true;
00403                           }
00404                           //tree::Node* n = new (tree::Node*)(*i);
00405                           GetTreeHandler()->LoadChildren((*i),4);
00406                           GetGimmickView()->AddIgnoreFile(*i);
00407                           GetTreeHandler()->Remove(*i);
00408                       }
00409                     
00410                     if(needRefresh && mLastLevel>1)
00411                       {
00412                         UpdateLevel(mLastLevel-2);
00413                       }
00414                     else if(mLastLevel>1)
00415                       {
00416                         UpdateLevel(mLastLevel-1);
00417                       }
00418                     else
00419                       {
00420                         UpdateLevel(mLastLevel);
00421                       }
00422                   }
00423         }
00424         else
00425         {
00426                 // no need to incremente level
00427                 mLastLevel = tempLevel;
00428         }
00429     
00430         if (erase && mLastLevel == 1 && i_save == "0")
00431         {
00432         
00433                 RemoveAlertDlg *dial = new RemoveAlertDlg(this,  crea::std2wx("Remove files"), wxSize(370,100));
00434                 //dial->ShowModal();
00435                 if (dial->ShowModal() == wxID_OK)
00436                 {
00437                         i_save = dial->isChecked() == false? "0" : "1";
00438                 }
00439                 
00440         }
00441   }
00442   
00443   
00444   //=====================================================================
00446   void WxTreeView::UpdateLevel( int level )
00447   {
00448     GimmickDebugMessage(1,
00449                         GetTreeHandler()->GetTree().GetLabel()
00450                         <<"WxTreeView::UpdateLevel(level "
00451                         <<level
00452                         <<")"
00453                         <<std::endl);
00454     
00455     wxBusyCursor busy;
00456     RecursiveUpdateLevel(level);
00457     int i;
00458     for (i=0; i<level-1; i++)
00459       {
00460         if (!GetSplitter(i)->IsSplit()) 
00461           GetSplitter(i)->SplitVertically(  GetCtrl(i), GetSplitter(i+1),
00462                                             100 );
00463       }
00464     if (GetSplitter(i)->IsSplit()) GetSplitter(i)->Unsplit();    
00465     
00466   }
00467   //=====================================================================
00468   
00469   //=====================================================================
00471   void WxTreeView::RecursiveUpdateLevel( int level )
00472   {
00473     GimmickDebugMessage(1,
00474                         GetTreeHandler()->GetTree().GetLabel()
00475                         <<"WxTreeView::RecursiveUpdateLevel(level "
00476                         <<level
00477                         <<")"<<std::endl);
00478     
00479     
00480     const std::vector<tree::Node*>& sel(GetSelected(level));
00481     
00482     int l = level - 1;
00483     
00484     // to speed up inserting we hide the control temporarily
00485     GetCtrl(l)->Hide();
00486     GetCtrl(l)->DeleteAllItems();
00487     
00488     std::vector<tree::Node*>::const_iterator i;
00489     
00490     for (i=sel.begin(); i!=sel.end(); ++i)
00491       {
00492         GimmickDebugMessage(1,
00493                             "adding children of '"
00494                             <<(*i)->GetLabel()
00495                             <<"'"
00496                             <<std::endl);
00497         int _id=0;
00498         
00499         //Adds items and sets their attributes 
00500         
00501         GetTreeHandler()->LoadChildren(*i,1);
00502         tree::Node::ChildrenListType::reverse_iterator j;
00503         for (j = (*i)->GetChildrenList().rbegin(); 
00504              j!= (*i)->GetChildrenList().rend(); 
00505              ++j)
00506           {
00507             GimmickDebugMessage(1,
00508                                 "adding children "
00509                                 <<(*j)->GetLabel()
00510                                 <<"'"
00511                                 <<std::endl);
00512             
00513             wxListItem item;
00514             item.SetMask(wxLIST_MASK_STATE | 
00515                          wxLIST_MASK_TEXT |
00516                          //                      wxLIST_MASK_IMAGE |
00517                          wxLIST_MASK_DATA |
00518                          //                      wxLIST_MASK_WIDTH |
00519                          wxLIST_MASK_FORMAT
00520                          );
00521             
00522                 ItemData* data = new ItemData();
00523             data->node = *j;
00524             data->id = _id;
00525                 
00526             item.SetId(_id);
00527             item.SetData(data);
00528 
00529             _id++;
00530             GetCtrl(l)->InsertItem(item);
00531             
00532             //Setting attributes
00533             for (int k=0; k<GetCtrl(l)->GetColumnCount(); ++k)                          
00534               {
00535                 std::string val;
00536                 //  Temporary correction : it works but no explanation about the problem FCY
00537                 
00538                 if(k==0 && level <3)
00539                 {
00540                   val = (*j)->GetAttribute("NumberOfChildren");
00541                 }
00542                 else
00543                   val = (*j)->GetAttribute(mLevelList[l].key[k]);
00544                 if(((*j)->GetAttributeDescriptor(mLevelList[l].key[k])).isDateEntry()) // Date
00545                   {
00546                     //                                    std::cout << "["<<val<< "]" << std::endl;
00547                     std::string valtmp(val);
00548                     try
00549                       {
00550                         boost::gregorian::date d1(boost::gregorian::from_undelimited_string(val));                                 
00551                         val = to_iso_extended_string(d1);
00552                       }
00553                     catch (...)
00554                       {
00555                         val =  valtmp;
00556                       }
00557                     //                                    std::cout << "["<<val<< "]" << std::endl;     
00558                   }
00559                 else if(((*j)->GetAttributeDescriptor(mLevelList[l].key[k])).isTimeEntry()) // Time
00560                   {
00561                     if ((val.size()>6) && 
00562                         (val != "" || val != " "))
00563                       val = val.substr(0,2) + " : " 
00564                         + val.substr(2,2) + " : " 
00565                         + val.substr(4,2);
00566                   }
00567                 else
00568                   {
00569                     if (val.size()==0) val = "?";
00570                   }
00571                 if (val.size()==0) val = "X";
00572                 item.SetText( crea::std2wx(val));
00573                 item.SetColumn(k);
00574                   
00575                   GetCtrl(l)->SetItem(item);
00576                   }
00577                 item.Clear();
00578             
00579           }
00580       }
00581     
00582     SortLevel(l);
00583     GetCtrl(l)->Show();
00584   }
00585   //=====================================================================
00586   
00587   
00588   //================================================================
00589   void WxTreeView::OnItemDeSelected(wxListEvent& event)
00590   { 
00591     GimmickDebugMessage(1,
00592                         GetTreeHandler()->GetTree().GetLabel()
00593                         <<" WxTreeView::OnItemDeselected"<<std::endl);
00594     // retrieve the level
00595     wxObject* obj = event.GetEventObject();   
00596     unsigned int level = 0;
00597     for (level = 0; level<mLevelList.size(); ++level)
00598       {
00599         if ( GetCtrl(level) == obj ) break;
00600       } 
00601     SetSelectedUpToDate(level,false);
00602     // to allow a first selection in images TreeView
00603     if (level==mLevelList.size()-1) 
00604       OnItemSelected(event);
00605   }
00606   //================================================================
00607   
00608   //================================================================
00609   void WxTreeView::OnItemSelected(wxListEvent& event)
00610   { 
00611           
00612     GimmickDebugMessage(1,
00613                         GetTreeHandler()->GetTree().GetLabel()
00614                         <<" WxTreeView::OnItemSelected"<<std::endl);
00615 
00616     if (mIgnoreSelectedChanged) 
00617       {
00618         GimmickDebugMessage(1,
00619                             " mIgnoreSelectedChanged true: returning"
00620                             <<std::endl);
00621         return;
00622       }
00623     
00624 
00625     
00626     wxListItem info;
00627     info.m_itemId = event.m_itemIndex;
00628     mLastSelected = event.m_itemIndex;
00629     // retrieve the level
00630     wxObject* obj = event.GetEventObject();   
00631     unsigned int level = 0;
00632     for (level = 0; level<mLevelList.size(); ++level)
00633       {
00634         if ( GetCtrl(level) == obj ) break;
00635       }
00636         mLastLevel=level;
00637     GimmickDebugMessage(1,
00638                         " Level "<<level+1
00639                         <<std::endl);
00640     
00641     // Update the children level (if selection not at last level)
00642     if (level<mLevelList.size()-1) 
00643       {
00644                 
00645         UpdateLevel( level + 2 ); 
00646         // Reset the viewer setting the default image
00647         GetGimmickView()->ClearSelection();
00648       }
00649     // Select all images if the selection is at series level
00650     if (level==mLevelList.size()-2) 
00651                 SelectAll(level+1);
00652     // Validate selected images if the selection is at image level
00653     if (level==(mLevelList.size()-1)) //&&mProcess) 
00654       {
00655         if(event.GetEventType()==wxEVT_COMMAND_LIST_ITEM_SELECTED)
00656           {
00657                   ValidateSelectedImages (true);
00658           }
00659         else
00660           {
00661                   ValidateSelectedImages (false);
00662           }
00663       }
00664     
00665   }
00666   //================================================================
00667 
00668   //================================================================
00669   void WxTreeView::SelectAll(int level)
00670   {
00671     long item = -1;
00672     //    int level=mLevelList.size()-1;
00673     for ( ;; )
00674       {
00675         item = GetCtrl(level)->GetNextItem(item,
00676                                            wxLIST_NEXT_ALL);
00677         if ( item == -1 )
00678           break;
00679         
00680         if(item==(GetCtrl(level)->GetItemCount()-1))
00681           {
00682             mIgnoreSelectedChanged = false;//mProcess=true;
00683           }
00684         else
00685           {
00686             mIgnoreSelectedChanged = true;//    mProcess=false;
00687           }
00688         GetCtrl(level)->SetItemState(item,wxLIST_STATE_SELECTED, wxLIST_MASK_STATE 
00689                                      | wxLIST_MASK_TEXT |wxLIST_MASK_IMAGE | wxLIST_MASK_DATA | wxLIST_MASK_WIDTH | wxLIST_MASK_FORMAT);
00690       }
00691   }
00692 
00693   //================================================================
00694   //================================================================
00695 
00696   void WxTreeView::OnColClick(wxListEvent& event)
00697   { 
00698     mColumnSelected = event.m_col;
00699     wxPoint clientpt;
00700     clientpt.x = wxGetMousePosition().x - this->GetScreenPosition().x;
00701     clientpt.y = wxGetMousePosition().y - this->GetScreenPosition().y;
00702     senderCtrl = event.GetEventObject(); 
00703     unsigned int level = 0;
00704     for (level = 0; level<mLevelList.size(); ++level)
00705       {
00706         if ( GetCtrl(level) == senderCtrl ) break;
00707       }
00708     PopupMenu(menu, clientpt);
00709     
00710   }
00711 
00712    //================================================================
00713   //================================================================
00714 
00715   void WxTreeView::OnItemMenu(wxListEvent &event)
00716   {
00717          wxPoint clientpt;
00718     clientpt.x = wxGetMousePosition().x - this->GetScreenPosition().x;
00719     clientpt.y = wxGetMousePosition().y - this->GetScreenPosition().y;
00720     senderCtrl = event.GetEventObject();
00721     unsigned int level = 0;
00722     for (level = 0; level<mLevelList.size(); ++level)
00723       {
00724                 if ( GetCtrl(level) == senderCtrl ) break;
00725       }
00726           long* ptr=0;
00727           int flag;
00728           mLastRightLevel=level;
00729           mLastRightSelected=GetCtrl(level)->HitTest(wxPoint(0,clientpt.y-8),flag,ptr);
00730     PopupMenu(menuItem, clientpt);
00731     
00732   }
00733   
00734   //================================================================
00735   //================================================================
00736 
00737   void WxTreeView::OnPopupFilter(wxCommandEvent& event)
00738   {
00739     wxBusyCursor busy;
00740     GimmickDebugMessage(7,
00741                         "WxTreeView::OnEndLabelEdit" 
00742                         <<std::endl);
00743     unsigned int level = 0;
00744     for (level = 0; level<mLevelList.size(); ++level)
00745       {
00746         if ( GetCtrl(level) == senderCtrl ) break;
00747       }
00748     std::string filter = crea::wx2std(wxGetTextFromUser(_T("Enter the filter to apply"), _T("Filter On Column")));
00749     
00750     std::string att;
00751     
00752     long it = -1;
00753     UpdateLevel(level+1);
00754     
00755     std::vector<long> items;
00756     bool in=false;
00757     int del=0;
00758     for ( ;; )
00759       {
00760         it = GetCtrl(level)->GetNextItem(it,
00761                                          wxLIST_NEXT_ALL);
00762         if ( it == -1 )
00763           break;
00764         
00765         long adr = GetCtrl(level)->GetItemData(it);
00766         tree::Node* nod = ((ItemData*)adr)->node;
00767         att=(*nod).GetAttribute(mLevelList[level].key[mColumnSelected]);
00768         
00769         
00770         if(att.find(filter)>900)
00771           {
00772             
00773             if(!in)
00774               {
00775                 in=true;
00776               }
00777             else
00778               {
00779                 del+=1;
00780               }
00781             
00782             items.push_back(it-del);
00783           }
00784         
00785       }
00786     std::vector<long>::iterator iter;
00787     for(iter=items.begin();iter!=items.end();++iter)
00788       {
00789         GetCtrl(level)->DeleteItem(*iter);
00790       }
00791     GetGimmickView()->ClearSelection();
00792   }
00793   //================================================================
00794   
00795   //================================================================
00796   void WxTreeView::OnPopupSort(wxCommandEvent& event)
00797   {
00798     wxBusyCursor busy;
00799     unsigned int level = 0;
00800     for (level = 0; level<mLevelList.size(); ++level)
00801       {
00802         if ( GetCtrl(level) == senderCtrl ) break;
00803       }
00804     mLevelList[level].SortColumn = mColumnSelected;
00805 
00806     if(event.GetId()==mAscendingID)
00807       {
00808         mLevelList[level].SortAscending = true;
00809       }
00810     else if(event.GetId()==mDescendingID)
00811       {
00812         mLevelList[level].SortAscending = false;
00813       }
00814           
00815     SortLevel(level);
00816   }
00817   //================================================================
00818 
00819   void WxTreeView::OnAnonymizer(wxCommandEvent &event)
00820   {
00821            wxBusyCursor busy;
00822            std::vector<std::string> filesname;
00823            std::vector<tree::Node*> nodes;
00824 //         nodes.push_back(((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node);
00825            if(nodes.size() != 0)
00826            {
00827                    GetFilenamesAsString(nodes,filesname);
00828                 //   GetGimmickView()->Anonymize(filesname,0);
00829            }
00830         
00831   }
00832 
00833   //================================================================
00834   void WxTreeView::OnLocalCopy(wxCommandEvent& event)
00835   {
00836     wxBusyCursor busy;
00837     
00838         unsigned int tempLevel = mLastLevel;
00839     mLastLevel+=1;
00840     const std::vector<tree::Node*>& sel=GetSelected(mLastLevel+1);
00841         
00842     if(sel.size() != 0)
00843         {
00844             bool copy=false;
00845             std::stringstream out;
00846             std::string levelName=GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName();
00847             out<<"Copy ";
00848             out<<sel.size();
00849             if(sel.size()>1&&levelName.at(levelName.size()-1)!='s')
00850               {
00851                 out<<" "<<levelName;
00852                 out<<"s to .creaImageIO?";
00853               }
00854             else
00855               {
00856                 out<<" "<<GetTreeHandler()->GetTree().GetLevelDescriptor(mLastLevel).GetName()<<" to .creaImageIO?";
00857               }
00858             if (wxMessageBox(crea::std2wx(out.str()),
00859                              _T("Remove Files"),
00860                              wxYES_NO,this ) == wxYES)
00861               {
00862                 copy = true;
00863               }
00864             if(copy)
00865                   {
00866                         std::vector<std::string> s;
00867                         GetFilenamesAsString(sel,s);
00868             GetGimmickView()->CopyFiles(s);
00869                   }
00870         }
00871         else
00872         {
00873                 mLastLevel = tempLevel;
00874         }
00875     
00876     
00877   }
00878   //================================================================
00879 
00880    //================================================================
00881   void WxTreeView::OnEditField(wxCommandEvent& event)
00882   {
00883         if(mLastRightSelected!=-1)
00884         {
00885     tree::Node* node=((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node;
00886         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
00887         std::vector<std::string> names;
00888         std::vector<std::string> keys;
00889         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).begin();
00890              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).end();
00891              ++a)
00892         {
00893                 if(a->GetFlags()==creaImageIO::tree::AttributeDescriptor::EDITABLE)
00894             {
00895                         names.push_back(a->GetName());
00896                         keys.push_back(a->GetKey());
00897                 }
00898         }
00899         GetGimmickView()->CreateEditFieldsDialog(node,names,keys);
00900         }
00901   }
00902 
00903   //================================================================
00904 
00905   //================================================================
00906 
00907   void WxTreeView::OnExportToStorage(wxCommandEvent &event)
00908   {
00909         std::vector<std::string> filesname;
00910         std::vector<tree::Node*> nodes;
00911         nodes.push_back(((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node);
00912         GetFilenamesAsString(nodes,filesname);
00913         GetGimmickView()->ExportToStorage(filesname);
00914   }
00915 
00916   //================================================================
00917 
00918   //================================================================
00919 
00920   void WxTreeView::OnDumpTags(wxCommandEvent &event)
00921   {
00922           if(mLastRightSelected!=-1)
00923         {
00924                 tree::Node* node=((ItemData*)GetCtrl(mLastRightLevel)->GetItemData(mLastRightSelected))->node;
00925                 tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
00926                 std::vector<std::string> names;
00927                 std::vector<std::string> keys;
00928                 for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).begin();
00929                          a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(mLastRightLevel+1).end();
00930                          ++a)
00931                         {
00932                                 if(a->GetKey()=="FullFileName")
00933                                 {
00934                                         GetGimmickView()->DumpTags(node->GetAttribute("FullFileName"));
00935                                         return;
00936                                 }
00937                         }
00938           }
00939   }
00940   
00941 
00942   //================================================================
00943 
00944   //================================================================
00945   void WxTreeView::SortLevel(int level)
00946   {       
00947     GimmickDebugMessage(1,
00948                         "WxTreeView::SortLevel(" 
00949                         <<level<<")"
00950                         <<std::endl);  
00951     //Obtain the column name and the level that needs to be organized
00952     
00953     //    int l = level - 1;
00954     //Sets the data for the items to be sorted
00955     //    std::string att;
00956     unsigned int ty=0;
00957     int nbselected = 0;
00958     int n = GetCtrl(level)->GetItemCount();
00959     for (int i = 0; i < n; i++)
00960       {
00961         
00962         //Gets current item data
00963         ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(i);
00964         
00965         //Extracts the node and the type of attribute   
00966         tree::Node* nod = data->node;
00967         if(i==0)
00968           {
00969             (*nod).GetAttributeDescriptor
00970               (mLevelList[level].key[mLevelList[level].SortColumn])
00971               .DecodeType( ty );
00972           }
00973         //Obtains the organizing attribute
00974         data->attr = & (*nod).GetAttribute
00975           (mLevelList[level].key[mLevelList[level].SortColumn]);
00976         //Selected ?
00977         data->selected = false;
00978         if (GetCtrl(level)->GetItemState(i,wxLIST_STATE_SELECTED)>0)
00979           {
00980             data->selected = true;
00981             nbselected++;
00982           }
00983 
00984       } 
00985     GimmickDebugMessage(1,
00986                         "WxTreeView::OnSort : " 
00987                         <<nbselected<<" selected before sorting"
00988                         <<std::endl);  
00989 
00990     mIgnoreSelectedChanged = true; 
00991     // 
00992     if (mLevelList[level].SortAscending)
00993       {
00994         
00995         if(ty==1)
00996           {
00997             GetCtrl(level)->SortItems(CompareFunctionInts, 0);
00998           }
00999         else
01000           {
01001             GetCtrl(level)->SortItems(CompareFunctionStrings, 0);
01002           }
01003         
01004       }
01005     else
01006       {
01007         if(ty==1)
01008           {
01009             GetCtrl(level)->SortItems(CompareFunctionInts, 1);
01010           }
01011         else
01012           {
01013             GetCtrl(level)->SortItems(CompareFunctionStrings, 1);
01014           }
01015       }
01016  
01017 
01018     // Reselects the unselected 
01019     n = GetCtrl(level)->GetItemCount();
01020     int after = 0;
01021     for (int i = 0; i < n; i++)
01022       {
01023         
01024         //Gets current item data
01025         ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(i);
01026   
01027         //  long item = -1;
01028         //    for ( ;; )
01029         //      {
01030         //      item = GetCtrl(level)->GetNextItem(item,wxLIST_NEXT_ALL);
01031         //      if ( item == -1 ) break;
01032         //Gets current item data
01033         //      ItemData* data = (ItemData*)GetCtrl(level)->GetItemData(item);
01034         // was selected ?
01035         
01036         if (data->selected)
01037           {
01038             nbselected--;
01039             if (nbselected==0)
01040               {
01041                 // if it is the last one we must process the selection
01042                 mIgnoreSelectedChanged = false;
01043               }
01044             GetCtrl(level)->SetItemState(i,
01045                                          wxLIST_STATE_SELECTED, 
01046                                          wxLIST_MASK_STATE 
01047                                          | wxLIST_MASK_TEXT 
01048                                          | wxLIST_MASK_IMAGE 
01049                                          | wxLIST_MASK_DATA 
01050                                          | wxLIST_MASK_WIDTH 
01051                                          | wxLIST_MASK_FORMAT);   
01052           }
01053         if (GetCtrl(level)->GetItemState(i,wxLIST_STATE_SELECTED)>0)
01054           {
01055             after++;
01056           }
01057 
01058         
01059       }
01060     mIgnoreSelectedChanged = false; 
01061      GimmickDebugMessage(1,
01062                         "WxTreeView::SortLevel : " 
01063                         <<after<<" selected after sorting"
01064                         <<std::endl);  
01065   
01066   }
01067   //================================================================
01068 
01069   
01070   //================================================================
01071   void WxTreeView::ValidateSelectedImages(bool isSelection)
01072   {
01073     GimmickDebugMessage(7,
01074                         "WxTreeView::ValidateSelectedImages" 
01075                         <<std::endl);
01076     const std::vector<tree::Node*>& sel(GetSelected(mLevelList.size()+1));
01077     GetGimmickView()->OnSelectionChange(sel,
01078                                         isSelection,(mLastSelected-1),
01079                                         !mIgnoreSelectedChanged);
01080  
01081   }
01082   //================================================================
01083 
01084 
01085   //================================================================
01086   void WxTreeView::GetNodes(std::vector<tree::Node*>& nodes, bool direction)
01087   {
01088         long item = mLastSelected;
01089         int level=mLevelList.size()-1;
01090         //Gets current item data
01091         long adr = GetCtrl(level)->GetItemData(item);
01092         //Extracts the node
01093         tree::Node* nod = ((ItemData*)adr)->node;
01094     for ( ;; )
01095     {
01096                 if(direction)
01097                 {
01098                         item = GetCtrl(level)->GetNextItem(item,
01099                                      wxLIST_NEXT_ABOVE);
01100                 }
01101                 else
01102                 {
01103                         item = GetCtrl(level)->GetNextItem(item,
01104                                      wxLIST_NEXT_BELOW);
01105                 }
01106         if ( item == -1 || item==0  )
01107                 {
01108             break;
01109                 }
01110                 if(GetCtrl(level)->GetItemState(item, wxLIST_STATE_SELECTED)==0 )
01111                 {
01112 
01113                         adr = GetCtrl(level)->GetItemData(item);
01114                         nod = ((ItemData*)adr)->node;
01115                         nodes.push_back(nod);
01116                 }
01117     }
01118 
01119   }
01120   //================================================================
01121    //=================================================
01122   void WxTreeView::OnKeyDown(wxListEvent &event)
01123   {
01124           if(event.GetKeyCode() == WXK_DELETE)
01125           {
01126                    wxBusyCursor busy;
01127                    std::string temp = "0";
01128                    RemoveSelected(temp);
01129                    GetGimmickView()->ClearSelection();
01130           }
01131                   
01132   }
01133   //================================================================
01134 
01135   //================================================================
01136   // Should be in another place : not specific !
01137   void WxTreeView::GetSelectedAsString(std::vector<std::string>&s)
01138   {
01139     int level=mLevelList.size();
01140     const std::vector<tree::Node*>& sel=GetSelected(level+1);
01141     std::vector<tree::Node*>::const_iterator i;
01142     
01143     for (i=sel.begin(); i!=sel.end(); ++i)
01144       {
01145         std::string filename=(*i)->GetAttribute("FullFileName");
01146         s.push_back(filename);
01147       }
01148   }
01149 
01150 
01151 
01152   //================================================================
01153   void WxTreeView::GetFilenamesAsString(const std::vector<tree::Node*>& nodes, std::vector<std::string>&s)
01154   {
01155     std::vector<tree::Node*>::const_iterator i;
01156     
01157     for (i=nodes.begin(); i!=nodes.end(); ++i)
01158       {
01159                   if((*i)->GetLevel()<mLevelList.size())
01160                   {
01161                          GetTreeHandler()->LoadChildren(*i,0);
01162                          GetFilenamesAsString((*i)->GetChildrenList(),s);
01163                   }
01164                   else
01165                   {
01166                         std::string filename=(*i)->GetAttribute("FullFileName");
01167                         s.push_back(filename);
01168                   }
01169       }
01170   }
01171 
01172    //================================================================
01173 
01174    //================================================================
01175   void WxTreeView::GetAttributes(std::vector<std::string>& areShown, std::vector<std::string>& notShown, int level)
01176   {
01177           areShown.clear();
01178           notShown.clear();
01179         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
01180         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(level).begin();
01181              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(level).end();
01182              ++a)
01183         {
01184                 if(a->GetFlags()==creaImageIO::tree::AttributeDescriptor::EDITABLE && IsAttributeVisible(a->GetName(),level))
01185             {
01186                         areShown.push_back(a->GetName());
01187                 }
01188         }
01189         notShown=mLevelList[level-1].notShownAtts;
01190   }
01191 
01192   //================================================================
01193   void WxTreeView::SetNonVisibleAttributes(const std::vector<std::string>& notShown, int nlevel)
01194   {
01195         mLevelList[nlevel].notShownAtts=notShown;
01196   }
01197 
01198   //================================================================
01199    void WxTreeView::CreateCtrl(std::vector<std::string>& notShown, int nlevel)
01200   {
01201         int ctrl_style = wxLC_REPORT | wxLC_VRULES;
01202     int col_style = wxLIST_FORMAT_LEFT;
01203         LevelType level;
01204         mLevelList[nlevel].SelectedUpToDate = true;
01205         mLevelList[nlevel].SortColumn = 0;
01206         mLevelList[nlevel].key.clear();
01207         
01208         mLevelList[nlevel].wxCtrl = new wxListCtrl(mLevelList[nlevel].wxSplitter,
01209                                           nlevel,
01210                                           wxDefaultPosition, 
01211                                           wxDefaultSize,
01212                                           ctrl_style);
01213         wxWindow* oldWin=mLevelList[nlevel].wxSplitter->GetWindow1();
01214         mLevelList[nlevel].wxSplitter->ReplaceWindow(oldWin,mLevelList[nlevel].wxCtrl);
01215         mLevelList[nlevel].wxSplitter->Initialize(mLevelList[nlevel].wxCtrl);
01216    
01217         // Create the columns : one for each attribute of the level
01218         int col = 0;
01219         std::string title;
01220 
01221         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
01222         for (a  = GetTreeHandler()->GetTree().GetAttributeDescriptorList(nlevel+1).begin();
01223              a != GetTreeHandler()->GetTree().GetAttributeDescriptorList(nlevel+1).end();
01224              ++a)
01225 
01226         {   
01227             if(a->GetFlags()!=creaImageIO::tree::AttributeDescriptor::PRIVATE && IsAttributeVisible(a->GetName(),nlevel+1))
01228               {
01229                   title=a->GetName();
01230                   std::string temp = a->GetKey();
01231                   if (temp.compare("ID") != 0)
01232                   {
01233                         mLevelList[nlevel].wxCtrl->InsertColumn(col, 
01234                                         crea::std2wx(title),
01235                                         col_style);
01236                         col++;
01237                   }
01238                 mLevelList[nlevel].key.push_back(a->GetKey());
01239               }
01240                 
01241           }
01242         oldWin->Destroy();
01243         UpdateLevel(1);
01244         }
01245 
01246    //================================================================
01247   bool WxTreeView::IsAttributeVisible(const std::string& val, int level)
01248   {
01249           std::vector<std::string> ns=mLevelList[level-1].notShownAtts;
01250           std::vector<std::string>::iterator it;
01251           bool found=false;
01252           for(it=ns.begin();it!=ns.end()&&!found;++it)
01253           {
01254                   if(val.compare(*it)==0)
01255                   {
01256                           found=true;
01257                   }
01258           }
01259           return !found;
01260   }
01261  //================================================================
01262   //================================================================
01263 
01264         RemoveAlertDlg::RemoveAlertDlg(wxWindow *parent, 
01265                                        wxString title,    
01266                                        const wxSize& size)
01267  :   wxDialog( parent, 
01268                   wxID_ANY, 
01269                   title,
01270                   wxDefaultPosition,
01271                   size,
01272                   wxDEFAULT_DIALOG_STYLE)
01273         {
01274             wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
01275 
01276                 //std::string out("To reload deleted patient, you should synchronize your database before.");  // JPR
01277                 //wxTextCtrl *text = new wxTextCtrl(this, wxID_ANY,crea::std2wx(out),wxDefaultPosition, wxSize(500,20));
01278                 wxTextCtrl *text = new wxTextCtrl(this, wxID_ANY,
01279                                         _T("To reload deleted patient, you should synchronize your database before."),
01280                                         wxDefaultPosition, wxSize(650,20));  // 650 vs 500 ? // JPRx
01281                 mcheck = new wxCheckBox(this, 5478, _T("Do not display this warning again!"));
01282                 Connect( mcheck->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &RemoveAlertDlg::onCheck ); 
01283                 wxSizer* buttonsSizer = this->CreateSeparatedButtonSizer(wxOK|wxCANCEL);
01284                 
01285                 topsizer->Add(text);
01286                 topsizer->Add(mcheck,0,wxGROW);
01287                 topsizer->Add(buttonsSizer,0,wxGROW);
01288                 SetSizer(topsizer, true);
01289                 mSave = false;
01290                 Layout();
01291         }
01292         RemoveAlertDlg::~RemoveAlertDlg(){};
01293         bool RemoveAlertDlg::isChecked()
01294         {
01295                 return mSave;
01296         }
01297         void RemoveAlertDlg::onCheck(wxCommandEvent &Event)
01298         {
01299                 mSave = mcheck->IsChecked();
01300         }
01301         
01302 
01303   //================================================================
01304   //================================================================
01305   BEGIN_EVENT_TABLE(WxTreeView, wxPanel)   
01306   /*
01307     EVT_SIZE(MyFrame::OnSize)
01308 
01309     EVT_MENU(LIST_QUIT, MyFrame::OnQuit)
01310     EVT_MENU(LIST_ABOUT, MyFrame::OnAbout)
01311     EVT_MENU(LIST_LIST_VIEW, MyFrame::OnListView)
01312     EVT_MENU(LIST_REPORT_VIEW, MyFrame::OnReportView)
01313     EVT_MENU(LIST_ICON_VIEW, MyFrame::OnIconView)
01314     EVT_MENU(LIST_ICON_TEXT_VIEW, MyFrame::OnIconTextView)
01315     EVT_MENU(LIST_SMALL_ICON_VIEW, MyFrame::OnSmallIconView)
01316     EVT_MENU(LIST_SMALL_ICON_TEXT_VIEW, MyFrame::OnSmallIconTextView)
01317     EVT_MENU(LIST_VIRTUAL_VIEW, MyFrame::OnVirtualView)
01318     EVT_MENU(LIST_SMALL_VIRTUAL_VIEW, MyFrame::OnSmallVirtualView)
01319 
01320     EVT_MENU(LIST_FOCUS_LAST, MyFrame::OnFocusLast)
01321     EVT_MENU(LIST_TOGGLE_FIRST, MyFrame::OnToggleFirstSel)
01322     EVT_MENU(LIST_DESELECT_ALL, MyFrame::OnDeselectAll)
01323     EVT_MENU(LIST_SELECT_ALL, MyFrame::OnSelectAll)
01324     EVT_MENU(LIST_DELETE, MyFrame::OnDelete)
01325     EVT_MENU(LIST_ADD, MyFrame::OnAdd)
01326     EVT_MENU(LIST_EDIT, MyFrame::OnEdit)
01327     EVT_MENU(LIST_DELETE_ALL, MyFrame::OnDeleteAll)
01328     EVT_MENU(LIST_SORT, MyFrame::OnSort)
01329     EVT_MENU(LIST_SET_FG_COL, MyFrame::OnSetFgColour)
01330     EVT_MENU(LIST_SET_BG_COL, MyFrame::OnSetBgColour)
01331     EVT_MENU(LIST_TOGGLE_MULTI_SEL, MyFrame::OnToggleMultiSel)
01332     EVT_MENU(LIST_SHOW_COL_INFO, MyFrame::OnShowColInfo)
01333     EVT_MENU(LIST_SHOW_SEL_INFO, MyFrame::OnShowSelInfo)
01334     EVT_MENU(LIST_FREEZE, MyFrame::OnFreeze)
01335     EVT_MENU(LIST_THAW, MyFrame::OnThaw)
01336     EVT_MENU(LIST_TOGGLE_LINES, MyFrame::OnToggleLines)
01337     EVT_MENU(LIST_MAC_USE_GENERIC, MyFrame::OnToggleMacUseGeneric)
01338 
01339     EVT_UPDATE_UI(LIST_SHOW_COL_INFO, MyFrame::OnUpdateShowColInfo)
01340     EVT_UPDATE_UI(LIST_TOGGLE_MULTI_SEL, MyFrame::OnUpdateToggleMultiSel)
01341 END_EVENT_TABLE()
01342 
01343 BEGIN_EVENT_TABLE(MyListCtrl, wxListCtrl)
01344     EVT_LIST_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnBeginDrag)
01345     EVT_LIST_BEGIN_RDRAG(LIST_CTRL, MyListCtrl::OnBeginRDrag)
01346         
01347     EVT_LIST_BEGIN_LABEL_EDIT(-1, WxTreeView::OnBeginLabelEdit)
01348     EVT_LIST_END_LABEL_EDIT(-1, WxTreeView::OnEndLabelEdit)
01349         
01350     EVT_LIST_DELETE_ITEM(LIST_CTRL, MyListCtrl::OnDeleteItem)
01351     EVT_LIST_DELETE_ALL_ITEMS(LIST_CTRL, MyListCtrl::OnDeleteAllItems)
01352 #if WXWIN_COMPATIBILITY_2_4
01353     EVT_LIST_GET_INFO(LIST_CTRL, MyListCtrl::OnGetInfo)
01354     EVT_LIST_SET_INFO(LIST_CTRL, MyListCtrl::OnSetInfo)
01355 #endif
01356   */
01357     EVT_LIST_KEY_DOWN(-1, WxTreeView::OnKeyDown)
01358     EVT_LIST_ITEM_SELECTED(-1, WxTreeView::OnItemSelected)
01359         EVT_LIST_ITEM_RIGHT_CLICK(-1, WxTreeView::OnItemMenu)
01360     EVT_LIST_ITEM_DESELECTED(-1, WxTreeView::OnItemDeSelected)
01361         /*
01362     EVT_LIST_KEY_DOWN(LIST_CTRL, MyListCtrl::OnListKeyDown)
01363     EVT_LIST_ITEM_ACTIVATED(LIST_CTRL, MyListCtrl::OnActivated)
01364     EVT_LIST_ITEM_FOCUSED(LIST_CTRL, MyListCtrl::OnFocused)
01365 */
01366     EVT_LIST_COL_RIGHT_CLICK(-1, WxTreeView::OnColClick)
01367         
01368     EVT_LIST_COL_CLICK(-1, WxTreeView::OnColClick)
01369 
01370         //EVT_LEFT_DOWN(WxTreeView::OnMouseClick)
01371         /*
01372     EVT_LIST_COL_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnColBeginDrag)
01373     EVT_LIST_COL_DRAGGING(LIST_CTRL, MyListCtrl::OnColDragging)
01374     EVT_LIST_COL_END_DRAG(LIST_CTRL, MyListCtrl::OnColEndDrag)
01375 
01376     EVT_LIST_CACHE_HINT(LIST_CTRL, MyListCtrl::OnCacheHint)
01377 
01378 #if USE_CONTEXT_MENU
01379     EVT_CONTEXT_MENU(MyListCtrl::OnContextMenu)
01380 #endif
01381     EVT_CHAR(MyListCtrl::OnChar)
01382 
01383     EVT_RIGHT_DOWN(MyListCtrl::OnRightClick)
01384   */
01385 END_EVENT_TABLE()
01386   
01387 } // EO namespace creaImageIO
01388
Generated by  doxygen 1.7.1