mwindow.C

Go to the documentation of this file.

#include "asset.h"
#include "assets.h"
#include "awindowgui.h"
#include "awindow.h"
#include "batchrender.h"
#include "bcdisplayinfo.h"
#include "brender.h"
#include "cache.h"
#include "channel.h"
#include "channeldb.h"
#include "clip.h"
#include "colormodels.h"
#include "cplayback.h"
#include "ctimebar.h"
#include "cwindowgui.h"
#include "cwindow.h"
#include "defaults.h"
#include "editpanel.h"
#include "edl.h"
#include "edlsession.h"
#include "errorbox.h"
#include "fileformat.h"
#include "file.h"
#include "filesystem.h"
#include "filexml.h"
#include "gwindow.h"
#include "gwindowgui.h"
#include "indexfile.h"
#include "interlacemodes.h"
#include "language.h"
#include "levelwindowgui.h"
#include "levelwindow.h"
#include "loadfile.inc"
#include "localsession.h"
#include "maincursor.h"
#include "mainindexes.h"
#include "mainmenu.h"
#include "mainprogress.h"
#include "mainsession.h"
#include "mainundo.h"
#include "mbuttons.h"
#include "mutex.h"
#include "mwindowgui.h"
#include "mwindow.h"
#include "new.h"
#include "patchbay.h"
#include "playbackengine.h"
#include "plugin.h"
#include "pluginserver.h"
#include "pluginset.h"
#include "preferences.h"
#include "record.h"
#include "recordlabel.h"
#include "render.h"
#include "samplescroll.h"
#include "sighandler.h"
#include "splashgui.h"
#include "statusbar.h"
#include "theme.h"
#include "threadloader.h"
#include "timebar.h"
#include "tipwindow.h"
#include "trackcanvas.h"
#include "track.h"
#include "tracking.h"
#include "trackscroll.h"
#include "tracks.h"
#include "transition.h"
#include "transportque.h"
#include "vframe.h"
#include "videodevice.inc"
#include "videowindow.h"
#include "vplayback.h"
#include "vwindowgui.h"
#include "vwindow.h"
#include "zoombar.h"

#include <string.h>



extern "C"
{




// Hack for libdv to remove glib dependancy

// void
// g_log (const char    *log_domain,
//        int  log_level,
//        const char    *format,
//        ...)
// {
// }
// 
// void
// g_logv (const char    *log_domain,
//        int  log_level,
//        const char    *format,
//        ...)
// {
// }
// 


// Hack for XFree86 4.1.0

int atexit(void (*function)(void))
{
        return 0;
}



}





MWindow::MWindow()
{
        plugin_gui_lock = new Mutex("MWindow::plugin_gui_lock");
        brender_lock = new Mutex("MWindow::brender_lock");
        brender = 0;
        session = 0;
        channeldb_buz = new ChannelDB;
        channeldb_v4l2jpeg = new ChannelDB;
}

MWindow::~MWindow()
{
        brender_lock->lock("MWindow::~MWindow");
        if(brender) delete brender;
        brender = 0;
        brender_lock->unlock();
        delete brender_lock;

        delete mainindexes;

TRACE("MWindow::~MWindow 1\n");
        clean_indexes();
TRACE("MWindow::~MWindow 2\n");

        save_defaults();
TRACE("MWindow::~MWindow 3\n");
// Give up and go to a movie
        exit(0);

TRACE("MWindow::~MWindow 4\n");
        delete mainprogress;
        delete audio_cache;             // delete the cache after the assets
        delete video_cache;             // delete the cache after the assets
        if(gui) delete gui;
        delete undo;
        delete preferences;
        delete defaults;
        delete render;
//      delete renderlist;
        delete awindow;
        delete vwindow;
        delete cwindow;
        delete lwindow;
        plugin_guis->remove_all_objects();
        delete plugin_guis;
        delete plugin_gui_lock;
}

void MWindow::init_defaults(Defaults* &defaults, char *config_path)
{
        char path[BCTEXTLEN];
// Use user supplied path
        if(config_path[0])
        {
                strcpy(path, config_path);
        }
        else
        {
// set the .bcast path
                FileSystem fs;

                sprintf(path, "%s", BCASTDIR);
                fs.complete_path(path);
                if(fs.is_dir(path)) 
                {
                        fs.create_dir(path); 
                }

// load the defaults
                strcat(path, "Cinelerra_rc");
        }

        defaults = new Defaults(path);
        defaults->load();
}

