void UpdateReferenceDialog::setObjref(Objref_ptr objref)
{
if (m_objref)
{
disconnect(this,
SIGNAL(updateReference(const CORBA::Object_var&)),
m_objref.get(),
SLOT(setReference(const CORBA::Object_var&)));
disconnect(m_objref.get(),
SIGNAL(updatedReference(const CORBA::Object_var&)),
m_status,
SLOT(setReference(const CORBA::Object_var&)));
}
m_objref = objref;
if (m_objref)
{
m_status->setInterface(objref->interface());
m_reference->setInterface(objref->interface());
m_status->setReference(objref->reference());
connect(this,
SIGNAL(updateReference(const CORBA::Object_var&)),
m_objref.get(),
SLOT(setReference(const CORBA::Object_var&)));
connect(m_objref.get(),
SIGNAL(updatedReference(const CORBA::Object_var&)),
m_status,
SLOT(setReference(const CORBA::Object_var&)));
}
}
void
ProgressPanel::startTask(const NodePtr& node,
const int firstFrame,
const int lastFrame,
const int frameStep,
const bool canPause,
const bool canCancel,
const QString& message,
const boost::shared_ptr<ProcessHandler>& process)
{
assert( QThread::currentThread() == qApp->thread() );
if (!node) {
return;
}
assert( (canPause && firstFrame != INT_MIN && lastFrame != INT_MAX) || !canPause );
ProgressTaskInfoPtr task;
{
QMutexLocker k(&_imp->tasksMutex);
task = _imp->findTask(node);
}
if (task) {
task->cancelTask(false, 1);
removeTaskFromTable(task);
}
QMutexLocker k(&_imp->tasksMutex);
task.reset( new ProgressTaskInfo(this,
node,
firstFrame,
lastFrame,
frameStep,
canPause,
canCancel,
message, process) );
if ( canPause || node->getEffectInstance()->isOutput() ) {
task->createItems();
QTimer::singleShot( NATRON_DISPLAY_PROGRESS_PANEL_AFTER_MS, this, SLOT(onShowProgressPanelTimerTriggered()) );
}
if (process) {
connectProcessSlots( task.get(), process.get() );
}
if (!process) {
if ( node->getEffectInstance()->isOutput() ) {
OutputEffectInstance* isOutput = dynamic_cast<OutputEffectInstance*>( node->getEffectInstance().get() );
if (isOutput) {
boost::shared_ptr<RenderEngine> engine = isOutput->getRenderEngine();
assert(engine);
QObject::connect( engine.get(), SIGNAL(frameRendered(int,double)), task.get(), SLOT(onRenderEngineFrameComputed(int,double)) );
QObject::connect( engine.get(), SIGNAL(renderFinished(int)), task.get(), SLOT(onRenderEngineStopped(int)) );
QObject::connect( task.get(), SIGNAL(taskCanceled()), engine.get(), SLOT(abortRendering_non_blocking()) );
}
}
}
void MainWindow::onNewGame()
{
m_needDestroy = false;
m_gameConfiguring = true;
std::shared_ptr<void> finalizer(nullptr, [&](void*) { m_gameConfiguring = false; });
NewGameDialog dialog;
if (dialog.exec() != QDialog::Accepted)
return;
const GameConfig& config = dialog.gameConfig();
if (!config.isInititialized())
return;
auto rival = std::move(dialog.rival());
connect(Kg::difficulty(),
SIGNAL(currentLevelChanged(const KgDifficultyLevel*)),
rival.get(),
SLOT(onDifficultyChanged(const KgDifficultyLevel*)));
m_menu.m_undoAction->setEnabled(rival->canUndo());
connect(rival.get(), SIGNAL(needDestroy()), this, SLOT(onNeedDestroy()));
m_model = std::unique_ptr<BoardModel>(new BoardModel(config, createStepQueue(config)));
connect(m_menu.m_undoAction, SIGNAL(triggered(bool)), m_model.get(), SLOT(undo()));
connect(m_model.get(), SIGNAL(statusUpdated(const QString&)), statusBar(), SLOT(showMessage(const QString&)));
{
std::unique_ptr<IBoardView> view(new BoardView(this));
connect(this, SIGNAL(preferencesUpdated()), view->getObject(), SLOT(update()));
setCentralWidget(qobject_cast<QWidget*>(view->getObject()));
m_model->setView(std::move(view));
}
m_model->setRival(std::move(rival));
m_menu.m_endAction->setEnabled(true);
if (m_needDestroy)
endGame();
}
void NetworkRemote::AcceptConnection() {
if (!signals_connected_) {
signals_connected_ = true;
// Setting up the signals, but only once
connect(incoming_data_parser_.get(), SIGNAL(SendClementineInfo()),
outgoing_data_creator_.get(), SLOT(SendClementineInfo()));
connect(incoming_data_parser_.get(), SIGNAL(SendFirstData(bool)),
outgoing_data_creator_.get(), SLOT(SendFirstData(bool)));
connect(incoming_data_parser_.get(), SIGNAL(SendAllPlaylists()),
outgoing_data_creator_.get(), SLOT(SendAllPlaylists()));
connect(incoming_data_parser_.get(), SIGNAL(SendAllActivePlaylists()),
outgoing_data_creator_.get(), SLOT(SendAllActivePlaylists()));
connect(incoming_data_parser_.get(), SIGNAL(SendPlaylistSongs(int)),
outgoing_data_creator_.get(), SLOT(SendPlaylistSongs(int)));
connect(app_->playlist_manager(), SIGNAL(ActiveChanged(Playlist*)),
outgoing_data_creator_.get(), SLOT(ActiveChanged(Playlist*)));
connect(app_->playlist_manager(), SIGNAL(PlaylistChanged(Playlist*)),
outgoing_data_creator_.get(), SLOT(PlaylistChanged(Playlist*)));
connect(app_->playlist_manager(), SIGNAL(PlaylistAdded(int,QString,bool)),
outgoing_data_creator_.get(), SLOT(PlaylistAdded(int,QString,bool)));
connect(app_->playlist_manager(), SIGNAL(PlaylistRenamed(int,QString)),
outgoing_data_creator_.get(), SLOT(PlaylistRenamed(int,QString)));
connect(app_->playlist_manager(), SIGNAL(PlaylistClosed(int)),
outgoing_data_creator_.get(), SLOT(PlaylistClosed(int)));
connect(app_->playlist_manager(), SIGNAL(PlaylistDeleted(int)),
outgoing_data_creator_.get(), SLOT(PlaylistDeleted(int)));
connect(app_->player(), SIGNAL(VolumeChanged(int)), outgoing_data_creator_.get(),
SLOT(VolumeChanged(int)));
connect(app_->player()->engine(), SIGNAL(StateChanged(Engine::State)),
outgoing_data_creator_.get(), SLOT(StateChanged(Engine::State)));
connect(app_->playlist_manager()->sequence(),
SIGNAL(RepeatModeChanged(PlaylistSequence::RepeatMode)),
outgoing_data_creator_.get(),
SLOT(SendRepeatMode(PlaylistSequence::RepeatMode)));
connect(app_->playlist_manager()->sequence(),
SIGNAL(ShuffleModeChanged(PlaylistSequence::ShuffleMode)),
outgoing_data_creator_.get(),
SLOT(SendShuffleMode(PlaylistSequence::ShuffleMode)));
connect(incoming_data_parser_.get(), SIGNAL(GetLyrics()),
outgoing_data_creator_.get(), SLOT(GetLyrics()));
connect(incoming_data_parser_.get(),
SIGNAL(SendSongs(pb::remote::RequestDownloadSongs,RemoteClient*)),
outgoing_data_creator_.get(),
SLOT(SendSongs(pb::remote::RequestDownloadSongs,RemoteClient*)));
connect(incoming_data_parser_.get(),
SIGNAL(ResponseSongOffer(RemoteClient*, bool)),
outgoing_data_creator_.get(),
SLOT(ResponseSongOffer(RemoteClient*, bool)));
connect(incoming_data_parser_.get(),
SIGNAL(SendLibrary(RemoteClient*)),
outgoing_data_creator_.get(),
SLOT(SendLibrary(RemoteClient*)));
}
Game::Game() {
players.push_back(unique_ptr<Player>(new Player("Player 1")));
players.push_back(unique_ptr<Player>(new Player("Player 2")));
// init View here
userInterface.reset(new View());
shared_ptr<View> v = std::dynamic_pointer_cast<View>(userInterface);
// connect View to Presenter
connect(v.get(), SIGNAL(New_game(int)), this, SLOT(new_game(int)));
connect(v.get(), SIGNAL(Save_game(std::string)), this, SLOT(save_game(std::string)));
connect(v.get(), SIGNAL(Load_game(std::string)), this, SLOT(load_game(std::string)));
connect(v.get(), SIGNAL(Host_game(std::string)), this, SLOT(host_game(std::string)));
connect(v.get(), SIGNAL(Join_game(std::string)), this, SLOT(join_game(std::string)));
connect(v.get(), SIGNAL(Leave()), this, SLOT(leave()));
connect(v.get(), SIGNAL(Put_stone(int,int)), this, SLOT(put_stone(int,int)));
connect(v.get(), SIGNAL(Rotate(IView::quadrant,IView::turn)), this, SLOT(rotate(IView::quadrant,IView::turn)));
// connect Presenter to View
connect(this, SIGNAL(draw_stone(int,int,IView::color)),v.get(),SLOT(Draw_stone(int,int,IView::color)));
connect(this, SIGNAL(set_control_settings(IView::control_setting)),v.get(),SLOT(Set_control_settings(IView::control_setting)));
connect(this, SIGNAL(message(string)), v.get(), SLOT(Show_message(string)));
}
void DatasetScalar::examineDataset()
{
int nx = m_properties.get( Fn::Property::NX ).toInt();
int ny = m_properties.get( Fn::Property::NY ).toInt();
int nz = m_properties.get( Fn::Property::NZ ).toInt();
float min = std::numeric_limits<float>::max();
float max = 0;
int size = nx * ny * nz;
for ( int i = 0; i < size; ++i )
{
min = qMin( min, m_data[i] );
max = qMax( max, m_data[i] );
}
m_properties.set( Fn::Property::SIZE, static_cast<int>( size * sizeof(float) ) );
m_properties.set( Fn::Property::MIN, min );
m_properties.set( Fn::Property::MAX, max );
m_properties.set( Fn::Property::SELECTED_MIN, min, min, max, true );
m_properties.set( Fn::Property::SELECTED_MAX, max, min, max, true );
m_properties.set( Fn::Property::LOWER_THRESHOLD, min + (max-min)/1000., min, max, true );
m_properties.set( Fn::Property::UPPER_THRESHOLD, max, min, max, true );
connect( m_properties.getProperty( Fn::Property::SELECTED_MIN ), SIGNAL( valueChanged( float ) ),
m_properties.getProperty( Fn::Property::LOWER_THRESHOLD ), SLOT( setMax( float ) ) );
connect( m_properties.getProperty( Fn::Property::SELECTED_MAX ), SIGNAL( valueChanged( float ) ),
m_properties.getProperty( Fn::Property::UPPER_THRESHOLD ), SLOT( setMin( float ) ) );
connect( m_properties.getProperty( Fn::Property::SELECTED_MIN ), SIGNAL( valueChanged( float ) ),
m_properties.getProperty( Fn::Property::SELECTED_MAX ), SLOT( setMin( float ) ) );
connect( m_properties.getProperty( Fn::Property::SELECTED_MAX ), SIGNAL( valueChanged( float ) ),
m_properties.getProperty( Fn::Property::SELECTED_MIN ), SLOT( setMax( float ) ) );
if ( m_qform( 1, 1 ) < 0 || m_sform( 1, 1 ) < 0 )
{
qDebug() << m_properties.get( Fn::Property::NAME ).toString() << ": RADIOLOGICAL orientation detected. Flipping voxels on X-Axis";
flipX();
}
}
void Transcribe::guiReady(QObject* root) {
m_main_window = qobject_cast<QWindow*>(root);
m_text_area = m_main_window->findChild<QObject*>("text_area");
// Set the icon, which, strangely enough, cannot be done from QML
m_main_window->setIcon(QIcon("://window_icon"));
#ifndef Q_OS_ANDROID
// Restore window state
QSettings settings;
settings.beginGroup(CFG_GROUP_SCREEN);
if (settings.value(CFG_SCREEN_IS_MAXIMIZED, false).toBool()) {
m_main_window->setVisibility(QWindow::Maximized);
} else {
m_main_window->resize(settings.value(CFG_SCREEN_SIZE,
QSize(640, 480)).toSize());
m_main_window->setPosition(settings.value(CFG_SCREEN_POS,
QPoint(200, 200)).toPoint());
settings.endGroup();\
}
#endif
// Install the key filter and connect its signals
KeyCatcher* catcher = new KeyCatcher(root);
connect(catcher, SIGNAL(keyTyped()),
&m_keeper, SLOT(keyTyped()));
connect(catcher, SIGNAL(saveFile()),
this, SLOT(saveText()));
connect(catcher, SIGNAL(seekAudio(int)),
m_player.get(), SLOT(skipSeconds(int)));
connect(catcher, SIGNAL(togglePlayPause()),
m_player.get(), SLOT(togglePlayPause()));
connect(catcher, SIGNAL(togglePlayPause(bool)),
m_player.get(), SLOT(togglePlayPause(bool)));
connect(catcher, SIGNAL(boost(bool)),
m_player.get(), SLOT(boost(bool)));
root->installEventFilter(catcher);
#ifdef Q_OS_ANDROID
// On Android, we might connect the signals when using the virtual keyboard
// in addition to the signals from the physical keyboard.
connect(qApp->inputMethod(), SIGNAL(visibleChanged()),
this, SLOT(connectVirtualKeyboard()));
connectVirtualKeyboard();
#endif
// Connect GUI events to their callbacks
connect(m_main_window, SIGNAL(audioPositionChanged(int)),
m_player.get(), SLOT(setPosition(int)));
connect(m_main_window, SIGNAL(playingStateChanged(bool)),
m_player.get(), SLOT(togglePlayPause(bool)));
connect(m_main_window, SIGNAL(seekAudio(int)),
m_player.get(), SLOT(skipSeconds(int)));
connect(m_main_window, SIGNAL(boostAudio(bool)),
m_player.get(), SLOT(boost(bool)));
connect(m_main_window, SIGNAL(saveText()),
this, SLOT(saveText()));
#ifdef Q_OS_ANDROID
connect(m_main_window, SIGNAL(shareText()),
this, SLOT(shareText()));
connect(m_main_window, SIGNAL(deleteText()),
this, SLOT(deleteText()));
#endif
connect(m_main_window, SIGNAL(pickFiles()),
this, SLOT(pickFiles()));
connect(m_main_window, SIGNAL(historySelected(int)),
this, SLOT(restoreHistory(int)));
connect(m_main_window, SIGNAL(signalQuit()),
this, SLOT(close()));
connect(m_main_window, SIGNAL(numWordsDirty()),
this, SLOT(countWords()));
}
void IndirectFitAnalysisTab::connectFitBrowserAndPlotPresenter() {
connect(m_plotPresenter.get(), SIGNAL(selectedFitDataChanged(std::size_t)),
this, SLOT(setBrowserWorkspace(std::size_t)));
connect(m_fitPropertyBrowser, SIGNAL(functionChanged()), this,
SLOT(updateAttributeValues()));
connect(m_plotPresenter.get(), SIGNAL(selectedFitDataChanged(std::size_t)),
this, SLOT(updateAttributeValues()));
connect(m_plotPresenter.get(), SIGNAL(selectedFitDataChanged(std::size_t)),
this, SLOT(updateParameterValues()));
connect(m_plotPresenter.get(), SIGNAL(plotSpectrumChanged(std::size_t)), this,
SLOT(setBrowserWorkspaceIndex(std::size_t)));
// Update attributes before parameters as the parameters may depend on the
// attribute values
connect(m_plotPresenter.get(), SIGNAL(plotSpectrumChanged(std::size_t)), this,
SLOT(updateAttributeValues()));
connect(m_plotPresenter.get(), SIGNAL(plotSpectrumChanged(std::size_t)), this,
SLOT(updateParameterValues()));
connect(m_fitPropertyBrowser, SIGNAL(startXChanged(double)),
m_plotPresenter.get(), SLOT(setStartX(double)));
connect(m_fitPropertyBrowser, SIGNAL(endXChanged(double)),
m_plotPresenter.get(), SLOT(setEndX(double)));
connect(m_fitPropertyBrowser, SIGNAL(updatePlotSpectrum(int)),
m_plotPresenter.get(), SLOT(updatePlotSpectrum(int)));
connect(m_fitPropertyBrowser, SIGNAL(workspaceIndexChanged(int)), this,
SLOT(setBrowserWorkspaceIndex(int)));
connect(m_fitPropertyBrowser, SIGNAL(workspaceIndexChanged(int)), this,
SLOT(updateAttributeValues()));
connect(m_fitPropertyBrowser, SIGNAL(workspaceIndexChanged(int)), this,
SLOT(updateParameterValues()));
connect(m_plotPresenter.get(), SIGNAL(startXChanged(double)), this,
SLOT(setBrowserStartX(double)));
connect(m_plotPresenter.get(), SIGNAL(endXChanged(double)), this,
SLOT(setBrowserEndX(double)));
connect(m_plotPresenter.get(), SIGNAL(fwhmChanged(double)), this,
SLOT(updateFitBrowserParameterValues()));
connect(m_plotPresenter.get(), SIGNAL(backgroundChanged(double)), this,
SLOT(updateFitBrowserParameterValues()));
connect(m_fitPropertyBrowser, SIGNAL(xRangeChanged(double, double)),
m_plotPresenter.get(), SLOT(updateGuess()));
connect(m_plotPresenter.get(), SIGNAL(fwhmChanged(double)),
m_plotPresenter.get(), SLOT(updateGuess()));
connect(m_plotPresenter.get(), SIGNAL(backgroundChanged(double)),
m_plotPresenter.get(), SLOT(updateGuess()));
connect(m_fitPropertyBrowser,
SIGNAL(parameterChanged(const Mantid::API::IFunction *)),
m_plotPresenter.get(), SLOT(updateRangeSelectors()));
connect(m_fitPropertyBrowser,
SIGNAL(parameterChanged(const Mantid::API::IFunction *)),
m_plotPresenter.get(), SLOT(updateGuess()));
connect(m_fitPropertyBrowser, SIGNAL(functionChanged()),
m_plotPresenter.get(), SLOT(updatePlots()));
connect(m_fitPropertyBrowser, SIGNAL(functionChanged()),
m_plotPresenter.get(), SLOT(updateGuess()));
connect(m_fitPropertyBrowser, SIGNAL(plotGuess()), m_plotPresenter.get(),
SLOT(enablePlotGuessInSeparateWindow()));
}
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent)
, config_()
, model_()
, synthesis_(new Synthesis)
, ui_(new Ui::MainWindow)
, dataEntryWindow_(new DataEntryWindow)
, intonationWindow_(new IntonationWindow)
, intonationParametersWindow_(new IntonationParametersWindow)
, postureEditorWindow_(new PostureEditorWindow)
, prototypeManagerWindow_(new PrototypeManagerWindow)
, specialTransitionEditorWindow_(new TransitionEditorWindow)
, ruleManagerWindow_(new RuleManagerWindow)
, ruleTesterWindow_(new RuleTesterWindow)
, synthesisWindow_(new SynthesisWindow)
, transitionEditorWindow_(new TransitionEditorWindow)
{
ui_->setupUi(this);
ui_->logTextEdit->setMaximumBlockCount(MAX_LOG_BLOCK_COUNT);
specialTransitionEditorWindow_->setSpecial();
connect(ui_->quitAction, SIGNAL(triggered()), qApp, SLOT(closeAllWindows()));
connect(ui_->aboutAction, SIGNAL(triggered()), this, SLOT(about()));
coutStreamBuffer_.reset(new LogStreamBuffer(std::cout, false, ui_->logTextEdit));
cerrStreamBuffer_.reset(new LogStreamBuffer(std::cerr, true, ui_->logTextEdit));
LogStreamBuffer::registerQDebugMessageHandler();
connect(prototypeManagerWindow_.get(), SIGNAL(editTransitionButtonClicked(unsigned int, unsigned int)),
transitionEditorWindow_.get(), SLOT(handleEditTransitionButtonClicked(unsigned int, unsigned int)));
connect(prototypeManagerWindow_.get(), SIGNAL(editSpecialTransitionButtonClicked(unsigned int, unsigned int)),
specialTransitionEditorWindow_.get(), SLOT(handleEditTransitionButtonClicked(unsigned int, unsigned int)));
connect(dataEntryWindow_.get(), SIGNAL(categoryChanged()) , postureEditorWindow_.get(), SLOT(unselectPosture()));
connect(dataEntryWindow_.get(), SIGNAL(parameterChanged()), postureEditorWindow_.get(), SLOT(unselectPosture()));
connect(dataEntryWindow_.get(), SIGNAL(symbolChanged()) , postureEditorWindow_.get(), SLOT(unselectPosture()));
connect(dataEntryWindow_.get(), SIGNAL(parameterChanged()), ruleManagerWindow_.get(), SLOT(loadRuleData()));
connect(dataEntryWindow_.get(), SIGNAL(parameterChanged()), synthesisWindow_.get(), SLOT(setupParameterTable()));
connect(postureEditorWindow_.get(), SIGNAL(postureChanged()), ruleManagerWindow_.get(), SLOT(unselectRule()));
connect(postureEditorWindow_.get(), SIGNAL(postureCategoryChanged()), dataEntryWindow_.get(), SLOT(updateCategoriesTable()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), transitionEditorWindow_.get(), SLOT(updateEquationsTree()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), transitionEditorWindow_.get(), SLOT(updateTransition()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), specialTransitionEditorWindow_.get(), SLOT(updateEquationsTree()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), specialTransitionEditorWindow_.get(), SLOT(updateTransition()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), ruleManagerWindow_.get(), SLOT(setupRuleSymbolEquationsTable()));
connect(prototypeManagerWindow_.get(), SIGNAL(equationChanged()), ruleManagerWindow_.get(), SLOT(setupEquationsTree()));
connect(prototypeManagerWindow_.get(), SIGNAL(transitionChanged()), transitionEditorWindow_.get(), SLOT(clear()));
connect(prototypeManagerWindow_.get(), SIGNAL(transitionChanged()), ruleManagerWindow_.get(), SLOT(setupRuleTransitionsTable()));
connect(prototypeManagerWindow_.get(), SIGNAL(transitionChanged()), ruleManagerWindow_.get(), SLOT(setupTransitionsTree()));
connect(prototypeManagerWindow_.get(), SIGNAL(specialTransitionChanged()), specialTransitionEditorWindow_.get(), SLOT(clear()));
connect(prototypeManagerWindow_.get(), SIGNAL(specialTransitionChanged()), ruleManagerWindow_.get(), SLOT(setupRuleSpecialTransitionsTable()));
connect(prototypeManagerWindow_.get(), SIGNAL(specialTransitionChanged()), ruleManagerWindow_.get(), SLOT(setupSpecialTransitionsTree()));
connect(transitionEditorWindow_.get(), SIGNAL(equationReferenceChanged()), prototypeManagerWindow_.get(), SLOT(setupEquationsTree()));
connect(transitionEditorWindow_.get(), SIGNAL(transitionChanged()), prototypeManagerWindow_.get(), SLOT(unselectTransition()));
connect(specialTransitionEditorWindow_.get(), SIGNAL(equationReferenceChanged()), prototypeManagerWindow_.get(), SLOT(setupEquationsTree()));
connect(specialTransitionEditorWindow_.get(), SIGNAL(transitionChanged()), prototypeManagerWindow_.get(), SLOT(unselectSpecialTransition()));
connect(ruleManagerWindow_.get(), SIGNAL(categoryReferenceChanged()), dataEntryWindow_.get(), SLOT(updateCategoriesTable()));
connect(ruleManagerWindow_.get(), SIGNAL(transitionReferenceChanged()) , prototypeManagerWindow_.get(), SLOT(setupTransitionsTree()));
connect(ruleManagerWindow_.get(), SIGNAL(specialTransitionReferenceChanged()), prototypeManagerWindow_.get(), SLOT(setupSpecialTransitionsTree()));
connect(ruleManagerWindow_.get(), SIGNAL(equationReferenceChanged()) , prototypeManagerWindow_.get(), SLOT(setupEquationsTree()));
connect(synthesisWindow_.get(), SIGNAL(textSynthesized()), intonationWindow_.get(), SLOT(loadIntonationFromEventList()));
connect(synthesisWindow_.get(), SIGNAL(audioStarted()), intonationWindow_.get(), SLOT(handleAudioStarted()));
connect(synthesisWindow_.get(), SIGNAL(audioFinished()), intonationWindow_.get(), SLOT(handleAudioFinished()));
connect(synthesisWindow_.get(), SIGNAL(synthesisFinished()), intonationWindow_.get(), SLOT(handleSynthesisFinished()));
connect(intonationWindow_.get(), SIGNAL(synthesisRequested()), synthesisWindow_.get(), SLOT(synthesizeWithManualIntonation()));
connect(intonationWindow_.get(), SIGNAL(synthesisToFileRequested(QString)), synthesisWindow_.get(), SLOT(synthesizeToFileWithManualIntonation(QString)));
}
void
Task::UiUpdater::updateUI(FilterUiInterface* ui)
{
// This function is executed from the GUI thread.
OptionsWidget* const opt_widget = m_ptrFilter->optionsWidget();
opt_widget->postUpdateUI();
ui->setOptionsWidget(opt_widget, ui->KEEP_OWNERSHIP);
ui->invalidateThumbnail(m_pageId);
if (m_batchProcessing) {
return;
}
std::auto_ptr<ImageViewBase> image_view(
new ImageView(m_outputImage, m_downscaledOutputImage)
);
QPixmap const downscaled_output_pixmap(image_view->downscaledPixmap());
std::auto_ptr<ImageViewBase> dewarping_view(
new DewarpingView(
m_origImage, m_downscaledOrigImage, m_xform.transform(),
PolygonUtils::convexHull(
(m_xform.resultingPreCropArea() + m_xform.resultingPostCropArea()).toStdVector()
),
m_virtContentRect, m_pageId, m_params.dewarpingMode(),
m_params.distortionModel(), opt_widget->depthPerception()
)
);
QPixmap const downscaled_orig_pixmap(dewarping_view->downscaledPixmap());
QObject::connect(
opt_widget, SIGNAL(depthPerceptionChanged(double)),
dewarping_view.get(), SLOT(depthPerceptionChanged(double))
);
QObject::connect(
dewarping_view.get(), SIGNAL(distortionModelChanged(dewarping::DistortionModel const&)),
opt_widget, SLOT(distortionModelChanged(dewarping::DistortionModel const&))
);
std::auto_ptr<QWidget> picture_zone_editor;
if (m_pictureMask.isNull()) {
picture_zone_editor.reset(
new ErrorWidget(tr("Picture zones are only available in Mixed mode."))
);
} else {
picture_zone_editor.reset(
new PictureZoneEditor(
m_origImage, downscaled_orig_pixmap, m_pictureMask,
m_xform.transform(), m_xform.resultingPostCropArea(),
m_pageId, m_ptrSettings
)
);
QObject::connect(
picture_zone_editor.get(), SIGNAL(invalidateThumbnail(PageId const&)),
opt_widget, SIGNAL(invalidateThumbnail(PageId const&))
);
}
// We make sure we never need to update the original <-> output
// mapping at run time, that is without reloading.
// In OptionsWidget::dewarpingChanged() we make sure to reload
// if we are on the "Fill Zones" tab, and if not, it will be reloaded
// anyway when another tab is selected.
boost::function<QPointF(QPointF const&)> orig_to_output;
boost::function<QPointF(QPointF const&)> output_to_orig;
if (m_params.dewarpingMode() != DewarpingMode::OFF && m_params.distortionModel().isValid()) {
boost::shared_ptr<DewarpingPointMapper> mapper(
new DewarpingPointMapper(
m_params.distortionModel(), m_params.depthPerception().value(),
m_xform.transform(), m_virtContentRect
)
);
orig_to_output = boost::bind(&DewarpingPointMapper::mapToDewarpedSpace, mapper, _1);
output_to_orig = boost::bind(&DewarpingPointMapper::mapToWarpedSpace, mapper, _1);
} else {
typedef QPointF (QTransform::*MapPointFunc)(QPointF const&) const;
orig_to_output = boost::bind((MapPointFunc)&QTransform::map, m_xform.transform(), _1);
output_to_orig = boost::bind((MapPointFunc)&QTransform::map, m_xform.transformBack(), _1);
}
std::auto_ptr<QWidget> fill_zone_editor(
new FillZoneEditor(
m_outputImage, downscaled_output_pixmap,
orig_to_output, output_to_orig, m_pageId, m_ptrSettings
)
);
QObject::connect(
fill_zone_editor.get(), SIGNAL(invalidateThumbnail(PageId const&)),
opt_widget, SIGNAL(invalidateThumbnail(PageId const&))
);
std::auto_ptr<QWidget> despeckle_view;
if (m_params.colorParams().colorMode() == ColorParams::COLOR_GRAYSCALE) {
despeckle_view.reset(
new ErrorWidget(tr("Despeckling can't be done in Color / Grayscale mode."))
);
} else {
despeckle_view.reset(
new DespeckleView(
m_despeckleState, m_despeckleVisualization, m_debug
)
);
QObject::connect(
opt_widget, SIGNAL(despeckleLevelChanged(DespeckleLevel, bool*)),
despeckle_view.get(), SLOT(despeckleLevelChanged(DespeckleLevel, bool*))
);
}
std::auto_ptr<TabbedImageView> tab_widget(new TabbedImageView);
tab_widget->setDocumentMode(true);
tab_widget->setTabPosition(QTabWidget::East);
tab_widget->addTab(image_view.release(), tr("Output"), TAB_OUTPUT);
tab_widget->addTab(picture_zone_editor.release(), tr("Picture Zones"), TAB_PICTURE_ZONES);
tab_widget->addTab(fill_zone_editor.release(), tr("Fill Zones"), TAB_FILL_ZONES);
tab_widget->addTab(dewarping_view.release(), tr("Dewarping"), TAB_DEWARPING);
tab_widget->addTab(despeckle_view.release(), tr("Despeckling"), TAB_DESPECKLING);
tab_widget->setCurrentTab(opt_widget->lastTab());
QObject::connect(
tab_widget.get(), SIGNAL(tabChanged(ImageViewTab)),
opt_widget, SLOT(tabChanged(ImageViewTab))
);
ui->setImageWidget(tab_widget.release(), ui->TRANSFER_OWNERSHIP, m_ptrDbg.get());
}
void MainWindow::createGUIWidgets(const QString modelFilePath ) {
cameras_ = Cameras::getInstance();
connect(cameras_.get(), SIGNAL(cameraAdded(int, QString)),
this, SLOT(addItemToCameraListWidget(int, QString)));
connect(cameras_.get(), SIGNAL(cameraNameModified(int, QString)),
this, SLOT(modifyCameraNameInListWidget(int, QString)));
connect(cameras_.get(), SIGNAL(cameraDeleted(int)),
this, SLOT(deleteItemInCameraListWidget(int)));
connect(cameras_.get(), SIGNAL(setSelectedCameraPropertiesInMainWindow(int, float, QString)),
this, SLOT(updateSelectedCameraProperties(int, float, QString)));
connect(this, SIGNAL(cameraListDoubleClicked(int)),
cameras_.get(), SLOT(setSelectedCamera(int)));
//ListWidget
lblCamerasList_ = new QLabel("Cameras");
lstWidgetCameras_ = new QListWidget();
connect(lstWidgetCameras_, SIGNAL(doubleClicked(QModelIndex)),
this, SLOT(onlstWidgetCamerasDoubleClicked(QModelIndex)));
//Selected Camera Info Widgets
lblCameraName_ = new QLabel("Name");
lnEditCameraName_ = new QLineEdit();
lblCameraName_->setBuddy(lnEditCameraName_);
lnEditCameraName_->setEnabled(false);
connect(lnEditCameraName_, SIGNAL(textEdited(QString)),
cameras_.get(), SLOT(setSelectedCameraName(QString)));
cameraNameLayout_ = new QHBoxLayout();
cameraNameLayout_->addWidget(lblCameraName_);
cameraNameLayout_->addWidget(lnEditCameraName_);
lblFOV_ = new QLabel("FOVx");
lblFOVValue_ = new QLabel("0");
sliderCameraFOVx_ = new QSlider(Qt::Horizontal);
sliderCameraFOVx_->setValue(0);
sliderCameraFOVx_->setEnabled(false);
connect(sliderCameraFOVx_, SIGNAL(valueChanged(int)),
lblFOVValue_, SLOT(setNum(int)));
connect(sliderCameraFOVx_, SIGNAL(sliderMoved(int)),
cameras_.get(), SLOT(setSelectedCameraFOV(int)));
connect(sliderCameraFOVx_, SIGNAL(sliderPressed()),
cameras_.get(), SLOT(setMemento()));
fovLayout_ = new QHBoxLayout();
fovLayout_->addWidget(lblFOV_);
fovLayout_->addWidget(lblFOVValue_);
fovLayout_->addWidget(sliderCameraFOVx_);
lblAspectRatio_ = new QLabel("Aspect Ratio");
spnBoxCameraAspectRatio_ = new QDoubleSpinBox();
spnBoxCameraAspectRatio_->setEnabled(false);
spnBoxCameraAspectRatio_->setSingleStep(0.1);
connect(spnBoxCameraAspectRatio_, SIGNAL(valueChanged(double)),
cameras_.get(), SLOT(setSelectedCameraAspectRatio(double)));
aspectRatioLayout_ = new QHBoxLayout();
aspectRatioLayout_->addWidget(lblAspectRatio_);
aspectRatioLayout_->addWidget(spnBoxCameraAspectRatio_);
selectedCameraInfoLayout_ = new QVBoxLayout();
selectedCameraInfoLayout_->addLayout(cameraNameLayout_);
selectedCameraInfoLayout_->addLayout(fovLayout_);
selectedCameraInfoLayout_->addLayout(aspectRatioLayout_);
//Buttons Widgets
btnUndo_ = new QPushButton();
btnUndo_->resize(64, 64);
btnUndo_->setIcon(QPixmap(":/assets/images/undo.png", 0, Qt::AutoColor));
btnUndo_->setIconSize(QSize(32, 32));
connect(btnUndo_, SIGNAL(clicked()),
cameras_.get(), SLOT(getMemento()));
btnDeleteCamera_ = new QPushButton();
btnDeleteCamera_->resize(64, 64);
btnDeleteCamera_->setIcon(QPixmap(":/assets/images/delete.png", 0, Qt::AutoColor));
btnDeleteCamera_->setIconSize(QSize(32, 32));
connect(btnDeleteCamera_, SIGNAL(pressed()),
cameras_.get(), SLOT(deleteSelectedCamera()));
btnCameraDragAndDrop_ = new QPushButton();
btnCameraDragAndDrop_->resize(64, 64);
btnCameraDragAndDrop_->setIcon(QPixmap(":/assets/images/camera.png", 0, Qt::AutoColor));
btnCameraDragAndDrop_->setIconSize(QSize(32, 32));
connect(btnCameraDragAndDrop_, SIGNAL(pressed()),
this, SLOT(onBtnCameraDragAndDropPressed()));
buttonsLayout_ = new QHBoxLayout();
buttonsLayout_->addStretch();
buttonsLayout_->addWidget(btnDeleteCamera_);
buttonsLayout_->addWidget(btnUndo_);
buttonsLayout_->addWidget(btnCameraDragAndDrop_);
//Checkbox Widget
chkBoxCamera180FOV_ = new QCheckBox("Show Full Coverage");
chkBoxCamera180FOV_->setChecked(false);
//MainWindow OpenGL Widgets
QGLFormat format;
format.setVersion(3,3);
format.setProfile(QGLFormat::CoreProfile);
format.setSampleBuffers(true);
format.setSamples(4);
glMainView_ = new MainView(format, modelFilePath);
glCameraView_ = new CameraView(glMainView_);
dockWidgetCameraView_ = new QDockWidget();
dockWidgetCameraView_->setAllowedAreas(Qt::NoDockWidgetArea);
dockWidgetCameraView_->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetFloatable);
dockWidgetCameraView_->setWidget(glCameraView_);
dockWidgetCameraView_->setWindowTitle("Selected Camera View");
connect(dockWidgetCameraView_, SIGNAL(topLevelChanged(bool)),
this, SLOT(cameraViewWidgetUndocked(bool)));
//Left Layout
leftMainWidget_ = new QWidget();
leftMainLayout_ = new QVBoxLayout(leftMainWidget_);
leftMainLayout_->addWidget(lblCamerasList_);
leftMainLayout_->addWidget(lstWidgetCameras_);
leftMainLayout_->addLayout(buttonsLayout_);
leftMainLayout_->addLayout(selectedCameraInfoLayout_);
leftMainLayout_->addWidget(chkBoxCamera180FOV_);
leftMainLayout_->addStretch(10);
leftMainLayout_->addWidget(dockWidgetCameraView_);
const float LEFT_MAIN_LAYOUT_WIDTH_FACTOR = 1 / 3.75f;
leftMainWidget_->setFixedWidth(this->width() * LEFT_MAIN_LAYOUT_WIDTH_FACTOR);
mainLayout_ = new QHBoxLayout();
mainLayout_->addWidget(leftMainWidget_);
mainLayout_->addWidget(glMainView_);
centralWidget_ = new QWidget();
centralWidget_->setLayout(mainLayout_);
this->setCentralWidget(centralWidget_); //now all QObjects created using "new" in this class are owned by MainWindow
connect(chkBoxCamera180FOV_, SIGNAL(toggled(bool)),
glMainView_, SLOT(toggelShowCamera180FOVView(bool)));
}
void
ProgressPanel::startTask(const NodePtr& node,
const TimeValue firstFrame,
const TimeValue lastFrame,
const TimeValue frameStep,
const bool canPause,
const bool canCancel,
const QString& message,
const ProcessHandlerPtr& process)
{
assert( QThread::currentThread() == qApp->thread() );
if (!node) {
return;
}
assert( (canPause && firstFrame != INT_MIN && lastFrame != INT_MAX) || !canPause );
ProgressTaskInfoPtr task;
{
QMutexLocker k(&_imp->tasksMutex);
task = _imp->findTask(node);
}
if (task) {
task->cancelTask(false, 1);
removeTaskFromTable(task);
}
QMutexLocker k(&_imp->tasksMutex);
task.reset( new ProgressTaskInfo(this,
node,
firstFrame,
lastFrame,
frameStep,
canPause,
canCancel,
message, process) );
if ( canPause || node->getEffectInstance()->isOutput() ) {
task->createItems();
QTimer::singleShot( NATRON_DISPLAY_PROGRESS_PANEL_AFTER_MS, this, SLOT(onShowProgressPanelTimerTriggered()) );
}
if (process) {
connectProcessSlots( task.get(), process.get() );
}
if (!process) {
if ( node->getEffectInstance()->isOutput() ) {
if ( getGui() && !getGui()->isGUIFrozen() && appPTR->getCurrentSettings()->isAutoTurboEnabled() ) {
getGui()->onFreezeUIButtonClicked(true);
}
RenderEnginePtr engine = node->getRenderEngine();
assert(engine);
QObject::connect( engine.get(), SIGNAL(frameRendered(int,double)), task.get(), SLOT(onRenderEngineFrameComputed(int,double)) );
QObject::connect( engine.get(), SIGNAL(renderFinished(int)), task.get(), SLOT(onRenderEngineStopped(int)) );
QObject::connect( task.get(), SIGNAL(taskCanceled()), engine.get(), SLOT(abortRendering_non_blocking()) );
}
}
_imp->tasks[node] = task;
} // ProgressPanel::startTask
CmpTreeDialog::CmpTreeDialog(QWidget* parent, Execution* execution, bool with_labels,
const Execution& ex1, const Execution& ex2)
: QDialog{parent} {
qDebug() << "new CmpTreeDialog";
auto main_layout = new QHBoxLayout();
layout = new QGridLayout(this);
auto nc_layout = new QVBoxLayout();
auto status_layout = new QVBoxLayout();
main_layout->addLayout(status_layout);
auto scrollArea = new QAbstractScrollArea(this);
m_Canvas.reset(new TreeCanvas(execution, layout, scrollArea->viewport()));
layout->addWidget(scrollArea, 0, 0, 1, 1);
layout->addWidget(m_Canvas->scaleBar(), 0, 1, Qt::AlignHCenter);
scrollArea->viewport()->setLayout(nc_layout);
connect(scrollArea->horizontalScrollBar(), SIGNAL(valueChanged(int)),
m_Canvas.get(), SLOT(scroll(void)));
connect(scrollArea->verticalScrollBar(), SIGNAL(valueChanged(int)),
m_Canvas.get(), SLOT(scroll(void)));
nc_layout->addWidget(m_Canvas.get());
auto menuBar = new QMenuBar(this);
auto nodeMenu = menuBar->addMenu(tr("&Node"));
auto analysisMenu = menuBar->addMenu(tr("&Analysis"));
addActions(nodeMenu, analysisMenu);
// Don't add the menu bar on Mac OS X
#ifndef Q_WS_MAC
layout->setMenuBar(menuBar);
#endif
statusBar = new QStatusBar(this);
QWidget* stw = new QWidget();
statusBar->addPermanentWidget(stw);
statusBar->showMessage("Ready");
layout->addWidget(statusBar);
auto hbl = new QHBoxLayout();
hbl->setContentsMargins(0,0,0,0);
hbl->addWidget(new NodeWidget(MERGING));
auto mergedLabel = new QLabel("0");
hbl->addWidget(mergedLabel);
stw->setLayout(hbl);
m_Cmp_result = treecomparison::compare(m_Canvas.get(), ex1, ex2, with_labels);
/// sort the pentagons by nodes diff:
m_Cmp_result->sortPentagons();
mergedLabel->setNum(m_Cmp_result->get_no_pentagons());
setAttribute( Qt::WA_DeleteOnClose );
m_Canvas->setCurrentNode(m_Canvas->getExecution()->nodeTree().getRoot());
resize(500, 400);
show();
}
