controller that manages the positioning and stacking of QmitkOverlays More...

#include <QmitkOverlayController.h>

Collaboration diagram for QmitkOverlayController:

Public Slots
void	AdjustOverlayPosition ()
	adjusts the position of all overlays to the position of the RenderWindow
void	UpdateAllOverlays ()
Public Member Functions
	QmitkOverlayController (QmitkRenderWindow rw, mitk::PropertyList pl=NULL)
	constructor with mandatory QmitkRenderWindow and optional mitk::PropertyList
virtual	~QmitkOverlayController ()
void	AddOverlay (QmitkOverlay *)
	adds an instance of QmitkOverlay to the RenderWindow
void	RemoveOverlay (QmitkOverlay *)
void	SetOverlayVisibility (bool visible)
	setting the visibility of all overlays
mitk::PropertyList *	GetPropertyList ()
	getter for the RenderWindow-specific PropertyList
void	SetPropertyList (mitk::PropertyList *)
	setter for the RenderWindow-specific PropertyList
Protected Types
typedef std::map < QmitkOverlay::DisplayPosition, QWidget * >	OverlayPositionMap
typedef std::vector < QmitkOverlay * >	OverlayVector
Protected Member Functions
void	InitializeOverlayLayout ()
	setting up the widgets that will hold all overlays
virtual void	AlignOverlays ()
	re-aligning the overlays - not implemented yet
void	InitializeWidget (QmitkOverlay::DisplayPosition pos)
	initializes one QWidget - internally used by InitializeOverlayLayout()
void	RestackOverlays (QmitkOverlay::DisplayPosition pos)
void	UpdateOverlayData (QmitkOverlay *overlay)
Protected Attributes
OverlayVector	m_AllOverlays
	all QmitkOverlays that are currently added
OverlayPositionMap	m_PositionedOverlays
	all possible positions and the QWidgets representing the corresponding QmitkOverlays
QmitkRenderWindow *	m_RenderWindow
	RenderWindow that all Overlays will be added to.
mitk::PropertyList::Pointer	m_PropertyList
	PropertyList for RenderWindow-specific properties.

Detailed Description

controller that manages the positioning and stacking of QmitkOverlays

This controller manages all QmitkOverlays of one QmitkRenderWindow.

When constructed, it creates one QWidget for each possible display-position and sets the appropriate attributes and layouts.

It is possible to add new Overlays using AddOverlay( QmitkOverlay ). This overlay will be added to the correct Widget according to its destined position (stored in QmitkOverlay). If this widget already holds an overlay, the layer-property is taken into account. If no layer has been set, the overlay will be appended at the end.

It is possible to set the visibility of all overlays at a time using SetOverlayVisibility(bool).

RenderWindow specific properties can be set using the internal mitk::PropertyList. This propertyList and the 'default' propertyList of the RenderingManager will be concatenated before the overlay is set up. If one property exists in both propertyLists, the one in the QmitkOverlayController will be used!

See also:: QmitkOverlay; QmitkRenderWindow

Definition at line 60 of file QmitkOverlayController.h.

Member Typedef Documentation

typedef std::map< QmitkOverlay::DisplayPosition, QWidget* > QmitkOverlayController::OverlayPositionMap [protected]

Definition at line 137 of file QmitkOverlayController.h.

typedef std::vector< QmitkOverlay* > QmitkOverlayController::OverlayVector [protected]

Definition at line 138 of file QmitkOverlayController.h.

Constructor & Destructor Documentation

QmitkOverlayController::QmitkOverlayController	(	QmitkRenderWindow *	rw,
		mitk::PropertyList *	pl = `NULL`
	)

constructor with mandatory QmitkRenderWindow and optional mitk::PropertyList

Definition at line 29 of file QmitkOverlayController.cpp.

References AdjustOverlayPosition(), InitializeOverlayLayout(), m_PropertyList, m_RenderWindow, MITK_ERROR, mitk::PropertyList::New(), and SetOverlayVisibility().

: QObject(), m_RenderWindow( rw ), m_PropertyList( pl )
{
  if ( m_RenderWindow == NULL )
  {
    MITK_ERROR << "invalid QmitkRenderWindow";
    return;
  }

  connect( rw, SIGNAL( Moved() ), this, SLOT( AdjustOverlayPosition() ) );

  this->InitializeOverlayLayout();
  this->AdjustOverlayPosition();
  this->SetOverlayVisibility( true );

  if ( m_PropertyList.IsNull() )
    m_PropertyList = mitk::PropertyList::New();

}

