/**
* projectM -- Milkdrop-esque visualisation SDK
* Copyright (C)2003-2004 projectM Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
* See 'LICENSE.txt' included within this release
*
*/

#include "RenderItemMatcher.hpp"
#include "RenderItemMergeFunction.hpp"
#include "fatal.h"
#include "Common.hpp"

#ifdef WIN32
#include "win32-dirent.h"
#endif

#include "timer.h"
#include <iostream>
#ifdef LINUX
#include "time.h"
#endif

#ifdef WIN32
#include <time.h>
#endif
#include "PipelineContext.hpp"
#include <iostream>
#include "projectM.hpp"
#include "BeatDetect.hpp"
#include "Preset.hpp"
#include "PipelineMerger.hpp"
#include "PCM.hpp"                    //Sound data handler (buffering, FFT, etc.)

#include <map>

#include "Renderer.hpp"
#include "PresetChooser.hpp"
#include "ConfigFile.h"
#include "TextureManager.hpp"
#include "TimeKeeper.hpp"
#include "RenderItemMergeFunction.hpp"

#ifdef USE_THREADS
#include "pthread.h"

pthread_mutex_t mutex;
pthread_cond_t  condition;
pthread_t thread;

#ifdef SYNC_PRESET_SWITCHES
pthread_mutex_t preset_mutex;
#endif
#endif

projectM::~projectM()
{

    #ifdef USE_THREADS
    std::cout << "[projectM] thread ";
    printf("c");
    running = false;
    printf("l");
    pthread_cond_signal(&condition);
    printf("e");
    pthread_mutex_unlock( &mutex );
    printf("a");
    pthread_detach(thread);
    printf("n");
    pthread_cond_destroy(&condition);
    printf("u");
    pthread_mutex_destroy( &mutex );
    #ifdef SYNC_PRESET_SWITCHES
    pthread_mutex_destroy( &preset_mutex );
    #endif

    printf("p");
    std::cout << std::endl;
    #endif
    destroyPresetTools();

    if ( renderer )
        delete ( renderer );
    if ( beatDetect )
        delete ( beatDetect );
    if ( _pcm ) {
        delete ( _pcm );
        _pcm = 0;
    }

    delete(_pipelineContext);
    delete(_pipelineContext2);
}

unsigned projectM::initRenderToTexture()
{
    return renderer->initRenderToTexture();
}

void projectM::projectM_resetTextures()
{
    renderer->ResetTextures();
}


projectM::projectM ( std::string config_file, int flags) :
beatDetect ( 0 ), renderer ( 0 ),  _pcm(0), m_presetPos(0), m_flags(flags), _pipelineContext(new PipelineContext()), _pipelineContext2(new PipelineContext())
{
    readConfig(config_file);
    projectM_reset();
    projectM_resetGL(_settings.windowWidth, _settings.windowHeight);

}

projectM::projectM(Settings settings, int flags):
beatDetect ( 0 ), renderer ( 0 ),  _pcm(0), m_presetPos(0), m_flags(flags), _pipelineContext(new PipelineContext()), _pipelineContext2(new PipelineContext())
{
    readSettings(settings);
    projectM_reset();
    projectM_resetGL(_settings.windowWidth, _settings.windowHeight);
}


bool projectM::writeConfig(const std::string & configFile, const Settings & settings) {

    ConfigFile config ( configFile );

    config.add("Mesh X", settings.meshX);
    config.add("Mesh Y", settings.meshY);
    config.add("Texture Size", settings.textureSize);
    config.add("FPS", settings.fps);
    config.add("Window Width", settings.windowWidth);
    config.add("Window Height", settings.windowHeight);
    config.add("Smooth Preset Duration", settings.smoothPresetDuration);
    config.add("Preset Duration", settings.presetDuration);
    config.add("Preset Path", settings.presetURL);
    config.add("Title Font", settings.titleFontURL);
    config.add("Menu Font", settings.menuFontURL);
    config.add("Hard Cut Sensitivity", settings.beatSensitivity);
    config.add("Aspect Correction", settings.aspectCorrection);
    config.add("Easter Egg Parameter", settings.easterEgg);
    config.add("Shuffle Enabled", settings.shuffleEnabled);
    config.add("Soft Cut Ratings Enabled", settings.softCutRatingsEnabled);
    std::fstream file(configFile.c_str());
    if (file) {
        file << config;
        return true;
    } else
        return false;
}


