GUIMainController.cxx

Go to the documentation of this file.

#include "GUIMainController.h"
#include "GUIObserver.h"
#include "../src_cpp/StockManager.h"
#include "../src_cpp/SMSubject.h"
#include "GUIMainFrame.h"

#include "Controllers/MainControllerIndicatorTHStock.h"
#include "View/MainIndicatorTHStockFrame.h"

// root dependency, may go to MainGUIFrame ??
//#include <TGClient.h>

GUIMainController::GUIMainController() : ControllerFrame<MainControllerIndicatorTHStock>(0), fcurrent_controller(0)
{
    // initialize fstockmanger
    // here get the global, other controllers call the parent pointer
    // no global access for child controllers anymore
        // could be send as a parameter, independent of the ROOT application
    fstockmanager = StockManager::getInstance(Utils::GetPathData());

#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tEntry Constructor GUIMainController" << std::endl;
    std::cout << "this " << this << std::endl;
        //std::cout << "GetStatus StockManager " << fstockmanager->GetStatus() << " adress " << fstockmanager << std::endl;
        //std::cout << "GetStatus StockManager::Server " << fstockmanager->GetStatusServer() << std::endl;
        //std::cout << "GetStatus StockManager " <<  StockManager::GetStatus() << std::endl;
        //std::cout << "GetStatus StockManager::Server " << StockManager::GetStatusServer() << std::endl;
#endif

    // gui_observer initialization, here attach gui_observer to StockManager
        // register the observer here ?? or in main or.. ?? would avoid to store as member
    gui_observer = new GUIObserver( this );
    fstockmanager->GetSubject()->attach( gui_observer );

    // here choice, send a pointer of the controller, or create a signal after the creation.
    // if Base class controller and Frame could be done "automatically"
    // maybe signal is better, more GUI design...to test both
    // create the unique menu, and a gui_mainframe
    gui_mainframe = new GUIMainFrame(gClient->GetRoot(),600,400, this);

    // create first controller child by default, default
    // need to get validation button
    // really used ?? fcurrent_controller could be in ControllerBase
    fcurrent_controller = CreateMainControllerIndicatorTHStock();

    // moved stuffs here, after the drawing of MainIndicatorTHStockFrame
    gui_mainframe->MapSubwindows();
    // see no changes
    //gui_mainframe->Resize(gui_mainframe->GetDefaultSize());
    gui_mainframe->Resize();
    gui_mainframe->MapWindow();

    // this is necessary only if kMainFrame false ??
    (( MainControllerIndicatorTHStock *)fcurrent_controller)->GetFrame()->ResetEntries();
}

GUIMainController::~GUIMainController()
{
#ifdef DEBUG_CONT_FRAME
        std::cout << "Destructor GUIMainController " << std::endl;
#endif

        // if Main receive the message to close
        // should call destructor of the controller first ??
        // will kill properly if TGMainframe

        // need to detach the observer !!
        // maybe safer later ?? could be done in main, where it is created
        // certainly better in main
        //fstockmanager-> StockManager::killInstance();
        //fstockmanager = 0;

        // delete frame
        delete gui_mainframe;
        gui_mainframe = 0;

        // delete the list of controllers, before or after the frames ??
        DeleteList();

}


MainControllerIndicatorTHStock * GUIMainController::CreateMainControllerIndicatorTHStock( bool kmain )
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tEntry GUIMainController::CreateMainControllerIndicatorTHStock() kmain " << kmain << std::endl;
    std::cout << "this " << this << std::endl;
#endif

    // new MainController to be created
    MainControllerIndicatorTHStock *controller;

    // creates a controller, who will create the Frame, will be printed in fhFrame0
    if ( kmain == false ) {
        controller = new MainControllerIndicatorTHStock( this, "MainIndicatorTHStock_1", gui_mainframe->GetFrame(), false );

    // else make an independent frame
    } else {
        controller = new MainControllerIndicatorTHStock( this, "MainIndicatorTHStock_2", 0, true );
    }
    // add to the list of controller
    AddController ( controller );

    // need a fcurrent_controller ?? or retrieve from the list later
    // keep it for the moment, maybe useful
    //fcurrent_controller = controller;

#ifdef DEBUG_CONT_FRAME
    // prinnt all frames
    //gui_mainframe->Print();
    //std::cout << "GUIMainController::CreateMainControllerIndicatorTHStock print controller->GetFrame()->Print()" << std::endl;
    //controller->GetFrame()->Print();
    //std::cout << "value of gpad after CreateMainControllerIndicatorTHStock " << gPad << std::endl;
#endif

    // return newly created MainController
    return controller;
}

void GUIMainController::DeleteControllerIndicatorTHStock( MainControllerIndicatorTHStock * control)
{
#ifdef DEBUG_CONT_FRAME
        std::cout << "Entry GUIMainController::DeleteControllerIndicatorTHStock" << std::endl;
#endif
        // remove the controller from the list
        RemoveController( control );
        // delete really the frame associated to the controller
        //delete control->GetFrame();
        std::cout << "after delete control->GetFrame" << std::endl;
        // delete really the controller
        delete control;
}

// needed for correct rescaling at the end of MainControllerIndicatorTHStock::Validation
// and MainControllerIndicatorTHStock::UpdateIndicator, but seems to work without
void GUIMainController::UpdateGUIFromController()
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tGUIMainController::UpdateGUIFromController " << std::endl;
#endif
    // work with this one alone ! before not rescaling of the frame
    // necessary for the first creation
    gui_mainframe->Resize();
}


// Update(d)_FromGUIObserver
void GUIMainController::Updated( std::vector<std::string> & message )
{
#ifdef DEBUG_CONT_FRAME
        std::cout << "Entry GUIMainController::Updated " << std::endl;
        std::cout << "Message " << message[0] << "," << message[1] << std::endl;
        std::cout << "Will only broadcast to child controller " << std::endl;
#endif
        std::cout << "Entry GUIMainController::Updated " << std::endl;

        // check message, only one for the moment
        //if ( message[0] == "update_dcsv" ) {

    // just broadcast
        for ( it_list it = list_controller.begin(); it != list_controller.end(); ++it ) {
                (*it)->Updated( message );
        }
}

/*
void GUIMainController::GetSelected( MainControllerIndicatorTHStock *child_controller )
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tEntry GUIMainController::GetSelected child_control " << child_controller << std::endl;
#endif

    // try to list important thing for adding SMA to first pad
    fcurrent_controller = child_controller;
    // seems only needed all done in child_controller ??
}
*/


void GUIMainController::AddObserver_Message( std::vector<std::string> & message )
{
#ifdef DEBUG_CONT_FRAME
    std::cout << "\n\tEntry GUIMainController::AddObserver_Message() from StockManager " << std::endl;
    std::cout << "message : " << message[0] << ", " << message[1] << std::endl;
#endif

    // new added test with RT2, let here because ROOT dependence
    // now register the message, for timer
    gui_mainframe->UpdateRT( message );
    return;
}