CodeSnip Old Code (SVN)

{
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/
 *
 * Copyright (C) 2011-2013, Peter Johnson (www.delphidabbler.com).
 *
 * $Rev$
 * $Date$
 *
 * Unicode string utility routines.
 *
 * Some of the routines are simply wrappers around SysUtils and StrUtils string
 * routines with the purpose of (a) collecting them together in one place and
 * (b) providing a standardised parameter order. Other routines are original.
}


unit UStrUtils;


interface


uses
  // Delphi
  Classes;


///  <summary>Checks if string Haystack contains string Needle. Case sensitive.
///  </summary>
function StrContainsStr(const Needle, Haystack: UnicodeString): Boolean;

///  <summary>Checks if string Haystack contains string Needle. Case
///  insensitive.</summary>
function StrContainsText(const Needle, Haystack: UnicodeString): Boolean;

///  <summary>Checks if string Str is present in string array Values. Case
///  insensitive.</summary>
function StrMatchText(const Str: string; const Values: array of string):
  Boolean;

///  <summary>Returns index of string Needle in string Haystack or 0 if Needle
///  is not in Haystack. Case sensitive.</summary>
function StrPos(const Needle, Haystack: UnicodeString): Integer; overload;

///  <summary>Returns index of string Needle in string Haystack, beginning the
///  search at Offset. Returns 0 if Haystack is not found or if Offset is less
///  than 1 or greater than length of Haystack. Case sensitive.</summary>
function StrPos(const Needle, Haystack: UnicodeString; const Offset: Integer):
  Integer; overload;

///  <summary>Returns index of last occurence of string Needle in string
///  Haystack or 0 if Needle is not in Haystack. Case sensitive.</summary>
function StrLastPos(const Needle, Haystack: UnicodeString): Integer;

///  <summary>Compares Left and Right strings, ignoring case. Returns 0 if both
///  strings are the same, -ve if Left is less than Right or +ve if Left is
///  greater than Right.</summary>
function StrCompareText(const Left, Right: UnicodeString): Integer;

///  <summary>Checks if Left and Right strings are equal. Case sensitive.
///  </summary>
function StrSameStr(const Left, Right: UnicodeString): Boolean;

///  <summary>Checks if Left and Right strings are equivalent when case is
///  ignored.</summary>
function StrSameText(const Left, Right: UnicodeString): Boolean;

///  <summary>Converts a string to upper case.</summary>
function StrToUpper(const Str: UnicodeString): UnicodeString;

///  <summary>Converts a string to lower case.</summary>
function StrToLower(const Str: UnicodeString): UnicodeString;

///  <summary>Returns a substring of Str starting at index StartIdx of length
///  Count.</summary>
///  <remarks>
///  <para>If Count specifies more than the available number of characters, the
///  substring from StartIdx to the end of the string is returned.</para>
///  <para>If StartIdx is beyond the end of Str the empty string is returned.
///  </para>
///  </remarks>
function StrSlice(const Str: UnicodeString; const StartIdx, Count: Integer):
  UnicodeString;

///  <summary>Returns the leading characters of Str up to a length of Count
///  characters.</summary>
///  <remarks>If Count is greater than the length of Str the whole string is
///  returned.</remarks>
function StrSliceLeft(const Str: UnicodeString; const Count: Integer):
  UnicodeString;

///  <summary>Returns the trailing characters of Str up to a length of Count
///  characters.</summary>
///  <remarks>If Count is greater than the length of Str the whole string is
///  returned.</remarks>
function StrSliceRight(const Str: UnicodeString; const Count: Integer):
  UnicodeString;

///  <summary>Checks if string Str begins with sub string SubStr. Case
///  sensitive.</summary>
///  <remarks>False is returned if SubStr = ''.</remarks>
function StrStartsStr(const SubStr, Str: UnicodeString): Boolean;

///  <summary>Checks if string Str begins with sub string SubStr. Case
///  insensitive.</summary>
///  <remarks>False is returned if SubStr = ''.</remarks>
function StrStartsText(const SubStr, Str: UnicodeString): Boolean;

