blob: 630fccbb3219c419904fc8ec3d7e5fcfce9d49f2 [file] [log] [blame]
DRC2ff39b82011-07-28 08:38:59 +00001//
2// "$Id: Fl_Text_Buffer.H 8148 2010-12-31 22:38:03Z matt $"
3//
4// Header file for Fl_Text_Buffer class.
5//
6// Copyright 2001-2010 by Bill Spitzak and others.
7// Original code Copyright Mark Edel. Permission to distribute under
8// the LGPL for the FLTK library granted by Mark Edel.
9//
10// This library is free software; you can redistribute it and/or
11// modify it under the terms of the GNU Library General Public
12// License as published by the Free Software Foundation; either
13// version 2 of the License, or (at your option) any later version.
14//
15// This library is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18// Library General Public License for more details.
19//
20// You should have received a copy of the GNU Library General Public
21// License along with this library; if not, write to the Free Software
22// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
23// USA.
24//
25// Please report all bugs and problems on the following page:
26//
27// http://www.fltk.org/str.php
28//
29
30/* \file
31 Fl_Text_Buffer, Fl_Text_Selection widget . */
32
33#ifndef FL_TEXT_BUFFER_H
34#define FL_TEXT_BUFFER_H
35
36
37#undef ASSERT_UTF8
38
39#ifdef ASSERT_UTF8
40# include <assert.h>
41# define IS_UTF8_ALIGNED(a) if (a && *a) assert(fl_utf8len(*(a))>0);
42# define IS_UTF8_ALIGNED2(a, b) if (b>=0 && b<a->length()) assert(fl_utf8len(a->byte_at(b))>0);
43#else
44# define IS_UTF8_ALIGNED(a)
45# define IS_UTF8_ALIGNED2(a, b)
46#endif
47
48
49/*
50 "character size" is the size of a UTF-8 character in bytes
51 "character width" is the width of a Unicode character in pixels
52 "column" was orginally defined as a character offset from the left margin.
53 It was identical to the byte offset. In UTF-8, we have neither a byte offset
54 nor truly fixed width fonts (*). Column could be a pixel value multiplied with
55 an average character width (which is a bearable approximation).
56
57 * in Unicode, there are no fixed width fonts! Even if the ASCII characters may
58 happen to be all the same width in pixels, chinese charcaters surely are not.
59 There are plenty of exceptions, like ligatures, that make special handling of
60 "fixed" character widths a nightmare. I decided to remove all references to
61 fixed fonts and see "columns" as a multiple of the average width of a
62 character in the main font.
63 - Matthias
64 */
65
66
67/* Maximum length in characters of a tab or control character expansion
68 of a single buffer character */
69#define FL_TEXT_MAX_EXP_CHAR_LEN 20
70
71#include "Fl_Export.H"
72
73
74/**
75 \class Fl_Text_Selection
76 \brief This is an internal class for Fl_Text_Buffer to manage text selections.
77 This class works correctly with utf-8 strings assuming that the parameters
78 for all calls are on character boundaries.
79 */
80class FL_EXPORT Fl_Text_Selection {
81 friend class Fl_Text_Buffer;
82
83public:
84
85 /**
86 \brief Set the selection range.
87 \param start byte offset to first selected character
88 \param end byte offset pointing after last selected character
89 */
90 void set(int start, int end);
91
92 /**
93 \brief Updates a selection afer text was modified.
94 Updates an individual selection for changes in the corresponding text
95 \param pos byte offset into text buffer at which the change occured
96 \param nDeleted number of bytes deleted from the buffer
97 \param nInserted number of bytes inserted into the buffer
98 */
99 void update(int pos, int nDeleted, int nInserted);
100
101 /**
102 \brief Return the byte offset to the first selected character.
103 \return byte offset
104 */
105 int start() const { return mStart; }
106
107 /**
108 \brief Return the byte ofsset to the character after the last selected character.
109 \return byte offset
110 */
111 int end() const { return mEnd; }
112
113 /**
114 \brief Returns true if any text is selected.
115 \return a non-zero number if any text has been selected, or 0
116 if no text is selected.
117 */
118 bool selected() const { return mSelected; }
119
120 /**
121 \brief Modify the 'selected' flag.
122 \param b new flag
123 */
124 void selected(bool b) { mSelected = b; }
125
126 /**
127 Return true if position \p pos with indentation \p dispIndex is in
128 the Fl_Text_Selection.
129 */
130 int includes(int pos) const;
131
132 /**
133 \brief Return the positions of this selection.
134 \param start retrun byte offset to first selected character
135 \param end retrun byte offset pointing after last selected character
136 \return true if selected
137 */
138 int position(int* start, int* end) const;
139
140protected:
141
142 int mStart; ///< byte offset to the first selected character
143 int mEnd; ///< byte offset to the character after the last selected character
144 bool mSelected; ///< this flag is set if any text is selected
145};
146
147
148typedef void (*Fl_Text_Modify_Cb)(int pos, int nInserted, int nDeleted,
149 int nRestyled, const char* deletedText,
150 void* cbArg);
151
152
153typedef void (*Fl_Text_Predelete_Cb)(int pos, int nDeleted, void* cbArg);
154
155
156/**
157 \brief This class manages unicode displayed in one or more Fl_Text_Display widgets.
158
159 All text in Fl_Text_Buffermust be encoded in UTF-8. All indices used in the
160 function calls must be aligned to the start of a UTF-8 sequence. All indices
161 and pointers returned will be aligned. All functions that return a single
162 character will return that in an unsiged int in UCS-4 encoding.
163
164 The Fl_Text_Buffer class is used by the Fl_Text_Display
165 and Fl_Text_Editor to manage complex text data and is based upon the
166 excellent NEdit text editor engine - see http://www.nedit.org/.
167 */
168class FL_EXPORT Fl_Text_Buffer {
169public:
170
171 /**
172 Create an empty text buffer of a pre-determined size.
173 \param requestedSize use this to avoid unnecessary re-allocation
174 if you know exactly how much the buffer will need to hold
175 \param preferredGapSize Initial size for the buffer gap (empty space
176 in the buffer where text might be inserted
177 if the user is typing sequential chars)
178 */
179 Fl_Text_Buffer(int requestedSize = 0, int preferredGapSize = 1024);
180
181 /**
182 Frees a text buffer
183 */
184 ~Fl_Text_Buffer();
185
186 /**
187 \brief Returns the number of bytes in the buffer.
188 \return size of text in bytes
189 */
190 int length() const { return mLength; }
191
192 /**
193 \brief Get a copy of the entire contents of the text buffer.
194 Memory is allocated to contain the returned string, which the caller
195 must free.
196 \return newly allocated text buffer - must be free'd, text is utf8
197 */
198 char* text() const;
199
200 /**
201 Replaces the entire contents of the text buffer.
202 \param text Text must be valid utf8.
203 */
204 void text(const char* text);
205
206 /**
207 \brief Get a copy of a part of the text buffer.
208 Return a copy of the text between \p start and \p end character positions
209 from text buffer \p buf. Positions start at 0, and the range does not
210 include the character pointed to by \p end.
211 When you are done with the text, free it using the free() function.
212 \param start byte offset to first character
213 \param end byte offset after last character in range
214 \return newly allocated text buffer - must be free'd, text is utf8
215 */
216 char* text_range(int start, int end) const;
217
218 /**
219 Returns the character at the specified position pos in the buffer.
220 Positions start at 0
221 \param pos byte offset into buffer, pos must be at acharacter boundary
222 \return Unicode UCS-4 encoded character
223 */
224 unsigned int char_at(int pos) const;
225
226 /**
227 Returns the raw byte at the specified position pos in the buffer.
228 Positions start at 0
229 \param pos byte offset into buffer
230 \return unencoded raw byte
231 */
232 char byte_at(int pos) const;
233
234 /**
235 Convert a byte offset in buffer into a memory address.
236 \param pos byte offset into buffer
237 \return byte offset converted to a memory address
238 */
239 const char *address(int pos) const
240 { return (pos < mGapStart) ? mBuf+pos : mBuf+pos+mGapEnd-mGapStart; }
241
242 /**
243 Convert a byte offset in buffer into a memory address.
244 \param pos byte offset into buffer
245 \return byte offset converted to a memory address
246 */
247 char *address(int pos)
248 { return (pos < mGapStart) ? mBuf+pos : mBuf+pos+mGapEnd-mGapStart; }
249
250 /**
251 Inserts null-terminated string \p text at position \p pos.
252 \param pos insertion position as byte offset (must be utf-8 character aligned)
253 \param text utf-8 encoded and nul terminated text
254 */
255 void insert(int pos, const char* text);
256
257 /**
258 Appends the text string to the end of the buffer.
259 \param t utf-8 encoded and nul terminated text
260 */
261 void append(const char* t) { insert(length(), t); }
262
263 /**
264 Deletes a range of characters in the buffer.
265 \param start byte offset to first character to be removed
266 \param end byte offset to charcatre after last character to be removed
267 */
268 void remove(int start, int end);
269
270 /**
271 Deletes the characters between \p start and \p end, and inserts the null-terminated string \p text in their place in the buffer.
272 \param start byte offset to first character to be removed and new insert position
273 \param end byte offset to charcatre after last character to be removed
274 \param text utf-8 encoded and nul terminated text
275 */
276 void replace(int start, int end, const char *text);
277
278 /**
279 Copies text from one buffer to this one.
280 \param fromBuf source text buffer may be the same as this
281 \param fromStart byte offset into buffer
282 \param fromEnd byte offset into buffer
283 \param toPos destination byte offset into buffer
284 */
285 void copy(Fl_Text_Buffer* fromBuf, int fromStart, int fromEnd, int toPos);
286
287 /**
288 Undo text modification according to the undo variables or insert text
289 from the undo buffer
290 */
291 int undo(int *cp=0);
292
293 /**
294 Lets the undo system know if we can undo changes
295 */
296 void canUndo(char flag=1);
297
298 /**
299 Inserts a file at the specified position. Returns 0 on success,
300 non-zero on error (strerror() contains reason). 1 indicates open
301 for read failed (no data loaded). 2 indicates error occurred
302 while reading data (data was partially loaded).
303 File can be UTF-8 or CP1252-encoded.
304 If the input file is not UTF-8-encoded, the Fl_Text_Buffer widget will contain
305 UTF-8-transcoded data. By default, the message Fl_Text_Buffer::file_encoding_warning_message
306 will warn the user about this.
307 \see input_file_was_transcoded and transcoding_warning_action.
308 */
309 int insertfile(const char *file, int pos, int buflen = 128*1024);
310
311 /**
312 Appends the named file to the end of the buffer. See also insertfile().
313 */
314 int appendfile(const char *file, int buflen = 128*1024)
315 { return insertfile(file, length(), buflen); }
316
317 /**
318 Loads a text file into the buffer. See also insertfile().
319 */
320 int loadfile(const char *file, int buflen = 128*1024)
321 { select(0, length()); remove_selection(); return appendfile(file, buflen); }
322
323 /**
324 Writes the specified portions of the file to a file. Returns 0 on success, non-zero
325 on error (strerror() contains reason). 1 indicates open for write failed
326 (no data saved). 2 indicates error occurred while writing data
327 (data was partially saved).
328 */
329 int outputfile(const char *file, int start, int end, int buflen = 128*1024);
330
331 /**
332 Saves a text file from the current buffer
333 */
334 int savefile(const char *file, int buflen = 128*1024)
335 { return outputfile(file, 0, length(), buflen); }
336
337 /**
338 Gets the tab width.
339 */
340 int tab_distance() const { return mTabDist; }
341
342 /**
343 Set the hardware tab distance (width) used by all displays for this buffer,
344 and used in computing offsets for rectangular selection operations.
345 */
346 void tab_distance(int tabDist);
347
348 /**
349 Selects a range of characters in the buffer.
350 */
351 void select(int start, int end);
352
353 /**
354 Returns a non 0 value if text has been selected, 0 otherwise
355 */
356 int selected() const { return mPrimary.selected(); }
357
358 /**
359 Cancels any previous selection on the primary text selection object
360 */
361 void unselect();
362
363 /**
364 Gets the selection position
365 */
366 int selection_position(int* start, int* end);
367
368 /**
369 Returns the currently selected text. When you are done with
370 the text, free it using the free() function.
371 */
372 char* selection_text();
373
374 /**
375 Removes the text in the primary selection.
376 */
377 void remove_selection();
378
379 /**
380 Replaces the text in the primary selection.
381 */
382 void replace_selection(const char* text);
383
384 /**
385 Selects a range of characters in the secondary selection.
386 */
387 void secondary_select(int start, int end);
388
389 /**
390 Returns a non 0 value if text has been selected in the secondary
391 text selection, 0 otherwise
392 */
393 int secondary_selected() { return mSecondary.selected(); }
394
395 /**
396 Clears any selection in the secondary text selection object.
397 */
398 void secondary_unselect();
399
400 /**
401 Returns the current selection in the secondary text selection object.
402 */
403 int secondary_selection_position(int* start, int* end);
404
405 /**
406 Returns the text in the secondary selection. When you are
407 done with the text, free it using the free() function.
408 */
409 char* secondary_selection_text();
410
411 /**
412 Removes the text from the buffer corresponding to the secondary text selection object.
413 */
414 void remove_secondary_selection();
415
416 /**
417 Replaces the text from the buffer corresponding to the secondary
418 text selection object with the new string \p text.
419 */
420 void replace_secondary_selection(const char* text);
421
422 /**
423 Highlights the specified text within the buffer.
424 */
425 void highlight(int start, int end);
426
427 /**
428 Returns the highlighted text. When you are done with the
429 text, free it using the free() function.
430 */
431 int highlight() { return mHighlight.selected(); }
432
433 /**
434 Unhighlights text in the buffer.
435 */
436 void unhighlight();
437
438 /**
439 Highlights the specified text between \p start and \p end within the buffer.
440 */
441 int highlight_position(int* start, int* end);
442
443 /**
444 Returns the highlighted text. When you are done with the
445 text, free it using the free() function.
446 */
447 char* highlight_text();
448
449 /**
450 Adds a callback function that is called whenever the text buffer is
451 modified. The callback function is declared as follows:
452
453 \code
454 typedef void (*Fl_Text_Modify_Cb)(int pos, int nInserted, int nDeleted,
455 int nRestyled, const char* deletedText,
456 void* cbArg);
457 \endcode
458 */
459 void add_modify_callback(Fl_Text_Modify_Cb bufModifiedCB, void* cbArg);
460
461 /**
462 Removes a modify callback.
463 */
464 void remove_modify_callback(Fl_Text_Modify_Cb bufModifiedCB, void* cbArg);
465
466 /**
467 Calls all modify callbacks that have been registered using
468 the add_modify_callback()
469 method.
470 */
471 void call_modify_callbacks() { call_modify_callbacks(0, 0, 0, 0, 0); }
472
473 /**
474 Adds a callback routine to be called before text is deleted from the buffer.
475 */
476 void add_predelete_callback(Fl_Text_Predelete_Cb bufPredelCB, void* cbArg);
477
478 /**
479 Removes a callback routine \p bufPreDeleteCB associated with argument \p cbArg
480 to be called before text is deleted from the buffer.
481 */
482 void remove_predelete_callback(Fl_Text_Predelete_Cb predelCB, void* cbArg);
483
484 /**
485 Calls the stored pre-delete callback procedure(s) for this buffer to update
486 the changed area(s) on the screen and any other listeners.
487 */
488 void call_predelete_callbacks() { call_predelete_callbacks(0, 0); }
489
490 /**
491 Returns the text from the entire line containing the specified
492 character position. When you are done with the text, free it
493 using the free() function.
494 \param pos byte index into buffer
495 \return copy of utf8 text, must be free'd
496 */
497 char* line_text(int pos) const;
498
499 /**
500 Returns the position of the start of the line containing position \p pos.
501 \param pos byte index into buffer
502 \return byte offset to line start
503 */
504 int line_start(int pos) const;
505
506 /**
507 Finds and returns the position of the end of the line containing position \p pos
508 (which is either a pointer to the newline character ending the line,
509 or a pointer to one character beyond the end of the buffer)
510 \param pos byte index into buffer
511 \return byte offset to line end
512 */
513 int line_end(int pos) const;
514
515 /**
516 Returns the position corresponding to the start of the word
517 \param pos byte index into buffer
518 \return byte offset to word start
519 */
520 int word_start(int pos) const;
521
522 /**
523 Returns the position corresponding to the end of the word.
524 \param pos byte index into buffer
525 \return byte offset to word end
526 */
527 int word_end(int pos) const;
528
529 /**
530 Count the number of displayed characters between buffer position
531 \p lineStartPos and \p targetPos. (displayed characters are the characters
532 shown on the screen to represent characters in the buffer, where tabs and
533 control characters are expanded)
534 */
535 int count_displayed_characters(int lineStartPos, int targetPos) const;
536
537 /**
538 Count forward from buffer position \p startPos in displayed characters
539 (displayed characters are the characters shown on the screen to represent
540 characters in the buffer, where tabs and control characters are expanded)
541 \param lineStartPos byte offset into buffer
542 \param nChars number of bytes that are sent to the display
543 \return byte offset in input after all output bytes are sent
544 */
545 int skip_displayed_characters(int lineStartPos, int nChars);
546
547 /**
548 Counts the number of newlines between \p startPos and \p endPos in buffer.
549 The character at position \p endPos is not counted.
550 */
551 int count_lines(int startPos, int endPos) const;
552
553 /**
554 Finds the first character of the line \p nLines forward from \p startPos
555 in the buffer and returns its position
556 */
557 int skip_lines(int startPos, int nLines);
558
559 /**
560 Finds and returns the position of the first character of the line \p nLines backwards
561 from \p startPos (not counting the character pointed to by \p startpos if
562 that is a newline) in the buffer. \p nLines == 0 means find the beginning of the line
563 */
564 int rewind_lines(int startPos, int nLines);
565
566 /**
567 Finds the next occurrence of the specified character.
568 Search forwards in buffer for character \p searchChar, starting
569 with the character \p startPos, and returning the result in \p foundPos
570 returns 1 if found, 0 if not. (The difference between this and
571 BufSearchForward is that it's optimized for single characters. The
572 overall performance of the text widget is dependent on its ability to
573 count lines quickly, hence searching for a single character: newline)
574 \param startPos byte offset to start position
575 \param searchChar UCS-4 character that we want to find
576 \param foundPos byte offset where the character was found
577 \return 1 if found, 0 if not
578 */
579 int findchar_forward(int startPos, unsigned searchChar, int* foundPos) const;
580
581 /**
582 Search backwards in buffer \p buf for character \p searchChar, starting
583 with the character BEFORE \p startPos, returning the result in \p foundPos
584 returns 1 if found, 0 if not. (The difference between this and
585 BufSearchBackward is that it's optimized for single characters. The
586 overall performance of the text widget is dependent on its ability to
587 count lines quickly, hence searching for a single character: newline)
588 \param startPos byte offset to start position
589 \param searchChar UCS-4 character that we want to find
590 \param foundPos byte offset where the character was found
591 \return 1 if found, 0 if not
592 */
593 int findchar_backward(int startPos, unsigned int searchChar, int* foundPos) const;
594
595 /**
596 Search forwards in buffer for string \p searchString, starting with the
597 character \p startPos, and returning the result in \p foundPos
598 returns 1 if found, 0 if not.
599 \param startPos byte offset to start position
600 \param searchString utf8 string that we want to find
601 \param foundPos byte offset where the string was found
602 \param matchCase if set, match character case
603 \return 1 if found, 0 if not
604 */
605 int search_forward(int startPos, const char* searchString, int* foundPos,
606 int matchCase = 0) const;
607
608 /**
609 Search backwards in buffer for string <i>searchCharssearchString</i>, starting with the
610 character BEFORE \p startPos, returning the result in \p foundPos
611 returns 1 if found, 0 if not.
612 \param startPos byte offset to start position
613 \param searchString utf8 string that we want to find
614 \param foundPos byte offset where the string was found
615 \param matchCase if set, match character case
616 \return 1 if found, 0 if not
617 */
618 int search_backward(int startPos, const char* searchString, int* foundPos,
619 int matchCase = 0) const;
620
621 /**
622 Returns the primary selection.
623 */
624 const Fl_Text_Selection* primary_selection() const { return &mPrimary; }
625
626 /**
627 Returns the primary selection.
628 */
629 Fl_Text_Selection* primary_selection() { return &mPrimary; }
630
631 /**
632 Returns the secondary selection.
633 */
634 const Fl_Text_Selection* secondary_selection() const { return &mSecondary; }
635
636 /**
637 Returns the current highlight selection.
638 */
639 const Fl_Text_Selection* highlight_selection() const { return &mHighlight; }
640
641 /**
642 Returns the index of the previous character.
643 \param ix index to the current char
644 */
645 int prev_char(int ix) const;
646 int prev_char_clipped(int ix) const;
647
648 /**
649 Returns the index of the next character.
650 \param ix index to the current char
651 */
652 int next_char(int ix) const;
653 int next_char_clipped(int ix) const;
654
655 /**
656 Align an index into the buffer to the current or previous utf8 boundary.
657 */
658 int utf8_align(int) const;
659
660 /**
661 \brief true iff the loaded file has been transcoded to UTF-8
662 */
663 int input_file_was_transcoded;
664
665 /** This message may be displayed using the fl_alert() function when a file
666 which was not UTF-8 encoded is input.
667 */
668 static const char* file_encoding_warning_message;
669
670 /**
671 \brief Pointer to a function called after reading a non UTF-8 encoded file.
672
673 This function is called after reading a file if the file content
674 was transcoded to UTF-8. Its default implementation calls fl_alert()
675 with the text of \ref file_encoding_warning_message. No warning message is
676 displayed if this pointer is set to NULL. Use \ref input_file_was_transcoded
677 to be informed if file input required transcoding to UTF-8.
678 */
679 void (*transcoding_warning_action)(Fl_Text_Buffer*);
680
681protected:
682
683 /**
684 Calls the stored modify callback procedure(s) for this buffer to update the
685 changed area(s) on the screen and any other listeners.
686 */
687 void call_modify_callbacks(int pos, int nDeleted, int nInserted,
688 int nRestyled, const char* deletedText) const;
689
690 /**
691 Calls the stored pre-delete callback procedure(s) for this buffer to update
692 the changed area(s) on the screen and any other listeners.
693 */
694 void call_predelete_callbacks(int pos, int nDeleted) const;
695
696 /**
697 Internal (non-redisplaying) version of BufInsert. Returns the length of
698 text inserted (this is just strlen(\p text), however this calculation can be
699 expensive and the length will be required by any caller who will continue
700 on to call redisplay). \p pos must be contiguous with the existing text in
701 the buffer (i.e. not past the end).
702 \return the number of bytes inserted
703 */
704 int insert_(int pos, const char* text);
705
706 /**
707 Internal (non-redisplaying) version of BufRemove. Removes the contents
708 of the buffer between start and end (and moves the gap to the site of
709 the delete).
710 */
711 void remove_(int start, int end);
712
713 /**
714 Calls the stored redisplay procedure(s) for this buffer to update the
715 screen for a change in a selection.
716 */
717 void redisplay_selection(Fl_Text_Selection* oldSelection,
718 Fl_Text_Selection* newSelection) const;
719
720 /**
721 Move the gap to start at a new position.
722 */
723 void move_gap(int pos);
724
725 /**
726 Reallocates the text storage in the buffer to have a gap starting at \p newGapStart
727 and a gap size of \p newGapLen, preserving the buffer's current contents.
728 */
729 void reallocate_with_gap(int newGapStart, int newGapLen);
730
731 char* selection_text_(Fl_Text_Selection* sel) const;
732
733 /**
734 Removes the text from the buffer corresponding to \p sel.
735 */
736 void remove_selection_(Fl_Text_Selection* sel);
737
738 /**
739 Replaces the \p text in selection \p sel.
740 */
741 void replace_selection_(Fl_Text_Selection* sel, const char* text);
742
743 /**
744 Updates all of the selections in the buffer for changes in the buffer's text
745 */
746 void update_selections(int pos, int nDeleted, int nInserted);
747
748 Fl_Text_Selection mPrimary; /**< highlighted areas */
749 Fl_Text_Selection mSecondary; /**< highlighted areas */
750 Fl_Text_Selection mHighlight; /**< highlighted areas */
751 int mLength; /**< length of the text in the buffer (the length
752 of the buffer itself must be calculated:
753 gapEnd - gapStart + length) */
754 char* mBuf; /**< allocated memory where the text is stored */
755 int mGapStart; /**< points to the first character of the gap */
756 int mGapEnd; /**< points to the first char after the gap */
757 // The hardware tab distance used by all displays for this buffer,
758 // and used in computing offsets for rectangular selection operations.
759 int mTabDist; /**< equiv. number of characters in a tab */
760 int mNModifyProcs; /**< number of modify-redisplay procs attached */
761 Fl_Text_Modify_Cb *mModifyProcs;/**< procedures to call when buffer is
762 modified to redisplay contents */
763 void** mCbArgs; /**< caller arguments for modifyProcs above */
764 int mNPredeleteProcs; /**< number of pre-delete procs attached */
765 Fl_Text_Predelete_Cb *mPredeleteProcs; /**< procedure to call before text is deleted
766 from the buffer; at most one is supported. */
767 void **mPredeleteCbArgs; /**< caller argument for pre-delete proc above */
768 int mCursorPosHint; /**< hint for reasonable cursor position after
769 a buffer modification operation */
770 char mCanUndo; /**< if this buffer is used for attributes, it must
771 not do any undo calls */
772 int mPreferredGapSize; /**< the default allocation for the text gap is 1024
773 bytes and should only be increased if frequent
774 and large changes in buffer size are expected */
775};
776
777#endif
778
779//
780// End of "$Id: Fl_Text_Buffer.H 8148 2010-12-31 22:38:03Z matt $".
781//