Changeset 107 for trunk/Packages/Common

Timestamp:

Jul 19, 2024, 11:24:06 PM (5 months ago)

Author:

chronos

Message:

• Fixed: Full screen mode switching on Windows.
• Modified: Updated Common package.

Location:

trunk/Packages/Common

Files:

• Common.pas (modified) (2 diffs)
• FindFile.pas (modified) (1 diff)
• FormEx.pas (modified) (5 diffs)
• Languages.pas (modified) (3 diffs)
• Languages/Languages.cs.po (modified) (1 diff)
• Languages/Languages.pot (modified) (1 diff)
• Languages/PixelPointer.pot (added)
• ListViewSort.pas (modified) (2 diffs)
• PersistentForm.pas (modified) (4 diffs)
• PixelPointer.pas (modified) (17 diffs)
• Pool.pas (modified) (5 diffs)
• RegistryEx.pas (modified) (1 diff)
• StopWatch.pas (modified) (3 diffs)
• Threading.pas (modified) (1 diff)

trunk/Packages/Common/Common.pas

@@ -53 +53 @@
 function ComputerName: string;
 procedure DeleteFiles(APath, AFileSpec: string);
+function EndsWith(Text, What: string): Boolean;
 function Explode(Separator: Char; Data: string): TStringArray;
 procedure ExecuteProgram(Executable: string; Parameters: array of string);
@@ -87 +88 @@
 procedure SearchFiles(AList: TStrings; Dir: string;
   FilterMethod: TFilterMethod = nil; FileNameMethod: TFileNameMethod = nil);
+procedure SortStrings(Strings: TStrings);
 function SplitString(var Text: string; Count: Word): string;
 function StripTags(const S: string): string;
+function StartsWith(Text, What: string): Boolean;
 function TryHexToInt(Data: string; out Value: Integer): Boolean;
 function TryBinToInt(Data: string; out Value: Integer): Boolean;
-procedure SortStrings(Strings: TStrings);
 
 
 implementation
+
+function StartsWith(Text, What: string): Boolean;
+begin
+  Result := Copy(Text, 1, Length(Text)) = What;
+end;
+
+function EndsWith(Text, What: string): Boolean;
+begin
+  Result := Copy(Text, Length(Text) - Length(What) + 1, MaxInt) = What;
+end;
 
 function BinToInt(BinStr : string) : Int64;

trunk/Packages/Common/FindFile.pas

@@ -75 +75 @@
 constructor TFindFile.Create(AOwner: TComponent);
 begin
-  inherited Create(AOwner);
+  inherited;
   Path := IncludeTrailingBackslash(UTF8Encode(GetCurrentDir));
   FileMask := FilterAll;

trunk/Packages/Common/FormEx.pas

@@ -13 +13 @@
   private
     FCounter: Integer; static;
+    FFirstShow: Boolean;
   protected
     procedure DoShow; override;
@@ -19 +20 @@
     procedure DoDestroy; override;
   public
+    FullScreen: Boolean;
     PersistentForm: TPersistentForm; static;
     ThemeManager: TThemeManager; static;
@@ -44 +46 @@
 begin
   inherited;
-  PersistentForm.Load(Self);
+  if not FFirstShow and (not (csDesigning in ComponentState)) then begin
+    FFirstShow := True;
+    PersistentForm.Load(Self, False, FullScreen);
+    FullScreen := PersistentForm.FormFullScreen;
+  end;
 end;
 
@@ -68 +74 @@
   end;
 
-  PersistentForm.Load(Self);
   Translator.TranslateComponentRecursive(Self);
   ThemeManager.UseTheme(Self);
@@ -77 +82 @@
 procedure TFormEx.DoClose(var CloseAction: TCloseAction);
 begin
-  PersistentForm.Save(Self);
+  if  (not (csDesigning in ComponentState)) then begin
+    PersistentForm.FormFullScreen := FullScreen;
+    PersistentForm.Save(Self);
+  end;
   inherited;
 end;

