indexing

	description: "[

		Color for the EiffelMedia library.

	]"
	date: "$Date$"
	revision: "$Revision$"

class EM_COLOR

create

	make, make_black, make_white, make_with_rgb, make_with_rgba, make_transparent,
	make_from_triple, make_from_quadruple

create {EM_PALETTE}

	make_from_pointer

convert

	make_from_triple ({TUPLE[INTEGER, INTEGER, INTEGER]}),
	make_from_quadruple ({TUPLE[INTEGER, INTEGER, INTEGER, INTEGER]})

feature {NONE} -- Initialization

	make_from_pointer (a_pointer: POINTER) is
			-- Initialise with struct at `a_pointer'.
		do
			create sdl_color_struct.make_shared (a_pointer)
		end

feature -- Initialization

	make_from_triple (t: TUPLE[r, g, b:INTEGER]) is
			-- Make from tuple of red, green, and blue values
		do
			make_with_rgb (t.r, t.g, t.b)
		end

	make_from_quadruple (t: TUPLE[r, g, b, a: INTEGER]) is
			-- Make from tuple of red, green, blue, and alpha values
		do
			make_with_rgba (t.r, t.g, t.b, t.a)
		end

	make is
			-- Default creation.
		do
			create sdl_color_struct.make_new_unshared
			set_alpha (255)
		ensure
			alpha_set: alpha = 255
		end

	make_black is
			-- Create a black color.
		do
			make
			set_red (0)
			set_green (0)
			set_blue (0)
		ensure
			red_set: red = 0
			green_set: green = 0
			blue_set: blue = 0
			alpha_set: alpha = 255
		end

	make_with_rgb (red_value, green_value, blue_value: INTEGER) is
			-- Create color with `red_value', `green_value' and `blue_value'.
		require
			red_value_in_range: 0 <= red_value and red_value <= 255
			green_value_in_range: 0 <= green_value and green_value <= 255
			blue_value_in_range: 0 <= blue_value and blue_value <= 255
		do
			make
			set_red (red_value)
			set_green (green_value)
			set_blue (blue_value)
		ensure
			red_set: red = red_value
			green_set: green = green_value
			blue_set: blue = blue_value
			alpha_set: alpha = 255
		end

	make_with_rgba(red_value, green_value, blue_value, alpha_value: INTEGER) is
			-- Create color with 'red_value', 'green_value', 'blue_value' and 'alpha_value'
		require
			red_value_in_range: 0 <= red_value and red_value <= 255
			green_value_in_range: 0 <= green_value and green_value <= 255
			blue_value_in_range: 0 <= blue_value and blue_value <= 255
			alpha_value_in_range: 0 <= alpha_value and alpha_value <= 255
		do
			make_with_rgb (red_value, green_value, blue_value)
			set_alpha(alpha_value)
		ensure
			red_set: red = red_value
			green_set: green = green_value
			blue_set: blue = blue_value
			alpha_set: alpha = alpha_value
		end



	make_white is
			-- Create a white color
		do
			make
			set_red (255)
			set_green (255)
			set_blue (255)
		ensure
			red_set: red = 255
			green_set: green = 255
			blue_set: blue = 255
			alpha_set: alpha = 255
		end

	make_transparent is
			-- Create with alpha = 0
		do
			make
			set_red (255)
			set_green (255)
			set_blue (255)
			set_alpha (0)
		ensure
			red_set: red = 255
			green_set: green = 255
			blue_set: blue = 255
			alpha_set: alpha = 0
		end

feature -- Access

	red: INTEGER is
			-- Red spectre of the color
		do
			Result := sdl_color_struct.r
		end

	green: INTEGER is
			-- Green spectre of the color
		do
			Result := sdl_color_struct.g
		end

	blue: INTEGER is
			-- Blue spectre of the color
		do
			Result := sdl_color_struct.b
		end

	alpha: INTEGER is
			-- Opacity of the color
			-- (value of 0 means transparent, 255 is opaque)
		do
			Result := sdl_color_struct.unused
		end

	sdl_pointer: POINTER is
			-- Pointer to sdl struct for passing this color to SDL.
		do
			Result := sdl_color_struct.item
		end

feature -- Element change

	set_red (a_value: INTEGER) is
			-- Set red spectre of the color to `a_value'
		require
			a_value_in_range: 0 <= a_value and a_value <= 255
		do
			sdl_color_struct.set_r (a_value)
		ensure
			red_set: red = a_value
		end

	set_green (a_value: INTEGER) is
			-- Set green spectre of the color to `a_value'
		require
			a_value_in_range: 0 <= a_value and a_value <= 255
		do
			sdl_color_struct.set_g (a_value)
		ensure
			green_set: green = a_value
		end

	set_blue (a_value: INTEGER) is
			-- Set blue spectre of the color to `a_value'
		require
			a_value_in_range: 0 <= a_value and a_value <= 255
		do
			sdl_color_struct.set_b (a_value)
		ensure
			blue_set: blue = a_value
		end

	set_alpha (a_value: INTEGER) is
			-- Set `alpha' to `a_value'
		require
			a_value_in_range: 0 <= a_value and a_value <= 255
		do
			sdl_color_struct.set_unused (a_value)
		ensure
			alpha_set: alpha = a_value
		end

	set_rgb (red_value, green_value, blue_value: INTEGER) is
			-- Set red, green and blue values
		require
			red_value_in_range: 0 <= red_value and red_value <= 255
			green_value_in_range: 0 <= green_value and green_value <= 255
			blue_value_in_range: 0 <= blue_value and blue_value <= 255
		do
			set_red (red_value)
			set_green (green_value)
			set_blue (blue_value)
		ensure
			red_set: red = red_value
			green_set: green = red_value
			blue_set: blue = red_value
		end

	set_rgba (red_value, green_value, blue_value, alpha_value: INTEGER) is
			-- Set red, green, blue and alpha values
		require
			red_value_in_range: 0 <= red_value and red_value <= 255
			green_value_in_range: 0 <= green_value and green_value <= 255
			blue_value_in_range: 0 <= blue_value and blue_value <= 255
			alpha_value_in_range: 0 <= alpha_value and alpha_value <= 255
		do
			set_red (red_value)
			set_green (green_value)
			set_blue (blue_value)
			set_alpha (alpha_value)
		ensure
			red_set: red = red_value
			green_set: green = red_value
			blue_set: blue = red_value
			alpha_set: alpha = red_value
		end



