void LayerModel::setVisible(bool v, int id)
{
m_layers.at(id)->visible = v;
feather::qml::command::set_layer_visible(v,id);
layoutChanged();
}
void MediaRoutingView::MessageReceived(
BMessage* message)
{
D_METHOD(("MediaRoutingView::MessageReceived()\n"));
switch (message->what)
{
case B_MEDIA_NODE_CREATED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(B_MEDIA_NODE_CREATED)\n"));
type_code type;
int32 count;
if (message->GetInfo("media_node_id", &type, &count) == B_OK)
{
for(int32 n = 0; n < count; n++)
{
int32 id;
if (message->FindInt32("media_node_id", n, &id) == B_OK)
{
// [e.moon 8dec99] allow for existing panel
MediaNodePanel* panel;
if(_findPanelFor(id, &panel) < B_OK)
_addPanelFor(id, BPoint(5.0, 5.0));
}
}
}
break;
}
case B_MEDIA_NODE_DELETED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(B_MEDIA_NODE_DELETED)\n"));
type_code type;
int32 count;
if (message->GetInfo("media_node_id", &type, &count) == B_OK)
{
for (int32 n = 0; n < count; n++)
{
int32 id;
if (message->FindInt32("media_node_id", n, &id) == B_OK)
{
_removePanelFor(id);
}
}
}
break;
}
case B_MEDIA_CONNECTION_MADE:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(B_MEDIA_CONNECTION_MADE)\n"));
type_code type;
int32 count;
if (message->GetInfo("output", &type, &count) == B_OK)
{
for (int32 n = 0; n < count; n++)
{
media_output output;
const void *data;
ssize_t dataSize;
if (message->FindData("output", B_RAW_TYPE, n, &data, &dataSize) == B_OK)
{
output = *reinterpret_cast<const media_output *>(data);
Connection connection;
if (manager->findConnection(output.node.node, output.source, &connection) == B_OK)
{
_addWireFor(connection);
}
}
}
}
break;
}
case B_MEDIA_CONNECTION_BROKEN:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(B_MEDIA_CONNECTION_BROKEN)\n"));
type_code type;
int32 count;
if (message->GetInfo("__connection_id", &type, &count) == B_OK)
{
for (int32 n = 0; n < count; n++)
{
int32 id;
if (message->FindInt32("__connection_id", n, &id) == B_OK)
{
_removeWireFor(id);
}
}
}
break;
}
case B_MEDIA_FORMAT_CHANGED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(B_MEDIA_FORMAT_CHANGED)\n"));
media_node_id nodeID;
if(message->FindInt32("__source_node_id", &nodeID) < B_OK)
break;
uint32 connectionID;
if(message->FindInt32("__connection_id", (int32*)&connectionID) < B_OK)
break;
media_source* source;
ssize_t dataSize;
if(message->FindData("be:source", B_RAW_TYPE, (const void**)&source, &dataSize) < B_OK)
break;
MediaWire* wire;
if(_findWireFor(connectionID, &wire) == B_OK) {
// copy new connection data
manager->findConnection(nodeID, *source, &wire->connection);
}
break;
}
case M_CLEANUP_REQUESTED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_M_CLEANUP_REQUESTED)\n"));
cleanUp();
break;
}
case M_SELECT_ALL:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_SELECT_ALL)\n"));
selectAll(DiagramItem::M_BOX);
break;
}
case M_DELETE_SELECTION:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_DELETE_SELECTION)\n"));
_deleteSelection();
break;
}
case M_NODE_CHANGE_CYCLING:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_NODE_CYCLING_CHANGED)\n"));
bool cycle;
if (message->FindBool("cycle", &cycle) == B_OK)
{
_changeCyclingForSelection(cycle);
}
break;
}
case M_NODE_CHANGE_RUN_MODE:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_NODE_RUNMODE_CHANGED)\n"));
int32 mode;
if (message->FindInt32("run_mode", &mode) == B_OK)
{
_changeRunModeForSelection(static_cast<uint32>(mode));
}
break;
}
case M_LAYOUT_CHANGED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_LAYOUT_CHANGED)\n"));
layout_t layout;
if (message->FindInt32("layout", (int32*)&layout) == B_OK)
{
if (layout != m_layout)
{
layoutChanged(layout);
updateDataRect();
Invalidate();
}
}
break;
}
case M_NODE_START_TIME_SOURCE:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_NODE_START_TIME_SOURCE)\n"));
int32 id;
if(message->FindInt32("nodeID", &id) < B_OK)
break;
NodeRef* ref;
if(manager->getNodeRef(id, &ref) < B_OK)
break;
bigtime_t when = system_time();
status_t err = manager->roster->StartTimeSource(ref->node(), when);
if(err < B_OK) {
PRINT((
"! StartTimeSource(%ld): '%s'\n",
ref->id(), strerror(err)));
}
break;
}
case M_NODE_STOP_TIME_SOURCE:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_NODE_STOP_TIME_SOURCE)\n"));
int32 id;
if(message->FindInt32("nodeID", &id) < B_OK)
break;
NodeRef* ref;
if(manager->getNodeRef(id, &ref) < B_OK)
break;
bigtime_t when = system_time();
status_t err = manager->roster->StopTimeSource(ref->node(), when);
if(err < B_OK) {
PRINT((
"! StopTimeSource(%ld): '%s'\n",
ref->id(), strerror(err)));
}
break;
}
case M_NODE_TWEAK_PARAMETERS: {
D_MESSAGE((" -> M_NODE_TWEAK_PARAMETERS\n"));
_openParameterWindowsForSelection();
break;
}
case M_NODE_START_CONTROL_PANEL: {
D_MESSAGE((" -> M_NODE_START_CONTROL_PANEL\n"));
_startControlPanelsForSelection();
break;
}
case M_GROUP_SET_LOCKED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(M_GROUP_SET_LOCKED)\n"));
int32 groupID;
if(message->FindInt32("groupID", &groupID) < B_OK)
break;
bool locked;
if(message->FindBool("locked", &locked) < B_OK)
break;
NodeGroup* group;
if(manager->findGroup(groupID, &group) < B_OK)
break;
uint32 f = locked ?
group->groupFlags() | NodeGroup::GROUP_LOCKED :
group->groupFlags() & ~NodeGroup::GROUP_LOCKED;
group->setGroupFlags(f);
break;
}
case M_BROADCAST_SELECTION: {
D_MESSAGE((" -> M_BROADCAST_SELECTION\n"));
_broadcastSelection();
break;
}
case InfoWindowManager::M_INFO_WINDOW_REQUESTED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(InfoView::M_INFO_WINDOW_REQUESTED)\n"));
type_code type;
int32 count;
if (message->GetInfo("input", &type, &count) == B_OK)
{
for (int32 i = 0; i < count; i++)
{
media_input input;
const void *data;
ssize_t dataSize;
if (message->FindData("input", B_RAW_TYPE, i, &data, &dataSize) == B_OK)
{
input = *reinterpret_cast<const media_input *>(data);
InfoWindowManager *manager = InfoWindowManager::Instance();
if (manager && manager->Lock()) {
manager->openWindowFor(input);
manager->Unlock();
}
}
}
}
else if (message->GetInfo("output", &type, &count) == B_OK)
{
for (int32 i = 0; i < count; i++)
{
media_output output;
const void *data;
ssize_t dataSize;
if (message->FindData("output", B_RAW_TYPE, i, &data, &dataSize) == B_OK)
{
output = *reinterpret_cast<const media_output *>(data);
InfoWindowManager *manager = InfoWindowManager::Instance();
if (manager && manager->Lock()) {
manager->openWindowFor(output);
manager->Unlock();
}
}
}
}
else
{
_openInfoWindowsForSelection();
}
break;
}
case NodeManager::M_RELEASED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(NodeManager::M_RELEASED)\n"));
remove_observer(this, manager);
const_cast<RouteAppNodeManager*&>(manager) = 0;
// +++++ disable view!
break;
}
case NodeRef::M_RELEASED:
{
D_MESSAGE(("MediaRoutingView::MessageReceived(NodeRef::M_RELEASED)\n"));
// only relevant on shutdown; do nothing
break;
}
default:
{
DiagramView::MessageReceived(message);
}
}
}
void RPCConsole::setClientModel(ClientModel *model)
{
clientModel = model;
ui->trafficGraph->setClientModel(model);
if (model && clientModel->getPeerTableModel() && clientModel->getBanTableModel())
{
// Subscribe to information, replies, messages, errors
connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));
setNumBlocks(model->getNumBlocks());
connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));
setMasternodeCount(model->getMasternodeCountString());
connect(model, SIGNAL(strMasternodesChanged(QString)), this, SLOT(setMasternodeCount(QString)));
updateTrafficStats(model->getTotalBytesRecv(), model->getTotalBytesSent());
connect(model, SIGNAL(bytesChanged(quint64,quint64)), this, SLOT(updateTrafficStats(quint64, quint64)));
// set up peer table
ui->peerWidget->setModel(model->getPeerTableModel());
ui->peerWidget->verticalHeader()->hide();
ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->peerWidget->setSelectionMode(QAbstractItemView::SingleSelection);
ui->peerWidget->setContextMenuPolicy(Qt::CustomContextMenu);
ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH);
ui->peerWidget->setColumnWidth(PeerTableModel::Subversion, SUBVERSION_COLUMN_WIDTH);
ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);
// create context menu actions
QAction* disconnectAction = new QAction(tr("&Disconnect Node"), this);
QAction* banAction1h = new QAction(tr("Ban Node for") + " " + tr("1 &hour"), this);
QAction* banAction24h = new QAction(tr("Ban Node for") + " " + tr("1 &day"), this);
QAction* banAction7d = new QAction(tr("Ban Node for") + " " + tr("1 &week"), this);
QAction* banAction365d = new QAction(tr("Ban Node for") + " " + tr("1 &year"), this);
// create peer table context menu
peersTableContextMenu = new QMenu();
peersTableContextMenu->addAction(disconnectAction);
peersTableContextMenu->addAction(banAction1h);
peersTableContextMenu->addAction(banAction24h);
peersTableContextMenu->addAction(banAction7d);
peersTableContextMenu->addAction(banAction365d);
// Add a signal mapping to allow dynamic context menu arguments.
// We need to use int (instead of int64_t), because signal mapper only supports
// int or objects, which is okay because max bantime (1 year) is < int_max.
QSignalMapper* signalMapper = new QSignalMapper(this);
signalMapper->setMapping(banAction1h, 60*60);
signalMapper->setMapping(banAction24h, 60*60*24);
signalMapper->setMapping(banAction7d, 60*60*24*7);
signalMapper->setMapping(banAction365d, 60*60*24*365);
connect(banAction1h, SIGNAL(triggered()), signalMapper, SLOT(map()));
connect(banAction24h, SIGNAL(triggered()), signalMapper, SLOT(map()));
connect(banAction7d, SIGNAL(triggered()), signalMapper, SLOT(map()));
connect(banAction365d, SIGNAL(triggered()), signalMapper, SLOT(map()));
connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(banSelectedNode(int)));
// peer table context menu signals
connect(ui->peerWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showPeersTableContextMenu(const QPoint&)));
connect(disconnectAction, SIGNAL(triggered()), this, SLOT(disconnectSelectedNode()));
// peer table signal handling - update peer details when selecting new node
connect(ui->peerWidget->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
this, SLOT(peerSelected(const QItemSelection &, const QItemSelection &)));
// peer table signal handling - update peer details when new nodes are added to the model
connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this, SLOT(peerLayoutChanged()));
// set up ban table
ui->banlistWidget->setModel(model->getBanTableModel());
ui->banlistWidget->verticalHeader()->hide();
ui->banlistWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
ui->banlistWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->banlistWidget->setSelectionMode(QAbstractItemView::SingleSelection);
ui->banlistWidget->setContextMenuPolicy(Qt::CustomContextMenu);
ui->banlistWidget->setColumnWidth(BanTableModel::Address, BANSUBNET_COLUMN_WIDTH);
ui->banlistWidget->setColumnWidth(BanTableModel::Bantime, BANTIME_COLUMN_WIDTH);
ui->banlistWidget->horizontalHeader()->setStretchLastSection(true);
// create ban table context menu action
QAction* unbanAction = new QAction(tr("&Unban Node"), this);
// create ban table context menu
banTableContextMenu = new QMenu();
banTableContextMenu->addAction(unbanAction);
// ban table context menu signals
connect(ui->banlistWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showBanTableContextMenu(const QPoint&)));
connect(unbanAction, SIGNAL(triggered()), this, SLOT(unbanSelectedNode()));
// ban table signal handling - clear peer details when clicking a peer in the ban table
connect(ui->banlistWidget, SIGNAL(clicked(const QModelIndex&)), this, SLOT(clearSelectedNode()));
// ban table signal handling - ensure ban table is shown or hidden (if empty)
connect(model->getBanTableModel(), SIGNAL(layoutChanged()), this, SLOT(showOrHideBanTableIfRequired()));
showOrHideBanTableIfRequired();
// Provide initial values
ui->clientVersion->setText(model->formatFullVersion());
ui->clientName->setText(model->clientName());
ui->buildDate->setText(model->formatBuildDate());
ui->startupTime->setText(model->formatClientStartupTime());
setNumConnections(model->getNumConnections());
ui->isTestNet->setChecked(model->isTestNet());
}
void
InstructionListModel::clear() {
layoutAboutToBeChanged().emit();
insns_.clear();
layoutChanged().emit();
}
PointViewerMainWindow::PointViewerMainWindow(const QGLFormat& format)
: m_progressBar(0),
m_pointView(0),
m_shaderEditor(0),
m_helpDialog(0),
m_logTextView(0),
m_maxPointCount(200*1000*1000), // 200 million
m_geometries(0),
m_ipcServer(0),
m_hookManager(0)
{
setWindowTitle("Displaz");
setAcceptDrops(true);
m_helpDialog = new HelpDialog(this);
m_geometries = new GeometryCollection(this);
connect(m_geometries, SIGNAL(layoutChanged()), this, SLOT(updateTitle()));
connect(m_geometries, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(updateTitle()));
connect(m_geometries, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(updateTitle()));
connect(m_geometries, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(updateTitle()));
//--------------------------------------------------
// Set up file loader in a separate thread
//
// Some subtleties regarding qt thread usage are discussed here:
// http://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation
//
// Main point: each QObject has a thread affinity which determines which
// thread its slots will execute on, when called via a connected signal.
QThread* loaderThread = new QThread();
m_fileLoader = new FileLoader(m_maxPointCount);
m_fileLoader->moveToThread(loaderThread);
connect(loaderThread, SIGNAL(finished()), m_fileLoader, SLOT(deleteLater()));
connect(loaderThread, SIGNAL(finished()), loaderThread, SLOT(deleteLater()));
//connect(m_fileLoader, SIGNAL(finished()), this, SIGNAL(fileLoadFinished()));
connect(m_fileLoader, SIGNAL(geometryLoaded(std::shared_ptr<Geometry>, bool, bool)),
m_geometries, SLOT(addGeometry(std::shared_ptr<Geometry>, bool, bool)));
loaderThread->start();
//--------------------------------------------------
// Menus
menuBar()->setNativeMenuBar(false); // OS X doesn't activate the native menu bar under Qt5
// File menu
QMenu* fileMenu = menuBar()->addMenu(tr("&File"));
QAction* openAct = fileMenu->addAction(tr("&Open"));
openAct->setToolTip(tr("Open a data set"));
openAct->setShortcuts(QKeySequence::Open);
connect(openAct, SIGNAL(triggered()), this, SLOT(openFiles()));
QAction* addAct = fileMenu->addAction(tr("&Add"));
addAct->setToolTip(tr("Add a data set"));
connect(addAct, SIGNAL(triggered()), this, SLOT(addFiles()));
QAction* reloadAct = fileMenu->addAction(tr("&Reload"));
reloadAct->setStatusTip(tr("Reload point files from disk"));
reloadAct->setShortcut(Qt::Key_F5);
connect(reloadAct, SIGNAL(triggered()), this, SLOT(reloadFiles()));
fileMenu->addSeparator();
QAction* screenShotAct = fileMenu->addAction(tr("Scree&nshot"));
screenShotAct->setStatusTip(tr("Save screen shot of 3D window"));
screenShotAct->setShortcut(Qt::Key_F9);
connect(screenShotAct, SIGNAL(triggered()), this, SLOT(screenShot()));
fileMenu->addSeparator();
QAction* quitAct = fileMenu->addAction(tr("&Quit"));
quitAct->setStatusTip(tr("Exit the application"));
quitAct->setShortcuts(QKeySequence::Quit);
connect(quitAct, SIGNAL(triggered()), this, SLOT(close()));
// View menu
QMenu* viewMenu = menuBar()->addMenu(tr("&View"));
QAction* trackballMode = viewMenu->addAction(tr("Use &Trackball camera"));
trackballMode->setCheckable(true);
trackballMode->setChecked(false);
// Background sub-menu
QMenu* backMenu = viewMenu->addMenu(tr("Set &Background"));
QSignalMapper* mapper = new QSignalMapper(this);
// Selectable backgrounds (svg_names from SVG standard - see QColor docs)
const char* backgroundNames[] = {/* "Display Name", "svg_name", */
"Default", "#3C3232",
"Black", "black",
"Dark Grey", "dimgrey",
"Slate Grey", "#858C93",
"Light Grey", "lightgrey",
"White", "white" };
for(size_t i = 0; i < sizeof(backgroundNames)/sizeof(const char*); i+=2)
{
QAction* backgroundAct = backMenu->addAction(tr(backgroundNames[i]));
QPixmap pixmap(50,50);
QString colName = backgroundNames[i+1];
pixmap.fill(QColor(colName));
QIcon icon(pixmap);
backgroundAct->setIcon(icon);
mapper->setMapping(backgroundAct, colName);
connect(backgroundAct, SIGNAL(triggered()), mapper, SLOT(map()));
}
connect(mapper, SIGNAL(mapped(QString)),
this, SLOT(setBackground(QString)));
backMenu->addSeparator();
QAction* backgroundCustom = backMenu->addAction(tr("&Custom"));
connect(backgroundCustom, SIGNAL(triggered()),
this, SLOT(chooseBackground()));
// Check boxes for drawing various scene elements by category
viewMenu->addSeparator();
QAction* drawBoundingBoxes = viewMenu->addAction(tr("Draw Bounding bo&xes"));
drawBoundingBoxes->setCheckable(true);
drawBoundingBoxes->setChecked(true);
QAction* drawCursor = viewMenu->addAction(tr("Draw 3D &Cursor"));
drawCursor->setCheckable(true);
drawCursor->setChecked(true);
QAction* drawAxes = viewMenu->addAction(tr("Draw &Axes"));
drawAxes->setCheckable(true);
drawAxes->setChecked(true);
QAction* drawGrid = viewMenu->addAction(tr("Draw &Grid"));
drawGrid->setCheckable(true);
drawGrid->setChecked(false);
// Shader menu
QMenu* shaderMenu = menuBar()->addMenu(tr("&Shader"));
QAction* openShaderAct = shaderMenu->addAction(tr("&Open"));
openShaderAct->setToolTip(tr("Open a shader file"));
connect(openShaderAct, SIGNAL(triggered()), this, SLOT(openShaderFile()));
QAction* editShaderAct = shaderMenu->addAction(tr("&Edit"));
editShaderAct->setToolTip(tr("Open shader editor window"));
QAction* saveShaderAct = shaderMenu->addAction(tr("&Save"));
saveShaderAct->setToolTip(tr("Save current shader file"));
connect(saveShaderAct, SIGNAL(triggered()), this, SLOT(saveShaderFile()));
shaderMenu->addSeparator();
// Help menu
QMenu* helpMenu = menuBar()->addMenu(tr("&Help"));
QAction* helpAct = helpMenu->addAction(tr("User &Guide"));
connect(helpAct, SIGNAL(triggered()), this, SLOT(helpDialog()));
helpMenu->addSeparator();
QAction* aboutAct = helpMenu->addAction(tr("&About"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(aboutDialog()));
//--------------------------------------------------
// Point viewer
m_pointView = new View3D(m_geometries, format, this);
setCentralWidget(m_pointView);
connect(drawBoundingBoxes, SIGNAL(triggered()),
m_pointView, SLOT(toggleDrawBoundingBoxes()));
connect(drawCursor, SIGNAL(triggered()),
m_pointView, SLOT(toggleDrawCursor()));
connect(drawAxes, SIGNAL(triggered()),
m_pointView, SLOT(toggleDrawAxes()));
connect(drawGrid, SIGNAL(triggered()),
m_pointView, SLOT(toggleDrawGrid()));
connect(trackballMode, SIGNAL(triggered()),
m_pointView, SLOT(toggleCameraMode()));
connect(m_geometries, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(geometryRowsInserted(QModelIndex,int,int)));
//--------------------------------------------------
// Docked widgets
// Shader parameters UI
QDockWidget* shaderParamsDock = new QDockWidget(tr("Shader Parameters"), this);
shaderParamsDock->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetClosable);
QWidget* shaderParamsUI = new QWidget(shaderParamsDock);
shaderParamsDock->setWidget(shaderParamsUI);
m_pointView->setShaderParamsUIWidget(shaderParamsUI);
// Shader editor UI
QDockWidget* shaderEditorDock = new QDockWidget(tr("Shader Editor"), this);
shaderEditorDock->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetClosable |
QDockWidget::DockWidgetFloatable);
QWidget* shaderEditorUI = new QWidget(shaderEditorDock);
m_shaderEditor = new ShaderEditor(shaderEditorUI);
QGridLayout* shaderEditorLayout = new QGridLayout(shaderEditorUI);
shaderEditorLayout->setContentsMargins(2,2,2,2);
shaderEditorLayout->addWidget(m_shaderEditor, 0, 0, 1, 1);
connect(editShaderAct, SIGNAL(triggered()), shaderEditorDock, SLOT(show()));
shaderEditorDock->setWidget(shaderEditorUI);
shaderMenu->addAction(m_shaderEditor->compileAction());
connect(m_shaderEditor->compileAction(), SIGNAL(triggered()),
this, SLOT(compileShaderFile()));
// TODO: check if this is needed - test shader update functionality
//connect(m_shaderEditor, SIGNAL(sendShader(QString)),
// &m_pointView->shaderProgram(), SLOT(setShader(QString)));
// Log viewer UI
QDockWidget* logDock = new QDockWidget(tr("Log"), this);
logDock->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetClosable);
QWidget* logUI = new QWidget(logDock);
m_logTextView = new LogViewer(logUI);
m_logTextView->setReadOnly(true);
m_logTextView->setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse);
m_logTextView->connectLogger(&g_logger); // connect to global logger
m_progressBar = new QProgressBar(logUI);
m_progressBar->setRange(0,100);
m_progressBar->setValue(0);
m_progressBar->hide();
connect(m_fileLoader, SIGNAL(loadStepStarted(QString)),
this, SLOT(setProgressBarText(QString)));
connect(m_fileLoader, SIGNAL(loadProgress(int)),
m_progressBar, SLOT(setValue(int)));
connect(m_fileLoader, SIGNAL(resetProgress()),
m_progressBar, SLOT(hide()));
QVBoxLayout* logUILayout = new QVBoxLayout(logUI);
//logUILayout->setContentsMargins(2,2,2,2);
logUILayout->addWidget(m_logTextView);
logUILayout->addWidget(m_progressBar);
//m_logTextView->setLineWrapMode(QPlainTextEdit::NoWrap);
logDock->setWidget(logUI);
// Data set list UI
QDockWidget* dataSetDock = new QDockWidget(tr("Data Sets"), this);
dataSetDock->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetClosable |
QDockWidget::DockWidgetFloatable);
DataSetUI* dataSetUI = new DataSetUI(this);
dataSetDock->setWidget(dataSetUI);
QAbstractItemView* dataSetOverview = dataSetUI->view();
dataSetOverview->setModel(m_geometries);
connect(dataSetOverview, SIGNAL(doubleClicked(const QModelIndex&)),
m_pointView, SLOT(centerOnGeometry(const QModelIndex&)));
m_pointView->setSelectionModel(dataSetOverview->selectionModel());
// Set up docked widgets
addDockWidget(Qt::RightDockWidgetArea, shaderParamsDock);
addDockWidget(Qt::LeftDockWidgetArea, shaderEditorDock);
addDockWidget(Qt::RightDockWidgetArea, logDock);
addDockWidget(Qt::RightDockWidgetArea, dataSetDock);
tabifyDockWidget(logDock, dataSetDock);
logDock->raise();
shaderEditorDock->setVisible(false);
// Add dock widget toggles to view menu
viewMenu->addSeparator();
viewMenu->addAction(shaderParamsDock->toggleViewAction());
viewMenu->addAction(logDock->toggleViewAction());
viewMenu->addAction(dataSetDock->toggleViewAction());
// Create custom hook events from CLI at runtime
m_hookManager = new HookManager(this);
}
void QxtFlowViewPrivate::setModel(QAbstractItemModel * m)
{
if (model)
{
disconnect(this->model, SIGNAL(columnsAboutToBeInserted(const QModelIndex & , int , int)),
this, SLOT(columnsAboutToBeInserted(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(columnsAboutToBeRemoved(const QModelIndex & , int , int)),
this, SLOT(columnsAboutToBeRemoved(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(columnsInserted(const QModelIndex & , int , int)),
this, SLOT(columnsInserted(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(columnsRemoved(const QModelIndex & , int , int)),
this, SLOT(columnsRemoved(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(dataChanged(const QModelIndex & , const QModelIndex &)),
this, SLOT(dataChanged(const QModelIndex & , const QModelIndex &)));
disconnect(this->model, SIGNAL(headerDataChanged(Qt::Orientation , int , int)),
this, SLOT(headerDataChanged(Qt::Orientation , int , int)));
disconnect(this->model, SIGNAL(layoutAboutToBeChanged()),
this, SLOT(layoutAboutToBeChanged()));
disconnect(this->model, SIGNAL(layoutChanged()),
this, SLOT(layoutChanged()));
disconnect(this->model, SIGNAL(modelAboutToBeReset()),
this, SLOT(modelAboutToBeReset()));
disconnect(this->model, SIGNAL(modelReset()),
this, SLOT(modelReset()));
disconnect(this->model, SIGNAL(rowsAboutToBeInserted(const QModelIndex & , int , int)),
this, SLOT(rowsAboutToBeInserted(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex & , int , int)),
this, SLOT(rowsAboutToBeRemoved(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(rowsInserted(const QModelIndex & , int , int)),
this, SLOT(rowsInserted(const QModelIndex & , int , int)));
disconnect(this->model, SIGNAL(rowsRemoved(const QModelIndex & , int , int)),
this, SLOT(rowsRemoved(const QModelIndex & , int , int)));
}
model = m;
if (model)
{
rootindex = model->parent(QModelIndex());
connect(this->model, SIGNAL(columnsAboutToBeInserted(const QModelIndex & , int , int)),
this, SLOT(columnsAboutToBeInserted(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(columnsAboutToBeRemoved(const QModelIndex & , int , int)),
this, SLOT(columnsAboutToBeRemoved(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(columnsInserted(const QModelIndex & , int , int)),
this, SLOT(columnsInserted(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(columnsRemoved(const QModelIndex & , int , int)),
this, SLOT(columnsRemoved(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(dataChanged(const QModelIndex & , const QModelIndex &)),
this, SLOT(dataChanged(const QModelIndex & , const QModelIndex &)));
connect(this->model, SIGNAL(headerDataChanged(Qt::Orientation , int , int)),
this, SLOT(headerDataChanged(Qt::Orientation , int , int)));
connect(this->model, SIGNAL(layoutAboutToBeChanged()),
this, SLOT(layoutAboutToBeChanged()));
connect(this->model, SIGNAL(layoutChanged()),
this, SLOT(layoutChanged()));
connect(this->model, SIGNAL(modelAboutToBeReset()),
this, SLOT(modelAboutToBeReset()));
connect(this->model, SIGNAL(modelReset()),
this, SLOT(modelReset()));
connect(this->model, SIGNAL(rowsAboutToBeInserted(const QModelIndex & , int , int)),
this, SLOT(rowsAboutToBeInserted(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex & , int , int)),
this, SLOT(rowsAboutToBeRemoved(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(rowsInserted(const QModelIndex & , int , int)),
this, SLOT(rowsInserted(const QModelIndex & , int , int)));
connect(this->model, SIGNAL(rowsRemoved(const QModelIndex & , int , int)),
this, SLOT(rowsRemoved(const QModelIndex & , int , int)));
}
reset();
}
void WSortFilterProxyModel::sourceLayoutChanged()
{
layoutChanged().emit();
}
void Applet::setSize(const QSize& size)
{
m_size = size;
layoutChanged();
}
void KipiImageModel::setColumnCount(const int nColumns)
{
emit(layoutAboutToBeChanged());
d->columnCount = nColumns;
emit(layoutChanged());
}
void CharacteristicsModel::setCharacteristic(int row, QVariant data)
{
_root->child(row)->setData(data);
emit layoutChanged();
}
void TreeModel::somethingChanged() {
emit layoutChanged();
//qDebug() << "Debug. [ somethingChanged() ] GRUNKLE";
}
void IxModel::raiseEvent_layoutChanged() { Q_EMIT layoutChanged(); }
void IxModel::raiseEvent_layoutChanged(const QList<QPersistentModelIndex> & parents /* = QList<QPersistentModelIndex>() */, QAbstractItemModel::LayoutChangeHint hint /* = QAbstractItemModel::NoLayoutChangeHint */) { Q_EMIT layoutChanged(parents, hint); }
void LayerModel::setLocked(bool l, int id)
{
m_layers.at(id)->locked = l;
feather::qml::command::set_layer_locked(l,id);
layoutChanged();
}
void BanTableModel::refresh()
{
Q_EMIT layoutAboutToBeChanged();
priv->refreshBanlist();
Q_EMIT layoutChanged();
}
/*
Return[0]: totalFile
Return[1]: totalSize
Return[2]: currentFile
*/
QList<quint64> TransferModel::synchronizeItems(const QList<returnActionOnCopyList>& returnActions)
{
loop_size=returnActions.size();
index_for_loop=0;
totalFile=0;
totalSize=0;
currentFile=0;
emit layoutAboutToBeChanged();
while(index_for_loop<loop_size)
{
const returnActionOnCopyList& action=returnActions.at(index_for_loop);
switch(action.type)
{
case AddingItem:
{
transfertItem newItem;
newItem.id=action.addAction.id;
newItem.source=action.addAction.sourceFullPath;
newItem.size=facilityEngine->sizeToString(action.addAction.size);
newItem.destination=action.addAction.destinationFullPath;
transfertItemList<<newItem;
totalFile++;
totalSize+=action.addAction.size;
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, size: %2, name: %3").arg(action.addAction.id).arg(action.addAction.size).arg(action.addAction.sourceFullPath));
}
break;
case MoveItem:
{
//bool current_entry=
if(action.userAction.position<0)
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
if(action.userAction.position>(transfertItemList.size()-1))
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
if(action.userAction.moveAt<0)
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
if(action.userAction.moveAt>(transfertItemList.size()-1))
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
transfertItemList.move(action.userAction.position,action.userAction.moveAt);
}
break;
case RemoveItem:
{
if(currentIndexSearch>0 && action.userAction.position<=currentIndexSearch)
currentIndexSearch--;
if(action.userAction.position<0)
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
if(action.userAction.position>(transfertItemList.size()-1))
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("id: %1, position is wrong: %3").arg(action.addAction.id).arg(action.userAction.position));
break;
}
transfertItemList.removeAt(action.userAction.position);
currentFile++;
startId.remove(action.addAction.id);
stopId.remove(action.addAction.id);
}
break;
case PreOperation:
{
ItemOfCopyListWithMoreInformations tempItem;
tempItem.currentProgression=0;
tempItem.generalData=action.addAction;
tempItem.actionType=action.type;
internalRunningOperation[action.addAction.id]=tempItem;
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("set for file %1: actionType: PreOperation").arg(action.addAction.id));
}
break;
case Transfer:
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("found entry for file %1: actionType: Transfer").arg(action.addAction.id));
if(!startId.contains(action.addAction.id))
startId << action.addAction.id;
stopId.remove(action.addAction.id);
if(internalRunningOperation.contains(action.addAction.id))
internalRunningOperation[action.addAction.id].actionType=action.type;
else
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Warning,QString("unable to found entry for file %1: actionType: Transfer").arg(action.addAction.id));
}
break;
case PostOperation:
{
if(!stopId.contains(action.addAction.id))
stopId << action.addAction.id;
startId.remove(action.addAction.id);
internalRunningOperation.remove(action.addAction.id);
}
break;
case CustomOperation:
{
bool custom_with_progression=(action.addAction.size==1);
//without progression
if(custom_with_progression)
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("switch the file: %1 to custom operation with progression").arg(action.addAction.id));
if(startId.remove(action.addAction.id))
if(!stopId.contains(action.addAction.id))
stopId << action.addAction.id;
}
//with progression
else
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,QString("switch the file: %1 to custom operation without progression").arg(action.addAction.id));
stopId.remove(action.addAction.id);
if(!startId.contains(action.addAction.id))
startId << action.addAction.id;
}
if(internalRunningOperation.contains(action.addAction.id))
{
ItemOfCopyListWithMoreInformations &item=internalRunningOperation[action.addAction.id];
item.actionType=action.type;
item.custom_with_progression=custom_with_progression;
item.currentProgression=0;
}
}
break;
default:
//unknow code, ignore it
break;
}
index_for_loop++;
}
emit layoutChanged();
return QList<quint64>() << totalFile << totalSize << currentFile;
}
void File_list_model::set_columns(const Columns &new_columns) {
emit layoutAboutToBeChanged();
columns = new_columns;
update_current_columns();
emit layoutChanged();
}
/*virtual*/
void AbstractItemView::setModel(QAbstractItemModel *model, AbstractViewItem *prototype)
{
if( m_model == model || !model)
return;
if (m_model) {
disconnect(m_model, SIGNAL(destroyed()),
this, SLOT(_q_modelDestroyed()));
disconnect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT( dataChanged(QModelIndex,QModelIndex)));
disconnect(m_model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(rowsInserted(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(rowsRemoved(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(columnsInserted(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(columnsAboutToBeInserted(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(columnsRemoved(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(columnsAboutToBeRemoved(QModelIndex,int,int)));
disconnect(m_model, SIGNAL(modelReset()), this, SLOT(reset()));
disconnect(m_model, SIGNAL(layoutChanged()), this, SLOT(_q_layoutChanged()));
m_model = 0;
}
setSelectionModel(0);
m_currentIndex = QModelIndex();
m_rootIndex = QModelIndex();
m_model = model;
Q_ASSERT_X(m_model->index(0,0) == m_model->index(0,0),
"AbstractItemView::setModel",
"A model should return the exact same index "
"(including its internal id/pointer) when asked for it twice in a row.");
Q_ASSERT_X(m_model->index(0,0).parent() == QModelIndex(),
"AbstractItemView::setModel",
"The parent of a top level index should be invalid");
connect(m_model, SIGNAL(destroyed()), this, SLOT(modelDestroyed()));
connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT( dataChanged(QModelIndex,QModelIndex)));
connect(m_model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeInserted(QModelIndex,int,int)));
connect(m_model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(rowsInserted(QModelIndex,int,int)));
connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
connect(m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(rowsRemoved(QModelIndex,int,int)));
connect(m_model, SIGNAL(modelReset()), this, SLOT(reset()));
connect(m_model, SIGNAL(layoutChanged()), this, SLOT(layoutChanged()));
setSelectionModel(new QItemSelectionModel(m_model));
if (prototype && m_container) {
m_container->setItemPrototype(prototype);
m_container->reset();
}
}
void Project_ItemModel::interface_changed(){
QModelIndex root_index = this->root_index();
emit dataChanged(root_index, root_index);
emit layoutChanged();
}
void WorkPackageProxyModel::setSourceModel( QAbstractItemModel *model )
{
if ( sourceModel() ) {
disconnect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(sourceDataChanged(QModelIndex,QModelIndex)));
/* disconnect(sourceModel(), SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
this, SLOT(sourceHeaderDataChanged(Qt::Orientation,int,int)));*/
disconnect(sourceModel(), SIGNAL(layoutChanged()),
this, SIGNAL(layoutChanged()));
disconnect(sourceModel(), SIGNAL(layoutAboutToBeChanged()),
this, SIGNAL(layoutAboutToBeChanged()));
disconnect(sourceModel(), SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(sourceRowsInserted(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
/*
disconnect(sourceModel(), SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(sourceColumnsAboutToBeInserted(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(sourceColumnsInserted(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(sourceColumnsAboutToBeRemoved(QModelIndex,int,int)));
disconnect(sourceModel(), SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(sourceColumnsRemoved(QModelIndex,int,int)));
*/
disconnect(sourceModel(), SIGNAL(modelAboutToBeReset()), this, SLOT(sourceModelAboutToBeReset()));
disconnect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceModelReset()));
disconnect(sourceModel(), SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceRowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
disconnect(sourceModel(), SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceRowsMoved(QModelIndex,int,int,QModelIndex,int)));
/*
disconnect(sourceModel(), SIGNAL(columnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceColumnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
disconnect(sourceModel(), SIGNAL(columnsMoved(QModelIndex&parent,int,int,QModelIndex,int)),
this, SLOT(sourceColumnsMoved(QModelIndex&parent,int,int,QModelIndex,int)));*/
}
QAbstractProxyModel::setSourceModel( model );
if ( model ) {
connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this, SLOT(sourceDataChanged(QModelIndex,QModelIndex)));
/* connect(model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
this, SLOT(sourceHeaderDataChanged(Qt::Orientation,int,int)));*/
connect(model, SIGNAL(layoutChanged()),
this, SIGNAL(layoutChanged()));
connect(model, SIGNAL(layoutAboutToBeChanged()),
this, SIGNAL(layoutAboutToBeChanged()));
connect(model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(sourceRowsAboutToBeInserted(QModelIndex,int,int)));
connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)),
this, SLOT(sourceRowsInserted(QModelIndex,int,int)));
connect(model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(sourceRowsAboutToBeRemoved(QModelIndex,int,int)));
connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
this, SLOT(sourceRowsRemoved(QModelIndex,int,int)));
/*
connect(model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
this, SLOT(sourceColumnsAboutToBeInserted(QModelIndex,int,int)));
connect(model, SIGNAL(columnsInserted(QModelIndex,int,int)),
this, SLOT(sourceColumnsInserted(QModelIndex,int,int)));
connect(model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
this, SLOT(sourceColumnsAboutToBeRemoved(QModelIndex,int,int)));
connect(model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
this, SLOT(sourceColumnsRemoved(QModelIndex,int,int)));
*/
connect(model, SIGNAL(modelAboutToBeReset()), this, SLOT(sourceModelAboutToBeReset()));
connect(model, SIGNAL(modelReset()), this, SLOT(sourceModelReset()));
connect(model, SIGNAL(rowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceRowsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
connect(model, SIGNAL(rowsMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceRowsMoved(QModelIndex,int,int,QModelIndex,int)));
/*
connect(model, SIGNAL(columnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)),
this, SLOT(sourceColumnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int)));
connect(model, SIGNAL(columnsMoved(QModelIndex&parent,int,int,QModelIndex,int)),
this, SLOT(sourceColumnsMoved(QModelIndex&parent,int,int,QModelIndex,int)));*/
}
}
void QtWorkspaceMementoModel::update()
{
emit layoutChanged(); //This should tell the view that the data has changed.
}
void DataFilesModel::uncheckAll()
{
emit layoutAboutToBeChanged();
mCheckStates.clear();
emit layoutChanged();
}
void
InstructionListModel::changeInstructions(const std::vector<SgAsmInstruction*> &insns) {
layoutAboutToBeChanged().emit();
insns_ = insns;
layoutChanged().emit();
}
void ConnectionsTreeWidget::dropEvent(QDropEvent *event)
{
QTreeWidget::dropEvent(event);
emit layoutChanged();
}
void ChatListModel::clearBookmarks() {
emit layoutAboutToBeChanged();
mucBookmarks_->clear();
emit layoutChanged();
}
void setStations(const StationInformation::List &list)
{
m_stations = list;
layoutChanged();
}
status_t MediaRoutingView::importState(
const BMessage* archive) {
status_t err;
_emptyInactiveNodeState();
layout_t layout;
err = archive->FindInt32("layout", (int32*)&layout);
if(err == B_OK && layout != m_layout) {
layoutChanged(layout);
}
const char* path;
err = archive->FindString("bgBitmap", &path);
if(err == B_OK) {
BEntry entry(path);
entry_ref ref;
err = entry.GetRef(&ref);
if(err == B_OK)
_changeBackground(&ref);
}
else {
rgb_color color;
color.alpha = 255;
if(
archive->FindInt8("bgRed", (int8*)&color.red) == B_OK &&
archive->FindInt8("bgGreen", (int8*)&color.green) == B_OK &&
archive->FindInt8("bgBlue", (int8*)&color.blue) == B_OK)
_changeBackground(color);
}
for(int32 n = 0; ; ++n) {
// find panel state info; stop when exhausted
BMessage m;
err = archive->FindMessage("panel", n, &m);
if(err < B_OK)
break;
const char* nodeName;
err = archive->FindString("nodeName", n, &nodeName);
if(err < B_OK)
break;
uint32 nodeKind;
err = archive->FindInt32("nodeKind", n, (int32*)&nodeKind);
if(err < B_OK)
break;
// look up matching panel +++++ SLOW +++++
uint32 panelIndex;
uint32 items = countItems(DiagramItem::M_BOX);
for(
panelIndex = 0;
panelIndex < items;
++panelIndex) {
MediaNodePanel* panel = dynamic_cast<MediaNodePanel*>(
itemAt(panelIndex, DiagramItem::M_BOX));
if(panel &&
!strcmp(panel->ref->name(), nodeName) &&
panel->ref->kind() == nodeKind) {
// found match; hand message to panel
panel->importState(&m);
break;
}
}
if(panelIndex == items) {
// no panel found
// if a "system node" hang onto (and re-export) state info
bool sysOwned;
if(m.FindBool("sysOwned", &sysOwned) == B_OK && sysOwned) {
m_inactiveNodeState.AddItem(
new _inactive_node_state_entry(
nodeName, nodeKind, m));
}
}
}
updateDataRect();
return B_OK;
}
void TablaModelInfo::setCabeceraV(QStringList &cabecV) // cuando modifiquemos la cabecera vertical
{
cabeceraV = cabecV;
layoutChanged();
}
MainWindow::MainWindow(DVRServerRepository *serverRepository, QWidget *parent)
: QMainWindow(parent), m_serverRepository(serverRepository), m_trayIcon(0)
{
Q_ASSERT(m_serverRepository);
bcApp->mainWindow = this;
connect(bcApp->eventDownloadManager(), SIGNAL(eventVideoDownloadAdded(EventVideoDownload*)),
this, SLOT(showDownloadsWindow()));
setUnifiedTitleAndToolBarOnMac(true);
resize(1100, 750);
createMenu();
updateTrayIcon();
setObjectName("MainWindow");
statusBar()->addPermanentWidget(new StatusBandwidthWidget(statusBar()));
statusBar()->addWidget(new StatusBarServerAlert(m_serverRepository, statusBar()));
#ifdef Q_OS_MAC
statusBar()->setSizeGripEnabled(false);
if (style()->inherits("QMacStyle"))
statusBar()->setFixedHeight(24);
#endif
/* Experimental toolbar */
m_mainToolbar = new QToolBar(tr("Main"));
m_mainToolbar->setMovable(false);
m_mainToolbar->setIconSize(QSize(16, 16));
m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/cassette.png")), tr("Events"), this, SLOT(showEventsWindow()));
m_expandAllServersAction = m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/expand-all.png")), tr("Expand All Servers"));
m_collapseAllServersAction = m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/collapse-all.png")), tr("Collapse All Servers"));
addToolBar(Qt::TopToolBarArea, m_mainToolbar);
/* Splitters */
m_leftSplit = new MacSplitter(Qt::Horizontal);
m_centerSplit = new MacSplitter(Qt::Vertical);
/* Live view */
m_liveView = new LiveViewWindow(serverRepository, this);
/* Recent events */
QWidget *eventsWidget = createRecentEvents();
/* Layouts */
m_leftSplit->addWidget(createSourcesList());
m_leftSplit->addWidget(m_centerSplit);
m_leftSplit->setStretchFactor(1, 1);
m_leftSplit->setCollapsible(0, false);
m_leftSplit->setCollapsible(1, false);
m_centerSplit->addWidget(m_liveView);
m_centerSplit->addWidget(eventsWidget);
m_centerSplit->setStretchFactor(0, 1);
m_centerSplit->setCollapsible(0, false);
m_centerSplit->setCollapsible(1, false);
/* Set center widget */
QWidget *center = new QWidget;
QBoxLayout *centerLayout = new QVBoxLayout(center);
centerLayout->setMargin(0);
centerLayout->setSpacing(0);
centerLayout->addWidget(m_leftSplit, 1);
setCentralWidget(center);
#ifdef Q_OS_WIN
/* There is no top border on the statusbar on Windows, and we need one. */
if (style()->inherits("QWindowsStyle"))
{
QFrame *line = new QFrame;
line->setFrameStyle(QFrame::Plain | QFrame::HLine);
QPalette p = line->palette();
p.setColor(QPalette::WindowText, QColor(171, 175, 183));
line->setPalette(p);
line->setFixedHeight(1);
centerLayout->addWidget(line);
}
#endif
QSettings settings;
bcApp->liveView->setBandwidthMode(settings.value(QLatin1String("ui/liveview/bandwidthMode")).toInt());
restoreGeometry(settings.value(QLatin1String("ui/main/geometry")).toByteArray());
if (!m_centerSplit->restoreState(settings.value(QLatin1String("ui/main/centerSplit")).toByteArray()))
{
m_centerSplit->setSizes(QList<int>() << 1000 << 130);
}
if (!m_leftSplit->restoreState(settings.value(QLatin1String("ui/main/leftSplit")).toByteArray()))
{
#ifdef Q_OS_MAC
m_leftSplit->setSizes(QList<int>() << 210 << 1000);
#else
m_leftSplit->setSizes(QList<int>() << 190 << 1000);
#endif
}
m_leftSplit->setHandleWidth(2);
m_centerSplit->setHandleWidth(2);
QString lastLayout = settings.value(QLatin1String("ui/cameraArea/lastLayout"), tr("Default")).toString();
m_liveView->setLayout(lastLayout);
connect(m_liveView, SIGNAL(layoutChanged(QString)), SLOT(liveViewLayoutChanged(QString)));
connect(m_leftSplit, SIGNAL(splitterMoved(int,int)), SLOT(updateToolbarWidth()));
updateToolbarWidth();
connect(bcApp, SIGNAL(sslConfirmRequired(DVRServer*,QList<QSslError>,QSslConfiguration)),
SLOT(sslConfirmRequired(DVRServer*,QList<QSslError>,QSslConfiguration)));
connect(bcApp, SIGNAL(queryLivePaused()), SLOT(queryLivePaused()));
connect(m_serverRepository, SIGNAL(serverAdded(DVRServer*)), SLOT(onServerAdded(DVRServer*)));
foreach (DVRServer *s, m_serverRepository->servers())
onServerAdded(s);
connect(qApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
m_sourcesList->setFocus(Qt::OtherFocusReason);
connect(m_expandAllServersAction, SIGNAL(triggered()), m_sourcesList, SLOT(expandAll()));
connect(m_collapseAllServersAction, SIGNAL(triggered()), m_sourcesList, SLOT(collapseAll()));
retranslateUI();
if (settings.value(QLatin1String("ui/saveSession"), false).toBool())
m_liveView->restoreSession();
}
void LayerModel::setColor(QColor color, int id)
{
m_layers.at(id)->color = color;
feather::qml::command::set_layer_color(color.red(), color.green(), color.blue(), id);
layoutChanged();
}