mORMot Open Source

  xUserApp := TSQLUserApplication.Create;
  xUserApp.FillMany(
    DBConnection,
    UserId,
    MyWhere);

  while xUserApp.FillOne do
  begin
    xUserApp.Dest.DoSomething;
  end;

/// implement TaskDialog window (native on Vista/Seven, emulated on XP)
// - this unit is a part of the freeware Synopse framework,
// licensed under a MPL/GPL/LGPL tri-license; version 1.16
unit SynTaskDialog;

{
    This file is part of Synopse framework.

    Synopse framework. Copyright (C) 2012 Arnaud Bouchez
      Synopse Informatique - http://synopse.info

  *** BEGIN LICENSE BLOCK *****
  Version: MPL 1.1/GPL 2.0/LGPL 2.1

  The contents of this file are subject to the Mozilla Public License Version
  1.1 (the "License"); you may not use this file except in compliance with
  the License. You may obtain a copy of the License at
  http://www.mozilla.org/MPL

  Software distributed under the License is distributed on an "AS IS" basis,
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  for the specific language governing rights and limitations under the License.

  The Original Code is Synopse framework.

  The Initial Developer of the Original Code is Arnaud Bouchez.

  Portions created by the Initial Developer are Copyright (C) 2012
  the Initial Developer. All Rights Reserved.

  Contributor(s):
  Alternatively, the contents of this file may be used under the terms of
  either the GNU General Public License Version 2 or later (the "GPL"), or
  the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  in which case the provisions of the GPL or the LGPL are applicable instead
  of those above. If you wish to allow use of your version of this file only
  under the terms of either the GPL or the LGPL, and not to allow others to
  use your version of this file under the terms of the MPL, indicate your
  decision by deleting the provisions above and replace them with the notice
  and other provisions required by the GPL or the LGPL. If you do not delete
  the provisions above, a recipient may use your version of this file under
  the terms of any one of the MPL, the GPL or the LGPL.

  ***** END LICENSE BLOCK *****

  Version 1.13
  - initial release

  Version 1.15
  - new tdfQueryMasked function to display * in the tdfQuery editor field

  Version 1.16
  - fixed issue when changing the current application with Alt+Tab - see
    http://synopse.info/fossil/tktview?name=01395e5932
  - fixed compiler error when using the unit with runtime packages enabled
    (known compiler issue about string resources, referenced as E2201)
  - some aesthetical rendering changes and code clean-up (e.g. no temporary
    form necessary), thanks to uligerhardt proposals

  Ondrej 2012-02-26
  - added WideString Support even for Delphi<=D2007 + Win 7
  - added TntControls for true unicode support even for Delphi<=D2007 + Win XP
}

interface

{$IFDEF CONDITIONALEXPRESSIONS}  // Delphi 6 or newer
  {$ifndef VER140} // Delphi 6
    {$define WITHUXTHEME} // Themes unit exists till Delphi 7
  {$endif}
{$ENDIF}

{$DEFINE USETNTPACK}//TRUE UNICODE SUPPORT FOR <Delphi2007 and WinXP
uses
  Windows, Classes, SysUtils, Consts, SynWideSupp,
  {$ifdef USETMSPACK}
  AdvGlowButton, AdvMenus, TaskDialog, TaskDialogEx,
  {$else}
    {$ifdef USETNTPACK}
    TntClasses, TntMenus, TntStdCtrls, TntButtons, TntExtCtrls, TntForms,
    {$else}
    Menus,
    {$endif USETNTPACK}
  {$endif USETMSPACK}
  {$ifndef UNICODE}WideStrUtils, {$endif}
  Graphics, Forms, Controls, StdCtrls, ExtCtrls, Buttons;

var
  /// will map a generic OK picture from SynTaskDialog.res
  BitmapOK: TBitmap;
  /// will map a generic Arrow picture from SynTaskDialog.res
  BitmapArrow: TBitmap;

  /// will map a default font, according to the available
  // - if Calibri is installed, will use it
  // - will fall back to Tahoma otherwise
  DefaultFont: TFont;

{$ifndef USETMSPACK}
  /// is filled once in the initialization block below
  // - you can set this reference to nil to force Delphi dialogs even
  // on Vista/Seven (e.g. make sense if TaskDialogBiggerButtons=true)
  TaskDialogIndirect: function(AConfig: pointer; Res: PInteger;
    ResRadio: PInteger; VerifyFlag: PBOOL): HRESULT; stdcall;

type

  /// the standard kind of common buttons handled by the Task Dialog
  TCommonButton = (
    cbOK, cbYes, cbNo, cbCancel, cbRetry, cbClose);

  /// set of standard kind of common buttons handled by the Task Dialog
  TCommonButtons = set of TCommonButton;

  /// the available main icons for the Task Dialog
  TTaskDialogIcon = (
    tiBlank, tiWarning, tiQuestion, tiError, tiInformation, tiNotUsed, tiShield);

  /// the available footer icons for the Task Dialog
  TTaskDialogFooterIcon = (
    tfiBlank, tfiWarning, tfiQuestion, tfiError, tfiInformation, tfiShield);

  /// the available configuration flags for the Task Dialog
  // - most are standard TDF_* flags used for Vista/Seven native API
  // (see http://msdn.microsoft.com/en-us/library/bb787473(v=vs.85).aspx
  // for TASKDIALOG_FLAGS)
  // - tdfQuery and tdfQueryMasked are custom flags, implemented in pure Delphi
  // code to handle input query
  // - our emulation code will handle only tdfUseCommandLinks,
  // tdfUseCommandLinksNoIcon, and tdfQuery options
  TTaskDialogFlag = (
    tdfEnableHyperLinks, tdfUseHIconMain, tdfUseHIconFooter,
    tdfAllowDialogCancellation, tdfUseCommandLinks, tdfUseCommandLinksNoIcon,
    tdfExpandFooterArea, tdfExpandByDefault, tdfVerificationFlagChecked,
    tdfShowProgressBar, tdfShowMarqueeProgressBar, tdfCallbackTimer,
    tdfPositionRelativeToWindow, tdfRtlLayout, tdfNoDefaultRadioButton,
    tdfCanBeMinimized, tdfQuery, tdfQueryMasked);

  /// set of available configuration flags for the Task Dialog
  TTaskDialogFlags = set of TTaskDialogFlag;

  /// implements a TaskDialog
  // - will use the new TaskDialog API under Vista/Seven, and emulate it with
  // pure Delphi code and standard themed VCL components under XP or 2K
  // - create a TTaskDialog object/record on the stack will initialize all
  // its string parameters to '' (it's a SHAME that since Delphi 2009, objects
  // are not initialized any more: we have to define this type as object before
  // Delphi 2009, and as record starting with Delphi 2009)
  // - set the appropriate string parameters, then call Execute() with all
  // additional parameters
  // - RadioRes/SelectionRes/VerifyChecked will be used to reflect the state
  // after dialog execution
  // - here is a typical usage:
  // !var Task: TTaskDialog;
  // !begin
  // !  Task.Inst := 'Saving application settings';
  // !  Task.Content := 'This is the content';
  // !  Task.Radios := 'Store settings in registry'#10'Store settings in XML file';
  // !  Task.Verify := 'Do no ask for this setting next time';
  // !  Task.VerifyChecked := true;
  // !  Task.Footer := 'XML file is perhaps a better choice';
  // !  Task.Execute([],0,[],tiQuestion,tfiInformation,200);
  // !  ShowMessage(IntToStr(Task.RadioRes)); // 200=Registry, 201=XML
  // !  if Task.VerifyChecked then
  // !    ShowMessage(Task.Verify);
  // !end;
  TTaskDialog = {$ifdef UNICODE}record{$else}object{$endif}
    /// the main title of the dialog window
    // - if left void, the title of the application main form is used
    Title: SynWideString;
    /// the main instruction (first line on top of window)
    // - any '\n' will be converted into a line feed
    // - if left void, the text is taken from the current dialog icon kind
    Inst: SynWideString;
    /// the dialog's primary content content text
    // - any '\n' will be converted into a line feed
    Content: SynWideString;
    /// a #13#10 or #10 separated list of custom buttons
    // - they will be identified with an ID number starting at 100
    // - by default, the buttons will be created at the dialog bottom, just
    // like the common buttons
    // - if tdfUseCommandLinks flag is set, the custom buttons will be created
    // as big button in the middle of the dialog window; in this case, any
    // '\n' will be converted as note text (shown with smaller text under native
    // Vista/Seven TaskDialog, or as popup hint within Delphi emulation)
    Buttons: SynWideString;
    /// a #13#10 or #10 separated list of custom radio buttons
    // - they will be identified with an ID number starting at 200
    // - aRadioDef parameter can be set to define the default selected value
    // - '\n' will be converted as note text (shown with smaller text under
    // native Vista/Seven TaskDialog, or as popup hint within Delphi emulation)
    Radios: SynWideString;
    /// the expanded information content text
    // - any '\n' will be converted into a line feed
    // - the Delphi emulation will always show the Info content (there is no
    // collapse/expand button)
    Info: SynWideString;
    /// the button caption to be displayed when the information is collapsed
    // - not used under XP: the Delphi emulation will always show the Info content
    InfoExpanded: SynWideString;
    /// the button caption to be displayed when the information is expanded
    // - not used under XP: the Delphi emulation will always show the Info content
    InfoCollapse: SynWideString;
    /// the footer content text
    // - any '\n' will be converted into a line feed
    Footer: SynWideString;
    /// the text of the bottom most optional checkbox
    Verify: SynWideString;
    /// a #13#10 or #10 separated list of items to be selected
    // - if set, a Combo Box will be displayed to select
    // - if tdfQuery is in the flags, the combo box will be in edition mode,
    // and the user will be able to edit the Query text or fill the field
    // with one item of the selection
    // - this selection is not handled via the Vista/Seven TaskDialog, but
    // with our Delphi emulation code (via a TComboBox)
    Selection: SynWideString;
    /// some text to be edited
    // - if tdfQuery is in the flags, will contain the default query text
    // - if Selection is set, the
    Query: SynWideString;
    /// the selected radio item
    // - first is numeroted 0
    RadioRes: integer;
    /// after execution, contains the selected item from the Selection list
    SelectionRes: integer;
    /// reflect the the bottom most optional checkbox state
    // - if Verify is not '', should be set before execution
    // - after execution, will contain the final checkbox state
    VerifyChecked: BOOL;
    /// launch the TaskDialog form
    // - some common buttons can be set via aCommonButtons
    // - in emulation mode, aFlags will handle only tdfUseCommandLinks,
    // tdfUseCommandLinksNoIcon, and tdfQuery options
    // - will return 0 on error, or the Button ID (e.g. mrOk for the OK button
    // or 100 for the first custom button defined in Buttons string)
    // - if Buttons was defined, aButtonDef can set the selected Button ID 
    // - if Radios was defined, aRadioDef can set the selected Radio ID
    // - aDialogIcon and aFooterIcon are used to specify the displayed icons
    // - aWidth can be used to force a custom form width (in pixels)
    // - aParent can be set to any HWND - by default, Application.DialogHandle
    // - if aNonNative is TRUE, the Delphi emulation code will always be used
    // - aEmulateClassicStyle can be set to enforce conformity with the non themed
    // user interface - see @http://synopse.info/forum/viewtopic.php?pid=2867#p2867
    function Execute(aCommonButtons: TCommonButtons=[];
      aButtonDef: integer=0; aFlags: TTaskDialogFlags=[];
      aDialogIcon: TTaskDialogIcon=tiInformation;
      aFooterIcon: TTaskDialogFooterIcon=tfiWarning;
      aRadioDef: integer=0; aWidth: integer=0; aParent: HWND=0;
      aNonNative: boolean=false; aEmulateClassicStyle: boolean = false): integer;
  end;

  /// a wrapper around the TTaskDialog.Execute method
  // - used to provide a "flat" access to task dialog parameters
  TTaskDialogEx = {$ifdef UNICODE}record{$else}object{$endif}
    /// the associated main TTaskDialog instance
    Base: TTaskDialog;
    /// some common buttons to be displayed
    CommonButtons: TCommonButtons;
    /// the default button ID
    ButtonDef: integer;
    /// the associated configuration flags for this Task Dialog
    // - in emulation mode, aFlags will handle only tdfUseCommandLinks,
    // tdfUseCommandLinksNoIcon, and tdfQuery options
    Flags: TTaskDialogFlags;
    /// used to specify the dialog icon
    DialogIcon: TTaskDialogIcon;
    /// used to specify the footer icon
    FooterIcon: TTaskDialogFooterIcon;
    /// the default radio button ID
    RadioDef: integer;
    /// can be used to force a custom form width (in pixels)
    Width: integer;
    /// if TRUE, the Delphi emulation code will always be used
    NonNative: boolean;
    /// can be used to enforce conformity with the non themed user interface
    EmulateClassicStyle: boolean;
    /// main (and unique) method showing the dialog itself
    // - is in fact a wrapper around the TTaskDialog.Execute method
    function Execute(aParent: HWND=0): integer;
  end;
{$endif USETMSPACK}

