trackcanvas.C

Go to the documentation of this file.

#include "asset.h"
#include "autoconf.h"
#include "automation.h"
#include "bcsignals.h"
#include "bctimer.h"
#include "clip.h"
#include "colors.h"
#include "cplayback.h"
#include "cursors.h"
#include "cwindow.h"
#include "cwindowgui.h"
#include "edithandles.h"
#include "editpopup.h"
#include "edits.h"
#include "edl.h"
#include "edlsession.h"
#include "floatauto.h"
#include "floatautos.h"
#include "intauto.h"
#include "keyframe.h"
#include "keyframepopup.h"
#include "keyframes.h"
#include "keys.h"
#include "localsession.h"
#include "mainclock.h"
#include "maincursor.h"
#include "mainundo.h"
#include "maskautos.h"
#include "mbuttons.h"
#include "mtimebar.h"
#include "mwindow.h"
#include "mwindowgui.h"
#include "patchbay.h"
#include "tracking.h"
#include "panautos.h"
#include "playbackengine.h"
#include "playtransport.h"
#include "plugin.h"
#include "pluginpopup.h"
#include "pluginset.h"
#include "pluginserver.h"
#include "preferences.h"
#include "resourcepixmap.h"
#include "mainsession.h"
#include "transitionhandles.h"
#include "transitionpopup.h"
#include "transportque.h"
#include "zoombar.h"
#include "theme.h"
#include "intautos.h"
#include "trackcanvas.h"
#include "tracks.h"
#include "transition.h"
#include "vframe.h"
#include "apatchgui.inc"
#include "vpatchgui.inc"

#include <string.h>

TrackCanvas::TrackCanvas(MWindow *mwindow, MWindowGUI *gui)
 : BC_SubWindow(mwindow->theme->mcanvas_x,
        mwindow->theme->mcanvas_y,
        gui->view_w,
        gui->view_h)
{
        this->mwindow = mwindow;
        this->gui = gui;
        current_end = 0;
        selection_midpoint1 = selection_midpoint2 = 0;
        selection_type = 0;
        region_selected = 0;
        handle_selected = 0;
        auto_selected = 0;
        translate_selected = 0;
        which_handle = 0;
        handle_pixel = 0;
        drag_scroll = 0;
        drag_popup = 0;
        active = 0;
        temp_picon = 0;
        resource_timer = new Timer;
        hourglass_enabled = 0;
}

TrackCanvas::~TrackCanvas()
{
        for(int i = 0; i < resource_pixmaps.total; i++)
                delete resource_pixmaps.values[i];
//      delete transition_handles;
        delete edit_handles;
        delete keyframe_pixmap;
        delete camerakeyframe_pixmap;
        delete modekeyframe_pixmap;
        delete pankeyframe_pixmap;
        delete projectorkeyframe_pixmap;
        delete maskkeyframe_pixmap;
        delete background_pixmap;
        if(temp_picon) delete temp_picon;
        delete resource_timer;
}

int TrackCanvas::create_objects()
{
        background_pixmap = new BC_Pixmap(this, get_w(), get_h());
//      transition_handles = new TransitionHandles(mwindow, this);
        edit_handles = new EditHandles(mwindow, this);
        keyframe_pixmap = new BC_Pixmap(this, mwindow->theme->keyframe_data, PIXMAP_ALPHA);
        camerakeyframe_pixmap = new BC_Pixmap(this, mwindow->theme->camerakeyframe_data, PIXMAP_ALPHA);
        modekeyframe_pixmap = new BC_Pixmap(this, mwindow->theme->modekeyframe_data, PIXMAP_ALPHA);
        pankeyframe_pixmap = new BC_Pixmap(this, mwindow->theme->pankeyframe_data, PIXMAP_ALPHA);
        projectorkeyframe_pixmap = new BC_Pixmap(this, mwindow->theme->projectorkeyframe_data, PIXMAP_ALPHA);
        maskkeyframe_pixmap = new BC_Pixmap(this, mwindow->theme->maskkeyframe_data, PIXMAP_ALPHA);
        draw();
        update_cursor();
        flash();
        return 0;
}

void TrackCanvas::resize_event()
{
//printf("TrackCanvas::resize_event 1\n");
        draw(0, 0);
        flash();
//printf("TrackCanvas::resize_event 2\n");
}

