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 ();
}
//!
//! Maximizes the given widget inside its parent widget.
//!
//! The widget can be a panel frame or a splitter widget.
//!
//! \param widget The widget to maximize.
//!
void PanelFrame::maximizeWidget ( QWidget *widget )
{
QWidget *parentWidget = widget->parentWidget();
QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget);
parentSplitter->setHandleWidth(1);
if (!parentSplitter) {
QMessageBox::information(this, "Maximize Panel", "The panel is already maximized.");
return;
}
int index = parentSplitter->indexOf(widget);
QList<int> sizes = parentSplitter->sizes();
// count number of visible panel frames
int visiblePanelFrames = 0;
for (int i = 0; i < sizes.size(); ++i)
if (sizes[i] > 0)
++visiblePanelFrames;
if (visiblePanelFrames == 1)
maximizeWidget(parentSplitter);
else {
// hide all other panels in the same splitter
for (int i = 0; i < sizes.size(); ++i)
if (i != index)
sizes[i] = 0;
parentSplitter->setSizes(sizes);
}
}
//!
//! Minimizes the given widget inside its parent widget.
//!
//! The widget can be a panel frame or a splitter widget.
//!
//! \param widget The widget to minimize.
//!
void PanelFrame::minimizeWidget ( QWidget *widget )
{
QWidget *parentWidget = widget->parentWidget();
QSplitter *parentSplitter = qobject_cast<QSplitter *>(parentWidget);
parentSplitter->setHandleWidth(1);
if (!parentSplitter) {
QMessageBox::information(this, "Minimize Panel", "The last visible panel cannot be minimized.");
return;
}
int index = parentSplitter->indexOf(widget);
QList<int> sizes = parentSplitter->sizes();
// count number of visible panel frames
int visiblePanelFrames = 0;
for (int i = 0; i < sizes.size(); ++i)
if (sizes[i] > 0)
++visiblePanelFrames;
if (visiblePanelFrames == 1)
minimizeWidget(parentSplitter);
else {
sizes[index] = 0;
parentSplitter->setSizes(sizes);
}
}
bool eventFilter(QObject* obj, QEvent* event) override
{
// check input
if (event->type() != QEvent::MouseButtonDblClick)
return false;
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
if (mouseEvent->button() != Qt::LeftButton)
return false;
QSplitterHandle* splitterHandle = qobject_cast<QSplitterHandle*>(obj);
if (!splitterHandle)
return false;
QSplitter* splitter = splitterHandle->splitter();
if (!splitter || splitter->count() < 2)
return false;
// change splitter sizes to make description panel occupy ideal height
QWidget* bottomWidget = splitter->widget(1);
QList<int> sizes = splitter->sizes();
if (sizes.size() != 2)
return false;
sizes[0] += sizes[1];
sizes[1] = bottomWidget->heightForWidth(bottomWidget->size().width());
sizes[0] -= qMax(sizes[1], 0);
splitter->setSizes(sizes);
return true;
}
void SplitView::split(BufferView* view, Qt::Orientation orientation)
{
if (view) {
QSplitter* container = qobject_cast<QSplitter*>(view->parentWidget());
if (container) {
int index = container->indexOf(view);
BufferView* bv = 0;
const int size = (orientation == Qt::Horizontal ? container->width() : container->height()) - container->handleWidth();
if (container->count() == 1 || container->orientation() == orientation) {
container->setOrientation(orientation);
bv = createBufferView(container, index + 1);
QList<int> sizes;
for (int i = 0; i < container->count(); ++i)
sizes += size / container->count();
container->setSizes(sizes);
} else if (index != -1) {
QList<int> sizes = container->sizes();
QSplitter* splitter = wrap(view, orientation);
if (splitter) {
container->setSizes(sizes);
bv = createBufferView(splitter);
splitter->setSizes(QList<int>() << size/2 << size/2);
}
}
if (bv) {
bv->setBuffer(view->buffer());
emit viewAdded(bv);
}
}
}
}
void PropertiesWidget::setVisibility(bool visible)
{
if (!visible && (state == VISIBLE)) {
QSplitter *hSplitter = static_cast<QSplitter *>(parentWidget());
m_ui->stackedProperties->setVisible(false);
slideSizes = hSplitter->sizes();
hSplitter->handle(1)->setVisible(false);
hSplitter->handle(1)->setDisabled(true);
QList<int> sizes = QList<int>() << hSplitter->geometry().height() - 30 << 30;
hSplitter->setSizes(sizes);
state = REDUCED;
return;
}
if (visible && (state == REDUCED)) {
m_ui->stackedProperties->setVisible(true);
QSplitter *hSplitter = static_cast<QSplitter *>(parentWidget());
hSplitter->handle(1)->setDisabled(false);
hSplitter->handle(1)->setVisible(true);
hSplitter->setSizes(slideSizes);
state = VISIBLE;
// Force refresh
loadDynamicData();
}
}
void TitleBar::onCommentsButtonClicked()
{
#ifdef USEWEBENGINE
QWebEngineView* comments = noteView()->commentView();
#else
QWebView* comments = noteView()->commentView();
#endif
if (comments->isVisible()) {
comments->hide();
return;
}
if (isNetworkAccessible()) {
if (!m_commentsUrl.isEmpty()) {
comments->load(m_commentsUrl);
QSplitter* splitter = qobject_cast<QSplitter*>(comments->parentWidget());
Q_ASSERT(splitter);
QList<int> li = splitter->sizes();
Q_ASSERT(li.size() == 2);
QList<int> lin;
lin.push_back(li.value(0) - COMMENT_FRAME_WIDTH);
lin.push_back(li.value(1) + COMMENT_FRAME_WIDTH);
splitter->setSizes(lin);
comments->show();
} else {
loadErrorPage();
comments->show();
}
} else {
m_commentsBtn->setEnabled(false);
}
}
void KKbdAccessExtensions::resizePanel(int dx, int dy, int state)
{
int adj = dx + dy;
if (adj == 0) return;
// kdDebug() << "KKbdAccessExtensions::resizePanel: panel = " << d->panel->name() << endl;
if (::qt_cast<QSplitter*>( d->panel )) {
QSplitter* splitter = dynamic_cast<QSplitter *>(d->panel);
int handleNdx = d->handleNdx - 1;
QValueList<int> sizes = splitter->sizes();
// kdDebug() << "KKbdAccessExtensions::resizePanel: before sizes = " << sizes << endl;
sizes[handleNdx] = sizes[handleNdx] + adj;
// kdDebug() << "KKbdAccessExtensions::resizePanel: setSizes = " << sizes << endl;
splitter->setSizes(sizes);
QApplication::postEvent(splitter, new QEvent(QEvent::LayoutHint));
} else {
// TODO: How to get the handle width?
QDockWindow* dockWindow = dynamic_cast<QDockWindow *>(d->panel);
if (dockWindow->area()) {
// kdDebug() << "KKbdAccessExtensions::resizePanel: fixedExtent = " << dockWindow->fixedExtent() << endl;
QSize fe = dockWindow->fixedExtent();
if (d->handleNdx == 1) {
// When vertically oriented and dock area is on right side of screen, pressing
// left arrow increases size.
if (dockWindow->area()->orientation() == Qt::Vertical &&
dockWindow->area()->handlePosition() == QDockArea::Reverse) adj = -adj;
int w = fe.width();
if (w < 0) w = dockWindow->width();
w = w + adj;
if (w > 0 ) dockWindow->setFixedExtentWidth(w);
} else {
// When horizontally oriented and dock area is at bottom of screen,
// pressing up arrow increases size.
if (dockWindow->area()->orientation() == Qt::Horizontal &&
dockWindow->area()->handlePosition() == QDockArea::Reverse) adj = -adj;
int h = fe.height();
if (h < 0) h = dockWindow->height();
h = h + adj;
if (h > 0) dockWindow->setFixedExtentHeight(h);
}
dockWindow->updateGeometry();
QApplication::postEvent(dockWindow->area(), new QEvent(QEvent::LayoutHint));
// kdDebug() << "KKbdAccessExtensions::resizePanel: fixedExtent = " << dockWindow->fixedExtent() << endl;
} else {
if (state == Qt::ShiftButton) {
QSize s = dockWindow->size();
s.setWidth(s.width() + dx);
s.setHeight(s.height() + dy);
dockWindow->resize(s);
} else {
QPoint p = dockWindow->pos();
p.setX(p.x() + dx);
p.setY(p.y() + dy);
dockWindow->move(p);
}
}
}
}
//!
//! 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);
}
}
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 PropertiesWidget::saveSettings() {
QIniSettings settings;
settings.setValue("TorrentProperties/Visible", state==VISIBLE);
// Splitter sizes
QSplitter *hSplitter = static_cast<QSplitter*>(parentWidget());
QList<int> sizes;
if (state == VISIBLE)
sizes = hSplitter->sizes();
else
sizes = slideSizes;
qDebug("Sizes: %d", sizes.size());
if (sizes.size() == 2) {
settings.setValue(QString::fromUtf8("TorrentProperties/SplitterSizes"), QVariant(QString::number(sizes.first())+','+QString::number(sizes.last())));
}
settings.setValue("TorrentProperties/FilesListState", filesList->header()->saveState());
// Remember current tab
settings.setValue("TorrentProperties/CurrentTab", m_tabBar->currentIndex());
}
void GTUtilsWorkflowDesigner::expandTabs(HI::GUITestOpStatus &os){
QSplitter* splitter = qobject_cast<QSplitter*>(GTWidget::findWidget(os,"splitter"));
GT_CHECK(splitter, "splitter not found");
QList<int> s;
s = splitter->sizes();
if(s.first()==0){//expands tabs if collapsed
QPoint p;
p.setX(splitter->geometry().left()+2);
p.setY(splitter->geometry().center().y());
GTMouseDriver::moveTo(os, p);
GTGlobals::sleep(300);
GTMouseDriver::press(os);
p.setX(p.x()+200);
GTMouseDriver::moveTo(os,p);
GTMouseDriver::release(os);
}
}
void PropertiesWidget::saveSettings() {
Preferences* const pref = Preferences::instance();
pref->setPropVisible(state==VISIBLE);
// Splitter sizes
QSplitter *hSplitter = static_cast<QSplitter*>(parentWidget());
QList<int> sizes;
if (state == VISIBLE)
sizes = hSplitter->sizes();
else
sizes = slideSizes;
qDebug("Sizes: %d", sizes.size());
if (sizes.size() == 2) {
pref->setPropSplitterSizes(QString::number(sizes.first()) + ',' + QString::number(sizes.last()));
}
pref->setPropFileListState(filesList->header()->saveState());
// Remember current tab
pref->setPropCurTab(m_tabBar->currentIndex());
}
static void set_widget_height(int height){
return;
#if 0
QWidget *main_window = static_cast<QWidget*>(root->song->tracker_windows->os_visual.main_window);
EditorWidget *editor = static_cast<EditorWidget*>(root->song->tracker_windows->os_visual.widget);
QSplitter *splitter = editor->ysplitter;
#if USE_QT4
# define QValueList QList
#endif
//printf("set_widghet_height. main_window->height(): %d, splitter: %p\n",main_window->height(),splitter);
QValueList<int> currentSizes = splitter->sizes();
currentSizes[0] = main_window->height() - height;
currentSizes[1] = height;
splitter->setSizes(currentSizes);
#if USE_QT4
# undef QValueList
#endif
#endif // 0
}
int main()
{
QWidget *parent = 0;
//! [0]
QSplitter *splitter = new QSplitter(parent);
QListView *listview = new QListView;
QTreeView *treeview = new QTreeView;
QTextEdit *textedit = new QTextEdit;
splitter->addWidget(listview);
splitter->addWidget(treeview);
splitter->addWidget(textedit);
//! [0]
{
// SAVE STATE
//! [1]
QSettings settings;
settings.setValue("splitterSizes", splitter->saveState());
//! [1]
}
{
// RESTORE STATE
//! [2]
QSettings settings;
splitter->restoreState(settings.value("splitterSizes").toByteArray());
//! [2]
}
//! [3]
QListIterator<int> it(splitter->sizes());
while (it.hasNext())
processSize(it.next());
//! [3]
return 0;
}
void RightPanePlaceHolder::applyStoredSize(int width)
{
if (width) {
QSplitter *splitter = qobject_cast<QSplitter *>(parentWidget());
if (splitter) {
// A splitter we need to resize the splitter sizes
QList<int> sizes = splitter->sizes();
int index = splitter->indexOf(this);
int diff = width - sizes.at(index);
int adjust = sizes.count() > 1 ? (diff / (sizes.count() - 1)) : 0;
for (int i = 0; i < sizes.count(); ++i) {
if (i != index)
sizes[i] -= adjust;
}
sizes[index]= width;
splitter->setSizes(sizes);
} else {
QSize s = size();
s.setWidth(width);
resize(s);
}
}
}
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();
}
void KKbdAccessExtensions::showIcon()
{
if (!d->panel) return;
QPoint p;
// kdDebug() << "KKbdAccessExtensions::showIcon: topLevelWidget = " << d->panel->topLevelWidget()->name() << endl;
if (::qt_cast<QSplitter*>( d->panel )) {
QSplitter* splitter = dynamic_cast<QSplitter *>(d->panel);
int handleNdx = d->handleNdx - 1;
QValueList<int> sizes = splitter->sizes();
// kdDebug() << "KKbdAccessExtensions::showIcon: sizes = " << sizes << endl;
if (splitter->orientation() == Qt::Horizontal) {
d->icon->setShape(Qt::SizeHorCursor);
p.setX(sizes[handleNdx] + (splitter->handleWidth() / 2));
p.setY(splitter->height() / 2);
} else {
d->icon->setShape(Qt::SizeVerCursor);
p.setX(splitter->width() / 2);
p.setY(sizes[handleNdx] + (splitter->handleWidth() / 2));
}
// kdDebug() << "KKbdAccessExtensions::showIcon: p = " << p << endl;
p = splitter->mapToGlobal(p);
// kdDebug() << "KKbdAccessExtensions::showIcon: mapToGlobal = " << p << endl;
} else {
QDockWindow* dockWindow = dynamic_cast<QDockWindow *>(d->panel);
p = dockWindow->pos();
if (dockWindow->area()) {
// kdDebug() << "KKbdAccessExtensions::showIcon: pos = " << p << " of window = " << dockWindow->parentWidget()->name() << endl;
p = dockWindow->parentWidget()->mapTo(dockWindow->topLevelWidget(), p);
// kdDebug() << "KKbdAccessExtensions::showIcon: mapTo = " << p << " of window = " << dockWindow->topLevelWidget()->name() << endl;
// TODO: How to get the handle width?
if (d->handleNdx == 1) {
d->icon->setShape(Qt::SizeHorCursor);
if (dockWindow->area()->orientation() == Qt::Vertical) {
if (dockWindow->area()->handlePosition() == QDockArea::Normal)
// Handle is to the right of the dock window.
p.setX(p.x() + dockWindow->width());
// else Handle is to the left of the dock window.
} else
// Handle is to the right of the dock window.
p.setX(p.x() + dockWindow->width());
p.setY(p.y() + (dockWindow->height() / 2));
} else {
d->icon->setShape(Qt::SizeVerCursor);
p.setX(p.x() + (dockWindow->width() / 2));
if (dockWindow->area()->orientation() == Qt::Vertical)
// Handle is below the dock window.
p.setY(p.y() + dockWindow->height());
else {
if (dockWindow->area()->handlePosition() == QDockArea::Normal)
// Handle is below the dock window.
p.setY(p.y() + dockWindow->height());
// else Handle is above the dock window.
}
}
p = dockWindow->topLevelWidget()->mapToGlobal(p);
} else {
d->icon->setShape(Qt::SizeAllCursor);
p = QPoint(dockWindow->width() / 2, dockWindow->height() / 2);
p = dockWindow->mapToGlobal(p); // Undocked. Position in center of window.
}
}
// kdDebug() << "KKbdAccessExtensions::showIcon: show(p) = " << p << endl;
d->icon->show(p);
}
