Aura GUI Programmer's Guide

×

Source Code (src)

A detailed list of all documented functions, variables, defines, enums, typedefs, and data structures in the src folder.

Each file in this folder is critical for the overall functionality of the Aura GUI. Below is a detailed description and breakdown of how the functions work in the code, what they do, and how to use them.

debug.c

Provides debugging utilities for the Aura GUI. It includes functions for logging debug messages, handling errors, and providing runtime information.

Functions:
- void DebugMessage(const char* format, ...): Logs a formatted debug message.
- void HandleError(const char* errorMsg): Handles and logs error messages.
Data Structures:
- typedef struct DebugInfo: Contains information about the current debug state.

devload.asm

Assembly file for low-level device loading routines used in the Aura GUI. It handles the initialization and management of hardware devices.

Procedures:
- _start: Entry point for device loading.
- LoadDevice: Loads and initializes a device.

dms.c

Core functionalities for the Data Management System, interfacing with various data types. It manages loading, saving, and processing data.

Functions:
- void DMSInit(void): Initializes the Data Management System.
- void DMSDeInit(void): Deinitializes the Data Management System.
Data Structures:
- typedef struct DMSFile: Represents a file managed by the DMS.

dms2.c

Additional functionalities and improvements for the Data Management System. It provides extended support for more data types and operations.

Functions:
- void DMS2Init(void): Initializes the extended Data Management System.
- void DMS2DeInit(void): Deinitializes the extended Data Management System.
Data Structures:
- typedef struct DMS2File: Represents a file managed by the extended DMS.

dynld.c

Dynamic loading routines for plugins and extensions within the Aura GUI. It handles the loading and unloading of dynamic libraries.

Functions:
- void InitDynLd(void): Initializes the dynamic loading system.
- void ShutDownDynLd(void): Shuts down the dynamic loading system.
Data Structures:
- typedef struct DynLdModule: Represents a dynamically loaded module.

dynldlnk.c

Linking routines for dynamically loaded modules in the Aura GUI. It resolves symbols and handles dependencies for dynamic modules.

Functions:
- void* ResolveSymbol(void* module, const char* symbol): Resolves a symbol in a dynamic module.

error.c

Error handling routines for the Aura GUI, providing mechanisms for logging and managing errors.

Functions:
- void LogError(const char* errorMsg): Logs an error message.
- void DisplayError(const char* errorMsg): Displays an error message to the user.

events.c

Event management system for handling user interactions and system events in the Aura GUI. It processes and dispatches events to appropriate handlers.

Functions:
- void InitializeEventsSystem(void): Initializes the events system.
- void HandleEvents(void): Processes and handles events.
Data Structures:
- typedef struct Event: Represents an event in the system.

exports.c

Exports functions and symbols for use by other modules and applications within the Aura GUI.

Functions:
- void RegisterExports(void): Registers exported functions and symbols.

font.c

Font management and rendering routines for the Aura GUI. It handles loading, rendering, and managing fonts used in the GUI.

Functions:
- Font* LoadFont(const char* fontPath): Loads a font from a specified path.
- void RenderText(Font* font, const char* text, int x, int y): Renders text using a specified font.
Data Structures:
- typedef struct Font: Represents a font used in the GUI.

grfx2.c

Graphics handling routines, providing functionalities for drawing and manipulating graphical elements in the Aura GUI.

Functions:
- void DrawImage(const char* imagePath, int x, int y): Draws an image at a specified location.
- void DrawRectangle(int x, int y, int width, int height, Color color): Draws a rectangle with a specified color.
Data Structures:
- typedef struct Color: Represents a color used in graphical operations.

image.c

Image loading and manipulation functions, supporting various image formats used within the Aura GUI.

Functions:
- Image* LoadImage(const char* imagePath): Loads an image from a specified path.
- void SaveImage(const char* imagePath, Image* image): Saves an image to a specified path.
Data Structures:
- typedef struct Image: Represents an image used in the GUI.

ini.c

INI file handling routines for reading and writing configuration files.

Functions:
- void ReadINIFile(const char* iniPath, INI* ini): Reads an INI file from a specified path.
- void WriteINIFile(const char* iniPath, INI* ini): Writes an INI file to a specified path.
Data Structures:
- typedef struct INI: Represents an INI file.

keyboard.c

Keyboard input handling, providing functions to manage and process keyboard events.

Functions:
- void InstallKeyboard(void): Installs the keyboard driver.
- void HandleKeyboardEvent(Event* event): Processes a keyboard event.

list.c

List management routines, providing functionalities for managing dynamic lists of data.

Functions:
- void AddToList(List* list, void* item): Adds an item to a list.
- void RemoveFromList(List* list, void* item): Removes an item from a list.
Data Structures:
- typedef struct List: Represents a dynamic list of data.

main.c

Main entry point for the Aura GUI application, initializing the system and starting the main loop.

Functions:
- int main(int argc, char* argv[]): Main function, initializes and starts the GUI.

metrics.c

Routines for measuring and managing performance metrics within the Aura GUI.

Functions:
- void StartMetric(const char* metricName): Starts measuring a performance metric.
- void EndMetric(const char* metricName): Ends measuring a performance metric.
Data Structures:
- typedef struct Metric: Represents a performance metric.

mouse.c

Mouse input handling, providing functions to manage and process mouse events.

Functions:
- void InstallMouse(void): Installs the mouse driver.
- void HandleMouseEvent(Event* event): Processes a mouse event.

mutex.c

Mutex handling routines for managing concurrent access to resources within the Aura GUI.

Functions:
- void InitializeMutex(Mutex* mutex): Initializes a mutex.
- void LockMutex(Mutex* mutex): Locks a mutex.
Data Structures:
- typedef struct Mutex: Represents a mutex for resource synchronization.

pdcurseswrapper.h

Header file providing wrappers for PDCurses functions used in the Aura GUI.

Functions:
- void InitCurses(void): Initializes the PDCurses library.
- void EndCurses(void): Ends the PDCurses library usage.

recource.c

Resource management routines, handling the loading and management of resources such as images and fonts.

Functions:
- void LoadResource(const char* resourcePath): Loads a resource from a specified path.
- void FreeResource(void* resource): Frees a loaded resource.

registry.c

Registry management routines for handling application settings and configurations.

Functions:
- void InitializeRegistry(void): Initializes the registry system.
- void ReadRegistryValue(const char* key, char* value): Reads a value from the registry.
Data Structures:
- typedef struct RegistryEntry: Represents an entry in the registry.

resource.c

Additional resource management functionalities for the Aura GUI.

Functions:
- void AddResource(Resource* resource): Adds a resource to the system.
- void RemoveResource(Resource* resource): Removes a resource from the system.

screen.c

Screen management and rendering routines, providing functionalities for managing display output.

Functions:
- void InitializeScreen(void): Initializes the screen system.
- void RenderScreen(void): Renders the current screen.

tasks.c

Task management routines, providing functionalities for managing and scheduling tasks within the Aura GUI.

Functions:
- void CreateTask(Task* task): Creates a new task.
- void ScheduleTask(Task* task): Schedules a task for execution.
Data Structures:
- typedef struct Task: Represents a task in the system.

text.c

Text handling and rendering routines, providing functionalities for displaying and manipulating text.

Functions:
- void RenderText(const char* text, int x, int y): Renders text at a specified location.
- void SetTextColor(Color color): Sets the color of the text.

thread.c

Thread management routines, providing functionalities for creating and managing threads within the Aura GUI.

Functions:
- void CreateThread(Thread* thread): Creates a new thread.
- void JoinThread(Thread* thread): Joins a thread.
Data Structures:
- typedef struct Thread: Represents a thread in the system.

timer.c

Timer handling routines, providing functionalities for creating and managing timers within the Aura GUI.

Functions:
- void InitializeTimer(void): Initializes the timer system.
- void SetTimerInterval(int interval): Sets the interval for the timer.

utext.c

Unicode text handling routines, providing functionalities for displaying and manipulating Unicode text.

Functions:
- void RenderUnicodeText(const wchar_t* text, int x, int y): Renders Unicode text at a specified location.
- void SetUnicodeTextColor(Color color): Sets the color of the Unicode text.

vfile.c

Virtual file handling routines, providing functionalities for managing virtual file systems within the Aura GUI.

Functions:
- void CreateVirtualFile(const char* path): Creates a new virtual file.
- void DeleteVirtualFile(const char* path): Deletes a virtual file.
Data Structures:
- typedef struct VirtualFile: Represents a virtual file in the system.

win32fix.c

Windows-specific fixes and adjustments for the Aura GUI.

Functions:
- void ApplyWindowsFixes(void): Applies fixes for Windows-specific issues.

×

debug.c

Overview:

debug.c is responsible for handling debugging operations in the Aura GUI project. It includes functions to log messages, handle errors, and manage debugging information, aiding developers in tracking the flow of execution and identifying bugs.

Key Functions:

void debug_init(void): Initializes the debugging system.
void debug_log(const char *format, ...): Logs a formatted message to the debug log.
void debug_error(const char *format, ...): Logs an error message and triggers additional error handling mechanisms.
void debug_close(void): Closes the debugging system, releasing all resources.
void assert_fail(const char *expr, const char *file, int line): Handles failed assertions, providing detailed information about the failure.

Dependencies:

Standard Libraries: <stdio.h>, <stdarg.h>
Project-Specific Headers: debug.h, config.h, util.h

Sample Usage:

#include "debug.h"

void some_function() {
    debug_log("Entering some_function");
    
    int value = compute_value();
    if (value < 0) {
        debug_error("compute_value returned a negative value: %d", value);
    }
    
    debug_log("Exiting some_function");
}

Detailed Workflow:

Initialization: debug_init sets up the debugging system at program start.
Logging Events: debug_log records important events and variable values.
Error Handling: debug_error logs errors and potential issues.
Assertions: assert_fail handles conditions that should never happen, providing detailed failure information.
Cleanup: debug_close properly closes the debugging system at program end.

×

devload.asm

Overview:

devload.asm is an assembly file responsible for low-level device loading routines within the Aura GUI. It includes functions to interface directly with hardware or system-level components, providing essential services that higher-level code in the application relies on.

Key Functions:

Initialization Routines: Sets up the necessary environment for device operations.
Device Loading Functions: Loads and initializes specific devices required by the Aura GUI.
Interrupt Handlers: Handles interrupts generated by devices.
Resource Cleanup: Cleans up resources and gracefully shuts down device operations.

Dependencies:

System-Specific Libraries: Relies on the specific system's architecture and available instructions.
Project-Specific Headers and Definitions: config.h, util.h

Sample Usage:

section .data
    ; Data section for storing variables and constants
    device_status db 0

section .text
    global _start

_start:
    ; Initialization routine
    call init_devices

    ; Main loop or program execution
    call main_program

    ; Cleanup routine
    call cleanup_devices
    hlt

init_devices:
    ; Initialize system registers and hardware components
    ; Example: setup interrupt vector table
    mov ax, 0x1234
    mov ds, ax
    ; More initialization code here
    ret

main_program:
    ; Main program execution
    ; Example: load and configure a device
    call load_device
    ; More main program code here
    ret

load_device:
    ; Device loading routine
    ; Example: configure a specific hardware device
    mov dx, 0xABCD
    out dx, al
    ; More device loading code here
    ret

cleanup_devices:
    ; Cleanup routine
    ; Example: reset hardware components to safe state
    mov ax, 0x0000
    mov ds, ax
    ; More cleanup code here
    ret

Detailed Workflow:

Initialization: init_devices sets up the environment for device operations.
Main Program Execution: main_program includes the main logic and device loading.
Device Loading: load_device handles the specifics of loading and configuring devices.
Cleanup: cleanup_devices resets hardware components and frees resources.

×

dms.c

Overview:

dms.c is a critical source file within the Aura GUI that handles the core functionalities of the Data Management System (DMS). This file manages various data formats, facilitates data manipulation, and ensures efficient data storage and retrieval. It acts as an interface between the application and the underlying data storage mechanisms.

Key Functions:

Initialization Functions: Initialize the data management system, setting up necessary structures and preparing the environment for data operations.
Data Loading and Saving: Load data from various sources and save data to persistent storage.
Data Manipulation Functions: Provide operations for modifying and processing data.
Query and Search Functions: Allow querying and searching within the data managed by the DMS.
Cleanup and Shutdown: Properly release resources and shut down the data management system.

Dependencies:

Standard Libraries: <stdlib.h>, <stdio.h>, <string.h>
Project-Specific Headers: dms.h, config.h, util.h

Sample Functions:

#include "dms.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// Initialization function
void dms_init() {
    // Allocate memory and initialize data structures
    data_cache = (DataCache *)malloc(sizeof(DataCache));
    if (data_cache == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(1);
    }
    memset(data_cache, 0, sizeof(DataCache));
    // Additional initialization code here
}

// Data loading function
int dms_load_data(const char *filename) {
    FILE *file = fopen(filename, "rb");
    if (file == NULL) {
        fprintf(stderr, "Failed to open file: %s\n", filename);
        return -1;
    }
    // Read data from file and load into data structures
    fread(data_cache->buffer, sizeof(char), DATA_BUFFER_SIZE, file);
    fclose(file);
    return 0;
}

// Data saving function
int dms_save_data(const char *filename) {
    FILE *file = fopen(filename, "wb");
    if (file == NULL) {
        fprintf(stderr, "Failed to open file: %s\n", filename);
        return -1;
    }
    // Write data from structures to file
    fwrite(data_cache->buffer, sizeof(char), DATA_BUFFER_SIZE, file);
    fclose(file);
    return 0;
}

// Cleanup function
void dms_cleanup() {
    if (data_cache != NULL) {
        free(data_cache);
        data_cache = NULL;
    }
}

Detailed Workflow:

Initialization: dms_init sets up the data management system by allocating memory and initializing components.
Data Loading: dms_load_data loads data from a file into memory for further processing.
Data Manipulation: Various functions handle reading, writing, updating, and deleting data records.
Data Saving: dms_save_data saves the current state of the data to a file.
Cleanup: dms_cleanup releases resources and ensures that all data is saved properly.

Detailed Description:

dms.c provides the foundational infrastructure for managing data within the Aura GUI. It supports multiple data formats and ensures efficient data operations. Here's a more in-depth look at its components and workflows:

1. Initialization Functions

The initialization functions in dms.c are designed to prepare the system for data operations. This involves setting up memory allocations, initializing caches and buffers, and ensuring that all necessary indices are in place for quick data access.

2. Data Loading and Saving

dms.c contains functions to load data from various sources such as files, databases, or network resources. It supports different data formats including BMP, JPG, MP3, and PNG. Similarly, it includes functions to save data back to these storage systems, ensuring data persistence and integrity.

3. Data Manipulation Functions

The data manipulation functions provide the core operations for interacting with the data. This includes reading, writing, updating, and deleting data records. The functions also handle data conversion between different formats and ensure the integrity of the data during these operations.

4. Query and Search Functions

These functions allow for efficient querying and searching within the data managed by the DMS. They are optimized for performance and can handle complex queries, making it easier to retrieve specific data based on various criteria.

5. Cleanup and Shutdown

Proper resource management is crucial for the stability of the system. The cleanup functions in dms.c ensure that all allocated memory is released and that all data is saved before the system shuts down. This prevents memory leaks and data loss.

×

dms2.c

Overview:

dms2.c extends the core functionalities of the Data Management System (DMS) by adding additional features and improvements. This file focuses on enhancing data handling capabilities, optimizing performance, and integrating new data formats and functionalities.

Key Functions:

Enhanced Data Loading: Improved data loading mechanisms to support additional formats and increase efficiency.
Advanced Data Manipulation: Additional functions for more complex data operations and transformations.
Performance Optimization: Functions aimed at optimizing the speed and efficiency of data operations.
Error Handling and Logging: Improved error handling mechanisms and detailed logging for debugging purposes.
Extended Query Functions: Advanced querying capabilities to support complex data retrieval scenarios.

Dependencies:

Standard Libraries: <stdlib.h>, <stdio.h>, <string.h>
Project-Specific Headers: dms.h, dms2.h, util.h

Sample Functions:

#include "dms2.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// Enhanced data loading function
int dms2_load_data(const char *filename) {
    FILE *file = fopen(filename, "rb");
    if (file == NULL) {
        fprintf(stderr, "Failed to open file: %s\n", filename);
        return -1;
    }
    // Read and process data from file
    while (!feof(file)) {
        // Implementation of enhanced data loading
    }
    fclose(file);
    return 0;
}

// Advanced data manipulation function
void dms2_transform_data(DataStruct *data) {
    // Perform complex data transformations
    // Example: Data normalization, filtering, etc.
}

// Performance optimization function
void dms2_optimize() {
    // Implementation of performance optimizations
    // Example: Caching strategies, indexing, etc.
}

// Extended query function
DataStruct *dms2_query_data(const char *query) {
    // Implementation of advanced query logic
    // Example: SQL-like query processing
    return query_result;
}

// Improved error handling function
void dms2_handle_error(int error_code) {
    // Implementation of error handling
    // Example: Logging, retries, etc.
    fprintf(stderr, "Error: %d\n", error_code);
}

Detailed Workflow:

Enhanced Data Loading: dms2_load_data improves upon the basic loading functions by adding support for new data formats and optimizing the loading process.
Advanced Data Manipulation: dms2_transform_data provides additional capabilities for complex data transformations, such as normalization and filtering.
Performance Optimization: dms2_optimize includes strategies for improving the efficiency of data operations, such as caching and indexing.
Extended Query Functions: dms2_query_data supports more complex queries, allowing for advanced data retrieval scenarios.
Improved Error Handling: dms2_handle_error offers enhanced error handling mechanisms, including detailed logging and retry logic.

Detailed Description:

dms2.c is designed to build upon the foundational features of dms.c, adding new capabilities and optimizing existing ones. It introduces several key improvements that enhance the data management system's functionality and performance.

1. Enhanced Data Loading

The data loading functions in dms2.c support additional data formats and offer more efficient loading mechanisms. This includes optimizations for reading large datasets and handling various file types.

2. Advanced Data Manipulation

dms2.c introduces new functions for more complex data manipulations. These functions enable advanced operations such as data normalization, filtering, and transformation, which are essential for preparing data for analysis and display.

3. Performance Optimization

Performance is a critical aspect of any data management system. dms2.c includes functions designed to optimize the speed and efficiency of data operations. Techniques such as caching frequently accessed data and indexing key data fields are implemented to reduce latency and improve overall performance.

4. Extended Query Functions

The query functions in dms2.c are enhanced to support more complex data retrieval scenarios. This includes the ability to execute SQL-like queries, enabling users to retrieve specific subsets of data based on various criteria. These advanced querying capabilities make the system more versatile and powerful.

5. Improved Error Handling and Logging

Error handling is crucial for maintaining system stability and reliability. dms2.c provides improved error handling mechanisms, including detailed logging of errors and the ability to retry failed operations. These features help in diagnosing issues and ensuring that the system can recover gracefully from errors.

×

dynld.c

Overview:

dynld.c is responsible for the dynamic loading of plugins and extensions within the Aura GUI. This file contains the necessary functions to load, initialize, and manage dynamically loaded modules, allowing the system to extend its functionalities at runtime without the need for recompilation.

Key Functions:

load_module: Loads a dynamic module from a specified file path.
unload_module: Unloads a previously loaded dynamic module.
get_symbol: Retrieves a symbol (function or variable) from a loaded module.
initialize_module: Initializes a loaded module, preparing it for use.
list_loaded_modules: Lists all currently loaded modules.

Dependencies:

Standard Libraries: <stdlib.h>, <stdio.h>, <string.h>
Dynamic Loading Libraries: <dlfcn.h> (for Unix-based systems) or equivalent for other platforms
Project-Specific Headers: dynld.h, module.h

Sample Functions:

#include "dynld.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>

static void *module_handle = NULL;

// Load a dynamic module
int load_module(const char *path) {
    module_handle = dlopen(path, RTLD_LAZY);
    if (!module_handle) {
        fprintf(stderr, "Failed to load module: %s\n", dlerror());
        return -1;
    }
    return 0;
}

// Unload a dynamic module
void unload_module() {
    if (module_handle) {
        dlclose(module_handle);
        module_handle = NULL;
    }
}

// Retrieve a symbol from the loaded module
void *get_symbol(const char *symbol) {
    if (!module_handle) {
        fprintf(stderr, "Module not loaded\n");
        return NULL;
    }
    return dlsym(module_handle, symbol);
}

// Initialize a loaded module
int initialize_module() {
    void (*init_func)();
    init_func = (void (*)())get_symbol("module_init");
    if (init_func) {
        init_func();
        return 0;
    }
    return -1;
}

// List all loaded modules (simplified example)
void list_loaded_modules() {
    if (module_handle) {
        printf("Module loaded: %p\n", module_handle);
    } else {
        printf("No modules loaded.\n");
    }
}

Detailed Workflow:

Loading Modules: load_module uses the dlopen function to load a shared library (dynamic module) from a specified path.
Unloading Modules: unload_module releases the resources associated with the loaded module using the dlclose function.
Retrieving Symbols: get_symbol utilizes the dlsym function to retrieve the address of a symbol (function or variable) within the loaded module.
Initializing Modules: initialize_module looks for an initialization function (e.g., module_init) within the module and calls it to set up the module for use.
Listing Loaded Modules: list_loaded_modules provides a simple way to list currently loaded modules (for demonstration purposes).

Detailed Description:

dynld.c plays a crucial role in the Aura GUI by enabling the dynamic extension of the system's capabilities through plugins and modules. The file leverages dynamic loading libraries, such as dlfcn.h, to load and manage these modules at runtime.

1. Loading Modules

The load_module function is the entry point for loading a dynamic module. It uses the dlopen function to load the specified shared library file. If successful, the handle to the loaded module is stored for further operations.

2. Unloading Modules

The unload_module function ensures that any loaded module is properly unloaded and its resources are released. This is important to prevent memory leaks and ensure that modules can be reloaded or replaced if needed.

3. Retrieving Symbols

The get_symbol function allows the system to access specific functions or variables within the loaded module. By using dlsym, the function retrieves the address of the requested symbol, enabling dynamic function calls and variable access.

4. Initializing Modules

After loading a module, the initialize_module function attempts to locate and call the module's initialization function (commonly named module_init). This step is essential to prepare the module for operation, as it may set up necessary resources or state.

5. Listing Loaded Modules

The list_loaded_modules function provides a simple way to list currently loaded modules. In a more advanced implementation, this function could return detailed information about each loaded module, such as its name, version, and status.

×

dynldlnk.c

Overview:

dynldlnk.c is responsible for the linking routines for dynamically loaded modules in the Aura GUI. This file contains the necessary functions to manage the linking of symbols and dependencies between dynamically loaded modules, ensuring proper integration and functionality.

Key Functions:

resolve_symbols: Resolves and links symbols required by a dynamically loaded module.
check_dependencies: Checks for and ensures that all dependencies of a module are satisfied before linking.
register_module: Registers a newly loaded module with the system, making its symbols available for linking.
unregister_module: Unregisters a module, removing its symbols from the system.
get_module_info: Retrieves information about a loaded module, such as its symbols and dependencies.

Dependencies:

Standard Libraries: <stdlib.h>, <stdio.h>, <string.h>
Dynamic Loading Libraries: <dlfcn.h> (for Unix-based systems) or equivalent for other platforms
Project-Specific Headers: dynldlnk.h, module.h

Sample Functions:

#include "dynldlnk.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>

static void *module_handle = NULL;
static char **resolved_symbols = NULL;

// Resolve and link symbols required by a module
int resolve_symbols(const char *module_name) {
    // Implementation for resolving and linking symbols
    // This is a simplified example and should include error handling
    // and specific symbol resolution logic
    return 0;
}

// Check for and ensure all dependencies are satisfied
int check_dependencies(const char *module_name) {
    // Implementation for checking module dependencies
    // This is a simplified example and should include specific dependency checks
    return 0;
}

// Register a newly loaded module
int register_module(const char *module_name) {
    // Implementation for registering a module
    // This is a simplified example and should include proper registration logic
    return 0;
}

// Unregister a module
void unregister_module(const char *module_name) {
    // Implementation for unregistering a module
    // This is a simplified example and should include proper unregistration logic
}