///  <summary>Replaces all occurences of FindStr in Str with ReplaceStr.
///  </summary>
function StrReplace(const Str, FindStr, ReplaceStr: UnicodeString):
  UnicodeString;

///  <summary>Trims leading and trailing white space characters from a string.
///  </summary>
///  <remarks>White space is considered to be any character from #0..#32.
///  </remarks>
function StrTrim(const Str: UnicodeString): UnicodeString;

///  <summary>Trims leading white space characters from a string.</summary>
///  <remarks>White space is considered to be any character from #0..#32.
///  </remarks>
function StrTrimLeft(const Str: UnicodeString): UnicodeString;

///  <summary>Trims trailing white space characters from a string.</summary>
///  <remarks>White space is considered to be any character from #0..#32.
///  </remarks>
function StrTrimRight(const Str: UnicodeString): UnicodeString;

///  <summary>Trims leading and trailing characters C from string Str.</summary>
function StrTrimChars(const Str: UnicodeString; const C: Char): UnicodeString;

///  <summary>Trims leading characters C from string Str.</summary>
function StrTrimLeftChars(const Str: UnicodeString; const C: Char):
  UnicodeString;

///  <summary>Trims trailing characters C from string Str.</summary>
function StrTrimRightChars(const Str: UnicodeString; const C: Char):
  UnicodeString;

///  <summary>Ensures line breaks in a string are in Windows format (CRLF).
///  </summary>
///  <remarks>Converts both Unix (LF) and Macintosh (CR) to CRLF.</remarks>
function StrWindowsLineBreaks(const Str: UnicodeString): UnicodeString;

///  <summary>Ensures line breaks in a string are in Unix format (LF).
///  </summary>
///  <remarks>Converts both Windows (CRLF) and Macintosh (CR) to LF.</remarks>
function StrUnixLineBreaks(const Str: UnicodeString): UnicodeString;

///  <summary>Checks if the character at index Idx in Str is one of the
///  delimiter characters stored in Delims.</summary>
///  <remarks>Delims must contain only characters that take just one wide
///  character, i.e. they are from the basic multiligual plane.</remarks>
function StrIsDelimiter(const Delims, Str: UnicodeString; const Idx: Integer):
  Boolean;

///  <summary>Returns total number of occurences of delimieters from Delim in
///  string Str.</summary>
///  <remarks>Delims must contain only characters that take just one wide
///  character, i.e. they are from the basic multiligual plane.</remarks>
function StrCountDelims(const Delims, Str: UnicodeString): Integer;

///  <summary>Returns position of last character in Str that matches any
///  character from Delims.</summary>
///  <remarks>Delims must contain only characters that take just one wide
///  character, i.e. they are from the basic multiligual plane.</remarks>
function StrLastDelimiterPos(const Delims, Str: UnicodeString): Integer;

///  <summary>Capitalises each word in string Str.</summary>
///  <remarks>Words are recognised only if separated by white space.</remarks>
function StrCapitaliseWords(const Str: UnicodeString): UnicodeString;

///  <summary>Compresses white space in string Str.</summary>
///  <remarks>Each sequence of one or more white space characters in Str is
///  replaced by a single space.</remarks>
function StrCompressWhiteSpace(const Str: UnicodeString): UnicodeString;

///  <summary>Removes all white space from string Str.</summary>
function StrStripWhiteSpace(const Str: UnicodeString): UnicodeString;

///  <summary>Checks if a stream contains white space.</summary>
function StrContainsWhiteSpace(const Str: UnicodeString): Boolean;

///  <summary>Encloses string Str in quotes specified by Quote iff Str contains
///  white space.</summary>
///  <remarks>Opening and closing quote are the same character.</remarks>
function StrQuoteSpaced(const Str: UnicodeString;
  const Quote: Char = '"'): UnicodeString;

