Temp: Display: support better temperature value formatting

CarterLi · CarterLi · commit a0c47204bb43 · 2024-02-26T11:09:00.000+08:00
Fix #737
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,16 @@
+# 2.8.6
+
+Changes:
+* Due to newly introduced configs, JSONC option `{ "temperatureUnit": "C" }` has been changed to `{ "temperature": { "unit": "C" } }`
+
+Bugfixes:
+* Fix incorrect GPU name detection for Intel iGPU on Linux (#736, GPU, Linux)
+
+Features:
+* Support additional temperature formatting options (#737)
+    * `{ "temperature": { "ndigits": 1 } }`
+    * `{ "temperature": { "color": { "green": "green", "yellow": "yellow", "red": "red" } } }`
+
 # 2.8.5
 
 Bugfixes:
diff --git a/doc/json_schema.json b/doc/json_schema.json
@@ -407,11 +407,42 @@
                         }
                     }
                 },
-                "temperatureUnit": {
-                    "type": "string",
-                    "description": "Set the unit of the temperature",
-                    "enum": ["CELSIUS", "C", "FAHRENHEIT", "F", "KELVIN", "K"],
-                    "default": "C"
+                "temperature": {
+                    "type": "object",
+                    "description": "Set how a temperature value should be displayed",
+                    "properties": {
+                        "unit": {
+                            "type": "string",
+                            "description": "Set the unit of the temperature",
+                            "enum": ["CELSIUS", "C", "FAHRENHEIT", "F", "KELVIN", "K"],
+                            "default": "C"
+                        },
+                        "ndigits": {
+                            "type": "integer",
+                            "description": "Set the number of digits to keep after the decimal point when formatting temperature values",
+                            "minimum": 0,
+                            "maximum": 9,
+                            "default": 1
+                        },
+                        "color": {
+                            "type": "object",
+                            "description": "Set color used in different states of temperature values",
+                            "properties": {
+                                "green": {
+                                    "description": "Color used in green state",
+                                    "$ref": "#/$defs/colors"
+                                },
+                                "yellow": {
+                                    "description": "Color used in yellow state",
+                                    "$ref": "#/$defs/colors"
+                                },
+                                "red": {
+                                    "description": "Color used in red state",
+                                    "$ref": "#/$defs/colors"
+                                }
+                            }
+                        }
+                    }
                 },
                 "bar": {
                     "type": "object",
diff --git a/src/common/parsing.c b/src/common/parsing.c
@@ -1,5 +1,6 @@
 #include "fastfetch.h"
 #include "common/parsing.h"
+#include "util/textModifier.h"
 
 #include <ctype.h>
 #include <inttypes.h>
@@ -98,18 +99,39 @@ void ffParseSize(uint64_t bytes, FFstrbuf* result)
 
 void ffParseTemperature(double celsius, FFstrbuf* buffer)
 {
-    switch (instance.config.display.temperatureUnit)
+    if (celsius != celsius) // ignores NaN
+        return;
+
+    const FFOptionsDisplay* options = &instance.config.display;
+    const char* colorGreen = options->temperatureColorGreen.chars;
+    const char* colorYellow = options->temperatureColorYellow.chars;
+    const char* colorRed = options->temperatureColorRed.chars;
+
+    if (!options->pipe)
+    {
+        if (celsius < 50)
+            ffStrbufAppendF(buffer, "\e[%sm", colorGreen);
+        else if (celsius < 80)
+            ffStrbufAppendF(buffer, "\e[%sm", colorYellow);
+        else
+            ffStrbufAppendF(buffer, "\e[%sm", colorRed);
+    }
+
+    switch (options->temperatureUnit)
     {
         case FF_TEMPERATURE_UNIT_CELSIUS:
-            ffStrbufAppendF(buffer, "%.1f°C", celsius);
+            ffStrbufAppendF(buffer, "%.*f°C", options->temperatureNdigits, celsius);
             break;
         case FF_TEMPERATURE_UNIT_FAHRENHEIT:
-            ffStrbufAppendF(buffer, "%.1f°F", celsius * 1.8 + 32);
+            ffStrbufAppendF(buffer, "%.*f°F", options->temperatureNdigits, celsius * 1.8 + 32);
             break;
         case FF_TEMPERATURE_UNIT_KELVIN:
-            ffStrbufAppendF(buffer, "%.1f K", celsius + 273.15);
+            ffStrbufAppendF(buffer, "%.*f K", options->temperatureNdigits, celsius + 273.15);
             break;
     }
+
+    if (!options->pipe)
+        ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
 }
 
 void ffParseGTK(FFstrbuf* buffer, const FFstrbuf* gtk2, const FFstrbuf* gtk3, const FFstrbuf* gtk4)
diff --git a/src/data/help.json b/src/data/help.json
@@ -667,6 +667,41 @@
                 },
                 "default": "C"
             }
