Class TWPCustomRtfEdit

You can use this event to implement text macros or automatic correction

This event can be used to add custom objects to the clipboard

This event is triggered after an image was saved.

This event is triggered after text was loaded using LoadFromStrea, AsString or LoadFromFile. It will also be triggered if text was inserted or pasted! This event can be used to preprocess the loaded text, for example to set protection markers.

This event makes it possible to draw on the desktop after the previous paint routine (OnPaintDesktopBackground or the default) was executed

This event is triggered after a single image (not beeing part of a RTF stream) has been pasted into the text. Using the provided txtobj reference it is possible to change its size and position.

This event is triggered before the text is changed.

This event is triggered before a paragraph is initialized. This happens after each change in the paragraph. This event makes it possible to prepocess the paragraph, for example to hide it "include(par.prop, paprHidden)" or to change the attributes depending on the contents of the paragraph.
This example hides paragraphs which contain empty merge fields and spaces only:

 
      if par.HasObjects(false,[wpobjMergeField]) and
      not par.IsNonSpace([wpobjMergeField]) then
      include(par.prop, paprHidden)
      else  exclude(par.prop, paprHidden);
       

This code applies a special character style to bookmarked text. It needs a global integer variable "charstyleid".

 
      var i  : Integer;
          inner_book : TWPTextObj;
      begin
         // This only done once!
         if charstyleid=0 then
         with WPRichText1.ParStyles.Add('CH1') do
         begin
            TextStyle.ASetColor( WPAT_CharBGColor, clGreen);
            TextStyle.ASetCharStyle(tsTRUE, WPSTY_BOLD  );
            charstyleid := id;
         end;


         for I := 0 to par.CharCount-1 do
         begin
            inner_book := WPRichText1.CodeInsideOf(par,i,wpobjBookmark);
               if inner_book>nil then
               begin
                 WPRichText1.AttrHelper.CharAttr := par.CharAttr[i];
                 WPRichText1.AttrHelper.ASet(WPAT_CharStyleSheet, charstyleid );
                 par.CharAttr[i] := (par.CharAttr[i] and $FF000000)  or
                    WPRichText1.AttrHelper.CharAttr;
               end;
         end;
      end;
       

This event is triggered before a file is overwritten by the editor. We suggest to make a backup copy of the existing file, maybe even support different versions. Backup copies can be also created in special designated 'backup' directories.

With WPTools Premium this event allows it to draw a colored background for the text boxes. The background can vary depending on the current cursor position.

 
       if InEditor and IsEditing and (RTFData.Kind = wpIsOwnerSelected) then
        begin
          Canvas.Brush.Style := bsSolid;
          Canvas.Brush.Color := $eaefea;
          Canvas.FillRect(r);
        end;
        

This event is triggered before an image was pasted into the text. It will be nalso triggered for each image which is part of an RTF stream.
The property InsertedObj is assigned when the event BeforePasteImage has been triggered for images which are part of pasted RTF text. If an image was pasted as object loaded from the clipboard, InsertedObj will be nil since the event happens before the bitmap is actually inserted into the text.

This event is executed after text was loaded from the clipboad and before it is inserted at the cursor position. This event makes it possible to modify the text before it is inserted!
This Example changes the attributes of the inserted text to 'Courier, 10.5, blue':

 
      procedure TForm1.WPRichText1BeforePasteText(Sender: TObject;
      RTFData: TWPRTFDataCollection; par: TParagraph; Stream: TStream;
      Reader: TWPCustomTextReader; OnlyBodyText: Boolean;
      var LoadedText: TWPRTFDataBlock);
      var i : Integer;
      CharAttrIndex : Cardinal;
      begin
      // This is an example to change the format
      // of all inserted text to a given font and size


      // 'AttrHelper' is our working horse to create the attribute
      RTFData.RTFProps.AttrHelper.Clear;
      RTFData.RTFProps.AttrHelper.SetFontName('Courier New');
      RTFData.RTFProps.AttrHelper.SetFontSize(10.5);
      RTFData.RTFProps.AttrHelper.SetColor(clBlue);
      CharAttrIndex := RTFData.RTFProps.AttrHelper.CharAttr;


      // At this point we can calculate another CharAttrIndex


      while par>nil do
      begin
      for i:=0 to par.CharCount-1 do
      begin
      par.CharAttr[i] := CharAttrIndex;
      end;
      par := par.next;
      end;
      end;
       