feature -- Basic operations

	brighter: EM_COLOR is
			-- A brighter variant of `Current'.
		local
			r, g, b, i: INTEGER
		do
			r := red
			g := green
			b := blue

			i := (1.0 / (1.0 - Factor)).rounded

			if r = 0 and g = 0 and b = 0 then
				create Result.make_with_rgb (i, i, i)
			else
				if r > 0 and r < i then
					r := i
				end
				if g > 0 and g < i then
					g := i
				end
				if b > 0 and b < i then
					b := i
				end
				r := (255).min ((r / Factor).rounded)
				g := (255).min ((g / Factor).rounded)
				b := (255).min ((b / Factor).rounded)
				create Result.make_with_rgb (r, g, b)
			end
		ensure
			brighter_color_not_void: Result /= Void
		end

	darker: EM_COLOR is
			-- A darker variant of `Current'.
		local
			r, g, b: INTEGER
		do
			r := (0).max ((red * Factor).rounded)
			g := (0).max ((green * Factor).rounded)
			b := (0).max ((blue * Factor).rounded)
			create Result.make_with_rgb (r, g, b)
		ensure
			darker_color_not_void: Result /= Void
		end

feature {NONE} -- Implementation

	sdl_color_struct: SDL_COLOR_STRUCT
			-- SDL color struct

	Factor: DOUBLE is 0.7
			-- Factor used in `brighter' and `darker'

invariant

	sdl_colors_not_void: sdl_color_struct /= Void

end