---

IgPage.cc

Go to the documentation of this file.

//<<<<<< INCLUDES                                                       >>>>>>

#include "Iguana/Studio/interface/IgPage.h"
#include "Iguana/Studio/interface/IgDocument.h"
#include "Iguana/Studio/interface/IgView.h"
#include "Iguana/Studio/interface/IgViewDB.h"
#include "Iguana/Studio/interface/IgViewCreator.h"
#include "Iguana/Studio/interface/IgQtFocusManager.h"
#include "Iguana/Studio/interface/IgQDockAreaSite.h"
#include "Iguana/Studio/interface/IgQDockWindowSite.h"
#include "Iguana/Studio/interface/IgQVSplitterSite.h"
#include "Iguana/Studio/interface/IgQWorkspaceSite.h"
#include "Iguana/Studio/interface/IgQWidgetSite.h"
#include "Iguana/Studio/interface/IgQWidgetStackSite.h"
#include "Iguana/Studio/interface/IgQtAppMenuService.h"
#include "Iguana/Studio/interface/IgQtAppToolBarService.h"
#include "Iguana/Studio/interface/IgQtAppWindowService.h"
#include "Iguana/Studio/interface/IgQtSite.h"
#include "Iguana/Studio/interface/IgQtSiteStack.h"
#include <qaccel.h>
#include <qwidget.h>
#include <qlayout.h>
#include <qpopupmenu.h>
#include <qmenubar.h>
#include <qtoolbar.h>
#include <classlib/utils/DebugAids.h>
#include <iostream>

//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>


IgQtSiteStack *
createWorkspace (IgState *state, IgSite *site)
{
    return new IgQWorkspaceSite (state, site);    
}


IgPage::IgPage (IgDocument *doc)
    : IgQHSplitterSite (doc->state (), doc->window ()),
      m_document (doc),
      m_leftDockArea (new IgQDockAreaSite (doc->state (), this)),
      m_stackArea (new IgQWidgetStackSite (doc->state (), new IgQDockWindowSite (doc->state (), m_leftDockArea))),
      m_centralSplitter (new IgQVSplitterSite (doc->state (), this)),
      m_workspace (createWorkspace (doc->state (), m_centralSplitter)),
      m_bottomDockArea (new IgQDockAreaSite (doc->state (), m_centralSplitter)),
      m_rightDockArea (new IgQDockAreaSite (doc->state (), this)),
      m_numRegisteredWindows (0)
{
    // Construct a grid layout for holding contents
    // m_layout = new QGridLayout (self ());
    // m_layout->setAutoAdd (true);

    // FIXME: register in document
    // FIXME: read, write support
    ASSERT (doc);    
    doc->addPage (this);    
    
    IgQtAppMenuService *service = IgQtAppMenuService::get (doc->state ());
    
    QMenuBar *bar = service->menuBar ();    
    QAccel *a = new QAccel (IgQtSite::selfFrom (m_workspace));  // create accels for main Window
    a->connectItem (a->insertItem (Qt::Key_Escape),     // adds Esc accelerator
                    this,                               // connected to IgPage's
                    SLOT (showFullScreen ()));          // showFullScreen() slot
    
    // Here we populate the file menu with the "New" entry to allow user to
    // create new views of the different models
    QPopupMenu *fileMenu = service->subMenu (IgQtAppMenuService::MENU_ID_FILE);
    
    ASSERT (fileMenu);
    
    QPopupMenu *newViewMenu = new QPopupMenu (bar);
    newViewMenu->setCaption ("New");
    fileMenu->insertItem ("&New", newViewMenu, MENU_ID_FILE_NEW,
                          IgQtAppMenuService::index (fileMenu, MENU_ID_FILE_NEW));
    fileMenu->insertSeparator (IgQtAppMenuService::index (fileMenu, MENU_ID_FILE_NEW) + 1 );
    newViewMenu->insertTearOffHandle ();
    
    IgViewDB *viewDB = IgViewDB::get ();
    ASSERT (viewDB);
    
    // FIXME: sometimes, especially after rebuilding, viewDB is
    // empty...We need to find some better way to get notified when a
    // new IgView plugin is loaded.
    for (IgViewDB::Iterator i = viewDB->begin ();
         i != viewDB->end ();
         i++)
    {   
        IgViewCreator *viewCreator = new IgViewCreator (i, this);
        newViewMenu->insertItem ((*i)->name (), 
                                 viewCreator,
                                 SLOT (createView ()),
                                 0,
                                 IgQtAppMenuService::index (newViewMenu,
                                                            MENU_ID_FILE_NEW));
    }
    
    // Here we create the "Window" menu in which the user can decide
    // to hide/show some utility views (for example the python shell
    // should go here...)
    //
    // FIXME: how do we distinguish between different kind of Views?
    // By having two, separate, plugin categories?
    
    QPopupMenu *windowMenu = new QPopupMenu (bar);
    windowMenu->setCaption ("Window");
    bar->insertItem ("&Window", windowMenu, MENU_ID_WINDOW,
                     IgQtAppMenuService::index (bar, MENU_ID_WINDOW));

    windowMenu->insertTearOffHandle ();
    windowMenu->insertItem ("&Tile", 
                            IgQtSite::selfFrom (m_workspace),
                            SLOT (tile ()),
                            0,
                            MENU_ID_WINDOW_TILE,
                            IgQtAppMenuService::index (bar, MENU_ID_WINDOW));
    windowMenu->insertItem ("&Cascade", 
                            IgQtSite::selfFrom (m_workspace),
                            SLOT (cascade ()),
                            0,
                            MENU_ID_WINDOW_CASCADE,
                            IgQtAppMenuService::index (bar, MENU_ID_WINDOW));

    windowMenu->insertItem ("Show &Maximized", 
                            this,
                            SLOT (showMaximized ()),
                            0,
                            MENU_ID_WINDOW_MAXIMIZE,
                            IgQtAppMenuService::index (bar, MENU_ID_WINDOW));

    windowMenu->insertItem ("&Full screen", 
                            this,
                            SLOT (showFullScreen ()),
                            Qt::CTRL+Qt::Key_F,
                            MENU_ID_WINDOW_FULLSCREEN,
                            IgQtAppMenuService::index (bar, MENU_ID_WINDOW));

    windowMenu->insertSeparator ();
    // Get notified by window selection changes
    //    connect (IgQtSite::selfFrom (m_workspace), SIGNAL (windowActivated (QWidget *)),
    //       this, SLOT (windowActivated (QWidget *)));
    IgQtFocusManager *focusManager = new IgQtFocusManager (state (), &m_views);
    
    QObject::connect (IgQtSite::selfFrom (m_workspace),
                      SIGNAL (windowActivated (QWidget *)),
                      focusManager,
                      SLOT (windowActivated (QWidget *)));
    
    self ()->show ();
}

