path: root/library/iconBuffer.cpp

#include "iconBuffer.h"
#include <wx/thread.h>
#include "globalFunctions.h"
#include <wx/utils.h>
#include <wx/bitmap.h>
#include <wx/msw/wrapwin.h> //includes "windows.h"
#include <wx/msgdlg.h>
#include "../algorithm.h"
#include <wx/icon.h>
#include <map>
#include <queue>

using FreeFileSync::IconBuffer;


class BasicString //simple thread safe string class
{
public:
    BasicString()
    {
        data = new DefaultChar[1]; //compliance with delete []
        *data = 0;                 //compliance with c_str()
    }

    BasicString(const Zstring& other) //make DEEP COPY from Zstring!
    {
        data = new DefaultChar[other.length() + 1];
        memcpy(data, other.c_str(), (other.length() + 1) * sizeof(DefaultChar));
    }

    BasicString(const BasicString& other)
    {
        const size_t otherLen = defaultLength(other.c_str());
        data = new DefaultChar[otherLen + 1];
        memcpy(data, other.c_str(), (otherLen + 1) * sizeof(DefaultChar));
    }

    ~BasicString()
    {
        delete [] data;
    }

    BasicString& operator=(const BasicString& other)
    {   //exception safety; handle self-assignment implicitly
        const size_t otherLen = defaultLength(other.c_str());
        DefaultChar* dataNew = new DefaultChar[otherLen + 1];
        memcpy(dataNew, other.c_str(), (otherLen + 1) * sizeof(DefaultChar));

        delete data;
        data = dataNew;

        return *this;
    }

    const DefaultChar* c_str() const
    {
        return data;
    }

private:
    DefaultChar* data;
};


class WorkerThread : public wxThread
{
public:
    WorkerThread(IconBuffer* iconBuff);

    void setWorkload(const std::vector<Zstring>& load); //(re-)set new workload of icons to be retrieved
    void quitThread();

    virtual ExitCode Entry();

private:
    void doWork();

//---------------------- Shared Data -------------------------
    typedef BasicString FileName;

    wxCriticalSection lockWorkload; //use for locking shared data
    std::vector<FileName> workload; //processes last elements of vector first!
    bool threadHasMutex;
    bool threadExitIsRequested;
//------------------------------------------------------------

    //event: icon buffer -> woker thread
    wxMutex threadIsListening;
    wxCondition continueWork; //wake up thread

    IconBuffer* iconBuffer;
};


WorkerThread::WorkerThread(IconBuffer* iconBuff) :
        wxThread(wxTHREAD_JOINABLE),
        threadHasMutex(false),
        threadExitIsRequested(false),
        threadIsListening(),
        continueWork(threadIsListening),
        iconBuffer(iconBuff)
{
    if (Create() != wxTHREAD_NO_ERROR)
        throw RuntimeException(wxString(wxT("Error creating icon buffer worker thread!")));

    if (Run() != wxTHREAD_NO_ERROR)
        throw RuntimeException(wxString(wxT("Error starting icon buffer worker thread!")));

    //wait until thread has aquired mutex
    bool hasMutex = false;
    while (!hasMutex)
    {
        wxMilliSleep(5);
        wxCriticalSectionLocker dummy(lockWorkload);
        hasMutex = threadHasMutex;
    }   //polling -> it's not nice, but works and is no issue
}


void WorkerThread::setWorkload(const std::vector<Zstring>& load) //(re-)set new workload of icons to be retrieved
{
    wxCriticalSectionLocker dummy(lockWorkload);

    workload.clear();
    for (std::vector<Zstring>::const_iterator i = load.begin(); i != load.end(); ++i)
        workload.push_back(*i); //make DEEP COPY from Zstring!

    if (!workload.empty())
        continueWork.Signal(); //wake thread IF he is waiting
}


void WorkerThread::quitThread()
{
    wxMutexLocker dummy(threadIsListening); //wait until thread is in waiting state
    threadExitIsRequested = true; //no sharing conflicts in this situation
    continueWork.Signal(); //exit thread
}


wxThread::ExitCode WorkerThread::Entry()
{
    try
    {
        wxMutexLocker dummy(threadIsListening); //this lock needs to be called from WITHIN the thread => calling it from constructor(Main thread) would be useless
        {                                       //this mutex STAYS locked all the time except of continueWork.Wait()!
            wxCriticalSectionLocker dummy(lockWorkload);
            threadHasMutex = true;
        }

        while (true)
        {
            continueWork.Wait(); //waiting for continueWork.Signal(); unlocks Mutex "threadIsListening"

            //no mutex needed in this context
            if (threadExitIsRequested) //no mutex here: atomicity is not prob for a bool, but visibility (e.g. caching in registers)
                return 0;              //shouldn't be a problem nevertheless because of implicit memory barrier caused by mutex.Lock() in .Wait()

            //do work: get the file icon.
            doWork();
        }
    }
    catch (RuntimeException& e) //exceptions must be catched per thread
    {
        wxMessageBox(e.show());
        return 0;
    }
}