void projectM::readConfig (const std::string & configFile )
{
    std::cout << "[projectM] config file: " << configFile << std::endl;

    ConfigFile config ( configFile );
    _settings.meshX = config.read<int> ( "Mesh X", 32 );
    _settings.meshY = config.read<int> ( "Mesh Y", 24 );
    _settings.textureSize = config.read<int> ( "Texture Size", 512 );
    _settings.fps = config.read<int> ( "FPS", 35 );
    _settings.windowWidth  = config.read<int> ( "Window Width", 512 );
    _settings.windowHeight = config.read<int> ( "Window Height", 512 );
    _settings.smoothPresetDuration =  config.read<int>
    ( "Smooth Preset Duration", config.read<int>("Smooth Transition Duration", 10));
    _settings.presetDuration = config.read<int> ( "Preset Duration", 15 );

    #ifdef LINUX
    _settings.presetURL = config.read<string> ( "Preset Path", CMAKE_INSTALL_PREFIX "/share/projectM/presets" );
    #endif

    #ifdef __APPLE__
    /// @bug awful hardcoded hack- need to add intelligence to cmake wrt bundling - carm
    _settings.presetURL = config.read<string> ( "Preset Path", "../Resources/presets" );
    #endif

    #ifdef WIN32
    _settings.presetURL = config.read<string> ( "Preset Path", CMAKE_INSTALL_PREFIX "/share/projectM/presets" );
    #endif

    #ifdef __APPLE__
    _settings.titleFontURL = config.read<string>
    ( "Title Font",  "../Resources/fonts/Vera.tff");
    _settings.menuFontURL = config.read<string>
    ( "Menu Font", "../Resources/fonts/VeraMono.ttf");
    #endif

    #ifdef LINUX
    _settings.titleFontURL = config.read<string>
    ( "Title Font", projectM_FONT_TITLE );
    _settings.menuFontURL = config.read<string>
    ( "Menu Font", projectM_FONT_MENU );
    #endif

    #ifdef WIN32
    _settings.titleFontURL = config.read<string>
    ( "Title Font", projectM_FONT_TITLE );
    _settings.menuFontURL = config.read<string>
    ( "Menu Font", projectM_FONT_MENU );
    #endif


    _settings.shuffleEnabled = config.read<bool> ( "Shuffle Enabled", true);

    _settings.easterEgg = config.read<float> ( "Easter Egg Parameter", 0.0);
    _settings.softCutRatingsEnabled =
	config.read<float> ( "Soft Cut Ratings Enabled", false);

    projectM_init ( _settings.meshX, _settings.meshY, _settings.fps,
                    _settings.textureSize, _settings.windowWidth,_settings.windowHeight);

                    _settings.beatSensitivity = beatDetect->beat_sensitivity = config.read<float> ( "Hard Cut Sensitivity", 10.0 );


	if ( config.read ( "Aspect Correction", true ) )
	{
	    _settings.aspectCorrection = true;
	    renderer->correction = true;
	}
	else
	{
	    _settings.aspectCorrection = false;
	    renderer->correction = false;
	}


}


void projectM::readSettings (const Settings & settings )
{
    _settings.meshX = settings.meshX;
    _settings.meshY = settings.meshY;
    _settings.textureSize = settings.textureSize;
    _settings.fps = settings.fps;
    _settings.windowWidth  = settings.windowWidth;
    _settings.windowHeight = settings.windowHeight;
    _settings.smoothPresetDuration = settings.smoothPresetDuration;
    _settings.presetDuration = settings.presetDuration;
    _settings.softCutRatingsEnabled = settings.softCutRatingsEnabled;

    _settings.presetURL = settings.presetURL;
    _settings.titleFontURL = settings.titleFontURL;
    _settings.menuFontURL =  settings.menuFontURL;
    _settings.shuffleEnabled = settings.shuffleEnabled;

    _settings.easterEgg = settings.easterEgg;

    projectM_init ( _settings.meshX, _settings.meshY, _settings.fps,
                    _settings.textureSize, _settings.windowWidth,_settings.windowHeight);


                    _settings.beatSensitivity = settings.beatSensitivity;
                    _settings.aspectCorrection = settings.aspectCorrection;

}

