src2/creaImageIOWxTreeView.cpp

   1 #include <creaImageIOWxTreeView.h>
   2 #include <creaImageIOGimmickView.h>
   3 #include <creaImageIOSystem.h>
   4 #include <wx/splitter.h>
   5 #include <wx/gdicmn.h>
   6 ///Comparing function for ordering algorithm. Takes parameters as strings.
   7 int wxCALLBACK CompareFunctionStrings(long item1, long item2, long sortData)
   8 {
   9         std::string s1((char*)((long*)item1)[1]);
  10         std::string s2((char*)((long*)item2)[1]);
  11         if(sortData==1)
  12         {
  13                 // inverse the order
  14                 if (s1 < s2)
  15                         return 1;
  16                 if (s1 > s2)
  17                         return -1;
  18
  19                 return 0;
  20         }
  21         else
  22         {
  23                 if (s1 < s2)
  24                         return -1;
  25                 if (s1 > s2)
  26                         return 1;
  27
  28                 return 0;
  29
  30         }
  31
  32 }
  33
  34 ///Comparing function for ordering algorithm. Takes parameters as ints.
  35 int wxCALLBACK CompareFunctionInts(long item1, long item2, long sortData)
  36 {
  37         int val1=atoi((char*)((long*)item1)[1]);
  38         int val2=atoi((char*)((long*)item2)[1]);
  39         if(sortData==1)
  40         {
  41                 // inverse the order
  42                 if (val1 < val2)
  43                         return 1;
  44                 if (val1 > val2)
  45                         return -1;
  46
  47                 return 0;
  48         }
  49         else
  50         {
  51                 if (val1 < val2)
  52                         return -1;
  53                 if (val1 > val2)
  54                         return 1;
  55
  56                 return 0;
  57
  58         }
  59
  60 }
  61
  62 namespace creaImageIO
  63 {
  64   //=====================================================================
  65   // CTor
  66   WxTreeView::WxTreeView(TreeHandler* handler,
  67                          GimmickView* gimmick,
  68                          wxWindow* parent,
  69                          const wxWindowID id)
  70     : wxPanel(parent,id),
  71       TreeView(handler,gimmick)
  72   {
  73     GimmickDebugMessage(1,"WxTreeView::WxTreeView"
  74                         <<std::endl);
  75
  76
  77     // Split part below toolbar into notebook for views and panel
  78     // for preview, messages...
  79     // TO DO : Splitter
  80     //    mSplitter = new wxSplitterWindow( this , -1);
  81
  82     // Global sizer
  83     wxBoxSizer  *sizer = new wxBoxSizer(wxHORIZONTAL);
  84
  85     int ctrl_style = wxLC_REPORT | wxLC_VRULES;
  86     int col_style = wxLIST_FORMAT_LEFT;
  87
  88     // Creating the ListCtrl for the levels > 0 (not for Root level)
  89     for (int i = 1;
  90          i < handler->GetTree().GetNumberOfLevels();
  91          ++i)
  92       {
  93
  94         GimmickDebugMessage(5,"Creating view for level "<<i
  95                             <<std::endl);
  96         LevelType level;
  97
  98         // If the first level : parent = this
  99         wxWindow* sparent = this;
 100         // else parent = last splitter
 101         if (i>1) sparent = mLevelList[i-2].wxSplitter;
 102
 103         level.wxSplitter = new wxSplitterWindow( sparent , -1);
 104         //          level.wxSplitter->SetMinimumPaneSize(100);
 105
 106         wxListCtrl* ctrl = new wxListCtrl(level.wxSplitter,
 107                                           i,
 108                                           wxDefaultPosition,
 109                                           wxDefaultSize,
 110                                           ctrl_style);
 111         level.wxCtrl = ctrl;
 112         level.wxSplitter->Initialize(ctrl);
 113
 114         // Create the first column : number of children
 115         if(i<handler->GetTree().GetNumberOfLevels()-1)
 116         {
 117         std::string title = "#";
 118         if (i<handler->GetTree().GetNumberOfLevels()-1)
 119           {
 120             title += handler->GetTree().GetLevelDescriptor(i+1).GetName();
 121             if (title[title.size()-1]!='s')
 122               title += "s";
 123           }
 124         ctrl->InsertColumn(0,crea::std2wx(title),col_style);
 125         }
 126
 127         // Create the columns : one for each attribute of the level
 128         int col = 1;
 129         tree::LevelDescriptor::AttributeDescriptorListType::const_iterator a;
 130         for (a  = handler->GetTree().GetAttributeDescriptorList(i).begin();
 131              a != handler->GetTree().GetAttributeDescriptorList(i).end();
 132              ++a)
 133           {
 134
 135                 GimmickDebugMessage(5,"Creating column "<<col<<" : "
 136                                 <<a->GetName()
 137                                 <<std::endl);
 138                 ctrl->InsertColumn(col,
 139                                 crea::std2wx(a->GetName()),
 140                                 col_style);
 141                 level.key.push_back(a->GetKey());
 142                 //          ctrl->SetColumnWidth(col, wxLIST_AUTOSIZE );
 143                 col++;
 144
 145
 146           }
 147
 148         mLevelList.push_back(level);
 149       }
 150
 151 #if wxUSE_MENUS
 152
 153     menu =new wxMenu;
 154         wxMenuItem* m1=menu->Append(wxID_ANY, _T("&Sort ascending"));
 155         wxMenuItem* m2=menu->Append(wxID_ANY, _T("&Sort descending"));
 156         wxMenuItem* m3=menu->Append(wxID_ANY, _T("&Filter"));
 157         mAscendingID=m1->GetId();
 158         mDescendingID=m2->GetId();
 159         mFilterID=m3->GetId();
 160         Connect( mAscendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
 161         Connect( mDescendingID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupSort) );
 162         Connect( mFilterID, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(WxTreeView::OnPopupFilter) );
 163
 164 #endif // wxUSE_MENUS
 165
 166
 167     /// Initialize the first level splitter
 168
 169       sizer->Add( mLevelList[0].wxSplitter ,1, wxGROW  ,0);
 170         mColumnSelected=1;
 171         mLastSelected=0;
 172         mDirection=true;
 173         mSelectionMade=false;
 174         mProcess=true;
 175         //CreateColorPalette();
 176     UpdateLevel(1);
 177
 178     SetSizer( sizer );
 179     SetAutoLayout(true);
 180     Layout();
 181
 182   }
 183   //=====================================================================
 184
 185   //=====================================================================
 186   /// Destructor
 187   WxTreeView::~WxTreeView()
 188   {
 189     GimmickDebugMessage(1,"WxTreeView::~WxTreeView"
 190                         <<std::endl);
 191   }
 192   //=====================================================================
 193
 194
 195   //=====================================================================
 196   struct ItemData
 197   {
 198     tree::Node* node;
 199         int id;
 200   };
 201
 202   //=====================================================================
 203    std::vector<tree::Node*> WxTreeView::GetSelected(int level)
 204   {
 205     int l = level - 1;
 206     // the selection of upper level
 207     std::vector<tree::Node*> sel;
 208
 209     if (level == 1)
 210       {
 211         sel.push_back(GetTreeHandler()->GetTree().GetTree());
 212       }
 213     else
 214       {
 215         int n = GetCtrl(l-1)->GetItemCount();
 216         for (int i = 0; i < n; i++)
 217           {
 218             if ( GetCtrl(l-1)->GetItemState(i,wxLIST_STATE_SELECTED))
 219               {
 220                 long adr = GetCtrl(l-1)->GetItemData(i);
 221                 tree::Node* n = ((ItemData*)adr)->node;
 222                         if(mLastSelected==i)
 223                         {
 224                                 std::vector<tree::Node*>::iterator it;
 225                                 it = sel.begin();
 226                                 it = sel.insert ( it , n );
 227                         }
 228                         else
 229                         {
 230                                 sel.push_back(n);
 231                         }
 232               }
 233           }
 234       }
 235
 236           return sel;
 237   }
 238
 239   //=====================================================================
 240
 241   ///Removes selected nodes on given level
 242   void WxTreeView::RemoveSelected( int level )
 243   {
 244           std::vector<tree::Node*> sel=GetSelected(level+1);
 245           bool erase=false;
 246           if (wxMessageBox(_T("Delete file(s) ?"),
 247                          _T("Remove Files"),
 248                          wxYES_NO,this ) == wxYES)
 249           {
 250             erase = true;
 251           }
 252           if(erase)
 253           {
 254                 std::vector<tree::Node*>::iterator i;
 255                 for (i=sel.begin(); i!=sel.end(); ++i)
 256                 {
 257                         GimmickDebugMessage(2,
 258                                         "deleting '"
 259                                         <<(*i)->GetLabel()
 260                                         <<"'"<<level
 261                                         <<std::endl);
 262                                 GetTreeHandler()->Remove(*i);
 263                 }
 264
 265                 UpdateLevel(level);
 266           }
 267
 268   }
 269
 270
 271   //=====================================================================
 272
 273
 274   //=====================================================================
 275   /// Updates a level of the view (adds or removes children, proganizes, etc.)
 276   void WxTreeView::UpdateLevel( int level )
 277   {
 278     GimmickDebugMessage(1,
 279                         GetTreeHandler()->GetTree().GetLabel()
 280                         <<" view : updating level "<<level
 281                         <<std::endl);
 282
 283     wxBusyCursor busy;
 284     RecursiveUpdateLevel(level);
 285     int i;
 286     for (i=0; i<level-1; i++)
 287       {
 288         if (!GetSplitter(i)->IsSplit())
 289           GetSplitter(i)->SplitVertically(  GetCtrl(i), GetSplitter(i+1),
 290                                             100 );
 291       }
 292     if (GetSplitter(i)->IsSplit()) GetSplitter(i)->Unsplit();
 293
 294   }
 295   //=====================================================================
 296
 297   /// Recursive method called upon by UpdateLevel to refresh all windows
 298   void WxTreeView::RecursiveUpdateLevel( int level )
 299   {
 300           GimmickDebugMessage(2,
 301                         GetTreeHandler()->GetTree().GetLabel()
 302                         <<" view : updating level (recursive)"<<level
 303                         <<std::endl);
 304
 305
 306     std::vector<tree::Node*> sel=GetSelected(level);
 307
 308           int l = level - 1;
 309
 310     // to speed up inserting we hide the control temporarily
 311     GetCtrl(l)->Hide();
 312     GetCtrl(l)->DeleteAllItems();
 313
 314     std::vector<tree::Node*>::iterator i;
 315
 316     //Adds the first item (filter)
 317
 318         for (i=sel.begin(); i!=sel.end(); ++i)
 319       {
 320         GimmickDebugMessage(2,
 321                             "adding children of '"
 322                             <<(*i)->GetLabel()
 323                             <<"'"
 324                             <<std::endl);
 325         int _id=1;
 326
 327         //Adds items (other than the first) and sets their attributes
 328            GetCtrl(l)->InsertItem(0, _T(""));
 329         GetTreeHandler()->LoadChildren(*i,1);
 330         tree::Node::ChildrenListType::reverse_iterator j;
 331         for (j = (*i)->GetChildrenList().rbegin();
 332              j!= (*i)->GetChildrenList().rend();
 333              ++j)
 334           {
 335                          wxListItem* item= new wxListItem;
 336             item->SetMask(wxLIST_MASK_STATE |
 337                          wxLIST_MASK_TEXT |
 338                          //                      wxLIST_MASK_IMAGE |
 339                          wxLIST_MASK_DATA |
 340                          //                      wxLIST_MASK_WIDTH |
 341                          wxLIST_MASK_FORMAT
 342                          );
 343
 344             ItemData* data = new ItemData;
 345
 346                 data->node = *j;
 347                 item->SetId(_id);
 348
 349                 data->id = _id;
 350             item->SetData(data);
 351
 352                 _id++;
 353
 354
 355                 //Setting first column (number of children)
 356             std::ostringstream oss;
 357             int n= GetTreeHandler()->GetNumberOfChildren(*j);
 358             oss << n;
 359             std::string s(oss.str());
 360             item->SetText( crea::std2wx(s));
 361
 362             item->SetColumn(0);
 363                  GetCtrl(l)->InsertItem(*item);
 364                 //GetCtrl(l)->SetItem(item);
 365
 366                 //Setting other attributes
 367                 if(level<mLevelList.size())
 368                 {
 369                 for (int k=1; k<GetCtrl(l)->GetColumnCount(); k++)
 370               {
 371                         std::string val = (*j)->GetAttribute(mLevelList[l].key[k-1]);
 372                         if (val.size()==0) val = "?";
 373                         item->SetText( crea::std2wx(val));
 374                         item->SetColumn(k);
 375                         GetCtrl(l)->SetItem(*item);
 376                         GetCtrl(l)->RefreshItem(*item);
 377               }
 378                 }
 379                 else
 380                 {
 381                         for (int k=0; k<GetCtrl(l)->GetColumnCount(); k++)
 382               {
 383                         std::string val = (*j)->GetAttribute(mLevelList[l].key[k]);
 384                         if (val.size()==0) val = "?";
 385                         item->SetText( crea::std2wx(val));
 386                         item->SetColumn(k);
 387                         GetCtrl(l)->SetItem(*item);
 388                         GetCtrl(l)->RefreshItem(*item);
 389               }
 390                 }
 391
 392           }
 393         GetCtrl(l)->DeleteItem(0);
 394       }
 395
 396     GetCtrl(l)->Show();
 397
 398     if (level<mLevelList.size()) UpdateLevel(level+1);
 399
 400  }
 401   //=====================================================================
 402
 403
 404   //================================================================
 405   void WxTreeView::OnSelectedChanged(wxListEvent& event)
 406   {
 407     GimmickDebugMessage(1,
 408                         GetTreeHandler()->GetTree().GetLabel()
 409                         <<" view : item selected "
 410                         <<std::endl);
 411
 412     wxListItem info;
 413     info.m_itemId = event.m_itemIndex;
 414     mLastSelected=event.m_itemIndex;
 415         // retrieve the level
 416         wxObject* obj = event.GetEventObject();
 417         unsigned int level = 0;
 418         for (level = 0; level<mLevelList.size(); ++level)
 419         {
 420         if ( GetCtrl(level) == obj ) break;
 421         }
 422         GimmickDebugMessage(1,
 423                         " Level "<<level+1
 424                         <<std::endl);
 425
 426         GimmickMessage(1,
 427                         " Event type "<<event.GetEventType()
 428                         <<std::endl);
 429         /*
 430         if(event.m_itemIndex!=0)
 431         {*/
 432                 if(level<mLevelList.size()-1)
 433                 {
 434                 mSelected=GetSelected(level+2);
 435                 }
 436                 else if(mProcess)
 437                 {
 438                 mLastLevelSelected=GetSelected(level+2);
 439                 }
 440                 else
 441                 {
 442                         event.Veto();
 443                 }
 444
 445                 if (level<mLevelList.size()-1)
 446                 {
 447                         UpdateLevel( level + 2 );
 448                         GetGimmickView()->ClearSelection();
 449                 }
 450                 if (level==mLevelList.size()-2) SelectLowerLevel();
 451                 if (level==(mLevelList.size()-1)&&mProcess)
 452                 {
 453                         if(event.GetEventType()==10145)
 454                         {
 455                         ValidateSelectedImages (true);
 456                         }
 457                         else
 458                         {
 459                                 ValidateSelectedImages (false);
 460                         }
 461                 }
 462                 //SetColor(level,event.m_itemIndex);
 463         /*}
 464         else
 465         {
 466                 if(event.GetEventType()==10145)
 467                 {
 468
 469                 GetCtrl(level)->SetItemText(0,crea::std2wx(""));
 470                 GetCtrl(level)->EditLabel(event.m_itemIndex);
 471                 }
 472
 473         }*/
 474
 475
 476   }
 477   //================================================================
 478
 479   //================================================================
 480   void WxTreeView::SelectLowerLevel()
 481   {
 482         long item = -1;
 483         int level=mLevelList.size()-1;
 484
 485     for ( ;; )
 486     {
 487                 item = GetCtrl(level)->GetNextItem(item,
 488                                      wxLIST_NEXT_ALL);
 489         if ( item == -1 )
 490             break;
 491
 492                 if(item==(GetCtrl(level)->GetItemCount()-1))
 493                 {
 494                         mProcess=true;
 495                 }
 496                 else
 497                 {
 498                         mProcess=false;
 499                 }
 500
 501                 /*if(item!=0)
 502                 {*/
 503                 GetCtrl(level)->SetItemState(item,wxLIST_STATE_SELECTED, wxLIST_MASK_STATE
 504                 | wxLIST_MASK_TEXT |wxLIST_MASK_IMAGE | wxLIST_MASK_DATA | wxLIST_MASK_WIDTH | wxLIST_MASK_FORMAT);
 505                 //}
 506
 507     }
 508
 509
 510   }
 511
 512   //================================================================
 513   //================================================================
 514
 515   void WxTreeView::OnColClick(wxListEvent& event)
 516   {
 517         mColumnSelected=event.m_col;
 518         wxPoint clientpt = event.GetPoint();
 519         senderCtrl = event.GetEventObject();
 520         unsigned int level = 0;
 521         for (level = 0; level<mLevelList.size(); ++level)
 522         {
 523         if ( GetCtrl(level) == senderCtrl ) break;
 524         }
 525         clientpt.x+=(mColumnSelected)*(GetCtrl(0)->GetColumnWidth(mColumnSelected));
 526         for(int i=0;i<level;i++)
 527         {
 528                 clientpt.x+=GetSplitter(i)->GetSashPosition();
 529         }
 530         clientpt.y+=level*2;
 531         if(level==mLevelList.size()-1)
 532         {
 533                 mColumnSelected+=1;
 534                 PopupMenu(menu, clientpt);
 535         }
 536         else if(mColumnSelected!=0)
 537         {
 538                 PopupMenu(menu, clientpt);
 539         }
 540
 541   }
 542     //================================================================
 543   void WxTreeView::OnPopupFilter(wxCommandEvent& event)
 544   {
 545                 wxBusyCursor busy;
 546                  GimmickDebugMessage(7,
 547                         "WxTreeView::OnEndLabelEdit"
 548                         <<std::endl);
 549           wxObject* ctrl = event.GetEventObject();
 550                 unsigned int level = 0;
 551                 for (level = 0; level<mLevelList.size(); ++level)
 552                 {
 553                 if ( GetCtrl(level) == senderCtrl ) break;
 554                 }
 555                 std::string filter = wxGetTextFromUser(_T("Enter the filter to apply"), _T("Filter On Column"));
 556
 557                 std::string att;
 558
 559                 long it = -1;
 560                 UpdateLevel(level+1);
 561
 562                 std::vector<long> items;
 563                 bool in=false;
 564                 int del=0;
 565                 for ( ;; )
 566                 {
 567                         it = GetCtrl(level)->GetNextItem(it,
 568                                                                                 wxLIST_NEXT_ALL);
 569                         if ( it == -1 )
 570                                 break;
 571
 572                         long adr = GetCtrl(level)->GetItemData(it);
 573                         tree::Node* nod = ((ItemData*)adr)->node;
 574                         att=(*nod).GetAttribute(mLevelList[level].key[mColumnSelected-1]);
 575
 576
 577                         if(att.find(filter)>900)
 578                         {
 579
 580                                 if(!in)
 581                                 {
 582                                         in=true;
 583                                 }
 584                                 else
 585                                 {
 586                                         del+=1;
 587                                 }
 588
 589                                 items.push_back(it-del);
 590                         }
 591
 592                 }
 593                 std::vector<long>::iterator iter;
 594                 for(iter=items.begin();iter!=items.end();++iter)
 595                 {
 596                         GetCtrl(level)->DeleteItem(*iter);
 597                 }
 598                 GetGimmickView()->ClearSelection();
 599   }
 600   //================================================================
 601
 602   //================================================================
 603   void WxTreeView::OnPopupSort(wxCommandEvent& event)
 604   {
 605                 wxBusyCursor busy;
 606                 unsigned int level = 0;
 607                 for (level = 0; level<mLevelList.size(); ++level)
 608                 {
 609                 if ( GetCtrl(level) == senderCtrl ) break;
 610                 }
 611                 if(event.GetId()==mAscendingID)
 612                 {
 613                         mDirection=true;
 614                 }
 615                 else if(event.GetId()==mDescendingID)
 616                 {
 617                         mDirection=false;
 618                 }
 619
 620         OnSort(level);
 621   }
 622   //================================================================
 623   void WxTreeView::OnSort(int level)
 624   {
 625         //Obtain the column name and the level that needs to be organized
 626
 627         if(level==mLevelList.size()-1||mColumnSelected!=0)
 628         {
 629                 int l = level - 1;
 630                 //GetCtrl(level)->DeleteItem(0);
 631                 //Sets the data for the items to be sorted
 632                 std::string att;
 633                 unsigned int ty=0;
 634                 int n = GetCtrl(level)->GetItemCount();
 635                 for (int i = 0; i < n; i++)
 636                 {
 637
 638                         //Gets current item data
 639                         long adr = GetCtrl(level)->GetItemData(i);
 640
 641                         //Extracts the node and the type of attribute
 642                         tree::Node* nod = ((ItemData*)adr)->node;
 643                         if(i==0)
 644                         {
 645                                 (*nod).GetAttributeDescriptor(mLevelList[level].key[mColumnSelected-1]).DecodeType(ty);
 646                         }
 647                         //Obtains the organizing attribute
 648                         att=(*nod).GetAttribute(mLevelList[level].key[mColumnSelected-1]);
 649
 650                         char* d= new char [att.size()+1];
 651                         strcpy (d, att.c_str());
 652
 653                         //Creates array
 654                         long* lp= new long[2];
 655                         lp[0]=adr;
 656                         lp[1]=(long)d;
 657
 658                         //Sets it as the data
 659                         GetCtrl(level)->SetItemData(i,(long)lp);
 660                 }
 661
 662                 if(mDirection)
 663                 {
 664                         if(ty==1)
 665                         {
 666                                 GetCtrl(level)->SortItems(CompareFunctionInts, 0);
 667                         }
 668                         else
 669                         {
 670                                 GetCtrl(level)->SortItems(CompareFunctionStrings, 0);
 671                         }
 672
 673                 }
 674                 else
 675                 {
 676                         if(ty==1)
 677                         {
 678                                 GetCtrl(level)->SortItems(CompareFunctionInts, 1);
 679                         }
 680                         else
 681                         {
 682                                 GetCtrl(level)->SortItems(CompareFunctionStrings, 1);
 683                         }
 684                 }
 685
 686                 //Resets original data
 687                 std::vector<tree::Node*>::iterator selection;
 688                 std::vector<long> change;
 689                 long it = -1;
 690                 for ( ;; )
 691                 {
 692                         it = GetCtrl(level)->GetNextItem(it,
 693                                                                                 wxLIST_NEXT_ALL);
 694                         if ( it == -1 )
 695                                 break;
 696
 697                         //Gets current item data, extracts the node and resets it
 698                         long item = GetCtrl(level)->GetItemData(it);
 699                         GetCtrl(level)->SetItemData(it,((long*)item)[0]);
 700                         tree::Node* n= ((ItemData*)((long*)item)[0])->node;
 701                         if(level<mLevelList.size()-1)
 702                         {
 703                                 for(selection=mSelected.begin();selection!=mSelected.end();++selection)
 704                                 {
 705                                         if((*selection)->GetAttribute("ID").compare(n->GetAttribute("ID"))==0)
 706                                         {
 707                                                 change.push_back(it);
 708                                         }
 709                                 }
 710                         }
 711                         else
 712                         {
 713                                 for(selection=mLastLevelSelected.begin();selection!=mLastLevelSelected.end();++selection)
 714                                 {
 715                                         if((*selection)->GetAttribute("ID").compare(n->GetAttribute("ID"))==0)
 716                                         {
 717                                                 change.push_back(it);
 718                                         }
 719                                 }
 720                         }
 721
 722
 723                 }
 724                 //Resets the selected items
 725                 std::vector<long>::iterator selectedIts;
 726                 for(selectedIts=change.begin();selectedIts!=change.end();++selectedIts)
 727                 {
 728                         GetCtrl(level)->SetItemState(*selectedIts,wxLIST_STATE_SELECTED, wxLIST_MASK_STATE
 729                 | wxLIST_MASK_TEXT |wxLIST_MASK_IMAGE | wxLIST_MASK_DATA | wxLIST_MASK_WIDTH | wxLIST_MASK_FORMAT);
 730
 731                 }
 732                 //GetCtrl(level)->InsertItem(0,_T("Filter:"));
 733         }
 734
 735    }
 736   //================================================================
 737   void WxTreeView::OnBeginLabelEdit(wxListEvent& event)
 738   {
 739         GimmickDebugMessage(7,
 740                         "WxTreeView::OnBeginLabelEdit"
 741                         <<std::endl);
 742         if(event.m_itemIndex!=0)
 743         {
 744                 event.Veto();
 745         }
 746
 747   }
 748
 749   //================================================================
 750   void WxTreeView::OnEndLabelEdit(wxListEvent& event)
 751   {
 752           GimmickDebugMessage(7,
 753                         "WxTreeView::OnEndLabelEdit"
 754                         <<std::endl);
 755           wxObject* ctrl = event.GetEventObject();
 756                 unsigned int level = 0;
 757                 for (level = 0; level<mLevelList.size(); ++level)
 758                 {
 759                 if ( GetCtrl(level) == ctrl ) break;
 760                 }
 761                 std::string filter = crea::wx2std(event.m_item.m_text.c_str());
 762
 763                 std::string att;
 764
 765                 long it = -1;
 766                 UpdateLevel(level+1);
 767
 768                 for ( ;; )
 769                 {
 770                         bool contains=false;
 771                         it = GetCtrl(level)->GetNextItem(it,
 772                                                                                 wxLIST_NEXT_ALL);
 773                         if ( it == -1 )
 774                                 break;
 775                         if(it!=0)
 776                         {
 777                                 long adr = GetCtrl(level)->GetItemData(it);
 778                                 for (int j=1;j<GetCtrl(level)->GetColumnCount()-1&&!contains;j++)
 779                                 {
 780                                 tree::Node* nod = ((ItemData*)adr)->node;
 781                                 att=(*nod).GetAttribute(mLevelList[level].key[j-1]);
 782
 783                                 if(att.find(filter)<900)
 784                                 {
 785                                         contains=true;
 786                                 }
 787                                 }
 788                                 if(!contains)
 789                                 {
 790                                         GetCtrl(level)->DeleteItem(it);
 791                                 }
 792                         }
 793                 }
 794                 GetGimmickView()->ClearSelection();
 795                 //GetCtrl(level)->DeleteAllItems();
 796
 797   }
 798   //================================================================
 799   void WxTreeView::ValidateSelectedImages(bool isSelection)
 800   {
 801     GimmickDebugMessage(7,
 802                         "WxTreeView::ValidateSelectedImages"
 803                         <<std::endl);
 804     std::vector<tree::Node*> sel(GetSelected(mLevelList.size()+1));
 805         GetGimmickView()->OnSelectionChange(sel,isSelection,(mLastSelected-1), mProcess);
 806
 807   }
 808   //================================================================
 809
 810
 811   //================================================================
 812   void WxTreeView::GetNodes(std::vector<tree::Node*>& nodes, bool direction)
 813   {
 814         long item = mLastSelected;
 815         int level=mLevelList.size()-1;
 816         //Gets current item data
 817         long adr = GetCtrl(level)->GetItemData(item);
 818         //Extracts the node
 819         tree::Node* nod = ((ItemData*)adr)->node;
 820     for ( ;; )
 821     {
 822                 if(direction)
 823                 {
 824                         item = GetCtrl(level)->GetNextItem(item,
 825                                      wxLIST_NEXT_ABOVE);
 826                 }
 827                 else
 828                 {
 829                         item = GetCtrl(level)->GetNextItem(item,
 830                                      wxLIST_NEXT_BELOW);
 831                 }
 832         if ( item == -1  )
 833                 {
 834             break;
 835                 }
 836                 if(GetCtrl(level)->GetItemState(item, wxLIST_STATE_SELECTED)==0 && item!=0)
 837                 {
 838                         adr = GetCtrl(level)->GetItemData(item);
 839                         nod = ((ItemData*)adr)->node;
 840                         nodes.push_back(nod);
 841                 }
 842     }
 843
 844   }
 845
 846   //================================================================
 847   void WxTreeView::GetSelectedAsString(std::vector<std::string>&s)
 848   {
 849           int level=mLevelList.size();
 850         std::vector<tree::Node*> sel=GetSelected(level+1);
 851         std::vector<tree::Node*>::iterator i;
 852
 853     for (i=sel.begin(); i!=sel.end(); ++i)
 854       {
 855                   std::string filename=(*i)->GetAttribute("FullFileName");
 856                   s.push_back(filename);
 857           }
 858   }
 859
 860    //================================================================
 861   void WxTreeView::SetColor(int l, int item)
 862   {
 863           int colorId=12;
 864           GetCtrl(l)->SetItemTextColour(item, wxColourDatabase().Find
 865                    (crea::std2wx(mColorPalette[colorId])));
 866           GetCtrl(l)->SetItemState(item,wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED);  /*
 867           int colorId=0;
 868           //Setting the color according to the parent
 869                 if(l==0)
 870                 {
 871                 item.SetBackgroundColour
 872                   (wxColourDatabase().Find
 873                    (crea::std2wx(mColorPalette[colorId])));
 874                 mColorMap.insert
 875                   (NodeColorPair
 876                    (*j,wxColourDatabase().Find
 877                     (crea::std2wx(mColorPalette[colorId]))));
 878                 if(colorId<64)
 879                   {
 880                     colorId++;
 881                   }
 882                 else
 883                         {
 884                           colorId=0;
 885                         }
 886                 }
 887                 else if(l!=mLevelList.size()-1)
 888                   {
 889                     item.SetBackgroundColour(mColorMap[*i]);
 890                         mColorMap.insert(NodeColorPair(*j,mColorMap[*i]));
 891                 }
 892                 else
 893                 {
 894                         item.SetBackgroundColour(mColorMap[*i]);
 895                 }*/
 896   }
 897   //================================================================
 898   void WxTreeView::CreateColorPalette()
 899   {
 900   GimmickDebugMessage(6,"WxTreeView::CreateColorPalette");
 901   mColorPalette.push_back("WHITE");
 902   mColorPalette.push_back("LIGHT GREY");
 903   mColorPalette.push_back("AQUAMARINE");
 904   mColorPalette.push_back("MEDIUM FOREST GREEN");
 905   mColorPalette.push_back("INDIAN RED");
 906   mColorPalette.push_back("KHAKI");
 907   mColorPalette.push_back("ORANGE");
 908   mColorPalette.push_back("LIGHT BLUE");
 909   mColorPalette.push_back("LIGHT STEEL BLUE");
 910   mColorPalette.push_back("PINK");
 911   mColorPalette.push_back("PLUM");
 912   mColorPalette.push_back("PURPLE");
 913   mColorPalette.push_back("RED");
 914   mColorPalette.push_back("SEA GREEN");
 915   mColorPalette.push_back("SIENNA");
 916   mColorPalette.push_back("SKY BLUE");
 917   mColorPalette.push_back("SLATE BLUE");
 918   mColorPalette.push_back("SPRING GREEN");
 919   mColorPalette.push_back("TAN");
 920   mColorPalette.push_back("THISTLE");
 921   mColorPalette.push_back("TURQUOISE");
 922   mColorPalette.push_back("VIOLET");
 923   mColorPalette.push_back("VIOLET RED");
 924   mColorPalette.push_back("WHEAT");
 925   mColorPalette.push_back("YELLOW");
 926   mColorPalette.push_back("YELLOW GREEN");
 927   mColorPalette.push_back("BLUE");
 928   mColorPalette.push_back("BLUE VIOLET");
 929   mColorPalette.push_back("BROWN");
 930   mColorPalette.push_back("CADET BLUE");
 931   mColorPalette.push_back("CORAL");
 932   mColorPalette.push_back("CORNFLOWER BLUE");
 933   mColorPalette.push_back("CYAN");
 934   mColorPalette.push_back("DARK GREY");
 935   mColorPalette.push_back("DARK GREEN");
 936   mColorPalette.push_back("DARK OLIVE GREEN");
 937   mColorPalette.push_back("DARK ORCHID");
 938   mColorPalette.push_back("DARK SLATE BLUE");
 939   mColorPalette.push_back("DARK SLATE GREY");
 940   mColorPalette.push_back("DARK TURQUOISE");
 941   mColorPalette.push_back("FIREBRICK");
 942   mColorPalette.push_back("FOREST GREEN");
 943   mColorPalette.push_back("GOLD");
 944   mColorPalette.push_back("GOLDENROD");
 945   mColorPalette.push_back("GREY");
 946   mColorPalette.push_back("GREEN");
 947   mColorPalette.push_back("GREEN YELLOW");
 948   mColorPalette.push_back("LIME GREEN");
 949   mColorPalette.push_back("MAGENTA");
 950   mColorPalette.push_back("MAROON");
 951   mColorPalette.push_back("MEDIUM AQUAMARINE");
 952   mColorPalette.push_back("MEDIUM BLUE");
 953   mColorPalette.push_back("MEDIUM GOLDENROD");
 954   mColorPalette.push_back("MEDIUM ORCHID");
 955   mColorPalette.push_back("MEDIUM SEA GREEN");
 956   mColorPalette.push_back("MEDIUM SLATE BLUE");
 957   mColorPalette.push_back("MEDIUM SPRING GREEN");
 958   mColorPalette.push_back("MEDIUM TURQUOISE");
 959   mColorPalette.push_back("MEDIUM VIOLET RED");
 960   mColorPalette.push_back("MIDNIGHT BLUE");
 961   mColorPalette.push_back("NAVY");
 962   mColorPalette.push_back("ORANGE RED");
 963   mColorPalette.push_back("ORCHID, PALE GREEN");
 964   mColorPalette.push_back("STEEL BLUE");
 965   mColorPalette.push_back("BLACK");
 966
 967
 968   }
 969   //================================================================
 970   BEGIN_EVENT_TABLE(WxTreeView, wxPanel)
 971   /*
 972     EVT_SIZE(MyFrame::OnSize)
 973
 974     EVT_MENU(LIST_QUIT, MyFrame::OnQuit)
 975     EVT_MENU(LIST_ABOUT, MyFrame::OnAbout)
 976     EVT_MENU(LIST_LIST_VIEW, MyFrame::OnListView)
 977     EVT_MENU(LIST_REPORT_VIEW, MyFrame::OnReportView)
 978     EVT_MENU(LIST_ICON_VIEW, MyFrame::OnIconView)
 979     EVT_MENU(LIST_ICON_TEXT_VIEW, MyFrame::OnIconTextView)
 980     EVT_MENU(LIST_SMALL_ICON_VIEW, MyFrame::OnSmallIconView)
 981     EVT_MENU(LIST_SMALL_ICON_TEXT_VIEW, MyFrame::OnSmallIconTextView)
 982     EVT_MENU(LIST_VIRTUAL_VIEW, MyFrame::OnVirtualView)
 983     EVT_MENU(LIST_SMALL_VIRTUAL_VIEW, MyFrame::OnSmallVirtualView)
 984
 985     EVT_MENU(LIST_FOCUS_LAST, MyFrame::OnFocusLast)
 986     EVT_MENU(LIST_TOGGLE_FIRST, MyFrame::OnToggleFirstSel)
 987     EVT_MENU(LIST_DESELECT_ALL, MyFrame::OnDeselectAll)
 988     EVT_MENU(LIST_SELECT_ALL, MyFrame::OnSelectAll)
 989     EVT_MENU(LIST_DELETE, MyFrame::OnDelete)
 990     EVT_MENU(LIST_ADD, MyFrame::OnAdd)
 991     EVT_MENU(LIST_EDIT, MyFrame::OnEdit)
 992     EVT_MENU(LIST_DELETE_ALL, MyFrame::OnDeleteAll)
 993     EVT_MENU(LIST_SORT, MyFrame::OnSort)
 994     EVT_MENU(LIST_SET_FG_COL, MyFrame::OnSetFgColour)
 995     EVT_MENU(LIST_SET_BG_COL, MyFrame::OnSetBgColour)
 996     EVT_MENU(LIST_TOGGLE_MULTI_SEL, MyFrame::OnToggleMultiSel)
 997     EVT_MENU(LIST_SHOW_COL_INFO, MyFrame::OnShowColInfo)
 998     EVT_MENU(LIST_SHOW_SEL_INFO, MyFrame::OnShowSelInfo)
 999     EVT_MENU(LIST_FREEZE, MyFrame::OnFreeze)
1000     EVT_MENU(LIST_THAW, MyFrame::OnThaw)
1001     EVT_MENU(LIST_TOGGLE_LINES, MyFrame::OnToggleLines)
1002     EVT_MENU(LIST_MAC_USE_GENERIC, MyFrame::OnToggleMacUseGeneric)
1003
1004     EVT_UPDATE_UI(LIST_SHOW_COL_INFO, MyFrame::OnUpdateShowColInfo)
1005     EVT_UPDATE_UI(LIST_TOGGLE_MULTI_SEL, MyFrame::OnUpdateToggleMultiSel)
1006 END_EVENT_TABLE()
1007
1008 BEGIN_EVENT_TABLE(MyListCtrl, wxListCtrl)
1009     EVT_LIST_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnBeginDrag)
1010     EVT_LIST_BEGIN_RDRAG(LIST_CTRL, MyListCtrl::OnBeginRDrag)
1011         */
1012     EVT_LIST_BEGIN_LABEL_EDIT(-1, WxTreeView::OnBeginLabelEdit)
1013     EVT_LIST_END_LABEL_EDIT(-1, WxTreeView::OnEndLabelEdit)
1014         /*
1015     EVT_LIST_DELETE_ITEM(LIST_CTRL, MyListCtrl::OnDeleteItem)
1016     EVT_LIST_DELETE_ALL_ITEMS(LIST_CTRL, MyListCtrl::OnDeleteAllItems)
1017 #if WXWIN_COMPATIBILITY_2_4
1018     EVT_LIST_GET_INFO(LIST_CTRL, MyListCtrl::OnGetInfo)
1019     EVT_LIST_SET_INFO(LIST_CTRL, MyListCtrl::OnSetInfo)
1020 #endif
1021   */
1022     EVT_LIST_ITEM_SELECTED(-1, WxTreeView::OnSelectedChanged)
1023
1024     EVT_LIST_ITEM_DESELECTED(-1, WxTreeView::OnSelectedChanged)
1025         /*
1026     EVT_LIST_KEY_DOWN(LIST_CTRL, MyListCtrl::OnListKeyDown)
1027     EVT_LIST_ITEM_ACTIVATED(LIST_CTRL, MyListCtrl::OnActivated)
1028     EVT_LIST_ITEM_FOCUSED(LIST_CTRL, MyListCtrl::OnFocused)
1029 */
1030     EVT_LIST_COL_RIGHT_CLICK(-1, WxTreeView::OnColClick)
1031
1032     EVT_LIST_COL_CLICK(-1, WxTreeView::OnColClick)
1033         /*
1034     EVT_LIST_COL_BEGIN_DRAG(LIST_CTRL, MyListCtrl::OnColBeginDrag)
1035     EVT_LIST_COL_DRAGGING(LIST_CTRL, MyListCtrl::OnColDragging)
1036     EVT_LIST_COL_END_DRAG(LIST_CTRL, MyListCtrl::OnColEndDrag)
1037
1038     EVT_LIST_CACHE_HINT(LIST_CTRL, MyListCtrl::OnCacheHint)
1039
1040 #if USE_CONTEXT_MENU
1041     EVT_CONTEXT_MENU(MyListCtrl::OnContextMenu)
1042 #endif
1043     EVT_CHAR(MyListCtrl::OnChar)
1044
1045     EVT_RIGHT_DOWN(MyListCtrl::OnRightClick)
1046   */
1047 END_EVENT_TABLE()
1048
1049 } // EO namespace creaImageIO
1050