+        },
+        {
+            "long": "temperature-ndigits",
+            "desc": "Set the number of digits to keep after the decimal point when printing temperature",
+            "arg": {
+                "type": "num",
+                "default": 2
+            }
+        },
+        {
+            "long": "temperature-color-green",
+            "desc": "Set color used in green state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "green"
+            }
+        },
+        {
+            "long": "temperature-color-yellow",
+            "desc": "Set color used in yellow state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_yellow"
+            }
+        },
+        {
+            "long": "temperature-color-red",
+            "desc": "Set color used in red state of temperature values",
+            "remark": "See `-h color` for the list of available colors",
+            "arg": {
+                "type": "color",
+                "default": "light_red"
+            }
         }
     ],
     "Library path": [
diff --git a/src/modules/battery/battery.c b/src/modules/battery/battery.c
@@ -58,13 +58,15 @@ static void printBattery(FFBatteryOptions* options, FFBatteryResult* result, uin
     {
         FF_STRBUF_AUTO_DESTROY capacityStr = ffStrbufCreate();
         ffPercentAppendNum(&capacityStr, result->capacity, options->percent, false);
+        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+        ffParseTemperature(result->temperature, &tempStr);
         ffPrintFormat(FF_BATTERY_MODULE_NAME, index, &options->moduleArgs, FF_BATTERY_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufacturer},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->modelName},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->technology},
             {FF_FORMAT_ARG_TYPE_STRBUF, &capacityStr},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->status},
-            {FF_FORMAT_ARG_TYPE_DOUBLE, &result->temperature},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr},
             {FF_FORMAT_ARG_TYPE_UINT, &result->cycleCount},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->serial},
             {FF_FORMAT_ARG_TYPE_STRBUF, &result->manufactureDate},
@@ -226,7 +228,7 @@ void ffPrintBatteryHelpFormat(void)
         "Battery technology",
         "Battery capacity (percentage)",
         "Battery status",
-        "Battery temperature",
+        "Battery temperature (formatted)",
         "Battery cycle count",
         "Battery serial number",
         "Battery manufactor date",
diff --git a/src/modules/cpu/cpu.c b/src/modules/cpu/cpu.c
@@ -60,6 +60,8 @@ void ffPrintCPU(FFCPUOptions* options)
         }
         else
         {
+            FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+            ffParseTemperature(cpu.temperature, &tempStr);
             ffPrintFormat(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.name},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &cpu.vendor},
@@ -68,7 +70,7 @@ void ffPrintCPU(FFCPUOptions* options)
                 {FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresOnline},
                 {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMin},
                 {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMax},
-                {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.temperature}
+                {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr}
             });
         }
     }
@@ -193,7 +195,7 @@ void ffPrintCPUHelpFormat(void)
         "Online core count",
         "Min frequency",
         "Max frequency",
-        "Temperature"
+        "Temperature (formatted)"
     });
 }
 
diff --git a/src/modules/gpu/gpu.c b/src/modules/gpu/gpu.c
@@ -72,11 +72,13 @@ static void printGPUResult(FFGPUOptions* options, uint8_t index, const FFGPUResu
     }
     else
     {
+        FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+        ffParseTemperature(gpu->temperature, &tempStr);
         ffPrintFormat(FF_GPU_MODULE_NAME, index, &options->moduleArgs, FF_GPU_NUM_FORMAT_ARGS, (FFformatarg[]){
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->vendor},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->name},
             {FF_FORMAT_ARG_TYPE_STRBUF, &gpu->driver},
-            {FF_FORMAT_ARG_TYPE_DOUBLE, &gpu->temperature},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr},
             {FF_FORMAT_ARG_TYPE_INT, &gpu->coreCount},
             {FF_FORMAT_ARG_TYPE_STRING, type},
             {FF_FORMAT_ARG_TYPE_UINT64, &gpu->dedicated.total},