#ifdef USE_THREADS
static void *thread_callback(void *prjm) {
    projectM *p = (projectM *)prjm;

    p->thread_func(prjm);
    return NULL;}


    void *projectM::thread_func(void *vptr_args)
    {
        pthread_mutex_lock( &mutex );
        //  printf("in thread: %f\n", timeKeeper->PresetProgressB());
        while (true)
        {
            pthread_cond_wait( &condition, &mutex );
            if(!running)
            {
                pthread_mutex_unlock( &mutex );
                return NULL;
            }
            evaluateSecondPreset();
        }
    }
    #endif

    void projectM::evaluateSecondPreset()
    {
        pipelineContext2().time = timeKeeper->GetRunningTime();
        pipelineContext2().frame = timeKeeper->PresetFrameB();
        pipelineContext2().progress = timeKeeper->PresetProgressB();

        m_activePreset2->Render(*beatDetect, pipelineContext2());
    }

    void projectM::renderFrame()
    {
        #ifdef SYNC_PRESET_SWITCHES
        pthread_mutex_lock(&preset_mutex);
        #endif

        #ifdef DEBUG
        char fname[1024];
        FILE *f = NULL;
        int index = 0;
        int x, y;
        #endif

        timeKeeper->UpdateTimers();
/*
        if (timeKeeper->IsSmoothing())
        {
            printf("Smoothing A:%f, B:%f, S:%f\n", timeKeeper->PresetProgressA(), timeKeeper->PresetProgressB(), timeKeeper->SmoothRatio());
        }
        else
        {
            printf("          A:%f\n", timeKeeper->PresetProgressA());
        }*/

        mspf= ( int ) ( 1000.0/ ( float ) settings().fps ); //milliseconds per frame

        /// @bug who is responsible for updating this now?"
        pipelineContext().time = timeKeeper->GetRunningTime();
        pipelineContext().frame = timeKeeper->PresetFrameA();
        pipelineContext().progress = timeKeeper->PresetProgressA();

        //m_activePreset->Render(*beatDetect, pipelineContext());

        beatDetect->detectFromSamples();

        //m_activePreset->evaluateFrame();

        //if the preset isn't locked and there are more presets
        if ( renderer->noSwitch==false && !m_presetChooser->empty() )
        {
            //if preset is done and we're not already switching
            if ( timeKeeper->PresetProgressA()>=1.0 && !timeKeeper->IsSmoothing())
            {

		if (settings().shuffleEnabled)
			selectRandom(false);
		else
			selectNext(false);

           }

            else if ((beatDetect->vol-beatDetect->vol_old>beatDetect->beat_sensitivity ) &&
                timeKeeper->CanHardCut())
            {
                // printf("Hard Cut\n");
		if (settings().shuffleEnabled)
			selectRandom(true);
		else
			selectNext(true);
            }
        }


        if ( timeKeeper->IsSmoothing() && timeKeeper->SmoothRatio() <= 1.0 && !m_presetChooser->empty() )
        {


            //	 printf("start thread\n");
            assert ( m_activePreset2.get() );

            #ifdef USE_THREADS

            pthread_cond_signal(&condition);
            pthread_mutex_unlock( &mutex );
            #endif
            m_activePreset->Render(*beatDetect, pipelineContext());

            #ifdef USE_THREADS
            pthread_mutex_lock( &mutex );
            #else
            evaluateSecondPreset();
            #endif

            Pipeline pipeline;

            pipeline.setStaticPerPixel(settings().meshX, settings().meshY);

            assert(_matcher);
            PipelineMerger::mergePipelines( m_activePreset->pipeline(),
                                            m_activePreset2->pipeline(), pipeline,
					    _matcher->matchResults(),
                                            *_merger, timeKeeper->SmoothRatio());

            renderer->RenderFrame(pipeline, pipelineContext());

	    pipeline.drawables.clear();

	    /*
	    while (!pipeline.drawables.empty()) {
		delete(pipeline.drawables.back());
		pipeline.drawables.pop_back();
	    } */

        }
        else
        {


            if ( timeKeeper->IsSmoothing() && timeKeeper->SmoothRatio() > 1.0 )
            {
                //printf("End Smooth\n");
                m_activePreset = m_activePreset2;
                timeKeeper->EndSmoothing();
            }
            //printf("Normal\n");

            m_activePreset->Render(*beatDetect, pipelineContext());
            renderer->RenderFrame (m_activePreset->pipeline(), pipelineContext());


        }

        //	std::cout<< m_activePreset->absoluteFilePath()<<std::endl;
        //	renderer->presetName = m_activePreset->absoluteFilePath();


        count++;
        #ifndef WIN32
        /** Frame-rate limiter */
        /** Compute once per preset */
        if ( this->count%100==0 )
        {
            this->renderer->realfps=100.0/ ( ( getTicks ( &timeKeeper->startTime )-this->fpsstart ) /1000 );
            this->fpsstart=getTicks ( &timeKeeper->startTime );
        }

        int timediff = getTicks ( &timeKeeper->startTime )-this->timestart;

        if ( timediff < this->mspf )
        {
            // printf("%s:",this->mspf-timediff);
            int sleepTime = ( unsigned int ) ( this->mspf-timediff ) * 1000;
            //		DWRITE ( "usleep: %d\n", sleepTime );
            if ( sleepTime > 0 && sleepTime < 100000 )
            {
                if ( usleep ( sleepTime ) != 0 ) {}}
        }
        this->timestart=getTicks ( &timeKeeper->startTime );
        #endif /** !WIN32 */

	#ifdef SYNC_PRESET_SWITCHES
        pthread_mutex_unlock(&preset_mutex);
        #endif

    }

    void projectM::projectM_reset()
    {
        this->mspf = 0;
        this->timed = 0;
        this->timestart = 0;
        this->count = 0;

        this->fpsstart = 0;

        setlocale(LC_NUMERIC, "C");

        projectM_resetengine();
    }

    void projectM::projectM_init ( int gx, int gy, int fps, int texsize, int width, int height )
    {
        setlocale(LC_NUMERIC, "C");

        /** Initialise start time */
        timeKeeper = new TimeKeeper(_settings.presetDuration,_settings.smoothPresetDuration, _settings.easterEgg);

        /** Nullify frame stash */

        /** Initialise per-pixel matrix calculations */
        /** We need to initialise this before the builtin param db otherwise bass/mid etc won't bind correctly */
        assert ( !beatDetect );

        if (!_pcm)
            _pcm = new PCM();
        assert(pcm());
        beatDetect = new BeatDetect ( _pcm );

        if ( _settings.fps > 0 )
            mspf= ( int ) ( 1000.0/ ( float ) _settings.fps );
        else mspf = 0;

        this->renderer = new Renderer ( width, height, gx, gy, texsize,  beatDetect, settings().presetURL, settings().titleFontURL, settings().menuFontURL );

        running = true;

        initPresetTools(gx, gy);


        #ifdef USE_THREADS
        pthread_mutex_init(&mutex, NULL);

	#ifdef SYNC_PRESET_SWITCHES
        pthread_mutex_init(&preset_mutex, NULL);
	#endif

        pthread_cond_init(&condition, NULL);
        if (pthread_create(&thread, NULL, thread_callback, this) != 0)
        {

            std::cerr << "[projectM] failed to allocate a thread! try building with option USE_THREADS turned off" << std::endl;;
            exit(EXIT_FAILURE);
        }
        pthread_mutex_lock( &mutex );
        #endif

        /// @bug order of operatoins here is busted
        //renderer->setPresetName ( m_activePreset->name() );
        timeKeeper->StartPreset();
        assert(pcm());

       pipelineContext().fps = fps;
       pipelineContext2().fps = fps;

    }

    /* Reinitializes the engine variables to a default (conservative and sane) value */
    void projectM::projectM_resetengine()
    {

        if ( beatDetect != NULL )
        {
            beatDetect->reset();
        }

    }

    /** Resets OpenGL state */
    void projectM::projectM_resetGL ( int w, int h )
    {

        /** Stash the new dimensions */

        renderer->reset ( w,h );
    }

    /** Sets the title to display */
    void projectM::projectM_setTitle ( std::string title ) {

        if ( title != renderer->title )
        {
            renderer->title=title;
            renderer->drawtitle=1;
        }
    }


    int projectM::initPresetTools(int gx, int gy)
    {

        /* Set the seed to the current time in seconds */
        srand ( time ( NULL ) );

        std::string url = (m_flags & FLAG_DISABLE_PLAYLIST_LOAD) ? std::string() : settings().presetURL;

        if ( ( m_presetLoader = new PresetLoader ( gx, gy, url) ) == 0 )
        {
            m_presetLoader = 0;
            std::cerr << "[projectM] error allocating preset loader" << std::endl;
            return PROJECTM_FAILURE;
        }

        if ( ( m_presetChooser = new PresetChooser ( *m_presetLoader, settings().softCutRatingsEnabled ) ) == 0 )
        {
            delete ( m_presetLoader );

            m_presetChooser = 0;
            m_presetLoader = 0;

            std::cerr << "[projectM] error allocating preset chooser" << std::endl;
            return PROJECTM_FAILURE;
        }

        // Start the iterator
        if (!m_presetPos)
            m_presetPos = new PresetIterator();

        // Initialize a preset queue position as well
        //	m_presetQueuePos = new PresetIterator();

        // Start at end ptr- this allows next/previous to easily be done from this position.
        *m_presetPos = m_presetChooser->end();

        // Load idle preset
        std::cerr << "[projectM] Allocating idle preset..." << std::endl;
        m_activePreset = m_presetLoader->loadPreset
        ("idle://Geiss & Sperl - Feedback (projectM idle HDR mix).milk");

        renderer->SetPipeline(m_activePreset->pipeline());

        // Case where no valid presets exist in directory. Could also mean
        // playlist initialization was deferred
        if (m_presetChooser->empty())
        {
            //std::cerr << "[projectM] warning: no valid files found in preset directory \""
            //<< m_presetLoader->directoryName() << "\"" << std::endl;
        }

        _matcher = new RenderItemMatcher();
        _merger = new MasterRenderItemMerge();
        //_merger->add(new WaveFormMergeFunction());
        _merger->add(new ShapeMerge());
        _merger->add(new BorderMerge());
        //_merger->add(new BorderMergeFunction());

        /// @bug These should be requested by the preset factories.
        _matcher->distanceFunction().addMetric(new ShapeXYDistance());

        //std::cerr << "[projectM] Idle preset allocated." << std::endl;

        projectM_resetengine();

        //std::cerr << "[projectM] engine has been reset." << std::endl;
        return PROJECTM_SUCCESS;
    }

    void projectM::destroyPresetTools()
    {

        if ( m_presetPos )
            delete ( m_presetPos );

        m_presetPos = 0;

        if ( m_presetChooser )
            delete ( m_presetChooser );

        m_presetChooser = 0;

        if ( m_presetLoader )
            delete ( m_presetLoader );

        m_presetLoader = 0;

    }

    /// @bug queuePreset case isn't handled
    void projectM::removePreset(unsigned int index) {

        unsigned int chooserIndex = **m_presetPos;

        m_presetLoader->removePreset(index);


        // Case: no more presets, set iterator to end
        if (m_presetChooser->empty())
            *m_presetPos = m_presetChooser->end();

        // Case: chooser index has become one less due to removal of an index below it
        else if (chooserIndex > index) {
            chooserIndex--;
            *m_presetPos = m_presetChooser->begin(chooserIndex);
        }

        // Case: we have deleted the active preset position
        // Set iterator to end of chooser
        else if (chooserIndex == index) {
            *m_presetPos = m_presetChooser->end();
        }


    }

    unsigned int projectM::addPresetURL ( const std::string & presetURL, const std::string & presetName, const RatingList & ratings)
    {
        bool restorePosition = false;

        if (*m_presetPos == m_presetChooser->end())
            restorePosition = true;

        int index = m_presetLoader->addPresetURL ( presetURL, presetName, ratings);

        if (restorePosition)
            *m_presetPos = m_presetChooser->end();

        return index;
    }

    void projectM::selectPreset ( unsigned int index, bool hardCut)
    {

		if (m_presetChooser->empty())
			return;

		if (!hardCut) {
                	timeKeeper->StartSmoothing();
		}

		*m_presetPos = m_presetChooser->begin(index);

		if (!hardCut) {
			switchPreset(m_activePreset2);
		} else {
			switchPreset(m_activePreset);
			timeKeeper->StartPreset();
		}

	presetSwitchedEvent(hardCut, **m_presetPos);

}


