cwindowgui.C

Go to the documentation of this file.

#include "automation.h"
#include "autos.h"
#include "bcsignals.h"
#include "canvas.h"
#include "clip.h"
#include "cpanel.h"
#include "cplayback.h"
#include "ctimebar.h"
#include "cursors.h"
#include "cwindowgui.h"
#include "cwindow.h"
#include "cwindowtool.h"
#include "editpanel.h"
#include "edl.h"
#include "edlsession.h"
#include "floatauto.h"
#include "floatautos.h"
#include "language.h"
#include "localsession.h"
#include "mainclock.h"
#include "mainmenu.h"
#include "mainundo.h"
#include "mainsession.h"
#include "maskauto.h"
#include "maskautos.h"
#include "meterpanel.h"
#include "mwindowgui.h"
#include "mwindow.h"
#include "mwindow.h"
#include "playtransport.h"
#include "theme.h"
#include "trackcanvas.h"
#include "tracks.h"
#include "transportque.h"
#include "vtrack.h"


static double my_zoom_table[] = 
{
        0.25,
        0.33,
        0.50,
        0.75,
        1.0,
        1.5,
        2.0,
        3.0,
        4.0
};

static int total_zooms = sizeof(my_zoom_table) / sizeof(double);


CWindowGUI::CWindowGUI(MWindow *mwindow, CWindow *cwindow)
 : BC_Window(PROGRAM_NAME ": Compositor",
        mwindow->session->cwindow_x, 
    mwindow->session->cwindow_y, 
    mwindow->session->cwindow_w, 
    mwindow->session->cwindow_h,
    100,
    100,
    1,
    1,
    1,
        BC_WindowBase::get_resources()->bg_color,
        mwindow->edl->session->get_cwindow_display())
{
        this->mwindow = mwindow;
    this->cwindow = cwindow;
        affected_track = 0;
        affected_x = 0;
        affected_y = 0;
        affected_z = 0;
        affected_keyframe = 0;
        affected_point = 0;
        x_offset = 0;
        y_offset = 0;
        x_origin = 0;
        y_origin = 0;
        current_operation = CWINDOW_NONE;
        tool_panel = 0;
        translating_zoom = 0;
        active = 0;
        inactive = 0;
        crop_translate = 0;
}

CWindowGUI::~CWindowGUI()
{
        if(tool_panel) delete tool_panel;
        delete meters;
        delete composite_panel;
        delete canvas;
        delete transport;
        delete edit_panel;
        delete zoom_panel;
        delete active;
        delete inactive;
}

int CWindowGUI::create_objects()
{
SET_TRACE
        set_icon(mwindow->theme->get_image("cwindow_icon"));

        active = new BC_Pixmap(this, mwindow->theme->get_image("cwindow_active"));
        inactive = new BC_Pixmap(this, mwindow->theme->get_image("cwindow_inactive"));

SET_TRACE
        mwindow->theme->get_cwindow_sizes(this, mwindow->session->cwindow_controls);
SET_TRACE
        mwindow->theme->draw_cwindow_bg(this);
SET_TRACE
        flash();
SET_TRACE

// Meters required by composite panel
        meters = new CWindowMeters(mwindow, 
                this,
                mwindow->theme->cmeter_x,
                mwindow->theme->cmeter_y,
                mwindow->theme->cmeter_h);
        meters->create_objects();
SET_TRACE


        composite_panel = new CPanel(mwindow, 
                this, 
                mwindow->theme->ccomposite_x,
                mwindow->theme->ccomposite_y,
                mwindow->theme->ccomposite_w,
                mwindow->theme->ccomposite_h);
        composite_panel->create_objects();

SET_TRACE
        canvas = new CWindowCanvas(mwindow, this);
        canvas->create_objects(mwindow->edl);
SET_TRACE


        add_subwindow(timebar = new CTimeBar(mwindow,
                this,
                mwindow->theme->ctimebar_x,
                mwindow->theme->ctimebar_y,
                mwindow->theme->ctimebar_w, 
                mwindow->theme->ctimebar_h));
        timebar->create_objects();

SET_TRACE
        add_subwindow(slider = new CWindowSlider(mwindow, 
                cwindow, 
                mwindow->theme->cslider_x,
                mwindow->theme->cslider_y, 
                mwindow->theme->cslider_w));

        transport = new CWindowTransport(mwindow, 
                this, 
                mwindow->theme->ctransport_x, 
                mwindow->theme->ctransport_y);
        transport->create_objects();
        transport->set_slider(slider);

SET_TRACE
        edit_panel = new CWindowEditing(mwindow, cwindow);
SET_TRACE
        edit_panel->set_meters(meters);
SET_TRACE
        edit_panel->create_objects();
SET_TRACE

//      add_subwindow(clock = new MainClock(mwindow, 
//              mwindow->theme->ctime_x, 
//              mwindow->theme->ctime_y));

        zoom_panel = new CWindowZoom(mwindow, 
                this, 
                mwindow->theme->czoom_x, 
                mwindow->theme->czoom_y);
        zoom_panel->create_objects();
        zoom_panel->zoom_text->add_item(new BC_MenuItem(AUTO_ZOOM));
        if(!mwindow->edl->session->cwindow_scrollbars) zoom_panel->set_text(AUTO_ZOOM);

//      destination = new CWindowDestination(mwindow, 
//              this, 
//              mwindow->theme->cdest_x,
//              mwindow->theme->cdest_y);
//      destination->create_objects();

// Must create after meter panel
        tool_panel = new CWindowTool(mwindow, this);
        tool_panel->Thread::start();
        
        set_operation(mwindow->edl->session->cwindow_operation);


        canvas->draw_refresh();

        draw_status();

SET_TRACE
        return 0;
}

