void MVOverviewWidgetPrivate::update_sizes()
{
float W0=q->width();
float H0=q->height();
int W1=W0/3; if (W1<300) W1=300; if (W1>500) W1=500;
int W2=W0-W1;
if (W2<500) {W2=500; W1=W0-W2;}
int H1=H0/3;
int H2=H0/3;
int H3=H0-H1-H2;
{
QList<int> sizes; sizes << W1 << W2;
m_hsplitter->setSizes(sizes);
}
{
QList<int> sizes; sizes << H1 << H2 << H3;
m_vsplitter->setSizes(sizes);
}
int H1_left=H0/3;
int H2_left=H0/3;
int H3_left=H0-H1_left-H2_left;
{
QList<int> sizes; sizes << H1_left << H2_left << H3_left;
m_left_vsplitter->setSizes(sizes);
}
}
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 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 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 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 ();
}
//!
//! 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 FenPrincipale::createDockWindows()
{
QDockWidget *dockDonnee = new QDockWidget(tr("Données"), this);
dockDonnee->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, dockDonnee);
QSplitter *splitter = new QSplitter(dockDonnee);
QSize size(800,800);
splitter->setMinimumSize(size);
splitter->addWidget(tablemesures);
splitter->addWidget(tabless);
splitter->setOrientation(Qt::Vertical);
QList<int> list = QList<int>() << 800 << 800;
splitter->setSizes(list);
viewMenu->addAction(dockDonnee->toggleViewAction());
QDockWidget *dockCalcul = new QDockWidget(tr("Calculs"), this);
addDockWidget(Qt::RightDockWidgetArea, dockCalcul);
viewMenu->addAction(dockCalcul->toggleViewAction());
// QSplitter *splitter = new QSplitter(dockDonnee);
// splitter->addWidget(tabless);
// splitter->addWidget(tablemesures);
// QList<int> list = QList<int>() << 150 << 150;
// splitter->setSizes(list);
}
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 DlgCustomizeSpaceball::setupLayout()
{
QLabel *buttonLabel = new QLabel(tr("Buttons"), this);
clearButton = new QPushButton(tr("Clear"), this);
QVBoxLayout *buttonGroup = new QVBoxLayout();
buttonGroup->addWidget(buttonLabel);
buttonGroup->addWidget(buttonView);
QHBoxLayout *clearLayout = new QHBoxLayout();
clearLayout->addWidget(clearButton);
clearLayout->addStretch();
buttonGroup->addLayout(clearLayout);
QSplitter *splitter = new QSplitter(this);
QWidget *leftPane = new QWidget(this);
leftPane->setLayout(buttonGroup);
splitter->addWidget(leftPane);
splitter->addWidget(commandView);
printReference = new QPushButton(tr("Print Reference"), this);
QHBoxLayout *printLayout = new QHBoxLayout();
printLayout->addStretch();
printLayout->addWidget(printReference);
QVBoxLayout *layout = new QVBoxLayout();
layout->addWidget(splitter);
layout->addLayout(printLayout);
this->setLayout(layout);
QList<int> sizes;
sizes << this->size().width()*0.40;
sizes << this->size().width()-sizes.at(0);
splitter->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;
}
AnnoqtConfEditor::AnnoqtConfEditor() : m_colorNames2EntityTypes(), m_entityTypes2ColorNames(), m_currentColor(QColor(Qt::black)), m_currentAnnotationConfigurationFile(),m_currentDirectory(),
m_currentItem(0)
{
QFont font = QApplication::font();
font.setPointSize(12);
QApplication::setFont(font);
QSplitter *splitter = new QSplitter( this );
setCentralWidget( splitter );
m_listWidget = new QListWidget();
splitter->addWidget( m_listWidget );
m_colorPicker = new KColorDialog(this);
m_colorPicker->setColor( Qt::white );
splitter->addWidget( m_colorPicker );
QList<int> l;
l.push_back( 100 );
l.push_back( 600 );
splitter->setSizes( l );
createActions();
createMenus();
createToolBars();
createStatusBar();
readSettings();
connect( m_listWidget, SIGNAL( itemClicked ( QListWidgetItem* ) ),
this, SLOT( slotTypesListItemclicked( QListWidgetItem* ) ) );
connect( m_colorPicker, SIGNAL(colorSelected( const QColor & )), this, SLOT(slotColorSelected( const QColor& )) );
}
MainWindow::MainWindow(QWidget *parent):QMainWindow(parent)
{
setMinimumSize(20, 20);
resize(1500, 900);
glViewer = new QGLViewer(this);
m_parameter_control = new ParameterControl(glViewer, this);
createActions();
createMenus();
createToolBars();
QList <int> sizes;
sizes<<1200<<300;
QSplitter* mainSplitter = new QSplitter(Qt::Horizontal);
mainSplitter->addWidget(glViewer);
mainSplitter->addWidget(m_parameter_control);
mainSplitter->setSizes(sizes);
mainSplitter->setStretchFactor(0, 1);
setCentralWidget(mainSplitter);
setWindowTitle("Parameter");
}
//!
//! 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);
}
}
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 Vizkit3DWidget::collapsePropertyBrowser()
{
QSplitter *splitter = findChild<QSplitter*>("splitter");
if(!splitter)
return;
QList<int> sizes;
sizes.push_front(0);
splitter->setSizes(sizes);
}
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);
}
}
}
}
MainWindow::MainWindow()
: filename_(),
default_extent_(-20037508.3428,-20037508.3428,20037508.3428,20037508.3428)
{
mapWidget_ = new MapWidget(this);
QSplitter *splitter = new QSplitter(this);
QTabWidget *tabWidget=new QTabWidget;
layerTab_ = new LayerTab;
layerTab_->setFocusPolicy(Qt::NoFocus);
layerTab_->setIconSize(QSize(16,16));
//LayerDelegate *delegate = new LayerDelegate(this);
//layerTab_->setItemDelegate(delegate);
//layerTab_->setItemDelegate(new QItemDelegate(this));
//layerTab_->setViewMode(QListView::IconMode);
layerTab_->setFlow(QListView::TopToBottom);
tabWidget->addTab(layerTab_,tr("Layers"));
// Styles tab
styleTab_ = new StyleTab;
tabWidget->addTab(styleTab_,tr("Styles"));
splitter->addWidget(tabWidget);
splitter->addWidget(mapWidget_);
QList<int> list;
list.push_back(200);
list.push_back(600);
splitter->setSizes(list);
mapWidget_->setFocusPolicy(Qt::StrongFocus);
mapWidget_->setFocus();
//setCentralWidget(mapWidget_);
setCentralWidget(splitter);
createActions();
createMenus();
createToolBars();
createContextMenu();
setWindowTitle(tr("Mapnik Viewer"));
status=new QStatusBar(this);
status->showMessage(tr(""));
setStatusBar(status);
resize(800,600);
//connect mapview to layerlist
connect(mapWidget_, SIGNAL(mapViewChanged()),layerTab_, SLOT(update()));
// slider
connect(slider_,SIGNAL(valueChanged(int)),mapWidget_,SLOT(zoomToLevel(int)));
//
connect(layerTab_,SIGNAL(update_mapwidget()),mapWidget_,SLOT(updateMap()));
connect(layerTab_,SIGNAL(layerSelected(int)),
mapWidget_,SLOT(layerSelected(int)));
}
MainWidget::MainWidget( MainWindow * parent ) :
QWidget( parent ), mMainWindow( parent )
{
QVBoxLayout *layout = new QVBoxLayout( this );
QSplitter *splitter = new QSplitter( Qt::Vertical, this );
layout->addWidget( splitter );
// Accounts
Akonadi::AgentInstanceModel *model = new Akonadi::AgentInstanceModel( this );
m_resourcesView = new QListView( splitter );
m_resourcesView->setModel( model );
connect( m_resourcesView, SIGNAL( clicked( const QModelIndex& ) ),
SLOT( slotCurrentResourceChanged( const QModelIndex& ) ) );
splitter->addWidget( m_resourcesView );
// Filter the collection to only show the blogs
Akonadi::AgentFilterProxyModel* proxy = new Akonadi::AgentFilterProxyModel( this );
proxy->addMimeTypeFilter( "application/x-vnd.kde.microblog" );
proxy->setSourceModel( model );
m_resourcesView->setModel( proxy );
// Bottom part
KVBox* box = new KVBox( splitter );
// Folders
m_tabBar = new AkonadiTabBar( box );
connect( m_tabBar, SIGNAL( currentChanged( const Akonadi::Collection& ) ),
SLOT( slotCurrentTabChanged( const Akonadi::Collection& ) ) );
mMessageList = new QTreeView( box );
mMessageList->setRootIsDecorated( false );
mMessageList->setDragEnabled( false );
mMessageList->setSelectionMode( QAbstractItemView::ExtendedSelection );
mMessageList->setSortingEnabled( true );
MicroblogDelegate *delegate = new MicroblogDelegate( mMessageList, this );
mMessageList->setItemDelegate( delegate );
mMessageModel = new BlogModel( this );
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel( this );
proxyModel->setSortRole( Qt::EditRole );
proxyModel->setDynamicSortFilter( true );
proxyModel->setSourceModel( mMessageModel );
mMessageList->setModel( proxyModel );
splitter->addWidget( box );
splitter->setSizes( QList<int>() << 30 << 470 );
}
void PersonalMessageWidget::initialize() {
setWindowTitle("Trek Personal Chat");
// QFont f = mUsernameLabel.font();
// f.setPointSize(11);
// mUsernameLabel.setFont(f);
mSendButton.setText("Send");
mSendButton.setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
mConversationText.setReadOnly(true);
mInputText.installEventFilter(this);
QHBoxLayout* inputLayout = new QHBoxLayout();
QWidget* inputWidget = new QWidget();
inputLayout->addWidget(&mInputText);
inputLayout->addWidget(&mSendButton);
inputWidget->setLayout(inputLayout);
QSplitter* splitter = new QSplitter();
splitter->setOrientation(Qt::Vertical);
splitter->addWidget(&mConversationText);
splitter->addWidget(inputWidget);
splitter->setCollapsible(0,false);
splitter->setCollapsible(1,false);
splitter->setHandleWidth(15);
mToolbar.setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
mSaveAction = mToolbar.addAction("Save");
mClearAction = mToolbar.addAction("Clear");
mGMainLayout.addWidget(&mUserIconLabel,0,2,2,1,Qt::AlignRight);
mGMainLayout.addWidget(&mToolbar, 1,0,1,2); //,1,2);
mGMainLayout.addWidget(&mUsernameLabel,0,0,Qt::AlignLeft);
mGMainLayout.addWidget(splitter, 2,0,1,3);
setLayout(&mGMainLayout);
QList<int> sizes;
sizes.append(400);
sizes.append(100);
splitter->setSizes(sizes);
userDataAltered();
connect(mClearAction, SIGNAL(triggered()), &mConversationText, SLOT(clear()));
connect(mSaveAction, SIGNAL(triggered()), this, SLOT(save()));
connect(&mSendButton, SIGNAL(clicked()), this, SLOT(send()));
connect(mUserData, SIGNAL(dataAltered()), this, SLOT(userDataAltered()));
connect(this, SIGNAL(controller_serverPersonalSpeak(const QUuid&, const QString&)), Controller::self(), SIGNAL(serverPersonalSpeak(const QUuid&, const QString&)));
connect(Controller::self(), SIGNAL(personalCommuniqueReceived(const QUuid&, const QString&)), this, SLOT(controller_personalCommuniqueReceived(const QUuid&, const QString&)));
}
MainWindow::MainWindow(QWidget *parent):QMainWindow(parent)
{
setMinimumSize(20, 20);
resize(1500, 900);
glViewer_1 = new QGLViewer;
glViewer_2 = new QGLViewer;
m_cross_param_control = new CrossParamControl(glViewer_1, glViewer_2, this);
createActions();
createMenus();
createToolBars();
QList <int> sizes1;
sizes1<<600<<600;
QSplitter* splitter = new QSplitter(Qt::Horizontal);
splitter->addWidget(glViewer_1);
splitter->addWidget(glViewer_2);
splitter->setSizes(sizes1);
QList <int> sizes2;
sizes2 << 1300 << 200;
QSplitter* mainSplitter = new QSplitter(Qt::Horizontal);
mainSplitter->addWidget(splitter);
mainSplitter->addWidget(m_cross_param_control);
mainSplitter->setSizes(sizes2);
mainSplitter->setStretchFactor(0, 1);
setCentralWidget(mainSplitter);
setWindowTitle("Cross Parameter");
connect(glViewer_1, SIGNAL(select_vertex()), this, SLOT(findCorrespondingOnB()));
// connect(glViewer_2, SIGNAL(select_vertex()), this, SLOT(findCorrespondingOnA()));
}
ScriptDock::ScriptDock(QWidget *parent)
: QDockWidget(parent),
mFileName(tr("untitled.lua")),
mMapDocument(0)
{
setObjectName(QLatin1String("scriptViewDock"));
mScriptArea = new ScriptEditor(this);
mScriptArea->setLineWrapMode(QPlainTextEdit::NoWrap);
connect(mScriptArea, SIGNAL(textChanged()),
SLOT(scriptChanged()));
mOutputArea = new QPlainTextEdit(this);
mOutputArea->setReadOnly(true);
highlighter = new ScriptHighlighter(mScriptArea->document());
QToolBar *buttonContainer = new QToolBar(this);
buttonContainer->setFloatable(false);
buttonContainer->setMovable(false);
buttonContainer->setIconSize(QSize(16, 16));
QAction *runAction = new QAction(this);
runAction->setShortcut(tr("Ctrl+Shift+R"));
runAction->setIcon(
QIcon(QLatin1String(":/images/16x16/script_run.png")));
buttonContainer->addAction(runAction);
connect(runAction, SIGNAL(triggered()),
SLOT(runScript()));
QWidget *widget = new QWidget(this);
QVBoxLayout *layout = new QVBoxLayout(widget);
layout->setMargin(5);
QSplitter *splitter = new QSplitter(Qt::Vertical, widget);
splitter->addWidget(mScriptArea);
splitter->addWidget(mOutputArea);
layout->addWidget(splitter);
layout->addWidget(buttonContainer);
QList<int> sizeList;
sizeList << 500 << 100;
splitter->setSizes(sizeList);
setWidget(widget);
retranslateUi();
}
void MainWindow::createLayout()
{
QVBoxLayout* mainLayout = new QVBoxLayout;
mainLayout->setContentsMargins(0,0,0,0);
QWidget* center = new QWidget(this);
center->setLayout(mainLayout);
setCentralWidget(center);
resize(Preferences::MainWindowSize());
mainLayout->addWidget(&m_toolBar);
m_helpBrowser.setWindowFlags(Qt::Tool);
// sideSplitter (ha ha) is a data member as we need to control its visibility
m_sideSplitter = new QSplitter(Qt::Vertical, this);
m_sideSplitter->addWidget(&m_viewerView);
/*
QWidget* progress = new QWidget(this);
progress->setLayoutDirection(
progress->addWidget();
progress->addWidget(&m_status);
progress->addWidget(&m_progressBar);
*/
m_sideSplitter->addWidget(&m_undoStackView);
m_sideSplitter->setCollapsible(0, true);
m_sideSplitter->setCollapsible(1, true);
QList<int> sizes;
sizes << Preferences::MainWindowSize().height()-220 << 220;
m_sideSplitter->setSizes(sizes);
// Main splitter
QSplitter* splitter = new QSplitter(Qt::Horizontal, this);
splitter->addWidget(m_sideSplitter);
splitter->addWidget(&m_viewer);
splitter->setCollapsible(0, true);
splitter->setCollapsible(1, false);
sizes.clear();
if (Preferences::ShowModelView()) {
sizes << 220 << Preferences::MainWindowSize().width()-200;
}else {
sizes << 0;
}
splitter->setSizes(sizes);
mainLayout->addWidget(splitter);
connect(splitter, SIGNAL(splitterMoved(int, int)), this, SLOT(splitterMoved(int, int)));
}
//------------------------------------------------------------------------------
//
int main( int argc, char** argv )
{
TApp app( argc, argv );
QSizePolicy maxsp( QSizePolicy::Maximum, QSizePolicy::Maximum );
QMainWindow* mw = new QMainWindow;
QWidget* cw = new QWidget( mw );
{
QHBoxLayout* lcw = new QHBoxLayout( cw );
QSplitter* spl = new QSplitter( cw );
{
spl->setOrientation( Qt::Vertical );
{
app.b1 = new QPushButton( spl );
app.b1->setText( "button 1" );
app.b2 = new QPushButton( spl);
app.b2->setText( "button 2" );
QObject::connect( app.b1, SIGNAL(clicked()),
&app, SLOT(clicked1()) );
QObject::connect( app.b2, SIGNAL(clicked()),
&app, SLOT(clicked2()) );
}
QValueList<int> vl;
vl.append( 10 );
vl.append( 20 );
spl->setSizes( vl );
}
lcw->addWidget( spl );
QPushButton* but = new QPushButton( cw );
but->setText( "overview" );
but->setSizePolicy( maxsp );
lcw->addWidget( but );
}
mw->statusBar();
mw->setCentralWidget( cw );
app.setMainWidget( mw );
mw->show();
int r = app.exec();
return r;
}
USBViewer::USBViewer(QWidget *parent, const char *name, const QStringList &) : KCModule(USBFactory::instance(), parent, name)
{
setButtons(Help);
setQuickHelp(
i18n("<h1>USB Devices</h1> This module allows you to see"
" the devices attached to your USB bus(es)."));
QVBoxLayout *vbox = new QVBoxLayout(this, 0, KDialog::spacingHint());
QGroupBox *gbox = new QGroupBox(i18n("USB Devices"), this);
gbox->setColumnLayout(0, Qt::Horizontal);
vbox->addWidget(gbox);
QVBoxLayout *vvbox = new QVBoxLayout(gbox->layout(), KDialog::spacingHint());
QSplitter *splitter = new QSplitter(gbox);
vvbox->addWidget(splitter);
_devices = new QListView(splitter);
_devices->addColumn(i18n("Device"));
_devices->setRootIsDecorated(true);
_devices->header()->hide();
_devices->setMinimumWidth(200);
_devices->setColumnWidthMode(0, QListView::Maximum);
QValueList< int > sizes;
sizes.append(200);
splitter->setSizes(sizes);
_details = new QTextView(splitter);
splitter->setResizeMode(_devices, QSplitter::KeepSize);
QTimer *refreshTimer = new QTimer(this);
// 1 sec seems to be a good compromise between latency and polling load.
refreshTimer->start(1000);
connect(refreshTimer, SIGNAL(timeout()), SLOT(refresh()));
connect(_devices, SIGNAL(selectionChanged(QListViewItem *)), this, SLOT(selectionChanged(QListViewItem *)));
KAboutData *about = new KAboutData(I18N_NOOP("kcmusb"), I18N_NOOP("KDE USB Viewer"), 0, 0, KAboutData::License_GPL,
I18N_NOOP("(c) 2001 Matthias Hoelzer-Kluepfel"));
about->addAuthor("Matthias Hoelzer-Kluepfel", 0, "*****@*****.**");
about->addCredit("Leo Savernik", "Live Monitoring of USB Bus", "*****@*****.**");
setAboutData(about);
load();
}
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();
}
QWidget* ViewAreaImpl::restoreSplitter(const Mapping& state, Archive* archive)
{
QWidget* widget = 0;
QWidget* childWidgets[2] = { 0, 0 };
const Listing& children = *state.findListing("children");
if(children.isValid()){
int numChildren = std::min(children.size(), 2);
for(int i=0; i < numChildren; ++i){
if(children[i].isMapping()){
const Mapping& childState = *children[i].toMapping();
childWidgets[i] = restoreViewContainer(childState, archive);
}
}
if(!childWidgets[0] || !childWidgets[1]){
for(int i=0; i < 2; ++i){
if(childWidgets[i]){
widget = childWidgets[i];
break;
}
}
} else {
QSplitter* splitter = new QSplitter();
string orientation;
if(state.read("orientation", orientation)){
splitter->setOrientation((orientation == "vertical") ? Qt::Vertical : Qt::Horizontal);
}
splitter->addWidget(childWidgets[0]);
splitter->addWidget(childWidgets[1]);
const Listing& sizes = *state.findListing("sizes");
if(sizes.isValid() && sizes.size() == 2){
QList<int> s;
int size;
for(int i=0; i < 2; ++i){
if(sizes[i].read(size)){
s.push_back(size);
}
}
splitter->setSizes(s);
}
widget = splitter;
}
}
return widget;
}
/**************************************************************************
Help dialog constructor
**************************************************************************/
help_dialog::help_dialog(QWidget *parent) :
QDialog(parent)
{
QSplitter *splitter;
QList<int> sizes;
QTreeWidgetItem *first;
QVBoxLayout *layout;
QDialogButtonBox *box;
setWindowTitle(_("Freeciv Help Browser"));
setWindowFlags(Qt::WindowStaysOnTopHint);
resize(750, 450);
layout = new QVBoxLayout(this);
splitter = new QSplitter(this);
layout->addWidget(splitter);
tree_wdg = new QTreeWidget();
tree_wdg->setHeaderHidden(true);
make_tree();
splitter->addWidget(tree_wdg);
help_wdg = new help_widget(splitter);
connect(
tree_wdg,
SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),
this, SLOT(item_changed(QTreeWidgetItem *)));
help_wdg->layout()->setContentsMargins(0, 0, 0, 0);
splitter->addWidget(help_wdg);
sizes << 150 << 600;
splitter->setSizes(sizes);
box = new QDialogButtonBox(QDialogButtonBox::Close);
layout->addWidget(box);
box->addButton(_("About Qt"), QDialogButtonBox::HelpRole);
box->button(QDialogButtonBox::Close)->setDefault(true);
connect(box, &QDialogButtonBox::rejected, this, &QWidget::close);
connect(box, &QDialogButtonBox::helpRequested, &QApplication::aboutQt);
first = tree_wdg->topLevelItem(0);
if (first) {
tree_wdg->setCurrentItem(first);
}
}
void PropertiesWidget::readSettings() {
QIniSettings settings;
// Restore splitter sizes
QStringList sizes_str = settings.value(QString::fromUtf8("TorrentProperties/SplitterSizes"), QString()).toString().split(",");
if (sizes_str.size() == 2) {
slideSizes << sizes_str.first().toInt();
slideSizes << sizes_str.last().toInt();
QSplitter *hSplitter = static_cast<QSplitter*>(parentWidget());
hSplitter->setSizes(slideSizes);
}
if (!filesList->header()->restoreState(settings.value("TorrentProperties/FilesListState").toByteArray())) {
filesList->header()->resizeSection(0, 400); //Default
}
const int current_tab = settings.value("TorrentProperties/CurrentTab", -1).toInt();
m_tabBar->setCurrentIndex(current_tab);
if (!settings.value("TorrentProperties/Visible", false).toBool()) {
setVisibility(false);
}
}
void PropertiesWidget::readSettings()
{
const Preferences *const pref = Preferences::instance();
// Restore splitter sizes
QStringList sizes_str = pref->getPropSplitterSizes().split(",");
if (sizes_str.size() == 2) {
slideSizes << sizes_str.first().toInt();
slideSizes << sizes_str.last().toInt();
QSplitter *hSplitter = static_cast<QSplitter *>(parentWidget());
hSplitter->setSizes(slideSizes);
}
const int current_tab = pref->getPropCurTab();
const bool visible = pref->getPropVisible();
// the following will call saveSettings but shouldn't change any state
if (!m_ui->filesList->header()->restoreState(pref->getPropFileListState()))
m_ui->filesList->header()->resizeSection(0, 400); // Default
m_tabBar->setCurrentIndex(current_tab);
if (!visible)
setVisibility(false);
}
