test-Gui.cxx

Go to the documentation of this file.

#include <Midad/Gui/GuiButton.h>
#include <Midad/Gui/GuiTable.h>
#include <Midad/Gui/GuiMainWindow.h>
#include <Midad/Gui/GuiMenu.h>
#include <Midad/Gui/GuiBox.h>
#include <Midad/Gui/GuiTab.h>
#include <Midad/Gui/GuiFrame.h>
#include <Midad/Gui/GuiCanvas.h>
#include <Midad/Gui/GuiStatusBar.h>
#include <Midad/Gui/GuiSlider.h>
#include <Midad/Gui/GuiTextEntry.h>
//#include "popup/MyClass.h"

#include "TROOT.h"
#include "TApplication.h"
#include "TGTableLayout.h"
#include "TCanvas.h"

#include <sigc++/signal.h>
#include <sigc++/bind.h>
#include <sigc++/object_slot.h>

#include <iostream>
#include <string>
#include <sstream>
using namespace std;

class Buttons : public GuiTable
{

public:

    Buttons(TGWindow& parent) : GuiTable(parent,1,4) {
        fPrev = SigC::manage(new GuiTextButton(*this,"<-Prev"));
        this->Attach(*fPrev,0,1,0,1);
        
        fRerun = SigC::manage(new GuiTextButton(*this,"Rerun"));
        this->Attach(*fRerun,1,2,0,1);
        
        fNext = SigC::manage(new GuiTextButton(*this,"Next->"));
        this->Attach(*fNext,2,3,0,1);

        GuiPicButton* picb = 
            SigC::manage(new GuiPicButton(*this,"root_s.xpm"));
        this->Attach(*picb,3,4,0,1);
    }

    ~Buttons() {}

    GuiTextButton& GetPrev() { return *fPrev; }
    GuiTextButton& GetRerun() { return *fRerun; }
    GuiTextButton& GetNext() { return *fNext; }

private:

    SigC::Ptr<GuiTextButton> fPrev,fRerun,fNext;

};


void handler(string what)
{
    cout << what << endl;
}
void handler_menu(string item, int ncalls)
{
    cout << "[" << ncalls << "]" << item << endl;
}

void add_menu(GuiMenu* menu)
{
    static int count = 0;
    ++count;
    stringstream ss;
    ss << "add " << count;
    menu->Add(ss.str().c_str(),SigC::bind(SigC::slot(add_menu),menu));
}
void insert_menu(GuiMenu* menu, GuiMenu::GuiMenuList::iterator gmit)
{
    static int count = 0;
    ++count;
    stringstream ss;
    ss << "insert " << count;
    menu->Insert(gmit,ss.str().c_str(),SigC::bind(SigC::slot(insert_menu),
                                                  menu,gmit));
}
void say_hello()
{
    cerr << "Hello!\n";
}
void fill_test_menu(GuiMenuBar* gmb);
void clear_menu(GuiMenu* menu, GuiMenuBar* gmb)
{
    menu->ClearAll();
    gmb->RemoveMenu("test");
    fill_test_menu(gmb);
    gmb->MapSubwindows();
    gmb->Layout();
    gmb->MapWindow();

}
void fill_test_menu(GuiMenuBar* gmb)
{
    using namespace SigC;

    GuiMenu* menu = gmb->MakeAddMenu("test");

    menu->Add("clear",bind(slot(clear_menu),menu,gmb));
    GuiMenu* submenu = manage(new GuiMenu);
    menu->Add("submenu",*submenu);
    submenu->Add("hello",slot(say_hello));

    GuiMenu::GuiMenuList::iterator gmit
        = menu->Add("add",bind(slot(add_menu),menu));
    menu->Add("insert",bind(slot(insert_menu),menu,gmit));
}

void fill_mydisplay_menu(GuiMenuBar* gmb)
{
    using SigC::bind;
    using SigC::slot;

    static int ncalls = 0;
    ++ncalls;

    static const char* menu_name[] = {
        "Menu1",
        "Menu2",
        "Menu3",
        0
    };
    static const char* menu_item_name[] = {
        "Item1",
        "Item2",
        "Item3",
        0
    };

    int m=0;
    while (menu_name[m]) {
        GuiMenu* menu;
        if (ncalls==1) menu = gmb->MakeAddMenu(menu_name[m]);
        else menu = gmb->GetMenu(menu_name[m]);
        if (!menu) {
            cerr << "No menu!\n";
            ++m;
            continue;
        }
        int i=0;
        while (menu_item_name[i]) {
            menu->Add(menu_item_name[i],
                      bind(slot(handler_menu),menu_item_name[i],ncalls));
            ++i;
        }
        ++m;
    }

    fill_test_menu(gmb);
}
void fill_menu(GuiMenuBar* gmb)
{
    using SigC::bind;
    using SigC::slot;

    static int ncalls = 0;
    ++ncalls;

    static const char* menu_name[] = {
        "Menu1",
        "Menu2",
        "Menu3",
        0
    };
    static const char* menu_item_name[] = {
        "Item1",
        "Item2",
        "Item3",
        0
    };

    int m=0;
    while (menu_name[m]) {
        GuiMenu* menu;
        if (ncalls==1) menu = gmb->MakeAddMenu(menu_name[m]);
        else menu = gmb->GetMenu(menu_name[m]);
        if (!menu) {
            cerr << "No menu!\n";
            ++m;
            continue;
        }
        int i=0;
        while (menu_item_name[i]) {
            menu->Add(menu_item_name[i],
                      bind(slot(handler_menu),menu_item_name[i],ncalls));
            ++i;
        }
        ++m;
    }

    fill_test_menu(gmb);
}


