mwindowedit.C

Go to the documentation of this file.

#include "asset.h"
#include "assets.h"
#include "awindowgui.h"
#include "awindow.h"
#include "bcsignals.h"
#include "cache.h"
#include "clip.h"
#include "clipedit.h"
#include "cplayback.h"
#include "ctimebar.h"
#include "cwindow.h"
#include "cwindowgui.h"
#include "defaults.h"
#include "edl.h"
#include "edlsession.h"
#include "filexml.h"
#include "gwindow.h"
#include "gwindowgui.h"
#include "keyframe.h"
#include "language.h"
#include "labels.h"
#include "levelwindow.h"
#include "localsession.h"
#include "mainclock.h"
#include "maincursor.h"
#include "mainindexes.h"
#include "mainmenu.h"
#include "mainsession.h"
#include "mainundo.h"
#include "maskautos.h"
#include "mtimebar.h"
#include "mwindowgui.h"
#include "mwindow.h"
#include "patchbay.h"
#include "playbackengine.h"
#include "pluginset.h"
#include "recordlabel.h"
#include "samplescroll.h"
#include "trackcanvas.h"
#include "track.h"
#include "trackscroll.h"
#include "tracks.h"
#include "transition.h"
#include "transportque.h"
#include "units.h"
#include "undostackitem.h"
#include "vplayback.h"
#include "vwindow.h"
#include "vwindowgui.h"
#include "zoombar.h"
#include "automation.h"
#include "maskautos.h"


#include <string.h>






void MWindow::add_audio_track_entry(int above, Track *dst)
{
        add_audio_track(above, dst);
        save_backup();
        undo->update_undo(_("add track"), LOAD_ALL);

        restart_brender();
        gui->get_scrollbars();
        gui->canvas->draw();
        gui->patchbay->update();
        gui->cursor->draw();
        gui->canvas->flash();
        gui->canvas->activate();
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                CHANGE_EDL,
                edl,
                1);
}

void MWindow::add_video_track_entry(Track *dst)
{
        add_video_track(1, dst);
        undo->update_undo(_("add track"), LOAD_ALL);

        restart_brender();
        gui->get_scrollbars();
        gui->canvas->draw();
        gui->patchbay->update();
        gui->cursor->draw();
        gui->canvas->flash();
        gui->canvas->activate();
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                                                        CHANGE_EDL,
                                                        edl,
                                                        1);
        save_backup();
}


int MWindow::add_audio_track(int above, Track *dst)
{
        edl->tracks->add_audio_track(above, dst);
        edl->tracks->update_y_pixels(theme);
        save_backup();
        return 0;
}

int MWindow::add_video_track(int above, Track *dst)
{
        edl->tracks->add_video_track(above, dst);
        edl->tracks->update_y_pixels(theme);
        save_backup();
        return 0;
}





void MWindow::asset_to_size()
{
        if(session->drag_assets->total &&
                session->drag_assets->values[0]->video_data)
        {
                int w, h;

// Get w and h
                w = session->drag_assets->values[0]->width;
                h = session->drag_assets->values[0]->height;


                edl->session->output_w = w;
                edl->session->output_h = h;

// Get aspect ratio
                if(defaults->get("AUTOASPECT", 0))
                {
                        create_aspect_ratio(edl->session->aspect_w, 
                                edl->session->aspect_h, 
                                w, 
                                h);
                }

                save_backup();

                undo->update_undo(_("asset to size"), LOAD_ALL);
                restart_brender();
                sync_parameters(CHANGE_ALL);
        }
}



void MWindow::clear_entry()
{
        clear(1);

        edl->optimize();
        save_backup();
        undo->update_undo(_("clear"), LOAD_EDITS | LOAD_TIMEBAR);

        restart_brender();
        update_plugin_guis();
        gui->update(1, 2, 1, 1, 1, 1, 0);
        cwindow->update(1, 0, 0, 0, 1);
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                           CHANGE_EDL,
                           edl,
                           1);
}

void MWindow::clear(int clear_handle)
{
        double start = edl->local_session->get_selectionstart();
        double end = edl->local_session->get_selectionend();
        if(clear_handle || !EQUIV(start, end))
        {
                edl->clear(start, 
                        end, 
                        edl->session->labels_follow_edits, 
                        edl->session->plugins_follow_edits);
        }
}

