modules

ExampleActionFunc demonstrates using a function as an action.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	// Create an action from a function
	action := modules.ActionFunc(func(ctx context.Context, click modules.Click) error {
		fmt.Printf("Clicked module: %s with button %d\n", click.Name, click.Button)
		return nil
	})

	ctx := context.Background()
	click := modules.Click{Name: "my-module", Button: 1}

	action.Execute(ctx, click)

}

Output:

Clicked module: my-module with button 1

ExampleBatteryModuleV2 demonstrates creating a battery module. Note: This example may not work on systems without a battery.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	battMod := modules.NewBatteryModuleV2(modules.BatteryModuleConfig{
		ID:      "my-battery",
		Battery: 0,
	})

	fmt.Printf("ID: %s\n", battMod.ID())
	fmt.Printf("Type: %s\n", battMod.Type())

}

Output:

ID: my-battery
Type: battery

ExampleBatteryModuleV2_customization demonstrates customizing battery display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	battMod := modules.NewBatteryModuleV2(modules.BatteryModuleConfig{
		ID:             "custom-battery",
		StatusCharging: "⚡",
		StatusBattery:  "🔋",
		StatusFull:     "✓",
		ColorOK:        "#00ff00",
		Color20:        "#ff9900",
		Color10:        "#ff0000",
	})

	fmt.Printf("ID: %s\n", battMod.ID())

}

Output:

ID: custom-battery

ExampleBatteryModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("battery-v2", "bat0", map[string]any{
		"battery":    0,
		"status-chr": "CHR",
		"color-ok":   "#00ff00",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: battery

ExampleBatteryModuleV2_skip demonstrates how the battery module automatically hides itself when no battery is present.

// Create modules for a desktop system without a battery
modules := []ModuleV2{
	NewTextModuleV2(TextModuleConfig{
		ID:   "label",
		Text: "Desktop",
	}),
	NewBatteryModuleV2(BatteryModuleConfig{
		ID:      "battery",
		Battery: 0, // Will skip if no battery present
	}),
	NewDateModuleV2(DateModuleConfig{
		ID:     "clock",
		Format: "15:04:05",
	}),
}

// When rendered, if no battery is present, only the text and date modules will appear
ctx := context.Background()
blocks := RenderAll(ctx, modules)

// On a desktop without a battery, we'll only get 2 blocks
// The battery module automatically skips itself
_ = blocks

ExampleBatteryModuleV2_skip demonstrates the automatic skip feature. When no battery is present, the module automatically hides itself.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	// Create a setup with multiple modules including battery
	mods := []modules.ModuleV2{
		modules.NewTextModuleV2(modules.TextModuleConfig{
			ID:   "label",
			Text: "System:",
		}),
		modules.NewBatteryModuleV2(modules.BatteryModuleConfig{
			ID:      "battery",
			Battery: 99, // Non-existent battery to demonstrate skip
		}),
		modules.NewDateModuleV2(modules.DateModuleConfig{
			ID:     "clock",
			Format: "15:04",
		}),
	}

	// Render all modules
	ctx := context.Background()
	blocks := modules.RenderAll(ctx, mods)

	// We only get 2 blocks (label + clock)
	// The battery module automatically skips itself when battery doesn't exist
	fmt.Printf("Modules defined: 3\n")
	fmt.Printf("Blocks rendered: %d\n", len(blocks))

}

Output:

Modules defined: 3
Blocks rendered: 2

ExampleBatteryModuleV2_withIcon demonstrates using the battery module with an icon.

// Create a battery module with a custom icon
battery := NewBatteryModuleV2(BatteryModuleConfig{
	ID:   "my-battery",
	Icon: "⚡",
})

// If a battery is present, the icon will be prefixed to the status:
// ⚡BAT 75.0% 2h30m
_ = battery

ExampleBatteryModuleV2_withIcon demonstrates the new icon feature. The icon is prepended to the battery status text.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	battMod := modules.NewBatteryModuleV2(modules.BatteryModuleConfig{
		ID:             "icon-battery",
		Icon:           "🔋",
		StatusCharging: "CHR",
		StatusBattery:  "BAT",
	})

	fmt.Printf("ID: %s\n", battMod.ID())
	// When rendered (if battery exists), output would be: "🔋BAT 75.0% 2h30m"

}

