void GLShaderDev::initializeDockWidgets()
{
QSplitter* splitter = new QSplitter;
QTabWidget* optionTab = new QTabWidget;
_shaderStages = new ShaderStagesView;
_shaderInput = new ShaderInputView;
optionTab->setMovable(true);
optionTab->addTab(_shaderInput, tr("Shader Input"));
optionTab->addTab(_shaderStages, tr("Build Stages"));
splitter->setOrientation(Qt::Vertical);
splitter->addWidget(_glpreview);
splitter->addWidget(optionTab);
QDockWidget *dockWidget = new QDockWidget(tr("OpenGL View"), this);
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
dockWidget->setWidget(splitter);
addDockWidget(Qt::RightDockWidgetArea, dockWidget);
// dockWidget->setFloating(true); FIXME
_buildOutputDock = new QDockWidget(tr("Build log"), this);
_buildOutputDock->setAllowedAreas(Qt::BottomDockWidgetArea);
_buildOutputDock->setFeatures(QDockWidget::DockWidgetVerticalTitleBar | _buildOutputDock->features());
_buildOutputDock->setWidget(_output);
addDockWidget(Qt::BottomDockWidgetArea, _buildOutputDock);
_buildOutputDock->hide();
connect(_output, SIGNAL(dereferencableItemActivated(const QString&, int, int)), _editor, SLOT(gotoFile(const QString&, int, int)));
}
logDirBrowser::logDirBrowser(QString path, QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
this->setWindowTitle(QString("Log Viewer :: Directory Browser [") + path + QString("]"));
this->doc = new QTextDocument();
this->dirModel = new QDirModel();
QSplitter* split = new QSplitter();
this->tree = new QTreeView(split);
this->texte = new QTextEdit(split);
this->tree->setSortingEnabled(true);
this->tree->setModel(this->dirModel);
this->tree->setRootIndex(this->dirModel->index(path));
for (int c = 0; c < this->dirModel->columnCount(); ++c) {
this->tree->resizeColumnToContents(c);
}
split->setOrientation(Qt::Vertical);
this->texte->setReadOnly(true);
connect(this->tree,SIGNAL(expanded(const QModelIndex &)),this,SLOT(slot_viewItem(const QModelIndex &)));
this->layout()->addWidget(split);
}
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 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);
}
}
}
}
MainWindow::MainWindow(QWidget *parent)
: QWidget(parent)
{
populateScene();
h1Splitter = new QSplitter;
h2Splitter = new QSplitter;
QSplitter *vSplitter = new QSplitter;
vSplitter->setOrientation(Qt::Vertical);
vSplitter->addWidget(h1Splitter);
vSplitter->addWidget(h2Splitter);
View *view = new View("Top left view");
view->view()->setScene(scene);
h1Splitter->addWidget(view);
view = new View("Top right view");
view->view()->setScene(scene);
h1Splitter->addWidget(view);
view = new View("Bottom left view");
view->view()->setScene(scene);
h2Splitter->addWidget(view);
view = new View("Bottom right view");
view->view()->setScene(scene);
h2Splitter->addWidget(view);
QHBoxLayout *layout = new QHBoxLayout;
layout->addWidget(vSplitter);
setLayout(layout);
setWindowTitle(tr("Chip Demo"));
}
main_window()
{
QWidget * top = new QWidget(this);
m_layout = new QGridLayout(top);
setCentralWidget(top);
m_first = new draw_widget(top);
m_second = new draw_widget(top);
m_third = new draw_widget(top);
m_top_splitter = new QSplitter(top);
m_top_splitter->addWidget(m_first);
QSplitter * other = new QSplitter(top);
other->addWidget(m_second);
QSplitter * another = new QSplitter(top);
another->addWidget(m_third);
another->setOrientation(Qt::Horizontal);
m_layout->addWidget(m_top_splitter,0,0);
m_layout->addWidget(other,1,0,1,2);
m_layout->addWidget(another,0,1);
}
StatisticsDock::StatisticsDock(QWidget *parent) :
QDockWidget(parent)
{
setWindowTitle(tr("Statistics"));
QSplitter * mainSplitter = new QSplitter(this);
mainSplitter->setOrientation(Qt::Vertical);
QLabel * bootedUpTimeTextLabel = new QLabel("Booted up:",this);
bootedUpTimeLabel = new QLabel("not available",this);
QLabel * appRunningTimeTextLabel = new QLabel("Running for:",this);
appRunningTimeLabel= new QLabel("0 s",this);
QLabel * lastUpdateTextLabel = new QLabel("Last update:",this);
lastUpdateLabel= new QLabel(QDateTime::currentDateTime().toString("hh:mm:ss"),this);
mainSplitter->addWidget(bootedUpTimeTextLabel);
mainSplitter->addWidget(bootedUpTimeLabel);
mainSplitter->addWidget(appRunningTimeTextLabel);
mainSplitter->addWidget(appRunningTimeLabel);
mainSplitter->addWidget(lastUpdateTextLabel);
mainSplitter->addWidget(lastUpdateLabel);
mainSplitter->addWidget(new QWidget());
setWidget(mainSplitter);
QTimer *timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(updateStatistics()));
timer->start(iUpdateMs);
elapsedTime = new QElapsedTimer();
elapsedTime->start();
}
QueryWidget::QueryWidget(IServerSPtr server, QWidget* parent)
: QWidget(parent)
{
shellWidget_ = new BaseShellWidget(server);
outputWidget_ = new OutputWidget(server);
VERIFY(connect(shellWidget_, &BaseShellWidget::rootCreated, outputWidget_, &OutputWidget::rootCreate));
VERIFY(connect(shellWidget_, &BaseShellWidget::rootCompleated, outputWidget_, &OutputWidget::rootCompleate));
VERIFY(connect(shellWidget_, &BaseShellWidget::addedChild, outputWidget_, &OutputWidget::addChild));
VERIFY(connect(shellWidget_, &BaseShellWidget::itemUpdated, outputWidget_, &OutputWidget::itemUpdate));
QSplitter* splitter = new QSplitter;
#ifdef OS_WIN
splitter->setStyleSheet("QSplitter::handle { background-color: gray }");
#endif
splitter->setOrientation(Qt::Vertical);
splitter->setHandleWidth(1);
QVBoxLayout *mainLayout = new QVBoxLayout;
splitter->addWidget(shellWidget_);
splitter->addWidget(outputWidget_);
splitter->setStretchFactor(0, 0);
splitter->setStretchFactor(1, 1);
mainLayout->addWidget(splitter);
setMinimumSize(QSize(min_width, min_height));
setLayout(mainLayout);
}
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 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 ();
}
QWidget* MainWindow::createRightView()
{
QSplitter* splitter = new QSplitter;
splitter->setOrientation(Qt::Vertical);
splitter->addWidget(new QTreeView);
splitter->addWidget(new QTreeView);
return splitter;
}
MultiWindowVisApp::MultiWindowVisApp(VisItViewer *v) : QMainWindow()
{
viewer = v;
windowsAdded = false;
currentWindow = 0;
for(int i = 0; i < NWINDOWS + 1; ++i)
viswindows[i] = 0;
setWindowTitle(tr("Multiwindow visualization"));
// Create the window.
QWidget *central = new QWidget(this);
setCentralWidget(central);
QHBoxLayout *hLayout = new QHBoxLayout(central);
hLayout->setMargin(10);
hLayout->setSpacing(10);
QVBoxLayout *leftLayout = new QVBoxLayout(0);
leftLayout->setSpacing(10);
hLayout->addLayout(leftLayout);
QLabel *scalarLabel = new QLabel(tr("Scalar variables"), central);
leftLayout->addWidget(scalarLabel);
variables = new QListWidget(central);
leftLayout->addWidget(variables);
connect(variables, SIGNAL(currentTextChanged(const QString &)),
this, SLOT(onSelectVariable(const QString &)));
// Create the visualization windows. Do an easy layout in this example.
QSplitter *splitter = new QSplitter(central);
splitter->setOrientation(Qt::Horizontal);
hLayout->addWidget(splitter, 100);
viswindows[PSEUDOCOLOR_WINDOW] = new vtkQtRenderWindow(splitter);
viswindows[PSEUDOCOLOR_WINDOW]->setMinimumSize(QSize(300,400));
viswindows[VOLUME_WINDOW] = new vtkQtRenderWindow(splitter);
viswindows[VOLUME_WINDOW]->setMinimumSize(QSize(300,400));
//
// Register a window creation function (before Setup) that will
// return the vtkQtRenderWindow objects that we've already
// parented into our interface.
//
viewer->SetWindowCreationCallback(ReturnVisWin, (void *)this);
// Create menus
QMenu *fileMenu = menuBar()->addMenu(tr("File"));
fileMenu->addAction(tr("Open . . ."), this, SLOT(selectFile()));
fileMenu->addSeparator();
fileMenu->addAction(tr("Quit"), qApp, SLOT(quit()));
QMenu *controlsMenu = menuBar()->addMenu(tr("Controls"));
controlsMenu->addAction(tr("Open GUI"), this, SLOT(openGUI()));
}
EncodeDecodeDialog::EncodeDecodeDialog(QWidget* parent)
: QDialog(parent)
{
setWindowIcon(GuiFactory::instance().encodeDecodeIcon());
setWindowTitle(translations::trEncodeDecode);
setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
QVBoxLayout* layout = new QVBoxLayout;
QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
QPushButton* closeButton = buttonBox->button(QDialogButtonBox::Close);
buttonBox->addButton(closeButton, QDialogButtonBox::ButtonRole(QDialogButtonBox::RejectRole | QDialogButtonBox::AcceptRole));
VERIFY(connect(buttonBox, &QDialogButtonBox::rejected, this, &EncodeDecodeDialog::reject));
QToolButton* decode = new QToolButton;
decode->setIcon(GuiFactory::instance().executeIcon());
VERIFY(connect(decode, &QToolButton::clicked, this, &EncodeDecodeDialog::decode));
decoders_ = new QComboBox;
for(int i = 0; i < SIZEOFMASS(common::EDecoderTypes); ++i) {
decoders_->addItem(common::convertFromString<QString>(common::EDecoderTypes[i]));
}
QHBoxLayout* toolBarLayout = new QHBoxLayout;
toolBarLayout->setContentsMargins(0, 0, 0, 0);
toolBarLayout->addWidget(decode);
toolBarLayout->addWidget(decoders_);
encodeButton_ = new QRadioButton;
decodeButton_ = new QRadioButton;
toolBarLayout->addWidget(encodeButton_);
toolBarLayout->addWidget(decodeButton_);
QSplitter* splitter = new QSplitter;
splitter->setOrientation(Qt::Horizontal);
splitter->setHandleWidth(1);
splitter->setContentsMargins(0, 0, 0, 0);
toolBarLayout->addWidget(splitter);
input_ = new FastoEditor;
input_->installEventFilter(this);
output_ = new FastoEditor;
output_->installEventFilter(this);
layout->addWidget(input_);
layout->addLayout(toolBarLayout);
layout->addWidget(output_);
layout->addWidget(buttonBox);
setMinimumSize(QSize(width, height));
setLayout(layout);
retranslateUi();
}
CentralWidget::CentralWidget(QWidget *parent) : QWidget(parent), timeOut(DEFAULT_TIMEOUT)
{
watcher = new QFutureWatcher<QSharedPointer<PatternViewMap>>();
compiler = new PatternCompiler();
txt = new TextBasicWidget(this);
pattern = new PatternsBasicWidget(compiler,this);
matches = new MatchesBasicWidget(this);
timeoutTimer = new QTimer(this);
timeoutTimer->setSingleShot(true);
QSplitter* vert = new QSplitter();
QSplitter* horiz = new QSplitter();
QWidget* containter = new QWidget();
QHBoxLayout* containterLay = new QHBoxLayout();
QVBoxLayout* mainLay = new QVBoxLayout();
containterLay->setContentsMargins(0,0,0,0);
horiz->addWidget(txt);
horiz->addWidget(pattern);
containterLay->addWidget(horiz);
containter->setLayout(containterLay);
vert->setOrientation(Qt::Vertical);
vert->addWidget(containter);
vert->addWidget(matches);
// vert->addWidget(progress);
mainLay->addWidget(vert);
setLayout(mainLay);
connect(pattern,SIGNAL(matchClicked()), this,SLOT(slotAnalyze()));
connect(matches,SIGNAL(patternWasUnchecked(QString)),txt,SLOT(slotPatternUncheked(QString)));
connect(matches,SIGNAL(patternWasChecked(QString)),txt,SLOT(slotPatternChecked(QString)));
connect(matches,SIGNAL(showAll()),txt,SLOT(slotHighlightAll()));
connect(matches,SIGNAL(showAll()),pattern,SLOT(slotDisableMatch()));
connect(matches,SIGNAL(hideAll()),txt,SLOT(slotDehighlightAll()));
connect(matches,SIGNAL(rowClicked(int,int)),txt,SLOT(slotSelectFragment(int,int)));
connect(matches,SIGNAL(patternWasUnchecked(QString)),this,SIGNAL(statusHighlighting()));
connect(matches,SIGNAL(patternWasChecked(QString)),this,SIGNAL(statusHighlighting()));
connect(txt,SIGNAL(tabChanged(int)),matches,SLOT(slotChangeTab(int)));
connect(txt,SIGNAL(tabClosed(int)),matches,SLOT(slotCloseTab(int)));
connect(txt,SIGNAL(editEnabled()),matches,SLOT(slotClear()));
connect(txt,SIGNAL(editEnabled()),this,SLOT(slotEdit()));
connect(txt,SIGNAL(checkingEnabled()),matches,SLOT(slotEnableChecking()));
connect(txt,SIGNAL(checkingEnabled()),this,SIGNAL(statusReady()));
connect(txt, SIGNAL(checkingEnabled()),pattern, SLOT(slotEnableMatch()));
connect(watcher,SIGNAL(finished()),this,SLOT(slotDisplay()));
connect(timeoutTimer,SIGNAL(timeout()),this,SLOT(slotTimeout()));
//connect(watcher,SIGNAL(progressValueChanged(int)),this,SLOT(slotProgress(int)));
if (QFile::exists(CRASH_TEXT) && QFile::exists(CRASH_PATTERNS)){
loadAfterCrash(CRASH_TEXT, CRASH_PATTERNS);
}
}
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&)));
}
ServerHistoryDialog::ServerHistoryDialog(const QString& title, connectionTypes type, QWidget* parent)
: QDialog(parent, Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint ), type_(type)
{
using namespace translations;
setWindowIcon(GuiFactory::instance().icon(type_));
setWindowTitle(title);
graphWidget_ = new fasto::qt::gui::GraphWidget;
settingsGraph_ = new QWidget;
QHBoxLayout *mainL = new QHBoxLayout;
QSplitter *splitter = new QSplitter;
splitter->setOrientation(Qt::Horizontal);
splitter->setHandleWidth(1);
splitter->setContentsMargins(0, 0, 0, 0);
mainL->addWidget(splitter);
splitter->addWidget(settingsGraph_);
serverInfoGroupsNames_ = new QComboBox;
serverInfoFields_ = new QComboBox;
typedef void (QComboBox::*curc)(int);
VERIFY(connect(serverInfoGroupsNames_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshInfoFields ));
VERIFY(connect(serverInfoFields_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshGraph ));
if(type_ == REDIS){
for(int i = 0; i < redisHeaders.size(); ++i){
serverInfoGroupsNames_->addItem(common::convertFromString<QString>(redisHeaders[i]));
}
}
else if(type_ == MEMCACHED){
for(int i = 0; i < memcachedHeaders.size(); ++i){
serverInfoGroupsNames_->addItem(common::convertFromString<QString>(memcachedHeaders[i]));
}
}
else if(type_ == SSDB){
for(int i = 0; i < SsdbHeaders.size(); ++i){
serverInfoGroupsNames_->addItem(common::convertFromString<QString>(SsdbHeaders[i]));
}
}
QVBoxLayout *setingsLayout = new QVBoxLayout;
setingsLayout->addWidget(serverInfoGroupsNames_);
setingsLayout->addWidget(serverInfoFields_);
settingsGraph_->setLayout(setingsLayout);
splitter->addWidget(graphWidget_);
setLayout(mainL);
glassWidget_ = new fasto::qt::gui::GlassWidget(GuiFactory::instance().pathToLoadingGif(), trLoading, 0.5, QColor(111, 111, 100), this);
}
OutputWidget::OutputWidget(IServerSPtr server, QWidget* parent)
: QWidget(parent)
{
commonModel_ = new FastoCommonModel(this);
VERIFY(connect(commonModel_, &FastoCommonModel::changedValue, server.get(), &IServer::changeValue, Qt::DirectConnection));
VERIFY(connect(server.get(), &IServer::startedChangeDbValue, this, &OutputWidget::startChangeDbValue, Qt::DirectConnection));
VERIFY(connect(server.get(), &IServer::finishedChangeDbValue, this, &OutputWidget::finishChangeDbValue, Qt::DirectConnection));
treeView_ = new FastoTreeView;
treeView_->setModel(commonModel_);
tableView_ = new FastoTableView;
tableView_->setModel(commonModel_);
textView_ = new FastoTextView(server->outputDelemitr());
textView_->setModel(commonModel_);
textView_->setReadOnly(true);
timeLabel_ = new fasto::qt::gui::IconLabel(GuiFactory::instance().timeIcon(), "0", QSize(32, 32));
QVBoxLayout* mainL = new QVBoxLayout;
QHBoxLayout* topL = new QHBoxLayout;
QSplitter* splitter = new QSplitter;
splitter->setOrientation(Qt::Horizontal);
splitter->setHandleWidth(1);
splitter->setContentsMargins(0, 0, 0, 0);
treeButton_ = new QPushButton;
tableButton_ = new QPushButton;
textButton_ = new QPushButton;
treeButton_->setIcon(GuiFactory::instance().treeIcon());
VERIFY(connect(treeButton_, SIGNAL(clicked()), this, SLOT(setTreeView())));
tableButton_->setIcon(GuiFactory::instance().tableIcon());
VERIFY(connect(tableButton_, SIGNAL(clicked()), this, SLOT(setTableView())));
textButton_->setIcon(GuiFactory::instance().textIcon());
VERIFY(connect(textButton_, SIGNAL(clicked()), this, SLOT(setTextView())));
topL->addWidget(treeButton_);
topL->addWidget(tableButton_);
topL->addWidget(textButton_);
topL->addWidget(splitter);
topL->addWidget(timeLabel_);
mainL->addLayout(topL);
mainL->addWidget(treeView_);
mainL->addWidget(tableView_);
mainL->addWidget(textView_);
setLayout(mainL);
syncWithSettings();
}
//------------------------------------------------------------------------------
//
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;
}
ServerHistoryDialog::ServerHistoryDialog(IServerSPtr server, QWidget* parent)
: QDialog(parent, Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint ), server_(server)
{
using namespace translations;
CHECK(server_);
setWindowIcon(GuiFactory::instance().icon(server_->type()));
graphWidget_ = new fasto::qt::gui::GraphWidget;
settingsGraph_ = new QWidget;
QHBoxLayout *mainL = new QHBoxLayout;
QSplitter *splitter = new QSplitter;
splitter->setOrientation(Qt::Horizontal);
splitter->setHandleWidth(1);
mainL->addWidget(splitter);
splitter->addWidget(settingsGraph_);
clearHistory_ = new QPushButton;
VERIFY(connect(clearHistory_, &QPushButton::clicked, this, &ServerHistoryDialog::clearHistory));
serverInfoGroupsNames_ = new QComboBox;
serverInfoFields_ = new QComboBox;
typedef void (QComboBox::*curc)(int);
VERIFY(connect(serverInfoGroupsNames_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshInfoFields ));
VERIFY(connect(serverInfoFields_, static_cast<curc>(&QComboBox::currentIndexChanged), this, &ServerHistoryDialog::refreshGraph ));
const std::vector<std::string> headers = infoHeadersFromType(server_->type());
for(int i = 0; i < headers.size(); ++i){
serverInfoGroupsNames_->addItem(common::convertFromString<QString>(headers[i]));
}
QVBoxLayout *setingsLayout = new QVBoxLayout;
setingsLayout->addWidget(clearHistory_);
setingsLayout->addWidget(serverInfoGroupsNames_);
setingsLayout->addWidget(serverInfoFields_);
settingsGraph_->setLayout(setingsLayout);
splitter->addWidget(graphWidget_);
setLayout(mainL);
glassWidget_ = new fasto::qt::gui::GlassWidget(GuiFactory::instance().pathToLoadingGif(), trLoading, 0.5, QColor(111, 111, 100), this);
VERIFY(connect(server.get(), &IServer::startedLoadServerHistoryInfo, this, &ServerHistoryDialog::startLoadServerHistoryInfo));
VERIFY(connect(server.get(), &IServer::finishedLoadServerHistoryInfo, this, &ServerHistoryDialog::finishLoadServerHistoryInfo));
VERIFY(connect(server.get(), &IServer::startedClearServerHistory, this, &ServerHistoryDialog::startClearServerHistory));
VERIFY(connect(server.get(), &IServer::finishedClearServerHistory, this, &ServerHistoryDialog::finishClearServerHistory));
VERIFY(connect(server.get(), &IServer::serverInfoSnapShoot, this, &ServerHistoryDialog::snapShotAdd));
retranslateUi();
}
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;
}
void SyncMeasuresDialog::createLayout()
{
setWindowTitle("Updates Available in Library");
setModal(true);
setSizeGripEnabled(true);
setObjectName("BlueGradientWidget");
// The central pane
m_centralWidget = new SyncMeasuresDialogCentralWidget(m_project, m_measureManager);
connect(m_centralWidget, &SyncMeasuresDialogCentralWidget::componentClicked, this, &SyncMeasuresDialog::on_componentClicked);
connect(m_centralWidget, &SyncMeasuresDialogCentralWidget::noComponents, this, &SyncMeasuresDialog::on_noComponents);
connect(m_centralWidget, &SyncMeasuresDialogCentralWidget::closeDlg, this, &SyncMeasuresDialog::closeDlg);
QScrollArea * centralScrollArea = new QScrollArea(this);
centralScrollArea->setFrameStyle(QFrame::NoFrame);
centralScrollArea->setObjectName("GrayWidget");
centralScrollArea->setWidgetResizable(true);
centralScrollArea->setWidget(m_centralWidget);
// The right pane
m_rightScrollArea = new QScrollArea(this);
m_rightScrollArea->setFrameStyle(QFrame::NoFrame);
m_rightScrollArea->setObjectName("GrayWidget");
m_rightScrollArea->setWidgetResizable(true);
QSplitter * splitter = new QSplitter(this);
splitter->setOrientation(Qt::Horizontal);
splitter->addWidget(centralScrollArea);
splitter->addWidget(m_rightScrollArea);
QHBoxLayout * mainLayout = new QHBoxLayout();
mainLayout->addWidget(splitter);
setLayout(mainLayout);
m_centralWidget->lowerPushButton->setFocus();
}
VariantPropertyDialog::VariantPropertyDialog( QWidget * parent, const char * name , bool modal, Qt::WFlags f )
:QDialog (parent, name, modal, f)
{
Q3GridLayout * grid_layout = new Q3GridLayout( this, 1, 1, 11, 6, "GridLayout");
QSplitter * splitter = new QSplitter( this, "splitter3" );
splitter->setOrientation( Qt::Horizontal );
table = new VariantItemTable( splitter, "table" );
table->setNumCols (1);
// table->show();
treeview = new VariantListTreeView( splitter, table );
treeview->addColumn( tr( "Column 1" ) );
// treview->show();
splitter->moveToFirst (treeview);
grid_layout->addWidget( splitter, 0, 0 );
Q3HBoxLayout * layout4 = new Q3HBoxLayout( 0, 0, 6, "layout4");
QSpacerItem * spacer2 = new QSpacerItem( 40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout4->addItem( spacer2 );
btn_ok = new QPushButton( this, "Ok" );
btn_ok->setText ("Ok");
connect (btn_ok, SIGNAL (clicked()), this, SLOT (accept() ) );
layout4->addWidget( btn_ok );
QSpacerItem * spacer1 = new QSpacerItem( 200, 23, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout4->addItem( spacer1 );
btn_cancel = new QPushButton( this, "Cancel" );
btn_cancel->setText ("Cancel");
connect (btn_cancel, SIGNAL (clicked()), this, SLOT (reject() ) );
layout4->addWidget( btn_cancel );
QSpacerItem * spacer4 = new QSpacerItem( 40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout4->addItem( spacer4 );
grid_layout->addLayout( layout4, 1, 0 );
resize( QSize(735, 568).expandedTo(minimumSizeHint()) );
//clearWState( WState_Polished );
}
void WebkitShow::initUI()
{
view = new QWebView(this);
QUrl url = QUrl(QString("file:///%1/echarts-1.4.1/test/allchart/all.html").arg(QDir::currentPath()));
qDebug(qPrintable(QString("file:///%1/echarts-1.4.1/test/allchart/all.html").arg(QDir::currentPath())));
view->load(url);
// setupInspector();
QSplitter* splitter = new QSplitter;
splitter->setOrientation(Qt::Vertical);
splitter->addWidget(view);
// splitter->addWidget(webInspector);
QVBoxLayout* mainLayout = new QVBoxLayout;
mainLayout->addWidget(splitter);
mainLayout->setContentsMargins(0, 0, 0, 0);
mainLayout->setSpacing(0);
setLayout(mainLayout);
}
CombiView::CombiView(Gui::Document* pcDocument, QWidget *parent)
: DockWindow(pcDocument,parent), oldTabIndex(0)
{
setWindowTitle(tr("CombiView"));
QGridLayout* pLayout = new QGridLayout(this);
pLayout->setSpacing( 0 );
pLayout->setMargin ( 0 );
// tabs to switch between Tree/Properties and TaskPanel
tabs = new QTabWidget ();
tabs->setObjectName(QString::fromUtf8("combiTab"));
tabs->setTabPosition(QTabWidget::North);
pLayout->addWidget( tabs, 0, 0 );
// splitter between tree and property view
QSplitter *splitter = new QSplitter();
splitter->setOrientation(Qt::Vertical);
// tree widget
tree = new TreeWidget(this);
//tree->setRootIsDecorated(false);
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/TreeView");
tree->setIndentation(hGrp->GetInt("Indentation", tree->indentation()));
splitter->addWidget(tree);
// property view
prop = new PropertyView(this);
splitter->addWidget(prop);
tabs->addTab(splitter,trUtf8("Model"));
// task panel
taskPanel = new Gui::TaskView::TaskView(this);
tabs->addTab(taskPanel, trUtf8("Tasks"));
// task panel
//projectView = new Gui::ProjectWidget(this);
//tabs->addTab(projectView, trUtf8("Project"));
}
QueryWidget::QueryWidget(core::IServerSPtr server, QWidget* parent)
: QWidget(parent), server_(server) {
shellWidget_ = new shell::BaseShellWidget(server);
outputWidget_ = new OutputWidget(server);
QSplitter* splitter = new QSplitter;
#ifdef OS_WIN
splitter->setStyleSheet("QSplitter::handle { background-color: gray }");
#endif
splitter->setOrientation(Qt::Vertical);
splitter->setHandleWidth(1);
QVBoxLayout* mainLayout = new QVBoxLayout;
splitter->addWidget(shellWidget_);
splitter->addWidget(outputWidget_);
splitter->setStretchFactor(0, 0);
splitter->setStretchFactor(1, 1);
mainLayout->addWidget(splitter);
setMinimumSize(QSize(min_width, min_height));
setLayout(mainLayout);
}
ChatPageWidget::ChatPageWidget(int friendId, QWidget* parent) :
QWidget(parent), friendId(friendId)
{
friendItem = new FriendItemWidget(this);
display = new MessageDisplayWidget(this);
input = new InputTextWidget(this);
connect(input, &InputTextWidget::sendMessage, this, &ChatPageWidget::sendMessage);
connect(input, &InputTextWidget::sendAction, this, &ChatPageWidget::sendAction);
// Create emoticon menu :)
CustomHintWidget *inputPanel = new CustomHintWidget(this, QSize(10, 10));
EmoticonMenu *menu = new EmoticonMenu(this);
emoticonButton = new QToolButton(inputPanel);
emoticonButton->setPopupMode(QToolButton::InstantPopup);
emoticonButton->setIcon(QIcon(":/icons/emoticons/emotion_smile.png"));
emoticonButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
emoticonButton->setMenu(menu);
connect(menu, &EmoticonMenu::insertEmoticon, input, &InputTextWidget::insertHtml);
QHBoxLayout *inputLayout = new QHBoxLayout(inputPanel);
inputLayout->setContentsMargins(0,0,0,0);
inputLayout->setSpacing(2);
inputLayout->addWidget(input);
inputLayout->addWidget(emoticonButton);
QSplitter* splitter = new QSplitter(this);
splitter->setOrientation(Qt::Vertical);
splitter->setChildrenCollapsible(false);
splitter->addWidget(display);
splitter->addWidget(inputPanel);
splitter->setStretchFactor(0, 3);
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(friendItem);
layout->addWidget(splitter);
layout->setSpacing(2);
layout->setContentsMargins(0, 0, 2, 3);
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::MainWindow)
, m_ports()
, m_listener(NULL)
{
ui->setupUi(this);
ui->groupBox->setEnabled(false);
ui->pbConnect->setText(tr("&Connect"));
ui->pbRefresh->setText(tr("&Refresh"));
ui->pbSpeak->setText(tr("&Speak"));
checkPorts();
QSplitter *splitter = new QSplitter(this);
splitter->setOrientation(Qt::Vertical);
ui->verticalLayout_2->addWidget(splitter);
ui->teInfo->setParent(splitter);
ui->tePlainText->setParent(splitter);
statusBar()->showMessage(QString("Version ")+qApp->applicationVersion());
}
ChatPageWidget::ChatPageWidget(const QString& userId, QWidget* parent) :
QWidget(parent), userId(userId)
{
friendItem = new FriendItemWidget(this);
display = new MessageDisplayWidget(this);
input = new InputTextWidget(this);
connect(input, &InputTextWidget::messageSent, this, &ChatPageWidget::messageSent);
connect(input, &InputTextWidget::messageSent, this, &ChatPageWidget::onMessageSent);
QSplitter* splitter = new QSplitter(this);
splitter->setOrientation(Qt::Vertical);
splitter->setChildrenCollapsible(false);
splitter->addWidget(display);
splitter->addWidget(input);
splitter->setStretchFactor(1, 3);
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(friendItem);
layout->addWidget(splitter);
layout->setSpacing(2);
layout->setContentsMargins(0, 3, 2, 3);
}
void MainWindow::setupView()
{
QSplitter *splitter = new QSplitter;
splitter->setOrientation(Qt::Vertical);
QTableView *table = new QTableView;
HistogramView *histogram = new HistogramView(splitter);
table->setModel(model);
histogram->setModel(model);
QItemSelectionModel *selectionModel = new QItemSelectionModel(model);
table->setSelectionModel(selectionModel);
histogram->setSelectionModel(selectionModel);
connect(selectionModel,SIGNAL(selectionChanged(const QItemSelection, const QItemSelection)),
histogram,SLOT(selectionChanged(const QItemSelection, const QItemSelection)));
connect(selectionModel,SIGNAL(selectionChanged(const QItemSelection, const QItemSelection)),
table,SLOT(selectionChanged(const QItemSelection, const QItemSelection)));
splitter->addWidget(table);
splitter->addWidget(histogram);
setCentralWidget(splitter);
}
MainWindow::MainWindow( const QString &marbleDataPath, const QVariantMap &cmdLineSettings, QWidget *parent ) :
QMainWindow( parent ),
m_marbleWidget( new MarbleWidget( this ) ),
m_legendBrowser( new MarbleLegendBrowser( this ) ),
m_downloadRegionDialog( 0 ),
m_mapViewDialog( 0 ),
m_routingWindow( 0 ),
m_trackingWindow( 0 ),
m_gotoDialog( 0 ),
m_routingWidget( 0 ),
m_workOfflineAct( 0 ),
m_kineticScrollingAction( 0 ),
m_showLegendAct( 0 )
{
#ifdef Q_WS_MAEMO_5
setAttribute( Qt::WA_Maemo5StackedWindow );
#endif // Q_WS_MAEMO_5
setUpdatesEnabled( false );
m_legendBrowser->setMarbleModel( m_marbleWidget->model() );
connect( m_legendBrowser, SIGNAL(toggledShowProperty(QString,bool)),
m_marbleWidget, SLOT(setPropertyValue(QString,bool)), Qt::QueuedConnection );
// prevent triggering of network requests under Maemo, presumably due to qrc: URLs
m_networkAccessManager.setNetworkAccessible( QNetworkAccessManager::NotAccessible );
m_legendBrowser->page()->setNetworkAccessManager( &m_networkAccessManager );
QString selectedPath = marbleDataPath.isEmpty() ? readMarbleDataPath() : marbleDataPath;
if ( !selectedPath.isEmpty() )
MarbleDirs::setMarbleDataPath( selectedPath );
QSplitter *splitter = new QSplitter( this );
splitter->setOrientation( Qt::Horizontal );
splitter->addWidget( m_legendBrowser );
splitter->setStretchFactor( 0, 0 );
splitter->addWidget( m_marbleWidget );
splitter->setStretchFactor( 1, 1 );
splitter->setSizes( QList<int>() << 180 << width() - 180 );
setWindowTitle( tr( "Marble - Virtual Globe" ) );
setWindowIcon( QIcon( ":/icons/marble.png" ) );
setCentralWidget( splitter );
m_workOfflineAct = menuBar()->addAction( tr( "Work Off&line" ) );
m_workOfflineAct->setIcon( QIcon( ":/icons/user-offline.png" ) );
m_workOfflineAct->setCheckable( true );
m_workOfflineAct->setChecked( m_marbleWidget->model()->workOffline() );
connect( m_workOfflineAct, SIGNAL(triggered(bool)), this, SLOT(setWorkOffline(bool)) );
m_kineticScrollingAction = menuBar()->addAction( QApplication::translate("MarbleNavigationSettingsWidget", "&Inertial Globe Rotation", 0, QApplication::UnicodeUTF8) );
m_kineticScrollingAction->setCheckable( true );
connect( m_kineticScrollingAction, SIGNAL(triggered(bool)), this, SLOT(setKineticScrollingEnabled(bool)) );
/** @todo: Full screen cannot be left on Maemo currently (shortcuts not working) */
//menuBar()->addAction( m_fullScreenAct );
QAction *const downloadRegionAction = menuBar()->addAction( tr( "Download &Region..." ) );
downloadRegionAction->setStatusTip( tr( "Download a map region in different zoom levels for offline usage" ) );
connect( downloadRegionAction, SIGNAL(triggered()), SLOT(showDownloadRegionDialog()) );
QAction *const showMapViewDialogAction = menuBar()->addAction( tr( "Map View" ) );
connect( showMapViewDialogAction, SIGNAL(triggered(bool)), this, SLOT(showMapViewDialog()) );
m_showLegendAct = menuBar()->addAction( tr( "Legend" ) );
m_showLegendAct->setCheckable( true );
connect( m_showLegendAct, SIGNAL(toggled(bool)), this, SLOT(setLegendShown(bool)) );
QAction *const m_toggleRoutingTabAction = menuBar()->addAction( tr( "Routing" ) );
connect( m_toggleRoutingTabAction, SIGNAL(triggered(bool)), this, SLOT(showRoutingDialog()) );
QAction *const m_showTrackingDialogAction = menuBar()->addAction( tr( "Tracking" ) );
connect( m_showTrackingDialogAction, SIGNAL(triggered()), this, SLOT(showTrackingDialog()) );
QAction *goToAction = menuBar()->addAction( tr( "&Go To...") );
connect( goToAction, SIGNAL(triggered()), this, SLOT(showGoToDialog()) );
QAction *const manageBookmarksAct = menuBar()->addAction( tr( "&Manage Bookmarks" ) );
manageBookmarksAct->setIcon( QIcon( ":/icons/bookmarks-organize.png" ) );
manageBookmarksAct->setStatusTip( tr( "Manage Bookmarks" ) );
connect( manageBookmarksAct, SIGNAL(triggered()), this, SLOT(showBookmarkManagerDialog()) );
QAction *const aboutMarbleAct = menuBar()->addAction( tr( "&About Marble Virtual Globe" ) );
aboutMarbleAct->setIcon( QIcon( ":/icons/marble.png" ) );
aboutMarbleAct->setStatusTip( tr( "Show the application's About Box" ) );
connect( aboutMarbleAct, SIGNAL(triggered()), this, SLOT(showAboutMarbleDialog()) );
// setup zoom buttons
#ifdef Q_WS_MAEMO_5
if ( winId() ) {
Atom atom = XInternAtom( QX11Info::display(), "_HILDON_ZOOM_KEY_ATOM", False );
if ( atom ) {
unsigned long val = 1;
XChangeProperty ( QX11Info::display(), winId(), atom, XA_INTEGER, 32,
PropModeReplace, reinterpret_cast<unsigned char *>( &val ), 1 );
QAction* zoomIn = new QAction( tr( "Zoom &In" ), this );
zoomIn->setShortcut( Qt::Key_F7 );
connect( zoomIn, SIGNAL(triggered()), m_marbleWidget, SLOT(zoomIn()) );
addAction( zoomIn );
QAction* zoomOut = new QAction( tr( "Zoom &Out" ), this );
zoomOut->setShortcut( Qt::Key_F8 );
connect( zoomOut, SIGNAL(triggered()), m_marbleWidget, SLOT(zoomOut()) );
addAction( zoomOut );
}
}
#endif // Q_WS_MAEMO_5
connect( &m_mapThemeManager, SIGNAL(themesChanged()), this, SLOT(fallBackToDefaultTheme()) );
setUpdatesEnabled( true );
QMetaObject::invokeMethod( this,
"initObject", Qt::QueuedConnection,
Q_ARG( QVariantMap, cmdLineSettings ) );
}