void MWindow::clear_automation()
{
        edl->tracks->clear_automation(edl->local_session->get_selectionstart(), 
                edl->local_session->get_selectionend()); 
        save_backup();
        undo->update_undo(_("clear keyframes"), LOAD_AUTOMATION); 

        restart_brender();
        update_plugin_guis();
        gui->canvas->draw_overlays();
        gui->canvas->flash();
        sync_parameters(CHANGE_PARAMS);
        gui->patchbay->update();
        cwindow->update(1, 0, 0);
}

int MWindow::clear_default_keyframe()
{
        edl->tracks->clear_default_keyframe();
        save_backup();
        undo->update_undo(_("clear default keyframe"), LOAD_AUTOMATION);
        
        restart_brender();
        gui->canvas->draw_overlays();
        gui->canvas->flash();
        sync_parameters(CHANGE_PARAMS);
        gui->patchbay->update();
        cwindow->update(1, 0, 0);
        
        return 0;
}

void MWindow::clear_labels()
{
        clear_labels(edl->local_session->get_selectionstart(), 
                edl->local_session->get_selectionend()); 
        undo->update_undo(_("clear labels"), LOAD_TIMEBAR);
        
        gui->timebar->update();
        cwindow->update(0, 0, 0, 0, 1);
        save_backup();
}

int MWindow::clear_labels(double start, double end)
{
        edl->labels->clear(start, end, 0);
        return 0;
}

void MWindow::concatenate_tracks()
{
        edl->tracks->concatenate_tracks(edl->session->plugins_follow_edits);
        save_backup();
        undo->update_undo(_("concatenate tracks"), LOAD_EDITS);

        restart_brender();
        gui->update(1, 1, 0, 0, 1, 0, 0);
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                CHANGE_EDL,
                edl,
                1);
}


void MWindow::copy()
{
        copy(edl->local_session->get_selectionstart(), 
                edl->local_session->get_selectionend());
}

int MWindow::copy(double start, double end)
{
        if(start == end) return 1;

//printf("MWindow::copy 1\n");
        FileXML file;
//printf("MWindow::copy 1\n");
        edl->copy(start, 
                end, 
                0,
                0,
                0,
                &file, 
                plugindb,
                "",
                1);
//printf("MWindow::copy 1\n");

// File is now terminated and rewound

//printf("MWindow::copy 1\n");
        gui->get_clipboard()->to_clipboard(file.string, strlen(file.string), SECONDARY_SELECTION);
//printf("MWindow::copy\n%s\n", file.string);
//printf("MWindow::copy 2\n");
        save_backup();
        return 0;
}

int MWindow::copy_automation()
{
        FileXML file;
        edl->tracks->copy_automation(edl->local_session->get_selectionstart(), 
                edl->local_session->get_selectionend(),
                &file,
                0,
                0); 
        gui->get_clipboard()->to_clipboard(file.string, 
                strlen(file.string), 
                SECONDARY_SELECTION);
        return 0;
}

int MWindow::copy_default_keyframe()
{
        FileXML file;
        edl->tracks->copy_default_keyframe(&file);
        gui->get_clipboard()->to_clipboard(file.string,
                strlen(file.string),
                SECONDARY_SELECTION);
        return 0;
}