void MWindow::init_plugin_path(Preferences *preferences, 
        ArrayList<PluginServer*>* &plugindb,
        FileSystem *fs,
        SplashGUI *splash_window,
        int *counter)
{
        int result = 0;
        PluginServer *newplugin;

        if(!result)
        {
                for(int i = 0; i < fs->dir_list.total; i++)
                {
                        char path[BCTEXTLEN];
                        strcpy(path, fs->dir_list.values[i]->path);

// File is a directory
                        if(!fs->is_dir(path))
                        {
                                continue;
                        }
                        else
                        {
// Try to query the plugin
                                fs->complete_path(path);
//printf("MWindow::init_plugin_path %s\n", path);
                                PluginServer *new_plugin = new PluginServer(path);
                                int result = new_plugin->open_plugin(1, preferences, 0, 0, -1);

                                if(!result)
                                {
                                        plugindb->append(new_plugin);
                                        new_plugin->close_plugin();
                                        if(splash_window)
                                                splash_window->operation->update(_(new_plugin->title));
                                }
                                else
                                if(result == PLUGINSERVER_IS_LAD)
                                {
                                        delete new_plugin;
// Open LAD subplugins
                                        int id = 0;
                                        do
                                        {
                                                new_plugin = new PluginServer(path);
                                                result = new_plugin->open_plugin(1,
                                                        preferences,
                                                        0,
                                                        0,
                                                        id);
                                                id++;
                                                if(!result)
                                                {
                                                        plugindb->append(new_plugin);
                                                        new_plugin->close_plugin();
                                                        if(splash_window)
                                                                splash_window->operation->update(_(new_plugin->title));
                                                }
                                        }while(!result);
                                }
                                else
                                {
// Plugin failed to open
                                        delete new_plugin;
                                }
                        }
                        if(splash_window) splash_window->progress->update((*counter)++);
                }
        }
}

void MWindow::init_plugins(Preferences *preferences, 
        ArrayList<PluginServer*>* &plugindb,
        SplashGUI *splash_window)
{
        plugindb = new ArrayList<PluginServer*>;



        FileSystem cinelerra_fs;
        ArrayList<FileSystem*> lad_fs;
        int result = 0;

// Get directories
        cinelerra_fs.set_filter("[*.plugin][*.so]");
        result = cinelerra_fs.update(preferences->global_plugin_dir);

        if(result)
        {
                fprintf(stderr, 
                        _("MWindow::init_plugins: couldn't open %s directory\n"),
                        preferences->global_plugin_dir);
        }

// Parse LAD environment variable
        char *env = getenv("LADSPA_PATH");
        if(env)
        {
                char string[BCTEXTLEN];
                char *ptr1 = env;
                while(ptr1)
                {
                        char *ptr = strchr(ptr1, ':');
                        char *end;
                        if(ptr)
                        {
                                end = ptr;
                        }
                        else
                        {
                                end = env + strlen(env);
                        }

                        if(end > ptr1)
                        {
                                int len = end - ptr1;
                                memcpy(string, ptr1, len);
                                string[len] = 0;


                                FileSystem *fs = new FileSystem;
                                lad_fs.append(fs);
                                fs->set_filter("*.so");
                                result = fs->update(string);

                                if(result)
                                {
                                        fprintf(stderr, 
                                                _("MWindow::init_plugins: couldn't open %s directory\n"),
                                                string);
                                }
                        }

                        if(ptr)
                                ptr1 = ptr + 1;
                        else
                                ptr1 = ptr;
                };
        }

        int total = cinelerra_fs.total_files();
        int counter = 0;
        for(int i = 0; i < lad_fs.total; i++)
                total += lad_fs.values[i]->total_files();
        if(splash_window) splash_window->progress->update_length(total);

// Cinelerra
#ifndef DO_STATIC
        init_plugin_path(preferences,
                plugindb,
                &cinelerra_fs,
                splash_window,
                &counter);
#else
// Call automatically generated routine to get plugins
#endif

// LAD
        for(int i = 0; i < lad_fs.total; i++)
                init_plugin_path(preferences,
                        plugindb,
                        lad_fs.values[i],
                        splash_window,
                        &counter);

        lad_fs.remove_all_objects();
}