QmitkOverlayController::~QmitkOverlayController ( ) [virtual]

Definition at line 49 of file QmitkOverlayController.cpp.

{
}

Member Function Documentation

void QmitkOverlayController::AddOverlay ( QmitkOverlay * overlay )

adds an instance of QmitkOverlay to the RenderWindow

This method adds the given QmitkOverlay as a sub-widget to the registered RenderWindow. It will be added to the correct position in the RenderWindow as it's defined by the overlays position-variable. The layer-property will only be considered if necessary.

Definition at line 262 of file QmitkOverlayController.cpp.

References AdjustOverlayPosition(), QmitkOverlay::GetPosition(), mitk::RenderingManager::GetPropertyList(), mitk::RenderWindowBase::GetRenderer(), mitk::BaseRenderer::GetRenderingManager(), QmitkOverlay::GetWidget(), m_AllOverlays, m_PositionedOverlays, m_PropertyList, m_RenderWindow, MITK_ERROR, RestackOverlays(), and UpdateOverlayData().

{
  // if no renderwindow has been set, it's not possible to add overlays...
  if ( m_RenderWindow == NULL )
  {
    MITK_ERROR << "invalid QmitkRenderWindow";
    return;
  }

  if ( overlay != NULL )
  {
    // get desired position and layer of the overlay
    QmitkOverlay::DisplayPosition pos = overlay->GetPosition();

    // concatenate local propertyList and propertyList of the RenderingManager
    // local properties have priority as they are not overwritten if preset in both 
    m_PropertyList->ConcatenatePropertyList( m_RenderWindow->GetRenderer()->GetRenderingManager()->GetPropertyList(), false );

    // setting up the overlay with the correct properties ...
    this->UpdateOverlayData( overlay );
    // ... and add it to the OverlayContainer in the RenderWindow
    overlay->GetWidget()->setParent( m_PositionedOverlays[ pos ] );
    
    // add overlay to list of all overlays and correctly put it into the layering
    m_AllOverlays.push_back( overlay );
    this->RestackOverlays( pos );

    // make sure the widget containing the added overlay is shown ...
    m_PositionedOverlays[ pos ]->show();
    // ... and reset the position of the widgets
    this->AdjustOverlayPosition();
  }
}

void QmitkOverlayController::AdjustOverlayPosition ( ) [slot]

adjusts the position of all overlays to the position of the RenderWindow

This method updates the position of all Widgets according to the position of the RenderWindow and the extend of the overlays.

Definition at line 177 of file QmitkOverlayController.cpp.

References QmitkOverlay::bottom_Center, QmitkOverlay::bottom_Left, QmitkOverlay::bottom_Right, m_PositionedOverlays, m_RenderWindow, QmitkOverlay::middle_Left, QmitkOverlay::middle_Right, QmitkOverlay::top_Center, QmitkOverlay::top_Left, and QmitkOverlay::top_Right.

Referenced by AddOverlay(), QmitkOverlayController(), and RemoveOverlay().

{
  // setting position of top-left overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::top_Left ]->isVisible() )
  {
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint(0,0) );
    m_PositionedOverlays[ QmitkOverlay::top_Left ]->move( pos.x(), pos.y() );
  }

  // setting position of top-center overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::top_Center ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::top_Center ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint( m_RenderWindow->size().width()/2, 0 ) ) ;
    widget->move( pos.x() - widget->size().width()/2, pos.y() );
  }

  // setting position of top-right overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::top_Right ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::top_Right ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint( m_RenderWindow->size().width(), 0 ) ) ;
    widget->move( pos.x() - widget->size().width(), pos.y() );
  }

  // setting position of middle-left overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::middle_Left ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::middle_Left ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint( 0, m_RenderWindow->size().height()/2 ) ) ;
    widget->move( pos.x(), pos.y() - widget->size().height()/2 );
  }

  // setting position of middle-right overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::middle_Right ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::middle_Right ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint( m_RenderWindow->size().width(), m_RenderWindow->size().height()/2 ) ) ;
    widget->move( pos.x() - widget->size().width(), pos.y() - widget->size().height()/2 );
  }

  // setting position of bottom-left overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::bottom_Left ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::bottom_Left ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint( 0, m_RenderWindow->size().height() ) ) ;
    widget->move( pos.x(), pos.y() - widget->size().height() );
  }

  // setting position of bottom-center overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::bottom_Center ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::bottom_Center ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint(  m_RenderWindow->size().width()/2, m_RenderWindow->size().height() ) ) ;
    widget->move( pos.x() - widget->size().width()/2, pos.y() - widget->size().height() );
  }

  // setting position of bottom-right overlay-container
  if ( m_PositionedOverlays[ QmitkOverlay::bottom_Right ]->isVisible() )
  {
    QWidget* widget = m_PositionedOverlays[ QmitkOverlay::bottom_Right ];
    QPoint pos = m_RenderWindow->mapToGlobal( QPoint(  m_RenderWindow->size().width(), m_RenderWindow->size().height() ) ) ;
    widget->move( pos.x() - widget->size().width(), pos.y() - widget->size().height() );
  }

}

