Mouse / Keyboard: add new modules

src/common/modules.c

@@ -73,6 +73,7 @@ static FFModuleBaseInfo* J[] = {
 
 static FFModuleBaseInfo* K[] = {
     (void*) &instance.config.modules.kernel,
+    (void*) &instance.config.modules.keyboard,
     NULL,
 };
 
@@ -88,6 +89,7 @@ static FFModuleBaseInfo* M[] = {
     (void*) &instance.config.modules.media,
     (void*) &instance.config.modules.memory,
     (void*) &instance.config.modules.monitor,
+    (void*) &instance.config.modules.mouse,
     NULL,
 };
 

src/detection/gamepad/gamepad_linux.c

@@ -68,7 +68,7 @@ const char* ffDetectGamepad(FFlist* devices /* List of FFGamepadDevice */)
     {
         if (!ffStrStartsWith(entry->d_name, "js"))
             continue;
-        if (!ffCharIsDigit(entry->d_name[2]))
+        if (!ffCharIsDigit(entry->d_name[strlen("js")]))
             continue;
 
         ffStrbufAppendS(&path, entry->d_name);

src/detection/keyboard/keyboard.h

@@ -0,0 +1,9 @@
+#include "fastfetch.h"
+
+typedef struct FFKeyboardDevice
+{
+    FFstrbuf serial;
+    FFstrbuf name;
+} FFKeyboardDevice;
+
+const char* ffDetectKeyboard(FFlist* devices /* List of FFKeyboardDevice */);

src/detection/keyboard/keyboard_apple.c

@@ -0,0 +1,54 @@
+#include "keyboard.h"
+#include "util/apple/cf_helpers.h"
+#include "util/mallocHelper.h"
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDLib.h>
+
+static void enumSet(IOHIDDeviceRef value, FFlist* results)
+{
+    FFKeyboardDevice* device = (FFKeyboardDevice*) ffListAdd(results);
+    ffStrbufInit(&device->serial);
+    ffStrbufInit(&device->name);
+
+    CFStringRef manufacturer = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDManufacturerKey));
+    ffCfStrGetString(manufacturer, &device->name);
+
+    CFStringRef product = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDProductKey));
+    if (device->name.length)
+    {
+        ffCfStrGetString(product, &device->serial);
+        ffStrbufAppendC(&device->name, ' ');
+        ffStrbufAppend(&device->name, &device->serial);
+    }
+    else
+    {
+        ffCfStrGetString(product, &device->name);
+    }
+
+    CFStringRef serialNumber = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDSerialNumberKey));
+    ffCfStrGetString(serialNumber, &device->serial);
+}
+
+const char* ffDetectKeyboard(FFlist* devices /* List of FFKeyboardDevice */)
+{
+    IOHIDManagerRef FF_CFTYPE_AUTO_RELEASE manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+    if (IOHIDManagerOpen(manager, kIOHIDOptionsTypeNone) != kIOReturnSuccess)
+        return "IOHIDManagerOpen() failed";
+
+    CFDictionaryRef FF_CFTYPE_AUTO_RELEASE matching1 = CFDictionaryCreate(kCFAllocatorDefault, (const void **)(CFStringRef[]){
+        CFSTR(kIOHIDDeviceUsagePageKey),
+        CFSTR(kIOHIDDeviceUsageKey)
+    }, (const void **)(CFNumberRef[]){
+        ffCfCreateInt(kHIDPage_GenericDesktop),
+        ffCfCreateInt(kHIDUsage_GD_Keyboard)
+    }, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    IOHIDManagerSetDeviceMatching(manager, matching1);
+
+    CFSetRef FF_CFTYPE_AUTO_RELEASE set = IOHIDManagerCopyDevices(manager);
+    if (set)
+        CFSetApplyFunction(set, (CFSetApplierFunction) &enumSet, devices);
+    IOHIDManagerClose(manager, kIOHIDOptionsTypeNone);
+
+    return NULL;
+}

src/detection/keyboard/keyboard_linux.c

@@ -0,0 +1,57 @@
+#include "keyboard.h"
+#include "common/io/io.h"
+#include "util/stringUtils.h"
+
+const char* ffDetectKeyboard(FFlist* devices /* List of FFKeyboardDevice */)
+{
+    // There is no /sys/class/input/kbd* on Linux
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir("/dev/input/by-path/");
+    if (dirp == NULL)
+        return "opendir(\"/dev/input/by-path/\") == NULL";
+
+    uint64_t flags = 0;
+
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
+
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (!ffStrEndsWith(entry->d_name, "-event-kbd"))
+            continue;
+
+        char buffer[32]; // `../eventX`
+        ssize_t len = readlinkat(dirfd(dirp), entry->d_name, buffer, sizeof(buffer) - 1);
+        if (len != strlen("../eventX") || !ffStrStartsWith(buffer, "../event")) continue;
+        buffer[len] = 0;
+
+        const char* eventid = buffer + strlen("../event");
+
+        char* pend = NULL;
+        uint32_t index = (uint32_t) strtoul(eventid, &pend, 10);
+        if (pend == eventid) continue;
+
+        // Ignore duplicate entries
+        if (flags & (1 << index))
+            continue;
+        flags |= (1 << index);
+
+        ffStrbufSetF(&path, "/sys/class/input/event%s/device/name", eventid);
+
+        FF_STRBUF_AUTO_DESTROY name = ffStrbufCreate();
+        if (ffAppendFileBuffer(path.chars, &name))
+        {
+            ffStrbufTrimRightSpace(&name);
+            ffStrbufSubstrBefore(&path, path.length - 4);
+
+            FFKeyboardDevice* device = (FFKeyboardDevice*) ffListAdd(devices);
+            ffStrbufInitMove(&device->name, &name);
+            ffStrbufInit(&device->serial);
+
+            ffStrbufAppendS(&path, "uniq");
+            if (ffAppendFileBuffer(path.chars, &device->serial))
+                ffStrbufTrimRightSpace(&device->serial);
+        }
+    }
+
+    return NULL;
+}