void MWindow::delete_plugins()
{
        for(int i = 0; i < plugindb->total; i++)
        {
                delete plugindb->values[i];
        }
        delete plugindb;
}

void MWindow::create_plugindb(int do_audio, 
                int do_video, 
                int is_realtime, 
                int is_transition,
                int is_theme,
                ArrayList<PluginServer*> &plugindb)
{
// Get plugins
        for(int i = 0; i < this->plugindb->total; i++)
        {
                PluginServer *current = this->plugindb->values[i];

                if(current->audio == do_audio &&
                        current->video == do_video &&
                        (current->realtime == is_realtime || is_realtime < 0) &&
                        current->transition == is_transition &&
                        current->theme == is_theme)
                        plugindb.append(current);
        }

// Alphabetize list by title
        int done = 0;
        while(!done)
        {
                done = 1;
                
                for(int i = 0; i < plugindb.total - 1; i++)
                {
                        PluginServer *value1 = plugindb.values[i];
                        PluginServer *value2 = plugindb.values[i + 1];
                        if(strcmp(_(value1->title), _(value2->title)) > 0)
                        {
                                done = 0;
                                plugindb.values[i] = value2;
                                plugindb.values[i + 1] = value1;
                        }
                }
        }
}

PluginServer* MWindow::scan_plugindb(char *title,
                int data_type)
{
        if(data_type < 0)
        {
                printf("MWindow::scan_plugindb data_type < 0\n");
                return 0;
        }

        for(int i = 0; i < plugindb->total; i++)
        {
                PluginServer *server = plugindb->values[i];
                if(!strcasecmp(server->title, title) &&
                ((data_type == TRACK_AUDIO && server->audio) ||
                (data_type == TRACK_VIDEO && server->video))) 
                        return plugindb->values[i];
        }
        return 0;
}

void MWindow::init_preferences()
{
        preferences = new Preferences;
        preferences->load_defaults(defaults);
        session = new MainSession(this);
        session->load_defaults(defaults);
}

void MWindow::clean_indexes()
{
        FileSystem fs;
        int total_excess;
        long oldest;
        int oldest_item = -1;
        int result;
        char string[BCTEXTLEN];
        char string2[BCTEXTLEN];

// Delete extra indexes
        fs.set_filter("*.idx");
        fs.complete_path(preferences->index_directory);
        fs.update(preferences->index_directory);
//printf("MWindow::clean_indexes 1 %d\n", fs.dir_list.total);

// Eliminate directories
        result = 1;
        while(result)
        {
                result = 0;
                for(int i = 0; i < fs.dir_list.total && !result; i++)
                {
                        fs.join_names(string, preferences->index_directory, fs.dir_list.values[i]->name);
                        if(!fs.is_dir(string))
                        {
                                delete fs.dir_list.values[i];
                                fs.dir_list.remove_number(i);
                                result = 1;
                        }
                }
        }
        total_excess = fs.dir_list.total - preferences->index_count;

//printf("MWindow::clean_indexes 2 %d\n", fs.dir_list.total);
        while(total_excess > 0)
        {
// Get oldest
                for(int i = 0; i < fs.dir_list.total; i++)
                {
                        fs.join_names(string, preferences->index_directory, fs.dir_list.values[i]->name);

                        if(i == 0 || fs.get_date(string) <= oldest)
                        {
                                oldest = fs.get_date(string);
                                oldest_item = i;
                        }
                }

                if(oldest_item >= 0)
                {
// Remove index file
                        fs.join_names(string, 
                                preferences->index_directory, 
                                fs.dir_list.values[oldest_item]->name);
//printf("MWindow::clean_indexes 1 %s\n", string);
                        if(remove(string))
                                perror("delete_indexes");
                        delete fs.dir_list.values[oldest_item];
                        fs.dir_list.remove_number(oldest_item);

// Remove table of contents if it exists
                        strcpy(string2, string);
                        char *ptr = strrchr(string2, '.');
                        if(ptr)
                        {
//printf("MWindow::clean_indexes 2 %s\n", string2);
                                sprintf(ptr, ".toc");
                                remove(string2);
                        }
                }

                total_excess--;
        }
}

void MWindow::init_awindow()
{
        awindow = new AWindow(this);
        awindow->create_objects();
}

void MWindow::init_gwindow()
{
        gwindow = new GWindow(this);
        gwindow->create_objects();
}