// Retrieve information about a loaded module
void get_module_info(const char *module_name) {
    // Implementation for retrieving module information
    // This is a simplified example and should include logic to fetch and display module info
}

Detailed Workflow:

Resolving Symbols: resolve_symbols handles the process of locating and linking required symbols for a module, ensuring that all necessary functions and variables are properly connected.
Checking Dependencies: check_dependencies ensures that a module's dependencies are satisfied before it is linked and used, preventing runtime errors and missing symbols.
Registering Modules: register_module makes a newly loaded module available for use by registering its symbols with the system, allowing other modules to link to it.
Unregistering Modules: unregister_module removes a module from the system, making its symbols unavailable and ensuring that resources are properly released.
Retrieving Module Information: get_module_info provides details about a loaded module, such as its symbols and dependencies, helping with debugging and module management.

Detailed Description:

dynldlnk.c is an essential component of the Aura GUI, enabling the dynamic linking of symbols and management of dependencies for dynamically loaded modules. This file ensures that modules can be integrated smoothly into the system, providing the necessary functionality without requiring recompilation.

1. Resolving Symbols

The resolve_symbols function is crucial for ensuring that all required symbols for a module are available and properly linked. This step prevents runtime errors due to missing functions or variables and ensures that the module operates correctly.

2. Checking Dependencies

The check_dependencies function verifies that all dependencies of a module are satisfied before linking it. This step is essential for preventing issues that may arise from missing or incompatible dependencies, ensuring that the module can function as intended.

3. Registering Modules

When a new module is loaded, the register_module function registers it with the system. This process makes the module's symbols available for linking by other modules, facilitating the dynamic extension of the system's capabilities.

4. Unregistering Modules

The unregister_module function removes a module from the system, releasing its resources and making its symbols unavailable. This step is important for maintaining system stability and preventing resource leaks when modules are no longer needed.

5. Retrieving Module Information

The get_module_info function provides detailed information about a loaded module, including its symbols and dependencies. This information is valuable for debugging, module management, and ensuring that all necessary components are correctly integrated.

×

error.c

Overview:

error.c is responsible for error handling routines within the Aura GUI. This file provides the mechanisms for logging, managing, and displaying errors, ensuring robust error management and debugging capabilities.

Key Functions:

log_error: Logs an error message to a file or console for later review.
display_error: Displays an error message to the user through the GUI.
handle_error: Centralized error handling function that logs and displays errors.
clear_error_log: Clears the error log file.
get_last_error: Retrieves the last logged error message.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: error.h, gui.h

Sample Functions:

#include "error.h"
#include "gui.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char last_error[256];

// Logs an error message to a file or console
void log_error(const char *message) {
    FILE *logfile = fopen("error.log", "a");
    if (logfile) {
        fprintf(logfile, "%s\n", message);
        fclose(logfile);
    }
    strncpy(last_error, message, sizeof(last_error) - 1);
}

// Displays an error message to the user through the GUI
void display_error(const char *message) {
    // Example: Displaying the error message using a GUI dialog
    show_gui_message("Error", message);
}

// Centralized error handling function
void handle_error(const char *message) {
    log_error(message);
    display_error(message);
}

// Clears the error log file
void clear_error_log() {
    FILE *logfile = fopen("error.log", "w");
    if (logfile) {
        fclose(logfile);
    }
}

// Retrieves the last logged error message
const char* get_last_error() {
    return last_error;
}

Detailed Workflow:

Logging Errors: log_error writes error messages to a log file or console, preserving them for later review and debugging.
Displaying Errors: display_error shows error messages to the user through the GUI, providing immediate feedback on issues.
Centralized Error Handling: handle_error combines logging and displaying errors into a single function for streamlined error management.
Clearing Error Logs: clear_error_log resets the error log file, removing all previously logged messages.
Retrieving Last Error: get_last_error returns the most recently logged error message, aiding in debugging and diagnostics.

Detailed Description:

error.c is a critical component of the Aura GUI, providing robust error handling capabilities. By centralizing error management functions, this file ensures that errors are consistently logged and displayed, aiding both users and developers in identifying and resolving issues.

1. Logging Errors

The log_error function writes error messages to a log file or console, preserving them for future reference. This step is essential for debugging, as it allows developers to track and review error occurrences over time.

2. Displaying Errors

The display_error function shows error messages to the user through the GUI, providing immediate feedback on issues. This step helps users understand what went wrong and can guide them in taking corrective actions.

3. Centralized Error Handling

The handle_error function combines logging and displaying errors into a single call, simplifying error management. By using this centralized function, developers can ensure that all errors are properly logged and communicated to the user.

4. Clearing Error Logs

The clear_error_log function resets the error log file, removing all previously logged messages. This step is useful for maintaining a clean log and removing old or irrelevant errors.

5. Retrieving Last Error

The get_last_error function returns the most recently logged error message, aiding in debugging and diagnostics. By retrieving the last error, developers can quickly identify the most recent issue and work on resolving it.

×

events.c

Overview:

events.c is responsible for managing and handling events within the Aura GUI. This file provides mechanisms to capture, process, and dispatch events such as user interactions, system events, and application-specific events.

Key Functions:

initialize_event_system: Initializes the event system, setting up necessary data structures and resources.
register_event_handler: Registers an event handler for a specific type of event.
unregister_event_handler: Unregisters an event handler, stopping it from receiving events.
dispatch_event: Dispatches an event to the appropriate event handler.
process_events: Processes the event queue, handling each event in turn.
shutdown_event_system: Shuts down the event system, releasing resources and cleaning up.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: events.h, gui.h, system.h

Sample Functions:

#include "events.h"
#include "gui.h"
#include "system.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static EventQueue event_queue;

void initialize_event_system() {
    // Initialize event queue and other necessary structures
    event_queue_init(&event_queue);
}

void register_event_handler(EventType type, EventHandler handler) {
    // Register an event handler for a specific type of event
    event_queue_register_handler(&event_queue, type, handler);
}

void unregister_event_handler(EventType type, EventHandler handler) {
    // Unregister an event handler
    event_queue_unregister_handler(&event_queue, type, handler);
}

void dispatch_event(Event *event) {
    // Dispatch an event to the appropriate handler
    event_queue_dispatch(&event_queue, event);
}

void process_events() {
    // Process all events in the queue
    event_queue_process(&event_queue);
}

void shutdown_event_system() {
    // Shutdown the event system and clean up resources
    event_queue_cleanup(&event_queue);
}

Detailed Workflow:

Initialization: initialize_event_system sets up the event system, preparing it to handle events.
Event Registration: register_event_handler and unregister_event_handler manage the registration and unregistration of event handlers.
Event Dispatching: dispatch_event sends events to the appropriate handlers.
Event Processing: process_events handles the queued events, processing them one by one.
Shutdown: shutdown_event_system cleans up the event system, releasing resources.

Detailed Description:

events.c is a critical component for the Aura GUI, enabling the system to respond to various events and interactions. By managing event registration, dispatch, and processing, this file ensures a responsive and interactive user experience.

1. Initialization

The initialize_event_system function sets up the event system, initializing the event queue and other necessary data structures. This preparation is essential for handling events efficiently.

2. Event Registration

Functions register_event_handler and unregister_event_handler manage the registration and unregistration of event handlers. These handlers are functions that respond to specific types of events, allowing for customized behavior in response to user actions or system changes.

3. Event Dispatching

The dispatch_event function sends events to the appropriate handlers. When an event occurs, this function ensures that the correct handler processes the event, enabling the system to respond appropriately.

4. Event Processing

The process_events function handles all events in the queue, processing them one by one. This function ensures that events are handled in the order they occur, maintaining a consistent and predictable behavior.

5. Shutdown

The shutdown_event_system function cleans up the event system, releasing resources and ensuring a clean shutdown. This step is crucial for preventing resource leaks and maintaining system stability.

×

exports.c

Overview:

exports.c is responsible for defining and managing the functions and symbols that are exported for use by other modules and applications within the Aura GUI. This file ensures that the necessary functions are available for external use, facilitating modularity and extensibility.

Key Functions:

initialize_exports: Initializes the export system, setting up necessary data structures and resources.
register_export: Registers a function or symbol for export, making it available for external use.
unregister_export: Unregisters a function or symbol, removing it from the list of available exports.
get_export: Retrieves the address of an exported function or symbol by name.
shutdown_exports: Shuts down the export system, releasing resources and cleaning up.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: exports.h, system.h

Sample Functions:

#include "exports.h"
#include "system.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static ExportTable export_table;

void initialize_exports() {
    // Initialize export table and other necessary structures
    export_table_init(&export_table);
}

void register_export(const char *name, void *address) {
    // Register a function or symbol for export
    export_table_register(&export_table, name, address);
}

void unregister_export(const char *name) {
    // Unregister a function or symbol
    export_table_unregister(&export_table, name);
}

void *get_export(const char *name) {
    // Retrieve the address of an exported function or symbol by name
    return export_table_get(&export_table, name);
}

void shutdown_exports() {
    // Shutdown the export system and clean up resources
    export_table_cleanup(&export_table);
}

Detailed Workflow:

Initialization: initialize_exports sets up the export system, preparing it to handle function and symbol exports.
Export Registration: register_export and unregister_export manage the registration and unregistration of exports.
Export Retrieval: get_export retrieves the address of an exported function or symbol by name.
Shutdown: shutdown_exports cleans up the export system, releasing resources.

Detailed Description:

exports.c is a critical component for the Aura GUI, enabling the system to define and manage functions and symbols that are available for external use. This modular approach allows other parts of the application or even third-party modules to access and utilize these exports, facilitating a more flexible and extensible system.

1. Initialization

The initialize_exports function sets up the export system, initializing the export table and other necessary data structures. This preparation is essential for managing exports efficiently.

2. Export Registration

Functions register_export and unregister_export manage the registration and unregistration of functions and symbols for export. By registering exports, these functions become accessible to other parts of the system or external modules.

3. Export Retrieval

The get_export function retrieves the address of an exported function or symbol by name. This function enables other parts of the system or external modules to dynamically access the exported functions and symbols.

4. Shutdown

The shutdown_exports function cleans up the export system, releasing resources and ensuring a clean shutdown. This step is crucial for preventing resource leaks and maintaining system stability.

×

font.c

Overview:

font.c handles font management and rendering within the Aura GUI. It provides functionalities for loading, managing, and rendering different fonts, enabling the display of text in various styles and sizes.

Key Functions:

load_font: Loads a font from a file and prepares it for use in the GUI.
render_text: Renders text on the screen using a specified font.
unload_font: Unloads a font and releases associated resources.
set_font_size: Sets the size of the font for rendering text.
get_font_metrics: Retrieves metrics for a given font, such as height and width of characters.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: font.h, graphics.h
Third-Party Libraries: FreeType (for font rendering)

Sample Functions:

#include "font.h"
#include "graphics.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static FontManager font_manager;

Font* load_font(const char* filename) {
    // Load a font from a file using FreeType library
    return font_manager_load(&font_manager, filename);
}

void render_text(Font* font, const char* text, int x, int y) {
    // Render text on the screen at the specified coordinates
    font_manager_render_text(&font_manager, font, text, x, y);
}

void unload_font(Font* font) {
    // Unload the font and free associated resources
    font_manager_unload(&font_manager, font);
}

void set_font_size(Font* font, int size) {
    // Set the size of the font
    font_manager_set_size(&font_manager, font, size);
}

FontMetrics get_font_metrics(Font* font) {
    // Retrieve font metrics such as character height and width
    return font_manager_get_metrics(&font_manager, font);
}

Detailed Workflow:

Loading Fonts: load_font loads a font from a file, preparing it for rendering.
Rendering Text: render_text renders text on the screen using the specified font and coordinates.
Unloading Fonts: unload_font unloads a font, freeing the associated resources.
Setting Font Size: set_font_size sets the font size for rendering text.
Retrieving Font Metrics: get_font_metrics retrieves metrics for a given font, such as the height and width of characters.

Detailed Description:

font.c is integral to the Aura GUI as it provides the capabilities to manage and render fonts. Proper font management allows for a consistent and customizable user interface, enabling text to be displayed in various styles and sizes according to user preferences and application needs.

1. Loading Fonts

The load_font function utilizes the FreeType library to load font files. This function reads the font data from the specified file and prepares it for rendering. Proper error handling ensures that any issues with loading the font file are managed gracefully.

2. Rendering Text

The render_text function is responsible for drawing text on the screen. It takes a font, the text to be rendered, and the coordinates where the text should be displayed. This function leverages the graphics rendering capabilities provided by the graphics.h library to draw the text.

3. Unloading Fonts

The unload_font function releases the resources associated with a font when it is no longer needed. This ensures efficient memory management and prevents resource leaks.

4. Setting Font Size

The set_font_size function allows for changing the size of the font dynamically. This is useful for applications that need to display text in different sizes, such as headings, subheadings, and body text.

5. Retrieving Font Metrics

The get_font_metrics function provides detailed information about the font's characteristics, including the height and width of characters. This information is crucial for layout calculations and ensuring that text is displayed correctly within the GUI.

×

grfx2.c

Overview:

grfx2.c is responsible for handling advanced graphics operations within the Aura GUI. It provides functionalities for drawing and manipulating graphical elements such as lines, shapes, images, and effects, enabling rich visual content in the user interface.

Key Functions:

draw_line: Draws a line between two points on the screen.
draw_rectangle: Draws a rectangle on the screen with specified dimensions and properties.
draw_circle: Draws a circle with a given radius at specified coordinates.
draw_image: Renders an image at specified coordinates on the screen.
apply_effect: Applies visual effects such as blur or color adjustment to a graphical element.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <math.h>
Project-Specific Headers: graphics.h, image.h
Third-Party Libraries: Allegro (for graphics operations)

Sample Functions:

#include "graphics.h"
#include "image.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void draw_line(int x1, int y1, int x2, int y2, Color color) {
    // Code to draw a line using Allegro library functions
}

void draw_rectangle(int x, int y, int width, int height, Color color) {
    // Code to draw a rectangle
}

void draw_circle(int x, int y, int radius, Color color) {
    // Code to draw a circle
}

void draw_image(Image* img, int x, int y) {
    // Code to render an image on the screen
}

void apply_effect(Image* img, Effect effect) {
    // Code to apply visual effects to an image
}

Detailed Workflow:

Drawing Lines: draw_line uses graphics library functions to draw lines between two points, with specified colors and styles.
Drawing Rectangles: draw_rectangle renders rectangles, useful for UI elements like buttons and borders.
Drawing Circles: draw_circle creates circular shapes, often used for icons and graphical indicators.
Rendering Images: draw_image places images on the screen, handling positioning and scaling.
Applying Effects: apply_effect modifies graphical elements with visual effects, enhancing the GUI's appearance.

Detailed Description:

grfx2.c plays a crucial role in the Aura GUI by providing advanced graphics capabilities. The functions defined in this file enable the creation and manipulation of various graphical elements, contributing to a visually appealing and interactive user interface.

1. Drawing Lines

The draw_line function is fundamental for creating straight lines between two points. It supports different colors and line styles, making it versatile for various UI components such as dividers, borders, and connectors.

2. Drawing Rectangles

The draw_rectangle function is used to draw rectangles, which are essential for UI elements like buttons, panels, and frames. The function allows specifying the position, dimensions, and color of the rectangle, providing flexibility in UI design.

3. Drawing Circles

The draw_circle function creates circular shapes at specified coordinates with a given radius. Circles are often used for icons, buttons, and graphical indicators within the GUI.

4. Rendering Images

The draw_image function renders images on the screen. It handles positioning and can include scaling and transformation features, making it a core function for displaying visual content such as icons, backgrounds, and illustrations.

5. Applying Effects

The apply_effect function adds visual effects to graphical elements. Effects such as blurring, color adjustments, and shadowing can be applied, enhancing the aesthetic quality of the GUI and providing visual feedback to user interactions.

×

image.c

Overview:

image.c is responsible for handling image loading, manipulation, and rendering in the Aura GUI. It provides functions for working with various image formats, including loading images from files, performing basic image operations, and displaying images on the screen.

Key Functions:

load_image: Loads an image from a specified file path.
save_image: Saves an image to a specified file path.
resize_image: Resizes an image to specified dimensions.
crop_image: Crops an image to specified dimensions.
draw_image: Draws an image at specified coordinates on the screen.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: image.h, graphics.h
Third-Party Libraries: libpng (for PNG images), libjpeg (for JPEG images)

Sample Functions:

#include "image.h"
#include "graphics.h"
#include <stdio.h>
#include <stdlib.h>

Image* load_image(const char* filepath) {
    // Code to load an image from a file
}

void save_image(Image* img, const char* filepath) {
    // Code to save an image to a file
}

Image* resize_image(Image* img, int new_width, int new_height) {
    // Code to resize an image
}

Image* crop_image(Image* img, int x, int y, int width, int height) {
    // Code to crop an image
}

void draw_image(Image* img, int x, int y) {
    // Code to draw an image on the screen
}

Detailed Workflow:

Loading Images: load_image reads image data from a file and creates an Image object in memory.
Saving Images: save_image writes image data to a file, supporting various image formats.
Resizing Images: resize_image changes the dimensions of an image, maintaining aspect ratio if needed.
Cropping Images: crop_image extracts a portion of an image based on specified coordinates and dimensions.
Drawing Images: draw_image renders an image at specified coordinates on the screen.

Detailed Description:

image.c is a critical component of the Aura GUI, enabling the application to handle and display images effectively. It supports various image formats and provides essential functions for manipulating and rendering images within the user interface.

1. Loading Images

The load_image function reads image data from a file, creating an Image object that can be used within the application. It supports multiple image formats, utilizing libraries like libpng and libjpeg for PNG and JPEG images, respectively.

2. Saving Images

The save_image function writes an Image object to a file, allowing users to save modified or generated images. It ensures compatibility with various image formats, providing flexibility in how images are stored and shared.

3. Resizing Images

The resize_image function changes the dimensions of an image. It can maintain the aspect ratio to prevent distortion, making it useful for creating thumbnails or adjusting images to fit specific areas of the GUI.

4. Cropping Images

The crop_image function extracts a specified portion of an image, defined by coordinates and dimensions. This is useful for focusing on a specific part of an image or removing unwanted areas.

5. Drawing Images

The draw_image function renders an image on the screen at specified coordinates. It handles positioning and can include scaling and transformation features, making it essential for displaying visual content such as icons, backgrounds, and illustrations.

×

ini.c

Overview:

ini.c is responsible for handling INI file operations within the Aura GUI. It provides functions for reading from and writing to INI files, which are commonly used for configuration and settings management. The INI file format is simple and consists of sections, keys, and values.

Key Functions:

ini_read: Reads a value from an INI file given a section and key.
ini_write: Writes a value to an INI file under a specified section and key.
ini_delete: Deletes a key from an INI file.
ini_load: Loads an INI file into memory for fast access.
ini_save: Saves the in-memory representation of an INI file back to disk.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: ini.h

Sample Functions:

#include "ini.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* ini_read(const char* filename, const char* section, const char* key) {
    // Code to read a value from an INI file
}

int ini_write(const char* filename, const char* section, const char* key, const char* value) {
    // Code to write a value to an INI file
}

int ini_delete(const char* filename, const char* section, const char* key) {
    // Code to delete a key from an INI file
}

INIFile* ini_load(const char* filename) {
    // Code to load an INI file into memory
}

int ini_save(INIFile* ini) {
    // Code to save an INI file from memory to disk
}

Detailed Workflow:

Reading from INI Files: ini_read locates the specified section and key in the INI file and returns the corresponding value.
Writing to INI Files: ini_write updates the INI file with the specified value under the given section and key. If the section or key does not exist, it creates them.
Deleting from INI Files: ini_delete removes the specified key from the INI file.
Loading INI Files: ini_load reads the entire INI file into memory, allowing for faster access and modifications.
Saving INI Files: ini_save writes the in-memory representation of the INI file back to disk, ensuring all changes are persisted.

Detailed Description:

ini.c is a fundamental part of the Aura GUI, providing essential functionality for managing configuration settings through INI files. These files are human-readable and easy to edit, making them a popular choice for configuration management.

1. Reading from INI Files

The ini_read function allows the application to retrieve configuration settings stored in INI files. It searches for the specified section and key and returns the corresponding value. This is useful for loading settings during application startup or when changes are needed.

2. Writing to INI Files

The ini_write function enables the application to update or add new settings to INI files. It ensures that configuration changes made within the application are saved and persist across sessions. If the specified section or key does not exist, it creates them, making the function versatile for various use cases.

3. Deleting from INI Files

The ini_delete function allows the application to remove specific keys from INI files. This is useful for cleaning up obsolete or temporary settings, ensuring the configuration files remain organized and relevant.

4. Loading INI Files

The ini_load function reads the entire INI file into memory, creating a structure that allows for fast access and modifications. This is particularly useful for applications that frequently read and update settings, as it reduces the need to repeatedly read from disk.

5. Saving INI Files

The ini_save function writes the in-memory representation of the INI file back to disk. This ensures that all changes made to the configuration settings are persisted, providing a reliable mechanism for saving updates.

×

keyboard.c

Overview:

keyboard.c is responsible for handling keyboard input within the Aura GUI. It provides functions for detecting key presses, processing keyboard events, and managing keyboard states. This module is crucial for user interactions, allowing the application to respond to user inputs efficiently.

Key Functions:

keyboard_init: Initializes the keyboard input system.
keyboard_poll: Polls the keyboard for current key states.
keyboard_is_key_pressed: Checks if a specific key is currently pressed.
keyboard_get_key_state: Retrieves the state of a specific key.
keyboard_update: Updates the keyboard state based on recent events.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: keyboard.h
External Libraries: Allegro or other input handling libraries

Sample Functions:

#include "keyboard.h"
#include <stdio.h>
#include <stdlib.h>

void keyboard_init() {
    // Code to initialize the keyboard system
}

void keyboard_poll() {
    // Code to poll the keyboard for key states
}

int keyboard_is_key_pressed(int keycode) {
    // Code to check if a specific key is pressed
}

int keyboard_get_key_state(int keycode) {
    // Code to get the state of a specific key
}

void keyboard_update() {
    // Code to update the keyboard state
}

Detailed Workflow:

Initializing Keyboard System: keyboard_init sets up the necessary structures and configurations for handling keyboard input.
Polling Keyboard: keyboard_poll checks the current state of the keyboard, updating internal structures with the latest key states.
Checking Key Presses: keyboard_is_key_pressed allows the application to query if a specific key is currently pressed.
Retrieving Key States: keyboard_get_key_state provides the current state of a specific key, useful for more complex input handling.
Updating Keyboard State: keyboard_update processes recent keyboard events, ensuring the internal state reflects the latest user inputs.

Detailed Description:

keyboard.c is an essential module in the Aura GUI, enabling the application to handle user input through the keyboard effectively. It provides a set of functions that allow for initializing the keyboard system, polling for key states, checking key presses, retrieving key states, and updating the internal keyboard state based on recent events.

1. Initializing Keyboard System

The keyboard_init function sets up the necessary structures and configurations for handling keyboard input. This includes initializing any external libraries (e.g., Allegro) and preparing the application to start receiving keyboard events.

2. Polling Keyboard

The keyboard_poll function checks the current state of the keyboard and updates internal structures with the latest key states. This is typically called in the main loop of the application to ensure the keyboard state is always up-to-date.

3. Checking Key Presses

The keyboard_is_key_pressed function allows the application to query if a specific key is currently pressed. This is useful for implementing immediate responses to user inputs, such as character movement in a game or triggering specific actions in the GUI.

4. Retrieving Key States

The keyboard_get_key_state function provides the current state of a specific key. This can be used for more complex input handling, such as checking for key combinations or handling key hold events.

5. Updating Keyboard State

The keyboard_update function processes recent keyboard events and updates the internal state to reflect the latest user inputs. This ensures the application responds correctly to user actions and maintains accurate input handling.

×

list.c

Overview:

list.c is responsible for managing dynamic lists of data within the Aura GUI. It provides functions for creating, manipulating, and traversing lists. This module is essential for handling collections of items, such as elements in a GUI or data structures used in various applications.

Key Functions:

list_create: Initializes a new list.
list_add: Adds an item to the list.
list_remove: Removes an item from the list.
list_get: Retrieves an item from the list by index.
list_size: Returns the number of items in the list.
list_clear: Clears all items from the list.
list_destroy: Frees the memory allocated for the list.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: list.h