void projectM::selectRandom(const bool hardCut) {

		if (m_presetChooser->empty())
			return;

		if (!hardCut) {
                	timeKeeper->StartSmoothing();
		}

		*m_presetPos = m_presetChooser->weightedRandom(hardCut);

		if (!hardCut) {
			switchPreset(m_activePreset2);
		} else {
			switchPreset(m_activePreset);
			timeKeeper->StartPreset();
		}

		presetSwitchedEvent(hardCut, **m_presetPos);

}

void projectM::selectPrevious(const bool hardCut) {

		if (m_presetChooser->empty())
			return;

		if (!hardCut) {
                	timeKeeper->StartSmoothing();
		}

		m_presetChooser->previousPreset(*m_presetPos);

		if (!hardCut) {
			switchPreset(m_activePreset2);
		} else {
			switchPreset(m_activePreset);
			timeKeeper->StartPreset();
		}

		presetSwitchedEvent(hardCut, **m_presetPos);

//		m_activePreset =  m_presetPos->allocate();
//		renderer->SetPipeline(m_activePreset->pipeline());
//		renderer->setPresetName(m_activePreset->name());

	       	//timeKeeper->StartPreset();

}

void projectM::selectNext(const bool hardCut) {

		if (m_presetChooser->empty())
			return;

		if (!hardCut) {
                	timeKeeper->StartSmoothing();
			std::cout << "start smoothing" << std::endl;
		}

		m_presetChooser->nextPreset(*m_presetPos);

		if (!hardCut) {
			switchPreset(m_activePreset2);
		} else {
			switchPreset(m_activePreset);
			timeKeeper->StartPreset();
		}
		presetSwitchedEvent(hardCut, **m_presetPos);


}

