note
	description: "A font that can be use to draw text with a {TEXT_IMAGE}."
	author: "Louis Marchand"
	date: "Mon, 30 Mar 2015 01:06:37 +0000"
	revision: "2.0"

class 
	TEXT_FONT

create 
	make,
	make_with_index

feature {NONE} -- Initialization

	make (a_filename: READABLE_STRING_GENERAL; a_size: INTEGER_32)
			-- Initialization for Current.
		require
			is_text_enable: Text_library.is_text_enable
			filename_not_empty: not a_filename.is_empty
			size_stricly_positive: a_size > 1
		do
			make_with_index (a_filename, a_size, 0)
		end

	make_with_index (a_filename: READABLE_STRING_GENERAL; a_size: INTEGER_32; a_index: INTEGER_32)
			-- Initialization for Current.
			-- The index is use if there is more than one font in a ttf file.
		require
			is_text_enable: Text_library.is_text_enable
			filename_not_empty: not a_filename.is_empty
			size_stricly_positive: a_size > 1
			index_positive: a_index >= 0
		local
			l_filename_c, l_mode_c: C_STRING
		do
			default_create
			size := a_size
			index := a_index
			create l_filename_c.make (a_filename)
			create l_mode_c.make ("rb")
			rwop := {GAME_SDL_EXTERNAL}.sdl_rwfromfile (l_filename_c.item, l_mode_c.item)
		end
	