int CWindowGUI::translation_event()
{
        mwindow->session->cwindow_x = get_x();
        mwindow->session->cwindow_y = get_y();
        return 0;
}

int CWindowGUI::resize_event(int w, int h)
{
        mwindow->session->cwindow_x = get_x();
        mwindow->session->cwindow_y = get_y();
        mwindow->session->cwindow_w = w;
        mwindow->session->cwindow_h = h;

        mwindow->theme->get_cwindow_sizes(this, mwindow->session->cwindow_controls);
        mwindow->theme->draw_cwindow_bg(this);
        flash();

        composite_panel->reposition_buttons(mwindow->theme->ccomposite_x,
                mwindow->theme->ccomposite_y);

        canvas->reposition_window(mwindow->edl,
                mwindow->theme->ccanvas_x,
                mwindow->theme->ccanvas_y,
                mwindow->theme->ccanvas_w,
                mwindow->theme->ccanvas_h);

        timebar->resize_event();

        slider->reposition_window(mwindow->theme->cslider_x,
                mwindow->theme->cslider_y, 
                mwindow->theme->cslider_w);
// Recalibrate pointer motion range
        slider->set_position();

        transport->reposition_buttons(mwindow->theme->ctransport_x, 
                mwindow->theme->ctransport_y);

        edit_panel->reposition_buttons(mwindow->theme->cedit_x, 
                mwindow->theme->cedit_y);

//      clock->reposition_window(mwindow->theme->ctime_x, 
//              mwindow->theme->ctime_y);

        zoom_panel->reposition_window(mwindow->theme->czoom_x, 
                mwindow->theme->czoom_y);

//      destination->reposition_window(mwindow->theme->cdest_x,
//              mwindow->theme->cdest_y);

        meters->reposition_window(mwindow->theme->cmeter_x,
                mwindow->theme->cmeter_y,
                mwindow->theme->cmeter_h);

        draw_status();

        BC_WindowBase::resize_event(w, h);
        return 1;
}


void CWindowGUI::draw_status()
{
        if(canvas->canvas && 
                canvas->canvas->get_video_on() ||
                canvas->is_processing)
                draw_pixmap(active, 
                        mwindow->theme->cstatus_x, 
                        mwindow->theme->cstatus_y);
        else
                draw_pixmap(inactive, 
                        mwindow->theme->cstatus_x, 
                        mwindow->theme->cstatus_y);
        flash(mwindow->theme->cstatus_x,
                mwindow->theme->cstatus_y,
                active->get_w(),
                active->get_h());
}



// TODO
// Don't refresh the canvas in a load file operation which is going to
// refresh it anyway.
void CWindowGUI::set_operation(int value)
{
        mwindow->edl->session->cwindow_operation = value;

        composite_panel->set_operation(value);
        edit_panel->update();

        tool_panel->start_tool(value);
        canvas->draw_refresh();
}

