stgenlog.pas

条码控件： 一维条码控件 二维条码控件 PDF417Barcode MaxiCodeBarcode

    glHighLevelMark := FBufferSize - Round(FBufferSize * FHighLevel / 100);
    glHighLevelCheck;
  finally
    glUnlockLog;
  end;
end;

{ Verifies the size of the temp buffer }
procedure TStGeneralLog.glCheckTempSize(SizeReq : DWORD);
begin
  if (SizeReq > glTempSize) then begin
    ReallocMem(glTempBuffer, SizeReq);
    glTempSize := SizeReq;
  end;
end;

{ Test for high level condition, fire event if necessary }
procedure TStGeneralLog.glHighLevelCheck;
begin
  glLockLog;
  try
    if FHighLevel = 0 then Exit;
    if BufferFree < glHighLevelMark then begin
      if Assigned(FOnHighLevel) and not glHighLevelTriggered then begin
        FOnHighLevel(Self);
        glHighLevelTriggered := True;
      end;
    end else begin
      glHighLevelTriggered := False;
    end;
  finally
    glUnlockLog;
  end;
end;

{ Pop log record from log, return False if no record to return }
function TStGeneralLog.glPopLogEntry(var LogRec : TStLogRec) : Boolean;
type
  BytesArray = array[0..SizeOf(TStLogRec)-1] of Byte;
var
  Bytes : BytesArray absolute LogRec;
  ChunkSize : DWORD;
begin
  glLockLog;
  try
    { Check for empty buffer }
    if (glBufferHead = glBufferTail) then begin
      Result := False;
      Exit;
    end else begin
      Result := True;
    end;

    { Check to see if log record wraps }
    if (glBufferHead + SizeOf(TStLogRec)) <= FBufferSize then begin

      { No wrap, copy directly over }
      Move(glBuffer[glBufferHead], LogRec, SizeOf(LogRec));
      Inc(glBufferHead, SizeOf(LogRec));

      { Fix head if needed }
      if (glBufferHead = FBufferSize) then glBufferHead := 0;
    end else begin

      { Need to deal with wrap -- copy first half }
      ChunkSize := (FBufferSize - glBufferHead);
      Move(glBuffer[glBufferHead], Bytes[0], ChunkSize);

      { Copy second half }
      Move(glBuffer[0], Bytes[ChunkSize], (SizeOf(LogRec) - ChunkSize));
      glBufferHead := SizeOf(LogRec) - ChunkSize;
    end;

    { Do we have data? If so, deal with it }
    if (LogRec.lrData2 and $80000000) = $80000000 then begin

      { Check to see if log data wraps }
      if (glBufferHead + LogRec.lrData4) <= FBufferSize then begin

        { No wrap -- point D2 to buffer }
        LogRec.lrData3 := DWORD(@glBuffer[glBufferHead]);
        Inc(glBufferHead, LogRec.lrData4);
      end else begin

        { Wrap -- copy first half to temp buffer }
        glCheckTempSize(LogRec.lrData4);
        ChunkSize := (FBufferSize - glBufferHead);
        Move(glBuffer[glBufferHead], glTempBuffer[0], ChunkSize);

        { Copy second half }
        Move(glBuffer[0], glTempBuffer[ChunkSize], (LogRec.lrData4 - ChunkSize));
        LogRec.lrData3 := DWORD(@glTempBuffer[0]);
        glBufferHead := LogRec.lrData4 - ChunkSize;
      end;
    end

  finally
    glUnlockLog;
  end;
end;

{ Return time stamp string }
function TStGeneralLog.glTimeStamp(Mark : DWORD) : string;
begin
  Result := Format('%07.7d : ', [Mark - glTimeBase]);
  Insert('.', Result, 5);
end;

{ Dumps log file to disk }
procedure TStGeneralLog.DumpLog;
var
  LR : TStLogRec;
  FS : TFileStream;
  S, T : string;