int TrackCanvas::keypress_event()
{
        int result = 0;


        return result;
}

int TrackCanvas::drag_motion()
{
        int cursor_x = get_relative_cursor_x();
        int cursor_y = get_relative_cursor_y();
        Track *over_track = 0;
        Edit *over_edit = 0;
        PluginSet *over_pluginset = 0;
        Plugin *over_plugin = 0;
        int redraw = 0;


        if(drag_popup)
        {
                drag_popup->cursor_motion_event();
        }


// there's no point in drawing highlights has until drag operation has been set
        if (!mwindow->session->current_operation)
                return 0;

        if(get_cursor_over_window() &&
                cursor_x >= 0 && 
                cursor_y >= 0 && 
                cursor_x < get_w() && 
                cursor_y < get_h())
        {
// Find the edit and track the cursor is over
                for(Track *track = mwindow->edl->tracks->first; track; track = track->next)
                {
                        int64_t track_x, track_y, track_w, track_h;
                        track_dimensions(track, track_x, track_y, track_w, track_h);

                        if(cursor_y >= track_y && 
                                cursor_y < track_y + track_h)
                        {
                                over_track = track;
                                for(Edit *edit = track->edits->first; edit; edit = edit->next)
                                {
                                        int64_t edit_x, edit_y, edit_w, edit_h;
                                        edit_dimensions(edit, edit_x, edit_y, edit_w, edit_h);

                                        if(cursor_x >= edit_x && 
                                                cursor_y >= edit_y && 
                                                cursor_x < edit_x + edit_w && 
                                                cursor_y < edit_y + edit_h)
                                        {
                                                over_edit = edit;
                                                break;
                                        }
                                }

                                for(int i = 0; i < track->plugin_set.total; i++)
                                {
                                        PluginSet *pluginset = track->plugin_set.values[i];
                                        


                                        for(Plugin *plugin = (Plugin*)pluginset->first;
                                                plugin;
                                                plugin = (Plugin*)plugin->next)
                                        {
                                                int64_t plugin_x, plugin_y, plugin_w, plugin_h;
                                                plugin_dimensions(plugin, plugin_x, plugin_y, plugin_w, plugin_h);
                                                
                                                if(cursor_y >= plugin_y &&
                                                        cursor_y < plugin_y + plugin_h)
                                                {
                                                        over_pluginset = plugin->plugin_set;
                                                
                                                        if(cursor_x >= plugin_x &&
                                                                cursor_x < plugin_x + plugin_w)
                                                        {
                                                                over_plugin = plugin;
                                                                break;
                                                        }
                                                }
                                        }
                                }
                                break;
                        }
                }
        }

        if (!over_track)        // check for pastes from patchbay
                over_track = mwindow->gui->patchbay->is_over_track();

        if(mwindow->session->track_highlighted != over_track) 
        {
                mwindow->session->track_highlighted = over_track;
                redraw = 1;
        }

        if(mwindow->session->edit_highlighted != over_edit)
        {
                mwindow->session->edit_highlighted = over_edit;
                redraw = 1;
        }

        if(mwindow->session->pluginset_highlighted != over_pluginset)
        {
                mwindow->session->pluginset_highlighted = over_pluginset;
                redraw = 1;
        }

        if(mwindow->session->plugin_highlighted != over_plugin)
        {
                mwindow->session->plugin_highlighted = over_plugin;
                redraw = 1;
        }

        if (mwindow->session->current_operation == DRAG_ASSET ||
          mwindow->session->current_operation == DRAG_EDIT)

        {
                redraw = 1;
        }

//printf("TrackCanvas::drag_motion 2 %p\n", mwindow->session->track_highlighted);
        if(redraw)
        {
                lock_window("TrackCanvas::drag_motion");
                draw_overlays();
                flash();
                unlock_window();
        }

        return 0;
}

int TrackCanvas::drag_start_event()
{
        int result = 0;
        int redraw = 0;
        int rerender = 0;
        int new_cursor, update_cursor;

        if(mwindow->session->current_operation != NO_OPERATION) return 0;

        if(is_event_win())
        {
                if(do_plugins(get_drag_x(), 
                        get_drag_y(), 
                        1,
                        0,
                        redraw,
                        rerender))
                {
                        result = 1;
                }
                else
                if(do_edits(get_drag_x(),
                        get_drag_y(),
                        0,
                        1,
                        redraw,
                        rerender,
                        new_cursor,
                        update_cursor))
                {
                        result = 1;
                }
        }

        return result;
}

