#include "mainsession.h"
#include "mainundo.h"
#include "mbuttons.h"
+#include "mixersalign.h"
#include "mutex.h"
#include "mwindowgui.h"
#include "mwindow.h"
#include "savefile.inc"
#include "samplescroll.h"
#include "sha1.h"
+#include "shuttle.h"
#include "sighandler.h"
#include "splashgui.h"
#include "statusbar.h"
playback_3d = 0;
splash_window = 0;
undo = 0;
+ undo_command = COMMAND_NONE;
defaults = 0;
assets = 0;
//commercials = 0;
in_destructor = 0;
speed_edl = 0;
proxy_beep = 0;
+ shuttle = 0;
+ mixers_align = 0;
}
run_lock->lock("MWindow::~MWindow");
in_destructor = 1;
//printf("MWindow::~MWindow %d\n", __LINE__);
+ if( wwindow && wwindow->is_running() )
+ wwindow->close_window();
+ if( twindow && twindow->is_running() )
+ twindow->close_window();
gui->remote_control->deactivate();
gui->record->stop();
#ifdef HAVE_DVB
delete proxy_beep;
delete create_bd; create_bd = 0;
delete create_dvd; create_dvd = 0;
+ delete shuttle; shuttle = 0;
delete batch_render; batch_render = 0;
delete render; render = 0;
+ delete mixers_align; mixers_align = 0;
commit_commercial();
if( commercials && !commercials->remove_user() ) commercials = 0;
close_mixers();
if( cwindow && cwindow->gui ) cwindow->gui->close(0);
if( lwindow && lwindow->gui ) lwindow->gui->close(0);
if( gwindow && gwindow->gui ) gwindow->gui->close(0);
- if( twindow && twindow->is_running() ) twindow->close_window();
- if( wwindow && wwindow->is_running() ) wwindow->close_window();
vwindows.remove_all_objects();
zwindows.remove_all_objects();
gui->close(0);
if( awindow ) awindow->join();
if( cwindow ) cwindow->join();
if( lwindow ) lwindow->join();
- if( twindow ) twindow->join();
- if( wwindow ) wwindow->join();
if( gwindow ) gwindow->join();
join();
#else
close_gui(cwindow);
close_gui(lwindow);
close_gui(gwindow);
- close_gui(twindow);
- close_gui(wwindow);
vwindows.remove_all_objects();
zwindows.remove_all_objects();
gui->close(0);
colormodels.remove_all_objects();
interlace_project_modes.remove_all_objects();
interlace_asset_modes.remove_all_objects();
- interlace_asset_fixmethods.remove_all_objects();
sighandler->terminate();
delete sighandler;
delete run_lock;
{
preferences = new Preferences;
preferences->load_defaults(defaults);
- const char *lv2_path = getenv("LV2_PATH");
- if( lv2_path && strcmp(lv2_path, preferences->lv2_path) ) {
- strncpy(preferences->lv2_path, lv2_path, sizeof(preferences->lv2_path));
- remove_plugin_index();
- }
- else if( !lv2_path && preferences->lv2_path[0] ) {
- File::setenv_path("LV2_PATH",preferences->lv2_path, 0);
- }
+ File::setenv_path("LV2_PATH",preferences->lv2_path, 1);
session = new MainSession(this);
session->load_defaults(defaults);
// set x11_host, screens, window_config
zwindows_lock->lock("MWindow::get_mixer");
if( !mixer ) mixer = edl->mixers.new_mixer();
ZWindow *zwindow = 0;
- for( int i=0; !zwindow && i<zwindows.size(); ++i )
- if( zwindows[i]->idx < 0 ) zwindow = zwindows[i];
+ for( int i=0; !zwindow && i<zwindows.size(); ++i ) {
+ ZWindow *zwdw = zwindows[i];
+ if( zwdw->running() ) continue;
+ if( zwdw->idx >= 0 ) continue;
+ zwindow = zwindows[i];
+ }
if( !zwindow )
zwindows.append(zwindow = new ZWindow(this));
zwindow->idx = mixer->idx;
zwindows_lock->unlock();
}
-void MWindow::queue_mixers(EDL *edl, int command, int wait_tracking,
- int use_inout, int update_refresh, int toggle_audio, int loop_play)
+void MWindow::handle_mixers(EDL *edl, int command, int wait_tracking,
+ int use_inout, int toggle_audio, int loop_play, float speed)
{
- zwindows_lock->lock("MWindow::queue_mixers");
+ zwindows_lock->lock("MWindow::handle_mixers");
for( int vidx=0; vidx<zwindows.size(); ++vidx ) {
ZWindow *zwindow = zwindows[vidx];
if( zwindow->idx < 0 ) continue;
track->record = track->play = 0;
}
zwindow->change_source(mixer_edl);
- zwindow->issue_command(command,
- wait_tracking, use_inout, update_refresh, toggle_audio, loop_play);
+ zwindow->handle_mixer(command, 0,
+ use_inout, toggle_audio, loop_play, speed);
}
zwindows_lock->unlock();
}
void MWindow::refresh_mixers(int dir)
{
int command = dir >= 0 ? CURRENT_FRAME : LAST_FRAME;
- queue_mixers(edl,command,0,0,1,0,0);
+ handle_mixers(edl, command, 0, 0, 0, 0, 0);
}
void MWindow::stop_mixers()
for( int vidx=0; vidx<zwindows.size(); ++vidx ) {
ZWindow *zwindow = zwindows[vidx];
if( zwindow->idx < 0 ) continue;
- zwindow->issue_command(STOP, 0, 0, 0, 0, 0);
+ zwindow->handle_mixer(STOP, 0, 0, 0, 0, 0);
}
}
for( int i=zwindows.size(); --i>=0; ) {
ZWindow *zwindow = zwindows[i];
if( zwindow->idx < 0 ) continue;
+ zwindow->idx = -1;
zwindow->destroy = destroy;
ZWindowGUI *zgui = zwindow->zgui;
zgui->lock_window("MWindow::select_zwindow 0");
}
}
-ZWindow *MWindow::create_mixer(Indexable *indexable)
+ZWindow *MWindow::create_mixer(Indexable *indexable, double position)
{
ArrayList<Indexable*> new_assets;
new_assets.append(indexable);
Track *track = edl->tracks->last;
- load_assets(&new_assets, 0, LOADMODE_NEW_TRACKS, 0, 0, 0, 0, 0, 0);
+ load_assets(&new_assets, position, LOADMODE_NEW_TRACKS, 0, 0, 0, 0, 0, 1);
track = !track ? edl->tracks->first : track->next;
Mixer *mixer = 0;
ZWindow *zwindow = get_mixer(mixer);
return zwindow;
}
-void MWindow::create_mixers()
+void MWindow::create_mixers(double position)
{
if( !session->drag_assets->size() &&
!session->drag_clips->size() ) return;
- undo->update_undo_before();
+ undo_before();
select_zwindow(0);
ArrayList<ZWindow *>new_mixers;
for( int i=0; i<session->drag_assets->size(); ++i ) {
Indexable *indexable = session->drag_assets->get(i);
if( !indexable->have_video() ) continue;
- ZWindow *zwindow = create_mixer(indexable);
+ ZWindow *zwindow = create_mixer(indexable, position);
new_mixers.append(zwindow);
}
for( int i=0; i<session->drag_clips->size(); ++i ) {
Indexable *indexable = (Indexable*)session->drag_clips->get(i);
if( !indexable->have_video() ) continue;
- ZWindow *zwindow = create_mixer(indexable);
+ ZWindow *zwindow = create_mixer(indexable, position);
new_mixers.append(zwindow);
}
refresh_mixers();
save_backup();
- undo->update_undo_after(_("create mixers"), LOAD_ALL);
+ undo_after(_("create mixers"), LOAD_ALL);
restart_brender();
gui->update(1, FORCE_REDRAW, 1, 1, 1, 1, 0);
sync_parameters(CHANGE_ALL);
#define ILACEASSETMODELISTADD(x) ilacemode_to_text(string, x); \
interlace_asset_modes.append(new InterlacemodeItem(string, x));
-#define ILACEFIXMETHODLISTADD(x) ilacefixmethod_to_text(string, x); \
- interlace_asset_fixmethods.append(new InterlacefixmethodItem(string, x));
-
// Interlacing Modes
ILACEASSETMODELISTADD(ILACE_MODE_UNDETECTED); // Not included in the list for the project options.
ILACEASSETMODELISTADD(ILACE_MODE_NOTINTERLACED);
ILACEPROJECTMODELISTADD(ILACE_MODE_NOTINTERLACED);
- // Interlacing Fixing Methods
- ILACEFIXMETHODLISTADD(ILACE_FIXMETHOD_NONE);
- ILACEFIXMETHODLISTADD(ILACE_FIXMETHOD_UPONE);
- ILACEFIXMETHODLISTADD(ILACE_FIXMETHOD_DOWNONE);
+ mixers_align = new MixersAlign(this);
}
void MWindow::init_indexes()
exportedl = new ExportEDL(this);
}
+void MWindow::init_shuttle()
+{
+#ifdef HAVE_SHUTTLE
+ int ret = Shuttle::probe();
+ if( ret >= 0 ) {
+ shuttle = new Shuttle(this);
+ if( shuttle->read_config_file() > 0 ) {
+ printf("shuttle: bad config file\n");
+ delete shuttle; shuttle = 0;
+ return;
+ }
+ shuttle->start(ret);
+ }
+#endif
+}
+
void MWindow::init_brender()
{
if(preferences->use_brender && !brender)
gui->stop_transport(gui->get_window_lock() ? "MWindow::stop_transport" : 0);
}
+void MWindow::undo_before(const char *description, void *creator)
+{
+ undo->update_undo_before(description, creator);
+}
+
+void MWindow::undo_after(const char *description, uint32_t load_flags, int changes_made)
+{
+ undo->update_undo_after(description, load_flags, changes_made);
+}
+
void MWindow::beep(double freq, double secs, double gain)
{
if( !proxy_beep ) proxy_beep = new ProxyBeep(this);
gui->lock_window("MWindow::load_filenames 0");
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
- undo->update_undo_before();
+ undo_before();
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
sprintf(string, _("Loading %s"), new_asset->path);
gui->show_message(string);
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
ftype = new_file->open_file(preferences, new_asset, 1, 0);
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
result = 1;
switch( ftype ) {
if( new_asset->video_data &&
((new_asset->width % 2) || (new_asset->height % 2)) ) {
char string[BCTEXTLEN];
- sprintf(string, _("%s's resolution is %dx%d.\nImages with odd dimensions may not decode properly."),
+ sprintf(string, _("%s's resolution is %dx%d.\n"
+ "Images with odd dimensions may not decode properly."),
new_asset->path, new_asset->width, new_asset->height);
MainError::show_error(string);
}
case FILE_IS_XML: {
FileXML xml_file;
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
xml_file.read_from_file(filenames->get(i));
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
const char *cin_version = 0;
while( !xml_file.read_tag() ) {
if( xml_file.tag.title_is("EDL") ) {
EDL *nested_edl = new EDL;
nested_edl->create_objects();
nested_edl->load_xml(&xml_file, LOAD_ALL);
-//printf("MWindow::load_filenames %p %s\n", nested_edl, nested_edl->project_path);
+ int groups = nested_edl->regroup(session->group_number);
+ session->group_number += groups;
new_edl->create_nested(nested_edl);
new_edl->set_path(filenames->get(i));
nested_edl->Garbage::remove_user();
else {
// Load EDL for pasting
new_edl->load_xml(&xml_file, LOAD_ALL);
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
+ int groups = new_edl->regroup(session->group_number);
+ session->group_number += groups;
test_plugins(new_edl, filenames->get(i));
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
if( load_mode == LOADMODE_REPLACE ||
load_mode == LOADMODE_REPLACE_CONCATENATE ) {
// Paste them.
// Don't back up here.
- if(new_edls.size())
- {
+ if( new_edls.size() ) {
// For pasting, clear the active region
- if(load_mode == LOADMODE_PASTE ||
- load_mode == LOADMODE_NESTED)
- {
+ if( load_mode == LOADMODE_PASTE ||
+ load_mode == LOADMODE_NESTED ) {
double start = edl->local_session->get_selectionstart();
double end = edl->local_session->get_selectionend();
if(!EQUIV(start, end))
- edl->clear(start,
- end,
+ edl->clear(start, end,
edl->session->labels_follow_edits,
edl->session->plugins_follow_edits,
edl->session->autos_follow_edits);
- }
- paste_edls(&new_edls, load_mode, 0, -1,
- edl->session->labels_follow_edits,
- edl->session->plugins_follow_edits,
- edl->session->autos_follow_edits,
- 0); // overwrite
+ paste_edls(&new_edls, load_mode, 0, -1,
+ edl->session->labels_follow_edits,
+ edl->session->plugins_follow_edits,
+ edl->session->autos_follow_edits,
+ 0); // overwrite
+ }
+ else
+ paste_edls(&new_edls, load_mode, 0, -1, 1, 1, 1, 0);
}
-
-
-
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
-
// Add new assets to EDL and schedule assets for index building.
int got_indexes = 0;
for( int i=0; i<new_edls.size(); ++i ) {
}
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
for( int i=0; i<new_assets.size(); ++i ) {
Asset *new_asset = new_assets[i];
edl->assets->update(new_asset);
got_indexes = 1;
}
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
// Start examining next batch of index files
if(got_indexes) mainindexes->start_build();
-if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
// Open plugin GUIs
Track *track = edl->tracks->first;
- while(track)
- {
- for(int j = 0; j < track->plugin_set.size(); j++)
- {
+ while( track ) {
+ for( int j = 0; j < track->plugin_set.size(); j++ ) {
PluginSet *plugins = track->plugin_set[j];
Plugin *plugin = plugins->get_first_plugin();
- while(plugin)
- {
- if(load_mode == LOADMODE_REPLACE ||
- load_mode == LOADMODE_REPLACE_CONCATENATE)
- {
- if(plugin->plugin_type == PLUGIN_STANDALONE &&
- plugin->show)
- {
+ while(plugin) {
+ if( load_mode == LOADMODE_REPLACE ||
+ load_mode == LOADMODE_REPLACE_CONCATENATE ) {
+ if( plugin->plugin_type == PLUGIN_STANDALONE &&
+ plugin->show ) {
show_plugin(plugin);
}
}
edl->local_session->loop_playback = 0;
edl->local_session->set_selectionstart(0);
edl->local_session->set_selectionend(0);
+ edl->local_session->unset_inpoint();
+ edl->local_session-> unset_outpoint();
set_brender_active(0, 0);
fit_selection();
goto_start();
// need to update undo before project, since mwindow is unlocked & a new load
// can begin here. Should really prevent loading until we're done.
if(debug) printf("MWindow::load_filenames %d\n", __LINE__);
- undo->update_undo_after(_("load"), LOAD_ALL);
+ undo_after(_("load"), LOAD_ALL);
for(int i = 0; i < new_edls.size(); i++)
{
edl->Garbage::add_user();
save_backup();
- undo->update_undo_before(_("proxy"), this);
+ undo_before(_("proxy"), this);
ProxyRender proxy_render(this, asset);
// revert project to original size from current size
edl->set_proxy(new_scale, new_use_scaler,
&proxy_render.orig_idxbls, &proxy_render.orig_proxies);
- undo->update_undo_after(_("proxy"), LOAD_ALL);
+ undo_after(_("proxy"), LOAD_ALL);
edl->Garbage::remove_user();
restart_brender();
init_render();
if(debug) printf("MWindow::create_objects %d total_time=%d\n", __LINE__, (int)timer.get_difference());
+ init_shuttle();
init_brender();
init_exportedl();
init_commercials();
gui->show_window();
gui->raise_window();
gui->unlock_window();
-
+ cwindow->gui->lock_window("MWindow::create_objects 1");
+ cwindow->gui->tool_panel->raise_tool();
+ cwindow->gui->unlock_window();
if(debug) PRINT_TRACE
if(preferences->use_tipwindow)
BC_WindowBase::get_resources()->vframe_shm = 1;
}
+int MWindow::uses_opengl()
+{
+ if( !playback_3d || !playback_3d->running() ) return 0;
+ PlaybackConfig *playback_config = edl->session->playback_config;
+ return playback_config->vconfig->driver == PLAYBACK_X11_GL ? 1 : 0;
+}
void MWindow::show_splash()
{
gui->focus();
}
-void MWindow::save_layout(int no)
+void MWindow::load_layout(const char *layout)
{
- char layout_path[BCTEXTLEN];
- snprintf(layout_path, sizeof(layout_path), "%s/" LAYOUT_FILE,
- File::get_config_path(), no);
- session->save_file(layout_path);
-}
-
-void MWindow::load_layout(int no)
-{
- char layout_path[BCTEXTLEN];
- snprintf(layout_path, sizeof(layout_path), "%s/" LAYOUT_FILE,
- File::get_config_path(), no);
- session->load_file(layout_path);
+ char path[BCTEXTLEN];
+ snprintf(path, sizeof(path), "%s/%s", File::get_config_path(), layout);
+ session->load_file(path);
restore_windows();
gui->default_positions();
save_defaults();
}
+void MWindow::save_layout(const char *layout)
+{
+ char path[BCTEXTLEN];
+ snprintf(path, sizeof(path), "%s/%s", File::get_config_path(), layout);
+ session->save_file(path);
+}
+
+void MWindow::delete_layout(const char *layout)
+{
+ char path[BCTEXTLEN];
+ snprintf(path, sizeof(path), "%s/%s", File::get_config_path(), layout);
+ unlink(path);
+}
+
int MWindow::tile_windows(int window_config)
{
int need_reload = 0;
screens = value;
}
-void MWindow::set_auto_keyframes(int value, int lock_mwindow, int lock_cwindow)
+void MWindow::set_auto_keyframes(int value)
{
- if(lock_mwindow) gui->lock_window("MWindow::set_auto_keyframes");
edl->session->auto_keyframes = value;
gui->mbuttons->edit_panel->keyframe->update(value);
gui->flush();
- if(lock_mwindow) gui->unlock_window();
-
- if(lock_cwindow) cwindow->gui->lock_window("MWindow::set_auto_keyframes");
+ cwindow->gui->lock_window("MWindow::set_auto_keyframes");
cwindow->gui->edit_panel->keyframe->update(value);
cwindow->gui->flush();
- if(lock_cwindow) cwindow->gui->unlock_window();
+ cwindow->gui->unlock_window();
}
void MWindow::set_auto_visibility(Autos *autos, int value)
gui->unlock_window();
}
-int MWindow::set_editing_mode(int new_editing_mode, int lock_mwindow, int lock_cwindow)
+int MWindow::set_editing_mode(int new_editing_mode)
{
- if(lock_mwindow) gui->lock_window("MWindow::set_editing_mode");
edl->session->editing_mode = new_editing_mode;
gui->mbuttons->edit_panel->editing_mode = edl->session->editing_mode;
gui->mbuttons->edit_panel->update();
gui->set_editing_mode(1);
- if(lock_mwindow) gui->unlock_window();
-
- if(lock_cwindow) cwindow->gui->lock_window("MWindow::set_editing_mode");
+ cwindow->gui->lock_window("MWindow::set_editing_mode");
cwindow->gui->edit_panel->update();
cwindow->gui->edit_panel->editing_mode = edl->session->editing_mode;
- if(lock_cwindow) cwindow->gui->unlock_window();
+ cwindow->gui->unlock_window();
return 0;
}
{
int mode = edl->session->editing_mode;
if( mode == EDITING_ARROW )
- set_editing_mode(EDITING_IBEAM, 0, 1);
+ set_editing_mode(EDITING_IBEAM);
else
- set_editing_mode(EDITING_ARROW, 0, 1);
+ set_editing_mode(EDITING_ARROW);
}
void MWindow::toggle_camera_xyz()
void MWindow::set_labels_follow_edits(int value)
{
- gui->lock_window("MWindow::set_labels_follow_edits");
edl->session->labels_follow_edits = value;
gui->mbuttons->edit_panel->locklabels->update(value);
gui->mainmenu->labels_follow_edits->set_checked(value);
gui->flush();
- gui->unlock_window();
}
void MWindow::sync_parameters(int change_type)
if( in_destructor ) return;
// Sync engines which are playing back
- if(cwindow->playback_engine->is_playing_back)
- {
- if(change_type == CHANGE_PARAMS)
- {
+ if( cwindow->playback_engine->is_playing_back ) {
+ if( change_type == CHANGE_PARAMS ) {
// TODO: block keyframes until synchronization is done
cwindow->playback_engine->sync_parameters(edl);
}
- else
+ else {
// Stop and restart
- {
int command = cwindow->playback_engine->command->command;
- cwindow->playback_engine->que->send_command(STOP,
- CHANGE_NONE,
- 0,
- 0);
// Waiting for tracking to finish would make the restart position more
// accurate but it can't lock the window to stop tracking for some reason.
// Not waiting for tracking gives a faster response but restart position is
// only as accurate as the last tracking update.
- cwindow->playback_engine->interrupt_playback(0);
- cwindow->playback_engine->que->send_command(command,
- change_type,
- edl,
- 1,
- 0);
+ cwindow->playback_engine->transport_stop(0);
+ cwindow->playback_engine->next_command->realtime = 1;
+ cwindow->playback_engine->transport_command(command, change_type, edl, 0);
}
}
- else
- {
+ else {
cwindow->refresh_frame(change_type);
}
}
uint8_t *bp = (uint8_t*)cp;
int v = 0;
while( *bp ) v += *bp++;
+ return get_hash_color(v);
+}
+
+int MWindow::get_hash_color(int v)
+{
int hash = 0x303030;
if( v & 0x01 ) hash ^= 0x000040;
if( v & 0x02 ) hash ^= 0x004000;
return hash;
}
+int MWindow::get_group_color(int v)
+{
+ int color = 0x606060;
+ if( v & 0x01 ) color ^= 0x000080;
+ if( v & 0x02 ) color ^= 0x008000;
+ if( v & 0x04 ) color ^= 0x800000;
+ if( v & 0x08 ) color ^= 0x100000;
+ if( v & 0x10 ) color ^= 0x001000;
+ if( v & 0x20 ) color ^= 0x000010;
+ if( v & 0x40 ) color ^= 0x080808;
+ if( v & 0x80 ) color ^= 0x909090;
+ return color;
+}
+
int MWindow::get_title_color(Edit *edit)
{
- unsigned color = edit->color;
+ unsigned color = edit->color & 0xffffff;
+ unsigned alpha = (~edit->color>>24) & 0xff;
if( !color ) {
- if( !preferences->autocolor_assets ) return 0;
- color = get_hash_color(edit);
+ if( edit->group_id )
+ color = get_group_color(edit->group_id);
+ else if( preferences->autocolor_assets )
+ color = get_hash_color(edit);
+ else
+ return 0;
}
- unsigned alpha = (~edit->color>>24) & 0xff;
if( alpha == 0xff )
alpha = session->title_bar_alpha*255;
return color | (~alpha<<24);
//printf("MWindow::asset_to_edl 4 %s\n", string);
if(debug) printf("MWindow::asset_to_edl %d\n", __LINE__);
+ new_edl->local_session->asset2edl = 1;
return 0;
}
gui->unlock_window();
init_brender();
- cwindow->gui->lock_window("MWindow::update_project 1");
cwindow->update(0, 0, 1, 1, 1);
- cwindow->gui->unlock_window();
if(debug) PRINT_TRACE
if(debug) PRINT_TRACE
cwindow->gui->lock_window("MWindow::update_project 2");
cwindow->gui->timebar->update(0);
+ Track *track = cwindow->calculate_affected_track();
+ cwindow->mask_track_id = track ? track->get_id() : -1;
+ cwindow->gui->tool_panel->raise_tool();
cwindow->gui->unlock_window();
if(debug) PRINT_TRACE
void MWindow::save_undo_data()
{
- undo->update_undo_before();
- undo->update_undo_after(_("perpetual session"), LOAD_ALL);
+ undo_before();
+ undo_after(_("perpetual session"), LOAD_ALL);
char perpetual_path[BCTEXTLEN];
snprintf(perpetual_path, sizeof(perpetual_path), "%s/%s",
File::get_config_path(), PERPETUAL_FILE);
}
//printf("MWindow::rebuild_indices 1 %s\n", indexable->path);
- if(push_undo) undo->update_undo_before();
+ if(push_undo) undo_before();
if(drag_assets) edl->remove_from_project(drag_assets);
if(drag_clips) edl->remove_from_project(drag_clips);
if(redraw) save_backup();
- if(push_undo) undo->update_undo_after(_("remove assets"), LOAD_ALL);
+ if(push_undo) undo_after(_("remove assets"), LOAD_ALL);
if(redraw) {
restart_brender();
session->auto_keyframes = 0;
int result = file->open_file(preferences, asset, 1, 0);
if( !result && delete_tracks > 0 )
- undo->update_undo_before();
+ undo_before();
int video_layers = asset->get_video_layers();
if( !result && asset->video_data && vstream < video_layers ) {
// try to get asset up to date, may fail
session->auto_keyframes = old_auto_keyframes;
if( !result && delete_tracks > 0 ) {
save_backup();
- undo->update_undo_after(_("select asset"), LOAD_ALL);
+ undo_after(_("select asset"), LOAD_ALL);
}
resync_guis();
return result;
projects / goodguy / cinelerra.git / blobdiff