begin
  glLockLog;

  try
    { Open file stream }
    if FileExists(FileName) and (WriteMode = wmAppend) then begin
      FS := TFileStream.Create(FileName, fmOpenReadWrite or fmShareDenyWrite);
      FS.Seek(0, soFromEnd);
    end else begin
      FS := TFileStream.Create(FileName, fmCreate or fmShareDenyWrite);
    end;

    try
      { Do file header if appropriate }
      if (FS.Size = 0) then begin
        S := FLogFileHeader;
        FS.Write(S[1], Length(S));

        { Write trailing CRLF }                                        {!!.02}
        FS.Write(StCRLF[1], Length(StCRLF));                           {!!.02}
      end;

      { Cycle through all data }
      while glPopLogEntry(LR) do begin
        if LR.lrData1 <> $FFFFFFFF then begin

          { It belongs to somone else, let them process it }
          DoGetLogString(LR.lrData1, LR.lrData2, LR.lrData3, LR.lrData4, S);
        end else begin

          { Something we're supposed to know about, deal with it }
          case LR.lrData2 of

            { Logging enabled }
            leEnabled : S := '**** Logging Enabled' + StCRLF;

            { Logging disabled }
            leDisabled : S := '**** Logging Disabled' + StCRLF;

            { WriteLogString entry }
            leString :
              begin
                if LR.lrData4 > 0 then begin                           {!!.02}
                  SetLength(S, LR.lrData4);
                  Move(PByteArray(LR.lrData3)[0], S[1], LR.lrData4);
                end else begin                                         {!!.02}
                  S := ''; { empty string }                            {!!.02}
                end;                                                   {!!.02}
              end;

            else
              S := Format('!! Unknown log entry : [%8.8x][%8.8x][%8.8x][%8.8x]' + StCRLF,
                [LR.lrData1, LR.lrData2, LR.lrData3, LR.lrData4]);

          end;
        end;

        { Write time stamp }
        T := glTimeStamp(LR.lrTime);
        FS.Write(T[1], Length(T));

        { Write log string }
        if Length(S) > 0 then                                          {!!.02}
          FS.Write(S[1], Length(S));

        { Write trailing CRLF }
        FS.Write(StCRLF[1], Length(StCRLF));
      end;

      { Do file header if appropriate }
      if (FLogFileFooter <> '') then begin
        S := FLogFileFooter;
        FS.Write(S[1], Length(S));

        { Write trailing CRLF }                                        {!!.02}
        FS.Write(StCRLF[1], Length(StCRLF));                           {!!.02}
      end;

      glHighLevelTriggered := False;

    finally
      FS.Free;
    end;

  finally
    glUnlockLog;
  end;
end;

{ Determines whether something is in the buffer }
function TStGeneralLog.GetBufferEmpty : Boolean;
begin
  glLockLog;
  try
    Result := (glBufferHead = glBufferTail);
  finally
    glUnlockLog;
  end;
end;

{ Calculates free space in the buffer }
function TStGeneralLog.GetBufferFree : DWORD;
begin
  glLockLog;
  try
    if (glBufferHead <= glBufferTail) then
      { One less than actual, since we always leave one byte free }
      Result := Pred(FBufferSize - (glBufferTail - glBufferHead))
    else
      Result := Pred(glBufferHead - glBufferTail);
  finally
    glUnlockLog;
  end;
end;

{ Retrieves buffer size }
function TStGeneralLog.GetBufferSize : DWORD;
begin
  glLockLog;
  try
    Result := FBufferSize;
  finally
    glUnlockLog;
  end;
end;

{ Get Enabled property }
function TStGeneralLog.GetEnabled : Boolean;
begin
  glLockLog;
  try
    Result := FEnabled;
  finally
    glUnlockLog;
  end;
end;

{ Get FileName property }
function TStGeneralLog.GetFileName : TFileName;
begin
  glLockLog;
  try
    Result := FFileName;
  finally
    glUnlockLog;
  end;
end;

{ Retrieves high level setpoint }
function TStGeneralLog.GetHighLevel : Byte;
begin
  glLockLog;
  try
    Result := FHighLevel;
  finally
    glUnlockLog;
  end;
end;

{!!.01 - added}
{ Retrieves log options }
function TStGeneralLog.GetLogOptions : StGenOptionSet;
begin
  glLockLog;
  try
    Result := FLogOptions;
  finally
    glUnlockLog;
  end;
end;

{ Retrieves write mode }
function TStGeneralLog.GetWriteMode : TStWriteMode;
begin
  glLockLog;
  try
    Result := FWriteMode;
  finally
    glUnlockLog;
  end;
end;

{ Sets the size of the logging buffer }
procedure TStGeneralLog.SetBufferSize(const Value : DWORD);
begin
  glLockLog;
  try
    if Value <> FBufferSize then begin
      FBufferSize := Value;
      ReallocMem(glBuffer, Value);
      ClearBuffer;
      glCalcHighLevel;
    end;
  finally
    glUnlockLog;
  end;
end;

{ Enables (or disables) logging }
procedure TStGeneralLog.SetEnabled(const Value : Boolean);
begin
  glLockLog;
  try
    if (Value = True) then begin

      { Allocate buffer if not already done }
      if (glBuffer = nil) then begin
        GetMem(glBuffer, FBufferSize);
      end;

      { Init temp buffer if not already done }
      if (glTempBuffer = nil) then begin
        glTempSize := 1024;
        GetMem(glTempBuffer, glTempSize);
      end;
    end else if not (goSuppressDisableMsg in LogOptions) then begin    {!!.01}
      AddLogEntry($FFFFFFFF, leDisabled, 0, 0);
    end;

    FEnabled := Value;

  finally
    glUnlockLog;
  end;

  if (Value = True) and not (goSuppressEnableMsg in LogOptions) then   {!!.01}
    AddLogEntry($FFFFFFFF, leEnabled, 0, 0);
end;

{ Set FileName property }
procedure TStGeneralLog.SetFileName(const Value : TFileName);
begin
  glLockLog;
  try
    FFileName := Value;
  finally
    glUnlockLog;
  end;
end;

{ Set HighLevel property }
procedure TStGeneralLog.SetHighLevel(const Value : Byte);
begin
  glLockLog;
  try
    if (FHighLevel <> Value) and (Value <= 100) then begin
      FHighLevel := Value;
      glCalcHighLevel;
    end;
  finally
    glUnlockLog;
  end;
end;

{!!.01 - added}
{ Set LogOptions property }
procedure TStGeneralLog.SetLogOptions(const Value : StGenOptionSet);
begin
  glLockLog;
  try
    FLogOptions := Value;
  finally
    glUnlockLog;
  end;
end;

{ Set WriteMode property }
procedure TStGeneralLog.SetWriteMode(const Value : TStWriteMode);
begin
  glLockLog;
  try
    FWriteMode := Value;
  finally
    glUnlockLog;
  end;
end;

{ Write log string to log buffer }
procedure TStGeneralLog.WriteLogString(const LogString : string);
begin
  AddLogEntry($FFFFFFFF, leString, DWORD(LogString), Length(LogString));
end;

end.