// Uses cropping coordinates in edl session to crop and translate video.
// We modify the projector since camera automation depends on the track size.
void MWindow::crop_video()
{

// Clamp EDL crop region
        if(edl->session->crop_x1 > edl->session->crop_x2)
        {
                edl->session->crop_x1 ^= edl->session->crop_x2;
                edl->session->crop_x2 ^= edl->session->crop_x1;
                edl->session->crop_x1 ^= edl->session->crop_x2;
        }
        if(edl->session->crop_y1 > edl->session->crop_y2)
        {
                edl->session->crop_y1 ^= edl->session->crop_y2;
                edl->session->crop_y2 ^= edl->session->crop_y1;
                edl->session->crop_y1 ^= edl->session->crop_y2;
        }

        float old_projector_x = (float)edl->session->output_w / 2;
        float old_projector_y = (float)edl->session->output_h / 2;
        float new_projector_x = (float)(edl->session->crop_x1 + edl->session->crop_x2) / 2;
        float new_projector_y = (float)(edl->session->crop_y1 + edl->session->crop_y2) / 2;
        float projector_offset_x = -(new_projector_x - old_projector_x);
        float projector_offset_y = -(new_projector_y - old_projector_y);

        edl->tracks->translate_projector(projector_offset_x, projector_offset_y);

        edl->session->output_w = edl->session->crop_x2 - edl->session->crop_x1;
        edl->session->output_h = edl->session->crop_y2 - edl->session->crop_y1;
        edl->session->crop_x1 = 0;
        edl->session->crop_y1 = 0;
        edl->session->crop_x2 = edl->session->output_w;
        edl->session->crop_y2 = edl->session->output_h;

// Recalculate aspect ratio
        if(defaults->get("AUTOASPECT", 0))
        {
                create_aspect_ratio(edl->session->aspect_w, 
                        edl->session->aspect_h, 
                        edl->session->output_w, 
                        edl->session->output_h);
        }

        undo->update_undo(_("crop"), LOAD_ALL);

        restart_brender();
        cwindow->playback_engine->que->send_command(CURRENT_FRAME,
                CHANGE_ALL,
                edl,
                1);
        save_backup();
}

void MWindow::cut()
{

        double start = edl->local_session->get_selectionstart();
        double end = edl->local_session->get_selectionend();

        copy(start, end);
        edl->clear(start, 
                end,
                edl->session->labels_follow_edits, 
                edl->session->plugins_follow_edits);


        edl->optimize();
        save_backup();
        undo->update_undo(_("cut"), LOAD_EDITS | LOAD_TIMEBAR);

        restart_brender();
        update_plugin_guis();
        gui->update(1, 2, 1, 1, 1, 1, 0);
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                                                        CHANGE_EDL,
                                                        edl,
                                                        1);
}

int MWindow::cut_automation()
{
        
        copy_automation();

        edl->tracks->clear_automation(edl->local_session->get_selectionstart(), 
                edl->local_session->get_selectionend()); 
        save_backup();
        undo->update_undo(_("cut keyframes"), LOAD_AUTOMATION); 


        restart_brender();
        update_plugin_guis();
        gui->canvas->draw_overlays();
        gui->canvas->flash();
        sync_parameters(CHANGE_PARAMS);
        gui->patchbay->update();
        cwindow->update(1, 0, 0);
        return 0;
}

int MWindow::cut_default_keyframe()
{

        copy_default_keyframe();
        edl->tracks->clear_default_keyframe();
        undo->update_undo(_("cut default keyframe"), LOAD_AUTOMATION);

        restart_brender();
        gui->canvas->draw_overlays();
        gui->canvas->flash();
        sync_parameters(CHANGE_PARAMS);
        gui->patchbay->update();
        cwindow->update(1, 0, 0);
        save_backup();


        return 0;
}

void MWindow::delete_inpoint()
{
        edl->local_session->unset_inpoint();
        save_backup();
}

void MWindow::delete_outpoint()
{
        edl->local_session->unset_outpoint();
        save_backup();
}

void MWindow::delete_track()
{
        if (edl->tracks->last)
                delete_track(edl->tracks->last);
}

void MWindow::delete_tracks()
{
        edl->tracks->delete_tracks();
        undo->update_undo(_("delete tracks"), LOAD_ALL);
        save_backup();

        restart_brender();
        update_plugin_states();
        gui->update(1, 1, 1, 0, 1, 0, 0);
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                           CHANGE_EDL,
                           edl,
                           1);
}

void MWindow::delete_track(Track *track)
{
        edl->tracks->delete_track(track);
        undo->update_undo(_("delete track"), LOAD_ALL);

        restart_brender();
        update_plugin_states();
        gui->update(1, 1, 1, 0, 1, 0, 0);
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                           CHANGE_EDL,
                           edl,
                           1);
        save_backup();
}

void MWindow::detach_transition(Transition *transition)
{
        hide_plugin(transition, 1);
        int is_video = (transition->edit->track->data_type == TRACK_VIDEO);
        transition->edit->detach_transition();
        save_backup();
        undo->update_undo(_("detach transition"), LOAD_ALL);

        if(is_video) restart_brender();
        gui->update(0,
                1,
                0,
                0,
                0, 
                0,
                0);
        sync_parameters(CHANGE_EDL);
}





// Insert data from clipboard
void MWindow::insert(double position, 
        FileXML *file,
        int edit_labels,
        int edit_plugins,
        EDL *parent_edl)
{
// For clipboard pasting make the new edl use a separate session 
// from the master EDL.  Then it can be resampled to the master rates.
// For splice, overwrite, and dragging need same session to get the assets.
        EDL edl(parent_edl);
        ArrayList<EDL*> new_edls;
        uint32_t load_flags = LOAD_ALL;
SET_TRACE

        new_edls.append(&edl);
        edl.create_objects();
SET_TRACE



        if(parent_edl) load_flags &= ~LOAD_SESSION;
        if(!edl.session->autos_follow_edits) load_flags &= ~LOAD_AUTOMATION;
        if(!edl.session->labels_follow_edits) load_flags &= ~LOAD_TIMEBAR;
SET_TRACE
        edl.load_xml(plugindb, file, load_flags);

SET_TRACE




        paste_edls(&new_edls, 
                LOAD_PASTE, 
                0, 
                position,
                edit_labels,
                edit_plugins);
// if(vwindow->edl)
// printf("MWindow::insert 5 %f %f\n", 
// vwindow->edl->local_session->in_point,
// vwindow->edl->local_session->out_point);
        new_edls.remove_all();
//printf("MWindow::insert 6 %p\n", vwindow->get_edl());
}

void MWindow::insert_effects_canvas(double start,
        double length)
{
        Track *dest_track = session->track_highlighted;
        if(!dest_track) return;


        for(int i = 0; i < session->drag_pluginservers->total; i++)
        {
                PluginServer *plugin = session->drag_pluginservers->values[i];

                insert_effect(plugin->title,
                        0,
                        dest_track,
                        i == 0 ? session->pluginset_highlighted : 0,
                        start,
                        length,
                        PLUGIN_STANDALONE);
        }

        save_backup();
        undo->update_undo(_("insert effect"), LOAD_EDITS | LOAD_PATCHES);
        restart_brender();
        sync_parameters(CHANGE_EDL);
// GUI updated in TrackCanvas, after current_operations are reset
}

void MWindow::insert_effects_cwindow(Track *dest_track)
{
        if(!dest_track) return;


        double start = 0;
        double length = dest_track->get_length();

        if(edl->local_session->get_selectionend() > 
                edl->local_session->get_selectionstart())
        {
                start = edl->local_session->get_selectionstart();
                length = edl->local_session->get_selectionend() - 
                        edl->local_session->get_selectionstart();
        }

        for(int i = 0; i < session->drag_pluginservers->total; i++)
        {
                PluginServer *plugin = session->drag_pluginservers->values[i];


                insert_effect(plugin->title,
                        0,
                        dest_track,
                        0,
                        start,
                        length,
                        PLUGIN_STANDALONE);
        }

        save_backup();
        undo->update_undo(_("insert effect"), LOAD_EDITS | LOAD_PATCHES);
        restart_brender();
        sync_parameters(CHANGE_EDL);
        gui->update(1,
                1,
                0,
                0,
                1,
                0,
                0);
}



void MWindow::insert_effect(char *title, 
        SharedLocation *shared_location, 
        Track *track,
        PluginSet *plugin_set,
        double start,
        double length,
        int plugin_type)
{
        KeyFrame *default_keyframe = 0;
        PluginServer *server = 0;






// Get default keyframe
        if(plugin_type == PLUGIN_STANDALONE)
        {
                default_keyframe = new KeyFrame;
                server = new PluginServer(*scan_plugindb(title, track->data_type));

                server->open_plugin(0, preferences, edl, 0, -1);
                server->save_data(default_keyframe);
        }



// Insert plugin object
        track->insert_effect(title, 
                shared_location, 
                default_keyframe, 
                plugin_set,
                start,
                length,
                plugin_type);

        track->optimize();


        if(plugin_type == PLUGIN_STANDALONE)
        {
                server->close_plugin();
                delete server;
                delete default_keyframe;
        }
}

int MWindow::modify_edithandles()
{





        edl->modify_edithandles(session->drag_start, 
                session->drag_position, 
                session->drag_handle, 
                edl->session->edit_handle_mode[session->drag_button],
                edl->session->labels_follow_edits, 
                edl->session->plugins_follow_edits);

        finish_modify_handles();


//printf("MWindow::modify_handles 1\n");
        return 0;
}

int MWindow::modify_pluginhandles()
{

        edl->modify_pluginhandles(session->drag_start, 
                session->drag_position, 
                session->drag_handle, 
                edl->session->edit_handle_mode[session->drag_button],
                edl->session->labels_follow_edits,
                session->trim_edits);

        finish_modify_handles();

        return 0;
}


// Common to edithandles and plugin handles
void MWindow::finish_modify_handles()
{
        int edit_mode = edl->session->edit_handle_mode[session->drag_button];

        if((session->drag_handle == 1 && edit_mode != MOVE_NO_EDITS) ||
                (session->drag_handle == 0 && edit_mode == MOVE_ONE_EDIT))
        {
                edl->local_session->set_selectionstart(session->drag_position);
                edl->local_session->set_selectionend(session->drag_position);
        }
        else
        if(edit_mode != MOVE_NO_EDITS)
        {
                edl->local_session->set_selectionstart(session->drag_start);
                edl->local_session->set_selectionend(session->drag_start);
        }

        if(edl->local_session->get_selectionstart(1) < 0)
        {
                edl->local_session->set_selectionstart(0);
                edl->local_session->set_selectionend(0);
        }

        save_backup();
        undo->update_undo(_("drag handle"), LOAD_EDITS | LOAD_TIMEBAR);
        restart_brender();
        sync_parameters(CHANGE_EDL);
        update_plugin_guis();
        gui->update(1, 2, 1, 1, 1, 1, 0);
        cwindow->update(1, 0, 0, 0, 1);
}

void MWindow::match_output_size(Track *track)
{
        track->track_w = edl->session->output_w;
        track->track_h = edl->session->output_h;
        save_backup();
        undo->update_undo(_("match output size"), LOAD_ALL);

        restart_brender();
        sync_parameters(CHANGE_EDL);
}


void MWindow::move_edits(ArrayList<Edit*> *edits, 
                Track *track,
                double position,
                int behaviour)
{

        edl->tracks->move_edits(edits, 
                track, 
                position,
                edl->session->labels_follow_edits, 
                edl->session->plugins_follow_edits,
                behaviour);

        save_backup();
        undo->update_undo(_("move edit"), LOAD_ALL);

        restart_brender();
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                CHANGE_EDL,
                edl,
                1);

        update_plugin_guis();
        gui->update(1,
                1,      // 1 for incremental drawing.  2 for full refresh
                1,
                0,
                0, 
                0,
                0);
}

void MWindow::move_effect(Plugin *plugin,
        PluginSet *dest_plugin_set,
        Track *dest_track,
        int64_t dest_position)
{

        edl->tracks->move_effect(plugin, 
                dest_plugin_set, 
                dest_track, 
                dest_position);

        save_backup();
        undo->update_undo(_("move effect"), LOAD_ALL);

        restart_brender();
        cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                CHANGE_EDL,
                edl,
                1);

        update_plugin_guis();
        gui->update(1,
                1,      // 1 for incremental drawing.  2 for full refresh
                0,
                0,
                0, 
                0,
                0);
}

void MWindow::move_plugins_up(PluginSet *plugin_set)
{

        plugin_set->track->move_plugins_up(plugin_set);

        save_backup();
        undo->update_undo(_("move effect up"), LOAD_ALL);
        restart_brender();
        gui->update(1,
                1,      // 1 for incremental drawing.  2 for full refresh
                0,
                0,
                0, 
                0,
                0);
        sync_parameters(CHANGE_EDL);
}