void CWindowGUI::update_tool()
{
        tool_panel->update_values();
}

int CWindowGUI::close_event()
{
        cwindow->hide_window();
        return 1;
}


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

        switch(get_keypress())
        {
                case 'w':
                case 'W':
                        close_event();
                        result = 1;
                        break;
                case '+':
                case '=':
                        keyboard_zoomin();
                        result = 1;
                        break;
                case '-':
                        keyboard_zoomout();
                        result = 1;
                        break;
        }

        if(!result) result = transport->keypress_event();

        return result;
}


void CWindowGUI::reset_affected()
{
        affected_x = 0;
        affected_y = 0;
        affected_z = 0;
}

void CWindowGUI::keyboard_zoomin()
{
//      if(mwindow->edl->session->cwindow_scrollbars)
//      {
                zoom_panel->zoom_tumbler->handle_up_event();
//      }
//      else
//      {
//      }
}

void CWindowGUI::keyboard_zoomout()
{
//      if(mwindow->edl->session->cwindow_scrollbars)
//      {
                zoom_panel->zoom_tumbler->handle_down_event();
//      }
//      else
//      {
//      }
}


void CWindowGUI::drag_motion()
{
        if(get_hidden()) return;

        if(mwindow->session->current_operation == DRAG_ASSET ||
                mwindow->session->current_operation == DRAG_VTRANSITION ||
                mwindow->session->current_operation == DRAG_VEFFECT)
        {
                int old_status = mwindow->session->ccanvas_highlighted;
                int cursor_x = get_relative_cursor_x();
                int cursor_y = get_relative_cursor_y();

                mwindow->session->ccanvas_highlighted = get_cursor_over_window() &&
                        cursor_x >= canvas->x &&
                        cursor_x < canvas->x + canvas->w &&
                        cursor_y >= canvas->y &&
                        cursor_y < canvas->y + canvas->h;


                if(old_status != mwindow->session->ccanvas_highlighted)
                        canvas->draw_refresh();
        }
}

int CWindowGUI::drag_stop()
{
        int result = 0;
        if(get_hidden()) return 0;

        if((mwindow->session->current_operation == DRAG_ASSET ||
                mwindow->session->current_operation == DRAG_VTRANSITION ||
                mwindow->session->current_operation == DRAG_VEFFECT) &&
                mwindow->session->ccanvas_highlighted)
        {
// Hide highlighting
                mwindow->session->ccanvas_highlighted = 0;
                canvas->draw_refresh();
                result = 1;
        }
        else
                return 0;

        if(mwindow->session->current_operation == DRAG_ASSET)
        {
                if(mwindow->session->drag_assets->total)
                {
                        mwindow->gui->lock_window("CWindowGUI::drag_stop 1");
                        mwindow->clear(0);
                        mwindow->load_assets(mwindow->session->drag_assets, 
                                mwindow->edl->local_session->get_selectionstart(), 
                                LOAD_PASTE,
                                mwindow->session->track_highlighted,
                                0,
                                mwindow->edl->session->labels_follow_edits, 
                                mwindow->edl->session->plugins_follow_edits);
                }

                if(mwindow->session->drag_clips->total)
                {
                        mwindow->gui->lock_window("CWindowGUI::drag_stop 2");
                        mwindow->clear(0);
                        mwindow->paste_edls(mwindow->session->drag_clips, 
                                LOAD_PASTE, 
                                mwindow->session->track_highlighted,
                                mwindow->edl->local_session->get_selectionstart(),
                                mwindow->edl->session->labels_follow_edits, 
                                mwindow->edl->session->plugins_follow_edits);
                }

                if(mwindow->session->drag_assets->total ||
                        mwindow->session->drag_clips->total)
                {
                        mwindow->save_backup();
                        mwindow->restart_brender();
                        mwindow->gui->update(1, 1, 1, 1, 0, 1, 0);
                        mwindow->undo->update_undo(_("insert assets"), LOAD_ALL);
                        mwindow->gui->unlock_window();
                        mwindow->sync_parameters(LOAD_ALL);
                }
        }

        if(mwindow->session->current_operation == DRAG_VEFFECT)
        {
//printf("CWindowGUI::drag_stop 1\n");
                Track *affected_track = cwindow->calculate_affected_track();
//printf("CWindowGUI::drag_stop 2\n");

                mwindow->gui->lock_window("CWindowGUI::drag_stop 3");
                mwindow->insert_effects_cwindow(affected_track);
                mwindow->session->current_operation = NO_OPERATION;
                mwindow->gui->unlock_window();
        }

        if(mwindow->session->current_operation == DRAG_VTRANSITION)
        {
                Track *affected_track = cwindow->calculate_affected_track();
                mwindow->gui->lock_window("CWindowGUI::drag_stop 4");
                mwindow->paste_transition_cwindow(affected_track);
                mwindow->session->current_operation = NO_OPERATION;
                mwindow->gui->unlock_window();
        }

        return result;
}