Sample Functions:

#include "list.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct ListNode {
    void *data;
    struct ListNode *next;
} ListNode;

typedef struct List {
    ListNode *head;
    int size;
} List;

List *list_create() {
    List *list = (List *)malloc(sizeof(List));
    list->head = NULL;
    list->size = 0;
    return list;
}

void list_add(List *list, void *data) {
    ListNode *node = (ListNode *)malloc(sizeof(ListNode));
    node->data = data;
    node->next = list->head;
    list->head = node;
    list->size++;
}

void list_remove(List *list, void *data) {
    ListNode *current = list->head;
    ListNode *previous = NULL;

    while (current != NULL) {
        if (current->data == data) {
            if (previous == NULL) {
                list->head = current->next;
            } else {
                previous->next = current->next;
            }
            free(current);
            list->size--;
            return;
        }
        previous = current;
        current = current->next;
    }
}

void *list_get(List *list, int index) {
    if (index < 0 || index >= list->size) {
        return NULL;
    }
    ListNode *current = list->head;
    for (int i = 0; i < index; i++) {
        current = current->next;
    }
    return current->data;
}

int list_size(List *list) {
    return list->size;
}

void list_clear(List *list) {
    ListNode *current = list->head;
    while (current != NULL) {
        ListNode *next = current->next;
        free(current);
        current = next;
    }
    list->head = NULL;
    list->size = 0;
}

void list_destroy(List *list) {
    list_clear(list);
    free(list);
}

Detailed Workflow:

Creating a List: list_create initializes a new list, allocating the necessary memory and setting up the initial structure.
Adding Items: list_add adds an item to the list, creating a new node and inserting it at the head of the list.
Removing Items: list_remove removes an item from the list by searching for the node containing the data and updating pointers to exclude the node from the list.
Retrieving Items: list_get retrieves an item from the list by its index, traversing the list to find the specified node.
Checking List Size: list_size returns the number of items currently in the list.
Clearing the List: list_clear removes all items from the list, freeing the memory allocated for each node.
Destroying the List: list_destroy frees all memory allocated for the list and its nodes, effectively deleting the list.

Detailed Description:

list.c is a fundamental module in the Aura GUI for managing collections of items. It provides a set of functions that allow for creating, adding, removing, retrieving, and managing dynamic lists of data. Each list is implemented as a linked list, with nodes containing pointers to the data and the next node in the list.

1. Creating a List

The list_create function initializes a new list, allocating memory for the list structure and setting the head to NULL and size to 0. This prepares the list for subsequent operations.

2. Adding Items

The list_add function adds a new item to the list. It creates a new node, sets the node's data to the provided data, and inserts the node at the head of the list. The list's size is incremented accordingly.

3. Removing Items

The list_remove function removes an item from the list by searching for the node containing the specified data. Once found, the node is removed by updating the previous node's next pointer to skip the removed node. The memory allocated for the removed node is then freed, and the list's size is decremented.

4. Retrieving Items

The list_get function retrieves an item from the list by its index. It traverses the list, starting from the head, until it reaches the specified index. The function then returns the data of the node at that index.

5. Checking List Size

The list_size function returns the number of items currently in the list. This is useful for determining the length of the list or for iterating through the list's items.

6. Clearing the List

The list_clear function removes all items from the list. It traverses the list, freeing the memory allocated for each node and setting the head to NULL and size to 0. This effectively empties the list.

7. Destroying the List

The list_destroy function frees all memory allocated for the list and its nodes. It first calls list_clear to remove all items, then frees the memory allocated for the list structure itself. This deletes the list and prevents memory leaks.

×

main.c

Overview:

main.c serves as the entry point for the Aura GUI application. It is responsible for initializing the system, setting up the main window, and starting the main event loop. This file orchestrates the initialization of various subsystems and ensures the application runs smoothly.

Key Functions:

main: The main function that serves as the entry point of the application.
_SystemInit: Initializes various system components and subsystems.
SystemEventHandler: Handles system events, delegating specific tasks based on the event type.
render_thread: A thread function dedicated to rendering widgets.
event_thread: A thread function dedicated to handling events.
InitScheduler: Initializes the thread scheduler and multitasking system.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: allegro.h, types.h, thread.h, kernel.h, dynld.h, internal.h, widget.h, menu.h

Detailed Workflow:

System Initialization: The _SystemInit function initializes various system components and subsystems. This includes setting up the dynamic loader, virtual file system, registry, text manipulation, events system, and hardware drivers.
Event Handling: The SystemEventHandler function handles various system events, such as keyboard shortcuts for launching applications or taking screenshots. It delegates event processing to the _SystemEventHandler function for more specific handling.
Multithreading: The render_thread and event_thread functions are responsible for rendering widgets and handling events, respectively. These functions run in separate threads, allowing for concurrent processing of rendering and events.
Scheduler Initialization: The InitScheduler function initializes the thread scheduler and multitasking system. It prepares the application to create and manage multiple threads.
Main Event Loop: The main function sets up the kernel mode, initializes the system, creates rendering and event handling threads, and starts the main event loop. This loop ensures the application remains responsive to user inputs and system events.

Detailed Description:

1. System Initialization

The _SystemInit function is responsible for setting up various system components. This includes initializing the dynamic loader, virtual file system, registry, text manipulation, events system, and hardware drivers. Proper initialization is essential for the smooth operation of the application.

2. Event Handling

The SystemEventHandler function handles system events, such as keyboard shortcuts for launching applications or taking screenshots. It processes events based on their type and delegates specific tasks to the _SystemEventHandler function for more detailed handling.

3. Multithreading

The render_thread and event_thread functions are responsible for rendering widgets and handling events, respectively. These functions run in separate threads, allowing for concurrent processing of rendering and events. This approach ensures a responsive user interface.

4. Scheduler Initialization

The InitScheduler function initializes the thread scheduler and multitasking system. It prepares the application to create and manage multiple threads. Proper scheduler initialization is crucial for effective multitasking.

5. Main Event Loop

The main function sets up the kernel mode based on command-line arguments, initializes the system, creates rendering and event handling threads, and starts the main event loop. This loop ensures the application remains responsive to user inputs and system events, handling tasks such as polling the system for events and yielding control to other threads.

Overall Flow:

The main function in main.c begins by setting the kernel mode based on command-line arguments. It then calls _SystemInit to set up the necessary components for the application. The function creates and starts the rendering and event handling threads before entering the main event loop, which keeps the application running by continuously processing events.

Proper initialization and event handling ensure a responsive and stable application, while multithreading allows for concurrent processing of rendering and events.

×

metrics.c

Overview:

The `metrics.c` file is responsible for measuring and managing performance metrics within the Aura GUI. This includes gathering data on various aspects of the system's performance, which can be used for monitoring, debugging, and optimizing the application.

Key Functions:

InitMetrics: Initializes the metrics system.
RecordMetric: Records a specific performance metric.
GetMetrics: Retrieves the collected metrics data.
PrintMetrics: Prints the metrics data for analysis.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: metrics.h

Detailed Workflow:

Initialization: The InitMetrics function sets up the metrics system, preparing it to collect data.
Recording Metrics: The RecordMetric function records a specific performance metric, storing the data for later analysis.
Retrieving Metrics: The GetMetrics function retrieves the collected metrics data, allowing other parts of the system to access performance information.
Printing Metrics: The PrintMetrics function prints the collected metrics data, providing a detailed overview of the system's performance.

Detailed Description:

1. Initialization

The InitMetrics function initializes the metrics system, setting up the necessary structures and preparing the system to collect performance data. This function is typically called during system startup.

2. Recording Metrics

The RecordMetric function records specific performance metrics, such as CPU usage, memory usage, and response times. This data is stored in a structured format for later retrieval and analysis.

3. Retrieving Metrics

The GetMetrics function retrieves the collected metrics data, allowing other parts of the system to access performance information. This function is useful for monitoring and debugging purposes.

4. Printing Metrics

The PrintMetrics function prints the collected metrics data, providing a detailed overview of the system's performance. This information can be used for analysis and optimization, helping developers identify and address performance bottlenecks.

Overall Flow:

The metrics.c file plays a crucial role in measuring and managing the performance of the Aura GUI. By collecting and analyzing performance data, developers can gain insights into the system's behavior and make informed decisions to optimize and improve the application.

×

mouse.c

Overview:

The `mouse.c` file handles mouse input within the Aura GUI. It is responsible for managing mouse events, such as movements, button clicks, and wheel scrolling. This file ensures that mouse interactions are properly captured and processed by the system, allowing for seamless user input.

Key Functions:

InitMouse: Initializes the mouse input system.
HandleMouseEvent: Processes individual mouse events.
GetMouseState: Retrieves the current state of the mouse.
SetMouseCursor: Sets the mouse cursor to a specified image.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: mouse.h, events.h, screen.h

Detailed Workflow:

Initialization: The InitMouse function sets up the mouse input system, ensuring that mouse events can be captured and processed.
Event Handling: The HandleMouseEvent function processes individual mouse events, such as movements and button clicks, updating the system's state accordingly.
State Retrieval: The GetMouseState function retrieves the current state of the mouse, providing information on the mouse's position and button states.
Cursor Management: The SetMouseCursor function sets the mouse cursor to a specified image, allowing for custom cursor graphics.

Detailed Description:

1. Initialization

The InitMouse function initializes the mouse input system. This function sets up the necessary structures and configurations to capture and process mouse events. It is typically called during system startup to ensure that mouse input is ready for use.

2. Event Handling

The HandleMouseEvent function processes individual mouse events, such as movements, button clicks, and wheel scrolling. This function updates the system's state based on the mouse's actions, ensuring that the user interface responds appropriately to mouse input.

3. State Retrieval

The GetMouseState function retrieves the current state of the mouse. This includes information on the mouse's position, button states, and wheel position. This function is useful for querying the mouse's state at any given time, allowing the system to respond to user input.

4. Cursor Management

The SetMouseCursor function sets the mouse cursor to a specified image. This allows for custom cursor graphics, enhancing the user experience by providing visual feedback that matches the application's design.

Overall Flow:

The mouse.c file is essential for managing mouse input within the Aura GUI. By handling mouse events and maintaining the mouse's state, this file ensures that user interactions are captured and processed accurately, providing a smooth and responsive user experience.

×

resource.c

Overview:

The `resource.c` file handles the management of resources within the Aura GUI. This includes loading, accessing, and managing various types of resources such as images, fonts, and other data required by the GUI. It ensures that resources are efficiently loaded and available for use throughout the application.

Key Functions:

LoadResource: Loads a resource from a specified file path.
GetResource: Retrieves a loaded resource by its identifier.
FreeResource: Frees a loaded resource from memory.
InitResourceSystem: Initializes the resource management system.
ShutdownResourceSystem: Shuts down the resource management system, freeing all resources.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: resource.h, memory.h, debug.h

Detailed Workflow:

Initialization: The InitResourceSystem function sets up the resource management system, preparing it to load and manage resources.
Loading Resources: The LoadResource function loads a resource from a specified file path and stores it in memory.
Accessing Resources: The GetResource function retrieves a previously loaded resource by its identifier.
Freeing Resources: The FreeResource function frees a loaded resource from memory, ensuring efficient memory usage.
Shutdown: The ShutdownResourceSystem function frees all loaded resources and shuts down the resource management system.

Detailed Description:

1. Initialization

The InitResourceSystem function initializes the resource management system. This function sets up the necessary structures and configurations to manage resources efficiently. It is typically called during system startup to ensure that the resource system is ready for use.

2. Loading Resources

The LoadResource function loads a resource from a specified file path. This function reads the resource data from the file and stores it in memory, making it available for use by the application. It returns a handle or identifier that can be used to access the resource later.

3. Accessing Resources

The GetResource function retrieves a previously loaded resource by its identifier. This function allows the application to access the resource data when needed, ensuring that resources are used efficiently and effectively.

4. Freeing Resources

The FreeResource function frees a loaded resource from memory. This function ensures that resources are released when they are no longer needed, preventing memory leaks and ensuring efficient memory usage.

5. Shutdown

The ShutdownResourceSystem function frees all loaded resources and shuts down the resource management system. This function is typically called during system shutdown to ensure that all resources are properly released and the system is cleaned up.

Overall Flow:

The resource.c file is crucial for managing resources within the Aura GUI. By handling the loading, accessing, and freeing of resources, this file ensures that the application can efficiently use the necessary data, providing a smooth and responsive user experience.

×

registry.c

Overview:

The `registry.c` file is responsible for managing the configuration settings and system registry for the Aura GUI. This includes reading from, writing to, and maintaining the integrity of the registry, which stores various configuration parameters and settings used by the GUI and its applications.

Key Functions:

InitRegistry: Initializes the registry system, preparing it for use.
ReadRegistry: Reads a value from the registry given a key.
WriteRegistry: Writes a value to the registry under a specified key.
DeleteRegistryKey: Deletes a key and its associated value from the registry.
ShutdownRegistry: Shuts down the registry system, ensuring all data is properly saved.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: registry.h, memory.h, debug.h

Detailed Workflow:

Initialization: The InitRegistry function sets up the registry system, creating necessary data structures and loading initial values.
Reading Values: The ReadRegistry function retrieves values from the registry using specified keys, allowing the system to access configuration settings.
Writing Values: The WriteRegistry function stores values in the registry under specified keys, updating the configuration settings.
Deleting Keys: The DeleteRegistryKey function removes keys and their associated values from the registry, allowing for cleanup and removal of outdated settings.
Shutdown: The ShutdownRegistry function ensures that all registry data is saved and the system is properly shut down, preventing data loss.

Detailed Description:

1. Initialization

The InitRegistry function initializes the registry system. This function sets up the necessary data structures and loads initial values from a persistent storage, such as a file or database. It ensures that the registry is ready to handle read and write operations.

2. Reading Values

The ReadRegistry function retrieves values from the registry using specified keys. This function allows the system and applications to access configuration settings stored in the registry. It returns the value associated with the given key, or a default value if the key is not found.

3. Writing Values

The WriteRegistry function stores values in the registry under specified keys. This function updates the configuration settings in the registry, allowing the system and applications to save their state and preferences. It ensures that the new value is associated with the given key, overwriting any previous value.

4. Deleting Keys

The DeleteRegistryKey function removes keys and their associated values from the registry. This function allows for cleanup and removal of outdated or unnecessary settings, ensuring that the registry remains organized and efficient.

5. Shutdown

The ShutdownRegistry function ensures that all registry data is saved and the system is properly shut down. This function writes any unsaved changes to persistent storage, such as a file or database, preventing data loss and maintaining the integrity of the registry.

Overall Flow:

The registry.c file is crucial for managing configuration settings within the Aura GUI. By handling the reading, writing, and deleting of registry values, this file ensures that the system can efficiently store and access configuration parameters, providing a flexible and customizable user experience.

×

resource.c

Overview:

The `resource.c` file handles the management of resources within the Aura GUI. This includes loading, accessing, and managing various types of resources such as images, fonts, and other data required by the GUI. It ensures that resources are efficiently loaded and available for use throughout the application.

Key Functions:

LoadResource: Loads a resource from a specified file path.
GetResource: Retrieves a loaded resource by its identifier.
FreeResource: Frees a loaded resource from memory.
InitResourceSystem: Initializes the resource management system.
ShutdownResourceSystem: Shuts down the resource management system, freeing all resources.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: resource.h, memory.h, debug.h

Detailed Workflow:

Initialization: The InitResourceSystem function sets up the resource management system, preparing it to load and manage resources.
Loading Resources: The LoadResource function loads a resource from a specified file path and stores it in memory.
Accessing Resources: The GetResource function retrieves a previously loaded resource by its identifier.
Freeing Resources: The FreeResource function frees a loaded resource from memory, ensuring efficient memory usage.
Shutdown: The ShutdownResourceSystem function frees all loaded resources and shuts down the resource management system.

Detailed Description:

1. Initialization

The InitResourceSystem function initializes the resource management system. This function sets up the necessary structures and configurations to manage resources efficiently. It is typically called during system startup to ensure that the resource system is ready for use.

2. Loading Resources

The LoadResource function loads a resource from a specified file path. This function reads the resource data from the file and stores it in memory, making it available for use by the application. It returns a handle or identifier that can be used to access the resource later.

3. Accessing Resources

The GetResource function retrieves a previously loaded resource by its identifier. This function allows the application to access the resource data when needed, ensuring that resources are used efficiently and effectively.

4. Freeing Resources

The FreeResource function frees a loaded resource from memory. This function ensures that resources are released when they are no longer needed, preventing memory leaks and ensuring efficient memory usage.

5. Shutdown

The ShutdownResourceSystem function frees all loaded resources and shuts down the resource management system. This function is typically called during system shutdown to ensure that all resources are properly released and the system is cleaned up.

Overall Flow:

The resource.c file is crucial for managing resources within the Aura GUI. By handling the loading, accessing, and freeing of resources, this file ensures that the application can efficiently use the necessary data, providing a smooth and responsive user experience.

×

screen.c

Overview:

The `screen.c` file is responsible for managing the screen and display functionalities within the Aura GUI. This includes initializing the screen, handling screen updates, and managing the drawing and rendering of graphical elements.

Key Functions:

GSSystemScreenInit: Initializes the screen system, setting up the display mode and screen buffers.
GSSystemScreenQuit: Shuts down the screen system, releasing any allocated resources.
ScreenUpdate: Updates the screen, rendering any changes made to the graphical elements.
ScreenClear: Clears the screen, preparing it for new drawings.
DrawPixel: Draws a single pixel on the screen at specified coordinates.
DrawLine: Draws a line between two points on the screen.
DrawRect: Draws a rectangle on the screen with specified dimensions and color.
DrawBitmap: Draws a bitmap image on the screen at specified coordinates.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: screen.h, graphics.h, debug.h

Detailed Workflow:

Initialization: The GSSystemScreenInit function sets up the screen system, configuring the display mode and initializing screen buffers.
Updating Screen: The ScreenUpdate function renders any changes made to the screen, ensuring that the display reflects the current state of the graphical elements.
Clearing Screen: The ScreenClear function clears the screen, preparing it for new drawings and preventing artifacts from previous frames.
Drawing Functions: Functions like DrawPixel, DrawLine, DrawRect, and DrawBitmap handle the rendering of basic graphical elements on the screen.
Shutdown: The GSSystemScreenQuit function releases any resources allocated by the screen system, ensuring a clean shutdown.

Detailed Description:

1. Initialization

The GSSystemScreenInit function initializes the screen system. It configures the display mode, sets up screen buffers, and prepares the system for rendering graphical elements. This function ensures that the screen is ready to display the user interface and other graphical components.

2. Updating Screen

The ScreenUpdate function renders any changes made to the screen. This function iterates through the graphical elements and updates the display to reflect their current state. It ensures that the user sees the most recent changes and interactions with the GUI.

3. Clearing Screen

The ScreenClear function clears the screen, removing any previous drawings and preparing it for new graphical elements. This function helps prevent artifacts from previous frames and ensures a clean slate for rendering new content.

4. Drawing Functions

The drawing functions handle the rendering of basic graphical elements on the screen:

DrawPixel: Draws a single pixel at specified coordinates.
DrawLine: Draws a line between two points.
DrawRect: Draws a rectangle with specified dimensions and color.
DrawBitmap: Draws a bitmap image at specified coordinates.

5. Shutdown

The GSSystemScreenQuit function releases any resources allocated by the screen system. This function ensures a clean shutdown, freeing memory and other resources used by the screen system.

Overall Flow:

The screen.c file is crucial for managing the display and rendering functionalities within the Aura GUI. By handling screen initialization, updates, clearing, and drawing, this file ensures that the graphical user interface is rendered correctly and efficiently, providing a smooth and responsive user experience.

×

tasks.c

Overview:

The `tasks.c` file is responsible for managing task scheduling and execution within the Aura GUI. It handles the creation, management, and scheduling of tasks, ensuring efficient multitasking and resource allocation.

Key Functions:

InitScheduler: Initializes the task scheduler, setting up necessary data structures and configurations for task management.
NewTask: Creates a new task, adding it to the scheduler's task list and setting up its initial state.
KillTask: Terminates a task, removing it from the scheduler's task list and freeing any associated resources.
ScheduleTasks: The main scheduling function that determines which task to run next based on priority and state.
Yield: A function that allows a task to voluntarily relinquish the CPU, enabling other tasks to run.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: tasks.h, kernel.h, debug.h

Detailed Workflow:

Initialization: The InitScheduler function sets up the task scheduler, initializing necessary data structures and configurations for managing tasks.
Creating Tasks: The NewTask function creates a new task, setting up its initial state and adding it to the scheduler's task list.
Scheduling Tasks: The ScheduleTasks function determines which task to run next based on priority and state. It ensures fair and efficient allocation of CPU time among tasks.
Yielding: The Yield function allows a task to voluntarily relinquish the CPU, enabling other tasks to run. This function helps in achieving cooperative multitasking.
Terminating Tasks: The KillTask function terminates a task, removing it from the scheduler's task list and freeing any associated resources.

Detailed Description:

1. Initialization

The InitScheduler function initializes the task scheduler. It sets up necessary data structures and configurations for managing tasks, ensuring that the system is ready to handle task scheduling and execution efficiently.

2. Creating Tasks

The NewTask function creates a new task. It sets up the task's initial state, including its stack, registers, and priority. The new task is then added to the scheduler's task list, making it eligible for execution.

3. Scheduling Tasks

The ScheduleTasks function is the main scheduling f

×

text.c

Overview:

The `text.c` file is responsible for handling text rendering and manipulation in the Aura GUI. It provides various functions for managing fonts, rendering text on the screen, and performing text-related operations.

Key Functions:

InitText: Initializes the text handling subsystem, setting up necessary data structures and configurations.
FontLoad: Loads a font from a file, returning a handle to the loaded font.
TextOut: Renders text on the screen at a specified position using a specified font.
TextWidth: Calculates the width of a given text string when rendered with a specified font.
TextHeight: Calculates the height of a given text string when rendered with a specified font.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: text.h, font.h, graphics.h

Detailed Workflow:

Initialization: The InitText function initializes the text handling subsystem, setting up necessary data structures and configurations for text rendering and manipulation.
Loading Fonts: The FontLoad function loads a font from a file, returning a handle to the loaded font. This handle can be used for rendering text with the specified font.
Rendering Text: The TextOut function renders text on the screen at a specified position using a specified font. It takes parameters for the font, text string, position, and color.
Calculating Text Dimensions: The TextWidth and TextHeight functions calculate the width and height of a given text string when rendered with a specified font. These functions are useful for layout calculations and text alignment.

Detailed Description:

1. Initialization

The InitText function initializes the text handling subsystem. It sets up necessary data structures and configurations for managing fonts and rendering text. This function is called during the system initialization process.

2. Loading Fonts

The FontLoad function loads a font from a file. It takes the file path as a parameter and returns a handle to the loaded font. This handle can be used for rendering text with the specified font. The function ensures that the font is loaded correctly and is ready for use.

3. Rendering Text

The TextOut function renders text on the screen at a specified position using a specified font. It takes parameters for the font handle, text string, x and y coordinates, and color. This function is used to display text on the screen, allowing for various font styles and colors.

4. Calculating Text Dimensions

The TextWidth and TextHeight functions calculate the width and height of a given text string when rendered with a specified font. These functions are useful for layout calculations and text alignment, ensuring that text fits within designated areas on the screen.

Overall Flow:

The text.c file is essential for handling text rendering and manipulation in the Aura GUI. By providing functions for initializing the text subsystem, loading fonts, rendering text, and calculating text dimensions, this file enables the display of text with various styles and layouts, enhancing the user interface and user experience.

×

thread.c

Overview:

The `thread.c` file is responsible for managing multithreading in the Aura GUI. It provides functions for creating, managing, and synchronizing threads, allowing the system to perform concurrent operations efficiently.

Key Functions:

InitScheduler: Initializes the thread scheduler, setting up necessary data structures for managing threads.
NewThread: Creates a new thread, assigning it a function to execute and allocating necessary resources.
Yield: Allows the current thread to yield control, enabling other threads to run.
ThreadId: Returns the identifier of the current thread.
Scheduler: Manages the execution of threads, ensuring fair and efficient use of CPU resources.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: thread.h, kernel.h, internal.h

Detailed Workflow:

