/* * editors.h * * Turbo Vision - Version 2.0 * * Copyright (c) 1994 by Borland International * All Rights Reserved. * * Modified by Sergio Sigala */ #if !defined( __EDIT_COMMAND_CODES ) #define __EDIT_COMMAND_CODES /** \file editors.h * editors.h */ const int ufUpdate = 0x01, ufLine = 0x02, ufView = 0x04; const int smExtend = 0x01, smDouble = 0x02; const unsigned sfSearchFailed = UINT_MAX; const int cmFind = 82, cmReplace = 83, cmSearchAgain = 84; const int cmCharLeft = 500, cmCharRight = 501, cmWordLeft = 502, cmWordRight = 503, cmLineStart = 504, cmLineEnd = 505, cmLineUp = 506, cmLineDown = 507, cmPageUp = 508, cmPageDown = 509, cmTextStart = 510, cmTextEnd = 511, cmNewLine = 512, cmBackSpace = 513, cmDelChar = 514, cmDelWord = 515, cmDelStart = 516, cmDelEnd = 517, cmDelLine = 518, cmInsMode = 519, cmStartSelect = 520, cmHideSelect = 521, cmIndentMode = 522, cmUpdateTitle = 523; /** \var edOutOfMemory * @see TEditor::doSearchReplace */ const int edOutOfMemory = 0, /** \var edReadError * @see TEditor::doSearchReplace */ edReadError = 1, /** \var edWriteError * @see TEditor::doSearchReplace */ edWriteError = 2, /** \var edCreateError * @see TEditor::doSearchReplace */ edCreateError = 3, /** \var edSaveModify * @see TEditor::doSearchReplace */ edSaveModify = 4, /** \var edSaveUntitled * @see TEditor::doSearchReplace */ edSaveUntitled = 5, /** \var edSaveAs * @see TEditor::doSearchReplace */ edSaveAs = 6, /** \var edFind * @see TEditor::doSearchReplace */ edFind = 7, /** \var edSearchFailed * @see TEditor::doSearchReplace */ edSearchFailed = 8, /** \var edReplace * @see TEditor::doSearchReplace */ edReplace = 9, /** \var edReplacePrompt * @see TEditor::doSearchReplace */ edReplacePrompt = 10; /** \var efCaseSensitive * Default to case-sensitive search. * @see TEditor::editorFlags */ const int efCaseSensitive = 0x0001, /** \var efWholeWordsOnly * Default to whole words only search. * @see TEditor::editorFlags */ efWholeWordsOnly = 0x0002, /** \var efPromptOnReplace * Prompt on replace. * @see TEditor::editorFlags */ efPromptOnReplace = 0x0004, /** \var efReplaceAll * Replace all occurrences. * @see TEditor::editorFlags */ efReplaceAll = 0x0008, /** \var efDoReplace * Do replace. * @see TEditor::editorFlags */ efDoReplace = 0x0010, /** \var efBackupFiles * Create backup files with a trailing ~ on saves. * @see TEditor::editorFlags */ efBackupFiles = 0x0100; /** \var maxLineLength * Maximum allowed line length for text in a TEditor view. */ const int maxLineLength = 256; #endif // __EDIT_COMMAND_CODES /** \enum TEditorDialog * The TEditorDialog data type is a pointer to function returning ushort * and taking one int argument and a variable number of additional * arguments. * * Since dialog boxes are very application-dependent, a @ref TEditor object * does not display its own dialog boxes directly. Instead it controls * them through this function pointer. * * The various dialog values, passed in the first int argument, are * self-explanatory: @ref edOutOfMemory, @ref edReadError, @ref edWriteError, * @ref edCreateError, @ref edSaveModify, @ref edSaveUntitled, @ref edSaveAs, * @ref edFind, @ref edSearchFailed, @ref edReplace and @ref edReplacePrompt. * @see TEditor::editorDialog */ typedef ushort (*TEditorDialog)( int, ... ); /** \fn defEditorDialog( int dialog, ... ) * Since dialog boxes are very application-dependent, a @ref TEditor object * does not display its own dialog boxes directly. Instead it controls * them through the @ref TEditorDialog function pointer. * @see TEditor::editorDialog * * This is the default dialog; it simply returns cmCancel. */ ushort defEditorDialog( int dialog, ... ); #if defined( Uses_TIndicator ) && !defined( __TIndicator ) #define __TIndicator class TRect; /** * TIndicator is the line and column counter in the lower left corner of the * edit window. * It is initialized by the @ref TEditWindow constructor and passed as the * fourth argument to the @ref TEditor constructor. * @short The line and column counter in the lower left corner of the edit * window */ class TIndicator : public TView { public: /** * Creates a TIndicator object. */ TIndicator( const TRect& ); /** * Draws the indicator. If variable @ref modified is True, a special * character (ASCII value 15, a star on PC graphic adapters) is displayed. */ virtual void draw(); /** * Returns the TIndicator default palette. */ virtual TPalette& getPalette() const; /** * Draws the indicator in the frame-dragging color if the view is being * dragged. */ virtual void setState( ushort, Boolean ); /** * Method called by @ref TEditor to update and display the values of the * data members of the associated TIndicator object. * @see TIndicator::location * @see TIndicator::modified */ void setValue( const TPoint& aLocation, Boolean aModified ); /** * Undocumented. */ static char dragFrame; /** * Undocumented. */ static char normalFrame; protected: /** * Stores the location to display. Updated by a TEditor. */ TPoint location; /** * True if the associated TEditor has been modified. */ Boolean modified; private: virtual const char *streamableName() const { return name; } protected: /** * Undocumented. */ TIndicator( StreamableInit ); public: /** * Undocumented. */ static const char * const name; /** * Called to create an object in certain stream reading situations. */ static TStreamable *build(); }; /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TIndicator& cl ) { return is >> (TStreamable&)cl; } /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TIndicator*& cl ) { return is >> (void *&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TIndicator& cl ) { return os << (TStreamable&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TIndicator* cl ) { return os << (TStreamable *)cl; } #endif // Uses_TIndicator #if defined( Uses_TEditor ) && !defined( __TEditor ) #define __TEditor class TRect; class TScrollBar; class TIndicator; class TEvent; /** * This class implements a text editor. * * TEditor is the base class for all editors. It implements most of the * editor's functionality. If a TEditor object is created, it allocates a * buffer of the given size out of the heap. The buffer is initially empty. * @short Implements a text editor */ class TEditor : public TView { public: /** * Constructor. * * Calls TView::TView(bounds) by creating a view with the given bounds. * The @ref hScrollBar, @ref vScrollBar, @ref indicator and @ref bufSize * data members are set from the given arguments. * @see TView::TView * * The scroll bar and indicator arguments can be set to 0 if you do not * want these objects. The following default values are set: * * 
     * Variable   Value                     Description
     *
     * canUndo    True                      @ref TEditor::canUndo
     * selecting  False                     @ref TEditor::selecting
     * overwrite  False                     @ref TEditor::overwrite
     * autoIndent False                     @ref TEditor::autoIndent
     * lockCount  0                         @ref TEditor::lockCount
     * keyState   0                         @ref TEditor::keyState
     * growMode   @ref gfGrowHiX | @ref gfGrowHiY     @ref TView::growMode
     * options    @ref ofSelectable              @ref TView::options
     * eventMask  @ref evMouseDown | @ref evKeyDown |
     *            @ref evCommand | @ref evBroadcast   @ref TView::eventMask
     *