type
{$ifdef USETMSPACK}
  /// a TMS PopupMenu
  TSynPopupMenu = TAdvPopupMenu;

  TSynButtonParent = TAdvGlowButton;
{$else}
{$ifdef USETNTPACK}
  TSynPopupMenu = TTntPopupMenu;

  TSynButtonParent = {$ifdef WITHUXTHEME}TTntBitBtn{$else}TTntButton{$endif};
{$else}
  /// a generic VCL popup menu
  TSynPopupMenu = TPopupMenu;

  TSynButtonParent = {$ifdef WITHUXTHEME}TBitBtn{$else}TButton{$endif};
{$endif USETNTPACK}
{$endif USETMSPACK}

{$ifdef USETNTPACK}
  TSynEdit = TTntEdit;
  TSynPanel = TTntPanel;
  TSynCheckBox = TTntCheckBox;
  TSynComboBox = TTntComboBox;
  TSynRadioButton = TTntRadioButton;
  TSynLabel = TTntLabel;
  TSynForm = TTntForm;

  TSynWideStrings = TTntStrings;
  TSynWideStringList = TTntStringList;
{$else}
  TSynEdit = TEdit;
  TSynPanel = TPanel;
  TSynCheckBox = TCheckBox;
  TSynComboBox = TComboBox;
  TSynRadioButton = TRadioButton;
  TSynLabel = TLabel;
  TSynForm = TForm;

  TSynWideStrings = TStrings;
  TSynWideStringList = TStringList;
{$endif USETNTPACK}

  /// a generic Button to be used in the User Interface
  // - is always a Themed button: under Delphi 6, since TBitBtn is not themed,
  // it will be a row TButton with no glyph... never mind...
  TSynButton = class(TSynButtonParent)
  protected
{$ifndef USETMSPACK}
    fDropDownMenu: TSynPopupMenu;
{$endif}
  public
    /// create a standard button instance
    // - ModalResult/Default/Cancel properties will be set as exepcted for this
    // kind of button
    constructor CreateKind(Owner: TWinControl; Btn: TCommonButton;
      Left, Right, Width, Height: integer);
    /// set the glyph of the button
    // - set nothing under Delphi 6
    procedure SetBitmap(Bmp: TBitmap);
{$ifndef USETMSPACK}
    /// drop down the associated Popup Menu
    procedure DoDropDown;
    /// the associated Popup Menu to drop down
    property DropDownMenu: TSynPopupMenu read fDropDownMenu write fDropDownMenu;
{$endif}
  end;

/// return the text without the '&' characters within
function UnAmp(const s: SynWideString): SynWideString;

{$ifndef USETMSPACK}
var
{
  /// if set to TRUE, buttons will be bigger than default
  // - can be useful e.g. for touch screens
  // - will work only for the Delphi emulated version (aNonNative=true) of
  // TSynTask - could be combined with @TaskDialogIndirect := nil;
  TaskDialogBiggerButtons: boolean = false;
}
  /// a default Task Dialog wrapper instance
  // - can be used to display some information with less parameters
  DefaultTaskDialog: TTaskDialogEx = (
    (*
    CommonButtons: [];
    ButtonDef: 0;
    Flags: [];
    *)
    DialogIcon: tiInformation;
    FooterIcon: tfiWarning;
    (*
    RadioDef: 0;
    Width: 0;
    NonNative: false;
    EmulateClassicStyle: false;
    *)
    );
{$endif}

implementation

{$R SynTaskDialog.res}


const
  TD_BTNS: array[TCommonButton] of string = (
    SMsgDlgOK, SMsgDlgYes, SMsgDlgNo, SMsgDlgCancel, SMsgDlgRetry,
    SCloseButton);
  TD_BTNMOD: array[TCommonButton] of Integer = (
    mrOk, mrYes, mrNo, mrCancel, mrRetry, mrAbort);

{ TSynButton }

constructor TSynButton.CreateKind(Owner: TWinControl; Btn: TCommonButton;
  Left, Right, Width, Height: integer);
begin
  Create(Owner);
  Parent := Owner;
  SetBounds(Left,Right,Width,Height);
  Caption := TD_BTNS[Btn];
  ModalResult := TD_BTNMOD[Btn];
  case Btn of
    cbOK:     Default := true;
    cbCancel: Cancel := true;
  end;
  case Btn of
    cbOK: SetBitmap(BitmapOK);
  end;
end;

{$ifndef USETMSPACK}
procedure TSynButton.DoDropDown;
begin
  if DropDownMenu<>nil then
    with ClientToScreen(BoundsRect.TopLeft) do
      DropDownMenu.Popup(X,Y+Height);