Initialization: The InitScheduler function initializes the thread scheduler, setting up necessary data structures for managing threads. It prepares the system for multithreading operations.
Creating Threads: The NewThread function creates a new thread, assigning it a function to execute and allocating necessary resources. It registers the new thread with the scheduler.
Yielding Control: The Yield function allows the current thread to yield control, enabling other threads to run. It is essential for cooperative multitasking.
Getting Thread ID: The ThreadId function returns the identifier of the current thread. This identifier can be used for thread-specific operations and debugging.
Scheduling Threads: The Scheduler function manages the execution of threads, ensuring fair and efficient use of CPU resources. It switches between threads based on their priorities and states.

Detailed Description:

1. Initialization

The InitScheduler function initializes the thread scheduler. It sets up necessary data structures for managing threads, such as the thread queue and the current thread pointer. This function is called during the system initialization process.

2. Creating Threads

The NewThread function creates a new thread. It takes a function pointer, arguments, stack size, and priority as parameters. This function allocates necessary resources for the new thread, registers it with the scheduler, and starts its execution.

3. Yielding Control

The Yield function allows the current thread to yield control. This function is essential for cooperative multitasking, enabling other threads to run. When a thread yields, the scheduler selects another thread to execute.

4. Getting Thread ID

The ThreadId function returns the identifier of the current thread. This identifier can be used for thread-specific operations, such as synchronization and debugging. It helps in identifying and managing individual threads.

5. Scheduling Threads

The Scheduler function manages the execution of threads. It ensures fair and efficient use of CPU resources by switching between threads based on their priorities and states. The scheduler is responsible for maintaining the overall performance and responsiveness of the system.

Overall Flow:

The thread.c file is crucial for managing multithreading in the Aura GUI. By providing functions for initializing the scheduler, creating threads, yielding control, getting thread IDs, and scheduling threads, this file enables the system to perform concurrent operations efficiently. It enhances the performance and responsiveness of the GUI by allowing multiple tasks to run simultaneously.

×

timer.c

Overview:

The `timer.c` file is responsible for managing timers within the Aura GUI. It provides functions for creating, starting, stopping, and handling timers, which are essential for performing time-based operations in the system.

Key Functions:

InitTimer: Initializes the timer system, setting up necessary data structures and configuring hardware timers.
StartTimer: Starts a timer with a specified interval and callback function.
StopTimer: Stops a running timer.
TimerHandler: The callback function that is called when a timer expires.
GetTime: Returns the current system time.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <time.h>
Project-Specific Headers: timer.h, kernel.h

Detailed Workflow:

Initialization: The InitTimer function initializes the timer system. It sets up necessary data structures, configures hardware timers, and registers the timer interrupt handler.
Starting a Timer: The StartTimer function starts a timer with a specified interval and callback function. It configures the timer hardware to generate an interrupt after the specified interval.
Stopping a Timer: The StopTimer function stops a running timer. It disables the timer hardware and removes the timer from the list of active timers.
Handling Timer Expiry: The TimerHandler function is the callback function that is called when a timer expires. It performs the necessary actions and schedules the next timer interrupt if needed.
Getting the Current Time: The GetTime function returns the current system time. It is used for time-based operations and calculating elapsed time.

Detailed Description:

1. Initialization

The InitTimer function initializes the timer system. It sets up necessary data structures, configures hardware timers, and registers the timer interrupt handler. This function is called during the system initialization process.

2. Starting a Timer

The StartTimer function starts a timer with a specified interval and callback function. It configures the timer hardware to generate an interrupt after the specified interval. The callback function is called when the timer expires.

3. Stopping a Timer

The StopTimer function stops a running timer. It disables the timer hardware and removes the timer from the list of active timers. This function is used to cancel a timer before it expires.

4. Handling Timer Expiry

The TimerHandler function is the callback function that is called when a timer expires. It performs the necessary actions, such as updating the system state or triggering an event, and schedules the next timer interrupt if needed.

5. Getting the Current Time

The GetTime function returns the current system time. It is used for time-based operations and calculating elapsed time. This function provides a consistent and accurate way to get the current time within the system.

Overall Flow:

The timer.c file is crucial for managing timers within the Aura GUI. By providing functions for initializing the timer system, starting and stopping timers, handling timer expiry, and getting the current time, this file enables the system to perform time-based operations efficiently. Timers are essential for various functionalities, such as scheduling tasks, measuring time intervals, and triggering events at specific times.

×

utext.c

Overview:

The `utext.c` file handles Unicode text manipulation within the Aura GUI. It provides functions for encoding, decoding, and processing Unicode text, ensuring proper display and handling of various character sets.

Key Functions:

InitUText: Initializes the Unicode text system, setting up necessary data structures and configurations.
EncodeUTF8: Encodes a Unicode string into UTF-8 format.
DecodeUTF8: Decodes a UTF-8 encoded string into a Unicode format.
EncodeUTF16: Encodes a Unicode string into UTF-16 format.
DecodeUTF16: Decodes a UTF-16 encoded string into a Unicode format.
ConvertToUnicode: Converts a given text from a specified encoding to Unicode.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: utext.h, kernel.h

Detailed Workflow:

Initialization: The InitUText function initializes the Unicode text system. It sets up necessary data structures and configurations for handling Unicode text within the system.
Encoding and Decoding: The file provides functions for encoding and decoding Unicode text. EncodeUTF8 and DecodeUTF8 handle UTF-8 encoding and decoding, while EncodeUTF16 and DecodeUTF16 handle UTF-16 encoding and decoding.
Conversion: The ConvertToUnicode function converts a given text from a specified encoding to Unicode, ensuring proper handling and display of various character sets.

Detailed Description:

1. Initialization

The InitUText function initializes the Unicode text system. It sets up necessary data structures and configurations for handling Unicode text within the system. This function is called during the system initialization process to ensure proper handling of Unicode text.

2. Encoding and Decoding

The EncodeUTF8 and DecodeUTF8 functions handle the encoding and decoding of Unicode text in UTF-8 format. These functions ensure that Unicode text is properly encoded and decoded for storage and display.

The EncodeUTF16 and DecodeUTF16 functions handle the encoding and decoding of Unicode text in UTF-16 format. These functions are essential for handling Unicode text in environments that use UTF-16 encoding.

3. Conversion

The ConvertToUnicode function converts a given text from a specified encoding to Unicode. This function ensures that text from various encodings is properly converted to Unicode for consistent handling and display within the system.

Overall Flow:

The utext.c file is crucial for handling Unicode text within the Aura GUI. By providing functions for initializing the Unicode text system, encoding and decoding Unicode text, and converting text to Unicode, this file ensures proper handling and display of various character sets. Proper Unicode text handling is essential for supporting internationalization and ensuring that text is displayed correctly in different languages and scripts.

×

vfile.c

Overview:

The `vfile.c` file manages virtual file handling within the Aura GUI. It provides an abstraction layer for handling files, allowing the system to interact with virtual files seamlessly as if they were physical files. This file is crucial for the efficient and flexible management of files within the Aura GUI.

Key Functions:

VFileOpen: Opens a virtual file for reading or writing.
VFileClose: Closes an open virtual file.
VFileRead: Reads data from a virtual file.
VFileWrite: Writes data to a virtual file.
VFileSeek: Moves the file pointer to a specified location within a virtual file.
VFileTell: Returns the current position of the file pointer within a virtual file.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: vfile.h, kernel.h

Detailed Workflow:

Opening and Closing Files: The VFileOpen function is used to open a virtual file for reading or writing. The VFileClose function closes an open virtual file, ensuring that all resources are properly released.
Reading and Writing Data: The VFileRead and VFileWrite functions handle the reading and writing of data to and from virtual files. These functions ensure that data is correctly transferred between the virtual file and the system.
File Positioning: The VFileSeek function moves the file pointer to a specified location within a virtual file, while the VFileTell function returns the current position of the file pointer. These functions are essential for navigating within virtual files.

Detailed Description:

1. Opening and Closing Files

The VFileOpen function opens a virtual file for reading or writing. It takes the file name and mode as arguments and returns a file handle that can be used for subsequent operations on the file. The VFileClose function closes an open virtual file, ensuring that all associated resources are properly released. These functions are essential for managing the lifecycle of virtual files.

2. Reading and Writing Data

The VFileRead function reads data from a virtual file into a buffer. It takes the file handle, buffer, size, and count as arguments and returns the number of items successfully read. The VFileWrite function writes data from a buffer to a virtual file. It takes the file handle, buffer, size, and count as arguments and returns the number of items successfully written. These functions ensure the correct transfer of data between the virtual file and the system.

3. File Positioning

The VFileSeek function moves the file pointer to a specified location within a virtual file. It takes the file handle, offset, and origin as arguments and returns the result of the seek operation. The VFileTell function returns the current position of the file pointer within a virtual file. It takes the file handle as an argument and returns the current file pointer position. These functions are essential for navigating within virtual files.

Overall Flow:

The `vfile.c` file is crucial for managing virtual files within the Aura GUI. By providing functions for opening, closing, reading, writing, and positioning within virtual files, this file ensures the efficient and flexible management of files within the system. Proper virtual file handling is essential for the seamless interaction with files and the overall performance of the Aura GUI.

×

win32fix.c

Overview:

The `win32fix.c` file contains Windows-specific fixes and adjustments for the Aura GUI. It addresses various compatibility issues and optimizes the GUI to work seamlessly on Windows platforms.

Key Functions:

Win32Init: Initializes Windows-specific settings and resources.
Win32Cleanup: Cleans up and releases Windows-specific resources.
Win32HandleEvent: Handles Windows-specific events and messages.

Dependencies:

Standard Libraries: <windows.h>, <stdio.h>
Project-Specific Headers: win32fix.h, kernel.h

Detailed Workflow:

Initialization: The Win32Init function initializes Windows-specific settings and resources. It configures the environment to ensure that the Aura GUI operates correctly on Windows platforms.
Event Handling: The Win32HandleEvent function processes Windows-specific events and messages. It ensures that the GUI responds appropriately to user interactions and system events.
Cleanup: The Win32Cleanup function releases Windows-specific resources and performs necessary cleanup tasks when the GUI is shutting down.

Detailed Description:

1. Initialization

The Win32Init function is responsible for initializing Windows-specific settings and resources. It configures the necessary environment and ensures that the GUI operates correctly on Windows platforms. This function is called during the startup process to set up the Windows-specific components.

2. Event Handling

The Win32HandleEvent function processes Windows-specific events and messages. It ensures that the GUI responds appropriately to user interactions and system events. This function is called whenever a Windows-specific event occurs, allowing the GUI to handle the event correctly and provide a seamless user experience.

3. Cleanup

The Win32Cleanup function is responsible for releasing Windows-specific resources and performing necessary cleanup tasks when the GUI is shutting down. It ensures that all resources are properly released and that the system is left in a clean state. This function is called during the shutdown process to clean up the Windows-specific components.

Overall Flow:

The `win32fix.c` file is crucial for ensuring that the Aura GUI operates correctly on Windows platforms. By providing functions for initialization, event handling, and cleanup, this file addresses various compatibility issues and optimizes the GUI for Windows. Proper handling of Windows-specific fixes and adjustments is essential for the seamless operation of the Aura GUI on Windows platforms.

×

button.c

Overview:

The `button.c` file implements functionalities related to button widgets in the Aura GUI. It provides mechanisms to create, draw, and manage buttons, allowing user interactions within the graphical user interface.

Key Functions:

CreateButton: Initializes and configures a button widget.
DrawButton: Renders the button widget on the screen.
HandleButtonEvent: Manages events and interactions for the button widget.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, events.h, iwidget.h

Detailed Workflow:

Initialization: Use the CreateButton function to initialize and configure a button widget.
Rendering: Use the DrawButton function to render the button widget on the screen.
Event Handling: Use the HandleButtonEvent function to manage user interactions with the button.

Example Usage:

#include "widget.h"
#include "events.h"
#include "iwidget.h"

// Function to create and display a window with a button
void ShowWindowWithButton() {
    // Create a window
    Window* window = CreateWindow("Example Window", 100, 100, 400, 300);

    // Create a button
    Button* button = CreateButton("Click Me", 150, 150, 100, 50);

    // Add the button to the window
    AddWidgetToWindow(window, button);

    // Draw the window
    DrawWindow(window);

    // Main event loop
    while (window->isVisible) {
        // Handle events
        HandleEvents();

        // Check for button click
        if (button->isClicked) {
            printf("Button clicked!\n");
            button->isClicked = false;
        }
    }

    // Cleanup
    DestroyButton(button);
    DestroyWindow(window);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Show the window with a button
    ShowWindowWithButton();

    // Main application loop
    while (1) {
        HandleEvents();
    }

    return 0;
}

Detailed Description:

1. Initialization

The CreateButton function initializes and configures a button widget. It sets the button's label, position, and dimensions. The function returns a pointer to the created button widget, which can be customized further if needed.

2. Rendering

The DrawButton function renders the button widget on the screen. It draws the button, including its label, and ensures it is visible to the user.

3. Event Handling

The HandleButtonEvent function manages events and interactions for the button widget. It handles user interactions, such as button clicks, and triggers the appropriate actions based on user input.

Example Workflow:

In the example provided, the ShowWindowWithButton function demonstrates the complete workflow of creating a window and adding a button to it. It initializes the window and button, adds the button to the window, and enters the main event loop to handle user interactions. When the button is clicked, a message is printed to the console, and the button's clicked state is reset.

Integration with iwidget and widgets system:

The button widget in `button.c` integrates with the `iwidget` and `widgets` system to provide a consistent interface for creating and managing GUI elements. The `CreateButton` function uses `iwidget` functions to initialize the button, while `DrawButton` and `HandleButtonEvent` leverage the `widgets` system to render and manage interactions.

×

canvas.c

Overview:

The `canvas.c` file provides functionalities for creating and managing drawable canvas areas within the Aura GUI. It allows for custom drawing operations, making it possible to render graphics, shapes, and other visual elements dynamically.

Key Functions:

CreateCanvas: Initializes and configures a canvas widget.
DrawCanvas: Renders the canvas widget on the screen.
UpdateCanvas: Updates the canvas with new drawings or changes.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, graphics.h, iwidget.h

Detailed Workflow:

Initialization: Use the CreateCanvas function to initialize and configure a canvas widget.
Rendering: Use the DrawCanvas function to render the canvas widget on the screen.
Updating: Use the UpdateCanvas function to refresh the canvas with new drawings or changes.

Example Usage:

#include "widget.h"
#include "graphics.h"
#include "iwidget.h"

// Function to create and display a window with a canvas
void ShowWindowWithCanvas() {
    // Create a window
    Window* window = CreateWindow("Example Window", 100, 100, 400, 300);

    // Create a canvas
    Canvas* canvas = CreateCanvas(50, 50, 300, 200);

    // Add the canvas to the window
    AddWidgetToWindow(window, canvas);

    // Draw the window
    DrawWindow(window);

    // Main event loop
    while (window->isVisible) {
        // Handle events
        HandleEvents();

        // Update the canvas with custom drawings
        UpdateCanvas(canvas, [](Graphics* g) {
            // Drawing operations
            SetColor(g, COLOR_RED);
            DrawRectangle(g, 10, 10, 100, 50);
            SetColor(g, COLOR_BLUE);
            DrawLine(g, 0, 0, 300, 200);
        });

        // Render the updated canvas
        DrawCanvas(canvas);
    }

    // Cleanup
    DestroyCanvas(canvas);
    DestroyWindow(window);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Show the window with a canvas
    ShowWindowWithCanvas();

    // Main application loop
    while (1) {
        HandleEvents();
    }

    return 0;
}

Detailed Description:

1. Initialization

The CreateCanvas function initializes and configures a canvas widget. It sets the canvas's position and dimensions, and prepares it for drawing operations. The function returns a pointer to the created canvas widget, which can be customized further if needed.

2. Rendering

The DrawCanvas function renders the canvas widget on the screen. It draws the canvas, including any graphical elements that have been added to it, ensuring it is visible to the user.

3. Updating

The UpdateCanvas function refreshes the canvas with new drawings or changes. It takes a callback function that receives a Graphics object, allowing custom drawing operations to be performed on the canvas.

Example Workflow:

In the example provided, the ShowWindowWithCanvas function demonstrates the complete workflow of creating a window and adding a canvas to it. It initializes the window and canvas, adds the canvas to the window, and enters the main event loop to handle user interactions. The UpdateCanvas function is used to perform custom drawing operations on the canvas, such as drawing a red rectangle and a blue line. The updated canvas is then rendered on the screen.

Integration with iwidget and widgets system:

The canvas widget in `canvas.c` integrates with the `iwidget` and `widgets` system to provide a consistent interface for creating and managing GUI elements. The CreateCanvas function uses `iwidget` functions to initialize the canvas, while DrawCanvas and UpdateCanvas leverage the `widgets` system to render and manage the canvas and its graphical content.

×

checkbox.c

Overview:

The `checkbox.c` file provides functionalities for creating and managing checkbox widgets within the Aura GUI. It allows for interactive checkbox elements that users can toggle on or off.

Key Functions:

CreateCheckbox: Initializes and configures a checkbox widget.
DrawCheckbox: Renders the checkbox widget on the screen.
HandleCheckboxEvent: Handles events related to the checkbox, such as toggling its state.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, graphics.h, iwidget.h

Detailed Workflow:

Initialization: Use the CreateCheckbox function to initialize and configure a checkbox widget.
Rendering: Use the DrawCheckbox function to render the checkbox widget on the screen.
Event Handling: Use the HandleCheckboxEvent function to manage interactions with the checkbox.

Example Usage:

#include "widget.h"
#include "graphics.h"
#include "iwidget.h"

// Function to create and display a window with a checkbox
void ShowWindowWithCheckbox() {
    // Create a window
    Window* window = CreateWindow("Example Window", 100, 100, 400, 300);

    // Create a checkbox
    Checkbox* checkbox = CreateCheckbox(50, 50, "Enable feature");

    // Add the checkbox to the window
    AddWidgetToWindow(window, checkbox);

    // Draw the window
    DrawWindow(window);

    // Main event loop
    while (window->isVisible) {
        // Handle events
        HandleEvents();

        // Render the checkbox
        DrawCheckbox(checkbox);
    }

    // Cleanup
    DestroyCheckbox(checkbox);
    DestroyWindow(window);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Show the window with a checkbox
    ShowWindowWithCheckbox();

    // Main application loop
    while (1) {
        HandleEvents();
    }

    return 0;
}

Detailed Description:

1. Initialization

The CreateCheckbox function initializes and configures a checkbox widget. It sets the checkbox's position and label, and prepares it for interaction. The function returns a pointer to the created checkbox widget, which can be customized further if needed.

2. Rendering

The DrawCheckbox function renders the checkbox widget on the screen. It draws the checkbox, including its label and current state (checked or unchecked), ensuring it is visible to the user.

3. Event Handling

The HandleCheckboxEvent function manages interactions with the checkbox, such as toggling its state when clicked. It updates the checkbox's state and triggers any associated actions or callbacks.

Example Workflow:

In the example provided, the ShowWindowWithCheckbox function demonstrates the complete workflow of creating a window and adding a checkbox to it. It initializes the window and checkbox, adds the checkbox to the window, and enters the main event loop to handle user interactions. The DrawCheckbox function is used to render the checkbox on the screen, while the main event loop handles interactions with the checkbox.

Integration with iwidget and widgets system:

The checkbox widget in `checkbox.c` integrates with the `iwidget` and `widgets` systems to provide a consistent interface for creating and managing GUI elements. The CreateCheckbox function uses `iwidget` functions to initialize the checkbox, while DrawCheckbox and HandleCheckboxEvent leverage the `widgets` system to render and manage the checkbox and its interactions.

×

colsel.c

Overview:

The `colsel.c` file provides functionalities for creating and managing color selection dialogs within the Aura GUI. It allows users to choose colors from a color palette, which can be used in various parts of the application.

Key Functions:

CreateColorSelector: Initializes and configures a color selection dialog.
DrawColorSelector: Renders the color selection dialog on the screen.
HandleColorSelectorEvent: Handles events related to the color selector, such as selecting a color.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, graphics.h, iwidget.h

Detailed Workflow:

Initialization: Use the CreateColorSelector function to initialize and configure a color selection dialog.
Rendering: Use the DrawColorSelector function to render the color selection dialog on the screen.
Event Handling: Use the HandleColorSelectorEvent function to manage interactions with the color selector.

Example Usage:

#include "widget.h"
#include "graphics.h"
#include "iwidget.h"

// Function to create and display a window with a color selector
void ShowWindowWithColorSelector() {
    // Create a window
    Window* window = CreateWindow("Color Selector Example", 100, 100, 400, 300);

    // Create a color selector
    ColorSelector* colorSelector = CreateColorSelector(50, 50);

    // Add the color selector to the window
    AddWidgetToWindow(window, colorSelector);

    // Draw the window
    DrawWindow(window);

    // Main event loop
    while (window->isVisible) {
        // Handle events
        HandleEvents();

        // Render the color selector
        DrawColorSelector(colorSelector);
    }

    // Cleanup
    DestroyColorSelector(colorSelector);
    DestroyWindow(window);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Show the window with a color selector
    ShowWindowWithColorSelector();

    // Main application loop
    while (1) {
        HandleEvents();
    }

    return 0;
}

Detailed Description:

1. Initialization

The CreateColorSelector function initializes and configures a color selection dialog. It sets the dialog's position and prepares it for interaction. The function returns a pointer to the created color selector widget, which can be customized further if needed.

2. Rendering

The DrawColorSelector function renders the color selection dialog on the screen. It draws the color palette and other UI elements, ensuring it is visible to the user.

3. Event Handling

The HandleColorSelectorEvent function manages interactions with the color selector, such as selecting a color from the palette. It updates the selector's state and triggers any associated actions or callbacks.

Example Workflow:

In the example provided, the ShowWindowWithColorSelector function demonstrates the complete workflow of creating a window and adding a color selector to it. It initializes the window and color selector, adds the selector to the window, and enters the main event loop to handle user interactions. The DrawColorSelector function is used to render the color selector on the screen, while the main event loop handles interactions with the selector.

Integration with iwidget and widgets system:

The color selector widget in `colsel.c` integrates with the `iwidget` and `widgets` systems to provide a consistent interface for creating and managing GUI elements. The CreateColorSelector function uses `iwidget` functions to initialize the color selector, while DrawColorSelector and HandleColorSelectorEvent leverage the `widgets` system to render and manage the color selector and its interactions.

×

combobox.c

Overview:

The `combobox.c` file provides functionalities for creating and managing combobox widgets within the Aura GUI. A combobox allows users to select an option from a dropdown list, which can be used in various parts of the application for user input.

Key Functions:

CreateComboBox: Initializes and configures a combobox widget.
DrawComboBox: Renders the combobox widget on the screen.
HandleComboBoxEvent: Handles events related to the combobox, such as opening the dropdown and selecting an item.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, graphics.h, iwidget.h

Detailed Workflow:

Initialization: Use the CreateComboBox function to initialize and configure a combobox widget.
Rendering: Use the DrawComboBox function to render the combobox widget on the screen.
Event Handling: Use the HandleComboBoxEvent function to manage interactions with the combobox.

Example Usage:

#include "widget.h"
#include "graphics.h"
#include "iwidget.h"

// Function to create and display a window with a combobox
void ShowWindowWithComboBox() {
    // Create a window
    Window* window = CreateWindow("Combobox Example", 100, 100, 400, 300);

    // Create a combobox
    ComboBox* combobox = CreateComboBox(50, 50, 100, 25);

    // Add items to the combobox
    AddItemToComboBox(combobox, "Item 1");
    AddItemToComboBox(combobox, "Item 2");
    AddItemToComboBox(combobox, "Item 3");

    // Add the combobox to the window
    AddWidgetToWindow(window, combobox);

    // Draw the window
    DrawWindow(window);

    // Main event loop
    while (window->isVisible) {
        // Handle events
        HandleEvents();

        // Render the combobox
        DrawComboBox(combobox);
    }

    // Cleanup
    DestroyComboBox(combobox);
    DestroyWindow(window);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Show the window with a combobox
    ShowWindowWithComboBox();

    // Main application loop
    while (1) {
        HandleEvents();
    }

    return 0;
}

Detailed Description:

1. Initialization

