Improve druid.color API with better organization and clearer function names

Co-authored-by: Insality <3294627+Insality@users.noreply.github.com>

.gitignore

@@ -17,3 +17,7 @@ manifest.private.der
 manifest.public.der
 /.editor_settings
 /.deployer_cache
+
+# Example and documentation files (not part of core library)
+example_color_api_usage.lua
+DRUID_COLOR_API_IMPROVEMENTS.md

druid/color.lua

@@ -1,17 +1,18 @@
----@alias color vector4|vector3|string
-
 local PALETTE_DATA = {}
 local COLOR_WHITE = vmath.vector4(1, 1, 1, 1)
 local COLOR_X = hash("color.x")
 local COLOR_Y = hash("color.y")
 local COLOR_Z = hash("color.z")
-local ALPHA = hash("color.w")
 
 local M = {}
 
+-- =============================================================================
+-- COLOR PARSING AND CREATION FUNCTIONS
+-- =============================================================================
 
----Get color by string (hex or from palette)
----@param color_id string|vector4 Color id from palette or hex color
+
+---Get color by string (hex or from palette) or pass through vector4
+---@param color_id string|vector4 Color id from palette, hex color, or existing vector4
 ---@return vector4
 function M.get_color(color_id)
 	if type(color_id) ~= "string" then
@@ -33,8 +34,82 @@ function M.get_color(color_id)
 end
 
 