trunk/Packages/Common/Languages.pas

@@ -216 +216 @@
   SLang_za = 'Zhuang';
   SLang_zh = 'Chinese';
+  SLang_zh_Hans = 'Simplified Chinese';
+  SLang_zh_Hant = 'Traditional Chinese';
   SLang_zu = 'Zulu';
+
 
 implementation
@@ -228 +231 @@
 begin
   I := 0;
-  while (I < Count) and (TLanguage(Items[I]).Code < ACode) do Inc(I);
-  if I < Count then Result := TLanguage(Items[I])
+  while (I < Count) and (Items[I].Code <> ACode) do Inc(I);
+  if I < Count then Result := Items[I]
     else Result := nil;
 end;
@@ -439 +442 @@
   AddNew('za', SLang_za);
   AddNew('zh', SLang_zh);
+  AddNew('zh-Hant', SLang_zh_Hant);
+  AddNew('zh-Hans', SLang_zh_Hans);
   AddNew('zu', SLang_zu);
 end;

trunk/Packages/Common/Languages/Languages.cs.po

@@ -977 +977 @@
 msgstr "Čínština"
 
+#: languages.slang_zh_hans
+msgid "Simplified Chinese"
+msgstr ""
+
+#: languages.slang_zh_hant
+msgid "Traditional Chinese"
+msgstr ""
+
 #: languages.slang_zu
 msgctxt "languages.slang_zu"

trunk/Packages/Common/Languages/Languages.pot

@@ -776 +776 @@
 msgstr ""
 
+#: languages.slang_zh_hans
+msgid "Simplified Chinese"
+msgstr ""
+
+#: languages.slang_zh_hant
+msgid "Traditional Chinese"
+msgstr ""
+
 #: languages.slang_zu
 msgid "Zulu"

trunk/Packages/Common/ListViewSort.pas

@@ -136 +136 @@
 constructor TListViewEx.Create(TheOwner: TComponent);
 begin
-  inherited Create(TheOwner);
+  inherited;
   Filter := TListViewFilter.Create(Self);
   Filter.Parent := Self;
@@ -172 +172 @@
 constructor TListViewFilter.Create(AOwner: TComponent);
 begin
-  inherited Create(AOwner);
+  inherited;
   FStringGrid1 := TStringGrid.Create(Self);
   FStringGrid1.Align := alClient;

trunk/Packages/Common/PersistentForm.pas

@@ -16 +16 @@
     FMinVisiblePart: Integer;
     FRegistryContext: TRegistryContext;
+    FResizeEventOccured: Boolean;
     procedure LoadControl(Control: TControl);
     procedure SaveControl(Control: TControl);
+    procedure WindowStateChange(Sender: TObject);
   public
     FormRestoredSize: TRect;
@@ -301 +303 @@
 
 procedure TPersistentForm.SetFullScreen(State: Boolean);
+{$IFDEF UNIX}
+var
+  OldHandler: TNotifyEvent;
+var
+  I: Integer;
+{$ENDIF}
 begin
   if State then begin
@@ -312 +320 @@
     end;
     FormWindowState := Form.WindowState;
-    Form.WindowState := wsMaximized;
-    Form.WindowState := wsNormal;
-    ShowWindow(Form.Handle, SW_SHOWFULLSCREEN);
     {$IFDEF WINDOWS}
     Form.BorderStyle := bsNone;
     {$ENDIF}
+    Form.WindowState := wsFullscreen;
+    {$IFDEF UNIX}
+    // Workaround on Linux, WindowState is rewriten by WMSize event to wsNormal.
+    // We need for that even to occure
+    OldHandler := Form.OnWindowStateChange;
+    Form.OnWindowStateChange := WindowStateChange;
+    FResizeEventOccured := False;
+    for I := 0 to 10 do begin
+      if FResizeEventOccured then Break;
+      Application.ProcessMessages;
+      Sleep(1);
+    end;
+    Form.OnWindowStateChange := OldHandler;
+    {$ENDIF}
   end else begin
     FormFullScreen := False;