void MWindow::init_tipwindow()
{
        twindow = new TipWindow(this);
        twindow->start();
}

void MWindow::init_theme()
{
        theme = 0;

// Replace blond theme with SUV since it doesn't work
        if(!strcasecmp(preferences->theme, "Blond"))
                strcpy(preferences->theme, DEFAULT_THEME);

        for(int i = 0; i < plugindb->total; i++)
        {
                if(plugindb->values[i]->theme &&
                        !strcasecmp(preferences->theme, plugindb->values[i]->title))
                {
                        PluginServer plugin = *plugindb->values[i];
                        plugin.open_plugin(0, preferences, 0, 0, -1);
                        theme = plugin.new_theme();
                        theme->mwindow = this;
                        strcpy(theme->path, plugin.path);
                        plugin.close_plugin();
                }
        }

        if(!theme)
        {
                fprintf(stderr, _("MWindow::init_theme: theme %s not found.\n"), preferences->theme);
                exit(1);
        }

// Load images which may have been forgotten
        theme->Theme::initialize();
// Load user images
        theme->initialize();
// Create menus with user colors
        theme->build_menus();
        init_menus();

        theme->check_used();
}

void MWindow::init_edl()
{
        edl = new EDL;
        edl->create_objects();
    edl->load_defaults(defaults);
        edl->create_default_tracks();
        edl->tracks->update_y_pixels(theme);
}

void MWindow::init_compositor()
{
        cwindow = new CWindow(this);
    cwindow->create_objects();
}

void MWindow::init_levelwindow()
{
        lwindow = new LevelWindow(this);
        lwindow->create_objects();
}

void MWindow::init_viewer()
{
        vwindow = new VWindow(this);
        vwindow->load_defaults();
        vwindow->create_objects();
}

void MWindow::init_cache()
{
        audio_cache = new CICache(edl, preferences, plugindb);
        video_cache = new CICache(edl, preferences, plugindb);
}

void MWindow::init_channeldb()
{
        channeldb_buz->load("channeldb_buz");
        channeldb_v4l2jpeg->load("channeldb_v4l2jpeg");
}

void MWindow::init_menus()
{
        char string[BCTEXTLEN];

        // Color Models
        cmodel_to_text(string, BC_RGB888);
        colormodels.append(new ColormodelItem(string, BC_RGB888));
        cmodel_to_text(string, BC_RGBA8888);
        colormodels.append(new ColormodelItem(string, BC_RGBA8888));
//      cmodel_to_text(string, BC_RGB161616);
//      colormodels.append(new ColormodelItem(string, BC_RGB161616));
//      cmodel_to_text(string, BC_RGBA16161616);
//      colormodels.append(new ColormodelItem(string, BC_RGBA16161616));
        cmodel_to_text(string, BC_RGB_FLOAT);
        colormodels.append(new ColormodelItem(string, BC_RGB_FLOAT));
        cmodel_to_text(string, BC_RGBA_FLOAT);
        colormodels.append(new ColormodelItem(string, BC_RGBA_FLOAT));
        cmodel_to_text(string, BC_YUV888);
        colormodels.append(new ColormodelItem(string, BC_YUV888));
        cmodel_to_text(string, BC_YUVA8888);
        colormodels.append(new ColormodelItem(string, BC_YUVA8888));
//      cmodel_to_text(string, BC_YUV161616);
//      colormodels.append(new ColormodelItem(string, BC_YUV161616));
//      cmodel_to_text(string, BC_YUVA16161616);
//      colormodels.append(new ColormodelItem(string, BC_YUVA16161616));

#define ILACEPROJECTMODELISTADD(x) ilacemode_to_text(string, x); \
                           interlace_project_modes.append(new InterlacemodeItem(string, x));

#define ILACEASSETMODELISTADD(x) ilacemode_to_text(string, x); \
                           interlace_asset_modes.append(new InterlacemodeItem(string, x));

#define ILACEFIXMETHODLISTADD(x) ilacefixmethod_to_text(string, x); \
                           interlace_asset_fixmethods.append(new InterlacefixmethodItem(string, x));

        // Interlacing Modes
        ILACEASSETMODELISTADD(BC_ILACE_MODE_UNDETECTED); // Not included in the list for the project options.

        ILACEASSETMODELISTADD(BC_ILACE_MODE_TOP_FIRST);
        ILACEPROJECTMODELISTADD(BC_ILACE_MODE_TOP_FIRST);

        ILACEASSETMODELISTADD(BC_ILACE_MODE_BOTTOM_FIRST);
        ILACEPROJECTMODELISTADD(BC_ILACE_MODE_BOTTOM_FIRST);

        ILACEASSETMODELISTADD(BC_ILACE_MODE_NOTINTERLACED);
        ILACEPROJECTMODELISTADD(BC_ILACE_MODE_NOTINTERLACED);

        // Interlacing Fixing Methods
        ILACEFIXMETHODLISTADD(BC_ILACE_FIXMETHOD_NONE);
        ILACEFIXMETHODLISTADD(BC_ILACE_FIXMETHOD_UPONE);
        ILACEFIXMETHODLISTADD(BC_ILACE_FIXMETHOD_DOWNONE);
}

