_stregini.pas

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

function TStRegIniValues.Next(celt: LongInt; out elt; pceltFetched: PLongInt): HResult;
var
  V : OleVariant;
  I : Integer;
begin
  Result := S_FALSE;
  try
    if pceltFetched <> nil then
      pceltFetched^ := 0;
    for I := 0 to celt - 1 do begin
      if FEnumPos >= FOwner.Count then begin
        FEnumPos := 0;
        Exit;
      end;
      V := Get_Item(FEnumPos);
      TVariantArgList(elt)[I] := TVariantArg(V);

      // Prevent COM garbage collection
      TVarData(V).VType := varEmpty;
      TVarData(V).VInteger := 0;

      Inc(FEnumPos);
      if pceltFetched <> nil then
        Inc(pceltFetched^);
    end;
  except
  end;
  if (pceltFetched = nil) or ((pceltFetched <> nil) and (pceltFetched^ = celt)) then
   Result := S_OK;
end;

function TStRegIniValues.Skip(celt: LongInt): HResult;
begin
  Inc(FEnumPos, celt);
  Result := S_OK;
end;

function TStRegIniValues.Reset: HResult;
begin
  FEnumPos := 0;
  Result := S_OK;
end;

function TStRegIniValues.Clone(out Enum: IEnumVariant): HResult;
begin
  Enum := nil;
  Result := S_OK;
  try
    Enum := Self.Create(FOwner);
  except
    Result := E_OUTOFMEMORY;
  end;
end;

function TStRegINIValues.Get__NewEnum: IUnknown;
begin
  Result := Self;
end;

function TStRegINIValues.Get_Count: Integer;
begin
  FOwner.Count;
end;

function TStRegINIValues.Get_Item(Index: Integer): IStRegINIValue;
begin
  Result := TStRegIniValue.Create(FOwner.Strings[Index]);
end;
{ ******************************** }

{ ******** IStRegIni ************* }
procedure TStRegINI.Initialize;
begin
  inherited Initialize;
  {$IFDEF LICENSE}
  FIsLicensed := False;
  {$ELSE}
  FIsLicensed := True;
  {$ENDIF}
end;

destructor TStRegINI.Destroy;
begin
  inherited Destroy;
end;

procedure TStRegINI.Open(const RootName: WideString; IsIniFile: WordBool);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  if Assigned(FOwner) then
    RaiseRegIniError(stscOpenKeyFail)
  else
    FOwner := StRegIni.TStRegIni.Create(RootName, IsIniFile);
end;

function TStRegINI.Get_CurrentSubKey: WideString;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.CurSubKey;
end;

procedure TStRegINI.Set_CurrentSubKey(const Value: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.CurSubKey := Value;
end;

function TStRegINI.Get_IsIniFile: WordBool;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.IsIniFile;
end;

procedure TStRegINI.CreateKey(const KeyName: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.CreateKey(KeyName);
end;

procedure TStRegINI.DeleteKey(const KeyName: WideString;
  DeleteSubKeys: WordBool);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.DeleteKey(KeyName, DeleteSubKeys);
end;

procedure TStRegINI.DeleteValue(const ValueName: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.DeleteValue(ValueName);
end;

function TStRegINI.Get_Primary: WideString;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.GetPrimary;
end;

procedure TStRegINI.Set_Primary(const Value: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.SetPrimary(Value);
end;

function TStRegINI.KeyExists(const KeyName: WideString): WordBool;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.KeyExists(KeyName);
end;

function TStRegINI.Get_SubKeys: IStRegIniSubKeys;
var
  Keys : TStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Keys := nil;
  try
    Keys := TStringList.Create;
    FOwner.GetSubKeys(Keys);
    Result := TStRegIniSubKeys.Create(Keys);
  except
    Result := nil;
    Keys.Free;
  end;
end;

function TStRegINI.Get_Values: IStRegIniValues;
var
  Keys : TStringList;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Keys := nil;
  try
    Keys := TStringList.Create;
    FOwner.GetValues(Keys);
    Result := TStRegIniValues.Create(Keys);
  except
    Result := nil;
    Keys.Free;
  end;
end;

function TStRegINI.QueryKey: IStRegIniQueryKeyInfo;
var
  QKI : StRegIni.TQueryKeyInfo;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.QueryKey(QKI);
  Result := TStRegIniQueryKeyInfo.Create(QKI);
end;

function TStRegINI.ReadBoolean(const ValueName: WideString;
  Default: WordBool): WordBool;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadBoolean(ValueName, Default);
end;

function TStRegINI.ReadDate(const ValueName: WideString;
  Default: TDateTime): TDateTime;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadDate(ValueName, StDate.DateTimeToStDate(Default));
end;

function TStRegINI.ReadDateTime(const ValueName: WideString;
  Default: TDateTime): TDateTime;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadDateTime(ValueName, Default);
end;

function TStRegINI.ReadInteger(const ValueName: WideString;
  Default: Integer): Integer;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadInteger(ValueName, Default);
end;

function TStRegINI.ReadString(const ValueName,
  Default: WideString): WideString;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadString(ValueName, Default);
end;

function TStRegINI.ReadTime(const ValueName: WideString;
  Default: TDateTime): TDateTime;
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  Result := FOwner.ReadTime(ValueName, StDate.DateTimeToStTime(Default));
end;

procedure TStRegINI.WriteBoolean(const ValueName: WideString;
  Value: WordBool);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteBoolean(ValueName, Value);
end;

procedure TStRegINI.WriteDate(const ValueName: WideString;
  Value: TDateTime);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteDate(ValueName, StDate.DateTimeToStDate(Value));
end;

procedure TStRegINI.WriteDateTime(const ValueName: WideString;
  Value: TDateTime);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteDateTime(ValueName, Value);
end;

procedure TStRegINI.WriteInteger(const ValueName: WideString;
  Value: Integer);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteInteger(ValueName, Value);
end;

procedure TStRegINI.WriteString(const ValueName, Value: WideString);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteString(ValueName, Value);
end;

procedure TStRegINI.WriteTime(const ValueName: WideString;
  Value: TDateTime);
begin
  {$IFDEF LICENSE}
   if (not FIsLicensed) or (not COMHasBeenLicensed) then
     OleError(CLASS_E_NOTLICENSED);
  {$ENDIF}
  FOwner.WriteTime(ValueName, StDate.DateTimeToStTime(Value));
end;
{ ******************************** }


function TStRegINI.License(const Key: WideString): WordBool;
begin
  {$IFDEF LICENSE}
  Result := COMIsValidKey(Key);
  {$ELSE}
  Result := True;
  {$ENDIF}
  FIsLicensed := Result;
end;

initialization
  TAutoObjectFactory.Create(ComServer, TStRegINI, Class_StRegINI, ciMultiInstance, tmBoth);
end.