Output:

ID: icon-battery

ExampleBlock_skip demonstrates the Skip field in Block.

// A module can signal it should not be rendered by setting Skip=true
block := Block{
	Name:     "conditional-module",
	FullText: "This won't be shown",
	Skip:     true, // This block will be filtered out by RenderAll
}

// When this block is included in RenderAll output, it will be omitted
_ = block

ExampleCPUModuleV2 demonstrates creating a CPU module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	cpuMod := modules.NewCPUModuleV2(modules.CPUModuleConfig{
		ID:     "my-cpu",
		Format: "percent",
	})

	fmt.Printf("ID: %s\n", cpuMod.ID())
	fmt.Printf("Type: %s\n", cpuMod.Type())

}

Output:

ID: my-cpu
Type: cpu

ExampleCPUModuleV2_customization demonstrates customizing CPU display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	cpuMod := modules.NewCPUModuleV2(modules.CPUModuleConfig{
		ID:              "custom-cpu",
		Format:          "with-temp",
		ShowTemp:        true,
		Icon:            "CPU:",
		WarnPercent:     60,
		CriticalPercent: 80,
		ColorOK:         "#00ff00",
		ColorWarn:       "#ffaa00",
		ColorCritical:   "#ff0000",
	})

	fmt.Printf("ID: %s\n", cpuMod.ID())

}

Output:

ID: custom-cpu

ExampleCPUModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("cpu-v2", "processor", map[string]any{
		"format":           "percent",
		"show-temp":        true,
		"warn-percent":     70,
		"critical-percent": 90,
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: cpu

ExampleChainAction demonstrates chaining multiple actions.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	action := &modules.ChainAction{
		Actions: []modules.Action{
			&modules.ShellAction{Command: "echo 'First'"},
			&modules.ShellAction{Command: "echo 'Second'"},
			&modules.ShellAction{Command: "echo 'Third'"},
		},
	}

	fmt.Printf("Chain has %d actions\n", len(action.Actions))

}

Output:

Chain has 3 actions

ExampleDateModuleV2 demonstrates creating and using a date module.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	dateMod := modules.NewDateModuleV2(modules.DateModuleConfig{
		ID:     "my-date",
		Format: "15:04:05", // Show time only
	})

	ctx := context.Background()

	// Start and render
	dateMod.Start(ctx)
	defer dateMod.Stop()

	block, _ := dateMod.Render(ctx)

	fmt.Printf("ID: %s\n", block.Name)
	fmt.Printf("Type: %s\n", dateMod.Type())
	// Note: We can't check the actual time in the test, but we can verify structure
	fmt.Printf("Has time: %t\n", len(block.FullText) > 0)

}

Output:

ID: my-date
Type: date
Has time: true

ExampleDateModuleV2_blinking demonstrates the blinking feature.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	dateMod := modules.NewDateModuleV2(modules.DateModuleConfig{
		ID:        "blink-date",
		Format:    "15:04:05",
		BlinkChar: ":", // Make colons blink
	})

	ctx := context.Background()

	// First render - colons visible
	block1, _ := dateMod.Render(ctx)
	hasColons1 := len(block1.FullText) > 0 && (block1.FullText[2:3] == ":" || block1.FullText[2:3] == " ")

	// Second render - colons invisible (replaced with spaces)
	block2, _ := dateMod.Render(ctx)
	hasColons2 := len(block2.FullText) > 0 && (block2.FullText[2:3] == ":" || block2.FullText[2:3] == " ")

	fmt.Printf("Blinking works: %t\n", hasColons1 || hasColons2)

}

Output:

Blinking works: true

ExampleDateModuleV2_registry demonstrates creating via registry.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("date-v2", "my-date", map[string]any{
		"format": "2006-01-02",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	ctx := context.Background()
	block, _ := mod.Render(ctx)

	fmt.Printf("Type: %s\n", mod.Type())
	fmt.Printf("Has date: %t\n", len(block.FullText) > 0)

}

Output:

Type: date
Has date: true

ExampleDiskModuleV2 demonstrates creating a disk usage module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	diskMod := modules.NewDiskModuleV2(modules.DiskModuleConfig{
		ID:     "my-disk",
		Path:   "/",
		Format: "both",
	})

	fmt.Printf("ID: %s\n", diskMod.ID())
	fmt.Printf("Type: %s\n", diskMod.Type())

}