CWindowEditing::CWindowEditing(MWindow *mwindow, CWindow *cwindow)
 : EditPanel(mwindow, 
                cwindow->gui, 
                mwindow->theme->cedit_x, 
                mwindow->theme->cedit_y,
                mwindow->edl->session->editing_mode, 
                0,
                1,
                0, 
                0,
                1,
                1,
                1,
                1,
                1,
                0,
                1,
                1,
                1,
                0,
                1)
{
        this->mwindow = mwindow;
        this->cwindow = cwindow;
}

void CWindowEditing::set_inpoint()
{
        mwindow->set_inpoint(0);
}

void CWindowEditing::set_outpoint()
{
        mwindow->set_outpoint(0);
}





CWindowMeters::CWindowMeters(MWindow *mwindow, CWindowGUI *gui, int x, int y, int h)
 : MeterPanel(mwindow, 
                gui,
                x,
                y,
                h,
                mwindow->edl->session->audio_channels,
                mwindow->edl->session->cwindow_meter)
{
        this->mwindow = mwindow;
        this->gui = gui;
}

CWindowMeters::~CWindowMeters()
{
}

int CWindowMeters::change_status_event()
{
        mwindow->edl->session->cwindow_meter = use_meters;
        mwindow->theme->get_cwindow_sizes(gui, mwindow->session->cwindow_controls);
        gui->resize_event(gui->get_w(), gui->get_h());
        return 1;
}




CWindowZoom::CWindowZoom(MWindow *mwindow, CWindowGUI *gui, int x, int y)
 : ZoomPanel(mwindow, 
        gui, 
        (double)mwindow->edl->session->cwindow_zoom, 
        x, 
        y,
        80, 
        my_zoom_table, 
        total_zooms, 
        ZOOM_PERCENTAGE)
{
        this->mwindow = mwindow;
        this->gui = gui;
}

CWindowZoom::~CWindowZoom()
{
}

int CWindowZoom::handle_event()
{
        if(!strcasecmp(AUTO_ZOOM, get_text()))
        {
                mwindow->edl->session->cwindow_scrollbars = 0;
        }
        else
        {
                mwindow->edl->session->cwindow_scrollbars = 1;
        }

        float old_zoom = mwindow->edl->session->cwindow_zoom;
        float new_zoom = get_value();
        float x = gui->canvas->w / 2;
        float y = gui->canvas->h / 2;
        gui->canvas->canvas_to_output(mwindow->edl, 
                                0, 
                                x, 
                                y);
        x -= gui->canvas->w_visible / 2 * old_zoom / new_zoom;
        y -= gui->canvas->h_visible / 2 * old_zoom / new_zoom;
        gui->canvas->update_zoom((int)x, 
                (int)y, 
                new_zoom);
        gui->canvas->reposition_window(mwindow->edl, 
                mwindow->theme->ccanvas_x,
                mwindow->theme->ccanvas_y,
                mwindow->theme->ccanvas_w,
                mwindow->theme->ccanvas_h);
        gui->canvas->draw_refresh();
        return 1;
}



CWindowSlider::CWindowSlider(MWindow *mwindow, CWindow *cwindow, int x, int y, int pixels)
 : BC_PercentageSlider(x, 
                        y,
                        0,
                        pixels, 
                        pixels, 
                        0, 
                        1, 
                        0)
{
        this->mwindow = mwindow;
        this->cwindow = cwindow;
        set_precision(0.00001);
}

