1------------------------------------------------------------------------------ 2-- -- 3-- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- 4-- Copyright (C) 2000-2015, AdaCore -- 5-- -- 6-- This library is free software; you can redistribute it and/or modify it -- 7-- under terms of the GNU General Public License as published by the Free -- 8-- Software Foundation; either version 3, or (at your option) any later -- 9-- version. This library is distributed in the hope that it will be useful, -- 10-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- 11-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- 12-- -- 13-- As a special exception under Section 7 of GPL version 3, you are granted -- 14-- additional permissions described in the GCC Runtime Library Exception, -- 15-- version 3.1, as published by the Free Software Foundation. -- 16-- -- 17-- You should have received a copy of the GNU General Public License and -- 18-- a copy of the GCC Runtime Library Exception along with this program; -- 19-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- 20-- <http://www.gnu.org/licenses/>. -- 21-- -- 22------------------------------------------------------------------------------ 23 24pragma Style_Checks (Off); 25pragma Warnings (Off, "*is already use-visible*"); 26with Ada.Unchecked_Conversion; 27with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks; 28with Glib.Values; use Glib.Values; 29with Gtk.Arguments; use Gtk.Arguments; 30with Gtkada.Bindings; use Gtkada.Bindings; 31pragma Warnings(Off); -- might be unused 32with Interfaces.C.Strings; use Interfaces.C.Strings; 33pragma Warnings(On); 34 35package body Gtk.Text_Buffer is 36 37 ------------ 38 -- Insert -- 39 ------------ 40 41 procedure Insert 42 (Buffer : access Gtk_Text_Buffer_Record; 43 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 44 Text : Gtkada.Types.Chars_Ptr) 45 is 46 procedure Internal 47 (Buffer : System.Address; 48 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 49 Text : Gtkada.Types.Chars_Ptr; 50 Len : Gint := -1); 51 pragma Import (C, Internal, "gtk_text_buffer_insert"); 52 53 begin 54 Internal (Get_Object (Buffer), Iter, Text); 55 end Insert; 56 57 procedure Insert_At_Cursor 58 (Buffer : access Gtk_Text_Buffer_Record; 59 Text : Gtkada.Types.Chars_Ptr; 60 Len : Gint := -1) 61 is 62 procedure Internal 63 (Buffer : System.Address; 64 Text : Gtkada.Types.Chars_Ptr; 65 Len : Gint); 66 pragma Import (C, Internal, "gtk_text_buffer_insert_at_cursor"); 67 68 begin 69 Internal (Get_Object (Buffer), Text, Len); 70 end Insert_At_Cursor; 71 72 procedure Insert_With_Tags 73 (Buffer : access Gtk_Text_Buffer_Record; 74 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 75 Text : UTF8_String; 76 Tag : Gtk_Text_Tag) 77 is 78 procedure Internal 79 (Buffer : System.Address; 80 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 81 Text : UTF8_String; 82 Len : Gint; 83 Tag : System.Address); 84 pragma Import (C, Internal, "ada_gtk_text_buffer_insert_with_tags"); 85 86 begin 87 Internal 88 (Get_Object (Buffer), Iter, Text, Text'Length, Get_Object (Tag)); 89 end Insert_With_Tags; 90 91 procedure Insert_With_Tags 92 (Buffer : access Gtk_Text_Buffer_Record; 93 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 94 Text : Gtkada.Types.Chars_Ptr; 95 Tag : Gtk.Text_Tag.Gtk_Text_Tag) 96 is 97 procedure Internal 98 (Buffer : System.Address; 99 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 100 Text : Gtkada.Types.Chars_Ptr; 101 Len : Gint := -1; 102 Tag : System.Address); 103 pragma Import (C, Internal, "ada_gtk_text_buffer_insert_with_tags"); 104 105 begin 106 Internal (Get_Object (Buffer), Iter, Text, Tag => Get_Object (Tag)); 107 end Insert_With_Tags; 108 109 -------------- 110 -- Get_Text -- 111 -------------- 112 113 function Get_Text 114 (Buffer : access Gtk_Text_Buffer_Record; 115 Start : Gtk.Text_Iter.Gtk_Text_Iter; 116 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 117 Include_Hidden_Chars : Boolean := False) return Gtkada.Types.Chars_Ptr 118 is 119 function Internal 120 (Buffer : System.Address; 121 Start : Gtk.Text_Iter.Gtk_Text_Iter; 122 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 123 Include_Hidden_Chars : Gboolean) 124 return Interfaces.C.Strings.chars_ptr; 125 pragma Import (C, Internal, "gtk_text_buffer_get_text"); 126 127 begin 128 return Internal 129 (Get_Object (Buffer), 130 Start, 131 The_End, 132 Boolean'Pos (Include_Hidden_Chars)); 133 end Get_Text; 134 135 function Selection_Exists 136 (Buffer : access Gtk_Text_Buffer_Record) return Boolean 137 is 138 Ignored_A, Ignored_B : Gtk_Text_Iter; 139 Has_Selection : Boolean; 140 begin 141 Get_Selection_Bounds (Buffer, Ignored_A, Ignored_B, Has_Selection); 142 return Has_Selection; 143 end Selection_Exists; 144 145 ---------------- 146 -- Get_Buffer -- 147 ---------------- 148 149 function Get_Buffer 150 (Iter : Gtk_Text_Iter) return Gtk.Text_Buffer.Gtk_Text_Buffer 151 is 152 function Internal (Iter : Gtk_Text_Iter) return System.Address; 153 pragma Import (C, Internal, "gtk_text_iter_get_buffer"); 154 Stub_Gtk_Text_Buffer : Gtk.Text_Buffer.Gtk_Text_Buffer_Record; 155 begin 156 return Gtk.Text_Buffer.Gtk_Text_Buffer (Get_User_Data (Internal (Iter), Stub_Gtk_Text_Buffer)); 157 end Get_Buffer; 158 159 ---------------- 160 -- Get_Buffer -- 161 ---------------- 162 163 function Get_Buffer 164 (Mark : Gtk_Text_Mark) 165 return Gtk.Text_Buffer.Gtk_Text_Buffer 166 is 167 function Internal (Mark : System.Address) return System.Address; 168 pragma Import (C, Internal, "gtk_text_mark_get_buffer"); 169 Stub_Gtk_Text_Buffer : Gtk.Text_Buffer.Gtk_Text_Buffer_Record; 170 begin 171 return Gtk.Text_Buffer.Gtk_Text_Buffer (Get_User_Data (Internal (Get_Object (Mark)), Stub_Gtk_Text_Buffer)); 172 end Get_Buffer; 173 174 ---------------- 175 -- Create_Tag -- 176 ---------------- 177 178 function Create_Tag 179 (Buffer : access Gtk_Text_Buffer_Record; 180 Tag_Name : String := "") 181 return Gtk_Text_Tag 182 is 183 function Internal 184 (Buffer : System.Address; 185 Tag_Name : Interfaces.C.Strings.chars_ptr) 186 return System.Address; 187 pragma Import (C, Internal, "ada_gtk_text_buffer_create_tag"); 188 Stub : Gtk_Text_Tag_Record; 189 Str : Interfaces.C.Strings.chars_ptr := String_Or_Null (Tag_Name); 190 Tag : Gtk_Text_Tag; 191 begin 192 Tag := Gtk_Text_Tag 193 (Get_User_Data (Internal (Get_Object (Buffer), Str), Stub)); 194 Free (Str); 195 return Tag; 196 end Create_Tag; 197 198 package Type_Conversion_Gtk_Text_Buffer is new Glib.Type_Conversion_Hooks.Hook_Registrator 199 (Get_Type'Access, Gtk_Text_Buffer_Record); 200 pragma Unreferenced (Type_Conversion_Gtk_Text_Buffer); 201 202 ------------- 203 -- Gtk_New -- 204 ------------- 205 206 procedure Gtk_New 207 (Buffer : out Gtk_Text_Buffer; 208 Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null) 209 is 210 begin 211 Buffer := new Gtk_Text_Buffer_Record; 212 Gtk.Text_Buffer.Initialize (Buffer, Table); 213 end Gtk_New; 214 215 ------------------------- 216 -- Gtk_Text_Buffer_New -- 217 ------------------------- 218 219 function Gtk_Text_Buffer_New 220 (Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null) 221 return Gtk_Text_Buffer 222 is 223 Buffer : constant Gtk_Text_Buffer := new Gtk_Text_Buffer_Record; 224 begin 225 Gtk.Text_Buffer.Initialize (Buffer, Table); 226 return Buffer; 227 end Gtk_Text_Buffer_New; 228 229 ---------------- 230 -- Initialize -- 231 ---------------- 232 233 procedure Initialize 234 (Buffer : not null access Gtk_Text_Buffer_Record'Class; 235 Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null) 236 is 237 function Internal (Table : System.Address) return System.Address; 238 pragma Import (C, Internal, "gtk_text_buffer_new"); 239 begin 240 if not Buffer.Is_Created then 241 Set_Object (Buffer, Internal (Get_Object_Or_Null (GObject (Table)))); 242 end if; 243 end Initialize; 244 245 -------------- 246 -- Add_Mark -- 247 -------------- 248 249 procedure Add_Mark 250 (Buffer : not null access Gtk_Text_Buffer_Record; 251 Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class; 252 Where : Gtk.Text_Iter.Gtk_Text_Iter) 253 is 254 procedure Internal 255 (Buffer : System.Address; 256 Mark : System.Address; 257 Where : Gtk.Text_Iter.Gtk_Text_Iter); 258 pragma Import (C, Internal, "gtk_text_buffer_add_mark"); 259 begin 260 Internal (Get_Object (Buffer), Get_Object (Mark), Where); 261 end Add_Mark; 262 263 ----------------------------- 264 -- Add_Selection_Clipboard -- 265 ----------------------------- 266 267 procedure Add_Selection_Clipboard 268 (Buffer : not null access Gtk_Text_Buffer_Record; 269 Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class) 270 is 271 procedure Internal 272 (Buffer : System.Address; 273 Clipboard : System.Address); 274 pragma Import (C, Internal, "gtk_text_buffer_add_selection_clipboard"); 275 begin 276 Internal (Get_Object (Buffer), Get_Object (Clipboard)); 277 end Add_Selection_Clipboard; 278 279 --------------- 280 -- Apply_Tag -- 281 --------------- 282 283 procedure Apply_Tag 284 (Buffer : not null access Gtk_Text_Buffer_Record; 285 Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class; 286 Start : Gtk.Text_Iter.Gtk_Text_Iter; 287 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 288 is 289 procedure Internal 290 (Buffer : System.Address; 291 Tag : System.Address; 292 Start : Gtk.Text_Iter.Gtk_Text_Iter; 293 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 294 pragma Import (C, Internal, "gtk_text_buffer_apply_tag"); 295 begin 296 Internal (Get_Object (Buffer), Get_Object (Tag), Start, The_End); 297 end Apply_Tag; 298 299 ----------------------- 300 -- Apply_Tag_By_Name -- 301 ----------------------- 302 303 procedure Apply_Tag_By_Name 304 (Buffer : not null access Gtk_Text_Buffer_Record; 305 Name : UTF8_String; 306 Start : Gtk.Text_Iter.Gtk_Text_Iter; 307 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 308 is 309 procedure Internal 310 (Buffer : System.Address; 311 Name : Interfaces.C.Strings.chars_ptr; 312 Start : Gtk.Text_Iter.Gtk_Text_Iter; 313 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 314 pragma Import (C, Internal, "gtk_text_buffer_apply_tag_by_name"); 315 Tmp_Name : Interfaces.C.Strings.chars_ptr := New_String (Name); 316 begin 317 Internal (Get_Object (Buffer), Tmp_Name, Start, The_End); 318 Free (Tmp_Name); 319 end Apply_Tag_By_Name; 320 321 --------------- 322 -- Backspace -- 323 --------------- 324 325 function Backspace 326 (Buffer : not null access Gtk_Text_Buffer_Record; 327 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 328 Interactive : Boolean; 329 Default_Editable : Boolean) return Boolean 330 is 331 function Internal 332 (Buffer : System.Address; 333 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 334 Interactive : Glib.Gboolean; 335 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 336 pragma Import (C, Internal, "gtk_text_buffer_backspace"); 337 begin 338 return Internal (Get_Object (Buffer), Iter, Boolean'Pos (Interactive), Boolean'Pos (Default_Editable)) /= 0; 339 end Backspace; 340 341 ----------------------- 342 -- Begin_User_Action -- 343 ----------------------- 344 345 procedure Begin_User_Action 346 (Buffer : not null access Gtk_Text_Buffer_Record) 347 is 348 procedure Internal (Buffer : System.Address); 349 pragma Import (C, Internal, "gtk_text_buffer_begin_user_action"); 350 begin 351 Internal (Get_Object (Buffer)); 352 end Begin_User_Action; 353 354 -------------------- 355 -- Copy_Clipboard -- 356 -------------------- 357 358 procedure Copy_Clipboard 359 (Buffer : not null access Gtk_Text_Buffer_Record; 360 Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class) 361 is 362 procedure Internal 363 (Buffer : System.Address; 364 Clipboard : System.Address); 365 pragma Import (C, Internal, "gtk_text_buffer_copy_clipboard"); 366 begin 367 Internal (Get_Object (Buffer), Get_Object (Clipboard)); 368 end Copy_Clipboard; 369 370 ------------------------- 371 -- Create_Child_Anchor -- 372 ------------------------- 373 374 function Create_Child_Anchor 375 (Buffer : not null access Gtk_Text_Buffer_Record; 376 Iter : Gtk.Text_Iter.Gtk_Text_Iter) 377 return Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor 378 is 379 function Internal 380 (Buffer : System.Address; 381 Iter : Gtk.Text_Iter.Gtk_Text_Iter) return System.Address; 382 pragma Import (C, Internal, "gtk_text_buffer_create_child_anchor"); 383 Stub_Gtk_Text_Child_Anchor : Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record; 384 begin 385 return Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor (Get_User_Data (Internal (Get_Object (Buffer), Iter), Stub_Gtk_Text_Child_Anchor)); 386 end Create_Child_Anchor; 387 388 ----------------- 389 -- Create_Mark -- 390 ----------------- 391 392 function Create_Mark 393 (Buffer : not null access Gtk_Text_Buffer_Record; 394 Mark_Name : UTF8_String := ""; 395 Where : Gtk.Text_Iter.Gtk_Text_Iter; 396 Left_Gravity : Boolean := True) return Gtk.Text_Mark.Gtk_Text_Mark 397 is 398 function Internal 399 (Buffer : System.Address; 400 Mark_Name : Interfaces.C.Strings.chars_ptr; 401 Where : Gtk.Text_Iter.Gtk_Text_Iter; 402 Left_Gravity : Glib.Gboolean) return System.Address; 403 pragma Import (C, Internal, "gtk_text_buffer_create_mark"); 404 Tmp_Mark_Name : Interfaces.C.Strings.chars_ptr; 405 Stub_Gtk_Text_Mark : Gtk.Text_Mark.Gtk_Text_Mark_Record; 406 Tmp_Return : System.Address; 407 begin 408 if Mark_Name = "" then 409 Tmp_Mark_Name := Interfaces.C.Strings.Null_Ptr; 410 else 411 Tmp_Mark_Name := New_String (Mark_Name); 412 end if; 413 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Mark_Name, Where, Boolean'Pos (Left_Gravity)); 414 Free (Tmp_Mark_Name); 415 return Gtk.Text_Mark.Gtk_Text_Mark (Get_User_Data (Tmp_Return, Stub_Gtk_Text_Mark)); 416 end Create_Mark; 417 418 ------------------- 419 -- Cut_Clipboard -- 420 ------------------- 421 422 procedure Cut_Clipboard 423 (Buffer : not null access Gtk_Text_Buffer_Record; 424 Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class; 425 Default_Editable : Boolean) 426 is 427 procedure Internal 428 (Buffer : System.Address; 429 Clipboard : System.Address; 430 Default_Editable : Glib.Gboolean); 431 pragma Import (C, Internal, "gtk_text_buffer_cut_clipboard"); 432 begin 433 Internal (Get_Object (Buffer), Get_Object (Clipboard), Boolean'Pos (Default_Editable)); 434 end Cut_Clipboard; 435 436 ------------ 437 -- Delete -- 438 ------------ 439 440 procedure Delete 441 (Buffer : not null access Gtk_Text_Buffer_Record; 442 Start : in out Gtk.Text_Iter.Gtk_Text_Iter; 443 The_End : in out Gtk.Text_Iter.Gtk_Text_Iter) 444 is 445 procedure Internal 446 (Buffer : System.Address; 447 Start : in out Gtk.Text_Iter.Gtk_Text_Iter; 448 The_End : in out Gtk.Text_Iter.Gtk_Text_Iter); 449 pragma Import (C, Internal, "gtk_text_buffer_delete"); 450 Tmp_Start : aliased Gtk.Text_Iter.Gtk_Text_Iter := Start; 451 Tmp_The_End : aliased Gtk.Text_Iter.Gtk_Text_Iter := The_End; 452 begin 453 Internal (Get_Object (Buffer), Tmp_Start, Tmp_The_End); 454 The_End := Tmp_The_End; 455 Start := Tmp_Start; 456 end Delete; 457 458 ------------------------ 459 -- Delete_Interactive -- 460 ------------------------ 461 462 procedure Delete_Interactive 463 (Buffer : not null access Gtk_Text_Buffer_Record; 464 Start_Iter : Gtk.Text_Iter.Gtk_Text_Iter; 465 End_Iter : Gtk.Text_Iter.Gtk_Text_Iter; 466 Default_Editable : Boolean; 467 Result : out Boolean) 468 is 469 function Internal 470 (Buffer : System.Address; 471 Start_Iter : Gtk.Text_Iter.Gtk_Text_Iter; 472 End_Iter : Gtk.Text_Iter.Gtk_Text_Iter; 473 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 474 pragma Import (C, Internal, "gtk_text_buffer_delete_interactive"); 475 begin 476 Result := Internal (Get_Object (Buffer), Start_Iter, End_Iter, Boolean'Pos (Default_Editable)) /= 0; 477 end Delete_Interactive; 478 479 ----------------- 480 -- Delete_Mark -- 481 ----------------- 482 483 procedure Delete_Mark 484 (Buffer : not null access Gtk_Text_Buffer_Record; 485 Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class) 486 is 487 procedure Internal (Buffer : System.Address; Mark : System.Address); 488 pragma Import (C, Internal, "gtk_text_buffer_delete_mark"); 489 begin 490 Internal (Get_Object (Buffer), Get_Object (Mark)); 491 end Delete_Mark; 492 493 ------------------------- 494 -- Delete_Mark_By_Name -- 495 ------------------------- 496 497 procedure Delete_Mark_By_Name 498 (Buffer : not null access Gtk_Text_Buffer_Record; 499 Name : UTF8_String) 500 is 501 procedure Internal 502 (Buffer : System.Address; 503 Name : Interfaces.C.Strings.chars_ptr); 504 pragma Import (C, Internal, "gtk_text_buffer_delete_mark_by_name"); 505 Tmp_Name : Interfaces.C.Strings.chars_ptr := New_String (Name); 506 begin 507 Internal (Get_Object (Buffer), Tmp_Name); 508 Free (Tmp_Name); 509 end Delete_Mark_By_Name; 510 511 ---------------------- 512 -- Delete_Selection -- 513 ---------------------- 514 515 function Delete_Selection 516 (Buffer : not null access Gtk_Text_Buffer_Record; 517 Interactive : Boolean; 518 Default_Editable : Boolean) return Boolean 519 is 520 function Internal 521 (Buffer : System.Address; 522 Interactive : Glib.Gboolean; 523 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 524 pragma Import (C, Internal, "gtk_text_buffer_delete_selection"); 525 begin 526 return Internal (Get_Object (Buffer), Boolean'Pos (Interactive), Boolean'Pos (Default_Editable)) /= 0; 527 end Delete_Selection; 528 529 ------------------------------------- 530 -- Deserialize_Get_Can_Create_Tags -- 531 ------------------------------------- 532 533 function Deserialize_Get_Can_Create_Tags 534 (Buffer : not null access Gtk_Text_Buffer_Record; 535 Format : Gdk.Types.Gdk_Atom) return Boolean 536 is 537 function Internal 538 (Buffer : System.Address; 539 Format : Gdk.Types.Gdk_Atom) return Glib.Gboolean; 540 pragma Import (C, Internal, "gtk_text_buffer_deserialize_get_can_create_tags"); 541 begin 542 return Internal (Get_Object (Buffer), Format) /= 0; 543 end Deserialize_Get_Can_Create_Tags; 544 545 ------------------------------------- 546 -- Deserialize_Set_Can_Create_Tags -- 547 ------------------------------------- 548 549 procedure Deserialize_Set_Can_Create_Tags 550 (Buffer : not null access Gtk_Text_Buffer_Record; 551 Format : Gdk.Types.Gdk_Atom; 552 Can_Create_Tags : Boolean) 553 is 554 procedure Internal 555 (Buffer : System.Address; 556 Format : Gdk.Types.Gdk_Atom; 557 Can_Create_Tags : Glib.Gboolean); 558 pragma Import (C, Internal, "gtk_text_buffer_deserialize_set_can_create_tags"); 559 begin 560 Internal (Get_Object (Buffer), Format, Boolean'Pos (Can_Create_Tags)); 561 end Deserialize_Set_Can_Create_Tags; 562 563 --------------------- 564 -- End_User_Action -- 565 --------------------- 566 567 procedure End_User_Action 568 (Buffer : not null access Gtk_Text_Buffer_Record) 569 is 570 procedure Internal (Buffer : System.Address); 571 pragma Import (C, Internal, "gtk_text_buffer_end_user_action"); 572 begin 573 Internal (Get_Object (Buffer)); 574 end End_User_Action; 575 576 ---------------- 577 -- Get_Bounds -- 578 ---------------- 579 580 procedure Get_Bounds 581 (Buffer : not null access Gtk_Text_Buffer_Record; 582 Start : out Gtk.Text_Iter.Gtk_Text_Iter; 583 The_End : out Gtk.Text_Iter.Gtk_Text_Iter) 584 is 585 procedure Internal 586 (Buffer : System.Address; 587 Start : out Gtk.Text_Iter.Gtk_Text_Iter; 588 The_End : out Gtk.Text_Iter.Gtk_Text_Iter); 589 pragma Import (C, Internal, "gtk_text_buffer_get_bounds"); 590 Tmp_Start : aliased Gtk.Text_Iter.Gtk_Text_Iter; 591 Tmp_The_End : aliased Gtk.Text_Iter.Gtk_Text_Iter; 592 begin 593 Internal (Get_Object (Buffer), Tmp_Start, Tmp_The_End); 594 The_End := Tmp_The_End; 595 Start := Tmp_Start; 596 end Get_Bounds; 597 598 -------------------- 599 -- Get_Char_Count -- 600 -------------------- 601 602 function Get_Char_Count 603 (Buffer : not null access Gtk_Text_Buffer_Record) return Gint 604 is 605 function Internal (Buffer : System.Address) return Gint; 606 pragma Import (C, Internal, "gtk_text_buffer_get_char_count"); 607 begin 608 return Internal (Get_Object (Buffer)); 609 end Get_Char_Count; 610 611 -------------------------- 612 -- Get_Copy_Target_List -- 613 -------------------------- 614 615 function Get_Copy_Target_List 616 (Buffer : not null access Gtk_Text_Buffer_Record) 617 return Gtk.Target_List.Gtk_Target_List 618 is 619 function Internal (Buffer : System.Address) return System.Address; 620 pragma Import (C, Internal, "gtk_text_buffer_get_copy_target_list"); 621 begin 622 return From_Object (Internal (Get_Object (Buffer))); 623 end Get_Copy_Target_List; 624 625 ------------------ 626 -- Get_End_Iter -- 627 ------------------ 628 629 procedure Get_End_Iter 630 (Buffer : not null access Gtk_Text_Buffer_Record; 631 Iter : out Gtk.Text_Iter.Gtk_Text_Iter) 632 is 633 procedure Internal 634 (Buffer : System.Address; 635 Iter : out Gtk.Text_Iter.Gtk_Text_Iter); 636 pragma Import (C, Internal, "gtk_text_buffer_get_end_iter"); 637 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 638 begin 639 Internal (Get_Object (Buffer), Tmp_Iter); 640 Iter := Tmp_Iter; 641 end Get_End_Iter; 642 643 ----------------------- 644 -- Get_Has_Selection -- 645 ----------------------- 646 647 function Get_Has_Selection 648 (Buffer : not null access Gtk_Text_Buffer_Record) return Boolean 649 is 650 function Internal (Buffer : System.Address) return Glib.Gboolean; 651 pragma Import (C, Internal, "gtk_text_buffer_get_has_selection"); 652 begin 653 return Internal (Get_Object (Buffer)) /= 0; 654 end Get_Has_Selection; 655 656 ---------------- 657 -- Get_Insert -- 658 ---------------- 659 660 function Get_Insert 661 (Buffer : not null access Gtk_Text_Buffer_Record) 662 return Gtk.Text_Mark.Gtk_Text_Mark 663 is 664 function Internal (Buffer : System.Address) return System.Address; 665 pragma Import (C, Internal, "gtk_text_buffer_get_insert"); 666 Stub_Gtk_Text_Mark : Gtk.Text_Mark.Gtk_Text_Mark_Record; 667 begin 668 return Gtk.Text_Mark.Gtk_Text_Mark (Get_User_Data (Internal (Get_Object (Buffer)), Stub_Gtk_Text_Mark)); 669 end Get_Insert; 670 671 ------------------------------ 672 -- Get_Iter_At_Child_Anchor -- 673 ------------------------------ 674 675 procedure Get_Iter_At_Child_Anchor 676 (Buffer : not null access Gtk_Text_Buffer_Record; 677 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 678 Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class) 679 is 680 procedure Internal 681 (Buffer : System.Address; 682 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 683 Anchor : System.Address); 684 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_child_anchor"); 685 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 686 begin 687 Internal (Get_Object (Buffer), Tmp_Iter, Get_Object (Anchor)); 688 Iter := Tmp_Iter; 689 end Get_Iter_At_Child_Anchor; 690 691 ---------------------- 692 -- Get_Iter_At_Line -- 693 ---------------------- 694 695 procedure Get_Iter_At_Line 696 (Buffer : not null access Gtk_Text_Buffer_Record; 697 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 698 Line_Number : Gint) 699 is 700 procedure Internal 701 (Buffer : System.Address; 702 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 703 Line_Number : Gint); 704 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_line"); 705 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 706 begin 707 Internal (Get_Object (Buffer), Tmp_Iter, Line_Number); 708 Iter := Tmp_Iter; 709 end Get_Iter_At_Line; 710 711 ---------------------------- 712 -- Get_Iter_At_Line_Index -- 713 ---------------------------- 714 715 procedure Get_Iter_At_Line_Index 716 (Buffer : not null access Gtk_Text_Buffer_Record; 717 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 718 Line_Number : Gint; 719 Byte_Index : Gint) 720 is 721 procedure Internal 722 (Buffer : System.Address; 723 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 724 Line_Number : Gint; 725 Byte_Index : Gint); 726 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_line_index"); 727 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 728 begin 729 Internal (Get_Object (Buffer), Tmp_Iter, Line_Number, Byte_Index); 730 Iter := Tmp_Iter; 731 end Get_Iter_At_Line_Index; 732 733 ----------------------------- 734 -- Get_Iter_At_Line_Offset -- 735 ----------------------------- 736 737 procedure Get_Iter_At_Line_Offset 738 (Buffer : not null access Gtk_Text_Buffer_Record; 739 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 740 Line_Number : Gint; 741 Char_Offset : Gint) 742 is 743 procedure Internal 744 (Buffer : System.Address; 745 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 746 Line_Number : Gint; 747 Char_Offset : Gint); 748 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_line_offset"); 749 Result : Boolean; 750 begin 751 -- Prevent critical crashes from gtk+ if Char_Offset is invalid 752 Internal (Get_Object (Buffer), Iter, Line_Number, 0); 753 754 if not Ends_Line (Iter) then 755 Forward_To_Line_End (Iter, Result); 756 757 if Char_Offset <= Get_Line_Offset (Iter) then 758 Internal (Get_Object (Buffer), Iter, Line_Number, Char_Offset); 759 end if; 760 end if; 761 end Get_Iter_At_Line_Offset; 762 763 ---------------------- 764 -- Get_Iter_At_Mark -- 765 ---------------------- 766 767 procedure Get_Iter_At_Mark 768 (Buffer : not null access Gtk_Text_Buffer_Record; 769 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 770 Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class) 771 is 772 procedure Internal 773 (Buffer : System.Address; 774 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 775 Mark : System.Address); 776 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_mark"); 777 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 778 begin 779 Internal (Get_Object (Buffer), Tmp_Iter, Get_Object (Mark)); 780 Iter := Tmp_Iter; 781 end Get_Iter_At_Mark; 782 783 ------------------------ 784 -- Get_Iter_At_Offset -- 785 ------------------------ 786 787 procedure Get_Iter_At_Offset 788 (Buffer : not null access Gtk_Text_Buffer_Record; 789 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 790 Char_Offset : Gint) 791 is 792 procedure Internal 793 (Buffer : System.Address; 794 Iter : out Gtk.Text_Iter.Gtk_Text_Iter; 795 Char_Offset : Gint); 796 pragma Import (C, Internal, "gtk_text_buffer_get_iter_at_offset"); 797 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 798 begin 799 Internal (Get_Object (Buffer), Tmp_Iter, Char_Offset); 800 Iter := Tmp_Iter; 801 end Get_Iter_At_Offset; 802 803 -------------------- 804 -- Get_Line_Count -- 805 -------------------- 806 807 function Get_Line_Count 808 (Buffer : not null access Gtk_Text_Buffer_Record) return Gint 809 is 810 function Internal (Buffer : System.Address) return Gint; 811 pragma Import (C, Internal, "gtk_text_buffer_get_line_count"); 812 begin 813 return Internal (Get_Object (Buffer)); 814 end Get_Line_Count; 815 816 -------------- 817 -- Get_Mark -- 818 -------------- 819 820 function Get_Mark 821 (Buffer : not null access Gtk_Text_Buffer_Record; 822 Name : UTF8_String) return Gtk.Text_Mark.Gtk_Text_Mark 823 is 824 function Internal 825 (Buffer : System.Address; 826 Name : Interfaces.C.Strings.chars_ptr) return System.Address; 827 pragma Import (C, Internal, "gtk_text_buffer_get_mark"); 828 Tmp_Name : Interfaces.C.Strings.chars_ptr := New_String (Name); 829 Stub_Gtk_Text_Mark : Gtk.Text_Mark.Gtk_Text_Mark_Record; 830 Tmp_Return : System.Address; 831 begin 832 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Name); 833 Free (Tmp_Name); 834 return Gtk.Text_Mark.Gtk_Text_Mark (Get_User_Data (Tmp_Return, Stub_Gtk_Text_Mark)); 835 end Get_Mark; 836 837 ------------------ 838 -- Get_Modified -- 839 ------------------ 840 841 function Get_Modified 842 (Buffer : not null access Gtk_Text_Buffer_Record) return Boolean 843 is 844 function Internal (Buffer : System.Address) return Glib.Gboolean; 845 pragma Import (C, Internal, "gtk_text_buffer_get_modified"); 846 begin 847 return Internal (Get_Object (Buffer)) /= 0; 848 end Get_Modified; 849 850 --------------------------- 851 -- Get_Paste_Target_List -- 852 --------------------------- 853 854 function Get_Paste_Target_List 855 (Buffer : not null access Gtk_Text_Buffer_Record) 856 return Gtk.Target_List.Gtk_Target_List 857 is 858 function Internal (Buffer : System.Address) return System.Address; 859 pragma Import (C, Internal, "gtk_text_buffer_get_paste_target_list"); 860 begin 861 return From_Object (Internal (Get_Object (Buffer))); 862 end Get_Paste_Target_List; 863 864 ------------------------- 865 -- Get_Selection_Bound -- 866 ------------------------- 867 868 function Get_Selection_Bound 869 (Buffer : not null access Gtk_Text_Buffer_Record) 870 return Gtk.Text_Mark.Gtk_Text_Mark 871 is 872 function Internal (Buffer : System.Address) return System.Address; 873 pragma Import (C, Internal, "gtk_text_buffer_get_selection_bound"); 874 Stub_Gtk_Text_Mark : Gtk.Text_Mark.Gtk_Text_Mark_Record; 875 begin 876 return Gtk.Text_Mark.Gtk_Text_Mark (Get_User_Data (Internal (Get_Object (Buffer)), Stub_Gtk_Text_Mark)); 877 end Get_Selection_Bound; 878 879 -------------------------- 880 -- Get_Selection_Bounds -- 881 -------------------------- 882 883 procedure Get_Selection_Bounds 884 (Buffer : not null access Gtk_Text_Buffer_Record; 885 Start : out Gtk.Text_Iter.Gtk_Text_Iter; 886 The_End : out Gtk.Text_Iter.Gtk_Text_Iter; 887 Result : out Boolean) 888 is 889 function Internal 890 (Buffer : System.Address; 891 Acc_Start : access Gtk.Text_Iter.Gtk_Text_Iter; 892 Acc_The_End : access Gtk.Text_Iter.Gtk_Text_Iter) 893 return Glib.Gboolean; 894 pragma Import (C, Internal, "gtk_text_buffer_get_selection_bounds"); 895 Acc_Start : aliased Gtk.Text_Iter.Gtk_Text_Iter; 896 Acc_The_End : aliased Gtk.Text_Iter.Gtk_Text_Iter; 897 Tmp_Acc_Start : aliased Gtk.Text_Iter.Gtk_Text_Iter; 898 Tmp_Acc_The_End : aliased Gtk.Text_Iter.Gtk_Text_Iter; 899 Tmp_Return : Glib.Gboolean; 900 begin 901 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Acc_Start'Access, Tmp_Acc_The_End'Access); 902 Acc_The_End := Tmp_Acc_The_End; 903 Acc_Start := Tmp_Acc_Start; 904 Start := Acc_Start; 905 The_End := Acc_The_End; 906 Result := Tmp_Return /= 0; 907 end Get_Selection_Bounds; 908 909 --------------- 910 -- Get_Slice -- 911 --------------- 912 913 function Get_Slice 914 (Buffer : not null access Gtk_Text_Buffer_Record; 915 Start : Gtk.Text_Iter.Gtk_Text_Iter; 916 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 917 Include_Hidden_Chars : Boolean := False) return UTF8_String 918 is 919 function Internal 920 (Buffer : System.Address; 921 Start : Gtk.Text_Iter.Gtk_Text_Iter; 922 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 923 Include_Hidden_Chars : Glib.Gboolean) 924 return Interfaces.C.Strings.chars_ptr; 925 pragma Import (C, Internal, "gtk_text_buffer_get_slice"); 926 begin 927 return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Buffer), Start, The_End, Boolean'Pos (Include_Hidden_Chars))); 928 end Get_Slice; 929 930 -------------------- 931 -- Get_Start_Iter -- 932 -------------------- 933 934 procedure Get_Start_Iter 935 (Buffer : not null access Gtk_Text_Buffer_Record; 936 Iter : out Gtk.Text_Iter.Gtk_Text_Iter) 937 is 938 procedure Internal 939 (Buffer : System.Address; 940 Iter : out Gtk.Text_Iter.Gtk_Text_Iter); 941 pragma Import (C, Internal, "gtk_text_buffer_get_start_iter"); 942 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 943 begin 944 Internal (Get_Object (Buffer), Tmp_Iter); 945 Iter := Tmp_Iter; 946 end Get_Start_Iter; 947 948 ------------------- 949 -- Get_Tag_Table -- 950 ------------------- 951 952 function Get_Tag_Table 953 (Buffer : not null access Gtk_Text_Buffer_Record) 954 return Gtk.Text_Tag_Table.Gtk_Text_Tag_Table 955 is 956 function Internal (Buffer : System.Address) return System.Address; 957 pragma Import (C, Internal, "gtk_text_buffer_get_tag_table"); 958 Stub_Gtk_Text_Tag_Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table_Record; 959 begin 960 return Gtk.Text_Tag_Table.Gtk_Text_Tag_Table (Get_User_Data (Internal (Get_Object (Buffer)), Stub_Gtk_Text_Tag_Table)); 961 end Get_Tag_Table; 962 963 -------------- 964 -- Get_Text -- 965 -------------- 966 967 function Get_Text 968 (Buffer : not null access Gtk_Text_Buffer_Record; 969 Start : Gtk.Text_Iter.Gtk_Text_Iter; 970 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 971 Include_Hidden_Chars : Boolean := False) return UTF8_String 972 is 973 function Internal 974 (Buffer : System.Address; 975 Start : Gtk.Text_Iter.Gtk_Text_Iter; 976 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 977 Include_Hidden_Chars : Glib.Gboolean) 978 return Interfaces.C.Strings.chars_ptr; 979 pragma Import (C, Internal, "gtk_text_buffer_get_text"); 980 begin 981 return Gtkada.Bindings.Value_And_Free (Internal (Get_Object (Buffer), Start, The_End, Boolean'Pos (Include_Hidden_Chars))); 982 end Get_Text; 983 984 ------------ 985 -- Insert -- 986 ------------ 987 988 procedure Insert 989 (Buffer : not null access Gtk_Text_Buffer_Record; 990 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 991 Text : UTF8_String) 992 is 993 procedure Internal 994 (Buffer : System.Address; 995 Iter : in out Gtk.Text_Iter.Gtk_Text_Iter; 996 Text : Interfaces.C.Strings.chars_ptr; 997 Len : Gint); 998 pragma Import (C, Internal, "gtk_text_buffer_insert"); 999 Tmp_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter := Iter; 1000 Tmp_Text : Interfaces.C.Strings.chars_ptr := New_String (Text); 1001 begin 1002 Internal (Get_Object (Buffer), Tmp_Iter, Tmp_Text, -1); 1003 Free (Tmp_Text); 1004 Iter := Tmp_Iter; 1005 end Insert; 1006 1007 ---------------------- 1008 -- Insert_At_Cursor -- 1009 ---------------------- 1010 1011 procedure Insert_At_Cursor 1012 (Buffer : not null access Gtk_Text_Buffer_Record; 1013 Text : UTF8_String) 1014 is 1015 procedure Internal 1016 (Buffer : System.Address; 1017 Text : Interfaces.C.Strings.chars_ptr; 1018 Len : Gint); 1019 pragma Import (C, Internal, "gtk_text_buffer_insert_at_cursor"); 1020 Tmp_Text : Interfaces.C.Strings.chars_ptr := New_String (Text); 1021 begin 1022 Internal (Get_Object (Buffer), Tmp_Text, -1); 1023 Free (Tmp_Text); 1024 end Insert_At_Cursor; 1025 1026 ------------------------- 1027 -- Insert_Child_Anchor -- 1028 ------------------------- 1029 1030 procedure Insert_Child_Anchor 1031 (Buffer : not null access Gtk_Text_Buffer_Record; 1032 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1033 Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class) 1034 is 1035 procedure Internal 1036 (Buffer : System.Address; 1037 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1038 Anchor : System.Address); 1039 pragma Import (C, Internal, "gtk_text_buffer_insert_child_anchor"); 1040 begin 1041 Internal (Get_Object (Buffer), Iter, Get_Object (Anchor)); 1042 end Insert_Child_Anchor; 1043 1044 ------------------------ 1045 -- Insert_Interactive -- 1046 ------------------------ 1047 1048 function Insert_Interactive 1049 (Buffer : not null access Gtk_Text_Buffer_Record; 1050 Iter : access Gtk.Text_Iter.Gtk_Text_Iter; 1051 Text : UTF8_String; 1052 Default_Editable : Boolean) return Boolean 1053 is 1054 function Internal 1055 (Buffer : System.Address; 1056 Acc_Iter : access Gtk.Text_Iter.Gtk_Text_Iter; 1057 Text : Interfaces.C.Strings.chars_ptr; 1058 Len : Gint; 1059 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 1060 pragma Import (C, Internal, "gtk_text_buffer_insert_interactive"); 1061 Acc_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 1062 Tmp_Acc_Iter : aliased Gtk.Text_Iter.Gtk_Text_Iter; 1063 Tmp_Text : Interfaces.C.Strings.chars_ptr := New_String (Text); 1064 Tmp_Return : Glib.Gboolean; 1065 begin 1066 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Acc_Iter'Access, Tmp_Text, -1, Boolean'Pos (Default_Editable)); 1067 Free (Tmp_Text); 1068 Acc_Iter := Tmp_Acc_Iter; 1069 Iter.all := Acc_Iter; 1070 return Tmp_Return /= 0; 1071 end Insert_Interactive; 1072 1073 ---------------------------------- 1074 -- Insert_Interactive_At_Cursor -- 1075 ---------------------------------- 1076 1077 function Insert_Interactive_At_Cursor 1078 (Buffer : not null access Gtk_Text_Buffer_Record; 1079 Text : UTF8_String; 1080 Default_Editable : Boolean) return Boolean 1081 is 1082 function Internal 1083 (Buffer : System.Address; 1084 Text : Interfaces.C.Strings.chars_ptr; 1085 Len : Gint; 1086 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 1087 pragma Import (C, Internal, "gtk_text_buffer_insert_interactive_at_cursor"); 1088 Tmp_Text : Interfaces.C.Strings.chars_ptr := New_String (Text); 1089 Tmp_Return : Glib.Gboolean; 1090 begin 1091 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Text, -1, Boolean'Pos (Default_Editable)); 1092 Free (Tmp_Text); 1093 return Tmp_Return /= 0; 1094 end Insert_Interactive_At_Cursor; 1095 1096 ------------------- 1097 -- Insert_Pixbuf -- 1098 ------------------- 1099 1100 procedure Insert_Pixbuf 1101 (Buffer : not null access Gtk_Text_Buffer_Record; 1102 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1103 Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class) 1104 is 1105 procedure Internal 1106 (Buffer : System.Address; 1107 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1108 Pixbuf : System.Address); 1109 pragma Import (C, Internal, "gtk_text_buffer_insert_pixbuf"); 1110 begin 1111 Internal (Get_Object (Buffer), Iter, Get_Object (Pixbuf)); 1112 end Insert_Pixbuf; 1113 1114 ------------------ 1115 -- Insert_Range -- 1116 ------------------ 1117 1118 procedure Insert_Range 1119 (Buffer : not null access Gtk_Text_Buffer_Record; 1120 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1121 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1122 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 1123 is 1124 procedure Internal 1125 (Buffer : System.Address; 1126 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1127 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1128 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 1129 pragma Import (C, Internal, "gtk_text_buffer_insert_range"); 1130 begin 1131 Internal (Get_Object (Buffer), Iter, Start, The_End); 1132 end Insert_Range; 1133 1134 ------------------------------ 1135 -- Insert_Range_Interactive -- 1136 ------------------------------ 1137 1138 function Insert_Range_Interactive 1139 (Buffer : not null access Gtk_Text_Buffer_Record; 1140 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1141 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1142 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 1143 Default_Editable : Boolean) return Boolean 1144 is 1145 function Internal 1146 (Buffer : System.Address; 1147 Iter : Gtk.Text_Iter.Gtk_Text_Iter; 1148 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1149 The_End : Gtk.Text_Iter.Gtk_Text_Iter; 1150 Default_Editable : Glib.Gboolean) return Glib.Gboolean; 1151 pragma Import (C, Internal, "gtk_text_buffer_insert_range_interactive"); 1152 begin 1153 return Internal (Get_Object (Buffer), Iter, Start, The_End, Boolean'Pos (Default_Editable)) /= 0; 1154 end Insert_Range_Interactive; 1155 1156 --------------- 1157 -- Move_Mark -- 1158 --------------- 1159 1160 procedure Move_Mark 1161 (Buffer : not null access Gtk_Text_Buffer_Record; 1162 Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class; 1163 Where : Gtk.Text_Iter.Gtk_Text_Iter) 1164 is 1165 procedure Internal 1166 (Buffer : System.Address; 1167 Mark : System.Address; 1168 Where : Gtk.Text_Iter.Gtk_Text_Iter); 1169 pragma Import (C, Internal, "gtk_text_buffer_move_mark"); 1170 begin 1171 Internal (Get_Object (Buffer), Get_Object (Mark), Where); 1172 end Move_Mark; 1173 1174 ----------------------- 1175 -- Move_Mark_By_Name -- 1176 ----------------------- 1177 1178 procedure Move_Mark_By_Name 1179 (Buffer : not null access Gtk_Text_Buffer_Record; 1180 Name : UTF8_String; 1181 Where : Gtk.Text_Iter.Gtk_Text_Iter) 1182 is 1183 procedure Internal 1184 (Buffer : System.Address; 1185 Name : Interfaces.C.Strings.chars_ptr; 1186 Where : Gtk.Text_Iter.Gtk_Text_Iter); 1187 pragma Import (C, Internal, "gtk_text_buffer_move_mark_by_name"); 1188 Tmp_Name : Interfaces.C.Strings.chars_ptr := New_String (Name); 1189 begin 1190 Internal (Get_Object (Buffer), Tmp_Name, Where); 1191 Free (Tmp_Name); 1192 end Move_Mark_By_Name; 1193 1194 --------------------- 1195 -- Paste_Clipboard -- 1196 --------------------- 1197 1198 procedure Paste_Clipboard 1199 (Buffer : not null access Gtk_Text_Buffer_Record; 1200 Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class; 1201 Default_Editable : Boolean := True) 1202 is 1203 procedure Internal 1204 (Buffer : System.Address; 1205 Clipboard : System.Address; 1206 Override_Location : System.Address; 1207 Default_Editable : Glib.Gboolean); 1208 pragma Import (C, Internal, "gtk_text_buffer_paste_clipboard"); 1209 begin 1210 Internal (Get_Object (Buffer), Get_Object (Clipboard), System.Null_Address, Boolean'Pos (Default_Editable)); 1211 end Paste_Clipboard; 1212 1213 ------------------ 1214 -- Place_Cursor -- 1215 ------------------ 1216 1217 procedure Place_Cursor 1218 (Buffer : not null access Gtk_Text_Buffer_Record; 1219 Where : Gtk.Text_Iter.Gtk_Text_Iter) 1220 is 1221 procedure Internal 1222 (Buffer : System.Address; 1223 Where : Gtk.Text_Iter.Gtk_Text_Iter); 1224 pragma Import (C, Internal, "gtk_text_buffer_place_cursor"); 1225 begin 1226 Internal (Get_Object (Buffer), Where); 1227 end Place_Cursor; 1228 1229 --------------------------------- 1230 -- Register_Deserialize_Tagset -- 1231 --------------------------------- 1232 1233 function Register_Deserialize_Tagset 1234 (Buffer : not null access Gtk_Text_Buffer_Record; 1235 Tagset_Name : UTF8_String := "") return Gdk.Types.Gdk_Atom 1236 is 1237 function Internal 1238 (Buffer : System.Address; 1239 Tagset_Name : Interfaces.C.Strings.chars_ptr) 1240 return Gdk.Types.Gdk_Atom; 1241 pragma Import (C, Internal, "gtk_text_buffer_register_deserialize_tagset"); 1242 Tmp_Tagset_Name : Interfaces.C.Strings.chars_ptr; 1243 Tmp_Return : Gdk.Types.Gdk_Atom; 1244 begin 1245 if Tagset_Name = "" then 1246 Tmp_Tagset_Name := Interfaces.C.Strings.Null_Ptr; 1247 else 1248 Tmp_Tagset_Name := New_String (Tagset_Name); 1249 end if; 1250 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Tagset_Name); 1251 Free (Tmp_Tagset_Name); 1252 return Tmp_Return; 1253 end Register_Deserialize_Tagset; 1254 1255 ------------------------------- 1256 -- Register_Serialize_Tagset -- 1257 ------------------------------- 1258 1259 function Register_Serialize_Tagset 1260 (Buffer : not null access Gtk_Text_Buffer_Record; 1261 Tagset_Name : UTF8_String := "") return Gdk.Types.Gdk_Atom 1262 is 1263 function Internal 1264 (Buffer : System.Address; 1265 Tagset_Name : Interfaces.C.Strings.chars_ptr) 1266 return Gdk.Types.Gdk_Atom; 1267 pragma Import (C, Internal, "gtk_text_buffer_register_serialize_tagset"); 1268 Tmp_Tagset_Name : Interfaces.C.Strings.chars_ptr; 1269 Tmp_Return : Gdk.Types.Gdk_Atom; 1270 begin 1271 if Tagset_Name = "" then 1272 Tmp_Tagset_Name := Interfaces.C.Strings.Null_Ptr; 1273 else 1274 Tmp_Tagset_Name := New_String (Tagset_Name); 1275 end if; 1276 Tmp_Return := Internal (Get_Object (Buffer), Tmp_Tagset_Name); 1277 Free (Tmp_Tagset_Name); 1278 return Tmp_Return; 1279 end Register_Serialize_Tagset; 1280 1281 --------------------- 1282 -- Remove_All_Tags -- 1283 --------------------- 1284 1285 procedure Remove_All_Tags 1286 (Buffer : not null access Gtk_Text_Buffer_Record; 1287 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1288 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 1289 is 1290 procedure Internal 1291 (Buffer : System.Address; 1292 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1293 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 1294 pragma Import (C, Internal, "gtk_text_buffer_remove_all_tags"); 1295 begin 1296 Internal (Get_Object (Buffer), Start, The_End); 1297 end Remove_All_Tags; 1298 1299 -------------------------------- 1300 -- Remove_Selection_Clipboard -- 1301 -------------------------------- 1302 1303 procedure Remove_Selection_Clipboard 1304 (Buffer : not null access Gtk_Text_Buffer_Record; 1305 Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class) 1306 is 1307 procedure Internal 1308 (Buffer : System.Address; 1309 Clipboard : System.Address); 1310 pragma Import (C, Internal, "gtk_text_buffer_remove_selection_clipboard"); 1311 begin 1312 Internal (Get_Object (Buffer), Get_Object (Clipboard)); 1313 end Remove_Selection_Clipboard; 1314 1315 ---------------- 1316 -- Remove_Tag -- 1317 ---------------- 1318 1319 procedure Remove_Tag 1320 (Buffer : not null access Gtk_Text_Buffer_Record; 1321 Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class; 1322 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1323 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 1324 is 1325 procedure Internal 1326 (Buffer : System.Address; 1327 Tag : System.Address; 1328 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1329 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 1330 pragma Import (C, Internal, "gtk_text_buffer_remove_tag"); 1331 begin 1332 Internal (Get_Object (Buffer), Get_Object (Tag), Start, The_End); 1333 end Remove_Tag; 1334 1335 ------------------------ 1336 -- Remove_Tag_By_Name -- 1337 ------------------------ 1338 1339 procedure Remove_Tag_By_Name 1340 (Buffer : not null access Gtk_Text_Buffer_Record; 1341 Name : UTF8_String; 1342 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1343 The_End : Gtk.Text_Iter.Gtk_Text_Iter) 1344 is 1345 procedure Internal 1346 (Buffer : System.Address; 1347 Name : Interfaces.C.Strings.chars_ptr; 1348 Start : Gtk.Text_Iter.Gtk_Text_Iter; 1349 The_End : Gtk.Text_Iter.Gtk_Text_Iter); 1350 pragma Import (C, Internal, "gtk_text_buffer_remove_tag_by_name"); 1351 Tmp_Name : Interfaces.C.Strings.chars_ptr := New_String (Name); 1352 begin 1353 Internal (Get_Object (Buffer), Tmp_Name, Start, The_End); 1354 Free (Tmp_Name); 1355 end Remove_Tag_By_Name; 1356 1357 ------------------ 1358 -- Select_Range -- 1359 ------------------ 1360 1361 procedure Select_Range 1362 (Buffer : not null access Gtk_Text_Buffer_Record; 1363 Ins : Gtk.Text_Iter.Gtk_Text_Iter; 1364 Bound : Gtk.Text_Iter.Gtk_Text_Iter) 1365 is 1366 procedure Internal 1367 (Buffer : System.Address; 1368 Ins : Gtk.Text_Iter.Gtk_Text_Iter; 1369 Bound : Gtk.Text_Iter.Gtk_Text_Iter); 1370 pragma Import (C, Internal, "gtk_text_buffer_select_range"); 1371 begin 1372 Internal (Get_Object (Buffer), Ins, Bound); 1373 end Select_Range; 1374 1375 ------------------ 1376 -- Set_Modified -- 1377 ------------------ 1378 1379 procedure Set_Modified 1380 (Buffer : not null access Gtk_Text_Buffer_Record; 1381 Setting : Boolean) 1382 is 1383 procedure Internal (Buffer : System.Address; Setting : Glib.Gboolean); 1384 pragma Import (C, Internal, "gtk_text_buffer_set_modified"); 1385 begin 1386 Internal (Get_Object (Buffer), Boolean'Pos (Setting)); 1387 end Set_Modified; 1388 1389 -------------- 1390 -- Set_Text -- 1391 -------------- 1392 1393 procedure Set_Text 1394 (Buffer : not null access Gtk_Text_Buffer_Record; 1395 Text : UTF8_String) 1396 is 1397 procedure Internal 1398 (Buffer : System.Address; 1399 Text : Interfaces.C.Strings.chars_ptr; 1400 Len : Gint); 1401 pragma Import (C, Internal, "gtk_text_buffer_set_text"); 1402 Tmp_Text : Interfaces.C.Strings.chars_ptr := New_String (Text); 1403 begin 1404 Internal (Get_Object (Buffer), Tmp_Text, -1); 1405 Free (Tmp_Text); 1406 end Set_Text; 1407 1408 ----------------------------------- 1409 -- Unregister_Deserialize_Format -- 1410 ----------------------------------- 1411 1412 procedure Unregister_Deserialize_Format 1413 (Buffer : not null access Gtk_Text_Buffer_Record; 1414 Format : Gdk.Types.Gdk_Atom) 1415 is 1416 procedure Internal 1417 (Buffer : System.Address; 1418 Format : Gdk.Types.Gdk_Atom); 1419 pragma Import (C, Internal, "gtk_text_buffer_unregister_deserialize_format"); 1420 begin 1421 Internal (Get_Object (Buffer), Format); 1422 end Unregister_Deserialize_Format; 1423 1424 --------------------------------- 1425 -- Unregister_Serialize_Format -- 1426 --------------------------------- 1427 1428 procedure Unregister_Serialize_Format 1429 (Buffer : not null access Gtk_Text_Buffer_Record; 1430 Format : Gdk.Types.Gdk_Atom) 1431 is 1432 procedure Internal 1433 (Buffer : System.Address; 1434 Format : Gdk.Types.Gdk_Atom); 1435 pragma Import (C, Internal, "gtk_text_buffer_unregister_serialize_format"); 1436 begin 1437 Internal (Get_Object (Buffer), Format); 1438 end Unregister_Serialize_Format; 1439 1440 use type System.Address; 1441 1442 function Cb_To_Address is new Ada.Unchecked_Conversion 1443 (Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void, System.Address); 1444 function Address_To_Cb is new Ada.Unchecked_Conversion 1445 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1446 1447 function Cb_To_Address is new Ada.Unchecked_Conversion 1448 (Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void, System.Address); 1449 function Address_To_Cb is new Ada.Unchecked_Conversion 1450 (System.Address, Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1451 1452 function Cb_To_Address is new Ada.Unchecked_Conversion 1453 (Cb_Gtk_Text_Buffer_Void, System.Address); 1454 function Address_To_Cb is new Ada.Unchecked_Conversion 1455 (System.Address, Cb_Gtk_Text_Buffer_Void); 1456 1457 function Cb_To_Address is new Ada.Unchecked_Conversion 1458 (Cb_GObject_Void, System.Address); 1459 function Address_To_Cb is new Ada.Unchecked_Conversion 1460 (System.Address, Cb_GObject_Void); 1461 1462 function Cb_To_Address is new Ada.Unchecked_Conversion 1463 (Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void, System.Address); 1464 function Address_To_Cb is new Ada.Unchecked_Conversion 1465 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1466 1467 function Cb_To_Address is new Ada.Unchecked_Conversion 1468 (Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void, System.Address); 1469 function Address_To_Cb is new Ada.Unchecked_Conversion 1470 (System.Address, Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1471 1472 function Cb_To_Address is new Ada.Unchecked_Conversion 1473 (Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void, System.Address); 1474 function Address_To_Cb is new Ada.Unchecked_Conversion 1475 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void); 1476 1477 function Cb_To_Address is new Ada.Unchecked_Conversion 1478 (Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void, System.Address); 1479 function Address_To_Cb is new Ada.Unchecked_Conversion 1480 (System.Address, Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void); 1481 1482 function Cb_To_Address is new Ada.Unchecked_Conversion 1483 (Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void, System.Address); 1484 function Address_To_Cb is new Ada.Unchecked_Conversion 1485 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void); 1486 1487 function Cb_To_Address is new Ada.Unchecked_Conversion 1488 (Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void, System.Address); 1489 function Address_To_Cb is new Ada.Unchecked_Conversion 1490 (System.Address, Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void); 1491 1492 function Cb_To_Address is new Ada.Unchecked_Conversion 1493 (Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void, System.Address); 1494 function Address_To_Cb is new Ada.Unchecked_Conversion 1495 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void); 1496 1497 function Cb_To_Address is new Ada.Unchecked_Conversion 1498 (Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void, System.Address); 1499 function Address_To_Cb is new Ada.Unchecked_Conversion 1500 (System.Address, Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void); 1501 1502 function Cb_To_Address is new Ada.Unchecked_Conversion 1503 (Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void, System.Address); 1504 function Address_To_Cb is new Ada.Unchecked_Conversion 1505 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void); 1506 1507 function Cb_To_Address is new Ada.Unchecked_Conversion 1508 (Cb_GObject_Gtk_Text_Mark_Void, System.Address); 1509 function Address_To_Cb is new Ada.Unchecked_Conversion 1510 (System.Address, Cb_GObject_Gtk_Text_Mark_Void); 1511 1512 function Cb_To_Address is new Ada.Unchecked_Conversion 1513 (Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void, System.Address); 1514 function Address_To_Cb is new Ada.Unchecked_Conversion 1515 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void); 1516 1517 function Cb_To_Address is new Ada.Unchecked_Conversion 1518 (Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void, System.Address); 1519 function Address_To_Cb is new Ada.Unchecked_Conversion 1520 (System.Address, Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void); 1521 1522 function Cb_To_Address is new Ada.Unchecked_Conversion 1523 (Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void, System.Address); 1524 function Address_To_Cb is new Ada.Unchecked_Conversion 1525 (System.Address, Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void); 1526 1527 function Cb_To_Address is new Ada.Unchecked_Conversion 1528 (Cb_GObject_Gtk_Clipboard_Void, System.Address); 1529 function Address_To_Cb is new Ada.Unchecked_Conversion 1530 (System.Address, Cb_GObject_Gtk_Clipboard_Void); 1531 1532 procedure Connect 1533 (Object : access Gtk_Text_Buffer_Record'Class; 1534 C_Name : Glib.Signal_Name; 1535 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1536 After : Boolean); 1537 1538 procedure Connect 1539 (Object : access Gtk_Text_Buffer_Record'Class; 1540 C_Name : Glib.Signal_Name; 1541 Handler : Cb_Gtk_Text_Buffer_Void; 1542 After : Boolean); 1543 1544 procedure Connect 1545 (Object : access Gtk_Text_Buffer_Record'Class; 1546 C_Name : Glib.Signal_Name; 1547 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1548 After : Boolean); 1549 1550 procedure Connect 1551 (Object : access Gtk_Text_Buffer_Record'Class; 1552 C_Name : Glib.Signal_Name; 1553 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 1554 After : Boolean); 1555 1556 procedure Connect 1557 (Object : access Gtk_Text_Buffer_Record'Class; 1558 C_Name : Glib.Signal_Name; 1559 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void; 1560 After : Boolean); 1561 1562 procedure Connect 1563 (Object : access Gtk_Text_Buffer_Record'Class; 1564 C_Name : Glib.Signal_Name; 1565 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void; 1566 After : Boolean); 1567 1568 procedure Connect 1569 (Object : access Gtk_Text_Buffer_Record'Class; 1570 C_Name : Glib.Signal_Name; 1571 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void; 1572 After : Boolean); 1573 1574 procedure Connect 1575 (Object : access Gtk_Text_Buffer_Record'Class; 1576 C_Name : Glib.Signal_Name; 1577 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void; 1578 After : Boolean); 1579 1580 procedure Connect 1581 (Object : access Gtk_Text_Buffer_Record'Class; 1582 C_Name : Glib.Signal_Name; 1583 Handler : Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void; 1584 After : Boolean); 1585 1586 procedure Connect_Slot 1587 (Object : access Gtk_Text_Buffer_Record'Class; 1588 C_Name : Glib.Signal_Name; 1589 Handler : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1590 After : Boolean; 1591 Slot : access Glib.Object.GObject_Record'Class := null); 1592 1593 procedure Connect_Slot 1594 (Object : access Gtk_Text_Buffer_Record'Class; 1595 C_Name : Glib.Signal_Name; 1596 Handler : Cb_GObject_Void; 1597 After : Boolean; 1598 Slot : access Glib.Object.GObject_Record'Class := null); 1599 1600 procedure Connect_Slot 1601 (Object : access Gtk_Text_Buffer_Record'Class; 1602 C_Name : Glib.Signal_Name; 1603 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1604 After : Boolean; 1605 Slot : access Glib.Object.GObject_Record'Class := null); 1606 1607 procedure Connect_Slot 1608 (Object : access Gtk_Text_Buffer_Record'Class; 1609 C_Name : Glib.Signal_Name; 1610 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 1611 After : Boolean; 1612 Slot : access Glib.Object.GObject_Record'Class := null); 1613 1614 procedure Connect_Slot 1615 (Object : access Gtk_Text_Buffer_Record'Class; 1616 C_Name : Glib.Signal_Name; 1617 Handler : Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void; 1618 After : Boolean; 1619 Slot : access Glib.Object.GObject_Record'Class := null); 1620 1621 procedure Connect_Slot 1622 (Object : access Gtk_Text_Buffer_Record'Class; 1623 C_Name : Glib.Signal_Name; 1624 Handler : Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void; 1625 After : Boolean; 1626 Slot : access Glib.Object.GObject_Record'Class := null); 1627 1628 procedure Connect_Slot 1629 (Object : access Gtk_Text_Buffer_Record'Class; 1630 C_Name : Glib.Signal_Name; 1631 Handler : Cb_GObject_Gtk_Text_Mark_Void; 1632 After : Boolean; 1633 Slot : access Glib.Object.GObject_Record'Class := null); 1634 1635 procedure Connect_Slot 1636 (Object : access Gtk_Text_Buffer_Record'Class; 1637 C_Name : Glib.Signal_Name; 1638 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void; 1639 After : Boolean; 1640 Slot : access Glib.Object.GObject_Record'Class := null); 1641 1642 procedure Connect_Slot 1643 (Object : access Gtk_Text_Buffer_Record'Class; 1644 C_Name : Glib.Signal_Name; 1645 Handler : Cb_GObject_Gtk_Clipboard_Void; 1646 After : Boolean; 1647 Slot : access Glib.Object.GObject_Record'Class := null); 1648 1649 procedure Marsh_GObject_Gtk_Clipboard_Void 1650 (Closure : GClosure; 1651 Return_Value : Glib.Values.GValue; 1652 N_Params : Glib.Guint; 1653 Params : Glib.Values.C_GValues; 1654 Invocation_Hint : System.Address; 1655 User_Data : System.Address); 1656 pragma Convention (C, Marsh_GObject_Gtk_Clipboard_Void); 1657 1658 procedure Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void 1659 (Closure : GClosure; 1660 Return_Value : Glib.Values.GValue; 1661 N_Params : Glib.Guint; 1662 Params : Glib.Values.C_GValues; 1663 Invocation_Hint : System.Address; 1664 User_Data : System.Address); 1665 pragma Convention (C, Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void); 1666 1667 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void 1668 (Closure : GClosure; 1669 Return_Value : Glib.Values.GValue; 1670 N_Params : Glib.Guint; 1671 Params : Glib.Values.C_GValues; 1672 Invocation_Hint : System.Address; 1673 User_Data : System.Address); 1674 pragma Convention (C, Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void); 1675 1676 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void 1677 (Closure : GClosure; 1678 Return_Value : Glib.Values.GValue; 1679 N_Params : Glib.Guint; 1680 Params : Glib.Values.C_GValues; 1681 Invocation_Hint : System.Address; 1682 User_Data : System.Address); 1683 pragma Convention (C, Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1684 1685 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void 1686 (Closure : GClosure; 1687 Return_Value : Glib.Values.GValue; 1688 N_Params : Glib.Guint; 1689 Params : Glib.Values.C_GValues; 1690 Invocation_Hint : System.Address; 1691 User_Data : System.Address); 1692 pragma Convention (C, Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void); 1693 1694 procedure Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void 1695 (Closure : GClosure; 1696 Return_Value : Glib.Values.GValue; 1697 N_Params : Glib.Guint; 1698 Params : Glib.Values.C_GValues; 1699 Invocation_Hint : System.Address; 1700 User_Data : System.Address); 1701 pragma Convention (C, Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void); 1702 1703 procedure Marsh_GObject_Gtk_Text_Mark_Void 1704 (Closure : GClosure; 1705 Return_Value : Glib.Values.GValue; 1706 N_Params : Glib.Guint; 1707 Params : Glib.Values.C_GValues; 1708 Invocation_Hint : System.Address; 1709 User_Data : System.Address); 1710 pragma Convention (C, Marsh_GObject_Gtk_Text_Mark_Void); 1711 1712 procedure Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void 1713 (Closure : GClosure; 1714 Return_Value : Glib.Values.GValue; 1715 N_Params : Glib.Guint; 1716 Params : Glib.Values.C_GValues; 1717 Invocation_Hint : System.Address; 1718 User_Data : System.Address); 1719 pragma Convention (C, Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1720 1721 procedure Marsh_GObject_Void 1722 (Closure : GClosure; 1723 Return_Value : Glib.Values.GValue; 1724 N_Params : Glib.Guint; 1725 Params : Glib.Values.C_GValues; 1726 Invocation_Hint : System.Address; 1727 User_Data : System.Address); 1728 pragma Convention (C, Marsh_GObject_Void); 1729 1730 procedure Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void 1731 (Closure : GClosure; 1732 Return_Value : Glib.Values.GValue; 1733 N_Params : Glib.Guint; 1734 Params : Glib.Values.C_GValues; 1735 Invocation_Hint : System.Address; 1736 User_Data : System.Address); 1737 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void); 1738 1739 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void 1740 (Closure : GClosure; 1741 Return_Value : Glib.Values.GValue; 1742 N_Params : Glib.Guint; 1743 Params : Glib.Values.C_GValues; 1744 Invocation_Hint : System.Address; 1745 User_Data : System.Address); 1746 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void); 1747 1748 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void 1749 (Closure : GClosure; 1750 Return_Value : Glib.Values.GValue; 1751 N_Params : Glib.Guint; 1752 Params : Glib.Values.C_GValues; 1753 Invocation_Hint : System.Address; 1754 User_Data : System.Address); 1755 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void); 1756 1757 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void 1758 (Closure : GClosure; 1759 Return_Value : Glib.Values.GValue; 1760 N_Params : Glib.Guint; 1761 Params : Glib.Values.C_GValues; 1762 Invocation_Hint : System.Address; 1763 User_Data : System.Address); 1764 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1765 1766 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void 1767 (Closure : GClosure; 1768 Return_Value : Glib.Values.GValue; 1769 N_Params : Glib.Guint; 1770 Params : Glib.Values.C_GValues; 1771 Invocation_Hint : System.Address; 1772 User_Data : System.Address); 1773 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void); 1774 1775 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void 1776 (Closure : GClosure; 1777 Return_Value : Glib.Values.GValue; 1778 N_Params : Glib.Guint; 1779 Params : Glib.Values.C_GValues; 1780 Invocation_Hint : System.Address; 1781 User_Data : System.Address); 1782 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void); 1783 1784 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void 1785 (Closure : GClosure; 1786 Return_Value : Glib.Values.GValue; 1787 N_Params : Glib.Guint; 1788 Params : Glib.Values.C_GValues; 1789 Invocation_Hint : System.Address; 1790 User_Data : System.Address); 1791 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void); 1792 1793 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void 1794 (Closure : GClosure; 1795 Return_Value : Glib.Values.GValue; 1796 N_Params : Glib.Guint; 1797 Params : Glib.Values.C_GValues; 1798 Invocation_Hint : System.Address; 1799 User_Data : System.Address); 1800 pragma Convention (C, Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void); 1801 1802 procedure Marsh_Gtk_Text_Buffer_Void 1803 (Closure : GClosure; 1804 Return_Value : Glib.Values.GValue; 1805 N_Params : Glib.Guint; 1806 Params : Glib.Values.C_GValues; 1807 Invocation_Hint : System.Address; 1808 User_Data : System.Address); 1809 pragma Convention (C, Marsh_Gtk_Text_Buffer_Void); 1810 1811 ------------- 1812 -- Connect -- 1813 ------------- 1814 1815 procedure Connect 1816 (Object : access Gtk_Text_Buffer_Record'Class; 1817 C_Name : Glib.Signal_Name; 1818 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1819 After : Boolean) 1820 is 1821 begin 1822 Unchecked_Do_Signal_Connect 1823 (Object => Object, 1824 C_Name => C_Name, 1825 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void'Access, 1826 Handler => Cb_To_Address (Handler),-- Set in the closure 1827 After => After); 1828 end Connect; 1829 1830 ------------- 1831 -- Connect -- 1832 ------------- 1833 1834 procedure Connect 1835 (Object : access Gtk_Text_Buffer_Record'Class; 1836 C_Name : Glib.Signal_Name; 1837 Handler : Cb_Gtk_Text_Buffer_Void; 1838 After : Boolean) 1839 is 1840 begin 1841 Unchecked_Do_Signal_Connect 1842 (Object => Object, 1843 C_Name => C_Name, 1844 Marshaller => Marsh_Gtk_Text_Buffer_Void'Access, 1845 Handler => Cb_To_Address (Handler),-- Set in the closure 1846 After => After); 1847 end Connect; 1848 1849 ------------- 1850 -- Connect -- 1851 ------------- 1852 1853 procedure Connect 1854 (Object : access Gtk_Text_Buffer_Record'Class; 1855 C_Name : Glib.Signal_Name; 1856 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1857 After : Boolean) 1858 is 1859 begin 1860 Unchecked_Do_Signal_Connect 1861 (Object => Object, 1862 C_Name => C_Name, 1863 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void'Access, 1864 Handler => Cb_To_Address (Handler),-- Set in the closure 1865 After => After); 1866 end Connect; 1867 1868 ------------- 1869 -- Connect -- 1870 ------------- 1871 1872 procedure Connect 1873 (Object : access Gtk_Text_Buffer_Record'Class; 1874 C_Name : Glib.Signal_Name; 1875 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 1876 After : Boolean) 1877 is 1878 begin 1879 Unchecked_Do_Signal_Connect 1880 (Object => Object, 1881 C_Name => C_Name, 1882 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void'Access, 1883 Handler => Cb_To_Address (Handler),-- Set in the closure 1884 After => After); 1885 end Connect; 1886 1887 ------------- 1888 -- Connect -- 1889 ------------- 1890 1891 procedure Connect 1892 (Object : access Gtk_Text_Buffer_Record'Class; 1893 C_Name : Glib.Signal_Name; 1894 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void; 1895 After : Boolean) 1896 is 1897 begin 1898 Unchecked_Do_Signal_Connect 1899 (Object => Object, 1900 C_Name => C_Name, 1901 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void'Access, 1902 Handler => Cb_To_Address (Handler),-- Set in the closure 1903 After => After); 1904 end Connect; 1905 1906 ------------- 1907 -- Connect -- 1908 ------------- 1909 1910 procedure Connect 1911 (Object : access Gtk_Text_Buffer_Record'Class; 1912 C_Name : Glib.Signal_Name; 1913 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void; 1914 After : Boolean) 1915 is 1916 begin 1917 Unchecked_Do_Signal_Connect 1918 (Object => Object, 1919 C_Name => C_Name, 1920 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void'Access, 1921 Handler => Cb_To_Address (Handler),-- Set in the closure 1922 After => After); 1923 end Connect; 1924 1925 ------------- 1926 -- Connect -- 1927 ------------- 1928 1929 procedure Connect 1930 (Object : access Gtk_Text_Buffer_Record'Class; 1931 C_Name : Glib.Signal_Name; 1932 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void; 1933 After : Boolean) 1934 is 1935 begin 1936 Unchecked_Do_Signal_Connect 1937 (Object => Object, 1938 C_Name => C_Name, 1939 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void'Access, 1940 Handler => Cb_To_Address (Handler),-- Set in the closure 1941 After => After); 1942 end Connect; 1943 1944 ------------- 1945 -- Connect -- 1946 ------------- 1947 1948 procedure Connect 1949 (Object : access Gtk_Text_Buffer_Record'Class; 1950 C_Name : Glib.Signal_Name; 1951 Handler : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void; 1952 After : Boolean) 1953 is 1954 begin 1955 Unchecked_Do_Signal_Connect 1956 (Object => Object, 1957 C_Name => C_Name, 1958 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void'Access, 1959 Handler => Cb_To_Address (Handler),-- Set in the closure 1960 After => After); 1961 end Connect; 1962 1963 ------------- 1964 -- Connect -- 1965 ------------- 1966 1967 procedure Connect 1968 (Object : access Gtk_Text_Buffer_Record'Class; 1969 C_Name : Glib.Signal_Name; 1970 Handler : Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void; 1971 After : Boolean) 1972 is 1973 begin 1974 Unchecked_Do_Signal_Connect 1975 (Object => Object, 1976 C_Name => C_Name, 1977 Marshaller => Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void'Access, 1978 Handler => Cb_To_Address (Handler),-- Set in the closure 1979 After => After); 1980 end Connect; 1981 1982 ------------------ 1983 -- Connect_Slot -- 1984 ------------------ 1985 1986 procedure Connect_Slot 1987 (Object : access Gtk_Text_Buffer_Record'Class; 1988 C_Name : Glib.Signal_Name; 1989 Handler : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 1990 After : Boolean; 1991 Slot : access Glib.Object.GObject_Record'Class := null) 1992 is 1993 begin 1994 Unchecked_Do_Signal_Connect 1995 (Object => Object, 1996 C_Name => C_Name, 1997 Marshaller => Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void'Access, 1998 Handler => Cb_To_Address (Handler),-- Set in the closure 1999 Slot_Object => Slot, 2000 After => After); 2001 end Connect_Slot; 2002 2003 ------------------ 2004 -- Connect_Slot -- 2005 ------------------ 2006 2007 procedure Connect_Slot 2008 (Object : access Gtk_Text_Buffer_Record'Class; 2009 C_Name : Glib.Signal_Name; 2010 Handler : Cb_GObject_Void; 2011 After : Boolean; 2012 Slot : access Glib.Object.GObject_Record'Class := null) 2013 is 2014 begin 2015 Unchecked_Do_Signal_Connect 2016 (Object => Object, 2017 C_Name => C_Name, 2018 Marshaller => Marsh_GObject_Void'Access, 2019 Handler => Cb_To_Address (Handler),-- Set in the closure 2020 Slot_Object => Slot, 2021 After => After); 2022 end Connect_Slot; 2023 2024 ------------------ 2025 -- Connect_Slot -- 2026 ------------------ 2027 2028 procedure Connect_Slot 2029 (Object : access Gtk_Text_Buffer_Record'Class; 2030 C_Name : Glib.Signal_Name; 2031 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2032 After : Boolean; 2033 Slot : access Glib.Object.GObject_Record'Class := null) 2034 is 2035 begin 2036 Unchecked_Do_Signal_Connect 2037 (Object => Object, 2038 C_Name => C_Name, 2039 Marshaller => Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void'Access, 2040 Handler => Cb_To_Address (Handler),-- Set in the closure 2041 Slot_Object => Slot, 2042 After => After); 2043 end Connect_Slot; 2044 2045 ------------------ 2046 -- Connect_Slot -- 2047 ------------------ 2048 2049 procedure Connect_Slot 2050 (Object : access Gtk_Text_Buffer_Record'Class; 2051 C_Name : Glib.Signal_Name; 2052 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 2053 After : Boolean; 2054 Slot : access Glib.Object.GObject_Record'Class := null) 2055 is 2056 begin 2057 Unchecked_Do_Signal_Connect 2058 (Object => Object, 2059 C_Name => C_Name, 2060 Marshaller => Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void'Access, 2061 Handler => Cb_To_Address (Handler),-- Set in the closure 2062 Slot_Object => Slot, 2063 After => After); 2064 end Connect_Slot; 2065 2066 ------------------ 2067 -- Connect_Slot -- 2068 ------------------ 2069 2070 procedure Connect_Slot 2071 (Object : access Gtk_Text_Buffer_Record'Class; 2072 C_Name : Glib.Signal_Name; 2073 Handler : Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void; 2074 After : Boolean; 2075 Slot : access Glib.Object.GObject_Record'Class := null) 2076 is 2077 begin 2078 Unchecked_Do_Signal_Connect 2079 (Object => Object, 2080 C_Name => C_Name, 2081 Marshaller => Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void'Access, 2082 Handler => Cb_To_Address (Handler),-- Set in the closure 2083 Slot_Object => Slot, 2084 After => After); 2085 end Connect_Slot; 2086 2087 ------------------ 2088 -- Connect_Slot -- 2089 ------------------ 2090 2091 procedure Connect_Slot 2092 (Object : access Gtk_Text_Buffer_Record'Class; 2093 C_Name : Glib.Signal_Name; 2094 Handler : Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void; 2095 After : Boolean; 2096 Slot : access Glib.Object.GObject_Record'Class := null) 2097 is 2098 begin 2099 Unchecked_Do_Signal_Connect 2100 (Object => Object, 2101 C_Name => C_Name, 2102 Marshaller => Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void'Access, 2103 Handler => Cb_To_Address (Handler),-- Set in the closure 2104 Slot_Object => Slot, 2105 After => After); 2106 end Connect_Slot; 2107 2108 ------------------ 2109 -- Connect_Slot -- 2110 ------------------ 2111 2112 procedure Connect_Slot 2113 (Object : access Gtk_Text_Buffer_Record'Class; 2114 C_Name : Glib.Signal_Name; 2115 Handler : Cb_GObject_Gtk_Text_Mark_Void; 2116 After : Boolean; 2117 Slot : access Glib.Object.GObject_Record'Class := null) 2118 is 2119 begin 2120 Unchecked_Do_Signal_Connect 2121 (Object => Object, 2122 C_Name => C_Name, 2123 Marshaller => Marsh_GObject_Gtk_Text_Mark_Void'Access, 2124 Handler => Cb_To_Address (Handler),-- Set in the closure 2125 Slot_Object => Slot, 2126 After => After); 2127 end Connect_Slot; 2128 2129 ------------------ 2130 -- Connect_Slot -- 2131 ------------------ 2132 2133 procedure Connect_Slot 2134 (Object : access Gtk_Text_Buffer_Record'Class; 2135 C_Name : Glib.Signal_Name; 2136 Handler : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void; 2137 After : Boolean; 2138 Slot : access Glib.Object.GObject_Record'Class := null) 2139 is 2140 begin 2141 Unchecked_Do_Signal_Connect 2142 (Object => Object, 2143 C_Name => C_Name, 2144 Marshaller => Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void'Access, 2145 Handler => Cb_To_Address (Handler),-- Set in the closure 2146 Slot_Object => Slot, 2147 After => After); 2148 end Connect_Slot; 2149 2150 ------------------ 2151 -- Connect_Slot -- 2152 ------------------ 2153 2154 procedure Connect_Slot 2155 (Object : access Gtk_Text_Buffer_Record'Class; 2156 C_Name : Glib.Signal_Name; 2157 Handler : Cb_GObject_Gtk_Clipboard_Void; 2158 After : Boolean; 2159 Slot : access Glib.Object.GObject_Record'Class := null) 2160 is 2161 begin 2162 Unchecked_Do_Signal_Connect 2163 (Object => Object, 2164 C_Name => C_Name, 2165 Marshaller => Marsh_GObject_Gtk_Clipboard_Void'Access, 2166 Handler => Cb_To_Address (Handler),-- Set in the closure 2167 Slot_Object => Slot, 2168 After => After); 2169 end Connect_Slot; 2170 2171 -------------------------------------- 2172 -- Marsh_GObject_Gtk_Clipboard_Void -- 2173 -------------------------------------- 2174 2175 procedure Marsh_GObject_Gtk_Clipboard_Void 2176 (Closure : GClosure; 2177 Return_Value : Glib.Values.GValue; 2178 N_Params : Glib.Guint; 2179 Params : Glib.Values.C_GValues; 2180 Invocation_Hint : System.Address; 2181 User_Data : System.Address) 2182 is 2183 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2184 H : constant Cb_GObject_Gtk_Clipboard_Void := Address_To_Cb (Get_Callback (Closure)); 2185 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2186 begin 2187 H (Obj, Gtk.Clipboard.Gtk_Clipboard (Unchecked_To_Object (Params, 1))); 2188 exception when E : others => Process_Exception (E); 2189 end Marsh_GObject_Gtk_Clipboard_Void; 2190 2191 ------------------------------------------------- 2192 -- Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void -- 2193 ------------------------------------------------- 2194 2195 procedure Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void 2196 (Closure : GClosure; 2197 Return_Value : Glib.Values.GValue; 2198 N_Params : Glib.Guint; 2199 Params : Glib.Values.C_GValues; 2200 Invocation_Hint : System.Address; 2201 User_Data : System.Address) 2202 is 2203 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2204 H : constant Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void := Address_To_Cb (Get_Callback (Closure)); 2205 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2206 begin 2207 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gdk.Pixbuf.Gdk_Pixbuf (Unchecked_To_Object (Params, 2))); 2208 exception when E : others => Process_Exception (E); 2209 end Marsh_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void; 2210 2211 ------------------------------------------------------------ 2212 -- Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void -- 2213 ------------------------------------------------------------ 2214 2215 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void 2216 (Closure : GClosure; 2217 Return_Value : Glib.Values.GValue; 2218 N_Params : Glib.Guint; 2219 Params : Glib.Values.C_GValues; 2220 Invocation_Hint : System.Address; 2221 User_Data : System.Address) 2222 is 2223 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2224 H : constant Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void := Address_To_Cb (Get_Callback (Closure)); 2225 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2226 begin 2227 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor (Unchecked_To_Object (Params, 2))); 2228 exception when E : others => Process_Exception (E); 2229 end Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 2230 2231 ---------------------------------------------------- 2232 -- Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void -- 2233 ---------------------------------------------------- 2234 2235 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void 2236 (Closure : GClosure; 2237 Return_Value : Glib.Values.GValue; 2238 N_Params : Glib.Guint; 2239 Params : Glib.Values.C_GValues; 2240 Invocation_Hint : System.Address; 2241 User_Data : System.Address) 2242 is 2243 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2244 H : constant Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void := Address_To_Cb (Get_Callback (Closure)); 2245 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2246 begin 2247 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Unchecked_To_Gtk_Text_Iter (Params, 2)); 2248 exception when E : others => Process_Exception (E); 2249 end Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2250 2251 ---------------------------------------------------- 2252 -- Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void -- 2253 ---------------------------------------------------- 2254 2255 procedure Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void 2256 (Closure : GClosure; 2257 Return_Value : Glib.Values.GValue; 2258 N_Params : Glib.Guint; 2259 Params : Glib.Values.C_GValues; 2260 Invocation_Hint : System.Address; 2261 User_Data : System.Address) 2262 is 2263 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2264 H : constant Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void := Address_To_Cb (Get_Callback (Closure)); 2265 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2266 begin 2267 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gtk.Text_Mark.Gtk_Text_Mark (Unchecked_To_Object (Params, 2))); 2268 exception when E : others => Process_Exception (E); 2269 end Marsh_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void; 2270 2271 ------------------------------------------------------- 2272 -- Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void -- 2273 ------------------------------------------------------- 2274 2275 procedure Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void 2276 (Closure : GClosure; 2277 Return_Value : Glib.Values.GValue; 2278 N_Params : Glib.Guint; 2279 Params : Glib.Values.C_GValues; 2280 Invocation_Hint : System.Address; 2281 User_Data : System.Address) 2282 is 2283 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2284 H : constant Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void := Address_To_Cb (Get_Callback (Closure)); 2285 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2286 begin 2287 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Unchecked_To_UTF8_String (Params, 2), Unchecked_To_Gint (Params, 3)); 2288 exception when E : others => Process_Exception (E); 2289 end Marsh_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void; 2290 2291 -------------------------------------- 2292 -- Marsh_GObject_Gtk_Text_Mark_Void -- 2293 -------------------------------------- 2294 2295 procedure Marsh_GObject_Gtk_Text_Mark_Void 2296 (Closure : GClosure; 2297 Return_Value : Glib.Values.GValue; 2298 N_Params : Glib.Guint; 2299 Params : Glib.Values.C_GValues; 2300 Invocation_Hint : System.Address; 2301 User_Data : System.Address) 2302 is 2303 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2304 H : constant Cb_GObject_Gtk_Text_Mark_Void := Address_To_Cb (Get_Callback (Closure)); 2305 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2306 begin 2307 H (Obj, Gtk.Text_Mark.Gtk_Text_Mark (Unchecked_To_Object (Params, 1))); 2308 exception when E : others => Process_Exception (E); 2309 end Marsh_GObject_Gtk_Text_Mark_Void; 2310 2311 ----------------------------------------------------------------- 2312 -- Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void -- 2313 ----------------------------------------------------------------- 2314 2315 procedure Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void 2316 (Closure : GClosure; 2317 Return_Value : Glib.Values.GValue; 2318 N_Params : Glib.Guint; 2319 Params : Glib.Values.C_GValues; 2320 Invocation_Hint : System.Address; 2321 User_Data : System.Address) 2322 is 2323 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2324 H : constant Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void := Address_To_Cb (Get_Callback (Closure)); 2325 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2326 begin 2327 H (Obj, Gtk.Text_Tag.Gtk_Text_Tag (Unchecked_To_Object (Params, 1)), Unchecked_To_Gtk_Text_Iter (Params, 2), Unchecked_To_Gtk_Text_Iter (Params, 3)); 2328 exception when E : others => Process_Exception (E); 2329 end Marsh_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2330 2331 ------------------------ 2332 -- Marsh_GObject_Void -- 2333 ------------------------ 2334 2335 procedure Marsh_GObject_Void 2336 (Closure : GClosure; 2337 Return_Value : Glib.Values.GValue; 2338 N_Params : Glib.Guint; 2339 Params : Glib.Values.C_GValues; 2340 Invocation_Hint : System.Address; 2341 User_Data : System.Address) 2342 is 2343 pragma Unreferenced (Return_Value, N_Params, Params, Invocation_Hint, User_Data); 2344 H : constant Cb_GObject_Void := Address_To_Cb (Get_Callback (Closure)); 2345 Obj : constant Glib.Object.GObject := Glib.Object.Convert (Get_Data (Closure)); 2346 begin 2347 H (Obj); 2348 exception when E : others => Process_Exception (E); 2349 end Marsh_GObject_Void; 2350 2351 ---------------------------------------------- 2352 -- Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void -- 2353 ---------------------------------------------- 2354 2355 procedure Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void 2356 (Closure : GClosure; 2357 Return_Value : Glib.Values.GValue; 2358 N_Params : Glib.Guint; 2359 Params : Glib.Values.C_GValues; 2360 Invocation_Hint : System.Address; 2361 User_Data : System.Address) 2362 is 2363 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2364 H : constant Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void := Address_To_Cb (Get_Callback (Closure)); 2365 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2366 begin 2367 H (Obj, Gtk.Clipboard.Gtk_Clipboard (Unchecked_To_Object (Params, 1))); 2368 exception when E : others => Process_Exception (E); 2369 end Marsh_Gtk_Text_Buffer_Gtk_Clipboard_Void; 2370 2371 --------------------------------------------------------- 2372 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void -- 2373 --------------------------------------------------------- 2374 2375 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void 2376 (Closure : GClosure; 2377 Return_Value : Glib.Values.GValue; 2378 N_Params : Glib.Guint; 2379 Params : Glib.Values.C_GValues; 2380 Invocation_Hint : System.Address; 2381 User_Data : System.Address) 2382 is 2383 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2384 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void := Address_To_Cb (Get_Callback (Closure)); 2385 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2386 begin 2387 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gdk.Pixbuf.Gdk_Pixbuf (Unchecked_To_Object (Params, 2))); 2388 exception when E : others => Process_Exception (E); 2389 end Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void; 2390 2391 -------------------------------------------------------------------- 2392 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void -- 2393 -------------------------------------------------------------------- 2394 2395 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void 2396 (Closure : GClosure; 2397 Return_Value : Glib.Values.GValue; 2398 N_Params : Glib.Guint; 2399 Params : Glib.Values.C_GValues; 2400 Invocation_Hint : System.Address; 2401 User_Data : System.Address) 2402 is 2403 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2404 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void := Address_To_Cb (Get_Callback (Closure)); 2405 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2406 begin 2407 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor (Unchecked_To_Object (Params, 2))); 2408 exception when E : others => Process_Exception (E); 2409 end Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 2410 2411 ------------------------------------------------------------ 2412 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void -- 2413 ------------------------------------------------------------ 2414 2415 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void 2416 (Closure : GClosure; 2417 Return_Value : Glib.Values.GValue; 2418 N_Params : Glib.Guint; 2419 Params : Glib.Values.C_GValues; 2420 Invocation_Hint : System.Address; 2421 User_Data : System.Address) 2422 is 2423 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2424 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void := Address_To_Cb (Get_Callback (Closure)); 2425 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2426 begin 2427 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Unchecked_To_Gtk_Text_Iter (Params, 2)); 2428 exception when E : others => Process_Exception (E); 2429 end Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2430 2431 ------------------------------------------------------------ 2432 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void -- 2433 ------------------------------------------------------------ 2434 2435 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void 2436 (Closure : GClosure; 2437 Return_Value : Glib.Values.GValue; 2438 N_Params : Glib.Guint; 2439 Params : Glib.Values.C_GValues; 2440 Invocation_Hint : System.Address; 2441 User_Data : System.Address) 2442 is 2443 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2444 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void := Address_To_Cb (Get_Callback (Closure)); 2445 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2446 begin 2447 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Gtk.Text_Mark.Gtk_Text_Mark (Unchecked_To_Object (Params, 2))); 2448 exception when E : others => Process_Exception (E); 2449 end Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void; 2450 2451 --------------------------------------------------------------- 2452 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void -- 2453 --------------------------------------------------------------- 2454 2455 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void 2456 (Closure : GClosure; 2457 Return_Value : Glib.Values.GValue; 2458 N_Params : Glib.Guint; 2459 Params : Glib.Values.C_GValues; 2460 Invocation_Hint : System.Address; 2461 User_Data : System.Address) 2462 is 2463 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2464 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void := Address_To_Cb (Get_Callback (Closure)); 2465 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2466 begin 2467 H (Obj, Unchecked_To_Gtk_Text_Iter (Params, 1), Unchecked_To_UTF8_String (Params, 2), Unchecked_To_Gint (Params, 3)); 2468 exception when E : others => Process_Exception (E); 2469 end Marsh_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void; 2470 2471 ---------------------------------------------- 2472 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void -- 2473 ---------------------------------------------- 2474 2475 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void 2476 (Closure : GClosure; 2477 Return_Value : Glib.Values.GValue; 2478 N_Params : Glib.Guint; 2479 Params : Glib.Values.C_GValues; 2480 Invocation_Hint : System.Address; 2481 User_Data : System.Address) 2482 is 2483 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2484 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void := Address_To_Cb (Get_Callback (Closure)); 2485 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2486 begin 2487 H (Obj, Gtk.Text_Mark.Gtk_Text_Mark (Unchecked_To_Object (Params, 1))); 2488 exception when E : others => Process_Exception (E); 2489 end Marsh_Gtk_Text_Buffer_Gtk_Text_Mark_Void; 2490 2491 ------------------------------------------------------------------------- 2492 -- Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void -- 2493 ------------------------------------------------------------------------- 2494 2495 procedure Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void 2496 (Closure : GClosure; 2497 Return_Value : Glib.Values.GValue; 2498 N_Params : Glib.Guint; 2499 Params : Glib.Values.C_GValues; 2500 Invocation_Hint : System.Address; 2501 User_Data : System.Address) 2502 is 2503 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2504 H : constant Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void := Address_To_Cb (Get_Callback (Closure)); 2505 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2506 begin 2507 H (Obj, Gtk.Text_Tag.Gtk_Text_Tag (Unchecked_To_Object (Params, 1)), Unchecked_To_Gtk_Text_Iter (Params, 2), Unchecked_To_Gtk_Text_Iter (Params, 3)); 2508 exception when E : others => Process_Exception (E); 2509 end Marsh_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2510 2511 -------------------------------- 2512 -- Marsh_Gtk_Text_Buffer_Void -- 2513 -------------------------------- 2514 2515 procedure Marsh_Gtk_Text_Buffer_Void 2516 (Closure : GClosure; 2517 Return_Value : Glib.Values.GValue; 2518 N_Params : Glib.Guint; 2519 Params : Glib.Values.C_GValues; 2520 Invocation_Hint : System.Address; 2521 User_Data : System.Address) 2522 is 2523 pragma Unreferenced (Return_Value, N_Params, Invocation_Hint, User_Data); 2524 H : constant Cb_Gtk_Text_Buffer_Void := Address_To_Cb (Get_Callback (Closure)); 2525 Obj : constant Gtk_Text_Buffer := Gtk_Text_Buffer (Unchecked_To_Object (Params, 0)); 2526 begin 2527 H (Obj); 2528 exception when E : others => Process_Exception (E); 2529 end Marsh_Gtk_Text_Buffer_Void; 2530 2531 ------------------ 2532 -- On_Apply_Tag -- 2533 ------------------ 2534 2535 procedure On_Apply_Tag 2536 (Self : not null access Gtk_Text_Buffer_Record; 2537 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2538 After : Boolean := False) 2539 is 2540 begin 2541 Connect (Self, "apply-tag" & ASCII.NUL, Call, After); 2542 end On_Apply_Tag; 2543 2544 ------------------ 2545 -- On_Apply_Tag -- 2546 ------------------ 2547 2548 procedure On_Apply_Tag 2549 (Self : not null access Gtk_Text_Buffer_Record; 2550 Call : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2551 Slot : not null access Glib.Object.GObject_Record'Class; 2552 After : Boolean := False) 2553 is 2554 begin 2555 Connect_Slot (Self, "apply-tag" & ASCII.NUL, Call, After, Slot); 2556 end On_Apply_Tag; 2557 2558 -------------------------- 2559 -- On_Begin_User_Action -- 2560 -------------------------- 2561 2562 procedure On_Begin_User_Action 2563 (Self : not null access Gtk_Text_Buffer_Record; 2564 Call : Cb_Gtk_Text_Buffer_Void; 2565 After : Boolean := False) 2566 is 2567 begin 2568 Connect (Self, "begin-user-action" & ASCII.NUL, Call, After); 2569 end On_Begin_User_Action; 2570 2571 -------------------------- 2572 -- On_Begin_User_Action -- 2573 -------------------------- 2574 2575 procedure On_Begin_User_Action 2576 (Self : not null access Gtk_Text_Buffer_Record; 2577 Call : Cb_GObject_Void; 2578 Slot : not null access Glib.Object.GObject_Record'Class; 2579 After : Boolean := False) 2580 is 2581 begin 2582 Connect_Slot (Self, "begin-user-action" & ASCII.NUL, Call, After, Slot); 2583 end On_Begin_User_Action; 2584 2585 ---------------- 2586 -- On_Changed -- 2587 ---------------- 2588 2589 procedure On_Changed 2590 (Self : not null access Gtk_Text_Buffer_Record; 2591 Call : Cb_Gtk_Text_Buffer_Void; 2592 After : Boolean := False) 2593 is 2594 begin 2595 Connect (Self, "changed" & ASCII.NUL, Call, After); 2596 end On_Changed; 2597 2598 ---------------- 2599 -- On_Changed -- 2600 ---------------- 2601 2602 procedure On_Changed 2603 (Self : not null access Gtk_Text_Buffer_Record; 2604 Call : Cb_GObject_Void; 2605 Slot : not null access Glib.Object.GObject_Record'Class; 2606 After : Boolean := False) 2607 is 2608 begin 2609 Connect_Slot (Self, "changed" & ASCII.NUL, Call, After, Slot); 2610 end On_Changed; 2611 2612 --------------------- 2613 -- On_Delete_Range -- 2614 --------------------- 2615 2616 procedure On_Delete_Range 2617 (Self : not null access Gtk_Text_Buffer_Record; 2618 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2619 After : Boolean := False) 2620 is 2621 begin 2622 Connect (Self, "delete-range" & ASCII.NUL, Call, After); 2623 end On_Delete_Range; 2624 2625 --------------------- 2626 -- On_Delete_Range -- 2627 --------------------- 2628 2629 procedure On_Delete_Range 2630 (Self : not null access Gtk_Text_Buffer_Record; 2631 Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2632 Slot : not null access Glib.Object.GObject_Record'Class; 2633 After : Boolean := False) 2634 is 2635 begin 2636 Connect_Slot (Self, "delete-range" & ASCII.NUL, Call, After, Slot); 2637 end On_Delete_Range; 2638 2639 ------------------------ 2640 -- On_End_User_Action -- 2641 ------------------------ 2642 2643 procedure On_End_User_Action 2644 (Self : not null access Gtk_Text_Buffer_Record; 2645 Call : Cb_Gtk_Text_Buffer_Void; 2646 After : Boolean := False) 2647 is 2648 begin 2649 Connect (Self, "end-user-action" & ASCII.NUL, Call, After); 2650 end On_End_User_Action; 2651 2652 ------------------------ 2653 -- On_End_User_Action -- 2654 ------------------------ 2655 2656 procedure On_End_User_Action 2657 (Self : not null access Gtk_Text_Buffer_Record; 2658 Call : Cb_GObject_Void; 2659 Slot : not null access Glib.Object.GObject_Record'Class; 2660 After : Boolean := False) 2661 is 2662 begin 2663 Connect_Slot (Self, "end-user-action" & ASCII.NUL, Call, After, Slot); 2664 end On_End_User_Action; 2665 2666 ---------------------------- 2667 -- On_Insert_Child_Anchor -- 2668 ---------------------------- 2669 2670 procedure On_Insert_Child_Anchor 2671 (Self : not null access Gtk_Text_Buffer_Record; 2672 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 2673 After : Boolean := False) 2674 is 2675 begin 2676 Connect (Self, "insert-child-anchor" & ASCII.NUL, Call, After); 2677 end On_Insert_Child_Anchor; 2678 2679 ---------------------------- 2680 -- On_Insert_Child_Anchor -- 2681 ---------------------------- 2682 2683 procedure On_Insert_Child_Anchor 2684 (Self : not null access Gtk_Text_Buffer_Record; 2685 Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void; 2686 Slot : not null access Glib.Object.GObject_Record'Class; 2687 After : Boolean := False) 2688 is 2689 begin 2690 Connect_Slot (Self, "insert-child-anchor" & ASCII.NUL, Call, After, Slot); 2691 end On_Insert_Child_Anchor; 2692 2693 ---------------------- 2694 -- On_Insert_Pixbuf -- 2695 ---------------------- 2696 2697 procedure On_Insert_Pixbuf 2698 (Self : not null access Gtk_Text_Buffer_Record; 2699 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void; 2700 After : Boolean := False) 2701 is 2702 begin 2703 Connect (Self, "insert-pixbuf" & ASCII.NUL, Call, After); 2704 end On_Insert_Pixbuf; 2705 2706 ---------------------- 2707 -- On_Insert_Pixbuf -- 2708 ---------------------- 2709 2710 procedure On_Insert_Pixbuf 2711 (Self : not null access Gtk_Text_Buffer_Record; 2712 Call : Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void; 2713 Slot : not null access Glib.Object.GObject_Record'Class; 2714 After : Boolean := False) 2715 is 2716 begin 2717 Connect_Slot (Self, "insert-pixbuf" & ASCII.NUL, Call, After, Slot); 2718 end On_Insert_Pixbuf; 2719 2720 -------------------- 2721 -- On_Insert_Text -- 2722 -------------------- 2723 2724 procedure On_Insert_Text 2725 (Self : not null access Gtk_Text_Buffer_Record; 2726 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void; 2727 After : Boolean := False) 2728 is 2729 begin 2730 Connect (Self, "insert-text" & ASCII.NUL, Call, After); 2731 end On_Insert_Text; 2732 2733 -------------------- 2734 -- On_Insert_Text -- 2735 -------------------- 2736 2737 procedure On_Insert_Text 2738 (Self : not null access Gtk_Text_Buffer_Record; 2739 Call : Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void; 2740 Slot : not null access Glib.Object.GObject_Record'Class; 2741 After : Boolean := False) 2742 is 2743 begin 2744 Connect_Slot (Self, "insert-text" & ASCII.NUL, Call, After, Slot); 2745 end On_Insert_Text; 2746 2747 --------------------- 2748 -- On_Mark_Deleted -- 2749 --------------------- 2750 2751 procedure On_Mark_Deleted 2752 (Self : not null access Gtk_Text_Buffer_Record; 2753 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void; 2754 After : Boolean := False) 2755 is 2756 begin 2757 Connect (Self, "mark-deleted" & ASCII.NUL, Call, After); 2758 end On_Mark_Deleted; 2759 2760 --------------------- 2761 -- On_Mark_Deleted -- 2762 --------------------- 2763 2764 procedure On_Mark_Deleted 2765 (Self : not null access Gtk_Text_Buffer_Record; 2766 Call : Cb_GObject_Gtk_Text_Mark_Void; 2767 Slot : not null access Glib.Object.GObject_Record'Class; 2768 After : Boolean := False) 2769 is 2770 begin 2771 Connect_Slot (Self, "mark-deleted" & ASCII.NUL, Call, After, Slot); 2772 end On_Mark_Deleted; 2773 2774 ----------------- 2775 -- On_Mark_Set -- 2776 ----------------- 2777 2778 procedure On_Mark_Set 2779 (Self : not null access Gtk_Text_Buffer_Record; 2780 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void; 2781 After : Boolean := False) 2782 is 2783 begin 2784 Connect (Self, "mark-set" & ASCII.NUL, Call, After); 2785 end On_Mark_Set; 2786 2787 ----------------- 2788 -- On_Mark_Set -- 2789 ----------------- 2790 2791 procedure On_Mark_Set 2792 (Self : not null access Gtk_Text_Buffer_Record; 2793 Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void; 2794 Slot : not null access Glib.Object.GObject_Record'Class; 2795 After : Boolean := False) 2796 is 2797 begin 2798 Connect_Slot (Self, "mark-set" & ASCII.NUL, Call, After, Slot); 2799 end On_Mark_Set; 2800 2801 ------------------------- 2802 -- On_Modified_Changed -- 2803 ------------------------- 2804 2805 procedure On_Modified_Changed 2806 (Self : not null access Gtk_Text_Buffer_Record; 2807 Call : Cb_Gtk_Text_Buffer_Void; 2808 After : Boolean := False) 2809 is 2810 begin 2811 Connect (Self, "modified-changed" & ASCII.NUL, Call, After); 2812 end On_Modified_Changed; 2813 2814 ------------------------- 2815 -- On_Modified_Changed -- 2816 ------------------------- 2817 2818 procedure On_Modified_Changed 2819 (Self : not null access Gtk_Text_Buffer_Record; 2820 Call : Cb_GObject_Void; 2821 Slot : not null access Glib.Object.GObject_Record'Class; 2822 After : Boolean := False) 2823 is 2824 begin 2825 Connect_Slot (Self, "modified-changed" & ASCII.NUL, Call, After, Slot); 2826 end On_Modified_Changed; 2827 2828 ------------------- 2829 -- On_Paste_Done -- 2830 ------------------- 2831 2832 procedure On_Paste_Done 2833 (Self : not null access Gtk_Text_Buffer_Record; 2834 Call : Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void; 2835 After : Boolean := False) 2836 is 2837 begin 2838 Connect (Self, "paste-done" & ASCII.NUL, Call, After); 2839 end On_Paste_Done; 2840 2841 ------------------- 2842 -- On_Paste_Done -- 2843 ------------------- 2844 2845 procedure On_Paste_Done 2846 (Self : not null access Gtk_Text_Buffer_Record; 2847 Call : Cb_GObject_Gtk_Clipboard_Void; 2848 Slot : not null access Glib.Object.GObject_Record'Class; 2849 After : Boolean := False) 2850 is 2851 begin 2852 Connect_Slot (Self, "paste-done" & ASCII.NUL, Call, After, Slot); 2853 end On_Paste_Done; 2854 2855 ------------------- 2856 -- On_Remove_Tag -- 2857 ------------------- 2858 2859 procedure On_Remove_Tag 2860 (Self : not null access Gtk_Text_Buffer_Record; 2861 Call : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2862 After : Boolean := False) 2863 is 2864 begin 2865 Connect (Self, "remove-tag" & ASCII.NUL, Call, After); 2866 end On_Remove_Tag; 2867 2868 ------------------- 2869 -- On_Remove_Tag -- 2870 ------------------- 2871 2872 procedure On_Remove_Tag 2873 (Self : not null access Gtk_Text_Buffer_Record; 2874 Call : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void; 2875 Slot : not null access Glib.Object.GObject_Record'Class; 2876 After : Boolean := False) 2877 is 2878 begin 2879 Connect_Slot (Self, "remove-tag" & ASCII.NUL, Call, After, Slot); 2880 end On_Remove_Tag; 2881 2882end Gtk.Text_Buffer; 2883