void MWindow::move_plugins_down(PluginSet *plugin_set)
{

        plugin_set->track->move_plugins_down(plugin_set);

        save_backup();
        undo->update_undo(_("move effect down"), LOAD_ALL);
        restart_brender();
        gui->update(1,
                1,      // 1 for incremental drawing.  2 for full refresh
                0,
                0,
                0, 
                0,
                0);
        sync_parameters(CHANGE_EDL);
}

void MWindow::move_track_down(Track *track)
{
        edl->tracks->move_track_down(track);
        save_backup();
        undo->update_undo(_("move track down"), LOAD_ALL);

        restart_brender();
        gui->update(1, 1, 0, 0, 1, 0, 0);
        sync_parameters(CHANGE_EDL);
        save_backup();
}

void MWindow::move_tracks_down()
{
        edl->tracks->move_tracks_down();
        save_backup();
        undo->update_undo(_("move tracks down"), LOAD_ALL);

        restart_brender();
        gui->update(1, 1, 0, 0, 1, 0, 0);
        sync_parameters(CHANGE_EDL);
        save_backup();
}

void MWindow::move_track_up(Track *track)
{
        edl->tracks->move_track_up(track);
        save_backup();
        undo->update_undo(_("move track up"), LOAD_ALL);
        restart_brender();
        gui->update(1, 1, 0, 0, 1, 0, 0);
        sync_parameters(CHANGE_EDL);
        save_backup();
}

void MWindow::move_tracks_up()
{
        edl->tracks->move_tracks_up();
        save_backup();
        undo->update_undo(_("move tracks up"), LOAD_ALL);
        restart_brender();
        gui->update(1, 1, 0, 0, 1, 0, 0);
        sync_parameters(CHANGE_EDL);
}


void MWindow::mute_selection()
{
        double start = edl->local_session->get_selectionstart();
        double end = edl->local_session->get_selectionend();
        if(start != end)
        {
                edl->clear(start, 
                        end, 
                        0, 
                        edl->session->plugins_follow_edits);
                edl->local_session->set_selectionend(end);
                edl->local_session->set_selectionstart(start);
                edl->paste_silence(start, end, 0, edl->session->plugins_follow_edits);
                save_backup();
                undo->update_undo(_("mute"), LOAD_EDITS);

                restart_brender();
                update_plugin_guis();
                gui->update(1, 2, 1, 1, 1, 1, 0);
                cwindow->playback_engine->que->send_command(CURRENT_FRAME, 
                                                                CHANGE_EDL,
                                                                edl,
                                                                1);
        }
}



void MWindow::overwrite(EDL *source)
{
        FileXML file;

        double src_start = source->local_session->get_selectionstart();
        double overwrite_len = source->local_session->get_selectionend() - src_start;
        double dst_start = edl->local_session->get_selectionstart();
        double dst_len = edl->local_session->get_selectionend() - dst_start;

        if (!EQUIV(dst_len, 0) && (dst_len < overwrite_len))
        {
// in/out points or selection present and shorter than overwrite range
// shorten the copy range
                overwrite_len = dst_len;
        }

        source->copy(src_start, 
                src_start + overwrite_len, 
                1,
                0,
                0,
                &file,
                plugindb,
                "",
                1);

// HACK around paste_edl get_start/endselection on its own
// so we need to clear only when not using both io points
// FIXME: need to write simple overwrite_edl to be used for overwrite function
        if (edl->local_session->get_inpoint() < 0 || 
                edl->local_session->get_outpoint() < 0)
                edl->clear(dst_start, 
                        dst_start + overwrite_len, 
                        0, 
                        0);

        paste(dst_start, 
                dst_start + overwrite_len, 
                &file,
                0,
                0);

        edl->local_session->set_selectionstart(dst_start + overwrite_len);
        edl->local_session->set_selectionend(dst_start + overwrite_len);

        save_backup();
        undo->update_undo(_("overwrite"), LOAD_EDITS);

        restart_brender();
        update_plugin_guis();
        gui->update(1, 1, 1, 1, 0, 1, 0);
        sync_parameters(CHANGE_EDL);
}

// For splice and overwrite
int MWindow::paste(double start, 
        double end, 
        FileXML *file,
        int edit_labels,
        int edit_plugins)
{
        clear(0);

// Want to insert with assets shared with the master EDL.
        insert(start, 
                        file,
                        edit_labels,
                        edit_plugins,
                        edl);

        return 0;
}

// For editing use insertion point position
void MWindow::paste()
{
SET_TRACE
        double start = edl->local_session->get_selectionstart();
        double end = edl->local_session->get_selectionend();
        int64_t len = gui->get_clipboard()->clipboard_len(SECONDARY_SELECTION);

        if(len)
        {
                char *string = new char[len + 1];

SET_TRACE

                gui->get_clipboard()->from_clipboard(string, 
                        len, 
                        SECONDARY_SELECTION);
                FileXML file;
                file.read_from_string(string);

SET_TRACE


                clear(0);
SET_TRACE
                insert(start, 
                        &file, 
                        edl->session->labels_follow_edits, 
                        edl->session->plugins_follow_edits);
SET_TRACE
                edl->optimize();
SET_TRACE

                delete [] string;

SET_TRACE

                save_backup();


                undo->update_undo(_("paste"), LOAD_EDITS | LOAD_TIMEBAR);
                restart_brender();
                update_plugin_guis();
                gui->update(1, 2, 1, 1, 0, 1, 0);
                awindow->gui->update_assets();
                sync_parameters(CHANGE_EDL);
        }
SET_TRACE
}

int MWindow::paste_assets(double position, Track *dest_track)
{
        int result = 0;




        if(session->drag_assets->total)
        {
                load_assets(session->drag_assets, 
                        position, 
                        LOAD_PASTE,
                        dest_track, 
                        0,
                        edl->session->labels_follow_edits, 
                        edl->session->plugins_follow_edits);
                result = 1;
        }


        if(session->drag_clips->total)
        {
                paste_edls(session->drag_clips, 
                        LOAD_PASTE, 
                        dest_track,
                        position, 
                        edl->session->labels_follow_edits, 
                        edl->session->plugins_follow_edits);
                result = 1;
        }


        save_backup();

        undo->update_undo(_("paste assets"), LOAD_EDITS);
        restart_brender();
        gui->update(1, 
                2,
                1,
                0,
                0,
                1,
                0);
        sync_parameters(CHANGE_EDL);
        return result;
}

void MWindow::load_assets(ArrayList<Asset*> *new_assets, 
        double position, 
        int load_mode,
        Track *first_track,
        RecordLabels *labels,
        int edit_labels,
        int edit_plugins)
{
//printf("MWindow::load_assets 1\n");
        if(position < 0) position = edl->local_session->get_selectionstart();

        ArrayList<EDL*> new_edls;
        for(int i = 0; i < new_assets->total; i++)
        {
                EDL *new_edl = new EDL;
                new_edl->create_objects();
                new_edl->copy_session(edl);
                new_edls.append(new_edl);


//printf("MWindow::load_assets 2 %d %d\n", new_assets->values[i]->audio_length, new_assets->values[i]->video_length);
                asset_to_edl(new_edl, new_assets->values[i]);


                if(labels)
                        for(RecordLabel *label = labels->first; label; label = label->next)
                        {
                                new_edl->labels->toggle_label(label->position, label->position);
                        }
        }
//printf("MWindow::load_assets 3\n");

        paste_edls(&new_edls, 
                load_mode, 
                first_track,
                position,
                edit_labels,
                edit_plugins);
//printf("MWindow::load_assets 4\n");


        save_backup();
        new_edls.remove_all_objects();

}

int MWindow::paste_automation()
{
        int64_t len = gui->get_clipboard()->clipboard_len(SECONDARY_SELECTION);

        if(len)
        {
                char *string = new char[len + 1];
                gui->get_clipboard()->from_clipboard(string, 
                        len, 
                        SECONDARY_SELECTION);
                FileXML file;
                file.read_from_string(string);

                edl->tracks->clear_automation(edl->local_session->get_selectionstart(), 
                        edl->local_session->get_selectionend()); 
                edl->tracks->paste_automation(edl->