From 75c56f8e6927018e3098fe012bb699b72ad0f1f8 Mon Sep 17 00:00:00 2001 From: Jedidiah Barber Date: Wed, 18 Dec 2024 17:52:21 +1300 Subject: Added Fl_Browser --- src/fltk-widgets-groups-browsers-textline.adb | 1255 +++++++++++++++++++++++++ 1 file changed, 1255 insertions(+) create mode 100644 src/fltk-widgets-groups-browsers-textline.adb (limited to 'src/fltk-widgets-groups-browsers-textline.adb') diff --git a/src/fltk-widgets-groups-browsers-textline.adb b/src/fltk-widgets-groups-browsers-textline.adb new file mode 100644 index 0000000..de3f339 --- /dev/null +++ b/src/fltk-widgets-groups-browsers-textline.adb @@ -0,0 +1,1255 @@ + + +-- Programmed by Jedidiah Barber +-- Released into the public domain + + +with + + Ada.Unchecked_Deallocation, + FLTK.Images, + Interfaces.C.Strings; + +use type + + Interfaces.C.int, + Interfaces.C.Strings.chars_ptr; + + +package body FLTK.Widgets.Groups.Browsers.Textline is + + + ------------------------ + -- Functions From C -- + ------------------------ + + function get_error_message + return Interfaces.C.Strings.chars_ptr; + pragma Import (C, get_error_message, "get_error_message"); + pragma Inline (get_error_message); + + + + + function new_fl_browser + (X, Y, W, H : in Interfaces.C.int; + Text : in Interfaces.C.char_array) + return Storage.Integer_Address; + pragma Import (C, new_fl_browser, "new_fl_browser"); + pragma Inline (new_fl_browser); + + procedure free_fl_browser + (B : in Storage.Integer_Address); + pragma Import (C, free_fl_browser, "free_fl_browser"); + pragma Inline (free_fl_browser); + + + + + procedure fl_browser_add + (B : in Storage.Integer_Address; + T : in Interfaces.C.char_array; + D : in Storage.Integer_Address); + pragma Import (C, fl_browser_add, "fl_browser_add"); + pragma Inline (fl_browser_add); + + procedure fl_browser_insert + (B : in Storage.Integer_Address; + L : in Interfaces.C.int; + T : in Interfaces.C.char_array; + D : in Storage.Integer_Address); + pragma Import (C, fl_browser_insert, "fl_browser_insert"); + pragma Inline (fl_browser_insert); + + procedure fl_browser_move + (B : in Storage.Integer_Address; + T, F : in Interfaces.C.int); + pragma Import (C, fl_browser_move, "fl_browser_move"); + pragma Inline (fl_browser_move); + + procedure fl_browser_swap + (B : in Storage.Integer_Address; + X, Y : in Interfaces.C.int); + pragma Import (C, fl_browser_swap, "fl_browser_swap"); + pragma Inline (fl_browser_swap); + + procedure fl_browser_remove + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_remove, "fl_browser_remove"); + pragma Inline (fl_browser_remove); + + procedure fl_browser_clear + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_clear, "fl_browser_clear"); + pragma Inline (fl_browser_clear); + + function fl_browser_size + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_size, "fl_browser_size"); + pragma Inline (fl_browser_size); + + + + + function fl_browser_load + (B : in Storage.Integer_Address; + F : in Interfaces.C.char_array) + return Interfaces.C.int; + pragma Import (C, fl_browser_load, "fl_browser_load"); + pragma Inline (fl_browser_load); + + function fl_browser_get_text + (B : in Storage.Integer_Address; + L : in Interfaces.C.int) + return Interfaces.C.Strings.chars_ptr; + pragma Import (C, fl_browser_get_text, "fl_browser_get_text"); + pragma Inline (fl_browser_get_text); + + procedure fl_browser_set_text + (B : in Storage.Integer_Address; + L : in Interfaces.C.int; + T : in Interfaces.C.char_array); + pragma Import (C, fl_browser_set_text, "fl_browser_set_text"); + pragma Inline (fl_browser_set_text); + + function fl_browser_get_textsize + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_get_textsize, "fl_browser_get_textsize"); + pragma Inline (fl_browser_get_textsize); + + procedure fl_browser_set_textsize + (B : in Storage.Integer_Address; + S : in Interfaces.C.int); + pragma Import (C, fl_browser_set_textsize, "fl_browser_set_textsize"); + pragma Inline (fl_browser_set_textsize); + + + + + function fl_browser_get_column_char + (B : in Storage.Integer_Address) + return Interfaces.C.char; + pragma Import (C, fl_browser_get_column_char, "fl_browser_get_column_char"); + pragma Inline (fl_browser_get_column_char); + + procedure fl_browser_set_column_char + (B : in Storage.Integer_Address; + C : in Interfaces.C.char); + pragma Import (C, fl_browser_set_column_char, "fl_browser_set_column_char"); + pragma Inline (fl_browser_set_column_char); + + procedure fl_browser_set_column_widths + (B, W : in Storage.Integer_Address); + pragma Import (C, fl_browser_set_column_widths, "fl_browser_set_column_widths"); + pragma Inline (fl_browser_set_column_widths); + + function fl_browser_get_format_char + (B : in Storage.Integer_Address) + return Interfaces.C.char; + pragma Import (C, fl_browser_get_format_char, "fl_browser_get_format_char"); + pragma Inline (fl_browser_get_format_char); + + procedure fl_browser_set_format_char + (B : in Storage.Integer_Address; + C : in Interfaces.C.char); + pragma Import (C, fl_browser_set_format_char, "fl_browser_set_format_char"); + pragma Inline (fl_browser_set_format_char); + + + + + function fl_browser_get_topline + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_get_topline, "fl_browser_get_topline"); + pragma Inline (fl_browser_get_topline); + + procedure fl_browser_set_topline + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_set_topline, "fl_browser_set_topline"); + pragma Inline (fl_browser_set_topline); + + procedure fl_browser_middleline + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_middleline, "fl_browser_middleline"); + pragma Inline (fl_browser_middleline); + + procedure fl_browser_bottomline + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_bottomline, "fl_browser_bottomline"); + pragma Inline (fl_browser_bottomline); + + procedure fl_browser_lineposition + (B : in Storage.Integer_Address; + L, P : in Interfaces.C.int); + pragma Import (C, fl_browser_lineposition, "fl_browser_lineposition"); + pragma Inline (fl_browser_lineposition); + + + + + function fl_browser_select + (B : in Storage.Integer_Address; + L, V : in Interfaces.C.int) + return Interfaces.C.int; + pragma Import (C, fl_browser_select, "fl_browser_select"); + pragma Inline (fl_browser_select); + + function fl_browser_selected + (B : in Storage.Integer_Address; + L : in Interfaces.C.int) + return Interfaces.C.int; + pragma Import (C, fl_browser_selected, "fl_browser_selected"); + pragma Inline (fl_browser_selected); + + function fl_browser_value + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_value, "fl_browser_value"); + pragma Inline (fl_browser_value); + + + + + function fl_browser_visible + (B : in Storage.Integer_Address; + L : in Interfaces.C.int) + return Interfaces.C.int; + pragma Import (C, fl_browser_visible, "fl_browser_visible"); + pragma Inline (fl_browser_visible); + + procedure fl_browser_make_visible + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_make_visible, "fl_browser_make_visible"); + pragma Inline (fl_browser_make_visible); + + function fl_browser_displayed + (B : in Storage.Integer_Address; + L : in Interfaces.C.int) + return Interfaces.C.int; + pragma Import (C, fl_browser_displayed, "fl_browser_displayed"); + pragma Inline (fl_browser_displayed); + + procedure fl_browser_show_line + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_show_line, "fl_browser_show_line"); + pragma Inline (fl_browser_show_line); + + procedure fl_browser_hide_line + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_hide_line, "fl_browser_hide_line"); + pragma Inline (fl_browser_hide_line); + + procedure fl_browser_show + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_show, "fl_browser_show"); + pragma Inline (fl_browser_show); + + procedure fl_browser_hide + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_hide, "fl_browser_hide"); + pragma Inline (fl_browser_hide); + + + + + procedure fl_browser_set_icon + (B : in Storage.Integer_Address; + L : in Interfaces.C.int; + C : in Storage.Integer_Address); + pragma Import (C, fl_browser_set_icon, "fl_browser_set_icon"); + pragma Inline (fl_browser_set_icon); + + procedure fl_browser_remove_icon + (B : in Storage.Integer_Address; + L : in Interfaces.C.int); + pragma Import (C, fl_browser_remove_icon, "fl_browser_remove_icon"); + pragma Inline (fl_browser_remove_icon); + + + + + function fl_browser_item_width + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_item_width, "fl_browser_item_width"); + pragma Inline (fl_browser_item_width); + + function fl_browser_item_height + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_item_height, "fl_browser_item_height"); + pragma Inline (fl_browser_item_height); + + function fl_browser_item_first + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_item_first, "fl_browser_item_first"); + pragma Inline (fl_browser_item_first); + + function fl_browser_item_last + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_item_last, "fl_browser_item_last"); + pragma Inline (fl_browser_item_last); + + function fl_browser_item_next + (B, I : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_item_next, "fl_browser_item_next"); + pragma Inline (fl_browser_item_next); + + function fl_browser_item_prev + (B, I : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_item_prev, "fl_browser_item_prev"); + pragma Inline (fl_browser_item_prev); + + function fl_browser_item_at + (B : in Storage.Integer_Address; + N : in Interfaces.C.int) + return Storage.Integer_Address; + pragma Import (C, fl_browser_item_at, "fl_browser_item_at"); + pragma Inline (fl_browser_item_at); + + procedure fl_browser_item_select + (B, I : in Storage.Integer_Address; + V : in Interfaces.C.int); + pragma Import (C, fl_browser_item_select, "fl_browser_item_select"); + pragma Inline (fl_browser_item_select); + + function fl_browser_item_selected + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_item_selected, "fl_browser_item_selected"); + pragma Inline (fl_browser_item_selected); + + procedure fl_browser_item_swap + (B, X, Y : in Storage.Integer_Address); + pragma Import (C, fl_browser_item_swap, "fl_browser_item_swap"); + pragma Inline (fl_browser_item_swap); + + function fl_browser_item_text + (B, I : in Storage.Integer_Address) + return Interfaces.C.Strings.chars_ptr; + pragma Import (C, fl_browser_item_text, "fl_browser_item_text"); + pragma Inline (fl_browser_item_text); + + procedure fl_browser_item_draw + (B, I : in Storage.Integer_Address; + X, Y, W, H : in Interfaces.C.int); + pragma Import (C, fl_browser_item_draw, "fl_browser_item_draw"); + pragma Inline (fl_browser_item_draw); + + + + + function fl_browser_selection + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_selection, "fl_browser_selection"); + pragma Inline (fl_browser_selection); + + function fl_browser_displayed2 + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_displayed2, "fl_browser_displayed2"); + pragma Inline (fl_browser_displayed2); + + function fl_browser_find_item + (B : in Storage.Integer_Address; + Y : in Interfaces.C.int) + return Storage.Integer_Address; + pragma Import (C, fl_browser_find_item, "fl_browser_find_item"); + pragma Inline (fl_browser_find_item); + + function fl_browser_top + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + pragma Import (C, fl_browser_top, "fl_browser_top"); + pragma Inline (fl_browser_top); + + + + + procedure fl_browser_bbox + (B : in Storage.Integer_Address; + X, Y, W, H : out Interfaces.C.int); + pragma Import (C, fl_browser_bbox, "fl_browser_bbox"); + pragma Inline (fl_browser_bbox); + + function fl_browser_leftedge + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_leftedge, "fl_browser_leftedge"); + pragma Inline (fl_browser_leftedge); + + procedure fl_browser_redraw_line + (B, I : in Storage.Integer_Address); + pragma Import (C, fl_browser_redraw_line, "fl_browser_redraw_line"); + pragma Inline (fl_browser_redraw_line); + + procedure fl_browser_redraw_lines + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_redraw_lines, "fl_browser_redraw_lines"); + pragma Inline (fl_browser_redraw_lines); + + + + + function fl_browser_full_width + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_full_width, "fl_browser_full_width"); + pragma Inline (fl_browser_full_width); + + function fl_browser_full_height + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_full_height, "fl_browser_full_height"); + pragma Inline (fl_browser_full_height); + + function fl_browser_incr_height + (B : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_incr_height, "fl_browser_incr_height"); + pragma Inline (fl_browser_incr_height); + + function fl_browser_item_quick_height + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_item_quick_height, "fl_browser_item_quick_height"); + pragma Inline (fl_browser_item_quick_height); + + + + + function fl_browser_lineno + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + pragma Import (C, fl_browser_lineno, "fl_browser_lineno"); + pragma Inline (fl_browser_lineno); + + + + + procedure fl_browser_new_list + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_new_list, "fl_browser_new_list"); + pragma Inline (fl_browser_new_list); + + procedure fl_browser_inserting + (B, A1, A2 : in Storage.Integer_Address); + pragma Import (C, fl_browser_inserting, "fl_browser_inserting"); + pragma Inline (fl_browser_inserting); + + procedure fl_browser_deleting + (B, I : in Storage.Integer_Address); + pragma Import (C, fl_browser_deleting, "fl_browser_deleting"); + pragma Inline (fl_browser_deleting); + + procedure fl_browser_replacing + (B, A1, A2 : in Storage.Integer_Address); + pragma Import (C, fl_browser_replacing, "fl_browser_replacing"); + pragma Inline (fl_browser_replacing); + + procedure fl_browser_swapping + (B, A1, A2 : in Storage.Integer_Address); + pragma Import (C, fl_browser_swapping, "fl_browser_swapping"); + pragma Inline (fl_browser_swapping); + + + + + procedure fl_browser_draw + (B : in Storage.Integer_Address); + pragma Import (C, fl_browser_draw, "fl_browser_draw"); + pragma Inline (fl_browser_draw); + + function fl_browser_handle + (B : in Storage.Integer_Address; + E : in Interfaces.C.int) + return Interfaces.C.int; + pragma Import (C, fl_browser_handle, "fl_browser_handle"); + pragma Inline (fl_browser_handle); + + + + + ------------------- + -- Destructors -- + ------------------- + + procedure Free is new Ada.Unchecked_Deallocation + (Object => C_Col_Widths, + Name => C_Col_Widths_Access); + + procedure Free is new Ada.Unchecked_Deallocation + (Object => FLTK.Images.Image'Class, + Name => Image_Access); + + + procedure Extra_Final + (This : in out Textline_Browser) is + begin + Free (This.Columns); + for Icon_Ptr of This.Icons loop + Free (Icon_Ptr); + end loop; + Extra_Final (Browser (This)); + end Extra_Final; + + + procedure Finalize + (This : in out Textline_Browser) is + begin + Extra_Final (This); + if This.Void_Ptr /= Null_Pointer and This.Needs_Dealloc then + free_fl_browser (This.Void_Ptr); + This.Void_Ptr := Null_Pointer; + end if; + end Finalize; + + + + + -------------------- + -- Constructors -- + -------------------- + + procedure Extra_Init + (This : in out Textline_Browser; + X, Y, W, H : in Integer; + Text : in String) is + begin + Extra_Init (Browser (This), X, Y, W, H, Text); + end Extra_Init; + + + procedure Initialize + (This : in out Textline_Browser) is + begin + This.Item_Override_Ptrs := + (Item_Width_Ptr => fl_browser_item_width'Address, + Item_Height_Ptr => fl_browser_item_height'Address, + Item_First_Ptr => fl_browser_item_first'Address, + Item_Last_Ptr => fl_browser_item_last'Address, + Item_Next_Ptr => fl_browser_item_next'Address, + Item_Previous_Ptr => fl_browser_item_prev'Address, + Item_At_Ptr => fl_browser_item_at'Address, + Item_Select_Ptr => fl_browser_item_select'Address, + Item_Selected_Ptr => fl_browser_item_selected'Address, + Item_Swap_Ptr => fl_browser_item_swap'Address, + Item_Text_Ptr => fl_browser_item_text'Address, + Item_Draw_Ptr => fl_browser_item_draw'Address); + This.Item_Inherit_Ptrs := + (Current_Selection_Ptr => fl_browser_selection'Address, + Is_Displayed_Ptr => fl_browser_displayed2'Address, + Find_Item_Ptr => fl_browser_find_item'Address, + Top_Item_Ptr => fl_browser_top'Address); + This.Redrawing_Ptrs := + (Bounding_Box_Ptr => fl_browser_bbox'Address, + Left_Edge_Ptr => fl_browser_leftedge'Address, + Redraw_Line_Ptr => fl_browser_redraw_line'Address, + Redraw_List_Ptr => fl_browser_redraw_lines'Address); + This.Wide_High_Ptrs := + (Full_List_Width_Ptr => fl_browser_full_width'Address, + Full_List_Height_Ptr => fl_browser_full_height'Address, + Average_Item_Height_Ptr => fl_browser_incr_height'Address, + Item_Quick_Height_Ptr => fl_browser_item_quick_height'Address); + This.Cache_Ptrs := + (New_List_Ptr => fl_browser_new_list'Address, + Inserting_Ptr => fl_browser_inserting'Address, + Deleting_Ptr => fl_browser_deleting'Address, + Replacing_Ptr => fl_browser_replacing'Address, + Swapping_Ptr => fl_browser_swapping'Address); + This.Draw_Ptr := fl_browser_draw'Address; + This.Handle_Ptr := fl_browser_handle'Address; + This.Line_Number_Ptr := fl_browser_lineno'Address; + end Initialize; + + + package body Forge is + + function Create + (X, Y, W, H : in Integer; + Text : in String := "") + return Textline_Browser is + begin + return This : Textline_Browser do + This.Void_Ptr := new_fl_browser + (Interfaces.C.int (X), + Interfaces.C.int (Y), + Interfaces.C.int (W), + Interfaces.C.int (H), + Interfaces.C.To_C (Text)); + Extra_Init (This, X, Y, W, H, Text); + end return; + end Create; + + end Forge; + + + + + ----------------------- + -- API Subprograms -- + ----------------------- + + procedure Add + (This : in out Textline_Browser; + Text : in String) is + begin + fl_browser_add + (This.Void_Ptr, + Interfaces.C.To_C (Text), + Null_Pointer); + end Add; + + + procedure Insert + (This : in out Textline_Browser; + Above : in Positive; + Text : in String) is + begin + fl_browser_insert + (This.Void_Ptr, + Interfaces.C.int (Above), + Interfaces.C.To_C (Text), + Null_Pointer); + end Insert; + + + procedure Move + (This : in out Textline_Browser; + From, To : in Positive) is + begin + fl_browser_move + (This.Void_Ptr, + Interfaces.C.int (To), + Interfaces.C.int (From)); + end Move; + + + procedure Swap + (This : in out Textline_Browser; + A, B : in Positive) is + begin + fl_browser_swap + (This.Void_Ptr, + Interfaces.C.int (A), + Interfaces.C.int (B)); + end Swap; + + + procedure Remove + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_remove + (This.Void_Ptr, + Interfaces.C.int (Line)); + end Remove; + + + procedure Clear + (This : in out Textline_Browser) is + begin + fl_browser_clear (This.Void_Ptr); + end Clear; + + + function Number_Of_Lines + (This : in Textline_Browser) + return Natural is + begin + return Natural (fl_browser_size (This.Void_Ptr)); + end Number_Of_Lines; + + + + + procedure Load + (This : in out Textline_Browser; + File : in String) + is + Code : Interfaces.C.int := fl_browser_load (This.Void_Ptr, Interfaces.C.To_C (File)); + begin + if Code = 0 then + raise Browser_Load_Error with Interfaces.C.Strings.Value (get_error_message); + elsif Code /= 1 then + raise Internal_FLTK_Error; + end if; + end Load; + + + function Get_Line_Text + (This : in Textline_Browser; + Line : in Positive) + return String + is + Ptr : Interfaces.C.Strings.chars_ptr := fl_browser_get_text + (This.Void_Ptr, + Interfaces.C.int (Line)); + begin + if Ptr = Interfaces.C.Strings.Null_Ptr then + return ""; + else + return Interfaces.C.Strings.Value (Ptr); + end if; + end Get_Line_Text; + + + procedure Set_Line_Text + (This : in out Textline_Browser; + Line : in Positive; + Text : in String) is + begin + fl_browser_set_text + (This.Void_Ptr, + Interfaces.C.int (Line), + Interfaces.C.To_C (Text)); + end Set_Line_Text; + + + function Get_Text_Size + (This : in Textline_Browser) + return Font_Size is + begin + return Font_Size (fl_browser_get_textsize (This.Void_Ptr)); + end Get_Text_Size; + + + procedure Set_Text_Size + (This : in out Textline_Browser; + Size : in Font_Size) is + begin + fl_browser_set_textsize (This.Void_Ptr, Interfaces.C.int (Size)); + end Set_Text_Size; + + + + + function Get_Column_Character + (This : in Textline_Browser) + return Character is + begin + return Interfaces.C.To_Ada (fl_browser_get_column_char (This.Void_Ptr)); + end Get_Column_Character; + + + procedure Set_Column_Character + (This : in out Textline_Browser; + Value : in Character) is + begin + fl_browser_set_column_char (This.Void_Ptr, Interfaces.C.To_C (Value)); + end Set_Column_Character; + + + function Get_Column_Widths + (This : in Textline_Browser) + return Column_Widths is + begin + if This.Columns = null then + return Result : Column_Widths (1 .. 0); + else + return Result : Column_Widths (This.Columns'First .. This.Columns'Last - 1) do + for Index in Result'Range loop + Result (Index) := Integer (This.Columns (Index)); + end loop; + end return; + end if; + end Get_Column_Widths; + + + procedure Set_Column_Widths + (This : in out Textline_Browser; + Widths : in Column_Widths) is + begin + Free (This.Columns); + This.Columns := new C_Col_Widths (1 .. Widths'Length + 1); + for Index in This.Columns'Range loop + This.Columns (Index) := Interfaces.C.int (Widths (Widths'First + Index - 1)); + end loop; + This.Columns (This.Columns'Last) := 0; + fl_browser_set_column_widths (This.Void_Ptr, Storage.To_Integer (This.Columns.all'Address)); + end Set_Column_Widths; + + + function Get_Format_Character + (This : in Textline_Browser) + return Character is + begin + return Interfaces.C.To_Ada (fl_browser_get_format_char (This.Void_Ptr)); + end Get_Format_Character; + + + procedure Set_Format_Character + (This : in out Textline_Browser; + Value : in Character) is + begin + fl_browser_set_format_char (This.Void_Ptr, Interfaces.C.To_C (Value)); + end Set_Format_Character; + + + + + function Get_Top_Line + (This : in Textline_Browser) + return Positive is + begin + return Positive (fl_browser_get_topline (This.Void_Ptr)); + end Get_Top_Line; + + + procedure Set_Top_Line + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_set_topline (This.Void_Ptr, Interfaces.C.int (Line)); + end Set_Top_Line; + + + procedure Set_Middle_Line + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_middleline (This.Void_Ptr, Interfaces.C.int (Line)); + end Set_Middle_Line; + + + procedure Set_Bottom_Line + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_bottomline (This.Void_Ptr, Interfaces.C.int (Line)); + end Set_Bottom_Line; + + + procedure Set_Line_Position + (This : in out Textline_Browser; + Line : in Positive; + Place : in Line_Position) is + begin + fl_browser_lineposition (This.Void_Ptr, Interfaces.C.int (Line), Line_Position'Pos (Place)); + end Set_Line_Position; + + + + + function Set_Select + (This : in out Textline_Browser; + Line : in Positive; + State : in Boolean := True) + return Boolean + is + Code : Interfaces.C.int := fl_browser_select + (This.Void_Ptr, + Interfaces.C.int (Line), + Boolean'Pos (State)); + begin + if Code not in 0 .. 1 then + raise Internal_FLTK_Error; + else + return Boolean'Val (Code); + end if; + end Set_Select; + + + procedure Set_Select + (This : in out Textline_Browser; + Line : in Positive; + State : in Boolean := True) + is + Code : Interfaces.C.int := fl_browser_select + (This.Void_Ptr, + Interfaces.C.int (Line), + Boolean'Pos (State)); + begin + if Code not in 0 .. 1 then + raise Internal_FLTK_Error; + end if; + end Set_Select; + + + function Is_Selected + (This : in Textline_Browser; + Line : in Positive) + return Boolean + is + Code : Interfaces.C.int := fl_browser_selected + (This.Void_Ptr, + Interfaces.C.int (Line)); + begin + if Code not in 0 .. 1 then + raise Internal_FLTK_Error; + else + return Boolean'Val (Code); + end if; + end Is_Selected; + + + function Selected_Index + (This : in Textline_Browser) + return Natural is + begin + return Natural (fl_browser_value (This.Void_Ptr)); + end Selected_Index; + + + + + function Is_Visible + (This : in Textline_Browser; + Line : in Positive) + return Boolean is + begin + return fl_browser_visible (This.Void_Ptr, Interfaces.C.int (Line)) /= 0; + end Is_Visible; + + + procedure Make_Visible + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_make_visible (This.Void_Ptr, Interfaces.C.int (Line)); + end Make_Visible; + + + function Is_Displayed + (This : in Textline_Browser; + Line : in Positive) + return Boolean + is + Code : Interfaces.C.int := fl_browser_displayed + (This.Void_Ptr, + Interfaces.C.int (Line)); + begin + if Code not in 0 .. 1 then + raise Internal_FLTK_Error; + else + return Boolean'Val (Code); + end if; + end Is_Displayed; + + + procedure Show_Line + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_show_line (This.Void_Ptr, Interfaces.C.int (Line)); + end Show_Line; + + + procedure Hide_Line + (This : in out Textline_Browser; + Line : in Positive) is + begin + fl_browser_hide_line (This.Void_Ptr, Interfaces.C.int (Line)); + end Hide_Line; + + + procedure Show + (This : in out Textline_Browser) is + begin + fl_browser_show (This.Void_Ptr); + end Show; + + + procedure Hide + (This : in out Textline_Browser) is + begin + fl_browser_hide (This.Void_Ptr); + end Hide; + + + + + function Has_Icon + (This : in Textline_Browser; + Line : in Positive) + return Boolean is + begin + return Line <= This.Icons.Last_Index and then This.Icons.Element (Line) /= null; + end Has_Icon; + + + function Get_Icon + (This : in Textline_Browser; + Line : in Positive) + return FLTK.Images.Image_Reference is + begin + return Ref : FLTK.Images.Image_Reference (Data => This.Icons.Element (Line)); + end Get_Icon; + + + procedure Set_Icon + (This : in out Textline_Browser; + Line : in Positive; + Icon : in FLTK.Images.Image'Class) is + begin + fl_browser_set_icon (This.Void_Ptr, Interfaces.C.int (Line), Wrapper (Icon).Void_Ptr); + if Line > This.Icons.Last_Index then + This.Icons.Append (null, Ada.Containers.Count_Type (Line - This.Icons.Last_Index - 1)); + This.Icons.Append (new FLTK.Images.Image); + Wrapper (This.Icons.Element (Line).all).Needs_Dealloc := False; + elsif This.Icons.Element (Line) = null then + This.Icons.Replace_Element (Line, new FLTK.Images.Image); + Wrapper (This.Icons.Element (Line).all).Needs_Dealloc := False; + end if; + Wrapper (This.Icons.Element (Line).all).Void_Ptr := Wrapper (Icon).Void_Ptr; + end Set_Icon; + + + procedure Remove_Icon + (This : in out Textline_Browser; + Line : in Positive) + is + Ptr : Image_Access; + begin + fl_browser_remove_icon (This.Void_Ptr, Interfaces.C.int (Line)); + if Line <= This.Icons.Last_Index then + Ptr := This.Icons.Element (Line); + Free (Ptr); + This.Icons.Replace_Element (Line, null); + end if; + end Remove_Icon; + + + + + function Full_List_Height + (This : in Textline_Browser) + return Integer is + begin + return Browser (This).Full_List_Height; + end Full_List_Height; + + + function Average_Item_Height + (This : in Textline_Browser) + return Integer is + begin + return Browser (This).Average_Item_Height; + end Average_Item_Height; + + + + + function Item_Width + (This : in Textline_Browser; + Item : in Item_Cursor) + return Integer + is + function my_item_width + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + for my_item_width'Address use This.Item_Override_Ptrs (Item_Width_Ptr); + pragma Import (Ada, my_item_width); + begin + return Integer (my_item_width (This.Void_Ptr, Cursor_To_Address (Item))); + end Item_Width; + + + function Item_Height + (This : in Textline_Browser; + Item : in Item_Cursor) + return Integer + is + function my_item_height + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + for my_item_height'Address use This.Item_Override_Ptrs (Item_Height_Ptr); + pragma Import (Ada, my_item_height); + begin + return Integer (my_item_height (This.Void_Ptr, Cursor_To_Address (Item))); + end Item_Height; + + + function Item_First + (This : in Textline_Browser) + return Item_Cursor + is + function my_item_first + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + for my_item_first'Address use This.Item_Override_Ptrs (Item_First_Ptr); + pragma Import (Ada, my_item_first); + begin + return Address_To_Cursor (my_item_first (This.Void_Ptr)); + end Item_First; + + + function Item_Last + (This : in Textline_Browser) + return Item_Cursor + is + function my_item_last + (B : in Storage.Integer_Address) + return Storage.Integer_Address; + for my_item_last'Address use This.Item_Override_Ptrs (Item_Last_Ptr); + pragma Import (Ada, my_item_last); + begin + return Address_To_Cursor (my_item_last (This.Void_Ptr)); + end Item_Last; + + + function Item_Next + (This : in Textline_Browser; + Item : in Item_Cursor) + return Item_Cursor + is + function my_item_next + (B, I : in Storage.Integer_Address) + return Storage.Integer_Address; + for my_item_next'Address use This.Item_Override_Ptrs (Item_Next_Ptr); + pragma Import (Ada, my_item_next); + begin + return Address_To_Cursor (my_item_next (This.Void_Ptr, Cursor_To_Address (Item))); + end Item_Next; + + + function Item_Previous + (This : in Textline_Browser; + Item : in Item_Cursor) + return Item_Cursor + is + function my_item_prev + (B, I : in Storage.Integer_Address) + return Storage.Integer_Address; + for my_item_prev'Address use This.Item_Override_Ptrs (Item_Previous_Ptr); + pragma Import (Ada, my_item_prev); + begin + return Address_To_Cursor (my_item_prev (This.Void_Ptr, Cursor_To_Address (Item))); + end Item_Previous; + + + function Item_At + (This : in Textline_Browser; + Index : in Positive) + return Item_Cursor + is + function my_item_at + (B : in Storage.Integer_Address; + N : in Interfaces.C.int) + return Storage.Integer_Address; + for my_item_at'Address use This.Item_Override_Ptrs (Item_At_Ptr); + pragma Import (Ada, my_item_at); + begin + return Address_To_Cursor (my_item_at (This.Void_Ptr, Interfaces.C.int (Index))); + end Item_At; + + + procedure Item_Select + (This : in out Textline_Browser; + Item : in Item_Cursor; + State : in Boolean := True) + is + procedure my_item_select + (B, I : in Storage.Integer_Address; + V : in Interfaces.C.int); + for my_item_select'Address use This.Item_Override_Ptrs (Item_Select_Ptr); + pragma Import (Ada, my_item_select); + begin + my_item_select (This.Void_Ptr, Cursor_To_Address (Item), Boolean'Pos (State)); + end Item_Select; + + + function Item_Selected + (This : in Textline_Browser; + Item : in Item_Cursor) + return Boolean + is + function my_item_selected + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + for my_item_selected'Address use This.Item_Override_Ptrs (Item_Selected_Ptr); + pragma Import (Ada, my_item_selected); + Code : Interfaces.C.int := my_item_selected (This.Void_Ptr, Cursor_To_Address (Item)); + begin + if Code not in 0 .. 1 then + raise Internal_FLTK_Error; + else + return Boolean'Val (Code); + end if; + end Item_Selected; + + + procedure Item_Swap + (This : in out Textline_Browser; + A, B : in Item_Cursor) + is + procedure my_item_swap + (B, X, Y : in Storage.Integer_Address); + for my_item_swap'Address use This.Item_Override_Ptrs (Item_Swap_Ptr); + pragma Import (Ada, my_item_swap); + begin + my_item_swap (This.Void_Ptr, Cursor_To_Address (A), Cursor_To_Address (B)); + end Item_Swap; + + + function Item_Text + (This : in Textline_Browser; + Item : in Item_Cursor) + return String + is + function my_item_text + (B, I : in Storage.Integer_Address) + return Interfaces.C.Strings.chars_ptr; + for my_item_text'Address use This.Item_Override_Ptrs (Item_Text_Ptr); + pragma Import (Ada, my_item_text); + begin + return Interfaces.C.Strings.Value (my_item_text (This.Void_Ptr, Cursor_To_Address (Item))); + end Item_Text; + + + procedure Item_Draw + (This : in Textline_Browser; + Item : in Item_Cursor; + X, Y, W, H : in Integer) + is + procedure my_item_draw + (B, I : in Storage.Integer_Address; + X, Y, W, H : in Interfaces.C.int); + for my_item_draw'Address use This.Item_Override_Ptrs (Item_Draw_Ptr); + pragma Import (Ada, my_item_draw); + begin + my_item_draw + (This.Void_Ptr, + Cursor_To_Address (Item), + Interfaces.C.int (X), + Interfaces.C.int (Y), + Interfaces.C.int (W), + Interfaces.C.int (H)); + end Item_Draw; + + + + + function Line_Number + (This : in Textline_Browser; + Item : in Item_Cursor) + return Natural + is + function my_lineno + (B, I : in Storage.Integer_Address) + return Interfaces.C.int; + for my_lineno'Address use This.Line_Number_Ptr; + pragma Import (Ada, my_lineno); + begin + return Natural (my_lineno (This.Void_Ptr, Cursor_To_Address (Item))); + end Line_Number; + + +end FLTK.Widgets.Groups.Browsers.Textline; + + -- cgit