int TrackCanvas::drag_motion_event()
{
        return drag_motion();
}

int TrackCanvas::cursor_leave_event()
{
// Because drag motion calls get_cursor_over_window we can be sure that
// all highlights get deleted now.
// This ended up blocking keyboard input from the drag operations.
        return 0;
//      return drag_motion();
}


int TrackCanvas::drag_stop_event()
{
        int result = drag_stop();

        if(drag_popup)
        {
                delete drag_popup;
                drag_popup = 0;
        }
        return result;
}


int TrackCanvas::drag_stop()
{
// In most cases the editing routine redraws and not the drag_stop
        int result = 0, redraw = 0;

        int insertion = 0;           // used in drag and drop mode
        switch(mwindow->session->current_operation)
        {
                case DRAG_VTRANSITION:
                case DRAG_ATRANSITION:
                        if(mwindow->session->edit_highlighted)
                        {
                                if((mwindow->session->current_operation == DRAG_ATRANSITION &&
                                        mwindow->session->track_highlighted->data_type == TRACK_AUDIO) ||
                                        (mwindow->session->current_operation == DRAG_VTRANSITION &&
                                        mwindow->session->track_highlighted->data_type == TRACK_VIDEO))
                                {
                                        mwindow->session->current_operation = NO_OPERATION;
                                        mwindow->paste_transition();
                                        result = 1;
                                }
                        }
                        redraw = 1;
                        break;




// Behavior for dragged plugins is limited by the fact that a shared plugin
// can only refer to a standalone plugin that exists in the same position in
// time.  Dragging a plugin from one point in time to another can't produce
// a shared plugin to the original plugin.  In this case we relocate the
// plugin instead of sharing it.
                case DRAG_AEFFECT_COPY:
                case DRAG_VEFFECT_COPY:
                        if(mwindow->session->track_highlighted &&
                                ((mwindow->session->current_operation == DRAG_AEFFECT_COPY &&
                                        mwindow->session->track_highlighted->data_type == TRACK_AUDIO) ||
                                        (mwindow->session->current_operation == DRAG_VEFFECT_COPY &&
                                        mwindow->session->track_highlighted->data_type == TRACK_VIDEO)))
                        {
                                mwindow->session->current_operation = NO_OPERATION;

// Insert shared plugin in source
                                if(mwindow->session->track_highlighted != mwindow->session->drag_plugin->track &&
                                        !mwindow->session->plugin_highlighted &&
                                        !mwindow->session->pluginset_highlighted)
                                {
// Move plugin if different startproject
                                        mwindow->move_effect(mwindow->session->drag_plugin,
                                                0,
                                                mwindow->session->track_highlighted,
                                                0);
                                        result = 1;
                                }
                                else
// Move source to different location
                                if(mwindow->session->pluginset_highlighted)
                                {
//printf("TrackCanvas::drag_stop 6\n");
                                        if(mwindow->session->plugin_highlighted)
                                        {
                                                mwindow->move_effect(mwindow->session->drag_plugin,
                                                        mwindow->session->plugin_highlighted->plugin_set,
                                                        0,
                                                        mwindow->session->plugin_highlighted->startproject);
                                        }
                                        else
                                        {
                                                mwindow->move_effect(mwindow->session->drag_plugin,
                                                        mwindow->session->pluginset_highlighted,
                                                        0,
                                                        mwindow->session->pluginset_highlighted->length());
                                        }
                                        result = 1;
                                }
                                else
// Move to a new plugin set between two edits
                                if(mwindow->session->edit_highlighted)
                                {
                                        mwindow->move_effect(mwindow->session->drag_plugin,
                                                0,
                                                mwindow->session->track_highlighted,
                                                mwindow->session->edit_highlighted->startproject);
                                        result = 1;
                                }
                                else
// Move to a new plugin set
                                if(mwindow->session->track_highlighted)
                                {
                                        mwindow->move_effect(mwindow->session->drag_plugin,
                                                0,
                                                mwindow->session->track_highlighted,
                                                0);
                                        result = 1;
                                }
                        }
                        break;

                case DRAG_AEFFECT:
                case DRAG_VEFFECT:
                        if(mwindow->session->track_highlighted && 
                                ((mwindow->session->current_operation == DRAG_AEFFECT &&
                                mwindow->session->track_highlighted->data_type == TRACK_AUDIO) ||
                                (mwindow->session->current_operation == DRAG_VEFFECT &&
                                mwindow->session->track_highlighted->data_type == TRACK_VIDEO)))
                        {
// Drop all the effects
                                PluginSet *plugin_set = mwindow->session->pluginset_highlighted;
                                Track *track = mwindow->session->track_highlighted;
                                double start = 0;
                                double length = track->get_length();

                                if(mwindow->session->plugin_highlighted)
                                {
                                        start = track->from_units(mwindow->session->plugin_highlighted->startproject);
                                        length = track->from_units(mwindow->session->plugin_highlighted->length);
                                        if(length <= 0) length = track->get_length();
                                }
                                else
                                if(mwindow->session->pluginset_highlighted)
                                {
                                        start = track->from_units(plugin_set->length());
                                        length = track->get_length() - start;
                                        if(length <= 0) length = track->get_length();
                                }
                                else
                                if(mwindow->edl->local_session->get_selectionend() > 
                                        mwindow->edl->local_session->get_selectionstart())
                                {
                                        start = mwindow->edl->local_session->get_selectionstart();
                                        length = mwindow->edl->local_session->get_selectionend() - 
                                                mwindow->edl->local_session->get_selectionstart();
                                }
// Move to a point between two edits
                                else
                                if(mwindow->session->edit_highlighted)
                                {
                                        start = mwindow->session->track_highlighted->from_units(
                                                mwindow->session->edit_highlighted->startproject);
                                        length = mwindow->session->track_highlighted->from_units(
                                                mwindow->session->edit_highlighted->length);
                                }

                                mwindow->insert_effects_canvas(start, length);
                                redraw = 1;
                        }
                        if (mwindow->session->track_highlighted)
                                result = 1;  // we have to cleanup
                        break;

                case DRAG_ASSET:
                        if(mwindow->session->track_highlighted)
                        {
                                float asset_length_float;
                                int64_t asset_length_units;
                                int64_t position = 0;
                                        
                                if(mwindow->session->current_operation == DRAG_ASSET &&
                                        mwindow->session->drag_assets->total)
                                {
                                        Asset *asset = mwindow->session->drag_assets->values[0];

                                        // we use video if we are over video and audio if we are over audio
                                        if (asset->video_data && mwindow->session->track_highlighted->data_type == TRACK_VIDEO)
                                                asset_length_float = asset->video_length / asset->frame_rate;
                                        else if (asset->audio_data && mwindow->session->track_highlighted->data_type == TRACK_AUDIO)
                                                asset_length_float = asset->audio_length / asset->sample_rate;
                                        else
                                        {
                                                result = 1;
                                                break;  // Do not do anything
                                        }
                                }
                                if(mwindow->session->current_operation == DRAG_ASSET &&
                                        mwindow->session->drag_clips->total)
                                {
                                        EDL *clip = mwindow->session->drag_clips->values[0];
                                        asset_length_float = clip->tracks->total_length();
                                }
                        
                                asset_length_units = mwindow->session->track_highlighted->to_units(asset_length_float, 0);
                                position = get_drop_position (&insertion, NULL, asset_length_units);
                                if (position == -1)
                                {
                                        result = 1;
                                        break;          // Do not do anything
                                }
                                
                                double position_f = mwindow->session->track_highlighted->from_units(position);
                                Track *track = mwindow->session->track_highlighted;

                                if (!insertion)
                                {
                                        // FIXME, we should create an mwindow/EDL method that overwrites, without clearing the keyframes and autos
                                        // Unfortunately, this is _a lot_ of work to do right
                                        mwindow->edl->tracks->clear(position_f, 
                                                position_f + asset_length_float, 0);
                                }
                                mwindow->paste_assets(position_f, track);
                                result = 1;    // need to be one no matter what, since we have track highlited so we have to cleanup....
                        }
                        break;

                case DRAG_EDIT:
                        mwindow->session->current_operation = NO_OPERATION;
                        if(mwindow->session->track_highlighted)
                        {
                                if(mwindow->session->track_highlighted->data_type == mwindow->session->drag_edit->track->data_type)
                                {
                                        int64_t position = 0;
                                
                                        position = get_drop_position (&insertion, mwindow->session->drag_edit, mwindow->session->drag_edit->length);

                                        if (position == -1)
                                        {
                                                result = 1;
                                                break;          // Do not do anything
                                        }
                                        
                                        double position_f = mwindow->session->track_highlighted->from_units(position);
                                        Track *track = mwindow->session->track_highlighted;
                                        mwindow->move_edits(mwindow->session->drag_edits,
                                                track,
                                                position_f,
                                                !insertion);
                                }

                                result = 1;
                        }
                        break;
        }

// since we don't have subwindows we have to terminate any drag operation
        if(result)
        {
                if (mwindow->session->track_highlighted
                        || mwindow->session->edit_highlighted
                        || mwindow->session->plugin_highlighted
                        || mwindow->session->pluginset_highlighted) 
                        redraw = 1;
                mwindow->session->track_highlighted = 0;
                mwindow->session->edit_highlighted = 0;
                mwindow->session->plugin_highlighted = 0;
                mwindow->session->pluginset_highlighted = 0;
                mwindow->session->current_operation = NO_OPERATION;
        }


//printf("TrackCanvas::drag_stop %d %d\n", redraw, mwindow->session->current_operation);
        if(redraw)
        {
                mwindow->edl->tracks->update_y_pixels(mwindow->theme);
                gui->get_scrollbars();
                draw();
                gui->patchbay->update();
                gui->cursor->update();
                flash();
                flush();
        }

        return result;
}