void WorkerThread::doWork()
{
    BasicString fileName; //don't use Zstring: reference-counted objects are NOT THREADSAFE!!! e.g. double deletion might happen

    //do work: get the file icon.
    while (true)
    {
        {
            wxCriticalSectionLocker dummy(lockWorkload);
            if (workload.empty())
                break; //enter waiting state
            fileName = workload.back();
            workload.pop_back();
        }

        if (iconBuffer->requestIcon(Zstring(fileName.c_str()))) //thread safety: Zstring okay, won't be reference-counted in requestIcon()
            break; //icon already in buffer: enter waiting state

        //load icon
        SHFILEINFO fileInfo;
        fileInfo.hIcon = 0; //initialize hIcon

        if (SHGetFileInfo(fileName.c_str(), //NOTE: CoInitializeEx()/CoUninitialize() implicitly called by wxWidgets on program startup!
                          0,
                          &fileInfo,
                          sizeof(fileInfo),
                          SHGFI_ICON | SHGFI_SMALLICON) &&

                fileInfo.hIcon != 0) //fix for weird error: SHGetFileInfo() might return successfully WITHOUT filling fileInfo.hIcon!!
        {                        //bug report: https://sourceforge.net/tracker/?func=detail&aid=2768004&group_id=234430&atid=1093080

            wxIcon newIcon; //attention: wxIcon uses reference counting!
            newIcon.SetHICON(fileInfo.hIcon);
            newIcon.SetSize(IconBuffer::ICON_SIZE, IconBuffer::ICON_SIZE);

            iconBuffer->insertIntoBuffer(fileName.c_str(), newIcon); //thread safety: icon may be deleted only within insertIntoBuffer()

            //freeing of icon handle seems to happen somewhere beyond wxIcon destructor
            //if (!DestroyIcon(fileInfo.hIcon))
            //  throw RuntimeException(wxString(wxT("Error deallocating Icon handle!\n\n")) + FreeFileSync::getLastErrorFormatted());

        }
        else
        {
            //if loading of icon fails for whatever reason, just save a dummy icon to avoid re-loading
            iconBuffer->insertIntoBuffer(fileName.c_str(), wxNullIcon);
        }
    }
}

//---------------------------------------------------------------------------------------------------

typedef Zstring FileName;
class IconDB : public std::map<FileName, wxIcon> {};
class IconDbSequence : public std::queue<FileName> {};

//---------------------------------------------------------------------------------------------------


IconBuffer& IconBuffer::getInstance()
{
    static IconBuffer instance;
    return instance;
}


IconBuffer::IconBuffer() :
        lockIconDB( new wxCriticalSection),
        buffer(     new IconDB),
        bufSequence(new IconDbSequence),
        worker(     new WorkerThread(this)) //might throw exceptions!
{}


IconBuffer::~IconBuffer()
{
    worker->quitThread();
    worker->Wait(); //wait until thread has exitted
}


bool IconBuffer::requestIcon(const Zstring& fileName, wxIcon* icon)
{
    wxCriticalSectionLocker dummy(*lockIconDB);
    IconDB::const_iterator i = buffer->find(fileName);

    if (i != buffer->end())
    {
        if (icon != NULL)
            *icon = i->second;
        return true;
    }

    return false;
}


void IconBuffer::setWorkload(const std::vector<Zstring>& load)
{
    worker->setWorkload(load);
}


void IconBuffer::insertIntoBuffer(const DefaultChar* fileName, const wxIcon& icon) //called by worker thread
{
    if (icon.IsOk()) //this check won't hurt
    {
        wxCriticalSectionLocker dummy(*lockIconDB);

        const Zstring fileNameZ = fileName;

        const std::pair<IconDB::iterator, bool> rc = buffer->insert(IconDB::value_type(fileNameZ, icon));

        if (rc.second) //if insertion took place
            bufSequence->push(fileNameZ);

        assert(buffer->size() == bufSequence->size());

        //remove elements if buffer becomes too big:
        if (buffer->size() > 1000) //limit buffer size: critical because large buffers seem to cause various wxIcon/wxBitmap issues!
        {
            //remove oldest element
            buffer->erase(bufSequence->front());
            bufSequence->pop();
        }
    }
}