void QmitkOverlayController::AlignOverlays ( ) [protected, virtual]

re-aligning the overlays - not implemented yet

Definition at line 332 of file QmitkOverlayController.cpp.

{
  //OverlayVector::iterator overlayIter;

  //for ( overlayIter=m_AllOverlays.begin(); overlayIter!=m_AllOverlays.end(); overlayIter++ )
  //{
  //  int stackLayer = dynamic_cast<QBoxLayout*>( m_PositionedOverlays[ (*overlayIter)->GetPosition() ]->layout() )->isEmpty() ? 0 : layer;
  //  dynamic_cast<QBoxLayout*>( m_PositionedOverlays[ (*overlayIter)->GetPosition() ]->layout() )->addWidget( (*overlayIter)->GetWidget(), stackLayer, Qt::AlignLeft );
  //}
}

mitk::PropertyList* QmitkOverlayController::GetPropertyList ( )

getter for the RenderWindow-specific PropertyList

void QmitkOverlayController::InitializeOverlayLayout ( ) [protected]

setting up the widgets that will hold all overlays

This method sets up the 8 QWidgets that will later hold all QmitkOverlays. This includes the correct setting of layouts, alignments and the widget attributes necessary to achieve a translucent background and correct rendering on all platforms.

Definition at line 53 of file QmitkOverlayController.cpp.

References QmitkOverlay::bottom_Center, QmitkOverlay::bottom_Left, QmitkOverlay::bottom_Right, InitializeWidget(), QmitkOverlay::middle_Left, QmitkOverlay::middle_Right, QmitkOverlay::top_Center, QmitkOverlay::top_Left, and QmitkOverlay::top_Right.

Referenced by QmitkOverlayController().

{
  // setup widget for each position
  this->InitializeWidget( QmitkOverlay::top_Left );
  this->InitializeWidget( QmitkOverlay::top_Center );
  this->InitializeWidget( QmitkOverlay::top_Right );
  this->InitializeWidget( QmitkOverlay::middle_Left );
  this->InitializeWidget( QmitkOverlay::middle_Right );
  this->InitializeWidget( QmitkOverlay::bottom_Left );
  this->InitializeWidget( QmitkOverlay::bottom_Center );
  this->InitializeWidget( QmitkOverlay::bottom_Right );

}

void QmitkOverlayController::InitializeWidget ( QmitkOverlay::DisplayPosition pos ) [protected]

initializes one QWidget - internally used by InitializeOverlayLayout()

Definition at line 67 of file QmitkOverlayController.cpp.

References QmitkOverlay::bottom_Center, QmitkOverlay::bottom_Left, QmitkOverlay::bottom_Right, m_PositionedOverlays, m_RenderWindow, QmitkOverlay::middle_Left, QmitkOverlay::middle_Right, QmitkOverlay::top_Center, QmitkOverlay::top_Left, and QmitkOverlay::top_Right.

Referenced by InitializeOverlayLayout().