void MWindow::init_indexes()
{
        mainindexes = new MainIndexes(this);
        mainindexes->start_loop();
}

void MWindow::init_gui()
{
        gui = new MWindowGUI(this);
        gui->create_objects();
        gui->load_defaults(defaults);
}

void MWindow::init_signals()
{
        sighandler = new SigHandler;
        sighandler->initialize();
ENABLE_BUFFER
}

void MWindow::init_render()
{
        render = new Render(this);
//      renderlist = new Render(this);
        batch_render = new BatchRenderThread(this);
}

void MWindow::init_brender()
{
        if(preferences->use_brender && !brender)
        {
                brender_lock->lock("MWindow::init_brender 1");
                brender = new BRender(this);
                brender->initialize();
                session->brender_end = 0;
                brender_lock->unlock();
        }
        else
        if(!preferences->use_brender && brender)
        {
                brender_lock->lock("MWindow::init_brender 2");
                delete brender;
                brender = 0;
                session->brender_end = 0;
                brender_lock->unlock();
        }
        if(brender) brender->restart(edl);
}

void MWindow::restart_brender()
{
//printf("MWindow::restart_brender 1\n");
        if(brender) brender->restart(edl);
}

void MWindow::stop_brender()
{
        if(brender) brender->stop();
}

int MWindow::brender_available(int position)
{
        int result = 0;
        brender_lock->lock("MWindow::brender_available 1");
        if(brender)
        {
                if(brender->map_valid)
                {
                        brender->map_lock->lock("MWindow::brender_available 2");
                        if(position < brender->map_size &&
                                position >= 0)
                        {
//printf("MWindow::brender_available 1 %d %d\n", position, brender->map[position]);
                                if(brender->map[position] == BRender::RENDERED)
                                        result = 1;
                        }
                        brender->map_lock->unlock();
                }
        }
        brender_lock->unlock();
        return result;
}

void MWindow::set_brender_start()
{
        edl->session->brender_start = edl->local_session->get_selectionstart();
        restart_brender();
        gui->canvas->draw_overlays();
        gui->canvas->flash();
}