///  <summary>Joins all strings from a string list together into a single string
///  with each list element being separated by Delim. Empty string list elements
///  are included in the output string only if AllowEmpty is True.</summary>
function StrJoin(const SL: TStrings; const Delim: UnicodeString;
  const AllowEmpty: Boolean = True): UnicodeString;

///  <summary>Splits string Str at delimiter Delim and records the components in
///  List. If TrimStrs is True spaces are trimmed from each component. If
///  AllowEmpty is True empty components are added to List.</summary>
///  <remarks>String components are trimmed before being checked for emptyness.
///  </remarks>
function StrExplode(Str: UnicodeString; const Delim: UnicodeString;
  const List: TStrings; const AllowEmpty: Boolean = True;
  const TrimStrs: Boolean = False): Integer;

///  <summary>Splits string Str at the first occurence of Delim setting Left to
///  the string preceding Delim and Right to the string following Delim.
///  Returns True if Delim was found in Str, False if not.</summary>
///  <remarks>Left and Right be empty if Delim is found at the start or end of
///  Str respectively.</remarks>
function StrSplit(const Str: UnicodeString; const Delim: UnicodeString;
  out Left, Right: UnicodeString): Boolean;

///  <summary>Returns the portion of string Str preceding the first occurence of
///  string Str and removes the returned string and Delim from Str.</summary>
///  <remarks>The empty string is returned if Str is empty or begins with Delim.
///  Str can be set to the empty string if Delim ends the string of if Str was
///  empty when the routine was called.</remarks>
function StrPop(var Str: string; const Delim: string): string;

///  <summary>Word wraps text Str to form lines of maximum length MaxLen and
///  offsets each line using spaces to form a left margin of size given by
///  Margin.</summary>
///  <remarks>Output lines are separated by CRLF.</remarks>
function StrWrap(const Str: UnicodeString; const MaxLen, Margin: Integer):
  UnicodeString; overload;

///  <summary>Word wraps each paragraph of text in Paras so that each line of a
///  paragraph has lines of maximum length MaxLineLen and is offset by the
///  number of spaces gvien by Margin. Blanks lines are used to separate
///  output paragraphs iff SeparateParas is true.</summary>
///  <remarks>Output lines are separated by CRLF.</remarks>
function StrWrap(const Paras: TStrings; const MaxLineLen, Margin: Integer;
  const SeparateParas: Boolean): UnicodeString; overload;

///  <summary>Checks in string Str forms a valid sentence and, if not, adds a
///  full stop.</summary>
///  <remarks>Trailing white space is ignored when detecting full stops etc.
///  </remarks>
function StrMakeSentence(const Str: UnicodeString): UnicodeString;

///  <summary>Returns one of two strings, TrueStr or FalseStr, depending on
///  value of given Condition.</summary>
function StrIf(const Condition: Boolean; const TrueStr, FalseStr: string):
  string;


implementation


uses
  // Delphi
  SysUtils, StrUtils, Character,
  // Project
  UConsts;

{ Internal helper routines }

///  <summary>Checks if character at position Idx in Str can be trimmed from
///  string.</summary>
///  <remarks>Character can be trimmed if it's not part of a multi-character
///  sequence and TrimFn returns True for the character.</remarks>
function IsTrimmableChar(const Str: UnicodeString; const Idx: Integer;
  const TrimFn: TFunc<Char,Boolean>): Boolean;
begin
  Result := (ByteType(Str, Idx) = mbSingleByte) and TrimFn(Str[Idx]);
end;

///  <summary>Trims characters from both ends of a string.</summary>
///  <remarks>Anonymous function TrimFn determines whether a character is to be
///  trimmed.</remarks>
function InternalTrim(const Str: UnicodeString;
  const TrimFn: TFunc<Char,Boolean>): UnicodeString;
var
  TextStart: Integer; // position of start of non-space text
  TextEnd: Integer;   // position of end of non-space text
