Creating a text editing command

MTextRepresentation provides a set of functions that your commands can call to modify the encapsulated data. These functions act on the TTextArea encapsulated by the target selection. You can retrieve the TTextArea with the MTextSelection::GetTextArea function.

These functions are:

• ReplaceText deletes the text in the selected range, if the selection is not an insertion point, and inserts the replacement text. Any styling information associated with the replacement text is retained when it is inserted into the text representation object. Use this function for programmatic editing.
• TypeText deletes the text in the selected range, if the selection is not an insertion point, and inserts the replacement text at the selection offset. The styles associated with the selection offset are propagated to the inserted text. Use this function for editing via keyboard input.
• RemoveText deletes the text in the selected range.
• AddStyles applies the specified styles to the characters in the selected range of text. Paragraph styles are applied to all paragraphs that intersect the selected range. Adding styles to an insertion point selection changes the typing styles that are propagated to text entered at that point.
• RemoveStyles removes the specified styles from the characters and paragraphs in the selected range of text.
• ReplaceStyles replaces the current styles in the selected range of text with the specified styles.

• Retrieve the encapsulated text object and call the appropriate TText modification functions (this portion is actually implemented by the appropriate protected Handle function in each concrete text representation class).
• Increment the time stamp stored by the text representation object.
• Issue notification to other interested objects--for example, views.

1. Provide standard constructors (an empty constructor and a copy constructor) and a destructor.
   
2. Provide streaming operators and other MCollectible overrides as appropriate for your implementation.
   
3. Override the necessary command member functions inherited from TCommandOn<MTextSelection>. You must override the TCommandOn<ATarget> function HandleDoBegin.
   If your command will be executed incrementally, also override:
   
   • HandleDoIncrement
   • HandleDoEnd
   You might also need to override:
   
   • HandleUndo
   • HandleRedo
   • HandleCanDo (returns True by default)
   • HandleCanUndo (returns True by default)
   • HandleCanRedo (returns True by default)
   See the information on commands in the manual Desktop Frameworks Concepts and the online class and member function documentation for TCommandOn<ATarget> for specific information on these functions. This information will help you determine which command functions you need to override for your command implementation.
   
4. Maintain the necessary data to support Undo and Redo for the command.
   

TReplaceTextCommand declaration

  // Copyright (C) 1994 Taligent, Inc. All rights reserved.
  class TReplaceTextCommand : public TCommandOn<MTextSelection>
  {
      public:
                               TReplaceTextCommand ();
                               TReplaceTextCommand(const TReplaceTextCommand&);
          virtual                  ~TReplaceTextCommand ();
  
  
        virtual void         SetText(const TText& text);
          virtual const TText* GetText() const;
  
          virtual TStream&     operator>>=(TStream&) const;
          virtual TStream&     operator<<=(TStream&);
          TReplaceTextCommand  &operator=(const TReplaceTextCommand&);
          MCollectibleDeclarationsMacro (TReplaceTextCommand);
  
      protected:
  
        virtual void         HandleDoBegin(MTextSelection&);
          virtual void         HandleUndo(MTextSelection&);
          virtual void         HandleRedo(MTextSelection&);
  
      private:
  
        TText* fDoText;
          TText* fUndoText;
          TTextArea fDoRegion;
          TTextArea fUndoRegion;
  };
  

TReplaceTextCommand implementation

  // Copyright (C) 1994 Taligent, Inc. All rights reserved.
  MCollectibleDefinitionsMacro(TReplaceTextCommand, 0);
  
  TReplaceTextCommand::TReplaceTextCommand ()
  : TCommandOn<MTextSelection>(TCommonCommand::kSerialUndo),
    fDoText(NIL),
    fUndoText(NIL)
  {
  }
  
  TReplaceTextCommand::TReplaceTextCommand (const TReplaceTextCommand& copy)
  : TCommandOn<MTextSelection>(copy),
    fDoText(NIL),
    fUndoText(NIL)
  {
      fDoText = ::CopyPointer(copy.fDoText);
      fUndoText = ::CopyPointer(copy.fUndoText);
      fDoRegion = copy.fDoRegion;
      fUndoRegion = copy.fUndoRegion;
  }
  
  
  TReplaceTextCommand::~TReplaceTextCommand ()
  {
      delete fDoText;
      delete fUndoText;
  }
  
  void
  TReplaceTextCommand::SetText (const TText& text)
  {
      if (fDoText != &text) {
          delete fDoText;
          fDoText = ::Copy(text);
      }
  }
  
  const TText*
  TReplaceTextCommand::GetText()const
  {
      if ( fDoText == NIL )
          ((TReplaceTextCommand*)this)->fDoText = new TStandardText;
      
      return fDoText;
  }
  
  TStream&
  TReplaceTextCommand::operator>>= (TStream& toWhere)const
  {
      WriteVersion(toWhere);
      TCommandOn<MTextSelection>::operator>>=(toWhere);
  
      ::Flatten(fDoText, toWhere);
      ::Flatten(fUndoText, toWhere);
      fDoRegion >>= toWhere;
      fUndoRegion >>= toWhere;
      return toWhere;
  }
  
  TStream&
  TReplaceTextCommand::operator<<= (TStream& fromWhere)
  {
      VersionInfo version = ReadVersion(fromWhere);
      TCommandOn<MTextSelection>::operator<<=(fromWhere);
  
      switch(version) {
  
    case 0: 
          delete fDoText;
          delete fUndoText;
          ::Resurrect(fDoText, fromWhere);
          ::Resurrect(fUndoText, fromWhere);
          fDoRegion <<= fromWhere;
          fUndoRegion <<= fromWhere;
          break;
      default:
          throw TInvalidVersionError();
      }
      return fromWhere;
  }
  TReplaceTextCommand&
  TReplaceTextCommand::operator= (const TReplaceTextCommand& obj)
  {
      if(&obj != this) {
          TCommandOn<MTextSelection>::operator=(obj);
          delete fDoText;
          delete fUndoText;
          fDoText = ::CopyPointer(obj.fDoText);
          fUndoText = ::CopyPointer(obj.fUndoText);
          fDoRegion = obj.fDoRegion;
          fUndoRegion = obj.fUndoRegion;
      }
      return *this;
  }
  
  void
  TReplaceTextCommand::HandleDoBegin(MTextSelection& selection)
  {
  
    fDoRegion = selection.GetTextArea();
      fUndoRegion = fDoRegion;
      
  
    MTextRepresentation* model = selection.GetTextForWriting();
      delete fUndoText;
      TTextRange firstRange;
      selection.GetFirstRange(firstRange);
      fUndoText = (model->GetText())->PartialCopy(firstRange);
      
  
    model->ReplaceText(*GetText(), fDoRegion);
      
  
    TTextCount textLength = GetText()->GetLength();
      if (textLength == 0) {
          fUndoRegion.SetInsertionOffset(firstRange.GetBegin());
      }
      else {
          firstRange.SetEnd( firstRange.GetBegin() + textLength );
          fUndoRegion.SetRange(firstRange);
      }
  
  
    selection.SetTextArea(fUndoRegion);
  }
  
  void
  TReplaceTextCommand::HandleUndo (MTextSelection& selection)
  {
      MTextRepresentation* model = selection.GetTextForWriting();
      model->ReplaceText(*fUndoText, fUndoRegion);
      selection.SetTextArea(fDoRegion);
  }
  
  void
  TReplaceTextCommand::HandleRedo (MTextSelection& selection)
  {
      MTextRepresentation* model = selection.GetTextForWriting();
      model->ReplaceText(*GetText(), fDoRegion);
      selection.SetTextArea(fUndoRegion);
  }