int64_t TrackCanvas::get_drop_position (int *is_insertion, Edit *moved_edit, int64_t moved_edit_length)
{
        *is_insertion = 0;

        // get the canvas/track position
        int cursor_x = get_relative_cursor_x();
        double pos = (double)cursor_x * 
                mwindow->edl->local_session->zoom_sample / 
                mwindow->edl->session->sample_rate + 
                (double)mwindow->edl->local_session->view_start * 
                mwindow->edl->local_session->zoom_sample /
                mwindow->edl->session->sample_rate;
        // convert to track's units to operate with them
        Track *track = mwindow->session->track_highlighted;
        // cursor relative position - depending on where we started the drag inside the edit
        int64_t cursor_position;
        if (moved_edit)  // relative cursor position depends upon grab point
                cursor_position = track->to_units (pos - (mwindow->session->drag_position - moved_edit->track->from_units(moved_edit->startproject)), 1);
        else             // for clips and assets acts as they were grabbed in the middle
                cursor_position = track->to_units (pos , 1) - moved_edit_length / 2;
           
        // we use real cursor position for affinity calculations
        int64_t real_cursor_position = track->to_units (pos, 0); 
        if (cursor_position < 0) cursor_position = 0;
        if (real_cursor_position < 0) real_cursor_position = 0;
        int64_t position = -1;
        int64_t span_start = 0;
        int64_t span_length = 0;
        int span_asset = 0;
        int last_ignore = 0; // used to make sure we can ignore the last edit if that is what we are dragging

        if (!track->edits->last)
        {
                // No edits -> no problems!
                position = cursor_position;
        }
        else
        {
                Edit *fake_edit = new Edit(mwindow->edl, track);
                int last2 = 0; // last2 is a hack that let us make virtual edits at the end so thing works for last edit also
                               // we do this by appending two VERY long virtual edits at the end
                
                for (Edit *edit = track->edits->first; edit || last2 < 2; )
                {
                
                        if (!edit && last_ignore)
                        {
                                span_length += 100000000000000LL;
                                last_ignore = 0;
                                span_asset = 0;
                        } else
                        if (edit && 
                            ((moved_edit && edit == moved_edit && edit->previous && !edit->previous->asset) ||
                            (moved_edit && edit->previous == moved_edit  && !edit->asset)))
                        {
                                span_length += edit->length;        // our fake edit spans over the edit we are moving
                                last_ignore = 1;
                        } else
                        { // This is a virtual edit
                                fake_edit->startproject = span_start;
                                fake_edit->length = span_length;
                                int64_t edit_x, edit_y, edit_w, edit_h;
                                edit_dimensions(fake_edit, edit_x, edit_y, edit_w, edit_h);
                                if (labs(edit_x - cursor_x) < HANDLE_W)                 // cursor is close to the beginning of an edit -> insertion
                                {
                                        *is_insertion = 1;
                                        position = span_start;
                                } else
                                if (labs(edit_x + edit_w - cursor_x) < HANDLE_W)        // cursor is close to the end of an edit -> insertion
                                {
                                        *is_insertion = 1;
                                        position = span_start + span_length;

                                }  else
                                if (!span_asset &&              // we have enough empty space to position the edit where user wants 
                                        span_start <= cursor_position &&
                                        span_start + span_length >= cursor_position + moved_edit_length)
                                {
                                        position = cursor_position; 
                                } else
                                if (!span_asset &                               // we are inside an empty edit, but cannot push the edit as far as user wants, so 'resist moving it further'
                                        real_cursor_position >= span_start && 
                                        real_cursor_position < span_start + span_length && 
                                        span_length >= moved_edit_length)
                                {
                                        if (llabs(real_cursor_position - span_start) < llabs(real_cursor_position - span_start - span_length))
                                                position = span_start;
                                        else
                                                position = span_start + span_length - moved_edit_length;
                                } else
                                if (cursor_x > edit_x && cursor_x <= edit_x + edit_w / 2) // we are inside an nonempty edit, - snap to left
                                {
                                        *is_insertion = 1;
                                        position = span_start;                          
                                } else
                                if (cursor_x > edit_x + edit_w / 2 && cursor_x <= edit_x + edit_w) // we are inside an nonempty edit, - snap to right
                                {
                                        *is_insertion = 1;
                                        position = span_start + span_length;                            
                                }                               
                                

                                if (position != -1) 
                                        break;
                                
                                // This is the new edit
                                if (edit)
                                {
                                                span_length = edit->length;             
                                                span_start = edit->startproject;  
                                                last_ignore = 0;
                                                if (!edit->asset || (!moved_edit || moved_edit == edit)) 
                                                {
                                                        if (moved_edit && moved_edit == edit)
                                                                last_ignore = 1;
                
                                                        span_asset = 0;
                                                } else 
                                                        span_asset = 1;
                                } else
                                {
                                        span_start = span_length + span_start;
                                        span_length = 100000000000000LL;
                                        span_asset = 0;
                                };
                                

                        }
                        if (edit)
                                edit = edit->next;
                        else
                                last2++;
                        
                }
                delete fake_edit;

        }
        if (real_cursor_position == 0) 
        {
                position = 0;
                *is_insertion = 1;
        }
//      printf("rcp: %lli, position: %lli, insertion: %i\n", real_cursor_position, position, *is_insertion);
        return position;


}