The CreateComboBox function initializes and configures a combobox widget. It sets the position and dimensions of the combobox and prepares it for user interaction. Items can be added to the combobox using the AddItemToComboBox function.

2. Rendering

The DrawComboBox function renders the combobox widget on the screen. It draws the selected item and the dropdown arrow, and manages the visibility of the dropdown list.

3. Event Handling

The HandleComboBoxEvent function manages interactions with the combobox, such as opening the dropdown list and selecting an item. It updates the combobox's state and triggers any associated actions or callbacks.

Example Workflow:

In the example provided, the ShowWindowWithComboBox function demonstrates the complete workflow of creating a window and adding a combobox to it. It initializes the window and combobox, adds items to the combobox, and enters the main event loop to handle user interactions. The DrawComboBox function is used to render the combobox on the screen, while the main event loop handles interactions with the combobox.

Integration with iwidget and widgets system:

The combobox widget in `combobox.c` integrates with the `iwidget` and `widgets` systems to provide a consistent interface for creating and managing GUI elements. The CreateComboBox function uses `iwidget` functions to initialize the combobox, while DrawComboBox and HandleComboBoxEvent leverage the `widgets` system to render and manage the combobox and its interactions.

×

conlib.c

Overview:

The `conlib.c` file provides a set of functions for managing console input and output operations within the Aura GUI. These functions facilitate text-based interactions, such as displaying messages, reading user input, and handling console commands.

Key Functions:

ConsoleInit: Initializes the console system, setting up necessary buffers and states.
ConsolePrint: Prints a message to the console.
ConsoleReadLine: Reads a line of input from the console.
ConsoleClear: Clears the console screen.
ConsoleSetColor: Sets the text color for console output.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: console.h, graphics.h, input.h

Detailed Workflow:

Initialization: Use the ConsoleInit function to initialize the console system.
Printing: Use the ConsolePrint function to display messages on the console.
Reading Input: Use the ConsoleReadLine function to capture user input from the console.
Clearing: Use the ConsoleClear function to clear the console screen.
Setting Color: Use the ConsoleSetColor function to change the text color for console output.

Example Usage:

#include "console.h"
#include "graphics.h"
#include "input.h"

// Function to demonstrate console operations
void DemoConsoleOperations() {
    // Initialize the console
    ConsoleInit();

    // Set console text color to green
    ConsoleSetColor(COLOR_GREEN);

    // Print a welcome message
    ConsolePrint("Welcome to the Aura Console\n");

    // Print instructions
    ConsolePrint("Type a message and press Enter:\n");

    // Buffer to hold user input
    char inputBuffer[256];

    // Read a line of input from the user
    ConsoleReadLine(inputBuffer, sizeof(inputBuffer));

    // Print the user's input
    ConsolePrint("You typed: ");
    ConsolePrint(inputBuffer);
    ConsolePrint("\n");

    // Clear the console screen
    ConsoleClear();

    // Print a goodbye message
    ConsolePrint("Goodbye!\n");

    // Reset console text color to default
    ConsoleSetColor(COLOR_DEFAULT);
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Demonstrate console operations
    DemoConsoleOperations();

    return 0;
}

Detailed Description:

1. Initialization

The ConsoleInit function sets up the console system, preparing it for input and output operations. It initializes necessary buffers and states required for console functionality.

2. Printing

The ConsolePrint function displays a message on the console. It takes a string as an argument and prints it to the console screen.

3. Reading Input

The ConsoleReadLine function captures a line of input from the user. It reads characters from the console until the user presses Enter, and stores the input in the provided buffer.

4. Clearing

The ConsoleClear function clears the console screen, removing all previously displayed text.

5. Setting Color

The ConsoleSetColor function changes the text color for console output. It takes a color constant as an argument and sets the text color accordingly.

Example Workflow:

In the example provided, the DemoConsoleOperations function demonstrates the complete workflow of initializing the console, setting text color, printing messages, reading user input, and clearing the console screen. The example showcases how to use the various functions in `conlib.c` to interact with the console in a text-based interface.

Integration with iwidget and widgets system:

The console functionalities in `conlib.c` are designed to work seamlessly within the Aura GUI, allowing text-based interactions in addition to graphical widgets. By integrating with the `iwidget` and `widgets` systems, the console provides a consistent interface for text input and output, complementing the overall user interface of the Aura GUI.

×

cp.c

Overview:

The `cp.c` file provides functionalities for handling clipboard operations within the Aura GUI. It allows for copying, cutting, and pasting text and other data types to and from the clipboard, facilitating data transfer between different parts of the application.

Key Functions:

ClipboardInit: Initializes the clipboard system.
ClipboardCopy: Copies data to the clipboard.
ClipboardCut: Cuts data to the clipboard, removing it from the source.
ClipboardPaste: Pastes data from the clipboard to the target.
ClipboardClear: Clears the clipboard data.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: clipboard.h, gui.h, system.h

Detailed Workflow:

Initialization: Use the ClipboardInit function to initialize the clipboard system.
Copying: Use the ClipboardCopy function to copy data to the clipboard.
Cutting: Use the ClipboardCut function to cut data to the clipboard, removing it from the source.
Pasting: Use the ClipboardPaste function to paste data from the clipboard to the target.
Clearing: Use the ClipboardClear function to clear the clipboard data.

Example Usage:

#include "clipboard.h"
#include "gui.h"
#include "system.h"

// Function to demonstrate clipboard operations
void DemoClipboardOperations() {
    // Initialize the clipboard
    ClipboardInit();

    // Example data to copy to the clipboard
    const char* text = "Hello, Aura Clipboard!";

    // Copy data to the clipboard
    ClipboardCopy(text, strlen(text) + 1);

    // Variable to hold pasted data
    char pasteBuffer[256];

    // Paste data from the clipboard
    ClipboardPaste(pasteBuffer, sizeof(pasteBuffer));

    // Print the pasted data
    printf("Pasted data: %s\n", pasteBuffer);

    // Clear the clipboard
    ClipboardClear();
}

// Main function
int main() {
    // Initialize the system
    SystemInit();

    // Demonstrate clipboard operations
    DemoClipboardOperations();

    return 0;
}

Detailed Description:

1. Initialization

The ClipboardInit function sets up the clipboard system, preparing it for copy, cut, and paste operations. It initializes necessary buffers and states required for clipboard functionality.

2. Copying

The ClipboardCopy function copies data to the clipboard. It takes a pointer to the data and the size of the data as arguments and stores the data in the clipboard.

3. Cutting

The ClipboardCut function cuts data to the clipboard, removing it from the source. It takes a pointer to the data and the size of the data as arguments and stores the data in the clipboard, also clearing the source data.

4. Pasting

The ClipboardPaste function pastes data from the clipboard to the target. It takes a pointer to a buffer and the size of the buffer as arguments, copying the clipboard data into the buffer.

5. Clearing

The ClipboardClear function clears the clipboard data, removing any previously stored data.

Example Workflow:

In the example provided, the DemoClipboardOperations function demonstrates the complete workflow of initializing the clipboard, copying data to the clipboard, pasting data from the clipboard, and clearing the clipboard. The example showcases how to use the various functions in `cp.c` to handle clipboard operations within the Aura GUI.

Integration with iwidget and widgets system:

The clipboard functionalities in `cp.c` are designed to work seamlessly within the Aura GUI, allowing data transfer between different parts of the application. By integrating with the `iwidget` and `widgets` systems, the clipboard provides a consistent interface for copying, cutting, and pasting data, enhancing the overall user experience of the Aura GUI.

×

fms2.c

Overview:

The `fms2.c` file provides functionalities for managing the File Management System (FMS) in Aura GUI. This module handles various file operations such as opening, reading, writing, and closing files. It also includes utilities for file system navigation and manipulation, supporting different file formats and ensuring data integrity during file operations.

Key Functions:

FMSInit: Initializes the File Management System.
FMSOpenFile: Opens a file and returns a file handle.
FMSReadFile: Reads data from an open file into a buffer.
FMSWriteFile: Writes data from a buffer to an open file.
FMSCloseFile: Closes an open file handle.
FMSDeleteFile: Deletes a specified file from the file system.
FMSListDirectory: Lists the contents of a directory.
FMSCreateDirectory: Creates a new directory.
FMSRemoveDirectory: Removes an existing directory.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: fms2.h, filesystem.h, utils.h

Detailed Workflow:

Initialization: Use the FMSInit function to initialize the File Management System.
File Operations: Use FMSOpenFile, FMSReadFile, FMSWriteFile, and FMSCloseFile for basic file operations.
File Deletion: Use FMSDeleteFile to delete files from the file system.
Directory Operations: Use FMSListDirectory, FMSCreateDirectory, and FMSRemoveDirectory for directory management.

Example Usage:

#include "fms2.h"
#include "filesystem.h"
#include "utils.h"

// Function to demonstrate file operations
void DemoFileOperations() {
    // Initialize the File Management System
    FMSInit();

    // Open a file for writing
    FILE* file = FMSOpenFile("example.txt", "w");
    if (file) {
        // Write data to the file
        const char* data = "Hello, Aura File Management System!";
        FMSWriteFile(file, data, strlen(data));

        // Close the file
        FMSCloseFile(file);
    }

    // Open the file for reading
    file = FMSOpenFile("example.txt", "r");
    if (file) {
        // Buffer to hold the read data
        char buffer[256];

        // Read data from the file
        FMSReadFile(file, buffer, sizeof(buffer));

        // Print the read data
        printf("Read data: %s\n", buffer);

        // Close the file
        FMSCloseFile(file);
    }

    // Delete the file
    FMSDeleteFile("example.txt");

    // Create a new directory
    FMSCreateDirectory("example_dir");

    // List directory contents
    FMSListDirectory(".");

    // Remove the directory
    FMSRemoveDirectory("example_dir");
}

// Main function
int main() {
    // Demonstrate file operations
    DemoFileOperations();

    return 0;
}

Detailed Description:

1. Initialization

The FMSInit function initializes the File Management System, setting up necessary structures and states for file operations. It must be called before any other FMS functions are used.

2. File Operations

FMSOpenFile: Opens a file specified by the filename and mode (e.g., "r" for read, "w" for write) and returns a file handle.

FMSReadFile: Reads data from an open file into a provided buffer, ensuring not to exceed the buffer size.

FMSWriteFile: Writes data from a provided buffer to an open file, ensuring data is correctly written to the file system.

FMSCloseFile: Closes an open file handle, ensuring all data is properly flushed and resources are released.

FMSDeleteFile: Deletes a specified file from the file system, removing it permanently.

3. Directory Operations

FMSListDirectory: Lists the contents of a specified directory, providing details about files and subdirectories.

FMSCreateDirectory: Creates a new directory with the specified name, ensuring it is correctly created in the file system.

FMSRemoveDirectory: Removes an existing directory, ensuring it is empty before deletion.

Example Workflow:

The provided example demonstrates the complete workflow of using the FMS functions to perform various file and directory operations. It includes opening a file, writing data to it, reading data from it, and deleting the file. It also shows how to create and remove directories, as well as list directory contents.

Integration with iwidget and widgets system:

The FMS functionalities in `fms2.c` are designed to work seamlessly within the Aura GUI, allowing efficient file and directory management. By integrating with the `iwidget` and `widgets` systems, FMS provides a consistent interface for file operations, enhancing the overall user experience of the Aura GUI.

×

fprop.c

Overview:

The `fprop.c` file provides functionalities for managing file properties within the Aura GUI. This module includes utilities to retrieve and modify various file attributes such as size, creation date, modification date, and file permissions. It ensures that file properties are accurately handled and presented to the user or other system components.

Key Functions:

GetFileSize: Retrieves the size of a specified file.
GetFileCreationDate: Retrieves the creation date of a specified file.
GetFileModificationDate: Retrieves the last modification date of a specified file.
SetFilePermissions: Sets the permissions for a specified file.
GetFilePermissions: Retrieves the permissions of a specified file.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>, <sys/stat.h>, <time.h>
Project-Specific Headers: fprop.h, utils.h

Detailed Workflow:

Retrieving File Size: Use the GetFileSize function to get the size of a file in bytes.
Retrieving Creation Date: Use the GetFileCreationDate function to get the creation date of a file.
Retrieving Modification Date: Use the GetFileModificationDate function to get the last modification date of a file.
Setting File Permissions: Use the SetFilePermissions function to set the permissions for a file.
Retrieving File Permissions: Use the GetFilePermissions function to get the permissions of a file.

Example Usage:

#include "fprop.h"
#include "utils.h"

// Function to demonstrate file property operations
void DemoFileProperties() {
    const char* filename = "example.txt";
    
    // Get and print file size
    long fileSize = GetFileSize(filename);
    printf("File Size: %ld bytes\n", fileSize);
    
    // Get and print file creation date
    char creationDate[20];
    GetFileCreationDate(filename, creationDate);
    printf("Creation Date: %s\n", creationDate);
    
    // Get and print file modification date
    char modificationDate[20];
    GetFileModificationDate(filename, modificationDate);
    printf("Modification Date: %s\n", modificationDate);
    
    // Get and print file permissions
    int permissions = GetFilePermissions(filename);
    printf("File Permissions: %o\n", permissions);
    
    // Set new file permissions
    SetFilePermissions(filename, 0644);
    printf("New File Permissions: %o\n", GetFilePermissions(filename));
}

// Main function
int main() {
    // Demonstrate file property operations
    DemoFileProperties();

    return 0;
}

Detailed Description:

1. Retrieving File Size

The GetFileSize function opens a file, seeks to the end, retrieves the file size in bytes, and then closes the file. This is essential for determining the amount of data stored in a file.

2. Retrieving Creation Date

GetFileCreationDate: This function retrieves the creation date of a file by accessing the file's metadata. It formats the date in a readable string format.

3. Retrieving Modification Date

GetFileModificationDate: Similar to creation date retrieval, this function accesses the file's metadata to get the last modification date and formats it in a readable string.

4. Setting and Retrieving File Permissions

SetFilePermissions: This function changes the permissions of a file to the specified mode (e.g., read, write, execute permissions).

GetFilePermissions: Retrieves the current permissions of a file, allowing the system to display or verify file access rights.

Example Workflow:

The provided example demonstrates how to use the file property functions to get and set file attributes. It includes retrieving file size, creation and modification dates, and file permissions, as well as setting new permissions.

Integration with iwidget and widgets system:

The file property functionalities in `fprop.c` are designed to work seamlessly within the Aura GUI, allowing efficient management of file attributes. By integrating with the `iwidget` and `widgets` systems, `fprop.c` provides a consistent interface for file property operations, enhancing the overall user experience of the Aura GUI.

×

grfx.c

Overview:

The `grfx.c` file provides general graphics handling routines for the Aura GUI. This module includes functions for drawing basic shapes, managing colors, and handling graphical transformations. It is a fundamental part of the graphical user interface, enabling the creation and manipulation of visual elements.

Key Functions:

DrawLine: Draws a line between two points.
DrawRectangle: Draws a rectangle given the top-left corner, width, and height.
DrawCircle: Draws a circle given the center point and radius.
SetColor: Sets the current drawing color.
FillRectangle: Fills a rectangle with the current color.
FillCircle: Fills a circle with the current color.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: grfx.h, colors.h, utils.h

Detailed Workflow:

Drawing a Line: Use the DrawLine function to draw a straight line between two specified points.
Drawing a Rectangle: Use the DrawRectangle function to draw a rectangle given the coordinates of the top-left corner, width, and height.
Drawing a Circle: Use the DrawCircle function to draw a circle given the coordinates of the center and the radius.
Setting Color: Use the SetColor function to set the current drawing color. This color will be used by subsequent drawing functions.
Filling Shapes: Use the FillRectangle and FillCircle functions to fill the specified shapes with the current color.

Example Usage:

#include "grfx.h"
#include "colors.h"
#include "utils.h"

// Function to demonstrate basic graphics operations
void DemoGraphics() {
    // Set the drawing color to red
    SetColor(RED);

    // Draw a line from (10, 10) to (100, 100)
    DrawLine(10, 10, 100, 100);

    // Draw a rectangle with the top-left corner at (50, 50), width 150, and height 100
    DrawRectangle(50, 50, 150, 100);

    // Draw a circle with the center at (200, 200) and radius 50
    DrawCircle(200, 200, 50);

    // Set the drawing color to blue
    SetColor(BLUE);

    // Fill a rectangle with the top-left corner at (300, 300), width 100, and height 50
    FillRectangle(300, 300, 100, 50);

    // Fill a circle with the center at (400, 400) and radius 30
    FillCircle(400, 400, 30);
}

