src/wx/content_menu.cc

   1 /*
   2     Copyright (C) 2013-2015 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "content_menu.h"
  21 #include "repeat_dialog.h"
  22 #include "wx_util.h"
  23 #include "timeline_video_content_view.h"
  24 #include "timeline_audio_content_view.h"
  25 #include "content_properties_dialog.h"
  26 #include "lib/playlist.h"
  27 #include "lib/film.h"
  28 #include "lib/image_content.h"
  29 #include "lib/content_factory.h"
  30 #include "lib/examine_content_job.h"
  31 #include "lib/job_manager.h"
  32 #include "lib/exceptions.h"
  33 #include "lib/dcp_content.h"
  34 #include "lib/ffmpeg_content.h"
  35 #include <wx/wx.h>
  36 #include <wx/dirdlg.h>
  37 #include <boost/foreach.hpp>
  38
  39 using std::cout;
  40 using std::vector;
  41 using std::exception;
  42 using boost::shared_ptr;
  43 using boost::weak_ptr;
  44 using boost::dynamic_pointer_cast;
  45
  46 enum {
  47         ID_repeat = 1,
  48         ID_join,
  49         ID_find_missing,
  50         ID_properties,
  51         ID_re_examine,
  52         ID_kdm,
  53         ID_remove
  54 };
  55
  56 ContentMenu::ContentMenu (wxWindow* p)
  57         : _menu (new wxMenu)
  58         , _parent (p)
  59 {
  60         _repeat = _menu->Append (ID_repeat, _("Repeat..."));
  61         _join = _menu->Append (ID_join, _("Join"));
  62         _find_missing = _menu->Append (ID_find_missing, _("Find missing..."));
  63         _properties = _menu->Append (ID_properties, _("Properties..."));
  64         _re_examine = _menu->Append (ID_re_examine, _("Re-examine..."));
  65         _kdm = _menu->Append (ID_kdm, _("Add KDM..."));
  66         _menu->AppendSeparator ();
  67         _remove = _menu->Append (ID_remove, _("Remove"));
  68
  69         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::repeat, this), ID_repeat);
  70         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::join, this), ID_join);
  71         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::find_missing, this), ID_find_missing);
  72         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::properties, this), ID_properties);
  73         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::re_examine, this), ID_re_examine);
  74         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::kdm, this), ID_kdm);
  75         _parent->Bind (wxEVT_COMMAND_MENU_SELECTED, boost::bind (&ContentMenu::remove, this), ID_remove);
  76 }
  77
  78 ContentMenu::~ContentMenu ()
  79 {
  80         delete _menu;
  81 }
  82
  83 void
  84 ContentMenu::popup (weak_ptr<Film> film, ContentList c, TimelineContentViewList v, wxPoint p)
  85 {
  86         _film = film;
  87         _content = c;
  88         _views = v;
  89         _repeat->Enable (!_content.empty ());
  90
  91         int n = 0;
  92         BOOST_FOREACH (shared_ptr<Content> i, _content) {
  93                 if (dynamic_pointer_cast<FFmpegContent> (i)) {
  94                         ++n;
  95                 }
  96         }
  97
  98         _join->Enable (n > 1);
  99
 100         _find_missing->Enable (_content.size() == 1 && !_content.front()->paths_valid ());
 101         _properties->Enable (_content.size() == 1);
 102         _re_examine->Enable (!_content.empty ());
 103
 104         if (_content.size() == 1) {
 105                 shared_ptr<DCPContent> dcp = dynamic_pointer_cast<DCPContent> (_content.front ());
 106                 _kdm->Enable (dcp && dcp->encrypted ());
 107         } else {
 108                 _kdm->Enable (false);
 109         }
 110
 111         _remove->Enable (!_content.empty ());
 112         _parent->PopupMenu (_menu, p);
 113 }
 114
 115 void
 116 ContentMenu::repeat ()
 117 {
 118         if (_content.empty ()) {
 119                 return;
 120         }
 121
 122         RepeatDialog* d = new RepeatDialog (_parent);
 123         if (d->ShowModal() != wxID_OK) {
 124                 d->Destroy ();
 125                 return;
 126         }
 127
 128         shared_ptr<Film> film = _film.lock ();
 129         if (!film) {
 130                 return;
 131         }
 132
 133         film->repeat_content (_content, d->number ());
 134         d->Destroy ();
 135
 136         _content.clear ();
 137         _views.clear ();
 138 }
 139
 140 void
 141 ContentMenu::join ()
 142 {
 143         vector<shared_ptr<Content> > fc;
 144         BOOST_FOREACH (shared_ptr<Content> i, _content) {
 145                 shared_ptr<FFmpegContent> f = dynamic_pointer_cast<FFmpegContent> (i);
 146                 if (f) {
 147                         fc.push_back (f);
 148                 }
 149         }
 150
 151         DCPOMATIC_ASSERT (fc.size() > 1);
 152
 153         shared_ptr<Film> film = _film.lock ();
 154         if (!film) {
 155                 return;
 156         }
 157
 158         try {
 159                 shared_ptr<FFmpegContent> joined (new FFmpegContent (film, fc));
 160                 BOOST_FOREACH (shared_ptr<Content> i, _content) {
 161                         film->remove_content (i);
 162                 }
 163                 film->add_content (joined);
 164         } catch (JoinError& e) {
 165                 error_dialog (_parent, std_to_wx (e.what ()));
 166         }
 167 }
 168
 169 void
 170 ContentMenu::remove ()
 171 {
 172         if (_content.empty ()) {
 173                 return;
 174         }
 175
 176         shared_ptr<Film> film = _film.lock ();
 177         if (!film) {
 178                 return;
 179         }
 180
 181         /* We are removing from the timeline if _views is not empty */
 182         bool handled = false;
 183         if (!_views.empty ()) {
 184                 /* Special case: we only remove FFmpegContent if its video view is selected;
 185                    if not, and its audio view is selected, we unmap the audio.
 186                 */
 187                 BOOST_FOREACH (shared_ptr<Content> i, _content) {
 188                         shared_ptr<FFmpegContent> fc = dynamic_pointer_cast<FFmpegContent> (i);
 189                         if (!fc) {
 190                                 continue;
 191                         }
 192
 193                         shared_ptr<TimelineVideoContentView> video;
 194                         shared_ptr<TimelineAudioContentView> audio;
 195
 196                         BOOST_FOREACH (shared_ptr<TimelineContentView> j, _views) {
 197                                 shared_ptr<TimelineVideoContentView> v = dynamic_pointer_cast<TimelineVideoContentView> (j);
 198                                 shared_ptr<TimelineAudioContentView> a = dynamic_pointer_cast<TimelineAudioContentView> (j);
 199                                 if (v && v->content() == fc) {
 200                                         video = v;
 201                                 } else if (a && a->content() == fc) {
 202                                         audio = a;
 203                                 }
 204                         }
 205
 206                         if (!video && audio) {
 207                                 AudioMapping m = fc->audio_mapping ();
 208                                 m.unmap_all ();
 209                                 fc->set_audio_mapping (m);
 210                                 handled = true;
 211                         }
 212                 }
 213         }
 214
 215         if (!handled) {
 216                 film->remove_content (_content);
 217         }
 218
 219         _content.clear ();
 220         _views.clear ();
 221 }
 222
 223 void
 224 ContentMenu::find_missing ()
 225 {
 226         if (_content.size() != 1) {
 227                 return;
 228         }
 229
 230         shared_ptr<const Film> film = _film.lock ();
 231         if (!film) {
 232                 return;
 233         }
 234
 235         shared_ptr<Content> content;
 236
 237         /* XXX: a bit nasty */
 238         shared_ptr<ImageContent> ic = dynamic_pointer_cast<ImageContent> (_content.front ());
 239         shared_ptr<DCPContent> dc = dynamic_pointer_cast<DCPContent> (_content.front ());
 240
 241         int r = wxID_CANCEL;
 242         boost::filesystem::path path;
 243
 244         if ((ic && !ic->still ()) || dc) {
 245                 wxDirDialog* d = new wxDirDialog (0, _("Choose a folder"), wxT (""), wxDD_DIR_MUST_EXIST);
 246                 r = d->ShowModal ();
 247                 path = wx_to_std (d->GetPath ());
 248                 d->Destroy ();
 249         } else {
 250                 wxFileDialog* d = new wxFileDialog (0, _("Choose a file"), wxT (""), wxT (""), wxT ("*.*"), wxFD_MULTIPLE);
 251                 r = d->ShowModal ();
 252                 path = wx_to_std (d->GetPath ());
 253                 d->Destroy ();
 254         }
 255
 256         if (r == wxID_OK) {
 257                 content = content_factory (film, path);
 258         }
 259
 260         if (!content) {
 261                 return;
 262         }
 263
 264         shared_ptr<Job> j (new ExamineContentJob (film, content));
 265
 266         _job_connection = j->Finished.connect (
 267                 bind (
 268                         &ContentMenu::maybe_found_missing,
 269                         this,
 270                         boost::weak_ptr<Job> (j),
 271                         boost::weak_ptr<Content> (_content.front ()),
 272                         boost::weak_ptr<Content> (content)
 273                         )
 274                 );
 275
 276         JobManager::instance()->add (j);
 277 }
 278
 279 void
 280 ContentMenu::re_examine ()
 281 {
 282         shared_ptr<Film> film = _film.lock ();
 283         if (!film) {
 284                 return;
 285         }
 286
 287         BOOST_FOREACH (shared_ptr<Content> i, _content) {
 288                 film->examine_content (i);
 289         }
 290 }
 291
 292 void
 293 ContentMenu::maybe_found_missing (weak_ptr<Job> j, weak_ptr<Content> oc, weak_ptr<Content> nc)
 294 {
 295         shared_ptr<Job> job = j.lock ();
 296         if (!job || !job->finished_ok ()) {
 297                 return;
 298         }
 299
 300         shared_ptr<Content> old_content = oc.lock ();
 301         shared_ptr<Content> new_content = nc.lock ();
 302         DCPOMATIC_ASSERT (old_content);
 303         DCPOMATIC_ASSERT (new_content);
 304
 305         if (new_content->digest() != old_content->digest()) {
 306                 error_dialog (0, _("The content file(s) you specified are not the same as those that are missing.  Either try again with the correct content file or remove the missing content."));
 307                 return;
 308         }
 309
 310         old_content->set_path (new_content->path (0));
 311 }
 312
 313 void
 314 ContentMenu::kdm ()
 315 {
 316         DCPOMATIC_ASSERT (!_content.empty ());
 317         shared_ptr<DCPContent> dcp = dynamic_pointer_cast<DCPContent> (_content.front ());
 318         DCPOMATIC_ASSERT (dcp);
 319
 320         wxFileDialog* d = new wxFileDialog (_parent, _("Select KDM"));
 321
 322         if (d->ShowModal() == wxID_OK) {
 323                 try {
 324                         dcp->add_kdm (dcp::EncryptedKDM (dcp::file_to_string (wx_to_std (d->GetPath ()))));
 325                 } catch (exception& e) {
 326                         error_dialog (_parent, wxString::Format (_("Could not load KDM (%s)"), e.what ()));
 327                         d->Destroy ();
 328                         return;
 329                 }
 330
 331                 shared_ptr<Film> film = _film.lock ();
 332                 DCPOMATIC_ASSERT (film);
 333                 film->examine_content (dcp);
 334         }
 335
 336         d->Destroy ();
 337 }
 338
 339 void
 340 ContentMenu::properties ()
 341 {
 342         ContentPropertiesDialog* d = new ContentPropertiesDialog (_parent, _content.front ());
 343         d->ShowModal ();
 344         d->Destroy ();
 345 }