void TrackCanvas::draw(int force, int hide_cursor)
{
// Swap pixmap layers
TRACE("TrackCanvas::draw 1")
        if(get_w() != background_pixmap->get_w() ||
                get_h() != background_pixmap->get_h())
        {
                delete background_pixmap;
                background_pixmap = new BC_Pixmap(this, get_w(), get_h());
        }

TRACE("TrackCanvas::draw 10")
// Cursor disappears after resize when this is called.
// Cursor doesn't redraw after editing when this isn't called.
        if(gui->cursor && hide_cursor) gui->cursor->hide();
TRACE("TrackCanvas::draw 20")
        draw_top_background(get_parent(), 0, 0, get_w(), get_h(), background_pixmap);
TRACE("TrackCanvas::draw 30")
        draw_resources(force);
TRACE("TrackCanvas::draw 40")
        draw_overlays();
UNTRACE
}

void TrackCanvas::update_cursor()
{
        switch(mwindow->edl->session->editing_mode)
        {
                case EDITING_ARROW: set_cursor(ARROW_CURSOR); break;
                case EDITING_IBEAM: set_cursor(IBEAM_CURSOR); break;
        }
}


void TrackCanvas::test_timer()
{
        if(resource_timer->get_difference() > 1000 && 
                !hourglass_enabled)
        {
                start_hourglass();
                hourglass_enabled = 1;
        }
}