src/detection/mouse/mouse.h

@@ -0,0 +1,9 @@
+#include "fastfetch.h"
+
+typedef struct FFMouseDevice
+{
+    FFstrbuf serial;
+    FFstrbuf name;
+} FFMouseDevice;
+
+const char* ffDetectMouse(FFlist* devices /* List of FFMouseDevice */);

src/detection/mouse/mouse_apple.c

@@ -0,0 +1,54 @@
+#include "mouse.h"
+#include "util/apple/cf_helpers.h"
+#include "util/mallocHelper.h"
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDLib.h>
+
+static void enumSet(IOHIDDeviceRef value, FFlist* results)
+{
+    FFMouseDevice* device = (FFMouseDevice*) ffListAdd(results);
+    ffStrbufInit(&device->serial);
+    ffStrbufInit(&device->name);
+
+    CFStringRef manufacturer = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDManufacturerKey));
+    ffCfStrGetString(manufacturer, &device->name);
+
+    CFStringRef product = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDProductKey));
+    if (device->name.length)
+    {
+        ffCfStrGetString(product, &device->serial);
+        ffStrbufAppendC(&device->name, ' ');
+        ffStrbufAppend(&device->name, &device->serial);
+    }
+    else
+    {
+        ffCfStrGetString(product, &device->name);
+    }
+
+    CFStringRef serialNumber = IOHIDDeviceGetProperty(value, CFSTR(kIOHIDSerialNumberKey));
+    ffCfStrGetString(serialNumber, &device->serial);
+}
+
+const char* ffDetectMouse(FFlist* devices /* List of FFMouseDevice */)
+{
+    IOHIDManagerRef FF_CFTYPE_AUTO_RELEASE manager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+    if (IOHIDManagerOpen(manager, kIOHIDOptionsTypeNone) != kIOReturnSuccess)
+        return "IOHIDManagerOpen() failed";
+
+    CFDictionaryRef FF_CFTYPE_AUTO_RELEASE matching1 = CFDictionaryCreate(kCFAllocatorDefault, (const void **)(CFStringRef[]){
+        CFSTR(kIOHIDDeviceUsagePageKey),
+        CFSTR(kIOHIDDeviceUsageKey)
+    }, (const void **)(CFNumberRef[]){
+        ffCfCreateInt(kHIDPage_GenericDesktop),
+        ffCfCreateInt(kHIDUsage_GD_Mouse)
+    }, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+    IOHIDManagerSetDeviceMatching(manager, matching1);
+
+    CFSetRef FF_CFTYPE_AUTO_RELEASE set = IOHIDManagerCopyDevices(manager);
+    if (set)
+        CFSetApplyFunction(set, (CFSetApplierFunction) &enumSet, devices);
+    IOHIDManagerClose(manager, kIOHIDOptionsTypeNone);
+
+    return NULL;
+}

src/detection/mouse/mouse_linux.c

@@ -0,0 +1,44 @@
+#include "mouse.h"
+#include "common/io/io.h"
+#include "util/stringUtils.h"
+
+const char* ffDetectMouse(FFlist* devices /* List of FFMouseDevice */)
+{
+    FF_AUTO_CLOSE_DIR DIR* dirp = opendir("/sys/class/input/");
+    if (dirp == NULL)
+        return "opendir(\"/sys/class/input/\") == NULL";
+
+    FF_STRBUF_AUTO_DESTROY path = ffStrbufCreateS("/sys/class/input/");
+    uint32_t baseLen = path.length;
+
+    struct dirent* entry;
+    while ((entry = readdir(dirp)) != NULL)
+    {
+        if (!ffStrStartsWith(entry->d_name, "mouse"))
+            continue;
+        if (!ffCharIsDigit(entry->d_name[strlen("mouse")]))
+            continue;
+
+        ffStrbufAppendS(&path, entry->d_name);
+        ffStrbufAppendS(&path, "/device/name");
+
+        FF_STRBUF_AUTO_DESTROY name = ffStrbufCreate();
+        if (ffAppendFileBuffer(path.chars, &name))
+        {
+            ffStrbufTrimRightSpace(&name);
+            ffStrbufSubstrBefore(&path, path.length - 4);
+
+            FFMouseDevice* device = (FFMouseDevice*) ffListAdd(devices);
+            ffStrbufInitMove(&device->name, &name);
+            ffStrbufInit(&device->serial);
+
+            ffStrbufAppendS(&path, "uniq");
+            if (ffAppendFileBuffer(path.chars, &device->serial))
+                ffStrbufTrimRightSpace(&device->serial);
+        }
+
+        ffStrbufSubstrBefore(&path, baseLen);
+    }
+
+    return NULL;
+}

src/modules/keyboard/keyboard.c

@@ -0,0 +1,142 @@
+#include "common/percent.h"
+#include "common/printing.h"
+#include "common/jsonconfig.h"
+#include "detection/keyboard/keyboard.h"
+#include "modules/keyboard/keyboard.h"
+#include "util/stringUtils.h"
+
+#define FF_KEYBOARD_NUM_FORMAT_ARGS 2
+
+static void printDevice(FFKeyboardOptions* options, const FFKeyboardDevice* device, uint8_t index)
+{
+    if(options->moduleArgs.outputFormat.length == 0)
+    {
+        ffPrintLogoAndKey(FF_KEYBOARD_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
+        ffStrbufPutTo(&device->name, stdout);
+    }
+    else
+    {
+        FF_PRINT_FORMAT_CHECKED(FF_KEYBOARD_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_KEYBOARD_NUM_FORMAT_ARGS, ((FFformatarg[]) {
+            FF_FORMAT_ARG(device->name, "name"),
+            FF_FORMAT_ARG(device->serial, "serial"),
+        }));
+    }
+}
+
+void ffPrintKeyboard(FFKeyboardOptions* options)
+{
+    FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFKeyboardDevice));
+
+    const char* error = ffDetectKeyboard(&result);
+
+    if(error)
+    {
+        ffPrintError(FF_KEYBOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
+        return;
+    }
+
+    if(!result.length)
+    {
+        ffPrintError(FF_KEYBOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No devices detected");
+        return;
+    }
+
+    uint8_t index = 0;
+    FF_LIST_FOR_EACH(FFKeyboardDevice, device, result)
+    {
+        printDevice(options, device, result.length > 1 ? ++index : 0);
+        ffStrbufDestroy(&device->serial);
+        ffStrbufDestroy(&device->name);
+    }
+}
+
+bool ffParseKeyboardCommandOptions(FFKeyboardOptions* options, const char* key, const char* value)
+{
+    const char* subKey = ffOptionTestPrefix(key, FF_KEYBOARD_MODULE_NAME);
+    if (!subKey) return false;
+    if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
+        return true;
+
+    return false;
+}
+
+void ffParseKeyboardJsonObject(FFKeyboardOptions* options, yyjson_val* module)
+{
+    yyjson_val *key_, *val;
+    size_t idx, max;
+    yyjson_obj_foreach(module, idx, max, key_, val)
+    {
+        const char* key = yyjson_get_str(key_);
+        if(ffStrEqualsIgnCase(key, "type"))
+            continue;
+
+        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
+            continue;
+
+        ffPrintError(FF_KEYBOARD_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
+    }
+}
+
+void ffGenerateKeyboardJsonConfig(FFKeyboardOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    __attribute__((__cleanup__(ffDestroyKeyboardOptions))) FFKeyboardOptions defaultOptions;
+    ffInitKeyboardOptions(&defaultOptions);
+
+    ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
+}
+
+void ffGenerateKeyboardJsonResult(FF_MAYBE_UNUSED FFKeyboardOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFKeyboardDevice));
+
+    const char* error = ffDetectKeyboard(&result);
+
+    if(error)
+    {
+        yyjson_mut_obj_add_str(doc, module, "error", error);
+        return;
+    }
+
+    yyjson_mut_val* arr = yyjson_mut_obj_add_arr(doc, module, "result");
+    FF_LIST_FOR_EACH(FFKeyboardDevice, device, result)
+    {
+        yyjson_mut_val* obj = yyjson_mut_arr_add_obj(doc, arr);
+        yyjson_mut_obj_add_strbuf(doc, obj, "serial", &device->serial);
+        yyjson_mut_obj_add_strbuf(doc, obj, "name", &device->name);
+    }
+
+    FF_LIST_FOR_EACH(FFKeyboardDevice, device, result)
+    {
+        ffStrbufDestroy(&device->serial);
+        ffStrbufDestroy(&device->name);
+    }
+}
+
+void ffPrintKeyboardHelpFormat(void)
+{
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_KEYBOARD_MODULE_NAME, "{1} ({3})", FF_KEYBOARD_NUM_FORMAT_ARGS, ((const char* []) {
+        "Name - name",
+        "Serial number - serial",
+    }));
+}
+
+void ffInitKeyboardOptions(FFKeyboardOptions* options)
+{
+    ffOptionInitModuleBaseInfo(
+        &options->moduleInfo,
+        FF_KEYBOARD_MODULE_NAME,
+        "List connected keyboards",
+        ffParseKeyboardCommandOptions,
+        ffParseKeyboardJsonObject,
+        ffPrintKeyboard,
+        ffGenerateKeyboardJsonResult,
+        ffPrintKeyboardHelpFormat,
+        ffGenerateKeyboardJsonConfig
+    );
+    ffOptionInitModuleArg(&options->moduleArgs, "");
+}
+
+void ffDestroyKeyboardOptions(FFKeyboardOptions* options)
+{
+    ffOptionDestroyModuleArg(&options->moduleArgs);
+}