// Main function
int main() {
    // Initialize graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate basic graphics operations
    DemoGraphics();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Drawing a Line

DrawLine: This function takes four parameters representing the starting and ending points of the line. It then uses a line-drawing algorithm to render the line on the screen.

2. Drawing a Rectangle

DrawRectangle: This function takes four parameters: the x and y coordinates of the top-left corner, the width, and the height. It draws four lines to form the outline of the rectangle.

3. Drawing a Circle

DrawCircle: This function takes three parameters: the x and y coordinates of the center and the radius. It uses a circle-drawing algorithm to render the circle on the screen.

4. Setting Color

SetColor: This function takes one parameter representing the color. It sets the current drawing color, which will be used by subsequent drawing functions. The color is typically represented as an RGB value or a predefined constant like RED or BLUE.

5. Filling Shapes

FillRectangle: This function fills a rectangle with the current drawing color. It takes the same parameters as DrawRectangle and uses a filling algorithm to color the entire area within the rectangle.

FillCircle: This function fills a circle with the current drawing color. It takes the same parameters as DrawCircle and uses a filling algorithm to color the entire area within the circle.

Example Workflow:

The provided example demonstrates how to use the basic graphics functions to draw and fill shapes. It initializes the graphics system, sets drawing colors, and performs various drawing operations such as lines, rectangles, and circles. Finally, it shuts down the graphics system.

Integration with iwidget and widgets system:

The graphics handling functionalities in `grfx.c` are designed to work seamlessly within the Aura GUI. By integrating with the `iwidget` and `widgets` systems, `grfx.c` provides a consistent interface for drawing and manipulating graphical elements, enhancing the overall visual experience of the Aura GUI.

×

groupbox.c

Overview:

The `groupbox.c` file implements the functionalities for the group box widget in the Aura GUI. A group box is a container widget that groups related widgets together, usually with a border and an optional title. This enhances the organization and visual structure of the user interface.

Key Functions:

CreateGroupBox: Creates a new group box widget.
DrawGroupBox: Draws the group box on the screen, including its border and title.
AddWidgetToGroupBox: Adds a widget to the group box, positioning it within the group box boundaries.
RemoveWidgetFromGroupBox: Removes a widget from the group box.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, colors.h

Detailed Workflow:

Creating a Group Box: Use the CreateGroupBox function to create a new group box widget, specifying its dimensions and optional title.
Drawing a Group Box: Use the DrawGroupBox function to render the group box on the screen, including its border and title.
Adding Widgets: Use the AddWidgetToGroupBox function to add widgets to the group box, positioning them relative to the group box boundaries.
Removing Widgets: Use the RemoveWidgetFromGroupBox function to remove widgets from the group box.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "colors.h"

// Function to demonstrate the group box functionalities
void DemoGroupBox() {
    // Create a group box with a title "Settings"
    Widget* groupBox = CreateGroupBox(50, 50, 300, 200, "Settings");

    // Create and add a checkbox widget to the group box
    Widget* checkbox = CreateCheckBox(60, 70, "Enable Feature");
    AddWidgetToGroupBox(groupBox, checkbox);

    // Create and add a button widget to the group box
    Widget* button = CreateButton(60, 100, "Apply");
    AddWidgetToGroupBox(groupBox, button);

    // Draw the group box and its child widgets
    DrawGroupBox(groupBox);

    // Render the group box on the screen
    RenderWidgets();
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the group box functionalities
    DemoGroupBox();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating a Group Box

CreateGroupBox: This function initializes a new group box widget. It takes parameters for the x and y coordinates, width, height, and an optional title. The group box can then be used to contain and organize

×

iodlg.c

Overview:

The `iodlg.c` file implements the functionalities for input/output dialogs in the Aura GUI. These dialogs are used to prompt the user for information or to display information to the user. This includes standard dialogs such as file open/save dialogs, message boxes, and custom input dialogs.

Key Functions:

CreateIODialog: Creates a new input/output dialog.
ShowIODialog: Displays the input/output dialog to the user.
HideIODialog: Hides the input/output dialog.
SetIODialogTitle: Sets the title of the input/output dialog.
SetIODialogMessage: Sets the message or prompt of the input/output dialog.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, dialog.h

Detailed Workflow:

Creating a Dialog: Use the CreateIODialog function to create a new input/output dialog, specifying its type and dimensions.
Showing a Dialog: Use the ShowIODialog function to display the dialog to the user.
Hiding a Dialog: Use the HideIODialog function to hide the dialog when it is no longer needed.
Setting Dialog Title and Message: Use the SetIODialogTitle and SetIODialogMessage functions to set the title and message or prompt of the dialog.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "dialog.h"

// Function to demonstrate the input/output dialog functionalities
void DemoIODialog() {
    // Create a file open dialog
    Widget* fileOpenDialog = CreateIODialog(DIALOG_FILE_OPEN, 100, 100, 400, 300);

    // Set the title and message of the dialog
    SetIODialogTitle(fileOpenDialog, "Open File");
    SetIODialogMessage(fileOpenDialog, "Select a file to open:");

    // Show the dialog
    ShowIODialog(fileOpenDialog);

    // Wait for user interaction
    // ...

    // Hide the dialog
    HideIODialog(fileOpenDialog);

    // Cleanup
    DestroyWidget(fileOpenDialog);
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the input/output dialog functionalities
    DemoIODialog();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating a Dialog

CreateIODialog: This function initializes a new input/output dialog widget. It takes parameters for the dialog type (e.g., file open, file save, message box), x and y coordinates, width, and height. The created dialog can then be customized and displayed to the user.

2. Showing a Dialog

ShowIODialog: This function renders the input/output dialog on the screen and makes it visible to the user. It is used after configuring the dialog to present it to the user for interaction.

3. Hiding a Dialog

HideIODialog: This function hides the input/output dialog, making it invisible and inactive. It is used when the dialog is no longer needed or after the user has interacted with it.

4. Setting Dialog Title and Message

SetIODialogTitle and SetIODialogMessage: These functions set the title and message or prompt of the input/output dialog, respectively. The title typically appears in the dialog's title bar, while the message or prompt appears within the dialog, providing instructions or information to the user.

Example Workflow:

The provided example demonstrates how to create and use an input/output dialog. It initializes the graphics system, creates a file open dialog, sets its title and message, shows the dialog, and then hides it after user interaction. Finally, it cleans up the resources and shuts down the graphics system.

Integration with iwidget and widgets system:

The input/output dialog functionalities in `iodlg.c` integrate seamlessly with the `iwidget` and `widgets` systems. By providing a standardized way to prompt the user for information or display messages, `iodlg.c` enhances the interactivity and user experience of the Aura GUI.

×

iodlg2.c

Overview:

The `iodlg2.c` file extends the functionalities of `iodlg.c` by providing additional and advanced input/output dialog capabilities. These enhanced dialogs include more complex user interactions, such as multi-step wizards, detailed error messages, and more customizable dialog components.

Key Functions:

CreateAdvancedIODialog: Creates a new advanced input/output dialog.
ShowAdvancedIODialog: Displays the advanced input/output dialog to the user.
HideAdvancedIODialog: Hides the advanced input/output dialog.
SetAdvancedIODialogTitle: Sets the title of the advanced input/output dialog.
SetAdvancedIODialogMessage: Sets the message or prompt of the advanced input/output dialog.
AddStepToIODialog: Adds a step to a multi-step wizard dialog.
SetIODialogError: Sets and displays an error message in the dialog.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, dialog.h

Detailed Workflow:

Creating an Advanced Dialog: Use the CreateAdvancedIODialog function to create a new advanced input/output dialog, specifying its type and dimensions.
Showing an Advanced Dialog: Use the ShowAdvancedIODialog function to display the dialog to the user.
Hiding an Advanced Dialog: Use the HideAdvancedIODialog function to hide the dialog when it is no longer needed.
Setting Dialog Title and Message: Use the SetAdvancedIODialogTitle and SetAdvancedIODialogMessage functions to set the title and message or prompt of the dialog.
Adding Steps to Wizard Dialog: Use the AddStepToIODialog function to add steps to a multi-step wizard dialog, allowing for complex user interactions.
Setting Dialog Error Messages: Use the SetIODialogError function to set and display error messages within the dialog.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "dialog.h"

// Function to demonstrate the advanced input/output dialog functionalities
void DemoAdvancedIODialog() {
    // Create a multi-step wizard dialog
    Widget* wizardDialog = CreateAdvancedIODialog(DIALOG_WIZARD, 100, 100, 400, 300);

    // Set the title and message of the dialog
    SetAdvancedIODialogTitle(wizardDialog, "Setup Wizard");
    SetAdvancedIODialogMessage(wizardDialog, "Welcome to the setup wizard. Follow the steps to complete the setup.");

    // Add steps to the wizard dialog
    AddStepToIODialog(wizardDialog, "Step 1: Introduction");
    AddStepToIODialog(wizardDialog, "Step 2: License Agreement");
    AddStepToIODialog(wizardDialog, "Step 3: Installation");
    AddStepToIODialog(wizardDialog, "Step 4: Completion");

    // Show the dialog
    ShowAdvancedIODialog(wizardDialog);

    // Wait for user interaction
    // ...

    // Hide the dialog
    HideAdvancedIODialog(wizardDialog);

    // Cleanup
    DestroyWidget(wizardDialog);
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the advanced input/output dialog functionalities
    DemoAdvancedIODialog();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating an Advanced Dialog

CreateAdvancedIODialog: This function initializes a new advanced input/output dialog widget. It takes parameters for the dialog type (e.g., wizard, advanced message box), x and y coordinates, width, and height. The created dialog can then be customized and displayed to the user.

2. Showing an Advanced Dialog

ShowAdvancedIODialog: This function renders the advanced input/output dialog on the screen and makes it visible to the user. It is used after configuring the dialog to present it to the user for interaction.

3. Hiding an Advanced Dialog

HideAdvancedIODialog: This function hides the advanced input/output dialog, making it invisible and inactive. It is used when the dialog is no longer needed or after the user has interacted with it.

4. Setting Dialog Title and Message

SetAdvancedIODialogTitle and SetAdvancedIODialogMessage: These functions set the title and message or prompt of the advanced input/output dialog, respectively. The title typically appears in the dialog's title bar, while the message or prompt appears within the dialog, providing instructions or information to the user.

5. Adding Steps to Wizard Dialog

AddStepToIODialog: This function adds steps to a multi-step wizard dialog, allowing for complex user interactions. Each step can have its own title and content, guiding the user through a sequence of actions.

6. Setting Dialog Error Messages

SetIODialogError: This function sets and displays an error message within the dialog. It is useful for showing validation errors or other issues that need to be communicated to the user.

Example Workflow:

The provided example demonstrates how to create and use an advanced input/output dialog. It initializes the graphics system, creates a multi-step wizard dialog, sets its title and message, adds steps to the wizard, shows the dialog, and then hides it after user interaction. Finally, it cleans up the resources and shuts down the graphics system.

Integration with iwidget and widgets system:

The advanced input/output dialog functionalities in `iodlg2.c` integrate seamlessly with the `iwidget` and `widgets` systems. By providing a more sophisticated and flexible way to prompt the user for information or display messages, `iodlg2.c` enhances the interactivity and user experience of the Aura GUI.

×

label.c

Overview:

The `label.c` file is responsible for implementing the label widget functionalities in the Aura GUI. Labels are used to display static text on the GUI, often serving as descriptions or titles for other widgets. This file defines the methods and structures necessary to create, render, and manage labels within the interface.

Key Functions:

CreateLabel: Initializes a new label widget with specified text and properties.
SetLabelText: Updates the text displayed by a label widget.
RenderLabel: Renders the label widget on the screen at its specified coordinates.
SetLabelFont: Sets the font used by the label widget.
SetLabelColor: Sets the color of the text displayed by the label widget.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, font.h

Detailed Workflow:

Creating a Label: Use the CreateLabel function to create a new label widget, specifying its initial text, position, and other properties.
Updating Label Text: Use the SetLabelText function to update the text displayed by an existing label widget.
Rendering the Label: Use the RenderLabel function to draw the label on the screen at its specified coordinates.
Setting Label Font: Use the SetLabelFont function to change the font used by the label widget.
Setting Label Color: Use the SetLabelColor function to change the color of the text displayed by the label widget.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "font.h"

// Function to demonstrate the label widget functionalities
void DemoLabel() {
    // Create a label widget
    Widget* label = CreateLabel("Hello, Aura!", 100, 50);

    // Set the font and color of the label
    SetLabelFont(label, "Helvetica", 12);
    SetLabelColor(label, makecol(255, 255, 255)); // White color

    // Render the label on the screen
    RenderLabel(label);

    // Update the text of the label
    SetLabelText(label, "Welcome to the Aura GUI!");

    // Render the updated label on the screen
    RenderLabel(label);

    // Cleanup
    DestroyWidget(label);
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the label widget functionalities
    DemoLabel();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating a Label

CreateLabel: This function initializes a new label widget. It takes parameters for the initial text, x and y coordinates, and other properties. The created label can then be rendered on the screen and updated as needed.

2. Updating Label Text

SetLabelText: This function updates the text displayed by an existing label widget. It is useful for dynamic interfaces where the displayed text needs to change based on user interactions or other events.

3. Rendering the Label

RenderLabel: This function draws the label on the screen at its specified coordinates. It uses the current text, font, and color settings of the label widget.

4. Setting Label Font

SetLabelFont: This function sets the font used by the label widget. It allows customization of the text appearance, including font family and size.

5. Setting Label Color

SetLabelColor: This function sets the color of the text displayed by the label widget. It allows customization of the text color to match the GUI's theme or user preferences.

Example Workflow:

The provided example demonstrates how to create and use a label widget. It initializes the graphics system, creates a label widget, sets its font and color, renders it on the screen, updates its text, and then renders the updated label. Finally, it cleans up the resources and shuts down the graphics system.

Integration with iwidget and widgets system:

The label widget functionalities in `label.c` integrate seamlessly with the `iwidget` and `widgets` systems. Labels are fundamental components of the GUI, providing static text that can be used for descriptions, titles, and other informational purposes. By allowing customization of text, font, and color, `label.c` enhances the flexibility and usability of the Aura GUI.

×

listbox.c

Overview:

The `listbox.c` file is responsible for implementing the list box widget functionalities in the Aura GUI. List boxes are used to display a list of selectable items within the GUI, allowing users to select one or multiple items from the list. This file defines the methods and structures necessary to create, render, and manage list boxes within the interface.

Key Functions:

CreateListBox: Initializes a new list box widget with specified properties.
AddListBoxItem: Adds a new item to the list box.
RemoveListBoxItem: Removes an item from the list box.
GetSelectedListBoxItem: Retrieves the currently selected item from the list box.
RenderListBox: Renders the list box widget on the screen.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, event.h

Detailed Workflow:

Creating a List Box: Use the CreateListBox function to create a new list box widget, specifying its position, size, and other properties.
Adding Items: Use the AddListBoxItem function to add new items to the list box. Each item can have a label and associated data.
Removing Items: Use the RemoveListBoxItem function to remove items from the list box based on their index.
Getting Selected Item: Use the GetSelectedListBoxItem function to retrieve the currently selected item from the list box.
Rendering the List Box: Use the RenderListBox function to draw the list box on the screen at its specified coordinates.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "event.h"

// Function to demonstrate the list box widget functionalities
void DemoListBox() {
    // Create a list box widget
    Widget* listBox = CreateListBox(100, 50, 200, 150);

    // Add items to the list box
    AddListBoxItem(listBox, "Item 1", NULL);
    AddListBoxItem(listBox, "Item 2", NULL);
    AddListBoxItem(listBox, "Item 3", NULL);

    // Render the list box on the screen
    RenderListBox(listBox);

    // Retrieve the selected item from the list box
    int selectedItem = GetSelectedListBoxItem(listBox);
    printf("Selected Item: %d\n", selectedItem);

    // Remove an item from the list box
    RemoveListBoxItem(listBox, 1);

    // Render the updated list box on the screen
    RenderListBox(listBox);

    // Cleanup
    DestroyWidget(listBox);
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the list box widget functionalities
    DemoListBox();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating a List Box

CreateListBox: This function initializes a new list box widget. It takes parameters for the x and y coordinates, width, height, and other properties. The created list box can then be populated with items and rendered on the screen.

2. Adding Items

AddListBoxItem: This function adds new items to the list box. Each item can have a label and associated data. The label is displayed in the list box, and the associated data can be used for other purposes within the application.

3. Removing Items

RemoveListBoxItem: This function removes items from the list box based on their index. It allows dynamic modification of the list box contents.

4. Getting Selected Item

GetSelectedListBoxItem: This function retrieves the currently selected item from the list box. It returns the index of the selected item, which can be used to access the item's label and associated data.

5. Rendering the List Box

RenderListBox: This function draws the list box on the screen at its specified coordinates. It uses the current list of items and the selected item index to render the list box correctly.

Example Workflow:

The provided example demonstrates how to create and use a list box widget. It initializes the graphics system, creates a list box widget, adds items to the list box, renders it on the screen, retrieves the selected item, removes an item from the list box, and then renders the updated list box. Finally, it cleans up the resources and shuts down the graphics system.

Integration with iwidget and widgets system:

The list box widget functionalities in `listbox.c` integrate seamlessly with the `iwidget` and `widgets` systems. List boxes are essential components of the GUI, providing a means to display and select from a list of items. By allowing dynamic addition and removal of items, `listbox.c` enhances the flexibility and interactivity of the Aura GUI.

×

listbox.c

Overview:

The `listbox.c` file is responsible for implementing the list box widget functionalities in the Aura GUI. List boxes are used to display a list of selectable items within the GUI, allowing users to select one or multiple items from the list. This file defines the methods and structures necessary to create, render, and manage list boxes within the interface.

Key Functions:

CreateListBox: Initializes a new list box widget with specified properties.
AddListBoxItem: Adds a new item to the list box.
RemoveListBoxItem: Removes an item from the list box.
GetSelectedListBoxItem: Retrieves the currently selected item from the list box.
RenderListBox: Renders the list box widget on the screen.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, grfx.h, event.h

Detailed Workflow:

Creating a List Box: Use the CreateListBox function to create a new list box widget, specifying its position, size, and other properties.
Adding Items: Use the AddListBoxItem function to add new items to the list box. Each item can have a label and associated data.
Removing Items: Use the RemoveListBoxItem function to remove items from the list box based on their index.
Getting Selected Item: Use the GetSelectedListBoxItem function to retrieve the currently selected item from the list box.
Rendering the List Box: Use the RenderListBox function to draw the list box on the screen at its specified coordinates.

Example Usage:

#include "widget.h"
#include "grfx.h"
#include "event.h"

// Function to demonstrate the list box widget functionalities
void DemoListBox() {
    // Create a list box widget
    Widget* listBox = CreateListBox(100, 50, 200, 150);

    // Add items to the list box
    AddListBoxItem(listBox, "Item 1", NULL);
    AddListBoxItem(listBox, "Item 2", NULL);
    AddListBoxItem(listBox, "Item 3", NULL);

    // Render the list box on the screen
    RenderListBox(listBox);

    // Retrieve the selected item from the list box
    int selectedItem = GetSelectedListBoxItem(listBox);
    printf("Selected Item: %d\n", selectedItem);

    // Remove an item from the list box
    RemoveListBoxItem(listBox, 1);

    // Render the updated list box on the screen
    RenderListBox(listBox);

    // Cleanup
    DestroyWidget(listBox);
}

// Main function
int main() {
    // Initialize the graphics system (assuming a function like this exists)
    InitGraphicsSystem();

    // Demonstrate the list box widget functionalities
    DemoListBox();

    // Shutdown graphics system (assuming a function like this exists)
    ShutdownGraphicsSystem();

    return 0;
}

Detailed Description:

1. Creating a List Box

CreateListBox: This function initializes a new list box widget. It takes parameters for the x and y coordinates, width, height, and other properties. The created list box can then be populated with items and rendered on the screen.

2. Adding Items

AddListBoxItem: This function adds new items to the list box. Each item can have a label and associated data. The label is displayed in the list box, and the associated data can be used for other purposes within the application.

3. Removing Items

RemoveListBoxItem: This function removes items from the list box based on their index. It allows dynamic modification of the list box contents.

4. Getting Selected Item

GetSelectedListBoxItem: This function retrieves the currently selected item from the list box. It returns the index of the selected item, which can be used to access the item's label and associated data.

5. Rendering the List Box

RenderListBox: This function draws the list box on the screen at its specified coordinates. It uses the current list of items and the selected item index to render the list box correctly.

Example Workflow:

The provided example demonstrates how to create and use a list box widget. It initializes the graphics system, creates a list box widget, adds items to the list box, renders it on the screen, retrieves the selected item, removes an item from the list box, and then renders the updated list box. Finally, it cleans up the resources and shuts down the graphics system.

Integration with iwidget and widgets system:

The list box widget functionalities in `listbox.c` integrate seamlessly with the `iwidget` and `widgets` systems. List boxes are essential components of the GUI, providing a means to display and select from a list of items. By allowing dynamic addition and removal of items, `listbox.c` enhances the flexibility and interactivity of the Aura GUI.

×

memfile.c

Overview:

The `memfile.c` file is responsible for implementing in-memory file handling functionalities in the Aura GUI. This allows for efficient manipulation and access to file-like data structures stored in memory rather than on disk. Such an approach is useful for temporary storage and manipulation of data without the need for persistent storage, which can significantly improve performance for certain operations.

Key Functions:

CreateMemFile: Initializes a new in-memory file with specified size.
WriteMemFile: Writes data to the in-memory file at the specified position.
ReadMemFile: Reads data from the in-memory file from the specified position.
CloseMemFile: Closes the in-memory file and frees allocated resources.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: memfile.h

Detailed Workflow:

Creating a MemFile: Use the CreateMemFile function to initialize a new in-memory file, specifying its initial size.
Writing to MemFile: Use the WriteMemFile function to write data to the in-memory file at a specific position.
Reading from MemFile: Use the ReadMemFile function to read data from the in-memory file starting at a specific position.
Closing MemFile: Use the CloseMemFile function to close the in-memory file and release any allocated memory.

Example Usage:

#include "memfile.h"

// Function to demonstrate the in-memory file functionalities
void DemoMemFile() {
    // Create a new in-memory file with an initial size of 1024 bytes
    MemFile* memFile = CreateMemFile(1024);

    // Data to write to the in-memory file
    char data[] = "Hello, Aura!";
    WriteMemFile(memFile, data, sizeof(data), 0);

    // Buffer to read data from the in-memory file
    char buffer[50];
    ReadMemFile(memFile, buffer, sizeof(data), 0);

    // Print the read data
    printf("Read from MemFile: %s\n", buffer);

    // Close the in-memory file and release resources
    CloseMemFile(memFile);
}

// Main function
int main() {
    // Demonstrate the in-memory file functionalities
    DemoMemFile();

    return 0;
}

Detailed Description:

1. Creating a MemFile

CreateMemFile: This function initializes a new in-memory file with a specified size. It allocates memory for the file's content and prepares it for read and write operations.

2. Writing to MemFile

WriteMemFile: This function writes data to the in-memory file at a specified position. It ensures that the data is correctly copied into the allocated memory space, updating the file's size if necessary.

3. Reading from MemFile

ReadMemFile: This function reads data from the in-memory file starting at a specified position. It copies the data from the in-memory file to a provided buffer, ensuring that the buffer size is not exceeded.

4. Closing MemFile

CloseMemFile: This function closes the in-memory file and releases any allocated memory. It ensures that all resources used by the in-memory file are properly freed.

Example Workflow:

The provided example demonstrates how to create and use an in-memory file. It initializes an in-memory file, writes data to it, reads the data back, and then closes the in-memory file. This workflow highlights the efficiency of using in-memory files for temporary data storage and manipulation.

×

menu.c

Overview:

The `menu.c` file is responsible for implementing the menu functionalities in the Aura GUI. This includes creating, displaying, and managing menus and their items, handling user interactions, and linking menu actions to corresponding functions.

Key Functions:

CreateMenu: Initializes a new menu structure.
AddMenuItem: Adds an item to a specified menu.
ShowMenu: Displays the menu on the screen.
HandleMenuEvent: Handles user interactions with the menu items.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: menu.h, widget.h, events.h

Detailed Workflow:

Creating a Menu: Use the CreateMenu function to initialize a new menu structure.
Adding Items to Menu: Use the AddMenuItem function to add items to the menu. Each item can have a label and an associated action.
Displaying the Menu: Use the ShowMenu function to render the menu on the screen.
Handling Menu Events: Use the HandleMenuEvent function to process user interactions with the menu items.

Example Usage:

#include "menu.h"

// Function to demonstrate menu functionalities
void DemoMenu() {
    // Create a new menu
    Menu* menu = CreateMenu();

    // Add items to the menu
    AddMenuItem(menu, "File", NULL);
    AddMenuItem(menu, "Edit", NULL);
    AddMenuItem(menu, "View", NULL);
    AddMenuItem(menu, "Help", NULL);

    // Display the menu
    ShowMenu(menu);

    // Handle menu events (simplified for demonstration)
    while (1) {
        PEvent event = WaitForEvent();
        HandleMenuEvent(menu, event);
        if (event->Type == EV_QUIT) break;
    }

    // Cleanup
    DestroyMenu(menu);
}

// Main function
int main() {
    // Demonstrate menu functionalities
    DemoMenu();

    return 0;
}

Detailed Description:

1. Creating a Menu

CreateMenu: This function initializes a new menu structure. It allocates memory for the menu and sets up necessary data structures for managing menu items.

2. Adding Items to Menu

AddMenuItem: This function adds an item to the specified menu. Each item can have a label (e.g., "File", "Edit") and an associated action that gets executed when the item is selected.

3. Displaying the Menu

ShowMenu: This function renders the menu on the screen. It positions the menu items and draws them using the appropriate graphical functions.

4. Handling Menu Events

HandleMenuEvent: This function processes user interactions with the menu items. It listens for events such as mouse clicks or keyboard shortcuts, determines which menu item was selected, and triggers the corresponding action.

Example Workflow:

The provided example demonstrates how to create and use a menu. It initializes a new menu, adds items to it, displays the menu, and handles user interactions with the menu items. This workflow highlights the simplicity and flexibility of using menus within the Aura GUI for user interactions and command execution.

×

prevscr.c

Overview:

The `prevscr.c` file is responsible for implementing the screen preview functionalities in the Aura GUI. This includes capturing the current screen, displaying previews, and managing screen preview interactions.

Key Functions:

CaptureScreen: Captures the current screen and stores it in a buffer.
ShowPreview: Displays the captured screen preview on the screen.
HandlePreviewEvent: Handles user interactions with the screen preview.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: prevscr.h, grfx.h, events.h

Detailed Workflow:

Capturing the Screen: Use the CaptureScreen function to capture the current screen content and store it in a buffer.
Displaying the Preview: Use the ShowPreview function to render the captured screen preview on the screen.
Handling Preview Events: Use the HandlePreviewEvent function to process user interactions with the screen preview, such as closing the preview or interacting with previewed elements.

Example Usage:

#include "prevscr.h"

// Function to demonstrate screen preview functionalities
void DemoScreenPreview() {
    // Capture the current screen
    CaptureScreen();

    // Display the screen preview
    ShowPreview();

    // Handle screen preview events (simplified for demonstration)
    while (1) {
        PEvent event = WaitForEvent();
        HandlePreviewEvent(event);
        if (event->Type == EV_QUIT) break;
    }

    // Cleanup
    ClosePreview();
}

// Main function
int main() {
    // Demonstrate screen preview functionalities
    DemoScreenPreview();

    return 0;
}

Detailed Description:

1. Capturing the Screen

CaptureScreen: This function captures the current screen content and stores it in a buffer. It uses graphical functions to read the screen pixels and save them for later display.

2. Displaying the Preview

ShowPreview: This function renders the captured screen preview on the screen. It positions the preview in a window or a specific area and draws the captured content.

3. Handling Preview Events

HandlePreviewEvent: This function processes user interactions with the screen preview. It listens for events such as mouse clicks or keyboard shortcuts, determines the appropriate action (e.g., closing the preview), and executes the corresponding function.

Example Workflow:

The provided example demonstrates how to use the screen preview functionalities. It captures the current screen, displays the preview, and handles user interactions with the preview. This workflow highlights the simplicity and effectiveness of using screen previews within the Aura GUI for providing visual feedback and managing screen content.

×

progress.c

Overview:

The `progress.c` file is responsible for implementing the progress bar widget functionalities in the Aura GUI. This includes creating, updating, and rendering progress bars to visually indicate the progress of tasks.

Key Functions:

CreateProgressBar: Initializes and creates a new progress bar widget.
UpdateProgressBar: Updates the progress value and visual representation of the progress bar.
RenderProgressBar: Renders the progress bar on the screen.
DestroyProgressBar: Cleans up and removes the progress bar widget.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: progress.h, widget.h, grfx.h

Detailed Workflow:

Creating a Progress Bar: Use the CreateProgressBar function to initialize and set up a new progress bar widget.
Updating the Progress Bar: Use the UpdateProgressBar function to change the progress value and update the visual representation of the progress bar.
Rendering the Progress Bar: Use the RenderProgressBar function to draw the progress bar on the screen.
Destroying the Progress Bar: Use the DestroyProgressBar function to clean up and remove the progress bar widget.

Example Usage:

#include "progress.h"

// Function to demonstrate progress bar functionalities
void DemoProgressBar() {
    // Create a progress bar
    ProgressBar* progressBar = CreateProgressBar(10, 10, 200, 30);

    // Update the progress bar (example loop)
    for (int i = 0; i <= 100; i++) {
        UpdateProgressBar(progressBar, i);
        RenderProgressBar(progressBar);
        rest(50);  // Simulate task progress
    }

    // Destroy the progress bar
    DestroyProgressBar(progressBar);
}

// Main function
int main() {
    // Demonstrate progress bar functionalities
    DemoProgressBar();

    return 0;
}

Detailed Description:

1. Creating a Progress Bar

CreateProgressBar: This function initializes and sets up a new progress bar widget. It allocates memory for the progress bar structure, sets the initial position, size, and progress value, and prepares it for rendering.

2. Updating the Progress Bar

UpdateProgressBar: This function updates the progress value and the visual representation of the progress bar. It takes the progress bar structure and a new progress value as inputs, adjusts the internal state, and prepares the updated progress bar for rendering.

3. Rendering the Progress Bar

RenderProgressBar: This function draws the progress bar on the screen. It takes the progress bar structure as input and uses graphical functions to render the progress bar at its specified position with the current progress value.

4. Destroying the Progress Bar

DestroyProgressBar: This function cleans up and removes the progress bar widget. It frees the allocated memory and performs any necessary cleanup to ensure the progress bar is properly removed from the screen.

Example Workflow:

The provided example demonstrates how to use the progress bar functionalities. It creates a progress bar, updates the progress value in a loop to simulate task progress, renders the progress bar on the screen, and finally destroys the progress bar. This workflow highlights the ease of creating, updating, and managing progress bars within the Aura GUI to provide visual feedback for task progress.

×

scrllbar.c

Overview:

The `scrllbar.c` file is responsible for implementing the scroll bar widget functionalities in the Aura GUI. This includes creating, updating, and rendering scroll bars to provide a mechanism for scrolling content in a window or container.

Key Functions:

CreateScrollBar: Initializes and creates a new scroll bar widget.
UpdateScrollBar: Updates the scroll position and visual representation of the scroll bar.
RenderScrollBar: Renders the scroll bar on the screen.
DestroyScrollBar: Cleans up and removes the scroll bar widget.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: scrllbar.h, widget.h, grfx.h

Detailed Workflow:

Creating a Scroll Bar: Use the CreateScrollBar function to initialize and set up a new scroll bar widget.
Updating the Scroll Bar: Use the UpdateScrollBar function to change the scroll position and update the visual representation of the scroll bar.
Rendering the Scroll Bar: Use the RenderScrollBar function to draw the scroll bar on the screen.
Destroying the Scroll Bar: Use the DestroyScrollBar function to clean up and remove the scroll bar widget.

Example Usage:

#include "scrllbar.h"

// Function to demonstrate scroll bar functionalities
void DemoScrollBar() {
    // Create a scroll bar
    ScrollBar* scrollBar = CreateScrollBar(10, 10, 200, 20);

    // Update the scroll bar (example loop)
    for (int i = 0; i <= 100; i++) {
        UpdateScrollBar(scrollBar, i);
        RenderScrollBar(scrollBar);
        rest(50);  // Simulate scrolling
    }

    // Destroy the scroll bar
    DestroyScrollBar(scrollBar);
}

// Main function
int main() {
    // Demonstrate scroll bar functionalities
    DemoScrollBar();

    return 0;
}

Detailed Description:

1. Creating a Scroll Bar

CreateScrollBar: This function initializes and sets up a new scroll bar widget. It allocates memory for the scroll bar structure, sets the initial position, size, and scroll position, and prepares it for rendering.

2. Updating the Scroll Bar

UpdateScrollBar: This function updates the scroll position and the visual representation of the scroll bar. It takes the scroll bar structure and a new scroll position as inputs, adjusts the internal state, and prepares the updated scroll bar for rendering.

3. Rendering the Scroll Bar

RenderScrollBar: This function draws the scroll bar on the screen. It takes the scroll bar structure as input and uses graphical functions to render the scroll bar at its specified position with the current scroll position.

4. Destroying the Scroll Bar

DestroyScrollBar: This function cleans up and removes the scroll bar widget. It frees the allocated memory and performs any necessary cleanup to ensure the scroll bar is properly removed from the screen.

Example Workflow:

The provided example demonstrates how to use the scroll bar functionalities. It creates a scroll bar, updates the scroll position in a loop to simulate scrolling, renders the scroll bar on the screen, and finally destroys the scroll bar. This workflow highlights the ease of creating, updating, and managing scroll bars within the Aura GUI to provide a mechanism for scrolling content in a window or container.

×

skin.c

Overview:

The `skin.c` file is responsible for implementing the skinning functionalities in the Aura GUI. This involves defining and managing the appearance of various GUI elements, allowing for a customizable look and feel through the use of skins.

Key Functions:

LoadSkin: Loads a skin from a specified file.
ApplySkin: Applies the loaded skin to the GUI elements.
RemoveSkin: Removes the applied skin and reverts to the default appearance.
SaveSkin: Saves the current skin configuration to a file.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: skin.h, widget.h, grfx.h

Detailed Workflow:

Loading a Skin: Use the LoadSkin function to load a skin configuration from a specified file.
Applying a Skin: Use the ApplySkin function to apply the loaded skin to the GUI elements, changing their appearance.
Removing a Skin: Use the RemoveSkin function to remove the applied skin and revert to the default appearance.
Saving a Skin: Use the SaveSkin function to save the current skin configuration to a file for later use.

Example Usage:

#include "skin.h"

// Function to demonstrate skin functionalities
void DemoSkin() {
    // Load a skin from a file
    if (LoadSkin("default.skin") == 0) {
        // Apply the loaded skin
        ApplySkin();

        // Save the skin configuration
        SaveSkin("saved.skin");

        // Remove the applied skin
        RemoveSkin();
    } else {
        printf("Failed to load skin\n");
    }
}

// Main function
int main() {
    // Demonstrate skin functionalities
    DemoSkin();

    return 0;
}

Detailed Description:

1. Loading a Skin

LoadSkin: This function loads a skin configuration from a specified file. It reads the file, parses the skin data, and prepares it for application to the GUI elements.

2. Applying a Skin

ApplySkin: This function applies the loaded skin to the GUI elements, changing their appearance according to the skin configuration. It updates the visual properties of the elements to reflect the new look and feel.

3. Removing a Skin

RemoveSkin: This function removes the applied skin and reverts the GUI elements to their default appearance. It ensures that the visual properties are reset to their original state.

4. Saving a Skin

SaveSkin: This function saves the current skin configuration to a file. It writes the skin data to the specified file, allowing the skin to be reloaded and applied later.

Example Workflow:

The provided example demonstrates how to use the skin functionalities. It loads a skin from a file, applies the skin to the GUI elements, saves the current skin configuration to a file, and finally removes the applied skin. This workflow highlights the ease of customizing the appearance of the Aura GUI through the use of skins, allowing for a customizable look and feel.

×

slider.c

Overview:

The `slider.c` file is responsible for implementing the slider widget functionalities in the Aura GUI. Sliders are used for selecting a value from a range, typically displayed as a horizontal or vertical bar with a movable handle.

Key Functions:

CreateSlider: Initializes and creates a slider widget.
SetSliderRange: Sets the range of values for the slider.
SetSliderValue: Sets the current value of the slider.
GetSliderValue: Retrieves the current value of the slider.
DrawSlider: Renders the slider widget on the screen.
HandleSliderEvent: Manages events related to the slider, such as user interaction.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: slider.h, widget.h, events.h, grfx.h

Detailed Workflow:

Creating a Slider: Use the CreateSlider function to initialize and create a slider widget with specified parameters.
Setting Slider Range: Use the SetSliderRange function to define the minimum and maximum values for the slider.
Setting and Getting Slider Value: Use the SetSliderValue and GetSliderValue functions to set and retrieve the current value of the slider.
Drawing the Slider: Use the DrawSlider function to render the slider widget on the screen, displaying its current state.
Handling Slider Events: Use the HandleSliderEvent function to manage user interactions and other events related to the slider.

Example Usage:

#include "slider.h"

// Function to demonstrate slider functionalities
void DemoSlider() {
    // Create a slider widget
    Widget* slider = CreateSlider(50, 50, 200, 30);

    // Set the range and initial value
    SetSliderRange(slider, 0, 100);
    SetSliderValue(slider, 50);

    // Main loop
    while (!exit) {
        // Handle events
        HandleSliderEvent(slider, GetNextEvent());

        // Draw the slider
        DrawSlider(slider);

        // Get the current value
        int value = GetSliderValue(slider);
        printf("Slider Value: %d\n", value);
    }
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate slider functionalities
    DemoSlider();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Slider

CreateSlider: This function initializes and creates a slider widget with specified parameters such as position, size, and initial value.

2. Setting Slider Range

SetSliderRange: This function defines the minimum and maximum values for the slider, allowing it to represent a range of values.

3. Setting and Getting Slider Value

SetSliderValue: This function sets the current value of the slider within the defined range. GetSliderValue: This function retrieves the current value of the slider, which can be used for various purposes such as displaying the value or processing it further.

4. Drawing the Slider

DrawSlider: This function renders the slider widget on the screen, displaying its current state, including the position of the handle and the filled portion of the bar representing the value.

5. Handling Slider Events

HandleSliderEvent: This function manages user interactions and other events related to the slider, such as moving the handle to change the value.

Example Workflow:

The provided example demonstrates how to use the slider functionalities. It creates a slider widget, sets its range and initial value, and enters a main loop where it handles events, draws the slider, and retrieves the current value. This workflow highlights the ease of using sliders in the Aura GUI for selecting values within a range, making them a useful component for various applications.

×

sound.c

Overview:

The `sound.c` file is responsible for managing sound functionalities within the Aura GUI. This includes loading, playing, stopping, and managing various audio resources such as sound effects and background music.

Key Functions:

LoadSound: Loads a sound file into memory.
PlaySound: Plays a loaded sound.
StopSound: Stops a playing sound.
PauseSound: Pauses a playing sound.
ResumeSound: Resumes a paused sound.
UnloadSound: Unloads a sound file from memory.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: sound.h, resources.h
Audio Library: Allegro or a similar library for handling audio operations.

Detailed Workflow:

Loading a Sound: Use the LoadSound function to load a sound file into memory.
Playing a Sound: Use the PlaySound function to play a loaded sound.
Stopping a Sound: Use the StopSound function to stop a playing sound.
Pausing and Resuming a Sound: Use the PauseSound and ResumeSound functions to control sound playback state.
Unloading a Sound: Use the UnloadSound function to free up memory by unloading a sound file.

Example Usage:

#include "sound.h"

// Function to demonstrate sound functionalities
void DemoSound() {
    // Load a sound file
    Sound* sound = LoadSound("example.wav");
    if (sound == NULL) {
        printf("Failed to load sound.\n");
        return;
    }

    // Play the sound
    PlaySound(sound);

    // Simulate some processing delay
    sleep(2);

    // Pause the sound
    PauseSound(sound);

    // Simulate some processing delay
    sleep(2);

    // Resume the sound
    ResumeSound(sound);

    // Simulate some processing delay
    sleep(2);

    // Stop the sound
    StopSound(sound);

    // Unload the sound
    UnloadSound(sound);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate sound functionalities
    DemoSound();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Loading a Sound

LoadSound: This function loads a sound file from the specified path into memory, returning a pointer to the sound object. It handles file operations and memory allocation required for sound management.

2. Playing a Sound

PlaySound: This function plays a loaded sound. It manages audio playback, ensuring the sound is played from the beginning or resumes if paused.

3. Stopping a Sound

StopSound: This function stops a playing sound, immediately halting audio playback. It's useful for managing sound effects that need to be stopped on certain events.

4. Pausing and Resuming a Sound

PauseSound: This function pauses a playing sound, allowing it to be resumed later. ResumeSound: This function resumes playback of a paused sound from the point it was paused.

5. Unloading a Sound

UnloadSound: This function unloads a sound file from memory, freeing up resources. It's important for managing memory usage, especially in applications with multiple sounds.

Example Workflow:

The provided example demonstrates how to use the sound functionalities. It shows loading a sound, playing it, pausing and resuming playback, stopping it, and finally unloading the sound from memory. This workflow illustrates the complete lifecycle of sound management within the Aura GUI.

×

tabbook.c

Overview:

The `tabbook.c` file is responsible for implementing the functionalities of a tabbed notebook widget within the Aura GUI. This widget allows multiple tabs to be displayed within a single window, providing a convenient way to organize and access different sections of the interface.

Key Functions:

CreateTabBook: Initializes and creates a new tabbed notebook widget.
AddTab: Adds a new tab to the tabbed notebook.
RemoveTab: Removes an existing tab from the tabbed notebook.
SetActiveTab: Sets the active tab, switching the visible content to the specified tab.
DrawTabBook: Renders the tabbed notebook widget, including all tabs and their contents.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>
Project-Specific Headers: widget.h, graphics.h

Detailed Workflow:

Creating a Tabbed Notebook: Use the CreateTabBook function to initialize a new tabbed notebook widget.
Adding Tabs: Use the AddTab function to add new tabs to the notebook, specifying the tab title and content.
Removing Tabs: Use the RemoveTab function to remove existing tabs from the notebook.
Setting Active Tab: Use the SetActiveTab function to switch between tabs, making a specific tab active.
Drawing the Tabbed Notebook: Use the DrawTabBook function to render the notebook and its tabs on the screen.

Example Usage:

#include "tabbook.h"

// Function to demonstrate tabbed notebook functionalities
void DemoTabBook() {
    // Create a new tabbed notebook
    TabBook* tabbook = CreateTabBook();
    if (tabbook == NULL) {
        printf("Failed to create tabbed notebook.\n");
        return;
    }

    // Add tabs to the notebook
    AddTab(tabbook, "Tab 1", CreateTabContent1());
    AddTab(tabbook, "Tab 2", CreateTabContent2());
    AddTab(tabbook, "Tab 3", CreateTabContent3());

    // Set the active tab
    SetActiveTab(tabbook, 1);

    // Render the tabbed notebook
    DrawTabBook(tabbook);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate tabbed notebook functionalities
    DemoTabBook();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Tabbed Notebook

CreateTabBook: This function initializes and creates a new tabbed notebook widget. It allocates memory for the notebook structure and sets up the necessary properties for managing tabs.

2. Adding Tabs

AddTab: This function adds a new tab to the tabbed notebook. It takes the notebook object, the title of the tab, and the content to be displayed in the tab as parameters. The content can be any widget or combination of widgets that should be displayed when the tab is active.

3. Removing Tabs

RemoveTab: This function removes an existing tab from the tabbed notebook. It takes the notebook object and the index of the tab to be removed as parameters. The function ensures that memory allocated for the tab content is properly freed.

4. Setting Active Tab

SetActiveTab: This function sets the active tab in the notebook, switching the visible content to the specified tab. It takes the notebook object and the index of the tab to be activated as parameters. This function updates the state of the notebook to reflect the active tab.

5. Drawing the Tabbed Notebook

DrawTabBook: This function renders the tabbed notebook widget on the screen. It draws the tabs, their titles, and the content of the active tab. The function handles the layout and appearance of the notebook, ensuring that tabs are properly displayed and content is correctly rendered.

Example Workflow:

The provided example demonstrates how to use the tabbed notebook functionalities. It shows creating a tabbed notebook, adding tabs with different content, setting the active tab, and rendering the notebook on the screen. This workflow illustrates the complete lifecycle of a tabbed notebook widget within the Aura GUI, demonstrating its practical use for organizing and displaying multiple sections of content.

×

textbox.c

Overview:

The `textbox.c` file is responsible for implementing the functionalities of a textbox widget within the Aura GUI. This widget allows users to input and display text, providing essential features for text manipulation and interaction.

Key Functions:

CreateTextBox: Initializes and creates a new textbox widget.
SetTextBoxText: Sets the text displayed in the textbox.
GetTextBoxText: Retrieves the text currently displayed in the textbox.
DrawTextBox: Renders the textbox widget, including the text and its border.
HandleTextBoxEvent: Handles user interactions and events related to the textbox, such as keyboard input.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: widget.h, graphics.h, events.h

Detailed Workflow:

Creating a Textbox: Use the CreateTextBox function to initialize a new textbox widget.
Setting Text: Use the SetTextBoxText function to set the text displayed in the textbox.
Getting Text: Use the GetTextBoxText function to retrieve the text currently displayed in the textbox.
Drawing the Textbox: Use the DrawTextBox function to render the textbox on the screen.
Handling Events: Use the HandleTextBoxEvent function to process user interactions and events related to the textbox.

Example Usage:

#include "textbox.h"

// Function to demonstrate textbox functionalities
void DemoTextBox() {
    // Create a new textbox
    TextBox* textbox = CreateTextBox();
    if (textbox == NULL) {
        printf("Failed to create textbox.\n");
        return;
    }

    // Set text in the textbox
    SetTextBoxText(textbox, "Hello, Aura GUI!");

    // Render the textbox
    DrawTextBox(textbox);

    // Retrieve and print the text from the textbox
    char* text = GetTextBoxText(textbox);
    printf("Textbox contains: %s\n", text);

    // Free allocated memory for text
    free(text);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate textbox functionalities
    DemoTextBox();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Textbox

CreateTextBox: This function initializes and creates a new textbox widget. It allocates memory for the textbox structure and sets up the necessary properties for managing text input and display.

2. Setting Text

SetTextBoxText: This function sets the text displayed in the textbox. It takes the textbox object and the text string as parameters. The function updates the textbox's internal state to reflect the new text.

3. Getting Text

GetTextBoxText: This function retrieves the text currently displayed in the textbox. It returns a pointer to the text string stored in the textbox's internal state. The caller is responsible for freeing the memory allocated for the returned text.

4. Drawing the Textbox

DrawTextBox: This function renders the textbox widget on the screen. It draws the textbox border, background, and the text inside the textbox. The function handles the layout and appearance of the textbox, ensuring that the text is correctly displayed.

5. Handling Events

HandleTextBoxEvent: This function processes user interactions and events related to the textbox. It handles keyboard input, updating the textbox's text based on user actions. The function ensures that the textbox responds appropriately to user interactions.

Example Workflow:

The provided example demonstrates how to use the textbox functionalities. It shows creating a textbox, setting text, rendering the textbox on the screen, retrieving the text, and printing it. This workflow illustrates the complete lifecycle of a textbox widget within the Aura GUI, demonstrating its practical use for text input and display.

×

theme.c

Overview:

The `theme.c` file is responsible for handling the theme management within the Aura GUI. It provides functionalities to load, apply, and manage themes, allowing for a customizable user interface. Themes can include various elements such as colors, fonts, and widget styles.

Key Functions:

LoadTheme: Loads a theme from a specified file.
ApplyTheme: Applies the currently loaded theme to the GUI.
SetThemeElement: Sets specific elements of the theme, such as colors or fonts.
GetThemeElement: Retrieves the value of specific elements of the theme.
SaveTheme: Saves the current theme to a specified file.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: widget.h, graphics.h, config.h

Detailed Workflow:

Loading a Theme: Use the LoadTheme function to load a theme from a specified file.
Applying a Theme: Use the ApplyTheme function to apply the currently loaded theme to the GUI.
Setting Theme Elements: Use the SetThemeElement function to customize specific elements of the theme.
Getting Theme Elements: Use the GetThemeElement function to retrieve the current values of theme elements.
Saving a Theme: Use the SaveTheme function to save the current theme settings to a file.

Example Usage:

#include "theme.h"

// Function to demonstrate theme functionalities
void DemoTheme() {
    // Load a theme from a file
    if (LoadTheme("default.theme") != 0) {
        printf("Failed to load theme.\n");
        return;
    }

    // Apply the loaded theme to the GUI
    ApplyTheme();

    // Set specific theme elements
    SetThemeElement("background_color", "blue");
    SetThemeElement("font", "Arial");

    // Get and print the current background color
    char* bgColor = GetThemeElement("background_color");
    printf("Current background color: %s\n", bgColor);

    // Save the current theme to a file
    if (SaveTheme("custom.theme") != 0) {
        printf("Failed to save theme.\n");
    }
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate theme functionalities
    DemoTheme();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Loading a Theme

LoadTheme: This function loads a theme from a specified file. It reads the theme configuration and initializes the theme settings. The function ensures that the theme is correctly loaded and ready to be applied to the GUI.

2. Applying a Theme

ApplyTheme: This function applies the currently loaded theme to the GUI. It updates the appearance of the GUI elements based on the theme settings. The function ensures that all relevant GUI components reflect the new theme.

3. Setting Theme Elements

SetThemeElement: This function sets specific elements of the theme, such as colors or fonts. It takes the element name and value as parameters and updates the theme configuration accordingly. The function allows for dynamic customization of the theme.

4. Getting Theme Elements

GetThemeElement: This function retrieves the value of specific elements of the theme. It takes the element name as a parameter and returns the current value of the element. The function allows for querying the current theme settings.

5. Saving a Theme

SaveTheme: This function saves the current theme to a specified file. It writes the theme configuration to the file, allowing for persistent storage of the theme settings. The function ensures that the current theme can be reused or shared.

Example Workflow:

The provided example demonstrates how to use the theme functionalities. It shows loading a theme from a file, applying the theme to the GUI, setting specific theme elements, retrieving theme elements, and saving the theme to a file. This workflow illustrates the complete lifecycle of theme management within the Aura GUI, demonstrating its practical use for customizing the user interface.

×

toolbar.c

Overview:

The `toolbar.c` file is responsible for managing toolbars within the Aura GUI. It provides functionalities to create, manage, and interact with toolbars, which are typically used to hold buttons and other widgets that perform various actions.

Key Functions:

CreateToolbar: Creates a new toolbar.
AddToolbarButton: Adds a button to an existing toolbar.
RemoveToolbarButton: Removes a button from a toolbar.
DrawToolbar: Renders the toolbar on the screen.
HandleToolbarEvent: Handles events such as button clicks within the toolbar.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: widget.h, graphics.h, events.h

Detailed Workflow:

Creating a Toolbar: Use the CreateToolbar function to create a new toolbar instance.
Adding Buttons to the Toolbar: Use the AddToolbarButton function to add buttons to the toolbar.
Removing Buttons from the Toolbar: Use the RemoveToolbarButton function to remove buttons from the toolbar.
Drawing the Toolbar: Use the DrawToolbar function to render the toolbar on the screen.
Handling Toolbar Events: Use the HandleToolbarEvent function to manage events like button clicks within the toolbar.

Example Usage:

#include "toolbar.h"

// Function to demonstrate toolbar functionalities
void DemoToolbar() {
    // Create a new toolbar
    Toolbar* myToolbar = CreateToolbar();

    // Add buttons to the toolbar
    AddToolbarButton(myToolbar, "New", NewButtonHandler);
    AddToolbarButton(myToolbar, "Open", OpenButtonHandler);
    AddToolbarButton(myToolbar, "Save", SaveButtonHandler);

    // Draw the toolbar
    DrawToolbar(myToolbar);

    // Handle events in the main loop
    while (!GSExit) {
        PEvent event = GetNextEvent();
        HandleToolbarEvent(myToolbar, event);
        Yield();
    }

    // Cleanup
    RemoveToolbarButton(myToolbar, "Save");
    DestroyToolbar(myToolbar);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate toolbar functionalities
    DemoToolbar();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Toolbar

CreateToolbar: This function initializes a new toolbar instance. It sets up the necessary data structures and prepares the toolbar for adding buttons and other widgets. The function returns a pointer to the created toolbar.

2. Adding Buttons to the Toolbar

AddToolbarButton: This function adds a button to an existing toolbar. It takes the toolbar instance, button label, and a handler function for the button click event as parameters. The function updates the toolbar to include the new button.

3. Removing Buttons from the Toolbar

RemoveToolbarButton: This function removes a button from a toolbar. It takes the toolbar instance and the button label as parameters. The function updates the toolbar to exclude the specified button.

4. Drawing the Toolbar

DrawToolbar: This function renders the toolbar on the screen. It iterates through the buttons and other widgets in the toolbar and draws them at the appropriate positions. The function ensures that the toolbar is visually represented on the GUI.

5. Handling Toolbar Events

HandleToolbarEvent: This function handles events such as button clicks within the toolbar. It takes the toolbar instance and an event as parameters. The function processes the event and invokes the appropriate handler functions for button clicks and other interactions.

Example Workflow:

The provided example demonstrates how to use the toolbar functionalities. It shows creating a toolbar, adding buttons to it, drawing the toolbar on the screen, handling events within the toolbar, and cleaning up after usage. This workflow illustrates the complete lifecycle of toolbar management within the Aura GUI, demonstrating its practical use for adding toolbars to your applications.

×

treeview.c

Overview:

The `treeview.c` file is responsible for managing tree view widgets within the Aura GUI. It provides functionalities to create, manage, and interact with tree views, which are used to display hierarchical data structures in a graphical format.

Key Functions:

CreateTreeView: Creates a new tree view widget.
AddTreeViewItem: Adds an item to the tree view.
RemoveTreeViewItem: Removes an item from the tree view.
DrawTreeView: Renders the tree view on the screen.
HandleTreeViewEvent: Handles events such as item selection within the tree view.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: widget.h, graphics.h, events.h

Detailed Workflow:

Creating a Tree View: Use the CreateTreeView function to create a new tree view widget.
Adding Items to the Tree View: Use the AddTreeViewItem function to add items to the tree view.
Removing Items from the Tree View: Use the RemoveTreeViewItem function to remove items from the tree view.
Drawing the Tree View: Use the DrawTreeView function to render the tree view on the screen.
Handling Tree View Events: Use the HandleTreeViewEvent function to manage events like item selection within the tree view.

Example Usage:

#include "treeview.h"

// Function to demonstrate tree view functionalities
void DemoTreeView() {
    // Create a new tree view
    TreeView* myTreeView = CreateTreeView();

    // Add items to the tree view
    AddTreeViewItem(myTreeView, "Root");
    AddTreeViewItem(myTreeView, "Root/Child1");
    AddTreeViewItem(myTreeView, "Root/Child2");

    // Draw the tree view
    DrawTreeView(myTreeView);

    // Handle events in the main loop
    while (!GSExit) {
        PEvent event = GetNextEvent();
        HandleTreeViewEvent(myTreeView, event);
        Yield();
    }

    // Cleanup
    RemoveTreeViewItem(myTreeView, "Root/Child2");
    DestroyTreeView(myTreeView);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate tree view functionalities
    DemoTreeView();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Tree View

CreateTreeView: This function initializes a new tree view widget. It sets up the necessary data structures and prepares the tree view for adding items and other interactions. The function returns a pointer to the created tree view.

2. Adding Items to the Tree View

AddTreeViewItem: This function adds an item to an existing tree view. It takes the tree view instance and the item label as parameters. The function updates the tree view to include the new item, maintaining the hierarchical structure.

3. Removing Items from the Tree View

RemoveTreeViewItem: This function removes an item from a tree view. It takes the tree view instance and the item label as parameters. The function updates the tree view to exclude the specified item, ensuring the hierarchical structure remains intact.

4. Drawing the Tree View

DrawTreeView: This function renders the tree view on the screen. It iterates through the items in the tree view and draws them at the appropriate positions, visually representing the hierarchical data structure.

5. Handling Tree View Events

HandleTreeViewEvent: This function handles events such as item selection within the tree view. It takes the tree view instance and an event as parameters. The function processes the event and invokes the appropriate handler functions for item selection and other interactions.

Example Workflow:

The provided example demonstrates how to use the tree view functionalities. It shows creating a tree view, adding items to it, drawing the tree view on the screen, handling events within the tree view, and cleaning up after usage. This workflow illustrates the complete lifecycle of tree view management within the Aura GUI, demonstrating its practical use for displaying and interacting with hierarchical data structures.

×

widget.c

Overview:

The `widget.c` file is a crucial component of the Aura GUI, responsible for managing the base functionalities of widgets. Widgets are the building blocks of the user interface, and this file provides the fundamental operations needed to create, manipulate, and render various widgets in the GUI.

Key Functions:

CreateWidget: Initializes a new widget instance.
DestroyWidget: Cleans up and deallocates a widget instance.
RenderWidget: Renders a widget on the screen.
HandleWidgetEvent: Processes events for a widget.
MoveWidget: Changes the position of a widget on the screen.
ResizeWidget: Adjusts the size of a widget.
ShowWidget: Makes a widget visible.
HideWidget: Hides a widget from view.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: graphics.h, events.h, types.h

Detailed Workflow:

Creating a Widget: Use the CreateWidget function to initialize a new widget instance.
Rendering a Widget: Use the RenderWidget function to draw the widget on the screen.
Handling Widget Events: Use the HandleWidgetEvent function to process user interactions and other events for the widget.
Moving a Widget: Use the MoveWidget function to change the widget's position.
Resizing a Widget: Use the ResizeWidget function to adjust the widget's size.
Showing and Hiding Widgets: Use the ShowWidget and HideWidget functions to control the widget's visibility.

Example Usage:

#include "widget.h"

// Function to demonstrate widget functionalities
void DemoWidget() {
    // Create a new widget
    Widget* myWidget = CreateWidget();

    // Set widget properties
    MoveWidget(myWidget, 100, 100);
    ResizeWidget(myWidget, 200, 100);

    // Show the widget
    ShowWidget(myWidget);

    // Main loop
    while (!GSExit) {
        PEvent event = GetNextEvent();
        HandleWidgetEvent(myWidget, event);
        RenderWidget(myWidget);
        Yield();
    }

    // Cleanup
    HideWidget(myWidget);
    DestroyWidget(myWidget);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate widget functionalities
    DemoWidget();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Widget

CreateWidget: This function initializes a new widget instance. It sets up the necessary data structures and properties for the widget, preparing it for further operations such as rendering and event handling.

2. Rendering a Widget

RenderWidget: This function is responsible for drawing the widget on the screen. It takes into account the widget's properties such as position, size, and visual appearance to render it appropriately.

3. Handling Widget Events

HandleWidgetEvent: This function processes events related to the widget. Events can include user interactions such as mouse clicks and keyboard input, as well as system events that affect the widget's state.

4. Moving a Widget

MoveWidget: This function changes the position of a widget on the screen. It takes the new coordinates as parameters and updates the widget's position accordingly.

5. Resizing a Widget

ResizeWidget: This function adjusts the size of a widget. It takes the new width and height as parameters and resizes the widget to match these dimensions.

6. Showing and Hiding Widgets

ShowWidget and HideWidget: These functions control the visibility of a widget. ShowWidget makes the widget visible on the screen, while HideWidget hides it from view.

Example Workflow:

The provided example demonstrates how to use the widget functionalities. It shows creating a widget, setting its properties, rendering it on the screen, handling events, and cleaning up after usage. This workflow illustrates the complete lifecycle of widget management within the Aura GUI, demonstrating its practical use for building interactive user interfaces.

×

window.c

Overview:

The `window.c` file is responsible for managing window functionalities within the Aura GUI. Windows serve as the primary containers for other GUI components, providing the structure for user interfaces. This file includes functions for creating, displaying, resizing, and interacting with windows.

Key Functions:

CreateWindow: Initializes a new window instance.
DestroyWindow: Cleans up and deallocates a window instance.
RenderWindow: Renders a window on the screen.
HandleWindowEvent: Processes events for a window.
MoveWindow: Changes the position of a window on the screen.
ResizeWindow: Adjusts the size of a window.
ShowWindow: Makes a window visible.
HideWindow: Hides a window from view.

Dependencies:

Standard Libraries: <stdio.h>, <stdlib.h>, <string.h>
Project-Specific Headers: graphics.h, events.h, types.h, widget.h

Detailed Workflow:

Creating a Window: Use the CreateWindow function to initialize a new window instance.
Rendering a Window: Use the RenderWindow function to draw the window on the screen.
Handling Window Events: Use the HandleWindowEvent function to process user interactions and other events for the window.
Moving a Window: Use the MoveWindow function to change the window's position.
Resizing a Window: Use the ResizeWindow function to adjust the window's size.
Showing and Hiding Windows: Use the ShowWindow and HideWindow functions to control the window's visibility.

Example Usage:

#include "window.h"

// Function to demonstrate window functionalities
void DemoWindow() {
    // Create a new window
    Window* myWindow = CreateWindow("Demo Window", 100, 100, 400, 300);

    // Show the window
    ShowWindow(myWindow);

    // Main loop
    while (!GSExit) {
        PEvent event = GetNextEvent();
        HandleWindowEvent(myWindow, event);
        RenderWindow(myWindow);
        Yield();
    }

    // Cleanup
    HideWindow(myWindow);
    DestroyWindow(myWindow);
}

// Main function
int main() {
    // Initialize the system
    InitSystem();

    // Demonstrate window functionalities
    DemoWindow();

    // Shutdown the system
    ShutdownSystem();

    return 0;
}

Detailed Description:

1. Creating a Window

CreateWindow: This function initializes a new window instance. It sets up the necessary data structures and properties for the window, preparing it for further operations such as rendering and event handling.

2. Rendering a Window

RenderWindow: This function is responsible for drawing the window on the screen. It takes into account the window's properties such as position, size, and visual appearance to render it appropriately.

3. Handling Window Events

HandleWindowEvent: This function processes events related to the window. Events can include user interactions such as mouse clicks and keyboard input, as well as system events that affect the window's state.

4. Moving a Window

MoveWindow: This function changes the position of a window on the screen. It takes the new coordinates as parameters and updates the window's position accordingly.

5. Resizing a Window

ResizeWindow: This function adjusts the size of a window. It takes the new width and height as parameters and resizes the window to match these dimensions.

6. Showing and Hiding Windows

ShowWindow and HideWindow: These functions control the visibility of a window. ShowWindow makes the window visible on the screen, while HideWindow hides it from view.

Example Workflow:

The provided example demonstrates how to use the window functionalities. It shows creating a window, setting its properties, rendering it on the screen, handling events, and cleaning up after usage. This workflow illustrates the complete lifecycle of window management within the Aura GUI, demonstrating its practical use for building interactive user interfaces.

×

Xlib System

A list of all documented functions, variables, defines, enums, and typedefs.

Detailed description and breakdown of how the functions work in the code, what they do, and how to use them.

alert.c

Functions:
- void ShowAlert(const char* title, const char* message)
- void HideAlert()

button.c

Functions:
- Button* CreateButton(const char* text, int x, int y, int width, int height)
- void DestroyButton(Button* button)
- void RenderButton(Button* button)
- void HandleButtonEvent(Button* button, PEvent event)
Variables:
- typedef struct { ... } Button;

canvas.c

Functions:
- Canvas* CreateCanvas(int x, int y, int width, int height)
- void DestroyCanvas(Canvas* canvas)
- void RenderCanvas(Canvas* canvas)
- void DrawOnCanvas(Canvas* canvas, int x, int y, int color)
Variables:
- typedef struct { ... } Canvas;

checkbox.c

Functions:
- Checkbox* CreateCheckbox(const char* text, int x, int y)
- void DestroyCheckbox(Checkbox* checkbox)
- void RenderCheckbox(Checkbox* checkbox)
- void HandleCheckboxEvent(Checkbox* checkbox, PEvent event)
Variables:
- typedef struct { ... } Checkbox;

colsel.c

Functions:
- ColorSelector* CreateColorSelector(int x, int y)
- void DestroyColorSelector(ColorSelector* colorSelector)
- void RenderColorSelector(ColorSelector* colorSelector)
- void HandleColorSelectorEvent(ColorSelector* colorSelector, PEvent event)
Variables:
- typedef struct { ... } ColorSelector;

combobox.c

Functions:
- Combobox* CreateCombobox(int x, int y, int width, int height)
- void DestroyCombobox(Combobox* combobox)
- void RenderCombobox(Combobox* combobox)
- void HandleComboboxEvent(Combobox* combobox, PEvent event)
Variables:
- typedef struct { ... } Combobox;

conlib.c

Functions:
- void InitializeConsole()
- void ShutdownConsole()
- void PrintToConsole(const char* message)

cp.c

Functions:
- void CopyToClipboard(const char* data)
- char* GetFromClipboard()

fms2.c

Functions:
- FileSystem* InitializeFileSystem()
- void ShutdownFileSystem(FileSystem* fs)
- File* OpenFile(FileSystem* fs, const char* path, const char* mode)
- void CloseFile(File* file)
Variables:
- typedef struct { ... } FileSystem;
- typedef struct { ... } File;

fprop.c

Functions:
- FileProperties* GetFileProperties(const char* path)
- void SetFileProperties(const char* path, FileProperties* properties)
Variables:
- typedef struct { ... } FileProperties;

grfx.c

Functions:
- void InitializeGraphics()
- void ShutdownGraphics()
- void DrawPixel(int x, int y, int color)
- void DrawLine(int x1, int y1, int x2, int y2, int color)

groupbox.c

Functions:
- Groupbox* CreateGroupbox(const char* text, int x, int y, int width, int height)
- void DestroyGroupbox(Groupbox* groupbox)
- void RenderGroupbox(Groupbox* groupbox)
Variables:
- typedef struct { ... } Groupbox;

iodlg.c

Functions:
- IODialog* CreateIODialog(int x, int y, int width, int height)
- void DestroyIODialog(IODialog* dialog)
- void RenderIODialog(IODialog* dialog)
- void HandleIODialogEvent(IODialog* dialog, PEvent event)
Variables:
- typedef struct { ... } IODialog;

iodlg2.c

Functions:
- IODialog2* CreateIODialog2(int x, int y, int width, int height)
- void DestroyIODialog2(IODialog2* dialog)
- void RenderIODialog2(IODialog2* dialog)
- void HandleIODialog2Event(IODialog2* dialog, PEvent event)
Variables:
- typedef struct { ... } IODialog2;

label.c

Functions:
- Label* CreateLabel(const char* text, int x, int y)
- void DestroyLabel(Label* label)
- void RenderLabel(Label* label)
Variables:
- typedef struct { ... } Label;

listbox.c

Functions:
- Listbox* CreateListbox(int x, int y, int width, int height)
- void DestroyListbox(Listbox* listbox)
- void RenderListbox(Listbox* listbox)
- void HandleListboxEvent(Listbox* listbox, PEvent event)
Variables:
- typedef struct { ... } Listbox;

listview.c

Functions:
- ListView* CreateListView(int x, int y, int width, int height)
- void DestroyListView(ListView* listView)
- void RenderListView(ListView* listView)
- void HandleListViewEvent(ListView* listView, PEvent event)
Variables:
- typedef struct { ... } ListView;

memfile.c

Functions:
- MemFile* OpenMemFile(const char* path)
- void CloseMemFile(MemFile* memFile)
- size_t ReadMemFile(MemFile* memFile, void* buffer, size_t size)
- size_t WriteMemFile(MemFile* memFile, const void* buffer, size_t size)
Variables:
- typedef struct { ... } MemFile;

menu.c

Functions:
- Menu* CreateMenu(int x, int y, int width, int height)
- void DestroyMenu(Menu* menu)
- void RenderMenu(Menu* menu)
- void HandleMenuEvent(Menu* menu, PEvent event)
Variables:
- typedef struct { ... } Menu;

prevscr.c

Functions:
- PreviewScreen* CreatePreviewScreen(int x, int y, int width, int height)
- void DestroyPreviewScreen(PreviewScreen* screen)
- void RenderPreviewScreen(PreviewScreen* screen)
- void HandlePreviewScreenEvent(PreviewScreen* screen, PEvent event)
Variables:
- typedef struct { ... } PreviewScreen;

progress.c

Functions:
- ProgressBar* CreateProgressBar(int x, int y, int width, int height)
- void DestroyProgressBar(ProgressBar* progressBar)
- void RenderProgressBar(ProgressBar* progressBar)
- void SetProgressBarValue(ProgressBar* progressBar, int value)
Variables:
- typedef struct { ... } ProgressBar;

scrllbar.c

Functions:
- Scrollbar* CreateScrollbar(int x, int y, int width, int height)
- void DestroyScrollbar(Scrollbar* scrollbar)
- void RenderScrollbar(Scrollbar* scrollbar)
- void SetScrollbarPosition(Scrollbar* scrollbar, int position)
Variables:
- typedef struct { ... } Scrollbar;

skin.c

Functions:
- void LoadSkin(const char* path)
- void ApplySkin()

slider.c

Functions:
- Slider* CreateSlider(int x, int y, int width, int height)
- void DestroySlider(Slider* slider)
- void RenderSlider(Slider* slider)
- void HandleSliderEvent(Slider* slider, PEvent event)
- void SetSliderValue(Slider* slider, int value)
Variables:
- typedef struct { ... } Slider;

sound.c

Functions:
- void InitializeSound()
- void ShutdownSound()
- void PlaySound(const char* path)

tabbook.c

Functions:
- TabBook* CreateTabBook(int x, int y, int width, int height)
- void DestroyTabBook(TabBook* tabBook)
- void RenderTabBook(TabBook* tabBook)
- void AddTab(TabBook* tabBook, const char* title)
- void RemoveTab(TabBook* tabBook, const char* title)
Variables:
- typedef struct { ... } TabBook;

textbox.c

Functions:
- TextBox* CreateTextBox(int x, int y, int width, int height)
- void DestroyTextBox(TextBox* textBox)
- void RenderTextBox(TextBox* textBox)
- void HandleTextBoxEvent(TextBox* textBox, PEvent event)
Variables:
- typedef struct { ... } TextBox;

theme.c

Functions:
- void LoadTheme(const char* path)
- void ApplyTheme()

toolbar.c

Functions:
- ToolBar* CreateToolBar(int x, int y, int width, int height)
- void DestroyToolBar(ToolBar* toolBar)
- void RenderToolBar(ToolBar* toolBar)
- void AddTool(ToolBar* toolBar, const char* toolName)
- void RemoveTool(ToolBar* toolBar, const char* toolName)
Variables:
- typedef struct { ... } ToolBar;

treeview.c

Functions:
- TreeView* CreateTreeView(int x, int y, int width, int height)
- void DestroyTreeView(TreeView* treeView)
- void RenderTreeView(TreeView* treeView)
- void AddTreeNode(TreeView* treeView, const char* nodeName)
- void RemoveTreeNode(TreeView* treeView, const char* nodeName)
Variables:
- typedef struct { ... } TreeView;

widget.c

Functions:
- Widget* CreateWidget(int x, int y, int width, int height)
- void DestroyWidget(Widget* widget)
- void RenderWidget(Widget* widget)
- void HandleWidgetEvent(Widget* widget, PEvent event)
Variables:
- typedef struct { ... } Widget;

window.c

Functions:
- Window* CreateWindow(const char* title, int x, int y, int width, int height)
- void DestroyWindow(Window* window)
- void RenderWindow(Window* window)
- void HandleWindowEvent(Window* window, PEvent event)
Variables:
- typedef struct { ... } Window;

×

Illkirch IDE (illkirch)

A detailed list of all documented functions, variables, defines, enums, and typedefs in the illkirch folder.

Each file in this folder is critical for the overall functionality of the Illkirch IDE. Below is a detailed description and breakdown of how the functions work in the code, what they do, and how to use them.

about.c

Implements the About dialog, providing information about the Illkirch IDE and its features.

Functions:
- void ShowAboutDialog(void): Displays the About dialog with IDE information.

devclass.c

Handles the development class functionalities, managing various development tasks and processes.

Functions:
- void InitializeDevClass(void): Initializes the development class system.
- void RegisterDevClass(DevClass* devClass): Registers a new development class.
Data Structures:
- typedef struct DevClass: Represents a development class.

devwdg.c

Implements widget development functionalities, allowing users to create and manage custom widgets within the IDE.

Functions:
- void CreateWidget(Widget* widget): Creates a new widget in the IDE.
- void DeleteWidget(Widget* widget): Deletes a widget from the IDE.
Data Structures:
- typedef struct Widget: Represents a custom widget.

file_handler.c

Handles file operations such as opening, reading, and writing files used within the IDE.

Functions:
- File* OpenFile(const char* filePath, const char* mode): Opens a file with the specified mode.
- void CloseFile(File* file): Closes an open file.
Data Structures:
- typedef struct File: Represents a file object.

gwidget.c

Implements general widget functionalities, providing base functionalities for all widgets in the IDE.

Functions:
- void InitGWidgetSystem(void): Initializes the general widget system.
- void DrawWidget(Widget* widget): Draws a widget on the screen.
Data Structures:
- typedef struct GWidget: Represents a general widget.

gwidget.h

Header file for gwidget.c, defining the structures and functions used for widget management.

Defines:
- #define MAX_WIDGETS 100: Maximum number of widgets.
Typedefs:
- typedef struct GWidget GWidget;

illkirch.h

Main header file for the Illkirch IDE, including all necessary includes and definitions for the IDE.

Defines:
- #define ILLKIRCH_VERSION "1.0": Defines the version of the Illkirch IDE.
Typedefs:
- typedef struct IllkirchConfig: Represents the configuration for the Illkirch IDE.

main.c

Main entry point for the Illkirch IDE, initializing the system, setting up the main window, and starting the event loop.

Functions:
- int main(int argc, char* argv[]): Main function, initializes and starts the IDE.

menuedit.c

Implements menu editing functionalities, allowing users to create and manage custom menus within the IDE.

Functions:
- void AddMenuItem(Menu* menu, MenuItem* item): Adds a menu item to a menu.
- void RemoveMenuItem(Menu* menu, MenuItem* item): Removes a menu item from a menu.
Data Structures:
- typedef struct Menu: Represents a menu.
- typedef struct MenuItem: Represents an item in a menu.

msgman.c

Handles message management, providing functionalities for displaying and managing messages and notifications.

Functions:
- void ShowMessage(const char* message): Displays a message to the user.
- void ClearMessages(void): Clears all messages.

viewprop.c

Implements view properties management, allowing users to configure and manage properties of various views within the IDE.

Functions:
- void SetViewProperty(View* view, const char* property, const char* value): Sets a property for a view.
- void GetViewProperty(View* view, const char* property, char* value): Gets a property value for a view.
Data Structures:
- typedef struct View: Represents a view in the IDE.

×

Illkirch IDE (illkirch)

A detailed list of all documented functions, variables, defines, enums, and typedefs in the illkirch folder.

Each file in this folder is critical for the overall functionality of the Illkirch IDE. Below is a detailed description and breakdown of how the functions work in the code, what they do, and how to use them.

about.c

Implements the About dialog, providing information about the Illkirch IDE and its features.

Functions:
- void ShowAboutDialog(void): Displays the About dialog with IDE information.

devclass.c

Handles the development class functionalities, managing various development tasks and processes.

Functions:
- void InitializeDevClass(void): Initializes the development class system.
- void RegisterDevClass(DevClass* devClass): Registers a new development class.
Data Structures:
- typedef struct DevClass: Represents a development class.

devwdg.c

Implements widget development functionalities, allowing users to create and manage custom widgets within the IDE.

Functions:
- void CreateWidget(Widget* widget): Creates a new widget in the IDE.
- void DeleteWidget(Widget* widget): Deletes a widget from the IDE.
Data Structures:
- typedef struct Widget: Represents a custom widget.

file_handler.c

Handles file operations such as opening, reading, and writing files used within the IDE.

Functions:
- File* OpenFile(const char* filePath, const char* mode): Opens a file with the specified mode.
- void CloseFile(File* file): Closes an open file.
Data Structures:
- typedef struct File: Represents a file object.

gwidget.c

Implements general widget functionalities, providing base functionalities for all widgets in the IDE.

Functions:
- void InitGWidgetSystem(void): Initializes the general widget system.
- void DrawWidget(Widget* widget): Draws a widget on the screen.
Data Structures:
- typedef struct GWidget: Represents a general widget.

gwidget.h

Header file for gwidget.c, defining the structures and functions used for widget management.

Defines:
- #define MAX_WIDGETS 100: Maximum number of widgets.
Typedefs:
- typedef struct GWidget GWidget;

illkirch.h

Main header file for the Illkirch IDE, including all necessary includes and definitions for the IDE.

Defines:
- #define ILLKIRCH_VERSION "1.0": Defines the version of the Illkirch IDE.
Typedefs:
- typedef struct IllkirchConfig: Represents the configuration for the Illkirch IDE.

main.c

Main entry point for the Illkirch IDE, initializing the system, setting up the main window, and starting the event loop.

Functions:
- int main(int argc, char* argv[]): Main function, initializes and starts the IDE.

menuedit.c

Implements menu editing functionalities, allowing users to create and manage custom menus within the IDE.

Functions:
- void AddMenuItem(Menu* menu, MenuItem* item): Adds a menu item to a menu.
- void RemoveMenuItem(Menu* menu, MenuItem* item): Removes a menu item from a menu.
Data Structures:
- typedef struct Menu: Represents a menu.
- typedef struct MenuItem: Represents an item in a menu.

msgman.c

Handles message management, providing functionalities for displaying and managing messages and notifications.

Functions:
- void ShowMessage(const char* message): Displays a message to the user.
- void ClearMessages(void): Clears all messages.

viewprop.c

Implements view properties management, allowing users to configure and manage properties of various views within the IDE.

Functions:
- void SetViewProperty(View* view, const char* property, const char* value): Sets a property for a view.
- void GetViewProperty(View* view, const char* property, char* value): Gets a property value for a view.
Data Structures:
- typedef struct View: Represents a view in the IDE.

Aura GUI Programmer's Guide

Project Structure Overview

bin

bin/desktop

bin/res

djgpp

djgpp/allegro

djgpp/bin

include

include/alfont

include/algif

lib

obj

res

src

src/xlib

src/xapps

src/illkirch

zlib

Aura GUI Programmer's Guide

Project Structure Overview

bin

bin/desktop

bin/res

djgpp

djgpp/allegro

djgpp/bin

include

include/alfont

include/algif

lib

obj

res

src

src/xlib

src/xapps

src/illkirch

zlib

Source Code (src)

debug.c

devload.asm

dms.c

dms2.c

dynld.c

dynldlnk.c

error.c

events.c

exports.c

font.c

grfx2.c

image.c

ini.c

keyboard.c

list.c

main.c

metrics.c

mouse.c

mutex.c

pdcurseswrapper.h

recource.c

registry.c

resource.c

screen.c

tasks.c

text.c

thread.c

timer.c

utext.c

vfile.c

win32fix.c

allegrowrapper.h

aura_root.zip

debug.c

devload.asm

dms.c

1. Initialization Functions

2. Data Loading and Saving

3. Data Manipulation Functions

4. Query and Search Functions

5. Cleanup and Shutdown

dms2.c

1. Enhanced Data Loading

2. Advanced Data Manipulation

3. Performance Optimization

4. Extended Query Functions

5. Improved Error Handling and Logging

dynld.c

1. Loading Modules

2. Unloading Modules

3. Retrieving Symbols

4. Initializing Modules

5. Listing Loaded Modules

dynldlnk.c

1. Resolving Symbols

2. Checking Dependencies

3. Registering Modules

4. Unregistering Modules

5. Retrieving Module Information

error.c