CWindowSlider::~CWindowSlider()
{
}

int CWindowSlider::handle_event()
{
        unlock_window();
        cwindow->playback_engine->interrupt_playback(1);
        lock_window("CWindowSlider::handle_event 1");
        
        mwindow->gui->lock_window("CWindowSlider::handle_event 2");
        mwindow->select_point((double)get_value());
        mwindow->gui->unlock_window();
        return 1;
}

void CWindowSlider::set_position()
{
        double new_length = mwindow->edl->tracks->total_playable_length();
        if(mwindow->edl->local_session->preview_end <= 0 ||
                mwindow->edl->local_session->preview_end > new_length)
                mwindow->edl->local_session->preview_end = new_length;
        if(mwindow->edl->local_session->preview_start > 
                mwindow->edl->local_session->preview_end)
                mwindow->edl->local_session->preview_start = 0;



        update(mwindow->theme->cslider_w, 
                mwindow->edl->local_session->get_selectionstart(1), 
                mwindow->edl->local_session->preview_start, 
                mwindow->edl->local_session->preview_end);
}


int CWindowSlider::increase_value()
{
        unlock_window();
        cwindow->gui->transport->handle_transport(SINGLE_FRAME_FWD);
        lock_window("CWindowSlider::increase_value");
        return 1;
}

int CWindowSlider::decrease_value()
{
        unlock_window();
        cwindow->gui->transport->handle_transport(SINGLE_FRAME_REWIND);
        lock_window("CWindowSlider::decrease_value");
        return 1;
}


// CWindowDestination::CWindowDestination(MWindow *mwindow, CWindowGUI *cwindow, int x, int y)
//  : BC_PopupTextBox(cwindow, 
//      &cwindow->destinations, 
//      cwindow->destinations.values[cwindow->cwindow->destination]->get_text(),
//      x, 
//      y, 
//      70, 
//      200)
// {
//      this->mwindow = mwindow;
//      this->cwindow = cwindow;
// }
// 
// CWindowDestination::~CWindowDestination()
// {
// }
// 
// int CWindowDestination::handle_event()
// {
//      return 1;
// }


CWindowTransport::CWindowTransport(MWindow *mwindow, 
        CWindowGUI *gui, 
        int x, 
        int y)
 : PlayTransport(mwindow, 
        gui, 
        x, 
        y)
{
        this->gui = gui;
}

EDL* CWindowTransport::get_edl()
{
        return mwindow->edl;
}

void CWindowTransport::goto_start()
{
        gui->unlock_window();
        handle_transport(REWIND, 1);

        mwindow->gui->lock_window("CWindowTransport::goto_start 1");
        mwindow->goto_start();
        mwindow->gui->unlock_window();

        gui->lock_window("CWindowTransport::goto_start 2");
}

void CWindowTransport::goto_end()
{
        gui->unlock_window();
        handle_transport(GOTO_END, 1);

        mwindow->gui->lock_window("CWindowTransport::goto_end 1");
        mwindow->goto_end();
        mwindow->gui->unlock_window();

        gui->lock_window("CWindowTransport::goto_end 2");
}



CWindowCanvas::CWindowCanvas(MWindow *mwindow, CWindowGUI *gui)
 : Canvas(gui,
                mwindow->theme->ccanvas_x,
                mwindow->theme->ccanvas_y,
                mwindow->theme->ccanvas_w,
                mwindow->theme->ccanvas_h,
                0,
                0,
                mwindow->edl->session->cwindow_scrollbars,
                1)
{
        this->mwindow = mwindow;
        this->gui = gui;
}

void CWindowCanvas::status_event()
{
        gui->draw_status();
}

void CWindowCanvas::update_zoom(int x, int y, float zoom)
{
        use_scrollbars = mwindow->edl->session->cwindow_scrollbars;

        mwindow->edl->session->cwindow_xscroll = x;
        mwindow->edl->session->cwindow_yscroll = y;
        mwindow->edl->session->cwindow_zoom = zoom;
}

int CWindowCanvas::get_xscroll()
{
        return mwindow->edl->session->cwindow_xscroll;
}

int CWindowCanvas::get_yscroll()
{
        return mwindow->edl->session->cwindow_yscroll;
}


float CWindowCanvas::get_zoom()
{
        return mwindow->edl->session->cwindow_zoom;
}