src/modules/keyboard/keyboard.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "fastfetch.h"
+
+#define FF_KEYBOARD_MODULE_NAME "Keyboard"
+
+void ffPrintKeyboard(FFKeyboardOptions* options);
+void ffInitKeyboardOptions(FFKeyboardOptions* options);
+void ffDestroyKeyboardOptions(FFKeyboardOptions* options);

src/modules/keyboard/option.h

@@ -0,0 +1,11 @@
+#pragma once
+
+// This file will be included in "fastfetch.h", do NOT put unnecessary things here
+
+#include "common/option.h"
+
+typedef struct FFKeyboardOptions
+{
+    FFModuleBaseInfo moduleInfo;
+    FFModuleArgs moduleArgs;
+} FFKeyboardOptions;

src/modules/modules.h

@@ -34,6 +34,7 @@
 #include "modules/icons/icons.h"
 #include "modules/initsystem/initsystem.h"
 #include "modules/kernel/kernel.h"
+#include "modules/keyboard/keyboard.h"
 #include "modules/lm/lm.h"
 #include "modules/loadavg/loadavg.h"
 #include "modules/locale/locale.h"
@@ -41,6 +42,7 @@
 #include "modules/media/media.h"
 #include "modules/memory/memory.h"
 #include "modules/monitor/monitor.h"