void refill_menu(GuiMenuBar* gmb)
{
    fill_menu(gmb);
    gmb->MapSubwindows();
    gmb->Layout();
    gmb->MapWindow();
}

void build_table(GuiVBox& vbox) 
{
    using SigC::bind;
    using SigC::slot;
    const int ncols = 5;
    const int nrows = 1;

    GuiTable* table = manage(new GuiTable(vbox,nrows,ncols));
    table->SetLayoutHints(table->GetLayoutHints() & ~kLHintsExpandY);
    vbox.Add(*table);

    int row = 0;

    if (true) {
        // Add buttons
        for (int i=0; i<ncols; ++i) {
            char buf[128];
            
            sprintf(buf,"[%d]",i+1);
            GuiTextButton* gb = SigC::manage(new GuiTextButton(*table,buf));
            table->Attach(*gb,i,i+1,row,row+1);

            sprintf(buf,"click (%d)",i+1);
            gb->clicked.connect(bind(slot(handler),buf));
            sprintf(buf,"press (%d)",i+1);
            gb->pressed.connect(bind(slot(handler),buf));
            sprintf(buf,"release (%d)",i+1);
            gb->released.connect(bind(slot(handler),buf));
        }

        ++row;
    }


    Buttons* gc;
    if (row < nrows) {
        cerr << "Putting Buttons in table\n";
        gc = manage(new Buttons(*table));
        table->Attach(*gc,0,ncols,row,row+1);
    }
    else {
        cerr << "Putting Buttons in vbox\n";
        gc = manage(new Buttons(vbox));
        gc->SetLayoutHints(gc->GetLayoutHints() & ~kLHintsExpandY);
        vbox.Add(*gc);
    }

    gc->GetPrev().clicked.connect(bind(slot(handler),"Previous"));
    gc->GetRerun().clicked.connect(bind(slot(handler),"Rerun"));
    gc->GetNext().clicked.connect(bind(slot(handler),"Next"));
}

void tab_chirp(int id, GuiTab* gt)
{

    GuiBase::ChildrenList cl = gt->GuisAt(id);
    cerr << "Tab " << id << " selected with "
         << cl.size() << " children\n";
    GuiBase::ChildrenList::iterator it, done = cl.end();
    for (it=cl.begin(); it != done; ++it) {
        cerr << "\t" << (*it)->GetName() << endl;
    }
}

void add_canvas(GuiVBox& vbox)
{
#if 1
    GuiTab* gt = manage(new GuiTab(vbox));
    vbox.Add(*gt);

    gt->selected.connect(bind(slot(tab_chirp),gt));

    GuiFrame* gf = gt->Add("Canvas");

    cerr << "Canvas frame: "  << (void*)gf << endl;

    GuiCanvas* gc = manage(new GuiCanvas(*gf->GetFrame()));
    gf->Add(*gc);

    gf->GetFrame()->SetWidth(100); gf->GetFrame()->SetHeight(100);
    gc->SetWidth(100); gc->SetHeight(100);
    gt->SetWidth(100); gt->SetHeight(100);

    TCanvas* canvas = gc->GetCanvas();
    canvas->cd();
//    MyClass* mc = new MyClass();
//    mc->Draw();

    gf = gt->Add("button");
    cerr << "Button frame: "  << (void*)gf << endl;
    GuiTextButton* gtb = manage(new GuiTextButton(*gf->GetFrame(),"click me"));
    gf->Add(*gtb);
    
#else
    GuiCanvas* gc = manage(new GuiCanvas(vbox));
    vbox.Add(*gc);
#endif
}

class AWindow : public GuiMainWindow
{
public:

    AWindow() : GuiMainWindow(250,50) {
        cerr << "Spawing a box\n";

        using SigC::bind;
        using SigC::slot;

        GuiVBox* vbox = manage(new GuiVBox(*this));
        this->Add(*vbox);

        GuiMenuBar* gmb = manage(new GuiMenuBar(*vbox));
        vbox->Add(*gmb);        
        fill_test_menu(gmb);

        GuiHBox* box = manage(new GuiHBox(*vbox));
        vbox->Add(*box);
        GuiTextButton* close = manage(new GuiTextButton(*box,"Close"));
        box->Add(*close);
        GuiTextButton* quit = manage(new GuiTextButton(*box,"quit"));
        box->Add(*quit);
        GuiTextButton* menu = manage(new GuiTextButton(*box,"redo menus"));
        box->Add(*menu);

        close->clicked.connect(slot(*this,&AWindow::SendCloseMessage));
        quit->clicked.connect(slot(*this,&AWindow::Quit));
        close_window.connect(slot(*this,&AWindow::KillMe));
        menu->clicked.connect(bind(slot(refill_menu),gmb));
    }
    ~AWindow() {
        cerr << "~AWindow()\n"; 
    }

//    void CloseMe() {
//        cerr << "CloseMe\n";
//        this->SendCloseMessage();
//    }