begin
  TextEnd := Length(Str);
  TextStart := 1;
  while (TextStart <= TextEnd)
    and IsTrimmableChar(Str, TextStart, TrimFn) do
    Inc(TextStart);
  if TextStart > TextEnd then
    Exit('');
  while IsTrimmableChar(Str, TextEnd, TrimFn) do
    Dec(TextEnd);
  Result := Copy(Str, TextStart, TextEnd - TextStart + 1);
end;

///  <summary>Trims characters from the left hand end of a string.</summary>
///  <remarks>Anonymous function TrimFn determines whether a character is to be
///  trimmed.</remarks>
function InternalTrimLeft(const Str: UnicodeString;
  const TrimFn: TFunc<Char,Boolean>): UnicodeString;
var
  TextStart: Integer; // position of start of non-space text
begin
  TextStart := 1;
  while (TextStart <= Length(Str))
    and IsTrimmableChar(Str, TextStart, TrimFn) do
    Inc(TextStart);
  Result := Copy(Str, TextStart, MaxInt);
end;

///  <summary>Trims characters from the right hand end of a string.</summary>
///  <remarks>Anonymous function TrimFn determines whether a character is to be
///  trimmed.</remarks>
function InternalTrimRight(const Str: UnicodeString;
  const TrimFn: TFunc<Char,Boolean>): UnicodeString;
var
  TextEnd: Integer;   // position of end of non-space text
begin
  TextEnd := Length(Str);
  while (TextEnd > 0) and IsTrimmableChar(Str, TextEnd, TrimFn) do
    Dec(TextEnd);
  Result := Copy(Str, 1, TextEnd);
end;

{ Public routines }

function StrCapitaliseWords(const Str: UnicodeString): UnicodeString;
var
  Idx: Integer;           // loops through each character in string
  WantCapital: Boolean;   // flag indicating whether captial letter required
begin
  Result := Str;
  WantCapital := True;
  for Idx := 1 to Length(Str) do
  begin
    if TCharacter.IsLetter(Result[Idx]) then
    begin
      if WantCapital then
        Result[Idx] := TCharacter.ToUpper(Result[Idx]);
      WantCapital := False;
    end
    else
      WantCapital := TCharacter.IsWhiteSpace(Result[Idx]);
  end;
end;

function StrCompareText(const Left, Right: UnicodeString): Integer;
begin
  Result := SysUtils.AnsiCompareText(Left, Right);
end;

function StrCompressWhiteSpace(const Str: UnicodeString): UnicodeString;
var
  Idx: Integer;       // loops thru all characters in string
  ResCount: Integer;  // counts number of characters in result string
  PRes: PChar;        // pointer to characters in result string
begin
  // Set length of result to length of source string and set pointer to it
  SetLength(Result, Length(Str));
  PRes := PChar(Result);
  // Reset count of characters in result string
  ResCount := 0;
  // Loop thru characters of source string
  Idx := 1;
  while Idx <= Length(Str) do
  begin
    if TCharacter.IsWhiteSpace(Str[Idx]) then
    begin
      // Current char is white space: replace by space char and count it
      PRes^ := ' ';
      Inc(PRes);
      Inc(ResCount);
      // Skip past any following white space
      Inc(Idx);
      while TCharacter.IsWhiteSpace(Str[Idx]) do
        Inc(Idx);
    end
    else
    begin
      // Current char is not white space: copy it literally and count it
      PRes^ := Str[Idx];
      Inc(PRes);
      Inc(ResCount);
      Inc(Idx);
    end;
  end;
  // Reduce length of result string if it is shorter than source string
  if ResCount < Length(Str) then
    SetLength(Result, ResCount);
end;

function StrContainsStr(const Needle, Haystack: UnicodeString): Boolean;
begin
  Result := StrUtils.AnsiContainsStr(Haystack, Needle);
end;

function StrContainsText(const Needle, Haystack: UnicodeString): Boolean;
begin
  Result := StrUtils.AnsiContainsText(Haystack, Needle);
end;

function StrMatchText(const Str: string; const Values: array of string):
  Boolean;
begin
  Result := StrUtils.MatchText(Str, Values);
end;