int MWindow::load_filenames(ArrayList<char*> *filenames, 
        int load_mode,
        int update_filename,
        char *reel_name,
        int reel_number,
        int overwrite_reel)
{
TRACE("MWindow::load_filenames 1");
        ArrayList<EDL*> new_edls;
        ArrayList<Asset*> new_assets;
        ArrayList<File*> new_files;

        save_defaults();
        gui->start_hourglass();

// Need to stop playback since tracking depends on the EDL not getting
// deleted.
        cwindow->playback_engine->que->send_command(STOP,
                CHANGE_NONE, 
                0,
                0);
        vwindow->playback_engine->que->send_command(STOP,
                CHANGE_NONE, 
                0,
                0);
        cwindow->playback_engine->interrupt_playback(0);
        vwindow->playback_engine->interrupt_playback(0);


TRACE("MWindow::load_filenames 80");

// Define new_edls and new_assets to load
        int result = 0;
        for(int i = 0; i < filenames->total; i++)
        {
// Get type of file
                File *new_file = new File;
                Asset *new_asset = new Asset(filenames->values[i]);
                EDL *new_edl = new EDL;
                char string[BCTEXTLEN];

// Set reel name and number for the asset
// If the user wants to overwrite the last used reel number for the clip,
// we have to rebuild the index for the file

                if(overwrite_reel)
                {
                        char source_filename[BCTEXTLEN];
                        char index_filename[BCTEXTLEN];
                        
                        strcpy(new_asset->reel_name, reel_name);
                        new_asset->reel_number = reel_number;

                        IndexFile::get_index_filename(source_filename,
                                preferences->index_directory,
                                index_filename,
                                new_asset->path);
                        remove(index_filename);
                        new_asset->index_status = INDEX_NOTTESTED;
                }
                
                new_edl->create_objects();
                new_edl->copy_session(edl);

                sprintf(string, "Loading %s", new_asset->path);
                gui->show_message(string);
TRACE("MWindow::load_filenames 81");
                result = new_file->open_file(preferences, new_asset, 1, 0, 0, 0);
TRACE("MWindow::load_filenames 82");

                switch(result)
                {
// Convert media file to EDL
                        case FILE_OK:
                                if(load_mode != LOAD_RESOURCESONLY)
                                {
TRACE("MWindow::load_filenames 83");
                                        asset_to_edl(new_edl, new_asset);
TRACE("MWindow::load_filenames 84");
                                        new_edls.append(new_edl);
TRACE("MWindow::load_filenames 85");
                                        delete new_asset;
                                        new_asset = 0;
TRACE("MWindow::load_filenames 86");
                                }
                                else
                                {
                                        new_assets.append(new_asset);
                                }

// Set filename to nothing for assets since save EDL would overwrite them.
                                if(load_mode == LOAD_REPLACE || 
                                        load_mode == LOAD_REPLACE_CONCATENATE)
                                {
                                        set_filename("");
// Reset timeline position
                                        new_edl->local_session->view_start = 0;
                                        new_edl->local_session->track_start = 0;
                                }

                                result = 0;
                                break;

// File not found
                        case FILE_NOT_FOUND:
                                sprintf(string, _("Failed to open %s"), new_asset->path);
                                gui->show_message(string, theme->message_error);
                                result = 1;
                                break;

// Unknown format
                        case FILE_UNRECOGNIZED_CODEC:
                        {
// Test index file
                                IndexFile indexfile(this);
                                result = indexfile.open_index(this, new_asset);
                                if(!result)
                                {
                                        indexfile.close_index();
                                }

// Test existing EDLs
                                if(result)
                                {
                                        for(int j = 0; j < new_edls.total + 1; j++)
                                        {
                                                Asset *old_asset;
                                                if(j == new_edls.total)
                                                {
                                                        if(old_asset = edl->assets->get_asset(new_asset->path))
                                                        {
                                                                *new_asset = *old_asset;
                                                                result = 0;
                                                        }
                                                }
                                                else
                                                {
                                                        if(old_asset = new_edls.values[j]->assets->get_asset(new_asset->path))
                                                        {
                                                                *new_asset = *old_asset;
                                                                result = 0;
                                                        }
                                                }
                                        }
                                }

// Prompt user
                                if(result)
                                {
                                        char string[BCTEXTLEN];
                                        FileSystem fs;
                                        fs.extract_name(string, new_asset->path);

                                        strcat(string, _("'s format couldn't be determined."));
                                        new_asset->audio_data = 1;
                                        new_asset->format = FILE_PCM;
                                        new_asset->channels = defaults->get("AUDIO_CHANNELS", 2);
                                        new_asset->sample_rate = defaults->get("SAMPLE_RATE", 44100);
                                        new_asset->bits = defaults->get("AUDIO_BITS", 16);
                                        new_asset->byte_order = defaults->get("BYTE_ORDER", 1);
                                        new_asset->signed_ = defaults->get("SIGNED_", 1);
                                        new_asset->header = defaults->get("HEADER", 0);

                                        FileFormat fwindow(this);
                                        fwindow.create_objects(new_asset, string);
                                        result = fwindow.run_window();

                                        defaults->update("AUDIO_CHANNELS", new_asset->channels);
                                        defaults->update("SAMPLE_RATE", new_asset->sample_rate);
                                        defaults->update("AUDIO_BITS", new_asset->bits);
                                        defaults->update("BYTE_ORDER", new_asset->byte_order);
                                        defaults->update("SIGNED_", new_asset->signed_);
                                        defaults->update("HEADER", new_asset->header);
                                        save_defaults();
                                }

// Append to list
                                if(!result)
                                {
// Recalculate length
                                        delete new_file;
                                        new_file = new File;
                                        result = new_file->open_file(preferences, new_asset, 1, 0, 0, 0);

                                        if(load_mode != LOAD_RESOURCESONLY)
                                        {
                                                asset_to_edl(new_edl, new_asset);
                                                new_edls.append(new_edl);
                                                delete new_asset;
                                                new_asset = 0;
                                        }
                                        else
                                        {
                                                new_assets.append(new_asset);
                                        }
                                }
                                else
                                {
                                        result = 1;
                                }
                                break;
                        }

                        case FILE_IS_XML:
                        {
                                FileXML xml_file;
                                xml_file.read_from_file(filenames->values[i]);
// Load EDL for pasting
                                new_edl->load_xml(plugindb, &xml_file, LOAD_ALL);
                                test_plugins(new_edl, filenames->values[i]);

// We don't want a valid reel name/number for projects
                                strcpy(new_asset->reel_name, "");
                                reel_number = -1;

                                if(load_mode == LOAD_REPLACE || 
                                        load_mode == LOAD_REPLACE_CONCATENATE)
                                {
                                        strcpy(session->filename, filenames->values[i]);
                                        strcpy(new_edl->local_session->clip_title, filenames->values[i]);
                                        if(update_filename)
                                                set_filename(new_edl->local_session->clip_title);
                                }

                                new_edls.append(new_edl);
                                result = 0;
                                break;
                        }
                }

TRACE("MWindow::load_filenames 87");
                if(result)
                {
                        delete new_edl;
                        delete new_asset;
                        new_edl = 0;
                        new_asset = 0;
                }
TRACE("MWindow::load_filenames 88");

// Store for testing index
                new_files.append(new_file);
TRACE("MWindow::load_filenames 89");
        }



        if(!result) gui->statusbar->default_message();



TRACE("MWindow::load_filenames 90");





// Paste them.
// Don't back up here.
        if(new_edls.total)
        {
SET_TRACE
// For pasting, clear the active region
                if(load_mode == LOAD_PASTE)
                {
SET_TRACE
                        double start = edl->local_session->get_selectionstart();
SET_TRACE
                        double end = edl->local_session->get_selectionend();
SET_TRACE
                        if(!EQUIV(start, end))
                                edl->clear(start, 
                                        end,
                                        edl->session->labels_follow_edits,
                                        edl->session->plugins_follow_edits);
SET_TRACE
                }

SET_TRACE
                paste_edls(&new_edls, 
                        load_mode,
                        0,
                        -1,
                        edl->session->labels_follow_edits, 
                        edl->session->plugins_follow_edits);
SET_TRACE
        }






TRACE("MWindow::load_filenames 91");

        if(new_assets.total)
        {
                for(int i = 0; i < new_assets.total; i++)
                {
                        Asset *new_asset = new_assets.values[i];
                        File *new_file = 0;
                        File *index_file = 0;
                        int got_it = 0;
                        for(int j = 0; j < new_files.total; j++)
                        {
                                new_file = new_files.values[j];
                                if(!strcmp(new_file->asset->path,
                                        new_asset->path))
                                {
                                        got_it = 1;
                                        break;
                                }
                        }

                        mainindexes->add_next_asset(got_it ? new_file : 0, 
                                new_assets.values[i]);
                        edl->assets->update(new_assets.values[i]);
                }


// Start examining next batch of index files
                mainindexes->start_build();
        }

TRACE("MWindow::load_filenames 100");
        update_project(load_mode);
TRACE("MWindow::load_filenames 110");

//printf("MWindow::load_filenames 9\n");
//sleep(10);

        new_edls.remove_all_objects();
TRACE("MWindow::load_filenames 120\n");
        new_assets.remove_all_objects();
TRACE("MWindow::load_filenames 130\n");
        new_files.remove_all_objects();
TRACE("MWindow::load_filenames 140\n");

        undo->update_undo(_("load"), LOAD_ALL, 0);


        gui->stop_hourglass();
UNTRACE

        return 0;
}




