wxInstantChooserPanel.cxx

Go to the documentation of this file.

//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------
#include "wxInstantChooserPanel.h"
#include "wxContourMainFrame.h"

//Test JCP 13-10-08
//#include "wxContourEventHandler.h"
//Test JCP 13-10-08

//----------------------------------------------------------------------------------------------------------------
// Class implementation
//----------------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------------
// Throwed Events definition
//----------------------------------------------------------------------------------------------------------------


DEFINE_EVENT_TYPE( wxINSTANT_CHOOSER_CHANGE )
        


        //------------------------------------------------------------------------------------------------------------
        // Constructors & Destructors
        //------------------------------------------------------------------------------------------------------------
        


        wxInstantChooserPanel :: wxInstantChooserPanel (wxWindow * parent, std::string title, bool theOrientation, bool resolutionALL,std::string configurationElem, std::string groupConfig )
        :wxPanel(parent, -1, wxPoint(20,20), wxDefaultSize, wxTAB_TRAVERSAL)
        {
                _lastConceptUpdated = NULL;             
                _concepts = new std::vector<wxConceptControl*>();
                _resolutionOverALL = resolutionALL;
                _configuration = configurationElem;
                //--- groupConfig -> format: ("## ## # ## "), #:any positive integer number, : space needed between the numbers and at the end of the string.
                setVerticalMaxSelectedNums( groupConfig );
                
                //_configuration = "CCCc";
                //setVerticalMaxSelectedNums( "1 2 3 3 ");//groupConfig );

                SetSize(300,300);
                _outSizer = new wxFlexGridSizer ( 1, 10, 10);
                _orientation = theOrientation;
                initializeResolutionSlider();
                _actualInstant=new std::map<std::string,int>();
                
                wxFlexGridSizer * resolutionSizer = new wxFlexGridSizer( 3,1,10,10 );
                resolutionSizer->AddSpacer(10);
                resolutionSizer->Add( _resolutionSlider, 1, wxEXPAND | wxGROW );
                resolutionSizer->AddSpacer(10);
                
                wxFlexGridSizer * sizer = new wxFlexGridSizer( 1,2,10,10 );
                sizer->Add( _outSizer, 1, wxEXPAND| wxGROW );
                sizer->Add( resolutionSizer, 1, wxEXPAND | wxGROW );
                SetSizer( sizer );
                Connect( wxID_ANY,  wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxInstantChooserPanel:: onCheckBoxClicked );               

        }

        wxInstantChooserPanel ::wxInstantChooserPanel (wxWindow * parent,wxWindowID id ,std::string title, const wxPoint& pos, const wxSize& size , bool theOrientation, std::string configurationElem , std::string groupConfig  )
                :wxPanel(parent, id ,pos, size) 
        {
                _lastConceptUpdated = NULL;             
                _concepts = new std::vector<wxConceptControl*>();
                _resolutionOverALL = false;
                _configuration = configurationElem;
                //--- groupConfig -> format: ("## ## # ## "), #:any positive integer number, : space needed between the numbers and at the end of the string.
                setVerticalMaxSelectedNums( groupConfig );
                
                SetSize(size);
                _outSizer = new wxFlexGridSizer ( 1, 10, 10);
                _orientation = theOrientation;
                initializeResolutionSlider();
                _actualInstant=new std::map<std::string,int>();
                wxFlexGridSizer * sizer = new wxFlexGridSizer( 1,2,10,10 );
                sizer->Add( _outSizer, 1, wxEXPAND| wxGROW );
                sizer->Add( _resolutionSlider, 1, wxEXPAND | wxGROW );
                SetSizer( sizer );
                Connect( wxID_ANY,  wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxInstantChooserPanel:: onCheckBoxClicked );               
        }

        wxInstantChooserPanel :: ~wxInstantChooserPanel()
        {
                int size,i;
                //deleting the _concepts
                if(_concepts!=NULL)
                {
                        size=_concepts->size();
                        for(i=0; i< size ; i++)
                                {
                                        delete (*_concepts)[i];
                                }
                        _concepts->clear();
                }
                _verticalMaxSelected.clear();
                //deleting the actual instant
                _actualInstant->clear();
        }

        //------------------------------------------------------------------------------------------------------------
        // Creational and initialization methods
        //------------------------------------------------------------------------------------------------------------
        
        void wxInstantChooserPanel :: addConcept(std::string aConceptName, int minV, int maxV, int actualV)
        {
                wxConceptControl * nwConcept = new wxConceptControl(this, _orientation, minV, maxV, actualV, aConceptName, _configuration);
                _concepts->push_back( nwConcept );
                _lastConceptUpdated = nwConcept;
                _outSizer->Add(nwConcept, wxEXPAND);
                Connect(nwConcept->GetId(), wxEVT_CONCEPT_RELEASE, (wxObjectEventFunction) (wxCommandEventFunction)  &wxInstantChooserPanel::onConceptRelease );
        }

        void wxInstantChooserPanel :: setWxEventHandler( wxEvtHandler * theEventHandler )
        {
                _eventHandler = theEventHandler;
        }

        //------------------------------------------------------------------------------------------------------------
        // Methods for capturing events
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: onResolutionSlider(wxScrollEvent& event)
        {
                std::string lasConcept = _lastConceptUpdated->getName();
                int value = _lastConceptUpdated->getActualValue();
                int min = _lastConceptUpdated->getMinValue();
                int max = _lastConceptUpdated->getMaxValue();
                int delta = (int) (pow((double) 2, _resolutionSlider->GetValue() ));
                int minTmp   = value - delta/2;
                int maxTmp   = value + delta/2;
                if (minTmp<min)
                        {
                                minTmp = min;   
                        }
                if (maxTmp>max)
                        {
                                maxTmp = max;
                        }                       
                _lastConceptUpdated->setRange( minTmp,maxTmp );

                if (! _resolutionOverALL)
                {
                        changeResolutionAtConceptControl( _lastConceptUpdated );
                }
                else
                {
                        for(int i=0; i< (int)(_concepts->size()); i++)
                        {
                                changeResolutionAtConceptControl( (*_concepts)[i] );
                        }
                }               

        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: onCheckBoxClicked( wxCommandEvent& event )
        {
                /*int groupID = (int)event.GetClientData();
                wxConceptControl * eventConcept = (wxConceptControl *)event.GetEventObject();
                if ( eventConcept->getIfChecked( groupID ) )
                {
                        int i,size = _concepts->size();
                        wxConceptControl * aConcept = NULL;
                        int accum = 0;          
                        for( i=0; i<size; i++)
                        {
                                accum+= (*_concepts)[i]->getIfChecked( groupID ) ? 1 :0;
                        }               
                        for( i=0; i<size && _verticalMaxSelected[groupID] < accum; i++)
                        {
                                aConcept = (*_concepts)[i]; 
                                if( aConcept!= eventConcept )
                                {
                                        if( aConcept->getIfChecked( groupID ) )
                                        {       
                                                aConcept->clearCheckAt( groupID );
                                                accum--;
                                        }                                       
                                }
                        }                                       
                }*/

                int groupID = *(int*)event.GetClientData();
                wxConceptControl * eventConcept = (wxConceptControl *)event.GetEventObject();
                if ( eventConcept->getIfChecked( groupID ) )
                {
                        int size = _concepts->size();
                        wxConceptControl * aConcept = NULL;
//                      int accum = 0;

                        for(int i = 0; i < eventConcept->getNumCheckBox();i++){
                                if(i!=groupID){
                                        eventConcept->clearCheckAt(i);
                                }
                        }
                        for(int i=0; i<size; i++)
                        {
                                aConcept = (*_concepts)[i]; 
                                if( aConcept!= eventConcept )
                                {
                                        if( aConcept->getIfChecked( groupID ) )
                                        {       
                                                aConcept->clearCheckAt( groupID );
                                        }                                       
                                }
                        }                       
                }
        }

        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: onConceptRelease( wxCommandEvent& event )
        {
                _lastConceptUpdated = (wxConceptControl*) event.GetEventObject();

                std::vector<int> theInstant;
        getInstant( theInstant );
                //-------------------------------------------------
                //  Sending the event of wxINSTANT_CHOOSER_CHANGE
                //-------------------------------------------------
                wxCommandEvent newevent(wxINSTANT_CHOOSER_CHANGE,GetId());  
                //this->onChangeInstant(newevent);
                ConceptDataWrap * dataConcept = getLastConceptData(); 
                if(getIfConceptCheckedAt( dataConcept->getName(), 0 )){
                        wxContourMainFrame::getInstance()->onChangeInstantInstantPanel(dataConcept->getName(), dataConcept->getActualValue(), dataConcept->getMinShowedValue(), dataConcept->getMaxShowedValue());
                }
                //((wxContourEventHandler*)_eventHandler)->onChangeInstant(newevent);
                //_eventHandler->ProcessEvent(newevent);
        }

        void wxInstantChooserPanel :: onChangeInstant( wxCommandEvent& event ){
                
        }

        //------------------------------------------------------------------------------------------------------------
        //  Methods for sending events
        //------------------------------------------------------------------------------------------------------------

        //------------------------------------------------------------------------------------------------------------
        //  Attributes getters and setters
        //------------------------------------------------------------------------------------------------------------
                
        ConceptDataWrap * wxInstantChooserPanel :: getLastConceptData()
        {
                ConceptDataWrap * conceptData = new ConceptDataWrap();
                if( _lastConceptUpdated != NULL)
                {
                        conceptData -> fillData( _lastConceptUpdated->getName(), _lastConceptUpdated->getMinValue(), _lastConceptUpdated->getMaxValue(), _lastConceptUpdated->getMinShowedValue(), _lastConceptUpdated->getMaxShowedValue(), _lastConceptUpdated->getActualValue());
                }
                return conceptData;
        }

        //------------------------------------------------------------------------------------------------------------
        //  Other functional methods
        //------------------------------------------------------------------------------------------------------------

        void wxInstantChooserPanel :: setInstant(std::vector<int> choiceInstant)
        {               
                int max = _concepts->size();
                if( (int)(choiceInstant.size()) == max )
                {
                        int i = 0;
                        while(i< max)
                        {
                                (*_concepts)[i]->setActualValue( choiceInstant[i] );
                                i++;
                        }
                }
        }
        
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: getInstant(std::vector<int> & choiceInstant)
        {
                if(_concepts!=NULL)
                {
                        int i = 0;

                        int size=_concepts->size();
                        while( i< size )
                        {
                                choiceInstant.push_back( ((*_concepts))[i]->getActualValue());
                                i++;
                        }
                }               
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setInstant(std::map<std::string,int>* _actualInstant )
        {
                int size,i;
                size=_concepts->size();
                std::map<std::string,int>::iterator iteratorActualInstant;
                wxConceptControl* concepti;
                std::string nameConcepti;
                for(i=0;i<size;i++)
                {
                        concepti=(*_concepts)[i];
                        nameConcepti=concepti->getName();
                        iteratorActualInstant=_actualInstant->find(nameConcepti);
                        if(iteratorActualInstant!=_actualInstant->end())
                        {
                                int actualValue=iteratorActualInstant->second;
                                concepti->setActualValue(actualValue);
                        }
                        nameConcepti.clear();
                }
        }
        //------------------------------------------------------------------------------------------------------------
        std::map<std::string,int>* wxInstantChooserPanel :: getInstantData()
        {
                int size,i=0;   
                wxConceptControl* concepti;
                if(_concepts!=NULL)
                {
                        bool isEmpty=_actualInstant->empty();
                        if(!isEmpty) _actualInstant->clear();
                        size=_concepts->size();
                        while( i< size )
                        {
                                concepti=(*_concepts)[i];
                                _actualInstant->insert(std::pair<std::string,int>(concepti->getName(),concepti->getActualValue()));
                                i++;
                        }
                }
                return _actualInstant;          
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: getInstantData(std::map<std::string,int> & choiceInstantData)
        {
                int i = 0,size;
                size=_concepts->size();
                while(i< size)
                {
                        choiceInstantData.insert(std::pair < std::string, int> ((*_concepts)[i]->getName(), (*_concepts)[i]->getActualValue()));
                        i++;
                }
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setResolutionRangeWithLasUpdate()
        {
                int minShow = _lastConceptUpdated->getMinShowedValue();
                int maxShow = _lastConceptUpdated->getMaxShowedValue();
                _resolutionSlider->SetRange( minShow, maxShow );
        }

        
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: refreshConceptLabels()
        {
                
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setConfiguration(std::string aConfiguration)
        {
                _configuration = aConfiguration;
        }
        //------------------------------------------------------------------------------------------------------------
        std::string wxInstantChooserPanel :: getConfiguration()
        {
                return _configuration;
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setResolutionOverAll( bool condition )
        {
                _resolutionOverALL = condition;
        }
        //------------------------------------------------------------------------------------------------------------
        bool wxInstantChooserPanel :: getIfResolutionOverAll()
        {
                return _resolutionOverALL;
        }

   //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: initializeResolutionSlider()
        {       
                _resolutionSlider = new wxSlider(this , -1,5,1,8,wxDefaultPosition, wxSize(25,45), wxSL_LEFT | wxSL_AUTOTICKS  );               
                Connect( _resolutionSlider->GetId(), wxEVT_COMMAND_SLIDER_UPDATED, wxScrollEventHandler(wxInstantChooserPanel::onResolutionSlider));//(wxObjectEventFunction) &wxInstantChooserPanel::onResolutionSlider ); 
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: changeResolutionAtConceptControl( wxConceptControl * theConceptToUpdate )
        {
                int value = theConceptToUpdate->getActualValue();
                int min = theConceptToUpdate->getMinValue();
                int max = theConceptToUpdate->getMaxValue();
                int delta = (int) (pow((double) 2, _resolutionSlider->GetValue() ));
                int minTmp   = value - delta/2;
                int maxTmp   = value + delta/2;
                if (minTmp<min)
                {
                        minTmp = min;   
                }
                if (maxTmp>max)
                {
                        maxTmp = max;
                }                       
                theConceptToUpdate->setRange( minTmp,maxTmp );
        }

        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setVerticalMaxSelectedNums( std::string groupMaxVertNums )
        {
                int endSub;
                std::string::size_type numberIndex = groupMaxVertNums.find(" ", 0);
                std::string::size_type start = 0;
                while( numberIndex != std::string::npos ) 
                {       
            endSub = numberIndex;
                        std::string number = groupMaxVertNums.substr( 0, endSub );
                        groupMaxVertNums.erase( 0, endSub+1 ); 
                        int intReturn = atoi(number.c_str());                   
                        if( intReturn>0 )
                                _verticalMaxSelected.push_back(intReturn);      
                        else
                                _verticalMaxSelected.push_back( 1 );    
                        start += numberIndex;
                        numberIndex = groupMaxVertNums.find(" ", endSub);                       
                }                               
        }
        //------------------------------------------------------------------------------------------------------------
        void wxInstantChooserPanel :: setConceptValue( std::string theConceptName, int theValue )
        {
                int i, size = _concepts->size();
                bool setted = false;
                for ( i=0; i<size && !setted; i++ )
                {       
                        if( (*_concepts)[i]->getName().compare( theConceptName ) == 0 )
                        {
                                (*_concepts)[i]->setActualValue( theValue );
                                setted = true;
                        }
                }
        }
        
        //------------------------------------------------------------------------------------------------------------
        int wxInstantChooserPanel :: getConceptValue( std::string theConceptName )
        {
                int i, size = _concepts->size();
                int value = -1;
                for ( i=0; i<size && value==-1; i++ )
                {       
                        if( (*_concepts)[i]->getName().compare( theConceptName ) == 0 )
                        {
                                value = (*_concepts)[i]->getActualValue(  );
                        }
                }
                return value;
        }
        //------------------------------------------------------------------------------------------------------------
        ConceptDataWrap * wxInstantChooserPanel :: getConceptDataOf( std::string theConceptName )
        {
                ConceptDataWrap * conceptData = new ConceptDataWrap();

                int i, size = _concepts->size();
                int value = -1;
                for ( i=0; i<size && value==-1; i++ )
                {       
                        if( (*_concepts)[i]->getName().compare( theConceptName ) == 0 )
                        {               
                                conceptData -> fillData( (*_concepts)[i]->getName(), (*_concepts)[i]->getMinValue(), (*_concepts)[i]->getMaxValue(), (*_concepts)[i]->getMinShowedValue(), (*_concepts)[i]->getMaxShowedValue(), (*_concepts)[i]->getActualValue());                    
                        }
                }
                return conceptData;
        }
        //------------------------------------------------------------------------------------------------------------
        bool wxInstantChooserPanel :: getIfConceptCheckedAt( std::string theConceptName, int atChecksPosition )
        {
                bool isChecked = false;

                int i,size = _concepts->size();
//              wxConceptControl * aConcept = NULL;                     
                for ( i=0; i<size && !isChecked; i++ )
                {       
                        if( (*_concepts)[i]->getName().compare( theConceptName ) == 0 )
                        {               
                                isChecked = (*_concepts)[i]->getIfChecked( atChecksPosition );
                        }
                }

                return isChecked;
        }
         
         
        void wxInstantChooserPanel::addConcepts(std::vector<std::string> conceptNameVect,std::vector<int> conceptSizeVect){
                int i=0;
                int max = conceptNameVect.size();                       
                for( ; i<max; i++)
                {
                        if( conceptNameVect[i].compare("Axe Depth") == 0 )
                        {
                                addConcept( conceptNameVect[i], 0, conceptSizeVect[i], 1);                                      
                        } else {
                                addConcept( conceptNameVect[i], 1, conceptSizeVect[i], 1);
                        } // if
                }
        }