1 // Generated by gmmproc 2.60.0 -- DO NOT MODIFY! 2 #ifndef _GTKMM_TEXTVIEW_H 3 #define _GTKMM_TEXTVIEW_H 4 5 #include <gtkmmconfig.h> 6 7 8 #include <glibmm/ustring.h> 9 #include <sigc++/sigc++.h> 10 11 /* Copyright(C) 2002 The gtkmm Development Team 12 * 13 * This library is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU Lesser General Public 15 * License as published by the Free Software Foundation; either 16 * version 2.1 of the License, or(at your option) any later version. 17 * 18 * This library is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * Lesser General Public License for more details. 22 * 23 * You should have received a copy of the GNU Lesser General Public 24 * License along with this library; if not, write to the Free Software 25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 26 */ 27 28 // This is for including the config header before any code (such as 29 // the #ifndef GTKMM_DISABLE_DEPRECATED in deprecated classes) is generated: 30 31 32 #include <gtkmm/container.h> 33 #include <gtkmm/scrollable.h> 34 #include <gtkmm/textbuffer.h> 35 #include <gtkmm/textmark.h> 36 #include <gtkmm/menu.h> 37 38 39 #ifndef DOXYGEN_SHOULD_SKIP_THIS 40 using GtkTextView = struct _GtkTextView; 41 using GtkTextViewClass = struct _GtkTextViewClass; 42 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 43 44 45 #ifndef DOXYGEN_SHOULD_SKIP_THIS 46 namespace Gtk 47 { class TextView_Class; } // namespace Gtk 48 #endif //DOXYGEN_SHOULD_SKIP_THIS 49 50 namespace Gtk 51 { 52 53 54 /** @addtogroup gtkmmEnums gtkmm Enums and Flags */ 55 56 /** 57 * @var TextWindowType TEXT_WINDOW_PRIVATE 58 * Invalid value, used as a marker. 59 * 60 * @var TextWindowType TEXT_WINDOW_WIDGET 61 * Window that floats over scrolling areas. 62 * 63 * @var TextWindowType TEXT_WINDOW_TEXT 64 * Scrollable text window. 65 * 66 * @var TextWindowType TEXT_WINDOW_LEFT 67 * Left side border window. 68 * 69 * @var TextWindowType TEXT_WINDOW_RIGHT 70 * Right side border window. 71 * 72 * @var TextWindowType TEXT_WINDOW_TOP 73 * Top border window. 74 * 75 * @var TextWindowType TEXT_WINDOW_BOTTOM 76 * Bottom border window. 77 * 78 * @enum TextWindowType 79 * 80 * Used to reference the parts of Gtk::TextView. 81 * 82 * @ingroup gtkmmEnums 83 */ 84 enum TextWindowType 85 { 86 TEXT_WINDOW_PRIVATE, 87 TEXT_WINDOW_WIDGET, 88 TEXT_WINDOW_TEXT, 89 TEXT_WINDOW_LEFT, 90 TEXT_WINDOW_RIGHT, 91 TEXT_WINDOW_TOP, 92 TEXT_WINDOW_BOTTOM 93 }; 94 95 } // namespace Gtk 96 97 #ifndef DOXYGEN_SHOULD_SKIP_THIS 98 namespace Glib 99 { 100 101 template <> 102 class Value<Gtk::TextWindowType> : public Glib::Value_Enum<Gtk::TextWindowType> 103 { 104 public: 105 static GType value_type() G_GNUC_CONST; 106 }; 107 108 } // namespace Glib 109 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 110 111 namespace Gtk 112 { 113 114 115 /** @defgroup TextView TextView Classes 116 * These classes are used with the Gtk::TextView widget. 117 */ 118 119 /** Multi-line text editing widget. It displays a Gtk::TextBuffer. 120 * 121 * The TextView widget looks like this: 122 * @image html textview1.png 123 * 124 * @ingroup Widgets 125 * @ingroup Containers 126 * @ingroup TextView 127 */ 128 129 class TextView 130 : public Container, 131 public Scrollable 132 { 133 public: 134 #ifndef DOXYGEN_SHOULD_SKIP_THIS 135 typedef TextView CppObjectType; 136 typedef TextView_Class CppClassType; 137 typedef GtkTextView BaseObjectType; 138 typedef GtkTextViewClass BaseClassType; 139 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 140 141 TextView(TextView&& src) noexcept; 142 TextView& operator=(TextView&& src) noexcept; 143 144 // noncopyable 145 TextView(const TextView&) = delete; 146 TextView& operator=(const TextView&) = delete; 147 148 ~TextView() noexcept override; 149 150 #ifndef DOXYGEN_SHOULD_SKIP_THIS 151 152 private: 153 friend class TextView_Class; 154 static CppClassType textview_class_; 155 156 protected: 157 explicit TextView(const Glib::ConstructParams& construct_params); 158 explicit TextView(GtkTextView* castitem); 159 160 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 161 162 public: 163 164 /** Get the GType for this class, for use with the underlying GObject type system. 165 */ 166 static GType get_type() G_GNUC_CONST; 167 168 #ifndef DOXYGEN_SHOULD_SKIP_THIS 169 170 171 static GType get_base_type() G_GNUC_CONST; 172 #endif 173 174 /// Provides access to the underlying C GObject. gobj()175 GtkTextView* gobj() { return reinterpret_cast<GtkTextView*>(gobject_); } 176 177 /// Provides access to the underlying C GObject. gobj()178 const GtkTextView* gobj() const { return reinterpret_cast<GtkTextView*>(gobject_); } 179 180 181 public: 182 //C++ methods used to invoke GTK+ virtual functions: 183 184 protected: 185 //GTK+ Virtual Functions (override these to change behaviour): 186 187 //Default Signal Handlers:: 188 /// This is a default handler for the signal signal_populate_popup(). 189 virtual void on_populate_popup(Menu* menu); 190 /// This is a default handler for the signal signal_set_anchor(). 191 virtual void on_set_anchor(); 192 /// This is a default handler for the signal signal_insert_at_cursor(). 193 virtual void on_insert_at_cursor(const Glib::ustring& str); 194 195 196 private: 197 198 199 public: 200 TextView(); 201 explicit TextView(const Glib::RefPtr<TextBuffer>& buffer); 202 203 204 /** Sets @a buffer as the buffer being displayed by @a text_view. The previous 205 * buffer displayed by the text view is unreferenced, and a reference is 206 * added to @a buffer. If you owned a reference to @a buffer before passing it 207 * to this function, you must remove that reference yourself; Gtk::TextView 208 * will not “adopt” it. 209 * 210 * @param buffer A Gtk::TextBuffer. 211 */ 212 void set_buffer(const Glib::RefPtr<TextBuffer>& buffer); 213 214 /** Returns the Gtk::TextBuffer being displayed by this text view. 215 * The reference count on the buffer is not incremented; the caller 216 * of this function won’t own a new reference. 217 * 218 * @return A Gtk::TextBuffer. 219 */ 220 Glib::RefPtr<TextBuffer> get_buffer(); 221 222 /** Returns the Gtk::TextBuffer being displayed by this text view. 223 * The reference count on the buffer is not incremented; the caller 224 * of this function won’t own a new reference. 225 * 226 * @return A Gtk::TextBuffer. 227 */ 228 Glib::RefPtr<const TextBuffer> get_buffer() const; 229 230 /** Scrolls the TextView so that @a iter is on the screen, by scrolling the minimal distance to get the mark onscreen, 231 * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size 232 * @a within_margin. 233 * @note This function uses the currently-computed height of the lines in the text buffer. Note that line heights are computed 234 * in an idle handler; so this function may not have the desired effect if it's called before the height computations. To avoid 235 * oddness, consider using gtk_text_view_scroll_to_mark() which saves a point to be scrolled to after line validation. 236 * 237 * @param iter An iterator pointing to the position that should be made visible by scrolling. 238 * @param within_margin margin as a [0.0,0.5] fraction of screen size. 239 * @result true if scrolling occurred. 240 */ 241 bool scroll_to(TextBuffer::iterator& iter, double within_margin = 0); 242 243 /** Scrolls the TextView so that @a iter is on the screen, in the position indicated by xalign and yalign, 244 * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size 245 * @a within_margin. 246 * @note This function uses the currently-computed height of the lines in the text buffer. Note that line heights are computed 247 * in an idle handler; so this function may not have the desired effect if it's called before the height computations. To avoid 248 * oddness, consider using gtk_text_view_scroll_to_mark() which saves a point to be scrolled to after line validation. 249 * 250 * @param iter An iterator pointing to the position that should be made visible by scrolling. 251 * @param within_margin margin as a [0.0,0.5] fraction of screen size. 252 * @param xalign horizontal alignment of mark within visible area. An alignment of 0.0 indicates left, 1.0 indicates right, 0.5 means center. 253 * @param yalign vertical alignment of mark within visible area. An alignment of 0.0 indicates top, 1.0 indicates bottom, 0.5 means center. 254 * @result true if scrolling occurred. 255 */ 256 bool scroll_to(TextBuffer::iterator& iter, double within_margin, double xalign, double yalign); 257 258 259 /** Scrolls text_view so that @a mark is on the screen, by scrolling the minimal distance to get the mark onscreen, 260 * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size 261 * @a within_margin. 262 * 263 * @param mark An mark pointing to the position that should be made visible by scrolling. 264 * @param within_margin margin as a [0.0,0.5] fraction of screen size. 265 */ 266 void scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin = 0); 267 268 /** Scrolls the TextView so that @a iter is on the screen, in the position indicated by xalign and yalign, 269 * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size 270 * @a within_margin. 271 * 272 * @param mark An mark pointing to the position that should be made visible by scrolling. 273 * @param within_margin margin as a [0.0,0.5] fraction of screen size. 274 * @param xalign horizontal alignment of mark within visible area. An alignment of 0.0 indicates left, 1.0 indicates right, 0.5 means center. 275 * @param yalign vertical alignment of mark within visible area. An alignment of 0.0 indicates top, 1.0 indicates bottom, 0.5 means center. 276 */ 277 void scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin, double xalign, double yalign); 278 279 280 //It does not do anything more than the default scroll_to(mark). 281 282 283 /** Moves a mark within the buffer so that it's 284 * located within the currently-visible text area. 285 * 286 * @param mark A Gtk::TextMark. 287 * @return <tt>true</tt> if the mark moved (wasn’t already onscreen). 288 */ 289 bool move_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark); 290 291 /** Moves the cursor to the currently visible region of the 292 * buffer, it it isn’t there already. 293 * 294 * @return <tt>true</tt> if the cursor had to be moved. 295 */ 296 bool place_cursor_onscreen(); 297 298 299 /** Fills @a visible_rect with the currently-visible 300 * region of the buffer, in buffer coordinates. Convert to window coordinates 301 * with buffer_to_window_coords(). 302 * 303 * @param visible_rect Rectangle to fill. 304 */ 305 void get_visible_rect(Gdk::Rectangle& visible_rect) const; 306 307 /** Toggles whether the insertion point should be displayed. A buffer with 308 * no editable text probably shouldn’t have a visible cursor, so you may 309 * want to turn the cursor off. 310 * 311 * Note that this property may be overridden by the 312 * Gtk::Settings::property_gtk_keynave_use_caret() settings. 313 * 314 * @param setting Whether to show the insertion cursor. 315 */ 316 void set_cursor_visible(bool setting = true); 317 318 /** Find out whether the cursor should be displayed. 319 * 320 * @return Whether the insertion mark is visible. 321 */ 322 bool get_cursor_visible() const; 323 324 /** Ensures that the cursor is shown (i.e.\ not in an 'off' blink 325 * interval) and resets the time that it will stay blinking (or 326 * visible, in case blinking is disabled). 327 * 328 * This function should be called in response to user input 329 * (e.g. from derived classes that override the textview's 330 * Gtk::Widget::signal_key_press_event() handler). 331 * 332 * @newin{3,20} 333 */ 334 void reset_cursor_blink(); 335 336 337 /** Given an @a iter within a text layout, determine the positions of the 338 * strong and weak cursors if the insertion point is at that 339 * iterator. The position of each cursor is stored as a zero-width 340 * rectangle. The strong cursor location is the location where 341 * characters of the directionality equal to the base direction of the 342 * paragraph are inserted. The weak cursor location is the location 343 * where characters of the directionality opposite to the base 344 * direction of the paragraph are inserted. 345 * 346 * If @a iter is <tt>nullptr</tt>, the actual cursor position is used. 347 * 348 * Note that if @a iter happens to be the actual cursor position, and 349 * there is currently an IM preedit sequence being entered, the 350 * returned locations will be adjusted to account for the preedit 351 * cursor’s offset within the preedit sequence. 352 * 353 * The rectangle position is in buffer coordinates; use 354 * buffer_to_window_coords() to convert these 355 * coordinates to coordinates for one of the windows in the text view. 356 * 357 * @newin{3,0} 358 * 359 * @param iter A Gtk::TextIter. 360 * @param strong Location to store the strong 361 * cursor position (may be <tt>nullptr</tt>). 362 * @param weak Location to store the weak 363 * cursor position (may be <tt>nullptr</tt>). 364 */ 365 void get_cursor_locations(const TextBuffer::iterator& iter, Gdk::Rectangle& strong, Gdk::Rectangle& weak) const; 366 367 368 /** Gets a rectangle which roughly contains the character at @a iter. 369 * The rectangle position is in buffer coordinates; use 370 * buffer_to_window_coords() to convert these 371 * coordinates to coordinates for one of the windows in the text view. 372 * 373 * @param iter A Gtk::TextIter. 374 * @param location Bounds of the character at @a iter. 375 */ 376 void get_iter_location(const TextBuffer::iterator& iter, Gdk::Rectangle& location) const; 377 378 /** Retrieves the iterator at buffer coordinates @a x and @a y. Buffer 379 * coordinates are coordinates for the entire buffer, not just the 380 * currently-displayed portion. If you have coordinates from an 381 * event, you have to convert those to buffer coordinates with 382 * window_to_buffer_coords(). 383 * 384 * @param iter A Gtk::TextIter. 385 * @param x X position, in buffer coordinates. 386 * @param y Y position, in buffer coordinates. 387 */ 388 void get_iter_at_location(TextBuffer::iterator& iter, int x, int y) const; 389 390 /** Retrieves the iterator pointing to the character at buffer 391 * coordinates @a x and @a y. Buffer coordinates are coordinates for 392 * the entire buffer, not just the currently-displayed portion. 393 * If you have coordinates from an event, you have to convert 394 * those to buffer coordinates with 395 * window_to_buffer_coords(). 396 * 397 * Note that this is different from get_iter_at_location(), 398 * which returns cursor locations, i.e. positions between 399 * characters. 400 * 401 * @newin{2,6} 402 * 403 * @param iter A Gtk::TextIter. 404 * @param trailing If non-<tt>nullptr</tt>, location to store an integer indicating where 405 * in the grapheme the user clicked. It will either be 406 * zero, or the number of characters in the grapheme. 407 * 0 represents the trailing edge of the grapheme. 408 * @param x X position, in buffer coordinates. 409 * @param y Y position, in buffer coordinates. 410 */ 411 void get_iter_at_position(TextBuffer::iterator& iter, int& trailing, int x, int y) const; 412 413 /** Gets the y coordinate of the top of the line containing @a iter, 414 * and the height of the line. The coordinate is a buffer coordinate; 415 * convert to window coordinates with buffer_to_window_coords(). 416 * 417 * @param iter A Gtk::TextIter. 418 * @param y Return location for a y coordinate. 419 * @param height Return location for a height. 420 */ 421 void get_line_yrange(const TextBuffer::iterator& iter, int& y, int& height) const; 422 423 424 /** Gets the Gtk::TextIter at the start of the line containing 425 * the coordinate @a y. @a y is in buffer coordinates, convert from 426 * window coordinates with window_to_buffer_coords(). 427 * If non-<tt>nullptr</tt>, @a line_top will be filled with the coordinate of the top 428 * edge of the line. 429 * 430 * @param target_iter A Gtk::TextIter. 431 * @param y A y coordinate. 432 * @param line_top Return location for top coordinate of the line. 433 */ 434 void get_line_at_y(TextBuffer::iterator& target_iter, int y, int& line_top) const; 435 436 437 /** Converts coordinate ( @a buffer_x, @a buffer_y) to coordinates for the window 438 * @a win, and stores the result in ( @a window_x, @a window_y). 439 * 440 * Note that you can’t convert coordinates for a nonexisting window (see 441 * set_border_window_size()). 442 * 443 * @param win A Gtk::TextWindowType, except Gtk::TEXT_WINDOW_PRIVATE. 444 * @param buffer_x Buffer x coordinate. 445 * @param buffer_y Buffer y coordinate. 446 * @param window_x Window x coordinate return location or <tt>nullptr</tt>. 447 * @param window_y Window y coordinate return location or <tt>nullptr</tt>. 448 */ 449 void buffer_to_window_coords(TextWindowType win, int buffer_x, int buffer_y, int& window_x, int& window_y) const; 450 451 /** Converts coordinates on the window identified by @a win to buffer 452 * coordinates, storing the result in ( @a buffer_x, @a buffer_y). 453 * 454 * Note that you can’t convert coordinates for a nonexisting window (see 455 * set_border_window_size()). 456 * 457 * @param win A Gtk::TextWindowType except Gtk::TEXT_WINDOW_PRIVATE. 458 * @param window_x Window x coordinate. 459 * @param window_y Window y coordinate. 460 * @param buffer_x Buffer x coordinate return location or <tt>nullptr</tt>. 461 * @param buffer_y Buffer y coordinate return location or <tt>nullptr</tt>. 462 */ 463 void window_to_buffer_coords(TextWindowType win, int window_x, int window_y, int& buffer_x, int& buffer_y) const; 464 465 //deprecated 466 467 468 /** Retrieves the Gdk::Window corresponding to an area of the text view; 469 * possible windows include the overall widget window, child windows 470 * on the left, right, top, bottom, and the window that displays the 471 * text buffer. Windows are <tt>nullptr</tt> and nonexistent if their width or 472 * height is 0, and are nonexistent before the widget has been 473 * realized. 474 * 475 * @param win Window to get. 476 * @return A Gdk::Window, or <tt>nullptr</tt>. 477 */ 478 Glib::RefPtr<Gdk::Window> get_window(TextWindowType win); 479 480 /** Retrieves the Gdk::Window corresponding to an area of the text view; 481 * possible windows include the overall widget window, child windows 482 * on the left, right, top, bottom, and the window that displays the 483 * text buffer. Windows are <tt>nullptr</tt> and nonexistent if their width or 484 * height is 0, and are nonexistent before the widget has been 485 * realized. 486 * 487 * @param win Window to get. 488 * @return A Gdk::Window, or <tt>nullptr</tt>. 489 */ 490 Glib::RefPtr<const Gdk::Window> get_window(TextWindowType win) const; 491 492 /** Usually used to find out which window an event corresponds to. 493 * 494 * If you connect to an event signal on @a text_view, this function 495 * should be called on `event->window` to see which window it was. 496 * 497 * @param window A window type. 498 * @return The window type. 499 */ 500 TextWindowType get_window_type(const Glib::RefPtr<Gdk::Window>& window); 501 502 503 /** Sets the width of Gtk::TEXT_WINDOW_LEFT or Gtk::TEXT_WINDOW_RIGHT, 504 * or the height of Gtk::TEXT_WINDOW_TOP or Gtk::TEXT_WINDOW_BOTTOM. 505 * Automatically destroys the corresponding window if the size is set 506 * to 0, and creates the window if the size is set to non-zero. This 507 * function can only be used for the “border windows”, and it won’t 508 * work with Gtk::TEXT_WINDOW_WIDGET, Gtk::TEXT_WINDOW_TEXT, or 509 * Gtk::TEXT_WINDOW_PRIVATE. 510 * 511 * @param type Window to affect. 512 * @param size Width or height of the window. 513 */ 514 void set_border_window_size(TextWindowType type, int size); 515 516 /** Gets the width of the specified border window. See 517 * set_border_window_size(). 518 * 519 * @param type Window to return size from. 520 * @return Width of window. 521 */ 522 int get_border_window_size(TextWindowType type) const; 523 524 525 /** Moves the given @a iter forward by one display (wrapped) line. 526 * A display line is different from a paragraph. Paragraphs are 527 * separated by newlines or other paragraph separator characters. 528 * Display lines are created by line-wrapping a paragraph. If 529 * wrapping is turned off, display lines and paragraphs will be the 530 * same. Display lines are divided differently for each view, since 531 * they depend on the view’s width; paragraphs are the same in all 532 * views, since they depend on the contents of the Gtk::TextBuffer. 533 * 534 * @param iter A Gtk::TextIter. 535 * @return <tt>true</tt> if @a iter was moved and is not on the end iterator. 536 */ 537 bool forward_display_line(TextBuffer::iterator& iter); 538 539 /** Moves the given @a iter backward by one display (wrapped) line. 540 * A display line is different from a paragraph. Paragraphs are 541 * separated by newlines or other paragraph separator characters. 542 * Display lines are created by line-wrapping a paragraph. If 543 * wrapping is turned off, display lines and paragraphs will be the 544 * same. Display lines are divided differently for each view, since 545 * they depend on the view’s width; paragraphs are the same in all 546 * views, since they depend on the contents of the Gtk::TextBuffer. 547 * 548 * @param iter A Gtk::TextIter. 549 * @return <tt>true</tt> if @a iter was moved and is not on the end iterator. 550 */ 551 bool backward_display_line(TextBuffer::iterator& iter); 552 553 /** Moves the given @a iter forward to the next display line end. 554 * A display line is different from a paragraph. Paragraphs are 555 * separated by newlines or other paragraph separator characters. 556 * Display lines are created by line-wrapping a paragraph. If 557 * wrapping is turned off, display lines and paragraphs will be the 558 * same. Display lines are divided differently for each view, since 559 * they depend on the view’s width; paragraphs are the same in all 560 * views, since they depend on the contents of the Gtk::TextBuffer. 561 * 562 * @param iter A Gtk::TextIter. 563 * @return <tt>true</tt> if @a iter was moved and is not on the end iterator. 564 */ 565 bool forward_display_line_end(TextBuffer::iterator& iter); 566 567 /** Moves the given @a iter backward to the next display line start. 568 * A display line is different from a paragraph. Paragraphs are 569 * separated by newlines or other paragraph separator characters. 570 * Display lines are created by line-wrapping a paragraph. If 571 * wrapping is turned off, display lines and paragraphs will be the 572 * same. Display lines are divided differently for each view, since 573 * they depend on the view’s width; paragraphs are the same in all 574 * views, since they depend on the contents of the Gtk::TextBuffer. 575 * 576 * @param iter A Gtk::TextIter. 577 * @return <tt>true</tt> if @a iter was moved and is not on the end iterator. 578 */ 579 bool backward_display_line_start(TextBuffer::iterator& iter); 580 581 /** Determines whether @a iter is at the start of a display line. 582 * See forward_display_line() for an explanation of 583 * display lines vs. paragraphs. 584 * 585 * @param iter A Gtk::TextIter. 586 * @return <tt>true</tt> if @a iter begins a wrapped line. 587 */ 588 bool starts_display_line(const TextBuffer::iterator& iter); 589 590 /** Move the iterator a given number of characters visually, treating 591 * it as the strong cursor position. If @a count is positive, then the 592 * new strong cursor position will be @a count positions to the right of 593 * the old cursor position. If @a count is negative then the new strong 594 * cursor position will be @a count positions to the left of the old 595 * cursor position. 596 * 597 * In the presence of bi-directional text, the correspondence 598 * between logical and visual order will depend on the direction 599 * of the current run, and there may be jumps when the cursor 600 * is moved off of the end of a run. 601 * 602 * @param iter A Gtk::TextIter. 603 * @param count Number of characters to move (negative moves left, 604 * positive moves right). 605 * @return <tt>true</tt> if @a iter moved and is not on the end iterator. 606 */ 607 bool move_visually(TextBuffer::iterator& iter, int count); 608 609 610 /** Allow the Gtk::TextView input method to internally handle key press 611 * and release events. If this function returns <tt>true</tt>, then no further 612 * processing should be done for this key event. See 613 * gtk_im_context_filter_keypress(). 614 * 615 * Note that you are expected to call this function from your handler 616 * when overriding key event handling. This is needed in the case when 617 * you need to insert your own key handling between the input method 618 * and the default key event handling of the Gtk::TextView. 619 * 620 * 621 * [C example ellipted] 622 * 623 * @newin{2,22} 624 * 625 * @param gdk_event The key event. 626 * @return <tt>true</tt> if the input method handled the key event. 627 */ 628 bool im_context_filter_keypress(GdkEventKey* gdk_event); 629 630 /** Reset the input method context of the text view if needed. 631 * 632 * This can be necessary in the case where modifying the buffer 633 * would confuse on-going input method behavior. 634 * 635 * @newin{2,22} 636 */ 637 void reset_im_context(); 638 639 640 /** Adds a child widget in the text buffer, at the given @a anchor. 641 * 642 * @param child A Gtk::Widget. 643 * @param anchor A Gtk::TextChildAnchor in the Gtk::TextBuffer for @a text_view. 644 */ 645 void add_child_at_anchor(Widget& child, const Glib::RefPtr<TextBuffer::ChildAnchor>& anchor); 646 647 648 /** Adds a child at fixed coordinates in one of the text widget's 649 * windows. 650 * 651 * The window must have nonzero size (see 652 * set_border_window_size()). Note that the child 653 * coordinates are given relative to scrolling. When 654 * placing a child in Gtk::TEXT_WINDOW_WIDGET, scrolling is 655 * irrelevant, the child floats above all scrollable areas. But when 656 * placing a child in one of the scrollable windows (border windows or 657 * text window) it will move with the scrolling as needed. 658 * 659 * @param child A Gtk::Widget. 660 * @param which_window Which window the child should appear in. 661 * @param xpos X position of child in window coordinates. 662 * @param ypos Y position of child in window coordinates. 663 */ 664 void add_child_in_window(Widget& child, TextWindowType which_window, int xpos, int ypos); 665 666 667 /** Updates the position of a child, as for add_child_in_window(). 668 * 669 * @param child Child widget already added to the text view. 670 * @param xpos New X position in window coordinates. 671 * @param ypos New Y position in window coordinates. 672 */ 673 void move_child(Widget& child, int xpos, int ypos); 674 675 676 /** Sets the line wrapping for the view. 677 * 678 * @param wrap_mode A Gtk::WrapMode. 679 */ 680 void set_wrap_mode(WrapMode wrap_mode); 681 682 /** Gets the line wrapping for the view. 683 * 684 * @return The line wrap setting. 685 */ 686 WrapMode get_wrap_mode() const; 687 688 /** Sets the default editability of the Gtk::TextView. You can override 689 * this default setting with tags in the buffer, using the “editable” 690 * attribute of tags. 691 * 692 * @param setting Whether it’s editable. 693 */ 694 void set_editable(bool setting = true); 695 696 /** Returns the default editability of the Gtk::TextView. Tags in the 697 * buffer may override this setting for some ranges of text. 698 * 699 * @return Whether text is editable by default. 700 */ 701 bool get_editable() const; 702 703 /** Sets the default number of blank pixels above paragraphs in @a text_view. 704 * Tags in the buffer for @a text_view may override the defaults. 705 * 706 * @param pixels_above_lines Pixels above paragraphs. 707 */ 708 void set_pixels_above_lines(int pixels_above_lines); 709 710 /** Gets the default number of pixels to put above paragraphs. 711 * Adding this function with get_pixels_below_lines() 712 * is equal to the line space between each paragraph. 713 * 714 * @return Default number of pixels above paragraphs. 715 */ 716 int get_pixels_above_lines() const; 717 718 /** Sets the default number of pixels of blank space 719 * to put below paragraphs in @a text_view. May be overridden 720 * by tags applied to @a text_view’s buffer. 721 * 722 * @param pixels_below_lines Pixels below paragraphs. 723 */ 724 void set_pixels_below_lines(int pixels_below_lines); 725 726 /** Gets the value set by set_pixels_below_lines(). 727 * 728 * The line space is the sum of the value returned by this function and the 729 * value returned by get_pixels_above_lines(). 730 * 731 * @return Default number of blank pixels below paragraphs. 732 */ 733 int get_pixels_below_lines() const; 734 735 /** Sets the default number of pixels of blank space to leave between 736 * display/wrapped lines within a paragraph. May be overridden by 737 * tags in @a text_view’s buffer. 738 * 739 * @param pixels_inside_wrap Default number of pixels between wrapped lines. 740 */ 741 void set_pixels_inside_wrap(int pixels_inside_wrap); 742 743 /** Gets the value set by set_pixels_inside_wrap(). 744 * 745 * @return Default number of pixels of blank space between wrapped lines. 746 */ 747 int get_pixels_inside_wrap() const; 748 749 /** Sets the default justification of text in @a text_view. 750 * Tags in the view’s buffer may override the default. 751 * 752 * @param justification Justification. 753 */ 754 void set_justification(Justification justification); 755 756 /** Gets the default justification of paragraphs in @a text_view. 757 * Tags in the buffer may override the default. 758 * 759 * @return Default justification. 760 */ 761 Justification get_justification() const; 762 763 /** Sets the default left margin for text in @a text_view. 764 * Tags in the buffer may override the default. 765 * 766 * Note that this function is confusingly named. 767 * In CSS terms, the value set here is padding. 768 * 769 * @param left_margin Left margin in pixels. 770 */ 771 void set_left_margin(int left_margin); 772 773 /** Gets the default left margin size of paragraphs in the @a text_view. 774 * Tags in the buffer may override the default. 775 * 776 * @return Left margin in pixels. 777 */ 778 int get_left_margin() const; 779 780 /** Sets the default right margin for text in the text view. 781 * Tags in the buffer may override the default. 782 * 783 * Note that this function is confusingly named. 784 * In CSS terms, the value set here is padding. 785 * 786 * @param right_margin Right margin in pixels. 787 */ 788 void set_right_margin(int right_margin); 789 790 /** Gets the default right margin for text in @a text_view. Tags 791 * in the buffer may override the default. 792 * 793 * @return Right margin in pixels. 794 */ 795 int get_right_margin() const; 796 797 /** Sets the top margin for text in @a text_view. 798 * 799 * Note that this function is confusingly named. 800 * In CSS terms, the value set here is padding. 801 * 802 * @newin{3,20} 803 * 804 * @param top_margin Top margin in pixels. 805 */ 806 void set_top_margin(int top_margin); 807 808 /** Gets the top margin for text in the @a text_view. 809 * 810 * @newin{3,20} 811 * 812 * @return Top margin in pixels. 813 */ 814 int get_top_margin() const; 815 816 /** Sets the bottom margin for text in @a text_view. 817 * 818 * Note that this function is confusingly named. 819 * In CSS terms, the value set here is padding. 820 * 821 * @newin{3,20} 822 * 823 * @param bottom_margin Bottom margin in pixels. 824 */ 825 void set_bottom_margin(int bottom_margin); 826 827 /** Gets the bottom margin for text in the @a text_view. 828 * 829 * @newin{3,20} 830 * 831 * @return Bottom margin in pixels. 832 */ 833 int get_bottom_margin() const; 834 835 /** Sets the default indentation for paragraphs in @a text_view. 836 * Tags in the buffer may override the default. 837 * 838 * @param indent Indentation in pixels. 839 */ 840 void set_indent(int indent); 841 842 /** Gets the default indentation of paragraphs in @a text_view. 843 * Tags in the view’s buffer may override the default. 844 * The indentation may be negative. 845 * 846 * @return Number of pixels of indentation. 847 */ 848 int get_indent() const; 849 850 /** Sets the default tab stops for paragraphs in @a text_view. 851 * Tags in the buffer may override the default. 852 * 853 * @param tabs Tabs as a Pango::TabArray. 854 */ 855 void set_tabs(Pango::TabArray& tabs); 856 857 /** Gets the default tabs for @a text_view. Tags in the buffer may 858 * override the defaults. The returned array will be empty if 859 * "standard" (8-space) tabs are used. 860 * 861 * @return Copy of default tab array, or an empty array if "standard" tabs are used. 862 */ 863 Pango::TabArray get_tabs() const; 864 865 /** Obtains a copy of the default text attributes. These are the 866 * attributes used for text unless a tag overrides them. 867 * You'd typically pass the default attributes in to 868 * Gtk::TextIter::get_attributes() in order to get the 869 * attributes in effect at a given text position. 870 * 871 * @return A new Gtk::TextAttributes. 872 */ 873 TextAttributes get_default_attributes() const; 874 875 876 /** Changes the Gtk::TextView overwrite mode. 877 * 878 * @newin{2,4} 879 * 880 * @param overwrite <tt>true</tt> to turn on overwrite mode, <tt>false</tt> to turn it off. 881 */ 882 void set_overwrite(bool overwrite = true); 883 884 /** Returns whether the Gtk::TextView is in overwrite mode or not. 885 * 886 * @newin{2,4} 887 * 888 * @return Whether @a text_view is in overwrite mode or not. 889 */ 890 bool get_overwrite() const; 891 892 893 /** Sets the behavior of the text widget when the Tab key is pressed. 894 * If @a accepts_tab is <tt>true</tt>, a tab character is inserted. If @a accepts_tab 895 * is <tt>false</tt> the keyboard focus is moved to the next widget in the focus 896 * chain. 897 * 898 * @newin{2,4} 899 * 900 * @param accepts_tab <tt>true</tt> if pressing the Tab key should insert a tab 901 * character, <tt>false</tt>, if pressing the Tab key should move the 902 * keyboard focus. 903 */ 904 void set_accepts_tab(bool accepts_tab = true); 905 906 /** Returns whether pressing the Tab key inserts a tab characters. 907 * set_accepts_tab(). 908 * 909 * @newin{2,4} 910 * 911 * @return <tt>true</tt> if pressing the Tab key inserts a tab character, 912 * <tt>false</tt> if pressing the Tab key moves the keyboard focus. 913 */ 914 bool get_accepts_tab() const; 915 916 917 /** Sets the Gtk::TextView::property_input_purpose() property which 918 * can be used by on-screen keyboards and other input 919 * methods to adjust their behaviour. 920 * 921 * @newin{3,6} 922 * 923 * @param purpose The purpose. 924 */ 925 void set_input_purpose(InputPurpose purpose); 926 927 /** Gets the value of the Gtk::TextView::property_input_purpose() property. 928 * 929 * @newin{3,6} 930 */ 931 InputPurpose get_input_purpose() const; 932 933 934 /** Sets the Gtk::TextView::property_input_hints() property, which 935 * allows input methods to fine-tune their behaviour. 936 * 937 * @newin{3,6} 938 * 939 * @param hints The hints. 940 */ 941 void set_input_hints(InputHints hints); 942 943 /** Gets the value of the Gtk::TextView::property_input_hints() property. 944 * 945 * @newin{3,6} 946 */ 947 InputHints get_input_hints() const; 948 949 950 /** Sets the Gtk::TextView::property_monospace() property, which 951 * indicates that the text view should use monospace 952 * fonts. 953 * 954 * @newin{3,16} 955 * 956 * @param monospace <tt>true</tt> to request monospace styling. 957 */ 958 void set_monospace(bool monospace = true); 959 960 /** Gets the value of the Gtk::TextView::property_monospace() property. 961 * 962 * Return: <tt>true</tt> if monospace fonts are desired 963 * 964 * @newin{3,16} 965 */ 966 bool get_monospace() const; 967 968 //TODO: This signal now takes a GtkWidget* instead of just a GtkMenu*, 969 //so change that when we can break ABI. 970 //See https://git.gnome.org/browse/gtk+/commit/?id=88623b98a7ca0afca08ac21bc3aa662c6ed3ab7f 971 972 973 /** 974 * @par Slot Prototype: 975 * <tt>void on_my_%populate_popup(Menu* menu)</tt> 976 * 977 * Flags: Run Last 978 * 979 * The signal_populate_popup() signal gets emitted before showing the 980 * context menu of the text view. 981 * 982 * If you need to add items to the context menu, connect 983 * to this signal and append your items to the @a menu, which 984 * will be a Gtk::Menu in this case. 985 * 986 * If Gtk::TextView::property_populate_all() is <tt>true</tt>, this signal will 987 * also be emitted to populate touch popups. In this case, 988 * @a menu will be a different container, e.g. a Gtk::Toolbar. 989 * 990 * The signal handler should not make assumptions about the 991 * type of @a widget, but check whether @a menu is a Gtk::Menu 992 * or Gtk::Toolbar or another kind of container. 993 * 994 * @param menu The container that is being populated. 995 */ 996 997 Glib::SignalProxy< void,Menu* > signal_populate_popup(); 998 999 1000 /** 1001 * @par Slot Prototype: 1002 * <tt>void on_my_%set_anchor()</tt> 1003 * 1004 * Flags: Run Last, Action 1005 * 1006 * The signal_set_anchor() signal is a 1007 * [keybinding signal][GtkBindingSignal] 1008 * which gets emitted when the user initiates setting the "anchor" 1009 * mark. The "anchor" mark gets placed at the same position as the 1010 * "insert" mark. 1011 * 1012 * This signal has no default bindings. 1013 */ 1014 1015 Glib::SignalProxy< void > signal_set_anchor(); 1016 1017 1018 /** 1019 * @par Slot Prototype: 1020 * <tt>void on_my_%insert_at_cursor(const Glib::ustring& str)</tt> 1021 * 1022 * Flags: Run Last, Action 1023 * 1024 * The signal_insert_at_cursor() signal is a 1025 * [keybinding signal][GtkBindingSignal] 1026 * which gets emitted when the user initiates the insertion of a 1027 * fixed string at the cursor. 1028 * 1029 * This signal has no default bindings. 1030 * 1031 * @param str The string to insert. 1032 */ 1033 1034 Glib::SignalProxy< void,const Glib::ustring& > signal_insert_at_cursor(); 1035 1036 1037 //Keybinding signals: 1038 1039 1040 /** Pixels of blank space above paragraphs. 1041 * 1042 * Default value: 0 1043 * 1044 * @return A PropertyProxy that allows you to get or set the value of the property, 1045 * or receive notification when the value of the property changes. 1046 */ 1047 Glib::PropertyProxy< int > property_pixels_above_lines() ; 1048 1049 /** Pixels of blank space above paragraphs. 1050 * 1051 * Default value: 0 1052 * 1053 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1054 * or receive notification when the value of the property changes. 1055 */ 1056 Glib::PropertyProxy_ReadOnly< int > property_pixels_above_lines() const; 1057 1058 /** Pixels of blank space below paragraphs. 1059 * 1060 * Default value: 0 1061 * 1062 * @return A PropertyProxy that allows you to get or set the value of the property, 1063 * or receive notification when the value of the property changes. 1064 */ 1065 Glib::PropertyProxy< int > property_pixels_below_lines() ; 1066 1067 /** Pixels of blank space below paragraphs. 1068 * 1069 * Default value: 0 1070 * 1071 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1072 * or receive notification when the value of the property changes. 1073 */ 1074 Glib::PropertyProxy_ReadOnly< int > property_pixels_below_lines() const; 1075 1076 /** Pixels of blank space between wrapped lines in a paragraph. 1077 * 1078 * Default value: 0 1079 * 1080 * @return A PropertyProxy that allows you to get or set the value of the property, 1081 * or receive notification when the value of the property changes. 1082 */ 1083 Glib::PropertyProxy< int > property_pixels_inside_wrap() ; 1084 1085 /** Pixels of blank space between wrapped lines in a paragraph. 1086 * 1087 * Default value: 0 1088 * 1089 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1090 * or receive notification when the value of the property changes. 1091 */ 1092 Glib::PropertyProxy_ReadOnly< int > property_pixels_inside_wrap() const; 1093 1094 /** Whether the text can be modified by the user. 1095 * 1096 * Default value: <tt>true</tt> 1097 * 1098 * @return A PropertyProxy that allows you to get or set the value of the property, 1099 * or receive notification when the value of the property changes. 1100 */ 1101 Glib::PropertyProxy< bool > property_editable() ; 1102 1103 /** Whether the text can be modified by the user. 1104 * 1105 * Default value: <tt>true</tt> 1106 * 1107 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1108 * or receive notification when the value of the property changes. 1109 */ 1110 Glib::PropertyProxy_ReadOnly< bool > property_editable() const; 1111 1112 /** Whether to wrap lines never, at word boundaries, or at character boundaries. 1113 * 1114 * Default value: Gtk::WRAP_NONE 1115 * 1116 * @return A PropertyProxy that allows you to get or set the value of the property, 1117 * or receive notification when the value of the property changes. 1118 */ 1119 Glib::PropertyProxy< WrapMode > property_wrap_mode() ; 1120 1121 /** Whether to wrap lines never, at word boundaries, or at character boundaries. 1122 * 1123 * Default value: Gtk::WRAP_NONE 1124 * 1125 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1126 * or receive notification when the value of the property changes. 1127 */ 1128 Glib::PropertyProxy_ReadOnly< WrapMode > property_wrap_mode() const; 1129 1130 /** Left, right, or center justification. 1131 * 1132 * Default value: Gtk::JUSTIFY_LEFT 1133 * 1134 * @return A PropertyProxy that allows you to get or set the value of the property, 1135 * or receive notification when the value of the property changes. 1136 */ 1137 Glib::PropertyProxy< Justification > property_justification() ; 1138 1139 /** Left, right, or center justification. 1140 * 1141 * Default value: Gtk::JUSTIFY_LEFT 1142 * 1143 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1144 * or receive notification when the value of the property changes. 1145 */ 1146 Glib::PropertyProxy_ReadOnly< Justification > property_justification() const; 1147 1148 /** The default left margin for text in the text view. 1149 * Tags in the buffer may override the default. 1150 * 1151 * Note that this property is confusingly named. In CSS terms, 1152 * the value set here is padding, and it is applied in addition 1153 * to the padding from the theme. 1154 * 1155 * Don't confuse this property with Gtk::Widget::property_margin_left(). 1156 * 1157 * Default value: 0 1158 * 1159 * @return A PropertyProxy that allows you to get or set the value of the property, 1160 * or receive notification when the value of the property changes. 1161 */ 1162 Glib::PropertyProxy< int > property_left_margin() ; 1163 1164 /** The default left margin for text in the text view. 1165 * Tags in the buffer may override the default. 1166 * 1167 * Note that this property is confusingly named. In CSS terms, 1168 * the value set here is padding, and it is applied in addition 1169 * to the padding from the theme. 1170 * 1171 * Don't confuse this property with Gtk::Widget::property_margin_left(). 1172 * 1173 * Default value: 0 1174 * 1175 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1176 * or receive notification when the value of the property changes. 1177 */ 1178 Glib::PropertyProxy_ReadOnly< int > property_left_margin() const; 1179 1180 /** The default right margin for text in the text view. 1181 * Tags in the buffer may override the default. 1182 * 1183 * Note that this property is confusingly named. In CSS terms, 1184 * the value set here is padding, and it is applied in addition 1185 * to the padding from the theme. 1186 * 1187 * Don't confuse this property with Gtk::Widget::property_margin_right(). 1188 * 1189 * Default value: 0 1190 * 1191 * @return A PropertyProxy that allows you to get or set the value of the property, 1192 * or receive notification when the value of the property changes. 1193 */ 1194 Glib::PropertyProxy< int > property_right_margin() ; 1195 1196 /** The default right margin for text in the text view. 1197 * Tags in the buffer may override the default. 1198 * 1199 * Note that this property is confusingly named. In CSS terms, 1200 * the value set here is padding, and it is applied in addition 1201 * to the padding from the theme. 1202 * 1203 * Don't confuse this property with Gtk::Widget::property_margin_right(). 1204 * 1205 * Default value: 0 1206 * 1207 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1208 * or receive notification when the value of the property changes. 1209 */ 1210 Glib::PropertyProxy_ReadOnly< int > property_right_margin() const; 1211 1212 /** The top margin for text in the text view. 1213 * 1214 * Note that this property is confusingly named. In CSS terms, 1215 * the value set here is padding, and it is applied in addition 1216 * to the padding from the theme. 1217 * 1218 * Don't confuse this property with Gtk::Widget::property_margin_top(). 1219 * 1220 * @newin{2,30} 1221 * 1222 * Default value: 0 1223 * 1224 * @return A PropertyProxy that allows you to get or set the value of the property, 1225 * or receive notification when the value of the property changes. 1226 */ 1227 Glib::PropertyProxy< int > property_top_margin() ; 1228 1229 /** The top margin for text in the text view. 1230 * 1231 * Note that this property is confusingly named. In CSS terms, 1232 * the value set here is padding, and it is applied in addition 1233 * to the padding from the theme. 1234 * 1235 * Don't confuse this property with Gtk::Widget::property_margin_top(). 1236 * 1237 * @newin{2,30} 1238 * 1239 * Default value: 0 1240 * 1241 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1242 * or receive notification when the value of the property changes. 1243 */ 1244 Glib::PropertyProxy_ReadOnly< int > property_top_margin() const; 1245 1246 /** The bottom margin for text in the text view. 1247 * 1248 * Note that this property is confusingly named. In CSS terms, 1249 * the value set here is padding, and it is applied in addition 1250 * to the padding from the theme. 1251 * 1252 * Don't confuse this property with Gtk::Widget::property_margin_bottom(). 1253 * 1254 * @newin{2,30} 1255 * 1256 * Default value: 0 1257 * 1258 * @return A PropertyProxy that allows you to get or set the value of the property, 1259 * or receive notification when the value of the property changes. 1260 */ 1261 Glib::PropertyProxy< int > property_bottom_margin() ; 1262 1263 /** The bottom margin for text in the text view. 1264 * 1265 * Note that this property is confusingly named. In CSS terms, 1266 * the value set here is padding, and it is applied in addition 1267 * to the padding from the theme. 1268 * 1269 * Don't confuse this property with Gtk::Widget::property_margin_bottom(). 1270 * 1271 * @newin{2,30} 1272 * 1273 * Default value: 0 1274 * 1275 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1276 * or receive notification when the value of the property changes. 1277 */ 1278 Glib::PropertyProxy_ReadOnly< int > property_bottom_margin() const; 1279 1280 /** Amount to indent the paragraph, in pixels. 1281 * 1282 * Default value: 0 1283 * 1284 * @return A PropertyProxy that allows you to get or set the value of the property, 1285 * or receive notification when the value of the property changes. 1286 */ 1287 Glib::PropertyProxy< int > property_indent() ; 1288 1289 /** Amount to indent the paragraph, in pixels. 1290 * 1291 * Default value: 0 1292 * 1293 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1294 * or receive notification when the value of the property changes. 1295 */ 1296 Glib::PropertyProxy_ReadOnly< int > property_indent() const; 1297 1298 /** Custom tabs for this text. 1299 * 1300 * @return A PropertyProxy that allows you to get or set the value of the property, 1301 * or receive notification when the value of the property changes. 1302 */ 1303 Glib::PropertyProxy< Pango::TabArray > property_tabs() ; 1304 1305 /** Custom tabs for this text. 1306 * 1307 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1308 * or receive notification when the value of the property changes. 1309 */ 1310 Glib::PropertyProxy_ReadOnly< Pango::TabArray > property_tabs() const; 1311 1312 /** If the insertion cursor is shown. 1313 * 1314 * Default value: <tt>true</tt> 1315 * 1316 * @return A PropertyProxy that allows you to get or set the value of the property, 1317 * or receive notification when the value of the property changes. 1318 */ 1319 Glib::PropertyProxy< bool > property_cursor_visible() ; 1320 1321 /** If the insertion cursor is shown. 1322 * 1323 * Default value: <tt>true</tt> 1324 * 1325 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1326 * or receive notification when the value of the property changes. 1327 */ 1328 Glib::PropertyProxy_ReadOnly< bool > property_cursor_visible() const; 1329 1330 /** The buffer which is displayed. 1331 * 1332 * @return A PropertyProxy that allows you to get or set the value of the property, 1333 * or receive notification when the value of the property changes. 1334 */ 1335 Glib::PropertyProxy< Glib::RefPtr<TextBuffer> > property_buffer() ; 1336 1337 /** The buffer which is displayed. 1338 * 1339 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1340 * or receive notification when the value of the property changes. 1341 */ 1342 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> > property_buffer() const; 1343 1344 /** Whether entered text overwrites existing contents. 1345 * 1346 * Default value: <tt>false</tt> 1347 * 1348 * @return A PropertyProxy that allows you to get or set the value of the property, 1349 * or receive notification when the value of the property changes. 1350 */ 1351 Glib::PropertyProxy< bool > property_overwrite() ; 1352 1353 /** Whether entered text overwrites existing contents. 1354 * 1355 * Default value: <tt>false</tt> 1356 * 1357 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1358 * or receive notification when the value of the property changes. 1359 */ 1360 Glib::PropertyProxy_ReadOnly< bool > property_overwrite() const; 1361 1362 /** Whether Tab will result in a tab character being entered. 1363 * 1364 * Default value: <tt>true</tt> 1365 * 1366 * @return A PropertyProxy that allows you to get or set the value of the property, 1367 * or receive notification when the value of the property changes. 1368 */ 1369 Glib::PropertyProxy< bool > property_accepts_tab() ; 1370 1371 /** Whether Tab will result in a tab character being entered. 1372 * 1373 * Default value: <tt>true</tt> 1374 * 1375 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1376 * or receive notification when the value of the property changes. 1377 */ 1378 Glib::PropertyProxy_ReadOnly< bool > property_accepts_tab() const; 1379 1380 /** Which IM (input method) module should be used for this text_view. 1381 * See Gtk::IMContext. 1382 * 1383 * Setting this to a non-<tt>nullptr</tt> value overrides the 1384 * system-wide IM module setting. See the GtkSettings 1385 * Gtk::Settings::property_gtk_im_module() property. 1386 * 1387 * @newin{2,16} 1388 * 1389 * Default value: "" 1390 * 1391 * @return A PropertyProxy that allows you to get or set the value of the property, 1392 * or receive notification when the value of the property changes. 1393 */ 1394 Glib::PropertyProxy< Glib::ustring > property_im_module() ; 1395 1396 /** Which IM (input method) module should be used for this text_view. 1397 * See Gtk::IMContext. 1398 * 1399 * Setting this to a non-<tt>nullptr</tt> value overrides the 1400 * system-wide IM module setting. See the GtkSettings 1401 * Gtk::Settings::property_gtk_im_module() property. 1402 * 1403 * @newin{2,16} 1404 * 1405 * Default value: "" 1406 * 1407 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1408 * or receive notification when the value of the property changes. 1409 */ 1410 Glib::PropertyProxy_ReadOnly< Glib::ustring > property_im_module() const; 1411 1412 /** The purpose of this text field. 1413 * 1414 * This property can be used by on-screen keyboards and other input 1415 * methods to adjust their behaviour. 1416 * 1417 * @newin{3,6} 1418 * 1419 * Default value: Gtk::INPUT_PURPOSE_FREE_FORM 1420 * 1421 * @return A PropertyProxy that allows you to get or set the value of the property, 1422 * or receive notification when the value of the property changes. 1423 */ 1424 Glib::PropertyProxy< InputPurpose > property_input_purpose() ; 1425 1426 /** The purpose of this text field. 1427 * 1428 * This property can be used by on-screen keyboards and other input 1429 * methods to adjust their behaviour. 1430 * 1431 * @newin{3,6} 1432 * 1433 * Default value: Gtk::INPUT_PURPOSE_FREE_FORM 1434 * 1435 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1436 * or receive notification when the value of the property changes. 1437 */ 1438 Glib::PropertyProxy_ReadOnly< InputPurpose > property_input_purpose() const; 1439 1440 /** Additional hints (beyond Gtk::TextView::property_input_purpose()) that 1441 * allow input methods to fine-tune their behaviour. 1442 * 1443 * @newin{3,6} 1444 * 1445 * Default value: Gtk::INPUT_HINT_NONE 1446 * 1447 * @return A PropertyProxy that allows you to get or set the value of the property, 1448 * or receive notification when the value of the property changes. 1449 */ 1450 Glib::PropertyProxy< InputHints > property_input_hints() ; 1451 1452 /** Additional hints (beyond Gtk::TextView::property_input_purpose()) that 1453 * allow input methods to fine-tune their behaviour. 1454 * 1455 * @newin{3,6} 1456 * 1457 * Default value: Gtk::INPUT_HINT_NONE 1458 * 1459 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1460 * or receive notification when the value of the property changes. 1461 */ 1462 Glib::PropertyProxy_ReadOnly< InputHints > property_input_hints() const; 1463 1464 /** If :populate-all is <tt>true</tt>, the Gtk::TextView::signal_populate_popup() 1465 * signal is also emitted for touch popups. 1466 * 1467 * @newin{3,8} 1468 * 1469 * Default value: <tt>false</tt> 1470 * 1471 * @return A PropertyProxy that allows you to get or set the value of the property, 1472 * or receive notification when the value of the property changes. 1473 */ 1474 Glib::PropertyProxy< bool > property_populate_all() ; 1475 1476 /** If :populate-all is <tt>true</tt>, the Gtk::TextView::signal_populate_popup() 1477 * signal is also emitted for touch popups. 1478 * 1479 * @newin{3,8} 1480 * 1481 * Default value: <tt>false</tt> 1482 * 1483 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1484 * or receive notification when the value of the property changes. 1485 */ 1486 Glib::PropertyProxy_ReadOnly< bool > property_populate_all() const; 1487 1488 /** Whether to use a monospace font. 1489 * 1490 * Default value: <tt>false</tt> 1491 * 1492 * @return A PropertyProxy that allows you to get or set the value of the property, 1493 * or receive notification when the value of the property changes. 1494 */ 1495 Glib::PropertyProxy< bool > property_monospace() ; 1496 1497 /** Whether to use a monospace font. 1498 * 1499 * Default value: <tt>false</tt> 1500 * 1501 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 1502 * or receive notification when the value of the property changes. 1503 */ 1504 Glib::PropertyProxy_ReadOnly< bool > property_monospace() const; 1505 1506 1507 }; 1508 1509 } //namespace Gtk 1510 1511 1512 namespace Glib 1513 { 1514 /** A Glib::wrap() method for this object. 1515 * 1516 * @param object The C instance. 1517 * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref. 1518 * @result A C++ instance that wraps this C instance. 1519 * 1520 * @relates Gtk::TextView 1521 */ 1522 Gtk::TextView* wrap(GtkTextView* object, bool take_copy = false); 1523 } //namespace Glib 1524 1525 1526 #endif /* _GTKMM_TEXTVIEW_H */ 1527 1528