src/levels__wndEditPanelOrder.cpp

   1 /*
   2  * levels__wndEditPanelOrder.cpp
   3  *
   4  *  Created on: 5 mai 2009
   5  *      Author: pat
   6  */
   7
   8 #include "wx/wxprec.h"
   9 #ifndef WX_PRECOMP
  10     #include "wx/wx.h"
  11 #endif
  12 #include <wx/dcbuffer.h>
  13
  14 #include "levels__sidesWindows.h"
  15 #include "levels__globals.h"
  16
  17
  18 const int max_img_size = 200;
  19 const int margins = 8;
  20 const int imgs_space = 5;
  21 const int margin_orderCtrl = 25;
  22
  23 //****************************************************
  24
  25 myWnd_EditPanelOrder::myWnd_EditPanelOrder( wxWindow* _parent, ob_stage* _stage )
  26 :wxDialog( _parent, wxID_ANY, wxT("Panel Order"), wxDefaultPosition, wxDefaultSize
  27                 ,wxMAXIMIZE_BOX | wxRESIZE_BORDER | wxDEFAULT_DIALOG_STYLE | wxFULL_REPAINT_ON_RESIZE )
  28 , font_Alphabet( 18, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD, true )
  29 , font_Label( 16, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxNORMAL, true )
  30 {
  31         ZeroInit();
  32         stage = _stage;
  33
  34         b_reverted_direction = false;
  35         b_rotate_imgs = false;
  36
  37 /*
  38         switch( stage->direction )
  39         {
  40                 case STAGE_DOWN:
  41                 case STAGE_OUT:
  42                 case STAGE_LEFT:
  43                         b_reverted_direction = true;
  44         }
  45
  46         switch( stage->direction )
  47         {
  48                 case STAGE_UP:
  49                 case STAGE_IN:
  50                 case STAGE_DOWN:
  51                 case STAGE_OUT:
  52                         b_rotate_imgs = true;
  53         }
  54 */
  55         Init();
  56 }
  57
  58
  59 void myWnd_EditPanelOrder::Init()
  60 {
  61         //*****************************
  62         // Pre-setup
  63         wxBoxSizer* sizer_wrapper = new wxBoxSizer( wxHORIZONTAL );
  64         thePanel = new wxScrolledWindow( this );
  65         thePanel->EnableScrolling( false, true );
  66         thePanel->SetScrollRate( 0, 20 );
  67         sizer_wrapper->Add( thePanel, 1, wxEXPAND | wxALL, 10 );
  68         wxBoxSizer* sizer_main = new wxBoxSizer( wxVERTICAL );
  69         thePanel->SetSizer( sizer_main );
  70
  71
  72
  73         //*****************************
  74         // SET the variables
  75         if( stage != NULL )
  76         {
  77                 l_panels = (ob_stage_panel**) stage->GetSubObjectS_ofType( OB_TYPE_STAGE_PANEL, nb_panels );
  78                 if( nb_panels == 0 )
  79                         ZeroInit();
  80                 else
  81                         curr_order = stage->Get_Panels_Order();
  82         }
  83
  84         // Stage == NULL
  85         if( stage == NULL )
  86         {
  87                 wxStaticText* t = new wxStaticText( thePanel, wxID_ANY, wxT("STAGE OBJECT == NULL !!"));
  88                 t->SetFont(font_Alphabet);
  89                 sizer_main->Add( t, 0, wxCENTER );
  90         }
  91
  92
  93         //*****************************
  94         // Set up the window
  95         else if( nb_panels <= 0 )
  96         {
  97                 wxStaticText* t = new wxStaticText( thePanel, wxID_ANY, wxT("NO PANELS DEFINED !!"));
  98                 t->SetFont(font_Alphabet);
  99                 sizer_main->Add( t, 0, wxCENTER );
 100         }
 101
 102         else
 103         {
 104                 wxBoxSizer* sizer_temp;
 105                 wxStaticText* t_stat;
 106
 107                 //*****************************
 108                 // Panel BGs List
 109
 110                 t_stat = new wxStaticText( thePanel, wxID_ANY, wxT("Avalaible panels"),
 111                                 wxDefaultPosition, wxDefaultSize );
 112                 t_stat->SetFont( font_Label );
 113                 sizer_main->Add( t_stat, 0, wxALL, margins );
 114
 115
 116                 wxBoxSizer* sizerWrapper_panel_BGs = new wxBoxSizer( wxVERTICAL );
 117                 AScrollPanel *panel_BGs = new AScrollPanel( thePanel );
 118 //              panel_BGs->SetBackgroundColour( *wxWHITE );
 119                 wxBoxSizer* panel_BGs_sizer = new wxBoxSizer( wxHORIZONTAL );
 120                 panel_BGs->SetSizer( panel_BGs_sizer );
 121                 panel_BGs->SetMinSize( wxSize(60, 60) );
 122                 panel_BGs->Set_FixedDirections( false, true );
 123                 sizerWrapper_panel_BGs->Add(panel_BGs, 1, wxEXPAND );
 124                 sizer_main->Add( sizerWrapper_panel_BGs, 0, wxEXPAND );
 125
 126                 for( size_t i = 0; i < nb_panels; i++ )
 127                 {
 128                         sizer_temp = new wxBoxSizer( wxVERTICAL );
 129
 130                         MyImageCtrl* t_imgctrl = new MyImageCtrl( panel_BGs );
 131                         t_imgctrl->Set_BoundDimensions( max_img_size, max_img_size );
 132                         t_imgctrl->SetImage( l_panels[i]->GetImage() );
 133                         sizer_temp->Add( t_imgctrl, 0, wxALL, imgs_space );
 134
 135                         t_stat = new wxStaticText( panel_BGs, wxID_ANY, l_panels[i]->GetName() );
 136                         sizer_temp->Add( t_stat, 0, wxCENTER |wxALL, imgs_space );
 137                         panel_BGs_sizer->Add( sizer_temp, 0, wxEXPAND |wxALL, imgs_space );
 138
 139                         t_stat = new wxStaticText( panel_BGs, wxID_ANY, wxChar( 'a' + i ),
 140                                         wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE);
 141                         t_stat->SetFont( font_Alphabet );
 142                         t_stat->SetMinSize( wxSize( 40, wxDefaultCoord ));
 143                         sizer_temp->Add( t_stat , 0, wxCENTER |wxALL, 5);
 144
 145                 }
 146
 147
 148                 //*****************************
 149                 // ADD the control Text of the order
 150                 sizer_temp = new wxBoxSizer( wxHORIZONTAL );
 151                 t_stat = new wxStaticText( thePanel, wxID_ANY, wxT("Order\n(Use arrow Keys)") );
 152                 sizer_temp->Add( t_stat, 0, wxCENTER );
 153                 txtCtrl_order = new wxTextCtrl( thePanel, wxID_ANY, wxString(),
 154                                 wxDefaultPosition, wxDefaultSize, 0,
 155                                 wxValidator_Restrict_Range( 'a', wxChar( 'a' + nb_panels - 1 ) ) );
 156                 txtCtrl_order->Connect( wxEVT_KEY_UP , wxKeyEventHandler(myWnd_EditPanelOrder::Evt_Order_KeyPress), NULL, this);
 157                 txtCtrl_order->Connect( wxEVT_COMMAND_TEXT_UPDATED , wxCommandEventHandler(myWnd_EditPanelOrder::Evt_Order_Changed), NULL, this);
 158 /*              txtCtrl_order->Connect( wxEVT_LEFT_UP , wxMouseEventHandler(myWnd_EditPanelOrder::Evt_Order_Mouse_In), NULL, this);
 159 */
 160                 sizer_temp->Add( txtCtrl_order, 1, wxCENTER|wxTOP|wxBOTTOM|wxEXPAND, margin_orderCtrl );
 161
 162                 sizer_main->Add( sizer_temp, 0, wxEXPAND );
 163
 164                 //Init the order
 165 /*              // No order, make a initial one
 166                 if( curr_order == wxString() )
 167                 {
 168                         for( size_t i =0; i < nb_panels; i++ )
 169                                 curr_order += wxChar( 'a' + i );
 170 //                      stage->Add_SubObj( new ob_object( "order", curr_order ) );
 171                 }*/
 172                 txtCtrl_order->ChangeValue( curr_order );
 173
 174
 175                 //*****************************
 176                 // ADD the view of the order
 177                 t_stat = new wxStaticText( thePanel, wxID_ANY, wxT("Order view"),
 178                                 wxDefaultPosition, wxDefaultSize );
 179                 t_stat->SetFont( font_Label );
 180                 sizer_main->Add( t_stat, 0, wxALL, margins );
 181
 182                 wxBoxSizer* sizerWrapper_stage_view = new wxBoxSizer( wxVERTICAL );
 183                 panel_stage_view = new AScrollPanel( thePanel );
 184                 panel_stage_view->SetMinSize( wxSize(100, 100) );
 185                 panel_stage_view->Set_FixedDirections( false, true );
 186                 panel_stage_view->SetBackgroundStyle( wxBG_STYLE_CUSTOM );
 187 //              panel_stage_view->SetBackgroundColour( *wxWHITE );
 188                 panel_stage_view->Connect( wxEVT_PAINT, wxPaintEventHandler(myWnd_EditPanelOrder::Evt_Paint_PanelView), NULL, this);
 189                 sizerWrapper_stage_view->Add(panel_stage_view, 1, wxEXPAND );
 190                 wxBoxSizer* panel_stage_view_sizer = new wxBoxSizer( wxHORIZONTAL );
 191                 panel_stage_view->SetSizer( panel_stage_view_sizer );
 192                 sizer_main->Add( sizerWrapper_stage_view, 0, wxEXPAND );
 193
 194                 img_ctrl_list = NULL;
 195                 img_ctrl_list_count = 0;
 196                 Update_PanelsView();
 197
 198
 199                 //*****************************
 200                 // ADD the OK/CANCEL buttons
 201                 sizer_temp = new wxBoxSizer( wxHORIZONTAL );
 202
 203                 sizer_temp->AddStretchSpacer();
 204
 205                 wxButton* t_butt = new wxButton( thePanel, wxID_ANY, wxT("OK") );
 206                 t_butt->Connect( wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEventHandler(myWnd_EditPanelOrder::Evt_Click_OK), NULL, this);
 207                 sizer_temp->Add( t_butt );
 208
 209                 sizer_temp->AddSpacer( 30 );
 210
 211                 t_butt = new wxButton( thePanel, wxID_ANY, wxT("CANCEL" ));
 212                 t_butt->Connect( wxEVT_COMMAND_BUTTON_CLICKED , wxCommandEventHandler(myWnd_EditPanelOrder::Evt_Click_CANCEL), NULL, this);
 213                 sizer_temp->Add( t_butt );
 214
 215                 sizer_temp->AddStretchSpacer();
 216
 217                 sizer_main->Add( sizer_temp, 0, wxEXPAND | wxTOP, 15);
 218         }
 219
 220         SetSizer( sizer_wrapper );
 221         Show();
 222         Frame_RestorePrevCoord( this, wxT("Panels_Ordering" ));
 223 }
 224
 225
 226 //****************************************************
 227
 228 void myWnd_EditPanelOrder::ZeroInit()
 229 {
 230         stage = NULL;
 231         nb_panels = 0;
 232         l_panels = NULL;
 233         orders = NULL;
 234         b_chg = false;
 235         panel_cursor_x = -1;
 236         img_ctrl_list = NULL;
 237         img_ctrl_list_count = 0;
 238         tay_panels_map = 0;
 239         panels_map = NULL;
 240 }
 241
 242 //****************************************************
 243
 244 void myWnd_EditPanelOrder::EvtClose( wxCloseEvent& event )
 245 {
 246         Frame_SaveCoord( this, wxT("Panels_Ordering" ));
 247         event.Skip();
 248 }
 249
 250
 251 //****************************************************
 252
 253 myWnd_EditPanelOrder::~myWnd_EditPanelOrder()
 254 {
 255         if( l_panels != NULL )
 256                 delete[] l_panels;
 257 }
 258
 259
 260 //****************************************************
 261
 262 void myWnd_EditPanelOrder::EvtSize( wxSizeEvent& evt )
 263 {
 264         wxSize s = thePanel->GetClientSize();
 265         int max_x = s.x - 20;
 266         if( max_x <= 10 )
 267                 max_x = 10;
 268         thePanel->SetVirtualSizeHints(60,60, max_x, -1 );
 269 //      SetSize( wxSize( s.x, wxDefaultCoord ) );
 270         thePanel->Layout();
 271         evt.Skip();
 272 }
 273
 274
 275 //****************************************************
 276
 277 void myWnd_EditPanelOrder::Evt_Click_OK( wxCommandEvent& evt )
 278 {
 279         if( stage != NULL )
 280         {
 281                 wxString old_order = stage->Get_Panels_Order();
 282                 if( curr_order != old_order )
 283                 {
 284                         b_chg = true;
 285                         orders = stage->GetSubObjectS( wxT("order"), nb_orders );
 286
 287                         if( orders == NULL )
 288                         {
 289                                 orders = new ob_object*[1];
 290                                 orders[0] = new ob_object( wxT("order") );
 291                                 nb_orders = 1;
 292                                 stage->Add_SubObj( orders[0] );
 293                         }
 294
 295                         size_t curr_ind = 0;
 296                         ob_object* last_obj = orders[nb_orders-1];
 297                         while( curr_order.Len() > 0 )
 298                         {
 299                                 ob_object* o;
 300                                 if( curr_ind >= nb_orders )
 301                                 {
 302                                         o = new ob_object(wxT("order" ));
 303                                         last_obj->InsertObject_After( o );
 304                                 }
 305                                 else
 306                                         o = orders[curr_ind];
 307
 308                                 if( curr_order.Len() <= 26 )
 309                                 {
 310                                         o->SetToken( 0, curr_order );
 311                                         curr_ind++;
 312                                         break;
 313                                 }
 314
 315                                 o->SetToken( 0, curr_order.Left(26) );
 316                                 curr_order = curr_order.Right(curr_order.Len()-26);
 317                                 curr_ind++;
 318                         }
 319
 320                         // Remove unused orders objects
 321                         for( size_t i = curr_ind; i < nb_orders; i++ )
 322                                 delete orders[i];
 323
 324                         delete[] orders;
 325                         orders = NULL;
 326
 327
 328 /*                      // Debug panel_map
 329                         if( false && panels_map != NULL )
 330                         {
 331                                 wxString str_panelmap = "[";
 332                                 for( int i = 0; i< tay_panels_map; i++)
 333                                 {
 334                                         str_panelmap += IntToStr( panels_map[i] ) + ",";
 335                                 }
 336                                 str_panelmap = str_panelmap.Mid(0, str_panelmap.Len() -1 );
 337                                 str_panelmap += "]";
 338
 339                                 wxMessageBox( "Panels Map :\n" + str_panelmap );
 340                         }*/
 341                 }
 342         }
 343         Close();
 344 }
 345
 346
 347 //****************************************************
 348
 349 void myWnd_EditPanelOrder::Evt_Click_CANCEL( wxCommandEvent& evt )
 350 {
 351 //      Update_PanelsView();
 352         Close();
 353 }
 354
 355
 356 //****************************************************
 357
 358 void myWnd_EditPanelOrder::Evt_Click_OrderElt( wxMouseEvent& evt )
 359 {
 360         int id = evt.GetId() - wxID_HIGHEST;
 361         if( b_reverted_direction )
 362                 id = curr_order.Len() - id - 1;
 363         txtCtrl_order->SetInsertionPoint( id );
 364         UpdateInsertPoint();
 365         evt.Skip();
 366 }
 367
 368
 369 //****************************************************
 370
 371 void myWnd_EditPanelOrder::Evt_Order_Mouse_In( wxMouseEvent& evt )
 372 {
 373         //int id = txtCtrl_order->GetInsertionPoint();
 374         txtCtrl_order->SetSelection( curr_ind, curr_ind );
 375         txtCtrl_order->SetInsertionPoint( curr_ind );
 376         txtCtrl_order->Update();
 377         UpdateInsertPoint();
 378 }
 379
 380
 381 //****************************************************
 382
 383 void myWnd_EditPanelOrder::Evt_Order_KeyPress( wxKeyEvent& evt )
 384 {
 385         UpdateInsertPoint();
 386         evt.Skip();
 387 }
 388
 389
 390 //****************************************************
 391
 392 void myWnd_EditPanelOrder::Evt_Order_Changed( wxCommandEvent& evt )
 393 {
 394         wxString new_order = txtCtrl_order->GetValue();
 395         if( new_order != curr_order )
 396         {
 397                 bool b_accept_change = true;
 398
 399                 // Find the change
 400                         // Insertion case
 401                         if( curr_order.Len() < new_order.Len() )
 402                         {
 403                                 int ind_change = -1;
 404                                 for( size_t i =0; i < curr_order.Len();i++)
 405                                 {
 406                                         if( curr_order[i] != new_order[i] )
 407                                         {
 408                                                 ind_change = i;
 409                                                 i = curr_order.Len();
 410                                         }
 411                                 }
 412
 413                                 // have to handle the clones char case
 414                                 if( ind_change > 0 && new_order[ind_change] == new_order[ind_change -1] )
 415                                 {
 416                                         // get insertion point
 417                                         long i = txtCtrl_order->GetInsertionPoint();
 418                                         if( i >= 0 )
 419                                                 ind_change = (int) i;
 420                                 }
 421
 422                                 // Found the change
 423                                 if( ind_change != -1 )
 424                                 {
 425                                         // Check that everything is really unchanged after the mod
 426                                         bool b_no_change_after = true;
 427                                         for( size_t i = ind_change; i < curr_order.Len();i++ )
 428                                         {
 429                                                 if( new_order[i+1] != curr_order[i] )
 430                                                 {
 431                                                         b_no_change_after = false;
 432                                                         i = curr_order.Len();
 433                                                 }
 434                                         }
 435
 436                                         if( ! b_no_change_after )
 437                                         {
 438                                                 wxMessageBox( wxT("More than one change at one time can't be handled !!\nChange after case...") );
 439                                                 b_accept_change = false;
 440                                         }
 441                                         else
 442                                         {
 443                                                 //Get the ind in map for the lower changed panel
 444                                                 int ind_in_map = -1;
 445                                                 for( int i = 0; i < tay_panels_map; i++ )
 446                                                 {
 447                                                         if( panels_map[i] >= ind_change )
 448                                                         {
 449                                                                 ind_in_map = i;
 450                                                                 i = tay_panels_map;
 451                                                         }
 452                                                 }
 453
 454                                                 if( ind_in_map == -1 )
 455                                                 {
 456                                                         wxMessageBox( wxT("BUG ??\nNo indice in map found for the insertion !!!") );
 457                                                         b_accept_change = false;
 458                                                 }
 459                                                 else
 460                                                 {
 461                                                         //must remap all the upper indices to indices +1
 462                                                         for( int i= ind_in_map; i < tay_panels_map; i++ )
 463                                                         {
 464                                                                 // except if the panel have been deleted
 465                                                                 if( panels_map[i] != -1 )
 466                                                                         panels_map[i] = panels_map[i] + 1;
 467                                                         }
 468                                                 }
 469                                         }
 470                                 }
 471
 472                                 // Insertion after the old order -> ok
 473                                 else
 474                                 {
 475                                 }
 476                         }
 477
 478                         // Suppression case
 479                         else if( curr_order.Len() > new_order.Len() )
 480                         {
 481                                 int ind_change = -1;
 482                                 for( size_t i =0; i < new_order.Len(); i++)
 483                                 {
 484                                         if( curr_order[i] != new_order[i] )
 485                                         {
 486                                                 ind_change = i;
 487                                                 i = curr_order.Len();
 488                                         }
 489                                 }
 490
 491                                 // Found the change
 492                                 if( ind_change != -1 )
 493                                 {
 494                                         // Check that everything is really unchanged after the mod
 495                                         bool b_no_change_after = true;
 496                                         for( size_t i = ind_change; i < new_order.Len();i++ )
 497                                         {
 498                                                 if( new_order[i] != curr_order[i+1] )
 499                                                 {
 500                                                         b_no_change_after = false;
 501                                                         i = curr_order.Len();
 502                                                 }
 503                                         }
 504
 505                                         if( ! b_no_change_after )
 506                                         {
 507                                                 wxMessageBox( wxT("More than one change at one time can't be handled !!\nChange after case...") );
 508                                                 b_accept_change = false;
 509                                         }
 510                                         else
 511                                         {
 512                                                 //Get the ind in map for the lower changed panel
 513                                                 int ind_in_map = -1;
 514                                                 bool b_suppress_original = false;
 515                                                 for( int i = 0; i < tay_panels_map; i++ )
 516                                                 {
 517                                                         if( panels_map[i] >= ind_change )
 518                                                         {
 519                                                                 if( panels_map[i] == ind_change )
 520                                                                         b_suppress_original = true;
 521                                                                 ind_in_map = i;
 522                                                                 i = tay_panels_map;
 523                                                         }
 524                                                 }
 525
 526                                                 // Problem
 527                                                 if( ind_in_map == -1 )
 528                                                 {
 529                                                         wxMessageBox( wxT("BUG ??\nNo indice in map found for the suppression !!!" ));
 530                                                         b_accept_change = false;
 531                                                 }
 532
 533                                                 // normal situation
 534                                                 else
 535                                                 {
 536                                                         //must remap all the upper indices to indices -1
 537                                                         for( int i= ind_in_map; i < tay_panels_map; i++ )
 538                                                         {
 539                                                                 // except if the panel have been deleted
 540                                                                 if( panels_map[i] != -1 )
 541                                                                         panels_map[i] = panels_map[i] - 1;
 542                                                         }
 543
 544                                                         // Must Set "delete" to the ind_of_change
 545                                                         if( b_suppress_original )
 546                                                                 panels_map[ind_in_map] = -1;
 547                                                 }
 548                                         }
 549                                 }
 550
 551                                 // End char Suppressed
 552                                 else
 553                                 {
 554                                         for( int i = tay_panels_map-1; i >= 0; i-- )
 555                                         {
 556                                                 if( (size_t) panels_map[i] >= new_order.Len() )
 557                                                         panels_map[i] = -1;
 558                                         }
 559                                 }
 560                         }
 561
 562                         // Replacement case
 563                         else
 564                         {
 565                                 // Check that there is only one change
 566                                 int ind_change = -1;
 567                                 for( size_t i = 0; i < curr_order.Len(); i++)
 568                                 {
 569                                         if( curr_order[i] != new_order[i] )
 570                                         {
 571                                                 if( ind_change == -1 && ind_change != -2 )
 572                                                 {
 573                                                         ind_change = i;
 574                                                 }
 575                                                 else
 576                                                 {
 577                                                         ind_change = -2;
 578                                                         i = curr_order.Len();
 579                                                 }
 580                                         }
 581                                 }
 582
 583                                 // Too much changes
 584                                 if( ind_change == -2 )
 585                                 {
 586                                         wxMessageBox( wxT("More than one change at one time can't be handled !!\nChange after case..." ));
 587                                         b_accept_change = false;
 588                                 }
 589
 590                                 // one change -> must update the map
 591                                 else if( ind_change >= 0 )
 592                                 {
 593                                         //Get the ind in map for the changed panel
 594                                         int ind_in_map = -1;
 595                                         for( int i = 0; i < tay_panels_map; i++ )
 596                                         {
 597                                                 if( panels_map[i] == ind_change )
 598                                                 {
 599                                                         ind_in_map = i;
 600                                                         i = tay_panels_map;
 601                                                 }
 602                                         }
 603
 604                                         if( ind_in_map != -1 )
 605                                         {
 606                                                 // the changed panel implie deletion of the older
 607                                                 panels_map[ind_in_map] = -1;
 608                                         }
 609                                 }
 610                         }
 611                         // END update the map
 612
 613                 // Update the panel map
 614                 if( b_accept_change )
 615                 {
 616                         curr_order = new_order;
 617                         Update_PanelsView();
 618                 }
 619                 else
 620                 {
 621                         txtCtrl_order->ChangeValue( curr_order );
 622                 }
 623         }
 624
 625         UpdateInsertPoint();
 626         evt.Skip();
 627 }
 628
 629
 630 //****************************************************
 631
 632 void myWnd_EditPanelOrder::Evt_Paint_PanelView( wxPaintEvent& evt )
 633 {
 634         wxAutoBufferedPaintDC dc( panel_stage_view );
 635         panel_stage_view->DoPrepareDC( dc );
 636 //      dc.SetBackground( *wxWHITE_BRUSH );
 637         dc.Clear();
 638
 639         if( panel_cursor_x <= 0 )
 640                 return;
 641
 642         wxSize s = panel_stage_view->GetSize();
 643         dc.SetBrush( *wxRED_BRUSH );
 644 //      int dummy = 0;
 645 //      panel_stage_view->CalcScrolledPosition( panel_cursor_x, dummy, &panel_cursor_x, &dummy );
 646                 dc.DrawRectangle(  panel_cursor_x, 5, 4, s.y - 10 );
 647 }
 648
 649
 650 //****************************************************
 651
 652 void myWnd_EditPanelOrder::UpdateInsertPoint()
 653 {
 654         //Get the current insertion point
 655         curr_ind = txtCtrl_order->GetInsertionPoint();
 656         MoveImagesCursor( curr_ind );
 657 }
 658
 659
 660 //****************************************************
 661
 662 int myWnd_EditPanelOrder::Get_OrderElt_X( int ind)
 663 {
 664         if( ind >= img_ctrl_list_count || ind < 0 )
 665                 return -1;
 666
 667         wxPoint p = img_ctrl_list[ind]->GetPosition();
 668         panel_stage_view->CalcUnscrolledPosition( p.x, p.y, &p.x, &p.y );
 669
 670         return p.x;
 671 }
 672
 673
 674 //****************************************************
 675
 676 const int dec_cursor = 3;
 677 void myWnd_EditPanelOrder::MoveImagesCursor( long i )
 678 {
 679         panel_cursor_x = 0;
 680         int scrollU_x, scrollU_y;
 681         int scroll_pos;
 682         panel_stage_view->GetScrollPixelsPerUnit(&scrollU_x, &scrollU_y);
 683         wxSize v_s =    panel_stage_view->GetVirtualSize();
 684         wxSize r_s =    panel_stage_view->GetSize();
 685
 686         if( b_reverted_direction )
 687                 i = curr_order.Len() - i;
 688
 689         if( curr_order.Len() <= 0 || (size_t) i >= curr_order.Len() )
 690         {
 691                 panel_cursor_x = -30;
 692                 scroll_pos = v_s.x / scrollU_x;
 693         }
 694         else if( i == 0 )
 695         {
 696                 panel_cursor_x = -30;
 697                 scroll_pos = 0;
 698         }
 699         else
 700         {
 701                 panel_cursor_x = Get_OrderElt_X( i ) - dec_cursor * 2.5;
 702                 scroll_pos = panel_cursor_x - r_s.x / 2;
 703                 if( scroll_pos < 0)
 704                         scroll_pos = 0;
 705         }
 706
 707         panel_stage_view->Scroll( scroll_pos / scrollU_x, -1 );
 708         panel_stage_view->Refresh();
 709 //      wxSizeEvent dummy;
 710 //      panel_stage_view->EvtSize( dummy );
 711 }
 712
 713
 714 //****************************************************
 715
 716 void myWnd_EditPanelOrder::Update_PanelsView()
 717 {
 718         wxSizer* panel_stage_view_sizer = panel_stage_view->GetSizer();
 719         panel_stage_view->Freeze();
 720
 721         // Remove old images ctrls
 722         if( img_ctrl_list != NULL )
 723         {
 724                 delete[] img_ctrl_list;
 725                 img_ctrl_list = NULL;
 726                 img_ctrl_list_count = 0;
 727         }
 728
 729         wxString order;
 730         size_t max_letter = (size_t) ('a' + nb_panels );
 731         for( size_t i = 0; i < curr_order.Len(); i++ )
 732         {
 733                 size_t curr_letter = (size_t) curr_order[i];
 734                 if( curr_letter >= (size_t) 'a' && curr_letter < max_letter )
 735                         order += curr_order[i];
 736         }
 737
 738         if( order.Len() > 0)
 739         {
 740                 img_ctrl_list = new MyImageCtrl*[order.Len()];
 741                 img_ctrl_list_count = order.Len();
 742         }
 743
 744         panel_stage_view_sizer->Clear( true );
 745
 746         for( size_t i = 0; i < order.Len(); i++ )
 747         {
 748                 wxBoxSizer* sizer_temp = new wxBoxSizer( wxVERTICAL );
 749
 750                 MyImageCtrl* t_imgctrl = new MyImageCtrl( panel_stage_view );
 751
 752                 // With vertical Levels  ==>>  rotate the stuff
 753                 if( b_rotate_imgs == true )
 754                         t_imgctrl->Rotate90( 3 );
 755                 int ind = b_reverted_direction ? order.Len() - i - 1 : i;
 756
 757                 t_imgctrl->SetId( wxID_HIGHEST + i );
 758                 t_imgctrl->Set_BoundDimensions( max_img_size, max_img_size );
 759                 t_imgctrl->SetImage( l_panels[order[ind]-'a']->GetImage() );
 760                 t_imgctrl->Connect( wxEVT_LEFT_UP, wxMouseEventHandler(myWnd_EditPanelOrder::Evt_Click_OrderElt), NULL, this);
 761                 sizer_temp->Add( t_imgctrl, 0, wxALL, 1 );
 762                 img_ctrl_list[i] = t_imgctrl;
 763
 764                 wxStaticText* t_stat = new wxStaticText( panel_stage_view, wxID_ANY, wxChar( order[ind] ),
 765                                 wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE);
 766                 t_stat->SetFont( font_Alphabet );
 767                 t_stat->SetMinSize( wxSize( 40, wxDefaultCoord ));
 768                 sizer_temp->Add( t_stat , 0, wxCENTER |wxALL, 1 );
 769
 770                 panel_stage_view_sizer->Add( sizer_temp, 0, wxEXPAND |wxALL, imgs_space );
 771         }
 772
 773         panel_stage_view->Layout();
 774         wxSizeEvent dummy;
 775         panel_stage_view->EvtSize(dummy );
 776
 777         UpdateInsertPoint();
 778         panel_stage_view->Thaw();
 779         panel_stage_view->Refresh();
 780 }
 781
 782
 783 //****************************************************
 784 //****************************************************
 785 //****************************************************
 786 //****************************************************
 787 //****************************************************
 788 // Event table
 789 BEGIN_EVENT_TABLE(myWnd_EditPanelOrder, wxDialog)
 790         EVT_CLOSE(myWnd_EditPanelOrder::EvtClose)
 791         EVT_SIZE(myWnd_EditPanelOrder::EvtSize)
 792 //      EVT_PAINT(myWnd_EditPanelOrder::Evt_Paint_PanelView)
 793 END_EVENT_TABLE()