end;
{$endif}

procedure TSynButton.SetBitmap(Bmp: TBitmap);
begin
  if Bmp<>nil then
    {$ifdef USETMSPACK}
    Picture.Assign(Bmp);
    {$else}
      {$ifdef WITHUXTHEME}
      Glyph := Bmp;
      {$else}
      // Delphi 6 TBitBtn has no theming -> use generic TButton without glyph
      {$endif}
    {$endif}
end;

function UnAmp(const s: SynWideString): SynWideString;
var i: integer;
begin
  result := s;
  repeat
    i := pos('&',result);
    if i=0 then
      exit;
    delete(result,i,1);
  until false;
end;


{$ifndef USETMSPACK}

const
  TD_ICONS: array[TTaskDialogIcon] of integer = (
    17, 84, 99, 98, 81, 0, 78);
  TD_ICONS_IDENT: array[TTaskDialogIcon] of string = (
    '', SMsgDlgWarning, SMsgDlgConfirm, SMsgDlgError, SMsgDlgInformation,
    '', SMsgDlgInformation);
  TD_FOOTERICONS: array[TTaskDialogFooterIcon] of integer = (
    17, 84, 99, 98, 65533, 65532);
  WIN_ICONS: array[TTaskDialogIcon] of PChar = (
    nil, IDI_WARNING, IDI_QUESTION, IDI_ERROR, IDI_INFORMATION, nil, IDI_WINLOGO);
  WIN_FOOTERICONS: array[TTaskDialogFooterIcon] of PChar = (
    nil, IDI_WARNING, IDI_QUESTION, IDI_ERROR, IDI_INFORMATION, IDI_WINLOGO);

procedure InitComCtl6;
var OSVersionInfo: TOSVersionInfo;
begin
  OSVersionInfo.dwOSVersionInfoSize := sizeof(OSVersionInfo);
  GetVersionEx(OSVersionInfo);
  if OSVersionInfo.dwMajorVersion<6 then
    @TaskDialogIndirect := nil else
    @TaskDialogIndirect := GetProcAddress(GetModuleHandle(comctl32),'TaskDialogIndirect');
end;

{ TTaskDialog }

type
  // see http://msdn.microsoft.com/en-us/library/bb787473(v=VS.85).aspx
  PTASKDIALOG_BUTTON = ^TTASKDIALOG_BUTTON;
  TTASKDIALOG_BUTTON = packed record
    nButtonID: integer;
    pszButtonText: PWideChar;
  end;

  TTASKDIALOGCONFIG = packed record
    cbSize: integer;
    hwndParent: HWND;
    hInstance: THandle;
    dwFlags: integer;
    dwCommonButtons: integer;
    pszWindowTitle: PWideChar;
    hMainIcon: integer;
    pszMainInstruction: PWideChar;
    pszContent: PWideChar;
    cButtons: integer;
    pButtons: PTASKDIALOG_BUTTON;
    nDefaultButton: integer;
    cRadioButtons: integer;
    pRadioButtons: PTASKDIALOG_BUTTON;
    nDefaultRadioButton: integer;
    pszVerificationText: PWideChar;
    pszExpandedInformation: PWideChar;
    pszExpandedControlText: PWideChar;
    pszCollapsedControlText: PWideChar;
    hFooterIcon: HICON;
    pszFooter: PWideChar;
    pfCallback: pointer;
    lpCallbackData: pointer;
    cxWidth: integer;
  end;


function TTaskDialog.Execute(aCommonButtons: TCommonButtons;
  aButtonDef: integer; aFlags: TTaskDialogFlags;
  aDialogIcon: TTaskDialogIcon; aFooterIcon: TTaskDialogFooterIcon;
  aRadioDef, aWidth: integer; aParent: HWND; aNonNative: boolean;
  aEmulateClassicStyle: boolean): integer;