This example converts a hyperlink before it is pasted:

 
          procedure TForm1.WPRichText1BeforePasteText(Sender: TObject;
            RTFData: TWPRTFDataCollection; par: TParagraph; Stream: TStream;
            Reader: TWPCustomTextReader; OnlyBodyText: Boolean;
            var LoadedText: TWPRTFDataBlock);
          var
              s : string;
              a : Cardinal;
          begin
            if (par.Next=nil)
               and (par.StartWithW('http://') or par.StartWithW('https://'))
               and not par.HasText(#32)
            then
            begin
               s := par.GetText(false, false);
               a := par.CharAttr[0];
               par.ClearText;
               par.AppendNewObjectPair(wpobjHyperlink,'link',a).Source := s;
            end;
          end;
       

This event is triggered before the control is resized - you can use it to adjust the zooming value.

This event is triggered wheh the user clicks on a link. The parameter 'IgnoredNumber' has no meaning. The link object is accessible as property HyperlinkObj

This event can be used to overwrite the page numbers which are internally calculated. You can check for the name of the TextObject. It can have the following values: PAGE, NUMPAGES, NEXTPAGE, PRIORPAGE and SECTIONPAGES. The passed RTFPageNr is 0 based. The passed PaintPageNr can be -1 if the event is not executed from painting code, othewise it is the 0 based number of the current page page (see WPRichText1.Memo.ExternPageRefAdd).
Note, if the var PrintedPageNr is set to 0 nothing will be printed!

This event is triggered after the text was changed.

This event is triggered after the cursor has been moved. It is triggered asynchronly, in the next idle state.

This event is triggered when the layout mode, autozoom or zooming is changed

This event is triggered when the CurrentZooming

This event is triggered after a Clear of the TWPRTFDataCollection

This event makes it possible to set the 'range' for a newly created header or footer. It is triggered after a double click in the header or footer area. To abort the creation of a header or footer set the 'Range' to wpraIgnored. This is the default value unless the flag wpDblClickCreateHeaderFooter was used in property EditOptionsEx.

This event is triggered when the use clicks on text which is surrounded by objects which types are present in the property ClickableCodes

This event is used like OnCustomLinePaintBefore but is triggered after the text has been rendered. This makes it possible to draw over the text. Param is an object which is usually reused for each paragraph. FirstRect is initialized to the rectangle of the first line of this paragraph on the page. Rect is the current rectangle. If the property UseUntilIncludingPar is set to a certain paragraph the object is reused for all paragraphs until the given one. If CallAgainToClose has been set to TRUE the event is triggered again after the last line.
The following example draws a line around each paragraph or consecuative paragraphs starting with one which contains $start and ends with one which containes $end.

 
      procedure Form1.WPRichText1CustomLinePaintAfter(Sender: TObject;
      RTFEngine: TWPRTFEngineBasis; Param: TWPVirtPagePaintParam;
      EndOfPageRun: Boolean);
      var r: TRect; par: TParagraph;
      begin
      if not EndOfPageRun then
      begin
      if Param.Tag = 0 then
      begin
      par := Param.Par;
      if par.HasText('$start') then
      begin
      while par > nil do
      begin
      if par.HasText('$end') then
      break;
      par := par.next;
      end;
      Param.UseUntilIncludingPar := par;
      end;
      end;
      Param.Tag := 1;
      Param.CallAgainToClose := TRUE;
      end
      else
      begin
      r := Param.UnionRect;
      Param.Canvas.Brush.Style := bsClear;
      Param.Canvas.Pen.COlor := clRed;
      Param.Canvas.Pen.Width := 0;
      Param.Canvas.Rectangle(
      r.Left, r.Top, r.Right, r.Bottom);
      end;
      end;  

Note: The API UnionRect() deals differently with rectangle which have a height of 0 than Param.UnionRect!.

This event is used like OnCustomLinePaintAfter but is triggered before the text has been rendered. This makes it possible to draw to the background of the text.
This example code will draw brackets into the left margin to show how paragraphs are linked together using the KeepN property:

 
      procedure TWPTBXForm.WPRichText1CustomLinePaintBefore(Sender: TObject;
      RTFEngine: TWPRTFEngineBasis; Param: TWPVirtPagePaintParam;
      EndOfPageRun: Boolean);
      var r: TRect; o: Integer; par: TParagraph; thiskeep, prevkeep, nextkeep: Boolean;
      begin
      if (Param.Par.ParentTable = nil) and (Param.PaintingInEditor) then
      begin
      if not EndOfPageRun then
      begin
      Param.CallAgainToClose := TRUE; // Make sure we get that EndOfPageRun!
      end else
      begin
      par := Param.Par.prev;
      prevkeep := (par > nil) and (par.AGetDef(WPAT_ParKeepN, 0) = 1);
      thiskeep := Param.par.AGetDef(WPAT_ParKeepN, 0) = 1;
      nextkeep := TRUE;
      par := Param.Par.next;
      if (par = nil) or (par.AGetDef(WPAT_ParKeepN, 0) = 0) then
      begin
      nextkeep := FALSE;
      end;
      r := Param.UnionRect;
      o := 30;
      Param.Canvas.Pen.Width := 0;
      Param.Canvas.Pen.Color := clRed;
      if thiskeep and not prevkeep then
      begin
      Param.Canvas.MoveTo(r.Left, r.Top);
      Param.Canvas.LineTo(r.Left - o, r.Top);
      end;


      if thiskeep or prevkeep then
      begin
      Param.Canvas.MoveTo(r.Left - o, r.Top);
      Param.Canvas.LineTo(r.Left - o, r.Bottom);
      end;


      if not thiskeep and prevkeep and not nextkeep then
      begin
      Param.Canvas.MoveTo(r.Left - o, r.Bottom);
      Param.Canvas.LineTo(r.Left, r.Bottom);
      end;
      end;
      end;
      end;




       

This event is triggered in the next idle cycle after the StartUpdate procedure

This event is triggered before a text underline is drawn. It makes it possible to either change the LineMode and LineColor according to the context or to capture the rectangle where a hyperlink is located. If the original line drawing code should not be executed, set Ignore=true.
Example:

 
    procedure TWPMiniEd.DoDrawUnderline(
               Sender : TObject;
               Engine: TWPRTFEnginePaint;
               Stage : TWPDrawStage;
               Canvas: TCanvas;
               R        : TRect;
               SpecialTextFlags: TWPSpecialCharacterAttrKinds;
               BaseY    : Integer;
               var LineMode : Integer;
               var LineColor: TColor;
               PaintMode : TWPPaintModes;
               xres,yres : Integer;
               par   : TParagraph;
               posinpar : Integer;
               var Ignore : Boolean
             );
    var obj : TWPTextObj;
    begin
      if (wpHyperlink in SpecialTextFlags) and (wpDrawBackground in Stage) then
      begin
           obj := par.ObjectRef[posinpar];
           if (obj=nil) or (obj.ObjType>wpobjHyperlink) then
           obj := (Sender as TWPRichText).CodeInsideOf(par,posinpar,wpobjHyperlink);
           if (obj>nil) and (Pos('wpcubed.com',obj.Source)>0) then
           Canvas.Brush.Color := $FAAAFA
           else  Canvas.Brush.Color := $FAAAAA;
           Canvas.Rectangle(r);
      end;
    end;
     

This event is used with EditBoxModes

This event is used with EditBoxModes

This event is only used when ppAllExceptForEditFields was used in ProtectedProp. Then it is possible to check the text and validate it against type and length constraints of an attached field.

This event can be used to customize the display of special text at runtime. The event is only called if the UseOnAttrColorEvent flag has been set in the special attribute property, i.e. InsertPointTextAttr.

 
     procedure TWPMiniEd.WPRichText1GetAttributeColor(Sender: TObject;
            var CharStyle: TCharacterAttr; par: TParagraph; posinpar: Integer);
     begin
          if CharStyle.CharStyle=wpInsertpoints then
          begin
               CharStyle.BackgroundColor := clYellow;
               CharStyle.UseBackgroundColor := true;
          end;
     end;
      

In the event you can modify the flag "AlsoUseForPrintout" which defaults to the setting in the special text property. Only if AlsoUseForPrintout is true, the setting will be used at printtime.
If you

    WPRichText1.Memo.SpecialTextFlagsForAllText := [wpBookmarkedText];

    

This function can be used to calculate the the string which should be displayed under thumbnails or between the pages. It is activated by the Viewption wpShowPageNRinGap. Please note that the 'Sender' of this event is the RTF.Engine class (TWPRTFEnginePaint) not the editor box

This event makes it possible to select special header or footer for certain pages. To select the header or footer text block, the name can be used. Use WPRichText.HeaderFooter.Get(...) to get a reference to a text block.

This event is triggered to modify the text displayed for a hyperlink start and end tag. It can be used the same way as OnTextObjGetTextEx.
The event will only be triggered if FormatOptions include the flag wpShowHyperlinkCodes!

This event is triggered after the RTFData has been created and the FormatOptions and Header properties have been assigned. Please note that this event will be only triggered for RTFData objects which are created by the memo control, not for objects which are created outside. If you want to attach a global RTFData or RTFProps object use .

This event is triggered when the RTFData or RTFProps are required the first time. This is the chance to get the objects from a different RTFEditor to have 2 editors working with the same text.
Alternatively you can assign a global TWPRTFProps object to make different RTF editors work with different texts but the same properties, such as style and color tables:

 
      WPGlobalRTFProps : TWPRTFProps; // global variable


      // in the main form, the MDI parent
      procedure TWPGlobalStyle.FormCreate(Sender: TObject);
      begin
      // Inititialize WPGlobalRTFProps
      WPGlobalRTFProps := TWPRTFProps.Create(nil);
      end;
      // in the MDI child:
      procedure TWPGlobalStyleChild.WPRichText1InitializeRTFDataObject(
      Sender: TObject; var RTFDataObject: TWPRTFDataCollection;
      var RTFPropsObject: TWPRTFProps);
      begin
      RTFPropsObject := WPGlobalRTFProps;
      end;
       

This event makes it possible to modify the paragraph before and after it was painted. It is called in four stages, before and after text output and before and after cell line drawing. So it is possible to change the paragraph text attributes (mostly colors) and draw custom borders.

 
      // Color paragraphs which are inside of an bookmark
      procedure TForm1.WPRichText1InternPaintPar(Sender: TObject;
            Stage: TWPInternPaintParEventStage; Editor: TWPRTFEnginePaint;
            var LineData: TWPVirtPageImageLineRef; ThisRTFpage: TWPVirtPage;
            Par: TParagraph; LineNr: Integer; Canvas: TCanvas; var ParColorOverride,
            TextColorOverride: TColor; var AnyObject: TObject; var IgnoreOutput: Boolean); begin
            if (Stage=wpBeforeLineText) and
               not Par.HasObjects(false, [wpobjBookmark]) and
               (WPRichText1.CodeInsideOf(par,0,wpobjBookmark)=nil)
            then
            begin
               Canvas.Brush.Color := clLime;
               Canvas.FillRect(Rect(LineData.x, LineData.Y, LineData.x+LineData.w, LineData.Y+LineData.h));
            end;
          end;
       

 
      // Check each character in a line and color background
           var i, l, x : Integer;
          inner_book : TWPTextObj;
      begin
          if (Stage=wpBeforeLineText)  then
          begin
             Canvas.Brush.Color := clLime;
             l := par.LineLength(LineNr);
             i := Par.LineOffset(LineNr);
             x := LineData.x;


             while l>0 do
             begin
                 inc(x, par.CharPos[i].xoff);
                 inner_book := WPRichText1.CodeInsideOf(par,i,wpobjBookmark);
                 if inner_book>nil then
                 begin
                    // set color based on    inner_book.Name
                    Canvas.FillRect(Rect(x, LineData.Y, x+par.CharPos[i].Width, LineData.Y+LineData.h));
                 end;
                 inc(i);
                 dec(l);
             end;
          end;
      end;
       

This event can be used to verify if a change of the current data block is allowed. You can check the current and the new RTFDataBlock and set Allowed to true to allow the change or to false to forbid it.
This code will disable the editing of any footer text:

 
      procedure TForm1.WPRichText1LeaveRTFDataBlock(Sender: TObject; FromBlock,
        ToBlock: TWPRTFDataBlock; var Allowed: Boolean);
      begin
       Allowed := ToBlock.Kind > wpIsFooter;
      end; 

Please note: If the anchor of a text box is in the header and the tex box is clicked, the header will be activated anyway. This is necessary because otherwise reizing and moving would not be possible. You can use EditOptionsEx2: wpDontSelectImageIn

This event is triggered when the MergeText or MergeEnumFields procedure is used

This event makes it possible to change the size of any page.

This event is used for context menuse. It is triggered usually when the ContextMenu key was pressed, or the right mouse button. You can set the flag wpDontTriggerPopupInContextEvent in EditOptionsEx, then this event will be always triggered in the MouseDown event.

This event is triggered when a new RTFDataBlock is created. This happens at load time or when the text is cleared. Please note that header and footer also are RTFDataBlocks.

 
      procedure TForm1.WPRichText1NewRTFDataBlock(Sender: TObject;
      RTFDataBlock: TWPRTFDataBlock);
      begin
      if RTFDataBlock.Kind=wpIsBody then
      begin
      // a) Set first paragraph attribute
      // RTFDataBlock.FirstPar.ASetColor(WPAT_CharColor, clRed);
      // RTFDataBlock.FirstPar.ASetFontName('Courier New');


      // b) Set default character attribute
      RTFDataBlock.RTFProps.AttrHelper.Clear;
      RTFDataBlock.RTFProps.AttrHelper.SetFontName('Times new Roman');
      RTFDataBlock.RTFProps.AttrHelper.SetFontSize(9.5);
      RTFDataBlock.FirstPar.LoadedCharAttr :=
      RTFDataBlock.RTFProps.AttrHelper.CharAttr;


      // c) create a default text
      RTFDataBlock.FirstPar.SetText('Please type here ...');
      end;
      end;
       

This event can be used to attach custom dialogs. You can also use it to display page setup and tabstop dialogs for clicks on the ruler and the section page properties after a click on the arrow which marks a section:

 
      procedure TForm1.WPRichText1OpenDialog(Sender: TObject;
      DiaType: TWPCustomRtfEditDialog; var ResultValue: Boolean);
      begin
      if DiaType in [wpdiaSectionPageSetup, wpdiaPageSetup] then
      begin
      WPPagePropDlg1.Execute;
      ResultValue := true;
      end else
      if DiaType=wpdiaTabstops then
      begin
      WPTabDlg1.Execute;
      ResultValue := true;
      end;
      end;
       

wpTriggerOpenDialogForSectionProps must be used in EditOptionsEx

This event is triggered after the controls content was painted. Since v5.19.8 it is possible to paint flickerfree since while this event is triggered the property 'Canvas' will provide the reference to the current double buffer canvas.

If this event is assigned the desktop will not be filled. You can use external code to paint the background. This can be used with TMS components to draw the shading of the TAdvOfficePager.

 
      procedure TForm1.WPRichText1PaintDesktopBackground(Sender: TObject;
      Canvas: TCanvas; R: TRect);
      begin
      // This would paint the TWPRichText, too - but TWPRichText is locked for repaint during this event
      AdvOfficePager1.PaintTo(Canvas, -WPRichText1.Left, -WPRichText1.Top);
      end;
       

This event makes it possible to inject page into the text. This pages are pure virtual, they can be painted by the event OnPaintExternPage, but they do not contain any text.

 
    procedure TWPExternalP.WPRichText1PaintExternPage(Sender: TObject;
        RTFEngine: TWPRTFEnginePaint; prCanvas: TCanvas; xoff, yoff: Integer;
        r: TRect; PaintPageNr: Integer; ExternPageRef: TObject; DestXRes,
        DestYRes: Integer);
      begin
        prCanvas.StretchDraw( r, ExternPageRef as TGraphic );
      end;
     

This code adds external pages to the document:

 
    var PageRef : TWPRTFExternPageRef;
    begin
         // We add a page at a certain location. The data object we added
         // Is freed automatically unless we set in the
         // returned TWPRTFExternPageRef object the property DontFreeExternPage
         // to true
         PageRef := WPRichText1.Memo.ExternPageRefAdd(
             wpAsPageX,
             PageNr,
             0,
             aPage,
             nil
            );
         // This values are optional
         PageRef.PageWidth  := MulDiv( pw, 1440, WPScreenPixelsPerInch);
         PageRef.PageHeight := MulDiv( ph, 1440, WPScreenPixelsPerInch);


    end;
     

This event makes it possible to either paint the page hint in your own code - then set Ignore to TRUE or to modify the Canvas.Brush, -Pen and -Font properties and let the engine use its usual paint code.

This event let You paint a border around the page text, or, with premium license, also around columns and custom text frames. Custom text frames can be created on event .

 
      Canvas.Brush.Style := bsSolid;
      Canvas.Brush.Color := $fffffa;
      Canvas.FillRect(Rect(x1,y1,x2,y2));
       

This event can be used to paint a watermark on the page. You can even use a different TWPRichText to paint the background of the page. This is a perfect feature to print letterheads.

 
   uses ... WPRTEPaint, WPRTEDefsConsts, WPRTEEdit;


   procedure TForm2.WPRichText1PaintWatermark(Sender: TObject;
        RTFEngine: TWPRTFEnginePaint; toCanvas: TCanvas; PageRect: TRect; PaintPageNr,
        RTFPageNr: Integer; WaterMarkRef: TObject; XRes, YRes: Integer;
        CurrentZoom: Single; PaintMode: TWPPaintModes);
      begin
        // You can also draw an image in the background
        // toCanvas.StretchDraw(PageRect, Image1.Picture.Graphic);
        BackgroundRTF.Memo.OverridePageCount := WPRichText1.PageCount;
        BackgroundRTF.Memo.OverridePageOffset := PaintPageNr;
        BackgroundRTF.PaintPageOnCanvas(
           0,
           PageRect.Left,
           PageRect.Top,
           PageRect.Width,
           PageRect.Height,
           toCanvas,
           [wppGrayAll, wppGrayHeaderFooter, wppWhiteIsTransparent ],
           0,
           0,
           -1,
           -1,
           [wpNoViewPortAPI, // Internally used
             wpNoViewPortOrgAPI]
            );
      end;
     

This event is triggered before an image is saved. You can use this event to compress the image or save it to file and store the link.

 
      procedure TForm1.WPRichText1PrepareImageforSaving(
      RTFData: TWPRTFDataCollection; Writer: TWPCustomTextWriter;
      TextObject: TWPTextObj; var DontSave: Boolean);
      begin
      // use WPIOHTML, WPOBJ_IMAGE
      if (Writer is TWPHTMLWriter) and TextObject.IsImage and
      (TextObject.Source='') and (TextObject.ObjRef.FileName='') and
      (TextObject.ObjRef.StreamName='') then
      begin
      TextObject.ObjRef.FileName :=
      TextObject.ObjRef.SaveToFile(Writer.SavePath,Writer.SaveName,'_img%d');
      end;
      end;
       

note: To clean up you can use the event AfterImageSaving.

This event is triggered by the paint routine for a paragraph which uses the flag paprNeedPreparePaintEvent in 'props'. This event may update some character properties but no properties which change the width of a character. Normally this event is used best to implement SpellAsYouGo, otherwise better use .

This event makes it possible to intercept the printing to integrate different printing code, i.e. to scale the printed page ot to print additional data. If this event is used, this code is NOT called and should be called within the event handler.

 
            Result := WPRichText1.PaintPageOnCanvas(n - 1, xoff, yoff,
                  0, 0, Printer.Canvas, Mode, 0,
                  0, -1, -1, []);
           

This event is triggered before a drag&drop operation is started. The parameter DoIt will default to false if no text is selected or the selected text is a range of table cells. DragMode must be set to "dmManual"!

This event is triggered when a linked image (an image without image blob) is loaded.

This event is triggered by the HTML reader when a linked style sheet is requested.

This event is triggered when the control is resized. Please use the event BeforeResize (not published) if you need to change the zooming value of a control which also uses property WordWrap set to true.

This event is triggered by the function "ReplaceTextMethod" which is called by the Search and Replace dialog. The event can be used to show a custom message. If ToStart is set to true, search will be started from the beginning. It is possible to load a new document inside the event, for example to implement a search through several database records

This event is triggered inside the SetFocus procedure.

This event is triggered at print time before printing starts and between each page

This event is used to check the word under the cursor if it is a hyperlink or not.

 
      procedure TForm1.DoTestLink(Sender: TObject; par : TParagraph;
      var posinpar, len : Integer; var IsLink : Boolean);
      var s : string;
      begin
      if par.CompareW(posinpar,'http://') then IsLink := TRUE;
      end;
       

This event can be used to react on click on text objects. It is very useful for TextBoxes (part of WPTools Premium). Here it can be used to activate the edit mode for a textbox (=text inside of frame):

 
    procedure TForm1.WPRichText1TextObjectClick(Sender: TWPCustomRtfEdit;
      pobj: TWPTextObj; obj: TWPObject; var Ignore: Boolean);
    begin
      if (obj>nil) and
        ((WPRichText1.TextCursor.SelectedObject>pobj)
         or (GetAsyncKeyState(VK_CONTROL)  0)
        )then
         obj.Edit;
    end;


    procedure TForm1.WPRichText1TextObjectDblClick(Sender: TWPCustomRtfEdit;
      pobj: TWPTextObj; obj: TWPObject; var Ignore: Boolean);
    begin
       if (obj>nil) then
       begin
         obj.Edit;
         Ignore := true;
       end;
    end;
     

This even is triggered when the user presses the mouse button while the mouse pointer is over an image object. It is also triggered by codes, such as mail merge fields - (Alternative

This even is triggered when the user moves the mouse pointer over an image object. It is also triggered by codes, such as mail merge fields. If it is triggered by an image object the X and Y coordinates are relative to the objects upperl left coordinate, for usual text objects the client coordinates in the editor are passed.

This even is triggered when the user releases the mouse button while the mouse pointer is over an image object. It is now also triggered by codes, such as mail merge fields - (Alternative

This event is triggered when an object is moved. In contrary to OnTextObjectMove (it was named wrongly) is triggered when the object is resized

This event is called to paint any embedded object. It can be also used to replace place holder images with the real data. In this example it applies a place holder image for all images which use the property Name.

 
      procedure TForm1.WPRichText1TextObjectPaint(Sender: TObject; pobj: TWPTextObj;
        toCanvas: TCanvas; XRes, YRes, X, Y, W, H, BASE: Integer;
        PageRef: TWPVirtPage; Modes: TWPTextObjectPaintModes;
        const CanvasExtraAttr: TWPPaintExtraParams;
        var ContinueMode: TWPTextObjectPaintResult);
      var mem : TMemoryStream;
      begin
            if (pobj.Name>'') and pobj.IsImage  then
            begin
              mem := TMemoryStream.Create;
              Placeholder.Picture.Bitmap.SaveToStream(mem);
              mem.Position := 0;
              pobj.LoadObjFromStream(
                      'BMP',
                      mem
                      );
              mem.Free;


              pobj.Name := ''; // dont call me again


            end;
      end;
     

Please note that the "Sender" ofd this event is the innner Memo control of type TWPRTFEnginePaint, not the TWPRichText.

This event is triggered for all TWPTextObj ecxept for hyperlinks, images and horizontal lines.
It can be used to to calculate dynamic contents for text objects. You can access the current page as WPRichText.Memo._MeasureObjectCurrPage. This reference may be nil! You can also read the current page number: WPRichText.Memo._CurrPaintedObjPageNumber
You can either pass a result value and / or paint the string directly.

 
        procedure TForm1.OnPaintSum(Sender: TWPTextObj; OutCanvas: TCanvas; xres, yres: Integer; x, Y, w, h, BASE: Integer);
        begin
          if Sender.NameIs('anyname') then
          begin
             OutCanvas.TextOut(X+w-OutCanvas.TextWidth(Sender.Params),Y+base,Sender.Params);
          end;
        end;


        procedure TForm1.WPRichText1TextObjGetTextEx(RefCanvas: TCanvas;
          TXTObject: TWPTextObj; var PrintString: WideString; var WidthInPix,
          HeightInPix: Integer; var PaintObject: TWPTextObj; Xres, YRes: Integer);
        begin
          if TXTObject.NameIs('anyname') then
          begin
             PrintString := '                ';
             PaintObject := TXTObject;
             TXTObject.Params := '99.12';
             PaintObject.OnPaint := OnPaintSum;
          end;
        end;
        

This example code will render date and time fields as MS Word would do. It requires the "Source" to hold the format in the form \@ d. mmmmm yyyyy

 
       procedure TWPMiniEd.WPRichText1TextObjGetTextEx(RefCanvas: TCanvas;
        TXTObject: TWPTextObj; var PrintString: WideString; var WidthInPix,
        HeightInPix: Integer; var PaintObject: TWPTextObj; Xres, YRes: Integer);
      var s : string;
      begin
        // Interpret \@ d. mmmmm yyyyy
        if (Pos('\@',TXTObject.Source)>0) and TXTObject.NameIs('TIME') or TXTObject.NameIs('DATE') then
        begin
          s := Trim(StringReplace( TXTObject.Source, '\@', '', [rfReplaceAll]));
          s := AnsiDequotedStr(s,'"');
          PrintString := FormatDateTime(s, Now);
        end;
      end; 

This event makes it possible to update the position of an external scrollbar. The parameters are automatically limited to a maximal value of 20000 my calculating a multiplicator value. This values are accessible through the properties ScrollVertMultiplicator and ScrollHorzMultiplicator.
Example:

 
      // Update the position of the scrollbar
      procedure TForm1.WPRichText1UpdateExternScrollbar(
      Sender: TWPCustomRtfEdit; ScrollBar: TScrollStyle; Range, Page,
      Pos: Integer);
      begin
      if ScrollBar=ssVertical then
      begin
      ScrollBar1.PageSize := Page;
      ScrollBar1.Max := Range;
      ScrollBar1.Position := Pos;
      end;
      end;


      // Change position when Scroll event happens
      procedure TForm1.ScrollBar1Scroll(Sender: TObject;
      ScrollCode: TScrollCode; var ScrollPos: Integer);
      begin
      WPRichText1.TopOffset := Round(ScrollPos / WPRichText1.ScrollVertMultiplicator);
      end;