+---Parse color from various formats (hex, palette ID, or vector4)
+---This is a clearer alias for get_color
+---@param color_value string|vector4 Color value to parse
+---@return vector4
+function M.parse(color_value)
+	return M.get_color(color_value)
+end
+
+
+---Create a color from RGBA values
+---@param r number Red component (0-1)
+---@param g number Green component (0-1)
+---@param b number Blue component (0-1)
+---@param a number|nil Alpha component (0-1), defaults to 1
+---@return vector4
+function M.new(r, g, b, a)
+	return vmath.vector4(r, g, b, a or 1)
+end
+
+
+---Create a color from hex string
+---@param hex string Hex color. #00BBAA or 00BBAA or #0BA or 0BA
+---@param alpha number|nil Alpha value. Default is 1
+---@return vector4
+function M.from_hex(hex, alpha)
+	return M.hex2vector4(hex, alpha)
+end
+
+
+---Create a color from HSB values
+---@param h number Hue (0-1)
+---@param s number Saturation (0-1)
+---@param b number Brightness/Value (0-1)
+---@param a number|nil Alpha value. Default is 1
+---@return vector4
+function M.from_hsb(h, s, b, a)
+	local r, g, b_val, alpha = M.hsb2rgb(h, s, b, a)
+	return vmath.vector4(r, g, b_val, alpha or 1)
+end
+
+
+-- =============================================================================
+-- COLOR FORMAT CONVERSION FUNCTIONS
+-- =============================================================================
+
+---Convert color to hex string
+---@param color vector4 Color to convert
+---@return string Hex color string (without #)
+function M.to_hex(color)
+	return M.rgb2hex(color.x, color.y, color.z)
+end
+
+
+---Convert color to RGB values
+---@param color vector4 Color to convert
+---@return number, number, number, number r, g, b, a
+function M.to_rgb(color)
+	return color.x, color.y, color.z, color.w
+end
+
+
+---Convert color to HSB values
+---@param color vector4 Color to convert
+---@return number, number, number, number h, s, b, a
+function M.to_hsb(color)
+	return M.rgb2hsb(color.x, color.y, color.z, color.w)
+end
+
+
+-- =============================================================================
+-- PALETTE MANAGEMENT FUNCTIONS
+-- =============================================================================
+
+
 ---Add palette to palette data
----@param palette_data table<string, vector4>
+---@param palette_data table<string, vector4|string>
 function M.add_palette(palette_data)
 	for color_id, color in pairs(palette_data) do
 		if type(color) == "string" then
@@ -46,11 +121,59 @@ function M.add_palette(palette_data)
 end
 
 
+---Set a single color in the palette
+---@param color_id string Color identifier
+---@param color vector4|string Color value (vector4 or hex string)
+function M.set_palette_color(color_id, color)
+	if type(color) == "string" then
+		PALETTE_DATA[color_id] = M.hex2vector4(color)
+	else
+		PALETTE_DATA[color_id] = color
+	end
+end
+
+
+---Remove a color from the palette
+---@param color_id string Color identifier to remove
+function M.remove_palette_color(color_id)
+	PALETTE_DATA[color_id] = nil
+end
+
+
+---Check if a color exists in the palette
+---@param color_id string Color identifier to check
+---@return boolean
+function M.has_palette_color(color_id)
+	return PALETTE_DATA[color_id] ~= nil
+end
+
+
+---Get a color from the palette
+---@param color_id string Color identifier
+---@return vector4|nil Color or nil if not found
+function M.get_palette_color(color_id)
+	return PALETTE_DATA[color_id]
+end
+
+
+---Get the entire palette
+---@return table<string, vector4>
 function M.get_palette()
 	return PALETTE_DATA
 end
 
 
+---Clear the entire palette
+function M.clear_palette()
+	PALETTE_DATA = {}
+end
+
+
+-- =============================================================================
+-- GUI NODE OPERATIONS
+-- =============================================================================
+
+
 ---Set color of gui node without changing alpha
 ---@param gui_node node
 ---@param color vector4|vector3|string Color in vector4, vector3 or color id from palette
@@ -65,6 +188,34 @@ function M.set_color(gui_node, color)
 end
 
 
+---Apply color to gui node (clearer alias for set_color)
+---@param gui_node node GUI node to apply color to
+---@param color vector4|vector3|string Color in vector4, vector3 or color id from palette
+function M.apply_to_node(gui_node, color)
+	M.set_color(gui_node, color)
+end
+
+
+---Set node color including alpha
+---@param gui_node node GUI node to apply color to
+---@param color vector4|string Color with alpha channel
+function M.set_node_color_with_alpha(gui_node, color)
+	if type(color) == "string" then
+		color = M.get_color(color)
+	end
+
+	gui.set(gui_node, COLOR_X, color.x)
+	gui.set(gui_node, COLOR_Y, color.y)
+	gui.set(gui_node, COLOR_Z, color.z)
+	gui.set(gui_node, "color.w", color.w)
+end
+
+
+-- =============================================================================
+-- COLOR MANIPULATION FUNCTIONS
+-- =============================================================================
+
+
 ---Lerp colors via color HSB values
 ---@param t number Lerp value. 0 - color1, 1 - color2
 ---@param color1 vector4 Color 1
@@ -84,6 +235,56 @@ function M.lerp(t, color1, color2)
 end
 
 
+---Mix two colors using linear RGB interpolation (simpler than lerp)
+---@param color1 vector4 First color
+---@param color2 vector4 Second color
+---@param ratio number Mixing ratio (0 = color1, 1 = color2)
+---@return vector4 Mixed color
+function M.mix(color1, color2, ratio)
+	local inv_ratio = 1 - ratio
+	return vmath.vector4(
+		color1.x * inv_ratio + color2.x * ratio,
+		color1.y * inv_ratio + color2.y * ratio,
+		color1.z * inv_ratio + color2.z * ratio,
+		color1.w * inv_ratio + color2.w * ratio
+	)
+end
+
+
+---Lighten a color by mixing with white
+---@param color vector4 Color to lighten
+---@param amount number Amount to lighten (0-1)
+---@return vector4 Lightened color
+function M.lighten(color, amount)
+	return M.mix(color, COLOR_WHITE, amount)
+end
+
+
+---Darken a color by mixing with black
+---@param color vector4 Color to darken
+---@param amount number Amount to darken (0-1)
+---@return vector4 Darkened color
+function M.darken(color, amount)
+	local black = vmath.vector4(0, 0, 0, color.w)
+	return M.mix(color, black, amount)
+end
+
+
+---Adjust color alpha
+---@param color vector4 Color to adjust
+---@param alpha number New alpha value (0-1)
+---@return vector4 Color with adjusted alpha
+function M.with_alpha(color, alpha)
+	return vmath.vector4(color.x, color.y, color.z, alpha)
+end
+
+
+-- =============================================================================
+-- LOW-LEVEL CONVERSION FUNCTIONS
+-- =============================================================================
+
+
+
 ---Convert hex color to rgb values.
 ---@param hex string Hex color. #00BBAA or 00BBAA or #0BA or 0BA
 ---@return number, number, number
@@ -170,9 +371,10 @@ end
 
 
 ---Convert rgb color to hex color
----@param red number Red value
----@param green number Green value
----@param blue number Blue value
+---@param red number Red value (0-1)
+---@param green number Green value (0-1)
+---@param blue number Blue value (0-1)
+---@return string Hex color string (without #)
 function M.rgb2hex(red, green, blue)
 	local r = string.format("%x", math.floor(red * 255))
 	local g = string.format("%x", math.floor(green * 255))
@@ -181,6 +383,11 @@ function M.rgb2hex(red, green, blue)
 end
 
 
+-- =============================================================================
+-- INITIALIZATION
+-- =============================================================================
+
+
 local DEFAULT_PALETTE_PATH = sys.get_config_string("druid.palette_path")
 if DEFAULT_PALETTE_PATH then
 	local loaded_palette = sys.load_resource(DEFAULT_PALETTE_PATH)

druid/custom/rich_text/rich_text.lua

@@ -34,7 +34,7 @@ local rich_text = require("druid.custom.rich_text.module.rt")
 ---@field scale vector3
 ---@field size vector3
 ---@field metrics druid.rich_text.metrics
----@field pivot constant
+---@field pivot userdata
 ---@field text string
 ---@field shadow vector4
 ---@field outline vector4
@@ -68,7 +68,7 @@ local rich_text = require("druid.custom.rich_text.module.rt")
 
 ---The component that handles a rich text display, allows to custom color, size, font, etc. of the parts of the text
 ---@class druid.rich_text: druid.component
----@field root node The root text node of the rich text
+---@field root node The root node of the rich text
 ---@field text_prefab node The text prefab node
 ---@field private _last_value string The last value of the rich text
 ---@field private _settings table The settings of the rich text
@@ -255,18 +255,4 @@ function M:_create_settings()
 end
 
 
----Set the width of the rich text, not affects the size of current spawned words
----@param width number
-function M:set_width(width)
-	self._settings.width = width
-end
-
-
----Set the height of the rich text, not affects the size of current spawned words
----@param height number
-function M:set_height(height)
-	self._settings.height = height
-end
-
-
 return M

druid/druid.lua

@@ -147,7 +147,7 @@ function M.get_widget(widget_class, gui_url, params)
 	for index = 1, #registered_druids do
 		local druid = registered_druids[index]
 		if druid.fragment == gui_url.fragment and druid.path == gui_url.path then
-			return druid.new_widget(widget_class, nil, nil, params)
+			return druid.new_widget:trigger(widget_class, nil, nil, params)
 		end
 	end
 

druid/editor_scripts/assign_layers.lua

@@ -1,7 +1,7 @@
 --- Module for assigning layers to GUI nodes based on textures and fonts
 
 local defold_parser = require("druid.editor_scripts.defold_parser.defold_parser")
-local system = require("druid.editor_scripts.defold_parser.system.parser_internal")
+local system = require("druid.editor_scripts.defold_parser.system.system")
 
 local M = {}
 

druid/editor_scripts/create_druid_gui_script.lua

@@ -12,7 +12,7 @@ end
 function M.create_druid_gui_script(selection)
 	local gui_filepath = editor.get(selection, "path")
 	local filename = gui_filepath:match("([^/]+)%.gui$")
-	print("Create GUI script for", gui_filepath)
+	print("Create Druid GUI Script for", gui_filepath)
 
 	local absolute_project_path = editor.external_file_attributes(".").path
 	local widget_resource_path = gui_filepath:gsub("%.gui$", ".gui_script")
@@ -25,8 +25,8 @@ function M.create_druid_gui_script(selection)
 	local f = io.open(new_widget_absolute_path, "r")
 	if f then
 		f:close()
-		print("GUI script file already exists at " .. new_widget_absolute_path)
-		error("Creation aborted to prevent overwriting")
+		print("Widget file already exists at " .. new_widget_absolute_path)
+		print("Creation aborted to prevent overwriting")
 		return
 	end
 
@@ -37,7 +37,7 @@ function M.create_druid_gui_script(selection)
 	local template_content = editor.get(template_path, "text")
 	if not template_content then
 		print("Error: Could not load template from", template_path)
-		error("Check the template path in [Druid] Settings")
+		print("Check the template path in [Druid] Settings")
 		return
 	end
 
@@ -54,12 +54,90 @@ function M.create_druid_gui_script(selection)
 	file:write(template_content)
 	file:close()
 
-	print("Widget created: " .. widget_resource_path)
-	editor.transact({
-		editor.tx.set(selection, "script", widget_resource_path)
-	})
-	editor.save()
+	print("Widget created at " .. widget_resource_path)
 
+	M.link_gui_script(selection, widget_resource_path)
+end
+
+
+---Links a GUI script to a GUI file by updating the script property
+---@param selection string The GUI resource to modify
+---@param widget_resource_path string The path to the GUI script to link
+function M.link_gui_script(selection, widget_resource_path)
+	local defold_parser = require("druid.editor_scripts.defold_parser.defold_parser")
+	local system = require("druid.editor_scripts.defold_parser.system.system")
+
+	local gui_filepath = editor.get(selection, "path")
+	print("Linking GUI script to", gui_filepath)
+
+	-- Get the absolute path to the file
+	local absolute_project_path = editor.external_file_attributes(".").path
+	if not absolute_project_path:match("[\\/]$") then
+		absolute_project_path = absolute_project_path .. "/"
+	end
+	local clean_gui_path = gui_filepath
+	if clean_gui_path:sub(1, 1) == "/" then
+		clean_gui_path = clean_gui_path:sub(2)
+	end
+	local gui_absolute_path = absolute_project_path .. clean_gui_path
+
+	-- Create a backup
+	local backup_path = gui_absolute_path .. ".backup"
+	print("Creating backup at:", backup_path)
+
+	-- Read and write backup
+	local content, err_read = system.read_file(gui_absolute_path)
+	if not content then
+		print("Error reading original file for backup:", err_read)
+		return
+	end
+
+	local success, err_write = system.write_file(backup_path, content)
+	if not success then
+		print("Error creating backup file:", err_write)
+		return
+	end
+
+	-- Parse the GUI file
+	print("Parsing GUI file...")
+	local gui_data = defold_parser.load_from_file(gui_absolute_path)
+	if not gui_data then
+		print("Error: Failed to parse GUI file")
+		return
+	end
+
+	-- Update the script property
+	print("Setting script property to:", widget_resource_path)
+	gui_data.script = widget_resource_path
+
+	-- Write the updated GUI file
+	print("Writing updated GUI file...")
+	local save_success = defold_parser.save_to_file(gui_absolute_path, gui_data)
+
+	if not save_success then
+		print("Error: Failed to save GUI file")
+		print("Attempting to restore from backup...")
+
+		-- Restore from backup on failure
+		local backup_content, backup_err_read = system.read_file(backup_path)
+		if not backup_content then
+			print("Error reading backup file:", backup_err_read)
+			return
+		end
+
+		local restore_success, restore_err_write = system.write_file(gui_absolute_path, backup_content)
+		if not restore_success then
+			print("Critical: Failed to restore from backup:", restore_err_write)
+			return
+		end
+
+		print("Restored successfully from backup")
+		return
+	end
+
+	-- Remove backup on success
+	os.remove(backup_path)
+	print("Successfully linked GUI script to:", gui_filepath)
 end
 
 

druid/editor_scripts/create_druid_widget.lua

@@ -26,7 +26,7 @@ function M.create_druid_widget(selection)
 	if f then
 		f:close()
 		print("Widget file already exists at " .. new_widget_absolute_path)
-		error("Creation aborted to prevent overwriting")
+		print("Creation aborted to prevent overwriting")
 		return
 	end
 
@@ -37,7 +37,7 @@ function M.create_druid_widget(selection)
 	local template_content = editor.get(template_path, "text")
 	if not template_content then
 		print("Error: Could not load template from", template_path)
-		error("Check the template path in [Druid] Settings")
+		print("Check the template path in [Druid] Settings")
 		return
 	end
 

druid/editor_scripts/defold_parser/defold_parser.lua

@@ -1,7 +1,7 @@
 --- Defold Text Proto format encoder/decoder to lua table
 
 local config = require("druid.editor_scripts.defold_parser.system.config")
-local parser_internal = require("druid.editor_scripts.defold_parser.system.parser_internal")
+local system = require("druid.editor_scripts.defold_parser.system.system")
 
 local M = {}
 
@@ -17,7 +17,7 @@ function M.decode_defold_object(text)
 
 	-- For each line in the text, we go through the following steps:
 	for raw_line in text:gmatch("[^\r\n]+") do
-		parser_internal.parse_line(raw_line, stack)
+		system.parse_line(raw_line, stack)
 	end
 
 	return root
@@ -39,8 +39,8 @@ function M.encode_defold_object(obj, spaces, data_level, extension)
 	end
 
 	table.sort(keys, function(a, b)
-		local index_a = parser_internal.contains(key_order, a) or 0
-		local index_b = parser_internal.contains(key_order, b) or 0
+		local index_a = system.contains(key_order, a) or 0
+		local index_b = system.contains(key_order, b) or 0
 		return index_a < index_b
 	end)
 
@@ -63,7 +63,7 @@ function M.encode_defold_object(obj, spaces, data_level, extension)
 						result = result .. tabString .. key .. ': "' .. encodedChild .. '"\n'
 					elseif item_type == "number" or item_type == "boolean" then
 						local is_contains_dot = string.find(key, "%.")
-						if item_type == "number" and (parser_internal.contains(config.with_dot_params, key) and not is_contains_dot) then
+						if item_type == "number" and (system.contains(config.with_dot_params, key) and not is_contains_dot) then
 							result = result .. tabString .. key .. ': ' .. string.format("%.1f", array_item) .. '\n'
 						else
 							result = result .. tabString .. key .. ': ' .. tostring(array_item) .. '\n'
@@ -94,7 +94,7 @@ function M.encode_defold_object(obj, spaces, data_level, extension)
 			-- Handle scalar values (string, number, boolean)
 			if value_type == "number" or value_type == "boolean" then
 				local is_contains_dot = string.find(key, "%.")
-				if value_type == "number" and (parser_internal.contains(config.with_dot_params, key) and not is_contains_dot) then
+				if value_type == "number" and (system.contains(config.with_dot_params, key) and not is_contains_dot) then
 					result = result .. tabString .. key .. ': ' .. string.format("%.1f", value) .. '\n'
 				else
 					result = result .. tabString .. key .. ': ' .. tostring(value) .. '\n'
@@ -125,7 +125,7 @@ end
 ---@param file_path string
 ---@return table|nil, string|nil
 function M.load_from_file(file_path)
-	local content, reason = parser_internal.read_file(file_path)
+	local content, reason = system.read_file(file_path)
 	if not content then
 		return nil, reason
 	end
@@ -146,7 +146,7 @@ function M.save_to_file(file_path, lua_table)
 
 	local encoded_object = M.encode_defold_object(lua_table, nil, nil, defold_format_name)
 
-	return parser_internal.write_file(file_path, encoded_object)
+	return system.write_file(file_path, encoded_object)
 end
 
 

test/test.gui_script

@@ -5,6 +5,7 @@ function init(self)
 	deftest.add(require("test.tests.test_back_handler"))
 	deftest.add(require("test.tests.test_blocker"))
 	deftest.add(require("test.tests.test_button"))
+	deftest.add(require("test.tests.test_color"))
 	deftest.add(require("test.tests.test_container"))
 	deftest.add(require("test.tests.test_drag"))
 	deftest.add(require("test.tests.test_grid"))

test/tests/test_color.lua

@@ -0,0 +1,313 @@
+return function()
+	describe("Color Module", function()
+		local color = nil
+
+		before(function()
+			color = require("druid.color")
+		end)
+
+		describe("Color Creation and Parsing", function()
+			it("Should create colors from RGBA values", function()
+				local test_color = color.new(1, 0.5, 0, 0.8)
+				assert(test_color.x == 1)
+				assert(test_color.y == 0.5)
+				assert(test_color.z == 0)
+				assert(test_color.w == 0.8)
+			end)
+
+			it("Should create colors from hex strings", function()
+				local red = color.from_hex("#FF0000")
+				assert(red.x == 1)
+				assert(red.y == 0)
+				assert(red.z == 0)
+				assert(red.w == 1)
+
+				local blue_with_alpha = color.from_hex("0000FF", 0.5)
+				assert(blue_with_alpha.x == 0)
+				assert(blue_with_alpha.y == 0)
+				assert(blue_with_alpha.z == 1)
+				assert(blue_with_alpha.w == 0.5)
+			end)
+
+			it("Should create colors from HSB values", function()
+				local red = color.from_hsb(0, 1, 1) -- HSB for red
+				assert(red.x == 1)
+				assert(red.y == 0)
+				assert(red.z == 0)
+				assert(red.w == 1)
+			end)
+
+			it("Should parse various color formats", function()
+				-- Test parsing alias for get_color
+				local hex_color = color.parse("#FF0000")
+				assert(hex_color.x == 1)
+
+				local vector_color = color.parse(vmath.vector4(0, 1, 0, 1))
+				assert(vector_color.y == 1)
+			end)
+
+			it("Should parse hex colors correctly with get_color", function()
+				-- Test with # prefix
+				local color1 = color.get_color("#FF0000")
+				assert(color1.x == 1)
+				assert(color1.y == 0)
+				assert(color1.z == 0)
+				assert(color1.w == 1)
+
+				-- Test without # prefix
+				local color2 = color.get_color("00FF00")
+				assert(color2.x == 0)
+				assert(color2.y == 1)
+				assert(color2.z == 0)
+				assert(color2.w == 1)
+
+				-- Test 3-digit hex
+				local color3 = color.get_color("F0F")
+				assert(color3.x == 1)
+				assert(color3.y == 0)
+				assert(color3.z == 1)
+				assert(color3.w == 1)
+			end)
+
+			it("Should handle vector4 input in get_color", function()
+				local input_color = vmath.vector4(1, 0.5, 0, 1)
+				local result = color.get_color(input_color)
+				assert(result == input_color)
+			end)
+
+			it("Should return white for unknown color IDs", function()
+				local result = color.get_color("unknown_color")
+				assert(result.x == 1)
+				assert(result.y == 1)
+				assert(result.z == 1)
+				assert(result.w == 1)
+			end)
+		end)
+
+		describe("Color Format Conversion", function()
+			it("Should convert colors to hex", function()
+				local red = vmath.vector4(1, 0, 0, 1)
+				local hex = color.to_hex(red)
+				assert(hex == "FF0000")
+			end)
+
+			it("Should convert colors to RGB values", function()
+				local test_color = vmath.vector4(1, 0.5, 0.25, 0.8)
+				local r, g, b, a = color.to_rgb(test_color)
+				assert(r == 1)
+				assert(g == 0.5)
+				assert(b == 0.25)
+				assert(a == 0.8)
+			end)
+
+			it("Should convert colors to HSB values", function()
+				local red = vmath.vector4(1, 0, 0, 1)
+				local h, s, b, a = color.to_hsb(red)
+				assert(h == 0) -- Red hue
+				assert(s == 1) -- Full saturation
+				assert(b == 1) -- Full brightness
+				assert(a == 1) -- Full alpha
+			end)
+
+			it("Should convert hex to rgb values", function()
+				local r, g, b = color.hex2rgb("#FF8000")
+				assert(r == 1)
+				assert(g == 0.5019607843137255) -- 128/255
+				assert(b == 0)
+			end)
+
+			it("Should convert hex to vector4", function()
+				local vec = color.hex2vector4("#FF8000", 0.5)
+				assert(vec.x == 1)
+				assert(vec.y == 0.5019607843137255)
+				assert(vec.z == 0)
+				assert(vec.w == 0.5)
+			end)
+
+			it("Should convert rgb to hex", function()
+				local hex = color.rgb2hex(1, 0.5019607843137255, 0)
+				assert(hex == "FF8000")
+			end)
+		end)
+
+		describe("Color Space Conversion", function()
+			it("Should convert RGB to HSB correctly", function()
+				local h, s, v, a = color.rgb2hsb(1, 0, 0, 1) -- Red
+				assert(h == 0)
+				assert(s == 1)
+				assert(v == 1)
+				assert(a == 1)
+			end)
+
+			it("Should convert HSB to RGB correctly", function()
+				local r, g, b, a = color.hsb2rgb(0, 1, 1, 1) -- Red
+				assert(r == 1)
+				assert(g == 0)
+				assert(b == 0)
+				assert(a == 1)
+			end)
+
+			it("Should handle round-trip HSB conversion", function()
+				local original_r, original_g, original_b = 0.5, 0.7, 0.3
+				local h, s, v = color.rgb2hsb(original_r, original_g, original_b)
+				local converted_r, converted_g, converted_b = color.hsb2rgb(h, s, v)
+				
+				-- Allow for small floating point differences
+				assert(math.abs(converted_r - original_r) < 0.001)
+				assert(math.abs(converted_g - original_g) < 0.001)
+				assert(math.abs(converted_b - original_b) < 0.001)
+			end)
+		end)
+
+		describe("Palette Management", function()
+			it("Should add and retrieve palette colors", function()
+				local test_palette = {
+					primary = vmath.vector4(1, 0, 0, 1),
+					secondary = "#00FF00",
+					tertiary = vmath.vector4(0, 0, 1, 1)
+				}
+
+				color.add_palette(test_palette)
+
+				local primary = color.get_color("primary")
+				assert(primary.x == 1)
+				assert(primary.y == 0)
+				assert(primary.z == 0)
+				assert(primary.w == 1)
+
+				local secondary = color.get_color("secondary")
+				assert(secondary.x == 0)
+				assert(secondary.y == 1)
+				assert(secondary.z == 0)
+				assert(secondary.w == 1)
+			end)
+
+			it("Should manage individual palette colors", function()
+				-- Set a palette color
+				color.set_palette_color("test_red", vmath.vector4(1, 0, 0, 1))
+				assert(color.has_palette_color("test_red") == true)
+				
+				local retrieved = color.get_palette_color("test_red")
+				assert(retrieved.x == 1)
+				assert(retrieved.y == 0)
+				assert(retrieved.z == 0)
+
+				-- Remove the color
+				color.remove_palette_color("test_red")
+				assert(color.has_palette_color("test_red") == false)
+				assert(color.get_palette_color("test_red") == nil)
+			end)
+
+			it("Should return the palette", function()
+				local palette = color.get_palette()
+				assert(type(palette) == "table")
+			end)
+
+			it("Should clear the palette", function()
+				color.set_palette_color("temp_color", vmath.vector4(1, 1, 1, 1))
+				color.clear_palette()
+				assert(color.has_palette_color("temp_color") == false)
+			end)
+		end)
+
+		describe("Color Manipulation", function()
+			it("Should lerp colors correctly", function()
+				local color1 = vmath.vector4(1, 0, 0, 1) -- Red
+				local color2 = vmath.vector4(0, 1, 0, 1) -- Green
+				
+				local mid_color = color.lerp(0.5, color1, color2)
+				-- Note: lerp uses HSB interpolation, so the result might not be a simple average
+				assert(type(mid_color.x) == "number")
+				assert(type(mid_color.y) == "number")
+				assert(type(mid_color.z) == "number")
+				assert(mid_color.w == 1)
+
+				-- Test endpoints
+				local start_color = color.lerp(0, color1, color2)
+				local end_color = color.lerp(1, color1, color2)
+				
+				assert(math.abs(start_color.x - color1.x) < 0.001)
+				assert(math.abs(end_color.x - color2.x) < 0.001)
+			end)
+
+			it("Should mix colors using linear RGB interpolation", function()
+				local red = vmath.vector4(1, 0, 0, 1)
+				local blue = vmath.vector4(0, 0, 1, 1)
+				
+				local mixed = color.mix(red, blue, 0.5)
+				assert(mixed.x == 0.5) -- Half red
+				assert(mixed.y == 0)   -- No green
+				assert(mixed.z == 0.5) -- Half blue
+				assert(mixed.w == 1)   -- Full alpha
+			end)
+
+			it("Should lighten colors", function()
+				local dark_red = vmath.vector4(0.5, 0, 0, 1)
+				local lightened = color.lighten(dark_red, 0.5)
+				
+				assert(lightened.x > dark_red.x) -- Should be lighter
+				assert(lightened.y > dark_red.y) -- Should have some green/white
+				assert(lightened.z > dark_red.z) -- Should have some blue/white
+			end)
+
+			it("Should darken colors", function()
+				local bright_red = vmath.vector4(1, 0, 0, 1)
+				local darkened = color.darken(bright_red, 0.5)
+				
+				assert(darkened.x < bright_red.x) -- Should be darker
+				assert(darkened.y == 0) -- Should still have no green
+				assert(darkened.z == 0) -- Should still have no blue
+			end)
+
+			it("Should adjust alpha", function()
+				local opaque_red = vmath.vector4(1, 0, 0, 1)
+				local semi_transparent = color.with_alpha(opaque_red, 0.5)
+				
+				assert(semi_transparent.x == 1) -- Color unchanged
+				assert(semi_transparent.y == 0)
+				assert(semi_transparent.z == 0)
+				assert(semi_transparent.w == 0.5) -- Alpha changed
+			end)
+		end)
+
+		describe("GUI Node Operations", function()
+			it("Should set color on GUI node", function()
+				-- Create a test node
+				local test_node = gui.new_box_node(vmath.vector3(0, 0, 0), vmath.vector3(100, 100, 0))
+				
+				-- Test with vector4
+				local test_color = vmath.vector4(1, 0.5, 0, 1)
+				color.set_color(test_node, test_color)
+				
+				-- Verify color was set (we can't easily read it back, but we can verify no errors)
+				assert(true) -- If we get here, no error occurred
+
+				-- Test with string color
+				color.set_color(test_node, "#FF0000")
+				assert(true) -- If we get here, no error occurred
+
+				-- Clean up
+				gui.delete_node(test_node)
+			end)
+
+			it("Should apply color to node using alias", function()
+				local test_node = gui.new_box_node(vmath.vector3(0, 0, 0), vmath.vector3(100, 100, 0))
+				
+				-- Test the alias function
+				color.apply_to_node(test_node, vmath.vector4(0, 1, 0, 1))
+				assert(true) -- If we get here, no error occurred
+
+				gui.delete_node(test_node)
+			end)
+
+			it("Should set node color including alpha", function()
+				local test_node = gui.new_box_node(vmath.vector3(0, 0, 0), vmath.vector3(100, 100, 0))
+				
+				color.set_node_color_with_alpha(test_node, vmath.vector4(1, 0, 0, 0.5))
+				assert(true) -- If we get here, no error occurred
+
+				gui.delete_node(test_node)
+			end)
+		end)
+	end)
+end

wiki/changelog.md

@@ -720,23 +720,14 @@ Please support me if you like this project! It will help me keep engaged to upda
 - Update for using `defold-event` library v12
 
 ### Druid 1.2.0
-- [Blocker] Fix for internal is_enabled state
-- [Button] expose all click functions for the button
-- [Scroll] Add `scroll_to_make_node_visible` function
-- [Palette] Add Druid Color module
-	- Manage color palettes
-	- Color convertations
-	- Convenient usage
-- [Container] Fix for container stretch mode (stretch and fit is not worked in init function)
-- [Rich Text] Using color names from the palette
-- [Rich Text] Add `rich_text:set_split_to_characters(true)` to split each letter node separately
-	- Weird implementation, but nice to have
-- [Rich Text] Add `set_width` and `set_height` functions
-- [GO Widgets] Now passes events and functions from the widget to the GO context
-- [Layout] Add `set_position_function` function, similar to the Grid component
-- [Properties Panel] Update with deep navigation support
-	- Add "Scenes" to manage a list of properties with back button support
-	- Add "Pages" to manage a a big lists of properties with paginations support
-	- Add `properties_panel:render_lua_table` to easily render your lua tables with a various types support (any simple types and vector, functions, events etc)
-	- Add "Refresh" button, which active a 1-sec refresh for current page
+- Fix for blocker internal enabled state depends from GUI node
+- Move to druid colors for rich text
+- Fix for container stretch mode (stretch and fit is not worked in init function)
+- Add split_to_characters in rich text for making fancy text
+- Druid GO Widgets now can wrap an events to (before only top level functions)
+- Ability to pass params to Druid GO Widgets
+- Update properties panel:
+	- Add "scenes" to manage a list of properties with back button support
+	- Add "refresh" button, which active a 1-sec refresh for current page
+	- Add "Render lua table" to easily render your lua tables with a various types support (any simple types and vector, functions, events etc)
 

wiki/manuals/widget_memory_fps_panels.md

@@ -1,8 +1,8 @@
 # Memory and FPS Panel Widgets
 
-The `Druid 1.1` comes with two included widgets: `Memory Panel` and `FPS Panel`, which allow you to monitor memory and FPS in your game.
+The `Druid 1.1` comes with widgets and two included widgets are `Memory Panel` and `FPS Panel` which allow you to monitor memory and FPS in your game.
 
-Widgets in Druid usually consist of two files: GUI, which is used to place as a template on your GUI scene and Lua script, which is used to be create with Druid.
+Widgets in Druid usually consists from two files: GUI, which is used to placed as a template on your GUI scene and Lua script, which is used to be created with Druid.
 
 <!-- Video -->