function StrContainsWhiteSpace(const Str: UnicodeString): Boolean;
var
  Ch: Char;   // scans through Str
begin
  Result := False;
  for Ch in Str do
    if TCharacter.IsWhiteSpace(Ch) then
      Exit(True);
end;

function StrCountDelims(const Delims, Str: UnicodeString): Integer;
var
  Idx: Integer; //loops thru all characters in string
begin
  Result := 0;
  for Idx := 1 to Length(Str) do
    if StrIsDelimiter(Delims, Str, Idx) then
      Inc(Result);
end;

function StrExplode(Str: UnicodeString; const Delim: UnicodeString;
  const List: TStrings; const AllowEmpty: Boolean = True;
  const TrimStrs: Boolean = False): Integer;
var
  Head: UnicodeString;      // head of Str before delimiter
  Remainder: UnicodeString; // remaining unconsumed part of string

  // ---------------------------------------------------------------------------
  procedure ProcessHead;
    {Modifies Head string as necessary and adds to list if required.
    }
  begin
    if TrimStrs then
      Head := StrTrim(Head);
    if (Head <> '') or AllowEmpty then
      List.Add(Head)
  end;
  // ---------------------------------------------------------------------------

begin
  // Clear the list
  List.Clear;
  // Check we have some entries in the string
  if Str <> '' then
  begin
    // Repeatedly split string until we have no more entries
    while StrSplit(Str, Delim, Head, Remainder) do
    begin
      ProcessHead;
      // Go round again with remainder of string
      Str := Remainder;
    end;
    // Deal with Head after last delimiter, if any
    ProcessHead;
  end;
  Result := List.Count;
end;

function StrIsDelimiter(const Delims, Str: UnicodeString; const Idx: Integer):
  Boolean;
begin
  Result := SysUtils.IsDelimiter(Delims, Str, Idx);
end;

function StrJoin(const SL: TStrings; const Delim: UnicodeString;
  const AllowEmpty: Boolean = True): UnicodeString;
var
  Idx: Integer;       // loops thru all items in string list
  FirstItem: Boolean; // flag true until first item has been added to result
begin
  Result := '';
  FirstItem := True;
  for Idx := 0 to Pred(SL.Count) do
  begin
    if (SL[Idx] <> '') or AllowEmpty then
    begin
      if FirstItem then
      begin
        Result := SL[Idx];
        FirstItem := False;
      end
      else
        Result := Result + Delim + SL[Idx];
    end;
  end;
end;

function StrLastDelimiterPos(const Delims, Str: UnicodeString): Integer;
begin
  Result := SysUtils.LastDelimiter(Delims, Str);
end;

function StrLastPos(const Needle, Haystack: UnicodeString): Integer;
var
  Idx: Integer; // an index of Needle in Haystack
begin
  Result := 0;
  Idx := StrPos(Needle, Haystack);
  if Idx = 0 then
    Exit;
  while Idx > 0 do
  begin
    Result := Idx;
    Idx := StrPos(Needle, Haystack, Idx + 1);
  end;
end;

function StrMakeSentence(const Str: UnicodeString): UnicodeString;
resourcestring
  // characters that can close sentence
  sSentenceClosers = '.!?';
  sFullStop = '.';
var
  Sentence: UnicodeString;            // sentence text without trailing spaces
  TrailingWhiteSpace: UnicodeString;  // records trailing white space from Str
begin
  Sentence := StrTrimRight(Str);
  TrailingWhiteSpace := StrSliceRight(Str, Length(Str) - Length(Sentence));
  if Sentence = '' then
    Exit(TrailingWhiteSpace);
  if not StrIsDelimiter(sSentenceClosers, Sentence, Length(Sentence)) then
    Sentence := Sentence + sFullStop;
  Result := Sentence + TrailingWhiteSpace;
end;

function StrPos(const Needle, Haystack: UnicodeString): Integer;
begin
  Result := SysUtils.AnsiPos(Needle, Haystack);
end;

function StrPos(const Needle, Haystack: UnicodeString; const Offset: Integer):
  Integer;