* * `aBufSize' is the buffer initial size; 0 is its common value. * The buffer is allocated and cleared. If insufficient memory exists, * the @ref edOutOfMemory dialog box is displayed using * @ref editorDialog(), and @ref isValid data member is set False. * Otherwise @ref isValid is set True. * * The data members associated with the editor buffer are initialized in * the obvious way: @ref bufLen to 0, @ref gapLen to @ref bufSize, * @ref selStart to 0, @ref modified to False, and so on. */ TEditor( const TRect& bounds, TScrollBar *aHScrollBar, TScrollBar *aVScrollBar, TIndicator *aIndicator, uint aBufSize ); /** * Destructor. * * Destroys the editor and deletes the buffer. */ virtual ~TEditor(); /** * Used internally by @ref TObject::destroy() to ensure correct * destruction of derived and related objects. shutDown() is overridden * in many classes to ensure the proper setting of related data members * when @ref destroy() is called. */ virtual void shutDown(); /** * Returns the p'th character in the file, factoring in the gap. */ char bufChar( uint p ); /** * Returns the offset into buffer of the p'th character in the file, * factoring in the gap. */ uint bufPtr( uint p ); /** * Changes the views bounds, adjusting the @ref delta value and redrawing * the scrollbars and view if necessary. * * Overridden to ensure the file stays within view if the parent size * changes. */ virtual void changeBounds( const TRect& bounds ); /** * Used by @ref handleEvent() to provide basic editing operations by * converting various key events to command events. You can change or * extend these default key bindings by overriding the convertEvent() * member function. */ virtual void convertEvent( TEvent& event ); /** * Returns True if the @ref cursor (insertion point) is visible within the * view. */ Boolean cursorVisible(); /** * Deletes the selection if one exists. For example, after a successful * @ref clipCopy(), the selected block is deleted. */ void deleteSelect(); /** * Deletes the buffer. */ virtual void doneBuffer(); /** * Overrides @ref TView::draw() to draw the editor. */ virtual void draw(); /** * Returns the default TEditor palette. Override if you wish to change the * palette of the editor. */ virtual TPalette& getPalette() const; /** * Provides the event handling for the editor. Override if you wish to * extend the commands the editor handles. * * The default handler calls @ref TView::handleEvent(), then converts all * relevant editing key events to command events by calling * @ref convertEvent(). */ virtual void handleEvent( TEvent& event ); /** * Allocates a buffer of size @ref bufSize and sets @ref buffer to point * at it. */ virtual void initBuffer(); /** * This is the lowest-level text insertion member function. It inserts * `length' bytes of text from the array `p' (starting at p[offset]) into * the buffer (starting at the @ref curPtr). * * If `allowUndo' is set True, insertBuffer() records undo information. If * `selectText' is set True, the inserted text will be selected. * insertBuffer() returns True for a successful operation. * * Failure invokes a suitable dialog box and returns False. insertBuffer() * is used by @ref insertFrom() and @ref insertText(); you will seldom * need to call it directly. */ Boolean insertBuffer( char *p, uint offset, uint length, Boolean allowUndo, Boolean selectText ); /** * Inserts the current block-marked selection from the argument `editor' * into this editor. * This member function implements @ref clipCut(), @ref clipCopy(), and * @ref clipPaste(). * * The implementation may help you understand the insertFrom() and * @ref insertBuffer() functions: * * 
     * Boolean TEditor::insertFrom(TEditor *editor)
     * {
     *     return insertBuffer(editor->buffer,
     *         editor->bufPtr(editor->selStart),
     *         editor->selEnd - editor->selStart, canUndo, isClipboard());
     * }
     *