Output:

ID: my-disk
Type: disk

ExampleDiskModuleV2_customization demonstrates customizing disk module display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	diskMod := modules.NewDiskModuleV2(modules.DiskModuleConfig{
		ID:              "custom-disk",
		Path:            "/home",
		Format:          "percent",
		Icon:            "🗄️",
		WarnPercent:     75,
		CriticalPercent: 85,
		ColorOK:         "#00ff00",
		ColorWarn:       "#ff9900",
		ColorCritical:   "#ff0000",
	})

	fmt.Printf("ID: %s\n", diskMod.ID())

}

Output:

ID: custom-disk

ExampleDiskModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("disk-v2", "root-disk", map[string]any{
		"path":   "/",
		"format": "short",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: disk

ExampleLoadModuleV2 demonstrates creating a load module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	loadMod := modules.NewLoadModuleV2(modules.LoadModuleConfig{
		ID:     "my-load",
		Format: "all",
	})

	fmt.Printf("ID: %s\n", loadMod.ID())
	fmt.Printf("Type: %s\n", loadMod.Type())

}

Output:

ID: my-load
Type: load

ExampleLoadModuleV2_customization demonstrates customizing load display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	loadMod := modules.NewLoadModuleV2(modules.LoadModuleConfig{
		ID:                "custom-load",
		Format:            "1min",
		Icon:              "CPU:",
		WarnThreshold:     0.5,
		CriticalThreshold: 0.8,
		ColorOK:           "#00ff00",
		ColorWarn:         "#ffaa00",
		ColorCritical:     "#ff0000",
	})

	fmt.Printf("ID: %s\n", loadMod.ID())

}

Output:

ID: custom-load

ExampleLoadModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("load-v2", "system-load", map[string]any{
		"format":             "1-5",
		"warn-threshold":     0.7,
		"critical-threshold": 0.9,
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: load

ExampleMemoryModuleV2 demonstrates creating a memory module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	memMod := modules.NewMemoryModuleV2(modules.MemoryModuleConfig{
		ID:     "my-memory",
		Format: "both",
	})

	fmt.Printf("ID: %s\n", memMod.ID())
	fmt.Printf("Type: %s\n", memMod.Type())

}

Output:

ID: my-memory
Type: memory

ExampleMemoryModuleV2_customization demonstrates customizing memory display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	memMod := modules.NewMemoryModuleV2(modules.MemoryModuleConfig{
		ID:              "custom-memory",
		Format:          "percent",
		Icon:            "RAM:",
		WarnPercent:     70,
		CriticalPercent: 85,
		ColorOK:         "#00ff00",
		ColorWarn:       "#ffaa00",
		ColorCritical:   "#ff0000",
	})

	fmt.Printf("ID: %s\n", memMod.ID())

}

Output:

ID: custom-memory

ExampleMemoryModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("memory-v2", "ram", map[string]any{
		"format":           "short",
		"warn-percent":     80,
		"critical-percent": 90,
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: memory

ExampleNetworkModuleV2 demonstrates creating a network interface module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	netMod := modules.NewNetworkModuleV2(modules.NetworkModuleConfig{
		ID:          "my-network",
		Interface:   "eth0",
		ShowIP:      true,
		ShowTraffic: true,
	})

	fmt.Printf("ID: %s\n", netMod.ID())
	fmt.Printf("Type: %s\n", netMod.Type())

}

Output:

ID: my-network
Type: network

ExampleNetworkModuleV2_autoDetection demonstrates using auto-detection.

// Create a network module with auto-detection
// This will automatically find the first active network interface
netMod := NewNetworkModuleV2(NetworkModuleConfig{
	ID:          "auto-network",
	Interface:   "auto", // Auto-detect any interface
	ShowIP:      true,
	ShowTraffic: true,
})

// Start the module to resolve the interface
ctx := context.Background()
netMod.Start(ctx)

// The module will now use whatever interface it detected
// Output depends on the system, so we just verify it was created
_ = netMod

ExampleNetworkModuleV2_autoEthernet demonstrates ethernet auto-detection.

// Create a network module that auto-detects ethernet interfaces
// Perfect for desktop systems with wired connections
netMod := NewNetworkModuleV2(NetworkModuleConfig{
	ID:          "ethernet",
	Interface:   "auto-ethernet", // Auto-detect first ethernet interface
	ShowIP:      true,
	ShowTraffic: true,
})

ctx := context.Background()
netMod.Start(ctx)

// Will find interfaces like: eth0, enp3s0, eno1, etc.
_ = netMod

ExampleNetworkModuleV2_autoWireless demonstrates wireless auto-detection.

// Create a network module that auto-detects wireless interfaces
// Perfect for laptops with WiFi
netMod := NewNetworkModuleV2(NetworkModuleConfig{
	ID:          "wifi",
	Interface:   "auto-wireless", // Auto-detect first wireless interface
	ShowIP:      true,
	ShowTraffic: true,
})

ctx := context.Background()
netMod.Start(ctx)

// Will find interfaces like: wlan0, wlp2s0, wlo1, etc.
_ = netMod

ExampleNetworkModuleV2_customization demonstrates customizing network module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	netMod := modules.NewNetworkModuleV2(modules.NetworkModuleConfig{
		ID:                "wifi",
		Interface:         "wlan0",
		ShowIP:            true,
		ShowTraffic:       true,
		Format:            "long",
		IconConnected:     "📶",
		IconDisconnected:  "❌",
		ColorConnected:    "#00ff00",
		ColorDisconnected: "#ff0000",
	})

	fmt.Printf("ID: %s\n", netMod.ID())

}