void CWindowCanvas::draw_refresh()
{
        if(!canvas->video_is_on())
        {
//printf("CWindowCanvas::draw_refresh 1 %f\n", mwindow->edl->session->cwindow_zoom);
                canvas->clear_box(0, 0, canvas->get_w(), canvas->get_h());
//printf("CWindowCanvas::draw_refresh 2\n");

                if(refresh_frame)
                {
                        int in_x, in_y, in_w, in_h, out_x, out_y, out_w, out_h;
//printf("CWindowCanvas::draw_refresh 3 %d\n", refresh_frame->get_color_model());
                        get_transfers(mwindow->edl, 
                                in_x, 
                                in_y, 
                                in_w, 
                                in_h, 
                                out_x, 
                                out_y, 
                                out_w, 
                                out_h);


// printf("CWindowCanvas::draw_refresh %d %d %d %d -> %d %d %d %d\n", 
// in_x, in_y, in_w, in_h, out_x, out_y, out_w, out_h);
//canvas->clear_box(0, 0, canvas->get_w(), canvas->get_h());


//printf("CWindowCanvas::draw_refresh 5\n");
                        if(out_w > 0 && out_h > 0 && in_w > 0 && in_h > 0)
                                canvas->draw_vframe(refresh_frame,
                                                out_x, 
                                                out_y, 
                                                out_w, 
                                                out_h,
                                                in_x, 
                                                in_y, 
                                                in_w, 
                                                in_h,
                                                0);
//printf("CWindowCanvas::draw_refresh 6\n");
                }
                else
                {
//printf("CWindowCanvas::draw_refresh 7\n");
                        canvas->clear_box(0, 0, canvas->get_w(), canvas->get_h());
//printf("CWindowCanvas::draw_refresh 8\n");
                }

//printf("CWindowCanvas::draw_refresh 9\n");
                draw_overlays();
                canvas->flash();
                canvas->flush();
//printf("CWindowCanvas::draw_refresh 10\n");
        }
}

#define CROPHANDLE_W 10
#define CROPHANDLE_H 10

void CWindowCanvas::draw_crophandle(int x, int y)
{
        canvas->draw_box(x, y, CROPHANDLE_W, CROPHANDLE_H);
}

#define CONTROL_W 10
#define CONTROL_H 10
#define FIRST_CONTROL_W 20
#define FIRST_CONTROL_H 20
#undef BC_INFINITY
#define BC_INFINITY 65536
#ifndef SQR
#define SQR(x) ((x) * (x))
#endif