void MWindow::test_plugins(EDL *new_edl, char *path)
{
// Do a check weather plugins exist
        for(Track *track = new_edl->tracks->first; track; track = track->next)
        {
                for(int k = 0; k < track->plugin_set.total; k++)
                {
                        PluginSet *plugin_set = track->plugin_set.values[k];
                        for(Plugin *plugin = (Plugin*)plugin_set->first; 
                        plugin; 
                        plugin = (Plugin*)plugin->next)
                        {
                                if(plugin->plugin_type == PLUGIN_STANDALONE)
                                {
                                        // ok we need to find it in plugindb
                                        int plugin_found = 0;
                                        for(int j = 0; j < plugindb->total; j++)
                                        {
                                                PluginServer *server = plugindb->values[j];
                                                if(!strcasecmp(server->title, plugin->title) &&
                                                        ((track->data_type == TRACK_AUDIO && server->audio) ||
                                                        (track->data_type == TRACK_VIDEO && server->video)) &&
                                                        (!server->transition))
                                                        plugin_found = 1;
                                        }
                                        if (!plugin_found) 
                                        {
                                                printf("\nWARNING: The plugin '%s' named in file '%s' is not part of your installation of Cinelerra. This means project will not be rendered as it was meant and it might result in Cinelerra crashing.\n", plugin->title, path); 
                                        }
                                }
                        }
                }
                for(Edit *edit = (Edit*)track->edits->first; 
                edit; 
                edit = (Edit*)edit->next)
                {
                        if (edit->transition)
                        {
                                // ok we need to find transition in plugindb
                                int transition_found = 0;
                                for(int j = 0; j < plugindb->total; j++)
                                {
                                        PluginServer *server = plugindb->values[j];
                                        if(!strcasecmp(server->title, edit->transition->title) &&
                                                ((track->data_type == TRACK_AUDIO && server->audio) ||
                                                (track->data_type == TRACK_VIDEO && server->video)) &&
                                                (server->transition))
                                                transition_found = 1;
                                }
                                if (!transition_found) 
                                {
                                        printf("\nWARNING: The transition '%s' named in file '%s' is not part of your installation of Cinelerra. This means project will not be rendered as it was meant and it might result in Cinelerra crashing.\n", edit->transition->title, path); 
                                }
                        }
                }
        }
}