Output:

ID: wifi

ExampleNetworkModuleV2_portableConfig demonstrates a portable config.

// This configuration works across different machines without modification
// Each machine will auto-detect its own network interface

// For a laptop that might use ethernet OR wifi:
netMod1 := NewNetworkModuleV2(NetworkModuleConfig{
	ID:        "network",
	Interface: "auto", // Uses whatever is active
})

// For a desktop that always uses ethernet:
netMod2 := NewNetworkModuleV2(NetworkModuleConfig{
	ID:        "network",
	Interface: "auto-ethernet", // Only looks for wired
})

// For a mobile device that only has wifi:
netMod3 := NewNetworkModuleV2(NetworkModuleConfig{
	ID:        "network",
	Interface: "auto-wireless", // Only looks for wireless
})

ctx := context.Background()
netMod1.Start(ctx)
netMod2.Start(ctx)
netMod3.Start(ctx)

// All three modules will work on their respective systems
_, _, _ = netMod1, netMod2, netMod3

ExampleNetworkModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("network-v2", "eth", map[string]any{
		"interface":    "eth0",
		"show-ip":      true,
		"show-traffic": true,
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: network

ExampleNotifyAction demonstrates showing a desktop notification.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	action := &modules.NotifyAction{
		Summary: "Test Notification",
		Body:    "This is a test",
		Icon:    "dialog-information",
	}

	// Note: This may not work in test environments without a display
	fmt.Printf("Action type: %T\n", action)

}

Output:

Action type: *modules.NotifyAction

ExampleParallelAction demonstrates running actions concurrently.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	action := &modules.ParallelAction{
		Actions: []modules.Action{
			&modules.ShellAction{Command: "echo 'Action 1'"},
			&modules.ShellAction{Command: "echo 'Action 2'"},
			&modules.ShellAction{Command: "echo 'Action 3'"},
		},
	}

	ctx := context.Background()
	click := modules.Click{Name: "test", Button: 1}

	err := action.Execute(ctx, click)
	fmt.Printf("All executed: %v\n", err == nil)

}

Output:

All executed: true

ExampleScriptModuleV2 demonstrates creating a script module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	scriptMod := modules.NewScriptModuleV2(modules.ScriptModuleConfig{
		ID:           "my-script",
		Command:      "echo 'Hello from script'",
		DefaultColor: "#00ff00",
	})

	fmt.Printf("ID: %s\n", scriptMod.ID())
	fmt.Printf("Type: %s\n", scriptMod.Type())

}

Output:

ID: my-script
Type: script

