void tst_QDockWidget::dockLocationChanged()
{
qRegisterMetaType<Qt::DockWidgetArea>("Qt::DockWidgetArea");
QMainWindow mw;
QDockWidget dw;
dw.setObjectName("dock1");
QSignalSpy spy(&dw, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)));
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::LeftDockWidgetArea);
spy.clear();
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::LeftDockWidgetArea);
spy.clear();
mw.addDockWidget(Qt::RightDockWidgetArea, &dw);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::RightDockWidgetArea);
spy.clear();
mw.removeDockWidget(&dw);
QCOMPARE(spy.count(), 0);
QDockWidget dw2;
dw2.setObjectName("dock2");
mw.addDockWidget(Qt::TopDockWidgetArea, &dw2);
mw.tabifyDockWidget(&dw2, &dw);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::TopDockWidgetArea);
spy.clear();
mw.splitDockWidget(&dw2, &dw, Qt::Horizontal);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::TopDockWidgetArea);
spy.clear();
dw.setFloating(true);
QTest::qWait(100);
dw.setFloating(false);
QTest::qWait(100);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::TopDockWidgetArea);
spy.clear();
QByteArray ba = mw.saveState();
mw.restoreState(ba);
QCOMPARE(spy.count(), 1);
QCOMPARE(qvariant_cast<Qt::DockWidgetArea>(spy.at(0).at(0)),
Qt::TopDockWidgetArea);
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
if (app.arguments().count() < 2) {
usage();
return 1;
}
///TODO: multi-part callgrind files
QFile file(app.arguments().at(1));
if (!file.open(QIODevice::ReadOnly)) {
qerr << "could not open callgrind file for reading:" << file.fileName() << file.errorString();
return 3;
}
Parser p;
p.parse(&file);
ParseData *data = p.takeData();
if (!data) {
qerr << "invalid callgrind file:" << file.fileName() << endl;
return 2;
}
QMainWindow window;
CallgrindWidgetHandler *handler = new CallgrindWidgetHandler(&window);
ModelTestWidget *widget = new ModelTestWidget(handler);
widget->setWindowTitle(file.fileName());
window.setCentralWidget(widget);
QDockWidget *callerDock = new QDockWidget("callers", &window);
callerDock->setWidget(handler->callersView());
window.addDockWidget(Qt::RightDockWidgetArea, callerDock);
QDockWidget *calleeDock = new QDockWidget("callees", &window);
calleeDock->setWidget(handler->calleesView());
window.addDockWidget(Qt::RightDockWidgetArea, calleeDock);
QDockWidget *widgetDock = new QDockWidget("vizualisation", &window);
widgetDock->setWidget(handler->visualisation());
window.addDockWidget(Qt::BottomDockWidgetArea, widgetDock);
handler->setParseData(data);
window.show();
return app.exec();
}
bool ImagePreviewNode::initialise( void )
{
if( !fugio::NodeControlBase::initialise() )
{
return( false );
}
QMainWindow *MainWindow = mNode->context()->global()->mainWindow();
if( MainWindow != 0 )
{
if( ( mDockWidget = new QDockWidget( QString( "Image Preview: %1" ).arg( mNode->name() ), MainWindow ) ) == 0 )
{
return( false );
}
mDockWidget->setObjectName( mNode->name() );
if( ( mGUI = new ImagePreview( mDockWidget ) ) == 0 )
{
return( false );
}
mDockWidget->setWidget( mGUI );
MainWindow->addDockWidget( mDockArea, mDockWidget );
connect( mNode->context()->qobject(), SIGNAL(frameStart()), this, SLOT(onContextFrame()) );
}
return( true );
}
QWidget* SpectralLibraryMatchResults::createWidget()
{
mpTabWidget = new QTabWidget(getDockWindow()->getWidget());
mpTabWidget->setTabPosition(QTabWidget::South);
mpTabWidget->setTabShape(QTabWidget::Rounded);
mpTabWidget->setMinimumHeight(100);
// dockwindow should exist so attach to it
DockWindow* pWindow = getDockWindow();
if (pWindow != NULL)
{
pWindow->attach(SIGNAL_NAME(DockWindow, AboutToShowContextMenu),
Slot(this, &SpectralLibraryMatchResults::updateContextMenu));
// Connect to the session explorer now that the window has been created
if (mpExplorer.get() == NULL)
{
Service<SessionExplorer> pExplorer;
mpExplorer.reset(pExplorer.get());
}
// set location of the results window
#pragma message(__FILE__ "(" STRING(__LINE__) ") : warning : Replace this block when public method to locate DockWindow is available. (rforehan)")
QMainWindow* pMainWindow = dynamic_cast<QMainWindow*>(Service<DesktopServices>()->getMainWidget());
if (pMainWindow != NULL)
{
pMainWindow->addDockWidget(Qt::LeftDockWidgetArea, dynamic_cast<QDockWidget*>(pWindow), Qt::Vertical);
}
}
return mpTabWidget;
}
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();
}
void FunctionListArea::generalSetting()
{
QWidget *widget = new QWidget();
QHBoxLayout *layout = new QHBoxLayout();
QLabel *label = new QLabel(tr("函数列表:"), this);
widget->setLayout(layout);
layout->addWidget(label);
layout->addWidget(functionListBox, 1);
setTitleBarWidget(widget);
setWidget(new QWidget());
setFixedHeight(24);
layout->setContentsMargins(5, 4, 5, 0);
connect(functionListBox,
SIGNAL(activated(int)),
this,
SLOT(cursorMove(int))
);
connect(functionListBox,
SIGNAL(updateFunctionList()),
this,
SLOT(createFunctionList())
);
QFont afont(font());
afont.setPointSize(10);
setFont(afont);
setWindowTitle(tr(""));
setAllowedAreas(Qt::TopDockWidgetArea);
setFeatures(QDockWidget::DockWidgetClosable);
//QDockWidget::DockWidgetVerticalTitleBar);
QMainWindow *main = qobject_cast<QMainWindow *>(parent());
main->addDockWidget(Qt::TopDockWidgetArea, this);
hide();//默认关闭
}
void EdStatsView::SetDefaultValues()
{
QMainWindow* mainWindow = EditorApp::GetMainFrame();
mainWindow->addDockWidget( Qt::BottomDockWidgetArea, this );
this->hide();
}
void tst_QDockWidget::task169808_setFloating()
{
//we try to test if the sizeHint of the dock widget widget is taken into account
class MyWidget : public QWidget
{
public:
QSize sizeHint() const
{
const QRect& deskRect = qApp->desktop()->availableGeometry();
return QSize(qMin(300, deskRect.width() / 2), qMin(300, deskRect.height() / 2));
}
QSize minimumSizeHint() const
{
return QSize(20,20);
}
void paintEvent(QPaintEvent *)
{
QPainter p(this);
p.fillRect(rect(), Qt::red);
}
};
QMainWindow mw;
mw.setCentralWidget(new MyWidget);
QDockWidget *dw = new QDockWidget("my dock");
dw->setWidget(new MyWidget);
mw.addDockWidget(Qt::LeftDockWidgetArea, dw);
dw->setFloating(true);
mw.show();
QVERIFY(QTest::qWaitForWindowExposed(&mw));
QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint());
//and now we try to test if the contents margin is taken into account
dw->widget()->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
dw->setFloating(false);
QVERIFY(QTest::qWaitForWindowExposed(&mw));
qApp->processEvents(); //leave time processing events
const QSize oldSize = dw->size();
const int margin = 20;
dw->setContentsMargins(margin, margin, margin, margin);
QVERIFY(QTest::qWaitForWindowExposed(&mw));
qApp->processEvents(); //leave time processing events
//widget size shouldn't have changed
QCOMPARE(dw->widget()->size(), dw->widget()->sizeHint());
//dockwidget should be bigger
QCOMPARE(dw->size(), oldSize + QSize(margin * 2, margin * 2));
}
int main(int argc, char ** argv)
{
QApplication a(argc, argv);
QMainWindow w;
w.setCentralWidget(new QLineEdit);
w.addDockWidget(Qt::TopDockWidgetArea, new Keyboard("Keyboard", &w));
w.show();
return a.exec();
}
void TestCasePlayerModule::init( const SteerLib::OptionDictionary & options, SteerLib::EngineInterface * engineInfo ) {
_engine = engineInfo;
_testCaseFilename = "";
_aiModuleName = "";
_aiModuleSearchPath = "";
_aiModule = NULL;
_obstacles.clear();
// parse command line options
SteerLib::OptionDictionary::const_iterator optionIter;
for (optionIter = options.begin(); optionIter != options.end(); ++optionIter) {
if ((*optionIter).first == "testcase") {
_testCaseFilename = (*optionIter).second;
}
else if ((*optionIter).first == "ai") {
_aiModuleName = (*optionIter).second;
}
else {
throw Util::GenericException("unrecognized option \"" + Util::toString((*optionIter).first) + "\" given to testCasePlayer module.");
}
}
// load the module if it is not already
if ( !_engine->isModuleLoaded(_aiModuleName) ) {
_engine->loadModule(_aiModuleName,_aiModuleSearchPath,"");
/// @todo add a boolean that flags this module was loaded here, so that we can unload the module after the simulation is done.
}
// get a pointer to the loaded module
_aiModule = _engine->getModule(_aiModuleName);
#ifdef ENABLE_GUI
#ifdef ENABLE_QT
QMainWindow * mainWindow = (QMainWindow*)(_engine->getEngineController()->getQtMainWindow());
if(mainWindow != NULL) {
/// @todo why is this tooltip attribute here, and not in the engine driver?
mainWindow->QWidget::setAttribute(Qt::WA_AlwaysShowToolTips);
_testCasePlayerDockWidget = new QDockWidget("Test Case Player");
_testCasePlayerWidget = new SteerSimQt::TestCasePlayerWidget(this, _engine);
_testCasePlayerDockWidget->setWidget(_testCasePlayerWidget);
mainWindow->addDockWidget(Qt::RightDockWidgetArea, _testCasePlayerDockWidget);
}
else {
_testCasePlayerDockWidget = NULL;
_testCasePlayerWidget = NULL;
}
#endif
#endif
}
void tst_QDockWidget::restoreStateOfFloating()
{
QMainWindow mw;
QDockWidget dock;
dock.setObjectName("dock1");
mw.addDockWidget(Qt::TopDockWidgetArea, &dock);
QVERIFY(!dock.isFloating());
QByteArray ba = mw.saveState();
dock.setFloating(true);
QVERIFY(dock.isFloating());
QVERIFY(mw.restoreState(ba));
QVERIFY(!dock.isFloating());
}
TEST_F(DataMapping_test, ViewAndPlotViewCleanedUp)
{
auto img = vtkSmartPointer<vtkImageData>::New();
img->SetDimensions(4, 6, 1);
img->AllocateScalars(VTK_FLOAT, 1);
auto imageObject = std::make_unique<ImageDataObject>("TestImage", *img);
auto imgPointer = imageObject.get();
env->dataSetHander.takeData(std::move(imageObject));
QPointer<AbstractRenderView> view, plotView;
{
QMainWindow mainWindow;
view = env->mapping.openInRenderView({ imgPointer });
ASSERT_TRUE(view);
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, view->dockWidgetParent());
auto impl3D = dynamic_cast<RendererImplementation3D *>(&view->implementation());
ASSERT_TRUE(impl3D);
auto impl3Dtest = static_cast<TestRendererImplementation3D *>(impl3D); // hacked...
auto strategy = dynamic_cast<RenderViewStrategy2D *>(impl3Dtest->strategyIfEnabled());
ASSERT_TRUE(strategy);
strategy->startProfilePlot();
ASSERT_EQ(2, env->mapping.renderViews().size());
auto first = env->mapping.renderViews()[0];
auto second = env->mapping.renderViews()[1];
plotView = view == first ? second : first;
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, plotView->dockWidgetParent());
qApp->processEvents();
env.reset();
}
ASSERT_FALSE(view);
ASSERT_FALSE(plotView);
}
/**
* returns paintViewPort
**/
nmc::DkPluginViewPort* DkNikonPlugin::getViewPort() {
if (!viewport) {
// >DIR: dummy viewport [4.7.2014 markus]
viewport = new DkNikonViewPort();
}
if (!maidFacade) {
QMainWindow* mainWindow = getMainWindow();
maidFacade = new MaidFacade(mainWindow);
if (maidFacade->init()) {
if (!camControls) {
// get last location
QSettings settings;
int dockLocation = settings.value("camControlsLocation", Qt::RightDockWidgetArea).toInt();
camControls = new DkCamControls(maidFacade, tr("Camera Controls"));
if (mainWindow)
mainWindow->addDockWidget((Qt::DockWidgetArea)dockLocation, camControls);
connect(camControls, SIGNAL(updateImage(QImage)), getViewPort(), SIGNAL(loadImage(QImage)));
connect(camControls, SIGNAL(loadFile(QFileInfo)), getViewPort(), SIGNAL(loadFile(QFileInfo)));
connect(camControls, SIGNAL(closeSignal()), getViewPort(), SIGNAL(closePlugin()));
}
camControls->setVisible(true);
} else {
QMessageBox warningDialog(mainWindow);
warningDialog.setWindowTitle(tr("MAID Library could not be opened"));
warningDialog.setText(tr("The MAID library could not be opened. Camera controls will be disabled."));
warningDialog.setIcon(QMessageBox::Warning);
warningDialog.setStandardButtons(QMessageBox::Ok);
warningDialog.setDefaultButton(QMessageBox::Ok);
warningDialog.show();
warningDialog.exec();
return 0;
}
}
return viewport;
}
void tst_QDockWidget::toggleViewAction()
{
QMainWindow mw;
QDockWidget dw(&mw);
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
mw.show();
QAction *toggleViewAction = dw.toggleViewAction();
QVERIFY(!dw.isHidden());
toggleViewAction->trigger();
QVERIFY(dw.isHidden());
toggleViewAction->trigger();
QVERIFY(!dw.isHidden());
toggleViewAction->trigger();
QVERIFY(dw.isHidden());
}
void tst_QDockWidget::task258459_visibilityChanged()
{
QMainWindow win;
QDockWidget dock1, dock2;
win.addDockWidget(Qt::RightDockWidgetArea, &dock1);
win.tabifyDockWidget(&dock1, &dock2);
QSignalSpy spy1(&dock1, SIGNAL(visibilityChanged(bool)));
QSignalSpy spy2(&dock2, SIGNAL(visibilityChanged(bool)));
win.show();
QTest::qWait(200);
QCOMPARE(spy1.count(), 1);
QCOMPARE(spy1.first().first().toBool(), false); //dock1 is invisible
QCOMPARE(spy2.count(), 1);
QCOMPARE(spy2.first().first().toBool(), true); //dock1 is visible
}
void tst_QDockWidget::task165177_deleteFocusWidget()
{
QMainWindow mw;
QDockWidget *dw = new QDockWidget(&mw);
mw.addDockWidget(Qt::LeftDockWidgetArea, dw);
QLineEdit *ledit = new QLineEdit;
dw->setWidget(ledit);
mw.show();
QVERIFY(QTest::qWaitForWindowExposed(&mw));
qApp->processEvents();
dw->setFloating(true);
delete ledit;
QCOMPARE(mw.focusWidget(), (QWidget *)0);
QCOMPARE(dw->focusWidget(), (QWidget *)0);
}
TEST_F(DataMapping_test, ViewDeletedOnAppShutdown)
{
QPointer<AbstractRenderView> view = env->mapping.createDefaultRenderViewType();
ASSERT_TRUE(view);
{
QMainWindow mainWindow;
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, view->dockWidgetParent());
ASSERT_EQ(view->dockWidgetParent(), view->parent());
ASSERT_EQ(&mainWindow, view->dockWidgetParent()->parent());
env.reset();
ASSERT_FALSE(view);
}
}
TEST_F(DataMapping_test, ViewOwnershipPassedToMainWindow)
{
QPointer<AbstractRenderView> view = env->mapping.createDefaultRenderViewType();
ASSERT_TRUE(view);
QMainWindow mainWindow;
mainWindow.addDockWidget(Qt::LeftDockWidgetArea, view->dockWidgetParent());
ASSERT_EQ(view->dockWidgetParent(), view->parent());
ASSERT_EQ(&mainWindow, view->dockWidgetParent()->parent());
view->close();
ASSERT_TRUE(view);
QCoreApplication::processEvents();
ASSERT_FALSE(view);
}
void tst_QDockWidget::titleBarDoubleClick()
{
QMainWindow win;
QDockWidget dock(&win);
win.show();
dock.setFloating(true);
QEvent e(QEvent::NonClientAreaMouseButtonDblClick);
QApplication::sendEvent(&dock, &e);
QVERIFY(dock.isFloating());
QCOMPARE(win.dockWidgetArea(&dock), Qt::NoDockWidgetArea);
win.addDockWidget(Qt::TopDockWidgetArea, &dock);
dock.setFloating(true);
QApplication::sendEvent(&dock, &e);
QVERIFY(!dock.isFloating());
QCOMPARE(win.dockWidgetArea(&dock), Qt::TopDockWidgetArea);
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QMainWindow v;
Escena *escena = new Escena(&v);
WidgetParametrico *widgetParametrico = new WidgetParametrico(&v);
QObject::connect(widgetParametrico, SIGNAL(aChanged(int)), escena, SLOT(aChanged(int)));
QObject::connect(widgetParametrico, SIGNAL(bChanged(int)), escena, SLOT(bChanged(int)));
QObject::connect(widgetParametrico, SIGNAL(cChanged(int)), escena, SLOT(cChanged(int)));
QObject::connect(widgetParametrico, SIGNAL(npChanged(int)), escena, SLOT(npChanged(int)));
QObject::connect(widgetParametrico, SIGNAL(nqChanged(int)), escena, SLOT(nqChanged(int)));
v.setCentralWidget(escena);
QDockWidget *dock = new QDockWidget(&v);
dock->setWidget(widgetParametrico);
v.addDockWidget(Qt::RightDockWidgetArea, dock);
v.show();
return app.exec();
}
void tst_QDockWidget::taskQTBUG_9758_undockedGeometry()
{
QMainWindow window;
QDockWidget dock1(&window);
QDockWidget dock2(&window);
window.addDockWidget(Qt::RightDockWidgetArea, &dock1);
window.addDockWidget(Qt::RightDockWidgetArea, &dock2);
window.tabifyDockWidget(&dock1, &dock2);
dock1.hide();
dock2.hide();
window.show();
QVERIFY(QTest::qWaitForWindowExposed(&window));
dock1.setFloating(true);
dock1.show();
QVERIFY(QTest::qWaitForWindowExposed(&dock1));
QVERIFY(dock1.x() >= 0);
QVERIFY(dock1.y() >= 0);
}
void TestQgsDockWidget::testToggleUserVisible()
{
QMainWindow *w = new QMainWindow();
QApplication::setActiveWindow( w ); //required for focus events
QgsDockWidget *d1 = new QgsDockWidget( w );
QgsDockWidget *d2 = new QgsDockWidget( w );
w->addDockWidget( Qt::RightDockWidgetArea, d1 );
w->addDockWidget( Qt::RightDockWidgetArea, d2 );
w->tabifyDockWidget( d1, d2 );
w->show();
QVERIFY( d2->isUserVisible() );
QVERIFY( !d1->isUserVisible() );
d1->toggleUserVisible();
QVERIFY( !d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
d2->hide();
d2->toggleUserVisible();
QVERIFY( d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( d1->isVisible() );
d2->hide();
d1->raise(); //shouldn't be necessary outside of tests
QVERIFY( !d2->isUserVisible() );
QVERIFY( !d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
d1->toggleUserVisible();
QVERIFY( !d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( !d1->isVisible() );
delete w;
}
void ProjectManagerPlugin::on_client_merged(qmdiHost *host)
{
if (m_dockWidget)
return;
QMainWindow *window = dynamic_cast<QMainWindow*>(host);
m_dockWidget = new QDockWidget(window);
m_dockWidget->setObjectName("m_dockWidget");
m_dockWidget->setWindowTitle( tr("Project") );
#if 0
m_treeView = new QTreeView(m_dockWidget);
m_treeView->setAlternatingRowColors(true);
m_dockWidget->setWidget(m_treeView);
#else
QWidget *w = new QWidget(m_dockWidget);
m_gui = new Ui::ProjectManagerGUI;
m_gui->setupUi(w);
m_dockWidget->setWidget(w);
#endif
m_projectModel = new FoldersModel(m_gui->filesView);
//m_projectModel->processDir("/home/elcuco/src/qtedit4/");
// m_projectModel->processDir("/home/elcuco/src/qt-creator/");
m_projectModel->processDir("/home/elcuco/src/googlecode/qtedit4/trunk/");
// m_projectModel->processDir("c:\\Users\\elcuco\\Source\\qtedit4");
m_gui->filesView->setModel(m_projectModel);
window->addDockWidget( Qt::LeftDockWidgetArea, m_dockWidget );
QCompleter *completer = new GenericItemCompleter();
completer->setModel(m_projectModel);
completer->setParent(m_gui->filenameLineEdit);
completer->setCaseSensitivity(Qt::CaseInsensitive);
completer->setCompletionMode(QCompleter::UnfilteredPopupCompletion);
completer->setCompletionRole(0);
completer->setCompletionPrefix("/");
m_gui->filenameLineEdit->setCompleter(completer);
connect(m_gui->filesView,SIGNAL(clicked(QModelIndex)),this,SLOT(onItemClicked(QModelIndex)));
connect(m_gui->addDirectoryButton,SIGNAL(clicked()),this,SLOT(onAddDirectoryClicked()));
}
/**
* @brief
* Adds the given Qt dock widget to the given Qt main window and tabifies it
*/
void DockWidget::AddDockWidgetAndTabify(QMainWindow &cQMainWindow, Qt::DockWidgetArea nQtDockWidgetArea, QDockWidget &cQDockWidget) const
{
// Add the given Qt dock widget to the given Qt main window
cQMainWindow.addDockWidget(nQtDockWidgetArea, &cQDockWidget);
// Tabify
const QList<QDockWidget*> lstQDockWidgets = cQMainWindow.findChildren<QDockWidget*>();
for (int i=0; i<lstQDockWidgets.count(); i++) {
// Get the current dock widget
QDockWidget *pQDockWidget = lstQDockWidgets.at(i);
// Is this current dock widget in the same dock widget area?
if (pQDockWidget != &cQDockWidget && cQMainWindow.dockWidgetArea(pQDockWidget) == nQtDockWidgetArea) {
// Tabify dock widget
cQMainWindow.tabifyDockWidget(pQDockWidget, &cQDockWidget);
// Get us out of the loop
i = lstQDockWidgets.count();
}
}
}
void RunCompile::generalSetting()
{
//设置 Dock 可移动区域为上下
setAllowedAreas(Qt::BottomDockWidgetArea);
//查找栏 可关 可移 可浮出 竖向标题
setFeatures(QDockWidget::DockWidgetClosable |
QDockWidget::DockWidgetFloatable |
QDockWidget::DockWidgetMovable
);
setWindowTitle(tr("编译"));//附着时不用标题
clearCompile->setFixedWidth(80);
compileToRun->setFixedWidth(80);
QMainWindow *main = qobject_cast<QMainWindow *>(parent());
main->addDockWidget(Qt::BottomDockWidgetArea, this);
hide();
connect(clearCompile, SIGNAL(clicked()),
this, SLOT(compileClear()));
/* connect(compileToRun, SIGNAL(clicked()),
this, SLOT(compilePrograms()));*/
}
void tst_QDockWidget::setFloating()
{
const QRect deskRect = QApplication::desktop()->availableGeometry();
QMainWindow mw;
mw.move(deskRect.left() + deskRect.width() * 2 / 3, deskRect.top() + deskRect.height() / 3);
QDockWidget dw;
mw.addDockWidget(Qt::LeftDockWidgetArea, &dw);
mw.show();
QVERIFY(QTest::qWaitForWindowExposed(&mw));
QVERIFY(!dw.isFloating());
const QPoint dockedPosition = dw.mapToGlobal(dw.pos());
QSignalSpy spy(&dw, SIGNAL(topLevelChanged(bool)));
dw.setFloating(true);
const QPoint floatingPosition = dw.pos();
// QTBUG-31044, show approximately at old position, give or take window frame.
QVERIFY((dockedPosition - floatingPosition).manhattanLength() < 50);
QVERIFY(dw.isFloating());
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating());
spy.clear();
dw.setFloating(dw.isFloating());
QCOMPARE(spy.count(), 0);
spy.clear();
dw.setFloating(false);
QVERIFY(!dw.isFloating());
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).value(0).toBool(), dw.isFloating());
spy.clear();
dw.setFloating(dw.isFloating());
QCOMPARE(spy.count(), 0);
spy.clear();
}
void tst_QWindowContainer::testDockWidget()
{
QMainWindow mainWindow;
mainWindow.resize(200, 200);
QDockWidget *dock = new QDockWidget();
QWindow *window = new QWindow();
QWidget *container = QWidget::createWindowContainer(window);
dock->setWidget(container);
mainWindow.addDockWidget(Qt::RightDockWidgetArea, dock);
mainWindow.show();
QVERIFY(QTest::qWaitForWindowExposed(&mainWindow));
QVERIFY(window->parent() == mainWindow.window()->windowHandle());
QTest::qWait(1000);
dock->setFloating(true);
QTRY_VERIFY(window->parent() != mainWindow.window()->windowHandle());
QTest::qWait(1000);
dock->setFloating(false);
QTRY_VERIFY(window->parent() == mainWindow.window()->windowHandle());
}
bool TextEditorNode::initialise( void )
{
QMainWindow *MainWindow = mNode->context()->global()->mainWindow();
if( !MainWindow )
{
return( false );
}
if( ( mDockWidget = new QDockWidget( "TextEditor", MainWindow ) ) == 0 )
{
return( false );
}
mDockWidget->setObjectName( mNode->name() );
if( ( mTextEdit = new TextEditorForm( mDockWidget ) ) == 0 )
{
return( false );
}
setupTextEditor( mTextEdit->textEdit() );
connect( mTextEdit, SIGNAL(updateText()), this, SLOT(onTextUpdate()) );
connect( mNode->qobject(), SIGNAL(nameChanged(QString)), mTextEdit, SLOT(updateNodeName(QString)) );
mDockWidget->setWidget( mTextEdit );
MainWindow->addDockWidget( mDockArea, mDockWidget );
mTextEdit->updateNodeName( mNode->name() );
checkHighlighter();
return( true );
}
void TestQgsDockWidget::testSetUserVisible()
{
QMainWindow *w = new QMainWindow();
QApplication::setActiveWindow( w ); //required for focus events
QgsDockWidget *d1 = new QgsDockWidget( w );
QgsDockWidget *d2 = new QgsDockWidget( w );
w->addDockWidget( Qt::RightDockWidgetArea, d1 );
w->addDockWidget( Qt::RightDockWidgetArea, d2 );
w->tabifyDockWidget( d1, d2 );
w->show();
QVERIFY( d2->isUserVisible() );
QVERIFY( !d1->isUserVisible() );
// showing dock widgets
// already visible
d2->setUserVisible( true );
QVERIFY( d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( d1->isVisible() );
// visible, but hidden by other dock
d1->setUserVisible( true );
QVERIFY( !d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
// hidden
d2->hide();
d2->setUserVisible( true );
QVERIFY( d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( d1->isVisible() );
// hiding dock widgets
// already hidden by other tab
d1->setUserVisible( false );
QVERIFY( d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( d1->isVisible() );
// already hidden
d2->hide();
d1->raise(); //shouldn't be necessary outside of tests
QVERIFY( !d2->isUserVisible() );
QVERIFY( !d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
d2->setUserVisible( false );
QVERIFY( !d2->isUserVisible() );
QVERIFY( !d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
// setting active dock as not user visible should hide it
d2->show();
d1->raise();
QVERIFY( !d2->isUserVisible() );
QVERIFY( d2->isVisible() );
QVERIFY( d1->isUserVisible() );
QVERIFY( d1->isVisible() );
d1->setUserVisible( false );
QVERIFY( d2->isVisible() );
QVERIFY( !d1->isUserVisible() );
QVERIFY( !d1->isVisible() );
delete w;
}
int main(int argc, char * argv[])
{
// Read command line options
cppassist::ArgumentParser argumentParser;
argumentParser.parse(argc, argv);
const auto contextString = argumentParser.value("--context");
// Create gloperate environment
Environment environment;
environment.setupScripting();
// Configure and load plugins
environment.componentManager()->addPluginPath(
gloperate::pluginPath(), cppexpose::PluginPathType::Internal
);
environment.componentManager()->scanPlugins();
// Initialize Qt application
gloperate_qt::Application app(&environment, argc, argv);
// Create render window
auto window = cppassist::make_unique<RenderWindow>(&environment);
// Specify desired context format
gloperate::GLContextFormat format;
format.setVersion(3, 2);
format.setProfile(gloperate::GLContextFormat::Profile::Core);
format.setForwardCompatible(true);
if (!contextString.empty())
{
if (!format.initializeFromString(contextString))
{
return 1;
}
}
window->setContextFormat(format);
auto windowRaw = window.get();
window->createContext();
window->canvas()->loadRenderStage("ShapeDemo");
// Create main window
QMainWindow mainWindow;
mainWindow.setWindowTitle("gloperate viewer");
mainWindow.resize(1280, 720);
mainWindow.setCentralWidget(QWidget::createWindowContainer(window.release())); // pass ownership to Qt
mainWindow.centralWidget()->setFocusPolicy(Qt::StrongFocus);
mainWindow.show();
// Create script console
auto scriptPrompt = cppassist::make_unique<ScriptPromptWidget>(&mainWindow);
scriptPrompt->setSyntaxHighlighter(cppassist::make_unique<ECMA26251SyntaxHighlighter>());
scriptPrompt->setCompleter(cppassist::make_unique<ECMA26251Completer>());
scriptPrompt->setFrameShape(QFrame::NoFrame);
auto scriptPromptRaw = scriptPrompt.get();
QObject::connect(scriptPrompt.get(), &ScriptPromptWidget::evaluate,
[&environment, scriptPromptRaw] (const QString & cmd)
{
// Execute script code
std::string code = cmd.toStdString();
cppexpose::Variant res = environment.executeScript(code);
// Output result
scriptPromptRaw->print(QString::fromStdString(res.value<std::string>()));
}
);
// Create dock window for scripting console
auto scriptPromptDockWidget = cppassist::make_unique<QDockWidget>("Script Prompt");
scriptPromptDockWidget->setWidget(scriptPrompt.release());
scriptPromptDockWidget->setObjectName("ScriptPromptWidget");
mainWindow.addDockWidget(Qt::DockWidgetArea::BottomDockWidgetArea, scriptPromptDockWidget.release());
// Initialize context, print context info
windowRaw->context()->use();
// windowRaw->context()->setSwapInterval(Context::SwapInterval::VerticalSyncronization);
cppassist::info() << std::endl
<< "OpenGL Version: " << GLContextUtils::version() << std::endl
<< "OpenGL Profile: " << GLContextUtils::profile() << std::endl
<< "OpenGL Vendor: " << GLContextUtils::vendor() << std::endl
<< "OpenGL Renderer: " << GLContextUtils::renderer() << std::endl;
windowRaw->context()->release();
// Run main loop
return app.exec();
}