void MWindow::create_objects(int want_gui, 
        int want_new,
        char *config_path)
{
        char string[BCTEXTLEN];
        FileSystem fs;
        edl = 0;


        show_splash();

// For some reason, init_signals must come after show_splash or the signals won't
// get trapped.
        init_signals();


TRACE("MWindow::create_objects 1");
        init_defaults(defaults, config_path);
TRACE("MWindow::create_objects 2");
        init_preferences();
TRACE("MWindow::create_objects 3");
        init_plugins(preferences, plugindb, splash_window);
        if(splash_window) splash_window->operation->update(_("Initializing GUI"));
TRACE("MWindow::create_objects 4");
        init_theme();
// Default project created here
TRACE("MWindow::create_objects 5");
        init_edl();

TRACE("MWindow::create_objects 6");
        init_awindow();
TRACE("MWindow::create_objects 7");
        init_compositor();
TRACE("MWindow::create_objects 8");
        init_levelwindow();
TRACE("MWindow::create_objects 9");
        init_viewer();
TRACE("MWindow::create_objects 10");
        init_cache();
TRACE("MWindow::create_objects 11");
        init_indexes();
TRACE("MWindow::create_objects 12");
        init_channeldb();
TRACE("MWindow::create_objects 13");

        init_gui();
        init_gwindow();
TRACE("MWindow::create_objects 14");
        init_render();
        init_brender();
        mainprogress = new MainProgress(this, gui);
        undo = new MainUndo(this);

        plugin_guis = new ArrayList<PluginServer*>;

TRACE("MWindow::create_objects 15");
        if(session->show_vwindow) vwindow->gui->show_window();
        if(session->show_cwindow) cwindow->gui->show_window();
        if(session->show_awindow) awindow->gui->show_window();
        if(session->show_lwindow) lwindow->gui->show_window();
        if(session->show_gwindow) gwindow->gui->show_window();
TRACE("MWindow::create_objects 16");


        gui->mainmenu->load_defaults(defaults);
TRACE("MWindow::create_objects 17");
        gui->mainmenu->update_toggles(0);
TRACE("MWindow::create_objects 18");
        gui->patchbay->update();
TRACE("MWindow::create_objects 19");
        gui->canvas->draw();
TRACE("MWindow::create_objects 20");
        gui->cursor->draw();
TRACE("MWindow::create_objects 21");