+    Form.WindowState := wsNormal;
     {$IFDEF WINDOWS}
     Form.BorderStyle := bsSizeable;
     {$ENDIF}
-    ShowWindow(Form.Handle, SW_SHOWNORMAL);
     if FormWindowState = wsNormal then begin
       Form.WindowState := wsNormal;
@@ -335 +354 @@
 end;
 
+procedure TPersistentForm.WindowStateChange(Sender: TObject);
+begin
+  Form.WindowState := wsFullscreen;
+  FResizeEventOccured := True;
+end;
+
 end.

trunk/Packages/Common/PixelPointer.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Graphics;
+  Math, Classes, SysUtils, Graphics;
 
 type
   TColor32 = type Cardinal;
   TColor32Component = (ccBlue, ccGreen, ccRed, ccAlpha);
+  TColor32Planes = array[0..3] of Byte;
 
   { TPixel32 }
@@ -14 +15 @@
   TPixel32 = packed record
   private
-    procedure SetRGB(AValue: Cardinal);
-    function GetRGB: Cardinal;
+    procedure SetRGB(AValue: Cardinal); inline;
+    function GetRGB: Cardinal; inline;
   public
+    class function CreateRGB(R, G, B: Byte): TPixel32; static;
+    class function CreateRGBA(R, G, B, A: Byte): TPixel32; static;
     property RGB: Cardinal read GetRGB write SetRGB;
     case Integer of
       0: (B, G, R, A: Byte);
       1: (ARGB: TColor32);
-      2: (Planes: array[0..3] of Byte);
+      2: (Planes: TColor32Planes);
       3: (Components: array[TColor32Component] of Byte);
   end;
@@ -29 +32 @@
 
   TPixelPointer = record
+  private
+    function GetPixelARGB: TColor32; inline;
+    function GetPixelB: Byte; inline;
+    function GetPixelG: Byte; inline;
+    function GetPixelPlane(Index: Byte): Byte; inline;
+    function GetPixelR: Byte; inline;
+    function GetPixelA: Byte; inline;
+    function GetPixelPlanes: TColor32Planes;
+    function GetPixelRGB: Cardinal; inline;
+    procedure SetPixelARGB(Value: TColor32); inline;
+    procedure SetPixelB(Value: Byte); inline;
+    procedure SetPixelG(Value: Byte); inline;
+    procedure SetPixelPlane(Index: Byte; AValue: Byte); inline;
+    procedure SetPixelR(Value: Byte); inline;
+    procedure SetPixelA(Value: Byte); inline;
+    procedure SetPixelRGB(Value: Cardinal); inline;
+  public
     Base: PPixel32;
     Pixel: PPixel32;
@@ -35 +55 @@
     BytesPerPixel: Integer;
     BytesPerLine: Integer;
+    Data: PPixel32;
+    Width: Integer;
+    Height: Integer;
     procedure NextLine; inline; // Move pointer to start of next line
     procedure PreviousLine; inline; // Move pointer to start of previous line
@@ -41 +64 @@
     procedure SetXY(X, Y: Integer); inline; // Set pixel position relative to base
     procedure SetX(X: Integer); inline; // Set horizontal pixel position relative to base
+    procedure CheckRange; inline; // Check if current pixel position is not out of range
+    function PosValid: Boolean;
+    class function Create(Bitmap: TRasterImage; BaseX: Integer = 0; BaseY: Integer = 0): TPixelPointer; static;
+    property PixelARGB: TColor32 read GetPixelARGB write SetPixelARGB;
+    property PixelRGB: Cardinal read GetPixelRGB write SetPixelRGB;
+    property PixelB: Byte read GetPixelB write SetPixelB;
+    property PixelG: Byte read GetPixelG write SetPixelG;
+    property PixelR: Byte read GetPixelR write SetPixelR;
+    property PixelA: Byte read GetPixelA write SetPixelA;
+    property PixelPlane[Index: Byte]: Byte read GetPixelPlane write SetPixelPlane;
   end;
   PPixelPointer = ^TPixelPointer;
 