begin
  Result := StrUtils.PosEx(Needle, Haystack, Offset);
end;

function StrQuoteSpaced(const Str: UnicodeString;
  const Quote: Char = '"'): UnicodeString;
begin
  if StrContainsWhiteSpace(Str) then
    Result := Quote + Str + Quote
  else
    Result := Str;
end;

function StrReplace(const Str, FindStr, ReplaceStr: UnicodeString):
  UnicodeString;
begin
  Result := StrUtils.AnsiReplaceStr(Str, FindStr, ReplaceStr);
end;

function StrSameStr(const Left, Right: UnicodeString): Boolean;
begin
  Result := SysUtils.AnsiSameStr(Left, Right);
end;

function StrSameText(const Left, Right: UnicodeString): Boolean;
begin
  Result := SysUtils.AnsiSameText(Left, Right);
end;

function StrSlice(const Str: UnicodeString; const StartIdx, Count: Integer):
  UnicodeString;
begin
  Result := StrUtils.AnsiMidStr(Str, StartIdx, Count);
end;

function StrSliceLeft(const Str: UnicodeString; const Count: Integer):
  UnicodeString;
begin
  Result := StrUtils.AnsiLeftStr(Str, Count);
end;

function StrSliceRight(const Str: UnicodeString; const Count: Integer):
  UnicodeString;
begin
  Result := StrUtils.AnsiRightStr(Str, Count);
end;

function StrSplit(const Str: UnicodeString; const Delim: UnicodeString;
  out Left, Right: UnicodeString): Boolean;
var
  DelimPos: Integer;  // position of delimiter in source string
begin
  // Find position of first occurence of delimiter in string
  DelimPos := StrPos(Delim, Str);
  if DelimPos > 0 then
  begin
    // Delimiter found: split string at delimiter
    Left := Copy(Str, 1, DelimPos - 1);
    Right := Copy(Str, DelimPos + Length(Delim), MaxInt);
    Result := True;
  end
  else
  begin
    // Delimiter not found: set Left to whole string
    Left := Str;
    Right := '';
    Result := False;
  end;
end;

function StrPop(var Str: string; const Delim: string): string;
var
  Right: string;  // part of Str to right of Delim
begin
  StrSplit(Str, Delim, Result, Right);
  Str := Right;
end;

function StrStartsStr(const SubStr, Str: UnicodeString): Boolean;
begin
  if SubStr = '' then
    Exit(False);
  Result := StrUtils.AnsiStartsStr(SubStr, Str);
end;

function StrStartsText(const SubStr, Str: UnicodeString): Boolean;
begin
  if SubStr = '' then
    Exit(False);
  Result := StrUtils.AnsiStartsText(SubStr, Str);
end;

function StrStripWhiteSpace(const Str: UnicodeString): UnicodeString;
var
  Idx: Integer;       // loops thru all characters in string
  ResCount: Integer;  // counts number of characters in result string
  PRes: PChar;        // pointer to characters in result string
begin
  // Set length of result to length of source string and set pointer to it
  SetLength(Result, Length(Str));
  PRes := PChar(Result);
  // Reset count of characters in result string
  ResCount := 0;
  // Loop thru characters of source string
  Idx := 1;
  while Idx <= Length(Str) do
  begin
    if not TCharacter.IsWhiteSpace(Str[Idx]) then
    begin
      // Character is not white space: copy to result string
      PRes^ := Str[Idx];
      Inc(ResCount);
      Inc(PRes);
    end;
    Inc(Idx);
  end;
  // Reduce length of result string if it is shorter than source string
  if ResCount < Length(Str) then
    SetLength(Result, ResCount);
end;

function StrToLower(const Str: UnicodeString): UnicodeString;
begin
  Result := SysUtils.AnsiLowerCase(Str);
end;

function StrToUpper(const Str: UnicodeString): UnicodeString;
begin
  Result := SysUtils.AnsiUpperCase(Str);
end;