+#include "modules/mouse/mouse.h"
 #include "modules/netio/netio.h"
 #include "modules/opengl/opengl.h"
 #include "modules/opencl/opencl.h"

src/modules/mouse/mouse.c

@@ -0,0 +1,142 @@
+#include "common/percent.h"
+#include "common/printing.h"
+#include "common/jsonconfig.h"
+#include "detection/mouse/mouse.h"
+#include "modules/mouse/mouse.h"
+#include "util/stringUtils.h"
+
+#define FF_MOUSE_NUM_FORMAT_ARGS 2
+
+static void printDevice(FFMouseOptions* options, const FFMouseDevice* device, uint8_t index)
+{
+    if(options->moduleArgs.outputFormat.length == 0)
+    {
+        ffPrintLogoAndKey(FF_MOUSE_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT);
+        ffStrbufPutTo(&device->name, stdout);
+    }
+    else
+    {
+        FF_PRINT_FORMAT_CHECKED(FF_MOUSE_MODULE_NAME, index, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, FF_MOUSE_NUM_FORMAT_ARGS, ((FFformatarg[]) {
+            FF_FORMAT_ARG(device->name, "name"),
+            FF_FORMAT_ARG(device->serial, "serial"),
+        }));
+    }
+}
+
+void ffPrintMouse(FFMouseOptions* options)
+{
+    FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFMouseDevice));
+
+    const char* error = ffDetectMouse(&result);
+
+    if(error)
+    {
+        ffPrintError(FF_MOUSE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "%s", error);
+        return;
+    }
+
+    if(!result.length)
+    {
+        ffPrintError(FF_MOUSE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "No devices detected");
+        return;
+    }
+
+    uint8_t index = 0;
+    FF_LIST_FOR_EACH(FFMouseDevice, device, result)
+    {
+        printDevice(options, device, result.length > 1 ? ++index : 0);
+        ffStrbufDestroy(&device->serial);
+        ffStrbufDestroy(&device->name);
+    }
+}
+
+bool ffParseMouseCommandOptions(FFMouseOptions* options, const char* key, const char* value)
+{
+    const char* subKey = ffOptionTestPrefix(key, FF_MOUSE_MODULE_NAME);
+    if (!subKey) return false;
+    if (ffOptionParseModuleArgs(key, subKey, value, &options->moduleArgs))
+        return true;
+
+    return false;
+}
+
+void ffParseMouseJsonObject(FFMouseOptions* options, yyjson_val* module)
+{
+    yyjson_val *key_, *val;
+    size_t idx, max;
+    yyjson_obj_foreach(module, idx, max, key_, val)
+    {
+        const char* key = yyjson_get_str(key_);
+        if(ffStrEqualsIgnCase(key, "type"))
+            continue;
+
+        if (ffJsonConfigParseModuleArgs(key, val, &options->moduleArgs))
+            continue;
+
+        ffPrintError(FF_MOUSE_MODULE_NAME, 0, &options->moduleArgs, FF_PRINT_TYPE_DEFAULT, "Unknown JSON key %s", key);
+    }
+}
+
+void ffGenerateMouseJsonConfig(FFMouseOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    __attribute__((__cleanup__(ffDestroyMouseOptions))) FFMouseOptions defaultOptions;
+    ffInitMouseOptions(&defaultOptions);
+
+    ffJsonConfigGenerateModuleArgsConfig(doc, module, &defaultOptions.moduleArgs, &options->moduleArgs);
+}
+
+void ffGenerateMouseJsonResult(FF_MAYBE_UNUSED FFMouseOptions* options, yyjson_mut_doc* doc, yyjson_mut_val* module)
+{
+    FF_LIST_AUTO_DESTROY result = ffListCreate(sizeof(FFMouseDevice));
+
+    const char* error = ffDetectMouse(&result);
+
+    if(error)
+    {
+        yyjson_mut_obj_add_str(doc, module, "error", error);
+        return;
+    }
+
+    yyjson_mut_val* arr = yyjson_mut_obj_add_arr(doc, module, "result");
+    FF_LIST_FOR_EACH(FFMouseDevice, device, result)
+    {
+        yyjson_mut_val* obj = yyjson_mut_arr_add_obj(doc, arr);
+        yyjson_mut_obj_add_strbuf(doc, obj, "serial", &device->serial);
+        yyjson_mut_obj_add_strbuf(doc, obj, "name", &device->name);
+    }
+
+    FF_LIST_FOR_EACH(FFMouseDevice, device, result)
+    {
+        ffStrbufDestroy(&device->serial);
+        ffStrbufDestroy(&device->name);
+    }
+}
+
+void ffPrintMouseHelpFormat(void)
+{
+    FF_PRINT_MODULE_FORMAT_HELP_CHECKED(FF_MOUSE_MODULE_NAME, "{1} ({3})", FF_MOUSE_NUM_FORMAT_ARGS, ((const char* []) {
+        "Name - name",
+        "Serial number - serial",
+    }));
+}
+
+void ffInitMouseOptions(FFMouseOptions* options)
+{
+    ffOptionInitModuleBaseInfo(
+        &options->moduleInfo,
+        FF_MOUSE_MODULE_NAME,
+        "List connected mouses",
+        ffParseMouseCommandOptions,
+        ffParseMouseJsonObject,
+        ffPrintMouse,
+        ffGenerateMouseJsonResult,
+        ffPrintMouseHelpFormat,
+        ffGenerateMouseJsonConfig
+    );
+    ffOptionInitModuleArg(&options->moduleArgs, "󰍽");
+}
+
+void ffDestroyMouseOptions(FFMouseOptions* options)
+{
+    ffOptionDestroyModuleArg(&options->moduleArgs);
+}