* * Note the the `allowUndo' argument is set to the value of the data * member @ref canUndo. The `selectText' argument will be True if there * is an active clipboard for this editor. */ virtual Boolean insertFrom( TEditor *editor ); /** * Copies `length' bytes from the given text into this object's buffer. * * If `selectText' is True, the inserted text will be selected. This is a * simplified version of @ref insertBuffer(). */ Boolean insertText( const void *text, uint length, Boolean selectText ); /** * Move column `x' and line `y' to the upper-left corner of the editor. */ void scrollTo( int x, int y ); /** * Search for the given string `findStr' in the editor @ref buffer * (starting at @ref curPtr) with the given options in `opts'. The valid * options are: * * 
     * Name              Value  Description
     *
* @ref efCaseSensitive   0x0001 Case sensitive search
* @ref efWholeWordsOnly  0x0002 Whole words only search
     *
* * Returns True if a match is found; otherwise returns False. If a match * is found, the matching text is selected. */ Boolean search( const char *findStr, ushort opts ); /** * Should be called before changing the buffer size to `newSize'. It * should return True if the the buffer can be of this new size. * * By default, it returns True if `newSize' is less than or equal to * @ref bufSize. */ virtual Boolean setBufSize( uint newSize ); /** * Enables or disables the given command depending on whether `enable' is * True or False and whether the editor is @ref sfActive. * @see TView::state * * The command is always disabled if the editor is not the selected view. * Offers a convenient alternative to @ref enableCommands() and * @ref disableCommands(). */ void setCmdState( ushort command, Boolean enable ); /** * Sets the selection to the given offsets into the file, and redraws the * view as needed. * * This member function will either place the cursor in front of or behind * the selection, depending on the value (True or False, respectively) of * `curStart'. */ void setSelect( uint newStart, uint newEnd, Boolean curStart ); /** * Overrides @ref TView::setState() to hide and show the indicator and * scroll bars. * * It first calls @ref TView::setState() to enable and disable commands. * If you wish to enable and disable additional commands, override * @ref updateCommands() instead. This is called whenever the command * states should be updated. */ virtual void setState( ushort aState, Boolean enable ); /** * Forces the cursor to be visible. If `center' is True, the cursor is * forced to be in the center of the screen in the y (line) direction. * The x (column) position is not changed. */ void trackCursor( Boolean center ); /** * Undoes the changes since the last cursor movement. */ void undo(); /** * Called whenever the commands should be updated. This is used to enable * and disable commands such as cmUndo and cmCopy. */ virtual void updateCommands(); /** * Returns whether the view is valid for the given command. By default it * returns the value of @ref isValid, which is True if @ref buffer is * not 0. */ virtual Boolean valid( ushort command ); /** * Calculates and returns the actual cursor position by examining the * characters in the buffer between `p' and `target'. * Any tab codes encountered are counted as spaces modulo the tab setting. * @see TEditor::charPtr */ uint charPos( uint p, uint target ); /** * The reverse of @ref charPos(). * Calculates and returns the buffer position corresponding to a cursor * position. */ uint charPtr( uint p, uint target ); /** * Returns False if this editor has no active clipboard. * Otherwise, copies the selected text from the editor to the clipboard * using clipboard->insertFrom(this). * @see TEditor::insertFrom * * The selected text is deselected (highlight removed) and the view * redrawn. Returns True if all goes well. */ Boolean clipCopy(); /** * The same as for @ref clipCopy(), but the selected text is deleted after * being copied to the clipboard. */ void clipCut(); /** * The reverse of @ref clipCopy(): the contents of the clipboard (if any) * are copied to the current position of the editor using * insertFrom(clipboard). * @see TEditor::insertFrom */ void clipPaste(); /** * If `delSelect' is True and a current selection exists, the current * selection is deleted; otherwise, the range `startPtr' to `endPtr' is * selected and deleted. */ void deleteRange( uint startPtr, uint endPtr, Boolean delSelect ); /** * If @ref updateFlags data member is 0, nothing happens. Otherwise, the * view and its scrollbars are updated and redrawn depending on the state * of the @ref updateFlags bits. * * For example, if ufView is set, the view is redrawn with * @ref drawView(). If the view is @ref sfActive, the command set is * updated with @ref updateCommands(). * @see TView::state * * After these updates, @ref updateFlags is set to 0. */ void doUpdate(); /** * Can be used in both find and find/replace operations, depending on the * state of @ref editorFlags data member bits and user-dialog box * interactions. * * If @ref efDoReplace is not set, doSearchReplace() acts as a simple * search for @ref findStr data member, with no replacement. Otherwise, * this function aims at replacing occurrences of @ref findStr with * @ref replaceStr data member. * * In all cases, if the target string is not found, an * editorDialog(@ref edSearchFailed) call is invoked. * @see TEditor::editorDialog * * If @ref efPromptOnReplace is set in @ref editorFlags, an * @ref edReplacePrompt dialog box appears. Replacement then depends on * the user response. If @ref efReplaceAll is set, replacement proceeds * for all matching strings without prompting until a cmCancel command is * detected. */ void doSearchReplace(); /** * Draws `count' copies of the line at `linePtr', starting at line * position `y'. */ void drawLines( int y, uint count, uint linePtr ); /** * Formats the line at `linePtr' in the given color and sets result in * `buff'. Used by @ref drawLines(). */ void formatLine(void *buff, uint linePtr, int x, ushort color); /** * Finds occurrences of the existing @ref findStr or a new user-supplied * string. find() displays an editor dialog inviting the input of a find * string or the acceptance of the existing @ref findStr. * * If a new find string is entered, it will replace the previous * @ref findStr (unless the user cancels). * find() first creates a @ref TFindDialogRec object defined as follows: * * 
     * struct TFindDialogRec
     * {
     *     TFindDialogRec(const char *str, ushort flgs)
     *     {
     *         strcpy(find, str);
     *         options = flgs;
     *     }
     *     char find[80];
     *     ushort options;
     * };
     *
* * The constructor is called with `str' set to the current @ref findStr, * and `flgs' set to the current @ref editorFlags. * * The @ref edFind editor dialog then invites change or acceptance of the * @ref findStr. Finally, @ref doSearchReplace() is called for a simple * find-no-replace (@ref efDoReplace switched off). */ void find(); /** * Returns the buffer character pointer corresponding to the point `m' on * the screen. */ uint getMousePtr( TPoint m ); /** * Returns True if a selection has been made; that is, if @ref selStart * does not equal @ref selEnd. If these two data members are equal, no * selection exists, and False is returned. */ Boolean hasSelection(); /** * Sets selecting to False and hides the current selection with * setSelect(curPtr, curPtr, False). * @see TEditor::curPtr * @see TEditor::setSelect */ void hideSelect(); /** * Returns True if this editor has an attached clipboard; otherwise * returns False. */ Boolean isClipboard(); /** * Returns the buffer pointer (offset) of the end of the line containing * the given pointer `p'. */ uint lineEnd( uint p ); /** * Moves the line containing the pointer (offset) `p' up or down `count' * lines depending on the sign of `count'. */ uint lineMove( uint p, int count ); /** * Returns the buffer pointer (offset) of the start of the line contaning * the given pointer `p'. */ uint lineStart( uint p ); /** * Increments the semaphore @ref lockCount. */ void lock(); /** * Inserts a newline at the current pointer. If @ref autoIndent is set, * appropriate tabs (if needed) are also inserted at the start of the new * line. */ void newLine(); /** * Returns the buffer offset for the character following the one at the * given offset `p'. */ uint nextChar( uint p ); /** * Returns the buffer offset for the start of the line following the line * containing the given offset `p'. */ uint nextLine( uint p ); /** * Returns the buffer offset for the start of the word following the word * containing the given offset `p'. */ uint nextWord( uint p ); /** * Returns the buffer offset for the character preceding the one at the * given offset `p'. */ uint prevChar( uint p ); /** * Returns the buffer offset for the start of the line preceding the line * containing the given offset `p'. */ uint prevLine( uint p ); /** * Returns the buffer offset corresponding to the start of the word * preceding the word containing the given offset `p'. */ uint prevWord( uint p ); /** * Replaces occurrences of the existing @ref findStr (or a new * user-supplied find string) with the existing @ref replaceStr (or a * new user-supplied replace string). * * replace() displays an editor dialog inviting the input of both strings * or the acceptance of the existing @ref findStr and @ref replaceStr. * If new strings are entered, they will replace the previous values * (unless the user cancels). * * replace() first creates a @ref TReplaceDialogRec object defined as * follows: * * 
     * struct TReplaceDialogRec
     * {
     *     TReplaceDialogRec(const char *str, const char *rep, ushort flgs)
     *     {
     *         strcpy(find, str);
     *         strcpy(replace, rep);
     *         options = flgs;
     *     }
     *     char find[80];
     *     char replace[80];
     *     ushort options;
     * };
     *
* * The constructor is called with `str' and `rep' set to the current * @ref findStr and @ref replaceStr, and with `flg' set to the current * @ref editorFlags. * * The @ref edReplace editor dialog then invites change or acceptance of * the two strings. * @see TEditor::editorDialog * * Finally, @ref doSearchReplace() is called for a find-replace operation * (@ref efDoReplace switched on). */ void replace(); /** * Sets @ref bufLen to `length', then adjusts @ref gapLen and @ref limit * accordingly. @ref selStart, @ref selEnd, @ref curPtr, delta.x, delta.y, * @ref drawLine, @ref drawPtr, @ref delCount, and @ref insCount are all * set to 0. * @see TEditor::delta * * @ref curPos is set to @ref delta, @ref modified is set to False, and * the view is updated and redrawn as needed. * * The TEditor constructor calls setBufLen(0). setBufLen() is also used * by @ref insertBuffer(). * @see TEditor::TEditor */ void setBufLen( uint length ); /** * Calls @ref setSelect() and repositions @ref curPtr to the offset `p'. * Some adjustments may be made, depending on the value of `selectMode', * if @ref curPtr is at the beginning or end of a selected text. */ void setCurPtr( uint p, uchar selectMode ); /** * Called by @ref handleEvent() when a Ctrl-K Ctrl-B selection is detected. * Hides the previous selection and sets @ref selecting to True. */ void startSelect(); /** * Toggles the @ref overwrite data member from True to False and from * False to True. Changes the cursor shape by calling @ref setState(). */ void toggleInsMode(); /** * Decrements the data member @ref lockCount until it reaches the value * 0, at which point a @ref doUpdate() is triggered. The lock/unlock * mechanism prevents over-frequent redrawing of the view. */ void unlock(); /** * Sets `aFlags' in the @ref updateFlags data member. If @ref lockCount * is 0, calls @ref doUpdate(). */ void update( uchar aFlags ); /** * Called by @ref handleEvent() in response to a cmScrollBarChanged * broadcast event. If the scroll bar's current value is different from * `d', the scroll bar is redrawn. */ void checkScrollBar( const TEvent& event, TScrollBar *p, int& d ); /** * Pointer to the horizontal scroll bar; 0 if the scroll bar does not * exist. */ TScrollBar *hScrollBar; /** * Pointer to the vertical scroll bar; 0 if the scroll bar does not exist. */ TScrollBar *vScrollBar; /** * Pointer to the indicator; 0 if the indicator does not exist. */ TIndicator *indicator; /** * Pointer to the buffer used to hold the text. */ char *buffer; /** * Size of the buffer (in bytes). */ uint bufSize; /** * The amount of text stored between the start of the buffer and the * current cursor position. */ uint bufLen; /** * The size of the "gap" between the text before the cursor and the text * after the cursor. */ uint gapLen; /** * The offset of the start of the text selected by Ctrl-K Ctrl-B. */ uint selStart; /** * The offset of the end of the text selected by Ctrl-K Ctrl-K. */ uint selEnd; /** * Offset of the cursor. */ uint curPtr; /** * The line/column location of the cursor in the file. */ TPoint curPos; /** * The top line and leftmost column shown in the view. */ TPoint delta; /** * The maximum number of columns to display, and the number of lines in * the file. Records the limits of the scroll bars. */ TPoint limit; /** * Column position on the screen where inserted characters are drawn. * Used internally by @ref draw(). */ int drawLine; /** * Buffer offset corresponding to the current cursor. Used internally by * @ref draw(). */ uint drawPtr; /** * Number of characters in the end of the gap that were deleted from the * text. Used to implement @ref undo(). */ uint delCount; /** * Number of characters inserted into the text since the last cursor * movement. Used to implement @ref undo(). */ uint insCount; /** * True if the view is valid. Used by the @ref valid() function. */ Boolean isValid; /** * True if the editor is to support undo. Otherwise False. */ Boolean canUndo; /** * True if the buffer has been modified. */ Boolean modified; /** * True if the editor is in selecting mode (that is, Ctrl-K Ctrl-B has * been pressed). */ Boolean selecting; /** * True if in overwrite mode; otherwise the editor is in insert mode. */ Boolean overwrite; /** * True if the editor is in autoindent mode. */ Boolean autoIndent; /** * The TEditorDialog data type is a pointer to function returning ushort * and taking one int argument and a variable number of additional * arguments. It is defined in `editors.h' as follows: * * 
     * typedef ushort (*TEditorDialog)(int, ...);
     *
* * Variable editorDialog is a function pointer used by TEditor objects to * display various dialog boxes. * * Since dialog boxes are very application-dependent, a TEditor object * does not display its own dialog boxes directly. Instead it controls * them through this function pointer. * * The various dialog values, passed in the first int argument, are * self-explanatory: @ref edOutOfMemory, @ref edReadError, * @ref edWriteError, @ref edCreateError, @ref edSaveModify, * @ref edSaveUntitled, @ref edSaveAs, @ref edFind, @ref edSearchFailed, * @ref edReplace and @ref edReplacePrompt. * * The default editorDialog, @ref defEditorDialog(), simply returns * cmCancel. */ static TEditorDialog editorDialog; /** * Variable editorFlags contains various flags for use in the editor: * * 
     * Name              Value  Description
     *
* @ref efCaseSensitive   0x0001 Default to case-sensitive search
* @ref efWholeWordsOnly  0x0002 Default to whole words only search
* @ref efPromptOnReplace 0x0004 Prompt on replace
* @ref efReplaceAll      0x0008 Replace all occurrences
* @ref efDoReplace       0x0010 Do replace
* @ref efBackupFiles     0x0100 Create backup files with a trailing ~ on saves
     *
* * The default value is @ref efBackupFiles | @ref efPromptOnReplace. */ static ushort editorFlags; /** * Stores the last string value used for a find operation. */ static char findStr[maxFindStrLen]; /** * Stores the last string value of a replace operation. */ static char replaceStr[maxReplaceStrLen]; /** * Pointer to the clipboard. * * Any TEditor can be the clipboard; it just needs be assigned to this * variable. The clipboard should not support undo (i.e., its @ref canUndo * should be false). */ static TEditor * clipboard; /** * Holds the lock count semaphore that controls when a view is redrawn. * lockCount is incremented by @ref lock() and decremented by * @ref unlock(). */ uchar lockCount; /** * A set of flags indicating the state of the editor. * @ref doUpdate() and other member functions examine these flags to * determine whether the view needs to be redrawn. */ uchar updateFlags; /** * Indicates that a special key, such as Ctrl-K, has been pressed. Used * by @ref handleEvent() to keep track of "double" control keys such * as Ctrl-K-H and Ctrl-K-B. */ int keyState; private: virtual const char *streamableName() const { return name; } protected: /** * Each streamable class needs a "builder" to allocate the correct memory * for its objects together with the initialized virtual table pointers. * * This is achieved by calling this constructor with an argument of type * @ref StreamableInit. */ TEditor( StreamableInit ); /** * Writes to the output stream `os'. */ virtual void write( opstream& os ); /** * Reads an editor object from the input stream `is'. */ virtual void *read( ipstream& is ); public: /** * Undocumented. */ static const char * const name; /** * Called to create an object in certain stream reading situations. */ static TStreamable *build(); }; /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TEditor& cl ) { return is >> (TStreamable&)cl; } /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TEditor*& cl ) { return is >> (void *&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TEditor& cl ) { return os << (TStreamable&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TEditor* cl ) { return os << (TStreamable *)cl; } #endif // Uses_TEditor #if defined( Uses_TMemo ) && !defined( __TMemo ) #define __TMemo class TEvent; /** * Data structure used by @ref TMemo. * @short Data structure used by TMemo */ struct TMemoData { /** * Undocumented. */ ushort length; /** * Undocumented. */ char buffer[1]; }; /** * TMemo, which is derived from TEditor, is designed for insertion into a * dialog or form. * @short Derived from TEditor and designed for insertion into a dialog or * form */ class TMemo : public TEditor { public: /** * Constructor. * @see TEditor::TEditor */ TMemo( const TRect& bounds, TScrollBar *aHScrollBar, TScrollBar *aVScrollBar, TIndicator *aIndicator, uint aBufSize ); virtual void getData( void *rec ); virtual void setData( void *rec ); /** * Used with @ref getData() and @ref setData(), which are inherited from * TView and redefined. By default it returns (sizeof(ushort) + * @ref bufSize). */ virtual ushort dataSize(); /** * Returns the default memo palette. */ virtual TPalette& getPalette() const; /** * Prevents TMemo from handling kbTab key events; otherwise handles * events the same as a @ref TEditor. * @see TEditor::handleEvent */ virtual void handleEvent( TEvent& ); private: virtual const char *streamableName() const { return name; } protected: /** * Each streamable class needs a "builder" to allocate the correct memory * for its objects together with the initialized virtual table pointers. * * This is achieved by calling this constructor with an argument of type * @ref StreamableInit. */ TMemo( StreamableInit ); /** * Writes to the output stream `os'. */ virtual void write( opstream& ); /** * Reads from the input stream `is'. */ virtual void *read( ipstream& ); public: /** * Undocumented. */ static const char * const name; /** * Called to create an object in certain stream-reading situations. */ static TStreamable *build(); }; /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TMemo& cl ) { return is >> (TStreamable&)cl; } /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TMemo*& cl ) { return is >> (void *&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TMemo& cl ) { return os << (TStreamable&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TMemo* cl ) { return os << (TStreamable *)cl; } #endif // Uses_TMemo #if defined( Uses_TFileEditor ) && !defined( __TFileEditor ) #define __TFileEditor #include class TRect; class TScrollBar; class TIndicator; class TEvent; /** * TFileEditor is a specialized derivative of TEditor for editing the contents * of a file. * @short Specialized derivative of TEditor for editing the contents of a file */ class TFileEditor : public TEditor { public: /** * The name of the file being edited. */ char fileName[PATH_MAX]; /** * Creates a TFileEditor object with the given scroll bars and indicator * and loads the contents of the file given in `aFileName'. * * If the file is not found or invalid, an error message will be displayed * and the object's @ref valid() member function will return False. * * The @ref options variable is set to @ref ofSelectable and the * @ref eventMask is set to allow the handling of broadcast events. * * Any of `aHScrollBar', `aVScrollBar' or `aIndicator' arguments can be * set to 0 if you do not want them. */ TFileEditor( const TRect& bounds, TScrollBar *aHScrollBar, TScrollBar *aVScrollBar, TIndicator *aIndicator, const char *aFileName ); /** * Deletes the buffer. */ virtual void doneBuffer(); /** * Calls @ref TEditor::handleEvent(), then handles cmSave and cmSaveAs * commands. * * The cmSave command invokes @ref save(); the cmSaveAs command invokes * @ref saveAs(). */ virtual void handleEvent( TEvent& ); /** * Allocates @ref bufSize bytes of memory for the file editor buffer. */ virtual void initBuffer(); /** * Reads the @ref fileName file from disk and checks for errors. * * Returns True if all is well; otherwise returns False. Depending on the * reason for failure, the @ref edOutOfMemory or @ref edReadError dialog * box is displayed with a call to @ref editorDialog(). */ Boolean loadFile(); /** * Calls @ref saveAs() if the file being edited is "Untitled" (that is, no * @ref fileName is allocated) and returns the return value from * @ref saveAs(). * * If there is a valid @ref fileName, @ref saveFile() is invoked, and * save() returns the return value of @ref saveFile(). */ Boolean save(); /** * Invokes the @ref edSaveAs dialog, which prompts for a "save as" file * name. If a valid file name is supplied, the current text will be saved * with this name using the @ref saveFile() member function. * @see editorDialog * * The file editor's owner is informed of this event via a broadcast * cmUpdateTitle message. saveAs() returns True if the @ref saveFile() * call is successful, otherwise False is returned. * * False is also returned if the @ref edSaveAs dialog is cancelled. */ Boolean saveAs(); /** * Saves the @ref fileName file to disk. Returns False if the save fails; * otherwise returns True. If @ref editorFlags has the @ref efBackupFiles * bit set, a backup file is created. * * The @ref edCreateError or @ref edWriteError dialog box will be * displayed to indicate the reason for failure if save fails. * @see editorDialog */ Boolean saveFile(); /** * Overrides @ref TEditor::setBufSize() to grow and shrink the buffer. * * Will grow and shrink the buffer in 4K byte increments. @ref gapLen * data member is adjusted appropriately. */ virtual Boolean setBufSize( uint newSize ); /** * Undocumented. */ virtual void shutDown(); /** * Calls @ref TEditor::updateCommands(), then enables the cmSave and * cmSaveAs commands. These commands are only valid if the selected view * is an editor, otherwise they should be disabled. */ virtual void updateCommands(); /** * Overrides @ref TEditor::valid() to warn that the file might need saving * before the program exits. * * The @ref edSaveUntitled or @ref edSaveModify dialogs are displayed as * appropriate. * @see editorDialog * * Returns False if the user cancels the save. */ virtual Boolean valid( ushort ); private: static const char * backupExt; virtual const char *streamableName() const { return name; } protected: /** * Each streamable class needs a "builder" to allocate the correct memory * for its objects together with the initialized virtual table pointers. * * This is achieved by calling this constructor with an argument of type * @ref StreamableInit. */ TFileEditor( StreamableInit ); /** * Writes to the output stream `os'. */ virtual void write( opstream& ); /** * Reads from the input stream `is'. */ virtual void *read( ipstream& ); public: /** * Undocumented. */ static const char * const name; /** * Called to create an object in certain stream-reading situations. */ static TStreamable *build(); }; /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TFileEditor& cl ) { return is >> (TStreamable&)cl; } /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TFileEditor*& cl ) { return is >> (void *&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TFileEditor& cl ) { return os << (TStreamable&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TFileEditor* cl ) { return os << (TStreamable *)cl; } #endif // Uses_TFileEditor #if defined( Uses_TEditWindow ) && !defined( __TEditWindow ) #define __TEditWindow class TFileEditor; /** * TEditWindow is a window designed to hold a @ref TFileEditor or the * clipboard. * * It will change its title to display the file name being edited and will * initialize scroll bars and an indicator for the editor. * @see TIndicator * @short Designed to hold a TFileEditor or the clipboard */ class TEditWindow : public TWindow { public: /** * Creates a TEditWindow object that will edit the given file name with * window number `aNumber'. Initializes a framed, tileable window with * scroll bars and an indicator. If `fileName' is 0, it is assumed to be * an untitled file. * * Note: if @ref editor data member is equal to @ref TEditor::clipboard * static data member, the editor is assumed to be the clipboard. */ TEditWindow( const TRect& bounds, const char *fileName, int aNumber ); /** * Overrides @ref TWindow::close() to hide rather than close the window * if the editor is a clipboard. */ virtual void close(); /** * Returns the name of the file being edited, or "Clipboard" if the editor * is the clipboard. */ virtual const char *getTitle( short ); /** * Handles cmUpdateTitle to redraw the frame of the window. Used in * @ref TFileEditor::saveAs() to change the title of the window if the * file being edited changes names. */ virtual void handleEvent( TEvent& event ); /** * Undocumented. */ virtual void sizeLimits( TPoint& min, TPoint& max ); /** * Pointer to the editor associated with this window. */ TFileEditor *editor; private: static const char * clipboardTitle; static const char * untitled; virtual const char *streamableName() const { return name; } protected: /** * Each streamable class needs a "builder" to allocate the correct memory * for its objects together with the initialized virtual table pointers. * * This is achieved by calling this constructor with an argument of type * @ref StreamableInit. */ TEditWindow( StreamableInit ); /** * Writes to the output stream `os'. */ virtual void write( opstream& ); /** * Reads from the input stream `is'. */ virtual void *read( ipstream& ); public: /** * Undocumented. */ static const char * const name; /** * Called to create an object in certain stream-reading situations. */ static TStreamable *build(); }; /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TEditWindow& cl ) { return is >> (TStreamable&)cl; } /** * Undocumented. */ inline ipstream& operator >> ( ipstream& is, TEditWindow*& cl ) { return is >> (void *&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TEditWindow& cl ) { return os << (TStreamable&)cl; } /** * Undocumented. */ inline opstream& operator << ( opstream& os, TEditWindow* cl ) { return os << (TStreamable *)cl; } #endif // Uses_TEditWindow #if defined( Uses_TFindDialogRec ) && !defined( __TFindDialogRec ) #define __TFindDialogRec #include /** * Data record used by TEditor. * @see TEditor::find * @see TReplaceDialogRec * @see TView::dataSize * @see TView::getData * @see TView::setData */ struct TFindDialogRec { /** * Undocumented. */ TFindDialogRec( const char *str, ushort flgs ) { strcpy( find, str ); options = flgs; } /** * Undocumented. */ char find[maxFindStrLen]; /** * Undocumented. */ ushort options; }; #endif // Uses_TFindDialogRec #if defined( Uses_TReplaceDialogRec ) && !defined( __TReplaceDialogRec ) #define __TReplaceDialogRec #include /** * Data record used by TEditor. * @see TEditor::replace * @see TFindDialogRec * @see TView::dataSize * @see TView::getData * @see TView::setData */ struct TReplaceDialogRec { /** * Undocumented. */ TReplaceDialogRec( const char *str, const char *rep, ushort flgs ) { strcpy( find, str ); strcpy( replace, rep ); options = flgs; } /** * Undocumented. */ char find[maxFindStrLen]; /** * Undocumented. */ char replace[maxReplaceStrLen]; /** * Undocumented. */ ushort options; }; #endif // Uses_TReplaceDialogRec