Updated: GPU widget improvements

Author: pozitronik

internal/widget/gpu/gpu.go

@@ -32,24 +32,26 @@ const (
 )
 
 // supportedMetrics lists metrics that are currently functional.
-// Memory metrics (memory_dedicated, memory_shared) are defined as constants but not yet
-// supported because PDH doesn't provide total VRAM counters needed for percentage calculation.
 var supportedMetrics = map[string]bool{
 	MetricUtilization:       true,
 	MetricUtilization3D:     true,
 	MetricUtilizationCopy:   true,
 	MetricUtilizationEncode: true,
 	MetricUtilizationDecode: true,
+	MetricMemoryDedicated:   true,
+	MetricMemoryShared:      true,
 }
 
 // AdapterInfo contains information about a GPU adapter.
 // Index is a sequential number (0, 1, 2, ...) assigned during discovery.
 // On Windows, LUID (Locally Unique Identifier) is the primary key used to
 // distinguish adapters, since all GPUs report phys_0 in PDH instance names.
 type AdapterInfo struct {
-	Index int
-	Name  string
-	LUID  string // Locally Unique Identifier from PDH instance names (Windows only)
+	Index                int
+	Name                 string
+	LUID                 string // Locally Unique Identifier from PDH instance names (Windows only)
+	DedicatedVideoMemory uint64 // Total dedicated VRAM in bytes (from DXGI, Windows only)
+	SharedSystemMemory   uint64 // Total shared system memory in bytes (from DXGI, Windows only)
 }
 
 // Reader is the interface for reading GPU metrics
@@ -75,8 +77,9 @@ type Widget struct {
 	Renderer *render.MetricRenderer
 
 	// GPU configuration
-	adapter int    // GPU adapter index
-	metric  string // Metric to display
+	adapter    int    // GPU adapter index
+	metric     string // Metric to display
+	textFormat string // Format string for bar text overlay (from text.format)
 
 	// GPU metrics reader
 	reader       Reader
@@ -110,9 +113,15 @@ func New(cfg config.WidgetConfig) (*Widget, error) {
 		}
 	}
 
+	// Extract text format for bar overlay
+	textFormat := ""
+	if cfg.Text != nil {
+		textFormat = cfg.Text.Format
+	}
+
 	// Validate metric
 	if !supportedMetrics[metric] {
-		return nil, fmt.Errorf("unsupported GPU metric: %q (supported: utilization, utilization_3d, utilization_copy, utilization_video_encode, utilization_video_decode)", metric)
+		return nil, fmt.Errorf("unsupported GPU metric: %q (supported: utilization, utilization_3d, utilization_copy, utilization_video_encode, utilization_video_decode, memory_dedicated, memory_shared)", metric)
 	}
 
 	// Initialize reader (platform-specific)
@@ -142,6 +151,7 @@ func New(cfg config.WidgetConfig) (*Widget, error) {
 		Renderer:     mr.Renderer,
 		adapter:      adapter,
 		metric:       metric,
+		textFormat:   textFormat,
 		reader:       reader,
 		readerFailed: readerFailed,
 		history:      util.NewRingBuffer[float64](mr.HistoryLen),
@@ -203,11 +213,17 @@ func (w *Widget) Render() (image.Image, error) {
 		return img, nil
 	}
 
+	// Determine text format: use configured format for text mode, default for others
+	textFmt := "%.0f"
+	if w.textFormat != "" {
+		textFmt = w.textFormat
+	}
+
 	// Use strategy pattern for rendering
 	w.strategy.Render(img, render.MetricData{
 		Value:       w.currentValue,
 		History:     w.history.ToSlice(),
-		TextFormat:  "%.0f",
+		TextFormat:  textFmt,
 		ContentArea: image.Rect(content.X, content.Y, content.X+content.Width, content.Y+content.Height),
 		GaugeArea:   image.Rect(0, 0, pos.W, pos.H),
 	}, w.Renderer)

internal/widget/gpu/gpu_test.go

@@ -139,6 +139,8 @@ func TestNew_WithGPUConfig(t *testing.T) {
 		{"adapter 0 copy", 0, MetricUtilizationCopy},
 		{"adapter 0 encode", 0, MetricUtilizationEncode},
 		{"adapter 0 decode", 0, MetricUtilizationDecode},
+		{"adapter 0 memory dedicated", 0, MetricMemoryDedicated},
+		{"adapter 0 memory shared", 0, MetricMemoryShared},
 	}
 
 	for _, tt := range tests {
@@ -180,8 +182,6 @@ func TestNew_InvalidMetric(t *testing.T) {
 		metric string
 	}{
 		{"unknown metric", "nonexistent"},
-		{"memory_dedicated (unsupported)", MetricMemoryDedicated},
-		{"memory_shared (unsupported)", MetricMemoryShared},
 		{"empty with explicit config", ""},
 	}
 
@@ -208,7 +208,7 @@ func TestNew_InvalidMetric(t *testing.T) {
 	}
 }
 
-// TestNew_SupportedMetricsCompleteness verifies that all utilization metric constants
+// TestNew_SupportedMetricsCompleteness verifies that all metric constants
 // are present in the supportedMetrics map
 func TestNew_SupportedMetricsCompleteness(t *testing.T) {
 	expectedSupported := []string{
@@ -217,24 +217,15 @@ func TestNew_SupportedMetricsCompleteness(t *testing.T) {
 		MetricUtilizationCopy,
 		MetricUtilizationEncode,
 		MetricUtilizationDecode,
+		MetricMemoryDedicated,
+		MetricMemoryShared,
 	}
 
 	for _, metric := range expectedSupported {
 		if !supportedMetrics[metric] {
 			t.Errorf("metric %q should be in supportedMetrics", metric)
 		}
 	}
-
-	expectedUnsupported := []string{
-		MetricMemoryDedicated,
-		MetricMemoryShared,
-	}
-
-	for _, metric := range expectedUnsupported {
-		if supportedMetrics[metric] {
-			t.Errorf("metric %q should NOT be in supportedMetrics (memory metrics not yet supported)", metric)
-		}
-	}
 }
 
 // TestWidget_Render_BeforeUpdate tests rendering before first update
@@ -417,3 +408,41 @@ func TestWidget_ValueClamping(t *testing.T) {
 		})
 	}
 }
+
+// TestNew_TextFormat tests that text format is correctly extracted from config
+func TestNew_TextFormat(t *testing.T) {
+	tests := []struct {
+		name       string
+		textConfig *config.TextConfig
+		wantFormat string
+	}{
+		{"no text config", nil, ""},
+		{"empty format", &config.TextConfig{Size: 10}, ""},
+		{"custom format", &config.TextConfig{Format: "GPU %.0f%%", Size: 10}, "GPU %.0f%%"},
+		{"vram format", &config.TextConfig{Format: "VRAM %.0f%%", Size: 10}, "VRAM %.0f%%"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cfg := config.WidgetConfig{
+				Type:    "gpu",
+				ID:      "test_gpu_format",
+				Enabled: config.BoolPtr(true),
+				Position: config.PositionConfig{
+					X: 0, Y: 0, W: 128, H: 40,
+				},
+				Mode: "bar",
+				Text: tt.textConfig,
+			}
+
+			w, err := New(cfg)
+			if err != nil {
+				t.Fatalf("New() error = %v", err)
+			}
+
+			if w.textFormat != tt.wantFormat {
+				t.Errorf("textFormat = %q, want %q", w.textFormat, tt.wantFormat)
+			}
+		})
+	}
+}