IgState *
IgPage::state (void) const
{ return m_document->state (); }

IgQtSiteStack *
IgPage::workspace (void)
{
    return m_workspace;
}

IgQtSite *
IgPage::leftDockArea (void)
{
    return m_leftDockArea;
}

IgQtSite *
IgPage::rightDockArea (void)
{
    return m_rightDockArea;
}

IgQtSite *
IgPage::bottomDockArea (void)
{
    return m_bottomDockArea;
}

IgQtSiteStack *
IgPage::stackArea (void)
{
    return m_stackArea;
}

void
IgPage::registerView (IgView *view, QWidget *selectableWidget)
{
    ASSERT (m_views[selectableWidget] == 0);
    m_views[selectableWidget] = view;
    
    // FIXME: maybe we should also introduce different kind of views,
    // so that a view can have a title, without having to be
    // registered in the window menu.
    if (view->title () != "")
    {
        IgQtAppMenuService *ms = IgQtAppMenuService::get (state ());
    
        QPopupMenu *menu = ms->subMenu (MENU_ID_WINDOW);
        int itemID = MENU_ID_WINDOW_LIST_OFFSET + m_numRegisteredWindows++;
    
        menu->insertItem (view->title (), 
                          selectableWidget,
                          SLOT (show ()),
                          0,
                          itemID,
                          IgQtAppMenuService::index (menu,
                                                     MENU_ID_WINDOW_LIST_OFFSET));
        menu->connectItem (itemID, selectableWidget, SLOT (setFocus()));
    }
}

void
IgPage::showMaximized (void)
{    
    QMenuBar *menu = IgQtAppMenuService::get (m_document->state ())->menuBar ();
    ASSERT (menu);
    QWidget *mainWindow = IgQtAppWindowService::get (m_document->state ())->mainWindow ();
    if (mainWindow->isMaximized ())
    {
        menu->changeItem (MENU_ID_WINDOW_MAXIMIZE, "Show &Maximized");
        menu->setItemEnabled (MENU_ID_WINDOW_FULLSCREEN, true);
        mainWindow->showNormal ();
    } 
    else 
    { 
        menu->changeItem (MENU_ID_WINDOW_MAXIMIZE, "Show &Normal");
        menu->setItemEnabled (MENU_ID_WINDOW_FULLSCREEN, false);
        mainWindow->showMaximized ();
    }
}

void            
IgPage::showFullScreen (void)
{    
    QMenuBar *menu = IgQtAppMenuService::get (m_document->state ())->menuBar ();
    ASSERT (menu);
    QToolBar *toolBar = IgQtAppToolBarService::get (m_document->state ())->toolBar (3000, "General graphics ops");
    ASSERT (toolBar);
    QWidget *mainWindow = IgQtAppWindowService::get (m_document->state ())->mainWindow ();
    if (mainWindow->isFullScreen ())
    {
        menu->setItemEnabled (MENU_ID_WINDOW_MAXIMIZE, true);
        menu->show ();
        toolBar->show ();
        IgQtSite::selfFrom (leftDockArea ())->show ();
        IgQtSite::selfFrom (bottomDockArea ())->show ();
        mainWindow->showNormal ();
    } 
    else 
    { 
        menu->hide ();
        toolBar->hide ();
        IgQtSite::selfFrom (leftDockArea ())->hide ();
        IgQtSite::selfFrom (rightDockArea ())->hide ();
        IgQtSite::selfFrom (bottomDockArea ())->hide ();
        menu->setItemEnabled (MENU_ID_WINDOW_MAXIMIZE, false);
        mainWindow->showFullScreen ();
    }
}

void
IgPage::printViews (const QString &text) 
{
    emit autoPrint (text);    
}

---