    void KillMe() {
        delete this;
    }
    void Quit() {
        cerr << "Quitting!\n"; 
        gApplication->Terminate(0);
    }

};


void spawn_a_window()
{
    AWindow* aw = new AWindow();
    aw->ShowAll();
}

class Display : public GuiBox
{
public:
    Display(TGWindow& parent, int nrows, int ncols)
        : GuiBox(parent,kVerticalFrame,100,100) {
        // Menu Bar
        fMenuBar = SigC::manage(new GuiMenuBar(*this));
        this->Add(*fMenuBar);
        
        // Main box
        fMainBox = SigC::manage(new GuiTable(*this,nrows,ncols));
        this->Add(*fMainBox);
        
        // Status bar
        fStatusBar = SigC::manage(new GuiStatusBar(*this));
        this->Add(*fStatusBar);
    }
    virtual ~Display() {}
    // Get GUI elements
    GuiMenuBar& GetMenuBar() { return *fMenuBar; }
    GuiTable& GetMainBox() { return *fMainBox; }
    GuiStatusBar& GetStatusBar() { return *fStatusBar; }
private:
    GuiMenuBar* fMenuBar;
    GuiTable* fMainBox;
    GuiStatusBar* fStatusBar;
};                              // end of class Display

class MyDisplay : public Display
{

public:

    MyDisplay(TGWindow& parent) : Display(parent,3,3){
        GuiTable& main_box = this->GetMainBox();

        GuiCanvas* gc = manage(new GuiCanvas(main_box,100,100));
        main_box.Attach(*gc, 1,2, 1,2);

        GuiSlider* xslider = manage(new GuiSlider(main_box,kHorizontalFrame));
        main_box.Attach(*xslider, 1,2, 2,3);
        
        GuiSlider* yslider = manage(new GuiSlider(main_box,kVerticalFrame));
        main_box.Attach(*yslider, 2,3, 1,2);
    
        GuiMenuBar& menubar = this->GetMenuBar();
        fill_mydisplay_menu(&menubar);
    }
    virtual ~MyDisplay() {}
};                              // end of class MyDisplay

void spawn_mydisplay()
{
    GuiMainWindow* gmw = new GuiMainWindow();

    MyDisplay* disp = manage(new MyDisplay(*gmw));
    gmw->Add(*disp);

    gmw->ShowAll();
    gmw->ConnectClose(true);     // delete on close
}

void add_button(GuiVBox* vbox)
{
    GuiTextButton* gb = manage(new GuiTextButton(*vbox,"add"));
    gb->SetLayoutHints(kLHintsExpandX | kLHintsTop | kLHintsLeft);
    vbox->Add(*gb);
    gb->clicked.connect(bind(slot(add_button),vbox));
}

void add_spawner(GuiVBox& vbox)
{
    using namespace SigC;

    GuiTextButton* gb = manage(new GuiTextButton(vbox,"spawn"));
    gb->SetLayoutHints(kLHintsExpandX | kLHintsTop | kLHintsLeft);
    vbox.Add(*gb);
    gb->clicked.connect(SigC::slot(spawn_a_window));


    gb = manage(new GuiTextButton(vbox,"test"));
    gb->SetLayoutHints(kLHintsExpandX | kLHintsTop | kLHintsLeft);
    vbox.Add(*gb);
    gb->clicked.connect(SigC::slot(spawn_mydisplay));

    add_button(&vbox);
}

void echo_text_entry(GuiTextEntry* entry)
{
    cerr << entry->GetText() << endl;
}

void echo(const char* text)
{
    cerr << text << endl;
}
int main (int argc, char *argv[])
{
    TApplication theApp("App", &argc, argv);

    GuiMainWindow* mw = manage(new GuiMainWindow(300,300));

    GuiVBox* vbox = manage(new GuiVBox(*mw));
    vbox->SetLayoutHints(vbox->GetLayoutHints() | kLHintsExpandX);
    mw->Add(*vbox);

    GuiHBox* hbox = manage(new GuiHBox(*vbox));
    vbox->Add(*hbox);

    GuiMenuBar* gmb = manage(new GuiMenuBar(*hbox));
    hbox->Add(*gmb);
    fill_menu(gmb);

    GuiTextEntry* entry = manage(new GuiTextEntry(*vbox,"<enter something>"));
    vbox->Add(*entry);
    entry->activated.connect(SigC::bind(SigC::slot(echo_text_entry),entry));
    entry->text_changed.connect(SigC::slot(echo));

    build_table(*vbox);
    add_spawner(*vbox);
    add_canvas(*vbox);

    mw->ShowAll();
    mw->SetMinSize();
    mw->ConnectClose();

    mw->close_window.connect(SigC::slot(*mw,&GuiMainWindow::KillMe));

    theApp.Run();
    return 0;
} // end of main()

---