void TrackCanvas::draw_indexes(Asset *asset)
{
// Don't redraw raw samples
        if(asset->index_zoom > mwindow->edl->local_session->zoom_sample)
                return;

        draw_resources(0, 1, asset);

        draw_overlays();
        draw_automation();
        flash();
        flush();
}

void TrackCanvas::draw_resources(int force, 
        int indexes_only, 
        Asset *index_asset)
{
        if(!mwindow->edl->session->show_assets) return;

        resource_timer->update();

// Age resource pixmaps for deletion
        if(!indexes_only)
                for(int i = 0; i < resource_pixmaps.total; i++)
                        resource_pixmaps.values[i]->visible--;

        if(force)
                resource_pixmaps.remove_all_objects();


// Search every edit
        for(Track *current = mwindow->edl->tracks->first;
                current;
                current = NEXT)
        {
                for(Edit *edit = current->edits->first; edit; edit = edit->next)
                {
                        if(!edit->asset) continue;
                        if(indexes_only)
                        {
                                if(edit->track->data_type != TRACK_AUDIO) continue;
                                if(!edit->asset->test_path(index_asset->path)) continue;
                        }

                        int64_t edit_x, edit_y, edit_w, edit_h;
                        edit_dimensions(edit, edit_x, edit_y, edit_w, edit_h);

// Edit is visible
                        if(MWindowGUI::visible(edit_x, edit_x + edit_w, 0, get_w()) &&
                                MWindowGUI::visible(edit_y, edit_y + edit_h, 0, get_h()))
                        {
                                int64_t pixmap_x, pixmap_w, pixmap_h;

// Search for existing pixmap containing edit
                                for(int i = 0; i < resource_pixmaps.total; i++)
                                {
                                        ResourcePixmap* pixmap = resource_pixmaps.values[i];
// Same pointer can be different edit if editing took place
                                        if(pixmap->edit_id == edit->id)
                                        {
                                                pixmap->visible = 1;
                                                break;
                                        }
                                }

// Get new size, offset of pixmap needed
                                get_pixmap_size(edit, 
                                        edit_x, 
                                        edit_w, 
                                        pixmap_x, 
                                        pixmap_w, 
                                        pixmap_h);

// Draw new data
                                if(pixmap_w && pixmap_h)
                                {
// Create pixmap if it doesn't exist
                                        ResourcePixmap* pixmap = create_pixmap(edit, 
                                                edit_x, 
                                                pixmap_x, 
                                                pixmap_w, 
                                                pixmap_h);
// Resize it if it's bigger
                                        if(pixmap_w > pixmap->pixmap_w ||
                                                pixmap_h > pixmap->pixmap_h)
                                                pixmap->resize(pixmap_w, pixmap_h);
                                        pixmap->draw_data(edit,
                                                edit_x, 
                                                edit_w, 
                                                pixmap_x, 
                                                pixmap_w, 
                                                pixmap_h, 
                                                force,
                                                indexes_only);
// Resize it if it's smaller
                                        if(pixmap_w < pixmap->pixmap_w ||
                                                pixmap_h < pixmap->pixmap_h)
                                                pixmap->resize(pixmap_w, pixmap_h);
// Copy pixmap to background canvas
                                        background_pixmap->draw_pixmap(pixmap, 
                                                pixmap->pixmap_x, 
                                                current->y_pixel,
                                                pixmap->pixmap_w,
                                                edit_h);
                                }
                        }
                }
        }

// Delete unused pixmaps
        if(!indexes_only)
                for(int i = resource_pixmaps.total - 1; i >= 0; i--)
                        if(resource_pixmaps.values[i]->visible < -5)
                        {
                                delete resource_pixmaps.values[i];
                                resource_pixmaps.remove(resource_pixmaps.values[i]);
                        }

        if(hourglass_enabled) 
        {
                stop_hourglass();
                hourglass_enabled = 0;
        }
}

