//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuPlotMainWindow::createDockPanels()
{
{
QDockWidget* dockWidget = new QDockWidget("Plot Project Tree", this);
dockWidget->setObjectName("dockWidget");
dockWidget->setAllowedAreas(Qt::AllDockWidgetAreas);
m_projectTreeView = new caf::PdmUiTreeView(this);
m_projectTreeView->enableSelectionManagerUpdating(true);
RiaApplication* app = RiaApplication::instance();
m_projectTreeView->enableAppendOfClassNameToUiItemText(app->preferences()->appendClassNameToUiText());
dockWidget->setWidget(m_projectTreeView);
m_projectTreeView->treeView()->setHeaderHidden(true);
m_projectTreeView->treeView()->setSelectionMode(QAbstractItemView::ExtendedSelection);
// Drag and drop configuration
m_projectTreeView->treeView()->setDragEnabled(true);
m_projectTreeView->treeView()->viewport()->setAcceptDrops(true);
m_projectTreeView->treeView()->setDropIndicatorShown(true);
m_projectTreeView->treeView()->setDragDropMode(QAbstractItemView::DragDrop);
// Install event filter used to handle key press events
RiuTreeViewEventFilter* treeViewEventFilter = new RiuTreeViewEventFilter(this);
m_projectTreeView->treeView()->installEventFilter(treeViewEventFilter);
addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
connect(m_projectTreeView, SIGNAL(selectionChanged()), this, SLOT(selectedObjectsChanged()));
m_projectTreeView->treeView()->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_projectTreeView->treeView(), SIGNAL(customContextMenuRequested(const QPoint&)),
SLOT(customMenuRequested(const QPoint&)));
m_projectTreeView->setUiConfigurationName("PlotWindow");
}
{
QDockWidget* dockWidget = new QDockWidget("Property Editor", this);
dockWidget->setObjectName("dockWidget");
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
m_pdmUiPropertyView = new caf::PdmUiPropertyView(dockWidget);
dockWidget->setWidget(m_pdmUiPropertyView);
m_pdmUiPropertyView->layout()->setContentsMargins(5, 0, 0, 0);
addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
}
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::BottomDockWidgetArea);
QList<QDockWidget*> dockWidgets = findChildren<QDockWidget*>();
for (QDockWidget* dock : dockWidgets)
{
connect(dock->toggleViewAction(), SIGNAL(triggered()), SLOT(slotDockWidgetToggleViewActionTriggered()));
}
}
void MainWindow::createDockWindows()
{
QDockWidget *dock = new QDockWidget(tr("Text Editor"), this);
m_editor = new TextEdit(dock);
connect(m_editor->document(), SIGNAL(contentsChanged()), this, SLOT(onEditorChanged()));
dock->setWidget(m_editor);
dock->setObjectName("text_editor");
addDockWidget(Qt::RightDockWidgetArea, dock);
m_showEditorDockAction = dock->toggleViewAction();
m_showEditorDockAction->setIconVisibleInMenu(false);
m_showEditorDockAction->setStatusTip(tr("Show or hide the document editor dock"));
m_showEditorDockAction->setIcon(QIcon::fromTheme("accessories-text-editor"));
m_showEditorDockAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_0));
dock = new QDockWidget(tr("Assistant"), this);
m_assistantToolBox = new QToolBox(dock);
dock->setWidget(m_assistantToolBox);
dock->setObjectName("assistant");
addDockWidget(Qt::LeftDockWidgetArea, dock);
connect(m_assistantToolBox, SIGNAL(currentChanged(int)),
this, SLOT(onCurrentAssistantChanged(int)));
m_showAssistantDockAction = dock->toggleViewAction();
m_showAssistantDockAction->setIconVisibleInMenu(false);
m_showAssistantDockAction->setStatusTip(tr("Show or hide the assistant dock"));
#if !defined(Q_WS_WIN) // BUG: icons are not displayed when cross-linking
m_showAssistantDockAction->setIcon(QIcon(":/assistant.svg"));
#endif
m_showAssistantDockAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_1));
dock = new QDockWidget(tr("Assistant Info"), this);
QWidget* widget = new QWidget(dock);
m_assistantPreviewNotes = new QLabel(widget);
m_assistantPreviewNotes->setText(tr("Code:"));
m_assistantCodePreview = new QTextEdit(widget);
m_assistantCodePreview->setReadOnly(true);
QBoxLayout* assistant_info_layout = new QBoxLayout(QBoxLayout::TopToBottom, widget);
assistant_info_layout->addWidget(m_assistantPreviewNotes);
assistant_info_layout->addWidget(m_assistantCodePreview);
widget->setLayout(assistant_info_layout);
dock->setWidget(widget);
dock->setObjectName("assistant_info");
addDockWidget(Qt::LeftDockWidgetArea, dock);
m_showAssistantInfoDockAction = dock->toggleViewAction();
m_showAssistantInfoDockAction->setIconVisibleInMenu(false);
m_showAssistantInfoDockAction->setStatusTip(tr("Show or hide the assistant info dock"));
#if !defined(Q_WS_WIN) // BUG: icons are not displayed when cross-linking
m_showAssistantInfoDockAction->setIcon(QIcon(":/assistant-info.svg"));
#endif
m_showAssistantInfoDockAction->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_2));
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
this->setWindowIcon(QIcon(":res/123.png"));
mdi = new QMdiArea(this);
this->setCentralWidget(mdi);
QDockWidget* dock = new QDockWidget(tr("Script log"),this);
dock->setObjectName(tr("ScriptLogDock"));
logText = new QTextEdit(dock);
logText->setReadOnly(true);
logText->setLineWrapMode(QTextEdit::NoWrap);
dock->setWidget(logText);
this->addDockWidget(Qt::BottomDockWidgetArea, dock);
run_script_init(this);
// make sure the about menu is shown
QMenu* menu = 0;
QList<QAction*> list = menuBar()->actions();
foreach(QAction* act, list){
if( act->text().contains(tr("help"),Qt::CaseInsensitive) ){
menu = act->menu();
}
}
if(menu == 0){
menu = menuBar()->addMenu(tr("&Help"));
}
menu->addAction(dock->toggleViewAction());
menu->addSeparator();
QAction* act = menu->addAction(tr("&About..."));
connect(act,SIGNAL(triggered()),this,SLOT(my_about()));
this->setWindowTitle(tr("X Toolbox (Beta)"));
}
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);
}
/*!
Keep track of dock widgets so they can be shown/hidden for different languages
*/
QDockWidget *DebuggerMainWindow::createDockWidget(const DebuggerLanguage &language,
QWidget *widget)
{
QDockWidget *dockWidget = addDockForWidget(widget);
dockWidget->setObjectName(widget->objectName());
addDockWidget(Qt::BottomDockWidgetArea, dockWidget);
if (!(d->m_activeDebugLanguages & language))
dockWidget->hide();
QAction *toggleViewAction = dockWidget->toggleViewAction();
Command *cmd = ActionManager::registerAction(toggleViewAction,
Id("Debugger.").withSuffix(widget->objectName()));
cmd->setAttribute(Command::CA_Hide);
dockWidget->installEventFilter(&d->m_resizeEventFilter);
connect(dockWidget->toggleViewAction(), &QAction::triggered,
d, &DebuggerMainWindowPrivate::updateDockWidgetSettings);
connect(dockWidget, &QDockWidget::topLevelChanged,
d, &DebuggerMainWindowPrivate::updateDockWidgetSettings);
connect(dockWidget, &QDockWidget::dockLocationChanged,
d, &DebuggerMainWindowPrivate::updateDockWidgetSettings);
return dockWidget;
}
void MainWindow::createDockWidget()
{
CreateDockWidgetDialog dialog(this);
int ret = dialog.exec();
if (ret == QDialog::Rejected)
return;
QDockWidget *dw = new QDockWidget;
dw->setObjectName(dialog.objectName());
dw->setWindowTitle(dialog.objectName());
dw->setWidget(new QTextEdit);
Qt::DockWidgetArea area = dialog.location();
switch (area) {
case Qt::LeftDockWidgetArea:
case Qt::RightDockWidgetArea:
case Qt::TopDockWidgetArea:
case Qt::BottomDockWidgetArea:
addDockWidget(area, dw);
break;
default:
if (!restoreDockWidget(dw)) {
QMessageBox::warning(this, QString(), tr("Failed to restore dock widget"));
delete dw;
return;
}
break;
}
extraDockWidgets.append(dw);
destroyDockWidgetMenu->setEnabled(true);
destroyDockWidgetMenu->addAction(new QAction(dialog.objectName(), this));
}
/**
* Adds a new dock window to the main window and embeds the given \a widget.
*/
QDockWidget* DockWindowManager::addDockWindow(const char* name, QWidget* widget, Qt::DockWidgetArea pos)
{
// creates the dock widget as container to embed this widget
MainWindow* mw = getMainWindow();
QDockWidget* dw = new QDockWidget(mw);
// Note: By default all dock widgets are hidden but the user can show them manually in the view menu.
// First, hide immediately the dock widget to avoid flickering, after setting up the dock widgets
// MainWindow::loadLayoutSettings() is called to restore the layout.
dw->hide();
switch (pos) {
case Qt::LeftDockWidgetArea:
case Qt::RightDockWidgetArea:
case Qt::TopDockWidgetArea:
case Qt::BottomDockWidgetArea:
mw->addDockWidget(pos, dw);
default:
break;
}
connect(dw, SIGNAL(destroyed(QObject*)),
this, SLOT(onDockWidgetDestroyed(QObject*)));
connect(widget, SIGNAL(destroyed(QObject*)),
this, SLOT(onWidgetDestroyed(QObject*)));
// add the widget to the dock widget
widget->setParent(dw);
dw->setWidget(widget);
// set object name and window title needed for i18n stuff
dw->setObjectName(QLatin1String(name));
dw->setWindowTitle(QDockWidget::trUtf8(name));
dw->setFeatures(QDockWidget::AllDockWidgetFeatures);
d->_dockedWindows.push_back(dw);
return dw;
}
void MainWindow::addAsDockWidget(QWidget* widget)
{
QDockWidget* dockWidget = new QDockWidget(widget->windowTitle(), this);
dockWidget->setObjectName(widget->objectName() + "DockWidget");
dockWidget->setWidget(widget);
QMainWindow::addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
}
QDockWidget* DebuggerMainWnd::createDockWidget(const char* name, const QString& title)
{
QDockWidget* w = new QDockWidget(title, this);
w->setObjectName(name);
// view menu changes when docking state changes
connect(w, SIGNAL(visibilityChanged(bool)), SLOT(updateUI()));
return w;
}
QDockWidget* ConsoleWidgetCollection::createDockWidget(QWidget* widget)
{
QDockWidget* dockWidget = new QDockWidget(widget->windowTitle(), this);
connect(widget, &QWidget::windowTitleChanged, this, &ConsoleWidgetCollection::onConsoleWindowTitleChanged);
dockWidget->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable);
dockWidget->setObjectName(widget->objectName() + "DockWidget");
dockWidget->setWidget(widget);
return dockWidget;
}
void DesktopMainWindow::createDockWindows()
{
QDockWidget *catalogDock = new QDockWidget(tr("Base Map"), this);
catalogDock->setObjectName(tr("CATALOG_DOCK_WINDOW"));
catalogDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
MapLayerCatalogWidget* layerCatalog = new MapLayerCatalogWidget(_app);
catalogDock->setWidget(layerCatalog);
addDockWidget(Qt::LeftDockWidgetArea, catalogDock);
_viewMenu->insertAction(_viewSeparator, catalogDock->toggleViewAction());
QDockWidget *serverDock = new QDockWidget(tr("User Data"), this);
serverDock->setObjectName(tr("SERVER_DOCK_WINDOW"));
serverDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
_serverManager = new ServerManagementWidget(_app);
serverDock->setWidget(_serverManager);
addDockWidget(Qt::LeftDockWidgetArea, serverDock);
_viewMenu->insertAction(_viewSeparator, serverDock->toggleViewAction());
}
Tab::Tab(QWidget *parent) :
QMainWindow(parent)
{
//Setting code field
code = new CodeEditor;
setCentralWidget(code);
//Setting input and output fields
input = new RuQTextEdit;
output = new RuQTextEdit;
output->setReadOnly(true);
inputLayout = new QVBoxLayout;
outputLayout = new QVBoxLayout;
inputLayout->addWidget(input);
outputLayout->addWidget(output);
setDockOptions(QMainWindow::AllowNestedDocks | QMainWindow::AnimatedDocks);
QDockWidget *inputDock = new QDockWidget(tr("Input"), this);
inputDock->setAllowedAreas(Qt::AllDockWidgetAreas);
inputWidget = new QWidget(inputDock);
inputWidget->setLayout(inputLayout);
inputDock->setWidget(inputWidget);
inputDock->setFeatures(QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
addDockWidget(Qt::RightDockWidgetArea, inputDock);
inputDock->setObjectName("inputDock");
QDockWidget *outputDock = new QDockWidget(tr("Output"), this);
outputDock->setAllowedAreas(Qt::AllDockWidgetAreas);
outputWidget = new QWidget(outputDock);
outputWidget->setLayout(outputLayout);
outputDock->setWidget(outputWidget);
outputDock->setFeatures(QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
addDockWidget(Qt::RightDockWidgetArea, outputDock);
outputDock->setObjectName("outputDock");
//Setting io and code fonts
setFonts();
//restore state
QSettings settings("SASM Project", "SASM");
restoreGeometry(settings.value("tabgeometry").toByteArray());
restoreState(settings.value("tabwindowstate").toByteArray());
}
void QgsTileScaleWidget::showTileScale( QMainWindow *mainWindow )
{
QDockWidget *dock = mainWindow->findChild<QDockWidget *>( "theTileScaleDock" );
if ( dock )
{
dock->setVisible( dock->isHidden() );
return;
}
QgsMapCanvas *canvas = mainWindow->findChild<QgsMapCanvas *>( "theMapCanvas" );
QgsDebugMsg( QString( "canvas:%1 [%2]" ).arg(( ulong ) canvas, 0, 16 ).arg( canvas ? canvas->objectName() : "" ) );
if ( !canvas )
{
QgsDebugMsg( "map canvas theMapCanvas not found" );
return;
}
QgsTileScaleWidget *tws = new QgsTileScaleWidget( canvas );
tws->setObjectName( "theTileScaleWidget" );
QObject *legend = mainWindow->findChild<QObject*>( "theLayerTreeView" );
if ( legend )
{
connect( legend, SIGNAL( currentLayerChanged( QgsMapLayer* ) ),
tws, SLOT( layerChanged( QgsMapLayer* ) ) );
}
else
{
QgsDebugMsg( "legend not found" );
}
//create the dock widget
dock = new QDockWidget( tr( "Tile Scale Panel" ), mainWindow );
dock->setObjectName( "theTileScaleDock" );
dock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
mainWindow->addDockWidget( Qt::RightDockWidgetArea, dock );
// add to the Panel submenu
QMenu *panelMenu = mainWindow->findChild<QMenu *>( "mPanelMenu" );
if ( panelMenu )
{
// add to the Panel submenu
panelMenu->addAction( dock->toggleViewAction() );
}
else
{
QgsDebugMsg( "panel menu not found" );
}
dock->setWidget( tws );
connect( dock, SIGNAL( visibilityChanged( bool ) ), tws, SLOT( scaleEnabled( bool ) ) );
QSettings settings;
dock->setVisible( settings.value( "/UI/tileScaleEnabled", false ).toBool() );
}
/******************************************************************************
* Creates a dock panel.
******************************************************************************/
void MainWindow::createDockPanel(const QString& caption, const QString& objectName, Qt::DockWidgetArea dockArea, Qt::DockWidgetAreas allowedAreas, QWidget* contents)
{
QDockWidget* dockWidget = new QDockWidget(caption, this);
dockWidget->setObjectName(objectName);
dockWidget->setAllowedAreas(allowedAreas);
dockWidget->setFeatures(QDockWidget::DockWidgetClosable);
dockWidget->setWidget(contents);
dockWidget->setTitleBarWidget(new QWidget());
addDockWidget(dockArea, dockWidget);
}
QDockWidget* MainWindow::createDockWidget(KoDockFactoryBase* factory)
{
QDockWidget* dockWidget = 0;
if(!m_dockWidgetMap.contains(factory->id())) {
dockWidget = factory->createDockWidget();
// It is quite possible that a dock factory cannot create the dock; don't
// do anything in that case.
if(!dockWidget) return 0;
m_dockWidgets.push_back(dockWidget);
dockWidget->setObjectName(factory->id());
dockWidget->setParent(this);
if(dockWidget->widget() && dockWidget->widget()->layout())
dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
bool visible = true;
switch(factory->defaultDockPosition()) {
case KoDockFactoryBase::DockTornOff:
dockWidget->setFloating(true); // position nicely?
break;
case KoDockFactoryBase::DockTop:
side = Qt::TopDockWidgetArea; break;
case KoDockFactoryBase::DockLeft:
side = Qt::LeftDockWidgetArea; break;
case KoDockFactoryBase::DockBottom:
side = Qt::BottomDockWidgetArea; break;
case KoDockFactoryBase::DockRight:
side = Qt::RightDockWidgetArea; break;
case KoDockFactoryBase::DockMinimized:
visible = false; break;
default:;
}
addDockWidget(side, dockWidget);
if(dockWidget->features() & QDockWidget::DockWidgetClosable) {
m_dockWidgetMenu->addAction(dockWidget->toggleViewAction());
if(!visible)
dockWidget->hide();
}
m_dockWidgetMap.insert(factory->id(), dockWidget);
} else {
dockWidget = m_dockWidgetMap[ factory->id()];
}
connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
return dockWidget;
}
DockedMainWindow::DockWidgetList DockedMainWindow::addToolWindows(const DesignerToolWindowList &tls)
{
DockWidgetList rc;
foreach (QDesignerToolWindow *tw, tls) {
QDockWidget *dockWidget = new QDockWidget;
dockWidget->setObjectName(tw->objectName() + QLatin1String("_dock"));
dockWidget->setWindowTitle(tw->windowTitle());
addDockWidget(tw->dockWidgetAreaHint(), dockWidget);
dockWidget->setWidget(tw);
rc.push_back(dockWidget);
}
void VentanaPrincipal::crearDockWindows()
{
QDockWidget *dock = new QDockWidget(tr("Comunicacion"));
dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
dock->setObjectName("communicationDock");
opciones = new OptionsWidget(this);
connect(opciones, SIGNAL(setTipoComunicacion(std::string)),
simplejo, SLOT(setTipoComunicacion(std::string)));
dock->setWidget(opciones);
addDockWidget(Qt::RightDockWidgetArea, dock);
}
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());
}
RightPanel::RightPanel(RestClientMainWindow* app)
{
m_responseHeaders = new QTextEdit;
m_responseHeaders->setAcceptRichText(false);
m_responseHeaders->setReadOnly(true);
QDockWidget *dock = new QDockWidget(app);
dock->setObjectName("Right");
dock->setWindowTitle(QObject::tr("Response Headers"));
dock->setWidget(m_responseHeaders);
dock->setFeatures(QDockWidget::DockWidgetMovable
| QDockWidget::DockWidgetFloatable);
app->addDockWidget(Qt::LeftDockWidgetArea, dock);
}
void BaseWidget::addDock(QWidget *w)
{
QDockWidget *dock = new QDockWidget(w->windowTitle(),this);
dock->setObjectName(w->windowTitle());
addDockWidget(Qt::LeftDockWidgetArea, dock);
dock->setWidget(w);
dock->setAttribute(Qt::WA_DeleteOnClose);
dock->show();
docks.append(dock);
connect(dock, SIGNAL(destroyed(QObject*)), this, SLOT(dock_destroyed_cb(QObject *)));
}
void ContextModel::setContext( QSharedPointer<fugio::ContextInterface> pContext )
{
clearContext();
mContext = pContext;
fugio::ContextSignals *CS = mContext->qobject();
connect( CS, SIGNAL(clearContext()), this, SLOT(clearContext()) );
connect( CS, SIGNAL(nodeAdded(QUuid)), this, SLOT(nodeAdded(QUuid)) );
connect( CS, SIGNAL(nodeRemoved(QUuid)), this, SLOT(nodeRemoved(QUuid)) );
connect( CS, SIGNAL(nodeRenamed(QUuid,QUuid)), this, SLOT(nodeRenamed(QUuid,QUuid)) );
connect( CS, SIGNAL(pinAdded(QUuid,QUuid)), this, SLOT(pinAdded(QUuid,QUuid)) );
connect( CS, SIGNAL(pinRemoved(QUuid,QUuid)), this, SLOT(pinRemoved(QUuid,QUuid)) );
connect( CS, SIGNAL(pinRenamed(QUuid,QUuid,QUuid)), this, SLOT(pinRenamed(QUuid,QUuid,QUuid)) );
connect( CS, SIGNAL(loadStart(QSettings&,bool)), this, SLOT(loadStarted(QSettings&,bool)) );
connect( CS, SIGNAL(loadEnd(QSettings&,bool)), this, SLOT(loadEnded(QSettings&,bool)) );
// if( QSharedPointer<ContextPrivate> C = qSharedPointerCast<ContextPrivate>( mContext ) )
// {
// connect( C.data(), SIGNAL(loading(QSettings&,bool)), this, SLOT(loadContext(QSettings&,bool)) );
// connect( C.data(), SIGNAL(saving(QSettings&)), this, SLOT(saveContext(QSettings&)) );
// connect( C.data(), SIGNAL(nodeUpdated(QUuid)), this, SLOT(nodeChanged(QUuid)) );
// connect( C.data(), SIGNAL(nodeActivated(QUuid)), this, SLOT(nodeActivated(QUuid)) );
// connect( C.data(), SIGNAL(linkAdded(QUuid,QUuid)), this, SLOT(linkAdded(QUuid,QUuid)) );
// connect( C.data(), SIGNAL(linkRemoved(QUuid,QUuid)), this, SLOT(linkRemoved(QUuid,QUuid)) );
// }
MainWindow *MW = gApp->mainWindow();
QDockWidget *DW = new QDockWidget( "Context Model", MW );
DW->setObjectName( "ContextModel" );
QTreeView *TV = new QTreeView( DW );
TV->setModel( this );
DW->setWidget( TV );
MW->addDockWidget( Qt::RightDockWidgetArea, DW );
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
this->setWindowIcon(QIcon(":res/123.png"));
mdi = new QMdiArea(this);
this->setCentralWidget(mdi);
QDockWidget* dock = new QDockWidget(tr("Script log"),this);
dock->setObjectName(tr("ScriptLogDock"));
logText = new QTextEdit(dock);
logText->setReadOnly(true);
logText->setLineWrapMode(QTextEdit::NoWrap);
dock->setWidget(logText);
this->addDockWidget(Qt::BottomDockWidgetArea, dock);
if(hidenum == 0){
hidenum = new QUsbHidEnumerator(this);
}
if(hid == 0){
hid = new QUsbHid(this);
}
connect(hidenum, SIGNAL(deviceDiscovered(QUsbHidInfo)), this, SLOT(devconnect(QUsbHidInfo)));
connect(hidenum, SIGNAL(deviceRemoved(QUsbHidInfo)), this, SLOT(devdisconnect(QUsbHidInfo)));
connect(hid, SIGNAL(readyRead()), this, SLOT(readyReadData()));
hidenum->setUpNotifications(0x250,0x250);
QList<QUsbHidInfo> devs = QUsbHid::enumDevices(0x250,0x250);
if(devs.size()){
hidpath = devs.at(0).path;
}
QMenu* menu = 0;
QList<QAction*> list = menuBar()->actions();
foreach(QAction* act, list){
if( act->text().contains(tr("help"),Qt::CaseInsensitive) ){
menu = act->menu();
}
}
if(menu == 0){
menu = menuBar()->addMenu(tr("&Help"));
}
menu->addAction(dock->toggleViewAction());
menu->addSeparator();
QAction* act = menu->addAction(tr("&About..."));
connect(act,SIGNAL(triggered()),this,SLOT(my_about()));
act = menu->addAction(tr("Send"));
connect(act,SIGNAL(triggered()),this,SLOT(my_send()));
this->setWindowTitle(QString::fromLocal8Bit("Tool Box"));
//test_hid_devices(this);
}
void UiController::addDockWidget(Qt::DockWidgetArea area, QString name, QWidget *widget)
{
QDockWidget *dockWidget = new QDockWidget;
dockWidget->setWindowTitle(name);
dockWidget->setObjectName(name);
dockWidget->setWidget(widget);
widget->setParent(dockWidget);
_mainWindow.addDockWidget(area, dockWidget);
if (area == Qt::BottomDockWidgetArea) {
if (_lastBottomDockWidgetAdded)
_mainWindow.tabifyDockWidget(_lastBottomDockWidgetAdded, dockWidget);
_lastBottomDockWidgetAdded = dockWidget;
}
}
void Window::createResultsDock()
{
LogWidget *logWidget = new LogWidget( this );
connect(
_myApp, SIGNAL( log(QString) ),
logWidget, SLOT( log(QString) )
);
QDockWidget *dockWidget = new QDockWidget( "Log", this );
dockWidget->setObjectName( "LogWidget" );
dockWidget->setWidget( logWidget );
addDockWidget( Qt::LeftDockWidgetArea, dockWidget );
}
QDockWidget *FancyMainWindow::addDockForWidget(QWidget *widget)
{
QDockWidget *dockWidget = new QDockWidget(widget->windowTitle(), this);
dockWidget->setObjectName(widget->windowTitle());
dockWidget->setWidget(widget);
connect(dockWidget->toggleViewAction(), SIGNAL(triggered()),
this, SLOT(onDockActionTriggered()), Qt::QueuedConnection);
connect(dockWidget, SIGNAL(visibilityChanged(bool)),
this, SLOT(onDockVisibilityChange(bool)));
connect(dockWidget, SIGNAL(topLevelChanged(bool)),
this, SLOT(onTopLevelChanged()));
m_dockWidgets.append(dockWidget);
m_dockWidgetActiveState.append(true);
updateDockWidget(dockWidget);
return dockWidget;
}
QDockWidget*
DockWidgetManager::createDockedWidget( const char *qs_name,
Qt::DockWidgetAreas areas,
QDockWidget::DockWidgetFeature features )
{
if ( m_dockWidgets.contains( qs_name ) )
return NULL;
QDockWidget* dock = new QDockWidget( tr( qs_name ), m_mainWin );
dock->setObjectName( QString( "docked_" ) + qs_name );
dock->setAllowedAreas( areas );
dock->setFeatures( features );
m_dockWidgets.insert( qs_name, dock );
return dock;
}
QDockWidget *DockWidgetCatalog::addDockWidget(QWidget *widget, const QString &windowTitle, Qt::DockWidgetArea area)
{
if (widget == nullptr)
return nullptr;
QDockWidget *dock = new QDockWidget();
dock->setWidget(widget);
dock->setWindowTitle(windowTitle);
dock->setObjectName(windowTitle);
m_widgets.push_back(dock);
m_mainWindow.addDockWidget(area, dock);
onDockWidgetAdded(dock);
return dock;
}
void MainWindow::initHistory(int snapType)
{
QString title = dockCtrlNames[snapType];
QDockWidget *dockWidget = new QDockWidget(this);
dockWidget->setObjectName("dockWidget_" + title);
dockWidget->setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetMovable|QDockWidget::NoDockWidgetFeatures);
QWidget *dockWidgetContents = new QWidget(dockWidget);
dockWidgetContents->setObjectName("dockWidgetContents_" + title);
QGridLayout *gridLayout = new QGridLayout(dockWidgetContents);
gridLayout->setObjectName("gridLayout_" + title);
gridLayout->setContentsMargins(0, 0, 0, 0);
QTextBrowser * tb;
if (snapType == DOCK_HISTORY)
{
tb = tbHistory = new QTextBrowser(dockWidgetContents);
tbHistory->setOpenExternalLinks(true);
}
else if (snapType == DOCK_MAMEINFO)
tb = tbMameinfo = new QTextBrowser(dockWidgetContents);
else if (snapType == DOCK_DRIVERINFO)
tb = tbDriverinfo = new QTextBrowser(dockWidgetContents);
else if (snapType == DOCK_STORY)
tb = tbStory = new QTextBrowser(dockWidgetContents);
else
tb = tbCommand = new QTextBrowser(dockWidgetContents);
tb->setObjectName("textBrowser_" + title);
tb->setFrameShape(QFrame::NoFrame);
gridLayout->addWidget(tb);
dockWidget->setWidget(dockWidgetContents);
dockWidget->setWindowTitle(tr(qPrintable(title)));
addDockWidget(static_cast<Qt::DockWidgetArea>(Qt::RightDockWidgetArea), dockWidget);
// create tabbed history widgets
if (dwHistory)
tabifyDockWidget(dwHistory, dockWidget);
else
dwHistory = dockWidget;
menuDocuments->addAction(dockWidget->toggleViewAction());
dockCtrls[snapType] = dockWidget;
}
QDockWidget *
MainWindow::createDockWidget( QWidget * widget, const QString& title, const QString& pageName )
{
if ( widget->windowTitle().isEmpty() ) // avoid QTC_CHECK warning on console
widget->setWindowTitle( title );
if ( widget->objectName().isEmpty() )
widget->setObjectName( pageName );
QDockWidget * dockWidget = addDockForWidget( widget );
dockWidget->setObjectName( pageName.isEmpty() ? widget->objectName() : pageName );
if ( title.isEmpty() )
dockWidget->setWindowTitle( widget->objectName() );
else
dockWidget->setWindowTitle( title );
return dockWidget;
}
// Inicializa los elementos necesarios para la aplicación
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
{
setupUi(this);
setupActions();
// Configura la barra de herramienta
QMenu *toolBarMenu = menuSettings->addMenu(tr("&Toolbars"));
toolBar->toggleViewAction()->setShortcut(tr("CTRL+T"));
toolBar->toggleViewAction()->setStatusTip(tr("Show/Hide Main Toolbar"));
toolBar->toggleViewAction()->setText(tr("&Main Toolbar"));
toolBarMenu->addAction(toolBar->toggleViewAction());
actionUndo->setEnabled(false);
actionRepeat->setEnabled(false);
mStatLabel = new QLabel();
statusBar()->addPermanentWidget(mStatLabel);
connect(textEdit, SIGNAL(textChanged()),
this, SLOT(updateStats()));
updateStats();
QDockWidget *templateDocker = new QDockWidget;
templateDocker->setAllowedAreas(Qt::LeftDockWidgetArea|
Qt::RightDockWidgetArea);
templateDocker->setObjectName("TemplateDocker");
templateDocker->setWindowTitle("Templates");
addDockWidget(Qt::LeftDockWidgetArea,templateDocker);
QListView *view = new QListView();
templateDocker->setWidget(view);
TemplateHandler *mTemplate = new TemplateHandler(view, textEdit, this);
templateDocker->toggleViewAction()->setShortcut(tr("CTRL+M"));
templateDocker->toggleViewAction()->setStatusTip(tr("Show/Hide Template Docker"));
templateDocker->toggleViewAction()->setText(tr("&Template Docker"));
toolBarMenu->addAction(templateDocker->toggleViewAction());
// Recuoera la configuración del editor
readsettings();
}