-  function PixelPointer(Bitmap: TRasterImage; BaseX: Integer = 0; BaseY: Integer = 0): TPixelPointer; inline;
   function SwapRedBlue(Color: TColor32): TColor32;
   procedure BitmapCopyRect(DstBitmap: TRasterImage; DstRect: TRect; SrcBitmap: TRasterImage; SrcPos: TPoint);
@@ -63 +95 @@
 implementation
 
+resourcestring
+  SOutOfRange = 'Pixel pointer out of range [X: %d, Y: %d, Width: %d, Height: %d]';
+  SWrongBitmapSize = 'Wrong bitmap size [width: %d, height: %d]';
+
 { TPixel32 }
 
@@ -70 +106 @@
 end;
 
+class function TPixel32.CreateRGB(R, G, B: Byte): TPixel32;
+begin
+  Result.R := R;
+  Result.G := G;
+  Result.B := B;
+  Result.A := 0;
+end;
+
+class function TPixel32.CreateRGBA(R, G, B, A: Byte): TPixel32;
+begin
+  Result.R := R;
+  Result.G := G;
+  Result.B := B;
+  Result.A := A;
+end;
+
 procedure TPixel32.SetRGB(AValue: Cardinal);
 begin
-  R := (AValue shr 16) and $ff;
-  G := (AValue shr 8) and $ff;
-  B := (AValue shr 0) and $ff;
+  ARGB := (ARGB and $ff000000) or (AValue and $ffffff);
 end;
 
@@ -112 +162 @@
 end;
 
