• [bugfix] Fixed bug in saving ColorEnd property
• [bugfix] Fixed bug in drawing non-rectangular shape gradients in Delphi 2010 and probably Delphi 2009.

• [bugfix] Fixed the GDI+ issue when it is used inside a dll (read more).
• [bugfix] Fixed the incorrect scrolling direction using mouse wheel.
• [feature] For convenience, added BeginAppend and EndAppend methods for adding a new page at the end of pages. These methods are simply a wrapper around BeginInsert and EndInsert methods.

• [feature] Like standard TShape control, the shape of TGradient control can be determined using the new Shape property.

• [bugfix] – Made the package compatible with Delphi 2009. However, the package has some problems on Delphi 2009: Because of a few bugs in Controls unit, mirroring page and tab controls for right-to-left languages causes child controls of these controls go off the screen. Some other common controls may also show odd behavior when toggle the layout’s direction.
• [bigfix] Fixed display problem of the date picker control on Windows XP.
• [feature] Some minor tweaks.

The i18n package makes the localization of applications an easy task for the Delphi developers. You just need to drop a component on each form and select which properties and string literals/constants should be translated. Then at runtime, just by changing value of a property you can change the locale of your application on the fly.

In the i18n package, changing locale is not only changing the strings of the user interface. It includes displaying numbers and date-time values in local format and native digits, supporting local calendar system, and mirroring the reading layout of the application for right-to-left languages.

Please visit the i18n package page to find out more about this package.

• [feature] Added two new options gloFixedAnchorStartPoint and gloFixedAnchorEndPoint to the LinkOptions property of the TGraphLink class. These options control whether the hooked links should be anchored to a fixed point on the target object or not.

• [feature] Before, each marquee item had its own image cache for HTML images. Now, all marquee items use a single image cache to prevent creating/loading images more than once.
• [bugfix] Fixed bug in EncodeHTMLEntities function of SimpleHTML unit. The function was encoding only one special character and ignoring the rest.

• [bugfix] Fixed the GDI+ issue when it is used inside a dll (read more).
• [bugfix] In some cases, resizing TPrintPreview control was not updating the visible area marker of the selected thumbnail.
• [feature] Added DisableTheme property to TThumbnailPreview control. Windows Aero makes the selected thumbnail unclear. By setting this property to true, you can prevent this problem.

• [feature] Added an option to show/hide date of posts.

Damerau-Levenshtein Distance

The Damerau-Levenshtein distance is defined as the minimum number of primitive edit operations needed to transform one string into the other, and these operations are substitution, deletion, insertion, and the transposition of two adjacent characters.

ABC → AXC       Substitution
ABC → AC        Deletion
ABC → ABXC      Insertion
ABC → ACB       Transposition

Here is the Delphi implementation of Damerau-Levenshtein distance algorithm:

function DamerauLevenshteinDistance(const Str1, Str2: String): Integer;
var
  LenStr1, LenStr2: Integer;
  I, J, T, Cost, Minimum: Integer;
  pStr1, pStr2, S1, S2: PChar;
  D, RowPrv2, RowPrv1, RowCur, Temp: PIntegerArray;
begin
  LenStr1 := Length(Str1);
  LenStr2 := Length(Str2);
  // to save some space, make sure the second index points to the shorter string
  if LenStr1 < LenStr2 then
  begin
    T := LenStr1;
    LenStr1 := LenStr2;
    LenStr2 := T;
    pStr1 := PChar(Str2);
    pStr2 := PChar(Str1);
  end
  else
  begin
    pStr1 := PChar(Str1);
    pStr2 := PChar(Str2);
  end;
  // to save some time and space, look for exact match 
  while (LenStr2 <> 0) and (pStr1^ = pStr2^) do
  begin
    Inc(pStr1);
    Inc(pStr2);
    Dec(LenStr1);
    Dec(LenStr2);
  end;
  // when one string is empty, length of the other is the distance
  if LenStr2 = 0 then
  begin
    Result := LenStr1;
    Exit;
  end;
  // calculate the edit distance
  T := LenStr2 + 1;
  GetMem(D, 3 * T * SizeOf(Integer));
  FillChar(D^, 2 * T * SizeOf(Integer), 0);
  RowCur := D;
  RowPrv1 := @D[T];
  RowPrv2 := @D[2 * T];
  S1 := pStr1;
  for I := 1 to LenStr1 do
  begin
    Temp := RowPrv2;
    RowPrv2 := RowPrv1;
    RowPrv1 := RowCur;
    RowCur := Temp;
    RowCur[0] := I;
    S2 := pStr2;
    for J := 1 to LenStr2 do
    begin
      Cost := Ord(S1^ <> S2^);
      Minimum := RowPrv1[J - 1] + Cost;      // substitution
      T := RowCur[J - 1] + 1;                // insertion
      if T < Minimum then
        Minimum := T;
      T := RowPrv1[J] + 1;                   // deletion
      if T < Minimum then
        Minimum := T;
      if (I <> 1) and (J <> 1) and (S1^ = (S2 - 1)^) and (S2^ = (S1 - 1)^) then
      begin
        T := RowPrv2[J - 2] + Cost;          // transposition
        if T < Minimum then
          Minimum := T;
      end;
      RowCur[J] := Minimum;
      Inc(S2);
    end;
    Inc(S1);
  end;
  Result := RowCur[LenStr2];
  FreeMem(D);
end;

Because DamerauLevenshteinDistance function is normally called inside a loop, I had to optimize my implementation. Otherwise, the original algorithm is smaller and more readable.

Similarity Ratio

Now that we have a function to find out how similar two strings are, we can use it to calculate the similarity ratio of the two strings to approximately match them.

function StringSimilarityRatio(const Str1, Str2: String; IgnoreCase: Boolean): Double;
var
  MaxLen: Integer;
  Distance: Integer;
begin
  Result := 1.0;
  if Length(Str1) > Length(Str2) then
    MaxLen := Length(Str1)
  else
    MaxLen := Length(Str2);
  if MaxLen <> 0 then
  begin
    if IgnoreCase then
      Distance := DamerauLevenshteinDistance(LowerCase(Str1), LowerCase(Str2))
    else
      Distance := DamerauLevenshteinDistance(Str1, Str2);
    Result := Result - (Distance / MaxLen);
  end;
end;

The return value of StringSimilarityRatio function is a floating-point number between 0 (zero) and 1 (one), where 0 means not similar at all and 1 means equal strings.