//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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()));
}
}
UIMain::UIMain( QWidget* parent )
: QMainWindow( parent ), mProject( 0 ), mInit( false ),
mProcess( new QProcess( this ) ), cbFont( new QComboBox( this ) ),
cbFontSize( new QComboBox( this ) ), mManual( new QAssistantClient( Options::qtBin( "assistant" ), this ) ),
mAssistant( new QAssistantClient( Options::qtBin( "assistant" ), this ) )
{
mProcess->setObjectName( "mProcess" );
mProcess->setReadChannelMode( QProcess::MergedChannels );
cbFont->setObjectName( "cbFont" );
cbFontSize->setObjectName( "cbFontSize" );
mAssistant->setObjectName( "mAssistant" );
mManual->setObjectName( "mManual" );
setupUi( this );
// setting argument to manual
mManual->setArguments( QStringList() << "-profile" << Options::documentationFile( "html/qt4ds-monkey.adp" ) );
// workspace scrollbars
workspace->setScrollBarsEnabled( true );
// Adding Search Replace Dialog inside Messages Box
twMessagesBox->addTab( ReplaceDialog::self(), QIcon( ":/Icons/Icons/tabsearch.png" ), tr( "Search Replace" ) );
ReplaceDialog::self()->pbCancel->hide();
connect( qApp, SIGNAL( focusChanged( QWidget*, QWidget* ) ), this, SLOT( focusChanged( QWidget*, QWidget* ) ) );
// Adding buttons to status bar
sbBar->addPermanentWidget( pbWidgetsBox );
sbBar->addPermanentWidget( pbProjectsBox );
sbBar->addPermanentWidget( pbMessagesBox );
//
QFont myFont;
if ( !myFont.fromString( Options::self()->value( "Options/Editor/TextFont" ).toString() ) )
myFont = qApp->font();
// Font
fontToolBar->addWidget( cbFont );
cbFont->setEditable( true );
QFontDatabase fdb;
cbFont->addItems( fdb.families() );
cbFont->setCurrentIndex( cbFont->findText( myFont.family() ) );
// Font Size
fontToolBar->addWidget( cbFontSize );
cbFontSize->setEditable( true );
foreach ( int size, fdb.standardSizes() )
cbFontSize->addItem( QString::number( size ) );
cbFontSize->setCurrentIndex( cbFontSize->findText (QString::number( myFont.pointSize() ) ) );
// Adding a application background
//workspace->setBackground( QBrush( QPixmap( ":/Icons/Icons/background.png" ) ) );
// Setting corners
setCorner( Qt::TopLeftCorner, Qt::LeftDockWidgetArea );
setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
// create action for styles
agStyles = new QActionGroup( this );
connect( agStyles, SIGNAL( triggered( QAction* ) ), this, SLOT( agStyles_triggered( QAction* ) ) );
QAction* action;
foreach ( QString style, QStyleFactory::keys() )
{
action = agStyles->addAction( style );
action->setCheckable( true );
if ( Options::self()->value( "Options/Style" ).toString() == style )
action->setChecked( true );
}
void RenderWindow::ResetDocksPositions()
{
// restoreGeometry(defaultGeometry);
restoreState(defaultState);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
}
/**
\param bd
**/
BtBulmaTPV::BtBulmaTPV ( QString bd ) : BlMainWindow()
{
BL_FUNC_DEBUG
setupUi ( this );
setUpdatesEnabled ( true );
pWorkspace = new BlWorkspace ( this );
pWorkspace->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
pWorkspace->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
QProgressBar *m_pb = new QProgressBar();
m_pb->setMaximum ( 100 );
m_pb->setMinimum ( 0 );
m_pb->setValue ( 0 );
/// Hacemos que el ProgressBar esté invisible hasta que se seleccione una empresa.
m_pb->setVisible ( false );
m_stackedWidget = new QStackedWidget(this);
BlMainWindow::setCentralWidget(m_stackedWidget);
/// Creamos un VerticalLayout donde metemos el contenido central del QMainWindow.
QVBoxLayout *vboxlayout = new QVBoxLayout ( this->centralWidget() );
vboxlayout->setSpacing ( 0 );
vboxlayout->setMargin ( 0 );
vboxlayout->addWidget ( pWorkspace );
vboxlayout->addWidget ( m_pb );
m_company = new BtCompany ( this );
m_company->setProgressBar ( m_pb );
m_company->init ( bd, "BulmaFact" );
m_company->setWorkspace ( pWorkspace );
/// Para que bulmalib pueda usar el BlMainCompany mantengo un puntero a el desde BlMainWindow
m_pcompany = m_company;
setCorner ( Qt::TopLeftCorner, Qt::TopDockWidgetArea );
setCorner ( Qt::TopRightCorner, Qt::RightDockWidgetArea );
setCorner ( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
setCorner ( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
// ============== OJO El listventanas no se utiliza pero lo pongo para poder usar componentes de bulmafact.
/// Aqui creamos la ventana dock para meter las distintas ventanas.
BlWindowListDock *list = new BlWindowListDock ( 0 );
list->setVisible ( false );
/// Iniciamos el listventanas con el workspace para que pueda operar con el.
list->setWorkspace ( pWorkspace );
m_company->setListVentanas ( list );
m_pb->setVisible ( false );
statusBar() ->showMessage ( bd, 2000 );
setWindowTitle ( bd );
}
void MainWindow::createDocks()
{
setCorner(Qt::BottomRightCorner,Qt::RightDockWidgetArea);
setCorner(Qt::BottomLeftCorner,Qt::LeftDockWidgetArea);
consoleDock = new QDockWidget( tr( "Console" ), this );
addDockWidget( Qt::BottomDockWidgetArea, consoleDock );
console = new QListWidget( this );
consoleDock->setWidget( console );
console->setMaximumHeight( 120 );
console->setAlternatingRowColors( true );
consoleDock->setVisible( false );
}
void NodeEditorWindows::createDocks()
{
// settings of mdi area
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setTabPosition(Qt::LeftDockWidgetArea, QTabWidget::North);
// cam explorer dock
_camExplorerDock = new QDockWidget(tr("Node project explorer"), this);
QWidget *camExplorerContent = new QWidget(_camExplorerDock);
QLayout *camExplorerLayout = new QVBoxLayout();
_camExplorerWidget = new CamExplorerWidget();
camExplorerLayout->addWidget(_camExplorerWidget);
camExplorerContent->setLayout(camExplorerLayout);
_camExplorerDock->setWidget(camExplorerContent);
addDockWidget(Qt::LeftDockWidgetArea, _camExplorerDock);
// viewer explorer dock
_viewerExplorerDock = new QDockWidget(tr("Viewers"), this);
QWidget *viewerExplorerContent = new QWidget(_viewerExplorerDock);
QLayout *viewerExplorerLayout = new QVBoxLayout();
_viewerExplorerWidget = new ViewerExplorerWidget();
viewerExplorerLayout->addWidget(_viewerExplorerWidget);
viewerExplorerContent->setLayout(viewerExplorerLayout);
_viewerExplorerDock->setWidget(viewerExplorerContent);
tabifyDockWidget(_camExplorerDock, _viewerExplorerDock);
// lib treeview dock
_libTreeViewDock = new QDockWidget(tr("IP library explorer"), this);
QWidget *libTreeViewContent = new QWidget(_libTreeViewDock);
QLayout *libTreeViewLayout = new QVBoxLayout();
_libTreeView = new LibTreeView();
_libTreeView->setLib(&Lib::getLib());
libTreeViewLayout->addWidget(_libTreeView);
libTreeViewContent->setLayout(libTreeViewLayout);
_libTreeViewDock->setWidget(libTreeViewContent);
addDockWidget(Qt::RightDockWidgetArea, _libTreeViewDock);
// compile log dock
_compileLogDock = new QDockWidget(tr("Compilation log"), this);
QWidget *compileLogContent = new QWidget(_compileLogDock);
QLayout *compileLogLayout = new QVBoxLayout();
_compileLog = new CompileLogWidget();
compileLogLayout->addWidget(_compileLog);
compileLogContent->setLayout(compileLogLayout);
_compileLogDock->setWidget(compileLogContent);
addDockWidget(Qt::BottomDockWidgetArea, _compileLogDock);
connect(_compileLog, SIGNAL(messageSended(QString)), this, SLOT(showMessage(QString)));
}
void Ellipse::setData(QString &xml)
{
QDomDocument doc("xml");
if (!doc.setContent(xml, false))
return;
QDomElement root = doc.documentElement();
if (root.tagName() != "data")
return;
QDomNodeList nodes = root.childNodes();
for (int i = 0; i < nodes.count(); i++) {
QDomNode node = nodes.at(i);
QDomElement element = node.toElement();
if (element.tagName() == "geometry") {
double x = element.attribute("x").toDouble();
double y = element.attribute("y").toDouble();
double width = element.attribute("width").toDouble();
double height = element.attribute("height").toDouble();
setCorner(Point(x, y));
setWidth(width);
setHeight(height);
}
}
}
Cell::Cell(int inp_dimension, double* inp_corner, double* inp_width) {
dimension = inp_dimension;
corner = (double*) malloc(dimension * sizeof(double));
width = (double*) malloc(dimension * sizeof(double));
for(int d = 0; d < dimension; d++) setCorner(d, inp_corner[d]);
for(int d = 0; d < dimension; d++) setWidth( d, inp_width[d]);
}
void MainWindow::createDocks()
{
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
m_logWidget = new LogWidget;
m_logWidget->setMaximumHeight(100);
m_logWidget->newMsg(QString("The simulator is up and ready to roll..."));
m_logDock = new QDockWidget(tr("Console"), this);
m_logDock->setWidget(m_logWidget);
addDockWidget(Qt::BottomDockWidgetArea, m_logDock);
m_dataTrees = new DataTrees();
m_dataTreesDock = new QDockWidget(tr("Data Trees"), this);
m_dataTreesDock->setWidget(m_dataTrees);
addDockWidget(Qt::RightDockWidgetArea, m_dataTreesDock);
m_infos = new InformationsBox;
m_infoDock = new QDockWidget(tr("Data Dock"), this);
m_infoDock->setWidget(m_infos);
addDockWidget(Qt::RightDockWidgetArea, m_infoDock);
QObject::connect(m_dataTrees->mainTree(), SIGNAL(itemClicked(QTreeWidgetItem*, int)),
m_infos, SLOT(setCurrentItem(QTreeWidgetItem*, int)));
QObject::connect(m_dataTrees->simTree(), SIGNAL(itemClicked(QTreeWidgetItem*, int)),
m_infos, SLOT(setCurrentItem(QTreeWidgetItem*, int)));
m_controlsWidget = new ControlsWidget;
m_controlsDock = new QDockWidget(tr("Controls"), this);
m_controlsDock->setWidget(m_controlsWidget);
addDockWidget(Qt::RightDockWidgetArea, m_controlsDock);
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
ui.setupUi(this);
ui.mainToolBar->setWindowTitle(LStr("工具栏"));
//设置嵌入窗口优先级
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
QAFApplication::splashMessage(LStr("正在初始化界面..."));
QAFApplication::splashMessage(LStr("正在创建菜单..."));
createMenu();
createAction();
QAF::QAFContext::getSingleton()->setUIInterface(this);
}
void MdiEditor::createDockWidget()
{
imageDockEditorL = new QDockWidget(tr("Input image1"),this);
imageDockEditorL->setFeatures(QDockWidget::DockWidgetMovable|
QDockWidget::DockWidgetFloatable);
imageDockEditorL->setAllowedAreas(Qt::AllDockWidgetAreas);
imageDockEditorL->setWidget(imageEditorL);
imageDockEditorR = new QDockWidget(tr("Input image2"),this);
imageDockEditorR->setFeatures(QDockWidget::DockWidgetMovable|
QDockWidget::DockWidgetFloatable);
imageDockEditorR->setAllowedAreas(Qt::AllDockWidgetAreas);
imageDockEditorR->setWidget(imageEditorR);
imageDockEditorM = new QDockWidget(tr("Halfway result"),this);
imageDockEditorM->setFeatures(QDockWidget::DockWidgetMovable|
QDockWidget::DockWidgetFloatable);
imageDockEditorM->setAllowedAreas(Qt::AllDockWidgetAreas);
imageDockEditorM->setWidget(imageEditorM);
imageDockEditorA = new QDockWidget(tr("Morphing result"),this);
imageDockEditorA->setFeatures(QDockWidget::DockWidgetMovable|
QDockWidget::DockWidgetFloatable);
imageDockEditorA->setAllowedAreas(Qt::AllDockWidgetAreas);
gridLayout=new QGridLayout();
gridLayout->addWidget(ctrbar,0,0);
gridLayout->addWidget(imageEditorA,1,0,10,1);
widgetA->setLayout(gridLayout);
imageDockEditorA->setWidget(widgetA);
addDockWidget(Qt::TopDockWidgetArea,imageDockEditorL);
addDockWidget(Qt::RightDockWidgetArea,imageDockEditorR);
addDockWidget(Qt::LeftDockWidgetArea,imageDockEditorM);
addDockWidget(Qt::BottomDockWidgetArea,imageDockEditorA);
setCorner(Qt::TopLeftCorner,Qt::TopDockWidgetArea);
setCorner(Qt::TopRightCorner,Qt::RightDockWidgetArea);
setCorner(Qt::BottomLeftCorner,Qt::LeftDockWidgetArea);
setCorner(Qt::BottomRightCorner,Qt::BottomDockWidgetArea);
}
GCF::Components::MainWindow::MainWindow()
:QMainWindow(0)
{
d = new GCF::Components::MainWindowData;
setAnimated(false);
setMinimumSize(800, 600);
d->centralWidget = new QSplitter(Qt::Vertical, this);
setCentralWidget(d->centralWidget);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
d->workspace = new QTabWidget(d->centralWidget);
d->workspace->setTabPosition(QTabWidget::North);
d->workspace->setSizePolicy( QSizePolicy::Ignored, QSizePolicy::Ignored );
d->centralWidget->addWidget(d->workspace);
connect(d->workspace, SIGNAL(currentChanged(int)), this, SLOT(on_workspace_currentChanged(int)));
// new TabWidgetStyle(d->workspace);
}
SpimView::SpimView(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::SpimView),
settings("Larus-Stone", "QtSpim")
{
// Open windows
//
ui->setupUi(this);
SpimConsole = new Console(this);
stdExceptionHandler = QString("<<SPIM Exception Handler>>");
// Set style parameters for docking widgets
//
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
// Dock widgets
//
win_Tile();
// Wire up the menu and context menu commands
//
wireCommands();
// Restore program settings and window positions
//
readSettings();
// Create a console
//
ui->action_Win_Console->setChecked(0);
programStatus = IDLE;
}
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
, timer_(new QTimer(this))
{
setDockNestingEnabled( true );
setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
setCorner( Qt::BottomRightCorner, Qt::BottomDockWidgetArea );
statusBar()->setProperty( "p_styled", true );
statusBar()->addWidget( new QLabel );
if ( auto p = statusBar()->findChild<QLabel *>() ) {
p->setText( "STATUS:" );
}
setupFileActions();
setupEditActions();
{
QMenu *helpMenu = new QMenu(tr("Help"), this);
menuBar()->addMenu(helpMenu);
helpMenu->addAction(tr("About"), this, SLOT(about()));
helpMenu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
}
#if defined USING_CHARTS
auto widget = new ChartView( this );
#else
auto widget = new WaveformView( this );
#endif
setCentralWidget( widget );
grabGesture( Qt::PanGesture );
grabGesture( Qt::PinchGesture );
connect( document::instance(), &document::updateData, this, &MainWindow::handleUpdateData );
createDockWidgets();
}
void InternalToolBox::restore(const KConfigGroup &containmentGroup)
{
KConfigGroup group = KConfigGroup(&containmentGroup, "ToolBox");
if (!group.hasKey("corner")) {
return;
}
m_userMoved = true;
setCorner(Corner(group.readEntry("corner", int(corner()))));
const int offset = group.readEntry("offset", 0);
const int w = boundingRect().width();
const int h = boundingRect().height();
const int maxW = m_containment ? m_containment->geometry().width() - w : offset;
const int maxH = m_containment ? m_containment->geometry().height() - h : offset;
switch (corner()) {
case InternalToolBox::TopLeft:
setPos(0, 0);
break;
case InternalToolBox::Top:
setPos(qMin(offset, maxW), 0);
break;
case InternalToolBox::TopRight:
setPos(m_containment->size().width() - boundingRect().width(), 0);
break;
case InternalToolBox::Right:
setPos(m_containment->size().width() - boundingRect().width(), qMin(offset, maxH));
break;
case InternalToolBox::BottomRight:
setPos(m_containment->size().width() - boundingRect().width(), m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::Bottom:
setPos(qMin(offset, maxW), m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::BottomLeft:
setPos(0, m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::Left:
setPos(0, qMin(offset, maxH));
break;
}
//kDebug() << "marked as user moved" << pos()
// << (m_containment->containmentType() == Containment::PanelContainment);
}
OBB::OBB(const vec3dd &p_p, vecintd ind_p, Vector3d color_p){
this->p=p_p;
this->ind=ind_p;
this->color=color_p;
this->box_color=Vector3d(0,1,0);
this->zoom_val=1.0;
//this->center=0;
//this->box_calculated=false;
this->q_now=Quat4d(0,0,0,1);
points=p;
center=points[0];
for(unsigned int i=1;i<points.size();i++){
center=center+points[i];
}
center=center/points.size();
caluculateC();
setCorner();
}
void QuadWarp::setBottomLeftCornerPosition(ofPoint p) {
setCorner(p, 3);
}
void QuadWarp::setBottomRightCornerPosition(ofPoint p) {
setCorner(p, 2);
}
void QuadWarp::setTopRightCornerPosition(ofPoint p) {
setCorner(p, 1);
}
void QuadWarp::setTopLeftCornerPosition(ofPoint p) {
setCorner(p, 0);
}
//! [0]
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
//! [0]
//! [1]
fileToolbar->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
addToolBar(Qt::TopToolBarArea, fileToolbar);
//! [1]
//! [2]
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
//! [2]
//! [3]
QWidget *centralWidget = new QWidget(this);
setCentralWidget(centralWidget);
//! [3]
//! [4]
QPopupMenu *fileMenu = new QPopupMenu(this);
openAction->addTo(fileMenu);
saveAction->addTo(fileMenu);
...
menuBar()->insertItem(tr("&File"), fileMenu);
//! [4]
//! [5]
QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(openAction);
fileMenu->addAction(saveAction);
...
//! [5]
//! [6]
QToolBar *fileTools = new QToolBar(this, "file toolbar");
openAction->addTo(fileTools);
saveAction->addTo(fileTools);
...
//! [6]
//! [7]
QToolBar *fileTools = addToolBar(tr("File Tool Bar"));
fileTools->addAction(openAction);
fileTools->addAction(saveAction);
...
//! [7]
//! [8]
QDockWidget *dockWidget = new QDockWidget(this);
mainWin->moveDockWidget(dockWidget, Qt::DockLeft);
//! [8]
//! [9]
QDockWidget *dockWidget = new QDockWidget(mainWindow);
mainWindow->addDockWidget(Qt::LeftDockWidgetArea, dockWidget);
Treenity::Treenity(QWidget *parent)
: QMainWindow(parent), m_running(true)
{
//Set some utility init things
Utils::GetInstance()->setParent(this);
Utils::GetInstance()->setFloating(true);
// Setup component names in the editor.
m_componentNames[RootForce::ComponentType::RENDERABLE] = "Renderable";
m_componentNames[RootForce::ComponentType::TRANSFORM] = "Transform";
m_componentNames[RootForce::ComponentType::POINTLIGHT] = "Point Light";
m_componentNames[RootForce::ComponentType::CAMERA] = "Camera";
m_componentNames[RootForce::ComponentType::HEALTH] = "Health";
m_componentNames[RootForce::ComponentType::PLAYERCONTROL] = "Player Control";
m_componentNames[RootForce::ComponentType::PHYSICS] = "Physics";
m_componentNames[RootForce::ComponentType::NETWORK] = "Network";
m_componentNames[RootForce::ComponentType::LOOKATBEHAVIOR] = "Look-At Behaviour";
m_componentNames[RootForce::ComponentType::THIRDPERSONBEHAVIOR] = "Third Person Behaviour";
m_componentNames[RootForce::ComponentType::SCRIPT] = "Script";
m_componentNames[RootForce::ComponentType::COLLISION] = "Physics"; // Required since the component list searches on name.
m_componentNames[RootForce::ComponentType::COLLISIONRESPONDER] = "Collision Responder";
m_componentNames[RootForce::ComponentType::PLAYER] = "Player";
m_componentNames[RootForce::ComponentType::ANIMATION] = "Animation";
m_componentNames[RootForce::ComponentType::PARTICLE] = "Particle";
m_componentNames[RootForce::ComponentType::TDMRULES] = "Team-Deathmatch Rules";
m_componentNames[RootForce::ComponentType::PLAYERACTION] = "Player Action";
m_componentNames[RootForce::ComponentType::PLAYERPHYSICS] = "Player Physics";
m_componentNames[RootForce::ComponentType::ENTITYSTATE] = "Entity State";
m_componentNames[RootForce::ComponentType::SHADOWCASTER] = "Shadowcaster";
m_componentNames[RootForce::ComponentType::DIRECTIONALLIGHT] = "Directional Light";
m_componentNames[RootForce::ComponentType::SERVERINFORMATION] = "Server Information";
m_componentNames[RootForce::ComponentType::CLIENT] = "Client";
m_componentNames[RootForce::ComponentType::RAGDOLL] = "Ragdoll";
m_componentNames[RootForce::ComponentType::WATERCOLLIDER] = "Water Collider";
m_componentNames[RootForce::ComponentType::ABILITYSPAWN] = "Ability Spawn";
m_componentNames[RootForce::ComponentType::TRYPICKUPCOMPONENT] = "Try Pickup";
m_componentNames[RootForce::ComponentType::SOUND] = "Sound";
m_componentNames[RootForce::ComponentType::TIMER] = "Timer";
m_componentNames[RootForce::ComponentType::FOLLOW] = "Follow";
m_componentNames[RootForce::ComponentType::HOMING] = "Homing";
m_componentNames[RootForce::ComponentType::RAY] = "Ray";
m_componentNames[RootForce::ComponentType::DAMAGEANDKNOCKBACK] = "Damage and Knockback";
m_componentNames[RootForce::ComponentType::SCALABLE] = "Scalable";
m_componentNames[RootForce::ComponentType::STATCHANGE] = "Stat Change";
m_componentNames[RootForce::ComponentType::KILLANNOUNCEMENT] = "Kill Announcement";
m_componentNames[RootForce::ComponentType::CONTROLLERACTIONS] = "Controller Action";
// Setup the main UI.
ui.setupUi(this);
setCorner( Qt::TopRightCorner, Qt::RightDockWidgetArea );
setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
m_compView = new ComponentView();
m_scrollArea = new VerticalScrollArea();
m_scrollArea->setWidget(m_compView);
m_scrollArea->setFrameStyle(QFrame::Plain);
// Setup the component view and its items.
ui.verticalLayout->addWidget(m_scrollArea);
m_componentViews[RootForce::ComponentType::TRANSFORM] = new TransformView();
m_componentViews[RootForce::ComponentType::RENDERABLE] = new RenderableView();
m_componentViews[RootForce::ComponentType::COLLISION] = new PhysicsView();
m_componentViews[RootForce::ComponentType::WATERCOLLIDER] = new WaterColliderView();
m_componentViews[RootForce::ComponentType::SCRIPT] = new ScriptView();
m_componentViews[RootForce::ComponentType::COLLISIONRESPONDER] = new CollisionResponderView();
m_componentViews[RootForce::ComponentType::PARTICLE] = new ParticleView();
// Block component views from updates while in game mode.
m_componentViews[RootForce::ComponentType::RENDERABLE]->SetReceiveUpdates(false);
for (auto it : m_componentViews)
{
it.second->SetEditorInterface(this);
}
ui.treeView_entityOutliner->SetEditorInterface(this);
//Set up water tool
m_waterToolDockable = new WaterTool(this);
// Match signals with slots.
connect(ui.actionNew, SIGNAL(triggered()), this, SLOT(New()));
connect(ui.actionOpen_Project, SIGNAL(triggered()), this, SLOT(OpenProject()));
connect(ui.action_saveAs, SIGNAL(triggered()), this, SLOT(SaveAs()));
connect(ui.action_save, SIGNAL(triggered()), this, SLOT(Save()));
connect(ui.actionExit, SIGNAL(triggered()), this, SLOT(close()));
connect(ui.actionLog, SIGNAL(triggered()), Utils::GetInstance(), SLOT(Show()));
connect(ui.action_addEntity, SIGNAL(triggered()), this, SLOT(CreateEntity()));
connect(ui.action_removeEntity, SIGNAL(triggered()), this, SLOT(DestroyEntity()));
connect(ui.lineEdit_entityName, SIGNAL(editingFinished()), this, SLOT(RenameEntity()));
connect(ui.action_addRenderable, SIGNAL(triggered()), this, SLOT(AddRenderable()));
connect(ui.action_addPhysics, SIGNAL(triggered()), this, SLOT(AddPhysics()));
connect(ui.action_addWaterCollider, SIGNAL(triggered()), this, SLOT(AddWaterCollider()));
connect(ui.action_addScript, SIGNAL(triggered()), this, SLOT(AddScriptComponent()));
connect(ui.action_collisionResponder, SIGNAL(triggered()), this, SLOT(AddCollisionResponder()));
connect(ui.action_addParticle, SIGNAL(triggered()), this, SLOT(AddParticleComponent()));
connect(ui.actionPlay, SIGNAL(triggered()), this, SLOT(Play()));
connect(ui.pushButton_translateMode, SIGNAL(clicked()), this, SLOT(SetTranslateTool()));
connect(ui.pushButton_rotateMode, SIGNAL(clicked()), this, SLOT(SetRotateTool()));
connect(ui.pushButton_scaleMode, SIGNAL(clicked()), this, SLOT(SetResizeTool()));
connect(ui.comboBox_mode, SIGNAL(currentIndexChanged(int)), this, SLOT(ChangeToolMode(int)));
connect(ui.actionWaterSetting, SIGNAL(triggered()), m_waterToolDockable, SLOT(Show()));
connect(m_componentViews[RootForce::ComponentType::RENDERABLE], SIGNAL(deleted(ECS::Entity*)), this, SLOT(RemoveRenderable(ECS::Entity*)));
connect(m_componentViews[RootForce::ComponentType::COLLISION], SIGNAL(deleted(ECS::Entity*)), this, SLOT(RemovePhysics(ECS::Entity*)));
connect(m_componentViews[RootForce::ComponentType::WATERCOLLIDER], SIGNAL(deleted(ECS::Entity*)), this, SLOT(RemoveWaterCollider(ECS::Entity*)));
connect(m_componentViews[RootForce::ComponentType::SCRIPT], SIGNAL(deleted(ECS::Entity*)), this, SLOT(RemoveScriptComponent(ECS::Entity*)));
connect(m_componentViews[RootForce::ComponentType::COLLISIONRESPONDER], SIGNAL(deleted(ECS::Entity*)), this, SLOT(RemoveCollisionResponder(ECS::Entity*)));
// Setup Qt-to-SDL keymatching.
InitialiseKeymap();
ui.widget_canvas3D->SetEditorInterface(this);
// Set tool mode.
m_toolMode = ToolMode::LOCAL;
}
void MainWin::init() {
connect(Client::instance(), SIGNAL(networkCreated(NetworkId)), SLOT(clientNetworkCreated(NetworkId)));
connect(Client::instance(), SIGNAL(networkRemoved(NetworkId)), SLOT(clientNetworkRemoved(NetworkId)));
connect(Client::messageModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
SLOT(messagesInserted(const QModelIndex &, int, int)));
connect(GraphicalUi::contextMenuActionProvider(), SIGNAL(showChannelList(NetworkId)), SLOT(showChannelList(NetworkId)));
connect(GraphicalUi::contextMenuActionProvider(), SIGNAL(showIgnoreList(QString)), SLOT(showIgnoreList(QString)));
connect(Client::coreConnection(), SIGNAL(startCoreSetup(QVariantList)), SLOT(showCoreConfigWizard(QVariantList)));
connect(Client::coreConnection(), SIGNAL(connectionErrorPopup(QString)), SLOT(handleCoreConnectionError(QString)));
connect(Client::coreConnection(), SIGNAL(userAuthenticationRequired(CoreAccount *, bool *, QString)), SLOT(userAuthenticationRequired(CoreAccount *, bool *, QString)));
connect(Client::coreConnection(), SIGNAL(handleNoSslInClient(bool*)), SLOT(handleNoSslInClient(bool *)));
connect(Client::coreConnection(), SIGNAL(handleNoSslInCore(bool*)), SLOT(handleNoSslInCore(bool *)));
#ifdef HAVE_SSL
connect(Client::coreConnection(), SIGNAL(handleSslErrors(const QSslSocket *, bool *, bool *)), SLOT(handleSslErrors(const QSslSocket *, bool *, bool *)));
#endif
// Setup Dock Areas
setDockNestingEnabled(true);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
// Order is sometimes important
setupActions();
setupBufferWidget();
setupMenus();
setupTopicWidget();
setupNickWidget();
setupInputWidget();
setupChatMonitor();
setupStatusBar();
setupToolBars();
setupSystray();
setupTitleSetter();
setupHotList();
#ifndef HAVE_KDE
# ifdef HAVE_PHONON
QtUi::registerNotificationBackend(new PhononNotificationBackend(this));
# endif
# ifndef QT_NO_SYSTEMTRAYICON
QtUi::registerNotificationBackend(new SystrayNotificationBackend(this));
# endif
QtUi::registerNotificationBackend(new TaskbarNotificationBackend(this));
#else /* HAVE_KDE */
QtUi::registerNotificationBackend(new KNotificationBackend(this));
#endif /* HAVE_KDE */
#ifdef HAVE_INDICATEQT
QtUi::registerNotificationBackend(new IndicatorNotificationBackend(this));
#endif
// we assume that at this point, all configurable actions are defined!
QtUi::loadShortcuts();
connect(bufferWidget(), SIGNAL(currentChanged(BufferId)), SLOT(currentBufferChanged(BufferId)));
setDisconnectedState(); // Disable menus and stuff
#ifdef HAVE_KDE
setAutoSaveSettings();
#endif
// restore mainwin state
QtUiSettings s;
restoreStateFromSettings(s);
// restore locked state of docks
QtUi::actionCollection("General")->action("LockLayout")->setChecked(s.value("LockLayout", false).toBool());
CoreConnection *conn = Client::coreConnection();
if(!conn->connectToCore()) {
// No autoconnect selected (or no accounts)
showCoreConnectionDlg();
}
}
MainWindow::MainWindow(running_machine* machine, QWidget* parent) :
WindowQt(machine, nullptr),
m_historyIndex(0),
m_inputHistory()
{
setGeometry(300, 300, 1000, 600);
//
// The main frame and its input and log widgets
//
QFrame* mainWindowFrame = new QFrame(this);
// The input line
m_inputEdit = new QLineEdit(mainWindowFrame);
connect(m_inputEdit, &QLineEdit::returnPressed, this, &MainWindow::executeCommandSlot);
m_inputEdit->installEventFilter(this);
// The log view
m_consoleView = new DebuggerView(DVT_CONSOLE,
m_machine,
mainWindowFrame);
m_consoleView->setFocusPolicy(Qt::NoFocus);
m_consoleView->setPreferBottom(true);
QVBoxLayout* vLayout = new QVBoxLayout(mainWindowFrame);
vLayout->addWidget(m_consoleView);
vLayout->addWidget(m_inputEdit);
vLayout->setSpacing(3);
vLayout->setContentsMargins(4,0,4,2);
setCentralWidget(mainWindowFrame);
//
// Options Menu
//
// Create three commands
m_breakpointToggleAct = new QAction("Toggle Breakpoint at Cursor", this);
m_breakpointEnableAct = new QAction("Disable Breakpoint at Cursor", this);
m_runToCursorAct = new QAction("Run to Cursor", this);
m_breakpointToggleAct->setShortcut(Qt::Key_F9);
m_breakpointEnableAct->setShortcut(Qt::SHIFT + Qt::Key_F9);
m_runToCursorAct->setShortcut(Qt::Key_F4);
connect(m_breakpointToggleAct, &QAction::triggered, this, &MainWindow::toggleBreakpointAtCursor);
connect(m_breakpointEnableAct, &QAction::triggered, this, &MainWindow::enableBreakpointAtCursor);
connect(m_runToCursorAct, &QAction::triggered, this, &MainWindow::runToCursor);
// Right bar options
QActionGroup* rightBarGroup = new QActionGroup(this);
rightBarGroup->setObjectName("rightbargroup");
QAction* rightActRaw = new QAction("Raw Opcodes", this);
QAction* rightActEncrypted = new QAction("Encrypted Opcodes", this);
QAction* rightActComments = new QAction("Comments", this);
rightActRaw->setCheckable(true);
rightActEncrypted->setCheckable(true);
rightActComments->setCheckable(true);
rightActRaw->setActionGroup(rightBarGroup);
rightActEncrypted->setActionGroup(rightBarGroup);
rightActComments->setActionGroup(rightBarGroup);
rightActRaw->setShortcut(QKeySequence("Ctrl+R"));
rightActEncrypted->setShortcut(QKeySequence("Ctrl+E"));
rightActComments->setShortcut(QKeySequence("Ctrl+N"));
rightActRaw->setChecked(true);
connect(rightBarGroup, &QActionGroup::triggered, this, &MainWindow::rightBarChanged);
// Assemble the options menu
QMenu* optionsMenu = menuBar()->addMenu("&Options");
optionsMenu->addAction(m_breakpointToggleAct);
optionsMenu->addAction(m_breakpointEnableAct);
optionsMenu->addAction(m_runToCursorAct);
optionsMenu->addSeparator();
optionsMenu->addActions(rightBarGroup->actions());
//
// Images menu
//
image_interface_iterator imageIterTest(m_machine->root_device());
if (imageIterTest.first() != nullptr)
{
createImagesMenu();
}
//
// Dock window menu
//
QMenu* dockMenu = menuBar()->addMenu("Doc&ks");
setCorner(Qt::TopRightCorner, Qt::TopDockWidgetArea);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
// The processor dock
QDockWidget* cpuDock = new QDockWidget("processor", this);
cpuDock->setObjectName("cpudock");
cpuDock->setAllowedAreas(Qt::LeftDockWidgetArea);
m_procFrame = new ProcessorDockWidget(m_machine, cpuDock);
cpuDock->setWidget(dynamic_cast<QWidget*>(m_procFrame));
addDockWidget(Qt::LeftDockWidgetArea, cpuDock);
dockMenu->addAction(cpuDock->toggleViewAction());
// The disassembly dock
QDockWidget* dasmDock = new QDockWidget("dasm", this);
dasmDock->setObjectName("dasmdock");
dasmDock->setAllowedAreas(Qt::TopDockWidgetArea);
m_dasmFrame = new DasmDockWidget(m_machine, dasmDock);
dasmDock->setWidget(m_dasmFrame);
connect(m_dasmFrame->view(), &DebuggerView::updated, this, &MainWindow::dasmViewUpdated);
addDockWidget(Qt::TopDockWidgetArea, dasmDock);
dockMenu->addAction(dasmDock->toggleViewAction());
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
core(new QRCore()),
ui(new Ui::MainWindow),
webserverThread(core, this)
{
ui->setupUi(this);
doLock = false;
// Add custom font
QFontDatabase::addApplicationFont(":/new/prefix1/fonts/Anonymous Pro.ttf");
/*
* Toolbar
*/
// Hide central tab widget tabs
QTabBar *centralbar = ui->centralTabWidget->tabBar();
centralbar->setVisible(false);
// Adjust console lineedit
ui->consoleInputLineEdit->setTextMargins(10, 0, 0, 0);
/*
ui->consoleOutputTextEdit->setFont(QFont("Monospace", 8));
ui->consoleOutputTextEdit->setStyleSheet("background-color:black;color:gray;");
ui->consoleInputLineEdit->setStyleSheet("background-color:black;color:gray;");
*/
// Adjust text margins of consoleOutputTextEdit
QTextDocument *console_docu = ui->consoleOutputTextEdit->document();
console_docu->setDocumentMargin(10);
// Sepparator between back/forward and undo/redo buttons
QWidget* spacer4 = new QWidget();
spacer4->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
spacer4->setMinimumSize(10, 10);
ui->mainToolBar->insertWidget(ui->actionForward, spacer4);
// Popup menu on theme toolbar button
QToolButton *backButton = new QToolButton(this);
backButton->setIcon(QIcon(":/new/prefix1/img/icons/arrow_left.png"));
//backButton->setPopupMode(QToolButton::DelayedPopup);
ui->mainToolBar->insertWidget(ui->actionForward, backButton);
connect(backButton, SIGNAL(clicked()), this, SLOT(on_backButton_clicked()));
// Sepparator between undo/redo and goto lineEdit
QWidget* spacer3 = new QWidget();
spacer3->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
spacer3->setMinimumSize(20, 20);
spacer3->setMaximumWidth(300);
ui->mainToolBar->insertWidget(ui->actionShow_Hide_mainsidebar, spacer3);
// Omnibar LineEdit
this->omnibar = new Omnibar(this);
ui->mainToolBar->insertWidget(ui->actionShow_Hide_mainsidebar, this->omnibar);
// Add special sepparators to the toolbar that expand to separate groups of elements
QWidget* spacer2 = new QWidget();
spacer2->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
spacer2->setMinimumSize(10, 10);
spacer2->setMaximumWidth(300);
ui->mainToolBar->insertWidget(ui->actionShow_Hide_mainsidebar, spacer2);
// Sepparator between back/forward and undo/redo buttons
QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
spacer->setMinimumSize(20, 20);
ui->mainToolBar->addWidget(spacer);
// codeGraphics tool bar
this->graphicsBar = new GraphicsBar(this);
this->graphicsBar->setMovable(false);
addToolBarBreak(Qt::TopToolBarArea);
addToolBar(graphicsBar);
// Fix output panel font
QHelpers *help = new QHelpers();
help->normalizeFont(ui->consoleOutputTextEdit);
/*
* Dock Widgets
*/
// Add Memory DockWidget
this->memoryDock = new MemoryWidget(this);
this->dockList << this->memoryDock;
// To use in the future when we handle more than one memory views
// this->memoryDock->setAttribute(Qt::WA_DeleteOnClose);
// this->add_debug_output( QString::number(this->dockList.length()) );
// Add Sections dock panel
this->sectionsWidget = new SectionsWidget(this);
this->sectionsDock = new QDockWidget("Sections");
this->sectionsDock->setObjectName("sectionsDock");
this->sectionsDock->setAllowedAreas(Qt::AllDockWidgetAreas);
this->sectionsDock->setWidget(this->sectionsWidget);
this->sectionsWidget->setContentsMargins(0,0,0,5);
this->sectionsDock->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
this->sectionsDock->setContextMenuPolicy(Qt::CustomContextMenu);
connect(this->sectionsDock, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(showSectionsContextMenu(const QPoint &)));
// Add functions DockWidget
this->functionsDock = new FunctionsWidget(this);
// Add imports DockWidget
this->importsDock = new ImportsWidget(this);
// Add symbols DockWidget
this->symbolsDock = new SymbolsWidget(this);
// Add relocs DockWidget
this->relocsDock = new RelocsWidget(this);
// Add comments DockWidget
this->commentsDock = new CommentsWidget(this);
// Add strings DockWidget
this->stringsDock = new StringsWidget(this);
// Add flags DockWidget
this->flagsDock = new FlagsWidget(this);
// Add Notepad Dock panel
this->notepadDock = new Notepad(this);
//Add Dashboard Dock panel
this->dashboardDock = new Dashboard(this);
// Set up dock widgets default layout
restoreDocks();
hideAllDocks();
showDefaultDocks();
// Restore saved settings
this->readSettings();
// TODO: Allow the user to select this option visually in the GUI settings
// Adjust the DockWidget areas
setCorner( Qt::TopLeftCorner, Qt::LeftDockWidgetArea );
//setCorner( Qt::TopRightCorner, Qt::RightDockWidgetArea );
setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
//setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
this->flagsDock->flagsTreeWidget->clear();
// Set omnibar completer for flags
this->omnibar->setupCompleter();
// Set console output context menu
ui->consoleOutputTextEdit->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->consoleOutputTextEdit, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(showConsoleContextMenu(const QPoint &)));
// Hide dummy columns so we can reorder the rest
hideDummyColumns();
// Setup and hide sidebar by default
this->sideBar = new SideBar(this);
this->sidebar_action = ui->sideToolBar->addWidget(this->sideBar);
ui->sideToolBar->hide();
// Show dashboard by default
this->dashboardDock->raise();
//qDebug() << "FOLDER: " << QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
/*
* Some global shortcuts
*/
// Period goes to command entry
QShortcut* cmd_shortcut = new QShortcut(QKeySequence(Qt::Key_Period), this);
connect(cmd_shortcut, SIGNAL(activated()), ui->consoleInputLineEdit, SLOT(setFocus()));
// G and S goes to goto entry
QShortcut* goto_shortcut = new QShortcut(QKeySequence(Qt::Key_G), this);
connect(goto_shortcut, SIGNAL(activated()), this->omnibar, SLOT(setFocus()));
QShortcut* seek_shortcut = new QShortcut(QKeySequence(Qt::Key_S), this);
connect(seek_shortcut, SIGNAL(activated()), this->omnibar, SLOT(setFocus()));
// : goes to goto entry
QShortcut* commands_shortcut = new QShortcut(QKeySequence(Qt::Key_Colon), this);
connect(commands_shortcut, SIGNAL(activated()), this->omnibar, SLOT(showCommands()));
connect(&webserverThread, SIGNAL(finished()), this, SLOT(webserverThreadFinished()));
}
Window::Window(QWidget* parent) :
QMainWindow(parent)
{
setObjectName("ChatWindow");
Settings::getInstance().load();
connect(&Settings::getInstance(), &Settings::dataChanged, this, &Window::applySettings);
QToolBar* toolbar = new QToolBar(this);
toolbar->setIconSize(QSize(24, 24));
toolbar->setFloatable(false);
toolbar->setContextMenuPolicy(Qt::PreventContextMenu);
addToolBar(toolbar);
//QAction* refreshAction = toolbar->addAction(QIcon(":/icons/refresh.png"), "refresh");
//connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshPlanets()));
QDockWidget* inputDock = new QDockWidget(this);
inputDock->setObjectName("Input dock");
inputDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
inputDock->setTitleBarWidget(new QWidget(inputDock));
inputDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::BottomDockWidgetArea, inputDock);
QWidget* inputDockWidget = new QWidget(inputDock);
QHBoxLayout* inputDockWidgetLayout = new QHBoxLayout(inputDockWidget);
nickLabel = new QLabel(inputDockWidget);
nickLabel->hide();
inputLine = new QLineEdit(inputDockWidget);
connect(inputLine, &QLineEdit::returnPressed, this, &Window::sendMessage);
inputDockWidgetLayout->addWidget(nickLabel);
inputDockWidgetLayout->addWidget(inputLine);
inputDockWidgetLayout->setContentsMargins(2, 2, 2, 6);
inputDockWidget->setLayout(inputDockWidgetLayout);
inputDock->setFixedHeight(inputDock->height());
inputDock->setWidget(inputDockWidget);
QDockWidget* tabDock = new QDockWidget(this);
tabDock->setObjectName("Tab dock");
tabDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
tabDock->setTitleBarWidget(new QWidget(tabDock));
tabDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::LeftDockWidgetArea, tabDock);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
tabTree = new TabTree(tabDock, 100);
tabTree->setHeaderLabel("Chats");
tabTree->setIndentation(8);
tabTree->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
tabTree->setMinimumWidth(1);
tabTree->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
tabDock->setWidget(tabTree);
tabTree->setContextMenuPolicy(Qt::CustomContextMenu);
connect(tabTree, &QTreeWidget::itemSelectionChanged, this, &Window::tabSelected);
connect(tabTree, &QTreeWidget::customContextMenuRequested, this, &Window::showTabTreeContextMenu);
QAction* connectAction = new QAction(QIcon(":/icons/connect.png"), "Connect", toolbar);
QAction* disconnectAction = new QAction(QIcon(":/icons/disconnect.png"), "Disconnect", toolbar);
QAction* settingsAction = toolbar->addAction(QIcon(":/icons/settings.png"), "Settings");
connect(connectAction, &QAction::triggered, this, &Window::connectToServer);
connect(disconnectAction, &QAction::triggered, this, &Window::disconnectFromServer);
connect(settingsAction, &QAction::triggered, this, &Window::showSettingsDialog);
toolbar->addActions(QList<QAction*>() << connectAction << disconnectAction << settingsAction);
serverTab = new QTreeWidgetItem(tabTree, QStringList() << "IRC Server");
tabTree->addTopLevelItem(serverTab);
userDock = new QDockWidget(this);
userDock->setObjectName("User dock");
userDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
userDock->setTitleBarWidget(new QWidget(userDock));
userDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::RightDockWidgetArea, userDock);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
userTree = new UserTree(userDock, 100);
userTree->setItemsExpandable(false);
userTree->setIndentation(8);
userTree->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
userTree->setMinimumWidth(1);
userTree->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
userDock->setWidget(userTree);
connect(userTree, &UserTree::privateActionTriggered, this, &Window::startPrivate);
topicDock = new QDockWidget(this);
topicDock->setObjectName("Topic dock");
topicDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
topicDock->setTitleBarWidget(new QWidget(topicDock));
topicDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::TopDockWidgetArea, topicDock);
topicLine = new TopicLabel(topicDock);
topicDock->setWidget(topicLine);
QMainWindow* pagesWindow = new QMainWindow(0);
pages = new QStackedWidget(pagesWindow);
serverPage = new ServerPage(serverTab, tabTree);
connect(serverPage, &ServerPage::connectActionTriggered, this, &Window::connectToServer);
connect(serverPage, &ServerPage::disconnectActionTriggered, this, &Window::disconnectFromServer);
pagesWindow->setCentralWidget(pages);
pages->addWidget(serverPage);
setCentralWidget(pagesWindow);
tabTree->setItemSelected(serverTab, true);
autojoinTimer = new QTimer(this);
autojoinTimer->setSingleShot(true);
connect(autojoinTimer, &QTimer::timeout, this, &Window::joinChannels);
applySettings();
ircClient->setVersion(QString("%1 %2 by %3; build date: %4").arg(MainWindow::name).arg(MainWindow::version).arg(MainWindow::author).arg(MainWindow::buildDate));
connect(ircClient, &IrcClient::IrcClient::notice, serverPage, &ServerPage::notice);
connect(ircClient, &IrcClient::IrcClient::serverResponse, serverPage, &ServerPage::serverResponse);
connect(ircClient, &IrcClient::IrcClient::ctcpRequest, serverPage, &ServerPage::ctcpRequest);
connect(ircClient, &IrcClient::IrcClient::ctcpReply, serverPage, &ServerPage::ctcpReply);
connect(ircClient, &IrcClient::IrcClient::quit, serverPage, &ServerPage::quit);
connect(ircClient, &IrcClient::IrcClient::connecting, serverPage, &ServerPage::connecting);
connect(ircClient, &IrcClient::IrcClient::disconnected, serverPage, &ServerPage::disconnected);
connect(ircClient, &IrcClient::IrcClient::userModeChanged, serverPage, &ServerPage::userModeChanged);
connect(ircClient, &IrcClient::IrcClient::join, this, &Window::joinedChannel);
connect(ircClient, &IrcClient::IrcClient::connected, this, &Window::connected);
connect(ircClient, &IrcClient::IrcClient::privateMessage, this, &Window::routePrivateMessage);
connect(ircClient, &IrcClient::IrcClient::action, this, &Window::routePrivateAction);
connect(ircClient, &IrcClient::IrcClient::nickChange, nickLabel, &QLabel::setText);
connect(ircClient, &IrcClient::IrcClient::connected, nickLabel, &QLabel::show);
connect(ircClient, &IrcClient::IrcClient::disconnected, nickLabel, &QLabel::hide);
if (Settings::getInstance().getAutoConnect()) {
connectToServer();
}
::Settings::loadWindow(this);
}
void mainWindow::createDocks()
{
Monitor = new monitor();
setCentralWidget(Monitor);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::BottomDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
setDockOptions(QMainWindow::ForceTabbedDocks|QMainWindow::VerticalTabs);
/////////
/// Create and dock the Log window
///////////////////////////
log = new logWindow();
showStartupMessage();
QDockWidget *log_dock = new QDockWidget(tr("FoldWatcher Log"), this);
log_dock->setWidget(log);
log_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, log_dock);
/////////
/// Create and dock the FAHLog window
///////////////////////////
fahlog_log = new logWindow();
QDockWidget *fahlog_dock = new QDockWidget(tr("FAHlog.txt"), this);
fahlog_dock->setWidget(fahlog_log);
fahlog_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, fahlog_dock);
/////////
/// Create and dock the Clients' List window
///////////////////////////
clients = new clientList();
QDockWidget *clients_dock = new QDockWidget(tr("Clients"), this);
clients_dock->setWidget(clients);
clients_dock->setAllowedAreas(Qt::BottomDockWidgetArea);
addDockWidget(Qt::BottomDockWidgetArea, clients_dock);
tabifyDockWidget(clients_dock, log_dock);
/////////
/// Create and dock the Information window
///////////////////////////
info = new proteinInfo();
QDockWidget *info_dock = new QDockWidget(tr("Protein information"), this);
info_dock->setWidget(info);
info_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, info_dock);
/////////
/// Create and dock the Team Stats window
///////////////////////////
TeamStats = new teamStats();
QDockWidget *team_dock = new QDockWidget(tr("Team Statistics"), this);
team_dock->setWidget(TeamStats);
team_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, team_dock);
/////////
/// Create and dock the Personal Stats window
///////////////////////////
PersonalStats = new personalStats();
QDockWidget *personal_dock = new QDockWidget(tr("Personal Statistics"), this);
personal_dock->setWidget(PersonalStats);
personal_dock->setAllowedAreas(Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, personal_dock);
/////////
/// Create and dock the Analog Clock window
///////////////////////////
analogClock = new AnalogClock();
QDockWidget *clock_dock = new QDockWidget(tr("Clock"), this);
clock_dock->setWidget(analogClock);
clock_dock->setAllowedAreas(Qt::LeftDockWidgetArea);
addDockWidget(Qt::LeftDockWidgetArea, clock_dock);
////////
/// Tabify those docks! (at last...)
////////////////////////////
// Right widget area
tabifyDockWidget(info_dock, personal_dock);
tabifyDockWidget(personal_dock, team_dock);
// Bottom widget area
tabifyDockWidget(clients_dock, fahlog_dock);
tabifyDockWidget(fahlog_dock, log_dock);
/////////
/// Create the "View" Menu
///////////////////////////
QMenu *logsMenu = new QMenu(tr("Logs"));
QMenu *statsMenu = new QMenu(tr("Stats"));
QMenu *widgetsMenu = new QMenu(tr("Widgets"));
logsMenu->addAction(log_dock->toggleViewAction());
logsMenu->addAction(fahlog_dock->toggleViewAction());
statsMenu->addAction(personal_dock->toggleViewAction());
statsMenu->addAction(team_dock->toggleViewAction());
widgetsMenu->addAction(clock_dock->toggleViewAction());
menuView->addMenu(logsMenu);
menuView->addMenu(statsMenu);
menuView->addMenu(widgetsMenu);
menuView->addSeparator();
menuView->addAction(clients_dock->toggleViewAction());
menuView->addAction(info_dock->toggleViewAction());
/////////
/// Create the Toggle-View Toolbar
///////////////////////////
toolbarLogs->addAction(clients_dock->toggleViewAction());
toolbarLogs->addSeparator();
toolbarLogs->addAction(log_dock->toggleViewAction());
toolbarLogs->addAction(fahlog_dock->toggleViewAction());
toolbarLogs->addSeparator();
toolbarLogs->addAction(info_dock->toggleViewAction());
toolbarLogs->addAction(personal_dock->toggleViewAction());
toolbarLogs->addAction(team_dock->toggleViewAction());
show();
}
MainWindow::MainWindow()
{
setWindowTitle( "BRDF Explorer" );
// create the parameter window
paramWnd = new ParameterWindow();
viewer3D = new Plot3DWidget( this->windowHandle(), paramWnd->getBRDFList() );
connect( paramWnd, SIGNAL(incidentDirectionChanged(float,float)), viewer3D, SLOT(incidentDirectionChanged(float,float)) );
connect( paramWnd, SIGNAL(graphParametersChanged(bool,bool)), viewer3D, SLOT(graphParametersChanged(bool,bool)) );
connect( paramWnd, SIGNAL(brdfListChanged(std::vector<brdfPackage>)), viewer3D, SLOT(brdfListChanged(std::vector<brdfPackage>)) );
plot3D = new ViewerWindow( viewer3D );
cartesianThetaV = new PlotCartesianWindow( paramWnd, THETA_V_PLOT );
cartesianThetaH = new PlotCartesianWindow( paramWnd, THETA_H_PLOT );
cartesianThetaD = new PlotCartesianWindow( paramWnd, THETA_D_PLOT );
cartesianAlbedo = new PlotCartesianWindow( paramWnd, ALBEDO_PLOT );
viewer2D = new PlotPolarWidget( this->windowHandle(), paramWnd->getBRDFList() );
connect( paramWnd, SIGNAL(incidentDirectionChanged(float,float)), viewer2D, SLOT(incidentDirectionChanged(float,float)) );
connect( paramWnd, SIGNAL(graphParametersChanged(bool,bool)), viewer2D, SLOT(graphParametersChanged(bool,bool)) );
connect( paramWnd, SIGNAL(brdfListChanged(std::vector<brdfPackage>)), viewer2D, SLOT(brdfListChanged(std::vector<brdfPackage>)) );
polarPlot = new ViewerWindow(viewer2D);
viewerSphere = new LitSphereWindow( paramWnd );
ibl = new IBLWindow( paramWnd );
imageSlice = new ImageSliceWindow( paramWnd );
ShowingDockWidget* Plot3DWidget = new ShowingDockWidget("3D Plot", this);
Plot3DWidget->setWidget( plot3D );
addDockWidget( Qt::RightDockWidgetArea, Plot3DWidget );
ShowingDockWidget* paramsWidget = new ShowingDockWidget(tr("BRDF Parameters"), this);
paramsWidget->setWidget( paramWnd );
addDockWidget( Qt::LeftDockWidgetArea, paramsWidget );
ShowingDockWidget* PlotPolarWidget = new ShowingDockWidget(tr("Polar Plot"), this);
PlotPolarWidget->setWidget( polarPlot );
addDockWidget( Qt::RightDockWidgetArea, PlotPolarWidget );
ShowingDockWidget* thetaVWidget = new ShowingDockWidget(tr("Theta V"), this);
thetaVWidget->setWidget( cartesianThetaV );
addDockWidget( Qt::RightDockWidgetArea, thetaVWidget );
ShowingDockWidget* thetaHWidget = new ShowingDockWidget(tr("Theta H"), this);
thetaHWidget->setWidget( cartesianThetaH );
addDockWidget( Qt::RightDockWidgetArea, thetaHWidget );
ShowingDockWidget* thetaDWidget = new ShowingDockWidget(tr("Theta D"), this);
thetaDWidget->setWidget( cartesianThetaD );
addDockWidget( Qt::RightDockWidgetArea, thetaDWidget );
ShowingDockWidget* albedoWidget = new ShowingDockWidget(tr("Albedo"), this);
albedoWidget->setWidget( cartesianAlbedo );
addDockWidget( Qt::RightDockWidgetArea, albedoWidget );
tabifyDockWidget( Plot3DWidget, albedoWidget);
tabifyDockWidget( albedoWidget, thetaHWidget);
tabifyDockWidget( thetaHWidget, thetaDWidget );
tabifyDockWidget( thetaDWidget, thetaVWidget );
tabifyDockWidget( thetaVWidget, PlotPolarWidget );
ShowingDockWidget* litSphereWidget = new ShowingDockWidget(tr("Lit Sphere"), this);
litSphereWidget->setWidget( viewerSphere );
addDockWidget( Qt::RightDockWidgetArea, litSphereWidget );
ShowingDockWidget* imageSliceWidget = new ShowingDockWidget(tr("Image Slice"), this);
imageSliceWidget->setWidget( imageSlice );
addDockWidget( Qt::RightDockWidgetArea, imageSliceWidget );
ShowingDockWidget* iblWidget = new ShowingDockWidget(tr("Lit Object"), this);
iblWidget->setWidget( ibl );
addDockWidget( Qt::RightDockWidgetArea, iblWidget );
tabifyDockWidget( imageSliceWidget, iblWidget );
tabifyDockWidget( iblWidget, litSphereWidget );
//tabifyDockWidget( litSphereWidget, imageSliceWidget );
setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
setCentralWidget( new QWidget() ); // dummy central widget
centralWidget()->hide();
QMenu* fileMenu = menuBar()->addMenu(tr("&File"));
QAction* openBRDF = fileMenu->addAction( "Open BRDF..." );
openBRDF->setShortcut( QKeySequence("Ctrl+O") );
connect( openBRDF, SIGNAL(triggered()), paramWnd, SLOT(openBRDFFromFile()) );
fileMenu->addAction( "&Quit", this, SLOT(close()), QKeySequence("Ctrl+Q") );
QMenu* utilMenu = menuBar()->addMenu(tr("&Utilities"));
QAction* reloadAuxShaders = utilMenu->addAction( "Reload Auxiliary Shaders" );
connect( reloadAuxShaders, SIGNAL(triggered()), ibl->getWidget(), SLOT(reloadAuxShaders()) );
QMenu* helpMenu = menuBar()->addMenu(tr("&Help"));
QAction* helpAbout = helpMenu->addAction( "About..." );
connect( helpAbout, SIGNAL(triggered()), this, SLOT(about()) );
// make sure everything has the correct incident direction param values at the start
paramWnd->emitIncidentDirectionChanged();
}
MainWindow::MainWindow()
{
//QTime t = QTime::currentTime();
#ifndef KTIKZ_USE_KDE
m_aboutDialog = 0;
m_assistantController = 0;
#endif
m_configDialog = 0;
m_isModifiedExternally = false;
m_insertAction = 0;
s_mainWindowList.append(this);
#ifndef KTIKZ_USE_KDE
QStringList themeSearchPaths;
themeSearchPaths << QDir::homePath() + QLatin1String("/.local/share/icons/");
themeSearchPaths << QIcon::themeSearchPaths();
QIcon::setThemeSearchPaths(themeSearchPaths);
#endif
setAttribute(Qt::WA_DeleteOnClose);
#ifdef KTIKZ_USE_KDE
setObjectName(QLatin1String("ktikz#"));
setWindowIcon(KIcon(QLatin1String("ktikz")));
Action::setActionCollection(actionCollection());
#else
setObjectName(QLatin1String("qtikz#") + QString::number(s_mainWindowList.size()));
setWindowIcon(QIcon(QLatin1String(":/icons/qtikz-22.png")));
#endif
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
//qCritical() << t.msecsTo(QTime::currentTime());
m_tikzPreviewController = new TikzPreviewController(this);
//qCritical() << "TikzPreviewController" << t.msecsTo(QTime::currentTime());
m_tikzEditorView = new TikzEditorView(this);
//qCritical() << "TikzEditorView" << t.msecsTo(QTime::currentTime());
m_commandInserter = new TikzCommandInserter(this);
m_tikzHighlighter = new TikzHighlighter(m_tikzEditorView->editor()->document());
m_userCommandInserter = new UserCommandInserter(this);
QWidget *mainWidget = new QWidget(this);
QVBoxLayout *mainLayout = new QVBoxLayout(mainWidget);
mainLayout->setSpacing(0);
mainLayout->setMargin(0);
mainLayout->addWidget(m_tikzPreviewController->templateWidget());
mainLayout->addWidget(m_tikzEditorView);
m_logDock = new QDockWidget(this);
m_logDock->setObjectName(QLatin1String("LogDock"));
m_logDock->setAllowedAreas(Qt::AllDockWidgetAreas);
m_logDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
m_logDock->setWindowTitle(tr("&Messages"));
addDockWidget(Qt::BottomDockWidgetArea, m_logDock);
m_logTextEdit = new LogTextEdit;
m_logTextEdit->setWhatsThis(tr("<p>The messages produced by "
"LaTeX are shown here. If your TikZ code contains errors, "
"then a red border will appear and the errors will be "
"highlighted.</p>"));
m_logDock->setWidget(m_logTextEdit);
m_previewDock = new QDockWidget(this);
m_previewDock->setObjectName(QLatin1String("PreviewDock"));
m_previewDock->setAllowedAreas(Qt::AllDockWidgetAreas);
m_previewDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
m_previewDock->setWindowTitle(tr("Previe&w"));
m_previewDock->setWidget(m_tikzPreviewController->tikzPreview());
addDockWidget(Qt::RightDockWidgetArea, m_previewDock);
setCentralWidget(mainWidget);
createActions();
#ifndef KTIKZ_USE_KDE
createToolBars(); // run first in order to be able to add file/editToolBar->toggleViewAction() to the menu
createMenus();
#endif
//qCritical() << "createMenus" << t.msecsTo(QTime::currentTime());
createCommandInsertWidget(); // must happen after createMenus and before readSettings
createStatusBar();
#ifdef KTIKZ_USE_KDE
setupGUI(ToolBar | Keys | StatusBar | Save);
setXMLFile(QLatin1String("ktikzui.rc"));
createGUI();
guiFactory()->addClient(this);
#endif
setTabOrder(m_tikzPreviewController->templateWidget()->lastTabOrderWidget(), m_tikzEditorView->editor());
connect(m_commandInserter, SIGNAL(showStatusMessage(QString,int)),
statusBar(), SLOT(showMessage(QString,int)));
connect(m_tikzEditorView, SIGNAL(modificationChanged(bool)),
this, SLOT(setDocumentModified(bool)));
connect(m_tikzEditorView, SIGNAL(cursorPositionChanged(int,int)),
this, SLOT(showCursorPosition(int,int)));
connect(m_tikzEditorView, SIGNAL(showStatusMessage(QString,int)),
statusBar(), SLOT(showMessage(QString,int)));
connect(m_tikzEditorView, SIGNAL(focusIn()),
this, SLOT(checkForFileChanges()));
connect(m_tikzEditorView, SIGNAL(focusOut()),
this, SLOT(saveLastInternalModifiedDateTime()));
connect(m_tikzPreviewController, SIGNAL(updateLog(QString,bool)),
m_logTextEdit, SLOT(updateLog(QString,bool)));
connect(m_tikzPreviewController, SIGNAL(appendLog(QString,bool)),
m_logTextEdit, SLOT(appendLog(QString,bool)));
connect(m_tikzPreviewController, SIGNAL(showMouseCoordinates(qreal,qreal,int,int)),
this, SLOT(showMouseCoordinates(qreal,qreal,int,int)));
connect(m_userCommandInserter, SIGNAL(updateCompleter()),
this, SLOT(updateCompleter()));
readSettings(); // must be run after defining tikzController and tikzHighlighter, and after creating the toolbars, and after the connects
//qCritical() << "readSettings()" << t.msecsTo(QTime::currentTime());
setCurrentUrl(Url());
setDocumentModified(false);
saveLastInternalModifiedDateTime();
m_tikzEditorView->editor()->setFocus();
// delayed initialization
// QTimer::singleShot(0, this, SLOT(init())); // this causes flicker at startup and init() is not executed in a separate thread anyway :(
init();
//qCritical() << "mainwindow" << t.msecsTo(QTime::currentTime());
}
MainWindow::MainWindow():
QMainWindow(),
m_ui(new Ui::MainWindow),
m_chdkptp(new ChdkPtpManager)
{
m_ui->setupUi(this);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
// http://qt-project.org/forums/viewthread/2884
qRegisterMetaType<CameraList>("CameraList");
// List of cameras
m_ui->camerasTableWidget->setHorizontalHeaderLabels({tr("Index"), tr("Bus/Device"), tr("Serial Number")});
connect(m_ui->actionReloadCameras, SIGNAL(triggered()), this, SLOT(slotReloadCameras()));
// Shooting process
connect(m_ui->actionShoot, SIGNAL(triggered()), this, SLOT(slotStartShooting()));
// Turn off all cameras
connect(m_ui->actionShutdownAll, SIGNAL(triggered()), this, SLOT(slotShutdownAll()));
// Check propsets
connect(m_ui->actionDiagnose, SIGNAL(triggered()), this, SLOT(slotDiagnose()));
connect(m_ui->actionConfigureStaticProps, SIGNAL(triggered()), this, SLOT(slotConfigureStaticProps()));
// Hightlight camera
connect(m_ui->camerasTableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem*)), this, SLOT(slotCameraDoubleClicked(QTableWidgetItem*)));
connect(&m_listCamerasWatcher, SIGNAL(finished()), this, SLOT(slotListCamerasReady()));
// Set up Tv slider
// TBD: verify if all these Tv values are supported on Canon PowerShot A1400
QStringList tvValues;
for (int tv96 = -576; tv96 <= 960; tv96 += 32) {
double tvSec = pow(2, static_cast<double>(tv96) / (-96.0));
if (tv96 <= 0)
tvValues << tr("%1 s").arg(tvSec);
else
tvValues << tr("1/%1 s").arg(1.0 / tvSec);
}
m_ui->tvSlider->setValues(tvValues);
m_ui->tvSlider->setSliderValue(32); // 1/25.4
// Set up Av slider
// TBD: verify if all these Av values are supported on Canon PowerShot A1400
QStringList avValues;
for (int av96 = 0; av96 <= 960; av96 += 32) {
double fn = pow(2, static_cast<double>(av96) / 96.0 / 2.0);
avValues << tr("f/%1").arg(QString::number(fn, 'f', 1));
}
m_ui->avSlider->setValues(avValues);
m_ui->avSlider->setSliderValue(9); // f/2.8
// Set up Sv slider
// TBD: verify if all these Sv values are supported on Canon PowerShot A1400
QStringList svValues;
for (int sv96 = 384; sv96 <= 960; sv96 += 32) {
double iso = 3.125 * pow(2, static_cast<double>(sv96) / 96.0);
svValues << tr("ISO %1").arg(QString::number(iso, 'f', 0));
}
m_ui->isoSlider->setValues(svValues);
m_ui->isoSlider->setSliderValue(3); // ISO 100
}
