int main(int argc, char *argv[])
{
QApplication::setGraphicsSystem("raster");
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.resize(500, 300);
mainWindow.setWindowTitle("PS Move API Labs - Sensor Filter");
QWidget centralWidget;
QBoxLayout layout(QBoxLayout::LeftToRight);
centralWidget.setLayout(&layout);
QTimer timer;
MoveGraph moveGraph;
layout.addWidget(&moveGraph);
mainWindow.setCentralWidget(¢ralWidget);
QObject::connect(&timer, SIGNAL(timeout()),
&moveGraph, SLOT(readSensors()));
timer.start(1);
mainWindow.show();
return app.exec();
}
void tst_QToolBar::accel()
{
#ifdef Q_WS_MAC
extern void qt_set_sequence_auto_mnemonic(bool b);
qt_set_sequence_auto_mnemonic(true);
#endif
QMainWindow mw;
QToolBar *toolBar = mw.addToolBar("test");
QAction *action = toolBar->addAction("&test");
action->setIconText(action->text()); // we really want that mnemonic in the button!
QSignalSpy spy(action, SIGNAL(triggered(bool)));
mw.show();
QApplication::setActiveWindow(&mw);
QTest::qWait(100);
QTRY_COMPARE(QApplication::activeWindow(), static_cast<QWidget *>(&mw));
QTest::keyClick(&mw, Qt::Key_T, Qt::AltModifier);
QTest::qWait(300);
QTRY_COMPARE(spy.count(), 1);
#ifdef Q_WS_MAC
qt_set_sequence_auto_mnemonic(false);
#endif
}
void tst_QToolBar::toggleViewAction()
{
{
QToolBar tb;
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
{
QMainWindow mw;
QToolBar tb(&mw);
mw.addToolBar(&tb);
mw.show();
QAction *toggleViewAction = tb.toggleViewAction();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
toggleViewAction->trigger();
QVERIFY(!tb.isHidden());
toggleViewAction->trigger();
QVERIFY(tb.isHidden());
}
}
/** Main application
*
* @param argc :: ignored
* @param argv :: ignored
* @return return code
*/
int main( int argc, char ** argv )
{
double min=0;
double max=100;
QApplication app(argc, argv);
app.setOrganizationName("MantidProject");
app.setApplicationName("Color Bar Widget Example");
QMainWindow * mainWin = new QMainWindow();
QFrame * frame = new QFrame(mainWin);
mainWin->setCentralWidget(frame);
QLayout * layout = new QVBoxLayout(frame);
frame->setLayout(layout);
ColorBarWidget * widget = new ColorBarWidget(frame);
widget->setViewRange(min, max);
widget->setLog(false);
layout->addWidget(widget);
mainWin->move(100, 100);
mainWin->resize(40, 500);
mainWin->show();
app.exec();
mainWin->close();
delete mainWin;
return 0;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMainWindow mainWin;
mainWin.setWindowTitle(QObject::tr("Qt SQL Browser"));
Browser browser(&mainWin);
mainWin.setCentralWidget(&browser);
QMenu *fileMenu = mainWin.menuBar()->addMenu(QObject::tr("&File"));
fileMenu->addAction(QObject::tr("Add &Connection..."), &browser, SLOT(addConnection()));
fileMenu->addSeparator();
fileMenu->addAction(QObject::tr("&Quit"), &app, SLOT(quit()));
QMenu *helpMenu = mainWin.menuBar()->addMenu(QObject::tr("&Help"));
helpMenu->addAction(QObject::tr("About"), &browser, SLOT(about()));
helpMenu->addAction(QObject::tr("About Qt"), qApp, SLOT(aboutQt()));
QObject::connect(&browser, SIGNAL(statusMessage(QString)),
mainWin.statusBar(), SLOT(showMessage(QString)));
addConnectionsFromCommandline(app.arguments(), &browser);
mainWin.show();
if (QSqlDatabase::connectionNames().isEmpty())
QMetaObject::invokeMethod(&browser, "addConnection", Qt::QueuedConnection);
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QMainWindow window;
// setup customPlot as central widget of window:
QCustomPlot customPlot;
window.setCentralWidget(&customPlot);
// create plot (from quadratic plot example):
QVector<double> x(101), y(101);
for (int i=0; i<101; ++i)
{
x[i] = i/50.0 - 1;
y[i] = x[i]*x[i];
}
customPlot.addGraph();
customPlot.graph(0)->setData(x, y);
customPlot.xAxis->setLabel(QLatin1String("x"));
customPlot.yAxis->setLabel(QLatin1String("y"));
customPlot.rescaleAxes();
window.setGeometry(100, 100, 500, 400);
window.show();
return a.exec();
}
int main(int argc, char** argv)
{
cmnLogger::SetMask(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskFunction(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskDefaultLog(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskClassMatching("mts", CMN_LOG_ALLOW_ALL);
cmnLogger::AddChannel(std::cerr, CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
mtsComponentManager * manager = mtsComponentManager::GetInstance();
mtsIntuitiveDaVinci * daVinci = new mtsIntuitiveDaVinci("daVinci", 50.0 * cmn_ms);
daVinci->Configure("");
manager->AddComponent(daVinci);
QApplication app(argc, argv);
mtsQtWidgetComponent * componentWidget = new mtsQtWidgetComponent("QtWidgetComponent");
componentWidget->CreateWidgetsForComponent(*daVinci);
QMainWindow win;
win.setCentralWidget(componentWidget);
win.show();
manager->CreateAll();
manager->WaitForStateAll(mtsComponentState::READY, 5.0 * cmn_s);
manager->StartAll();
manager->WaitForStateAll(mtsComponentState::ACTIVE, 5.0 * cmn_s);
app.exec();
return 0;
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
// Load the Periodic Table translations
QPointer <QTranslator> ptTranslator = QPeriodicTable::createTranslator();
if (ptTranslator)
qApp->installTranslator(ptTranslator);
// Construct Periodic Table
PeriodicTableView* periodicTable = new PeriodicTableView;
periodicTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
QMainWindow *window = new QMainWindow();
window->setWindowTitle("Periodic System of D.I.Mendeleyev");
QWidget *widget = new QWidget;
QHBoxLayout *layout = new QHBoxLayout(widget);
widget->setLayout(layout);
QPlainTextEdit *elementInfo = new QPlainTextEdit;
elementInfo->setReadOnly(true);
elementInfo->setPlainText("Click on element to get the information about it");
elementInfo->setMaximumHeight(periodicTable->height());
elementInfo->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
layout->addWidget(periodicTable);
layout->addWidget(elementInfo);
window->setCentralWidget(widget);
PeriodicTableWatcher *watcher = new PeriodicTableWatcher(periodicTable, elementInfo);
window->show();
app.exec();
delete periodicTable;
delete elementInfo;
delete window;
return 0;
}
int main( int argc, char **argv )
{
QApplication app( argc, argv );
QMainWindow mw;
app.setMainWidget( &mw );
QPopupMenu menu2;
menu2.insertItem( "Test 2" );
TrayIcon tray2( QPixmap( (const char**)minimize_xpm ), "Minimize MainWindow", &menu2 );
QObject::connect(&tray2,SIGNAL(clicked(const QPoint&)),&mw,SLOT(showMinimized()));
QPopupMenu menu;
menu.insertItem( "Test 1" );
menu.insertSeparator();
menu.insertItem( "&Quit", &app, SLOT(quit()) );
TrayIcon tray( QPixmap( (const char**)normalize_xpm ), "Show MainWindow", &menu );
QObject::connect(&tray,SIGNAL(clicked(const QPoint&)),&mw,SLOT(showNormal()));
TrayIcon tray3( QPixmap( (const char**)maximize_xpm ), "Maximize MainWindow" );
QObject::connect(&tray3,SIGNAL(clicked(const QPoint&)),&mw,SLOT(showMaximized()));
mw.show();
tray.show();
tray2.show();
tray3.show();
return app.exec();
}
int main( int argc, char *argv[] )
{
QApplication a( argc, argv );
QMainWindow mainWindow;
HGRSVM svm = HGRSVM();
svm.train( 100 );
QStackedWidget *stackedWidget = new QStackedWidget;
MyMainWindow *myMainWindow = new MyMainWindow( stackedWidget );
stackedWidget->addWidget( myMainWindow );
stackedWidget->setCurrentWidget( myMainWindow );
mainWindow.setCentralWidget(stackedWidget);
mainWindow.setWindowTitle( "Hand gesture recognition for ArDrone" );
mainWindow.resize(950, 500);
mainWindow.show();
thread th1( runArdrone );
int status = a.exec();
order = 1;
th1.join();
return status;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
//declare and initialize the stack that will hold the windows
CUNavigationStack *stack = new CUNavigationStack();
//declare the navigation element that will manage the control flow
CUNavigationProvisioning *navigation = new CUNavigationProvisioning(stack);
LoginForm *initialPage = new LoginForm(navigation);
stack->addWidget(initialPage);
stack->setCurrentWidget(initialPage);
QMainWindow mainWindow;
mainWindow.setWindowTitle(QString("CUCare"));
mainWindow.setCentralWidget(stack);
QRect geo = mainWindow.geometry();
QPoint center = QApplication::desktop()->availableGeometry().center();
center.setX(center.x() - 100);
center.setY(center.y() - 100);
geo.moveCenter(center);
mainWindow.setGeometry(geo);
mainWindow.show();
return app.exec();
}
void tst_QMenu::statusTip()
{
//check that the statustip of actions inserted into the menu are displayed
QMainWindow w;
connect(w.statusBar(), SIGNAL(messageChanged(QString)), SLOT(onStatusMessageChanged(QString)));; //creates the status bar
QToolBar tb;
QAction a("main action", &tb);
a.setStatusTip("main action");
QMenu m(&tb);
QAction subact("sub action", &m);
subact.setStatusTip("sub action");
m.addAction(&subact);
a.setMenu(&m);
tb.addAction(&a);
w.addToolBar(&tb);
w.show();
QVERIFY(QTest::qWaitForWindowExposed(&w));
QRect rect1 = tb.actionGeometry(&a);
QToolButton *btn = qobject_cast<QToolButton*>(tb.childAt(rect1.center()));
QVERIFY(btn != NULL);
//because showMenu calls QMenu::exec, we need to use a singleshot
//to continue the test
QTimer::singleShot(200,this, SLOT(onStatusTipTimer()));
btn->showMenu();
QVERIFY(statustip.isEmpty());
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMainWindow *window = new QMainWindow();
window->setWindowTitle(QString::fromUtf8("QLCDnumber Show Milliseconds Time"));
window->resize(800, 250);
QWidget* centralWidget = new QWidget();
QVBoxLayout* verticalLayout = new QVBoxLayout();
centralWidget->setLayout(verticalLayout);
QLCDNumber *number = new QLCDNumber();
verticalLayout->addWidget(number);
number->setFixedSize(-800, 245);
number->setDigitCount(12);
number->display(QTime::currentTime().toString(QString("hh:mm:ss.zzz")));
window->setCentralWidget(centralWidget);
window->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
new Kernel; // will be deleted by the QQmlEngine
qmlRegisterSingletonType<Kernel>("Lemonade", 1, 0, "Kernel",
kernelInstanceProvider);
QQmlEngine engine;
auto window_color = app.palette().color(QPalette::Window);
QMainWindow window;
window.setWindowTitle(window.tr("Lemonade"));
window.setMenuBar(initMenuBar());
auto central = new QWidget;
auto layout = new QHBoxLayout;
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
auto tool_button_bar = new QQuickWidget(&engine, central);
tool_button_bar->setClearColor(window_color);
tool_button_bar->setSource(
QUrl(QLatin1String("qrc:/content/ToolButtonBar.qml")));
layout->addWidget(tool_button_bar);
auto hsplitter = new QSplitter(Qt::Horizontal);
hsplitter->setChildrenCollapsible(false);
hsplitter->addWidget(initCanvasView());
layout->addWidget(hsplitter);
auto vsplitter = new QSplitter(Qt::Vertical);
vsplitter->addWidget(initNavigatorPanel());
vsplitter->addWidget(initLayerTreePanel());
hsplitter->addWidget(vsplitter);
central->setLayout(layout);
window.setCentralWidget(central);
window.resize(800, 600);
window.show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMainWindow mw;
#ifndef Q_WS_MAC
app.setWindowIcon(QIcon(QLatin1String(":/trolltech/qdbusviewer/images/qdbusviewer.png")));
#else
mw.setWindowTitle(qApp->translate("QtDBusViewer", "Qt D-Bus Viewer"));
#endif
QTabWidget *mainWidget = new QTabWidget;
mw.setCentralWidget(mainWidget);
QDBusViewer *sessionBusViewer = new QDBusViewer(QDBusConnection::sessionBus());
QDBusViewer *systemBusViewer = new QDBusViewer(QDBusConnection::systemBus());
mainWidget->addTab(sessionBusViewer, QObject::tr("Session Bus"));
mainWidget->addTab(systemBusViewer, QObject::tr("System Bus"));
QMenu *fileMenu = mw.menuBar()->addMenu(QObject::tr("&File"));
QAction *quitAction = fileMenu->addAction(QObject::tr("&Quit"), &mw, SLOT(close()));
Q_UNUSED(quitAction);
QMenu *helpMenu = mw.menuBar()->addMenu(QObject::tr("&Help"));
QAction *aboutAction = helpMenu->addAction(QObject::tr("&About"));
aboutAction->setMenuRole(QAction::AboutRole);
QObject::connect(aboutAction, SIGNAL(triggered()), sessionBusViewer, SLOT(about()));
QAction *aboutQtAction = helpMenu->addAction(QObject::tr("About &Qt"));
aboutQtAction->setMenuRole(QAction::AboutQtRole);
QObject::connect(aboutQtAction, SIGNAL(triggered()), &app, SLOT(aboutQt()));
mw.show();
return app.exec();
}
/*
* Steps to reproduce issue:
* - start application
* - click "add horizontal"
* - click "add horizontal"
* - click "add vertical"
* - click "add horizontal"
* ... the layout will look like this:
* 11 22 44
* 33333 44
* - click "save state"
* - close application
*
* - start application
* - click "add vertical" 5 times
* ... the layout will look like this:
* 11
* 22
* 33
* 44
* 55
* - click "restore state"
* ... the layout will look like this:
* 11 22 44 55
* 33333 44 55
*
* BUT since 5 was not known before I would expect its orientation
* (vertical) to not change by the restoreState invocation
* ... the layout should look like this:
* 11 22 44
* 33333 44
* 55555555
*/
int main(int argc, char** argv)
{
QApplication* app = new QApplication(argc, argv);
QSettings* settings = new QSettings(QSettings::IniFormat, QSettings::UserScope, "qt_restore_state_orientation", "qt_restore_state_orientation");
QMainWindow* mw = new QMainWindow();
mw->resize(800, 600);
mw->setCentralWidget(new QLabel("foo"));
QToolBar* tb = new QToolBar();
tb->setObjectName("toolbar");
mw->addToolBar(tb);
QAction* aha = new AddHorizontalAction("add horizontal", tb);
tb->addAction(aha);
QAction* ava = new AddVerticalAction("add vertical", tb);
tb->addAction(ava);
QAction* ss = new SaveStateAction("save state", tb, settings);
tb->addAction(ss);
QAction* rs = new RestoreStateAction("restore state", tb, settings);
tb->addAction(rs);
mw->show();
app->exec();
}
void tiBackupEdit::on_btnEditScriptAfterBackup_clicked()
{
QMainWindow *winScriptEditor = new QMainWindow(this, Qt::Dialog);
winScriptEditor->setWindowModality(Qt::WindowModal);
winScriptEditor->setAttribute(Qt::WA_DeleteOnClose, true);
QString path = ui->leScriptPathAfterBackup->text();
tiConfMain main_settings;
if(path.isEmpty())
{
QDateTime currentDate = QDateTime::currentDateTime();
path = QString("%1/%2_afterbackup.sh").arg(main_settings.getValue("paths/scripts").toString(), currentDate.toString("yyyyMMddhhmmss"));
//ui->leScriptPathAfterBackup->setText(path);
}
//tiPreferences *f = new tiPreferences(winScriptEditor);
scriptEditor *e = new scriptEditor(winScriptEditor);
e->loadScript(path);
QObject::connect(e, SIGNAL(scriptSaved(QString)), this, SLOT(onScriptAfterChanged(QString)));
winScriptEditor->setCentralWidget(e);
winScriptEditor->setMinimumSize(QSize(e->width(),e->height()));
//winScriptEditor->setMaximumSize(QSize(e->width(),e->height()));
winScriptEditor->setWindowTitle(windowTitle() + QObject::trUtf8(" - Script Editor"));
winScriptEditor->show();
qDebug() << "tiBackupAdd::on_btnEditScriptAfterBackup_clicked() -> test test";
}
/**
* Construct an SpectrumView to display data from the specified data source.
* The specified SpectrumDataSource must be constructed elsewhere and passed
* into this SpectrumView constructor. Most other components of the SpectrumView
* are managed by this class. That is the graphs, image display and other
* parts of the SpectrumView are constructed here and are deleted when the
* SpectrumView destructor is called.
*
* @param dataSource The source of the data that will be displayed.
* @param peakMin The min peak value
* @param peakMax The max peak value
* @param backMin The min background value
* @param backMax The max background value
* @param tofMin The min time of flight value
* @param tofMax The max time of flight value
*/
RefImageView::RefImageView( SpectrumView::SpectrumDataSource_sptr dataSource,
int peakMin, int peakMax,
int backMin, int backMax,
int tofMin, int tofMax)
: m_ui(new Ui::RefImageViewer())
{
QMainWindow* window = this;
m_ui->setupUi( window );
window->resize( 1050, 800 );
window->show();
window->setAttribute(Qt::WA_DeleteOnClose); // We just need to close the
// window to trigger the
// destructor and clean up
window->setWindowTitle(QString::fromUtf8("Reflector Detector Viewer"));
m_sliderHandler = new RefSliderHandler( m_ui );
m_rangeHandler = new RefRangeHandler( m_ui );
// Create the handler for comminicating peak/background/tof values to/from the ui
// This ends up being owned by the RefImagePlotItem instance
RefLimitsHandler* limits_handler = new RefLimitsHandler(m_ui);
m_hGraph = new SpectrumView::GraphDisplay( m_ui->h_graphPlot, NULL, false );
m_vGraph = new SpectrumView::GraphDisplay( m_ui->v_graphPlot, NULL, true );
m_imageDisplay = new RefImageDisplay( m_ui->imagePlot,
m_sliderHandler,
m_rangeHandler,
limits_handler,
m_hGraph, m_vGraph,
m_ui->image_table);
RefIVConnections * iv_connections = new RefIVConnections( m_ui, this,
m_imageDisplay,
m_hGraph, m_vGraph );
// Set validators on the QLineEdits to restrict them to integers
m_ui->lineEdit_peakLeft->setValidator(new QIntValidator(this));
m_ui->lineEdit_peakRight->setValidator(new QIntValidator(this));
m_ui->lineEdit_backLeft->setValidator(new QIntValidator(this));
m_ui->lineEdit_backRight->setValidator(new QIntValidator(this));
m_ui->lineEdit_TOFmin->setValidator(new QIntValidator(this));
m_ui->lineEdit_TOFmax->setValidator(new QIntValidator(this));
//populate widgets with peak, back and tof values
limits_handler->setPeakLeft(peakMin);
limits_handler->setPeakRight(peakMax);
limits_handler->setBackLeft(backMin);
limits_handler->setBackRight(backMax);
limits_handler->setTOFmin(tofMin);
limits_handler->setTOFmax(tofMax);
m_ivConnections = iv_connections;
m_imageDisplay->updateImage();
iv_connections->peakBackTofRangeUpdate();
m_imageDisplay->setDataSource( dataSource );
}
/////////////////////MAIN////////////////////////
int main(int argc, char** argv) {
load_geom(argc, argv);
QApplication app(argc, argv);
glutInit(&argc, argv);
if ( !QGLFormat::hasOpenGL() ) {
qWarning( "This system has no OpenGL support. Exiting." );
return EXIT_FAILURE;
}
QMainWindow main;
SketchSample* sketch = new SketchSample(&m_mesh, &ppal_data);
Observer* obs = new Observer(sketch);
GLWidget w1(&main, "OpenGL", obs);
main.setCentralWidget( &w1 );
main.resize( 500, 500 );
app.setMainWidget(&main);
main.show();
return app.exec();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.setCentralWidget(new StaticWidget());
mainWindow.setStatusBar(new QStatusBar());
QDockWidget *dockWidget = new QDockWidget();
dockWidget->setWidget(new StaticWidget());
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
QToolBar *toolBar = new QToolBar();
toolBar->addWidget(new StaticWidget())->setVisible(true);;
toolBar->addWidget(new QSpinBox())->setVisible(true);;
mainWindow.addToolBar(toolBar);
mainWindow.resize(600, 400);
mainWindow.show();
return app.exec();
}
int main(int argc, char** argv)
{
// QApplication::setAttribute(Qt::AA_DisableHighDpiScaling);
SetProcessDPIAware();
QApplication qapp(argc, argv);
int x = QApplication::desktop()->physicalDpiX();
int y = QApplication::desktop()->physicalDpiY();
double scaleX = 284.0/double(x);
double scaleY = 285.0/double(y);
std::cout << x << " " << y << std::endl;
std::cout << QApplication::desktop()->logicalDpiX() << " " << QApplication::desktop()->logicalDpiY() << std::endl;
QMainWindow window;
QtOSGWidget* widget = new QtOSGWidget(1, 1, &window);
window.setCentralWidget(widget);
window.show();
std::cout << scaleX << " " << scaleY << std::endl;
// std::cout << pr << " " << ps << std::endl;
return qapp.exec();
}
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.setGeometry(0,0, 300, 300);
mainWindow.show();
// cerr << "Wainting some time until props are populated (later do this on event...)" << endl;
// sleep(3);
// cerr << "Ok, waited enough! Moving!" << endl;
//bool res = focusClient->move(5, 123);
//cerr << "res: " << res << endl;
// Now do an exposure for 3 seconds...
//focusClient->takeExposure();
FocuserCntlPanel focuserCntlPanel;
focuserCntlPanel.setFocusClient(& focusClient);
fitWindow(mainWindow, & focuserCntlPanel); // Add the focuser panel
app.exec();
return 0;
}
int main(int argc, char **argv)
{
BrowserApplication application(argc, argv);
QCoreApplication::setApplicationName(QLatin1String("urllineeditexample"));
QMainWindow w;
QWidget *window = new QWidget;
QComboBox *comboBox = new QComboBox(window);
comboBox->setEditable(true);
QLineEdit *lineEdit = new QLineEdit(window);
LocationBar *s1 = new LocationBar(window);
LocationBar *s2 = new LocationBar(window);
WebView *view = new WebView(window);
view->setUrl(QUrl("http://www.google.com"));
s2->setWebView(view);
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(comboBox);
layout->addWidget(lineEdit);
layout->addWidget(s1);
layout->addWidget(s2);
layout->addWidget(view);
window->setLayout(layout);
w.show();
w.setCentralWidget(window);
QToolBar *bar = w.addToolBar("foo");
QSplitter *splitter = new QSplitter(window);
splitter->addWidget(new LocationBar);
splitter->addWidget(new QLineEdit);
bar->addWidget(splitter);
return application.exec();
}
int main (int argc, char ** argv)
{
QApplication app(argc,argv);;
QMainWindow *mainW = new QMainWindow;
CodeEditor *plainTextEdit = new CodeEditor(mainW);
mainW->setCentralWidget(plainTextEdit);
QStatusBar *sbar = mainW->statusBar();
if(argc >1)
{
QFile file(argv[1]);
plainTextEdit->setFile(&file);
file.close();
}
mainW->show();
// sbar->showMessage( "Ready");
return app.exec();
}
void tst_QToolBar::visibilityChanged()
{
QMainWindow mw;
QToolBar tb;
QSignalSpy spy(&tb, SIGNAL(visibilityChanged(bool)));
mw.addToolBar(&tb);
mw.show();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
spy.clear();
tb.hide();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), false);
spy.clear();
tb.hide();
QCOMPARE(spy.count(), 0);
tb.show();
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
spy.clear();
tb.show();
QCOMPARE(spy.count(), 0);
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.show();
/*
//QTextEdit text;
//text.show();
//QMainWindow mainWindow;;
//QThreadPool *threadPool = QThreadPool::globalInstance();
//SimulationWrapper method1(new SolverRemoveIfSwappingMakesBetter(jobs));
//SimulationWrapper method2(new SolverRemoveActualIfWorseThan(jobs));
//SimulationWrapper method3(new SolverLBcriterion(jobs));
list<pair<int,int> > exchange;
//locker.
GraphWidget *widget = new GraphWidget(exchange);
mainWindow.setCentralWidget(widget);
list<Zad> jobs=readFromFile("5.txt");
SimulationWrapper method0(new Solver(jobs), widget);
//SimulationWrapper method0(0, widget);
method0.start();
//threadPool->start(&wt);
//threadPool->start(&method0);
//threadPool->start(&method1);
//threadPool->start(&method2);
//threadPool->start(&method3);*/
return app.exec();
}
void tst_QToolBar::task197996_visibility()
{
QMainWindow mw;
QToolBar *toolBar = new QToolBar(&mw);
mw.addToolBar(toolBar);
toolBar->addAction(new QAction("Foo", &mw));
QAction *pAction = new QAction("Test", &mw);
toolBar->addAction(pAction);
pAction->setVisible(false);
toolBar->setVisible(false);
toolBar->setVisible(true);
pAction->setVisible(true);
mw.show();
QVERIFY(toolBar->widgetForAction(pAction)->isVisible());
toolBar->setVisible(false);
pAction->setVisible(false);
toolBar->setVisible(true);
pAction->setVisible(true);
QTest::qWait(100);
QVERIFY(toolBar->widgetForAction(pAction)->isVisible());
}
int main(int argc, char **argv)
{
icons << "konqueror";
icons << "okular";
icons << "plasma";
icons << "system-file-manager";
QApplication app(argc, argv);
QMainWindow *mainWindow = new QMainWindow();
mainWindow->setMinimumSize(640, 480);
KCategorizedView *listView = new KCategorizedView();
listView->setCategoryDrawer(new KCategoryDrawer());
listView->setViewMode(QListView::IconMode);
MyModel *model = new MyModel();
model->insertRows(0, 100);
for (int i = 0; i < 100; ++i)
{
model->setData(model->index(i, 0), QString::number(i), Qt::DisplayRole);
}
KCategorizedSortFilterProxyModel *proxyModel = new KCategorizedSortFilterProxyModel();
proxyModel->setCategorizedModel(true);
proxyModel->setSourceModel(model);
listView->setModel(proxyModel);
mainWindow->setCentralWidget(listView);
mainWindow->show();
return app.exec();
}
int main(int argc,char *argv[])
{
if (argc < 1)
return 1;
const QString skinFile = QString::fromUtf8(argv[1]);
QApplication app(argc,argv);
QMainWindow mw;
DeviceSkinParameters params;
QString errorMessage;
if (!params.read(skinFile, DeviceSkinParameters::ReadAll, &errorMessage)) {
qWarning() << errorMessage;
return 1;
}
DeviceSkin ds(params, &mw);
// View Dialog
QDialog *dialog = new QDialog();
QHBoxLayout *dialogLayout = new QHBoxLayout();
dialog->setLayout(dialogLayout);
QDialogButtonBox *dialogButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
QObject::connect(dialogButtonBox, SIGNAL(rejected()), dialog, SLOT(reject()));
QObject::connect(dialogButtonBox, SIGNAL(accepted()), dialog, SLOT(accept()));
dialogLayout->addWidget(dialogButtonBox);
dialog->setFixedSize(params.screenSize());
dialog->setParent(&ds, Qt::SubWindow);
dialog->setAutoFillBackground(true);
ds.setView(dialog);
QObject::connect(&ds, SIGNAL(popupMenu()), &mw, SLOT(close()));
QObject::connect(&ds, SIGNAL(skinKeyPressEvent(int,QString,bool)), &mw, SLOT(close()));
mw.show();
return app.exec();
}
/******************************************************************************
* Is called when the user presses the "Open Inspector" button.
******************************************************************************/
void DislocationNetworkEditor::onOpenInspector()
{
DislocationNetwork* dislocationsObj = static_object_cast<DislocationNetwork>(editObject());
if(!dislocationsObj) return;
QMainWindow* inspectorWindow = new QMainWindow(container()->window(), (Qt::WindowFlags)(Qt::Tool | Qt::CustomizeWindowHint | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint));
inspectorWindow->setWindowTitle(tr("Dislocation Inspector"));
PropertiesPanel* propertiesPanel = new PropertiesPanel(inspectorWindow);
propertiesPanel->hide();
QWidget* mainPanel = new QWidget(inspectorWindow);
QVBoxLayout* mainPanelLayout = new QVBoxLayout(mainPanel);
mainPanelLayout->setStretch(0,1);
mainPanelLayout->setContentsMargins(0,0,0,0);
inspectorWindow->setCentralWidget(mainPanel);
ObjectNode* node = dynamic_object_cast<ObjectNode>(dataset()->selection()->front());
DislocationInspector* inspector = new DislocationInspector(node);
connect(inspector, &QObject::destroyed, inspectorWindow, &QMainWindow::close);
inspector->setParent(propertiesPanel);
inspector->initialize(propertiesPanel, mainWindow(), RolloutInsertionParameters().insertInto(mainPanel));
inspector->setEditObject(dislocationsObj);
inspectorWindow->setAttribute(Qt::WA_DeleteOnClose);
inspectorWindow->resize(1000, 350);
inspectorWindow->show();
}
