cinelerra-5.1/cinelerra/loadfile.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2009 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "assets.h"
  23 #include "bcsignals.h"
  24 #include "bchash.h"
  25 #include "edl.h"
  26 #include "errorbox.h"
  27 #include "file.h"
  28 #include "filesystem.h"
  29 #include "indexfile.h"
  30 #include "language.h"
  31 #include "loadfile.h"
  32 #include "loadmode.h"
  33 #include "localsession.h"
  34 #include "mainmenu.h"
  35 #include "mainundo.h"
  36 #include "mainsession.h"
  37 #include "mwindow.h"
  38 #include "mwindowgui.h"
  39 #include "preferences.h"
  40 #include "theme.h"
  41
  42
  43
  44 #include <string.h>
  45
  46 Load::Load(MWindow *mwindow, MainMenu *mainmenu)
  47  : BC_MenuItem(_("Load files..."), "o", 'o')
  48 {
  49         this->mwindow = mwindow;
  50         this->mainmenu = mainmenu;
  51         this->thread = 0;
  52 }
  53
  54 Load::~Load()
  55 {
  56         delete thread;
  57 }
  58
  59 void Load::create_objects()
  60 {
  61         thread = new LoadFileThread(mwindow, this);
  62 }
  63
  64 int Load::handle_event()
  65 {
  66         mwindow->gui->unlock_window();
  67         thread->start();
  68         mwindow->gui->lock_window("Load::handle_event");
  69         return 1;
  70 }
  71
  72
  73
  74
  75
  76
  77 LoadFileThread::LoadFileThread(MWindow *mwindow, Load *load)
  78  : BC_DialogThread()
  79 {
  80         this->mwindow = mwindow;
  81         this->load = load;
  82         this->window = 0;
  83         load_mode = LOADMODE_REPLACE;
  84         edl_mode = LOADMODE_EDL_CLIP;
  85 }
  86
  87 LoadFileThread::~LoadFileThread()
  88 {
  89         close_window();
  90 }
  91
  92 BC_Window* LoadFileThread::new_gui()
  93 {
  94         char default_path[BCTEXTLEN];
  95
  96         sprintf(default_path, "~");
  97         mwindow->defaults->get("DEFAULT_LOADPATH", default_path);
  98         load_mode = mwindow->defaults->get("LOAD_MODE", load_mode);
  99
 100         mwindow->gui->lock_window("LoadFileThread::new_gui");
 101         window = new LoadFileWindow(mwindow, this, default_path);
 102         mwindow->gui->unlock_window();
 103
 104         window->create_objects();
 105         return window;
 106 }
 107
 108 void LoadFileThread::handle_done_event(int result)
 109 {
 110         window->lock_window("LoadFileThread::handle_done_event");
 111         window->hide_window();
 112         window->unlock_window();
 113
 114         if( !result ) load_apply();
 115 }
 116
 117 void LoadFileThread::load_apply()
 118 {
 119         mwindow->defaults->update("DEFAULT_LOADPATH", window->get_submitted_path());
 120         mwindow->defaults->update("LOAD_MODE", load_mode);
 121         if( edl_mode == LOADMODE_EDL_FILEREF )
 122                 mwindow->show_warning(
 123                         &mwindow->preferences->warn_fileref,
 124                         _("Other projects can change this project\n"
 125                           "and this can become a broken link"));
 126         ArrayList<char*> path_list;
 127         path_list.set_array_delete();
 128
 129 // Collect all selected files
 130         char *in_path;
 131         for( int i=0; (in_path = window->get_path(i))!=0; ++i ) {
 132                 int k = path_list.size();
 133                 while( --k >= 0 && strcmp(in_path, path_list.values[k]) );
 134                 if( k < 0 ) path_list.append(cstrdup(in_path));
 135         }
 136
 137 // No file selected
 138         if( !path_list.size() ) return;
 139
 140         if( load_mode == LOADMODE_REPLACE )
 141                 mwindow->set_filename(path_list[0]);
 142
 143         mwindow->interrupt_indexes();
 144         mwindow->gui->lock_window("LoadFileThread::run");
 145         mwindow->load_filenames(&path_list, load_mode, edl_mode, 0);
 146         mwindow->gui->mainmenu->add_load(path_list.values[0]);
 147         mwindow->gui->unlock_window();
 148         path_list.remove_all_objects();
 149
 150         mwindow->save_backup();
 151
 152         mwindow->restart_brender();
 153
 154         if( load_mode == LOADMODE_REPLACE ||
 155             load_mode == LOADMODE_REPLACE_CONCATENATE )
 156                 mwindow->session->changes_made = 0;
 157         else
 158                 mwindow->session->changes_made = 1;
 159 }
 160
 161
 162 LoadFileWindow::LoadFileWindow(MWindow *mwindow,
 163         LoadFileThread *thread,
 164         char *init_directory)
 165  : BC_FileBox(mwindow->gui->get_abs_cursor_x(1),
 166                 mwindow->gui->get_abs_cursor_y(1) -
 167                         BC_WindowBase::get_resources()->filebox_h / 2,
 168                 init_directory,
 169                 _(PROGRAM_NAME ": Load"),
 170                 _("Select files to load:"),
 171                 0,
 172                 0,
 173                 1,
 174                 mwindow->theme->loadfile_pad)
 175 {
 176         this->thread = thread;
 177         this->mwindow = mwindow;
 178 }
 179
 180 LoadFileWindow::~LoadFileWindow()
 181 {
 182         lock_window("LoadFileWindow::~LoadFileWindow");
 183         delete loadmode;
 184         unlock_window();
 185 }
 186
 187 void LoadFileWindow::create_objects()
 188 {
 189         lock_window("LoadFileWindow::create_objects");
 190         BC_FileBox::create_objects();
 191
 192         int x = get_w() / 2 - LoadMode::calculate_w(this, mwindow->theme) / 2;
 193         int y = get_y_margin();
 194 // always start as clip to match historical behavior
 195         thread->edl_mode = LOADMODE_EDL_CLIP;
 196         loadmode = new LoadMode(mwindow, this, x, y,
 197                 &thread->load_mode, &thread->edl_mode, 0, 1);
 198         loadmode->create_objects();
 199         const char *apply =  _("Apply");
 200         x = 3*get_w()/4 - BC_GenericButton::calculate_w(this, apply)/2;
 201         y = get_h() - BC_CancelButton::calculate_h() - yS(16);
 202         add_subwindow(load_file_apply = new LoadFileApply(this, x, y, apply));
 203
 204         show_window(1);
 205         unlock_window();
 206
 207 }
 208
 209 int LoadFileWindow::resize_event(int w, int h)
 210 {
 211         draw_background(0, 0, w, h);
 212         BC_FileBox::resize_event(w, h);
 213         int x = w / 2 - LoadMode::calculate_w(this, mwindow->theme) / 2;
 214         int y = get_y_margin();
 215         loadmode->reposition_window(x, y);
 216         const char *apply =  load_file_apply->get_text();
 217         x = 3*get_w()/4 - BC_GenericButton::calculate_w(this, apply)/2;
 218         y = get_h() - BC_CancelButton::calculate_h() - yS(16);
 219         load_file_apply->reposition_window(x, y);
 220         flush();
 221         return 1;
 222 }
 223
 224
 225 LoadFileApply::LoadFileApply(LoadFileWindow *load_file_window,
 226                 int x, int y, const char *text)
 227  : BC_GenericButton(x, y, text)
 228 {
 229         this->load_file_window = load_file_window;
 230 }
 231
 232 int LoadFileApply::handle_event()
 233 {
 234         load_file_window->thread->load_apply();
 235         return 1;
 236 }
 237
 238
 239 LocateFileWindow::LocateFileWindow(MWindow *mwindow,
 240         char *init_directory,
 241         char *old_filename)
 242  : BC_FileBox(mwindow->gui->get_abs_cursor_x(1),
 243                 mwindow->gui->get_abs_cursor_y(1),
 244                 init_directory,
 245                 _(PROGRAM_NAME ": Locate file"),
 246                 old_filename)
 247 {
 248         this->mwindow = mwindow;
 249 }
 250
 251 LocateFileWindow::~LocateFileWindow()
 252 {
 253 }
 254
 255
 256
 257
 258
 259
 260
 261 LoadPrevious::LoadPrevious(MWindow *mwindow, Load *loadfile)
 262  : BC_MenuItem("")
 263 {
 264         this->mwindow = mwindow;
 265         this->loadfile = loadfile;
 266 }
 267
 268 int LoadPrevious::handle_event()
 269 {
 270         if( !path[0] ) return 1;
 271         ArrayList<char*> path_list;
 272         path_list.set_array_delete();
 273         char *out_path;
 274         int load_mode = mwindow->defaults->get("LOAD_MODE", LOADMODE_REPLACE);
 275
 276         path_list.append(out_path = new char[strlen(path) + 1]);
 277         strcpy(out_path, path);
 278
 279         mwindow->load_filenames(&path_list, LOADMODE_REPLACE);
 280         mwindow->gui->mainmenu->add_load(path_list.values[0]);
 281         path_list.remove_all_objects();
 282
 283         mwindow->defaults->update("LOAD_MODE", load_mode);
 284         mwindow->save_backup();
 285         mwindow->session->changes_made = 0;
 286         return 1;
 287 }
 288
 289 int LoadPrevious::set_path(const char *path)
 290 {
 291         strcpy(this->path, path);
 292         return 0;
 293 }
 294
 295
 296
 297 LoadBackup::LoadBackup(MWindow *mwindow)
 298  : BC_MenuItem(_("Load backup"))
 299 {
 300         this->mwindow = mwindow;
 301 }
 302
 303 int LoadBackup::handle_event()
 304 {
 305         mwindow->load_backup();
 306         mwindow->session->changes_made = 1;
 307         return 1;
 308 }
 309
 310