Debian Codegraph @

src/include/Fl_Text_Buffer_mod.H

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