ExampleScriptModuleV2_colorRules demonstrates using color rules.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	scriptMod := modules.NewScriptModuleV2(modules.ScriptModuleConfig{
		ID:      "status-script",
		Command: "echo 'OK: All systems go'",
		ColorRules: []modules.ColorRule{
			{Pattern: "^OK:", Color: "#00ff00"},
			{Pattern: "^WARN:", Color: "#ffa500"},
			{Pattern: "^ERROR:", Color: "#ff0000"},
		},
		DefaultColor: "#ffffff",
		OnError:      "Script failed",
	})

	fmt.Printf("ID: %s\n", scriptMod.ID())
	fmt.Printf("Type: %s\n", scriptMod.Type())

}

Output:

ID: status-script
Type: script

ExampleScriptModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("script-v2", "uptime", map[string]any{
		"command":       "uptime",
		"default-color": "#00ff00",
		"on-error":      "Uptime unavailable",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: script

ExampleShellAction demonstrates executing a shell command.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	action := &modules.ShellAction{
		Command: "echo 'Hello from action!'",
	}

	ctx := context.Background()
	click := modules.Click{Name: "test", Button: 1}

	err := action.Execute(ctx, click)
	fmt.Printf("Executed: %v\n", err == nil)

}

Output:

Executed: true

ExampleTextModuleV2 demonstrates how to create and use the new TextModuleV2.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	// Create a new text module with custom configuration
	textMod := modules.NewTextModuleV2(modules.TextModuleConfig{
		ID:      "my-text",
		Text:    "Hello from V2!",
		Color:   "#00ff00",
		OnClick: "echo 'clicked!'",
	})

	// Start the module (not required for text module, but good practice)
	ctx := context.Background()
	if err := textMod.Start(ctx); err != nil {
		fmt.Printf("Error starting module: %v\n", err)
		return
	}
	defer textMod.Stop()

	// Render the module
	block, err := textMod.Render(ctx)
	if err != nil {
		fmt.Printf("Error rendering: %v\n", err)
		return
	}

	fmt.Printf("ID: %s\n", block.Name)
	fmt.Printf("Text: %s\n", block.FullText)
	fmt.Printf("Color: %s\n", block.Color)

}

Output:

ID: my-text
Text: Hello from V2!
Color: #00ff00

ExampleTextModuleV2_defaults demonstrates using default values.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	// Create with minimal configuration - uses defaults
	textMod := modules.NewTextModuleV2(modules.TextModuleConfig{})

	ctx := context.Background()
	block, _ := textMod.Render(ctx)

	fmt.Printf("Default text: %s\n", block.FullText)

}

Output:

Default text: Hello world!

ExampleTextModuleV2_dynamic demonstrates updating module state.

package main

import (
	"context"
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	textMod := modules.NewTextModuleV2(modules.TextModuleConfig{
		ID:   "dynamic",
		Text: "Initial text",
	})

	ctx := context.Background()

	// Render initial state
	block, _ := textMod.Render(ctx)
	fmt.Printf("Before: %s\n", block.FullText)

	// Update the text dynamically
	textMod.SetText("Updated text")

	// Render again
	block, _ = textMod.Render(ctx)
	fmt.Printf("After: %s\n", block.FullText)

}

Output:

Before: Initial text
After: Updated text

ExampleVolumeModuleV2 demonstrates creating a volume module.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	volMod := modules.NewVolumeModuleV2(modules.VolumeModuleConfig{
		ID:     "my-volume",
		Format: "icon-percent",
	})

	fmt.Printf("ID: %s\n", volMod.ID())
	fmt.Printf("Type: %s\n", volMod.Type())

}

Output:

ID: my-volume
Type: volume

ExampleVolumeModuleV2_customization demonstrates customizing volume display.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	volMod := modules.NewVolumeModuleV2(modules.VolumeModuleConfig{
		ID:         "custom-volume",
		Format:     "icon-only",
		IconMuted:  "MUTE",
		IconLow:    "LOW",
		IconMedium: "MED",
		IconHigh:   "HIGH",
		ColorMuted: "#ff0000",
	})

	fmt.Printf("ID: %s\n", volMod.ID())

}

Output:

ID: custom-volume

ExampleVolumeModuleV2_registry demonstrates creating via registry.

package main

import (
	"fmt"

	"git.lyda.ie/kevin/i3going-on/modules"
)

func main() {
	mod, err := modules.Create("volume-v2", "vol", map[string]any{
		"format": "icon-percent",
		"sink":   "@DEFAULT_SINK@",
	})
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	fmt.Printf("Type: %s\n", mod.Type())

}

Output:

Type: volume