feature -- Access

	ascent: INTEGER_32
			-- distance from the top of the drawing area to the baseline in pixel.
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_fontascent (item)
		end

	descent: INTEGER_32
			-- distance from the baseline to the bottom of the drawing area in pixel.
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_fontdescent (item)
		end

	disable_bold
			-- remove a bold style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_bold.bit_not))
		ensure
			is_disabled: not is_bold
		end

	disable_hinting
			-- Disable the draw hinting of Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfonthinting (item, {GAME_TEXT_EXTERNAL}.ttf_hinting_none)
		end

	disable_italic
			-- remove an italic style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_italic.bit_not))
		ensure
			is_disabled: not is_italic
		end

	disable_kerning
			-- Does not allow the library to use kerning when drawing a text with Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontkerning (item, 0)
		ensure
			is_disabled: not is_kerning_enabled
		end

	disable_outline
			-- Disable the outline size in Current
		require
				exists
		do
			set_outline_size (0)
		ensure
			is_disabled: not has_outline
		end

	disable_strike_through
			-- remove a strike through style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_strikethrough.bit_not))
		ensure
			is_disabled: not is_strike_through
		end

	disable_style_modifier
			-- Disable all style modifier (underline, bold, italic and strike through)
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_style_normal)
		end

	disable_underline
			-- remove an underline style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_underline.bit_not))
		ensure
			is_disabled: not is_underline
		end

	enable_bold
			-- Add a bold style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_or ({GAME_TEXT_EXTERNAL}.ttf_style_bold))
		ensure
			is_enabled: is_bold
		end

	enable_italic
			-- Add an italic style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_or ({GAME_TEXT_EXTERNAL}.ttf_style_italic))
		ensure
			is_enabled: is_italic
		end

	enable_kerning
			-- Allow the library to use kerning when drawing a text with Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontkerning (item, 1)
		ensure
			is_enabled: is_kerning_enabled
		end

	enable_light_hinting
			-- Use the light hinting to draw Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfonthinting (item, {GAME_TEXT_EXTERNAL}.ttf_hinting_light)
		ensure
			is_enable: has_light_hinting
		end

	enable_monochrome_hinting
			-- Use the monochrome hinting to draw Current.
			-- Must only be use with monochrome display
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfonthinting (item, {GAME_TEXT_EXTERNAL}.ttf_hinting_mono)
		ensure
			is_enable: has_monochrome_hinting
		end

	enable_normal_hinting
			-- Use the normal hinting to draw Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfonthinting (item, {GAME_TEXT_EXTERNAL}.ttf_hinting_normal)
		ensure
			is_enable: has_normal_hinting
		end

	enable_strike_through
			-- Add a strike through style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_or ({GAME_TEXT_EXTERNAL}.ttf_style_strikethrough))
		ensure
			is_enabled: is_strike_through
		end

	enable_underline
			-- Add an underline style modifier to Current
		require
				exists
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontstyle (item, {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_or ({GAME_TEXT_EXTERNAL}.ttf_style_underline))
		ensure
			is_enabled: is_underline
		end

	exists: BOOLEAN
			-- Is allocated memory still allocated?
		do
			Result := not item.is_default_pointer
		end

	face_family_name: READABLE_STRING_GENERAL
			-- The name of the face family of Curent
		require
				exists
		local
			l_name_ptr: POINTER
			l_name_c: C_STRING
		do
			l_name_ptr := {GAME_TEXT_EXTERNAL}.ttf_fontfacefamilyname (item)
			if l_name_ptr.is_default_pointer then
				Result := ""
			else
				create l_name_c.make_by_pointer (l_name_ptr)
				Result := l_name_c.string
			end
		end

	face_style_name: READABLE_STRING_GENERAL
			-- The name of the face style of Curent
		require
				exists
		local
			l_name_ptr: POINTER
			l_name_c: C_STRING
		do
			l_name_ptr := {GAME_TEXT_EXTERNAL}.ttf_fontfacestylename (item)
			if l_name_ptr.is_default_pointer then
				Result := ""
			else
				create l_name_c.make_by_pointer (l_name_ptr)
				Result := l_name_c.string
			end
		end

	generating_type: TYPE [detachable TEXT_FONT]
			-- Type of current object
			-- (type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generating_type_not_void: Result /= Void
		end

	generator: STRING_8
			-- Name of current object's generating class
			-- (base class of the type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generator_not_void: Result /= Void
			generator_not_empty: not Result.is_empty
		end

	glyph_metrics (a_character: CHARACTER_32): TUPLE [minimal_x: INTEGER_32; maximal_x: INTEGER_32; minimal_y: INTEGER_32; maximal_y: INTEGER_32; advance: INTEGER_32]
			-- The informations about the glyph representing a_character generated with Current.
			-- Set has_error on error.
		require
				exists
			is_character_valid: is_glyph_provided (a_character)
		local
			l_error, l_minimal_x, l_maximal_x, l_minimal_y, l_maximal_y, l_advance: INTEGER_32
		do
			clear_error
			l_error := {GAME_TEXT_EXTERNAL}.ttf_glyphmetrics (item, a_character.natural_32_code.as_natural_16, $l_minimal_x.to_pointer, $l_maximal_x.to_pointer, $l_minimal_y.to_pointer, $l_maximal_y.to_pointer, $l_advance.to_pointer)
			if l_error < 0 then
				manage_error_code (l_error, "Cannot get the glyph information.")
				Result := [0, 0, 0, 0, 0]
			else
				Result := [l_minimal_x, l_maximal_x, l_minimal_y, l_maximal_y, l_advance]
			end
		end

	has_error: BOOLEAN
			-- Is the library has generate an error
			-- (from GAME_ERROR_MANAGER)

	has_ressource_error: BOOLEAN
			-- Has an error occured while opening Current
			-- (from GAME_RESSOURCE)

	has_hinting: BOOLEAN
			-- Has the library a hint about how to draw Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfonthinting (item) /= {GAME_TEXT_EXTERNAL}.ttf_hinting_none
		end

	has_light_hinting: BOOLEAN
			-- The library has the light hinting to draw Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfonthinting (item) /= {GAME_TEXT_EXTERNAL}.ttf_hinting_light
		end

	has_monochrome_hinting: BOOLEAN
			-- The library has the monochrome hinting to draw Current.
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfonthinting (item) /= {GAME_TEXT_EXTERNAL}.ttf_hinting_mono
		end

	has_normal_hinting: BOOLEAN
			-- The library has the normal hinting to draw `Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfonthinting (item) /= {GAME_TEXT_EXTERNAL}.ttf_hinting_normal
		end

	has_outline: BOOLEAN
			-- Is Current has an outline size.
		require
				exists
		do
			Result := outline_size > 0
		end

	has_style_modifier: BOOLEAN
			-- Is Current has a style modifier (underline, bold, italic or strike through)
		require
				exists
		do
			Result := is_underline or is_bold or is_italic or is_strike_through
		end

	index: INTEGER_32
			-- The index of the font in the file.

	is_bold: BOOLEAN assign set_is_bold
			-- Is Current has a bold style modifier
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_bold) /= 0
		end

	is_glyph_provided (a_character: CHARACTER_32): BOOLEAN
			-- Is Current can draw a glyph representing a_character
		require
				exists
		local
			l_prototype: NATURAL_32
		do
			if a_character.natural_32_code > l_prototype.Max_value then
				Result := False
			else
				Result := {GAME_TEXT_EXTERNAL}.ttf_glyphisprovided (item, a_character.natural_32_code.as_natural_16) /= 0
			end
		end

	is_italic: BOOLEAN assign set_is_italic
			-- Is Current has an italic style modifier
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_italic) /= 0
		end

	is_kerning_enabled: BOOLEAN assign set_is_kerning_enabled
			-- If True, the library can use kerning when drawing a text with Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontkerning (item) /= 0
		end

	is_monospace: BOOLEAN
			-- True if every character that exists in Current is the same width
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_fontfaceisfixedwidth (item) > 0
		end

	is_open: BOOLEAN
			-- Is Current has been properly opened
			-- (from GAME_RESSOURCE)

	is_openable: BOOLEAN
			-- Can Current be open
		do
			Result := not rwop.is_default_pointer
		end

	is_strike_through: BOOLEAN assign set_is_strike_through
			-- Is Current has a strike through style modifier
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_strikethrough) /= 0
		end

	is_underline: BOOLEAN assign set_is_underline
			-- Is Current has an underline style modifier
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontstyle (item).bit_and ({GAME_TEXT_EXTERNAL}.ttf_style_underline) /= 0
		end

	last_error: READABLE_STRING_GENERAL
			-- The last error generate by the library
			-- (from GAME_SDL_ANY)
		local
			l_string: C_STRING
		do
			if is_manual_error then
				Result := Precursor {GAME_ERROR_MANAGER}
			else
				create l_string.make_by_pointer ({GAME_SDL_EXTERNAL}.sdl_geterror)
				Result := l_string.string
			end
		end

	line_skip_height: INTEGER_32
			-- the recommended pixel height of a rendered line of text using Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_fontlineskip (item)
		end

	maximum_height: INTEGER_32
			-- The maximum height that a gliph can take in pixel using Current
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_fontheight (item)
		end

	open
			-- Open Current
		require -- from GAME_RESSOURCE
			ressource_is_openable: is_openable
			ressource_is_not_open: not is_open and not has_ressource_error
		do
			clear_error
			internal_pointer := {GAME_TEXT_EXTERNAL}.ttf_openfontindexrw (rwop, 0, size, index)
			manage_error_pointer (internal_pointer, "Cannot open the font")
			has_ressource_error := has_error
			is_open := not has_error
		ensure -- from GAME_RESSOURCE
			ressource_is_open: is_open or has_ressource_error
		ensure then
			exists: not has_error implies exists
			is_open: not has_error implies is_open
		end

	outline_size: INTEGER_32 assign set_outline_size
			-- The ouline width of Current (0 for disabled)
		require
				exists
		do
			Result := {GAME_TEXT_EXTERNAL}.ttf_getfontoutline (item)
		end

	set_is_bold (a_value: BOOLEAN)
			-- Assign to is_bold the value of a_value
		do
			if a_value then
				enable_bold
			else
				disable_bold
			end
		ensure
			is_assign: is_bold ~ a_value
		end

	set_is_italic (a_value: BOOLEAN)
			-- Assign to is_italic the value of a_value
		do
			if a_value then
				enable_italic
			else
				disable_italic
			end
		ensure
			is_assign: is_italic ~ a_value
		end

	set_is_kerning_enabled (a_value: BOOLEAN)
			-- Assign to is_kerning_enabled the value of a_value
		do
			if a_value then
				enable_kerning
			else
				disable_kerning
			end
		ensure
			is_assign: is_kerning_enabled ~ a_value
		end

	set_is_strike_through (a_value: BOOLEAN)
			-- Assign to is_strike_through the value of a_value
		do
			if a_value then
				enable_strike_through
			else
				disable_strike_through
			end
		ensure
			is_assign: is_strike_through ~ a_value
		end

	set_is_underline (a_value: BOOLEAN)
			-- Assign to is_underline the value of a_value
		do
			if a_value then
				enable_underline
			else
				disable_underline
			end
		ensure
			is_assign: is_underline ~ a_value
		end

	set_outline_size (a_outline_size: INTEGER_32)
			-- Assign outline_size with the value of outline_size
		require
			exists: exists
			outline_size_valid: a_outline_size >= 0
		do
			{GAME_TEXT_EXTERNAL}.ttf_setfontoutline (item, a_outline_size)
		ensure
			is_assign: outline_size = a_outline_size
		end

	size: INTEGER_32
			-- The font height.

	text_dimension (a_text: READABLE_STRING_GENERAL): TUPLE [width: INTEGER_32; height: INTEGER_32]
			-- The dimension of the a_text drawed with Current
		require
				exists
		local
			l_error, l_width, l_height: INTEGER_32
			l_text_c: C_STRING
			l_utf_converter: UTF_CONVERTER
		do
			clear_error
			if a_text.is_string_8 then
				create l_text_c.make (a_text)
				l_error := {GAME_TEXT_EXTERNAL}.ttf_sizetext (item, l_text_c.item, $l_width.to_pointer, $l_height.to_pointer)
			else
				create l_utf_converter
				create l_text_c.make (l_utf_converter.string_32_to_utf_8_string_8 (a_text.as_string_32))
				l_error := {GAME_TEXT_EXTERNAL}.ttf_sizeutf8 (item, l_text_c.item, $l_width.to_pointer, $l_height.to_pointer)
			end
			if l_error < 0 then
				manage_error_code (l_error, "Cannot get the text size once drawed.")
				Result := [0, 0]
			else
				Result := [l_width, l_height]
			end
		end

	Text_library: TEXT_CONTROLLER
			-- The main manager of the text library
			-- (from TEXT_LIBRARY_SHARED)
		once ("PROCESS")
			create Result
		end
	
feature -- Comparison

	frozen deep_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void
			-- or attached to isomorphic object structures?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_deep_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			shallow_implies_deep: standard_equal (a, b) implies Result
			both_or_none_void: (a = Void) implies (Result = (b = Void))
			same_type: (Result and (a /= Void)) implies (b /= Void and then a.same_type (b))
			symmetric: Result implies deep_equal (b, a)
		end

	frozen equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached
			-- to objects considered equal?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.is_equal (b))
		end

	frozen is_deep_equal alias "≡≡≡" (other: TEXT_FONT): BOOLEAN
			-- Are Current and other attached to isomorphic object structures?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			shallow_implies_deep: standard_is_equal (other) implies Result
			same_type: Result implies same_type (other)
			symmetric: Result implies other.is_deep_equal (Current)
		end

	is_equal (other: TEXT_FONT): BOOLEAN
			-- Is other attached to an object considered
			-- equal to current object?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			symmetric: Result implies other ~ Current
			consistent: standard_is_equal (other) implies Result
		end

	frozen standard_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached to
			-- field-by-field identical objects of the same type?
			-- Always uses default object comparison criterion.
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.standard_is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.standard_is_equal (b))
		end

	frozen standard_is_equal alias "≜" (other: TEXT_FONT): BOOLEAN
			-- Is other attached to an object of the same type
			-- as current object, and field-by-field identical to it?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			same_type: Result implies same_type (other)
			symmetric: Result implies other.standard_is_equal (Current)
		end
	
feature -- Status report

	conforms_to (other: ANY): BOOLEAN
			-- Does type of current object conform to type
			-- of other (as per Eiffel: The Language, chapter 13)?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		end

	same_type (other: ANY): BOOLEAN
			-- Is type of current object identical to type of other?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			definition: Result = (conforms_to (other) and other.conforms_to (Current))
		end
	
feature {NONE} -- Status report

	is_in_final_collect: BOOLEAN
			-- Is GC currently performing final collection
			-- after execution of current program?
			-- Safe to use in dispose.
			-- (from DISPOSABLE)
		external
			"C inline use %"eif_memory.h%""
		alias
			"return eif_is_in_final_collect;"
		end
	
feature -- Duplication

	frozen clone (other: detachable ANY): like other
		obsolete "Use `twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- equal to other
			--
			-- For non-void other, clone calls copy;
			-- to change copying/cloning semantics, redefine copy.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.twin
			end
		ensure -- from ANY
			instance_free: class
			equal: Result ~ other
		end

	copy (other: TEXT_FONT)
			-- Update current object using fields of object attached
			-- to other, so as to yield equal objects.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_equal: Current ~ other
		end

	frozen deep_clone (other: detachable ANY): like other
		obsolete "Use `deep_twin' instead. [2017-05-31]"
			-- Void if other is void: otherwise, new object structure
			-- recursively duplicated from the one attached to other
			-- (from ANY)
		do
			if other /= Void then
				Result := other.deep_twin
			end
		ensure -- from ANY
			instance_free: class
			deep_equal: deep_equal (other, Result)
		end

	frozen deep_copy (other: TEXT_FONT)
			-- Effect equivalent to that of:
			--		copy (other . deep_twin)
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		do
			copy (other.deep_twin)
		ensure -- from ANY
			deep_equal: deep_equal (Current, other)
		end

	frozen deep_twin: TEXT_FONT
			-- New object structure recursively duplicated from Current.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			deep_twin_not_void: Result /= Void
			deep_equal: deep_equal (Current, Result)
		end

	frozen standard_clone (other: detachable ANY): like other
		obsolete "Use `standard_twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.standard_twin
			end
		ensure -- from ANY
			instance_free: class
			equal: standard_equal (Result, other)
		end

	frozen standard_copy (other: TEXT_FONT)
			-- Copy every field of other onto corresponding field
			-- of current object.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_standard_equal: standard_is_equal (other)
		end

	frozen standard_twin: TEXT_FONT
			-- New object field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			standard_twin_not_void: Result /= Void
			equal: standard_equal (Result, Current)
		end

	frozen twin: TEXT_FONT
			-- New object equal to Current
			-- twin calls copy; to change copying/twinning semantics, redefine copy.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			twin_not_void: Result /= Void
			is_equal: Result ~ Current
		end
	
feature -- Basic operations

	frozen as_attached: attached TEXT_FONT
		obsolete "Remove calls to this feature. [2017-05-31]"
			-- Attached version of Current.
			-- (Can be used during transitional period to convert
			-- non-void-safe classes to void-safe ones.)
			-- (from ANY)
		do
			Result := Current
		end

	frozen default: detachable TEXT_FONT
			-- Default value of object's type
			-- (from ANY)
		do
		end

	frozen default_pointer: POINTER
			-- Default value of type POINTER
			-- (Avoid the need to write p.default for
			-- some p of type POINTER.)
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end

	default_rescue
			-- Process exception for routines with no Rescue clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		end

	frozen do_nothing
			-- Execute a null action.
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end
	
feature {GAME_SDL_ANY} -- Implementation

	item: POINTER
			-- Access to memory area.
		do
			Result := internal_pointer
		end
	
feature {NONE} -- Implementation

	clear_error
			-- Remove error pending in Current
			-- (from GAME_SDL_ANY)
		require -- from  GAME_ERROR_MANAGER
			True
		do
			{GAME_SDL_EXTERNAL}.sdl_clearerror
			Precursor {GAME_ERROR_MANAGER}
			is_manual_error := False
		ensure -- from GAME_ERROR_MANAGER
			no_error: not has_error
		ensure then -- from GAME_SDL_ANY
			no_error: not is_manual_error
		end

	disable_print_on_error
			-- Desactive the print_on_error functionnality.
			-- (from GAME_ERROR_MANAGER)
		do
			Print_on_error_internal.put (False)
		end

	enable_print_on_error
			-- Active the print_on_error functionnality.
			-- (from GAME_ERROR_MANAGER)
		do
			Print_on_error_internal.put (True)
		end

	internal_pointer: POINTER
			-- The pointer to the C structure representing Current

	is_manual_error: BOOLEAN
			-- Is the current pending error is a manual error (using manual_error as message)
			-- (from GAME_SDL_ANY)

	manage_error_boolean (a_boolean: BOOLEAN; a_message: READABLE_STRING_GENERAL)
			-- Create an error if a_boolean is false.
			-- If there is an error, append a_message to the error message
			-- on the SDL2 library
			-- (from GAME_SDL_ANY)
		do
			if not a_boolean then
				if Print_on_error_internal.item then
					Io.Error.put_string (a_message.to_string_8 + "%N");
					Io.Error.put_string (last_error.to_string_8 + "%N")
				end
				has_error := True
			end
		ensure -- from GAME_SDL_ANY
				not a_boolean implies has_error
		end

	manage_error_code (a_error_code: INTEGER_32; a_message: READABLE_STRING_GENERAL)
			-- If needed create an error depending of the error code a_code.
			-- If there is an error, append a_message to the error message
			-- on the SDL2 library
			-- (from GAME_SDL_ANY)
		do
			if a_error_code < 0 then
				if Print_on_error_internal.item then
					Io.Error.put_string (a_message.to_string_8 + "%N");
					Io.Error.put_string (last_error.to_string_8 + "%N")
				end
				has_error := True
			end
		end

	manage_error_pointer (a_pointer: POINTER; a_message: READABLE_STRING_GENERAL)
			-- Create an error if a_pointer is not valid.
			-- If there is an error, append a_message to the error message
			-- on the SDL2 library
			-- (from GAME_SDL_ANY)
		do
			if a_pointer.is_default_pointer then
				if Print_on_error_internal.item then
					Io.Error.put_string (a_message.to_string_8 + "%N");
					Io.Error.put_string (last_error.to_string_8 + "%N")
				end
				has_error := True
			end
		ensure -- from GAME_SDL_ANY
				a_pointer.is_default_pointer implies has_error
		end

	manual_error: detachable READABLE_STRING_GENERAL
			-- The specific message for the last error
			-- (from GAME_ERROR_MANAGER)

	print_on_error: BOOLEAN
			-- When an error occured, the library will print
			-- informations about the error on the error console
			-- output (default is True).
			-- (from GAME_ERROR_MANAGER)
		do
			Result := Print_on_error_internal.item
		end

	Print_on_error_internal: CELL [BOOLEAN]
			-- True when an error occured,
			-- The library will print it right away.
			-- (from GAME_ERROR_MANAGER)
		once ("PROCESS")
			create Result.put (True)
		end

	put_manual_error (a_general_message, a_specific_error: READABLE_STRING_GENERAL)
			-- Create an error using a_general_error for the debug information
			-- and a_specific_error for the lasting information
			-- (from GAME_SDL_ANY)
		do
			is_manual_error := True
			Precursor {GAME_ERROR_MANAGER} (a_general_message, a_specific_error)
		ensure -- from GAME_ERROR_MANAGER
				has_error
		end

	rwop: POINTER
			-- The pointer to the SDL Read/Write handle

	set_print_on_error (a_value: BOOLEAN)
			-- Assign to print_on_error the value of a_value
			-- (from GAME_ERROR_MANAGER)
		do
			if a_value then
				enable_print_on_error
			else
				disable_print_on_error
			end
		ensure -- from GAME_ERROR_MANAGER
			is_assign: print_on_error ~ a_value
		end
	
feature -- Implementation

	dispose
			-- Action to be executed just before garbage collection
			-- reclaims an object.
			-- Effect it in descendants to perform specific dispose
			-- actions. Those actions should only take care of freeing
			-- external resources; they should not perform remote calls
			-- on other objects since these may also be dead and reclaimed.
		do
			if not rwop.is_default_pointer then
				{GAME_SDL_EXTERNAL}.sdl_freerw (rwop)
			end
			if exists then
				{GAME_TEXT_EXTERNAL}.ttf_closefont (item)
				is_open := False
				create internal_pointer
			end
		end
	
feature {NONE} -- Initialisation

	default_create
			-- Initialization of Current
			-- (from GAME_RESSOURCE)
		require -- from  ANY
			True
		do
			is_open := False
			has_ressource_error := False
		end
	
feature -- Output

	Io: STD_FILES
			-- Handle to standard file setup
			-- (from ANY)
		once
			create Result;
			Result.set_output_default
		ensure -- from ANY
			instance_free: class
			io_not_void: Result /= Void
		end

	out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		do
			Result := tagged_out
		ensure -- from ANY
			out_not_void: Result /= Void
		end

	print (o: detachable ANY)
			-- Write terse external representation of o
			-- on standard output.
			-- (from ANY)
		local
			s: READABLE_STRING_8
		do
			if attached o then
				s := o.out
				if attached {READABLE_STRING_32} s as s32 then
					Io.put_string_32 (s32)
				elseif attached {READABLE_STRING_8} s as s8 then
					Io.put_string (s8)
				else
					Io.put_string_32 (s.as_string_32)
				end
			end
		ensure -- from ANY
			instance_free: class
		end

	frozen tagged_out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			tagged_out_not_void: Result /= Void
		end
	
feature -- Platform

	Operating_environment: OPERATING_ENVIRONMENT
			-- Objects available from the operating system
			-- (from ANY)
		once
			create Result
		ensure -- from ANY
			instance_free: class
			operating_environment_not_void: Result /= Void
		end
	
feature {NONE} -- Retrieval

	frozen internal_correct_mismatch
			-- Called from runtime to perform a proper dynamic dispatch on correct_mismatch
			-- from MISMATCH_CORRECTOR.
			-- (from ANY)
		local
			l_msg: STRING_32
			l_exc: EXCEPTIONS
		do
			if attached {MISMATCH_CORRECTOR} Current as l_corrector then
				l_corrector.correct_mismatch
			else
				create l_msg.make_from_string ("Mismatch: ".as_string_32)
				create l_exc;
				l_msg.append (generating_type.name_32);
				l_exc.raise_retrieval_exception (l_msg)
			end
		end
	
invariant
	is_open_exists: is_open implies exists

		-- from ANY
	reflexive_equality: standard_is_equal (Current)
	reflexive_conformance: conforms_to (Current)

end -- class TEXT_FONT

Generated by ISE EiffelStudio