HandlerChain_HandlerFunctions.c

Go to the documentation of this file.

 
 
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
 
#include "helpers/mutex.h"
#include "helpers/uintarray.h"
 
#include "HandlerChain_MessageWindow.h"
#include "HandlerChain_HandlerFunctions.h"
 
static Mutex _mutex;
 
static bool  _mutex_initialized = false;
 
 
//#############################################################################
//#############################################################################
//#############################################################################
 
 
static void _DestroyMutex(void)
{
    if (_mutex_initialized)
    {
        mutex_destroy(&_mutex);
        _mutex_initialized = false;
    }
}
 
static bool _CreateMutex(void)
{
    if (!_mutex_initialized)
    {
        _mutex_initialized = mutex_create(&_mutex);
        if (_mutex_initialized)
        {
            atexit(_DestroyMutex);
        }
    }
    return _mutex_initialized;
}
 
static void _LockMutex(void)
{
    if (_CreateMutex())
    {
        mutex_lock(&_mutex);
    }
}
 
static void _UnlockMutex(void)
{
    if (_CreateMutex())
    {
        mutex_unlock(&_mutex);
    }
}
 
 
 
//#############################################################################
//#############################################################################
//#############################################################################
 
static UIntArray _handleList = { 0 };
 
//#############################################################################
//#############################################################################
//#############################################################################
 
 
// HandlerChain_SendMessage()
void HandlerChain_SendMessage(int windowId, Message* message)
{
    _LockMutex();
    UIntArray localList = { 0 };
    bool success = UIntArray_Copy(&_handleList, &localList);
    _UnlockMutex();
 
    if (success)
    {
        for (size_t index = 0; index < localList.length; index++)
        {
            if (windowId == -1 || windowId == (int)localList.data[index])
            {
                if (MessageWindow_ProcessMessage((int)localList.data[index], message))
                {
                    // Processing terminated
                    break;
                }
            }
        }
    }
    else
    {
        printf("  Error!  Out of memory condition copying the handler chain list in HandlerChain_SendMessage()!\n'");
    }
    UIntArray_Clear(&localList);
}
 
// HandlerChain_AddWindow()
bool HandlerChain_AddWindow(int windowId)
{
    bool success = false;
 
    _LockMutex();
    int foundIndex = UIntArray_Find(&_handleList, (uint32_t)windowId);
    if (foundIndex == -1)
    {
        success = UIntArray_AddInt(&_handleList, (uint32_t)windowId);
        if (!success)
        {
            printf("  Error!  Out of memory condition adding window handle to handler chain in HandlerChain_AddWindow()!\n");
        }
    }
    else
    {
        printf("  Error!  Unable to find window handle %d in HandlerChain_AddWindow()!\n", windowId);
    }
    _UnlockMutex();
 
    return success;
}
 
// HandlerChain_RemoveWindow()
void HandlerChain_RemoveWindow(int windowId)
{
    _LockMutex();
    int foundIndex = UIntArray_Find(&_handleList, (uint32_t)windowId);
    if (foundIndex != -1)
    {
        UIntArray_RemoveInt(&_handleList, foundIndex);
    }
    _UnlockMutex();
}
 
// HandlerChain_ToString()
bool HandlerChain_ToString(DynamicString* output)
{
    bool success = false;
 
    if (output != NULL)
    {
        _LockMutex();
        UIntArray localList = { 0 };
        success = UIntArray_Copy(&_handleList, &localList);
        _UnlockMutex();
 
        if (success)
        {
            for (size_t index = 0; index < _handleList.length; index++)
            {
                DynamicString localOutput = { 0 };
                success = MessageWindow_ToString((int)_handleList.data[index], &localOutput);
                if (success)
                {
                    success = DynamicString_Append(output, "    ");
                    if (success)
                    {
                        success = DynamicString_Append(output, localOutput.string);
                    }
                    if (success)
                    {
                        success = DynamicString_Append(output, "\n");
                    }
                }
 
                DynamicString_Clear(&localOutput);
 
                if (!success)
                {
                    printf("  Error!  Out of memory condition converting handler chain to a string!\n");
                    break;
                }
            }
        }
        else
        {
            printf("  Error!  Out of memory condition copying the handler chain in HandlerChain_ToString()!\n");
        }
        UIntArray_Clear(&localList);
    }
 
    return success;
}