src/modules/mouse/mouse.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "fastfetch.h"
+
+#define FF_MOUSE_MODULE_NAME "Mouse"
+
+void ffPrintMouse(FFMouseOptions* options);
+void ffInitMouseOptions(FFMouseOptions* options);
+void ffDestroyMouseOptions(FFMouseOptions* options);

src/modules/mouse/option.h

@@ -0,0 +1,11 @@
+#pragma once
+
+// This file will be included in "fastfetch.h", do NOT put unnecessary things here
+
+#include "common/option.h"
+
+typedef struct FFMouseOptions
+{
+    FFModuleBaseInfo moduleInfo;
+    FFModuleArgs moduleArgs;
+} FFMouseOptions;

src/modules/options.h

@@ -34,6 +34,7 @@
 #include "modules/icons/option.h"
 #include "modules/initsystem/option.h"
 #include "modules/kernel/option.h"
+#include "modules/keyboard/option.h"
 #include "modules/loadavg/option.h"
 #include "modules/locale/option.h"
 #include "modules/lm/option.h"
@@ -41,6 +42,7 @@
 #include "modules/media/option.h"
 #include "modules/memory/option.h"
 #include "modules/monitor/option.h"
+#include "modules/mouse/option.h"
 #include "modules/netio/option.h"
 #include "modules/opengl/option.h"
 #include "modules/opencl/option.h"

