#include <VP1TabManager.h>

Inheritance diagram for VP1TabManager:

Collaboration diagram for VP1TabManager:

Classes
class	Imp

Public Slots
void	addNewTab (const QString &, const int &index=-1)

void	renameTab (const QString &tabname, const QString &newtabname)

void	removeTab (const QString &tabname)

void	removeChannel (const QString &channeluniquename)

void	moveChannelToTab (const QString &channeluniquename, const QString &tabname)

void	cloneChannelToTab (const QString &channeluniquename, const QString &tabname)

void	cloneTab (const QString &oldtabname, const QString &newtabname)

void	removeAllTabs ()

void	saveConfigurationToFile (const QString &filename, const bool &askonoverride=true)

void	loadConfigurationFromFile (const QString &filename, const QMap< QString, QString > &availableplugins)

void	showChannelFullScreen (IVP1ChannelWidget *)

void	showCurrentChannelFullScreen ()

void	showTabFullScreen (const QString &tabname)

void	showCurrentTabFullScreen ()

void	showNextTab ()

void	showPreviousTab ()

void	raiseTabBarContextMenu (int, const QPoint &)

void	setSelectedDockWidget (VP1DockWidget *dw=0)

void	setSelectedChannelWidget (IVP1ChannelWidget *cw=0)

Signals
void	tabListChanged (QStringList)

void	selectedChannelChanged (IVP1ChannelWidget *)

void	visibleChannelsChanged (const QSet< IVP1ChannelWidget * > &vis, const QSet< IVP1ChannelWidget * > &soonvis, const double &soonvisbonus)

Public Member Functions
	VP1TabManager (QObject parent, VP1TabWidget , VP1ChannelManager *)

	~VP1TabManager ()

bool	hasTab (const QString &) const

bool	showTab (const QString &)

bool	showFirstChannelWithGivenBasename (const QString &basename)

QString	suggestNewTabName (const QString &oldtabname) const

QString	currentTab () const

QString	currentChannelUniqueName () const

IVP1ChannelWidget *	selectedChannelWidget () const

int	nTabs () const

void	dropOutOfFullScreen ()

QList< IVP1ChannelWidget * >	allChannels () const

const QSet< IVP1ChannelWidget * > &	visibleChannels () const

const QSet< IVP1ChannelWidget * > &	soonVisibleChannels () const

bool	isVisible (IVP1ChannelWidget *) const

void	setTabCruiseMode (const bool &)

QStringList	tabList ()

QString	channelToTab (IVP1ChannelWidget *)

void	launchStereoEditorCurrentTab ()

IVP1ChannelWidget *	addChannelToTab (const QString &channelbasename, const QString &tabname)

void	removeChannelAfterQueueEmpties (const QString &)

Protected Types
typedef QPair< QByteArray, QMultiMap< QString, QByteArray > >	ChanState

Protected Slots
void	currentVisibleChanged ()

void	executePendingChannelRemoval ()

Protected Member Functions
bool	eventFilter (QObject , QEvent )

void	serializeChannelState (IVP1ChannelWidget *, ChanState &state)

void	unserializeChannelState (IVP1ChannelWidget *cw, ChanState tate)

Protected Attributes
Imp *	m_d

Detailed Description

Definition at line 30 of file VP1TabManager.h.

Member Typedef Documentation

◆ ChanState

typedef QPair<QByteArray,QMultiMap<QString,QByteArray> > VP1TabManager::ChanState

protected

Definition at line 103 of file VP1TabManager.h.

Constructor & Destructor Documentation

◆ VP1TabManager()

VP1TabManager::VP1TabManager	(	QObject *	parent,
		VP1TabWidget *	tw,
		VP1ChannelManager *	cm
	)

Definition at line 112 of file VP1TabManager.cxx.

   : QObject(parent), m_d(new Imp(this,tw,cm)) {
  
   m_d->dontEmitVisibilityChanges=false;
   tw->setTabReorderingEnabled(true);
   connect(tw->getVP1TabBar(),SIGNAL(contextMenu( int, const QPoint& )),
       this,SLOT(raiseTabBarContextMenu(int,const QPoint &)));
  
   connect(tw,SIGNAL(currentChanged(int)),this,SLOT(currentVisibleChanged()));
 }

◆ ~VP1TabManager()

VP1TabManager::~VP1TabManager ( )

Definition at line 126 of file VP1TabManager.cxx.

                              {
   while (m_d->tabwidget->count()>0) {
     removeTab( m_d->tabwidget->tabText(0) );
   }
   delete m_d;
 }

Member Function Documentation

◆ addChannelToTab()

IVP1ChannelWidget * VP1TabManager::addChannelToTab	(	const QString &	channelbasename,
		const QString &	tabname
	)

Definition at line 470 of file VP1TabManager.cxx.

                                                                                                         {
  
   #if defined BUILDVP1LIGHT
     bool checkDisallowMultipleChannels = VP1QtUtils::expertSettingIsOn("general","ExpertSettings/VP1_DISALLOW_MULTIPLE_CHANNELS");
   #else
     bool checkDisallowMultipleChannels = VP1QtUtils::environmentVariableIsOn("VP1_DISALLOW_MULTIPLE_CHANNELS");
   #endif
  
   if (m_d->channelwidget_2_dockwidget.size()&&checkDisallowMultipleChannels) {
     QMessageBox::critical(0, "Error - Not allowed to open channel",
               "The possibility to launch multiple channels has been disabled by the environment variable VP1_DISALLOW_MULTIPLE_CHANNELS."
               " This was likely set since some badly written 3D drivers have been known to cause crashes when showing multiple 3D views."
               "\n In order to launch a new channel you must thus first remove the already active channel."
               "\n To disable this behaviour don't set VP1_DISALLOW_MULTIPLE_CHANNELS, or set it to \"0'.",QMessageBox::Ok,QMessageBox::Ok);
     return 0;
   }
  
   if (!m_d->checkTabnameExists(tabname)) return 0;
   if (!m_d->checkChannelNameExists(channelbasename, false)) return 0;
  
   //Then we get the channel:
   QString err;
   IVP1ChannelWidget * cw = m_d->channelmanager->getChannel( channelbasename,err );
   if (!err.isEmpty()) {
     QMessageBox::critical(0, "Error - could not get channel: "+channelbasename,
               "Could not get channel: "+channelbasename
               +"\n\nReason: "+err,QMessageBox::Ok,QMessageBox::Ok);
  
     return 0;
   }
   assert(cw);
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
   cw->setUpdatesEnabled(false);
  
   //Everything went well - go ahead and add the channel to the tab.
   VP1DockWidget *dock = new VP1DockWidget(cw,this);
   connect(dock,SIGNAL(topLevelChanged(bool)),this,SLOT(currentVisibleChanged()));
   connect(dock,SIGNAL(wasSelected(VP1DockWidget*)),this,SLOT(setSelectedDockWidget(VP1DockWidget*)));
  
   QMainWindow * tab = m_d->name_2_tab[tabname];
   tab->addDockWidget(Qt::TopDockWidgetArea, dock);
  
   assert(m_d->channelwidget_2_dockwidget.find(cw)==m_d->channelwidget_2_dockwidget.end());
   m_d->channelwidget_2_dockwidget[cw]=dock;
   assert(m_d->tab_2_channelwidgets.find(tab)!=m_d->tab_2_channelwidgets.end());
   m_d->tab_2_channelwidgets[tab].insert(cw);
   cw->setUpdatesEnabled(true);
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
   return cw;
 }

◆ addNewTab

void VP1TabManager::addNewTab	(	const QString &	tabname,
		const int &	index = `-1`
	)

slot

Definition at line 236 of file VP1TabManager.cxx.

 {
   if (!m_d->checkTabnameNotExists(tabname)) return;
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
  
   QMainWindow * t = new QMainWindow();
   t->setDockNestingEnabled(true);
   if (index==-1)
     m_d->tabwidget->addTab(t,tabname);
   else
     m_d->tabwidget->insertTab(index,t,tabname);
   //NB: Do not call: t->setParent(m_d->tabwidget);
   m_d->name_2_tab[tabname]=t;
   m_d->tab_2_channelwidgets[t] = std::set<IVP1ChannelWidget*>();
   tabListChanged(tabList());
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
 }

◆ allChannels()

QList< IVP1ChannelWidget * > VP1TabManager::allChannels ( ) const

Definition at line 1455 of file VP1TabManager.cxx.

 {
   QList<IVP1ChannelWidget*> l;
   std::map<IVP1ChannelWidget*,VP1DockWidget*>::iterator it, itE(m_d->channelwidget_2_dockwidget.end());
   for(it=m_d->channelwidget_2_dockwidget.begin();it!=itE;++it) {
     l <<it->first;
   }
   return l;
 }

◆ channelToTab()

QString VP1TabManager::channelToTab ( IVP1ChannelWidget * cw )

Definition at line 1406 of file VP1TabManager.cxx.

 {
   QMainWindow * tab = m_d->channel2tab(cw);
   if (!tab)
     return "VP1TabManager::channelToTab ERROR: Unknown CW";
  
   std::map<QString,QMainWindow *>::const_iterator it, itE = m_d->name_2_tab.end();
   for ( it = m_d->name_2_tab.begin(); it!=itE; ++it ) {
     if (it->second == tab)
       return it->first;
   }
   return "";
 }

◆ cloneChannelToTab

void VP1TabManager::cloneChannelToTab	(	const QString &	channeluniquename,
		const QString &	tabname
	)

slot

Definition at line 719 of file VP1TabManager.cxx.

                                                                                              {
   if (!m_d->checkTabnameExists(tabname)) return;
   if (!m_d->checkChannelNameExists(channeluniquename, true)) return;
   IVP1ChannelWidget* cw = m_d->channelmanager->uniqueName2Channel(channeluniquename);
   assert(cw);
   IVP1ChannelWidget * newcw = addChannelToTab(cw->name(),tabname);
   if (newcw) {
     ChanState state;
     serializeChannelState(cw,state);
     unserializeChannelState(newcw,state);
   }
 }

◆ cloneTab

void VP1TabManager::cloneTab	(	const QString &	oldtabname,
		const QString &	newtabname
	)

slot

Definition at line 733 of file VP1TabManager.cxx.

 {
   if (!m_d->checkTabnameExists(oldtabname)) return;
   if (!m_d->checkTabnameNotExists(newtabname)) return;
  
   addNewTab(newtabname);
  
   assert(m_d->name_2_tab.find(newtabname)!=m_d->name_2_tab.end());
  
   QMainWindow * oldtab = m_d->name_2_tab[oldtabname];
  
   assert(m_d->tab_2_channelwidgets.find(oldtab)!=m_d->tab_2_channelwidgets.end());
   std::set<IVP1ChannelWidget*>::const_iterator it = m_d->tab_2_channelwidgets[oldtab].begin();
   std::set<IVP1ChannelWidget*>::const_iterator itE = m_d->tab_2_channelwidgets[oldtab].end();
  
   for (;it!=itE;++it) {
     IVP1ChannelWidget * newcw = addChannelToTab((*it)->name(),newtabname);
     if (newcw) {
       ChanState state;
       serializeChannelState(*it,state);
       unserializeChannelState(newcw,state);
     }
   }
  
   QMainWindow * newtab = m_d->name_2_tab[newtabname];
   QByteArray state = oldtab->saveState();
   if (!newtab->restoreState(state))
     QMessageBox::warning(0, "Warning - Problems cloning channel arrangement",
              "Problems cloning channel arrangement.",QMessageBox::Ok,QMessageBox::Ok);
 }

◆ currentChannelUniqueName()

QString VP1TabManager::currentChannelUniqueName ( ) const

Definition at line 386 of file VP1TabManager.cxx.

 {
   if(!m_d->selecteddockwidget)
     return "";
   else
     return m_d->selecteddockwidget->channelWidget()->unique_name();
 }

◆ currentTab()

QString VP1TabManager::currentTab ( ) const

Definition at line 1036 of file VP1TabManager.cxx.

                                         {
   if (m_d->tabwidget->count()==0)
     return "";
   return m_d->tabwidget->tabText(m_d->tabwidget->currentIndex());
 }

◆ currentVisibleChanged

void VP1TabManager::currentVisibleChanged ( )

protectedslot

Definition at line 1248 of file VP1TabManager.cxx.

                                           {
   if (m_d->dontEmitVisibilityChanges)
     return;
  
   QSet<IVP1ChannelWidget*> visible;
   QSet<IVP1ChannelWidget*> soonvisible;
   double soonbonus(0.0);
  
  
   if (m_d->fullscreen_dockwidget) {
     //Thats an easy one:
     visible << m_d->fullscreen_dockwidget->channelWidget();
   } else if (m_d->fullscreen_tab) {
     //Add all channel widgets from this tab:
     assert(m_d->tab_2_channelwidgets.find(m_d->fullscreen_tab)!=m_d->tab_2_channelwidgets.end());
     std::set<IVP1ChannelWidget*>::iterator  it,itE;
     itE = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].end();
     for (it = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].begin();it!=itE;++it) {
       visible << *it;
     }
     std::cout<<"fullscreen tab:"<<m_d->fullscreen_tab<<std::endl;
   } else {
     //Go through the tabs, if it is the current tab we add all dock
     //widgets, otherwise we add those that are floating:
     QWidget * currentTab = m_d->tabwidget->currentWidget();
     std::map<QMainWindow*,std::set<IVP1ChannelWidget*> >::iterator tabIt,tabItE = m_d->tab_2_channelwidgets.end();
     std::set<IVP1ChannelWidget*>::iterator  it,itE;
     for (tabIt=m_d->tab_2_channelwidgets.begin();tabIt!=tabItE;++tabIt) {
       //Loop over channels;
       it = tabIt->second.begin();
       itE = tabIt->second.end();
       for (;it!=itE;++it) {
     if (currentTab==tabIt->first) {
       //Add all:
       visible << *it;
     } else {
       if (!m_d->fullscreen_tab) {
         //Add only if floating and not a fullscreen tab:
         assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
         if (m_d->channelwidget_2_dockwidget[*it]->isFloating())
           visible << *it;
       }
     }
       }
     }
   }
  
  
   if (m_d->fullscreen_dockwidget) {
     assert(!m_d->tabcruisemode);
     //Soon visible: All floating channels (not this one) and all channels in the present tab.
     soonbonus = 2000;//We are afterall quite sure here what will soon be visible.
     QWidget * currentTab = m_d->tabwidget->currentWidget();
     std::map<QMainWindow*,std::set<IVP1ChannelWidget*> >::iterator tabIt, tabItE = m_d->tab_2_channelwidgets.end();
     std::set<IVP1ChannelWidget*>::iterator  it,itE;
     for (tabIt=m_d->tab_2_channelwidgets.begin();tabIt!=tabItE;++tabIt) {
       //Loop over channels;
       itE = tabIt->second.end();
       for (it=tabIt->second.begin();it!=itE;++it) {
     if (currentTab==tabIt->first) {
       //Add all except the fullscreen'ed one:
       if (*it!=m_d->fullscreen_dockwidget->channelWidget())
         soonvisible << *it;
     } else {
       //Add only if floating:
       assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
       if (m_d->channelwidget_2_dockwidget[*it]->isFloating())
         soonvisible << *it;
     }
       }
     }
   } else if (m_d->fullscreen_tab) {
     if (m_d->tabcruisemode&&m_d->tab_2_channelwidgets.size()>1) {
       //Everything in the next tab.
       soonbonus = 10000;//Very important that the stuff in the next tab gets a high priority!
       QMainWindow * nexttab = m_d->nextTab();
       assert(nexttab);
       std::cout<<"fullscreen tab:"<<m_d->fullscreen_tab<<std::endl;
       std::cout<<"nexttab:"<<nexttab<<std::endl;
       assert(m_d->tab_2_channelwidgets.find(nexttab)!=m_d->tab_2_channelwidgets.end());
       std::set<IVP1ChannelWidget*>::iterator  it,itE=m_d->tab_2_channelwidgets[nexttab].end();
       for(it=m_d->tab_2_channelwidgets[nexttab].begin();it!=itE;++it){
     soonvisible << *it;
       }
     } else {
       //All floating channels not in the present tab
       soonbonus = 1000;//We are rather sure here what will soon be visible.
       QWidget * currentTab = m_d->tabwidget->currentWidget();
       std::map<QMainWindow*,std::set<IVP1ChannelWidget*> >::iterator tabIt, tabItE = m_d->tab_2_channelwidgets.end();
       std::set<IVP1ChannelWidget*>::iterator  it,itE;
       for (tabIt=m_d->tab_2_channelwidgets.begin();tabIt!=tabItE;++tabIt) {
     //Loop over channels;
     itE = tabIt->second.end();
     for (it=tabIt->second.begin();it!=itE;++it) {
       if (m_d->fullscreen_tab!=tabIt->first&&currentTab!=tabIt->first) {
         //Add only if floating:
         assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
         if (m_d->channelwidget_2_dockwidget[*it]->isFloating())
           soonvisible << *it;
       }
     }
       }
     }
   } else {
     //Add everything non-floating from the next tab.
     soonbonus = 200;//A weak guess (fixme: Stronger if tab cruise mode).
     if (m_d->tabwidget->count()>=2) {
       int nexttabindex = (m_d->tabwidget->currentIndex() + 1) % m_d->tabwidget->count();
       QMainWindow* tab = static_cast<QMainWindow*>(m_d->tabwidget->widget(nexttabindex));
       assert(tab);
       assert(m_d->tab_2_channelwidgets.find(tab)!=m_d->tab_2_channelwidgets.end());
       std::set<IVP1ChannelWidget*>::iterator  it,itE=m_d->tab_2_channelwidgets[tab].end();
       for (it=m_d->tab_2_channelwidgets[tab].begin();it!=itE;++it) {
     assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
     if (!m_d->channelwidget_2_dockwidget[*it]->isFloating())
       soonvisible << *it;
       }
     }
   }
  
  
   assert(soonbonus>0.0);
  
 #ifndef NDEBUG
   //There should be no intersection between visible and soon visible!
   QSet<IVP1ChannelWidget*> tmp = visible;
   tmp.intersect(soonvisible);
   assert(tmp.empty());
 #endif
  
   if (visible!=m_d->lastvisible||soonvisible!=m_d->lastsoonvisible) {
     m_d->lastvisible=visible;
     m_d->lastsoonvisible=soonvisible;
     visibleChannelsChanged(visible,soonvisible,soonbonus);
  
     //To ensure that we dont show controllers for channels that are
     //not visible:
     if (m_d->selecteddockwidget) {
       if (!visible.contains(m_d->selecteddockwidget->channelWidget()))
     setSelectedDockWidget(0);
     }
  
     //To make sure we automatically select a channel if it is the only
     //one visible:
     if (visible.count()==1&&(!m_d->selecteddockwidget||*(visible.begin())!=m_d->selecteddockwidget->channelWidget())) {
       assert(m_d->channelwidget_2_dockwidget.find(*(visible.begin()))!=m_d->channelwidget_2_dockwidget.end());
       setSelectedDockWidget(m_d->channelwidget_2_dockwidget[*(visible.begin())]);
     }
   }
 }

◆ dropOutOfFullScreen()

void VP1TabManager::dropOutOfFullScreen ( )

Definition at line 257 of file VP1TabManager.cxx.

 {
   if (!(m_d->fullscreen_dockwidget||m_d->fullscreen_tab))
     return;
  
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
   qApp->removeEventFilter(this);
   QWidget * focuswidget = qApp->focusWidget();
  
   if (m_d->fullscreen_dockwidget) {
     assert(m_d->fullscreen_dockwidget&&m_d->fullscreen_channelwidget);
     m_d->fullscreen_dockwidget->ensureCWHasParent();
     m_d->fullscreen_channelwidget->showNormal();//fixme? Do inside dockwidget?
     m_d->fullscreen_dockwidget=0;
     m_d->fullscreen_channelwidget=0;
   } else {
     assert(m_d->fullscreen_tab);
     QWidget * dummywidget=m_d->tabwidget->widget(m_d->fullscreen_tabindex);
     m_d->tabwidget->removeTab(m_d->fullscreen_tabindex);
     m_d->tabwidget->insertTab(m_d->fullscreen_tabindex, m_d->fullscreen_tab, m_d->fullscreen_tabname );
     delete dummywidget;
     m_d->tabwidget->setCurrentIndex(m_d->fullscreen_tabindex);
     //Make dockwidgets in the tab floatable again
     assert(m_d->tab_2_channelwidgets.find(m_d->fullscreen_tab)!=m_d->tab_2_channelwidgets.end());
     std::set<IVP1ChannelWidget*>::const_iterator it = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].begin();
     std::set<IVP1ChannelWidget*>::const_iterator itE = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].end();
     for (;it!=itE;++it) {
       assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
       VP1DockWidget * dock = m_d->channelwidget_2_dockwidget[*it];
       dock->setFeatures(VP1DockWidget::DockWidgetMovable|VP1DockWidget::DockWidgetFloatable);
       if (m_d->fullscreen_floatingdocks.find(dock)!=m_d->fullscreen_floatingdocks.end())
     dock->setFloating(true);
     }
     m_d->fullscreen_tabname = "";
     m_d->fullscreen_tabindex = -1;
     m_d->fullscreen_tab = 0;
     m_d->fullscreen_floatingdocks.clear();
   }
   if (focuswidget&&!focuswidget->hasFocus())
     focuswidget->setFocus(Qt::OtherFocusReason);
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
 }

◆ eventFilter()

bool VP1TabManager::eventFilter	(	QObject *	,
		QEvent *	event
	)

protected

Definition at line 303 of file VP1TabManager.cxx.

                                                             {
  
   //When in fullscreen mode we monitor all events in the application
   //to look for ESC (leave fullscreen) and to prevent any toplevel
   //widgets from getting closed by e.g. the user pressing ALT+F4.
  
   if (event->type()==QEvent::Close) {
     event->ignore();
     return true;
   }
  
   if (event->type()!=QEvent::KeyPress)
     return false;
  
   QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
   assert(keyEvent);
   if (keyEvent->key()!=Qt::Key_Escape)
     return false;
  
   dropOutOfFullScreen();
  
   //Eat the event:
   return true;
 }

◆ executePendingChannelRemoval

void VP1TabManager::executePendingChannelRemoval ( )

protectedslot

Definition at line 1516 of file VP1TabManager.cxx.

 {
   if (m_d->channelWithPendingRemoval.isEmpty())
     return;
   removeChannel(m_d->channelWithPendingRemoval);
   m_d->channelWithPendingRemoval="";
 }

◆ hasTab()

bool VP1TabManager::hasTab ( const QString & tabname ) const

Definition at line 1421 of file VP1TabManager.cxx.

 {
   return m_d->name_2_tab.find(tabname)!=m_d->name_2_tab.end();
 }

◆ isVisible()

bool VP1TabManager::isVisible ( IVP1ChannelWidget * cw ) const

Definition at line 1479 of file VP1TabManager.cxx.

 {
   return m_d->lastvisible.contains(cw);
 }

◆ launchStereoEditorCurrentTab()

void VP1TabManager::launchStereoEditorCurrentTab ( )

Definition at line 135 of file VP1TabManager.cxx.

                                                  {
     VP1Msg::messageVerbose("VP1TabManager::launchStereoEditorCurrentTab()");
   IVP13DStandardChannelWidget* channel = dynamic_cast<IVP13DStandardChannelWidget*>(selectedChannelWidget());
     if (channel ) {
         channel->launchStereoEditor();
     }
 }

◆ loadConfigurationFromFile

void VP1TabManager::loadConfigurationFromFile	(	const QString &	filename,
		const QMap< QString, QString > &	availableplugins
	)

slot

Definition at line 824 of file VP1TabManager.cxx.

                                                                                                                    {
   if (filename.isEmpty()) {
     QMessageBox::critical(0, "Error - Empty file name provided",
               "Empty file name provided.",QMessageBox::Ok,QMessageBox::Ok);
     return;
   }
   QFileInfo fi(filename);
   if (!fi.exists()) {
     QMessageBox::critical(0, "Error - file does not exists: "+filename,
               "File does not exists: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
     return;
   }
   if (!fi.isReadable()) {
     QMessageBox::critical(0, "Error - file is not readable: "+filename,
               "File is not readable: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
     return;
   }
   //open file
   QFile file(filename);
   if (!file.open(QIODevice::ReadOnly)) {
       QMessageBox::critical(0, "Error - problems opening file "+filename,
                 "Problems opening file: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
       return;
   }
  
   //Read:
   QString head,foot;
   QStringList pluginfiles;
   QMap<QString,QMultiMap<QString,ChanState> > tab2channels;
   QMap<QString,QByteArray> tab2arrangements;
   QStringList tabs_orded;
  
   QByteArray byteArray64;
   QDataStream infile(&file);
   infile >> byteArray64;
  
   QByteArray byteArray = qUncompress(QByteArray::fromBase64(byteArray64));
  
   QBuffer buffer(&byteArray);
   buffer.open(QIODevice::ReadOnly);
   QDataStream in(&buffer);
   in >> head;
   in >> pluginfiles;
   in >> tab2channels;
   in >> tab2arrangements;
   in >> tabs_orded;
   in >> foot;
   buffer.close();
  
   if (head!="This is an automatically generated config file for VP1. [cfg version 003]"
     ||foot!="This is the end of the automatically generated config file for VP1."
       ||tab2channels.count()!=tab2arrangements.count()) {
     QMessageBox::critical(0, "Error - file not in correct format: "+filename,
               "File not in correct format: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
     return;
   }
  
   QStringList pf_withproblem;
   QStringList errormessage;
  
 #ifdef __APPLE__
   QString sharedlibsuffix_correct = ".dylib";
   QString sharedlibsuffix_wrong = ".so";
 #else
   QString sharedlibsuffix_correct = ".so";
   QString sharedlibsuffix_wrong = ".dylib";
 #endif
   
   for(QString pf : pluginfiles) {
     if (pf.endsWith(sharedlibsuffix_wrong)) {
       pf.replace(sharedlibsuffix_wrong, sharedlibsuffix_correct);
     } 
     
     if (!availableplugins.contains(pf)) {
       pf_withproblem<<pf;
       errormessage<<"Could not locate " + pf;
       continue;
     }
     QString pfabsolute = availableplugins[pf];
     QString err;
     if (m_d->channelmanager->channelsInPluginFile(pfabsolute).empty())
       err = m_d->channelmanager->loadPluginFile(pfabsolute);
     if (!err.isEmpty()) {
       pf_withproblem<<pfabsolute;
       errormessage<<err;
     }
   }
  
   if (!pf_withproblem.empty()) {
     assert(pf_withproblem.count()==errormessage.count());
     QString tmp;
     for (int i = 0; i<pf_withproblem.count();++i) {
       tmp += pf_withproblem.value(i)+": "+errormessage.value(i)+"\n";
     }
     QMessageBox::warning(0, "Warning - could not load all plugins",
              "Some or more plugins did not load properly:\n\n"+tmp,QMessageBox::Ok,QMessageBox::Ok);
   }
  
   QString channelsFailureMsg;
   QString tabArrangementFailureMsg;
  
   QString lastaddedtab;
  
   for (const QString& newtabname_infile : tabs_orded) {
     //Check format:
     if (!tab2channels.contains(newtabname_infile)||!tab2arrangements.contains(newtabname_infile)) {
       QMessageBox::critical(0, "Error - file not in correct format: "+filename,
                 "File not in correct format: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
       return;
     }
  
     //We are about to add a new tab. If there is already one with
     //that name we remove it if it is empty:
     QMainWindow * existingtab = m_d->name2tab(newtabname_infile);
     if (existingtab) {
       if (m_d->tab_2_channelwidgets.find(existingtab)==m_d->tab_2_channelwidgets.end()
       ||m_d->tab_2_channelwidgets[existingtab].empty())
     removeTab(newtabname_infile);
     }
  
     //Special case: If there are presently no loaded channels, and
     //only one existing tab named 'My Tab', then we remove that one
     if (m_d->channelwidget_2_dockwidget.empty()
     &&m_d->name_2_tab.size()==1
     &&m_d->name_2_tab.begin()->first=="My Tab")
       removeTab("My Tab");
  
     QString newtabname = suggestNewTabName(newtabname_infile);
     addNewTab(newtabname);
     if (!m_d->checkTabnameExists(newtabname))
       return;
     lastaddedtab=newtabname;
  
     QMapIterator<QString,ChanState> it( tab2channels.value(newtabname_infile) );
  
     while (it.hasNext()) {
       it.next();
       //it.key(): Channel base name.
       //it.value(): Channel state info.
       if (!m_d->channelmanager->baseNameExists(it.key())) {
     channelsFailureMsg += it.key()+" (tab "+newtabname+")"+"\n";
       } else {
     IVP1ChannelWidget * cw = addChannelToTab( it.key(), newtabname );
     if (cw)
       unserializeChannelState(cw,it.value());
     else
       channelsFailureMsg += it.key()+" (tab "+newtabname+")"+"\n";
       }
     }
  
     //Setup layout state:
     assert(m_d->name_2_tab.find(newtabname)!=m_d->name_2_tab.end());
     QMainWindow * tab = m_d->name_2_tab.find(newtabname)->second;
     QByteArray state = tab2arrangements.value(newtabname_infile);
  
     if (!state.isEmpty()) {
       if (!tab->restoreState(state,0/*version*/)) {
     tabArrangementFailureMsg += newtabname+"\n";
       }
     }
   }
   if (!channelsFailureMsg.isEmpty()) {
     QMessageBox::warning(0, "Warning - could not start all channels",
              "Some or more channels were not available to start:\n\n"
              +channelsFailureMsg,QMessageBox::Ok,QMessageBox::Ok);
   }
   if (!tabArrangementFailureMsg.isEmpty()) {
     QMessageBox::warning(0, "Warning - could not arrange channels in all tabs",
              "The arrangement of channels could not be properly determined withing the following tabs:\n\n"
              +tabArrangementFailureMsg,QMessageBox::Ok,QMessageBox::Ok);
   }
   if (!lastaddedtab.isEmpty())
     showTab(lastaddedtab);
 }

◆ moveChannelToTab

void VP1TabManager::moveChannelToTab	(	const QString &	channeluniquename,
		const QString &	tabname
	)

slot

Definition at line 683 of file VP1TabManager.cxx.

                                                                                             {
  
   if (!m_d->checkTabnameExists(tabname)) return;
   if (!m_d->checkChannelNameExists(channeluniquename, true)) return;
  
   QMainWindow * tab_new = m_d->name_2_tab[tabname];
   assert(tab_new);
   IVP1ChannelWidget* cw = m_d->channelmanager->uniqueName2Channel(channeluniquename);
   assert(cw);
  
   assert(m_d->channelwidget_2_dockwidget.find(cw)!=m_d->channelwidget_2_dockwidget.end());
  
   VP1DockWidget* dw = m_d->channelwidget_2_dockwidget[cw];
   assert(dw);
   QMainWindow * tab_old = m_d->channel2tab(cw);
   assert(tab_old);
  
   if (tab_old==tab_new)//Fixme: Make warning here instead, and ensure that the interface does not allow this.
     return;
  
   tab_old->removeDockWidget(dw);
   dw->setParent(tab_new);
   tab_new->addDockWidget(Qt::TopDockWidgetArea, dw);
   dw->show();
  
   //Update tab_2_channelwidgets:
   assert(m_d->tab_2_channelwidgets.find(tab_old)!=m_d->tab_2_channelwidgets.end());
   assert(m_d->tab_2_channelwidgets.find(tab_new)!=m_d->tab_2_channelwidgets.end());
   assert(m_d->tab_2_channelwidgets[tab_old].find(cw)!=m_d->tab_2_channelwidgets[tab_old].end());
   assert(m_d->tab_2_channelwidgets[tab_new].find(cw)==m_d->tab_2_channelwidgets[tab_new].end());//dies!
   m_d->tab_2_channelwidgets[tab_old].erase(m_d->tab_2_channelwidgets[tab_old].find(cw));
   m_d->tab_2_channelwidgets[tab_new].insert(cw);
  
 }

◆ nTabs()

int VP1TabManager::nTabs ( ) const

Definition at line 1043 of file VP1TabManager.cxx.

                                {
   return m_d->tabwidget->count();
 }

◆ raiseTabBarContextMenu

void VP1TabManager::raiseTabBarContextMenu	(	int	i,
		const QPoint &	p
	)

slot

Definition at line 1136 of file VP1TabManager.cxx.

                                                                  {
  
   QString tabname = m_d->tabwidget->tabText(i);
  
   QMenu menu(m_d->tabwidget);
  
   //Construct menu:
   //   menu.addAction("Tab: "+tabname)->setEnabled(false);
   //   menu.addSeparator ();
   QAction* pFullScreenAction = menu.addAction("Show &full Screen");
   menu.addSeparator();
   QAction* pRenameAction = menu.addAction("Re&name tab");
   QAction* pDeleteAction = menu.addAction("&Remove tab");
   menu.addSeparator ();
   QAction* pInsertNewAction = menu.addAction("&Insert new tab");
   QAction* pCloneAction = menu.addAction("&Clone tab");
   menu.addSeparator ();
   QAction* pAddChannelAction = menu.addAction("&Add channel");
   QAction* pRemoveChannelAction = menu.addAction("R&emove channel");
  
   QMenu menu_addchan(m_d->tabwidget);
   QStringList chnls = m_d->channelmanager->availableChannelList();
   if (chnls.empty()) {
     menu_addchan.addAction("No channels available")->setEnabled(false);
   } else {
     for (const QString& chnl : chnls) {
       QString iconloc = m_d->channelmanager->getIconLocation(chnl, true);
       QAction* pChnlAct;
       if (iconloc.isEmpty())
     pChnlAct = menu_addchan.addAction(chnl);
       else
     pChnlAct = menu_addchan.addAction(QIcon(iconloc),chnl);
       pChnlAct->setData("ADDCHAN");
     }
   }
   pAddChannelAction->setMenu(&menu_addchan);
   QStringList chnls_rem = m_d->channelsInTab(tabname);
   if (chnls_rem.empty())
     pFullScreenAction->setEnabled(false);
   QMenu menu_remchan(m_d->tabwidget);
   if (chnls_rem.empty()) {
     menu_remchan.addAction("No channels in tab")->setEnabled(false);
   } else {
     for (const QString& chnl : chnls_rem) {
       QString iconloc = m_d->channelmanager->getIconLocation(chnl, false);
       QAction* pChnlAct;
       if (iconloc.isEmpty())
     pChnlAct = menu_remchan.addAction(chnl);
       else
     pChnlAct = menu_remchan.addAction(QIcon(iconloc),chnl);
       pChnlAct->setData("REMCHAN");
     }
   }
   pRemoveChannelAction->setMenu(&menu_remchan);
  
  
   //Execute
   QAction * selAct = menu.exec(p);
   //
   if (!selAct)
     return;
   if (selAct==pFullScreenAction) {
     showTabFullScreen(tabname);
     return;
   }
   if (selAct==pRenameAction) {
     bool ok;
     QString text = QInputDialog::getText( 0, "Rename tab '"+tabname+"'","Rename tab '"+tabname+"' to:",
                       QLineEdit::Normal, tabname, &ok );
     if (!ok||text==tabname)
       return;
     renameTab(tabname,text);
     return;
   }
   if (selAct==pDeleteAction) {
     removeTab( tabname );
     return;
   }
   if (selAct==pInsertNewAction) {
     bool ok;
     QString newtabname = QInputDialog::getText( 0, "New Tab Name","New tab name:",
                         QLineEdit::Normal, suggestNewTabName("My Tab"), &ok );
     if (!ok||newtabname.isEmpty())
       return;
     addNewTab(newtabname,i+1);
     return;
   }
   if (selAct==pCloneAction) {
     bool ok;
     QString newtabname = QInputDialog::getText( 0, "Cloning '"+tabname+"'.","Cloning '"+tabname+"'. Name of new tab:",
                         QLineEdit::Normal, suggestNewTabName(tabname), &ok );
     if (!ok||newtabname.isEmpty())
       return;
     cloneTab(tabname,newtabname);
     return;
   }
   if (selAct==pAddChannelAction) {
     return;
   }
   //Only option left is channels...
   if (selAct->data()=="ADDCHAN") {
     addChannelToTab( selAct->text(), tabname );
     return;
   }
   if (selAct->data()=="REMCHAN") {
     removeChannel( selAct->text() );
     return;
   }
   std::cout<<"ERROR in VP1TabManager::raiseTabBarContextMenu!!!!!"<<std::endl;
 }

◆ removeAllTabs

void VP1TabManager::removeAllTabs ( )

slot

Definition at line 590 of file VP1TabManager.cxx.

 {
     VP1Msg::messageDebug("VP1TabManager::removeAllTabs()");
     for(const QString& tab : tabList() ) {
         removeTab(tab);
     }
 }

◆ removeChannel

void VP1TabManager::removeChannel ( const QString & channeluniquename )

slot

Definition at line 600 of file VP1TabManager.cxx.

                                                                   {
  
     VP1Msg::messageDebug("VP1TabManager::removeChannel()");
  
   if (!m_d->checkChannelNameExists(channeluniquename, true)) return;
  
   IVP1ChannelWidget* cw = m_d->channelmanager->uniqueName2Channel(channeluniquename);
   assert(cw);
  
   //Unselect if selected:
   if (m_d->selecteddockwidget&&cw==m_d->selecteddockwidget->channelWidget())
     setSelectedDockWidget(0);
  
   QString bn = cw->name();
   cw->setUpdatesEnabled(false);
  
   assert(m_d->channelwidget_2_dockwidget.find(cw)!=m_d->channelwidget_2_dockwidget.end());
   VP1DockWidget * dw = m_d->channelwidget_2_dockwidget[cw];
  
   //Update maps:
   assert(m_d->channelwidget_2_dockwidget.find(cw)!=m_d->channelwidget_2_dockwidget.end());
   m_d->channelwidget_2_dockwidget.erase(m_d->channelwidget_2_dockwidget.find(cw));
  
   //And remove dock from tab.
   QMainWindow * tab = m_d->channel2tab(cw);
   assert(tab);
  
 //   int itab = m_d->tabwidget->indexOf(tab);
 //   assert(itab!=-1);
 //   QString tabname = m_d->tabwidget->tabText(itab);
   //  m_d->tabwidget->removeTab(itab);
   tab->setUpdatesEnabled(false);
   tab->removeDockWidget(dw);
  
  
   //Update map:
   assert(m_d->tab_2_channelwidgets[tab].find(cw)!=m_d->tab_2_channelwidgets[tab].end());
   m_d->tab_2_channelwidgets[tab].erase(m_d->tab_2_channelwidgets[tab].find(cw));
  
   //delete channel
   cw->hide();
   dw->ensureCWHasNoParent();
   [[maybe_unused]] //To avoid compile warning in opt mode.
   bool ok=m_d->channelmanager->deleteChannel(cw->unique_name());
   assert(ok);
  
   //delete dock widget
   delete dw;
  
   tab->setUpdatesEnabled(true);
   //  m_d->tabwidget->insertTab(itab,tab,tabname);
  
   if (m_d->selecteddockwidget==dw) {
     m_d->selecteddockwidget=0;
     selectedChannelChanged(0);
   }
  
   currentVisibleChanged();
 }

◆ removeChannelAfterQueueEmpties()

void VP1TabManager::removeChannelAfterQueueEmpties ( const QString & chnlun )

Definition at line 1509 of file VP1TabManager.cxx.

 {
   m_d->channelWithPendingRemoval = chnlun;
   QTimer::singleShot(0, this, SLOT(executePendingChannelRemoval()));
 }

◆ removeTab

void VP1TabManager::removeTab ( const QString & tabname )

slot

Definition at line 549 of file VP1TabManager.cxx.

                                                       {
  
   if (!m_d->checkTabnameExists(tabname)) return;
  
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
  
   assert(m_d->name_2_tab.find(tabname)!=m_d->name_2_tab.end());
   QMainWindow * tab = m_d->name_2_tab[tabname];
   assert(tab);
   assert(m_d->tab_2_channelwidgets.find(tab)!=m_d->tab_2_channelwidgets.end());
  
   //First, we turn off updates on all channel widgets in the tab (this
   //prevents some crashes due to poorly written channels):
   std::set<IVP1ChannelWidget*>::const_iterator it = m_d->tab_2_channelwidgets[tab].begin();
   std::set<IVP1ChannelWidget*>::const_iterator itE = m_d->tab_2_channelwidgets[tab].end();
   for (;it!=itE;++it) {
     (*it)->setUpdatesEnabled(false);//Fixme: do this on detach/reattach also?
     (*it)->hide();
   }
  
   while(m_d->tab_2_channelwidgets[tab].size()>0) {
     IVP1ChannelWidget * channelwidget = *(m_d->tab_2_channelwidgets[tab].begin());
     removeChannel(channelwidget->unique_name());
   }
  
   //Remove the tab from the tabwidget (this does not actually delete the tab)
   m_d->name_2_tab.erase(m_d->name_2_tab.find(tabname));
   int i = m_d->tabwidget->indexOf(tab);
   assert(i!=-1);
   m_d->tabwidget->removeTab(i);
  
   delete tab;
  
   tabListChanged(tabList());
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
 }

◆ renameTab

void VP1TabManager::renameTab	(	const QString &	tabname,
		const QString &	newtabname
	)

slot

Definition at line 524 of file VP1TabManager.cxx.

                                                                                  {
   if (!m_d->checkTabnameExists(tabname)) return;
   if (!m_d->checkTabnameNotExists(newtabname)) return;
  
   QMainWindow * tab = m_d->name_2_tab[tabname];
  
   m_d->name_2_tab.erase(m_d->name_2_tab.find(tabname));
   m_d->name_2_tab[newtabname]=tab;
   int tabindex = m_d->tabwidget->indexOf(tab);
   assert(tabindex!=-1);
   m_d->tabwidget->setTabText ( tabindex, newtabname );
   tabListChanged(tabList());
 }

◆ saveConfigurationToFile

void VP1TabManager::saveConfigurationToFile	(	const QString &	filename,
		const bool &	askonoverride = `true`
	)

slot

Definition at line 767 of file VP1TabManager.cxx.

                                                                                              {
   if (filename.isEmpty()) {
     QMessageBox::critical(0, "Error - Empty file name provided",
               "Empty file name provided.",QMessageBox::Ok,QMessageBox::Ok);
     return;
   }
   //If file exists, ask to overwrite.
   QFileInfo fi(filename);
   if (fi.exists()) {
     if (!fi.isWritable()) {
       QMessageBox::critical(0, "Error - could not save to file "+filename,
                 "Could not save to file: <i>"+filename+"</i>"
                 +"<br/><br/>Reason: File exists already and is write protected",QMessageBox::Ok,QMessageBox::Ok);
       return;
     }
     if (askonoverride) {
       int ret = QMessageBox::question(0, "File already exists: "+filename,
                       "The file <i>"+filename+"</i> already exists.\n"
                       "Override this file?",
                       QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel);
       if (ret==QMessageBox::Cancel)
     return;
     }
   }
  
   QFile file(filename);
   if (!file.open(QIODevice::WriteOnly)) {
       QMessageBox::critical(0, "Error - problems writing to file "+filename,
                 "Problems writing to file: <i>"+filename+"</i>",QMessageBox::Ok,QMessageBox::Ok);
       return;
   }
  
   //Serialise :
   QMap<QString,QMultiMap<QString,ChanState> > tab2channels;
   QMap<QString,QByteArray> tab2arrangements;
   m_d->serializeTabAndChannelConfigInfo(tab2channels, tab2arrangements);
  
   //Put into bytearray:
   QByteArray byteArray;
   QBuffer buffer(&byteArray);
   buffer.open(QIODevice::WriteOnly);
   QDataStream out(&buffer);
   out<<QString("This is an automatically generated config file for VP1. [cfg version 003]" );
   out<<m_d->channelmanager->serializePluginInfo();
   out<<tab2channels;
   out<<tab2arrangements;
   out<<tabList();//For tab *order*
   out<<QString("This is the end of the automatically generated config file for VP1." );
   buffer.close();
  
   QDataStream outfile(&file);
   outfile<<qCompress(byteArray).toBase64();
  
  
 }

◆ selectedChannelChanged

void VP1TabManager::selectedChannelChanged ( IVP1ChannelWidget * )

signal

◆ selectedChannelWidget()

IVP1ChannelWidget * VP1TabManager::selectedChannelWidget ( ) const

Definition at line 465 of file VP1TabManager.cxx.

                                                               {
   return m_d->selecteddockwidget ? m_d->selecteddockwidget->channelWidget() : 0;
 }

◆ serializeChannelState()

void VP1TabManager::serializeChannelState	(	IVP1ChannelWidget *	cw,
		ChanState &	state
	)

protected

Definition at line 1525 of file VP1TabManager.cxx.

 {
   QMultiMap<QString,QByteArray> sysstate;
   std::set<IVP1System*>::const_iterator it, itE = cw->systems().end();
   for (it=cw->systems().begin();it!=itE;++it) {
     unsigned nVP1Serialise = VP1Serialise::numberOfInstantiations();
     sysstate.insert((*it)->name(),(*it)->saveState());
     if (nVP1Serialise==VP1Serialise::numberOfInstantiations())
       VP1Msg::messageDebug("VP1TabManager WARNING: System "+(*it)->name()
                +" did not use VP1Serialise in implementation of saveState()");
   }
  
   state.first = cw->saveState();
   state.second = sysstate;
 }

◆ setSelectedChannelWidget

void VP1TabManager::setSelectedChannelWidget ( IVP1ChannelWidget * cw = 0 )

slot

Definition at line 347 of file VP1TabManager.cxx.

 {
   if (!cw) {
     setSelectedDockWidget(0);
     return;
   }
   assert(m_d->channelwidget_2_dockwidget.find(cw)!=m_d->channelwidget_2_dockwidget.end());
   setSelectedDockWidget(m_d->channelwidget_2_dockwidget[cw]);
 }

◆ setSelectedDockWidget

void VP1TabManager::setSelectedDockWidget ( VP1DockWidget * dw = 0 )

slot

Definition at line 329 of file VP1TabManager.cxx.

                                                           {
  
     VP1Msg::messageDebug("VP1TabManager::setSelectedDockWidget()");
  
   if ( m_d->selecteddockwidget == dw )
     return;
  
   if (m_d->selecteddockwidget)
     m_d->selecteddockwidget->setUnselected();
  
   m_d->selecteddockwidget=dw;
   if (dw)
     dw->setSelected();
  
   selectedChannelChanged( dw ? dw->channelWidget() : 0 );
 }

◆ setTabCruiseMode()

void VP1TabManager::setTabCruiseMode ( const bool & b )

Definition at line 1485 of file VP1TabManager.cxx.

                                                   {
   if (m_d->tabcruisemode==b)
     return;
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges = true;
   m_d->tabcruisemode = b;
 //   if (m_d->tabcruisemode) {
 //     assert(!fullscreen_dockwidget);//We cant be in FS single-channel mode.
 //     if (fullscreen_tab) {
 //       //Dock all floating (in other tabs) immediately (fixme: only when they need to be shown!.
 //     } else {
 //       //normal mode
 //     }
 //   } else {
 //   }
   //Soonvisible might have changed - so emit changes:
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
 }

◆ showChannelFullScreen

void VP1TabManager::showChannelFullScreen ( IVP1ChannelWidget * cw )

slot

Definition at line 358 of file VP1TabManager.cxx.

                                                               {
   dropOutOfFullScreen();
  
   assert(m_d->channelwidget_2_dockwidget.find(cw)!=m_d->channelwidget_2_dockwidget.end());
   VP1DockWidget* dock = m_d->channelwidget_2_dockwidget[cw];
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
   m_d->fullscreen_dockwidget=dock;
   m_d->fullscreen_channelwidget=cw;
   cw->hide();
   dock->ensureCWHasNoParent();
   cw->showFullScreen();
   qApp->installEventFilter(this);
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
  
  
 }

◆ showCurrentChannelFullScreen

void VP1TabManager::showCurrentChannelFullScreen ( )

slot

Definition at line 378 of file VP1TabManager.cxx.

 {
   if(!m_d->selecteddockwidget)
     return;
   showChannelFullScreen(m_d->selecteddockwidget->channelWidget());
 }

◆ showCurrentTabFullScreen

void VP1TabManager::showCurrentTabFullScreen ( )

slot

Definition at line 455 of file VP1TabManager.cxx.

 {
   if (m_d->tabwidget->count()==0)
     return;
   showTabFullScreen(m_d->tabwidget->tabText(m_d->tabwidget->currentIndex()));
 }

◆ showFirstChannelWithGivenBasename()

bool VP1TabManager::showFirstChannelWithGivenBasename ( const QString & basename )

Definition at line 1427 of file VP1TabManager.cxx.

                                                                              {
  
   std::set<IVP1ChannelWidget*>::const_iterator it2,it2E;
  
   std::map<QMainWindow*,std::set<IVP1ChannelWidget*> >::const_iterator
     it = m_d->tab_2_channelwidgets.begin(), itE=m_d->tab_2_channelwidgets.end();
   for (;it!=itE;++it) {
     it2=it->second.begin();
     it2E=it->second.end();
     for (;it2!=it2E;++it2) {
       if ((*it2)->name()==basename) {
     //Figure out the tabname:
     std::map<QString,QMainWindow *>::const_iterator it3,it3E;
     it3=m_d->name_2_tab.begin();it3E=m_d->name_2_tab.end();
     for (;it3!=it3E;++it3) {
       if (it3->second==it->first)
         return showTab(it3->first);
     }
     //Something is wrong.
     return false;
       }
     }
   }
   return false;
 }

◆ showNextTab

void VP1TabManager::showNextTab ( )

slot

Definition at line 1108 of file VP1TabManager.cxx.

                                {
   if (m_d->tabwidget->count()<=1)
     return;
   assert(!m_d->fullscreen_channelwidget);
   if (m_d->fullscreen_tab) {
     bool save = m_d->dontEmitVisibilityChanges;
     m_d->dontEmitVisibilityChanges=true;
     dropOutOfFullScreen();
     showNextTab();
     showCurrentTabFullScreen();
     m_d->dontEmitVisibilityChanges=save;
   }
   m_d->tabwidget->setCurrentIndex((m_d->tabwidget->currentIndex() + 1) % m_d->tabwidget->count());
 }

◆ showPreviousTab

void VP1TabManager::showPreviousTab ( )

slot

Definition at line 1124 of file VP1TabManager.cxx.

                                     {
   assert(!m_d->fullscreen_channelwidget);
   assert(!m_d->fullscreen_tab);//Fixme: as above.
   if (m_d->tabwidget->count()<=1)
     return;
   int newindex = m_d->tabwidget->currentIndex() - 1;
   if (newindex<0)
     newindex += m_d->tabwidget->count();
   m_d->tabwidget->setCurrentIndex( newindex % m_d->tabwidget->count());
 }

◆ showTab()

bool VP1TabManager::showTab ( const QString & tabname )

Definition at line 1078 of file VP1TabManager.cxx.

                                                  {
   int itarget(-1);
   for (int i = 0; i < m_d->tabwidget->count(); ++i) {
     if (m_d->tabwidget->tabText(i)==tabname) {
       itarget = i;
       break;
     }
   }
   if (itarget<0)
     return false;
   if (itarget==m_d->tabwidget->currentIndex())
     return true;
  
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
  
   bool fullscreentab = (m_d->fullscreen_tab!=0);
   if (m_d->fullscreen_channelwidget||m_d->fullscreen_tab)
     dropOutOfFullScreen();
  
   m_d->tabwidget->setCurrentIndex(itarget);
   if (fullscreentab)
     showCurrentTabFullScreen();
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
   return true;
 }

◆ showTabFullScreen

void VP1TabManager::showTabFullScreen ( const QString & tabname )

slot

Definition at line 395 of file VP1TabManager.cxx.

 {
   int index = 0;
   for (; index < m_d->tabwidget->count(); ++index) {
     if (m_d->tabwidget->tabText(index)==tabname)
       break;
   }
   if (index >= m_d->tabwidget->count())
     return;
   dropOutOfFullScreen();
   //Test that we are not already fs:
   assert(m_d->fullscreen_tabname.isEmpty());
   assert(m_d->fullscreen_tabindex==-1);
   assert(!m_d->fullscreen_tab);
   assert(m_d->fullscreen_floatingdocks.empty());
  
   bool save = m_d->dontEmitVisibilityChanges;
   m_d->dontEmitVisibilityChanges=true;
  
   //Set tab info:
   m_d->fullscreen_tabindex = index;
   m_d->fullscreen_tabname = m_d->tabwidget->tabText(m_d->fullscreen_tabindex);
   assert(m_d->name_2_tab.find(m_d->fullscreen_tabname)!=m_d->name_2_tab.end());
   m_d->fullscreen_tab = m_d->name_2_tab[m_d->fullscreen_tabname];
   //Dock all dockwidgets in the tab that are currently floating, and make them unfloatable:
   assert(m_d->tab_2_channelwidgets.find(m_d->fullscreen_tab)!=m_d->tab_2_channelwidgets.end());
   std::set<IVP1ChannelWidget*>::const_iterator it = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].begin();
   std::set<IVP1ChannelWidget*>::const_iterator itE = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].end();
   for (;it!=itE;++it) {
     assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
     VP1DockWidget * dock = m_d->channelwidget_2_dockwidget[*it];
     if (dock->isFloating()) {
       m_d->fullscreen_floatingdocks.insert(dock);
       dock->setFloating(false);
     }
     dock->setFeatures(VP1DockWidget::DockWidgetMovable);
   }
  
   //Remove tab, put a dummy in its place, and go fullscreen:
   m_d->tabwidget->removeTab(m_d->fullscreen_tabindex);
   m_d->fullscreen_tab->hide();
   m_d->fullscreen_tab->setParent(0);
   m_d->tabwidget->insertTab ( m_d->fullscreen_tabindex, new QWidget(), m_d->fullscreen_tabname );
   m_d->fullscreen_tab->showFullScreen();
    //Needs an extra update apparently, to get selection frame properly enlarged
   it = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].begin();
   itE = m_d->tab_2_channelwidgets[m_d->fullscreen_tab].end();
   for (;it!=itE;++it) {
     assert(m_d->channelwidget_2_dockwidget.find(*it)!=m_d->channelwidget_2_dockwidget.end());
     VP1DockWidget * dock = m_d->channelwidget_2_dockwidget[*it];
     dock->update();
   }
  
   qApp->installEventFilter(this);
   m_d->dontEmitVisibilityChanges=save;
   currentVisibleChanged();
  
 }

◆ soonVisibleChannels()

const QSet< IVP1ChannelWidget * > & VP1TabManager::soonVisibleChannels ( ) const

Definition at line 1472 of file VP1TabManager.cxx.

 {
   return m_d->lastsoonvisible;
 }

◆ suggestNewTabName()

QString VP1TabManager::suggestNewTabName ( const QString & oldtabname ) const

Definition at line 1027 of file VP1TabManager.cxx.

                                                                         {
   QString newtabname=oldtabname;
   int i = 1;
   while (m_d->name_2_tab.find(newtabname)!=m_d->name_2_tab.end())
     newtabname=oldtabname+" "+QString::number(++i);
   return newtabname;
 }

◆ tabList()

QStringList VP1TabManager::tabList ( )

Definition at line 539 of file VP1TabManager.cxx.

                                    {
   QStringList l;
   for (int i = 0; i < m_d->tabwidget->count(); ++i) {
     l<<m_d->tabwidget->tabText(i);
   }
   return l;
 }

◆ tabListChanged

void VP1TabManager::tabListChanged ( QStringList )

signal

◆ unserializeChannelState()

void VP1TabManager::unserializeChannelState	(	IVP1ChannelWidget *	cw,
		ChanState	tate
	)

protected

Definition at line 1542 of file VP1TabManager.cxx.

 {
   if(!state.first.isEmpty())
     cw->restoreFromState(state.first);
  
   QList<QString> storedSystems = state.second.keys();
  
   std::set<IVP1System*>::const_iterator itsys, itsysE = cw->systems().end();
   for (itsys=cw->systems().begin();itsys!=itsysE;++itsys) {
     QString name = (*itsys)->name();
     //Look for the first entry with this system name in the list. If it is there - use it and remove it:
     QMultiMap<QString,QByteArray>::iterator it_state = state.second.find(name);
     if (it_state != state.second.end()) {
       storedSystems.removeAll(name);
 //       //Lets make sure that we advance it_state to the LAST of the elements with the same key:
 //       QMultiMap<QString,QByteArray>::iterator it_state_tmp = it_state;
 //       while ( it_state_tmp != state.second.end() && it_state_tmp.key() == (*itsys)->name() ) {
 //  it_state=it_state_tmp;
 //  ++it_state_tmp;
 //       }
       //Fixme ^^^: The above has not been tested on any channel which
       //actually has multiple similar systems. So might be buggy.
  
       //Use it and remove it from array:
       if (!it_state.value().isEmpty()) {
     unsigned nVP1Deserialise = VP1Deserialise::numberOfInstantiations();
     (*itsys)->restoreFromState(it_state.value());
     if (nVP1Deserialise==VP1Deserialise::numberOfInstantiations())
       VP1Msg::messageDebug("VP1TabManager WARNING: System "+(*itsys)->name()
                    +" did not use VP1Deserialise in implementation of restoreFromState()");
       }
       //state.second.erase(it_state);
     } else {
       std::cout<<"VP1TabManager::unserializeChannelState Warning: Did not find state data for system "<<name.toStdString()<<std::endl;
     }
   }
   for (const QString& name : storedSystems)
     std::cout<<"VP1TabManager::unserializeChannelState Warning: Did not use stored configuration for system "<<name.toStdString()<<std::endl;
 }

◆ visibleChannels()

const QSet< IVP1ChannelWidget * > & VP1TabManager::visibleChannels ( ) const

Definition at line 1467 of file VP1TabManager.cxx.

 {
   return m_d->lastvisible;
 }

◆ visibleChannelsChanged

void VP1TabManager::visibleChannelsChanged	(	const QSet< IVP1ChannelWidget * > &	vis,
		const QSet< IVP1ChannelWidget * > &	soonvis,
		const double &	soonvisbonus
	)

signal

Member Data Documentation

◆ m_d

Imp* VP1TabManager::m_d

protected

Definition at line 100 of file VP1TabManager.h.

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

Classes

Public Slots

Signals

Public Member Functions

Protected Types

Protected Slots

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ ChanState

Constructor & Destructor Documentation

◆ VP1TabManager()

◆ ~VP1TabManager()

Member Function Documentation

◆ addChannelToTab()

◆ addNewTab

◆ allChannels()

◆ channelToTab()

◆ cloneChannelToTab

◆ cloneTab

◆ currentChannelUniqueName()

◆ currentTab()

◆ currentVisibleChanged

◆ dropOutOfFullScreen()

◆ eventFilter()

◆ executePendingChannelRemoval

◆ hasTab()

◆ isVisible()

◆ launchStereoEditorCurrentTab()

◆ loadConfigurationFromFile

◆ moveChannelToTab

◆ nTabs()

◆ raiseTabBarContextMenu

◆ removeAllTabs

◆ removeChannel

◆ removeChannelAfterQueueEmpties()

◆ removeTab

◆ renameTab

◆ saveConfigurationToFile

◆ selectedChannelChanged

◆ selectedChannelWidget()

◆ serializeChannelState()

◆ setSelectedChannelWidget

◆ setSelectedDockWidget

◆ setTabCruiseMode()

◆ showChannelFullScreen

◆ showCurrentChannelFullScreen

◆ showCurrentTabFullScreen

◆ showFirstChannelWithGivenBasename()

◆ showNextTab

◆ showPreviousTab

◆ showTab()

◆ showTabFullScreen

◆ soonVisibleChannels()

◆ suggestNewTabName()

◆ tabList()

◆ tabListChanged

◆ unserializeChannelState()

◆ visibleChannels()

◆ visibleChannelsChanged

Member Data Documentation

◆ m_d