function CR(const aText: SynWideString): SynWideString;
begin
  if pos('\n',aText)=0 then
    result := aText else
    result := SynWideStringReplace(aText,'\n',#10,[rfReplaceAll]);
end;
function GetNextStringLineToWS(var P: PSynWideChar): SynWideString;
var S: PSynWideChar;
begin
  if P=nil then
    result := '' else begin
    S := P;
    while S[0]>=' ' do
      inc(S);
    SetString(result,P,S-P);
    result := CR(result);
    while (S^<>#0) and (S^<' ') do inc(S); // ignore e.g. #13 or #10
    if S^<>#0 then
      P := S else
      P := nil;
  end;
end;
var aHint: SynWideString;
function NoCR(const aText: SynWideString): SynWideString;
var i: integer;
begin
  result := aText;
  aHint := '';
  i := pos('\n',result);
  if i>0 then begin
    aHint := CR(copy(result,i+2,maxInt));
    SetLength(result,i-1);
  end;
end;
function N(const aText: SynWideString): SynWideString;
begin
  if aText='' then
    result := '' else
    result := CR(aText);
end;
var RU: array of SynWideString;
    RUCount: integer;
    But: array of TTASKDIALOG_BUTTON;
procedure AddRU(Text: SynWideString; var n: integer; firstID: integer);
var P: PSynWideChar;
begin
  if Text='' then
    exit;
  Text := SysUtils.trim(Text);
  P := @Text[1]; // '\n' handling in GetNextStringLineToWS(P) will change P^
  while P<>nil do begin
    if length(RU)<=RUCount then begin
      SetLength(RU,RUCount+16);
      SetLength(But,RUCount+16);
    end;
    RU[RUCount] := GetNextStringLineToWS(P);
    with But[RUCount] do begin
      nButtonID := n+firstID;
      pszButtonText := pointer(RU[RUCount]);
    end;
    inc(n);
    inc(RUCount);
  end;
end;
var Config: TTASKDIALOGCONFIG;
    i, X, Y, XB, IconBorder, FontHeight: integer;
    Par: TWinControl;
    Panel: TSynPanel;
    CurrTabOrder: TTabOrder;
    Form: TSynForm;
    Image: TImage;
    Pic: TIcon;
    Bmp: TBitmap;
    Edit: TSynEdit;
    Combo: TSynComboBox;
    List: TSynWideStrings;
    B: TCommonButton;
    CommandLink: TSynButton;
    Rad: array of TSynRadioButton;
    Verif: TSynCheckBox;
function AddLabel(const Text: SynWideString; BigFont: boolean): TSynLabel;
begin
  result := TSynLabel.Create(Form);
  result.Parent := Par;
  result.WordWrap := true;
  if BigFont then begin
    if aEmulateClassicStyle then begin
      result.Font.Height := FontHeight-2;
      result.Font.Style := [fsBold]
    end else begin
      result.Font.Height := FontHeight-4;
      result.Font.Color := $B00000;
    end;
  end else
    result.Font.Height := FontHeight;
  result.Left := X;
  result.Top := Y;
  result.Width := aWidth-X-8;
  result.Caption := CR(Text);
  inc(Y,result.Height+16);
end;
procedure AddBevel;
var BX: integer;
begin
  with TBevel.Create(Form) do begin
    Parent := Par;
    if (Image<>nil) and (Y<Image.Top+Image.Height) then
      BX := X else
      BX := 2;
    SetBounds(BX,Y,aWidth-BX-2,2);
  end;
  inc(Y,16);
end;
function AddButton(s: SynWideString; ModalResult: integer): TSynButton;
var WB: integer;
begin
  s := UnAmp(s);
  WB := Form.Canvas.TextWidth(s)+52;
  dec(XB,WB);
  if XB<X shr 1 then begin
    XB := aWidth-WB;
    inc(Y,32);
  end;
  result := TSynButton.Create(Form);
  result.Parent := Par;
    if aEmulateClassicStyle then
      result.SetBounds(XB,Y,WB-10,22) else
      result.SetBounds(XB,Y,WB-12,28);
  result.Caption := s;
  result.ModalResult := ModalResult;
  result.TabOrder := CurrTabOrder;
  case ModalResult of
    mrOk: begin
      result.Default := true;
      if aCommonButtons=[cbOk] then
        result.Cancel := true;
    end;
    mrCancel: result.Cancel := true;
  end;
  if ModalResult=aButtonDef then
    Form.ActiveControl := result;
end;

begin
  if (byte(aCommonButtons)=0) and (Buttons='') then begin
    aCommonButtons := [cbOk];
    if aButtonDef=0 then
      aButtonDef := mrOk;
  end;
  if Title='' then
    if Application.MainForm=nil then
      Title := Application.Title else
      Title := Application.MainForm.Caption;
  if (Inst='') and (TD_ICONS_IDENT[aDialogIcon]<>'') then
    Inst := TD_ICONS_IDENT[aDialogIcon];
  if aParent=0 then
    aParent := Application.Handle;
  if Assigned(TaskDialogIndirect) and not aNonNative and
     not (tdfQuery in aFlags) and (Selection='') then begin
    // use Vista/Seven TaskDialog implementation (not tdfQuery nor Selection)
    FillChar(Config,sizeof(Config),0);
    Config.cbSize := sizeof(Config);
    Config.hwndParent := aParent;
    Config.pszWindowTitle := pointer(N(Title));
    Config.pszMainInstruction := pointer(N(Inst));
    Config.pszContent := pointer(N(Content));
    RUCount := 0;
    AddRU(Buttons,Config.cButtons,100);
    AddRU(Radios,Config.cRadioButtons,200);
    if Config.cButtons>0 then
      Config.pButtons := @But[0];
    if Config.cRadioButtons>0 then
      Config.pRadioButtons := @But[Config.cButtons];
    Config.pszVerificationText := pointer(N(Verify));
    Config.pszExpandedInformation := pointer(N(Info));
    Config.pszExpandedControlText := pointer(N(InfoExpanded));
    Config.pszCollapsedControlText := pointer(N(InfoCollapse));
    Config.pszFooter := pointer(N(Footer));
    Config.dwCommonButtons := byte(aCommonButtons);
    if (Verify<>'') and VerifyChecked then
      include(aFlags,tdfVerificationFlagChecked);
    if (Config.cButtons=0) and (aCommonButtons=[cbOk]) then
      Include(aFlags,tdfAllowDialogCancellation); // just OK -> Esc/Alt+F4 close
    Config.dwFlags := integer(aFlags);
    Config.hMainIcon := TD_ICONS[aDialogIcon];
    Config.hFooterIcon := TD_FOOTERICONS[aFooterIcon];
    Config.nDefaultButton := aButtonDef;
    Config.nDefaultRadioButton := aRadioDef;
    Config.cxWidth := aWidth;
    if TaskDialogIndirect(@Config,@result,@RadioRes,@VerifyChecked)<>S_OK then
      result := 0; // error (mostly invalid argument)
  end else begin
    // use our native (naive?) Delphi implementation
    Verif := nil;
    Combo := nil;
    Edit := nil;
    Form := TSynForm.Create(Application);
    try
      // initialize form properties
      Form.BorderStyle := bsDialog;
      Form.BorderIcons := [];
      Form.Position := poScreenCenter;
      if not aEmulateClassicStyle then
        Form.Font := DefaultFont;
      FontHeight := Form.Font.Height;
      if aWidth=0 then begin
        aWidth := Form.Canvas.TextWidth(Inst);
        if (aWidth>300) or (Form.Canvas.TextWidth(Content)>300) or
           (length(Buttons)>40) then
          aWidth := 480 else
          aWidth := 420;
      end;
      Form.ClientWidth := aWidth;
      Form.Height := 200;
      Form.Caption := Title;
      // create a white panel for the main dialog part
      Panel := TSynPanel.Create(Form);
      Panel.Parent := Form;
      Panel.Align := alTop;
      Panel.BorderStyle := bsNone;
      Panel.BevelOuter := bvNone;
      if not aEmulateClassicStyle then begin
        {$ifdef HASINLINE}
        Panel.BevelEdges := [beBottom];
        Panel.BevelKind := bkFlat;
        {$endif}
        Panel.Color := clWhite;
        {$ifdef WITHUXTHEME}
        Panel.ParentBackground := false; // clWhite not used otherwise
        {$endif}
      end;
      Par := Panel;
      // handle main dialog icon
      if aEmulateClassicStyle then
        IconBorder := 10 else
        IconBorder := 24;
       if WIN_ICONS[aDialogIcon]<>nil then begin
        Image := TImage.Create(Form);
        Image.Parent := Par;
        Image.Picture.Icon.Handle := LoadIcon(0,WIN_ICONS[aDialogIcon]);
        Image.SetBounds(IconBorder,IconBorder,Image.Picture.Icon.Width,Image.Picture.Icon.Height);
        X := Image.Width+IconBorder*2;
        Y := Image.Top;
        if aEmulateClassicStyle then
          inc(Y, 8);
      end else begin
        Image := nil;
        if not aEmulateClassicStyle then
          IconBorder := IconBorder*2;
        X := IconBorder;
        Y := IconBorder;
      end;
      // add main texts (Instruction, Content, Information)
      AddLabel(Inst,true);
      AddLabel(Content,false);
      if Info<>'' then
        // no information collapse/expand yet: it's always expanded
        AddLabel(Info,false);
      // add command links buttons
      if (tdfUseCommandLinks in aFlags) and (Buttons<>'') then
        with TSynWideStringList.Create do
        try
          inc(Y,8);
          Text := SysUtils.trim(Buttons);
          for i := 0 to Count-1 do begin
            CommandLink := TSynButton.Create(Form);
            with CommandLink do begin
              Parent := Par;
              Font.Height := FontHeight-3;
              if aEmulateClassicStyle then
                SetBounds(X,Y,aWidth-10-X,40) else
                SetBounds(X,Y,aWidth-16-X,40);
              Caption := NoCR(Strings[i]);
              if aHint<>'' then begin
                ShowHint := true;
                Hint := aHint; // note shown as Hint
              end;
              inc(Y,Height+2);
              ModalResult := i+100;
              if ModalResult=aButtonDef then
                Form.ActiveControl := CommandLink;
              if aEmulateClassicStyle then begin
                Font.Height := FontHeight - 2;
                Font.Style := [fsBold]
              end;
              {$ifdef WITHUXTHEME}
              if aEmulateClassicStyle then begin
                Margin := 7;
                Spacing := 7;
              end else begin
                Margin := 24;
                Spacing := 10;
              end;
              if not (tdfUseCommandLinksNoIcon in aFlags) then
                SetBitmap(BitmapArrow);
              {$endif}
            end;
          end;
          inc(Y,24);
        finally
          Free;
        end;
      // add radio buttons
      if Radios<>'' then
        with TSynWideStringList.Create do
        try
          Text := SysUtils.trim(Radios);
          SetLength(Rad,Count);
          for i := 0 to Count-1 do begin
            Rad[i] := TSynRadioButton.Create(Form);
            with Rad[i] do begin
              Parent := Par;
              SetBounds(X+16,Y,aWidth-32-X,6-FontHeight);
              Caption := NoCR(Strings[i]);
              if aHint<>'' then begin
                ShowHint := true;
                Hint := aHint; // note shown as Hint
              end;
              inc(Y,Height);
              if (i=0) or (i+200=aRadioDef) then
                Checked := true;
            end;
          end;
          inc(Y,24);
        finally
          Free;
        end;
      // add selection list or query editor
      if Selection<>'' then begin
        List := TSynWideStringList.Create;
        try
          Combo := TSynComboBox.Create(Form);
          Combo.Parent := Par;
          Combo.SetBounds(X,Y,aWidth-32-X,22);
          if tdfQuery in aFlags then
            Combo.Style := csDropDown else
            Combo.Style := csDropDownList;
          List.Text := trim(Selection);
          Combo.Items.Assign(List);
          Combo.ItemIndex := List.IndexOf(Query);
          inc(Y,42);
        finally
          List.Free;
        end;
      end else
        if tdfQuery in aFlags then begin
          Edit := TSynEdit.Create(Form);
          Edit.Parent := Par;
          Edit.SetBounds(X,Y,aWidth-16-X,22);
          Edit.Text := Query;
          if tdfQueryMasked in aFlags then
            Edit.PasswordChar := '*';
          inc(Y,42);
        end;
      // from now we won't add components to the white panel, but to the form
      Panel.Height := Y;
      Par := Form;
      // add buttons and verification checkbox
      if (byte(aCommonButtons)<>0) or (Verify<>'') or
         ((Buttons<>'') and not (tdfUseCommandLinks in aFlags)) then begin
        CurrTabOrder := Panel.TabOrder;
        inc(Y, 16);
        XB := aWidth;
        if not (tdfUseCommandLinks in aFlags) then
          with TSynWideStringList.Create do
          try
            Text := SysUtils.trim(Buttons);
            for i := Count-1 downto 0 do
              AddButton(Strings[i],i+100);
          finally
            Free;
          end;
        for B := high(B) downto low(B) do
          if B in aCommonButtons then
            AddButton(TD_BTNS[b], TD_BTNMOD[b]);
        if Verify<>'' then begin
          Verif := TSynCheckBox.Create(Form);
          with Verif do begin
            Parent := Par;
            if X+16+Form.Canvas.TextWidth(Verify)>XB then begin
              inc(Y,32);
              XB := aWidth;
            end;
            SetBounds(X,Y,XB-X,24);
            Caption := Verify;
            Checked := VerifyChecked;
          end;
        end;
        inc(Y,36);
      end else
        XB := 0;
      // add footer text with optional icon
      if Footer<>'' then begin
        if XB<>0 then
          AddBevel else
          inc(Y,16);
        if WIN_FOOTERICONS[aFooterIcon]<>nil then begin
          Image := TImage.Create(Form);
          Image.Parent := Par;
          Pic := TIcon.Create;
          Bmp := TBitmap.Create;
          try
            Pic.Handle := LoadIcon(0,WIN_FOOTERICONS[aFooterIcon]);
            Bmp.Transparent := true;
            Bmp.Canvas.Brush.Color := Form.Color;
            Bmp.Width := Pic.Width shr 1;
            Bmp.Height := Pic.Height shr 1;
            DrawIconEx(Bmp.Canvas.Handle,0,0,Pic.Handle,Bmp.Width,Bmp.Height,0,
              Bmp.Canvas.Brush.Handle,DI_NORMAL);
            Image.Picture.Bitmap := Bmp;
            Image.SetBounds(24,Y,Bmp.Width,Bmp.Height);
            X := 40+Bmp.Width;
          finally
            Bmp.Free;
            Pic.Free;
          end;
        end else
          X := 24;
        AddLabel(Footer,false);
      end;
      // display the form
      Form.ClientHeight := Y;
      // retrieve the results
      result := Form.ShowModal;
      if Combo<>nil then begin
        SelectionRes := Combo.ItemIndex;
        Query := Combo.Text;
      end else
      if Edit<>nil then
        Query := Edit.Text;
      if Verif<>nil then
        VerifyChecked := Verif.Checked;
      RadioRes := 0;
      for i := 0 to high(Rad) do
        if Rad[i].Checked then
          RadioRes := i+200;
    finally
      Form.Free;
    end;
  end;
end;


{ TTaskDialogEx }

function TTaskDialogEx.Execute(aParent: HWND): integer;
begin
  Result := Base.Execute(CommonButtons, ButtonDef, Flags, DialogIcon, FooterIcon,
    RadioDef, Width, aParent, NonNative, EmulateClassicStyle);
end;

{$endif USETMSPACK}


initialization
  DefaultFont := TFont.Create;
  DefaultFont.Style := [];
  if Screen.Fonts.IndexOf('Calibri')>=0 then begin
    DefaultFont.Height := -14;
    DefaultFont.Name := 'Calibri';
  end else begin
    if Screen.Fonts.IndexOf('Tahoma')>=0 then
      DefaultFont.Name := 'Tahoma' else
      DefaultFont.Name := 'Arial';
    DefaultFont.Height := -13;
  end;
  {$ifndef USETMSPACK}
  InitComCtl6;
  assert(ord(tdfCanBeMinimized)=15);
  {$endif USETMSPACK}
  BitmapOK := TBitmap.Create;
  BitmapOK.LoadFromResourceName(HInstance,'btnOk'); // SQLite3btnok.bmp
  BitmapOK.Transparent := true;
  BitmapArrow := TBitmap.Create;
  BitmapArrow.LoadFromResourceName(HInstance,'btnArrow'); // SQLite3btnArrow.bmp
  BitmapArrow.Transparent := true;

finalization
  DefaultFont.Free;
  BitmapArrow.Free;
  BitmapOK.Free;

end.

unit SynWideSupp;

interface

uses SysUtils
  {$IFNDEF UNICODE}, WideStrUtils{$ENDIF}
;

type
  {$IFDEF UNICODE}
    SynWideString = String;
    PSynWideChar = PChar;
  {$ELSE}
    SynWideString = WideString;
    PSynWideChar = PWideChar;
  {$ENDIF}

function SynWideStringReplace(const S, OldPattern, NewPattern: SynWideString;
  Flags: TReplaceFlags): SynWideString; inline;

implementation

function SynWideStringReplace(const S, OldPattern, NewPattern: SynWideString;
  Flags: TReplaceFlags): SynWideString;
begin
  {$IFDEF UNICODE}
  Result := StringReplace(S, OldPattern, NewPattern, Flags);
  {$ELSE}
  Result := WideStringReplace(S, OldPattern, NewPattern, Flags);
  {$ENDIF}
end;

end.

procedure TForm1.BtnTestFontClick(Sender: TObject);
var
  xRect: TRect;
  I: Integer;
const
  Text: WideString = 'Ondrej, RedDwarf:';
begin
  with TPdfDocumentGDI.Create do
  try
    KerningHScaleBottomLimit := 100;
    KerningHScaleTopLimit := 100;
    UseSetTextJustification := False;//try to use True

    AddPage;
    with VCLCanvas do begin
      Font.Name := 'Tahoma';//'Times New Roman';
      Font.Style := [fsBold, fsUnderline];
      Pen.Color := $AAAAAA;
      Img1.Canvas.Font.Assign(Font);
      Img1.Canvas.Pen.Assign(Pen);
      Img1.Canvas.Brush.Style := bsClear;

      for I := 5 to 15 do begin
        Font.Size := I;

        xRect := Rect(0, 0, TextWidthXP(Text), TextHeightXP(Text));
        OffsetRect(xRect, 100, 100+(I-5)*30);
        Rectangle(xRect);
        Windows.ExtTextOutW(Handle, xRect.Left, xRect.Top, ETO_CLIPPED,
          @xRect, PWideChar(Text), Length(Text), nil);

        //just to check with an image canvas
        Img1.Canvas.Font.Assign(Font);
        Img1.Canvas.Rectangle(xRect);
        Windows.ExtTextOutW(Img1.Canvas.Handle, xRect.Left, xRect.Top, ETO_CLIPPED,
          @xRect, PWideChar(Text), Length(Text), nil);
      end;
    end;
    SaveToFile('TestVcl.pdf');
  finally
    Free;
  end;
end;

unit PrintRichText;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ComCtrls, TntComCtrls, TntControls, TntSysUtils;

type
  TPrintRichEdit = class helper for TTntRichEdit
  private
    function GetRawRTF: String;
    procedure SetRawRTF(const Value: String);
  public
    function DrawTo(ACanvas: TCanvas; aRect: TRect;
      DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint;

    //WARNING MyFindText COUNTS FROM 0!!!! if found at start return value = 0 !!!
    function MyFindText(aStr: WideString; FromPosition: Integer = 1): Integer;
    function GetLineBreakStyle: TTntTextLineBreakStyle;
    function GetTextLenW: Integer;
    procedure MyDelete(aPos, aLength: Integer);

    procedure ReplaceText(const FromStr, ToStr: WideString);
    procedure ProcessIfStatement(const IfStatement: WideString; const aBoolean: Boolean); overload;
    procedure ProcessIfStatement(const IfStatement, ElseStatement, EndIfStatement: WideString; const aBoolean: Boolean); overload;

    property RawRTF: String read GetRawRTF write SetRawRTF;
  end;

  TTntRichEditAccessProtected = class(TTntRichEdit)
  public
    function LineBreakStyle: TTntTextLineBreakStyle; reintroduce;
  end;

function DefPrintRTFToCanvas(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  FromChar: Integer = 0; ToChar: Integer = -1): Longint;
function DefPrintRTFToCanvasTransparent(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  Rop: Cardinal; FromChar: Integer = 0; ToChar: Integer = -1): Longint;
function DefCalculateRTFHeight(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint;

function PrintRTFToCanvas(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint; overload;
function PrintRTFToCanvas(aRichRawText: String; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint; overload;
function CalculateRTFHeight(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint; overload;
function CalculateRTFHeight(aRichRawText: String; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint; overload;

procedure SetRawRTF(RE: TTntRichEdit; RawRTF: String);
function GetRawRTF(RE: TTntRichEdit): String;

function ReplaceRTFText(aRichRawText: String; aFromText, aToText: WideString): String;

function DrawRichEdit: TTntRichEdit;

implementation

uses RichEdit, Types, WideStrUtils, Math;

var
  XDrawRichEdit: TTntRichEdit = nil;

function DrawRichEdit: TTntRichEdit;
begin
  if Application.MainForm = nil then begin
    Result := nil;
    exit;
  end;

  if not Assigned(XDrawRichEdit) then begin
    XDrawRichEdit := TTntRichEdit.Create(Application.MainForm);
    XDrawRichEdit.Visible := False;
    XDrawRichEdit.Parent := Application.MainForm;
  end;
  Result := XDrawRichEdit;
end;

function GetRawRTF(RE: TTntRichEdit): String;
var
   strStream: TStringStream;
begin
   strStream := TStringStream.Create('') ;
   try
     RE.PlainText := False;
     RE.Lines.SaveToStream(strStream) ;
     Result := strStream.DataString;
   finally
     strStream.Free
   end;
end;

procedure SetRawRTF(RE: TTntRichEdit; RawRTF: String);
var
   strStream: TStringStream;
begin
   strStream := TStringStream.Create(RawRTF) ;
   try
     RE.PlainText := False;
     RE.Lines.LoadFromStream(strStream) ;
   finally
     strStream.Free
   end;
end;

function PrintRTFToCanvas(aRichRawText: String; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint;
var
  RE: TTntRichEdit;
begin
  RE := TTntRichEdit.Create(nil);
  with RE do
  try
    Visible := false;
    Parent := Application.MainForm;

    RE.RawRTF := aRichRawText;

    Result := PrintRTFToCanvas(RE, aCanvas, aRect, DPI, FromChar, ToChar);
  finally
    RE.Free;
  end;
end;

function DefCalculateRTFHeight(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer; FromChar: Integer; ToChar: Integer): Integer;
var
  MTF: TMetafile;
  MTFCanvas: TMetafileCanvas;
  Range: TFormatRange;
  rZoom: Single;
  SaveMapMode, LogX, LogY: Integer;
  SaveViewPort, SaveWindowExt: tagSize;
begin
  if Trim(aRichEdit.Text) = '' then begin
    Result := 0;
    exit;
  end;

  MTF := TMetafile.Create;
  MTFCanvas := TMetafileCanvas.Create(MTF, 0);
  try
    MTFCanvas.Font.Assign(aCanvas.Font);
    MTF.Width := aRect.Right-aRect.Left;
    MTF.Height := aRect.Bottom-aRect.Top;
    if DPI = 0 then
      DPI := ACanvas.Font.PixelsPerInch;
    LogX := GetDeviceCaps(MTFCanvas.Handle, LOGPIXELSX);
    LogY := GetDeviceCaps(MTFCanvas.Handle, LOGPIXELSY);

    rZoom := DPI/MTFCanvas.Font.PixelsPerInch;

    FillChar(Range, SizeOf(TFormatRange), 0);
    Range.hdc        := MTFCanvas.Handle;
    Range.hdcTarget  := MTFCanvas.Handle;
    Range.rc.left    := 0;
    Range.rc.top     := 0;
    Range.rc.right   := (aRect.Right-aRect.Left) * 1440 div DPI;
    Range.rc.Bottom  := (aRect.Bottom-aRect.Top) * 1440 div DPI;
    {Range.rc.left    := aRect.Left * 1440 div LogX;
    Range.rc.top     := aRect.Top * 1440 div LogY;
    Range.rc.right   := aRect.Right * 1440 div LogX;
    Range.rc.Bottom  := aRect.Bottom * 1440 div LogY;}
    if not((FromChar = 0) and (ToChar = 0)) then begin
      Range.chrg.cpMax := ToChar;
      Range.chrg.cpMin := FromChar;
    end else begin
      Range.chrg.cpMax := -1;
      Range.chrg.cpMin := 0;
    end;
    Range.rcPage := Range.rc;

    with MTFCanvas do begin
      SaveMapMode := GetMapMode(Handle);
      GetWindowExtEx(Handle, SaveWindowExt);
      GetViewportExtEx(Handle, SaveViewPort);
    end;
    try
      with MTFCanvas do begin
        SetMapMode(Handle, MM_TEXT);//MM_ANISOTROPIC MM_TEXT
        SetWindowExtEx(Handle, LogX, LogY, nil);
        SetViewportExtEx(Handle, Round(LogX * rZoom), Round(LogY * rZoom), nil);
      end;

      SendMessage(ARichedit.Handle, EM_FORMATRANGE, 0, Longint(@Range));
      SendMessage(ARichEdit.handle, EM_FORMATRANGE, 0,0);

      Result := Round(range.rc.bottom * DPI / 1440);
    finally
      with MTFCanvas do begin
        SetMapMode(Handle, SaveMapMode);
        SetWindowExtEx(Handle, SaveWindowExt.cx, SaveWindowExt.cy, nil);
        SetViewportExtEx(Handle, SaveViewPort.cx, SaveViewPort.cy, nil);
      end;
    end;
  finally
    MTFCanvas.Free;
    MTF.Free;
  end;
end;

function DefPrintRTFToCanvasTransparent(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  Rop: Cardinal; FromChar: Integer = 0; ToChar: Integer = -1): Longint;
var B: TBitmap;
begin
  B := TBitmap.Create;
  try
    B.Canvas.Font.Assign(aCanvas.Font);
    B.Width := aRect.Right-aRect.Left;
    B.Height := aRect.Bottom-aRect.Top;
    B.Canvas.Brush.Color := clWhite;
    B.Canvas.FillRect(Rect(0, 0, B.Width, B.Height));

    Result := DefPrintRTFToCanvas(aRichEdit, B.Canvas, Rect(0, 0, B.Width, B.Height), FromChar, ToChar);

    {B.TransparentColor := clWhite;  DOES NOT REALLY FUNCTION BECAUSE OF ANTIALIASING
    B.TransparentMode := tmFixed;
    B.Transparent := True;
    aCanvas.Draw(aRect.Left, aRect.Top, B);}
    BitBlt(aCanvas.Handle, aRect.Left, aRect.Top, B.Width, B.Height,
      B.Canvas.Handle, 0, 0, Rop);
  finally
    B.Free;
  end;
end;

function DefPrintRTFToCanvas(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  FromChar: Integer = 0; ToChar: Integer = -1): Longint; overload;
var
  Range: TFormatRange;
  SaveMapMode, LogX, LogY: Integer;
  //SaveViewPort, SaveWindowExt: tagSize;
  //B: TBitmap;
begin
  //B := TBitmap.Create;
  try
    //B.Canvas.Font.Assign(aCanvas.Font);
    //B.Width := aRect.Right-aRect.Left;
    //B.Height := aRect.Bottom-aRect.Top;
    //B.Canvas.Brush.Color := clWhite;
    //B.Canvas.FillRect(aRect);
    LogX := GetDeviceCaps(ACanvas.Handle, LOGPIXELSX);
    LogY := GetDeviceCaps(ACanvas.Handle, LOGPIXELSY);

    FillChar(Range, SizeOf(TFormatRange), 0);
    Range.hdc        := ACanvas.Handle;
    Range.hdcTarget  := ACanvas.Handle;
    {Range.rc.left    := 0;
    Range.rc.top     := 0;
    Range.rc.right   := B.Width * 1440 div DPI;
    Range.rc.Bottom  := B.Height * 1440 div DPI;}
    Range.rc.left    := aRect.Left * 1440 div LogX;
    Range.rc.top     := aRect.Top * 1440 div LogY;
    Range.rc.right   := aRect.Right * 1440 div LogX;
    Range.rc.Bottom  := aRect.Bottom * 1440 div LogY;
    if not((FromChar = 0) and (ToChar = 0)) then begin
      Range.chrg.cpMax := ToChar;
      Range.chrg.cpMin := FromChar;
    end else begin
      Range.chrg.cpMax := -1;
      Range.chrg.cpMin := 0;
    end;

    with ACanvas do begin
      SaveMapMode := GetMapMode(Handle);
      //GetWindowExtEx(Handle, SaveWindowExt);
      //GetViewportExtEx(Handle, SaveViewPort);
    end;
    try
      with ACanvas do begin
        SetMapMode(Handle, MM_TEXT);//MM_ANISOTROPIC
        //SetWindowExtEx(Handle, DPI, DPI, nil);
        //SetViewportExtEx(Handle, Round(DPI * rZoom), Round(DPI * rZoom), nil);
      end;
      {ARichedit.SelStart :=40;
      ARichedit.SelLength := 15;
      aRichEdit.SelAttributes.Color := clRed;}
      Result := SendMessage(ARichedit.Handle, EM_FORMATRANGE, 1, Longint(@Range));
      SendMessage(ARichEdit.handle, EM_FORMATRANGE, 0,0);

      //aCanvas.Draw(aRect.Left, aRect.Top, B);
      {BitBlt(aCanvas.Handle, aRect.Left, aRect.Top, B.Width, B.Height,
        B.Canvas.Handle, 0, 0, srcAND);}
    finally
      with ACanvas do begin
        SetMapMode(Handle, SaveMapMode);
        //SetWindowExtEx(Handle, SaveWindowExt.cx, SaveWindowExt.cy, nil);
        //SetViewportExtEx(Handle, SaveViewPort.cx, SaveViewPort.cy, nil);
      end;
    end;
  finally
    //B.Free;
  end;
end;

{function PrintRTFToCanvas(ARichEdit: TCustomRichEdit; ACanvas: TCanvas; aRect: TRect;
  DPI, FromChar, ToChar: Integer): Longint;
var
  LogX: Integer;
begin
  LogX := GetDeviceCaps(ACanvas.Handle, LOGPIXELSX);
  if DPI = 0 then
    DPI := ACanvas.Font.PixelsPerInch;
  if DPI <> LogX then
    result := DefPrintRTFToCanvasWithZoom(ARichEdit, ACanvas, aRect, DPI, FromChar, ToChar)
  else
    result := DefPrintRTFToCanvas(aRichEdit, aCanvas, aRect, FromChar, ToChar);
end;}

function CalculateRTFHeight(aRichRawText: String; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint;
begin
  DrawRichEdit.RawRTF := aRichRawText;
  Result := CalculateRTFHeight(DrawRichEdit, aCanvas, aRect, DPI, FromChar, ToChar);
end;

function CalculateRTFHeight(aRichEdit: TCustomRichEdit; aCanvas: TCanvas; aRect: TRect;
  DPI: Integer = 0; FromChar: Integer = 0; ToChar: Integer = -1): Longint;
{var
  LogX: Integer;
  MTF: TMetafile;
  MTFCanvas: TMetafileCanvas;
  aZoom: Single;}
begin
  Result := DefCalculateRTFHeight(aRichEdit, aCanvas, Rect(0, 0, Round((aRect.Right-aRect.Left)), High(SmallInt)), DPI);

  {LogX := GetDeviceCaps(aCanvas.Handle, LOGPIXELSX);
  if DPI = 0 then
    DPI := LogX;

  MTF := TMetafile.Create;
  try
    MTFCanvas := TMetafileCanvas.Create(MTF, 0);
    with MTFCanvas do
    try
      LogX := GetDeviceCaps(Handle, LOGPIXELSX);

      aZoom := DPI / LogX;
      if aZoom <= 0 then
        aZoom := 1;

      Result := Round(DefCalculateRTFHeight(aRichEdit, MTFCanvas, Rect(0, 0, Round((aRect.Right-aRect.Left) / aZoom), High(SmallInt)), 0) * aZoom);
      //Result := Round(DefCalculateRTFHeight(aRichEdit, MTFCanvas, aRect, 0) * aZoom);
    finally
      Free;
    end;
  finally
    MTF.Free;
  end;}
end;

function PrintRTFToCanvas(ARichEdit: TCustomRichEdit; ACanvas: TCanvas; aRect: TRect;
  DPI, FromChar, ToChar: Integer): Longint;
var
  LogX: Integer;
  MTF: TMetafile;
  MTFCanvas: TMetafileCanvas;
  aZoom: Single;
begin
  LogX := GetDeviceCaps(aCanvas.Handle, LOGPIXELSX);
  if DPI = 0 then
    DPI := LogX;

  if DPI = LogX then begin
    result := DefPrintRTFToCanvas(aRichEdit, aCanvas, aRect, FromChar, ToChar);{}
  end else begin
    MTF := TMetafile.Create;
    try
      with TMetafileCanvas.Create(MTF, 0) do
      try
        LogX := GetDeviceCaps(Handle, LOGPIXELSX);
      finally
        Free;
      end;

      aZoom := DPI / LogX;
      if aZoom <= 0 then
        aZoom := 1;

      MTF.Width := Round((aRect.Right-aRect.Left) / aZoom);
      //ShowMessage(IntToStr((aRect.Right-aRect.Left))+':'+IntToStr(MTF.Width));
      MTF.Height := Round((aRect.Bottom-aRect.Top) / aZoom);

      MTFCanvas := TMetafileCanvas.Create(MTF, 0);
      with MTFCanvas do
      try
        Result := DefPrintRTFToCanvas(aRichEdit, MTFCanvas, Rect(0, 0, MTF.Width, MTF.Height), FromChar, ToChar);
      finally
        MTFCanvas.Free;
      end;

      //MTF.Width := Round((aRect.Right-aRect.Left) / 1);
      //ShowMessage(IntToStr((aRect.Right-aRect.Left))+':'+IntToStr(MTF.Width));
      //MTF.Height := Round((aRect.Bottom-aRect.Top) / 1);

      ACanvas.StretchDraw(aRect, MTF);
      //ACanvas.Draw(0, 0, MTF);
    finally
      MTF.Free;
    end;{}
  end;
  
  {LogX := GetDeviceCaps(ACanvas.Handle, LOGPIXELSX);
  if DPI = 0 then
    DPI := ACanvas.Font.PixelsPerInch;
  if DPI <> LogX then
    result := DefPrintRTFToCanvasWithZoom(ARichEdit, ACanvas, aRect, DPI, FromChar, ToChar)
  else
    result := DefPrintRTFToCanvas(aRichEdit, aCanvas, aRect, FromChar, ToChar);{}
end;


{ TPrintRichEdit }

function TPrintRichEdit.DrawTo(ACanvas: TCanvas; aRect: TRect; DPI, FromChar,
  ToChar: Integer): Longint;
begin
  Result := PrintRTFToCanvas(Self, ACanvas, aRect, DPI, FromChar, ToChar);
end;

function TPrintRichEdit.GetRawRTF: String;
begin
  Result := PrintRichText.GetRawRTF(Self);

  Result := TrimRight(WideReplaceText(Result, #0, '')); 
end;

function TPrintRichEdit.GetTextLenW: Integer;
begin
  //Result := TntAdjustLineBreaksLength(Text, GetLineBreakStyle);
  Result := TntAdjustLineBreaksLength(TntControl_GetText(Self), GetLineBreakStyle);
end;

function TPrintRichEdit.GetLineBreakStyle: TTntTextLineBreakStyle;
begin
  Result := TTntRichEditAccessProtected(Self).LineBreakStyle;
end;

procedure TPrintRichEdit.MyDelete(aPos, aLength: Integer);
begin
  SelStart := aPos-1;
  SelLength := aLength;
  SelText := '';
end;

function TPrintRichEdit.MyFindText(aStr: WideString;
  FromPosition: Integer): Integer;
begin
  Result := FindText(aStr, FromPosition-1, Length(Text)-FromPosition+1, [])+1;
end;

procedure TPrintRichEdit.ProcessIfStatement(const IfStatement, ElseStatement,
  EndIfStatement: WideString; const aBoolean: Boolean);
var pos1, pos2, pos3: Integer;
  I: Integer;
begin
  I := 0;
  pos1 := MyFindText(IfStatement);
  while (pos1 <> 0) and (I < 20) do begin
    MyDelete(pos1, Length(IfStatement));

    pos2 := MyFindText(ElseStatement, pos1);
    pos3 := MyFindText(EndIfStatement, pos1);
    pos2 := Min(pos2, pos3);
    if (pos2 = 0) then
      pos2 := pos3;
    if aBoolean then begin
      MyDelete(pos2, pos3-pos2+Length(EndIfStatement));
    end else begin
      MyDelete(pos1, pos2-pos1);
      if (MyFindText(ElseStatement, pos1) = pos1) then
        MyDelete(pos1, Length(ElseStatement));
      pos1 := MyFindText(EndIfStatement, pos1);
      MyDelete(pos1, Length(EndIfStatement));
    end;
    pos1 := MyFindText(IfStatement);
    Inc(I);
  end;
end;

procedure TPrintRichEdit.ProcessIfStatement(const IfStatement: WideString;
  const aBoolean: Boolean);
var ElseStatement, EndIfStatement: WideString;
begin
  if Length(IfStatement) > 0 then begin
    ElseStatement := IfStatement[1] + 'ELSE' + IfStatement[Length(IfStatement)];
    EndIfStatement := IfStatement[1] + 'ENDIF' + IfStatement[Length(IfStatement)];

    ProcessIfStatement(IfStatement, ElseStatement, EndIfStatement, aBoolean);
  end;
end;

procedure TPrintRichEdit.ReplaceText(const FromStr, ToStr: WideString);
var X: Integer;
begin
  X := 1;
  X := MyFindText(FromStr, X);
  while X <> 0 do begin
    SelStart := X-1;
    SelLength := Length(FromStr);
    SelText := ToStr;
    X := MyFindText(FromStr, X + Length(ToStr));
  end;
end;

procedure TPrintRichEdit.SetRawRTF(const Value: String);
begin
  PrintRichText.SetRawRTF(Self, Value);
end;

function ReplaceRTFText(aRichRawText: String; aFromText, aToText: WideString): String;
var
  RE: TTntRichEdit;
begin
  RE := TTntRichEdit.Create(nil);
  with RE do
  try
    Visible := false;
    Parent := Application.MainForm;

    RawRTF := aRichRawText;

    ReplaceText(aFromText, aToText);

    Result := RawRTF;
  finally
    RE.Free;
  end;
end;



{ TTntRichEditAccessProtected }

function TTntRichEditAccessProtected.LineBreakStyle: TTntTextLineBreakStyle;
begin
  Result := inherited LineBreakStyle;
end;

end.

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ComCtrls, TntComCtrls;

type
  TForm1 = class(TForm)
    RE1: TTntRichEdit;
    BtnSynopseRTFTest: TButton;
    BtnMorePagesTest: TButton;
    procedure BtnSynopseRTFTestClick(Sender: TObject);
    procedure BtnMorePagesTestClick(Sender: TObject);
  private
    { Private declarations }
  protected
    procedure DoCreate; override;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses SynPDF, PrintRichText, TntSysUtils;

procedure TForm1.BtnMorePagesTestClick(Sender: TObject);
var
  xPDF: TPdfDocumentGDI;
  xRect: TRect;
  xMF: TMetafile;
  xMFC: TMetaFileCanvas;
  xHeight, xLastChar, xMaxChar, I: Integer;

begin
  xPDF := TPdfDocumentGDI.Create;
  xMF := TMetafile.Create;
  try
    xPDF.AddPage;

    xLastChar := -1;
    //xMaxChar := RE1.GetTextLen;//USE FOR NORMAL RichEdit
    xMaxChar := RE1.GetTextLenW;
    I := 0;
    repeat
      xRect := Rect(100, 100+I*200, 300, 190++I*200);
      xLastChar := PrintRTFToCanvas(RE1, xPDF.VCLCanvas, xRect, 0, xLastChar);
      with xPDF.VCLCanvas do begin
        Brush.Style := bsClear;
        Pen.Width := 1;
        Pen.Color := clBlack;
        Rectangle(xRect);
      end;
      Inc(I);
    until (xLastChar >= xMaxChar) or (xLastChar = -1);
    
    xPDF.SaveToFile('a.pdf');
  finally
    xPDF.Free;
    xMF.Free;
  end;
end;

procedure TForm1.BtnSynopseRTFTestClick(Sender: TObject);
var
  xPDF: TPdfDocumentGDI;
  xRect: TRect;
  xMF: TMetafile;
  xMFC: TMetaFileCanvas;
  xHeight, xLastChar: Integer;

begin
  xPDF := TPdfDocumentGDI.Create;
  xMF := TMetafile.Create;
  try
    xPDF.AddPage;

    xRect := Rect(100, 100, 300, 1000);
    xHeight := CalculateRTFHeight(RE1, xPDF.VCLCanvas, xRect);
    xRect.Bottom := xRect.Top + xHeight;
    PrintRTFToCanvas(RE1, xPDF.VCLCanvas, xRect);
    with xPDF.VCLCanvas do begin
      Brush.Style := bsClear;
      Pen.Width := 1;
      Pen.Color := clBlack;
      Rectangle(xRect);
    end;

    xPDF.SaveToFile('a.pdf');
  finally
    xPDF.Free;
    xMF.Free;
  end;
end;

procedure TForm1.DoCreate;
var xStr: TStrings;
  I: Integer;
begin
  inherited;

  xStr := TStringList.Create;
  try
    if FileExists('a.rtf') then
      xStr.LoadFromFile('a.rtf');
    RE1.RawRTF := xStr.Text;
  finally
    xStr.Free;
  end;
end;

end.

procedure TForm1.Btn1Click(Sender: TObject);
var
  xPDF: TPdfDocumentGDI;
  xRect: TRect;
  xMF: TMetafile;
  xMFC: TMetaFileCanvas;

  procedure RotTextWithPoint(aC: TCanvas; aText: String; aAngle, aX, aY: Integer);
  var
    xLF: TLogFont;
    xF: TFont;
  begin
    xF := TFont.Create;
    try
      xF.Assign(aC.Font);
      GetObject(xF.Handle, SizeOf(xLF), @xLF);
      xLF.lfEscapement  := aAngle*10;
      xLF.lfOrientation := aAngle*10;
      SetBkMode(Handle, TRANSPARENT);
      xF.Handle := CreateFontIndirect(xLF);
      aC.Font.Assign(xF);
    finally
      xF.Free;
    end;
    aC.TextOut(aX, aY, aText);
    aC.MoveTo(aX-2, aY);
    aC.LineTo(aX+2,aY);
    aC.MoveTo(aX,aY-2);
    aC.LineTo(aX,aY+2);
  end;
  
begin
  xPDF := TPdfDocumentGDI.Create;
  xMF := TMetafile.Create;
  try
    xMF.Width := 500;
    xMF.Height := 500;
    
    xMFC := TMetafileCanvas.Create(xMF, 0);
    with xMFC do
    try
      Pen.Color := clBlue;
      Brush.Style := bsClear;
      Rectangle(0, 0, ClipRect.Right-1, ClipRect.Bottom-1);
      Pen.Color := clRed;
      xRect := Rect(100, 20, 150, 40);
      Rectangle(xRect);
      
      TextRect(xRect, xRect.Left, xRect.Top, 'long text is not clipped');

      RotTextWithPoint(xMFC, 'rotated text is misplaced', 90, 100, 200);
      RotTextWithPoint(xMFC, 'rotated text is misplaced', 180, 250, 200);
      RotTextWithPoint(xMFC, 'rotated text is misplaced', 270, 300, 200);
      RotTextWithPoint(xMFC, 'rotated text is misplaced', 45, 350, 200);
    finally
      Free;
    end;

    xMF.SaveToFile('a.emf');

    xPDF.AddPage;
    with xPDF.VCLCanvas do begin
      Draw(0, 0, xMF);
    end;

    xPDF.SaveToFile('a.pdf');
  finally
    xPDF.Free;
    xMF.Free;
  end;
end;

(...)
    if font.spec.angle<>0 then begin
      a := font.spec.angle*(PI/180);
      acos := cos(a);
      asin := sin(a);
      with Canvas do
        SetTextMatrix(acos, asin, -asin, acos,
          I2X(R.emrtext.ptlReference.X+Round(W*acos-H*asin)),
          I2Y(R.emrtext.ptlReference.Y-Round(H*acos-W*asin))); // <- minus sign REDDWARF
    end else
(...)

procedure TPdfEnum.TextOut(var R: TEMRExtTextOut);
var W,H: integer;
    DX: PIntegerArray; // not handled during drawing yet
    ASize: single;
    tmp: array of WideChar; // R.emrtext is not #0 terminated -> use tmp[]
    a, acos, asin: single;
begin
  with DC[nDC] do begin
    SetLength(tmp,R.emrtext.nChars+1); // faster than WideString for our purpose
    move(pointer(PtrUInt(@R)+R.emrtext.offString)^,tmp[0],R.emrtext.nChars*2);
    // guess the font size
    if font.LogFont.lfHeight<0 then
      ASize := -font.LogFont.lfHeight*Canvas.fFactorY else
      ASize := font.spec.cell*Canvas.fFactorY;
    // ensure this font is selected (very fast if was already selected)
    Canvas.SetFont(Canvas.FDoc.FDC,font.LogFont,ASize);
    // calculate coordinates
    if R.emrtext.offDx=0 then begin
       if R.emrtext.fOptions and ETO_GLYPH_INDEX<>0 then
         W := 0 else
         W := Round(Canvas.UnicodeTextWidth(pointer(tmp))/Canvas.fFactorX);
    end else  begin
      DX := pointer(cardinal(@R)+R.emrtext.offDx);
      W := DXTextWidth(DX,R.emrText.nChars);
    end;
    if font.Align and TA_CENTER=TA_CENTER then
      W := W shr 1 else
    if font.Align and TA_RIGHT=0 then
      W := 0;
    if font.Align and TA_BASELINE<>0 then
      H := 0 else
    if font.Align and TA_BOTTOM<>0 then
      H := font.spec.descent else
      H := -font.spec.ascent;
    // draw background (if any)
    if (R.emrtext.fOptions and ETO_OPAQUE<>0) and not brush.null and
       (font.spec.angle=0) then begin
      // don't handle BkMode, since global to the page, but only specific text
      // don't handle rotation here, since should not be used much
      NormalizeRect(R.rclBounds);
      FillRectangle(R.rclBounds);
    end;
    // draw text
    FillColor := font.color;
{$ifdef USE_UNISCRIBE}
    Canvas.RightToLeftText := R.emrtext.fOptions and ETO_RTLREADING<>0;
{$endif}

    //REDDWARF BEGIN CLIPPING
    with Canvas do begin
      GSave;
      with R.emrtext.rcl do begin
        MoveTo(I2X(Left), I2Y(Top));
        LineTo(I2X(Left), I2Y(Bottom-1));
        LineTo(I2X(Right-1), I2Y(Bottom-1));
        LineTo(I2X(Right-1), I2Y(Top));
      end;
      ClosePath;
      Clip;
      NewPath;
    end;
    //REDDWARF END CLIPPING

    Canvas.BeginText;
    if font.spec.angle<>0 then begin
      a := font.spec.angle*(PI/180);
      acos := cos(a);
      asin := sin(a);
      with Canvas do
        SetTextMatrix(acos, asin, -asin, acos,
          I2X(R.emrtext.ptlReference.X+Round(W*acos-H*asin)),
          I2Y(R.emrtext.ptlReference.Y-Round(H*acos-W*asin))); // <- minus REDDWARF
    end else
      Canvas.MoveTextPoint(
        Canvas.I2X(R.emrtext.ptlReference.X-W),
        Canvas.I2Y(R.emrtext.ptlReference.Y-H));
    if R.emrtext.fOptions and ETO_GLYPH_INDEX<>0 then
      Canvas.ShowGlyph(pointer(tmp),R.emrtext.nChars) else
      Canvas.ShowText(pointer(tmp));
    Canvas.EndText;

    Canvas.GRestore;//REDDWARF CLIPPING RESTORE
  end;
end;