{
  // create a new QWidget as Tool & FramelessWindowHint
  m_PositionedOverlays[ pos ] = new QWidget( m_RenderWindow, Qt::Tool | Qt::FramelessWindowHint );
  
  // autoFillBackGround(false) and WA_TranslucentBackground = true are needed to have a translucent background 
  // transparency does NOT work under Win-XP 32-Bit --> paint black background

#if !defined(_WIN32) || defined(_WIN64)
  m_PositionedOverlays[ pos ]->setAttribute( Qt::WA_TranslucentBackground, true );
#else
  m_PositionedOverlays[ pos ]->setStyleSheet( "QWidget { background: black }" );
  m_PositionedOverlays[ pos ]->setAttribute( Qt::WA_TranslucentBackground, false );
#endif

  // X11 specific attributes
  m_PositionedOverlays[ pos ]->setAttribute( Qt::WA_X11NetWmWindowTypeUtility, true );

  // mac-specific attributes:
  // making sure overlays are even visible if RenderWindow does not have the focus (not default for Qt::Tool on mac)
  m_PositionedOverlays[ pos ]->setAttribute( Qt::WA_MacAlwaysShowToolWindow, true );
  // testing something
  m_PositionedOverlays[ pos ]->setAttribute( Qt::WA_MacShowFocusRect, false );

  // overlays should not get the focus
  m_PositionedOverlays[ pos ]->setFocusPolicy( Qt::NoFocus );

  // setting the color of the background to transparent - not sure it's needed after the attributes have been set above
  QPalette p = QPalette();
  p.setColor( QPalette::Window, Qt::transparent );
  m_PositionedOverlays[ pos ]->setPalette( p );

  // setting position-specific properties
  switch ( pos )
  {
  case QmitkOverlay::top_Left : 
    {
      // adding left-aligned top-to-bottom layout
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::TopToBottom );
      layout->setAlignment( Qt::AlignLeft );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  case QmitkOverlay::top_Center : 
    {
      // adding center-aligned top-to-bottom layout
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::TopToBottom );
      layout->setAlignment( Qt::AlignCenter );
      layout->setAlignment( Qt::AlignLeft );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  case QmitkOverlay::top_Right :
    {
      // adding right-aligned top-to-bottom layout
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::TopToBottom );
      layout->setAlignment( Qt::AlignRight );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  case QmitkOverlay::middle_Left : 
    {
      // adding left-aligned left-to-right layout
      QHBoxLayout* layout = new QHBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::LeftToRight );
      layout->setAlignment( Qt::AlignLeft );
      layout->setSpacing( 3 );
      break;

    }
  case QmitkOverlay::middle_Right : 
    {
      // adding right-aligned right-to-left layout
      QHBoxLayout* layout = new QHBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::RightToLeft );
      layout->setAlignment( Qt::AlignRight );
      layout->setSpacing( 3 );
      break;
    }
  case QmitkOverlay::bottom_Left : 
    {
      // adding left-aligned bottom-to-top layout
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::BottomToTop );
      layout->setAlignment( Qt::AlignLeft );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  case QmitkOverlay::bottom_Center : 
    {
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::BottomToTop );
      layout->setAlignment( Qt::AlignCenter );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  case QmitkOverlay::bottom_Right :
    {
      QVBoxLayout* layout = new QVBoxLayout( m_PositionedOverlays[ pos ] );
      layout->setDirection( QBoxLayout::BottomToTop );
      layout->setAlignment( Qt::AlignRight );
      m_PositionedOverlays[ pos ]->layout()->setSpacing( 0 );
      break;
    }
  }
}

void QmitkOverlayController::RemoveOverlay ( QmitkOverlay * overlay )

Definition at line 301 of file QmitkOverlayController.cpp.

References AdjustOverlayPosition(), QmitkOverlay::GetPosition(), QmitkOverlay::GetWidget(), m_AllOverlays, m_PositionedOverlays, and RestackOverlays().

{
  if ( overlay != NULL )
  {
    // get desired position and layer of the overlay
    QmitkOverlay::DisplayPosition pos = overlay->GetPosition();

    OverlayVector::iterator iter = std::find( m_AllOverlays.begin(), m_AllOverlays.end(), overlay );
    
    if ( iter != m_AllOverlays.end() )
    {
      m_AllOverlays.erase( iter );
      overlay->GetWidget()->setParent( NULL );
      overlay->GetWidget()->hide();

      if ( m_PositionedOverlays[ pos ]->layout()->isEmpty() )
      {
        m_PositionedOverlays[ pos ]->hide();
      }
      else
      {
        this->RestackOverlays( pos );
        // reset the position of the widgets
        this->AdjustOverlayPosition();
      }
    }
  }
}

void QmitkOverlayController::RestackOverlays ( QmitkOverlay::DisplayPosition pos ) [protected]

Definition at line 343 of file QmitkOverlayController.cpp.

References QmitkOverlay::bottom_Center, QmitkOverlay::bottom_Left, QmitkOverlay::bottom_Right, m_AllOverlays, m_PositionedOverlays, QmitkOverlay::middle_Left, QmitkOverlay::middle_Right, QuadProgPP::sort(), QmitkOverlay::top_Center, QmitkOverlay::top_Left, and QmitkOverlay::top_Right.

Referenced by AddOverlay(), and RemoveOverlay().