ResourcePixmap* TrackCanvas::create_pixmap(Edit *edit, 
        int64_t edit_x, 
        int64_t pixmap_x, 
        int64_t pixmap_w, 
        int64_t pixmap_h)
{
        ResourcePixmap *result = 0;

        for(int i = 0; i < resource_pixmaps.total; i++)
        {
//printf("TrackCanvas::create_pixmap 1 %d %d\n", edit->id, resource_pixmaps.values[i]->edit->id);
                if(resource_pixmaps.values[i]->edit_id == edit->id) 
                {
                        result = resource_pixmaps.values[i];
                        break;
                }
        }

        if(!result)
        {
//printf("TrackCanvas::create_pixmap 2\n");
                result = new ResourcePixmap(mwindow, 
                        this, 
                        edit, 
                        pixmap_w, 
                        pixmap_h);
                resource_pixmaps.append(result);
        }

//      result->resize(pixmap_w, pixmap_h);
        return result;
}

void TrackCanvas::get_pixmap_size(Edit *edit, 
        int64_t edit_x, 
        int64_t edit_w, 
        int64_t &pixmap_x, 
        int64_t &pixmap_w,
        int64_t &pixmap_h)
{

// Align x on frame boundaries


//      switch(edit->edits->track->data_type)
//      {
//              case TRACK_AUDIO:

                        pixmap_x = edit_x;
                        pixmap_w = edit_w;
                        if(pixmap_x < 0)
                        {
                                pixmap_w -= -edit_x;
                                pixmap_x = 0;
                        }

                        if(pixmap_x + pixmap_w > get_w())
                        {
                                pixmap_w = get_w() - pixmap_x;
                        }

//                      break;
// 
//              case TRACK_VIDEO:
//              {
//                      int64_t picon_w = (int64_t)(edit->picon_w() + 0.5);
//                      int64_t frame_w = (int64_t)(edit->frame_w() + 0.5);
//                      int64_t pixel_increment = MAX(picon_w, frame_w);
//                      int64_t pixmap_x1 = edit_x;
//                      int64_t pixmap_x2 = edit_x + edit_w;
// 
//                      if(pixmap_x1 < 0)
//                      {
//                              pixmap_x1 = (int64_t)((double)-edit_x / pixel_increment) * 
//                                      pixel_increment + 
//                                      edit_x;
//                      }
// 
//                      if(pixmap_x2 > get_w())
//                      {
//                              pixmap_x2 = (int64_t)((double)(get_w() - edit_x) / pixel_increment + 1) * 
//                                      pixel_increment + 
//                                      edit_x;
//                      }
//                      pixmap_x = pixmap_x1;
//                      pixmap_w = pixmap_x2 - pixmap_x1;
//                      break;
//              }
//      }

        pixmap_h = mwindow->edl->local_session->zoom_track;
        if(mwindow->edl->session->show_titles) pixmap_h += mwindow->theme->title_bg_data->get_h();
//printf("get_pixmap_size %d %d %d %d\n", edit_x, edit_w, pixmap_x, pixmap_w);
}

