WindowController.cxx

Go to the documentation of this file.

// for defects
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

// for version
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "WindowController.h"

#include "CanvasView.h"
#include "CanvasWindow.h"
#include "Inspector.h"

#include <qapplication.h>
#if QT_VERSION < 0x040000
#else
#include <QDesktopWidget>
#endif

#include <algorithm>

using std::find;
using std::list;
using std::mem_fun;
using std::for_each;

WindowController * WindowController::s_instance = 0;
std::string WindowController::s_version ( VERSION );

/* static */
const std::string & WindowController::version ()
{
  return s_version;
}

WindowController::WindowController ( )
  : m_active_window ( 0 ),
    m_inspector ( 0 ),
    m_quit ( false )
{
  s_instance = this;
}

WindowController::~WindowController ()
{
}

WindowController * WindowController::instance ()
{
  if ( s_instance == 0 ) {
    s_instance = new WindowController ();
  }

  return s_instance;
}

void WindowController::createInspector ()
{
  if ( m_inspector == 0 ) {
    m_inspector = new Inspector ();
  }
  positionInspector ();
}

void WindowController::newWindow ( CanvasWindow * window )
{
  unsigned int size = m_window_list.size ();
  if ( size == 0  &&
       m_quit == true ) {
    window->inhibitClose ();
  }
  else if ( size == 1 ) {
    CanvasWindow * w = m_window_list.front ();
    w->inhibitClose ( false );
  }

  m_window_list.push_back ( window );
  positionCanvas ( window );
  if ( m_inspector != 0 ) resizeCanvas ( window );
  setCurrentCanvas ( window ); 

  CanvasView * view = window->getCanvasView ();
  if ( m_inspector != 0 ) view->setInspector ( m_inspector );
 
}

void
WindowController::
quitOnLastWindowClose ( bool yes )
{
  m_quit = yes;
}

void WindowController::aboutToClose ( CanvasWindow * window )
{
  m_window_list.remove ( window );
  // window will delete itself.

  if ( m_window_list.size() == 1 &&
       m_quit == true ) {
    CanvasWindow * w = m_window_list.front();
    w->inhibitClose ();
  }
  if ( m_window_list.empty() ) {
    if ( m_inspector != 0 ) {
      m_inspector -> hide ();
      if ( m_quit == true ) {
        m_inspector -> close ();
        m_inspector = 0;
      }
      qApp->quit ();
    }
  }
}

void WindowController::hasBeenHidden ( CanvasWindow * window )
{
  bool allhidden = true;
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  list < CanvasWindow * > :: iterator first = m_window_list.begin ();
  while ( first != m_window_list.end() ) {
    CanvasWindow * w = *first++;
    allhidden = w->isMinimized ();
    if ( allhidden == false ) break;
  }
  if ( allhidden == true ) {
    if ( m_inspector != 0 ) m_inspector->hide();
  }
}

void WindowController::unHide ( CanvasWindow * )
{
  if ( m_inspector != 0 )  m_inspector->show();
}

bool WindowController::okToQuit ()
{
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  list < CanvasWindow * > :: iterator first = m_window_list.begin ();
  bool ok = m_quit;

  if ( m_quit == true ) {
    while ( first != m_window_list.end() ) {
      CanvasWindow * window = *first++;
      ok = window->allowClose ();
      if ( ! ok ) break;
    }
  }

  return ok;
}

void
WindowController::
updateActions ()
{
  for_each ( m_window_list.begin(), m_window_list.end(),
             mem_fun ( &CanvasWindow::updateActions ) );
}

void WindowController::closeAllWindows ()
{
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  list < CanvasWindow * > :: iterator first = m_window_list.begin ();
  while ( first != m_window_list.end() ) {
    CanvasWindow * window = *first++;
    window->close ( );
  }

  m_inspector->close();
}

#if QT_VERSION < 0x040000
const QRect & WindowController::getScreenRect ()
#else
QRect WindowController::getScreenRect ()
#endif
{
  QDesktopWidget * dt = QApplication::desktop ();
  int screen = dt->primaryScreen ();

  return dt->screenGeometry ( screen );
}

void WindowController::positionCanvas ( CanvasWindow * window )
{
  const QRect & rect = getScreenRect ();
  QSize size = rect.size ();
  size *= 0.95;
  window->setMaximumSize ( size );

  QPoint p = rect.topLeft ();
  if ( m_active_window != 0 ) {
    p = m_active_window->pos();
    QPoint offset ( 10, 10 );
    p += offset;
  }

  window->move ( p );
}
void
WindowController::
resizeCanvas ( CanvasWindow * window )
{
  if ( m_inspector == 0 ) return; // can't do it without inspector
 
  QPoint insp_pos = m_inspector -> pos ();
  QSize w_size = window -> size ();

  const QRect & rect = getScreenRect ();
  QSize s_size = rect.size ();
  s_size *= 0.95;
  QSize size = window -> sizeHint ();
  size.setHeight ( s_size.height () );
  
  if ( w_size.width() > insp_pos.x () ) {
    double x = insp_pos.x ();
    double w = w_size.width ();
    double scale = 0.90 * ( x / w );
    CanvasView * cv = window -> getCanvasView ();
    cv -> scaleBy ( scale );
    
    QSize size = window -> sizeHint ();
    int width = static_cast < int > ( 0.95 * insp_pos.x () );
    size.setWidth ( width );
    window -> resize ( size );
    }
}

void WindowController::positionInspector ( )
{
  const QRect & rect = getScreenRect ();
  QPoint pos = m_inspector->pos();
  QSize size = m_inspector->size ();
  int new_x = rect.width() - size.width();
  pos.setX ( new_x );

  m_inspector->move ( pos );
}

void WindowController::setCurrentCanvas ( CanvasWindow * canvas )
{
  m_active_window = canvas;
}

CanvasWindow * WindowController::currentCanvas ()
{
  return m_active_window;
}

Inspector * WindowController::getInspector ()
{
  return m_inspector;
}

void
WindowController::
setFirstWindow ()
{
  createInspector ();
  quitOnLastWindowClose ();
  CanvasWindow * window = new CanvasWindow ();
  window->setCaption ();

  window->show();
}

---