public:
explicit DOMFrame (wxString const& title)
: wxFrame (nullptr, -1, title)
+ /* Use a panel as the only child of the Frame so that we avoid
+ the dark-grey background on Windows.
+ */
+ , _overall_panel(new wxPanel(this, wxID_ANY))
+ , _film_viewer(_overall_panel)
{
#if defined(DCPOMATIC_WINDOWS)
if (Config::instance()->win32_console()) {
Bind (wxEVT_CLOSE_WINDOW, boost::bind (&DOMFrame::close, this, _1));
Bind (wxEVT_SHOW, boost::bind (&DOMFrame::show, this, _1));
- /* Use a panel as the only child of the Frame so that we avoid
- the dark-grey background on Windows.
- */
- auto overall_panel = new wxPanel (this, wxID_ANY);
-
- _film_viewer.reset (new FilmViewer (overall_panel));
- _controls = new StandardControls (overall_panel, _film_viewer, true);
- _film_editor = new FilmEditor (overall_panel, _film_viewer);
- auto job_manager_view = new JobManagerView (overall_panel, false);
+ _controls = new StandardControls(_overall_panel, _film_viewer, true);
+ _film_editor = new FilmEditor(_overall_panel, _film_viewer);
+ auto job_manager_view = new JobManagerView(_overall_panel, false);
auto right_sizer = new wxBoxSizer (wxVERTICAL);
- right_sizer->Add (_film_viewer->panel(), 2, wxEXPAND | wxALL, 6);
+ right_sizer->Add(_film_viewer.panel(), 2, wxEXPAND | wxALL, 6);
right_sizer->Add (_controls, 0, wxEXPAND | wxALL, 6);
right_sizer->Add (job_manager_view, 1, wxEXPAND | wxALL, 6);
JobManager::instance()->ActiveJobsChanged.connect(boost::bind(&DOMFrame::active_jobs_changed, this));
- overall_panel->SetSizer (main_sizer);
+ _overall_panel->SetSizer(main_sizer);
UpdateChecker::instance()->StateChanged.connect(boost::bind(&DOMFrame::update_checker_state_changed, this));
void set_film (shared_ptr<Film> film)
{
_film = film;
- _film_viewer->set_film (_film);
- _film_editor->set_film (_film);
+ _film_viewer.set_film(_film);
+ _film_editor->set_film(_film);
_controls->set_film (_film);
if (_video_waveform_dialog) {
_video_waveform_dialog->Destroy ();
void view_closed_captions ()
{
- _film_viewer->show_closed_captions ();
+ _film_viewer.show_closed_captions ();
}
void view_video_waveform ()
void start_stop_pressed ()
{
- if (_film_viewer->playing()) {
- _film_viewer->stop();
+ if (_film_viewer.playing()) {
+ _film_viewer.stop();
} else {
- _film_viewer->start();
+ _film_viewer.start();
}
}
void back_frame ()
{
- _film_viewer->seek_by (-_film_viewer->one_video_frame(), true);
+ _film_viewer.seek_by(-_film_viewer.one_video_frame(), true);
}
void forward_frame ()
{
- _film_viewer->seek_by (_film_viewer->one_video_frame(), true);
+ _film_viewer.seek_by(_film_viewer.one_video_frame(), true);
}
void analytics_message (string title, string html)
}
FilmEditor* _film_editor;
- std::shared_ptr<FilmViewer> _film_viewer;
+ wxPanel* _overall_panel;
+ FilmViewer _film_viewer;
StandardControls* _controls;
VideoWaveformDialog* _video_waveform_dialog = nullptr;
SystemInformationDialog* _system_information_dialog = nullptr;
DOMFrame ()
: wxFrame (nullptr, -1, _("DCP-o-matic Player"))
, _mode (Config::instance()->player_mode())
+ /* Use a panel as the only child of the Frame so that we avoid
+ the dark-grey background on Windows.
+ */
+ , _overall_panel(new wxPanel(this, wxID_ANY))
+ , _viewer(_overall_panel)
, _main_sizer (new wxBoxSizer(wxVERTICAL))
{
dcpomatic_log = make_shared<NullLog>();
Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_timing, this), ID_tools_timing);
Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_system_information, this), ID_tools_system_information);
- /* Use a panel as the only child of the Frame so that we avoid
- the dark-grey background on Windows.
- */
- _overall_panel = new wxPanel (this, wxID_ANY);
-
- _viewer = make_shared<FilmViewer>(_overall_panel);
if (Config::instance()->player_mode() == Config::PLAYER_MODE_DUAL) {
auto pc = new PlaylistControls (_overall_panel, _viewer);
_controls = pc;
} else {
_controls = new StandardControls (_overall_panel, _viewer, false);
}
- _viewer->set_dcp_decode_reduction (Config::instance()->decode_reduction ());
- _viewer->set_optimise_for_j2k (true);
- _viewer->PlaybackPermitted.connect (bind(&DOMFrame::playback_permitted, this));
- _viewer->TooManyDropped.connect (bind(&DOMFrame::too_many_frames_dropped, this));
+ _viewer.set_dcp_decode_reduction(Config::instance()->decode_reduction());
+ _viewer.set_optimise_for_j2k(true);
+ _viewer.PlaybackPermitted.connect(bind(&DOMFrame::playback_permitted, this));
+ _viewer.TooManyDropped.connect(bind(&DOMFrame::too_many_frames_dropped, this));
_info = new PlayerInformation (_overall_panel, _viewer);
setup_main_sizer (Config::instance()->player_mode());
#ifdef __WXOSX__
/* It's important that this is stopped before our frame starts destroying its children,
* otherwise UI elements that it depends on will disappear from under it.
*/
- _viewer.reset ();
+ _viewer.stop();
}
void setup_main_sizer (Config::PlayerMode mode)
{
- _main_sizer->Detach (_viewer->panel());
+ _main_sizer->Detach(_viewer.panel());
_main_sizer->Detach (_controls);
_main_sizer->Detach (_info);
if (mode != Config::PLAYER_MODE_DUAL) {
- _main_sizer->Add (_viewer->panel(), 1, wxEXPAND);
+ _main_sizer->Add(_viewer.panel(), 1, wxEXPAND);
}
_main_sizer->Add (_controls, mode == Config::PLAYER_MODE_DUAL ? 1 : 0, wxEXPAND | wxALL, 6);
_main_sizer->Add (_info, 0, wxEXPAND | wxALL, 6);
void too_many_frames_dropped ()
{
if (!Config::instance()->nagged(Config::NAG_TOO_MANY_DROPPED_FRAMES)) {
- _viewer->stop ();
+ _viewer.stop();
}
NagDialog::maybe_nag (
void set_decode_reduction (optional<int> reduction)
{
- _viewer->set_dcp_decode_reduction (reduction);
+ _viewer.set_dcp_decode_reduction(reduction);
_info->triggered_update ();
Config::instance()->set_decode_reduction (reduction);
}
_film = film;
_film->set_tolerant (true);
_film->set_audio_channels (MAX_DCP_AUDIO_CHANNELS);
- _viewer->set_film (_film);
+ _viewer.set_film(_film);
_controls->set_film (_film);
_film->Change.connect (bind(&DOMFrame::film_changed, this, _1, _2));
_info->triggered_update ();
return;
}
- if (_viewer->playing ()) {
- _viewer->stop ();
+ if (_viewer.playing()) {
+ _viewer.stop();
}
/* Start off as Flat */
}
}
- _viewer->seek (DCPTime(), true);
+ _viewer.seek(DCPTime(), true);
_info->triggered_update ();
set_menu_sensitivity ();
DCPOMATIC_ASSERT (dcp);
try {
if (dcp) {
- _viewer->set_coalesce_player_changes (true);
+ _viewer.set_coalesce_player_changes(true);
dcp->add_kdm (dcp::EncryptedKDM(dcp::file_to_string(wx_to_std(d->GetPath()), MAX_KDM_SIZE)));
examine_content();
- _viewer->set_coalesce_player_changes (false);
+ _viewer.set_coalesce_player_changes(false);
}
} catch (exception& e) {
error_dialog (this, wxString::Format (_("Could not load KDM.")), std_to_wx(e.what()));
auto path = boost::filesystem::path (wx_to_std(dialog.GetPath()));
auto player = make_shared<Player>(_film, Image::Alignment::PADDED);
- player->seek (_viewer->position(), true);
+ player->seek(_viewer.position(), true);
bool done = false;
player->Video.connect ([path, &done, this](shared_ptr<PlayerVideo> video, DCPTime) {
--id;
}
- _viewer->set_coalesce_player_changes (true);
+ _viewer.set_coalesce_player_changes(true);
dcp->set_cpl ((*i)->id());
examine_content ();
- _viewer->set_coalesce_player_changes (false);
+ _viewer.set_coalesce_player_changes(false);
_info->triggered_update ();
}
_info->Show (_mode != Config::PLAYER_MODE_FULL);
_overall_panel->SetBackgroundColour (_mode == Config::PLAYER_MODE_FULL ? wxColour(0, 0, 0) : wxNullColour);
ShowFullScreen (_mode == Config::PLAYER_MODE_FULL);
- _viewer->set_pad_black (_mode != Config::PLAYER_MODE_WINDOW);
+ _viewer.set_pad_black(_mode != Config::PLAYER_MODE_WINDOW);
if (_mode == Config::PLAYER_MODE_DUAL) {
_dual_screen = new wxFrame (this, wxID_ANY, wxT(""));
_dual_screen->SetBackgroundColour (wxColour(0, 0, 0));
_dual_screen->ShowFullScreen (true);
- _viewer->panel()->Reparent (_dual_screen);
- _viewer->panel()->SetFocus();
+ _viewer.panel()->Reparent(_dual_screen);
+ _viewer.panel()->SetFocus();
_dual_screen->Show ();
if (wxDisplay::GetCount() > 1) {
switch (Config::instance()->image_display()) {
_dual_screen->Bind(wxEVT_CHAR_HOOK, boost::bind(&DOMFrame::dual_screen_key_press, this, _1));
} else {
if (_dual_screen) {
- _viewer->panel()->Reparent (_overall_panel);
+ _viewer.panel()->Reparent(_overall_panel);
_dual_screen->Destroy ();
_dual_screen = 0;
}
void view_closed_captions ()
{
- _viewer->show_closed_captions ();
+ _viewer.show_closed_captions();
}
void tools_verify ()
void tools_timing ()
{
- auto d = new TimerDisplay (this, _viewer->state_timer(), _viewer->gets());
+ auto d = new TimerDisplay(this, _viewer.state_timer(), _viewer.gets());
d->ShowModal ();
d->Destroy ();
}
void start_stop_pressed ()
{
- if (_viewer->playing()) {
- _viewer->stop();
+ if (_viewer.playing()) {
+ _viewer.stop();
} else {
- _viewer->start();
+ _viewer.start();
}
}
void go_back_frame ()
{
- _viewer->seek_by (-_viewer->one_video_frame(), true);
+ _viewer.seek_by(-_viewer.one_video_frame(), true);
}
void go_forward_frame ()
{
- _viewer->seek_by (_viewer->one_video_frame(), true);
+ _viewer.seek_by(_viewer.one_video_frame(), true);
}
void go_seconds (int s)
{
- _viewer->seek_by (DCPTime::from_seconds(s), true);
+ _viewer.seek_by(DCPTime::from_seconds(s), true);
}
void go_to_start ()
{
- _viewer->seek (DCPTime(), true);
+ _viewer.seek(DCPTime(), true);
}
void go_to_end ()
{
- _viewer->seek (_film->length() - _viewer->one_video_frame(), true);
+ _viewer.seek(_film->length() - _viewer.one_video_frame(), true);
}
wxFrame* _dual_screen = nullptr;
int _history_items = 0;
int _history_position = 0;
wxMenuItem* _history_separator = nullptr;
- shared_ptr<FilmViewer> _viewer;
+ FilmViewer _viewer;
Controls* _controls;
SystemInformationDialog* _system_information_dialog = nullptr;
std::shared_ptr<Film> _film;
* @param film Film we are using.
* @param content Content to analyse, or 0 to analyse all of the film's audio.
*/
-AudioDialog::AudioDialog (wxWindow* parent, shared_ptr<Film> film, weak_ptr<FilmViewer> viewer, shared_ptr<Content> content)
+AudioDialog::AudioDialog (wxWindow* parent, shared_ptr<Film> film, FilmViewer& viewer, shared_ptr<Content> content)
: wxDialog (
parent,
wxID_ANY,
class AudioDialog : public wxDialog
{
public:
- AudioDialog (wxWindow* parent, std::shared_ptr<Film> film, std::weak_ptr<FilmViewer> viewer, std::shared_ptr<Content> content = std::shared_ptr<Content>());
+ AudioDialog(wxWindow* parent, std::shared_ptr<Film> film, FilmViewer& viewer, std::shared_ptr<Content> content = std::shared_ptr<Content>());
bool Show (bool show = true) override;
std::shared_ptr<AudioAnalysis> _analysis;
std::weak_ptr<Film> _film;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
/** content to analyse, or 0 to analyse all the film's content */
std::weak_ptr<Content> _content;
int _channels;
int const AudioPlot::max_smoothing = 128;
-AudioPlot::AudioPlot (wxWindow* parent, weak_ptr<FilmViewer> viewer)
+AudioPlot::AudioPlot(wxWindow* parent, FilmViewer& viewer)
: wxPanel (parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE)
, _viewer (viewer)
, _smoothing (max_smoothing / 2)
AudioPlot::left_down ()
{
if (_cursor) {
- if (auto fv = _viewer.lock()) {
- fv->seek (_cursor->time, true);
- }
+ _viewer.seek(_cursor->time, true);
}
}
class AudioPlot : public wxPanel
{
public:
- explicit AudioPlot (wxWindow *, std::weak_ptr<FilmViewer> viewer);
+ explicit AudioPlot (wxWindow *, FilmViewer& viewer);
void set_analysis (std::shared_ptr<AudioAnalysis>);
void set_channel_visible (int c, bool v);
void mouse_moved (wxMouseEvent& ev);
void mouse_leave (wxMouseEvent& ev);
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
std::shared_ptr<AudioAnalysis> _analysis;
bool _channel_visible[MAX_DCP_AUDIO_CHANNELS];
bool _type_visible[AudioPoint::COUNT];
};
-ContentMenu::ContentMenu (wxWindow* p, weak_ptr<FilmViewer> viewer)
+ContentMenu::ContentMenu(wxWindow* p, FilmViewer& viewer)
: _menu (new wxMenu)
, _parent (p)
, _pop_up_open (false)
auto film = _film.lock ();
DCPOMATIC_ASSERT (film);
- auto viewer = _viewer.lock ();
- DCPOMATIC_ASSERT (viewer);
auto update_viewer = [this](Crop crop) {
auto film = _film.lock();
DCPOMATIC_ASSERT (film);
- auto viewer = _viewer.lock ();
- DCPOMATIC_ASSERT (viewer);
auto const content = _content.front();
auto const current_crop = content->video->actual_crop();
- viewer->set_crop_guess (
+ _viewer.set_crop_guess(
dcpomatic::Rect<float>(
static_cast<float>(std::max(0, crop.left - current_crop.left)) / content->video->size().width,
static_cast<float>(std::max(0, crop.top - current_crop.top)) / content->video->size().height,
));
};
- auto guess_crop_for_content = [this, film, viewer]() {
- auto position = viewer->position_in_content(_content.front()).get_value_or(
+ auto guess_crop_for_content = [this, film]() {
+ auto position = _viewer.position_in_content(_content.front()).get_value_or(
ContentTime::from_frames(_content.front()->video->length(), _content.front()->video_frame_rate().get_value_or(24))
);
return guess_crop(film, _content.front(), Config::instance()->auto_crop_threshold(), position);
});
/* Also update the dialog and view when we're looking at a different frame */
- _auto_crop_viewer_connection = viewer->ImageChanged.connect([this, guess_crop_for_content, update_viewer](shared_ptr<PlayerVideo>) {
+ _auto_crop_viewer_connection = _viewer.ImageChanged.connect([this, guess_crop_for_content, update_viewer](shared_ptr<PlayerVideo>) {
auto const crop = guess_crop_for_content();
_auto_crop_dialog->set(crop);
update_viewer(crop);
});
/* Handle the user closing the dialog (with OK or cancel) */
- _auto_crop_dialog->Bind (wxEVT_BUTTON, [this, viewer](wxCommandEvent& ev) {
+ _auto_crop_dialog->Bind(wxEVT_BUTTON, [this](wxCommandEvent& ev) {
_auto_crop_config_connection.disconnect ();
_auto_crop_viewer_connection.disconnect ();
if (ev.GetId() == wxID_OK) {
_content.front()->video->set_crop(_auto_crop_dialog->get());
}
_auto_crop_dialog->Show (false);
- viewer->unset_crop_guess ();
+ _viewer.unset_crop_guess ();
});
/* Update the view when something in the dialog is changed */
class ContentMenu
{
public:
- ContentMenu (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
+ ContentMenu(wxWindow* parent, FilmViewer& viewer);
ContentMenu (ContentMenu const &) = delete;
ContentMenu& operator= (ContentMenu const &) = delete;
std::weak_ptr<Film> _film;
wxWindow* _parent;
bool _pop_up_open;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
ContentList _content;
TimelineContentViewList _views;
wxMenuItem* _repeat;
};
-ContentPanel::ContentPanel (wxNotebook* n, shared_ptr<Film> film, weak_ptr<FilmViewer> viewer)
+ContentPanel::ContentPanel(wxNotebook* n, shared_ptr<Film> film, FilmViewer& viewer)
: _parent (n)
, _film (film)
, _film_viewer (viewer)
}
if (go_to && Config::instance()->jump_to_selected() && signal_manager) {
- auto fv = _film_viewer.lock ();
- DCPOMATIC_ASSERT (fv);
- signal_manager->when_idle(boost::bind(&FilmViewer::seek, fv.get(), go_to.get().ceil(_film->video_frame_rate()), true));
+ signal_manager->when_idle(boost::bind(&FilmViewer::seek, &_film_viewer, go_to.get().ceil(_film->video_frame_rate()), true));
}
if (_timeline_dialog) {
class ContentPanel
{
public:
- ContentPanel (wxNotebook *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
+ ContentPanel(wxNotebook *, std::shared_ptr<Film>, FilmViewer& viewer);
ContentPanel (ContentPanel const&) = delete;
ContentPanel& operator= (ContentPanel const&) = delete;
bool remove_clicked (bool hotkey);
void timeline_clicked ();
- std::weak_ptr<FilmViewer> film_viewer () const {
+ FilmViewer& film_viewer() const {
return _film_viewer;
}
wxWindow* _last_selected_tab = nullptr;
std::shared_ptr<Film> _film;
- std::weak_ptr<FilmViewer> _film_viewer;
+ FilmViewer& _film_viewer;
bool _generally_sensitive;
bool _ignore_deselect;
bool _no_check_selection;
using namespace dcpomatic;
-Controls::Controls (wxWindow* parent, shared_ptr<FilmViewer> viewer, bool editor_controls)
+Controls::Controls(wxWindow* parent, FilmViewer& viewer, bool editor_controls)
: wxPanel (parent)
, _markers (new MarkersPanel(this, viewer))
, _slider (new wxSlider(this, wxID_ANY, 0, 0, 4096))
_jump_to_selected->SetValue (Config::instance()->jump_to_selected ());
}
- viewer->Started.connect (boost::bind(&Controls::started, this));
- viewer->Stopped.connect (boost::bind(&Controls::stopped, this));
+ viewer.Started.connect (boost::bind(&Controls::started, this));
+ viewer.Stopped.connect (boost::bind(&Controls::stopped, this));
Bind (wxEVT_TIMER, boost::bind(&Controls::update_position, this));
_timer.Start (80, wxTIMER_CONTINUOUS);
- set_film (viewer->film());
+ set_film(viewer.film());
setup_sensitivity ();
void
Controls::update_position ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- if (!_slider_being_moved && !viewer->pending_idle_get()) {
+ if (!_slider_being_moved && !_viewer.pending_idle_get()) {
update_position_label ();
update_position_slider ();
}
void
Controls::eye_changed ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- viewer->set_eyes (_eye->GetSelection() == 0 ? Eyes::LEFT : Eyes::RIGHT);
+ _viewer.set_eyes(_eye->GetSelection() == 0 ? Eyes::LEFT : Eyes::RIGHT);
}
void
Controls::outline_content_changed ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- viewer->set_outline_content (_outline_content->GetValue());
+ _viewer.set_outline_content(_outline_content->GetValue());
}
void
Controls::slider_moved (bool page)
{
- auto viewer = _viewer.lock ();
- if (!_film || !viewer) {
+ if (!_film) {
return;
}
if (!page && !_slider_being_moved) {
/* This is the first event of a drag; stop playback for the duration of the drag */
- viewer->suspend ();
+ _viewer.suspend();
_slider_being_moved = true;
}
*/
bool accurate = false;
if (t >= _film->length ()) {
- t = _film->length() - viewer->one_video_frame();
+ t = _film->length() - _viewer.one_video_frame();
accurate = true;
}
- viewer->seek (t, accurate);
+ _viewer.seek(t, accurate);
update_position_label ();
}
void
Controls::slider_released ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
/* Restart after a drag */
- viewer->resume ();
+ _viewer.resume();
_slider_being_moved = false;
}
return;
}
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
auto const len = _film->length ();
if (len.get ()) {
- int const new_slider_position = 4096 * viewer->position().get() / len.get();
+ int const new_slider_position = 4096 * _viewer.position().get() / len.get();
if (new_slider_position != _slider->GetValue()) {
_slider->SetValue (new_slider_position);
}
return;
}
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
double const fps = _film->video_frame_rate ();
/* Count frame number from 1 ... not sure if this is the best idea */
- checked_set (_frame_number, wxString::Format (wxT("%ld"), lrint (viewer->position().seconds() * fps) + 1));
- checked_set (_timecode, time_to_timecode (viewer->position(), fps));
+ checked_set(_frame_number, wxString::Format (wxT("%ld"), lrint(_viewer.position().seconds() * fps) + 1));
+ checked_set(_timecode, time_to_timecode(_viewer.position(), fps));
}
DCPTime
Controls::nudge_amount (wxKeyboardState& ev)
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return {};
- }
-
- auto amount = viewer->one_video_frame ();
+ auto amount = _viewer.one_video_frame();
if (ev.ShiftDown() && !ev.ControlDown()) {
amount = DCPTime::from_seconds (1);
void
Controls::rewind_clicked (wxMouseEvent& ev)
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->seek (DCPTime(), true);
- }
+ _viewer.seek(DCPTime(), true);
ev.Skip();
}
void
Controls::back_frame ()
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->seek_by (-viewer->one_video_frame(), true);
- }
+ _viewer.seek_by(-_viewer.one_video_frame(), true);
}
void
Controls::forward_frame ()
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->seek_by (viewer->one_video_frame(), true);
- }
+ _viewer.seek_by(_viewer.one_video_frame(), true);
}
void
Controls::back_clicked (wxKeyboardState& ev)
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->seek_by (-nudge_amount(ev), true);
- }
+ _viewer.seek_by(-nudge_amount(ev), true);
}
void
Controls::forward_clicked (wxKeyboardState& ev)
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->seek_by (nudge_amount(ev), true);
- }
+ _viewer.seek_by(nudge_amount(ev), true);
}
void
Controls::timecode_clicked ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- auto dialog = new PlayheadToTimecodeDialog (this, viewer->position(), _film->video_frame_rate());
+ auto dialog = new PlayheadToTimecodeDialog(this, _viewer.position(), _film->video_frame_rate());
if (dialog->ShowModal() == wxID_OK) {
- viewer->seek (dialog->get(), true);
+ _viewer.seek(dialog->get(), true);
}
dialog->Destroy ();
}
void
Controls::frame_number_clicked ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- auto dialog = new PlayheadToFrameDialog (this, viewer->position(), _film->video_frame_rate());
+ auto dialog = new PlayheadToFrameDialog(this, _viewer.position(), _film->video_frame_rate());
if (dialog->ShowModal() == wxID_OK) {
- viewer->seek (dialog->get(), true);
+ _viewer.seek(dialog->get(), true);
}
dialog->Destroy ();
}
public:
Controls (
wxWindow* parent,
- std::shared_ptr<FilmViewer>,
+ FilmViewer &,
bool editor_controls = true
);
std::shared_ptr<Film> _film;
MarkersPanel* _markers;
wxSlider* _slider;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
boost::optional<std::string> _active_job;
private:
using dcp::locale_convert;
-DCPPanel::DCPPanel (wxNotebook* n, shared_ptr<Film> film, weak_ptr<FilmViewer> viewer)
+DCPPanel::DCPPanel(wxNotebook* n, shared_ptr<Film> film, FilmViewer& viewer)
: _film (film)
, _viewer (viewer)
, _generally_sensitive (true)
class DCPPanel
{
public:
- DCPPanel (wxNotebook *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
+ DCPPanel(wxNotebook *, std::shared_ptr<Film>, FilmViewer& viewer);
DCPPanel (DCPPanel const&) = delete;
DCPPanel& operator= (DCPPanel const&) = delete;
SMPTEMetadataDialog* _smpte_metadata_dialog = nullptr;
std::shared_ptr<Film> _film;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
bool _generally_sensitive;
};
#endif
-FilmEditor::FilmEditor (wxWindow* parent, weak_ptr<FilmViewer> viewer)
+FilmEditor::FilmEditor(wxWindow* parent, FilmViewer& viewer)
: wxPanel (parent)
{
auto s = new wxBoxSizer (wxVERTICAL);
class FilmEditor : public wxPanel
{
public:
- FilmEditor (wxWindow *, std::weak_ptr<FilmViewer> viewer);
+ FilmEditor(wxWindow *, FilmViewer& viewer);
void set_film (std::shared_ptr<Film>);
void first_shown ();
class Marker
{
public:
- Marker (wxWindow* parent, wxGridBagSizer* grid, int row, weak_ptr<Film> film_, weak_ptr<FilmViewer> viewer_, wxString name, dcp::Marker type_)
+ Marker(wxWindow* parent, wxGridBagSizer* grid, int row, weak_ptr<Film> film_, FilmViewer const& viewer_, wxString name, dcp::Marker type_)
: film (film_)
, viewer (viewer_)
, type (type_)
{
auto f = film.lock ();
DCPOMATIC_ASSERT (f);
- auto v = viewer.lock ();
- DCPOMATIC_ASSERT (v);
- timecode->set (v->position(), f->video_frame_rate());
+ timecode->set(viewer.position(), f->video_frame_rate());
changed ();
}
}
weak_ptr<Film> film;
- weak_ptr<FilmViewer> viewer;
+ FilmViewer const& viewer;
dcp::Marker type;
CheckBox* checkbox;
Timecode<dcpomatic::DCPTime>* timecode;
};
-MarkersDialog::MarkersDialog (wxWindow* parent, weak_ptr<Film> film, weak_ptr<FilmViewer> viewer)
+MarkersDialog::MarkersDialog(wxWindow* parent, weak_ptr<Film> film, FilmViewer const& viewer)
: wxDialog (parent, wxID_ANY, _("Markers"))
, _film (film)
{
class MarkersDialog : public wxDialog
{
public:
- MarkersDialog (wxWindow* parent, std::weak_ptr<Film> film, std::weak_ptr<FilmViewer> viewer);
+ MarkersDialog (wxWindow* parent, std::weak_ptr<Film> film, FilmViewer const& viewer);
private:
std::list<std::shared_ptr<Marker>> _markers;
static constexpr auto line_to_label_gap = 2;
-MarkersPanel::MarkersPanel (wxWindow* parent, weak_ptr<FilmViewer> viewer)
+MarkersPanel::MarkersPanel(wxWindow* parent, FilmViewer& viewer)
: wxPanel (parent, wxID_ANY, wxDefaultPosition, wxSize(-1, 16))
, _viewer (viewer)
{
MarkersPanel::mouse_left_down ()
{
if (_over) {
- auto viewer = _viewer.lock ();
- DCPOMATIC_ASSERT (viewer);
- viewer->seek (_markers[*_over].time, true);
+ _viewer.seek(_markers[*_over].time, true);
}
}
MarkersPanel::move_marker_to_current_position ()
{
auto film = _film.lock ();
- auto viewer = _viewer.lock ();
- if (!film || !viewer || !_menu_marker) {
+ if (!film || !_menu_marker) {
return;
}
- film->set_marker (*_menu_marker, viewer->position());
+ film->set_marker(*_menu_marker, _viewer.position());
}
MarkersPanel::remove_marker ()
{
auto film = _film.lock ();
- auto viewer = _viewer.lock ();
- if (!film || !viewer || !_menu_marker) {
+ if (!film || !_menu_marker) {
return;
}
- film->unset_marker (*_menu_marker);
+ film->unset_marker(*_menu_marker);
}
MarkersPanel::add_marker (wxCommandEvent& ev)
{
auto film = _film.lock ();
- auto viewer = _viewer.lock ();
- if (!film || !viewer) {
+ if (!film) {
return;
}
auto marker = static_cast<dcp::Marker>(ev.GetId() - ID_add_base);
- film->set_marker (marker, viewer->position());
+ film->set_marker(marker, _viewer.position());
}
class MarkersPanel : public wxPanel
{
public:
- MarkersPanel (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
+ MarkersPanel(wxWindow* parent, FilmViewer& viewer);
void set_film (std::weak_ptr<Film> film);
std::weak_ptr<Film> _film;
std::map<dcp::Marker, Marker> _markers;
boost::optional<dcp::Marker> _over;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
boost::optional<dcp::Marker> _menu_marker;
};
static int const dcp_lines = 6;
-PlayerInformation::PlayerInformation (wxWindow* parent, weak_ptr<FilmViewer> viewer)
+PlayerInformation::PlayerInformation(wxWindow* parent, FilmViewer const& viewer)
: wxPanel (parent)
, _viewer (viewer)
, _sizer (new wxBoxSizer (wxHORIZONTAL))
void
PlayerInformation::periodic_update ()
{
- auto fv = _viewer.lock ();
- if (fv) {
- auto s = wxString::Format(_("Dropped frames: %d"), fv->dropped() + fv->errored());
- if (fv->errored() == 1) {
- s += wxString::Format(_(" (%d error)"), fv->errored());
- } else if (fv->errored() > 1) {
- s += wxString::Format(_(" (%d errors)"), fv->errored());
- }
- checked_set (_dropped, s);
+ auto s = wxString::Format(_("Dropped frames: %d"), _viewer.dropped() + _viewer.errored());
+ if (_viewer.errored() == 1) {
+ s += wxString::Format(_(" (%d error)"), _viewer.errored());
+ } else if (_viewer.errored() > 1) {
+ s += wxString::Format(_(" (%d errors)"), _viewer.errored());
}
+ checked_set (_dropped, s);
}
void
PlayerInformation::triggered_update ()
{
- auto fv = _viewer.lock ();
- if (!fv) {
- return;
- }
-
shared_ptr<DCPContent> dcp;
- if (fv->film()) {
- auto content = fv->film()->content();
+ if (_viewer.film()) {
+ auto content = _viewer.film()->content();
if (content.size() == 1) {
dcp = dynamic_pointer_cast<DCPContent>(content.front());
}
auto const len = String::compose(
wx_to_std(_("Length: %1 (%2 frames)")),
- time_to_hmsf(dcp->full_length(fv->film()), lrint(*vfr)),
- dcp->full_length(fv->film()).frames_round(*vfr)
+ time_to_hmsf(dcp->full_length(_viewer.film()), lrint(*vfr)),
+ dcp->full_length(_viewer.film()).frames_round(*vfr)
);
checked_set (_dcp[r++], std_to_wx(len));
auto decode = dcp->video->size();
- auto reduction = fv->dcp_decode_reduction();
+ auto reduction = _viewer.dcp_decode_reduction();
if (reduction) {
decode.width /= pow(2, *reduction);
decode.height /= pow(2, *reduction);
class PlayerInformation : public wxPanel
{
public:
- PlayerInformation (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
+ PlayerInformation(wxWindow* parent, FilmViewer const& viewer);
void triggered_update ();
void periodic_update ();
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer const& _viewer;
wxPanel* _kdm_panel;
wxSizer* _sizer;
wxStaticText** _dcp;
using namespace dcpomatic;
-PlaylistControls::PlaylistControls (wxWindow* parent, shared_ptr<FilmViewer> viewer)
+PlaylistControls::PlaylistControls(wxWindow* parent, FilmViewer& viewer)
: Controls (parent, viewer, false)
, _play_button (new Button(this, _("Play")))
, _pause_button (new Button(this, _("Pause")))
_previous_button->Bind (wxEVT_BUTTON, boost::bind(&PlaylistControls::previous_clicked, this));
_spl_view->Bind (wxEVT_LIST_ITEM_SELECTED, boost::bind(&PlaylistControls::spl_selection_changed, this));
_spl_view->Bind (wxEVT_LIST_ITEM_DESELECTED, boost::bind(&PlaylistControls::spl_selection_changed, this));
- viewer->Finished.connect (boost::bind(&PlaylistControls::viewer_finished, this));
+ _viewer.Finished.connect(boost::bind(&PlaylistControls::viewer_finished, this));
_refresh_spl_view->Bind (wxEVT_BUTTON, boost::bind(&PlaylistControls::update_playlist_directory, this));
_refresh_content_view->Bind (wxEVT_BUTTON, boost::bind(&ContentView::update, _content_view));
_selected_playlist = boost::none;
_spl_view->SetItemState (selected, 0, wxLIST_STATE_SELECTED);
}
- ResetFilm (shared_ptr<Film>(new Film(optional<boost::filesystem::path>())));
+ ResetFilm(std::make_shared<Film>(optional<boost::filesystem::path>()));
}
void
PlaylistControls::play_clicked ()
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->start ();
- }
+ _viewer.start();
}
void
PlaylistControls::setup_sensitivity ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
Controls::setup_sensitivity ();
bool const active_job = _active_job && *_active_job != "examine_content";
bool const c = _film && !_film->content().empty() && !active_job;
- _play_button->Enable (c && !viewer->playing());
- _pause_button->Enable (viewer->playing());
- _spl_view->Enable (!viewer->playing());
+ _play_button->Enable(c && !_viewer.playing());
+ _pause_button->Enable(_viewer.playing());
+ _spl_view->Enable(!_viewer.playing());
_next_button->Enable (can_do_next());
_previous_button->Enable (can_do_previous());
}
void
PlaylistControls::pause_clicked ()
{
- auto viewer = _viewer.lock ();
- if (viewer) {
- viewer->stop ();
- }
+ _viewer.stop();
}
void
PlaylistControls::stop_clicked ()
{
- auto viewer = _viewer.lock ();
- if (!viewer) {
- return;
- }
-
- viewer->stop ();
- viewer->seek (DCPTime(), true);
+ _viewer.stop();
+ _viewer.seek(DCPTime(), true);
if (_selected_playlist) {
_selected_playlist_position = 0;
update_current_content ();
void
PlaylistControls::viewer_finished ()
{
- auto viewer = _viewer.lock ();
- if (!_selected_playlist || !viewer) {
+ if (!_selected_playlist) {
return;
}
if (_selected_playlist_position < int(_playlists[*_selected_playlist].get().size())) {
/* Next piece of content on the SPL */
update_current_content ();
- viewer->start ();
+ _viewer.start();
} else {
/* Finished the whole SPL */
_selected_playlist_position = 0;
- ResetFilm (shared_ptr<Film>(new Film(optional<boost::filesystem::path>())));
+ ResetFilm(std::make_shared<Film>(optional<boost::filesystem::path>()));
_play_button->Enable (true);
_pause_button->Enable (false);
}
class PlaylistControls : public Controls
{
public:
- PlaylistControls (wxWindow* parent, std::shared_ptr<FilmViewer> viewer);
+ PlaylistControls(wxWindow* parent, FilmViewer& viewer);
void set_film (std::shared_ptr<Film> film) override;
using std::shared_ptr;
-StandardControls::StandardControls (wxWindow* parent, shared_ptr<FilmViewer> viewer, bool editor_controls)
+StandardControls::StandardControls(wxWindow* parent, FilmViewer& viewer, bool editor_controls)
: Controls (parent, viewer, editor_controls)
, _play_button (new wxToggleButton(this, wxID_ANY, _("Play")))
{
void
StandardControls::check_play_state ()
{
- auto viewer = _viewer.lock ();
- if (!_film || _film->video_frame_rate() == 0 || !viewer) {
+ if (!_film || _film->video_frame_rate() == 0) {
return;
}
if (_play_button->GetValue()) {
- viewer->start ();
+ _viewer.start();
} else {
- viewer->stop ();
+ _viewer.stop();
}
}
class StandardControls : public Controls
{
public:
- StandardControls (wxWindow* parent, std::shared_ptr<FilmViewer> viewer, bool editor_controls);
+ StandardControls(wxWindow* parent, FilmViewer& viewer, bool editor_controls);
void play () override;
void stop () override;
#if wxCHECK_VERSION(3, 1, 0)
-SystemInformationDialog::SystemInformationDialog (wxWindow* parent, weak_ptr<FilmViewer> weak_viewer)
+SystemInformationDialog::SystemInformationDialog(wxWindow* parent, FilmViewer const& viewer)
: TableDialog (parent, _("System information"), 2, 1, false)
{
- auto viewer = weak_viewer.lock ();
- shared_ptr<const GLVideoView> gl;
- if (viewer) {
- gl = std::dynamic_pointer_cast<const GLVideoView>(viewer->video_view());
- }
+ auto gl = std::dynamic_pointer_cast<const GLVideoView>(viewer.video_view());
if (!gl) {
add (_("OpenGL version"), true);
add (_("unknown (OpenGL not enabled in DCP-o-matic)"), false);
} else {
-
auto information = gl->information();
auto add_string = [this, &information](GLenum name, wxString label) {
add (label, true);
#else
-SystemInformationDialog::SystemInformationDialog (wxWindow* parent, weak_ptr<FilmViewer>)
+SystemInformationDialog::SystemInformationDialog(wxWindow* parent, FilmViewer&)
: TableDialog (parent, _("System information"), 2, 1, false)
{
add (_("OpenGL version"), true);
class SystemInformationDialog : public TableDialog
{
public:
- SystemInformationDialog (wxWindow* parent, std::weak_ptr<FilmViewer> viewer);
+ SystemInformationDialog(wxWindow* parent, FilmViewer const& viewer);
};
void
TextPanel::update_outline_subtitles_in_viewer ()
{
- auto fv = _parent->film_viewer().lock();
- if (!fv) {
- return;
- }
+ auto& fv = _parent->film_viewer();
if (_analysis) {
auto rect = _analysis->bounding_box ();
rect->x += content->text.front()->x_offset() - _analysis->analysis_x_offset();
rect->y += content->text.front()->y_offset() - _analysis->analysis_y_offset();
}
- fv->set_outline_subtitles (rect);
+ fv.set_outline_subtitles(rect);
} else {
- fv->set_outline_subtitles ({});
+ fv.set_outline_subtitles({});
}
}
using std::dynamic_pointer_cast;
using std::list;
using std::shared_ptr;
-using std::weak_ptr;
using boost::bind;
using namespace dcpomatic;
#if BOOST_VERSION >= 106100
TextView::TextView (
- wxWindow* parent, shared_ptr<Film> film, shared_ptr<Content> content, shared_ptr<TextContent> text, shared_ptr<Decoder> decoder, weak_ptr<FilmViewer> viewer
+ wxWindow* parent, shared_ptr<Film> film, shared_ptr<Content> content, shared_ptr<TextContent> text, shared_ptr<Decoder> decoder, FilmViewer& viewer
)
: wxDialog (parent, wxID_ANY, _("Captions"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
, _content (content)
DCPOMATIC_ASSERT (ev.GetIndex() < int(_start_times.size()));
auto lc = _content.lock ();
DCPOMATIC_ASSERT (lc);
- auto fv = _film_viewer.lock ();
- DCPOMATIC_ASSERT (fv);
/* Add on a frame here to work around any rounding errors and make sure land in the subtitle */
- fv->seek (lc, _start_times[ev.GetIndex()] + ContentTime::from_frames(1, _frc->source), true);
+ _film_viewer.seek(lc, _start_times[ev.GetIndex()] + ContentTime::from_frames(1, _frc->source), true);
}
std::shared_ptr<Content> content,
std::shared_ptr<TextContent> caption,
std::shared_ptr<Decoder>,
- std::weak_ptr<FilmViewer> viewer
+ FilmViewer& viewer
);
private:
boost::optional<int> _last_count;
std::vector<dcpomatic::ContentTime> _start_times;
std::weak_ptr<Content> _content;
- std::weak_ptr<FilmViewer> _film_viewer;
+ FilmViewer& _film_viewer;
};
int const Timeline::_minimum_pixels_per_track = 16;
-Timeline::Timeline (wxWindow* parent, ContentPanel* cp, shared_ptr<Film> film, weak_ptr<FilmViewer> viewer)
+Timeline::Timeline(wxWindow* parent, ContentPanel* cp, shared_ptr<Film> film, FilmViewer& viewer)
: wxPanel (parent, wxID_ANY)
, _labels_canvas (new wxScrolledCanvas (this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE))
, _main_canvas (new wxScrolledCanvas (this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE))
/* Playhead */
- auto vp = _viewer.lock ();
- DCPOMATIC_ASSERT (vp);
-
gc->SetPen (*wxRED_PEN);
auto path = gc->CreatePath ();
- double const ph = vp->position().seconds() * pixels_per_second().get_value_or(0);
+ double const ph = _viewer.position().seconds() * pixels_per_second().get_value_or(0);
path.MoveToPoint (ph, 0);
path.AddLineToPoint (ph, pixels_per_track() * _tracks + 32);
gc->StrokePath (path);
class Timeline : public wxPanel
{
public:
- Timeline (wxWindow *, ContentPanel *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
+ Timeline (wxWindow *, ContentPanel *, std::shared_ptr<Film>, FilmViewer& viewer);
std::shared_ptr<const Film> film () const;
wxScrolledCanvas* _main_canvas;
ContentPanel* _content_panel;
std::weak_ptr<Film> _film;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
TimelineViewList _views;
std::shared_ptr<TimelineTimeAxisView> _time_axis_view;
std::shared_ptr<TimelineReelsView> _reels_view;
#endif
-TimelineDialog::TimelineDialog (ContentPanel* cp, shared_ptr<Film> film, weak_ptr<FilmViewer> viewer)
+TimelineDialog::TimelineDialog(ContentPanel* cp, shared_ptr<Film> film, FilmViewer& viewer)
: wxDialog (
cp->window(),
wxID_ANY,
class TimelineDialog : public wxDialog
{
public:
- TimelineDialog (ContentPanel *, std::shared_ptr<Film>, std::weak_ptr<FilmViewer> viewer);
+ TimelineDialog(ContentPanel *, std::shared_ptr<Film>, FilmViewer& viewer);
void set_selection (ContentList selection);
using namespace dcpomatic;
-TimingPanel::TimingPanel (ContentPanel* p, weak_ptr<FilmViewer> viewer)
+TimingPanel::TimingPanel (ContentPanel* p, FilmViewer& viewer)
/* horrid hack for apparent lack of context support with wxWidgets i18n code */
/// TRANSLATORS: translate the word "Timing" here; do not include the "Timing|" prefix
: ContentSubPanel (p, S_("Timing|Timing"))
_trim_end_to_playhead->Bind (wxEVT_BUTTON, boost::bind (&TimingPanel::trim_end_to_playhead_clicked, this));
_play_length->Changed.connect (boost::bind (&TimingPanel::play_length_changed, this));
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- DCPOMATIC_ASSERT (fv);
- fv->ImageChanged.connect (boost::bind (&TimingPanel::setup_sensitivity, this));
+ _viewer.ImageChanged.connect(boost::bind(&TimingPanel::setup_sensitivity, this));
setup_sensitivity ();
add_to_grid ();
void
TimingPanel::trim_start_changed ()
{
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- if (!fv) {
- return;
- }
-
- DCPTime const ph = fv->position ();
+ DCPTime const ph = _viewer.position();
- fv->set_coalesce_player_changes (true);
+ _viewer.set_coalesce_player_changes(true);
shared_ptr<Content> ref;
optional<FrameRateChange> ref_frc;
}
if (ref) {
- fv->seek (max(DCPTime(), ref_ph.get() + ref->position() - DCPTime(ref->trim_start(), ref_frc.get())), true);
+ _viewer.seek(max(DCPTime(), ref_ph.get() + ref->position() - DCPTime(ref->trim_start(), ref_frc.get())), true);
}
- fv->set_coalesce_player_changes (false);
+ _viewer.set_coalesce_player_changes(false);
}
void
TimingPanel::trim_end_changed ()
{
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- if (!fv) {
- return;
- }
-
- fv->set_coalesce_player_changes (true);
+ _viewer.set_coalesce_player_changes(true);
Suspender::Block bl = _film_content_changed_suspender.block ();
for (auto i: _parent->selected()) {
}
/* XXX: maybe playhead-off-the-end-of-the-film should be handled elsewhere */
- if (fv->position() >= _parent->film()->length()) {
- fv->seek (_parent->film()->length() - DCPTime::from_frames(1, _parent->film()->video_frame_rate()), true);
+ if (_viewer.position() >= _parent->film()->length()) {
+ _viewer.seek(_parent->film()->length() - DCPTime::from_frames(1, _parent->film()->video_frame_rate()), true);
}
- fv->set_coalesce_player_changes (false);
+ _viewer.set_coalesce_player_changes(false);
}
void
void
TimingPanel::trim_start_to_playhead_clicked ()
{
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- if (!fv) {
- return;
- }
-
- shared_ptr<const Film> film = _parent->film ();
- DCPTime const ph = fv->position().floor (film->video_frame_rate ());
+ auto film = _parent->film ();
+ DCPTime const ph = _viewer.position().floor(film->video_frame_rate());
optional<DCPTime> new_ph;
- fv->set_coalesce_player_changes (true);
+ _viewer.set_coalesce_player_changes(true);
for (auto i: _parent->selected()) {
if (i->position() < ph && ph < i->end(film)) {
}
}
- fv->set_coalesce_player_changes (false);
+ _viewer.set_coalesce_player_changes(false);
if (new_ph) {
- fv->seek (new_ph.get(), true);
+ _viewer.seek(new_ph.get(), true);
}
}
void
TimingPanel::trim_end_to_playhead_clicked ()
{
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- if (!fv) {
- return;
- }
-
- shared_ptr<const Film> film = _parent->film ();
- DCPTime const ph = fv->position().floor (film->video_frame_rate ());
+ auto film = _parent->film ();
+ auto const ph = _viewer.position().floor(film->video_frame_rate());
for (auto i: _parent->selected()) {
if (i->position() < ph && ph < i->end(film)) {
FrameRateChange const frc = film->active_frame_rate_change (i->position ());
_trim_end->Enable (e);
_play_length->Enable (e);
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- DCPOMATIC_ASSERT (fv);
- DCPTime const ph = fv->position ();
+ auto const ph = _viewer.position();
bool any_over_ph = false;
for (auto i: _parent->selected()) {
if (i->position() <= ph && ph < i->end(_parent->film())) {
}
}
- MoveToDialog* d = new MoveToDialog (this, position, _parent->film());
+ auto d = new MoveToDialog(this, position, _parent->film());
if (d->ShowModal() == wxID_OK) {
for (auto i: _parent->selected()) {
class TimingPanel : public ContentSubPanel
{
public:
- TimingPanel (ContentPanel *, std::weak_ptr<FilmViewer> viewer);
+ TimingPanel(ContentPanel *, FilmViewer& viewer);
void create () override;
void film_changed (Film::Property) override;
void setup_sensitivity ();
void add_to_grid () override;
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
wxStaticText* _h_label;
wxStaticText* _m_label;
#endif
-VideoWaveformDialog::VideoWaveformDialog (wxWindow* parent, weak_ptr<const Film> film, weak_ptr<FilmViewer> viewer)
+VideoWaveformDialog::VideoWaveformDialog(wxWindow* parent, weak_ptr<const Film> film, FilmViewer& viewer)
: wxDialog (
parent,
wxID_ANY,
{
_plot->set_enabled (ev.IsShown ());
if (ev.IsShown ()) {
- shared_ptr<FilmViewer> fv = _viewer.lock ();
- DCPOMATIC_ASSERT (fv);
- fv->slow_refresh ();
+ _viewer.slow_refresh();
}
}
class VideoWaveformDialog : public wxDialog
{
public:
- VideoWaveformDialog (wxWindow* parent, std::weak_ptr<const Film> film, std::weak_ptr<FilmViewer> viewer);
+ VideoWaveformDialog(wxWindow* parent, std::weak_ptr<const Film> film, FilmViewer& viewer);
private:
void shown (wxShowEvent &);
void contrast_changed ();
void mouse_moved (int x1, int x2, int y1, int y2);
- std::weak_ptr<FilmViewer> _viewer;
+ FilmViewer& _viewer;
VideoWaveformPlot* _plot;
wxChoice* _component;
wxSlider* _contrast;
int const VideoWaveformPlot::_x_axis_width = 52;
-VideoWaveformPlot::VideoWaveformPlot (wxWindow* parent, weak_ptr<const Film> film, weak_ptr<FilmViewer> viewer)
+VideoWaveformPlot::VideoWaveformPlot(wxWindow* parent, weak_ptr<const Film> film, FilmViewer& viewer)
: wxPanel (parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE)
, _film (film)
{
SetDoubleBuffered (true);
#endif
- auto fv = viewer.lock ();
- DCPOMATIC_ASSERT (fv);
-
- _viewer_connection = fv->ImageChanged.connect (boost::bind(&VideoWaveformPlot::set_image, this, _1));
+ _viewer_connection = viewer.ImageChanged.connect(boost::bind(&VideoWaveformPlot::set_image, this, _1));
Bind (wxEVT_PAINT, boost::bind(&VideoWaveformPlot::paint, this));
Bind (wxEVT_SIZE, boost::bind(&VideoWaveformPlot::sized, this, _1));
class VideoWaveformPlot : public wxPanel
{
public:
- VideoWaveformPlot (wxWindow* parent, std::weak_ptr<const Film> film, std::weak_ptr<FilmViewer> viewer);
+ VideoWaveformPlot(wxWindow* parent, std::weak_ptr<const Film> film, FilmViewer& viewer);
void set_enabled (bool e);
void set_component (int c);