src/options/modules.c

@@ -35,6 +35,7 @@ void ffOptionsInitModules(FFOptionsModules* options)
     ffInitIconsOptions(&options->icons);
     ffInitInitSystemOptions(&options->initSystem);
     ffInitKernelOptions(&options->kernel);
+    ffInitKeyboardOptions(&options->keyboard);
     ffInitLMOptions(&options->lm);
     ffInitLoadavgOptions(&options->loadavg);
     ffInitLocalIpOptions(&options->localIP);
@@ -42,6 +43,7 @@ void ffOptionsInitModules(FFOptionsModules* options)
     ffInitMediaOptions(&options->media);
     ffInitMemoryOptions(&options->memory);
     ffInitMonitorOptions(&options->monitor);
+    ffInitMouseOptions(&options->mouse);
     ffInitNetIOOptions(&options->netIo);
     ffInitOSOptions(&options->os);
     ffInitOpenCLOptions(&options->openCL);
@@ -110,6 +112,7 @@ void ffOptionsDestroyModules(FFOptionsModules* options)
     ffDestroyIconsOptions(&options->icons);
     ffDestroyInitSystemOptions(&options->initSystem);
     ffDestroyKernelOptions(&options->kernel);
+    ffDestroyKeyboardOptions(&options->keyboard);
     ffDestroyLMOptions(&options->lm);
     ffDestroyLoadavgOptions(&options->loadavg);
     ffDestroyLocalIpOptions(&options->localIP);
@@ -117,6 +120,7 @@ void ffOptionsDestroyModules(FFOptionsModules* options)
     ffDestroyMediaOptions(&options->media);
     ffDestroyMemoryOptions(&options->memory);
     ffDestroyMonitorOptions(&options->monitor);
+    ffDestroyMouseOptions(&options->mouse);
     ffDestroyNetIOOptions(&options->netIo);
     ffDestroyOSOptions(&options->os);
     ffDestroyOpenCLOptions(&options->openCL);

src/options/modules.h

@@ -36,6 +36,7 @@ typedef struct FFOptionsModules
     FFIconsOptions icons;
     FFInitSystemOptions initSystem;
     FFKernelOptions kernel;
+    FFKeyboardOptions keyboard;
     FFLMOptions lm;
     FFLoadavgOptions loadavg;
     FFLocalIpOptions localIP;
@@ -43,6 +44,7 @@ typedef struct FFOptionsModules
     FFMediaOptions media;
     FFMemoryOptions memory;
     FFMonitorOptions monitor;
+    FFMouseOptions mouse;
     FFNetIOOptions netIo;
     FFOSOptions os;
     FFOpenCLOptions openCL;