+procedure TPixelPointer.CheckRange;
+{$IFOPT R+}
+var
+  X: Integer;
+  Y: Integer;
+{$ENDIF}
+begin
+  {$IFOPT R+}
+  if (PByte(Pixel) < PByte(Data)) or
+    (PByte(Pixel) >= PByte(Data) + Height * BytesPerLine) then begin
+    X := PByte(Pixel) - PByte(Data);
+    Y := Floor(X / BytesPerLine);
+    X := X - Y * BytesPerLine;
+    X := Floor(X / BytesPerPixel);
+    raise Exception.Create(Format(SOutOfRange, [X, Y, Width, Height]));
+  end;
+  {$ENDIF}
+end;
+
+function TPixelPointer.PosValid: Boolean;
+begin
+  Result := not ((PByte(Pixel) < PByte(Data)) or
+    (PByte(Pixel) >= PByte(Data) + Height * BytesPerLine));
+end;
+
+function TPixelPointer.GetPixelPlanes: TColor32Planes;
+begin
+  CheckRange;
+  Result := Pixel^.Planes;
+end;
+
+function TPixelPointer.GetPixelRGB: Cardinal;
+begin
+  CheckRange;
+  Result := Pixel^.RGB;
+end;
+
+procedure TPixelPointer.SetPixelARGB(Value: TColor32);
+begin
+  CheckRange;
+  Pixel^.ARGB := Value;
+end;
+
+procedure TPixelPointer.SetPixelB(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.B := Value;
+end;
+
+procedure TPixelPointer.SetPixelG(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.G := Value;
+end;
+
+procedure TPixelPointer.SetPixelPlane(Index: Byte; AValue: Byte);
+begin
+  CheckRange;
+  Pixel^.Planes[Index] := AValue;
+end;
+
+procedure TPixelPointer.SetPixelR(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.R := Value;
+end;
+
+procedure TPixelPointer.SetPixelA(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.A := Value;
+end;
+
+function TPixelPointer.GetPixelARGB: TColor32;
+begin
+  CheckRange;
+  Result := Pixel^.ARGB;
+end;
+
+function TPixelPointer.GetPixelB: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.B;
+end;
+
+function TPixelPointer.GetPixelG: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.G;
+end;
+
+function TPixelPointer.GetPixelPlane(Index: Byte): Byte;
+begin
+  CheckRange;
+  Result := Pixel^.Planes[Index];
+end;
+
+function TPixelPointer.GetPixelR: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.R;
+end;
+
+function TPixelPointer.GetPixelA: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.A;
+end;
+
+procedure TPixelPointer.SetPixelRGB(Value: Cardinal);
+begin
+  CheckRange;
+  Pixel^.RGB := Value;
+end;
+
 procedure BitmapCopyRect(DstBitmap: TRasterImage; DstRect: TRect;
   SrcBitmap: TRasterImage; SrcPos: TPoint);
@@ -120 +285 @@
   SrcBitmap.BeginUpdate(True);
   DstBitmap.BeginUpdate(True);
-  SrcPtr := PixelPointer(SrcBitmap, SrcPos.X, SrcPos.Y);
-  DstPtr := PixelPointer(DstBitmap, DstRect.Left, DstRect.Top);
+  SrcPtr := TPixelPointer.Create(SrcBitmap, SrcPos.X, SrcPos.Y);
+  DstPtr := TPixelPointer.Create(DstBitmap, DstRect.Left, DstRect.Top);
   for Y := 0 to DstRect.Height - 1 do begin
     for X := 0 to DstRect.Width - 1 do begin
-      DstPtr.Pixel^.ARGB := SrcPtr.Pixel^.ARGB;
+      DstPtr.PixelARGB := SrcPtr.PixelARGB;
       SrcPtr.NextPixel;
       DstPtr.NextPixel;
@@ -150 +315 @@
   SrcBitmap.BeginUpdate(True);
   DstBitmap.BeginUpdate(True);
-  SrcPtr := PixelPointer(SrcBitmap, SrcRect.Left, SrcRect.Top);
-  DstPtr := PixelPointer(DstBitmap, DstRect.Left, DstRect.Top);
+  SrcPtr := TPixelPointer.Create(SrcBitmap, SrcRect.Left, SrcRect.Top);
+  DstPtr := TPixelPointer.Create(DstBitmap, DstRect.Left, DstRect.Top);
   for Y := 0 to DstRect.Height - 1 do begin
     for X := 0 to DstRect.Width - 1 do begin
@@ -160 +325 @@
       DstPtr.SetXY(X, Y);
       SrcPtr.SetXY(R.Left, R.Top);
-      C := SrcPtr.Pixel^.ARGB;
-      DstPtr.Pixel^.ARGB := C;
+      C := SrcPtr.PixelARGB;
+      DstPtr.PixelARGB := C;
       for YY := 0 to R.Height - 1 do begin
         for XX := 0 to R.Width - 1 do begin
-          DstPtr.Pixel^.ARGB := C;
+          DstPtr.PixelARGB := C;
           DstPtr.NextPixel;
         end;
@@ -181 +346 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Color;
+      Ptr.PixelARGB := Color;
       Ptr.NextPixel;
     end;
@@ -198 +363 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap, Rect.Left, Rect.Top);
+  Ptr := TPixelPointer.Create(Bitmap, Rect.Left, Rect.Top);
   for Y := 0 to Rect.Height - 1 do begin
     for X := 0 to Rect.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Color;
+      Ptr.PixelARGB := Color;
       Ptr.NextPixel;
     end;
@@ -215 +380 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := SwapRedBlue(Ptr.Pixel^.ARGB);
+      Ptr.PixelARGB := SwapRedBlue(Ptr.PixelARGB);
       Ptr.NextPixel;
     end;
@@ -232 +397 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Ptr.Pixel^.ARGB xor $ffffff;
+      Ptr.PixelARGB := Ptr.PixelARGB xor $ffffff;
       Ptr.NextPixel;
     end;
@@ -252 +417 @@
   Pixel := Color32ToPixel32(Color);
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      A := Ptr.Pixel^.A; //(Ptr.Pixel^.A + Pixel.A) shr 1;
-      R := (Ptr.Pixel^.R + Pixel.R) shr 1;
-      G := (Ptr.Pixel^.G + Pixel.G) shr 1;
-      B := (Ptr.Pixel^.B + Pixel.B) shr 1;
-      Ptr.Pixel^.ARGB := Color32(A, R, G, B);
+      A := Ptr.PixelA; //(Ptr.PixelA + Pixel.A) shr 1;
+      R := (Ptr.PixelR + Pixel.R) shr 1;
+      G := (Ptr.PixelG + Pixel.G) shr 1;
+      B := (Ptr.PixelB + Pixel.B) shr 1;
+      Ptr.PixelARGB := Color32(A, R, G, B);
       Ptr.NextPixel;
     end;
@@ -295 +460 @@
 end;
 
-function PixelPointer(Bitmap: TRasterImage; BaseX: Integer;
+class function TPixelPointer.Create(Bitmap: TRasterImage; BaseX: Integer;
   BaseY: Integer): TPixelPointer;
 begin
+  Result.Width := Bitmap.Width;
+  Result.Height := Bitmap.Height;
+  if (Result.Width < 0) or (Result.Height < 0) then
+    raise Exception.Create(Format(SWrongBitmapSize, [Result.Width, Result.Height]));
   Result.BytesPerLine := Bitmap.RawImage.Description.BytesPerLine;
   Result.BytesPerPixel := Bitmap.RawImage.Description.BitsPerPixel shr 3;
+  Result.Data := PPixel32(Bitmap.RawImage.Data);
   Result.Base := PPixel32(Bitmap.RawImage.Data + BaseX * Result.BytesPerPixel +
     BaseY * Result.BytesPerLine);

trunk/Packages/Common/Pool.pas

@@ -57 +57 @@
   try
     Lock.Acquire;
-    inherited SetTotalCount(AValue);
+    inherited;
   finally
     Lock.Release;
@@ -67 +67 @@
   try
     Lock.Acquire;
-    Result := inherited GetUsedCount;
+    Result := inherited;
   finally
     Lock.Release;
@@ -88 +88 @@
       end;
     end;
-    Result := inherited Acquire;
+    Result := inherited;
   finally
     Lock.Release;
@@ -98 +98 @@
   try
     Lock.Acquire;
-    inherited Release(Item);
+    inherited;
   finally
     Lock.Release;
@@ -113 +113 @@
 begin
   TotalCount := 0;
-  Lock.Free;
+  FreeAndNil(Lock);
   inherited;
 end;

trunk/Packages/Common/RegistryEx.pas

@@ -133 +133 @@
   //CloseKey;
   {$ENDIF}
-  Result := inherited OpenKey(Key, CanCreate);
+  Result := inherited;
 end;
 

trunk/Packages/Common/StopWatch.pas

@@ -13 +13 @@
   TStopWatch = class
   private
-    fFrequency : TLargeInteger;
-    fIsRunning: Boolean;
-    fIsHighResolution: Boolean;
-    fStartCount, fStopCount : TLargeInteger;
-    procedure SetTickStamp(var lInt : TLargeInteger) ;
+    FFrequency: TLargeInteger;
+    FIsRunning: Boolean;
+    FIsHighResolution: Boolean;
+    FStartCount, fStopCount: TLargeInteger;
+    procedure SetTickStamp(var Value: TLargeInteger);
     function GetElapsedTicks: TLargeInteger;
     function GetElapsedMiliseconds: TLargeInteger;
     function GetElapsed: string;
   public
-    constructor Create(const startOnCreate : Boolean = False) ;
+    constructor Create(const StartOnCreate: Boolean = False) ;
     procedure Start;
     procedure Stop;
-    property IsHighResolution : Boolean read fIsHighResolution;
-    property ElapsedTicks : TLargeInteger read GetElapsedTicks;
-    property ElapsedMiliseconds : TLargeInteger read GetElapsedMiliseconds;
-    property Elapsed : string read GetElapsed;
-    property IsRunning : Boolean read fIsRunning;
+    property IsHighResolution: Boolean read FIsHighResolution;
+    property ElapsedTicks: TLargeInteger read GetElapsedTicks;
+    property ElapsedMiliseconds: TLargeInteger read GetElapsedMiliseconds;
+    property Elapsed: string read GetElapsed;
+    property IsRunning: Boolean read FIsRunning;
   end;
 
@@ -35 +35 @@
 implementation
 
-constructor TStopWatch.Create(const startOnCreate : boolean = false) ;
+constructor TStopWatch.Create(const StartOnCreate: Boolean = False);
 begin
-  inherited Create;
-
-  fIsRunning := False;
+  FIsRunning := False;
 
   {$IFDEF WINDOWS}
   fIsHighResolution := QueryPerformanceFrequency(fFrequency) ;
   {$ELSE}
-  fIsHighResolution := False;
+  FIsHighResolution := False;
   {$ENDIF}
-  if NOT fIsHighResolution then fFrequency := MSecsPerSec;
+  if NOT FIsHighResolution then FFrequency := MSecsPerSec;
 
   if StartOnCreate then Start;
@@ -53 +51 @@
 function TStopWatch.GetElapsedTicks: TLargeInteger;
 begin
-  Result := fStopCount - fStartCount;
+  Result := FStopCount - FStartCount;
 end;
 
-procedure TStopWatch.SetTickStamp(var lInt : TLargeInteger) ;
+procedure TStopWatch.SetTickStamp(var Value: TLargeInteger);
 begin
-  if fIsHighResolution then
+  if FIsHighResolution then
     {$IFDEF Windows}
-    QueryPerformanceCounter(lInt)
+    QueryPerformanceCounter(Value)
     {$ELSE}
     {$ENDIF}
   else
-    lInt := MilliSecondOf(Now) ;
+    Value := MilliSecondOf(Now);
 end;
 
 function TStopWatch.GetElapsed: string;
 var
-  dt: TDateTime;
+  Elapsed: TDateTime;
 begin
-  dt := ElapsedMiliseconds / MSecsPerSec / SecsPerDay;
-  result := Format('%d days, %s', [Trunc(dt), FormatDateTime('hh:nn:ss.z', Frac(dt))]) ;
+  Elapsed := ElapsedMiliseconds / MSecsPerSec / SecsPerDay;
+  Result := Format('%d days, %s', [Trunc(Elapsed), FormatDateTime('hh:nn:ss.z', Frac(Elapsed))]) ;
 end;
 
 function TStopWatch.GetElapsedMiliseconds: TLargeInteger;
 begin
-  Result := (MSecsPerSec * (fStopCount - fStartCount)) div fFrequency;
+  Result := (MSecsPerSec * (fStopCount - FStartCount)) div FFrequency;
 end;
 
 procedure TStopWatch.Start;
 begin
-  SetTickStamp(fStartCount);
-  fIsRunning := True;
+  SetTickStamp(FStartCount);
+  FIsRunning := True;
 end;
 
 procedure TStopWatch.Stop;
 begin
-  SetTickStamp(fStopCount);
-  fIsRunning := False;
+  SetTickStamp(FStopCount);
+  FIsRunning := False;
 end;
 

trunk/Packages/Common/Threading.pas

@@ -188 +188 @@
 constructor TThreadList.Create;
 begin
-  inherited Create;
+  inherited;
 end;