/**
 *
 * @param targetPreset
 */
void projectM::switchPreset(std::auto_ptr<Preset> & targetPreset) {

	#ifdef SYNC_PRESET_SWITCHES
	pthread_mutex_lock(&preset_mutex);
	#endif

        targetPreset = m_presetPos->allocate();

        // Set preset name here- event is not done because at the moment this function is oblivious to smooth/hard switches
        renderer->setPresetName(targetPreset->name());
        renderer->SetPipeline(targetPreset->pipeline());

	#ifdef SYNC_PRESET_SWITCHES
	pthread_mutex_unlock(&preset_mutex);
	#endif
    }

    void projectM::setPresetLock ( bool isLocked )
    {
        renderer->noSwitch = isLocked;
    }

    bool projectM::isPresetLocked() const
    {
        return renderer->noSwitch;
    }

    std::string projectM::getPresetURL ( unsigned int index ) const
    {
        return m_presetLoader->getPresetURL(index);
    }

    int projectM::getPresetRating ( unsigned int index, const PresetRatingType ratingType) const
    {
        return m_presetLoader->getPresetRating(index, ratingType);
    }

    std::string projectM::getPresetName ( unsigned int index ) const
    {
        return m_presetLoader->getPresetName(index);
    }

    void projectM::clearPlaylist ( )
    {
        m_presetLoader->clear();
        *m_presetPos = m_presetChooser->end();
    }

    void projectM::selectPresetPosition(unsigned int index) {
        *m_presetPos = m_presetChooser->begin(index);
    }

    bool projectM::selectedPresetIndex(unsigned int & index) const {

        if (*m_presetPos == m_presetChooser->end())
            return false;

        index = **m_presetPos;
        return true;
    }


    bool projectM::presetPositionValid() const {

        return (*m_presetPos != m_presetChooser->end());
    }

    unsigned int projectM::getPlaylistSize() const
    {
        return m_presetLoader->size();
    }

    void projectM::changePresetRating (unsigned int index, int rating, const PresetRatingType ratingType) {
        m_presetLoader->setRating(index, rating, ratingType);
        presetRatingChanged(index, rating, ratingType);
    }

    void projectM::insertPresetURL(unsigned int index, const std::string & presetURL, const std::string & presetName, const RatingList & ratings)
    {
        bool atEndPosition = false;

        int newSelectedIndex;


        if (*m_presetPos == m_presetChooser->end()) // Case: preset not selected
        {
            atEndPosition = true;
        }

        else if (**m_presetPos < index) // Case: inserting before selected preset
        {
            newSelectedIndex = **m_presetPos;
        }

        else if (**m_presetPos > index) // Case: inserting after selected preset
        {
            newSelectedIndex++;
        }

        else  // Case: inserting at selected preset
        {
            newSelectedIndex++;
        }

        m_presetLoader->insertPresetURL (index, presetURL, presetName, ratings);

        if (atEndPosition)
            *m_presetPos = m_presetChooser->end();
        else
            *m_presetPos = m_presetChooser->begin(newSelectedIndex);


    }

void projectM::changePresetName ( unsigned int index, std::string name ) {
	m_presetLoader->setPresetName(index, name);
}


void projectM::changeTextureSize(int size) {
  _settings.textureSize = size;

  delete renderer;
  renderer = new Renderer(_settings.windowWidth, _settings.windowHeight,
                          _settings.meshX, _settings.meshY,
                          _settings.textureSize, beatDetect, _settings.presetURL,
                          _settings.titleFontURL, _settings.menuFontURL);
}

void projectM::changePresetDuration(int seconds) {
  timeKeeper->ChangePresetDuration(seconds);
}