ugfx/src/gos/gos_qt.cpp

/*
 * This file is subject to the terms of the GFX License. If a copy of
 * the license was not distributed with this file, you can obtain one at:
 *
 *              http://ugfx.io/license.html
 */

#include "../../gfx.h"

#if GFX_USE_OS_QT
#include <QMutex>
#include <QSemaphore>
#include <QThread>
#include <QElapsedTimer>

extern "C" void _gosPostInit(void);

class Thread : public QThread
{
public:
    typedef gThreadreturn (*fptr)(void* param);

    void setFunction(fptr function, void* param)
    {
        _function = function;
        _param = param;
    }

    gThreadreturn returnValue()
    {
        return _returnValue;
    }

    virtual void run() override
    {
        if (!_function) {
            return;
        }

        _returnValue = _function(_param);
    }

private:
    fptr _function;
    void* _param;
    gThreadreturn _returnValue;
};

static QElapsedTimer _systickTimer;
static QMutex _systemMutex;

void _gosInit(void)
{
    _systickTimer.start();
}

void _gosPostInit(void)
{
}

void _gosDeinit(void)
{
}

void gfxHalt(const char *msg)
{
    volatile gU32 dummy;

    (void)msg;

    while(1) {
        dummy++;
    }
}

void gfxExit(void)
{
    volatile gU32 dummy;

    while(1) {
        dummy++;
    }
}

void* gfxAlloc(gMemSize sz)
{
    return malloc(sz);
}

void* gfxRealloc(void* ptr, gMemSize oldsz, gMemSize newsz)
{
    Q_UNUSED(oldsz)
    return realloc(ptr, newsz);
}

void gfxFree(void* ptr)
{
    free(ptr);
}

void gfxYield(void)
{
    QThread::msleep(0);
}

void gfxSleepMilliseconds(gDelay ms)
{
    QThread::msleep(ms);
}

void gfxSleepMicroseconds(gDelay us)
{
    QThread::usleep(us);
}

gTicks gfxSystemTicks(void)
{
    return _systickTimer.elapsed();
}

gTicks gfxMillisecondsToTicks(gDelay ms)
{
    return ms;
}

void gfxSystemLock(void)
{
    _systemMutex.lock();
}

void gfxSystemUnlock(void)
{
    _systemMutex.unlock();
}

void gfxMutexInit(gMutex *pmutex)
{
    *pmutex = new QMutex;
}

void gfxMutexDestroy(gMutex *pmutex)
{
    delete static_cast<QMutex*>(*pmutex);
}

void gfxMutexEnter(gMutex *pmutex)
{
    static_cast<QMutex*>(*pmutex)->lock();
}

void gfxMutexExit(gMutex *pmutex)
{
    static_cast<QMutex*>(*pmutex)->unlock();
}

void gfxSemInit(gSem *psem, gSemcount val, gSemcount limit)
{
    *psem = new QSemaphore(limit);

    static_cast<QSemaphore*>(*psem)->release(val);
}

void gfxSemDestroy(gSem *psem)
{
    delete static_cast<QSemaphore*>(*psem);
}

gBool gfxSemWait(gSem *psem, gDelay ms)
{
    return static_cast<QSemaphore*>(*psem)->tryAcquire(1, ms);
}

gBool gfxSemWaitI(gSem *psem)
{
    return static_cast<QSemaphore*>(*psem)->tryAcquire(1);
}

void gfxSemSignal(gSem *psem)
{
    static_cast<QSemaphore*>(*psem)->release(1);
}

void gfxSemSignalI(gSem *psem)
{
    static_cast<QSemaphore*>(*psem)->release(1);
}

gThread gfxThreadCreate(void *stackarea, gMemSize stacksz, gThreadpriority prio, GFX_THREAD_FUNCTION((*fn),p), void *param)
{
    Q_UNUSED(stackarea)

    Thread* thread = new Thread;
    thread->setFunction(fn, param);
    if (stacksz > 0) {
        thread->setStackSize(stacksz);
    }
    thread->start(static_cast<QThread::Priority>(prio));

    return static_cast<gThread>(thread);
}

gThreadreturn gfxThreadWait(gThread thread)
{
    Thread* t = static_cast<Thread*>(thread);

    gThreadreturn returnValue = t->returnValue();
    t->wait();
    t->exit();

    return returnValue;
}

gThread gfxThreadMe(void)
{
    return static_cast<Thread*>(QThread::currentThread());
}

void gfxThreadClose(gThread thread)
{
    static_cast<Thread*>(thread)->exit();
}

#endif /* GFX_USE_OS_QT */