void TrackCanvas::edit_dimensions(Edit *edit, 
        int64_t &x, 
        int64_t &y, 
        int64_t &w, 
        int64_t &h)
{
//      w = Units::round(edit->track->from_units(edit->length) * 
//              mwindow->edl->session->sample_rate / 
//              mwindow->edl->local_session->zoom_sample);

        h = resource_h();

        x = Units::round(edit->track->from_units(edit->startproject) * 
                        mwindow->edl->session->sample_rate /
                        mwindow->edl->local_session->zoom_sample - 
                        mwindow->edl->local_session->view_start);

// Method for calculating w so when edits are together we never get off by one error due to rounding
        int64_t x_next = Units::round(edit->track->from_units(edit->startproject + edit->length) * 
                        mwindow->edl->session->sample_rate /
                        mwindow->edl->local_session->zoom_sample - 
                        mwindow->edl->local_session->view_start);
        w = x_next - x;

        y = edit->edits->track->y_pixel;

        if(mwindow->edl->session->show_titles) 
                h += mwindow->theme->title_bg_data->get_h();
}

void TrackCanvas::track_dimensions(Track *track, int64_t &x, int64_t &y, int64_t &w, int64_t &h)
{
        x = 0;
        w = get_w();
        y = track->y_pixel;
        h = track->vertical_span(mwindow->theme);
}


void TrackCanvas::draw_paste_destination()
{
        int current_atrack = 0;
        int current_vtrack = 0;
        int current_aedit = 0;
        int current_vedit = 0;
        int64_t w = 0;
        int64_t x;
        double position;
        int insertion  = 0;


        if((mwindow->session->current_operation == DRAG_ASSET &&
                        (mwindow->session->drag_assets->total ||
                        mwindow->session->drag_clips->total)) ||
                (mwindow->session->current_operation == DRAG_EDIT &&
                        mwindow->session->drag_edits->total))
        {

                Asset *asset = 0;