diff --git a/src/modules/physicaldisk/physicaldisk.c b/src/modules/physicaldisk/physicaldisk.c
@@ -102,6 +102,8 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)
         }
         else
         {
+            FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();
+            ffParseTemperature(dev->temperature, &tempStr);
             if (dev->type & FF_PHYSICALDISK_TYPE_READWRITE)
                 readOnlyType = "Read-write";
             ffParseSize(dev->size, &buffer);
@@ -115,7 +117,7 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)
                 {FF_FORMAT_ARG_TYPE_STRING, removableType},
                 {FF_FORMAT_ARG_TYPE_STRING, readOnlyType},
                 {FF_FORMAT_ARG_TYPE_STRBUF, &dev->revision},
-                {FF_FORMAT_ARG_TYPE_DOUBLE, &dev->temperature},
+                {FF_FORMAT_ARG_TYPE_DOUBLE, &tempStr},
             });
         }
         ++index;
@@ -263,7 +265,7 @@ void ffPrintPhysicalDiskHelpFormat(void)
         "Device kind (Removable or Fixed)",
         "Device kind (Read-only or Read-write)",
         "Product revision",
-        "Device temperature",
+        "Device temperature (formatted)",
     });
 }
 
diff --git a/src/options/display.c b/src/options/display.c
diff --git a/src/options/display.h b/src/options/display.h

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,8 @@ void ffPrintCPU(FFCPUOptions* options)`
`60`	`60`	`}`
`61`	`61`	`else`
`62`	`62`	`{`
	`63`	`+ FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();`
	`64`	`+ ffParseTemperature(cpu.temperature, &tempStr);`
`63`	`65`	`ffPrintFormat(FF_CPU_MODULE_NAME, 0, &options->moduleArgs, FF_CPU_NUM_FORMAT_ARGS, (FFformatarg[]){`
`64`	`66`	`{FF_FORMAT_ARG_TYPE_STRBUF, &cpu.name},`
`65`	`67`	`{FF_FORMAT_ARG_TYPE_STRBUF, &cpu.vendor},`
`@@ -68,7 +70,7 @@ void ffPrintCPU(FFCPUOptions* options)`
`68`	`70`	`{FF_FORMAT_ARG_TYPE_UINT16, &cpu.coresOnline},`
`69`	`71`	`{FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMin},`
`70`	`72`	`{FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.frequencyMax},`
`71`		`- {FF_FORMAT_ARG_TYPE_DOUBLE, &cpu.temperature}`
	`73`	`+ {FF_FORMAT_ARG_TYPE_STRBUF, &tempStr}`
`72`	`74`	`});`
`73`	`75`	`}`
`74`	`76`	`}`
`@@ -193,7 +195,7 @@ void ffPrintCPUHelpFormat(void)`
`193`	`195`	`"Online core count",`
`194`	`196`	`"Min frequency",`
`195`	`197`	`"Max frequency",`
`196`		`- "Temperature"`
	`198`	`+ "Temperature (formatted)"`
`197`	`199`	`});`
`198`	`200`	`}`
`199`	`201`
Original file line number	Diff line number	Diff line change
`@@ -102,6 +102,8 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)`
`102`	`102`	`}`
`103`	`103`	`else`
`104`	`104`	`{`
	`105`	`+ FF_STRBUF_AUTO_DESTROY tempStr = ffStrbufCreate();`
	`106`	`+ ffParseTemperature(dev->temperature, &tempStr);`
`105`	`107`	`if (dev->type & FF_PHYSICALDISK_TYPE_READWRITE)`
`106`	`108`	`readOnlyType = "Read-write";`
`107`	`109`	`ffParseSize(dev->size, &buffer);`
`@@ -115,7 +117,7 @@ void ffPrintPhysicalDisk(FFPhysicalDiskOptions* options)`
`115`	`117`	`{FF_FORMAT_ARG_TYPE_STRING, removableType},`
`116`	`118`	`{FF_FORMAT_ARG_TYPE_STRING, readOnlyType},`
`117`	`119`	`{FF_FORMAT_ARG_TYPE_STRBUF, &dev->revision},`
`118`		`- {FF_FORMAT_ARG_TYPE_DOUBLE, &dev->temperature},`
	`120`	`+ {FF_FORMAT_ARG_TYPE_DOUBLE, &tempStr},`
`119`	`121`	`});`
`120`	`122`	`}`
`121`	`123`	`++index;`
`@@ -263,7 +265,7 @@ void ffPrintPhysicalDiskHelpFormat(void)`
`263`	`265`	`"Device kind (Removable or Fixed)",`
`264`	`266`	`"Device kind (Read-only or Read-write)",`
`265`	`267`	`"Product revision",`
`266`		`- "Device temperature",`
	`268`	`+ "Device temperature (formatted)",`
`267`	`269`	`});`
`268`	`270`	`}`
`269`	`271`