function StrTrim(const Str: UnicodeString): UnicodeString;
begin
  Result := InternalTrim(Str, TCharacter.IsWhiteSpace);
end;

function StrTrimChars(const Str: UnicodeString; const C: Char): UnicodeString;
begin
  Result := InternalTrim(
    Str,
    function (Ch: Char): Boolean begin Result := Ch = C; end
  );
end;

function StrTrimLeft(const Str: UnicodeString): UnicodeString;
begin
  Result := InternalTrimLeft(Str, TCharacter.IsWhiteSpace);
end;

function StrTrimLeftChars(const Str: UnicodeString; const C: Char):
  UnicodeString;
begin
  Result := InternalTrimLeft(
    Str,
    function (Ch: Char): Boolean begin Result := Ch = C; end
  );
end;

function StrTrimRight(const Str: UnicodeString): UnicodeString;
begin
  Result := InternalTrimRight(Str, TCharacter.IsWhiteSpace);
end;

function StrTrimRightChars(const Str: UnicodeString; const C: Char):
  UnicodeString; overload;
begin
  Result := InternalTrimRight(
    Str,
    function (Ch: Char): Boolean begin Result := Ch = C; end
  );
end;

function StrUnixLineBreaks(const Str: UnicodeString): UnicodeString;
begin
  // Replace any CRLF (MSDOS/Windows) line ends with LF
  Result := StrReplace(Str, CRLF, LF);
  // Replace any remaining CR (Mac) line ends with LF
  Result := StrReplace(Result, CR, LF);
end;

function StrWindowsLineBreaks(const Str: UnicodeString): UnicodeString;
begin
  // First convert to Unix to get rid of all CR characters (CRs could come from
  // existing Windows CRLF or from Max CR)
  Result := StrUnixLineBreaks(Str);
  // Now have only LFs - convert them all to CRLFs
  Result := StrReplace(Result, LF, CRLF);
end;

function StrWrap(const Str: UnicodeString; const MaxLen, Margin: Integer):
  UnicodeString;
var
  Word: UnicodeString;  // next word in input Str
  Line: UnicodeString;  // current output line
  Words: TStringList;   // list of words in input Str
  I: Integer;           // loops thru all words in input Str

  // -------------------------------------------------------------------------
  ///  Adds a line of text to output, offseting line by Margin spaces
  procedure AddLine(const Line: string);
  begin
    if Result <> '' then    // not first line: insert new line
      Result := Result + EOL;
    Result := Result + StringOfChar(' ', Margin) + Line;
  end;
  // -------------------------------------------------------------------------

begin
  // Get all words in Str
  Words := TStringList.Create;
  try
    StrExplode(Str, ' ', Words);
    Result := '';
    Line := '';
    // Loop for each word in Str
    for I := 0 to Pred(Words.Count) do
    begin
      Word := Words[I];
      if Length(Line) + Length(Word) + 1 <= MaxLen then
      begin
        // Word fits on current line: add it
        if Line = '' then
          Line := Word  // 1st word on line
        else
          Line := Line + ' ' + Word;
      end
      else
      begin
        // Word doesn't fit on line
        AddLine(Line);
        Line := Word;   // store word as first on next line
      end;
    end;
    if Line <> '' then
      // Residual line after end of loop: add to output
      AddLine(Line);
  finally
    Words.Free;
  end;
end;

function StrWrap(const Paras: TStrings; const MaxLineLen, Margin: Integer;
  const SeparateParas: Boolean): UnicodeString; overload;
var
  Para: string;
  SB: TStringBuilder;
begin
  SB := TStringBuilder.Create;
  try
    for Para in Paras do
    begin
      SB.AppendLine(StrTrimRight(StrWrap(Para, MaxLineLen, Margin)));
      if SeparateParas then
        SB.AppendLine;
    end;
    Result := SB.ToString;
  finally
    SB.Free;
  end;
end;

function StrIf(const Condition: Boolean; const TrueStr, FalseStr: string):
  string;
begin
  if Condition then
    Result := TrueStr
  else
    Result := FalseStr;
end;

end.