int CWindowCanvas::do_mask(int &redraw, 
                int &rerender, 
                int button_press, 
                int cursor_motion,
                int draw)
{
// Retrieve points from top recordable track
//printf("CWindowCanvas::do_mask 1\n");
        Track *track = gui->cwindow->calculate_affected_track();
//printf("CWindowCanvas::do_mask 2\n");

        if(!track) return 0;
//printf("CWindowCanvas::do_mask 3\n");

        MaskAutos *mask_autos = (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
        int64_t position = track->to_units(
                mwindow->edl->local_session->get_selectionstart(1),
                0);
        ArrayList<MaskPoint*> points;
        mask_autos->get_points(&points, mwindow->edl->session->cwindow_mask,
                position, 
                PLAY_FORWARD);
//printf("CWindowCanvas::do_mask 4\n");

// Projector zooms relative to the center of the track output.
        float half_track_w = (float)track->track_w / 2;
        float half_track_h = (float)track->track_h / 2;
// Translate mask to projection
        float projector_x, projector_y, projector_z;
        track->automation->get_projector(&projector_x,
                &projector_y,
                &projector_z,
                position,
                PLAY_FORWARD);


// Get position of cursor relative to mask
        float mask_cursor_x = get_cursor_x();
        float mask_cursor_y = get_cursor_y();
        canvas_to_output(mwindow->edl, 0, mask_cursor_x, mask_cursor_y);

        projector_x += mwindow->edl->session->output_w / 2;
        projector_y += mwindow->edl->session->output_h / 2;

        mask_cursor_x -= projector_x;
        mask_cursor_y -= projector_y;
        mask_cursor_x = mask_cursor_x / projector_z + half_track_w;
        mask_cursor_y = mask_cursor_y / projector_z + half_track_h;

// Fix cursor origin
        if(button_press)
        {
                gui->x_origin = mask_cursor_x;
                gui->y_origin = mask_cursor_y;
        }

        int result = 0;
// Points of closest line
        int shortest_point1 = -1;
        int shortest_point2 = -1;
// Closest point
        int shortest_point = -1;
// Distance to closest line
        float shortest_line_distance = BC_INFINITY;
// Distance to closest point
        float shortest_point_distance = BC_INFINITY;
        int selected_point = -1;
        int selected_control_point = -1;
        float selected_control_point_distance = BC_INFINITY;
        ArrayList<int> x_points;
        ArrayList<int> y_points;

        if(!cursor_motion)
        {
                if(draw)
                {
                        canvas->set_color(WHITE);
                        canvas->set_inverse();
                }
//printf("CWindowCanvas::do_mask 1 %d\n", points.total);

// Never draw closed polygon and a closed
// polygon is harder to add points to.
                for(int i = 0; i < points.total && !result; i++)
                {
                        MaskPoint *point1 = points.values[i];
                        MaskPoint *point2 = (i >= points.total - 1) ? 
                                points.values[0] : 
                                points.values[i + 1];
                        float x0, x1, x2, x3;
                        float y0, y1, y2, y3;
                        float old_x, old_y, x, y;
                        int segments = (int)(sqrt(SQR(point1->x - point2->x) + SQR(point1->y - point2->y)));

//printf("CWindowCanvas::do_mask 1 %f, %f -> %f, %f projectorz=%f\n",
//point1->x, point1->y, point2->x, point2->y, projector_z);
                        for(int j = 0; j <= segments && !result; j++)
                        {
//printf("CWindowCanvas::do_mask 1 %f, %f -> %f, %f\n", x0, y0, x3, y3);
                                x0 = point1->x;
                                y0 = point1->y;
                                x1 = point1->x + point1->control_x2;
                                y1 = point1->y + point1->control_y2;
                                x2 = point2->x + point2->control_x1;
                                y2 = point2->y + point2->control_y1;
                                x3 = point2->x;
                                y3 = point2->y;

                                float t = (float)j / segments;
                                float tpow2 = t * t;
                                float tpow3 = t * t * t;
                                float invt = 1 - t;
                                float invtpow2 = invt * invt;
                                float invtpow3 = invt * invt * invt;

                                x = (        invtpow3 * x0
                                        + 3 * t     * invtpow2 * x1
                                        + 3 * tpow2 * invt     * x2 
                                        +     tpow3            * x3);
                                y = (        invtpow3 * y0 
                                        + 3 * t     * invtpow2 * y1
                                        + 3 * tpow2 * invt     * y2 
                                        +     tpow3            * y3);

                                x = (x - half_track_w) * projector_z + projector_x;
                                y = (y - half_track_h) * projector_z + projector_y;


// Test new point addition
                                if(button_press)
                                {
                                        float line_distance = 
                                                sqrt(SQR(x - mask_cursor_x) + SQR(y - mask_cursor_y));

//printf("CWindowCanvas::do_mask 1 x=%f mask_cursor_x=%f y=%f mask_cursor_y=%f %f %f %d, %d\n", 
//x, mask_cursor_x, y, mask_cursor_y, line_distance, shortest_line_distance, shortest_point1, shortest_point2);
                                        if(line_distance < shortest_line_distance || 
                                                shortest_point1 < 0)
                                        {
                                                shortest_line_distance = line_distance;
                                                shortest_point1 = i;
                                                shortest_point2 = (i >= points.total - 1) ? 0 : (i + 1);
//printf("CWindowCanvas::do_mask 2 %f %f %d, %d\n", line_distance, shortest_line_distance, shortest_point1, shortest_point2);
                                        }


                                        float point_distance1 = 
                                                sqrt(SQR(point1->x - mask_cursor_x) + SQR(point1->y - mask_cursor_y));
                                        float point_distance2 = 
                                                sqrt(SQR(point2->x - mask_cursor_x) + SQR(point2->y - mask_cursor_y));

                                        if(point_distance1 < shortest_point_distance || 
                                                shortest_point < 0)
                                        {
                                                shortest_point_distance = point_distance1;
                                                shortest_point = i;
                                        }

                                        if(point_distance2 < shortest_point_distance || 
                                                shortest_point < 0)
                                        {
                                                shortest_point_distance = point_distance2;
                                                shortest_point = (i >= points.total - 1) ? 0 : (i + 1);
                                        }
                                }

                                output_to_canvas(mwindow->edl, 0, x, y);


#define TEST_BOX(cursor_x, cursor_y, target_x, target_y) \
        (cursor_x >= target_x - CONTROL_W / 2 && \
        cursor_x < target_x + CONTROL_W / 2 && \
        cursor_y >= target_y - CONTROL_H / 2 && \
        cursor_y < target_y + CONTROL_H / 2)

// Test existing point selection
                                if(button_press)
                                {
                                        float canvas_x = (x0 - half_track_w) * projector_z + projector_x;
                                        float canvas_y = (y0 - half_track_h) * projector_z + projector_y;
                                        int cursor_x = get_cursor_x();
                                        int cursor_y = get_cursor_y();

// Test first point
                                        if(gui->shift_down())
                                        {
                                                float control_x = (x1 - half_track_w) * projector_z + projector_x;
                                                float control_y = (y1 - half_track_h) * projector_z + projector_y;
                                                output_to_canvas(mwindow->edl, 0, control_x, control_y);

                                                float distance = 
                                                        sqrt(SQR(control_x - cursor_x) + SQR(control_y - cursor_y));

                                                if(distance < selected_control_point_distance)
                                                {
                                                        selected_point = i;
                                                        selected_control_point = 1;
                                                        selected_control_point_distance = distance;
                                                }
                                        }
                                        else
                                        {
                                                output_to_canvas(mwindow->edl, 0, canvas_x, canvas_y);
                                                if(!gui->ctrl_down())
                                                {
                                                        if(TEST_BOX(cursor_x, cursor_y, canvas_x, canvas_y))
                                                        {
                                                                selected_point = i;
                                                        }
                                                }
                                                else
                                                {
                                                        selected_point = shortest_point;
                                                }
                                        }

// Test second point
                                        canvas_x = (x3 - half_track_w) * projector_z + projector_x;
                                        canvas_y = (y3 - half_track_h) * projector_z + projector_y;
                                        if(gui->shift_down())
                                        {
                                                float control_x = (x2 - half_track_w) * projector_z + projector_x;
                                                float control_y = (y2 - half_track_h) * projector_z + projector_y;
                                                output_to_canvas(mwindow->edl, 0, control_x, control_y);

                                                float distance = 
                                                        sqrt(SQR(control_x - cursor_x) + SQR(control_y - cursor_y));

//printf("CWindowCanvas::do_mask %d %f %f\n", i, distance, selected_control_point_distance);
                                                if(distance < selected_control_point_distance)
                                                {
                                                        selected_point = (i < points.total - 1 ? i + 1 : 0);
                                                        selected_control_point = 0;
                                                        selected_control_point_distance = distance;
                                                }
                                        }
                                        else
                                        if(i < points.total - 1)
                                        {
                                                output_to_canvas(mwindow->edl, 0, canvas_x, canvas_y);
                                                if(!gui->ctrl_down())
                                                {
                                                        if(TEST_BOX(cursor_x, cursor_y, canvas_x, canvas_y))
                                                        {
                                                                selected_point = (i < points.total - 1 ? i + 1 : 0);
                                                        }
                                                }
                                                else
                                                {
                                                        selected_point = shortest_point;
                                                }
                                        }
                                }



                                if(j > 0)
                                {
// Draw joining line
                                        if(draw)
                                        {
                                                x_points.append((int)x);
                                                y_points.append((int)y);
                                        }

                                        if(j == segments)
                                        {




                                                if(draw)
                                                {
// Draw second anchor
                                                        if(i < points.total - 1)
                                                        {
                                                                if(i == gui->affected_point - 1)
                                                                        canvas->draw_disc((int)x - CONTROL_W / 2, 
                                                                                (int)y - CONTROL_W / 2, 
                                                                                CONTROL_W, 
                                                                                CONTROL_W);
                                                                else
                                                                        canvas->draw_circle((int)x - CONTROL_W / 2, 
                                                                                (int)y - CONTROL_W / 2,