{
  OverlayVector::iterator overlayIter;
  QBoxLayout* layout = dynamic_cast<QBoxLayout*>( m_PositionedOverlays[ pos ]->layout() );

  std::sort( m_AllOverlays.begin(), m_AllOverlays.end() );

  for ( overlayIter=m_AllOverlays.begin(); overlayIter!=m_AllOverlays.end(); overlayIter++ )
  {
    // do nothing if the overlay is not in the right position
    if ( (*overlayIter)->GetPosition() != pos )
    {
      continue;
    }

    // determine the desired stacking layer
    // if the overlay-container is empty, simply append the overlay to the list
    // if it's not empty, use the layer of the overlay
    unsigned int layer = (*overlayIter)->GetLayer();
    int stackLayer = 0;
    if ( !layout->isEmpty() )
    {
      stackLayer = layer;
    }
    
    switch ( pos )
    {
      // same alignment for all lefts, ...
    case QmitkOverlay::top_Left : {}
    case QmitkOverlay::middle_Left : {}
    case QmitkOverlay::bottom_Left : 
      {
        layout->insertWidget( stackLayer, (*overlayIter)->GetWidget(), 0, Qt::AlignLeft );    
        break;
      }
      // ... for all centers, ...
    case QmitkOverlay::top_Center : {}
    case QmitkOverlay::bottom_Center :
      {
        layout->insertWidget( stackLayer, (*overlayIter)->GetWidget(), 0, Qt::AlignCenter );
        break;
      }
      // ... and for all rights
    case QmitkOverlay::top_Right : {}
    case QmitkOverlay::middle_Right : {}
    case QmitkOverlay::bottom_Right : 
      {
        layout->insertWidget( stackLayer, (*overlayIter)->GetWidget(), 0, Qt::AlignRight );    
        break;
      }
    }
  }

}

void QmitkOverlayController::SetOverlayVisibility ( bool visible )

setting the visibility of all overlays

Definition at line 245 of file QmitkOverlayController.cpp.

References QmitkOverlay::GetWidget(), and m_AllOverlays.

Referenced by QmitkOverlayController().

{
  // setting visibility of all registered overlays to 'visible'
  foreach( QmitkOverlay* overlay, m_AllOverlays )
  {
    if ( visible )
    {
      overlay->GetWidget()->show();
    }
    else
    {
      overlay->GetWidget()->hide();
    }
  }
}

void QmitkOverlayController::SetPropertyList ( mitk::PropertyList * )

setter for the RenderWindow-specific PropertyList

void QmitkOverlayController::UpdateAllOverlays ( ) [slot]

Definition at line 398 of file QmitkOverlayController.cpp.

References m_AllOverlays, and UpdateOverlayData().

{
  foreach( QmitkOverlay* overlay, m_AllOverlays )
  {
    this->UpdateOverlayData( overlay );
  }
}

void QmitkOverlayController::UpdateOverlayData ( QmitkOverlay * overlay ) [protected]

Definition at line 296 of file QmitkOverlayController.cpp.

References QmitkOverlay::GenerateData(), and m_PropertyList.

Referenced by AddOverlay(), and UpdateAllOverlays().

{
  overlay->GenerateData( m_PropertyList );
}

Member Data Documentation

OverlayVector QmitkOverlayController::m_AllOverlays [protected]

all QmitkOverlays that are currently added

Definition at line 143 of file QmitkOverlayController.h.

Referenced by AddOverlay(), RemoveOverlay(), RestackOverlays(), SetOverlayVisibility(), and UpdateAllOverlays().

OverlayPositionMap QmitkOverlayController::m_PositionedOverlays [protected]

all possible positions and the QWidgets representing the corresponding QmitkOverlays

Definition at line 148 of file QmitkOverlayController.h.

Referenced by AddOverlay(), AdjustOverlayPosition(), InitializeWidget(), RemoveOverlay(), and RestackOverlays().

mitk::PropertyList::Pointer QmitkOverlayController::m_PropertyList [protected]

PropertyList for RenderWindow-specific properties.

Definition at line 158 of file QmitkOverlayController.h.

Referenced by AddOverlay(), QmitkOverlayController(), and UpdateOverlayData().

QmitkRenderWindow* QmitkOverlayController::m_RenderWindow [protected]

RenderWindow that all Overlays will be added to.

Definition at line 153 of file QmitkOverlayController.h.

Referenced by AddOverlay(), AdjustOverlayPosition(), InitializeWidget(), and QmitkOverlayController().

The documentation for this class was generated from the following files:

QmitkOverlayController Class Reference

Public Slots

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation