HelpWindow::HelpWindow(QWidget *parent) :
QDockWidget (parent)
{
setMinimumWidth (MIN_WIDTH);
setMinimumHeight (MIN_HEIGHT);
QHelpEngine *helpEngine = new QHelpEngine (helpPath());
helpEngine->setupData();
QTabWidget *tabs = new QTabWidget;
tabs->addTab (helpEngine->contentWidget(),
tr ("Contents"));
tabs->addTab (helpEngine->indexWidget(),
tr ("Index"));
HelpBrowser *browser = new HelpBrowser (helpEngine);
// URL is constructed from <namespace>, <virtualFolder> and <file> in engauge.qhp
browser->setSource (QUrl ("qthelp://engaugedigitizer.net/doc/index.html"));
connect (helpEngine->contentWidget (), SIGNAL (linkActivated (QUrl)), browser, SLOT (setSource (QUrl)));
connect (helpEngine->indexWidget (), SIGNAL (linkActivated (QUrl, QString)), browser, SLOT (setSource (QUrl)));
QSplitter *splitter = new QSplitter (Qt::Horizontal);
splitter->insertWidget (0, tabs);
splitter->insertWidget (1, browser);
setWidget (splitter);
}
void KateViewManager::splitViewSpace( KateViewSpace* vs, // = 0
Qt::Orientation o )// = Qt::Horizontal
{
// emergency: fallback to activeViewSpace, and if still invalid, abort
if (!vs) vs = activeViewSpace();
if (!vs) return;
// get current splitter, and abort if null
QSplitter *currentSplitter = qobject_cast<QSplitter*>(vs->parentWidget());
if (!currentSplitter) return;
// index where to insert new splitter/viewspace
const int index = currentSplitter->indexOf( vs );
// create new viewspace
KateViewSpace* vsNew = new KateViewSpace( this );
// only 1 children -> we are the root container. So simply set the orientation
// and add the new view space, then correct the sizes to 50%:50%
if (currentSplitter->count() == 1)
{
if( currentSplitter->orientation() != o )
currentSplitter->setOrientation( o );
QList<int> sizes = currentSplitter->sizes();
sizes << (sizes.first() - currentSplitter->handleWidth() ) / 2;
sizes[0] = sizes[1];
currentSplitter->insertWidget( index, vsNew );
currentSplitter->setSizes( sizes );
}
else
{
// create a new QSplitter and replace vs with the splitter. vs and newVS are
// the new children of the new QSplitter
QSplitter* newContainer = new QSplitter( o );
newContainer->setOpaqueResize( KGlobalSettings::opaqueResize() );
QList<int> currentSizes = currentSplitter->sizes();
newContainer->addWidget( vs );
newContainer->addWidget( vsNew );
currentSplitter->insertWidget( index, newContainer );
newContainer->show();
// fix sizes of children of old and new splitter
currentSplitter->setSizes( currentSizes );
QList<int> newSizes = newContainer->sizes();
newSizes[0] = (newSizes[0] + newSizes[1] - newContainer->handleWidth()) / 2;
newSizes[1] = newSizes[0];
newContainer->setSizes( newSizes );
}
m_viewSpaceList.append( vsNew );
activeViewSpace()->setActive( false );
vsNew->setActive( true, true );
vsNew->show();
createView ((KTextEditor::Document*)activeView()->document());
updateViewSpaceActions ();
}
MainWindow::MainWindow(QApplication* app)
{
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
this->setWindowTitle("kmeans");
// create status bar
m_framesPerSec = new QLabel("nA");
m_framesPerSec->setMinimumSize(m_framesPerSec->sizeHint());
m_framesPerSec->setAlignment(Qt::AlignLeft);
m_framesPerSec->setToolTip("Current frames per second not yet initialized.");
statusBar()->addWidget(m_framesPerSec);
m_viewport = new Viewport(this);
m_viewport->show();
m_toolBox = new ToolBox();
QSplitter* splitter = new QSplitter(Qt::Horizontal);
splitter->insertWidget(0, m_toolBox);
splitter->insertWidget(1, m_viewport);
QList<int> sizes;
sizes.append(200);
sizes.append(1300);
splitter->setSizes(sizes);
splitter->setStretchFactor(0, 1);
splitter->setStretchFactor(1, 1);
splitter->setChildrenCollapsible(false);
setCentralWidget(splitter);
connect(m_viewport, SIGNAL(framesPerSecondChanged(int)), this, SLOT(updateFramesPerSecond(int)));
connect(m_toolBox, SIGNAL(setSeedingAlgorithm(SeedingAlgorithm)), m_viewport, SLOT(setSeedingAlgorithm(SeedingAlgorithm)));
connect(m_toolBox->m_doClusterButton, SIGNAL(clicked()), m_viewport, SLOT(doCluster()));
connect(m_toolBox->m_findKButton, SIGNAL(clicked()), m_viewport, SLOT(findK()));
connect(m_toolBox->m_kBox, SIGNAL(valueChanged(int)), m_viewport, SLOT(setK(int)));
connect(m_toolBox->m_iterationsBox, SIGNAL(valueChanged(int)), m_viewport, SLOT(setIterations(int)));
connect(m_toolBox->m_runBox, SIGNAL(valueChanged(int)), m_viewport, SLOT(setRuns(int)));
connect(m_toolBox->m_clearButton, SIGNAL(clicked()), m_viewport, SLOT(doClear()));
connect(m_toolBox->m_clearSeedButton, SIGNAL(clicked()), m_viewport, SLOT(doClearSeed()));
show();
this->adjustSize();
m_viewport->updateGL();
m_viewport->m_timer->start();
}
void MultiViewWidget::splitView(Qt::Orientation orient,
ContainerWidget *container)
{
QVBoxLayout *widgetLayout = qobject_cast<QVBoxLayout *>(container->parent());
QSplitter *split = qobject_cast<QSplitter *>(container->parent());
if (!widgetLayout)
if (container->parent() == this)
widgetLayout = qobject_cast<QVBoxLayout *>(layout());
if (widgetLayout) {
QSplitter *splitter = new QSplitter(orient, this);
widgetLayout->removeWidget(container);
widgetLayout->addWidget(splitter);
splitter->addWidget(container);
container = createContainer();
splitter->addWidget(container);
QList<int> sizes;
int s = Qt::Horizontal ? splitter->size().width() / 2
: splitter->size().height() / 2;
sizes << s << s;
splitter->setSizes(sizes);
}
else if (split) {
QSplitter *splitter = new QSplitter(orient, this);
int idx = split->indexOf(container);
splitter->addWidget(container);
container = createContainer();
splitter->addWidget(container);
split->insertWidget(idx, splitter);
QList<int> sizes;
int s = Qt::Horizontal ? splitter->size().width() / 2
: splitter->size().height() / 2;
sizes << s << s;
splitter->setSizes(sizes);
}
}
void ViewAreaImpl::dropViewInsidePane(ViewPane* pane, View* view, int dropEdge)
{
if(dropEdge == OVER){
addView(pane, view, true);
} else {
QSize destSize = pane->size();
QSplitter* parentSplitter = static_cast<QSplitter*>(pane->parentWidget());
if(parentSplitter->count() >= 2){
QList<int> sizes = parentSplitter->sizes();
QSplitter* newSplitter = new QSplitter(parentSplitter);
parentSplitter->insertWidget(parentSplitter->indexOf(pane), newSplitter);
newSplitter->addWidget(pane);
parentSplitter->setSizes(sizes);
parentSplitter = newSplitter;
}
ViewPane* newViewPane = new ViewPane(this, parentSplitter);
if(dropEdge == LEFT){
parentSplitter->setOrientation(Qt::Horizontal);
parentSplitter->insertWidget(0, newViewPane);
} else if(dropEdge == RIGHT){
parentSplitter->setOrientation(Qt::Horizontal);
parentSplitter->insertWidget(1, newViewPane);
} else if(dropEdge == TOP){
parentSplitter->setOrientation(Qt::Vertical);
parentSplitter->insertWidget(0, newViewPane);
} else {
parentSplitter->setOrientation(Qt::Vertical);
parentSplitter->insertWidget(1, newViewPane);
}
addView(newViewPane, view, true);
int half;
if(parentSplitter->orientation() == Qt::Horizontal){
half = destSize.height() / 2;
} else {
half = destSize.width() / 2;
}
QList<int> sizes;
sizes << half << half;
parentSplitter->setSizes(sizes);
}
}
void HelpWidget::setup()
{
if (mVerticalLayout)
return;
// this->setToolTip("Context-sensitive and browser help");
mVerticalLayout = new QVBoxLayout(this);
mVerticalLayout->setMargin(0);
mVerticalLayout->setSpacing(0);
this->setLayout(mVerticalLayout);
mTabWidget = new QTabWidget(this);
mTabWidget->setElideMode(Qt::ElideRight);
QSplitter *splitter = new QSplitter(Qt::Horizontal);
mSplitter = splitter;
HelpBrowser *browser = new HelpBrowser(this, mEngine);
connect(this, &HelpWidget::requestShowLink,
browser, &HelpBrowser::setSource);
mBrowser = browser;
QHBoxLayout* buttonLayout = new QHBoxLayout;
// buttonLayout->setMargin(0);
mVerticalLayout->addLayout(buttonLayout);
splitter->insertWidget(0, mTabWidget);
splitter->insertWidget(1, browser);
splitter->setStretchFactor(1, 1);
mVerticalLayout->addWidget(splitter);
this->addContentWidget(mTabWidget, buttonLayout);
this->addSearchWidget(mTabWidget, buttonLayout);
this->addIndexWidget(mTabWidget, buttonLayout);
this->addToggleTabWidgetButton(buttonLayout);
this->addWebNavigationButtons(buttonLayout);
this->addWebButton(buttonLayout);
buttonLayout->addStretch();
browser->showHelpForKeyword("user_doc_overview");
bool navVis = settings()->value("org.custusx.help/navigationVisible").toBool();
mTabWidget->setVisible(navVis);
}
//!
//! Splits the panel frame according to the given orientation.
//!
//! \param orientation The orientation in which to split the panel frame.
//!
void PanelFrame::split ( Qt::Orientation orientation )
{
QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget());
parentSplitter->setHandleWidth(1);
if (!parentSplitter && !mainWindow) {
QMessageBox::information(this, "Split Panel", "Splitting this panel is not possible.");
return;
}
// flip the orientation
if (orientation == Qt::Horizontal)
orientation = Qt::Vertical;
else
orientation = Qt::Horizontal;
// save the size of this panel
QSize panelSize = size();
int widthHeight = orientation == Qt::Horizontal ? panelSize.width() : panelSize.height();
// clone this panel frame
PanelFrame *clonedPanelFrame = new PanelFrame(m_panelType, parentWidget(), windowFlags());
QList<int> sizes;
int panelIndex;
if (parentSplitter) {
// save the parent splitter's sizes
sizes = parentSplitter->sizes();
// obtain the index of this panel in its parent splitter
panelIndex = parentSplitter->indexOf(this);
}
// create new splitter for this panel and its clone
QSplitter *newSplitter = new QSplitter(orientation);
newSplitter->setHandleWidth(1);
newSplitter->addWidget(this);
newSplitter->addWidget(clonedPanelFrame);
// give both panels in the new splitter the same space
QList<int> newSizes;
newSizes << widthHeight / 2 << widthHeight / 2;
newSplitter->setSizes(newSizes);
if (parentSplitter) {
// insert the new splitter into the panel's former parent splitter
parentSplitter->insertWidget(panelIndex, newSplitter);
// restore the parent splitter's sizes
parentSplitter->setSizes(sizes);
} else {
mainWindow->setCentralWidget(newSplitter);
}
}
QSplitter* SplitView::wrap(BufferView* view, Qt::Orientation orientation)
{
QSplitter* container = qobject_cast<QSplitter*>(view->parentWidget());
if (container) {
int index = container->indexOf(view);
QSplitter* splitter = new QSplitter(orientation, container);
container->insertWidget(index, splitter);
container->setCollapsible(index, false);
splitter->addWidget(view);
splitter->setCollapsible(0, false);
return splitter;
}
return 0;
}
SpectrumWindow::SpectrumWindow(QWidget *pParent)
: QDockWidget(pParent),
m_signal(cSignalSize, 0.0f)
{
setObjectName("spectrumWindow");
setWindowTitle(tr("Audio output"));
createWaveformPlot();
createSpectrumPlot();
QSplitter *pSplitter = new QSplitter(Qt::Horizontal);
pSplitter->insertWidget(0, m_pWaveformPlot);
pSplitter->insertWidget(1, m_pSpectrumPlot);
setWidget(pSplitter);
}
void MultiViewWidget::removeView()
{
ContainerWidget *container = qobject_cast<ContainerWidget *>(sender());
if (container) {
QSplitter *splitter = qobject_cast<QSplitter *>(container->parent());
if (splitter && splitter->count() == 2) {
// Get its parent, and insert the other widget into it, delete this widget.
QSplitter *splitterParent = qobject_cast<QSplitter *>(splitter->parent());
QWidget *moveWidget = splitter->widget(0);
if (moveWidget == container)
moveWidget = splitter->widget(1);
setActiveWidget(moveWidget);
if (splitterParent) {
int idx = splitterParent->indexOf(splitter);
splitterParent->insertWidget(idx, moveWidget);
splitter->deleteLater();
}
else if (splitter->parent() == this) {
// No more splits - back to single view widget.
QVBoxLayout *layoutParent = qobject_cast<QVBoxLayout *>(layout());
if (layoutParent) {
layoutParent->addWidget(moveWidget);
layoutParent->removeWidget(splitter);
splitter->deleteLater();
}
}
}
else if (container->parent() == this) {
// Delete the current container, and create the option container.
QVBoxLayout *vLayout = qobject_cast<QVBoxLayout *>(layout());
container->deleteLater();
ContainerWidget *newContainer = createContainer();
vLayout->addWidget(newContainer);
setActiveWidget(newContainer);
}
}
}
bool DockTabMotherWidget::insertTabWidget(DockTabWidget *tabWidget, const TabWidgetArea &area)
{
if (!area.isValid())
goto error;
if (area.tabWidgetIndex == -1)
{
Qt::Orientation orientation;
if (area.dir == Left || area.dir == Right)
orientation = Qt::Vertical;
else
orientation = Qt::Horizontal;
auto splitter = createSplitter(orientation);
splitter->addWidget(tabWidget);
int mainSplitterIndex;
QSplitter *mainSplitter;
switch (area.dir)
{
case Left:
mainSplitterIndex = area.splitterIndex;
mainSplitter = _mainHorizontalSplitter;
break;
case Right:
mainSplitterIndex = _mainHorizontalSplitter->count() - area.splitterIndex;
mainSplitter = _mainHorizontalSplitter;
break;
case Top:
mainSplitterIndex = area.splitterIndex;
mainSplitter = _mainVerticalSplitter;
break;
case Bottom:
mainSplitterIndex = _mainVerticalSplitter->count() - area.splitterIndex;
mainSplitter = _mainVerticalSplitter;
break;
default:
goto error;
}
mainSplitter->insertWidget(mainSplitterIndex, splitter);
mainSplitter->setStretchFactor(mainSplitterIndex, 0);
_splitterLists[area.dir].insert(area.splitterIndex, splitter);
}
else
{
QSplitter *splitter = _splitterLists[area.dir].at(area.splitterIndex);
splitter->insertWidget(area.tabWidgetIndex, tabWidget);
}
connect(tabWidget, SIGNAL(willBeAutomaticallyDeleted(DockTabWidget*)), this, SLOT(onTabWidgetWillBeDeleted(DockTabWidget*)));
return true;
error:
PAINTFIELD_WARNING << "failed";
//tabWidget->deleteLater();
return false;
}
void KateViewManager::removeViewSpace (KateViewSpace *viewspace)
{
// abort if viewspace is 0
if (!viewspace) return;
// abort if this is the last viewspace
if (m_viewSpaceList.count() < 2) return;
// get current splitter
QSplitter *currentSplitter = qobject_cast<QSplitter*>(viewspace->parentWidget());
// no splitter found, bah
if (!currentSplitter)
return;
// delete views of the viewspace
while (viewspace->viewCount() > 0 && viewspace->currentView())
{
deleteView( viewspace->currentView(), false );
}
// cu viewspace
m_viewSpaceList.removeAt( m_viewSpaceList.indexOf( viewspace ) );
delete viewspace;
// at this point, the splitter has exactly 1 child
Q_ASSERT( currentSplitter->count() == 1 );
// if we are not the root splitter, move the child one level up and delete
// the splitter then.
if (currentSplitter != this)
{
// get parent splitter
QSplitter *parentSplitter = qobject_cast<QSplitter*>(currentSplitter->parentWidget());
// only do magic if found ;)
if (parentSplitter)
{
int index = parentSplitter->indexOf (currentSplitter);
// save current splitter size, as the removal of currentSplitter looses the info
QList<int> parentSizes = parentSplitter->sizes();
parentSplitter->insertWidget (index, currentSplitter->widget (0));
if (qVersion() == QLatin1String("4.6.2")) currentSplitter->hide(); // bug in Qt v4.6.2, prevents crash (bug:232140), line can be removed once we are sure that noone uses Qt 4.6.2 anymore.
delete currentSplitter;
// now restore the sizes again
parentSplitter->setSizes(parentSizes);
}
}
else if( QSplitter* splitter = qobject_cast<QSplitter*>(currentSplitter->widget(0)) )
{
// we are the root splitter and have only one child, which is also a splitter
// -> eliminate the redundant splitter and move both children into the root splitter
QList<int> sizes = splitter->sizes();
// adapt splitter orientation to the splitter we are about to delete
currentSplitter->setOrientation(splitter->orientation());
currentSplitter->addWidget( splitter->widget(0) );
currentSplitter->addWidget( splitter->widget(0) );
delete splitter;
currentSplitter->setSizes( sizes );
}
// find the view that is now active.
KTextEditor::View* v = activeViewSpace()->currentView();
if ( v )
activateView( v );
updateViewSpaceActions ();
emit viewChanged();
}
