source: projectionDesigner/trunk/projdesigner/src/GUIControler.cpp @ 210

#include "ProjectionModel.h"
#include "Channel.h"
#include "RSync.h"
#include "gui/QDesignViewWindow.h"
#include "gui/QDesignViewWidget.h"
#include "gui/QPanelWidget.h"
#include "gui/QClientWindow.h"
#include "gui/QProjectorWindow.h"
#include "gui/QSceneViewerWindow.h"
#include "gui/QPreferenceDialog.h"

#include "GUIControler.h"

using namespace projection;

/**
 * Constructor.
 *
 * @param pModel Projection model.
 */
GUIControler::GUIControler(ProjectionModel* pModel)
{
    m_pModel = pModel;

    m_pDesignViewWindow = NULL;
    m_pClientWindow = NULL;
    m_pSceneViewerWindow = NULL;
    m_pPreferenceDialog = NULL;
}

/**
 * Destructor.
 */
GUIControler::~GUIControler()
{
    delete m_pDesignViewWindow;
    delete m_pClientWindow;
}

/**
 * Initialize GUIs.
 *
 * @param bServer True if this program is a server, false if it is a client.
 */
void GUIControler::init(bool bServer)
{
    if (bServer)
    {
        m_pDesignViewWindow = new QDesignViewWindow;
        m_pDesignViewWindow->setModel(m_pModel);
        m_pDesignViewWindow->showMaximized();
    }
    else
    {
        m_pClientWindow = new QClientWindow(NULL);
                m_pClientWindow->show();
    }
}

/**
 * Load projection settings from a file.
 *
 * @param fileName File name to load.
 * @return True if successfully loaded.
 */
bool GUIControler::loadFile(const QString& fileName)
{
    if (m_pDesignViewWindow)
        return m_pDesignViewWindow->loadFile(fileName);
    return false;
}

/**
 * Save the current projection settings to a file.
 *
 * @param fileName File name to save.
 * @return True if successfully saved.
 */
bool GUIControler::saveFile(const QString& fileName)
{
    if (m_pDesignViewWindow)
        return m_pDesignViewWindow->saveFile(fileName);
    return false;
}

/**
 * Retrieve main window.
 *
 * @return DesignViewWindow in server, ClientWindow in Client.
 */
QWidget* GUIControler::getMainWindow()
{
    if (m_pDesignViewWindow)
        return m_pDesignViewWindow;
    if (m_pClientWindow)
        return m_pClientWindow;
    return NULL;
}

/**
 * Retrieve QGLWidget for sharing OpenGL context.
 *
 * @return QGLWidget for sharing OpenGL context.
 */
QGLWidget* GUIControler::getGLWidget()
{
    if (m_pDesignViewWindow) {
        return m_pDesignViewWindow->getGLWidget();
    }
/*    else if (m_pProjectorWindows.size() > 0) {
        return m_pProjectorWindows[0];
    }*/
    static QGLWidget* g_pGLWidget = NULL;
    if (!g_pGLWidget)
        g_pGLWidget = new QGLWidget(getMainWindow());
    return g_pGLWidget;
}

/**
 * Select a channel.
 *
 * @param pChannel Channel object to select.
 */
void GUIControler::selectChannel(Channel* pChannel)
{
    if (m_pDesignViewWindow) {
        m_pDesignViewWindow->getPanel()->selectChannel(pChannel);
    }
}

/**
 * Remove the specified channel.
 *
 * @param pChannel Channel object to remove.
 */
void GUIControler::removeChannel(Channel* pChannel)
{
    for (int i=0; i<m_pProjectorWindows.size(); ++i) {
        if (m_pProjectorWindows.at(i)->getChannel() == pChannel) {
            QProjectorWindow* pProjectorWindow = m_pProjectorWindows.takeAt(i);
            delete pProjectorWindow;
            return;
        }
    }
}

/**
 * Process key event for channel.
 *
 * @param pChannel Channel to process key event.
 * @param pEvent Key event.
 */
void GUIControler::processChannelKeyEvent(Channel* pChannel, QKeyEvent* pEvent)
{
    m_pDesignViewWindow->getDesignView()->processChannelKeyEvent(pChannel, pEvent);
}

/**
 * Update the channel list in GUI.
 */
void GUIControler::updateChannelsGUI()
{
    if (m_pDesignViewWindow)
        m_pDesignViewWindow->getPanel()->updateChannels();
}

/**
 * Update the name of channels in GUI.
 */
void GUIControler::updateChannelNamesGUI()
{
    if (m_pDesignViewWindow)
        m_pDesignViewWindow->getPanel()->updateChannelNames();

    for (int i=0; i<m_pProjectorWindows.size(); ++i)
        m_pProjectorWindows[i]->updateTitle();
}

/**
 * Update the channel in GUI.
 */
void GUIControler::updateChannelGUI()
{
    if (m_pDesignViewWindow)
        m_pDesignViewWindow->getPanel()->updateCurrentChannel();
}

/**
 * Update GUI.
 */
void GUIControler::updateGUI()
{
    if (m_pDesignViewWindow)
        m_pDesignViewWindow->getPanel()->updateGUI();
}

/**
 * Redraw SceneViewer.
 */
void GUIControler::updateSceneViewer()
{
    if (m_pSceneViewerWindow)
    {
        m_pSceneViewerWindow->blockSignals(true);
        m_pSceneViewerWindow->updateGL();
        m_pSceneViewerWindow->blockSignals(false);
    }
}

/**
 * Put the SceneViewer camera at the center of the scene.
 */
void GUIControler::sceneCenterView()
{
    if (m_pSceneViewerWindow)
        m_pSceneViewerWindow->centerView();
}

/**
 * Set the SceneViewer camera to view all the scene.
 */
void GUIControler::sceneViewAll()
{
    if (m_pSceneViewerWindow)
        m_pSceneViewerWindow->viewAll();
}

/**
 * Redraw DesignViewWindow and ProjectorWindows.
 */
void GUIControler::updateViews()
{
    if (m_pDesignViewWindow)
        m_pDesignViewWindow->getDesignView()->updateGL();

    for (int i=0; i<m_pProjectorWindows.size(); ++i)
        if (m_pProjectorWindows[i]->isVisible())
            m_pProjectorWindows[i]->updateGL();
}

/**
 * Set scene size for SceneViewer.
 *
 * @param radius Radius of the scene.
 */
void GUIControler::setSceneSize(float radius)
{
    if (m_pSceneViewerWindow) {
        m_pSceneViewerWindow->setSceneSize(radius * 4.0f);
        m_pSceneViewerWindow->setZFar(radius * 4.0f);
    }
}

/**
 * Create (if not exist) and show a ProjectorWindow for the specified channel.
 *
 * @param pChannel Channel object for the ProjectorWindow.
 */
void GUIControler::showProjectorWindow(Channel* pChannel)
{
    if (!pChannel)
        return;
    QProjectorWindow* pProjectorWindow = NULL;
    for (int i=0; i<m_pProjectorWindows.size(); ++i)
        if (m_pProjectorWindows.at(i)->getChannel() == pChannel)
            pProjectorWindow = m_pProjectorWindows[i];
    if (!pProjectorWindow)
    {
        pProjectorWindow = new QProjectorWindow (0, getGLWidget(), Qt::Dialog);
        pProjectorWindow->setModel(m_pModel);
        pProjectorWindow->setChannel(pChannel);

        m_pProjectorWindows.append(pProjectorWindow);
    }

    if (!m_pModel->getRSync()->isServer() && pChannel->getRemoteFullScreen())
    {
        QDesktopWidget desktop;
        if (!pProjectorWindow->isFullScreen() ||
            desktop.availableGeometry(pChannel->getRemoteScreen()) != desktop.availableGeometry(pProjectorWindow))
        {
            QRect rect = desktop.availableGeometry(pChannel->getRemoteScreen());
            pProjectorWindow->move(rect.x() + 10, rect.y() + 10);
            pProjectorWindow->showFullScreen();
        }
    } else
        pProjectorWindow->showNormal();
}

/**
 * Create (if not exist) and show a SceneViewerWindow.
 */
void GUIControler::showSceneViewerWindow()
{
    if (!m_pSceneViewerWindow)
    {
        m_pSceneViewerWindow = new QSceneViewerWindow(0);
        m_pSceneViewerWindow->setModel(m_pModel);
        m_pSceneViewerWindow->initFromDOMElement(m_sceneViewerSettings);
    }
    m_pSceneViewerWindow->show();
}

/**
 * Create (if not exist) and show a PreferenceDialog.
 */
void GUIControler::showPreferenceDialog()
{
    if (!m_pPreferenceDialog)
    {
        m_pPreferenceDialog = new QPreferenceDialog(getMainWindow());
        m_pPreferenceDialog->setModel(m_pModel);
    }
    m_pPreferenceDialog->show();
}

/**
 * Show an instant message in status bar of the DesignViewWindow.
 *
 * @param message Message to show.
 * @param timeout Time out interval to disappear in micro seconds.
 */
void GUIControler::showStatusBarMessage(const QString& message, int timeout)
{
    if (m_pDesignViewWindow)
    m_pDesignViewWindow->statusBar()->showMessage(message, timeout);
}

/**
 * Append log to Client Window.
 *
 * @param log Log text.
 */
void GUIControler::appendClientLog(const QString& log)
{
    if (m_pClientWindow)
        m_pClientWindow->appendLog(log);
}

/**
 * Close all windows to quit the application.
 */
void GUIControler::closeAllWindows()
{
    if (m_pClientWindow)
        m_pClientWindow->close();
    if (m_pSceneViewerWindow)
        m_pSceneViewerWindow->close();
    if (m_pPreferenceDialog)
        m_pPreferenceDialog->close();
    while (m_pProjectorWindows.size() > 0) {
        QProjectorWindow* pProjectorWindow = m_pProjectorWindows.takeAt(0);
        delete pProjectorWindow;
    }
}

/**
 * Restore settings of the DesignView and the SceneViewer.
 *
 * @param Parent XML element of the DesignView and the SceneViewer settings.
 */
bool GUIControler::initFromDOMElement(const QDomElement& element)
{
    if (m_pDesignViewWindow && !element.firstChildElement("DesignViewWindow").isNull())
    {
        m_pDesignViewWindow->initFromDOMElement(element.firstChildElement("DesignViewWindow"));
    }
    if (!element.firstChildElement("SceneViewerWindow").isNull())
    {
        m_sceneViewerSettings = element.firstChildElement("SceneViewerWindow");
        if (!m_pSceneViewerWindow && m_sceneViewerSettings.attribute("show") == "true")
            showSceneViewerWindow();
        else if (m_pSceneViewerWindow)
            m_pSceneViewerWindow->initFromDOMElement(m_sceneViewerSettings);
    }

        return true;    // todo: secure this function and return false on any critical error
}

/**
 * Store the current DesignView and SceneViewer as XML data.
 *
 * @param name XML node name of the data.
 * @param doc XML document to store the data.
 * @return Current DesignView and SceneViewersettings as XML data.
 */
QDomElement GUIControler::domElement(const QString& name, QDomDocument& doc)
{
    QDomElement gui = doc.createElement(name);
    if (m_pDesignViewWindow)
        gui.appendChild(m_pDesignViewWindow->domElement("DesignViewWindow", doc));
    if (m_pSceneViewerWindow)
        gui.appendChild(m_pSceneViewerWindow->domElement("SceneViewerWindow", doc));
    else
        gui.appendChild(m_sceneViewerSettings);
    return gui;
}