diff options
| author | murphy <murphy@rubychan.de> | 2006-07-11 05:45:00 +0000 |
|---|---|---|
| committer | murphy <murphy@rubychan.de> | 2006-07-11 05:45:00 +0000 |
| commit | f52bf8ab02dfe021e415adb17fb01ea9b1d388f1 (patch) | |
| tree | f69ef9b8323175f8fbb0b0d11d8f8d3fea53ea4c /test/delphi | |
| parent | 7bb2aef0553091a10c197e302475c9f14de8a860 (diff) | |
| download | coderay-f52bf8ab02dfe021e415adb17fb01ea9b1d388f1.tar.gz | |
Totally revamped test system. Nitro will be fixed soon.
A bunch of new tests. Delphi and XML are now tested, too.
bench/example.dump deleted (depends on Ruby version, OS, whatever. Nothing for the repo.)
Diffstat (limited to 'test/delphi')
| -rw-r--r-- | test/delphi/pluto.in.pas | 10829 | ||||
| -rw-r--r-- | test/delphi/pluto.out.raydebug | 10829 | ||||
| -rw-r--r-- | test/delphi/suite.rb | 3 | ||||
| -rw-r--r-- | test/delphi/ytools.in.pas | 2708 | ||||
| -rw-r--r-- | test/delphi/ytools.out.raydebug | 2708 |
5 files changed, 27077 insertions, 0 deletions
diff --git a/test/delphi/pluto.in.pas b/test/delphi/pluto.in.pas new file mode 100644 index 0000000..b7aaad7 --- /dev/null +++ b/test/delphi/pluto.in.pas @@ -0,0 +1,10829 @@ +unit FindTH;
+
+interface
+
+uses
+ Classes, windows, Dialogs, ComCtrls, CompEx, SysUtils, YTools, YTypes,
+ clock, plutoconst, StdCtrls, Masks, Forms, XReg;
+
+const
+ RegMoleVersion = '1.1';
+
+type
+ TFindThreadProgress = (fpNone, fpEvery512th, fpEach);
+
+ TRegFindThread = class(TThread)
+ private
+ SearchText: string;
+ SearchFor: TSearchOptions;
+ Progress: TFindThreadProgress;
+ FindNodeText: string;
+ TimeElapsed: Double;
+ syncIcon: Integer;
+ syncStatusText: string;
+ CurrentPath: string;
+ KeysScanned: Integer;
+ Mask: TMask;
+ dwordVal: DWORD;
+ SearchForValues: Boolean;
+
+ procedure Find;
+
+ //Synchronizers
+ procedure Start;
+ procedure Add;
+ procedure UpdateStatus;
+ procedure Finish;
+ protected
+ procedure Execute; override;
+ public
+ SpecialPath: string;
+ FindNode: TTreeNode;
+ ListTV: TTreeView;
+ ObjectsFound, KeysFound, ValuesFound, DataFound: Integer;
+ Ranges: TRanges;
+ destructor Destroy; override;
+ constructor CreateIt(PriorityLevel: TThreadPriority; s: string;
+ SearchFor: TSearchOptions; Progress: TFindThreadProgress);
+ end;
+
+implementation
+
+uses
+ ValuesU, StrUtils;
+
+{ TRegFindThread }
+
+procedure TRegFindThread.Add;
+var
+ Node: TTreeNode;
+begin
+ with ListTV do begin
+ //Items.BeginUpdate;
+ Node := TTreeNode.Create(Items);
+ SetTNImage(Node, syncIcon);
+ Items.AddNode(Node, FindNode, Copy(CurrentPath, 1, 255), nil,
+ naAddChildFirst);
+ if not FindNode.Expanded and (FindNode.Count = 1) then //First Node
+ FindNode.Expand(False);
+ //Items.EndUpdate;
+ end;
+end;
+
+constructor TRegFindThread.CreateIt(PriorityLevel: TThreadPriority; s: string;
+ SearchFor: TSearchOptions; Progress: TFindThreadProgress);
+begin
+ inherited Create(True); // Create thread suspended
+ Priority := PriorityLevel; // Set Priority Level
+ FreeOnTerminate := True; // Thread Free Itself when terminated
+
+ SearchText := s;
+ Ranges := nil;
+ Self.SearchFor := SearchFor;
+ Self.Progress := Progress;
+end;
+
+destructor TRegFindThread.Destroy;
+begin
+ if Assigned(FindNode) then
+ FindNode.Data := nil;
+ inherited;
+end;
+
+procedure TRegFindThread.Execute;
+begin
+ Synchronize(Start);
+ Find;
+ Synchronize(Finish);
+end;
+
+procedure TRegFindThread.Find;
+var
+ SpecialKey: HKEY;
+
+ procedure Add(const Path: string; const Icon: Integer);
+ var
+ zCurrentPath: string;
+ begin
+ zCurrentPath := CurrentPath;
+
+ CurrentPath := Path;
+ syncIcon := Icon;
+ Synchronize(Self.Add);
+
+ CurrentPath := zCurrentPath;
+ end;
+
+ procedure AddValueName(const ValueName: string; Typ: TRegDataType);
+ begin
+ Add(CurrentPath + '\\' + ValueName, IconOfDataType(Typ));
+ end;
+
+ procedure AddValueData(const ValueName: string; Context: TRegContext);
+ begin
+ Add(CurrentPath + '\\' + ValueName + ' = ' + DataPreviewOfContext(Context),
+ IconOfDataType(Context.Typ));
+ end;
+
+ function FoundInStr(const Data: string): Boolean;
+ begin
+ Result := False;
+ if SearchText = '' then
+ Exit;
+
+ if (Data = '') and not (sfWildCards in SearchFor) then
+ Exit;
+
+ if sfWildCards in SearchFor then begin
+ if Assigned(Mask) then
+ Result := Mask.Matches(Data);
+ end else begin
+ {if not (sfFileNames in SearchFor) then begin
+ if TextBegin(SearchText, UntilChar(Data, '~')) and FileExists(Data) then
+ Result := SameFileName(SearchText, GetFileNew(Data));
+ Exit;
+ end; }
+
+ if [sfParts, sfIgnoreCase] <= SearchFor then
+ if SfUseLocales in SearchFor then
+ Result := 0<PosEx(SearchText, AnsiLowerCase(Data))
+ else
+ Result := 0<PosExText(SearchText, Data)
+ else if sfParts in SearchFor then
+ Result := 0<PosEx(SearchText, Data)
+ else if sfIgnoreCase in SearchFor then
+ if SfUseLocales in SearchFor then
+ Result := (AnsiLowerCase(Data) = SearchText)
+ else
+ Result := SameText(Data, SearchText)
+ else
+ Result := (SearchText = Data);
+ end;
+ end;
+
+ function FoundInByteA(const Data: TByteA): Boolean;
+ begin
+ Result := FoundInStr(StrOfByteA(Data));
+ end;
+
+ procedure ScanValues(Key: HKEY; Info: TRegKeyInfo);
+ var
+ i: Integer;
+ MaxLen, NameLen, Len, Typ: Cardinal;
+ Buffer: PByte;
+ ValueName: PChar;
+
+ procedure ScanValue(const ValueName: string; const Typ: TRegDataType;
+ const Data: string);
+ begin
+ if (sfSpecialTypes in SearchFor) and not InRanges(Ranges, Typ) then
+ Exit;
+
+ case Typ of
+ rdString, rdExpandString: if sfString in SearchFor then begin
+ if FoundInStr(Data) then begin
+ Inc(DataFound);
+ AddValueData(ValueName,
+ RegContext(Typ, TByteA(Copy(Data, 1, Length(Data)-1))));
+ end;
+ end;
+
+ rdCardinal, rdCardBigEndian: if sfDWord in SearchFor then begin
+ if (Length(Data) >= SizeOf(Cardinal)) and
+ (dwordVal = PCardinal(Copy(Data, 1, SizeOf(Cardinal)))^) then begin
+ Inc(DataFound);
+ AddValueData(ValueName,
+ RegContext(Typ, ByteAOfStr(Data)));
+ end;
+ end;
+
+ else
+ if sfOtherTypes in SearchFor then begin
+ if FoundInStr(Data) then begin
+ Inc(DataFound);
+ AddValueData(ValueName,
+ RegContext(Typ, ByteAOfStr(Data)));
+ end;
+ end;
+ end;
+ end;
+
+ begin
+ MaxLen := Info.MaxValueLen + 1; //Include Nullbyte
+
+ Buffer := nil;
+ if sfValueData in SearchFor then
+ GetMem(Buffer, Info.MaxDataLen);
+
+ GetMem(ValueName, MaxLen);
+ for i := 0 to Info.NumValues-1 do begin
+ NameLen := MaxLen;
+ Len := Info.MaxDataLen;
+ if not Success(RegEnumValue(Key, i, ValueName, NameLen, nil, @Typ,
+ Buffer, @Len)) then
+ Continue;
+
+ if sfValueNames in SearchFor then
+ if FoundInStr(ValueName) then begin
+ Inc(ValuesFound);
+ AddValueName(ValueName, Typ);
+ end;
+
+ if sfValueData in SearchFor then
+ ScanValue(ValueName, Typ, string(Copy(TByteA(Buffer), 0, Len)));
+ end;
+
+ FreeMem(ValueName, MaxLen);
+ if sfValueData in SearchFor then
+ FreeMem(Buffer, Info.MaxDataLen);
+ end;
+
+ procedure ScanKey(Key: HKEY; const KeyName: string = '');
+ var
+ p: PChar;
+ i, z: Integer;
+ l, Len: DWORD;
+ NewKey: HKEY;
+ Info: TRegKeyInfo;
+ begin
+ if Terminated then Exit;
+
+ Inc(KeysScanned);
+ if Progress <> fpNone then
+ if (Progress = fpEach) or
+ ((Progress = fpEvery512th) and ((KeysScanned and $1FF) = 0)) then begin
+ syncStatusText := '(' + IntToStr(KeysScanned) + ' k) ' + CurrentPath;
+ Synchronize(UpdateStatus);
+ end;
+
+ with Info do
+ if not Success(RegQueryInfoKey(Key, nil, nil, nil, @NumSubKeys,
+ @MaxSubKeyLen, nil, @NumValues, @MaxValueLen, @MaxDataLen,
+ nil, nil)) then
+ Exit;
+
+ if (Info.NumValues > 0) and SearchForValues then
+ ScanValues(Key, Info);
+
+ if Info.NumSubKeys <= 0 then
+ Exit;
+
+ Len := Info.MaxSubKeyLen + 1;
+ GetMem(p, Len);
+
+ for i := 0 to Info.NumSubKeys-1 do begin
+ l := Len;
+ RegEnumKeyEx(Key, i, p, l, nil, nil, nil, nil);
+ if sfKeys in SearchFor then
+ if FoundInStr(p) then begin
+ Inc(KeysFound);
+ Add(CurrentPath + '\' + p, iconKeyMiddle);
+ end;
+
+ if Success(RegOpenKey(Key, p, NewKey)) then begin
+ z := Length(CurrentPath);
+ CurrentPath := CurrentPath + '\' + p;
+
+ try
+ ScanKey(NewKey, p);
+ finally
+ RegCloseKey(NewKey);
+ end;
+
+ SetLength(CurrentPath, z);
+ end;
+
+ if Terminated then Break;
+ end;
+
+ FreeMem(p, Len);
+ end;
+
+begin
+ with TClock.Create do begin
+ FindNode.Text := FindNodeText + ': ';
+
+ try
+ if sfHKU in SearchFor then begin
+ CurrentPath := 'HKU';
+ ScanKey(HKEY_USERS);
+ end;
+ if sfHKLM in SearchFor then begin
+ CurrentPath := 'HKLM';
+ ScanKey(HKEY_LOCAL_MACHINE);
+ end;
+ if sfHKDD in SearchFor then begin
+ CurrentPath := 'HKDD';
+ ScanKey(HKEY_DYN_DATA);
+ end;
+
+ if SpecialPath <> '' then begin
+ if Success(RegOpenKey(HKEYOfStr(ExRegRoot(SpecialPath)),
+ PChar(ExRegKey(SpecialPath)), SpecialKey)) then begin
+ CurrentPath := LWPSolve(SpecialPath);
+ ScanKey(SpecialKey);
+ RegCloseKey(SpecialKey);
+ end else
+ ShowMessage('Could not open' + EOL +
+ Quote(SpecialPath));
+ end;
+ except
+ syncStatusText := '(' + IntToStr(KeysScanned) + ' k) ' + CurrentPath +
+ 'Error --> Terminated.';
+ Synchronize(UpdateStatus);
+ Sleep(1000);
+ end;
+
+ TimeElapsed := SecondsPassed;
+ Free; end;
+end;
+
+function StrOfSearchOptions(const Options: TSearchOptions): string;
+
+ procedure Add(const s: string);
+ begin
+ Result := Result + s;
+ end;
+
+ procedure AddOption(const Option: string; const Flag: TSearchVar;
+ const Optional: Boolean = False);
+ begin
+ if Flag in Options then
+ Add(Option)
+ else
+ if not Optional then
+ Add('^' + Option);
+ end;
+
+begin
+ Result := '';
+
+ Add('[');
+ AddOption('H', sfAsHex, True);
+ AddOption('W ', sfWildcards, True);
+
+ AddOption('C', sfIgnoreCase);
+ AddOption('L', sfUseLocales);
+ AddOption('P ', sfParts);
+
+ AddOption('K', sfKeys);
+ AddOption('N', sfValueNames);
+ AddOption('D ', sfValueData);
+
+ AddOption('S', sfString);
+ AddOption('D', sfDWORD);
+ AddOption('O', sfOtherTypes);
+ AddOption('?', sfSpecialTypes);
+
+ Add('] [');
+
+ if [sfHKU, sfHKLM, sfHKDD] <= Options then
+ Add('ALL')
+ else begin
+ AddOption('HKU ', sfHKU, True);
+ AddOption('HKLM ', sfHKLM, True);
+ AddOption('HKDD ', sfHKDD, True);
+ Result := TrimRight(Result);
+ end;
+
+ Add(']');
+end;
+
+procedure TRegFindThread.Start;
+begin
+ Mask := nil;
+ KeysFound := 0;
+ ValuesFound := 0;
+ DataFound := 0;
+ KeysScanned := 0;
+
+ //Prepare for options
+ if sfAsHex in SearchFor then begin
+ SearchText := string(ByteAOfHex(SearchText));
+ SearchFor := SearchFor - [sfDWord, sfIgnoreCase];
+ end else begin
+ if SfUseLocales in SearchFor then
+ SearchText := AnsiLowerCase(SearchText);
+
+ dwordVal := 0;
+ if sfDWord in SearchFor then
+ if IsValidInteger(SearchText) then
+ dwordVal := StrToInt(SearchText)
+ else
+ Exclude(SearchFor, sfDWord);
+
+ if sfWildCards in SearchFor then
+ try
+ Mask := TMask.Create(SearchText);
+ except
+ Mask.Free;
+ Mask := nil;
+ end;
+ end;
+
+ SearchForValues := (sfValueNames in SearchFor)
+ or (sfValueData in SearchFor);
+
+ FindNodeText := 'Find ' + Quote(FriendlyStr(SearchText)) + ' ' +
+ StrOfSearchOptions(SearchFor);
+
+ with ListTV.Items do begin
+ BeginUpdate;
+ FindNode := AddChildObject(nil, FindNodeText + '...', nil);
+ FindNode.Data := Self;
+ SetTNImage(FindNode, iconHostReg);
+ EndUpdate;
+ end;
+end;
+
+procedure TRegFindThread.UpdateStatus;
+begin
+ FindNode.Text := FindNodeText + ' ' + syncStatusText;
+end;
+
+procedure TRegFindThread.Finish;
+var
+ Found: string;
+begin
+ ObjectsFound := KeysFound + ValuesFound + DataFound;
+
+ Found := StrNumerus(ObjectsFound, 'object', 'objects', 'No');
+ if ObjectsFound < 2 then
+ Found := Found + ' found.'
+ else begin
+ Found := Found + ' found: ';
+ if KeysFound > 0 then
+ Found := Found + StrNumerus(KeysFound, 'KeyName, ', 'KeyNames, ', 'No');
+ if ValuesFound > 0 then
+ Found := Found + StrNumerus(ValuesFound, 'ValueName, ', 'ValueNames, ',
+ 'No');
+ if DataFound > 0 then
+ Found := Found + StrNumerus(DataFound, 'Data', 'Datas', 'No');
+
+ if RightStr(Found, 2) = ', ' then
+ Delete(Found, Length(Found) - 1, 2);
+ end;
+
+ FindNode.Text := FindNodeText + Format(' OK (%0.1f s) %s',
+ [TimeElapsed, Found]);
+end;
+
+end.
+unit FindWinU;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
+ ComCtrls, StdCtrls, ExtCtrls, Clipbrd, NewPanels, plutoconst, FindTH, YTools,
+ PrefTools, Menus, XReg, RangeEdit;
+
+type
+ TFindWin = class(TForm)
+ ListTV: TTreeView;
+ FindP: TPanel;
+ FindE: TEdit;
+ ColorPanel1: TColorPanel;
+ ResultsPopup: TPopupMenu;
+ Copy1: TMenuItem;
+ ColorPanel2: TColorPanel;
+ FindPrefP: TPanel;
+ CommonGB: TGroupBox;
+ Label4: TLabel;
+ SfWildCardsCB: TCheckBox;
+ SfPartsCB: TCheckBox;
+ SfIgnoreCaseCB: TCheckBox;
+ SfAsHexCB: TCheckBox;
+ SfAsDWord: TCheckBox;
+ SfUseLocalesCB: TCheckBox;
+ FindGB: TGroupBox;
+ SfHKUCB: TCheckBox;
+ SfHKLMCB: TCheckBox;
+ SfHKDDCB: TCheckBox;
+ SfRootKeyRB: TRadioButton;
+ SfCurKeyRB: TRadioButton;
+ SfCLSIDCB: TCheckBox;
+ SfInterfaceCB: TCheckBox;
+ SfKeysCb: TCheckBox;
+ SfValuesCB: TCheckBox;
+ SfDataCB: TCheckBox;
+ SfStringCB: TCheckBox;
+ SfOtherCB: TCheckBox;
+ SfDWordCB: TCheckBox;
+ Panel2: TPanel;
+ GroupBox1: TGroupBox;
+ Label1: TLabel;
+ ThreadPriorityComB: TComboBox;
+ ProgressRG: TRadioGroup;
+ Panel5: TPanel;
+ BorderPanel1: TBorderPanel;
+ MoleLogoI: TImage;
+ TypeRangeE: TRangeEdit;
+ SfTypesCB: TCheckBox;
+ Panel1: TPanel;
+ TransparentCB: TPrefCheckBox;
+ StayOnTopCB: TPrefCheckBox;
+ FindB: TButton;
+ FindPrefB: TButton;
+ procedure FindBClick(Sender: TObject);
+ procedure ListTVKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure FindEKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure ActivateIt(Sender: TObject);
+ procedure DeActivateIt(Sender: TObject);
+ procedure FormDeactivate(Sender: TObject);
+ procedure FormActivate(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure SfWildCardsCBClick(Sender: TObject);
+ procedure StayOnTopCBClick(Sender: TObject);
+ procedure SfRootKeysUpdate(Sender: TObject);
+ procedure FindPrefBClick(Sender: TObject);
+
+ procedure CloseFindPrefP;
+ procedure OpenFindPrefP;
+ procedure FindEChange(Sender: TObject);
+ procedure SfDataCBClick(Sender: TObject);
+ procedure ListTVDblClick(Sender: TObject);
+ procedure SfAsHexCBClick(Sender: TObject);
+ procedure Copy1Click(Sender: TObject);
+ procedure SfIgnoreCaseCBClick(Sender: TObject);
+ procedure FormCreate(Sender: TObject);
+ procedure FormShow(Sender: TObject);
+ procedure SfTypesCBClick(Sender: TObject);
+ end;
+
+const
+ fpbOpen = 0;
+ fpbCloseCaption = 'Params &<<';
+
+ fpbClosed = 1;
+ fpbOpenCaption = 'Params &>>';
+
+var
+ FindWin: TFindWin;
+
+implementation
+
+uses plutomain, PrefU, ValuesU;
+
+{$R *.DFM}
+
+procedure TFindWin.FindBClick(Sender: TObject);
+var
+ SearchFor: TSearchOptions;
+ FindThread: TRegFindThread;
+
+ procedure AddOption(CheckBox: TCustomCheckBox; Flag: TSearchVar);
+ begin
+ with CheckBox as TCheckBox do
+ if Enabled and Checked then
+ Include(SearchFor, Flag);
+ end;
+
+begin
+ SearchFor := [];
+
+ AddOption(SfKeysCB, sfKeys);
+
+ AddOption(SfValuesCB, sfValueNames);
+ AddOption(SfDataCB, sfValueData);
+
+ AddOption(SfStringCB, sfString);
+ AddOption(SfDWordCB, sfDWord);
+ AddOption(SfOtherCB, sfOtherTypes);
+
+ if SfRootKeyRB.Checked then begin
+ AddOption(SfHKUCB, sfHKU);
+ AddOption(SfHKLMCB, sfHKLM);
+ AddOption(SfHKDDCB, sfHKDD);
+ end;
+
+ AddOption(SfAsHexCB, sfAsHex);
+ AddOption(SfWildCardsCB, sfWildCards);
+ AddOption(SfPartsCB, sfParts);
+ AddOption(SfIgnoreCaseCB, sfIgnoreCase);
+ AddOption(SfUseLocalesCB, sfUseLocales);
+
+ {AddOption(SfCLSIDCB, sfCLSID);
+ AddOption(SfInterfaceCB, sfInterface);}
+
+ if SfTypesCB.Checked and not TypeRangeE.RangeMaximal then
+ Include(SearchFor, sfSpecialTypes);
+
+ FindThread := TRegFindThread.CreateIt(
+ TThreadPriority(ThreadPriorityComB.ItemIndex), FindE.Text, SearchFor,
+ TFindThreadProgress(ProgressRG.ItemIndex));
+
+ FindThread.ListTV := ListTV;
+
+ if sfSpecialTypes in SearchFor then
+ FindThread.Ranges := TypeRangeE.Value;
+
+ if SfCurKeyRB.Checked then
+ FindThread.SpecialPath :=
+ LWPSolve(StrOfRegPath(CurKey(uhNonSystemShortcuts)));
+
+ FindThread.Resume;
+ CloseFindPrefP;
+end;
+
+procedure TFindWin.ListTVKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+var
+ Node: TTreeNode;
+
+ procedure TerminateFindThread;
+ var
+ FindThread: TRegFindThread;
+ begin
+ if (Node.Level = 0) then begin
+ FindThread := TRegFindThread(Node.Data);
+ if not Assigned(FindThread) then
+ Node.Delete
+ else
+ try
+ FindThread.Terminate;
+ except
+ Node.Text := 'Error: couldn''t terminate thread!';
+ end;
+ end else
+ Node.Delete;
+ end;
+
+begin
+ Node := ListTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ case Key of
+ VK_F12: if Assigned(Node.Parent) then
+ Node.Parent.AlphaSort;
+
+ VK_RETURN: ListTVDblClick(Sender);
+
+ VK_DELETE: TerminateFindThread;
+ end;
+end;
+
+procedure TFindWin.FindEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if Key = VK_RETURN then
+ FindBClick(Sender);
+
+ if Key = VK_UP then begin
+ CloseFindPrefP;
+ Key := 0;
+ end else if Key = VK_Down then begin
+ OpenFindPrefP;
+ Key := 0;
+ end;
+end;
+
+procedure TFindWin.ActivateIt(Sender: TObject);
+begin
+ ActivateThis(Sender);
+end;
+
+procedure TFindWin.DeActivateIt(Sender: TObject);
+begin
+ DeActivateThis(Sender);
+end;
+
+procedure TFindWin.FormDeactivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ DeActivateThis(ActiveControl);
+
+ AlphaBlend := TransparentCB.Checked;
+end;
+
+procedure TFindWin.FormActivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ ActivateThis(ActiveControl);
+
+ AlphaBlend := False;
+end;
+
+procedure TFindWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if Key = VK_ESCAPE then
+ Close;
+ MainWin.FormKeyDown(Sender, Key, Shift);
+end;
+
+procedure TFindWin.SfWildCardsCBClick(Sender: TObject);
+begin
+ SfPartsCB.Enabled := not SfWildcardsCB.Checked;
+ SfIgnoreCaseCB.Enabled := not SfWildcardsCB.Checked;
+ SfUseLocalesCB.Enabled := SfIgnoreCaseCB.Checked and not SfWildcardsCB.Checked;
+end;
+
+procedure TFindWin.StayOnTopCBClick(Sender: TObject);
+begin
+ if StayOnTopCB.Checked then
+ FormStyle := fsStayOnTop
+ else
+ FormStyle := fsNormal;
+end;
+
+procedure TFindWin.SfRootKeysUpdate(Sender: TObject);
+begin
+ with SfRootKeyRB do begin
+ SfHKLMCB.Enabled := Checked;
+ SfHKUCB.Enabled := Checked;
+ SfHKDDCB.Enabled := Checked;
+ end;
+end;
+
+procedure TFindWin.FindPrefBClick(Sender: TObject);
+begin
+ case FindPrefB.Tag of
+ fpbOpen:
+ CloseFindPrefP;
+ fpbClosed:
+ OpenFindPrefP;
+ else
+ ShowMessage('Fehler: FindPrefB hat unbekanntes Tag');
+ end;
+end;
+
+procedure TFindWin.CloseFindPrefP;
+begin
+ with FindPrefB do begin
+ Tag := fpbClosed;
+ Caption := fpbOpenCaption;
+ end;
+ FindPrefP.Visible := False;
+ ListTV.Repaint;
+end;
+
+procedure TFindWin.OpenFindPrefP;
+begin
+ with FindPrefB do begin
+ Tag := fpbOpen;
+ Caption := fpbCloseCaption;
+ end;
+ FindPrefP.Visible := True;
+ ListTV.Repaint;
+end;
+
+procedure TFindWin.FindEChange(Sender: TObject);
+begin
+ if IsValidInteger(FindE.Text) then
+ SfDWORDCB.Caption := 'D&WORD OK'
+ else
+ SfDWORDCB.Caption := 'D&WORD ??';
+
+ SfAsHexCB.Enabled := (FindE.Text <> '')
+ and not CharIn(FindE.Text, AllChars - HexadecimalChars - [' ']);
+ SfAsDWord.Enabled := SfAsHexCB.Enabled and (Length(TrimAll(FindE.Text)) < 8);
+end;
+
+procedure TFindWin.SfDataCBClick(Sender: TObject);
+begin
+ with SfDataCB do begin
+ SfStringCB.Enabled := Checked;
+ SfDWordCB.Enabled := Checked;
+ SfOtherCB.Enabled := Checked;
+ end;
+end;
+
+procedure TFindWin.ListTVDblClick(Sender: TObject);
+var
+ Node: TTreeNode;
+begin
+ Node := ListTV.Selected;
+ if not Assigned(Node) or (Node.Level = 0) then
+ Exit;
+
+ MainWin.GotoKey(UntilLastChar(Node.Text, '='))
+end;
+
+procedure TFindWin.SfAsHexCBClick(Sender: TObject);
+begin
+ with SfAsHexCB do begin
+ SfIgnoreCaseCB.Enabled := Checked;
+ SfWildCardsCB.Enabled := Checked;
+ end;
+end;
+
+procedure TFindWin.Copy1Click(Sender: TObject);
+var
+ Node: TTreeNode;
+begin
+ Node := ListTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ Clipboard.AsText := Node.Text;
+end;
+
+procedure TFindWin.SfIgnoreCaseCBClick(Sender: TObject);
+begin
+ SfUseLocalesCB.Enabled := SfIgnoreCaseCB.Checked;
+end;
+
+procedure TFindWin.FormCreate(Sender: TObject);
+var
+ ImageFile: string;
+begin
+ Caption := 'Pluto.RegMole ' + RegMoleVersion +
+ ' - The fastest registry search engine for Win9x';
+
+ ImageFile := PlutoDir + 'mole.bmp';
+ if FileExists(ImageFile) then
+ MoleLogoI.Picture.LoadFromFile(ImageFile);
+
+ Width := Screen.WorkAreaWidth - 100;
+
+ CloseFindPrefP;
+end;
+
+procedure TFindWin.FormShow(Sender: TObject);
+begin
+ Top := Screen.WorkAreaHeight - 450;
+ Height := Screen.WorkAreaHeight - Top;
+ Left := (Screen.WorkAreaWidth - Width) div 2;
+end;
+
+procedure TFindWin.SfTypesCBClick(Sender: TObject);
+begin
+ TypeRangeE.Enabled := SfTypesCB.Checked;
+end;
+
+end.
+unit Plutoconst;
+
+interface
+
+uses ComCtrls, Classes, XReg, UniKey, YTools;
+
+var
+ Started: Boolean = False;
+ MurphyMode: Boolean = False;
+ PlutoKey: TUniKey;
+
+const
+ Version = '1.6 -nium Alpha';
+ Overnight = True;
+ Codename = 'Phoenix';
+ //Generation.Version-Release-Beta
+ // GG.VVRRBB
+ VersionNum: Double = 1.600000;
+ //Must be Double!
+
+const
+ iconKey = 0;
+
+ iconFirstHKEY = 2;
+ iconHKLM = iconFirstHKEY;
+ iconHKU = iconFirstHKEY + 2;
+
+ iconFirstShortcut = iconFirstHKEY + 4;
+ iconHKCC = iconFirstShortcut;
+ iconHKCU = iconFirstShortcut + 2;
+ iconHKCR = iconFirstShortcut + 4;
+ iconHKDD = iconFirstShortcut + 6;
+ iconHKPD = iconFirstShortcut + 8;
+ iconHKWM = iconFirstShortcut + 10;
+ iconHKWU = iconFirstShortcut + 12;
+ iconShortcut = iconFirstShortcut + 14;
+ nHKeyIcons = 16;
+
+ iconFirstType = iconFirstShortcut + nHKeyIcons;
+ iconNone = iconFirstType + 0;
+ iconString = iconFirstType + 1;
+ iconExpandString =iconFirstType + 2;
+ iconBinary = iconFirstType + 3;
+ iconCardinal = iconFirstType + 4;
+ iconCardBigEndian=iconFirstType + 5;
+ iconLink = iconFirstType + 6;
+ iconMultiString = iconFirstType + 7;
+ iconResList = iconFirstType + 8;
+ iconFullResDesc = iconFirstType + 9;
+ iconResReqList = iconFirstType + 10;
+ iconUnknownType = iconFirstType + 11;
+ nTypeIcons = 12;
+
+ iconFirstValue = iconFirstType + nTypeIcons;
+ iconValueElse = iconFirstValue;
+ iconValueEdit = iconFirstValue + 1;
+ iconValueEditBinary = iconFirstValue + 2;
+ iconValueZeromize = iconFirstValue + 3;
+ iconValueDublicate = iconFirstValue + 4;
+ iconMainValue = iconFirstValue + 5;
+ iconTakeAsMainValue = iconFirstValue + 6;
+ nValueIcons = 7;
+
+ iconFirstKey = iconFirstValue + nValueIcons;
+ iconKeyInfos = iconFirstKey;
+ iconSubKey = iconFirstKey + 1;
+ iconKeyDublicate = iconFirstKey + 2;
+ iconKeyFind = iconFirstKey + 3;
+ iconKeyTrace = iconFirstKey + 4;
+ nKeyIcons = 5;
+
+ iconFirstContextMenues = iconFirstKey + nKeyIcons;
+ iconRename = iconFirstContextMenues;
+ iconDelete = iconFirstContextMenues + 1;
+ nContextMenuesIcon = 2;
+
+ iconFirstIni = iconFirstContextMenues + nContextMenuesIcon;
+ iconIniSection = iconFirstIni;
+ nIniIcons = 1;
+
+ iconFirstHost = iconFirstIni + nIniIcons;
+ iconHostReg = iconFirstHost;
+ iconHostIni = iconFirstHost + 1;
+ iconHostUni = iconFirstHost + 2;
+ iconHostUni2 = iconFirstHost + 3;
+ nHostIcons = 4;
+
+ iconFirstOther = iconFirstHost + nHostIcons;
+
+ iconSortArrowAsc = iconFirstOther + 0;
+ iconSortArrowDesc = iconFirstOther + 1;
+ iconKeyMiddle = iconFirstOther + 2;
+ iconLock = iconFirstOther + 3;
+
+ //iconDefect = iconFirstOther;
+
+ { WorkWin.ChangeImages }
+ iconFirstChange = 0;
+ iconCKeyPlus = iconFirstChange;
+ iconCKeyMinus = iconFirstChange + 1;
+ iconCValuePlus = iconFirstChange + 2;
+ iconCValueMinus = iconFirstChange + 3;
+ iconCContext = iconFirstChange + 4;
+ iconOldContext = iconFirstChange + 5;
+ iconNewContext = iconFirstChange + 6;
+ iconGroup = iconFirstChange + 7;
+ iconGroupBlinking = iconFirstChange + 8;
+ nChangeIcons = 7;
+
+ DefaultValueFlag = Pointer(1);
+ MultiEditFlag = Pointer(2);
+
+ NoValueCaption = '[No Value]';
+
+ EditControlFlag = 100;
+
+ MaxPreviewLen = 255;
+ RegMaxDataSize = $FFFF; //64 KB
+
+const
+ BoolStrFileName = 'Boolean Strings.txt';
+ ShortcutsFileName = 'Shortcuts.ini';
+ StandardShortcutsFileName = 'StandardShortcuts.ini';
+ SisyFilterFileName = 'sisy filter.txt';
+
+ clDarkGray = $00404040;
+ clBrightRed = $00BBBBFF;
+ clVeryBrightRed = $00DDDDFF;
+ clBrightBlue = $00FFBBBB;
+ clBrightGreen = $00BBFFBB;
+ clCyan = $00FFFF44;
+ clBrightCyan = $00FFFFBB;
+ clVeryBrightCyan = $00FFFFDD;
+ clBrightYellow = $00BBFFFF;
+ clVeryBrightYellow = $00DDFFFF;
+ clBrightPurple = $00FFBBFF;
+ clBrightSilver = $00DDDDDD;
+ clGold = $0055CCEE;
+
+ clVeryBrightBlue = $00FFDDDD;
+
+type
+ TValueListColumn = (vlcName, vlcSize, vlcType, vlcData);
+
+const
+ ValueListColumnRange = [Low(TValueListColumn)..High(TValueListColumn)];
+
+type
+ TSearchVar = (sfKeys, sfValueNames, sfValueData,
+ sfAsHex, sfAsDWord,
+ sfWildCards, sfParts, sfIgnoreCase, SfUseLocales,
+ sfHKU, sfHKLM, sfHKDD,// sfCLSID, sfInterface,
+ sfString, sfDWord, sfOtherTypes, sfSpecialTypes);
+
+ TSearchOptions = set of TSearchVar;
+
+ //be carefull: used in with!
+ TKeyShortcut = record
+ Alias: string;
+ RealPath: string;
+ Node: TTreeNode;
+ end;
+ PKeyShortcut = ^TKeyShortcut;
+ TShortcutA = array of TKeyShortcut;
+
+ TOpenNode = function (Reg: TXRegistry; Node: TTreeNode): Boolean;
+ TCheckNode = procedure (Node: TTreeNode; OnlyOnce: Boolean = True);
+
+ //NodeInfo System
+ TNodeFlag = (nfDefect, nfReadOnly, nfChecked,
+ nfCopy, nfCut, nfPaste);
+ TNodeFlags = set of TNodeFlag;
+
+ TUniHostType = (uhNone,
+ uhReg, uhIni, uhRegFile,
+ uhUserShortcut, uhStandardShortcut, uhSystemShortcut);
+ TUniHostTypes = set of TUniHostType;
+
+const
+ uhShortcuts = [uhUserShortcut, uhStandardShortcut, uhSystemShortcut];
+ uhNonSystemShortcuts = [uhUserShortcut, uhStandardShortcut];
+
+ NodeFlagStrings: array[TNodeFlag] of string = (
+ 'nfDefect', 'nfReadOnly', 'nfChecked',
+ 'nfCopy', 'nfCut', 'nfPaste');
+
+ HostTypeStrings: array[TUniHostType] of string = ('uhNone',
+ 'uhReg', 'uhIni', 'uhRegFile',
+ 'uhUserShortcut', 'uhStandardShortcut', 'uhSystemShortcut');
+
+type
+ TNodeInfo = packed class
+ public
+ HostType: TUniHostType;
+ Flags: TNodeFlags;
+ constructor Create(HostType: TUniHostType = uhNone; Flags: TNodeFlags = []);
+
+ procedure IncludeFlag(Flag: TNodeFlag);
+ procedure ExcludeFlag(Flag: TNodeFlag);
+
+ function IsHost: Boolean;
+ function IsShortcut: Boolean;
+
+ function ReadOnly: Boolean;
+ function Checked: Boolean;
+ function Defect: Boolean;
+ end;
+
+function NodeInfo(Node: TTreeNode): TNodeInfo;
+procedure ReportStatus(const s: string);
+
+const
+ PlatformStrings: array[0..2] of string =
+ ('VER_PLATFORM_WIN32s', 'VER_PLATFORM_WIN32_WINDOWS', 'VER_PLATFORM_WIN32_NT');
+
+var
+ PlutoDir: string = '';
+
+implementation
+
+uses SysUtils;
+
+function NodeInfo(Node: TTreeNode): TNodeInfo;
+begin
+ if not Assigned(Node) then begin
+ Result := nil;
+ Exit end;
+
+ if not Assigned(Node.Data) then
+ Node.Data := TNodeInfo.Create;
+ Result := TNodeInfo(Node.Data);
+end;
+
+{ TNodeInfo }
+
+constructor TNodeInfo.Create(HostType: TUniHostType; Flags: TNodeFlags);
+begin
+ inherited Create;
+ Self.HostType := HostType;
+ Self.Flags := Flags;
+end;
+
+function TNodeInfo.Checked: Boolean;
+begin
+ Result := nfChecked in Flags;
+end;
+
+function TNodeInfo.ReadOnly: Boolean;
+begin
+ Result := nfReadOnly in Flags;
+end;
+
+function TNodeInfo.Defect: Boolean;
+begin
+ Result := nfDefect in Flags;
+end;
+
+procedure TNodeInfo.IncludeFlag(Flag: TNodeFlag);
+begin
+ Include(Flags, Flag);
+end;
+
+procedure TNodeInfo.ExcludeFlag(Flag: TNodeFlag);
+begin
+ Exclude(Flags, Flag);
+end;
+
+function TNodeInfo.IsHost: Boolean;
+begin
+ Result := HostType <> uhNone;
+end;
+
+function TNodeInfo.IsShortcut: Boolean;
+begin
+ Result := HostType in uhShortcuts;
+end;
+
+function GetPlutoDir: string;
+begin
+ Result := LWPSlash(GetParam('-imports=', MyDir));
+ if not DirectoryExists(Result) then begin
+ ReportStatus('PlutoDir "' + Result + '" not found -> setting to default (MyDir).');
+ Result := MyDir;
+ end;
+ ReportStatus('PlutoDir=' + Result);
+end;
+
+var
+ ReportSL: TStringList;
+ ReportFileName: string;
+
+procedure ReportStatus(const s: string);
+begin
+ ReportSL.Add(s);
+ try
+ ReportSL.SaveToFile(ReportFileName);
+ except end;
+end;
+
+initialization
+ ReportFileName := MyDir + 'loadreport.txt';
+ ReportSL := TStringList.Create;
+ PlutoDir := GetPlutoDir;
+
+end.
+//winampviscolor <viscolor.txt>:
+unit plutomain;
+{$DEFINE UNIKEY}
+{$DEFINE CYCFS}
+
+{===============================================================================
+
+ cYcnus.Pluto 1.57 Beta 14
+ by Murphy
+
+ ©2000-2003 by cYcnus
+ visit www.cYcnus.de
+
+ murphy@cYcnus.de (Kornelius Kalnbach)
+
+ this programm is published under the terms of the GPL
+
+===============================================================================}
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
+ StdCtrls, ImgList, ComCtrls, ExtCtrls, Menus, Clipbrd, IniFiles,
+ ShellAPI, Grids,
+ //Components
+ NewPanels,
+ //Units
+ YTools, YTypes, UniKey, XReg,
+ //Pluto
+ Plutoconst,
+ SpyTH, SisyphusTH;
+
+const
+ NoPreBlinkHint = #1;
+
+type
+ TMainWin = class(TForm)
+ StatusBar: TStatusBar;
+ StatusBarPU: TPopupMenu;
+ CopyPath: TMenuItem;
+ InsertPath: TMenuItem;
+ ShowRealPathMI: TMenuItem;
+ PathP: TPanel;
+ N1: TMenuItem;
+ MainMenu1: TMainMenu;
+ Desktop1: TMenuItem;
+ Pluto1: TMenuItem;
+ RegEdit1: TMenuItem;
+ Free1: TMenuItem;
+ BigVal1: TMenuItem;
+ Hilfe1: TMenuItem;
+ History1: TMenuItem;
+ SplashScreen1: TMenuItem;
+ wwwcYcnusde1: TMenuItem;
+ Credits1: TMenuItem;
+ Optionen1: TMenuItem;
+ PrefMI: TMenuItem;
+ EditBoolStrMI: TMenuItem;
+ N4: TMenuItem;
+ ImageList1: TImageList;
+ Plutoini1: TMenuItem;
+ About1: TMenuItem;
+ kornycYcnusde1: TMenuItem;
+ ools1: TMenuItem;
+ NotePad1: TMenuItem;
+ RegEdit2: TMenuItem;
+ SysEdit1: TMenuItem;
+ WordPad1: TMenuItem;
+ N3: TMenuItem;
+ N5: TMenuItem;
+ Suchen1: TMenuItem;
+ Find1: TMenuItem;
+ File1: TMenuItem;
+ ExitPluto1: TMenuItem;
+ OpenProgramFolder1: TMenuItem;
+ N6: TMenuItem;
+ OpenWinDir1: TMenuItem;
+ HintBlinkT: TTimer;
+ FindCLSID1: TMenuItem;
+ Clipboard1: TMenuItem;
+ GotoCLSID1: TMenuItem;
+ CommandLineParameters1: TMenuItem;
+ plutocYcnusde1: TMenuItem;
+ N7: TMenuItem;
+ heinzcYcnusde1: TMenuItem;
+ kornycYcnusde2: TMenuItem;
+ N8: TMenuItem;
+ ExternalHexEditMI: TMenuItem;
+ Cleanup1: TMenuItem;
+ DeleteTempFolder1: TMenuItem;
+ Debug1: TMenuItem;
+ CurrentDir1: TMenuItem;
+ RepairPluto155bBug1: TMenuItem;
+ BackupRegistryscanreg1: TMenuItem;
+ Username1: TMenuItem;
+ SupportMI: TMenuItem;
+ MurphyMI: TMenuItem;
+ ToDoMI: TMenuItem;
+ Beta1: TMenuItem;
+ UniKeycYcnusde1: TMenuItem;
+ YToolscYcnusde1: TMenuItem;
+ YPanelscYcnusde1: TMenuItem;
+ Usedenginescomponents1: TMenuItem;
+ PrefToolscYcnusde1: TMenuItem;
+ BugReportsRequests1: TMenuItem;
+ murphycYcnusde1: TMenuItem;
+ Credits2: TMenuItem;
+ News1: TMenuItem;
+ cYcnus1: TMenuItem;
+ Contact1: TMenuItem;
+ N2: TMenuItem;
+ IjustwantCONTACT1: TMenuItem;
+ N9: TMenuItem;
+ AnotherPluto1: TMenuItem;
+ UniKeyDemoMI: TMenuItem;
+ Path1: TMenuItem;
+ RegisterPlugIns1: TMenuItem;
+ UniPluginOD: TOpenDialog;
+ SwapLM_CUB: TButton;
+ PathE: TEdit;
+ ShowLoadreport1: TMenuItem;
+ KillPluto1: TMenuItem;
+ ShowPlatform1: TMenuItem;
+ MSConfig1: TMenuItem;
+ TimetoRelaxMI: TMenuItem;
+ N10: TMenuItem;
+
+ procedure FormCreate(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure FormClose(Sender: TObject; var Action: TCloseAction);
+ procedure InsertPathClick(Sender: TObject);
+
+ procedure StatusBarResize(Sender: TObject);
+ procedure StatusBarDblClick(Sender: TObject);
+ procedure StatusBarUpdate;
+ procedure CopyPathClick(Sender: TObject);
+
+ procedure SetStatus;
+ procedure GotoKey(Key: string);
+ procedure FindCLSID;
+ procedure GotoCLSID;
+ procedure UserGotoKey;
+ procedure ShowRealPathMIClick(Sender: TObject);
+ procedure PathEKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure PathEChange(Sender: TObject);
+ procedure PathEExit(Sender: TObject);
+
+ procedure AppActivate(Sender: TObject);
+ procedure PathEKeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure ActivateIt(Sender: TObject);
+ procedure FormActivate(Sender: TObject);
+ procedure FormDeactivate(Sender: TObject);
+ procedure Pluto1Click(Sender: TObject);
+ procedure RegEdit1Click(Sender: TObject);
+ procedure Free1Click(Sender: TObject);
+ procedure BigVal1Click(Sender: TObject);
+ procedure SplashScreen1Click(Sender: TObject);
+ procedure HistoryClick(Sender: TObject);
+ procedure Credits1Click(Sender: TObject);
+
+ function Greeting(Name: string = NoPreBlinkHint): string;
+ procedure PrefMIClick(Sender: TObject);
+ procedure EditBoolStrMIClick(Sender: TObject);
+ procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
+ procedure SisyTerminate(Sender: TObject);
+ procedure OnSisyChange(Sender: TSisyThread; Change: TSisyChange);
+ procedure OnSisyValuePlus(Sender: TSisyThread; Change: TSisyChange);
+ procedure OnSisyValueMinus(Sender: TSisyThread; Change: TSisyChange);
+ procedure OnSisyContextChange(Sender: TSisyThread; Change: TSisyChange);
+
+ procedure Plutoini1Click(Sender: TObject);
+ procedure RegEdit2Click(Sender: TObject);
+ procedure SysEdit1Click(Sender: TObject);
+ procedure NotePad1Click(Sender: TObject);
+ procedure WordPad1Click(Sender: TObject);
+ procedure OpenWinDir1Click(Sender: TObject);
+ procedure OpenProgramFolder1Click(Sender: TObject);
+ procedure ExitPluto1Click(Sender: TObject);
+ procedure Find1Click(Sender: TObject);
+ procedure FormPaint(Sender: TObject);
+
+ procedure Load;
+ procedure StatusBarDrawPanel(StatusBar: TStatusBar;
+ Panel: TStatusPanel; const Rect: TRect);
+ procedure PathEKeyPress(Sender: TObject; var Key: Char);
+ procedure HintBlinkTTimer(Sender: TObject);
+ procedure FindCLSID1Click(Sender: TObject);
+ procedure GotoCLSID1Click(Sender: TObject);
+ procedure CommandLineParameters1Click(Sender: TObject);
+ procedure WebLinkMIClick(Sender: TObject);
+ procedure DeleteTempFolder1Click(Sender: TObject);
+ procedure CurrentDir1Click(Sender: TObject);
+ procedure RepairPluto155bBug1Click(Sender: TObject);
+ procedure BackupRegistryscanreg1Click(Sender: TObject);
+ procedure SisyStarted(Sender: TObject);
+ procedure StopHintBlinking;
+ procedure Username1Click(Sender: TObject);
+ procedure SupportMIClick(Sender: TObject);
+ procedure ToDoMIClick(Sender: TObject);
+ procedure MailLinkMIClick(Sender: TObject);
+ procedure IjustwantCONTACT1Click(Sender: TObject);
+ procedure ExternalHexEditMIClick(Sender: TObject);
+ procedure AnotherPluto1Click(Sender: TObject);
+ procedure Path1Click(Sender: TObject);
+ procedure RegisterPlugIns1Click(Sender: TObject);
+ procedure FormResize(Sender: TObject);
+ procedure SwapLM_CUBClick(Sender: TObject);
+ procedure ShowLoadreport1Click(Sender: TObject);
+ procedure KillPluto1Click(Sender: TObject);
+ procedure ShowPlatform1Click(Sender: TObject);
+ procedure MSConfig1Click(Sender: TObject);
+ procedure TimetoRelaxMIClick(Sender: TObject);
+ private
+ DoAutoComplete: Boolean;
+ MainWinLoaded: Boolean;
+ DontSavePrefs: Boolean;
+ PreBlinkHint: string;
+ end;
+
+var
+ MainWin: TMainWin;
+
+ StatusBar: TStatusBar;
+ MainReg: TXRegistry;
+
+ SpyThread: TRegSpyThread;
+ Sisys: TList;
+
+function TempDir: string;
+function PlutoUniPath: string;
+function PlutoIniFileName: string;
+
+function PathOfNode(Node: TTreeNode): string;
+function CurKey(AllowedShortcutTypes: TUniHostTypes = []): TRegPath;
+
+procedure ArrangePlutoStyle;
+procedure ArrangeRegEdStyle;
+procedure ArrangeFreeStyle;
+procedure ArrangeBigValStyle;
+
+procedure ActivateThis(Sender: TObject);
+procedure DeActivateThis(Sender: TObject);
+
+procedure SwapFonts(Sender: TWinControl);
+
+procedure AddHint(const Hint: string; Blinking: Boolean = False);
+procedure AddToLastHint(Appendix: string);
+procedure ChangeLastHint(NewHint: string);
+
+implementation
+
+uses
+ //Forms
+ FindWinU, valuesU, TreeU, WorkU, splash, PrefU,
+ //Units
+ Clock, Start, keybrd, CompEx, Colors, FindAllThread,
+ PrefTools;
+
+{$R *.DFM}
+
+var
+ SavedPlutoIniFileName: string = '';
+
+procedure AddHint(const Hint: string; Blinking: Boolean = False);
+begin
+ if Assigned(WorkWin) then
+ WorkWin.AddAHint(Hint);
+
+ with MainWin do begin
+ StopHintBlinking;
+
+ if Blinking then begin
+ HintBlinkT.Enabled := True;
+ if PreBlinkHint = NoPreBlinkHint then
+ PreBlinkHint := StatusBar.Panels[0].Text;
+ StatusBar.Panels[0].Text := WorkWin.LastHint;
+ end;
+ end;
+end;
+
+procedure AddToLastHint(Appendix: string);
+begin
+ with WorkWin.HintLB.Items do begin
+ if Count = 0 then
+ Exit;
+
+ Strings[Count-1] := Strings[Count-1] + Appendix;
+ end;
+ Application.ProcessMessages;
+// Sleep(1000);
+end;
+
+procedure ChangeLastHint(NewHint: string);
+begin
+ with WorkWin.HintLB.Items do begin
+ if Count = 0 then
+ Exit;
+
+ Strings[Count-1] := NewHint;
+ end;
+ Application.ProcessMessages;
+// Sleep(1000);
+end;
+
+function CurKey(AllowedShortcutTypes: TUniHostTypes = []): TRegPath;
+var
+ s: string;
+ Item: TListItem;
+begin
+ if Assigned(RegTV.Selected) then begin
+ s := PathOfNode(RegTV.Selected);
+ if AllowedShortcutTypes <> [] then
+ s := TraceKey(s, AllowedShortcutTypes);
+ Result.Root := ExRegRoot(s);
+ Result.Key := ExRegKey(s);
+
+ Item := ValueList.ItemFocused;
+ if Assigned(Item) then
+ Result.Value := RealValueName(Item);
+ Result.ValueSet := Assigned(Item);
+ end;
+end;
+
+function PathOfNode(Node: TTreeNode): string;
+begin
+ Result := '';
+
+ if not Assigned(Node) then
+ Exit;
+
+ if Assigned(Node.Parent) then
+ Result := LWPSlash(PathOfNode(Node.Parent)) + Node.Text
+ else
+ Result := Node.Text;
+end;
+
+procedure TMainWin.AppActivate(Sender: TObject);
+var
+ ActForm: TCustomForm;
+
+ procedure TryShow(Win: TCustomForm);
+ begin
+ if Assigned(Win) and Win.Visible then
+ Win.Show;
+ end;
+
+begin
+ ActForm := Screen.ActiveCustomForm; //LastActiveForm;
+ TryShow(ValuesWin);
+ TryShow(WorkWin);
+ TryShow(TreeWin);
+ TryShow(FindWin);
+ TryShow(SplashWin);
+ TryShow(MainWin);
+ TryShow(ActForm);
+end;
+
+procedure TMainWin.FormCreate(Sender: TObject);
+
+ procedure InitHKEYString(var H: THKEYString; const Long, Short: string;
+ Handle: Integer = 0; IsDefault: Boolean = False);
+ begin
+ H.Long := Long;
+ H.Short := Short;
+ H.Handle := Handle;
+ H.IsDefault := IsDefault;
+ end;
+
+begin
+{$IFDEF UNIKEY}
+{$IFDEF CYCFS}
+ RegisterUniClass('Y:\programme\unikey\cyc_fs.uni');
+{$ENDIF}
+{$ENDIF}
+
+ Application.OnActivate := AppActivate;
+ PlutoMain.StatusBar := StatusBar;
+
+ //Creating
+ MainReg := TXRegistry.Create;
+
+ //Initialize
+ Caption := 'cYcnus.Pluto ' + Version;
+ PreBlinkHint := NoPreBlinkHint;
+
+ SetLength(HKEYStrings, Length(HKEYStrings) + 2);
+ InitHKEYString(HKEYStrings[LastDefaultHKEYString + 1],
+ 'HKEY_WindowsMachine', 'HKWM');
+
+ InitHKEYString(HKEYStrings[LastDefaultHKEYString + 2],
+ 'HKEY_WindowsUser', 'HKWU');
+
+ Application.HintHidePause := -1; //that's approximately 136 years :D
+
+ StatusBar.Panels[0].Width := Screen.Width div 6;
+
+ MurphyMI.Visible := MurphyMode;
+
+{$IFDEF UNIKEY}
+ UniPluginOD.InitialDir := MyDir;
+{$ELSE}
+ UniKeyDemoMI.Visible := False;
+{$ENDIF}
+end;
+
+procedure TMainWin.GotoKey(Key: string);
+var
+ Full: TregPath;
+ Node: TTreeNode;
+ keySA: TStrA;
+ i: integer;
+
+ function NodeOfRoot(Root: string): TTreeNode;
+ var
+ i: Integer;
+ begin
+ Result := nil;
+ Root := LongHKEY(Root);
+
+ for i := 0 to RootNodes.Count-1 do
+ if SameText(TTreeNode(RootNodes[i]).Text, Root) then begin
+ Result := TTreeNode(RootNodes[i]);
+ Break; end;
+
+ for i := 0 to High(Shortcuts) do
+ if SameText(Shortcuts[i].Alias, Full.Root) then begin
+ Result := Shortcuts[i].Node;
+ Break; end;
+ end;
+
+begin
+ keySA := nil;
+
+ //Get FullPath of the Key
+ Key := TrimLeft(Key);
+ if TextAtPos(Key, 1, 'Reg:') then
+ Key := TrimLeft(FromChar(Key, ':'));
+ Key := UnQuote(Key);
+
+ Full := RegPathOfStr(Key);
+ if Trim(Full.Root) = '' then begin
+ AddHint('Empty Path.', True);
+ Exit; end;
+
+ //Get Root Node
+ Node := NodeOfRoot(Full.Root);
+ if not Assigned(Node) then begin
+ if not PathE.Focused then
+ AddHint('Key not found:' + EOL + Key);
+ Exit; end;
+
+ //Create an array of all SubKeys
+ keySA := Split(Full.Key, '\');
+
+ //Avoid SmartExpand
+ TreeWin.DoSmartExpand := False; begin
+
+ //Open all SubKeys
+ for i := 0 to High(keySA) do begin
+ //Open the Node if neccessary
+ if not Node.Expanded then begin
+ if not Node.Selected then
+ RegTV.Selected := Node;
+ CheckNode(Node, False);
+ //TreeWin.RegTVChange(Self, Node);
+ Node.Expand(False);
+ end;
+
+ //Get Node of the SubKey
+ Node := FindNodeText(Node, keySA[i]);
+ if not Assigned(Node) then begin
+ if not PathE.Focused then
+ AddHint('Goto Key not found: ' + KeySA[i], True);
+ Exit;
+ end;
+ end;
+
+ end; TreeWin.DoSmartExpand := True;
+
+ if Node <> RegTV.Selected then begin
+ RegTV.Selected := Node;
+ TreeWin.RegTVChange(Self, Node);
+ end;
+
+ Application.ProcessMessages;
+
+ if Full.ValueSet then
+ ValuesWin.FocusItem(Full.Value, not (Active and PathE.Focused))
+ else begin
+ if not (Active and PathE.Focused) then //if not user is currently editing the path
+ TreeWin.FocusControl(RegTV);
+
+ if LastChar(Full.Key) = '\' then
+ Node.Expand(False);
+ end;
+end;
+
+procedure SwapFonts(Sender: TWinControl);
+
+ function OtherFont(N: TFontName): TFontName;
+ begin
+ Result := 'Courier New';
+ if N = Result then
+ Result := 'Arial';
+ end;
+
+begin
+ TEdit(Sender).Font.Name := OtherFont(TTreeView(Sender).Font.Name);
+end;
+
+procedure ActivateThis(Sender: TObject);
+begin
+ if not Assigned(Sender) then
+ Exit;
+
+ with TEdit(Sender) do begin
+ if Tag <> EditControlFlag then
+ Exit;
+ Color := RealColor(clVeryBrightBlue);
+ Font.Color := clBlack;
+ end;
+end;
+
+procedure DeActivateThis(Sender: TObject);
+begin
+ if not Assigned(Sender) then
+ Exit;
+
+ with TEdit(Sender) do begin
+ if Tag <> EditControlFlag then
+ Exit;
+ Color := RealColor(clDarkGray);
+ Font.Color := clWhite;
+ end;
+end;
+
+procedure CreateSisyThreads;
+var
+ i: Integer;
+
+ procedure CreateSisyThread(const Name: string; const KeyName: string;
+ Key: HKEY; StatusLabel: TLabel);
+ var
+ Sisy: TSisyThread;
+ begin
+ ChangeLastHint('Creating ' + Name + '...');
+ Sisy := TSisyThread.CreateIt(Name, KeyName, Key, StatusLabel, PlutoKey);
+ Sisy.OnChange := MainWin.OnSisyChange;
+// Sisy.OnSpecialChange[cValuePlus] := MainWin.OnSisyValuePlus;
+// Sisy.OnSpecialChange[cValueMinus] := MainWin.OnSisyValueMinus;
+// Sisy.OnSpecialChange[cContextChange] := MainWin.OnSisyContextChange;
+ Sisys.Add(Sisy);
+ AddToLastHint('OK');
+ end;
+
+begin
+ AddHint('Starting Sisyphus ' + SisyVersion + '...');
+
+ Sisys := TSisyList.Create;
+ WorkWin.LoadSisyFilter;
+
+ CreateSisyThread('Sisy HKU', 'HKU', HKU, WorkWin.SisyHKUL);
+ CreateSisyThread('Sisy HKLM', 'HKLM', HKLM, WorkWin.SisyHKLML);
+
+ ChangeLastHint('Initializing Sisyphus...');
+ for i := 0 to Sisys.Count-1 do
+ with TSisyThread(Sisys[i]) do begin
+ if Name = 'Sisy HKU' then
+ with WorkWin.SisyHKUCB do begin
+ Settings.KeyName := StrOfUni(Uni.Path);
+ Settings.Load;
+ Settings.AutoSave := True;
+ if Checked then
+ Resume;
+ end
+ else if Name = 'Sisy HKLM' then
+ with WorkWin.SisyHKLMCB do begin
+ Settings.KeyName := StrOfUni(Uni.Path);
+ Settings.Load;
+ Settings.AutoSave := True;
+ if Checked then
+ Resume;
+ end;
+ OnStarted := MainWin.SisyStarted;
+ end;
+end;
+
+procedure CreateSpyThread;
+begin
+ AddHint('Creating SpyThread...');
+ SpyThread := TRegSpyThread.CreateIt(tpLowest);
+ WorkWin.SpyDelayIEChange(MainWin);
+ WorkWin.SpyTestLClick(MainWin);
+ AddToLastHint('OK');
+end;
+
+procedure ShowParams;
+var
+ SL: TStringList;
+begin
+ if Switch('params?') then begin
+ SL := TStringList.Create;
+ GetParams(SL);
+ ShowMessage(SL.Text);
+ SL.Free;
+ end;
+end;
+
+procedure GotoParamKey;
+var
+ s: string;
+begin
+ s := ParamStr(1);
+ if (s <> '')
+ and (s[1] <> '-') then begin //Params have '-' as prefix
+ AddHint('Goto Key ' + Quote(s) + '...');
+ MainWin.GotoKey(s);
+ end else begin
+ RegTV.Selected := RegTV.TopItem;
+ end;
+end;
+
+procedure TMainWin.Load;
+begin
+ TreeWin.Load;
+ WorkWin.LoadBoolStr;
+
+ CreateSpyThread;
+ CreateSisyThreads;
+
+ AddHint(Greeting, True);
+
+ ShowParams;
+ GotoParamKey;
+
+ if Assigned(SplashWin) and SplashWin.Visible then
+ SplashWin.SetFocus;
+end;
+
+procedure TMainWin.CopyPathClick(Sender: TObject);
+begin
+ Clipboard.AsText := StatusBar.Panels[1].Text;
+end;
+
+procedure TMainWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if (ssAlt in shift) and (Key = VK_F4) then begin
+ Key := 0;
+ Close;
+ Exit; end;
+
+ if ssCtrl in Shift then
+ case Key of
+ Byte('W'): begin
+ MainPC.ActivePage := WorkWin.WorkPage;
+ if Assigned(MainPC.ActivePage) then
+ WorkWin.FocusControl(TWinControl(ShowPC.ActivePage.Tag))
+ end;
+
+ Byte('H'): MainPC.ActivePage := WorkWin.HintPage;
+
+ Byte('L'): MainWin.FindCLSID;
+ end;
+
+ if Shift = [] then
+ case Key of
+ VK_F6: TreeWin.FocusControl(RegTV);
+
+ VK_F7: with ValueList do begin
+ ValuesWin.FocusControl(ValueList);
+ if (Selected = nil) and (Items.Count > 0) then begin
+ Selected := Items[0];
+ ItemFocused := Selected;
+ end;
+ end;
+
+ VK_F8: WorkWin.FocusControl(MainPC);
+ end;
+
+ if Key = VK_SCROLL then begin
+ TreeWin.CheckRegTVHotTrack;
+ ValuesWin.CheckValueListHotTrack;
+ end;
+end;
+
+procedure TMainWin.StatusBarResize(Sender: TObject);
+begin
+ with StatusBar do
+ Panels[1].Width :=
+ Width - (Panels[0].Width + Panels[2].Width + Panels[3].Width);
+end;
+
+procedure TMainWin.StatusBarDblClick(Sender: TObject);
+begin
+ ShowRealPathMIClick(Sender);
+end;
+
+procedure TMainWin.InsertPathClick(Sender: TObject);
+begin
+ GotoKey(Clipboard.AsText);
+end;
+
+procedure TMainWin.SetStatus;
+begin
+ StatusBarUpdate;
+end;
+
+procedure TMainWin.StatusBarUpdate;
+var
+ Inf: TRegKeyInfo;
+begin
+ OpenCurKey;
+ MainReg.GetKeyInfo(Inf);
+ MainReg.CloseKey;
+
+ StatusBar.Panels[2].Text := StrNumerus(Inf.NumSubKeys, 'key', 'keys', 'no');
+ StatusBar.Panels[3].Text := StrNumerus(Inf.NumValues, 'value', 'values', 'no');
+
+ if ShowRealPathMI.Checked then
+ StatusBar.Panels[1].Text := StrOfRegPath(CurKey(uhShortcuts))
+ else
+ StatusBar.Panels[1].Text := StrOfRegPath(CurKey(uhNonSystemShortcuts));
+
+ if not PathE.Focused then
+ PathE.Text := StrOfRegPath(CurKey);
+end;
+
+procedure TMainWin.ShowRealPathMIClick(Sender: TObject);
+begin
+ ShowRealPathMI.Checked := not ShowRealPathMI.Checked;
+ StatusBarUpdate;
+end;
+
+procedure TMainWin.PathEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+var
+ Pos: Integer;
+ s: string;
+begin
+ DoAutoComplete := not (Key in [VK_DELETE, VK_BACK, VK_ESCAPE]);
+
+ case Key of
+ VK_BACK:
+ begin
+ s := PathE.Text;
+ Pos := PathE.SelStart;
+
+ if ssCtrl in Shift then
+ repeat
+ Dec(Pos);
+ until (Pos < 1) or (s[Pos] = '\')
+ else if PathE.SelLength = 0 then
+ Exit;
+
+ PathE.Text := Copy(s, 1, Pos);
+ PathE.SelStart := Length(s);
+ Key := 0;
+ UserGotoKey;
+ end;
+
+ VK_ESCAPE:
+ with PathE do begin
+ if SelLength = 0 then
+ Exit;
+ Text := StrOfRegPath(CurKey);
+ SelStart := Length(Text);
+ end;
+
+ VK_RETURN: begin
+ if CurKey.ValueSet then
+ ValuesWin.ValueListDblClick(Self);
+ Key := 0;
+ end;
+
+ VK_RIGHT: begin
+ if not (ssCtrl in Shift) then
+ Exit;
+
+ Key := 0;
+
+ s := PathE.Text;
+ Pos := PathE.SelStart + 1;
+ repeat
+ Inc(Pos);
+ until (Pos > Length(s)) or (s[Pos] = '\');
+
+ PathE.SelStart := Pos - 1;
+ end;
+
+ VK_LEFT: begin
+ if not (ssCtrl in Shift) then
+ Exit;
+
+ with PathE do begin
+ Key := 0;
+
+ s := Text;
+ Pos := SelStart;
+ repeat
+ Dec(Pos);
+ until (Pos < 1) or (s[Pos] = '\');
+
+ if Pos < 1 then
+ Pos := 1;
+
+ SelStart := Pos - 1;
+ end;
+ end;
+ end;
+end;
+
+procedure TMainWin.UserGotoKey;
+begin
+ GotoKey(PathE.Text);
+end;
+
+procedure TMainWin.PathEChange(Sender: TObject);
+var
+ Prefix, Suffix, Key, Path, Root: string;
+ i, p, Len: Integer;
+ SL: TStringList;
+ CompleteKind: (ckRoots, ckKeys, ckValues);
+
+ procedure GetRootNames(Strings: TStrings);
+ var
+ Node: TTreeNode;
+ begin
+ SL.Clear;
+ Node := RegTV.Items.GetFirstNode;
+ while Assigned(Node) do begin
+ SL.Add(Node.Text);
+ Node := Node.GetNextSibling;
+ end;
+ end;
+
+begin
+ if not DoAutoComplete then
+ Exit;
+
+ Key := PathE.Text;
+ Root := TraceKey(ExRegRoot(Key));
+
+ if not CharIn(Key, '\') then
+ CompleteKind := ckRoots
+ else if ExRegValueSet(Key) then
+ CompleteKind := ckValues
+ else
+ CompleteKind := ckKeys;
+
+ case CompleteKind of
+ ckRoots: begin
+ Prefix := '';
+ Suffix := Key;
+ end;
+
+ ckKeys: begin
+ Path := ExRegFullKey(Key);
+ Prefix := UntilLastChar(Path, '\');
+ Suffix := FromLastChar(Path, '\');
+ end;
+
+ ckValues: begin
+ p := Pos('\\', Key);
+ Prefix := Copy(Key, 1, p - 1);
+ Suffix := Copy(Key, p + 2, Length(Key) - p - 1);
+ end;
+
+ else
+ end;
+
+ SL := TStringList.Create;
+
+ if CompleteKind in [ckKeys, ckValues] then
+ with MainReg do begin
+ RootKey := HKEYOfStr(ExRegRoot(Root));
+ OpenKey(ExRegKey(Root));
+ OpenKey(ExRegKey(Prefix));
+
+ if CompleteKind = ckValues then begin
+ if not HasValues then
+ Exit;
+ GetValueNames(SL);
+ end else if CompleteKind = ckKeys then begin
+ if not HasSubKeys then
+ Exit;
+ GetKeyNames(SL);
+ end;
+
+ CloseKey;
+ end
+ else begin
+ GetRootNames(SL);
+ end;
+
+ if Suffix = '' then begin
+ if (SL.Count > 0) and not StrIn(SL, '') then
+ Suffix := SL[0];
+ end else begin
+ for i := 0 to SL.Count-1 do
+ if TextAtBegin(SL[i], Suffix) then begin
+ Suffix := SL[i];
+ Break; end;
+ end;
+
+ Len := Length(PathE.Text);
+
+ if CompleteKind = ckValues then
+ Prefix := Prefix + '\\'
+ else if CompleteKind = ckKeys then
+ Prefix := Prefix + '\';
+
+ with PathE do begin
+ DoAutoComplete := False; //Avoid Recursion
+ Text := Prefix + Suffix;
+ DoAutoComplete := True;
+
+ SelStart := Len;
+ SelLength := Length(Text) - Len;
+ end;
+
+ SL.Free;
+end;
+
+procedure TMainWin.PathEExit(Sender: TObject);
+begin
+ DeActivateThis(PathE);
+ DoAutoComplete := False;
+end;
+
+procedure ArrangePlutoStyle;
+begin
+ with ValuesWin do begin
+ Height := MainWin.ClientHeight div 3;
+ Top := MainWin.ClientHeight - Height - 43;
+ Left := 0;
+ Width := MainWin.ClientWidth - 4;
+ //Align := alBottom;
+ end;
+
+ with WorkWin do begin
+ Top := 0;
+ Width := Max(MainWin.ClientWidth div 3, WorkWin.Constraints.MinWidth);
+ Left := ValuesWin.Width - Width;
+ Height := MainWin.ClientHeight - 43 - ValuesWin.Height;
+ //Align := alRight;
+ end;
+
+ with TreeWin do begin
+ Top := 0;
+ Height := WorkWin.Height;
+ Left := 0;
+ Width := ValuesWin.Width - WorkWin.Width;
+ end;
+
+ {TreeWin.Align := alNone;
+ WorkWin.Align := alNone;
+ ValuesWin.Align := alNone;}
+end;
+
+procedure ArrangeFreeStyle;
+const
+ Space = 10;
+begin
+ with ValuesWin do begin
+ Height := Screen.Height div 3;
+ Align := alBottom;
+ end;
+
+ with WorkWin do begin
+ Width := Max(Screen.WorkAreaWidth div 3, Constraints.MinWidth + 2 * Space);
+ Align := alRight;
+ end;
+
+ with TreeWin do begin
+ Align := alClient;
+ end;
+
+ TreeWin.Align := alNone;
+ WorkWin.Align := alNone;
+ ValuesWin.Align := alNone;
+
+ with ValuesWin do begin
+ Height := Height - 2 * Space;
+ Width := Width - 2 * Space;
+ Top := Top + Space;
+ Left := Left + Space;
+ end;
+
+ with TreeWin do begin
+ Height := Height - 1 * Space;
+ Width := Width - 1 * Space;
+ Top := Top + Space;
+ Left := Left + Space;
+ end;
+
+ with WorkWin do begin
+ Height := Height - 1 * Space;
+ Width := Width - 2 * Space;
+ Top := Top + Space;
+ Left := Left + Space;
+ end;
+end;
+
+procedure ArrangeBigValStyle;
+var
+ MinHeight: Integer;
+begin
+ MinHeight := WorkWin.Constraints.MinHeight +
+ MainWin.Constraints.MinHeight;
+
+ with ValuesWin do begin
+ Height := Screen.WorkAreaHeight - Max(Screen.Height div 3, MinHeight);
+ Align := alBottom;
+ end;
+
+ with WorkWin do begin
+ Width := Screen.WorkAreaWidth div 3;
+ Align := alRight;
+ end;
+
+ with TreeWin do begin
+ Align := alClient;
+ end;
+
+ TreeWin.Align := alNone;
+ WorkWin.Align := alNone;
+ ValuesWin.Align := alNone;
+end;
+
+procedure ArrangeRegEdStyle;
+begin
+ with TreeWin do begin
+ Width := Screen.WorkAreaWidth div 4;
+ Align := alLeft;
+ end;
+
+ with ValuesWin do begin
+ Align := alClient;
+ Align := alNone;
+ Height := Height - WorkWin.Constraints.MinHeight;
+ end;
+
+ with WorkWin do begin
+ Top := ValuesWin.Top + ValuesWin.Height;
+ Left := ValuesWin.Left;
+ Height := Constraints.MinHeight;
+ Width := ValuesWin.Width;
+ end;
+
+ TreeWin.Align := alNone;
+end;
+
+procedure TMainWin.PathEKeyUp(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if not (Key in [VK_DELETE, VK_BACK, VK_ESCAPE]) then
+ UserGotoKey;
+end;
+
+procedure TMainWin.ActivateIt(Sender: TObject);
+begin
+ ActivateThis(Sender);
+end;
+
+procedure TMainWin.FormActivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ ActivateThis(ActiveControl);
+end;
+
+procedure TMainWin.FormDeactivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ DeActivateThis(ActiveControl);
+end;
+
+procedure TMainWin.Pluto1Click(Sender: TObject);
+begin
+ ArrangePlutoStyle;
+end;
+
+procedure TMainWin.RegEdit1Click(Sender: TObject);
+begin
+ ArrangeRegEdStyle;
+end;
+
+procedure TMainWin.Free1Click(Sender: TObject);
+begin
+ ArrangeFreeStyle;
+end;
+
+procedure TMainWin.BigVal1Click(Sender: TObject);
+begin
+ ArrangeBigValStyle;
+end;
+
+procedure TMainWin.SplashScreen1Click(Sender: TObject);
+begin
+ SplashWin.Show;
+end;
+
+procedure TMainWin.HistoryClick(Sender: TObject);
+begin
+ NotePad(PlutoDir + 'version.txt');
+end;
+
+procedure TMainWin.WebLinkMIClick(Sender: TObject);
+begin
+ Browse('http://' + TMenuItem(Sender).Caption);
+end;
+
+procedure TMainWin.SupportMIClick(Sender: TObject);
+begin
+ Browse('http://cYcnus.de/php/phpbb/viewforum.php?f=1');
+end;
+
+procedure TMainWin.Credits1Click(Sender: TObject);
+var
+ FileName: string;
+begin
+ FileName := PlutoDir + 'credits deluxe.htm';
+ if FileExists(FileName) then
+ ExecFile(FileName)
+ else begin
+ FileName := PlutoDir + 'credits.htm';
+ if FileExists(FileName) then
+ ExecFile(FileName);
+ end;
+end;
+
+function GetCLSIDFromClipboard: string;
+var
+ CLSID: string;
+begin
+ CLSID := BetweenChars(Clipboard.AsText, '{', '}', True);
+ if CLSID = '' then begin
+ Result := Clipboard.AsText;
+ InputQuery('No CLSID in Clipboard.',
+ 'Use following format:' + EOL +
+ '{00000000-0000-0000-0000-000000000000}', Result);
+ Exit; end else
+ Result := CLSID;
+end;
+
+procedure TMainWin.FindCLSID;
+var
+ CLSID, Desc: string;
+begin
+ CLSID := GetCLSIDFromClipboard;
+ Desc := RegNameOfCLSID(CLSID);
+ if Desc <> '' then
+ InputQuery('Your CLSID is...', CLSID, Desc)
+ else
+ ShowMessage('CLSID not found: ' + CLSID + '.');
+end;
+
+procedure TMainWin.GotoCLSID;
+var
+ CLSID, Desc: string;
+begin
+ CLSID := GetCLSIDFromClipboard;
+ Desc := RegNameOfCLSID(CLSID);
+ if Desc <> '' then begin
+ GotoKey('HKCR\CLSID\' + CLSID);
+ TreeWin.FocusControl(RegTV);
+ end else
+ ShowMessage('CLSID not found: ' + CLSID + '.');
+end;
+
+function TMainWin.Greeting(Name: string = NoPreBlinkHint): string;
+const
+ Alias: array[0..4] of string =
+ ('Licenser', 'Murphy', 'Sleeper', 'Leon', 'Great Admin');
+ RealNames: array[0..4] of string =
+ ('Heinz', 'Korny', 'Sven', 'Simon', 'Korny ;-)');
+var
+ i: Integer;
+ s: string;
+begin
+ if Name = NoPreBlinkHint then
+ Name := PrefWin.UserNameE.Text;
+
+ if Trim(Name) = '' then
+ s := 'No name?'
+ else if SameText(Trim(Name), 'Pluto-User') then
+ s := 'Hi!'
+ else
+ for i := 0 to 4 do
+ if SameText(Name, Alias[i]) then begin
+ s := 'Hi ' + RealNames[i] + '! This is a cYcnus.EasterEgg';
+ Break; end
+ else if Length(Name) > 20 then
+ s := 'Hi ' + Name +
+ '. What a name.'
+ else
+ s := 'Hi ' + Name + '!';
+
+ Result := s;
+end;
+
+procedure TMainWin.PrefMIClick(Sender: TObject);
+begin
+ PrefWin.Show;
+end;
+
+function TempDir: string;
+begin
+ Result := PlutoDir + 'temp\';
+ if not (DirectoryExists(Result) or CreateDir(Result)) then
+ Result := PlutoDir;
+end;
+
+function PlutoIniFileName: string;
+
+ function Default: string;
+ begin
+ Result := MyDir + 'pluto.ini';
+ end;
+
+begin
+ Result := SavedPlutoIniFileName;
+ if Result <> '' then
+ Exit;
+
+// Result := Params.ReadString('ini', '');
+
+ if IsValidFileName(Result) then
+ Result := PlutoDir + Result
+ else
+ Result := Default;
+
+ SavedPlutoIniFileName := Result; //Faster in future calls
+end;
+
+function PlutoUniPath: string;
+begin
+ //Result := 'Reg: HKCU\Software\Pluto\';
+ Result := 'Ini <' + PlutoIniFileName + '>:';
+end;
+
+procedure TMainWin.EditBoolStrMIClick(Sender: TObject);
+begin
+ NotePad(PlutoDir + BoolStrFileName);
+ ShowMessage('Click OK when you finished editing.' + EOL +
+ '(Pluto will reload the Boolean Strings.)');
+ WorkWin.LoadBoolStr;
+end;
+
+procedure TMainWin.SisyStarted(Sender: TObject);
+{var
+ NextSisyIndex: Integer;
+ NextSisy: TSisyThread; }
+begin
+ {NextSisy := nil;
+
+ with TSisyThread(Sender) do begin
+ //AddHint(Format('%s started after %0.1f seconds', [Name, SecsPerRound]), True);
+
+ with Sisys do begin
+ NextSisyIndex := IndexOf(Sender) + 1;
+ if NextSisyIndex < Count then
+ NextSisy := Items[NextSisyIndex];
+ end;
+
+ if Assigned(NextSisy) then
+ with NextSisy do
+ if not Started and Suspended then
+ Resume;
+ end; }
+end;
+
+procedure TMainWin.SisyTerminate(Sender: TObject);
+begin
+ if Assigned(Sisys) then
+ Sisys.Delete(Sisys.IndexOf(Sender));
+ AddHint('Sisyphus ' + Quote(TSisyThread(Sender).Name) + ' destroyed.');
+end;
+
+procedure TMainWin.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
+var
+ i: Integer;
+
+ procedure TerminateThread(Thread: TThread; Name: string);
+ const
+ ThreadTimeOut = 3000;
+ begin
+ if Assigned(Thread) then
+ with Thread do begin
+ Priority := tpNormal;
+ Terminate;
+ while Suspended do Resume; // ensure running
+ if 0 <> WaitForSingleObject(Handle, ThreadTimeOut) then begin
+ ShowMessage('Timeout: Killing Thread: ' + Name + EOL +
+ 'This is a critical error and may cause memory leaks and crashes.' + EOL +
+ 'We recommend to reboot your system before you continue.');
+ Windows.TerminateThread(Handle, 0);
+ end else
+ Thread.Free;
+ end;
+ end;
+
+begin
+ CanClose := False;
+
+ try
+ AddHint('Stopping SisyphusThreads...');
+ if Assigned(Sisys) then
+ for i := 0 to Sisys.Count-1 do
+ TSisyThread(Sisys[i]).Suspend;
+ AddToLastHint('OK');
+
+ AddHint('Wait for SpyThread...');
+ TerminateThread(SpyThread, 'SpyThread');
+ AddToLastHint('OK');
+
+ AddHint('Wait for SisyphusThreads...');
+ if Assigned(Sisys) then
+ for i := 0 to Sisys.Count-1 do begin
+ ChangeLastHint('Wait for SisyphusThreads...' + TSisyThread(Sisys[i]).Name);
+ TerminateThread(TSisyThread(Sisys[i]), TSisyThread(Sisys[i]).Name);
+ end;
+ ChangeLastHint('Wait for SisyphusThreads...OK');
+ except
+ with WorkWin.HintLB.Items do
+ ShowMessage('Error while trying to terminate threads.' + EOL +
+ 'Last Message:' + EOL +
+ Strings[Count - 1]);
+ CanClose := True;
+ end;
+
+ AddHint('Terminating successfull.');
+ CanClose := True;
+end;
+
+procedure TMainWin.FormClose(Sender: TObject; var Action: TCloseAction);
+
+ procedure TryClose(Win: TCustomForm);
+ begin
+ if Assigned(Win) and Win.Visible then
+ Win.Close;
+ end;
+
+begin
+ MainReg.Free;
+
+ Action := caFree;
+
+ if DontSavePrefs then
+ Exit;
+
+ AddHint('Saving settings...');
+
+ try
+ TryClose(WorkWin);
+ TryClose(ValuesWin);
+ TryClose(TreeWin);
+ TryClose(FindWin);
+ TryClose(SplashWin);
+ TryClose(PrefWin);
+ except
+ DontSavePrefs := True; //try again without pref saving
+ end;
+
+ with PlutoKey.GetKey('Window') do
+ try
+ WriteBool('Maximized', WindowState = wsMaximized);
+ if WindowState = wsNormal then begin
+ WriteInteger('Left', Left);
+ WriteInteger('Top', Top);
+ WriteInteger('Width', Width);
+ WriteInteger('Height', Height);
+ end;
+ finally
+ Free;
+ end;
+end;
+
+procedure TMainWin.Plutoini1Click(Sender: TObject);
+begin
+ NotePad(PlutoIniFileName);
+ ShowMessage('Click OK when you finished editing.' + EOL +
+ '(Pluto will reload ' + PlutoIniFileName + ')');
+ PrefWin.PrefHost.Load;
+end;
+
+procedure TMainWin.RegEdit2Click(Sender: TObject);
+begin
+ RegEdit;
+end;
+
+procedure TMainWin.SysEdit1Click(Sender: TObject);
+begin
+ SysEdit;
+end;
+
+procedure TMainWin.NotePad1Click(Sender: TObject);
+begin
+ NotePad;
+end;
+
+procedure TMainWin.WordPad1Click(Sender: TObject);
+begin
+ WordPad;
+end;
+
+procedure TMainWin.OpenWinDir1Click(Sender: TObject);
+begin
+ ExploreFolder(WinDir);
+end;
+
+procedure TMainWin.OpenProgramFolder1Click(Sender: TObject);
+begin
+ ExploreFolder(MyDir);
+end;
+
+procedure TMainWin.ExitPluto1Click(Sender: TObject);
+begin
+ Close;
+end;
+
+procedure TMainWin.Find1Click(Sender: TObject);
+begin
+ FindWin.SfRootKeyRB.Checked := True;
+ FindWin.Show;
+end;
+
+procedure TMainWin.FormPaint(Sender: TObject);
+begin
+ if Started and not MainWinLoaded then begin
+ MainWinLoaded := True;
+ Load;
+ end;
+end;
+
+procedure TMainWin.StatusBarDrawPanel(StatusBar: TStatusBar;
+ Panel: TStatusPanel; const Rect: TRect);
+begin
+ with StatusBar.Canvas do begin
+ Brush.Color := clBlack;
+ FillRect(Rect);
+ with Font do begin
+ Name := 'MS Sans Serif';
+ Style := [];
+ case Panel.Index of
+ 0: if HintBlinkT.Enabled then
+ Color := clBrightRed
+ else
+ Color := clBrightSilver;
+ 1: Color := clWhite;
+ 2: Color := clCyan;
+ 3: Color := clBrightPurple;
+ end;
+ end;
+
+ if Panel.Alignment = taRightJustify then
+ TextOut(Rect.Right - TextWidth(Panel.Text), Rect.Top, Panel.Text)
+ else
+ TextOut(Rect.Left, Rect.Top, Panel.Text);
+ end;
+end;
+
+procedure TMainWin.PathEKeyPress(Sender: TObject; var Key: Char);
+begin
+ if Key = #127 then //Silly key management
+ Key := #0;
+end;
+
+procedure TMainWin.HintBlinkTTimer(Sender: TObject);
+begin
+ StatusBar.Panels[0].Text := 'Ready';
+ StopHintBlinking;
+end;
+
+procedure TMainWin.StopHintBlinking;
+begin
+ HintBlinkT.Enabled := False;
+ PreBlinkHint := NoPreBlinkHint;
+end;
+
+procedure TMainWin.FindCLSID1Click(Sender: TObject);
+begin
+ FindCLSID;
+end;
+
+procedure TMainWin.GotoCLSID1Click(Sender: TObject);
+begin
+ GotoCLSID;
+end;
+
+procedure TMainWin.CommandLineParameters1Click(Sender: TObject);
+begin
+ NotePad(PlutoDir + 'Params.txt');
+end;
+
+procedure TMainWin.DeleteTempFolder1Click(Sender: TObject);
+begin
+ if mrYes = MessageDlg('Deleting ' + Quote(TempDir + '*.*' + EOL, '"') +
+ 'Are you sure?', mtConfirmation, [mbYes, mbCancel], 0) then
+ DeleteFiles(TempDir + '*.*', False);
+end;
+
+procedure TMainWin.CurrentDir1Click(Sender: TObject);
+begin
+ ShowMessage('MyDir: ' + MyDir + EOL +
+ 'PlutoDir: ' + PlutoDir + EOL +
+ 'CurrentDir: ' + GetCurrentDir + EOL +
+ 'Params: ' + EOL +
+ GetParams(EOL));
+end;
+
+procedure TMainWin.RepairPluto155bBug1Click(Sender: TObject);
+var
+ Msg: string;
+ Reg: TXRegistry;
+begin
+ Reg := TXRegistry.Create;
+
+ try
+ Reg.RootKey := HKCU;
+ Reg.OpenKey('Software');
+ Msg := '';
+ if Reg.KeyExists('Sisyphus') then
+ Msg := Msg + 'HKCU\Software\Sisyphus' + EOL;
+ if Reg.KeyExists('Main') then
+ Msg := Msg + 'HKCU\Software\Main' + EOL;
+ if Reg.KeyExists('Spy') then
+ Msg := Msg + 'HKCU\Software\Spy' + EOL;
+ if Reg.KeyExists('View') then
+ Msg := Msg + 'HKCU\Software\View' + EOL;
+ if Msg = '' then begin
+ ShowMessage('No bug detected :-)');
+ end else begin
+ Msg :=
+ 'Hi folks!' + EOL +
+ 'We are very sorry: A bug in Pluto made some components in the Edit' + EOL +
+ 'window save their values to the regsitry instead of the ini file.' + EOL +
+ 'If you want to repair that, you have to delete the following keys:' + EOL +
+ EOL +
+ Msg +
+ EOL +
+ 'This is not dangerous at all, but if you are interested in having' + EOL +
+ 'a clean registry, you should delete this useless keys.' + EOL +
+ EOL +
+ 'You surely noticed that this key names are rubish because they are' + EOL +
+ 'in the level that is normally used by programs.' + EOL +
+ 'If you have programs installed that use this keys for their' + EOL +
+ 'preferences, you may get problems when deleting the keys!' + EOL +
+ EOL +
+ 'So, now you have to decide what to do:' + EOL +
+ EOL +
+ 'Yes: Delete the keys. You have to confirm the deleting of each key.' + EOL +
+ 'No: Jump to the Software key and delete manually.' + EOL +
+ 'Cancel: Do nothing.' + EOL +
+ 'Yes to All: Delete all keys.';
+
+ case MessageDlg(Msg, mtWarning, [mbYes, mbNo, mbYesToAll, mbCancel], 0) of
+ mrYes: begin
+ if Reg.KeyExists('Main')
+ and (mrYes=MessageDlg('Delete HKU\Software\Main ?',
+ mtWarning, [mbYes, mbNo], 0)) then
+ Reg.DeleteKey('Main');
+
+ if Reg.KeyExists('Sisyphus')
+ and (mrYes=MessageDlg('Delete HKU\Software\Sisyphus ?',
+ mtWarning, [mbYes, mbNo], 0)) then
+ Reg.DeleteKey('Sisyphus');
+
+ if Reg.KeyExists('Spy')
+ and (mrYes=MessageDlg('Delete HKU\Software\Spy ?',
+ mtWarning, [mbYes, mbNo], 0)) then
+ Reg.DeleteKey('Spy');
+
+ if Reg.KeyExists('View')
+ and (mrYes=MessageDlg('Delete HKU\Software\View ?',
+ mtWarning, [mbYes, mbNo], 0)) then
+ Reg.DeleteKey('View');
+ end;
+
+ mrYesToAll: begin
+ Reg.DeleteKey('Main');
+ Reg.DeleteKey('Sisyphus');
+ Reg.DeleteKey('Spy');
+ Reg.DeleteKey('View');
+ end;
+
+ mrNo: begin
+ TreeWin.SetFocus;
+ GotoKey('HKCU\Software\');
+ end;
+ end;
+ end;
+
+ finally
+ Reg.Free;
+ end;
+end;
+
+procedure TMainWin.BackupRegistryscanreg1Click(Sender: TObject);
+begin
+ ExecFile('scanreg');
+end;
+
+procedure TMainWin.Username1Click(Sender: TObject);
+begin
+ ShowMessage(UserName);
+end;
+
+procedure TMainWin.ToDoMIClick(Sender: TObject);
+begin
+ NotePad(PlutoDir + 'ToDo.txt');
+end;
+
+procedure TMainWin.MailLinkMIClick(Sender: TObject);
+begin
+ MailTo(TMenuItem(Sender).Caption);
+end;
+
+procedure TMainWin.IjustwantCONTACT1Click(Sender: TObject);
+begin
+ MailTo('pluto@cYcnus.de');
+end;
+
+procedure TMainWin.ExternalHexEditMIClick(Sender: TObject);
+begin
+ ExecFile(PrefWin.ExternalHexEditE.Text);
+end;
+
+procedure TMainWin.AnotherPluto1Click(Sender: TObject);
+begin
+ ExecFile(Application.ExeName);
+end;
+
+procedure TMainWin.Path1Click(Sender: TObject);
+begin
+{$IFDEF UNIKEY}
+ UserUniPath := InputBox('UniKey', 'Input an UniPath.' + EOL +
+ EOL +
+ 'No idea? Try one of these: ' + EOL +
+ 'WinAmpVisColor <viscolor.txt>:' + EOL +
+ 'Params:' + EOL +
+ 'Reg: HKCU' + EOL +
+ 'Ini <' + MyDir + 'pluto.ini>:' + EOL +
+ 'Ini <' + MyDir + 'pluto.ini>:[View]' + EOL,
+ UserUniPath);
+{$ENDIF}
+end;
+
+procedure TMainWin.RegisterPlugIns1Click(Sender: TObject);
+begin
+{$IFDEF UNIKEY}
+ if UniPluginOD.Execute then
+ RegisterUniClass(UniPluginOD.FileName);
+{$ENDIF}
+end;
+
+procedure TMainWin.FormResize(Sender: TObject);
+begin
+ ArrangeIcons;
+ ArrangePlutoStyle;
+ WorkWin.WindowState := wsNormal;
+ ValuesWin.WindowState := wsNormal;
+ TreeWin.WindowState := wsNormal;
+end;
+
+procedure TMainWin.SwapLM_CUBClick(Sender: TObject);
+var
+ Path: string;
+begin
+ Path := TraceKey(PathE.Text, uhShortcuts);
+ if SwapHKU_HKLM(Path) then begin
+ PathE.Text := Path;
+ UserGotoKey;
+ end;
+end;
+
+procedure TMainWin.ShowLoadreport1Click(Sender: TObject);
+begin
+ NotePad(MyDir + 'loadreport.txt');
+end;
+
+procedure TMainWin.KillPluto1Click(Sender: TObject);
+begin
+ Application.Terminate;
+end;
+
+procedure TMainWin.ShowPlatform1Click(Sender: TObject);
+begin
+ ShowMessage(Format('Platform: %s' + EOL +
+ 'Versin: %d.%d Build %d',
+ [PlatformStrings[Win32Platform],
+ Win32MajorVersion, Win32MinorVersion, Win32BuildNumber]));
+end;
+
+procedure TMainWin.MSConfig1Click(Sender: TObject);
+begin
+ ExecFile('msconfig');
+end;
+
+procedure TMainWin.TimetoRelaxMIClick(Sender: TObject);
+var
+ RelaxFile: string;
+begin
+ with PlutoKey.GetKey('Main') do
+ try
+ RelaxFile := ReadString('Relax');
+ finally
+ Free;
+ end;
+
+ if RelaxFile = '' then
+ ShowMessage('This menu item can be used for something that lets you relax,' + EOL +
+ 'for example Diablo2, you favorite song or the latest news about the' + EOL +
+ 'decreasing AOL member numbers.' + EOL +
+ EOL +
+ 'Feel free to use everything you want.' + EOL +
+ 'Open the pluto.ini (CTRL+I) and add a new value "Relax" in the "Main"' + EOL +
+ 'section.' + EOL +
+ EOL +
+ 'And don''t forget:' + EOL +
+ 'R E L A X ! ! !')
+ else
+ ExecFile(RelaxFile);
+end;
+
+procedure TMainWin.OnSisyChange(Sender: TSisyThread; Change: TSisyChange);
+
+ procedure UpdateValue;
+ var
+ Reg: TXRegistry;
+ Index: Integer;
+ begin
+ if not SameRegPath(ExRegFullKey(Change.Path), PathOfNode(RegTV.Selected)) then
+ Exit;
+
+ Reg := TXRegistry.Create;
+ try
+ Reg.RootKey := HKEYOfStr(ExRegRoot(Change.Path));
+ if Reg.OpenKey(ExRegKey(Change.Path)) then
+ with ValuesWin do begin
+ Index := FindItemByRealName(ExRegValue(Change.Path));
+ if Index > -1 then begin
+ if Change.Typ = cValueMinus then
+ ValueList.Items.Delete(Index)
+ else if Change.Typ = cContextChange then
+ UpdateValue(Reg, ValueList.Items[Index]);
+ end else if Change.Typ = cValuePlus then
+ AddValue(Reg, ExRegValue(Change.Path));
+ end;
+ finally
+ Reg.Free;
+ end;
+ end;
+
+begin
+ AddHint(Sender.Name + ' notified ' + Change.Path);
+ if Change.Typ in [cValueMinus, cValuePlus, cContextChange] then
+ UpdateValue;
+end;
+
+procedure TMainWin.OnSisyValuePlus(Sender: TSisyThread; Change: TSisyChange);
+var
+ Reg: TXRegistry;
+begin
+ if not SameRegPath(ExRegFullKey(Change.Path), PathOfNode(RegTV.Selected)) then
+ Exit;
+
+ Reg := TXRegistry.Create;
+ try
+ Reg.RootKey := HKEYOfStr(ExRegRoot(Change.Path));
+ if Reg.OpenKey(ExRegKey(Change.Path)) then
+ ValuesWin.AddValue(Reg, ExRegValue(Change.Path));
+ finally
+ Reg.Free;
+ end;
+end;
+
+procedure TMainWin.OnSisyValueMinus(Sender: TSisyThread; Change: TSisyChange);
+var
+ Reg: TXRegistry;
+ Index: Integer;
+begin
+ if not SameRegPath(ExRegFullKey(Change.Path), PathOfNode(RegTV.Selected)) then
+ Exit;
+
+ Reg := TXRegistry.Create;
+ try
+ Reg.RootKey := HKEYOfStr(ExRegRoot(Change.Path));
+ if Reg.OpenKey(ExRegKey(Change.Path)) then
+ with ValuesWin do begin
+ Index := FindItemByRealName(ExRegValue(Change.Path));
+ if Index > -1 then
+ ValueList.Items.Delete(Index);
+ end;
+ finally
+ Reg.Free;
+ end;
+end;
+
+procedure TMainWin.OnSisyContextChange(Sender: TSisyThread; Change: TSisyChange);
+var
+ Reg: TXRegistry;
+ Index: Integer;
+begin
+ if not SameRegPath(ExRegFullKey(Change.Path), PathOfNode(RegTV.Selected)) then
+ Exit;
+
+ Reg := TXRegistry.Create;
+ try
+ Reg.RootKey := HKEYOfStr(ExRegRoot(Change.Path));
+ if Reg.OpenKey(ExRegKey(Change.Path)) then
+ with ValuesWin do begin
+ Index := FindItemByRealName(ExRegValue(Change.Path));
+ if Index > -1 then
+ UpdateValue(Reg, ValueList.Items[Index]);
+ end;
+ finally
+ Reg.Free;
+ end;
+end;
+
+end.
+unit PrefU;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+ Dialogs, ComCtrls, ExtCtrls, StdCtrls, PlutoConst, NewPanels, PrefTools,
+ YTools, YTypes, start, XReg, LinkLabel;
+
+type
+ TPrefWin = class(TForm)
+ PrefPC: TPageControl;
+ CommonPage: TTabSheet;
+ KeyPage: TTabSheet;
+ DataPage: TTabSheet;
+ KeysBP: TBorderPanel;
+ GroupBox3: TGroupBox;
+ MainPrevBP: TBorderPanel;
+ GroupBox4: TGroupBox;
+ BorderPanel6: TBorderPanel;
+ GroupBox6: TGroupBox;
+ SortKeysCB: TPrefCheckBox;
+ PrefHost: TPrefHost;
+ MainPreviewCB: TPrefCheckBox;
+ SplashScreenCB: TPrefCheckBox;
+ PrefValuesPC: TPageControl;
+ StringPage: TTabSheet;
+ MultiStringPage: TTabSheet;
+ IntPage: TTabSheet;
+ BinaryPage: TTabSheet;
+ BorderPanel8: TBorderPanel;
+ GroupBox8: TGroupBox;
+ ShowDwordAsHex: TPrefCheckBox;
+ BorderPanel7: TBorderPanel;
+ GroupBox7: TGroupBox;
+ CountZeroByteCB: TPrefCheckBox;
+ BorderPanel1: TBorderPanel;
+ GroupBox2: TGroupBox;
+ UseExtendedModelCB: TPrefCheckBox;
+ BorderPanel2: TBorderPanel;
+ GroupBox1: TGroupBox;
+ ShowAsBinaryCB: TPrefCheckBox;
+ ShowBinaryAsRG: TPrefRadioGroup;
+ Smart4BBCB: TPrefCheckBox;
+ DWordPreviewL: TLabel;
+ Label4: TLabel;
+ Label5: TLabel;
+ Label6: TLabel;
+ Label7: TLabel;
+ UserNameE: TPrefEdit;
+ Label8: TLabel;
+ MainPreviewE: TPrefEdit;
+ Label12: TLabel;
+ DefaultIconPreviewCB: TPrefCheckBox;
+ KeyInfoPreviewCB: TPrefCheckBox;
+ SelectExternalHexEditOD: TOpenDialog;
+ BorderPanel3: TBorderPanel;
+ GroupBox9: TGroupBox;
+ IntegrationPage: TTabSheet;
+ BorderPanel4: TBorderPanel;
+ GroupBox5: TGroupBox;
+ Label11: TLabel;
+ SelectExternalHexEditB: TButton;
+ RunExternalHexEditB: TButton;
+ ExternalHexEditE: TPrefEdit;
+ Label13: TLabel;
+ BorderPanel5: TBorderPanel;
+ GroupBox10: TGroupBox;
+ Label15: TLabel;
+ RegisterAppCB: TCheckBox;
+ Label3: TLabel;
+ Memo1: TMemo;
+ ExpandStringsRG: TPrefRadioGroup;
+ QuotersE: TPrefEdit;
+ Label1: TLabel;
+ StringPreviewL: TLabel;
+ ShowLineCountCB: TPrefCheckBox;
+ ShowTreeViewLinesCB: TPrefCheckBox;
+ ValuePage: TTabSheet;
+ BorderPanel10: TBorderPanel;
+ GroupBox12: TGroupBox;
+ ShowListViewGridCB: TPrefCheckBox;
+ Label9: TLabel;
+ DefaultValueNameE: TPrefEdit;
+ Label10: TLabel;
+ GotoPlutoKeyB: TButton;
+ ColorPanel2: TColorPanel;
+ LinkLabel1: TLinkLabel;
+ SmartExpandCB: TPrefCheckBox;
+ KeysSingleClickCB: TPrefCheckBox;
+ ValuesSingleClickCB: TPrefCheckBox;
+ ShowProgressCB: TPrefCheckBox;
+ ColorPanel1: TColorPanel;
+ Label2: TLabel;
+ ReloadB: TButton;
+ DefaultB: TButton;
+ SaveB: TButton;
+ procedure PrefPCDrawTab(Control: TCustomTabControl;
+ TabIndex: Integer; const Rect: TRect; Active: Boolean);
+ procedure PrefHostLoaded(Sender: TObject);
+ procedure StandardPreviewChange(Sender: TObject);
+ procedure DataPreviewChange(Sender: TObject);
+ procedure UserNameEChange(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+ procedure FormDeactivate(Sender: TObject);
+ procedure FormActivate(Sender: TObject);
+ procedure PrefValuesPCDrawTab(Control: TCustomTabControl;
+ TabIndex: Integer; const Rect: TRect; Active: Boolean);
+ procedure ShowDwordAsHexClick(Sender: TObject);
+ procedure MainPreviewEChange(Sender: TObject);
+ procedure FormCreate(Sender: TObject);
+ procedure ActivateIt(Sender: TObject);
+ procedure DeActivateIt(Sender: TObject);
+ procedure ReloadBClick(Sender: TObject);
+ procedure RunExternalHexEditBClick(Sender: TObject);
+ procedure SelectExternalHexEditBClick(Sender: TObject);
+ procedure ExternalHexEditEChange(Sender: TObject);
+ procedure DefaultBClick(Sender: TObject);
+ procedure RegisterAppCBClick(Sender: TObject);
+ procedure SaveBClick(Sender: TObject);
+ procedure StringPreviewChange(Sender: TObject);
+ procedure ShowTreeViewLinesCBClick(Sender: TObject);
+ procedure ShowListViewGridCBClick(Sender: TObject);
+ procedure DefaultValueNameEChange(Sender: TObject);
+ procedure LoadPrefs;
+ procedure UseExtendedModelCBClick(Sender: TObject);
+ procedure IntegrationPageShow(Sender: TObject);
+ procedure GotoPlutoKeyBClick(Sender: TObject);
+ procedure FormShow(Sender: TObject);
+ procedure KeysSingleClickCBClick(Sender: TObject);
+ procedure ValuesSingleClickCBClick(Sender: TObject);
+ procedure QuotersEChange(Sender: TObject);
+ procedure SplashScreenCBClick(Sender: TObject);
+ procedure SaveBMouseMove(Sender: TObject; Shift: TShiftState; X,
+ Y: Integer);
+ public
+ StringQuoterBegin, StringQuoterEnd: string;
+ end;
+
+var
+ PrefWin: TPrefWin;
+
+implementation
+
+uses
+ TreeU, ValuesU, Splash, plutomain, WorkU;
+
+{$R *.dfm}
+
+procedure TPrefWin.PrefPCDrawTab(Control: TCustomTabControl;
+ TabIndex: Integer; const Rect: TRect; Active: Boolean);
+var
+ PC: TPageControl;
+ Page: TTabSheet;
+begin
+ PC := TPageControl(Control);
+ Page := PC.Pages[TabIndex];
+ with PC.Canvas.Font do begin
+ if Page.Caption = 'Common' then
+ Color := clWhite
+ else if Page.Caption = 'Keys' then
+ Color := clBrightCyan
+ else if Page.Caption = 'Values' then
+ Color := clBrightPurple
+ else if Page.Caption = 'Data' then
+ Color := clBrightBlue
+ else if Page.Caption = 'System' then
+ Color := clBrightYellow
+ else
+ Color := clWhite;
+ end;
+
+ with PC.Canvas do
+ if Active then begin
+ Font.Style := [fsBold];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 5, Rect.Top + 3, Page.Caption);
+ end else begin
+ Font.Style := [];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 3, Rect.Top + 2, Page.Caption);
+ end;
+end;
+
+procedure TPrefWin.PrefHostLoaded(Sender: TObject);
+begin
+ PrefHost.KeyName := PlutoUniPath;
+end;
+
+procedure TPrefWin.StandardPreviewChange(Sender: TObject);
+begin
+ if Started then
+ RegTV.Repaint;
+end;
+
+procedure TPrefWin.DataPreviewChange(Sender: TObject);
+begin
+ if not Started then
+ Exit;
+
+ ValuesWin.UpdateValues;
+ RegTV.Repaint;
+end;
+
+procedure TPrefWin.UserNameEChange(Sender: TObject);
+begin
+ StatusBar.Panels[0].Text := MainWin.Greeting;
+end;
+
+procedure TPrefWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if Key = VK_ESCAPE then
+ Close;
+
+ if Key = VK_SCROLL then
+ MainWin.FormKeyDown(Sender, Key, Shift);
+end;
+
+procedure TPrefWin.FormDeactivate(Sender: TObject);
+begin
+ if ActiveControl.Tag = EditControlFlag then
+ DeActivateThis(ActiveControl);
+
+ AlphaBlendValue := 127;
+end;
+
+procedure TPrefWin.FormActivate(Sender: TObject);
+begin
+ if Started and (ActiveControl.Tag = EditControlFlag) then
+ ActivateThis(ActiveControl);
+
+ AlphaBlendValue := 255;
+end;
+
+procedure TPrefWin.PrefValuesPCDrawTab(Control: TCustomTabControl;
+ TabIndex: Integer; const Rect: TRect; Active: Boolean);
+var
+ PC: TPageControl;
+ Page: TTabSheet;
+begin
+ PC := TPageControl(Control);
+ Page := PC.Pages[TabIndex];
+ with PC.Canvas.Font do begin
+ if Page = StringPage then
+ Color := clBrightRed
+ else if Page = MultiStringPage then
+ Color := clBrightPurple
+ else if Page = IntPage then
+ Color := clBrightBlue
+ else if Page = BinaryPage then
+ Color := clBrightGreen;
+ end;
+
+ with PC.Canvas do
+ if Active then begin
+ Font.Style := [fsBold];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 18 + 5, Rect.Top + 3, Page.Caption);
+ PC.Images.Draw(PC.Canvas, Rect.Left + 4, Rect.Top + 2, Page.ImageIndex);
+ end else begin
+ Font.Style := [];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 18 + 3, Rect.Top + 2, Page.Caption);
+ PC.Images.Draw(PC.Canvas, Rect.Left + 1, Rect.Top + 1, Page.ImageIndex);
+ end;
+end;
+
+procedure TPrefWin.ShowDwordAsHexClick(Sender: TObject);
+begin
+ DWordPreviewL.Caption := 'Preview: ' + ValuesU.DataPreviewOfContext(
+ RegContext(rdCardinal, Reverse(ByteAOfHex(HexOfCard(1234567890, 8)))));
+ DataPreviewChange(Self);
+end;
+
+procedure TPrefWin.MainPreviewEChange(Sender: TObject);
+begin
+ if MainPreviewE.Text = '' then
+ MainPreviewCB.Caption := '&Show Preview for Default Value'
+ else
+ MainPreviewCB.Caption := '&Show Preview for ' +
+ Quote(MainPreviewE.Text);
+
+ StandardPreviewChange(Self);
+end;
+
+procedure TPrefWin.FormCreate(Sender: TObject);
+begin
+ UserNameE.DefaultValue := UserName;
+ MainPreviewEChange(Self);
+ PrefPC.ActivePageIndex := 0;
+ PrefValuesPC.ActivePageIndex := 0;
+end;
+
+procedure TPrefWin.ActivateIt(Sender: TObject);
+begin
+ ActivateThis(Sender);
+end;
+
+procedure TPrefWin.DeActivateIt(Sender: TObject);
+begin
+ DeActivateThis(Sender);
+end;
+
+procedure TPrefWin.ReloadBClick(Sender: TObject);
+begin
+ LoadPrefs;
+end;
+
+procedure TPrefWin.RunExternalHexEditBClick(Sender: TObject);
+var
+ FileName, TestValue: string;
+begin
+ FileName := TempDir + '~test.bin';
+ TestValue := 'This is only a test.' + EOL +
+ 'Everything seems to be OK.';
+ if SaveByteA(ByteAOfStr(TestValue), FileName) then
+ ExecFileWith(ExternalHexEditE.Text, FileName)
+ else
+ ShowMessage('Could not write into file:' + EOL +
+ FileName);
+end;
+
+procedure TPrefWin.SelectExternalHexEditBClick(Sender: TObject);
+begin
+ with SelectExternalHexEditOD do begin
+ InitialDir := ExtractPath(ExternalHexEditE.Text);
+ FileName := ExtractFileName(ExternalHexEditE.Text);
+ if Execute and FileExists(FileName) then
+ ExternalHexEditE.Text := FileName;
+ end;
+end;
+
+procedure TPrefWin.ExternalHexEditEChange(Sender: TObject);
+begin
+ RunExternalHexEditB.Enabled := FileExists(ExternalHexEditE.Text);
+ if Assigned(WorkWin) then
+ WorkWin.ExternalEditB.Enabled := RunExternalHexEditB.Enabled;
+ if Assigned(MainWin) then
+ MainWin.ExternalHexEditMI.Enabled := RunExternalHexEditB.Enabled;
+end;
+
+procedure TPrefWin.DefaultBClick(Sender: TObject);
+begin
+ if mrYes=MessageDlg('Do you really want to reset the preferences' + EOL +
+ 'to their defaults?' + EOL +
+ '(This can not be undone.)', mtWarning, [mbYes, mbCancel], 0) then begin
+ CopyFile(PChar(PlutoIniFileName), PChar(PlutoIniFileName + '.backup'), False);
+ //PrefHost.KeyName := 'Ini <' + PlutoIniFileName + '.backup>:';
+ //PrefHost.Save;
+ //PrefHost.KeyName := PlutoUniPath;
+ PrefHost.BackUp;
+ end;
+end;
+
+procedure TPrefWin.RegisterAppCBClick(Sender: TObject);
+begin
+ with TXRegistry.Create do
+ try
+ RootKey := HKLM;
+ OpenKey('Software\Microsoft\Windows\CurrentVersion\App Paths');
+ if RegisterAppCB.Checked then begin
+ OpenKey('pluto.exe', True);
+ WriteString('', GetFileNew(Application.ExeName));
+ end else
+ DeleteKey('pluto.exe');
+ finally
+ Free;
+ end;
+end;
+
+procedure TPrefWin.SaveBClick(Sender: TObject);
+begin
+ PrefHost.Save;
+end;
+
+procedure TPrefWin.StringPreviewChange(Sender: TObject);
+begin
+ StringPreviewL.Caption := 'Preview: ' + ValuesU.DataPreviewOfContext(
+ RegContext(rdString, ByteAOfStr('%windir%')));
+ DataPreviewChange(Self);
+end;
+
+procedure TPrefWin.ShowTreeViewLinesCBClick(Sender: TObject);
+begin
+ with RegTV do begin
+ ShowLines := ShowTreeViewLinesCB.Checked;
+ ShowButtons := ShowLines;
+ end;
+ StandardPreviewChange(Sender);
+end;
+
+procedure TPrefWin.ShowListViewGridCBClick(Sender: TObject);
+begin
+ ValueList.GridLines := ShowListViewGridCB.Checked;
+end;
+
+procedure TPrefWin.DefaultValueNameEChange(Sender: TObject);
+begin
+ DefaultValueCaption := DefaultValueNameE.Text;
+ if Started then
+ TreeWin.RegTVChange(Self, RegTV.Selected);
+end;
+
+procedure TPrefWin.LoadPrefs;
+begin
+ PrefHost.Load;
+end;
+
+procedure TPrefWin.UseExtendedModelCBClick(Sender: TObject);
+begin
+ WorkWin.MultiStringTypeRG.ItemIndex := Integer(UseExtendedModelCB.Checked);
+ DataPreviewChange(Sender);
+end;
+
+procedure TPrefWin.IntegrationPageShow(Sender: TObject);
+begin
+ with TXRegistry.Create do
+ try
+ RootKey := HKLM;
+ OpenKey('Software\Microsoft\Windows\CurrentVersion\App Paths\pluto.exe');
+ RegisterAppCB.Checked := SameFileName(GetFileNew(ReadString('')),
+ GetFileNew(Application.ExeName));
+ finally
+ Free;
+ end;
+end;
+
+procedure TPrefWin.GotoPlutoKeyBClick(Sender: TObject);
+begin
+ MainWin.GotoKey('HKLM\Software\Microsoft\Windows\CurrentVersion\App Paths\pluto.exe');
+end;
+
+procedure TPrefWin.FormShow(Sender: TObject);
+begin
+ PrefHost.Load;
+end;
+
+procedure TPrefWin.KeysSingleClickCBClick(Sender: TObject);
+begin
+ TreeWin.CheckRegTVHotTrack;
+end;
+
+procedure TPrefWin.ValuesSingleClickCBClick(Sender: TObject);
+begin
+ ValuesWin.CheckValueListHotTrack;
+end;
+
+procedure TPrefWin.QuotersEChange(Sender: TObject);
+var
+ QBegin, QEnd: string;
+begin
+ with QuotersE do begin
+ if Text = '' then
+ QBegin := ''
+ else
+ QBegin := Text[1];
+ if Length(Text) < 2 then
+ QEnd := QBegin
+ else
+ QEnd := Text[2];
+ end;
+
+ if (QBegin <> StringQuoterBegin) or (QEnd <> StringQuoterEnd) then begin
+ StringQuoterBegin := QBegin;
+ StringQuoterEnd := QEnd;
+ StringPreviewChange(Self);
+ end;
+end;
+
+procedure TPrefWin.SplashScreenCBClick(Sender: TObject);
+begin
+ if Started and Assigned(SplashWin) then
+ SplashWin.SplashScreenCB.Checked := SplashScreenCB.Checked;
+end;
+
+procedure TPrefWin.SaveBMouseMove(Sender: TObject; Shift: TShiftState; X,
+ Y: Integer);
+begin
+ Label2.Font.Color := clBrightRed;
+ Application.ProcessMessages;
+ Sleep(200);
+ Label2.Font.Color := clWhite;
+end;
+
+end.
+unit RegScanner;
+
+interface
+
+uses
+ Windows, SysUtils, Dialogs, Classes,
+ YTools, YTypes, XReg, Clock;
+
+type
+ TRegScanThread = class;
+
+ TRegScanKeyEvent = procedure (Sender: TRegScanThread; const KeyName: string; Key: HKEY; Info: TRegKeyInfo) of object;
+ TRegScanValueEvent = procedure (Sender: TRegScanThread; const ValueName: string; Context: TRegContext) of object;
+
+ TRegScanTask = record
+ Root: string;
+ Key: HKEY;
+ end;
+ TRegScanTasks = array of TRegScanTask;
+
+ TRegScanThread = class(TThread)
+ private
+ Keys, KeysOK, Values, ValuesOK: Integer;
+ DoScanValues: Boolean;
+ FOnKey: TRegScanKeyEvent;
+ FOnValue: TRegScanValueEvent;
+ FOnFaileKey: TRegScanKeyEvent;
+ protected
+ procedure ScanKey(Key: HKEY; const KeyName: string = ''); virtual;
+ procedure ScanValues(Key: HKEY; Info: TRegKeyInfo); virtual;
+
+ public
+ Path: string;
+ CurrentTask: TRegScanTask;
+ Tasks: TRegScanTasks;
+ destructor Destroy; override;
+ procedure Execute; override;
+ procedure ScanAll;
+ function CurrentPath: string;
+ published
+ constructor CreateIt(PriorityLevel: TThreadPriority;
+ DoScanValues: Boolean = True; Tasks: TRegScanTasks = nil);
+
+ property OnKey: TRegScanKeyEvent read FOnKey write FOnKey;
+ property OnValue: TRegScanValueEvent read FOnValue write FOnValue;
+ property OnFaileKey: TRegScanKeyEvent read FOnFaileKey write FOnFaileKey;
+ end;
+
+implementation
+
+{ TRegScanThread }
+
+constructor TRegScanThread.CreateIt(PriorityLevel: TThreadPriority;
+ DoScanValues: Boolean = True; Tasks: TRegScanTasks = nil);
+begin
+ inherited Create(True);
+ Priority := PriorityLevel;
+ FreeOnTerminate := False;
+ Self.DoScanValues := DoScanValues;
+ Self.Tasks := Tasks;
+end;
+
+destructor TRegScanThread.Destroy;
+begin
+ inherited;
+end;
+
+procedure TRegScanThread.ScanAll;
+var
+ i: Integer;
+begin
+ Keys := 0;
+ KeysOK := 0;
+ Values := 0;
+ ValuesOK := 0;
+
+ for i := 0 to High(Tasks) do begin
+ CurrentTask := Tasks[i];
+ with CurrentTask do begin
+ Inc(Keys);
+ ScanKey(Key);
+ end;
+
+ if Terminated then Break;
+ end;
+end;
+
+procedure TRegScanThread.ScanValues(Key: HKEY; Info: TRegKeyInfo);
+var
+ i: Integer;
+ MaxLen, NameLen, Len, Typ: Cardinal;
+ p: PChar;
+ Buffer: TByteA;
+
+ procedure ScanValue(ValueName: string; Typ: TRegDataType; Data: TByteA);
+ begin
+ if Assigned(OnValue) then
+ OnValue(Self, ValueName, RegContext(Typ, Data));
+ Inc(ValuesOK);
+ end;
+
+begin
+ MaxLen := Info.MaxValueLen + 1; //Include Nullbyte
+ SetLength(Buffer, Info.MaxDataLen);
+ GetMem(p, MaxLen);
+
+ Inc(Values, Info.NumValues);
+ for i := 0 to Info.NumValues-1 do begin
+ NameLen := MaxLen;
+ Len := Info.MaxDataLen;
+ if Success(RegEnumValue(Key, i, p, NameLen, nil, @Typ, Pointer(Buffer),
+ @Len)) then
+ ScanValue(Copy(p, 0, NameLen), Typ, Copy(Buffer, 0, Len))
+ else
+ Yield;
+ end;
+ FreeMem(p, MaxLen);
+end;
+
+procedure TRegScanThread.ScanKey(Key: HKEY; const KeyName: string = '');
+var
+ i: Integer;
+ NewHKEY: HKEY;
+ Info: TRegKeyInfo;
+ l, Len: DWORD;
+ p: PChar;
+ z: Integer;
+begin
+ if Terminated then Exit;
+
+ with Info do begin
+ if not Success(RegQueryInfoKey(Key, nil, nil, nil, @NumSubKeys,
+ @MaxSubKeyLen, nil, @NumValues, @MaxValueLen, @MaxDataLen,
+ nil, nil)) then
+ Exit;
+
+ if Assigned(OnKey) then
+ OnKey(Self, KeyName, Key, Info);
+ if DoScanValues and (NumValues > 0) then
+ ScanValues(Key, Info);
+
+ if Info.NumSubKeys > 0 then begin
+ Inc(Keys, NumSubKeys);
+
+ Len := MaxSubKeyLen + 1;
+ GetMem(p, Len);
+
+ for i := 0 to NumSubKeys-1 do begin
+ l := Len;
+ RegEnumKeyEx(Key, i, p, l, nil, nil, nil, nil);
+ if Success(RegOpenKey(Key, p, NewHKEY)) then begin
+ z := Length(Path);
+ Path := Path + '\' + p;
+ ScanKey(NewHKEY, p);
+ RegCloseKey(NewHKEY);
+ SetLength(Path, z);
+ end else
+ if Assigned(OnFaileKey) then
+ OnFaileKey(Self, p, Key, Info);
+
+ if Terminated then
+ Break;
+ end;
+ FreeMem(p, Len);
+ end;
+ end;
+
+ Inc(KeysOK);
+end;
+
+procedure TRegScanThread.Execute;
+var
+ Secs: Double;
+begin
+ with TClock.Create do begin
+ ScanAll;
+ Secs := SecondsPassed;
+ Free;
+ end;
+
+ WriteLn('finished.');
+ WriteLn( Format('Keys: %6d counted (%3d failed)', [Keys, Keys - KeysOK]));
+ if DoScanValues then
+ WriteLn(Format('Values: %6d counted (%3d failed)', [Values, Values - ValuesOK]));
+ WriteLn('t ' + Format('%.2f', [Secs]) + ' seconds');
+ if Secs > 0 then
+ WriteLn('r ' + Format('%.0f', [Keys / Secs]) + ' k/s');
+end;
+
+function TRegScanThread.CurrentPath: string;
+begin
+ Result := CurrentTask.Root + Path;
+end;
+
+end.
+unit RegTV;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
+ ComCtrls;
+
+type
+ TRegTV = class(TTreeView)
+ private
+ { Private-Deklarationen }
+ protected
+ { Protected-Deklarationen }
+ public
+ { Public-Deklarationen }
+ published
+ { Published-Deklarationen }
+ end;
+
+procedure Register;
+
+implementation
+
+procedure Register;
+begin
+ RegisterComponents('pluto', [TRegTV]);
+end;
+
+end.
+unit Sisyphus;
+
+interface
+
+uses
+ Windows, Classes, SysUtils, XReg, YTools, YTypes, Clock;
+
+type
+ TSpyValue = class
+ Name: string;
+ Next: TSpyValue;
+ //DIC: TByteA;
+ Typ: TXRegDataType;
+ Data: TByteA;
+ constructor Create(AName: string);
+ end;
+
+ TSpyKey = class
+ public
+ Parent: TSpyKey;
+ Name: string;
+ Next: TSpyKey;
+ Keys: TSpyKey;
+ Values: TSpyValue;
+ procedure Spy(AHKEY: HKEY);
+ function Path: string;
+ constructor Create(AParent: TSpyKey; AName: string);
+ destructor Destroy; override;
+ end;
+
+var
+ Reg: TXRegistry;
+ HKLMSpyKey, HKUSpyKey: TSpyKey;
+ Started: Boolean = False;
+
+implementation
+
+uses
+ Plutomain;
+
+procedure AddChange(M: string);
+begin
+ Yield;
+ //AddHint(M);
+end;
+
+{ TSpyValue }
+
+constructor TSpyValue.Create(AName: string);
+begin
+ Name := AName;
+ Next := nil;
+end;
+
+{ TSpyKey }
+
+constructor TSpyKey.Create(AParent: TSpyKey; AName: string);
+begin
+ Name := AName;
+ Parent := AParent;
+
+ Next := nil;
+ Keys := nil;
+ Values := nil;
+end;
+
+destructor TSpyKey.Destroy;
+var
+ Value, NextValue: TSpyValue;
+ Key, NextKey: TSpyKey;
+begin
+ Value := Values;
+ while Value <> nil do begin
+ NextValue := Value.Next;
+ Value.Free;
+ Value := NextValue;
+ end;
+
+ Key := Keys;
+ while Key <> nil do begin
+ NextKey := Key.Next;
+ Key.Free;
+ Key := NextKey;
+ end;
+
+ inherited;
+end;
+
+function TSpyKey.Path: string;
+begin
+ if Assigned(Parent) then
+ Result := Parent.Path + '\'
+ else
+ Result := 'Reg: ';
+
+ Result := Result + Name;
+end;
+
+procedure TSpyKey.Spy(AHKEY: HKEY);
+var
+ SL: TStringList;
+
+ procedure CompareValues;
+ var
+ i: Integer;
+ Value, LastValue, NewValue, SearchValue: TSpyValue;
+ begin
+ //OK, this part is a little bit complicate. So I will comment very much.
+ //First, two terms are important:
+ //<REAL> means the list of values that will be read from the registry now:
+ Reg.GetValueNames(SL);
+ //So <REAL> is TStringList.
+
+ //<CURRENT> means the image that was saved before.
+ //Here, it is a linear list of TSpyValue objects. That means that you can
+ //only get X.Next and not X.Prev! However, I use "X.Prev" to simplify
+ //some comments.
+
+ //!!! Comparing means: Make <CURRENT> fit <REAL> !!!
+
+ //If <CURRENT> wasn't saved before, it is just empty.
+
+ //!!! There is no difference in comparing and saving in this method !!!
+
+ //Building means: Comparing with an empty image.
+
+ //We go through <REAL> and make <CURRENT> fit it
+
+ //The following rules are important:
+ //Value = "The currently interesting value.
+ //LastValue = "The value with X.Next = Value" = "Value.Pref"
+
+ LastValue := nil; // := "Values.Prev"
+ Value := Values; // := "LastValue.Next"
+
+ //Now compare step by step
+ for i := 0 to SL.Count-1 do begin
+ if Assigned(Value) and (SL[i] = Value.Name) then begin
+ //cV= Normally (0.9999) everything's the same
+ LastValue := Value;
+ Value := Value.Next;
+ end else begin //Something's different? Yes, the IMPORTANT rest (0.0001))
+ //Because the list finally must exactly fit SL, the "SL[i] value" hast
+ //to be inserted right here. But first let's look...
+
+ //Maybe it was just moved? So search for it...
+ NewValue := nil;
+ if Assigned(Value) then begin
+ SearchValue := Value;
+ while Assigned(SearchValue.Next) do
+ if (SearchValue.Next.Name = SL[i]) then begin
+ //cV\
+ NewValue := SearchValue.Next;
+ AddChange('cV\ ' + Path);
+ SearchValue.Next := SearchValue.Next.Next;
+ Break; end;
+ end;
+
+ if not Assigned(NewValue) then begin
+ //cV+ No, not found! So it is new...
+ NewValue := TSpyValue.Create(SL[i]);
+ AddChange('cV+ ' + Path + '\\' + NewValue.Name);
+ with NewValue do begin
+ Typ := Reg.GetDataType(SL[i]);
+ Data := Reg.ReadBin(SL[i]);
+ end;
+ end;
+
+ //The new object now must be placed after the last value
+ if Assigned(LastValue) then begin
+ LastValue.Next := NewValue;
+ end else begin
+ //If it's the first value, we don't have LastValue defined
+ //So we have to set the "Root" to it
+ Values := NewValue;
+ end;
+ //Now the rest of <CURRENT> has to be placed after the new value
+ NewValue.Next := Value;
+ //And LastValue also has to refreshed: It is "Value.Pref" = NewValue!
+ LastValue := NewValue;
+ end;
+ end;
+
+ //Because the whole <CURRENT> before Value is exactly <REAL>, the rest
+ //(if there is one) must have been deleted!
+
+ //So first let's ensure that <CURRENT> ends here:
+ if Assigned(LastValue) then begin
+ LastValue.Next := nil;
+ end else begin
+ //Another time: <CURRENT> is empty now, so set Values instead
+ Values := nil;
+ end;
+
+ //Now, the first value that maybe was "cut" off is Value:
+ while Assigned(Value) do begin
+ //cV- So, here really something HAS been deleted
+ LastValue := Value;
+ Value := Value.Next;
+ AddChange('cV- ' + Path + '\\' + LastValue.Name);
+ LastValue.Free;
+ end;
+ end;
+
+ procedure CompareData;
+ var
+ Value: TSpyValue;
+ Typ: TXRegDataType;
+ Data: TByteA;
+ begin
+ //So, finally <CURRENT> = <REAL>. That means we now can compare the data:
+ Value := Values;
+ while Assigned(Value) do begin
+ Typ := Reg.GetDataType(Value.Name);
+ Data := Reg.ReadBin(Value.Name);
+ if Typ <> Value.Typ then begin
+ //cT#
+ AddChange('cT# ' + Path + '\\' + Value.Name);
+ Value.Typ := Typ;
+ end;
+ if not SameByteA(Data, Value.Data) then begin
+ //cD#
+ AddChange('cD# ' + Path + '\\' + Value.Name);
+ Value.Data := Data;
+ end;
+
+ Value := Value.Next;
+ end;
+ end;
+
+ procedure CompareKeys;
+ var
+ i: Integer;
+ Key, LastKey, NewKey, SearchKey: TSpyKey;
+ NewHKEY: HKEY;
+ begin
+ //OK, this part is a little bit complicate. So I will comment very much.
+ //First, two terms are important:
+ //<REAL> means the list of keys that will be read from the registry now:
+ Reg.GetKeyNames(SL);
+ //So <REAL> is TStringList.
+
+ //<CURRENT> means the image that was saved before.
+ //Here, it is a linear list of TSpyKey objects. That means that you can
+ //only get X.Next and not X.Prev! However, I use "X.Prev" to simplify
+ //some comments.
+
+ //!!! Comparing means: Make <CURRENT> fit <REAL> !!!
+
+ //If <CURRENT> wasn't saved before, it is just empty.
+
+ //!!! There is no difference in comparing and saving in this method !!!
+
+ //Building means: Comparing with an empty image.
+
+ //We go through <REAL> and make <CURRENT> fit it
+
+ //The following rules are important:
+ //Key = "The currently interesting key.
+ //LastKey = "The key with X.Next = Key" = "Key.Pref"
+
+ LastKey := nil; // := "Keys.Prev"
+ Key := Keys; // := "LastKey.Next"
+
+ //Now compare step by step
+ for i := 0 to SL.Count-1 do begin
+ if Assigned(Key) and (SL[i] = Key.Name) then begin
+ //cK= Normally (0.9999) everything's the same
+ RegOpenKey(AHKEY, PChar(SL[i]), NewHKEY);
+ Key.Spy(NewHKEY);
+ LastKey := Key;
+ Key := Key.Next;
+ end else begin //Something's different? Yes, the IMPORTANT rest (0.0001))
+ //Because the list finally must exactly fit SL, the "SL[i] key" hast
+ //to be inserted right here. But first let's look...
+
+ //Maybe it was just moved? So search for it...
+ NewKey := nil;
+ if Assigned(Key) then begin
+ SearchKey := Key;
+ while Assigned(SearchKey.Next) do
+ if (SearchKey.Next.Name = SL[i]) then begin
+ //cK\
+ NewKey := SearchKey.Next;
+ AddChange('cK\ ' + Path);
+ SearchKey.Next := SearchKey.Next.Next;
+ Break; end;
+ end;
+
+ if not Assigned(NewKey) then begin
+ //cK+ No, not found! So it is new...
+ NewKey := TSpyKey.Create(Self, SL[i]);
+ AddChange('cK+ ' + Path + '\' + NewKey.Name);
+
+ RegOpenKey(AHKEY, PChar(SL[i]), NewHKEY);
+ NewKey.Spy(NewHKEY);
+ end;
+
+ //The new object now must be placed after the last key
+ if Assigned(LastKey) then begin
+ LastKey.Next := NewKey;
+ end else begin
+ //If it's the first key, we don't have LastKey defined
+ //So we have to set the "Root" to it
+ Keys := NewKey;
+ end;
+ //Now the rest of <CURRENT> has to be placed after the new key
+ NewKey.Next := Key;
+ //And LastKey also has to refreshed: It is "Key.Pref" = NewKey!
+ LastKey := NewKey;
+ end;
+ end;
+
+ //Because the whole <CURRENT> before Key is exactly <REAL>, the rest
+ //(if there is one) must have been deleted!
+
+ //So first let's ensure that <CURRENT> ends here:
+ if Assigned(LastKey) then begin
+ LastKey.Next := nil;
+ end else begin
+ //Another time: <CURRENT> is empty now, so set Keys instead
+ Keys := nil;
+ end;
+
+ //Now, the first key that maybe was "cut" off is Key:
+ while Assigned(Key) do begin
+ //cV- So, here really something HAS been deleted
+ LastKey := Key;
+ Key := Key.Next;
+ AddChange('cK- ' + Path + '\' + LastKey.Name);
+ LastKey.Free;
+ end;
+ end;
+
+
+begin
+ SL := TStringList.Create;
+
+ try
+ Reg.CurrentKey := AHKEY;
+
+ CompareValues;
+
+ CompareData;
+
+ CompareKeys;
+
+ finally
+ RegCloseKey(AHKEY);
+ end;
+
+ SL.Free;
+end;
+
+initialization
+ Reg := TXRegistry.Create;
+ HKLMSpyKey := TSpyKey.Create(nil, 'HKEY_LOCAL_MACHINE');
+ HKUSpyKey := TSpyKey.Create(nil, 'HKEY_USERS');
+
+finalization
+ Reg.Free;
+ HKLMSpyKey.Free;
+ HKUSpyKey.Free;
+
+end.
+unit SisyphusTH;
+
+interface
+
+uses
+ Windows, Classes, StdCtrls, Dialogs, SysUtils, XReg, YTools, YTypes, Clock,
+ ComCtrls, PlutoConst, UniKey, CompEx;
+
+const
+ SisyVersion = '1.2 b3';
+ StatusPoints = 25;
+
+type
+ TSisyChangeType = (cNone, cError,
+ cKeyPlus, cKeyMinus,
+ cValuePlus, cValueMinus,
+ cContextChange);
+
+const
+ SisyChangeStrings: array[TSisyChangeType] of string =
+ ('?', 'Error',
+ 'cK+', 'cK-',
+ 'cV+', 'cV-',
+ 'cC');
+
+type
+ TSpyValue = class
+ Name: string;
+ Next: TSpyValue;
+ Context: TRegContext;
+ constructor Create(const Name: string; Context: TRegContext);
+ end;
+
+ TSisyThread = class;
+
+ TSpyKey = class
+ public
+ Parent: TSpyKey;
+ Name: string;
+ Next: TSpyKey;
+ Keys: TSpyKey;
+ Values: TSpyValue;
+ procedure Spy(AHKEY: HKEY; Sisy: TSisyThread);
+ function Path: string;
+ constructor Create(AParent: TSpyKey; AName: string);
+ destructor Destroy; override;
+ end;
+
+ TSisyChange = class
+ public
+ Typ: TSisyChangeType;
+ Path: string;
+ Old, New: TRegContext;
+ constructor Create(ATyp: TSisyChangeType; const APath: string;
+ AOldContext: TRegContext; ANewContext: TRegContext);
+ procedure ReportToPluto;
+ end;
+
+ TSisyChangeEvent = procedure (Sender: TSisyThread; Change: TSisyChange) of object;
+ TSisyThread = class(TThread)
+ private
+ Reg: TXRegistry;
+ Key: TSpyKey;
+ KeyHKEY: HKEY;
+ CurrentChange: TSisyChange;
+ FOnChange: TSisyChangeEvent;
+ FOnSpecialChanges: array[TSisyChangeType] of TSisyChangeEvent;
+ procedure FreeKey;
+ procedure IncKeyCount;
+ procedure IncKeyIndex;
+ function GetSpecialChange(ChangeType: TSisyChangeType): TSisyChangeEvent;
+ procedure SetSpecialChange(ChangeType: TSisyChangeType;
+ const Value: TSisyChangeEvent);
+ protected
+ procedure AddValueChange(Typ: TSisyChangeType; const Path: string;
+ Old, New: TRegContext);
+ procedure AddKeyChange(Typ: TSisyChangeType; const Path: string);
+ procedure Execute; override;
+ procedure ShowInfo;
+ procedure NotifyChange;
+ procedure ReportCurrentChange;
+ public
+ CurrentSpyKey: TSpyKey;
+ StatusLabel: TLabel;
+ Name: string;
+ Started: Boolean;
+ DoReport: Boolean;
+ SecsPerRound: Double;
+ InfoForShow: string;
+ OnStarted: TNotifyEvent;
+ KeyCount: Integer;
+ PrevKeyCount: Integer;
+ KeyIndex: Integer;
+ TheClock: TClock;
+ Uni: TUniKey;
+ MaxValueCountToScan, MaxKeyCountToScan, MaxDataLenToScan: Cardinal;
+ constructor CreateIt(const AName, AKeyName: string; AHKEY: HKEY;
+ ALabel: TLabel; AUniKey: TUniKey);
+ destructor Destroy; override;
+
+ property OnChange: TSisyChangeEvent read FOnChange write FOnChange;
+ property OnSpecialChange[ChangeType: TSisyChangeType]: TSisyChangeEvent
+ read GetSpecialChange write SetSpecialChange;
+ end;
+
+ TSisyList = class(TList)
+ protected
+ function GetSisy(Index: Integer): TSisyThread;
+ procedure PutSisy(Index: Integer; Sisy: TSisyThread);
+ public
+ procedure Suspend;
+ procedure Resume;
+ property Items[Index: Integer]: TSisyThread read GetSisy write PutSisy; default;
+ end;
+
+procedure SetSisyChangeState(Node: TTreeNode; Active: Boolean);
+function SisyChangeActivated(Node: TTreeNode): Boolean;
+
+var
+ SisyFilter: TStringList;
+
+implementation
+
+uses plutomain, workU, ValuesU;
+
+procedure SetSisyChangeState(Node: TTreeNode; Active: Boolean);
+begin
+ Node.Data := Pointer(not Active);
+end;
+
+function SisyChangeActivated(Node: TTreeNode): Boolean;
+begin
+ Result := Node.Data = Pointer(False);
+end;
+
+{ TSisyThread }
+
+constructor TSisyThread.CreateIt(const AName, AKeyName: string;
+ AHKEY: HKEY; ALabel: TLabel; AUniKey: TUniKey);
+begin
+ inherited Create(True); // Create thread suspended
+
+ Started := False;
+ DoReport := True;
+ KeyCount := 0;
+ FreeOnTerminate := False; // Thread frees itself not when terminated
+
+ KeyHKEY := AHKEY;
+ Name := AName;
+ StatusLabel := ALabel;
+ StatusLabel.Caption := 'Zzzzzzz...';
+
+ Reg := TXRegistry.Create;
+ TheClock := TClock.Create;
+
+ Uni := AUniKey.GetKey(Name);
+ Priority := TThreadPriority(Uni.ReadInteger('Priority', Integer(tpLowest)));
+ PrevKeyCount := Uni.ReadInteger('KeyCount', 0);
+
+ MaxKeyCountToScan := Cardinal(Uni.ReadInteger('ScanTuner: MaxKeys', -1));
+ MaxValueCountToScan := Cardinal(Uni.ReadInteger('ScanTuner: MaxValues', -1));
+ MaxDataLenToScan := Cardinal(Uni.ReadInteger('ScanTuner: MaxDataLen', -1));
+
+ Key := TSpyKey.Create(nil, AKeyName);
+end;
+
+procedure TSisyThread.FreeKey;
+begin
+ Reg.Free;
+ TheClock.Free;
+ Key.Free;
+end;
+
+destructor TSisyThread.Destroy;
+begin
+ Synchronize(FreeKey);
+ inherited;
+end;
+
+procedure TSisyThread.Execute;
+begin
+ InfoForShow := Name + ' initializing...';
+ Synchronize(ShowInfo);
+
+ TheClock.Restart;
+ Started := False;
+ while not Terminated do
+ try
+ KeyIndex := 0;
+
+ { ===================== }
+ Key.Spy(KeyHKEY, Self);
+ { ===================== }
+
+ if Terminated then
+ Continue; //= Exit
+
+ SecsPerRound := TheClock.SecondsPassed;
+ TheClock.Restart;
+ if not Started then begin
+ Started := True;
+ Uni.WriteInteger('KeyCount', KeyCount);
+ if Assigned(OnStarted) then
+ OnStarted(Self);
+ end;
+ except
+ ShowMessage('Error in Sisyphus');
+ end;
+end;
+
+procedure TSisyThread.AddValueChange(Typ: TSisyChangeType; const Path: string;
+ Old, New: TRegContext);
+
+ procedure TryNotify(Event: TSisyCHangeEvent);
+ begin
+
+ end;
+
+begin
+ if not (Started and DoReport) then
+ Exit;
+
+ CurrentChange := TSisyChange.Create(Typ, Path, Old, New);
+ Synchronize(ReportCurrentChange);
+ Synchronize(NotifyChange);
+
+// CurrentChange.Free; //this makes Pluto itself
+end;
+
+procedure TSisyThread.AddKeyChange(Typ: TSisyChangeType; const Path: string);
+begin
+ AddValueChange(Typ, Path, ZeroRegContext, ZeroRegContext);
+end;
+
+procedure TSisyThread.ShowInfo;
+begin
+ if Assigned(StatusLabel) then
+ StatusLabel.Caption := InfoForShow;
+end;
+
+procedure TSisyThread.ReportCurrentChange;
+begin
+ if Assigned(CurrentChange) then
+ CurrentChange.ReportToPluto;
+end;
+
+procedure TSisyThread.IncKeyCount;
+var
+ c: Integer;
+begin
+ if Started then
+ Exit;
+
+ Inc(KeyCount);
+
+ if (KeyCount and $1FF) = 0 then begin
+ if KeyCount > PrevKeyCount then
+ PrevKeyCount := KeyCount;
+
+ c := 0;
+ if PrevkeyCount > 0 then
+ c := Round((KeyCount * StatusPoints) / PrevKeyCount);
+ InfoForShow := '|' + MulStr('.', c) + MulStr(' ', StatusPoints - c) + '|' +
+ Format(' (%0.1f s) %d/%d k ',
+ [TheClock.SecondsPassed, KeyCount, PrevKeyCount]);
+
+ Synchronize(ShowInfo);
+ end;
+end;
+
+procedure TSisyThread.IncKeyIndex;
+var
+ c: Integer;
+begin
+ if not Started then
+ Exit;
+
+ Inc(KeyIndex);
+
+ if ((KeyIndex and $1FF) = 0) and (KeyCount > 0) then begin
+ if KeyIndex > KeyCount then
+ KeyCount := KeyIndex;
+
+ c := 0;
+ if KeyCount > 0 then
+ c := Round((KeyIndex * StatusPoints) / KeyCount);
+
+ InfoForShow := '|' + MulStr(':', c) + MulStr('.', StatusPoints - c) + '|' +
+ Format(' (%0.1f s) %d/%d k ', [SecsPerRound, KeyIndex, KeyCount]);
+
+ Synchronize(ShowInfo);
+ end;
+end;
+
+function TSisyThread.GetSpecialChange(ChangeType: TSisyChangeType):
+ TSisyChangeEvent;
+begin
+ Result := FOnSpecialChanges[ChangeType];
+end;
+
+procedure TSisyThread.SetSpecialChange(ChangeType: TSisyChangeType;
+ const Value: TSisyChangeEvent);
+begin
+ FOnSpecialChanges[ChangeType] := Value;
+end;
+
+procedure TSisyThread.NotifyChange;
+var
+ Event: TSisyChangeEvent;
+begin
+ Event := FOnSpecialChanges[CurrentChange.Typ];
+ if Assigned(Event) then
+ Event(Self, CurrentChange);
+
+ if Assigned(FOnChange) then
+ FOnChange(Self, CurrentChange);
+end;
+
+{ TSpyValue }
+
+constructor TSpyValue.Create(const Name: string; Context: TRegContext);
+begin
+ Self.Name := Name;
+ Next := nil;
+ Self.Context := Context;
+end;
+
+{ TSpyKey }
+
+constructor TSpyKey.Create(AParent: TSpyKey; AName: string);
+begin
+ Name := AName;
+ Parent := AParent;
+
+ Next := nil;
+ Keys := nil;
+ Values := nil;
+end;
+
+destructor TSpyKey.Destroy;
+var
+ Value, NextValue: TSpyValue;
+ Key, NextKey: TSpyKey;
+begin
+ Value := Values;
+ while Assigned(Value) do begin
+ NextValue := Value.Next;
+ Value.Free;
+ Value := NextValue;
+ end;
+
+ Key := Keys;
+ while Assigned(Key) do begin
+ NextKey := Key.Next;
+ Key.Free;
+ Key := NextKey;
+ end;
+
+ inherited;
+end;
+
+function TSpyKey.Path: string;
+begin
+ if Assigned(Parent) then
+ Result := Parent.Path + '\'
+ else
+ Result := '';
+
+ Result := Result + Name;
+end;
+
+procedure TSpyKey.Spy(AHKEY: HKEY; Sisy: TSisyThread);
+var
+ SL: TStringList;
+ LastKey: TSpyKey;
+
+ procedure CompareValues;
+ var
+ i: Integer;
+ Value, LastValue, NewValue, SearchValue, SearchValue_Prev: TSpyValue;
+ begin
+ //OK, this part is a little bit complicate. So I will comment very much.
+ //First, two terms are important:
+ //<REAL> means the list of values that will be read from the registry now:
+ Sisy.Reg.GetValueNames(SL);
+ if Cardinal(SL.Count) > Sisy.MaxValueCountToScan then
+ Exit;
+ //So <REAL> is TStringList.
+
+ //<CURRENT> means the image that was saved before.
+ //Here, it is a linear list of TSpyValue objects. That means that you can
+ //only get X.Next and not X.Prev! However, I use "X.Prev" to simplify
+ //some comments.
+
+ //!!! Comparing means: Make <CURRENT> fit <REAL> !!!
+
+ //If <CURRENT> wasn't saved before, it is just empty.
+
+ //!!! There is no difference in comparing and saving in this method !!!
+
+ //Building means: Comparing with an empty image.
+
+ //We go through <REAL> and make <CURRENT> fit it
+
+ //The following rules are important:
+ //Value = "The currently interesting value.
+ //LastValue = "The value with X.Next = Value" = "Value.Pref"
+
+ LastValue := nil; // := "Values.Prev"
+ Value := Values; // := "LastValue.Next"
+
+ //Now compare step by step
+ for i := 0 to SL.Count-1 do begin
+ if Assigned(Value) and (SL[i] = Value.Name) then begin
+ //cV= Normally (0.9999) everything's the same
+ LastValue := Value;
+ Value := Value.Next;
+ end else begin //Something's different? Yes, the IMPORTANT rest (0.0001))
+ //Because the list finally must exactly fit SL, the "SL[i] value" hast
+ //to be inserted right here. But first let's look...
+
+ //Maybe it was just moved? So search for it...
+ NewValue := nil;
+ if Assigned(Value) then begin
+ SearchValue_Prev := Value;
+ SearchValue := Value.Next;
+ while Assigned(SearchValue) do begin
+ if SearchValue.Name = SL[i] then begin //we found our moved value
+ SearchValue_Prev.Next := SearchValue.Next; //delete it from <CURRENT>
+ NewValue := SearchValue; //save that we found it
+ Break end;
+ SearchValue_Prev := SearchValue;
+ SearchValue := SearchValue.Next;
+ end;
+ end;
+
+ if not Assigned(NewValue) then begin
+ //cV+ No, not found! So it is new...
+ NewValue := TSpyValue.Create(SL[i], Sisy.Reg.ReadContext(SL[i]));
+ { ================ cV+ ================ }
+ if Sisy.Started and Sisy.Reg.ValueReallyExists(SL[i]) then
+ Sisy.AddValueChange(cValuePlus, Path + '\\' + NewValue.Name,
+ ZeroRegContext, NewValue.Context);
+ end;
+
+ //The new object now must be placed after the last value
+ if Assigned(LastValue) then
+ LastValue.Next := NewValue
+ else
+ //If it's the first value, we don't have LastValue defined
+ //So we have to set the "Root" to it
+ Values := NewValue;
+
+ //Now the rest of <CURRENT> has to be placed after the new value
+ NewValue.Next := Value;
+ //And LastValue also has to refreshed: It is "Value.Pref" = NewValue!
+ LastValue := NewValue;
+ end;
+ end;
+
+ //Because the whole <CURRENT> before Value is exactly <REAL>, the rest
+ //(if there is one) must have been deleted!
+
+ //So first let's ensure that <CURRENT> ends here:
+ if Assigned(LastValue) then
+ LastValue.Next := nil
+ else
+ //Another time: <CURRENT> is empty now, so set Values instead
+ Values := nil;
+
+ //Now, the first value that maybe was "cut" off is Value:
+ while Assigned(Value) do begin
+ //cV- So, here really something HAS been deleted
+ LastValue := Value;
+ Value := Value.Next;
+ { ================ cV- ================ }
+ if Sisy.Started and not Sisy.Reg.ValueReallyExists(LastValue.Name) then
+ Sisy.AddValueChange(cValueMinus, Path + '\\' + LastValue.Name,
+ LastValue.Context, ZeroRegContext);
+ LastValue.Free;
+ end;
+ end;
+
+ procedure CompareData;
+ var
+ Value: TSpyValue;
+ Context: TRegContext;
+ Size: Cardinal;
+ begin
+ Context := ZeroRegContext; //Initialize
+ //So, finally <CURRENT> = <REAL>. That means we now can compare the data:
+ Value := Values;
+ while Assigned(Value) and not Sisy.Terminated do begin
+ Size := Sisy.Reg.GetDataSize(Value.Name);
+ if (Size = Cardinal(-1)) or
+ (Size <= Sisy.MaxDataLenToScan) then begin
+ Context := Sisy.Reg.ReadContext(Value.Name);
+ if not SameContext(Context, Value.Context) then begin
+ { ================ cC ================ }
+ Sisy.AddValueChange(cContextChange, Path + '\\' + Value.Name,
+ Value.Context, Context);
+ Value.Context := Context;
+ end;
+ end;
+
+ Value := Value.Next;
+ end;
+ end;
+
+ procedure CompareKeys;
+ var
+ i: Integer;
+ Key, LastKey, NewKey, SearchKey, SearchKey_Prev: TSpyKey;
+ SavedDoReport: Boolean;
+ NewHKEY: HKEY;
+ begin
+ //OK, this part is a little bit complicate. So I will comment very much.
+ //First, two terms are important:
+ //<REAL> means the list of keys that will be read from the registry now:
+
+ Sisy.Reg.GetKeyNames(SL);
+ if Cardinal(SL.Count) > Sisy.MaxKeyCountToScan then
+ Exit;
+ //So <REAL> is TStringList.
+
+ //<CURRENT> means the image that was saved before.
+ //Here, it is a linear list of TSpyKey objects. That means that you can
+ //only get X.Next and not X.Prev! However, I use "X.Prev" to simplify
+ //some comments.
+
+ //!!! Comparing means: Make <CURRENT> fit <REAL> !!!
+
+ //If <CURRENT> wasn't saved before, it is just empty.
+
+ //!!! There is no difference in comparing and saving in this method !!!
+
+ //Building means: Comparing with an empty image.
+
+ //We go through <REAL> and make <CURRENT> fit it
+
+ //The following rules are important:
+ //Key = "The currently interesting key.
+ //LastKey = "The key with X.Next = Key" = "Key.Pref"
+
+ LastKey := nil; // := "Keys.Prev"
+ Key := Keys; // := "LastKey.Next"
+
+ //Now compare step by step
+ for i := 0 to SL.Count-1 do begin
+ if Assigned(Key) and (SL[i] = Key.Name) then begin
+ //cK= Normally (0.9999) everything's the same
+ if Success(RegOpenKey(AHKEY, PChar(SL[i]), NewHKEY)) then
+ try
+ Key.Spy(NewHKEY, Sisy);
+ finally
+ RegCloseKey(NewHKEY);
+ end;
+ if Sisy.Terminated then
+ Exit;
+
+ LastKey := Key;
+ Key := Key.Next;
+ end else begin //Something's different? Yes, the IMPORTANT rest (0.0001))
+ //Because the list finally must exactly fit SL, the "SL[i] key" has
+ //to be inserted right here. But first let's look...
+
+ //Maybe it was just moved? So search for it...
+ NewKey := nil;
+ if Assigned(Key) then begin
+ SearchKey_Prev := Key;
+ SearchKey := Key.Next;
+ while Assigned(SearchKey) do begin
+ if SearchKey.Name = SL[i] then begin //we found our moved key
+ SearchKey_Prev.Next := SearchKey.Next; //delete it from <CURRENT>
+ NewKey := SearchKey; //save that we found it
+ Break end;
+ SearchKey_Prev := SearchKey;
+ SearchKey := SearchKey.Next;
+ end;
+ end;
+
+ if not Assigned(NewKey) then begin //if we didn't find it
+ //cK+ No, not found! So it is new...
+ NewKey := TSpyKey.Create(Self, SL[i]);
+ Sisy.IncKeyCount;
+ Sisy.Reg.CurrentKey := AHKEY;
+ { ================ cK+ ================ }
+ if Sisy.Started and Sisy.Reg.KeyExists(SL[i]) then
+ Sisy.AddKeyChange(cKeyPlus, Path + '\' + NewKey.Name);
+
+ SavedDoReport := Sisy.DoReport;
+ if Success(RegOpenKey(AHKEY, PChar(SL[i]), NewHKEY)) then
+ try
+ Sisy.DoReport := False;
+ NewKey.Spy(NewHKEY, Sisy); //<-- recursion itself
+ finally
+ RegCloseKey(NewHKEY);
+ Sisy.DoReport := SavedDoReport;
+ end;
+
+ if Sisy.Terminated then
+ Exit;
+ end;
+
+ //The new key now must be placed after the last key
+ if Assigned(LastKey) then
+ LastKey.Next := NewKey
+ else
+ //If it's the first key, we don't have LastKey defined
+ //So we have to set the "Root" to it
+ Keys := NewKey;
+
+ //Now the rest of <CURRENT> has to be placed after the new key
+ NewKey.Next := Key;
+ //And LastKey also has to refreshed: It is "Key.Pref" = NewKey!
+ LastKey := NewKey;
+ end;
+ end;
+
+ //Because the whole <CURRENT> before Key is exactly <REAL>, the rest
+ //(if there is one) must have been deleted!
+
+ //So first let's ensure that <CURRENT> ends here:
+ if Assigned(LastKey) then
+ LastKey.Next := nil
+ else
+ //Another time: <CURRENT> is empty now, so set Keys instead
+ Keys := nil;
+
+ //Now, the first key that maybe was "cut" off is Key:
+ while Assigned(Key) do begin
+ //cV- So, here really something HAS been deleted
+ LastKey := Key;
+ Key := Key.Next;
+ Sisy.Reg.CurrentKey := AHKEY;
+ { ================ cK- ================ }
+ if Sisy.Started and not Sisy.Reg.KeyExists(LastKey.Name) then
+ Sisy.AddKeyChange(cKeyMinus, Path + '\' + LastKey.Name);
+ LastKey.Free;
+ end;
+ end;
+
+
+begin
+ if Sisy.Terminated or (AHKEY = 0) then
+ Exit;
+ LastKey := Sisy.CurrentSpyKey;
+ Sisy.CurrentSpyKey := Self;
+
+ Sisy.IncKeyIndex;
+
+ SL := TStringList.Create;
+ try
+ Sisy.Reg.CurrentKey := AHKEY;
+ CompareValues;
+ if Sisy.Started then CompareData;
+ CompareKeys;
+ finally
+ Sisy.Reg.CurrentKey := 0;
+ SL.Free;
+ Sisy.CurrentSpyKey := LastKey;
+ end;
+end;
+
+{ TSisyChange }
+
+constructor TSisyChange.Create(ATyp: TSisyChangeType; const APath: string;
+ AOldContext: TRegContext; ANewContext: TRegContext);
+begin
+ inherited Create;
+ Typ := ATyp;
+ Path := APath;
+ Old := AOldContext;
+ New := ANewContext;
+end;
+
+procedure TSisyChange.ReportToPluto;
+var
+ Node, RootNode: TTreeNode;
+ Root, SubPath: string;
+ NewNode: Boolean;
+ i: Integer;
+
+ function IconOfSisyChangeType(Typ: TSisyChangeType): Integer;
+ begin
+ Result := -1;
+ case Typ of
+ //cNone, cError: Result := -1;
+ cKeyPlus..cContextChange: Result := Integer(Typ) - 2;
+ end;
+ end;
+
+ function FindNode(Text: string): TTreeNode;
+ begin
+ Result := WorkWin.SisyTV.Items.GetFirstNode;
+ while Assigned(Result) do begin
+ if SameText(Result.Text, Text) then
+ Exit;
+ Result := Result.GetNextSibling;
+ end;
+ end;
+
+begin
+ if not WorkWin.SisyListCB.Checked then
+ Exit;
+
+ if Typ in [cContextChange, cValueMinus, cValuePlus] then begin
+ Root := ExRegFullKey(Path);
+ SubPath := ExRegValue(Path);
+ end else begin
+ Root := UntilLastChar(ExRegFullKey(Path), '\');
+ SubPath := FromLastChar(ExRegFullKey(Path), '\');
+ end;
+
+ with WorkWin do
+ for i := 0 to SisyFilter.Count-1 do begin
+ if TextAtPos(Root, 1, SisyFilter[i]) then begin
+ //show that it's working
+ with FilterChangesB do begin
+ Caption := 'Filter..!';
+ Repaint;
+ Caption := 'Filter...';
+ Repaint;
+ end;
+ Exit; end;
+ end;
+
+ with WorkWin.SisyTV.Items do begin
+ BeginUpdate;
+ try
+ RootNode := FindNode(Root);
+ NewNode := not Assigned(RootNode);
+ if NewNode then begin
+ RootNode := AddChild(nil, Root);
+ RootNode.ImageIndex := iconGroup;
+ end else if not SisyChangeActivated(RootNode) then begin
+ EndUpdate;
+ Exit end;
+
+ Node := AddChildObject(RootNode, SubPath, Self);
+ Node.ImageIndex := IconOfSisyChangeType(Typ);
+ if Typ = cContextChange then begin
+ AddChild(Node, DataPreviewOfContext(Old)).ImageIndex := iconOldContext;
+ AddChild(Node, DataPreviewOfContext(New)).ImageIndex := iconNewContext;
+ end;
+ finally
+ EndUpdate;
+ end;
+ end;
+
+ if NewNode and WorkWin.SisyExpandGroupsCB.Checked then
+ RootNode.Expand(False);
+
+ if not RootNode.Expanded then
+ RootNode.ImageIndex := iconGroupBlinking;
+end;
+
+{ TSisyList }
+
+function TSisyList.GetSisy(Index: Integer): TSisyThread;
+begin
+ Result := Get(Index);
+end;
+
+procedure TSisyList.PutSisy(Index: Integer; Sisy: TSisyThread);
+begin
+ Put(Index, Sisy);
+end;
+
+procedure TSisyList.Resume;
+var
+ i: Integer;
+begin
+ for i := 0 to Count-1 do
+ Items[i].Resume;
+end;
+
+procedure TSisyList.Suspend;
+var
+ i: Integer;
+begin
+ for i := 0 to Count-1 do
+ Items[i].Resume;
+end;
+
+initialization
+ SisyFilter := TStringList.Create;
+ SisyFilter.Sorted := True;
+ SisyFilter.Duplicates := dupIgnore;
+
+finalization
+ SisyFilter.Free;
+
+end.
+unit splash;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
+ ExtCtrls, StdCtrls, ImgList, YTools, IniFiles, LinkLabel, PrefTools,
+ PlutoConst;
+
+type
+ TSplashWin = class(TForm)
+ Image1: TImage;
+ StartB: TButton;
+ SplashScreenCB: TPrefCheckBox;
+ LinkLabel1: TLinkLabel;
+ LinkLabel2: TLinkLabel;
+ LogoL: TLabel;
+ procedure StartBClick(Sender: TObject);
+ procedure FormShow(Sender: TObject);
+ procedure FormCreate(Sender: TObject);
+ procedure FormHide(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+ procedure SplashScreenCBClick(Sender: TObject);
+ end;
+
+var
+ SplashWin: TSplashWin;
+
+implementation
+
+uses plutomain, TreeU, WorkU, PrefU;
+
+{$R *.DFM}
+
+procedure TSplashWin.StartBClick(Sender: TObject);
+begin
+ Close;
+end;
+
+procedure TSplashWin.FormShow(Sender: TObject);
+const
+ Messages: array[0..12] of string = ('Let''s see...',
+ 'Ready',
+ 'Hello World!',
+ 'Start',
+ 'OK',
+ 'Pluto!',
+ 'Go Go Go',
+ 'Everything''s OK',
+ 'Yes!',
+ 'God save the Queen',
+ 'Oh yeah',
+ 'Yabadabadoo!',
+ 'Don''t worry, be happy!'
+ );
+var
+ ImageFile: string;
+begin
+ Left := (Screen.Width - Width) div 2;
+ Top := (Screen.Height - Height) div 2;
+
+ StartB.Caption := Messages[Random(Length(Messages))];
+ SplashWin.SplashScreenCB.Load;
+
+ Caption := 'cYcnus.Pluto ' + Version + ' says ' + MainWin.Greeting;
+
+ try
+ ImageFile := PlutoDir + 'logo deluxe.bmp';
+ if FileEx(ImageFile) then begin
+ with Image1.Picture do
+ if Graphic = nil then
+ LoadFromFile(ImageFile);
+ if not Switch('MurphyMode') then
+ LogoL.Visible := False;
+ Exit;
+ end;
+
+ ImageFile := PlutoDir + 'logo.bmp';
+ if FileEx(ImageFile) then begin
+ with Image1.Picture do
+ if Graphic = nil then
+ LoadFromFile(ImageFile);
+ end;
+ except
+ ShowMessage('Could not load Splash Screen image!');
+ end;
+end;
+
+procedure TSplashWin.FormCreate(Sender: TObject);
+begin
+ Hide;
+ Randomize;
+end;
+
+procedure TSplashWin.FormHide(Sender: TObject);
+begin
+ //Image1.Picture.Bitmap.FreeImage;
+end;
+
+procedure TSplashWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if Key = VK_ESCAPE then
+ Close;
+end;
+
+procedure TSplashWin.SplashScreenCBClick(Sender: TObject);
+begin
+ if Started then
+ PrefWin.SplashScreenCB.Checked := SplashScreenCB.Checked;
+end;
+
+end.
+unit SpyTH;
+
+interface
+
+uses
+ Classes, Windows, Dialogs, ComCtrls, CompEx, SysUtils, YTools, clock,
+ plutoconst, StdCtrls, forms, XReg, stringcomp;
+
+type
+ TChildren = array of TTreeNode;
+
+ TRegSpyThread = class(TThread)
+ private
+ Reg: TXRegistry;
+ CurNode: TTreeNode;
+ Dead: Boolean;
+ Dif: TSLComp;
+ CurChildren: TChildren;
+ protected
+ procedure Execute; override;
+
+ procedure SaveCheckNode;
+ procedure SaveGetDif;
+ procedure SaveDeleteDead;
+ procedure SaveGetChildren;
+ procedure SaveAddNew;
+ public
+ Restart: Boolean;
+ Mess: string;
+ Delay: Integer;
+ function Alive(Node: TTreeNode): Boolean;
+ procedure Spy;
+ procedure Reload(Node: TTreeNode);
+ procedure ReloadValues;
+ procedure AddTrace(Trace: string);
+ constructor CreateIt(PriorityLevel: TThreadPriority);
+ destructor Destroy; override;
+ end;
+
+implementation
+
+uses plutomain, TreeU, WorkU, ValuesU;
+
+{ TRegSpyThread }
+
+constructor TRegSpyThread.CreateIt(PriorityLevel: TThreadPriority);
+begin
+ inherited Create(True); // Create thread suspended
+ Priority := PriorityLevel; // Set Priority Level
+ FreeOnTerminate := False; // Thread frees itself when terminated
+ Reg := TXRegistry.Create;
+ Delay := 100;
+end;
+
+procedure TRegSpyThread.Execute;
+begin
+ while not Terminated do begin
+ Restart := False;
+ try
+ if not Terminated then
+ Sleep(Delay);
+ if not Terminated then
+ Spy;
+ except end;
+ end;
+end;
+
+function TRegSpyThread.Alive(Node: TTreeNode): Boolean;
+begin
+ Result := False;
+
+ if Restart then
+ Exit;
+
+ if Terminated then
+ Exit;
+
+ if Assigned(Node) then
+ try
+ if (Node.Text = '') then
+ Exit;
+
+ if not Assigned(Node) then
+ Exit;
+
+ Result := True;
+ except
+ Exit;
+ end;
+end;
+
+procedure TRegSpyThread.SaveCheckNode;
+begin
+ Dead := not Alive(CurNode);
+ if Dead then
+ Exit;
+
+ CheckNode(CurNode, False);
+end;
+
+procedure TRegSpyThread.SaveGetDif;
+var
+ Real, Cur: TStringList;
+begin
+ Dead := not Alive(CurNode);
+ if Dead then
+ Exit;
+
+ dif := nil;
+
+ if not CurNode.Expanded then begin
+ Dead := True;
+ Exit; end;
+
+ if not OpenNodeOK(Reg, CurNode) then
+ Exit;
+
+ Real := TStringList.Create;
+
+ Reg.GetKeyNames(Real);
+ Reg.CloseKey;
+
+ Cur := GetChildNames(CurNode);
+
+ if (Cur.Count = 0) and (Real.Count = 0) then
+ Dead := True;
+
+ dif := TSLComp.Create(Cur, Real, False);
+
+ Cur.Free;
+ Real.Free;
+end;
+
+procedure TRegSpyThread.SaveDeleteDead;
+var
+ TN: TTreeNode;
+ i: Integer;
+begin
+ Dead := not Alive(CurNode);
+ if Dead then
+ Exit;
+
+ if not Assigned(dif) or not Assigned(dif.OnlyA) then
+ Exit;
+
+ if CurNode.Expanded then
+ for i := 0 to dif.OnlyA.Count-1 do begin
+ TN := FindNode(CurNode, dif.OnlyA[i]);
+ if Assigned(TN) then begin
+ RegTV.Selected := GetNextBest(TN);
+ TN.Delete;
+ AddTrace('Key deleted: ' + dif.OnlyA[i]);
+ end;
+ end
+ else
+ Exit;
+end;
+
+procedure TRegSpyThread.SaveGetChildren;
+var
+ i: Integer;
+ TN: TTreeNode;
+begin
+ Dead := not Alive(CurNode);
+ if Dead then
+ Exit;
+
+ CurChildren := nil;
+ SetLength(CurChildren, CurNode.Count);
+
+ i := 0;
+ TN := CurNode.GetFirstChild;
+ while Assigned(TN) do begin
+ if i <= High(CurChildren) then
+ CurChildren[i] := TN
+ else
+ ShowMessage('Error: Too much children');
+ Inc(i);
+ TN := CurNode.GetNextChild(TN)
+ end;
+end;
+
+procedure TRegSpyThread.SaveAddNew;
+var
+ i: Integer;
+begin
+ Dead := not Alive(CurNode);
+ if Dead then
+ Exit;
+
+ if not Assigned(Dif) or not Assigned(Dif.OnlyB) or (Dif.OnlyB.Count = 0) then
+ Exit;
+
+ for i := 0 to Dif.OnlyB.Count-1 do begin //Erstellt/hinbenannt
+ RegTV.Items.AddChild(CurNode, Dif.OnlyB[i]);
+ AddTrace('New Key: ' + dif.OnlyB[i]);
+ MainWin.StatusBarUpdate;
+ //AddHint('Neuer Schlüssel: ' + CurNode.Text + '\' + Dif.OnlyB[i]);
+ end;
+end;
+
+procedure TRegSpyThread.Reload(Node: TTreeNode);
+var
+ i: Integer;
+ TN: TTreeNode;
+ zCurNode: TTreeNode;
+ MyChildren: TChildren;
+begin
+ if Terminated or Restart then
+ Exit;
+
+ CurNode := Node;
+
+ zCurNode := CurNode;
+ try
+ //Mess := 'SaveCheckNode';
+ Synchronize(SaveCheckNode);
+ if Dead or Terminated then
+ Exit;
+
+ //Mess := 'SaveGetDif';
+ Synchronize(SaveGetDif);
+ if Dead or Terminated then
+ Exit;
+
+ //Mess := 'SaveDeleteDead';
+ Synchronize(SaveDeleteDead);
+ if Dead or Terminated then
+ Exit;
+
+ //Mess := 'SaveGetChildren';
+ Synchronize(SaveGetChildren);
+ if Dead or Terminated then
+ Exit;
+
+ //Mess := 'SaveGetChildren';
+ Synchronize(SaveAddNew);
+ if Dead or Terminated then
+ Exit;
+
+ Dif.Free;
+
+ //Mess := 'MyChildren';
+ SetLength(MyChildren, Length(CurChildren));
+ for i := 0 to High(MyChildren) do
+ MyChildren[i] := CurChildren[i];
+
+ for i := 0 to High(MyChildren) do begin
+ TN := MyChildren[i];
+ if Alive(TN) then
+ //if TN.Expanded then
+ //if NodeVisible(TN) then
+ Reload(TN);
+ //else
+ //Break;
+ if Restart or Terminated then
+ Break;
+ end;
+ MyChildren := nil;
+
+ except
+ if Terminated then
+ Exit;
+ AddHint('Error in Spy: ' + Mess);
+ WorkWin.Label7.Caption := 'ERROR';
+ end;
+ CurNode := zCurNode;
+end;
+
+function FindItemByRealName(LV: TListView; Text: string): TListItem;
+var
+ i: Integer;
+begin
+ Result := nil;
+ for i := 0 to LV.Items.Count-1 do
+ if LV.Items[i].Caption = Text then begin
+ Result := LV.Items[i];
+ Exit; end;
+ for i := 0 to LV.Items.Count-1 do
+ if SameText(RealValueName(LV.Items[i]), Text) then begin
+ Result := LV.Items[i];
+ Break; end;
+end;
+
+procedure TRegSpyThread.ReloadValues;
+var
+ Item: TListItem;
+ Real, Cur: TStringList;
+ Dif: TSLComp;
+ i: integer;
+begin
+ if Terminated or Restart then
+ Exit;
+
+ if not OpenNodeOK(Reg, RegTV.Selected) then
+ Exit;
+
+ Real := TStringList.Create;
+ Reg.GetValueNames(Real);
+
+ Cur := TStringList.Create;
+ with ValueList.Items do
+ for i := 0 to Count-1 do
+ Cur.Add(RealValueName(Item[i]));
+
+ Dif := TSLComp.Create(Cur, Real, False);
+ Real.Free;
+ Cur.Free;
+
+ for i := 0 to Dif.OnlyA.Count-1 do begin //Gelöscht/wegbenannt
+ Item := FindItemByRealName(ValueList, Dif.OnlyA[i]);
+ if Assigned(Item) then begin
+ Item.Delete;
+ AddTrace('Value deleted: ' + Dif.OnlyA[i]);
+ end;
+ end;
+
+ for i := 0 to ValueList.Items.Count-1 do begin //Daten
+ Item := ValueList.Items[i];
+ {if Item.SubItems.Count < 2 then begin
+ ShowMessage('Fehler in Sync.');
+ Exit end; }
+ if ValuesWin.UpdateValue(Reg, Item) then
+ AddTrace('Value Changed: ' + Item.Caption + ' = ' +
+ ValueDataPreview(Reg.ReadContext(RealValueName(Item))));
+ end;
+
+ for i := 0 to dif.OnlyB.Count-1 do begin //Erstellt/hinbenannt
+ ValuesWin.AddValue(Reg, dif.OnlyB[i]);
+ AddTrace('New Value: ' + Dif.OnlyB[i]);
+ end;
+
+ Reg.CloseKey;
+ Dif.Free;
+end;
+
+procedure TRegSpyThread.Spy;
+var
+ i: Integer;
+ a: Real;
+begin
+ with TClock.Create do begin
+ for i := 0 to RootNodes.Count-1 do
+ Reload(TTreeNode(RootNodes[i]));
+ for i := 0 to High(Shortcuts) do
+ Reload(Shortcuts[i].Node);
+ Synchronize(ReloadValues);
+ a := SecondsPassed * 1000;
+ Free; end;
+
+ if a > 0 then
+ WorkWin.Label7.Caption := 'Spy: ' + Format('%0.2f', [a]) + ' s';
+end;
+
+procedure TRegSpyThread.AddTrace(Trace: string);
+begin
+ with WorkWin do
+ if ListTracesCB.Checked then
+ SpyLB.Items.Add(Trace);
+end;
+
+destructor TRegSpyThread.Destroy;
+begin
+ Dif.Free;
+ Reg.Free;
+ inherited;
+end;
+
+end.
+unit TreeU;
+{$DEFINE UNIKEY}
+{$DEFINE CYCFS}
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+ ComCtrls, Menus, Clipbrd, keybrd, Dialogs, YTools, PlutoConst, CompEx,
+ IniFiles, XReg, Colors, Clock,
+ ToolWin, RegFiles {$IFDEF UNIKEY}, UniKey, ImgList {$ENDIF};
+
+type
+ TTreeWin = class(TForm)
+ RegTVPU: TPopupMenu;
+ NewSubKeyMI: TMenuItem;
+ NewKeyMI: TMenuItem;
+ CreateShortcutMI: TMenuItem;
+ TraceMI: TMenuItem;
+ N3: TMenuItem;
+ DeleteMI: TMenuItem;
+ DublicateMI: TMenuItem;
+ N4: TMenuItem;
+ FindMI: TMenuItem;
+ RegTV: TTreeView;
+ PastePathMI: TMenuItem;
+ N1: TMenuItem;
+ InsertPathMI: TMenuItem;
+ RenameMI: TMenuItem;
+ CopyPathMI: TMenuItem;
+ CutPathMI: TMenuItem;
+ EditShortcutMI: TMenuItem;
+ N2: TMenuItem;
+ Export1: TMenuItem;
+ SubKeylist1: TMenuItem;
+ ValueNameslist1: TMenuItem;
+ KeyInfosMI: TMenuItem;
+ N5: TMenuItem;
+ ExportAsReg: TMenuItem;
+ ExportD: TSaveDialog;
+ procedure FormCreate(Sender: TObject);
+ procedure RegTVClick(Sender: TObject);
+ procedure RegTVChange(Sender: TObject; Node: TTreeNode);
+ procedure RegTVChanging(Sender: TObject; Node: TTreeNode; var AllowChange: Boolean);
+ procedure RegTVCollapsing(Sender: TObject; Node: TTreeNode; var AllowCollapse: Boolean);
+ procedure RegTVCustomDrawItem(Sender: TCustomTreeView; Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean);
+ procedure RegTVDblClick(Sender: TObject);
+ procedure RegTVDeletion(Sender: TObject; Node: TTreeNode);
+ procedure RegTVDragDrop(Sender, Source: TObject; X, Y: Integer);
+ procedure RegTVDragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
+ procedure RegTVEdited(Sender: TObject; Node: TTreeNode; var S: String);
+ procedure RegTVEditing(Sender: TObject; Node: TTreeNode; var AllowEdit: Boolean);
+ procedure RegTVEndDrag(Sender, Target: TObject; X, Y: Integer);
+ procedure RegTVEnter(Sender: TObject);
+ procedure RegTVExpanded(Sender: TObject; Node: TTreeNode);
+ procedure RegTVExpanding(Sender: TObject; Node: TTreeNode; var AllowExpansion: Boolean);
+ procedure RegTVGetSelectedIndex(Sender: TObject; Node: TTreeNode);
+ procedure RegTVKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure RegTVMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
+ procedure RegTVStartDrag(Sender: TObject; var DragObject: TDragObject);
+
+ function CreateKey(Subkey: Boolean): Boolean;
+ procedure CloneKey;
+ procedure DeleteKey;
+ procedure NewShortcut;
+ procedure MoveKey(const Src, Trg: TRegPath; CopyWanted: Boolean);
+ procedure MoveValues(SrcNode, TrgNode: TTreeNode; CopyWanted: Boolean);
+
+ procedure NewSubKeyMIClick(Sender: TObject);
+ procedure NewKeyMIClick(Sender: TObject);
+ procedure CreateShortcutMIClick(Sender: TObject);
+ procedure TraceMIClick(Sender: TObject);
+ procedure DeleteMIClick(Sender: TObject);
+ procedure DublicateMIClick(Sender: TObject);
+ procedure FindMIClick(Sender: TObject);
+ procedure RegTVPUPopup(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure RegTVKeyPress(Sender: TObject; var Key: Char);
+ procedure RegTVAdvancedCustomDrawItem(Sender: TCustomTreeView;
+ Node: TTreeNode; State: TCustomDrawState; Stage: TCustomDrawStage;
+ var PaintImages, DefaultDraw: Boolean);
+ procedure RenameMIClick(Sender: TObject);
+ procedure CopyPathMIClick(Sender: TObject);
+ procedure InsertPathMIClick(Sender: TObject);
+ procedure RegTVGetImageIndex(Sender: TObject; Node: TTreeNode);
+ procedure CheckRegTVHotTrack;
+ procedure PasteKeyMIClick(Sender: TObject);
+ procedure CutPathMIClick(Sender: TObject);
+
+ procedure OpenNextLevel(Node: TTreeNode);
+ procedure EditShortcutMIClick(Sender: TObject);
+ procedure SubKeylist1Click(Sender: TObject);
+ procedure ValueNameslist1Click(Sender: TObject);
+ procedure KeyInfosMIClick(Sender: TObject);
+ function GetKeyInfos: string;
+ procedure ExportAsRegClick(Sender: TObject);
+ procedure FormClose(Sender: TObject; var Action: TCloseAction);
+
+ procedure Load;
+ procedure Reg4WriterTerminate(Sender: TObject);
+ private
+ DragNode: TTreeNode;
+ NoAsterisk: Boolean; //To prevent NumPadMULTIPLY and asterisk errors
+ UserCopyKeyFlag: Boolean;
+ SpaceCount: Integer; //EasterEgg
+ public
+ CantWrite: Boolean;
+ DoSmartExpand: Boolean;
+ end;
+
+procedure CheckNode(Node: TTreeNode; OnlyOnce: Boolean = True;
+ TakeNodeSelected: Boolean = False);
+
+function AddShortcut(Alias, RealPath: string; Icon: Integer;
+ AHostType: TUniHostType = uhUserShortcut; WriteIni: Boolean = False): TTreeNode;
+function ShortcutIndex(Node: TTreeNode): Integer;
+
+function TraceKey(const Path: string; AllowedShortcutTypes: TUniHostTypes =
+ uhNonSystemShortcuts): string;
+
+type
+ TOpenNodeMode = (onNodeNil, onError, onReadOnly, onFull);
+
+const
+ onOK = [onFull, onReadOnly];
+
+function OpenNode(Reg: TXRegistry; Node: TTreeNode): TOpenNodeMode;
+function OpenNodeOK(Reg: TXRegistry; Node: TTreeNode): Boolean;
+function OpenCurKey: Boolean;
+function OpenCurParent: Boolean;
+
+var
+ TreeWin: TTreeWin;
+
+ RegTV: TTreeView; //Shortcut for other units, equals TreeWin.RegTV
+
+{$IFDEF UNIKEY}
+ UserUniPath: string {$IFDEF CYCFS} = 'cYcFS <y:\programme\cYcFS\test>'{$ENDIF};
+{$ENDIF}
+ Shortcuts: TShortcutA;
+ RootNodes: TList; //list of TTreeNode;
+
+implementation
+
+uses
+ PlutoMain, ValuesU, FindWinU, WorkU, PrefU, ShellEx, Types;
+
+{$R *.dfm}
+
+{$IFDEF UNIKEY}
+function UniOfNode(Node: TTreeNode): TUniKey;
+var
+ UniPath: TUniPath;
+begin
+ UniPath := UniOfStr(UserUniPath);
+ UniPath.Path := Join(Copy(NodePath(Node), 1, MaxInt), '/');
+ Result := TUniKey.CreateU(UniPath, reTryToSolve);
+end;
+{$ENDIF}
+
+procedure TTreeWin.FormCreate(Sender: TObject);
+begin
+ TreeU.RegTV := RegTV;
+
+ DragNode := nil;
+ NoAsterisk := False;
+ DoSmartExpand := True;
+ UserCopyKeyFlag := True;
+ SpaceCount := 0; //EasterEgg
+
+ RegTV.Items.Clear;
+ CheckRegTVHotTrack;
+
+ KeyInfosMI.ImageIndex := iconKeyInfos;
+
+ NewSubKeyMI.ImageIndex := iconSubKey;
+ NewKeyMI.ImageIndex := iconKey;
+ CreateShortcutMI.ImageIndex := iconShortcut;
+
+ RenameMI.ImageIndex := iconRename;
+ DeleteMI.ImageIndex := iconDelete;
+ DublicateMI.ImageIndex := iconKeyDublicate;
+
+ FindMI.ImageIndex := iconKeyFind;
+ TraceMI.ImageIndex := iconKeyTrace;
+end;
+
+procedure TTreeWin.RegTVClick(Sender: TObject);
+begin
+ if KeyIsDown(VK_CONTROL) then begin
+ TraceMIClick(Sender);
+ Exit; end;
+end;
+
+procedure TTreeWin.RegTVChange(Sender: TObject; Node: TTreeNode);
+var
+ Reg: TXRegistry;
+ OpenRe: TOpenNodeMode;
+
+{$IFDEF UNIKEY}
+ Uni: TUniKey;
+ ValueNames: TStringList;
+ Item: TListItem;
+ i: Integer;
+
+ procedure AppendSubItemData(SubItems: TStrings; Uni: TUniKey;
+ const ValueName: string);
+ var
+ SL: TStringList;
+
+ procedure Add(const s: string);
+ begin
+ SubItems.Append(s);
+ end;
+
+ begin
+ SL := nil;
+ try
+ Add('beta');
+
+ case Uni.GetDataType(ValueName) of
+
+ udString, udExpandString: begin
+ Add('String');
+ Add(Uni.ReadString(ValueName));
+ end;
+
+ udCardinal, udCardBigEndian, udInteger: begin
+ Add('Numeric');
+ Add(IntToStr(Uni.ReadInteger(ValueName)));
+ end;
+
+ udBinary, udNone: begin
+ Add('Binary');
+ Add(FriendlyStr(Uni.ReadBinary(ValueName)));
+ end;
+
+ udBoolean: begin
+ Add('Boolean');
+ Add(StrOfBool(Uni.ReadBool(ValueName)));
+ end;
+
+ udStringList: begin
+ Add('List');
+ if not Assigned(SL) then
+ SL := TStringList.Create
+ else
+ SL.Clear;
+ Uni.ReadStringList(ValueName, SL);
+ Add(Join(SL, MultiStringSeparator));
+ end;
+
+ udColor: begin
+ Add('Color');
+ Add(ColorToString(Uni.ReadColor(ValueName)));
+ end;
+
+ else
+ Add('Unsupported Data Type: ' +
+ IntToStr(Cardinal(Uni.GetDataType(ValueName))));
+ end; //case
+
+ finally
+ SL.Free;
+ end;
+ end;
+
+
+{$ENDIF}
+
+begin
+ SpaceCount := 0; //Easteregg
+
+ CheckNode(Node, False);
+ CantWrite := False;
+
+ try
+ SpyThread.Suspend;
+ Reg := TXRegistry.Create;
+ try
+
+{$IFDEF UNIKEY}
+ if RootOfNode(Node).ImageIndex = iconHostUni then begin
+ ValueNames := TStringList.Create;
+ ValueList.Clear;
+
+ Uni := UniOfNode(Node);
+ {Uni := CreateUniSubKey(UserUniPath, Copy(NodePath(Node), 1, MaxInt),
+ reFaile); }
+ if Assigned(Uni) then
+ try
+ Uni.GetValueNames(ValueNames);
+
+ for i := 0 to ValueNames.Count-1 do begin
+ Item := ValuesWin.AddValue(Reg, ValueNames[i], False);
+ Item.ImageIndex := iconHostUni2;
+ AppendSubItemData(Item.SubItems, Uni, ValueNames[i]);
+ end;
+
+ finally
+ Uni.Free;
+ ValueNames.Free;
+ end;
+
+ end else begin
+{$ENDIF}
+
+ OpenRe := OpenNode(Reg, Node);
+ if OpenRe in onOK then begin
+ ValuesWin.LoadValues(Reg);
+ if OpenRe = onReadOnly then begin
+ AddHint('Read only', True);
+ CantWrite := True;
+ end;
+ end else if OpenRe = onError then begin
+ ValueList.Clear;
+ CantWrite := True;
+ if Node.Level = 0 then begin
+ AddHint('Shortcut target not found', True);
+ end else
+ AddHint('Key not found: ' + Node.Text, True);
+ end;
+
+{$IFDEF UNIKEY}
+ end;
+{$ENDIF}
+
+ finally
+ Reg.Free;
+ end;
+
+ CantWrite := CantWrite or not Assigned(Node)
+ or NodeInfo( Node ).ReadOnly //Node itself
+ or NodeInfo(RootOfNode(Node)).ReadOnly //or host
+ or (SameText(CurKey(uhNonSystemShortcuts).Root, 'HKEY_DYN_DATA'));
+
+ MainWin.SetStatus;
+ WorkWin.InfoMemo.Text := GetKeyInfos;
+ finally
+ SpyThread.Restart := True;
+ SpyThread.Resume;
+ end;
+end;
+
+procedure TTreeWin.RegTVChanging(Sender: TObject; Node: TTreeNode;
+ var AllowChange: Boolean);
+begin
+ CantWrite := False;
+ AllowChange := Assigned(Node);
+ // CheckNode(Node, True);
+end;
+
+procedure TTreeWin.RegTVCollapsing(Sender: TObject; Node: TTreeNode;
+ var AllowCollapse: Boolean);
+begin
+ SpyThread.Restart := True;
+ Node.DeleteChildren;
+ RegTVChange(Sender, Node);
+end;
+
+procedure TTreeWin.RegTVCustomDrawItem(Sender: TCustomTreeView; Node: TTreeNode;
+ State: TCustomDrawState; var DefaultDraw: Boolean);
+var
+ Info: TNodeInfo;
+begin
+ {if Node.Text = '' then begin
+ ShowMessage('Error: Key has empty name.');
+ Node.Delete;
+ Exit; end;}
+
+ Info := NodeInfo(Node);
+ with TTreeView(Sender).Canvas.Font do begin
+ if Info.Defect then begin
+ Style := [];
+ Color := $AAAAAA
+ end else begin
+ case Info.HostType of
+
+ uhReg: begin
+ Style := [fsBold];
+ Color := clCyan;
+ end;
+
+ {uhIni: begin
+ Style := [fsBold];
+ Color := clBrightYellow;
+ end;
+
+ uhRegFile: begin
+ Style := [fsBold];
+ Color := clBrightGreen;
+ end; }
+
+ uhSystemShortcut: begin
+ Style := [];
+ Color := clBrightCyan;
+ end;
+
+ uhStandardShortcut: begin
+ Style := [fsBold];
+ Color := $EEEEEE;
+ end;
+
+ uhUserShortcut: begin
+ Style := [];
+ Color := $EEEEEE;
+ end;
+
+ else
+ Style := [];
+ if Info.ReadOnly then
+ Color := clBrightRed
+ else
+ Color := clWhite;
+ end;
+
+ end;
+ end;
+end;
+
+procedure TTreeWin.RegTVDblClick(Sender: TObject);
+var
+ Node: TTreeNode;
+ MouseX: Integer;
+ NodeRect: TRect;
+begin
+ Node := RegTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ MouseX := RegTV.ScreenToClient(Mouse.CursorPos).X;
+ NodeRect := Node.DisplayRect(True);
+ if MouseX > NodeRect.Right then begin
+ with ValuesWin do begin
+ FocusItem(PrefWin.MainPreviewE.Text);
+ ValueListDblClick(Self);
+ end;
+ end;
+end;
+
+procedure TTreeWin.RegTVDeletion(Sender: TObject; Node: TTreeNode);
+begin
+ if Assigned(SpyThread) then
+ SpyThread.Restart := True;
+ if Node.Selected then
+ RegTV.Selected := GetNextBest(Node);
+ NodeInfo(Node).Free;
+end;
+
+procedure TTreeWin.RegTVDragDrop(Sender, Source: TObject; X, Y: Integer);
+
+ procedure DragKey;
+ var
+ Src, Trg: TRegPath;
+ Node: TTreeNode;
+ begin
+ Src := RegPathOfStr(TraceKey(PathOfNode(DragNode)));
+ Trg := RegPathOfStr(TraceKey(PathOfNode(RegTV.DropTarget)));
+ Trg.Key := Trg.Key + '\' + DragNode.Text;
+
+ MoveKey(Src, Trg, KeyIsDown(VK_CONTROL));
+
+ Node := RegTV.DropTarget;
+ if Node.Expanded then
+ Node.Collapse(False);
+ Node.Expanded := False;
+ CheckNode(Node, False, True);
+ Node.Expand(False);
+ end;
+
+ procedure DragValues;
+ begin
+ MoveValues(RegTV.Selected, RegTV.DropTarget, KeyIsDown(VK_CONTROL));
+ end;
+
+begin
+ if Source is TTreeView then
+ DragKey
+ else if Source is TListView then
+ DragValues;
+end;
+
+procedure TTreeWin.RegTVDragOver(Sender, Source: TObject; X, Y: Integer;
+ State: TDragState; var Accept: Boolean);
+begin
+ Accept := False;
+ if not Assigned(RegTV.DropTarget) then
+ Exit;
+
+ if Source is TTreeView then begin
+ if not Assigned(DragNode) then
+ Exit;
+ if not KeyIsDown(VK_CONTROL) then begin
+ if (DragNode = RegTV.DropTarget)
+ or RegTV.DropTarget.HasAsParent(DragNode) then
+ Exit; //avoid recursive moving
+ end;
+ end else if Source is TListView then begin
+ //accept
+ end;
+ Accept := True;
+end;
+
+procedure TTreeWin.RegTVEdited(Sender: TObject; Node: TTreeNode; var S: string);
+var
+ old, tmp: string;
+ i: Integer;
+ Shortcut: PKeyShortcut;
+begin
+ if s = Node.Text then
+ Exit;
+
+ Old := Node.Text;
+
+ if NodeInfo(Node).HostType = uhUserShortcut then begin
+ i := ShortcutIndex(Node);
+ if i = -1 then begin
+ ShowMessage('Shortcut not found!');
+ s := old;
+ Exit; end;
+
+ Shortcut := @Shortcuts[i];
+ Shortcut.Alias := s;
+
+ with TIniFile.Create(PlutoDir + 'Shortcuts.ini') do
+ try
+ DeleteKey('Shortcuts', Old);
+ WriteString('Shortcuts', Shortcut.Alias, Shortcut.RealPath);
+ finally
+ Free;
+ end;
+ Node.Text := s;
+ RegTVChange(Self, Node);
+ Exit; end;
+
+ if s = '' then begin
+ ShowMessage('KeyNames cannot be empty.');
+ s := old;
+ Exit; end;
+
+ SpyThread.Suspend;
+ SpyThread.Restart := True;
+ Node.Text := s;
+
+ if Length(s) > RegMaxKeyLen then begin
+ s := Copy(s, 1, RegMaxKeyLen);
+ if MessageDlg(
+ 'The maximum size of a key name is ' + IntToStr(RegMaxKeyLen) + ' characters.' + EOL +
+ 'Shorten the key name to:' + EOL +
+ Quote(StringWrap(s, 80)),
+ mtConfirmation, [mbOK, mbCancel], 0) <> mrOK then begin
+ s := Old;
+ SpyThread.Resume;
+ Exit;
+ end;
+ end;
+
+ if CharIn(s, [#0..#31, '\']) then begin
+ s := ReplaceChars(s, [#0..#31], '#');
+ s := ReplaceChars(s, '\', '-');
+
+ if MessageDlg('The following characters are not allowed in KeyNames:' + EOL +
+ '- Control chars (0-31)' + EOL +
+ '- ' + Quote('\') + EOL +
+ 'The following name is allowed:' + EOL +
+ s + EOL +
+ 'Use this name instead?',
+ mtConfirmation, [mbYes, mbNo], 0) <> mrYes then begin
+ s := Old;
+ SpyThread.Resume;
+ Exit;
+ end;
+ end;
+
+ try
+ OpenCurParent;
+ if not SameText(s, Old) then begin
+ if not MainReg.KeyExists(s) or
+ (mrIgnore = MessageDlg(
+ 'Key already exists.' + EOL +
+ 'Click Ignore to overwrite the key.',
+ mtConfirmation, [mbCancel, mbIgnore], 0)
+ ) then begin
+ MainReg.DeleteKey(s);
+ MainReg.MoveKey(Old, s, True);
+ Node.Text := Old;
+ end else begin
+ s := Old;
+ end;
+ end else begin //change CharCase
+ tmp := MainReg.GetFreeKeyName;
+ AddHint('Forced change of case using temporary key ' + Quote(tmp));
+ MainReg.MoveKey(Old, tmp, True);
+ MainReg.MoveKey(tmp, s, True);
+ end;
+ finally
+ MainReg.CloseKey;
+ end;
+
+ Node.Text := s;
+ SpyThread.Resume;
+ RegTVChange(Sender, Node);
+end;
+
+procedure TTreeWin.RegTVEditing(Sender: TObject; Node: TTreeNode;
+ var AllowEdit: Boolean);
+begin
+ CheckNode(Node, False);
+ if RegTV.Selected <> Node then
+ Exit;
+ AllowEdit := (NodeInfo(Node).HostType in [uhNone, uhUserShortcut])
+ and (not CantWrite)
+ and OpenCurKey;
+ MainReg.CloseKey;
+end;
+
+procedure TTreeWin.RegTVEndDrag(Sender, Target: TObject; X, Y: Integer);
+begin
+ DragNode := nil;
+end;
+
+procedure TTreeWin.RegTVEnter(Sender: TObject);
+begin
+ if not Started then
+ Exit;
+ ValueList.ItemFocused := nil;
+ MainWin.SetStatus;
+end;
+
+procedure TTreeWin.RegTVExpanded(Sender: TObject; Node: TTreeNode);
+begin
+ if not DoSmartExpand or not PrefWin.SmartExpandCB.Checked then
+ Exit;
+
+ if not Assigned(Node) then
+ Exit;
+
+ RegTVChange(Sender, Node);
+
+ //SmartExpand
+ if (Node.Count > 0) and (ValueList.Items.Count = 0) then begin
+ RegTV.Selected := Node.GetFirstChild;
+ RegTVChange(Sender, RegTV.Selected);
+ end;
+
+ if Node.Count = 1 then
+ Node.GetFirstChild.Expand(False);
+end;
+
+procedure TTreeWin.RegTVExpanding(Sender: TObject; Node: TTreeNode;
+ var AllowExpansion: Boolean);
+var
+ SL: TStringList;
+ Reg: TXRegistry;
+ Clock: TClock;
+{$IFDEF UNIKEY}
+ Uni: TUniKey;
+{$ENDIF}
+
+ procedure AddKeys(TreeView: TTreeView; Node: TTreeNode; SL: TStrings);
+ var
+ i: Integer;
+ begin
+ for i := 0 to SL.Count-1 do
+ TreeView.Items.AddNode(TTreeNode.Create(TreeView.Items), Node, SL[i],
+ nil, naAddChild);
+ end;
+
+ procedure AddKeysProgressive(TreeView: TTreeView; Node: TTreeNode;
+ SL: TStrings);
+ var
+ i, delta: Integer;
+ GaugeRect, FullRect: TRect;
+ GaugeWidth: Integer;
+ begin
+ delta := SL.Count div 100;
+ GaugeWidth := 100;
+ with TreeView.Canvas do begin
+ FullRect := Node.DisplayRect(True);
+ with FullRect do begin
+ Left := Right + 40;
+ Right := Left + GaugeWidth + 2;
+ Inc(Top, 5);
+ Dec(Bottom, 5);
+ end;
+ with Pen do begin
+ Width := 1;
+ Style := psSolid;
+ end;
+ Pen.Color := clBrightBlue;
+ Brush.Style := bsClear;
+ Rectangle(FullRect);
+ Pen.Style := psClear;
+ end;
+
+ GaugeRect := FullRect;
+ with GaugeRect do begin
+ Inc(Left);
+ Inc(Top);
+ Dec(Bottom);
+ end;
+
+ for i := 0 to SL.Count-1 do begin
+ TreeView.Items.AddNode(TTreeNode.Create(TreeView.Items), Node, SL[i],
+ nil, naAddChild);
+
+ if ((i + 1) mod delta) = 0 then begin
+ with TreeView.Canvas do begin
+ GaugeRect.Right := GaugeRect.Left + (GaugeWidth * i) div SL.Count;
+ Brush.Color := GadientAqua(90 + Round(100 * ((i+1) / SL.Count)));
+ FillRect(GaugeRect);
+ end;
+ end;
+ end;
+
+ with TreeView.Canvas do begin
+ Pen.Color := clVeryBrightBlue;
+ Pen.Style := psSolid;
+ Brush.Color := GadientAqua(200);
+ Rectangle(FullRect);
+ Brush.Style := bsClear;
+ end;
+ end;
+
+begin
+ if Node.Expanded then
+ Exit;
+
+ SpyThread.Suspend;
+ SL := TStringList.Create;
+ Clock := TClock.Create;
+
+ try
+
+{$IFDEF UNIKEY}
+ if RootOfNode(Node).ImageIndex = iconHostUni then begin
+ Uni := UniOfNode(Node);
+ if Assigned(Uni) then
+ try
+ Uni.GetKeyNames(SL);
+ finally
+ Uni.Free;
+ end;
+
+ end else begin
+{$ENDIF}
+
+ Reg := TXRegistry.Create;
+ try
+ if OpenNodeOK(Reg, Node) then
+ Reg.GetKeyNames(SL);
+ finally
+ Reg.Free;
+ end;
+
+{$IFDEF UNIKEY}
+ end;
+{$ENDIF}
+
+ Node.DeleteChildren;
+ if PrefWin.ShowProgressCB.Checked and (SL.Count > 100) then
+ AddKeysProgressive(RegTV, Node, SL)
+ else
+ AddKeys(RegTV, Node, SL);
+
+ if PrefWin.SortKeysCB.Checked then
+ Node.AlphaSort;
+
+ if MurphyMode then begin
+ Clock.Stop;
+ AddHint(Format('[MM] Key opened after %0.2f s.', [Clock.SecondsPassed]));
+ end;
+ finally
+ Clock.Free;
+ SL.Free;
+ SpyThread.Resume;
+ end;
+end;
+
+procedure TTreeWin.RegTVGetSelectedIndex(Sender: TObject; Node: TTreeNode);
+begin
+ Node.SelectedIndex := Node.ImageIndex;
+end;
+
+procedure TTreeWin.RegTVKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+var
+ Node: TTreeNode;
+begin
+ if Key = VK_SCROLL then
+ CheckRegTVHotTrack;
+
+ if RegTV.IsEditing then
+ Exit;
+
+ Node := RegTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ if ssShift in Shift then
+ case Key of
+ VK_DOWN: begin
+ Node := Node.GetNextSibling;
+ if Assigned(Node) then
+ RegTV.Selected := Node;
+ Key := 0; end;
+
+ VK_UP: begin
+ Node := Node.GetPrevSibling;
+ if Assigned(Node) then
+ RegTV.Selected := Node;
+ Key := 0; end;
+
+ VK_RIGHT: Key := VK_MULTIPLY;
+ VK_LEFT: Key := VK_DIVIDE;
+ end;
+
+ if Assigned(Node.Parent) then begin
+ case Key of
+ VK_END:
+ begin
+ RegTV.Selected := Node.Parent.GetLastChild;
+ Key := 0; end;
+
+ VK_HOME:
+ begin
+ RegTV.Selected := Node.Parent.GetFirstChild;
+ Key := 0; end;
+ end;
+ end;
+
+ case Key of
+ 0: Exit;
+ VK_RETURN: ValuesWin.FocusControl(ValueList);
+ VK_DELETE: DeleteMIClick(Sender);
+ VK_SPACE: begin
+ JumpToSel(RegTV);
+ Inc(SpaceCount);
+ if SpaceCount > 10 then begin
+ ShowMessage('YES!');
+ SpaceCount := 0;
+ end;
+ end;
+ VK_F9: SwapFonts(RegTV);
+
+ VK_F12:
+ if ssShift in Shift then begin
+ if Assigned(Node.Parent) then Node.Parent.AlphaSort;
+ end else
+ if Node.Expanded then Node.AlphaSort;
+
+ VK_LEFT, VK_SUBTRACT:
+ begin
+ if Node.Expanded then
+ Node.Collapse(False)
+ else if Assigned(Node.Parent) then
+ RegTV.Selected := Node.Parent;
+ Key := 0; end;
+
+ VK_RIGHT, VK_ADD:
+ begin
+ if not Node.HasChildren then
+ TreeWin.RegTV.Items.AddChild(Node, '');
+ if Node.Expanded then
+ RegTV.Selected := Node.GetFirstChild
+ else
+ Node.Expand(False);
+ Key := 0; end;
+
+ VK_MULTIPLY:
+ begin
+ NoAsterisk := True;
+ OpenNextLevel(Node);
+ JumpToSel(RegTV);
+ AddHint('Press the Multiply Key again to open the next level.');
+ Key := 0; end;
+
+ VK_DIVIDE:
+ begin
+ DoSmartExpand := False;
+ Node.Collapse(true);
+ DoSmartExpand := True;
+ Key := 0; end;
+ end;
+
+ if ssctrl in Shift then
+ case Key of
+ Ord('C'): CopyPathMIClick(Sender);
+ Ord('X'): CutPathMIClick(Sender);
+ Ord('V'): PasteKeyMIClick(Sender);
+ end;
+end;
+
+procedure TTreeWin.RegTVMouseDown(Sender: TObject; Button: TMouseButton;
+ Shift: TShiftState; X, Y: Integer);
+var
+ Node: TTreeNode;
+ RelX, RelY: Integer;
+ NodeRect: TRect;
+begin
+ CheckRegTVHotTrack;
+
+ if not Active then
+ Exit;
+
+ RelX := RegTV.ScreenToClient(Mouse.CursorPos).X;
+ RelY := RegTV.ScreenToClient(Mouse.CursorPos).Y;
+ Node := RegTV.GetNodeAt(RelX, RelY);
+ if not Assigned(Node) then
+ Exit;
+
+ if not Node.Selected then
+ Node.Selected := True;
+
+ if Button = mbLeft then begin
+ NodeRect := RegTV.Selected.DisplayRect(True);
+ if RegTV.HotTrack
+ or (RelX < NodeRect.Left) and (RelX > NodeRect.Left - 20) then begin
+ //4px more to the left (friendlier for the user)
+ if not Node.HasChildren then
+ RegTV.Items.AddChild(Node, '');
+ DoSmartExpand := False;
+ with Node do
+ if not Expanded then
+ Expand(False)
+ else
+ Collapse(False);
+ DoSmartExpand := True;
+ end;
+ end;
+end;
+
+procedure TTreeWin.RegTVStartDrag(Sender: TObject; var DragObject: TDragObject);
+begin
+ DragNode := RegTV.Selected;
+ if NodeInfo(DragNode).IsHost then
+ DragNode := nil;
+end;
+
+function OpenNodeError(Reg: TXRegistry; Node: TTreeNode;
+ out Mode: TOpenNodeMode): Integer;
+var
+ Key: string;
+begin
+ Result := ERROR_SUCCESS;
+ Mode := onNodeNil;
+ if not Assigned(Node) then
+ Exit;
+
+ Reg.CloseKey;
+ Key := TraceKey(PathOfNode(Node));
+ Reg.RootKey := HKEYOfStr(ExRegRoot(Key));
+ Result := Reg.OpenKeyError(ExRegKey(Key), False, True);
+ if Success(Result) then
+ if Reg.RootKey = HKDD then
+ Mode := onReadOnly
+ else
+ Mode := onFull
+ else if Reg.OpenKeyReadOnly(ExRegKey(Key)) then
+ Mode := onReadOnly
+ else
+ Mode := onError;
+end;
+
+function OpenNode(Reg: TXRegistry; Node: TTreeNode): TOpenNodeMode;
+begin
+ OpenNodeError(Reg, Node, Result);
+end;
+
+function OpenNodeOK(Reg: TXRegistry; Node: TTreeNode): Boolean;
+begin
+ Result := OpenNode(Reg, Node) in onOK;
+end;
+
+function OpenCurKey: Boolean;
+begin
+ Result := OpenNodeOK(MainReg, RegTV.Selected);
+end;
+
+function OpenCurParent: Boolean;
+begin
+ Result := Assigned(RegTV.Selected)
+ and OpenNodeOK(MainReg, RegTV.Selected.Parent);
+end;
+
+function TTreeWin.CreateKey(Subkey: Boolean): Boolean;
+var
+ Node, NewNode: TTreeNode;
+ KeyName: string;
+ i: integer;
+begin
+ Result := False;
+
+ if CantWrite then
+ Exit;
+
+ Node := RegTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ if not Subkey then begin
+ //key shall be created on same level...
+ if Node.Level = 0 then begin
+ Node := RegTV.Selected;
+ if TraceKey(PathOfNode(Node)) <> PathOfNode(Node) then
+ //check for shortcut: shortcuts are unequal to their trace
+ if mrOK = MessageDlg(
+ 'You are trying to create a Key in the shortcut''s level.' + EOL +
+ 'Pluto needs to jump to the target of the shortcut to do this.',
+ mtConfirmation, [mbOK, mbCancel], 0) then begin
+ MainWin.GotoKey(TraceKey(PathOfNode(Node)));
+ Node := RegTV.Selected.Parent;
+ end else Exit
+ else begin
+ ShowMessage('Key is a HKEY.' + EOL +
+ 'It is not possible to create Keys on HKEY level.');
+ Exit; end;
+ end else
+ Node := Node.Parent; //set reference key to parent
+ end;
+
+ try
+
+ case OpenNode(MainReg, Node) of
+
+ onFull: begin
+ KeyName := 'New'; //find best free name
+ i := 0;
+ while MainReg.KeyExists(KeyName) do begin
+ Inc(i);
+ KeyName := 'New ' + IntToStr(i);
+ end;
+
+ Result := MainReg.CreateKey(KeyName) and MainReg.KeyExists(KeyName);
+ // ^-- CREATE KEY
+
+ if not Result then // <-- FAILED
+ ShowMessage('Could not create key!');
+ end;
+
+ onReadOnly: ShowMessage('Key is read-only.');
+
+ else
+ ShowMessage('Error: Couldn''t open key.');
+
+ end; //case
+
+ finally
+ MainReg.CloseKey;
+ end;
+
+ if not Result then
+ Exit;
+
+ if not Node.Expanded then begin //find the node, if Parent not Expanded
+ CheckNode(Node, False);
+ DoSmartExpand := False;
+ Node.Expand(False);
+ DoSmartExpand := True;
+ NewNode := FindNode(Node, KeyName);
+ end else
+ NewNode := RegTV.Items.AddChild(Node, KeyName); //else create a new node
+
+ Result := Assigned(NewNode);
+ if not Result then
+ ShowMessage('Error: Could not find created key.');
+
+ if Result then begin
+ RegTV.Selected := NewNode;
+ RegTV.Selected.EditText;
+ end;
+end;
+
+procedure TTreeWin.CloneKey;
+var
+ Node: TTreeNode;
+ Full: TRegPath;
+ MainKey, SubKey, NewKey, zKey: string;
+ i: integer;
+begin
+ Node := RegTV.Selected;
+
+ if CantWrite then
+ Exit;
+
+ if NodeInfo(Node).IsHost then
+ Exit;
+
+ Full := CurKey(uhNonSystemShortcuts);
+ MainKey := LWPSolve(Full.Key);
+ SubKey := FromLastChar(MainKey, '\');
+ MainKey := UntilLastChar(MainKey, '\');
+ if SubKey = '' then begin //Directly beyound HKEY
+ SubKey := MainKey;
+ MainKey := '';
+ end;
+
+ try
+ MainReg.RootKey := HKEYOfStr(Full.Root);
+ if not MainReg.OpenKey(MainKey, False) then begin
+ ShowMessage('Error: Couldn''t not open Key: ' + MainKey);
+ Exit end;
+ if Copy(SubKey, 1, 3) <> 'New' then
+ NewKey := 'New ' + SubKey
+ else
+ NewKey := SubKey;
+
+ zKey := Trim(FromLastChar(NewKey, ' '));
+
+ i := StrToIntDef(zKey, 0);
+ if IsValidInteger(zKey) then
+ zKey := Trim(UntilLastChar(NewKey, ' '))
+ else
+ zKey := NewKey;
+
+ while MainReg.KeyExists(NewKey) do begin
+ Inc(i);
+ NewKey := zKey + ' ' + IntToStr(i);
+ end;
+
+ MainReg.MoveKey(SubKey, NewKey, False);
+ finally
+ MainReg.CloseKey;
+ end;
+
+ Node := RegTV.Items.Add(Node, NewKey);
+ RegTV.Selected := Node;
+ Node.EditText;
+end;
+
+procedure TTreeWin.NewShortcut;
+var
+ Node, ShortCutNode: TTreeNode;
+ ScName, ScRealPath: string;
+ i: Integer;
+begin
+ Node := RegTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ if Node.Level = 0 then
+ ScName := 'new ' + Node.Text
+ else
+ ScName := '' + Node.Text;
+
+ ScRealPath := TraceKey(PathOfNode(Node));
+ if not InputQuery('New shortcut to ', ScRealPath, ScName) then
+ Exit;
+
+ for i := 0 to High(ShortCuts) do
+ if SameText(ScName, ShortCuts[i].Alias) then begin
+ ShowMessage('Name already in use.');
+ NewShortcut;
+ Exit; end;
+
+ ShortCutNode := AddShortcut(ScName, ScRealPath, iconShortcut, uhUserShortcut,
+ True);
+ CheckNode(Node, False);
+ RegTV.Selected := ShortCutNode;
+end;
+
+function AddShortcut(Alias, RealPath: string; Icon: Integer;
+ AHostType: TUniHostType = uhUserShortcut;
+ WriteIni: Boolean = False): TTreeNode;
+var
+ Last: Integer;
+begin
+ RealPath := TraceKey(RealPath); //Important: do this BEFORE adding a new,
+ //empty shortcut to ShortCuts
+
+ SetLength(ShortCuts, Length(ShortCuts) + 1);
+ Last := High(Shortcuts);
+ ShortCuts[Last].Alias := Alias;
+ ShortCuts[Last].RealPath := RealPath;
+
+ Result := RegTV.Items.Add(nil, Alias);
+ ShortCuts[Last].Node := Result;
+
+ if Alias = 'HKEY_WindowsMachine' then
+ Icon := iconHKWM
+ else if Alias = 'HKEY_WindowsUser' then
+ Icon := iconHKWU;
+ SetTNImage(Result, Icon);
+
+ NodeInfo(Result).HostType := AHostType;
+
+ if WriteIni then
+ with TIniFile.Create(PlutoDir + 'Shortcuts.ini') do
+ try
+ WriteString('Shortcuts', Alias, RealPath);
+ finally
+ Free;
+ end;
+end;
+
+procedure TTreeWin.DeleteKey;
+var
+ i: Integer;
+ Node, Node2: TTreeNode;
+begin
+ Node := RegTV.Selected;
+
+
+ i := ShortcutIndex(Node);
+ if (i > -1) then begin
+ if (mrYes = MessageDlg('This is a Pluto shortcut to a real key.'#13#10 +
+ 'Do you really want to delete the shortcut?',
+ mtConfirmation, [mbYes, mbCancel], 0)) then begin
+ SpyThread.Suspend;
+ SpyThread.Restart := True;
+ with TIniFile.Create(PlutoDir + 'Shortcuts.ini') do
+ try
+ DeleteKey('Shortcuts', Shortcuts[i].Alias);
+ finally
+ Free;
+ end;
+ Shortcuts[i] := Shortcuts[High(Shortcuts)];
+ SetLength(Shortcuts, Length(Shortcuts)-1);
+ RegTV.Selected := GetNextBest(Node);
+ Node.Delete;
+ RegTVChange(Self, RegTV.Selected);
+ SpyThread.Resume;
+ end;
+ Exit; end;
+
+ if CantWrite then
+ Exit;
+
+ if NodeInfo(Node).IsHost then
+ Exit;
+
+ SpyThread.Suspend;
+ SpyThread.Restart := True;
+
+ Node2 := GetNextBest(Node);
+
+ if MessageDlg('Do you really want to delete this key?', mtConfirmation,
+ [mbYes, mbCancel], 0) = mrYes then
+ try
+ if OpenCurParent then begin
+ if not MainReg.DeleteKey(Node.Text) then //<-- DELETE KEY
+ ShowMessage('Key could not be deleted.')
+ else begin
+ RegTV.Selected := Node2;
+ if Assigned(Node.Parent) and (Node2 = Node.Parent) then
+ Node.Parent.Collapse(False);
+ Node.Delete;
+ end;
+ end;
+ finally
+ MainReg.CloseKey;
+ end;
+
+ RegTVChange(Self, Node2);
+
+ SpyThread.Resume;
+end;
+
+procedure TTreeWin.MoveKey(const Src, Trg: TRegPath; CopyWanted: Boolean);
+var
+ TrgReg: TXRegistry;
+begin
+ with MainReg do begin
+ RootKey := HKEYOfStr(Src.Root);
+ OpenKey('');
+
+ if not KeyExists(Src.Key) then begin
+ ShowMessage('Source not found.');
+ Exit; end;
+ end;
+
+ TrgReg := TXRegistry.Create;
+ with TrgReg do begin
+ RootKey := HKEYOfStr(Trg.Root);
+ OpenKey('');
+ if KeyExists(Trg.Key) then begin
+ ShowMessage('Target already existing.');
+ TrgReg.Free;
+ Exit; end;
+ end;
+
+ if not CopyWanted then
+ if mrYes <> MessageDlg('From source: ' + StrOfRegPath(Src) + EOL +
+ 'To target: ' + StrOfRegPath(Trg) + EOL +
+ 'Do you really want to move this key?',
+ mtConfirmation, [mbYes, mbCancel], 0)
+ then
+ Exit;
+
+ try
+ MainReg.MoveKey(Src.Key, TrgReg, Trg.Key, not CopyWanted); //<-- MOVE KEY
+ except
+ end;
+
+ if not TrgReg.OpenKey(Trg.Key, False) then
+ ShowMessage('Could not move key!')
+ else
+ if not CopyWanted then
+ DragNode.Delete;
+
+
+ TrgReg.Free;
+
+ MainReg.CloseKey;
+end;
+
+procedure TTreeWin.MoveValues(SrcNode, TrgNode: TTreeNode;
+ CopyWanted: Boolean);
+var
+ SrcReg, TrgReg: TXRegistry;
+ i: Integer;
+ ValueName: string;
+ AnswerToAll: Integer;
+
+ function AskForReplacing(const ValueName: string): Integer;
+ begin
+ if AnswerToAll = -1 then begin
+ Result := MessageDlg(
+ 'Value ' + Quote(ValueName) + 'already exists in target key.' + EOL +
+ 'Do you want to replace it?',
+ mtWarning, [mbNo, mbYes, mbNoToAll, mbYesToAll, mbAbort], 0);
+ if Result in [mrNoToAll, mrYesToAll] then begin
+ if Result = mrYesToAll then
+ Result := mrYes
+ else if Result = mrNoToAll then
+ Result := mrNo;
+ AnswerToAll := Result;
+ end;
+ end else Result := AnswerToAll;
+ end;
+
+begin
+ AnswerToAll := -1;
+
+ if not CopyWanted then
+ if mrYes<>MessageDlg(
+ Format(
+ 'Do you really want to move %s' + EOL +
+ 'from: %s' + EOL +
+ 'to: %s',
+ [StrNumerus(ValueList.SelCount, 'value', 'values'),
+ PathOfNode(SrcNode), PathOfNode(TrgNode)]
+ ), mtConfirmation, [mbYes, mbAbort], 0) then
+ Exit;
+
+ SrcReg := TXRegistry.Create;
+ try
+ if not (OpenNode(SrcReg, SrcNode) in onOK) then
+ MessageDlg('Couldn''t open source key: ' + PathOfNode(SrcNode),
+ mtError, [mbOK], 0);
+
+ TrgReg := TXRegistry.Create;
+ try
+ if not (OpenNode(TrgReg, TrgNode) in onOK) then
+ MessageDlg('Couldn''t open target key: ' + PathOfNode(TrgNode),
+ mtError, [mbOK], 0);
+
+ with ValueList.Items do begin
+ for i := 0 to Count-1 do begin
+ if not Item[i].Selected then
+ Continue;
+ ValueName := RealValueName(Item[i]);
+
+ if TrgReg.ValueExists(ValueName) then begin
+ case AskForReplacing(ValueName) of
+ mrYes: ;
+ mrNo: Continue;
+ mrAbort: Break;
+ end;
+ end;
+
+ TrgReg.WriteContext(ValueName, SrcReg.ReadContext(ValueName));
+ if not CopyWanted then
+ SrcReg.DeleteValue(ValueName);
+ end;
+ end;
+
+ finally
+ TrgReg.Free;
+ end;
+
+ finally
+ SrcReg.Free;
+ end;
+
+ if not CopyWanted then
+ ValuesWin.Reload;
+end;
+
+procedure TTreeWin.NewSubKeyMIClick(Sender: TObject);
+begin
+ CreateKey(True);
+end;
+
+procedure TTreeWin.NewKeyMIClick(Sender: TObject);
+begin
+ CreateKey(False);
+end;
+
+procedure TTreeWin.CreateShortcutMIClick(Sender: TObject);
+begin
+ NewShortcut;
+end;
+
+procedure TTreeWin.TraceMIClick(Sender: TObject);
+begin
+ if NodeInfo(RegTV.Selected).IsShortcut then
+ MainWin.GotoKey(TraceKey(PathOfNode(RegTV.Selected)));
+end;
+
+procedure TTreeWin.DeleteMIClick(Sender: TObject);
+begin
+ if not RegTV.IsEditing then
+ DeleteKey;
+end;
+
+procedure TTreeWin.DublicateMIClick(Sender: TObject);
+begin
+ CloneKey;
+end;
+
+procedure TTreeWin.FindMIClick(Sender: TObject);
+begin
+ FindWin.SfCurKeyRB.Checked := True;
+ FindWin.Show;
+end;
+
+procedure TTreeWin.RegTVPUPopup(Sender: TObject);
+begin
+ RegTVChange(Sender, RegTV.Selected);
+ with NodeInfo(RegTV.Selected) do begin
+ NewSubKeyMI.Enabled := not CantWrite;
+ NewKeyMI.Enabled := not CantWrite and (not IsHost or IsShortcut);
+ DublicateMI.Enabled := not CantWrite and not IsHost;
+
+ with DeleteMI do
+ if HostType = uhUserShortcut then begin
+ Caption := '&Delete Shortcut';
+ Enabled := True;
+ end else begin
+ Caption := '&Delete';
+ Enabled := not CantWrite and not IsHost;
+ end;
+
+ RenameMI.Enabled := not CantWrite and (HostType in [uhNone, uhUserShortcut]);
+ TraceMI.Visible := IsShortcut;
+ EditShortcutMI.Visible := HostType = uhUserShortcut;
+ end;
+end;
+
+procedure CheckNode(Node: TTreeNode; OnlyOnce: Boolean = True;
+ TakeNodeSelected: Boolean = False);
+var
+ CurIcon, NewIcon: Integer;
+ Reg: TXRegistry;
+ OpenMode: TOpenNodeMode;
+ Info: TNodeInfo;
+{$IFDEF UNIKEY}
+ Uni: TUniKey;
+{$ENDIF}
+ KeyHasChildren: Boolean;
+
+ procedure SetShortcutIcon(Node: TTreeNode);
+ var
+ Full: string;
+ i: Integer;
+ begin
+ Full := TraceKey(PathOfNode(Node));
+ for i := Low(Shortcuts) to High(Shortcuts) do
+ if Full = Shortcuts[i].RealPath then begin
+ CurIcon := Shortcuts[i].Node.ImageIndex;
+ Exit; end;
+ if Node.ImageIndex in [iconShortcut, iconShortcut + 1] then
+ CurIcon := iconKey + (CurIcon - iconShortcut);
+ end;
+
+begin
+ if not Assigned(Node) then
+ Exit;
+
+ Info := NodeInfo(Node);
+ if OnlyOnce and Info.Checked then
+ Exit;
+
+ CurIcon := Node.ImageIndex;
+ if (CurIcon > iconFirstType) then begin
+{$IFDEF UNIKEY}
+ if RootOfNode(Node).ImageIndex <> iconHostUni then begin
+ SetShortcutIcon(Node);
+ CurIcon := (CurIcon div 2) * 2;
+ end;
+{$ELSE}
+ Exit;
+{$ENDIF}
+ end else begin
+ SetShortcutIcon(Node);
+ CurIcon := (CurIcon div 2) * 2;
+ end;
+ NewIcon := CurIcon;
+
+ Info.ExcludeFlag(nfDefect);
+ Info.ExcludeFlag(nfReadOnly);
+
+{$IFDEF UNIKEY}
+ KeyHasChildren := False;
+
+ if RootOfNode(Node).ImageIndex = iconHostUni then begin
+ Uni := UniOfNode(Node);
+ if Assigned(Uni) then
+ try
+ KeyHasChildren := Uni.HasKeys;
+ if usReadOnly >= Uni.Skills then
+ OpenMode := onReadOnly
+ else
+ OpenMode := onFull;
+ finally
+ Uni.Free;
+ end
+ else
+ OpenMode := onError;
+ end else begin
+{$ENDIF}
+ Reg := TXRegistry.Create;
+ try
+ OpenMode := OpenNode(Reg, Node);
+ KeyHasChildren := Reg.HasSubKeys;
+ finally
+ Reg.Free;
+ end;
+{$IFDEF UNIKEY}
+ end;
+{$ENDIF}
+
+ if OpenMode = onReadOnly then
+ Info.IncludeFlag(nfReadOnly);
+
+ if OpenMode in onOK then begin
+ //OK, could open
+ if not Node.Expanded then begin //Collapsed
+ if KeyHasChildren then begin //HasSubKeys
+ if not Node.HasChildren then begin
+ //Update: Ensure HasChildren
+ if TakeNodeSelected or Node.Selected then
+ TreeWin.RegTV.Items.AddChild(Node, '');
+ end;
+ //Ensure Plus-Icon
+ NewIcon := CurIcon + 1;
+ end else begin
+ //Has still Children?
+ if Node.HasChildren then
+ Node.DeleteChildren;
+ end;
+
+ end else begin //Expanded
+ //HasSubKeys?
+ if KeyHasChildren then begin
+ //OK
+ NewIcon := CurIcon + 1;
+ end else begin
+ //not OK --> update
+ Node.Collapse(True);
+ Node.DeleteChildren;
+ end;
+ end;
+
+ //not OK, couldn't open
+ end else begin //defect
+ if Node.HasChildren then
+ Node.DeleteChildren;
+ Info.IncludeFlag(nfDefect);
+ end;
+
+ if Node.ImageIndex <> iconHostUni then //don't change icon of UniHosts
+ Node.ImageIndex := NewIcon;
+
+ Info.IncludeFlag(nfChecked);
+end;
+
+procedure TTreeWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ MainWin.FormKeyDown(Sender, Key, Shift);
+end;
+
+function ShortcutIndex(Node: TTreeNode): Integer;
+//If Node is a Shortcut,
+//S. returns its index in the Shortcuts array
+//else -1
+begin
+ if Node.Level > 0 then begin
+ Result := -1;
+ Exit; end;
+
+ for Result := 0 to High(Shortcuts) do
+ if Shortcuts[Result].Node = Node then begin
+ Exit;
+ end;
+
+ Result := -1;
+end;
+
+function TraceKey(const Path: string; AllowedShortcutTypes: TUniHostTypes =
+ uhNonSystemShortcuts): string;
+var
+ i: Integer;
+ isAim: Boolean;
+
+ function NodeOkForTracing(Node: TTreeNode): Boolean;
+ begin
+ Result := Assigned(Node) and
+ (NodeInfo(Node).HostType in AllowedShortcutTypes);
+ end;
+
+begin
+ Result := MakeLongHKEY(Path);
+ repeat
+ isAim := True;
+ for i := 0 to High(ShortCuts) do begin
+ with Shortcuts[i] do
+ if NodeOkForTracing(Node) and
+ SameText(UntilChar(Result, '\'), Alias) then begin
+ if Alias = RealPath then
+ Break;
+ Delete(Result, 1, Length(Alias));
+ Result := RealPath + Result;
+ isAim := False;
+ Break; end;
+ end;
+ until isAim;
+end;
+
+procedure TTreeWin.RegTVKeyPress(Sender: TObject; var Key: Char);
+begin
+ if (Key = '*') and NoAsterisk then begin
+ Key := #0;
+ NoAsterisk := False;
+ end;
+end;
+
+procedure TTreeWin.RegTVAdvancedCustomDrawItem(Sender: TCustomTreeView;
+ Node: TTreeNode; State: TCustomDrawState; Stage: TCustomDrawStage;
+ var PaintImages, DefaultDraw: Boolean);
+var
+ Rect: TRect;
+ MainValueName: string;
+ Reg: TXRegistry;
+ Info: TRegKeyInfo;
+ PreviewPosX: Integer;
+
+ procedure DefaultIconPreview(Reg: TXRegistry);
+ var
+ Icon: HICON;
+ IconFile: string;
+ begin
+ if (Node.Level = 0) and not RegTV.ShowLines then
+ Exit;
+
+ IconFile := Reg.ReadDefaultIcon;
+ if IconFile = '' then
+ Exit;
+
+ Icon := GetIconFromFile(ExpandString(IconFile));
+ if Icon = 0 then
+ Exit;
+
+ with Rect do begin
+ Dec(Left, TTreeView(Sender).Indent + 16);
+ DrawIconEx(Sender.Canvas.Handle, Left, Top,
+ Icon, 16, 16,
+ 0, 0, DI_NORMAL);
+ DestroyIcon(Icon);
+ end;
+ end;
+
+ procedure AddPreview(const PreviewText: string; Color: TColor);
+ begin
+ with Sender.Canvas do begin
+ SetTextColor(Handle, Color);
+ ExtTextOut(Handle, PreviewPosX, Rect.Top + 1, TextFlags, nil,
+ PChar(PreviewText), Length(PreviewText), nil);
+ Inc(PreviewPosX, TextWidth(PreviewText));
+ end;
+ end;
+
+begin
+ if Stage <> cdPostPaint then
+ Exit;
+
+ MainValueName := PrefWin.MainPreviewE.Text;
+
+ Rect := Node.DisplayRect(True);
+ PreviewPosX := Rect.Right + 5;
+
+ Reg := TXRegistry.Create(KEY_READ);
+ try
+ if OpenNodeOK(Reg, Node) then begin
+// Sender.Canvas.Font.Style := [];
+ if PrefWin.KeyInfoPreviewCB.Checked and Reg.GetKeyInfo(Info) then
+ with Info do begin
+ if NumSubKeys > 0 then
+ AddPreview(IntToStr(NumSubKeys) + 'k ', clCyan);
+ if NumValues > 0 then
+ AddPreview(IntToStr(NumValues) + 'v ', clBrightPurple);
+ end;
+
+ if PrefWin.MainPreviewCB.Checked then
+ if Reg.ValueReallyExists(MainValueName) then
+ AddPreview(DataPreviewOfContext(Reg.ReadContext(MainValueName)), $00AAFFFF);
+ {clBrightYellow}
+ if PrefWin.DefaultIconPreviewCB.Checked then
+ DefaultIconPreview(Reg);
+ end;
+ finally
+ Reg.Free;
+ end;
+
+ {if nfCopy in NodeInfo(Node).Flags then begin
+ //Node.StateIndex := 2;
+ Brush.Style := bsClear;
+ with Font do begin
+ Style := [fsItalic, fsBold];
+ Color := clRed;
+ end;
+ //TextOut(Rect.Left - 10, Rect.Top + 3, 'c');
+ end;}
+end;
+
+procedure TTreeWin.RenameMIClick(Sender: TObject);
+begin
+ RegTV.Selected.EditText;
+end;
+
+procedure TTreeWin.CopyPathMIClick(Sender: TObject);
+begin
+ UserCopyKeyFlag := True;
+ MainWin.CopyPathClick(Sender);
+end;
+
+procedure TTreeWin.InsertPathMIClick(Sender: TObject);
+begin
+ MainWin.InsertPathClick(Sender);
+end;
+
+procedure TTreeWin.RegTVGetImageIndex(Sender: TObject; Node: TTreeNode);
+begin
+ if not NodeInfo(Node).Checked then
+ CheckNode(Node);
+end;
+
+procedure TTreeWin.CheckRegTVHotTrack;
+const
+ FindCursorOfSwitch: array[Boolean] of TCursor = (crArrow, crHandPoint);
+var
+ NewHotTrack: Boolean;
+begin
+ NewHotTrack := ScrollON xor PrefWin.KeysSingleClickCB.Checked;
+ if NewHotTrack = RegTV.HotTrack then Exit;
+
+ with RegTV do begin
+ HotTrack := NewHotTrack;
+ Cursor := FindCursorOfSwitch[HotTrack];
+ Mouse.CursorPos := Mouse.CursorPos; //update cursor
+ end;
+end;
+
+procedure TTreeWin.PasteKeyMIClick(Sender: TObject);
+var
+ Src, Trg: TRegPath;
+ Node: TTreeNode;
+begin
+ Src := RegPathOfStr(Clipboard.AsText);
+ Trg := CurKey(uhNonSystemShortcuts);
+ Trg.Key := Trg.Key + '\' + FromLastChar(Src.Key, '\', True);
+
+ MoveKey(Src, Trg, UserCopyKeyFlag);
+
+ Node := RegTV.Selected;
+ if Node.Expanded then
+ Node.Collapse(False);
+ Node.Expanded := False;
+ CheckNode(Node, False);
+ Node.Expand(False);
+
+ if not UserCopyKeyFlag then
+ RegTV.Repaint; // CheckNode(Node, False);
+
+ UserCopyKeyFlag := True;
+end;
+
+procedure TTreeWin.CutPathMIClick(Sender: TObject);
+begin
+ UserCopyKeyFlag := False;
+ MainWin.CopyPathClick(Sender);
+end;
+
+procedure TTreeWin.OpenNextLevel(Node: TTreeNode);
+
+ procedure ExpandKeys(Node: TTreeNode);
+ begin
+ CheckNode(Node, False, True);
+ if not Node.HasChildren then
+ Exit;
+ if not Node.Expanded then
+ Node.Expand(False)
+ else begin
+ Node := Node.GetFirstChild;
+ while Assigned(Node) do begin
+ ExpandKeys(Node);
+ Node := Node.GetNextSibling; end;
+ end;
+ end;
+
+begin
+ DoSmartExpand := False;
+ ExpandKeys(Node);
+ DoSmartExpand := True;
+end;
+
+procedure TTreeWin.EditShortcutMIClick(Sender: TObject);
+var
+ NewPath: string;
+ i: Integer;
+ Node: TTreeNode;
+ Shortcut: PKeyShortcut;
+begin
+ Node := RegTV.Selected;
+ if NodeInfo(Node).HostType <> uhUserShortcut then
+ Exit;
+
+ i := ShortcutIndex(Node);
+ if i = -1 then
+ Exit;
+
+ with TIniFile.Create(PlutoDir + 'Shortcuts.ini') do
+ try
+ NewPath := ReadString('Shortcuts', Shortcuts[i].Alias, '');
+ finally
+ Free;
+ end;
+
+ if not InputQuery('Edit Shortcut', 'Shortcut to...', NewPath) then
+ Exit;
+
+ Node.Collapse(False);
+ Shortcut := @Shortcuts[i];
+ Shortcut.RealPath := TraceKey(NewPath);
+ with TIniFile.Create(PlutoDir + 'Shortcuts.ini') do
+ try
+ WriteString('Shortcuts', Shortcut.Alias, Shortcut.RealPath);
+ finally
+ Free;
+ end;
+
+ RegTVChange(Self, Node);
+end;
+
+procedure TTreeWin.SubKeylist1Click(Sender: TObject);
+var
+ SL: TStringList;
+begin
+ SL := TStringList.Create;
+ if OpenCurKey then
+ try
+ MainReg.GetKeyNames(SL);
+ if PrefWin.SortKeysCB.Checked then
+ SL.Sort;
+ Clipboard.AsText := SL.Text;
+ finally
+ MainReg.CloseKey;
+ SL.Free;
+ end;
+end;
+
+procedure TTreeWin.ValueNameslist1Click(Sender: TObject);
+var
+ SL: TStringList;
+begin
+ SL := TStringList.Create;
+ if OpenCurKey then
+ try
+ MainReg.GetValueNames(SL);
+ if PrefWin.SortKeysCB.Checked then
+ SL.Sort;
+ Clipboard.AsText := SL.Text;
+ finally
+ MainReg.CloseKey;
+ SL.Free;
+ end;
+end;
+
+procedure TTreeWin.KeyInfosMIClick(Sender: TObject);
+begin
+ MessageDlg(GetKeyInfos, mtInformation, [mbOK], 0);
+end;
+
+function TTreeWin.GetKeyInfos: string;
+const
+ sErrorMsg = 'Error! No: %d Msg: %s';
+
+var
+ Node: TTreeNode;
+ Reg: TXRegistry;
+ Mode: TOpenNodeMode;
+ Error: Integer;
+ Info: TNodeInfo;
+ Flag: TNodeFlag;
+
+ procedure Add(const S: string);
+ begin
+ Result := Result + S;
+ end;
+
+ procedure AddLn(const S: string = '');
+ begin
+ Add(S + EOL);
+ end;
+
+ procedure AddNodeInfo(Key: HKEY);
+ var
+ KeyInfo: TRegKeyInfo;
+ Res: Integer;
+ KeyAge: TDateTime;
+ begin
+ FillChar(KeyInfo, SizeOf(TRegKeyInfo), 0);
+ with KeyInfo do begin
+ Res := RegQueryInfoKey(Reg.CurrentKey, nil, nil, nil, @NumSubKeys,
+ @MaxSubKeyLen, nil, @NumValues, @MaxValueLen,
+ @MaxDataLen, nil, @LastWriteTime);
+
+ if Res = ERROR_SUCCESS then begin
+ Add(Format(
+ 'Subkeys: %0:d' + EOL +
+ 'Values: %2:d' + EOL +
+ 'Max subkeys length: %1:d' + EOL +
+ 'Max value name length: %3:d' + EOL +
+ 'Max data length: %4:d' + EOL +
+ '',
+ [NumSubKeys, MaxSubKeyLen, NumValues, MaxValueLen, MaxDataLen]));
+ KeyAge := DateTimeOfFileTime(LastWriteTime);
+ if KeyAge > 0 then
+ AddLn('Last write time: ' + DateTimeToStr(KeyAge));
+ end else
+ AddLn('Couldn''t get key info.' + EOL +
+ 'Error Code: ' + IntToStr(Res) + EOL +
+ 'Message: ' + SysErrorMessage(Res));
+ end;
+ end;
+
+begin
+ Result := '';
+ Node := RegTV.Selected;
+
+ Reg := TXRegistry.Create(KEY_READ);
+ try
+ try
+ Error := OpenNodeError(Reg, RegTV.Selected, Mode);
+
+ case Mode of
+ onFull: AddLn('Full Access');
+ onReadOnly: AddLn('Read only');
+ onError:
+ AddLn(Format(sErrorMsg, [Error, SysErrorMessage(Error)]));
+ onNodeNil: AddLn('Node is nil!');
+
+ else
+ AddLn('Unknown Mode: ' + IntToStr(Integer(Mode)));
+ end;
+
+ if Mode in onOK then
+ AddNodeInfo(Reg.CurrentKey);
+
+ except
+ on E: Exception do begin
+ Error := GetLastError;
+ if Error <> ERROR_SUCCESS then
+ AddLn(Format('Error! No: %d Msg: %s', [Error, SysErrorMessage(Error)]))
+ else
+ AddLn(E.Message);
+ end;
+ end;
+ finally
+ Reg.Free;
+ end;
+
+ if MurphyMode then begin
+ AddLn('[MM] ImageIndex: ' + IntToStr(Node.ImageIndex));
+ Info := NodeInfo(Node);
+
+ if Info.HostType in [uhNone..High(HostTypeStrings)] then
+ AddLn('[MM] HostType: ' + HostTypeStrings[Info.HostType])
+ else
+ AddLn('[MM] Unknown HostType: ' + IntToStr(Integer(Info.HostType)));
+ Add('[MM] Flags: ');
+ for Flag := Low(TNodeFlag) to High(TNodeFlag) do
+ if Flag in Info.Flags then
+ Add(NodeFlagStrings[Flag] + ' ');
+ AddLn;
+ end;
+end;
+
+procedure TTreeWin.ExportAsRegClick(Sender: TObject);
+var
+ Node: TTreeNode;
+ Reg: TXRegistry;
+
+ procedure ExportAsReg4(Reg: TXRegistry; const FileName: string);
+ var
+ Reg4Writer: TReg4Writer;
+ begin
+ Reg4Writer := TReg4Writer.Create(tpNormal, FileName,
+ TraceKey(PathOfNode(Node)), Reg.DeliverKey);
+ with Reg4Writer do begin
+ OnTerminate := Reg4WriterTerminate;
+ try
+ AddHint(Format('starting .reg-export: %s...',
+ [Root + '\' + Path]));
+ Resume;
+ except
+ Free;
+ end;
+ end;
+ AddToLastHint('started.');
+ end;
+
+
+ procedure ExportAsHive(Reg: TXRegistry; const FileName: string);
+ begin
+ if Reg.SaveKey('', FileName) then
+ AddHint('hive export successfull.')
+ else
+ AddHint(Format('hive export failed: %s',
+ [SysErrorMessage(LastSuccessRes)]));
+ end;
+
+begin
+ Node := RegTV.Selected;
+ with ExportD do begin
+ FileName := MakeValidFileName(Node.Text, 'key');
+
+ if Execute then begin
+ Reg := TXRegistry.Create;
+ try
+ if OpenNodeOK(Reg, Node) then begin
+ if FileExists(FileName) and (mrYes=MessageDlg(
+ 'File already exists.' + EOL +
+ 'Delete existing file?',
+ mtWarning, [mbYes, mbNo], 0)) then begin
+ FileSetAttr(FileName, 0);
+ DeleteFile(FileName);
+ end;
+ case FilterIndex of
+ 1: ExportAsReg4(Reg, FileName);
+ 2: ExportAsHive(Reg, FileName);
+ else
+ ShowMessage(Format('Wrong Filter: %d', [FilterIndex]));
+ end;
+ end;
+ finally
+ Reg.Free;
+ end;
+ end;
+ end;
+end;
+
+procedure TTreeWin.FormClose(Sender: TObject; var Action: TCloseAction);
+begin
+// Action := caNone;
+end;
+
+procedure TTreeWin.Load;
+var
+ NodeHKLM, NodeHKU, NodeHKDD, NodeHKPD: TTreeNode;
+ NodeHostReg: TTreeNode;
+
+ procedure LoadShortcuts(FileName: string; HostType: TUniHostType);
+ var
+ i: Integer;
+ SL: TStringList;
+ ShortcutIni: TIniFile;
+ begin
+ if not FileEx(FileName) then begin
+ AddToLastHint('not found:');
+ AddHint(FileName);
+ Exit end;
+
+ ShortcutIni := TIniFile.Create(FileName);
+ SL := TStringList.Create;
+
+ try
+ ShortcutIni.ReadSectionValues('Shortcuts', SL);
+ for i := 0 to SL.Count-1 do
+ AddShortcut(SL.Names[i], SL.Values[SL.Names[i]], iconShortcut,
+ HostType);
+ AddToLastHint('OK');
+ finally
+ SL.Free;
+ ShortcutIni.Free;
+ end;
+ end;
+
+begin
+ NodeHostReg := nil;
+
+ AddHint('Creating Hosts...');
+ RootNodes := TList.Create;
+ ChangeLastHint('Creating Hosts...HKEY_LOCAL_MACHINE');
+ NodeHKLM := RegTV.Items.AddChild(NodeHostReg, 'HKEY_LOCAL_MACHINE');
+ SetTNImage(NodeHKLM, iconHKLM);
+ NodeInfo(NodeHKLM).HostType := uhReg;
+ RootNodes.Add(NodeHKLM);
+
+ ChangeLastHint('Creating Hosts...HKEY_USERS');
+ NodeHKU := RegTV.Items.AddChild(NodeHostReg, 'HKEY_USERS');
+ SetTNImage(NodeHKU, iconHKU);
+ NodeInfo(NodeHKU).HostType := uhReg;
+ RootNodes.Add(NodeHKU);
+
+ ChangeLastHint('Creating Hosts...HKEY_CURRENT_USER');
+ if RegRealPath('HKEY_CURRENT_USER') = 'HKEY_CURRENT_USER' then
+ //could not dereference hkcu
+ AddShortcut('HKEY_CURRENT_USER', 'HKEY_CURRENT_USER',
+ iconHKCU, uhReg)
+ else
+ AddShortcut('HKEY_CURRENT_USER', RegRealPath('HKEY_CURRENT_USER'),
+ iconHKCU, uhSystemShortcut);
+
+ ChangeLastHint('Creating Hosts...HKEY_CURRENT_CONFIG');
+ AddShortcut('HKEY_CURRENT_CONFIG', RegRealPath('HKEY_CURRENT_CONFIG'),
+ iconHKCC, uhSystemShortcut);
+
+ ChangeLastHint('Creating Hosts...HKEY_CLASSES_ROOT');
+ AddShortcut('HKEY_CLASSES_ROOT', RegRealPath('HKEY_CLASSES_ROOT'),
+ iconHKCR, uhSystemShortcut);
+
+ MainReg.RootKey := HKEY_DYN_DATA;
+ if MainReg.OpenKeyReadOnly('') then begin
+ MainReg.CloseKey;
+ ChangeLastHint('Creating Hosts...HKEY_DYN_DATA');
+ NodeHKDD := RegTV.Items.AddChild(nil, 'HKEY_DYN_DATA');
+ NodeInfo(NodeHKDD).HostType := uhReg;
+ NodeInfo(NodeHKDD).IncludeFlag(nfReadOnly);
+ SetTNImage(NodeHKDD, iconHKDD);
+ RootNodes.Add(NodeHKDD);
+ end;
+
+ MainReg.RootKey := HKEY_PERFORMANCE_DATA;
+ if MainReg.OpenKeyReadOnly('') then begin
+ MainReg.CloseKey;
+ ChangeLastHint('Creating Hosts...HKEY_PERFORMANCE_DATA');
+ NodeHKPD := RegTV.Items.AddChild(nil, 'HKEY_PERFORMANCE_DATA');
+ NodeInfo(NodeHKPD).HostType := uhReg;
+ SetTNImage(NodeHKPD, iconHKPD);
+ RootNodes.Add(NodeHKPD);
+ end;
+
+ ChangeLastHint('Creating Host...OK');
+
+ AddHint('Loading Standard Shortcuts...');
+ LoadShortcuts(PlutoDir + StandardShortcutsFileName, uhStandardShortcut);
+
+ AddHint('Loading User Shortcuts...');
+ LoadShortcuts(PlutoDir + ShortcutsFileName, uhUserShortcut);
+
+{$IFDEF UNIKEY}
+ AddShortcut('Uni', '', iconHostUni);
+{$ENDIF}
+end;
+
+procedure TTreeWin.Reg4WriterTerminate(Sender: TObject);
+begin
+ with Sender as TRegFileWriter do
+ AddHint(Format('.reg-export finished (%0.2f s): %s',
+ [Clk.SecsPassed, Root + '\' + Path]));
+end;
+
+end.
+unit valuesU;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+ ComCtrls, Menus, Clipbrd, XReg, CompEx, Math, YTools, Dialogs, YTypes,
+ PlutoConst, keybrd, ImgList, clock;
+
+type
+ TValuesWin = class(TForm)
+ ValueListPU: TPopupMenu;
+ NewStringMI: TMenuItem;
+ NewDWORDMI: TMenuItem;
+ NewBinaryMI: TMenuItem;
+ ConvertToMI: TMenuItem;
+ ConvStringMI: TMenuItem;
+ ConvDWORDMI: TMenuItem;
+ ConvBinaryMI: TMenuItem;
+ ValueList: TListView;
+ DeleteMI: TMenuItem;
+ N1: TMenuItem;
+ RenameMI: TMenuItem;
+ NewElseMI: TMenuItem;
+ NewMultiStringMI: TMenuItem;
+ REGNONE1: TMenuItem;
+ LINK1: TMenuItem;
+ NewExpandStringMI: TMenuItem;
+ N3BINARY1: TMenuItem;
+ N4DWORD1: TMenuItem;
+ N4DWORDLITTLEEDIAN1: TMenuItem;
+ NewBigEndianMI: TMenuItem;
+ N6LINK1: TMenuItem;
+ N7MULTISZ1: TMenuItem;
+ RESOURCELIST1: TMenuItem;
+ N9FULLRESOURCEDESCRIPTOR1: TMenuItem;
+ ARESOURCEREQUIREMENTSLIST1: TMenuItem;
+ NewDefaultValueMI: TMenuItem;
+ EditMI: TMenuItem;
+ EditBinaryMI: TMenuItem;
+ N3: TMenuItem;
+ CopyDataPreviewMI: TMenuItem;
+ DublicateMI: TMenuItem;
+ MultiString1: TMenuItem;
+ ZeromizeMI: TMenuItem;
+ N4: TMenuItem;
+ CopyPathMI: TMenuItem;
+ TakeAsMainValueMI: TMenuItem;
+ SelectAllMI: TMenuItem;
+ InvertSelectionMI: TMenuItem;
+ procedure FormCreate(Sender: TObject);
+ procedure InitListColumnTags;
+
+ procedure NewStringMIClick(Sender: TObject);
+ procedure NewDWORDMIClick(Sender: TObject);
+ procedure NewBinaryMIClick(Sender: TObject);
+ procedure ConvertValue(Sender: TObject);
+
+ procedure CreateValue(Typ: TRegDataType);
+ procedure ZeromizeValue;
+ procedure DeleteValue;
+ procedure CloneValue;
+ function TryRenameValue(OldName: string; var NewName: string): Boolean;
+
+ procedure ValueListChange(Sender: TObject; Item: TListItem; Change: TItemChange);
+ procedure ValueListCustomDrawItem(Sender: TCustomListView; Item: TListItem; State: TCustomDrawState; var DefaultDraw: Boolean);
+ procedure ValueListDblClick(Sender: TObject);
+ procedure ValueListEditing(Sender: TObject; Item: TListItem; var AllowEdit: Boolean);
+ procedure ValueListEdited(Sender: TObject; Item: TListItem; var S: String);
+ procedure ValueListKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure ValueListResize(Sender: TObject);
+
+ function UpdateValue(Reg: TXRegistry; Item: TListItem): Boolean;
+ procedure UpdateValues(SelectedOnly: Boolean = False);
+ procedure Reload(JumpToNewValue: Boolean = False; ValueName: string = '');
+ procedure LoadValues(Reg: TXRegistry);
+
+ function AddValue(Reg: TXRegistry; const ValueName: string; AppendInfos: Boolean = True): TListItem;
+ procedure ValueListPUPopup(Sender: TObject);
+ procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure ValueListDeletion(Sender: TObject; Item: TListItem);
+ procedure DeleteMIClick(Sender: TObject);
+ procedure RenameMIClick(Sender: TObject);
+ procedure NewBigEndianMIClick(Sender: TObject);
+ procedure NewExpandStringMIClick(Sender: TObject);
+ procedure NewMultiStringMIClick(Sender: TObject);
+ procedure NewStrangeTypeMIClick(Sender: TObject);
+ procedure NewDefaultValueMIClick(Sender: TObject);
+ procedure ValueListChanging(Sender: TObject; Item: TListItem; Change: TItemChange; var AllowChange: Boolean);
+ procedure ValueListMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
+ procedure EditBinaryMIClick(Sender: TObject);
+ procedure EditMIClick(Sender: TObject);
+ procedure ValueListCustomDrawSubItem(Sender: TCustomListView; Item: TListItem; SubItem: Integer; State: TCustomDrawState; var DefaultDraw: Boolean);
+ procedure ValueListCompare(Sender: TObject; Item1, Item2: TListItem; Data: Integer; var Compare: Integer);
+ procedure ValueListColumnClick(Sender: TObject; Column: TListColumn);
+ procedure DublicateMIClick(Sender: TObject);
+ procedure CopyDataPreviewMIClick(Sender: TObject);
+ procedure CopyDataPreview;
+ procedure ZeromizeMIClick(Sender: TObject);
+ procedure CopyPathMIClick(Sender: TObject);
+
+ function FindItemByRealName(const ValueName: string): Integer;
+
+ function FocusItem(ARealValueName: string;
+ FocusValueList: Boolean = False): Boolean;
+ procedure TakeAsMainValueMIClick(Sender: TObject);
+ procedure FormShow(Sender: TObject);
+ procedure FormClose(Sender: TObject; var Action: TCloseAction);
+ procedure ValueListClick(Sender: TObject);
+ procedure CheckValueListHotTrack;
+ procedure SelectAllMIClick(Sender: TObject);
+ procedure InvertSelectionMIClick(Sender: TObject);
+ procedure FormDestroy(Sender: TObject);
+ private
+ ValueLabelClicked: Boolean;
+ SortBy: TValueListColumn;
+ SortByColumn: TListColumn;
+ SubItemIndex: array[TValueListColumn] of Integer;
+ public
+ ValueNames: TStringList;
+ ValuesCommon: Boolean;
+ ValueCommonType: TRegDataType;
+ end;
+
+var
+ ValuesWin: TValuesWin;
+ ValueList: TListView;
+
+ DefaultValueCaption: string = '';
+
+function ItemIsDefaultValue(Item: TListItem): Boolean;
+function RealValueName(Item: TListItem): string;
+procedure SetRealValueName(Item: TListItem; Caption: string);
+function IconOfDataType(Typ: TRegDataType): Integer;
+function IsMainValue(Item: TListItem): Boolean;
+
+function ColorOfDataType(DataType: TRegDataType;
+ DefaultColor: TColor = clWhite): TColor;
+function DataPreviewOfContext(Context: TRegContext): string;
+
+function ValueDataSize(Context: TRegContext): string;
+function ValueDataType(Context: TRegContext): string;
+function ValueDataPreview(Context: TRegContext): string;
+function ValueTypeIcon(Context: TRegContext): Integer;
+
+function StrOfRegDataType(Typ: TRegDataType): string;
+
+implementation
+
+uses PlutoMain, TreeU, WorkU, PrefU;
+
+{$R *.dfm}
+
+function ItemIsDefaultValue(Item: TListItem): Boolean;
+begin
+ Result := Item.Data = Pointer(DefaultValueFlag);
+end;
+
+function RealValueName(Item: TListItem): string;
+begin
+ if ItemIsDefaultValue(Item) then
+ Result := ''
+ else
+ Result := Item.Caption;
+end;
+
+procedure SetRealValueName(Item: TListItem; Caption: string);
+begin
+ if Caption = '' then begin
+ Item.Caption := DefaultValueCaption;
+ Item.Data := Pointer(DefaultValueFlag);
+ end else begin
+ Item.Caption := Caption;
+ Item.Data := nil;
+ end;
+end;
+
+function IsMainValue(Item: TListItem): Boolean;
+begin
+ Result := False;
+ if csDestroying in PrefWin.ComponentState then
+ Exit;
+
+ Result := RealValueName(Item) = PrefWin.MainPreviewE.Text;
+end;
+
+function ColorOfDataType(DataType: TRegDataType;
+ DefaultColor: TColor = clWhite): TColor;
+begin
+ if DataType in rdStringTypes then Result := clBrightRed
+ else if DataType = rdMultiString then Result := clBrightPurple
+ else if DataType in rdCardTypes then Result := clBrightBlue
+ else if DataType = rdBinary then Result := clBrightGreen
+ else Result := DefaultColor;
+end;
+
+function StrOfRegDataType(Typ: TRegDataType): string;
+const
+ RegDataTypeStrings: array[rdNone..rdLastType] of string = (
+ 'NONE',
+ 'SZ',
+ 'EXPAND_SZ',
+ 'BINARY',
+ 'DWORD',
+ 'DWORD_BIG_ENDIAN',
+ 'LINK',
+ 'MULTI_SZ',
+ 'RESOURCE_LIST',
+ 'FULL_RESOURCE_DESCRIPTOR',
+ 'RESOURCE_REQUIREMENTS_LIST',
+ 'QUAD_WORD'
+ );
+begin
+ if Typ in [rdNone..rdLastType] then
+ Result := RegDataTypeStrings[Typ]
+ else
+ Result := IntToStr(Typ);
+end;
+
+procedure TValuesWin.NewStringMIClick(Sender: TObject);
+begin
+ CreateValue(rdString);
+end;
+
+procedure TValuesWin.NewDWORDMIClick(Sender: TObject);
+begin
+ CreateValue(rdCardinal);
+end;
+
+procedure TValuesWin.NewBinaryMIClick(Sender: TObject);
+begin
+ CreateValue(rdBinary);
+end;
+
+procedure TValuesWin.CreateValue(Typ: TRegDataType);
+var
+ Item: TListItem;
+ ValueName: string;
+ i: Integer;
+ SL: TStringList;
+begin
+ if csDestroying in (TreeWin.ComponentState + MainWin.ComponentState) then
+ Exit;
+
+ if TreeWin.CantWrite then
+ Exit;
+
+ with MainReg do begin
+ try
+ OpenCurKey;
+
+ ValueName := 'New'; // find free name
+ i := 0;
+ while ValueExists(ValueName) do begin
+ Inc(i);
+ ValueName := 'New ' + IntToStr(i);
+ end;
+
+ case Typ of
+ rdString: begin
+ WriteString(ValueName, '');
+ end;
+ rdExpandString: begin
+ WriteExpandString(ValueName, '');
+ end;
+ rdCardinal: begin
+ WriteCardinal(ValueName, 0);
+ end;
+ rdCardBigEndian: begin
+ WriteCardinal(ValueName, 0, True);
+ end;
+ rdMultiString: begin
+ SL := TStringList.Create;
+ WriteMultiString(ValueName, SL);
+ SL.Free;
+ end;
+ rdBinary: begin
+ WriteBin(ValueName, nil);
+ end;
+ else
+ WriteBinType(ValueName, nil, Typ);
+ end;
+
+ if not ValueExists(ValueName) then begin
+ ShowMessage('Could not create Value.');
+ CloseKey;
+ Exit; end;
+
+ ValuesWin.AddValue(MainReg, ValueName);
+ finally
+ CloseKey;
+ end;
+ end;
+
+ Item := FindItem(ValueList, ValueName);
+
+ if not Assigned(Item) then begin
+ ShowMessage('Error, Value not found: ' + ValueName);
+ Exit; end;
+
+ SelectItemOnly(ValueList, Item);
+ MainWin.StatusBarUpdate;
+ ValueLabelClicked := True;
+ Item.EditCaption;
+end;
+
+procedure TValuesWin.FormCreate(Sender: TObject);
+begin
+ ValuesU.ValueList := ValueList;
+
+ DefaultValueCaption := PrefWin.DefaultValueNameE.Text;
+ ValueLabelClicked := False;
+ SortBy := vlcName;
+ SortByColumn := nil;
+
+ ValueListResize(Sender);
+ ValueList.Items.Clear;
+ CheckValueListHotTrack;
+
+ ValueNames := TStringList.Create;
+ ValuesCommon := False;
+ ValueCommonType := 0;
+
+ NewDefaultValueMI.ImageIndex := iconMainValue;
+ NewStringMI.ImageIndex := iconString;
+ NewDWORDMI.ImageIndex := iconCardinal;
+ NewBinaryMI.ImageIndex := iconBinary;
+ NewMultiStringMI.ImageIndex := iconMultiString;
+ NewElseMI.ImageIndex := iconValueElse;
+
+ DublicateMI.ImageIndex := iconValueDublicate;
+ DeleteMI.ImageIndex := iconDelete;
+ ZeromizeMI.ImageIndex := iconValueZeromize;
+
+ EditMI.ImageIndex := iconValueEdit;
+ EditBinaryMI.ImageIndex := iconValueEditBinary;
+ RenameMI.ImageIndex := iconRename;
+
+ TakeAsMainValueMI.ImageIndex := iconTakeAsMainValue;
+end;
+
+procedure TValuesWin.ConvertValue(Sender: TObject);
+{var
+ Allow: Boolean;
+ OldActive: Integer; }
+begin
+{ TargetPage := ShowPC.Pages[TMenuItem(Sender).Tag];
+
+ OldActive := ShowPC.ActivePageIndex;
+ ShowPC.ActivePageIndex := TMenuItem(Sender).Tag;
+ WorkWin.ShowPCChanging(Sender, Allow);
+ if not Allow then
+ ShowPC.ActivePageIndex := OldActive; }
+end;
+
+function ValueDataSize(Context: TRegContext): string;
+var
+ Typ: TRegDataType;
+ Size: Integer;
+// ValueName: string;
+// SL: TStringList;
+begin
+ Result := '';
+
+ if csDestroying in PrefWin.ComponentState then
+ Exit;
+
+// ValueName := RealValueName(Item);
+ Typ := Context.Typ;
+ Size := Length(Context.Data);
+
+ if Typ in rdStringTypes then
+ if not PrefWin.CountZeroByteCB.Checked then
+ Dec(Size);
+
+ if Typ = rdMultiString then
+ if PrefWin.ShowLineCountCB.Checked then begin
+ Size := CharCount(StrOfByteA(Context.Data), #0) - 2;
+{ SL := TStringList.Create;
+ try
+ Reg.ReadMultiString(ValueName, SL, PrefWin.UseExtendedModelCB.Checked);
+ Size := SL.Count;
+ finally
+ SL.Free;
+ end; }
+ Result := '#';
+ end;
+
+ Result := Result + IntToStr(Size);
+end;
+
+function ValueDataType(Context: TRegContext): string;
+begin
+ Result := StrOfRegDataType(Context.Typ);
+end;
+
+function DataPreviewOfContext(Context: TRegContext): string;
+
+ function DWORDPreview(Value: Integer): string;
+ begin
+ if PrefWin.ShowDwordAsHex.Checked then
+ Result := IntToStr(Value) + ' = $' + IntToHex(Value, 8)
+ else
+ Result := IntToStr(Value)
+ end;
+
+ function BinaryPreview(Context: TRegContext): string;
+ var
+ z: string;
+
+ function DWORDStringOfByteA(a: TByteA; AddBinary: Boolean = False): string;
+ var
+ piece: TByteA;
+ i: Integer;
+ begin
+ Result := '';
+
+ i := 0;
+ while (i <= High(a)) and (Length(Result) < MaxPreviewLen) do begin
+ piece := Copy(a, i, 4);
+ if AddBinary then
+ Result := Result + FriendlyStr(piece) + '=';
+ SetLength(piece, 4);
+ Result := Result + IntToStr(PInteger(piece)^) + ' ';
+ Inc(i, SizeOf(Integer));
+ end;
+ end;
+
+ begin
+ with Context do begin
+ Data := Copy(Data, 0, MaxPreviewLen);
+ case PrefWin.ShowBinaryAsRG.ItemIndex of
+ 0: z := FriendlyStr(Data);
+ 1: z := DWORDStringOfByteA(Data);
+ 2: z := DWORDStringOfByteA(Data, True);
+ 3: z := BinOfByteA(Data, 8, ' ');
+ 4: z := HexOfByteA(Data, 0);
+ 5: z := HexOfByteA(Data, 1);
+ 6: z := HexOfByteA(Data, 2);
+ 7: z := HexOfByteA(Data, 4);
+ end;
+ end;
+
+ Result := Copy(z, 1, MaxPreviewLen);
+ end;
+
+ function StringPreview(Context: TRegContext): string;
+ var
+ s: string;
+ Expanded: string;
+ DoExpand: Boolean;
+ begin
+ s := PChar(Context.Data);
+ with PrefWin do
+ Result := StringQuoterBegin + FriendlyStr(s) + StringQuoterEnd;
+ if s = '' then
+ Exit;
+
+ case PrefWin.ExpandStringsRG.ItemIndex of
+ 0: DoExpand := False;
+ 1: DoExpand := (Context.Typ = rdExpandString) and (CharCount(s, '%') >= 2);
+ 2: DoExpand := True;
+ else
+ ShowMessage('Error: Unknown PrefWin.ExpandStringsRG.ItemIndex!');
+ PrefWin.ExpandStringsRG.ItemIndex := 0;
+ Exit;
+ end;
+
+ if DoExpand then begin
+ Expanded := ExpandString(s);
+ if s <> Expanded then
+ Result := Result + ' <' + Expanded + '>';
+ end;
+ end;
+
+ function IntegerPreview(Context: TRegContext): string;
+ begin
+ if Length(Context.Data) >= SizeOf(Cardinal) then begin
+ Result := DWORDPreview(PInteger(Context.Data)^);
+ end else
+ Result := BinaryPreview(Context);
+ end;
+
+ function MultiStringPreview(Context: TRegContext): string;
+ var
+ z: string;
+ SL: TStringList;
+ i: Integer;
+ begin
+ z := '';
+
+ SL := TStringList.Create;
+ try
+ RegMultiStringOfByteA(Context.Data, SL, PrefWin.UseExtendedModelCB.Checked);
+
+ for i := 0 to SL.Count-1 do
+ z := z + SL[i] + ' ';
+ finally
+ SL.Free;
+ end;
+
+ Result := Copy(FriendlyStr(z), 1, MaxPreviewLen);
+ end;
+
+begin
+ Result := '';
+
+ if csDestroying in PrefWin.ComponentState then
+ Exit;
+
+ if (Context.Data = nil) or (Length(Context.Data) > RegMaxDataSize) then
+ Exit;
+
+ if Length(Context.Data) > MaxPreviewLen then
+ SetLength(Context.Data, MaxPreviewLen);
+
+ if PrefWin.ShowAsBinaryCB.Checked then begin
+ Result := BinaryPreview(Context);
+ Exit; end;
+
+ case Context.Typ of
+ rdExpandString, rdString: Result := StringPreview(Context);
+ rdCardinal, rdCardBigEndian: Result := IntegerPreview(Context);
+ rdMultiString: Result := MultiStringPreview(Context);
+ else
+ if PrefWin.Smart4BBCB.Checked and (Length(Context.Data) = 4) then
+ Result := IntegerPreview(Context)
+ else
+ Result := BinaryPreview(Context);
+ end;
+end;
+
+function ValueDataPreview(Context: TRegContext): string;
+begin
+ Result := DataPreviewOfContext(Context);
+end;
+
+function IconOfDataType(Typ: TRegDataType): Integer;
+begin
+ if Typ in [rdNone..rdLastType] then
+ Result := iconFirstType + Ord(Typ)
+ else
+ Result := iconUnknownType;
+end;
+
+function ValueTypeIcon(Context: TRegContext): Integer;
+begin
+ Result := IconOfDataType(Context.Typ);
+end;
+
+function TValuesWin.UpdateValue(Reg: TXRegistry; Item: TListItem): Boolean;
+//Return Value: True if something has changed
+var
+ Size, Typ, Data: string;
+ Icon: Integer;
+ Context: TRegContext;
+begin
+ Result := False;
+ if not Assigned(Item) then
+ Exit;
+
+ Context := Reg.ReadContext(RealValueName(Item));
+ Data := ValueDataPreview(Context);
+ Size := ValueDataSize(Context);
+ Typ := ValueDataType(Context);
+ Icon := ValueTypeIcon(Context);
+
+ if Icon <> Item.ImageIndex then begin
+ Item.ImageIndex := Icon;
+ Result := True;
+ end;
+
+ while Item.SubItems.Count < Integer(High(TValueListColumn)) do
+ Item.SubItems.Add('');
+
+ if Size <> Item.SubItems[SubItemIndex[vlcSize]] then begin
+ Result := True;
+ Item.SubItems[SubItemIndex[vlcSize]] := Size;
+ end;
+
+ if Typ <> Item.SubItems[SubItemIndex[vlcType]] then begin
+ Result := True;
+ Item.SubItems[SubItemIndex[vlcType]] := Typ;
+ end;
+
+ if (Data <> Item.SubItems[SubItemIndex[vlcData]]) then begin
+ Result := True;
+ Item.SubItems[SubItemIndex[vlcData]] := Data;
+ if IsMainValue(Item) then
+ RegTV.Repaint;
+ end;
+end;
+
+procedure AppendNewValueInfos(Item: TListItem; Context: TRegContext);
+begin
+ Item.ImageIndex := ValueTypeIcon(Context);
+ with Item.SubItems do begin
+ Append(ValueDataSize(Context));
+ Append(ValueDataType(Context));
+ Append(ValueDataPreview(Context));
+ end;
+end;
+
+function TValuesWin.AddValue(Reg: TXRegistry; const ValueName: string;
+ AppendInfos: Boolean = True): TListItem;
+begin
+ Result := ValueList.Items.AddItem(nil, -1);
+ Result.Indent := -1;
+ SetRealValueName(Result, ValueName);
+ if AppendInfos then
+ AppendNewValueInfos(Result, Reg.ReadContext(ValueName));
+end;
+
+procedure TValuesWin.ValueListChange(Sender: TObject; Item: TListItem;
+ Change: TItemChange);
+var
+ ValueName: string;
+ Reg: TXRegistry;
+
+ function ComputeValuesCommon(Reg: TXRegistry; var DataType: TRegDataType): Boolean;
+ var
+ i: Integer;
+ ItemType: TRegDataType;
+ begin
+ Result := False;
+
+ i := 0;
+ DataType := 0;
+ while i < ValueList.Items.Count do begin
+ Item := ValueList.Items[i];
+ if not Item.Selected then begin
+ Inc(i);
+ Continue; end;
+
+ ValueName := RealValueName(Item);
+ if Reg.ValueReallyExists(ValueName) then begin
+
+ ItemType := Reg.GetDataType(ValueName);
+ if not Result then begin
+ DataType := ItemType;
+ Result := True;
+ end else if ItemType <> DataType then begin
+ Result := False;
+ DataType := 0;
+ Break; end;
+
+ with ValueNames do
+ if Item.Focused then
+ Insert(0, ValueName)
+ else
+ Add(ValueName);
+
+ end else begin
+ ShowMessage('Value has been deleted!');
+ DataType := 0;
+ Result := False;
+ Reload;
+ Break; end;
+
+ Inc(i);
+ end;
+ end;
+
+begin
+ if not Assigned(Item) or ValueList.IsEditing or not ValueList.Enabled then
+ Exit;
+
+ if Change <> ctState then
+ Exit;
+
+ if csDestroying in WorkWin.ComponentState then
+ Exit;
+
+ if (ValueList.SelCount = 0) then begin
+ ValueNames.Clear;
+ WorkWin.ReInitShowPC;
+ Exit; end;
+
+ if not Item.Focused then
+ Exit;
+
+ WorkWin.ReInitShowPC;
+
+ ValueNames.Clear;
+ Reg := TXRegistry.Create;
+ try
+ if OpenNodeOK(Reg, RegTV.Selected) then begin
+ ValuesCommon := ComputeValuesCommon(Reg, ValueCommonType);
+ if ValuesCommon then
+ WorkWin.ShowValues(Reg);
+ end;
+ finally
+ Reg.Free;
+ end;
+
+ if csDestroying in MainWin.ComponentState then
+ Exit;
+
+ if ActiveControl = ValueList then
+ MainWin.SetStatus;
+end;
+
+procedure TValuesWin.ValueListCustomDrawItem(Sender: TCustomListView;
+ Item: TListItem; State: TCustomDrawState; var DefaultDraw: Boolean);
+begin
+ with ValueList.Canvas.Font do begin
+ if Item.Focused then
+ Style := Style + [fsBold];
+ if ItemIsDefaultValue(Item) then
+ Color := clBrightYellow
+ else
+ Color := ColorOfDataType(TRegDataType(Item.ImageIndex - iconFirstType));
+ end;
+end;
+
+procedure TValuesWin.ValueListDblClick(Sender: TObject);
+begin
+ ValueListChange(Sender, ValueList.ItemFocused, ctState);
+ MainPC.ActivePage := WorkWin.WorkPage;
+
+ if not Assigned(ValueList.ItemFocused) then
+ Exit;
+
+ if csDestroying in WorkWin.ComponentState then
+ Exit;
+
+ WorkWin.EditData;
+end;
+
+procedure TValuesWin.ValueListEditing(Sender: TObject; Item: TListItem;
+ var AllowEdit: Boolean);
+begin
+ if not ValueLabelClicked then begin
+ AllowEdit := False;
+ Exit; end;
+
+ if ItemIsDefaultValue(Item) then //unschön, aber beste Lösung bisher
+ Keyboard.SimKey(VK_DELETE);
+end;
+
+procedure TValuesWin.ValueListEdited(Sender: TObject; Item: TListItem;
+ var S: string);
+var
+ Old: string;
+ OldCaption: string;
+begin
+ OldCaption := Item.Caption;
+ Old := RealValueName(Item);
+
+ if s = Old then begin
+ if ItemIsDefaultValue(Item) then
+ s := DefaultValueCaption;
+ Exit; end;
+
+ SpyThread.Suspend;
+ try
+ Item.Caption := s;
+
+ if TryRenameValue(Old, s) then begin
+ SetRealValueName(Item, s); //Sichere Zuweisung des Standard-Flags
+ s := Item.Caption; //Anschließend externer Aufruf "Item.Caption := s"!
+ end else begin
+ s := OldCaption;
+ end;
+
+ finally
+ SpyThread.Restart := True;
+ SpyThread.Resume;
+ end;
+end;
+
+procedure TValuesWin.ValueListKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+var
+ T: string;
+ Item: TListItem;
+begin
+ if ValueList.IsEditing then
+ Exit;
+
+ if csDestroying in TreeWin.ComponentState then
+ Exit;
+
+ Item := ValueList.ItemFocused;
+
+ case Key of
+ VK_SPACE: JumpToSel(ValueList);
+
+ VK_F9: SwapFonts(ValueList);
+
+ VK_F5: Reload;
+
+ VK_F12: begin //Sort
+ if Assigned(Item) then
+ T := Item.Caption;
+ ValueList.SortType := TSortType(2 - (Integer(ValueList.SortType)));
+ if ValueList.SortType = stNone then
+ TreeWin.RegTVChange(Sender, RegTV.Selected);
+ ValueList.ItemFocused := FindItem(ValueList, T);
+ if Assigned(ValueList.ItemFocused) then
+ ValueList.ItemFocused.MakeVisible(True);
+ end;
+
+ VK_DELETE: DeleteMIClick(Sender);
+
+ VK_RETURN: ValueListDblCLick(Sender);
+
+ Ord('C'):
+ if not ValueList.IsEditing then
+ CopyPathMIClick(Sender);
+
+ VK_SCROLL: CheckValueListHotTrack;
+ end;
+end;
+
+procedure TValuesWin.ValueListResize(Sender: TObject);
+begin
+ with ValueList do
+ Columns[3].Width := ClientWidth - (0 +
+ Columns[0].Width + Columns[1].Width + Columns[2].Width);
+end;
+
+procedure TValuesWin.DeleteValue;
+var
+ Item, NewSel: TListItem;
+ YesToAll: Boolean;
+ i: Integer;
+
+ procedure DeleteIt(Item: TListItem);
+ begin
+ OpenCurKey;
+ if MainReg.DeleteValue(RealValueName(Item))
+ and not MainReg.ValueReallyExists(RealValueName(Item)) then begin
+ Item.Delete;
+ end else begin
+ ShowMessage('Could not delete Value ' + Quote(RealValueName(Item)));
+ Inc(i);
+ end;
+ MainReg.CloseKey;
+
+ if IsMainValue(Item) then
+ RegTV.Repaint;
+ end;
+
+begin
+ SpyThread.Suspend;
+
+ NewSel := GetNextBestNotSelected(ValueList.ItemFocused);
+
+ YesToAll := False;
+ i := 0;
+ while i < ValueList.Items.Count do begin
+ Item := ValueList.Items[i];
+ if not Item.Selected then begin
+ Inc(i);
+ Continue; end;
+
+ if YesToAll then
+ DeleteIt(Item)
+ else begin
+ case MessageDlg('Do you really want to delete the Value ' +
+ Quote(RealValueName(Item)) + '?',
+ mtConfirmation, [mbYes, mbYesToAll, mbNo, mbCancel], 0) of
+ mrYes: DeleteIt(Item);
+ mrYesToAll: YesToAll := True;
+ mrCancel: Exit;
+ mrNo: begin
+ Item.Selected := False;
+ NewSel := Item;
+ end;
+ end;
+ end;
+ end;
+
+ if Assigned(NewSel) then begin
+ ValueList.ItemFocused := NewSel;
+ NewSel.Selected := True;
+ end else
+ WorkWin.ReInitShowPC;
+
+ SpyThread.Restart := True;
+ SpyThread.Resume;
+end;
+
+procedure TValuesWin.ZeromizeValue;
+var
+ Item: TListItem;
+ YesToAll: Boolean;
+ i: Integer;
+
+ procedure ZeromizeIt(Item: TListItem);
+ begin
+ with MainReg do begin
+ OpenCurKey;
+ ZeromizeValue(RealValueName(Item));
+ UpdateValue(MainReg, Item);
+ CloseKey;
+ end;
+ end;
+
+begin
+ SpyThread.Suspend;
+
+ YesToAll := False;
+ i := 0;
+ while i < ValueList.Items.Count do begin
+ Item := ValueList.Items[i];
+ if not Item.Selected then begin
+ Inc(i);
+ Continue; end;
+
+ if YesToAll then
+ ZeromizeIt(Item)
+ else
+ case MessageDlg('Do you really want to zeromize ValueData of ' +
+ Quote(RealValueName(Item)) + ' ?',
+ mtConfirmation, [mbYes, mbYesToAll, mbNo, mbCancel], 0) of
+
+ mrYes: begin
+ ZeromizeIt(Item);
+ Inc(i);
+ end;
+
+ mrYesToAll: begin
+ YesToAll := True;
+ ZeromizeIt(Item);
+ end;
+ mrCancel: Exit;
+ end;
+
+ if IsMainValue(Item) then
+ RegTV.Repaint;
+ end;
+
+
+ SpyThread.Resume;
+end;
+
+procedure TValuesWin.ValueListPUPopup(Sender: TObject);
+var
+ Writable, ValueOK, OnlyOneValue, OneValueOK: Boolean;
+ Item: TListItem;
+begin
+ if Assigned(ValueList.ItemFocused) then
+ ValueList.ItemFocused.Selected := True;
+
+ if csDestroying in (TreeWin.ComponentState + PrefWin.ComponentState) then
+ Exit;
+
+ Writable := not TreeWin.CantWrite;
+ NewDefaultValueMI.Visible := Writable;
+ NewStringMI.Visible := Writable;
+ NewDWORDMI.Visible := Writable;
+ NewBinaryMI.Visible := Writable;
+ NewMultiStringMI.Visible := Writable;
+ NewElseMI.Visible := Writable;
+
+ ValueOK := Writable and (ValueList.ItemFocused <> nil);
+ OnlyOneValue := ValueList.SelCount = 1;
+ OneValueOK := OnlyOneValue and ValueOK;
+
+ EditMI.Visible := ValueOK;
+ EditBinaryMI.Visible := ValueOK;
+ DublicateMI.Visible := OneValueOK;
+ CopyPathMI.Visible := OnlyOneValue;
+ CopyDataPreviewMI.Visible := OnlyOneValue;
+ TakeAsMainValueMI.Visible := OnlyOneValue;
+ RenameMI.Visible := OneValueOK;
+ DeleteMI.Visible := ValueOK;
+ ZeromizeMI.Visible := ValueOK;
+
+ Item := ValueList.ItemFocused;
+ if not Assigned(Item) then
+ Exit;
+
+ TakeAsMainValueMI.Checked := RealValueName(Item) = PrefWin.MainPreviewE.Text;
+end;
+
+procedure TValuesWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if ValueList.IsEditing then
+ Exit;
+
+ if csDestroying in MainWin.ComponentState then
+ Exit;
+ MainWin.FormKeyDown(Sender, Key, Shift);
+end;
+
+procedure TValuesWin.ValueListDeletion(Sender: TObject; Item: TListItem);
+begin
+ if Assigned(SpyThread) then
+ SpyThread.Restart := True;
+
+ if csDestroying in WorkWin.ComponentState then
+ Exit;
+
+ if Assigned(ShowPC.ActivePage)
+ and Item.Selected and Item.Focused then begin
+ ValueList.ItemFocused := GetNextBest(Item);
+ WorkWin.ReInitShowPC;
+ end;
+end;
+
+procedure TValuesWin.DeleteMIClick(Sender: TObject);
+begin
+ if ValueList.IsEditing then
+ Exit;
+
+ DeleteValue;
+end;
+
+procedure TValuesWin.RenameMIClick(Sender: TObject);
+begin
+ if Assigned(ValueList.ItemFocused) then begin
+ ValueLabelClicked := True;
+ ValueList.ItemFocused.EditCaption;
+ ValueLabelClicked := False;
+ end;
+end;
+
+procedure TValuesWin.NewBigEndianMIClick(Sender: TObject);
+begin
+ CreateValue(rdCardBigEndian);
+end;
+
+procedure TValuesWin.NewExpandStringMIClick(Sender: TObject);
+begin
+ CreateValue(rdExpandString);
+end;
+
+procedure TValuesWin.NewMultiStringMIClick(Sender: TObject);
+begin
+ CreateValue(rdMultiString);
+end;
+
+procedure TValuesWin.NewStrangeTypeMIClick(Sender: TObject);
+begin
+ CreateValue(TRegDataType(TMenuItem(Sender).Tag));
+end;
+
+procedure TValuesWin.NewDefaultValueMIClick(Sender: TObject);
+var
+ DefaultItem: TListItem;
+ i: Integer;
+begin
+ if csDestroying in (TreeWin.ComponentState + MainWin.ComponentState) then
+ Exit;
+ if TreeWin.CantWrite then
+ Exit;
+
+ with MainReg do begin
+ try
+ OpenCurKey;
+
+ if StandardValueExists then begin
+ ShowMessage('Default Value already exists.');
+ CloseKey;
+ Exit; end;
+
+ WriteString('', '');
+
+ if not StandardValueExists then begin
+ ShowMessage('Could not create Default Value.');
+ CloseKey;
+ Exit; end;
+
+ ValuesWin.AddValue(MainReg, '');
+ finally
+ CloseKey;
+ end;
+ end;
+
+ with ValueList.Items do begin
+ DefaultItem := nil;
+ for i := 0 to Count-1 do
+ if ItemIsDefaultValue(Item[i]) then
+ Break;
+
+ if i < Count then
+ DefaultItem := Item[i];
+ end;
+
+ if not Assigned(DefaultItem) then
+ ShowMessage('Error: Lost Default Value!')
+ else begin
+ SelectItemOnly(ValueList, DefaultItem);
+ MainWin.StatusBarUpdate;
+ ValueListDblClick(Sender);
+ end;
+end;
+
+procedure TValuesWin.ValueListChanging(Sender: TObject; Item: TListItem;
+ Change: TItemChange; var AllowChange: Boolean);
+begin
+ if Item = nil then
+ AllowChange := False;
+end;
+
+procedure TValuesWin.ValueListMouseDown(Sender: TObject; Button: TMouseButton;
+ Shift: TShiftState; X, Y: Integer);
+begin
+ ValueLabelClicked := False;
+ with ValueList do
+ if ([htOnIcon, htOnLabel] * GetHitTestInfoAt(X, Y)) <> [] then
+ ValueLabelClicked := True;
+end;
+
+procedure TValuesWin.EditBinaryMIClick(Sender: TObject);
+begin
+ if csDestroying in WorkWin.ComponentState then
+ Exit;
+
+ WorkWin.ShowAsBinary := True;
+ ValueListChange(Sender, ValueList.ItemFocused, ctState);
+ ValueListDblClick(Sender);
+end;
+
+procedure TValuesWin.EditMIClick(Sender: TObject);
+begin
+ ValueListDblClick(Sender);
+end;
+
+procedure TValuesWin.ValueListCustomDrawSubItem(Sender: TCustomListView;
+ Item: TListItem; SubItem: Integer; State: TCustomDrawState;
+ var DefaultDraw: Boolean);
+begin
+ with ValueList.Canvas.Font do begin
+ Style := [];
+ if SubItem = 1 then
+ Color := clSilver
+ else
+ Color := ColorOfDataType(TRegDataType(Item.ImageIndex - iconFirstType));
+ end;
+end;
+
+procedure TValuesWin.ValueListCompare(Sender: TObject; Item1, Item2: TListItem;
+ Data: Integer; var Compare: Integer);
+begin
+ case SortBy of
+ vlcName: Compare := AnsiCompareText(RealValueName(Item1), RealValueName(Item2));
+ vlcSize: Compare := Integer(
+ StrToIntDef(Item1.SubItems[SubItemIndex[vlcSize]], -1) >
+ StrToIntDef(Item2.SubItems[SubItemIndex[vlcSize]], -1));
+ vlcData: Compare := Integer(Item1.SubItems[SubItemIndex[vlcData]] >
+ Item2.SubItems[SubItemIndex[vlcData]]);
+ vlcType: Compare := Integer(Item1.ImageIndex > Item2.ImageIndex);
+ end;
+
+ if Assigned(SortByColumn)
+ and (SortByColumn.ImageIndex = iconSortArrowDesc) then
+ Compare := 1 - Compare;
+end;
+
+procedure TValuesWin.ValueListColumnClick(Sender: TObject; Column: TListColumn);
+begin
+ case Column.ImageIndex of
+ iconSortArrowAsc: Column.ImageIndex := iconSortArrowDesc;
+ iconSortArrowDesc: Column.ImageIndex := -1;
+ else
+ if Assigned(SortByColumn) then
+ SortByColumn.ImageIndex := -1;
+ if TValueListColumn(Column.Tag) in ValueListColumnRange then
+ SortBy := TValueListColumn(Column.Tag)
+ else
+ ShowMessage('Unknown Column Tag');
+ Column.ImageIndex := iconSortArrowAsc;
+ end;
+
+ if Column.ImageIndex = -1 then
+ ValueList.SortType := stNone
+ else begin
+ ValueList.SortType := stData;
+ SortByColumn := Column;
+ end;
+
+ Update;
+ ValueList.AlphaSort;
+end;
+
+procedure TValuesWin.CloneValue;
+var
+ OldName, NewName: string;
+
+ function GetNewName(Reg: TXRegistry; const OldName: string): string;
+ var
+ i: Integer;
+ Prefix: string;
+ begin
+ if OldName = '' then
+ Result := 'New Default Value'
+ else if Copy(OldName, 1, 4) <> 'New ' then
+ Result := 'New ' + OldName
+ else
+ Result := OldName;
+
+ Prefix := Result;
+ i := 1;
+ while Reg.ValueExists(Result) do begin
+ Result := Prefix + ' ' + IntToStr(i);
+ Inc(i);
+ end;
+ end;
+
+begin
+ if csDestroying in TreeWin.ComponentState then
+ Exit;
+
+ if TreeWin.CantWrite then
+ Exit;
+
+ OldName := RealValueName(ValueList.ItemFocused);
+
+ try
+ OpenCurKey;
+
+ NewName := GetNewName(MainReg, OldName);
+ MainReg.CopyValue(OldName, NewName);
+ AddValue(MainReg, NewName);
+ finally
+ MainReg.CloseKey;
+ end;
+end;
+
+procedure TValuesWin.DublicateMIClick(Sender: TObject);
+begin
+ CloneValue;
+end;
+
+procedure TValuesWin.CopyDataPreviewMIClick(Sender: TObject);
+begin
+ if ValueList.IsEditing then
+ Exit;
+
+ CopyDataPreview;
+end;
+
+procedure TValuesWin.CopyDataPreview;
+begin
+ OpenCurKey;
+ Clipboard.AsText := DataPreviewOfContext(MainReg.ReadContext(
+ RealValueName(ValueList.ItemFocused)));
+ MainReg.CloseKey;
+end;
+
+procedure TValuesWin.UpdateValues(SelectedOnly: Boolean = False);
+var
+ i: Integer;
+ Reg: TXRegistry;
+begin
+ if not Started then
+ Exit;
+
+ SpyThread.Suspend;
+
+ Reg := TXRegistry.Create;
+ try
+ if OpenNodeOK(Reg, RegTV.Selected) then
+ with ValueList.Items do begin
+ for i := 0 to Count-1 do begin
+ if SelectedOnly and not Item[i].Selected then
+ Continue;
+ UpdateValue(Reg, Item[i]);
+ end;
+ end;
+ finally
+ Reg.Free;
+ end;
+
+ SpyThread.Resume;
+end;
+
+function TValuesWin.TryRenameValue(OldName: string;
+ var NewName: string): Boolean;
+var
+ x: string;
+begin
+ Result := False;
+ if OldName = NewName then
+ Exit;
+
+ if (Length(NewName) > RegMaxValueNameLen) then begin
+ NewName := Copy(NewName, 1, RegMaxValueNameLen);
+ if MessageDlg(
+ 'The maximum size of a value name is ' + IntToStr(RegMaxValueNameLen) + ' characters.' + EOL +
+ 'Shorten the value name to:' + EOL +
+ Quote(StringWrap(NewName, 80)),
+ mtConfirmation, [mbOK, mbCancel], 0) <> mrOK then
+ Exit;
+ end;
+
+ if CharIn(NewName, [#0..#31]) then begin
+ NewName := ReplaceChars(NewName, [#0..#31], '#');
+ if MessageDlg('The following chars are not allowed in ValueNames:' + EOL +
+ '- Control chars (#0..#31)' + EOL +
+ 'The following name is allowed:' + EOL +
+ NewName + EOL +
+ 'Use this name instead?',
+ mtConfirmation, [mbYes, mbNo], 0) <> mrYes then
+ Exit;
+ end;
+
+ if not OpenCurKey then
+ Exit;
+
+ if SameText(OldName, NewName) then begin //CharCase ändern
+ x := MainReg.GetFreeValueName;
+ MainReg.RenameValue(OldName, x);
+ MainReg.RenameValue(x, NewName);
+ end else begin
+ if not MainReg.ValueReallyExists(NewName) then begin
+ MainReg.RenameValue(OldName, NewName);
+ end else begin
+ if NewName = '' then
+ ShowMessage('Default value already exists.')
+ else
+ ShowMessage('Value ' + Quote(NewName) + ' already exists.');
+ Exit; end;
+ end;
+ MainReg.CloseKey;
+
+ if TextIn(NewName, 'default') then
+ AddHint('You can create default values by empty string ValueNames.');
+
+ Result := True;
+end;
+
+procedure TValuesWin.ZeromizeMIClick(Sender: TObject);
+begin
+ ZeromizeValue;
+end;
+
+procedure TValuesWin.CopyPathMIClick(Sender: TObject);
+begin
+ if ValueList.IsEditing then
+ Exit;
+
+ if csDestroying in MainWin.ComponentState then
+ Exit;
+
+ MainWin.CopyPathClick(Sender);
+end;
+
+function TValuesWin.FindItemByRealName(const ValueName: string): Integer;
+begin
+ with ValueList.Items do begin
+ for Result := 0 to Count-1 do
+ if SameText(RealValueName(Item[Result]), ValueName) then
+ Exit;
+ end;
+ Result := -1;
+end;
+
+function TValuesWin.FocusItem(ARealValueName: string;
+ FocusValueList: Boolean = False): Boolean;
+var
+ i: Integer;
+begin
+ with ValueList do begin
+ i := FindItemByRealName(ARealValueName);
+
+ if (i > -1) and (i < Items.Count) then
+ Selected := Items[i]
+ else
+ Selected := nil;
+
+ ItemFocused := Selected;
+
+ Result := Assigned(Selected);
+ if Result then
+ JumpToSel(ValueList);
+
+ if FocusValueList then
+ FocusControl(ValueList);
+ end;
+end;
+
+procedure TValuesWin.TakeAsMainValueMIClick(Sender: TObject);
+var
+ Item: TListItem;
+ ValueName: string;
+begin
+ if csDestroying in PrefWin.ComponentState then
+ Exit;
+
+ Item := ValueList.ItemFocused;
+ if not Assigned(Item) then
+ Exit;
+
+ ValueName := RealValueName(Item);
+ with PrefWin.MainPreviewE do
+ if ValueName = Text then
+ Text := ''
+ else
+ Text := ValueName;
+end;
+
+procedure TValuesWin.InitListColumnTags;
+var
+ i: Integer;
+begin
+ for i := 0 to ValueList.Columns.Count-1 do
+ with ValueList.Columns.Items[i] do begin
+ Tag := -1;
+ if Caption = 'Name' then
+ Tag := Integer(vlcName)
+ else if Caption = 'Size' then
+ Tag := Integer(vlcSize)
+ else if Caption = 'Type' then
+ Tag := Integer(vlcType)
+ else if Caption = 'Data' then
+ Tag := Integer(vlcData)
+ else
+ ShowMessage(Format('Error: Unknown ValueList.Columns[%d].Caption = "%s"',
+ [Index, Caption]));
+ if Tag > -1 then
+ SubItemIndex[TValueListColumn(Tag)] := Index - 1;
+ end;
+end;
+
+procedure TValuesWin.FormShow(Sender: TObject);
+begin
+ InitListColumnTags;
+end;
+
+procedure TValuesWin.Reload(JumpToNewValue: Boolean = False;
+ ValueName: string = '');
+var
+ Sel: TListItem;
+ SelIndex: Integer;
+ SelRealValueName: string;
+begin
+ if csDestroying in TreeWin.ComponentState then
+ Exit;
+
+ SelIndex := -1;
+ if JumpToNewValue then
+ SelRealValueName := ValueName
+ else begin
+ Sel := ValueList.ItemFocused;
+ if Assigned(Sel) then
+ SelIndex := Sel.Index;
+
+ if SelIndex > -1 then
+ SelRealValueName := RealValueName(ValueList.Items[SelIndex]);
+ end;
+
+ TreeWin.RegTVChange(Self, RegTV.Selected);
+
+ if SelIndex > -1 then
+ if not FocusItem(SelRealValueName, True) then begin
+ SelIndex := GetBestIndex(ValueList, SelIndex);
+ if SelIndex > -1 then
+ with ValueList do begin
+ Selected := Items[SelIndex];
+ ItemFocused := Selected;
+ end;
+ end;
+end;
+
+procedure TValuesWin.LoadValues(Reg: TXRegistry);
+var
+ SL: TStringList;
+ i: Integer;
+ Clock: TClock;
+begin
+ if csDestroying in WorkWin.ComponentState then
+ Exit;
+
+ with ValueList.Items do begin
+ Clock := TClock.Create(1, tfSecs);
+ ValueList.Enabled := False;
+ BeginUpdate;
+ try
+ Clear;
+ WorkWin.ReInitShowPC;
+
+ SL := TStringList.Create;
+ try
+ Reg.GetValueNames(SL);
+ for i := 0 to SL.Count-1 do
+ ValuesWin.AddValue(Reg, SL[i]);
+ finally
+ SL.Free;
+ end;
+
+ finally
+ EndUpdate;
+ ValueList.Enabled := True;
+ Clock.Stop;
+ if MurphyMode then
+ AddHint(Format('Values loaded after %0.2f secs.', [Clock.SecsPassed]));
+ Clock.Free;
+ end;
+ end;
+end;
+
+procedure TValuesWin.FormClose(Sender: TObject; var Action: TCloseAction);
+begin
+// Action := caNone;
+end;
+
+procedure TValuesWin.ValueListClick(Sender: TObject);
+begin
+ CheckValueListHotTrack;
+ if ValueList.HotTrack then
+ ValueListDblClick(Sender);
+end;
+
+procedure TValuesWin.CheckValueListHotTrack;
+const
+ StyleOfSwitch: array[Boolean] of TListHotTrackStyles = (
+ [], [htHandPoint, htUnderlineHot] );
+var
+ NewHotTrack: Boolean;
+begin
+ if csDestroying in PrefWin.ComponentState then
+ Exit;
+
+ NewHotTrack := ScrollON xor PrefWin.ValuesSingleClickCB.Checked;
+ if NewHotTrack = ValueList.HotTrack then Exit;
+
+ with ValueList do begin
+ HotTrack := NewHotTrack;
+ HotTrackStyles := StyleOfSwitch[HotTrack];
+ Mouse.CursorPos := Mouse.CursorPos;
+ end;
+end;
+
+procedure TValuesWin.SelectAllMIClick(Sender: TObject);
+var
+ i: Integer;
+begin
+ with ValueList.Items do
+ for i := 0 to Count-1 do
+ Item[i].Selected := True;
+end;
+
+procedure TValuesWin.InvertSelectionMIClick(Sender: TObject);
+var
+ i: Integer;
+begin
+ with ValueList.Items do
+ for i := 0 to Count-1 do
+ Item[i].Selected := not Item[i].Selected;
+end;
+
+procedure TValuesWin.FormDestroy(Sender: TObject);
+begin
+ ValueNames.Free;
+end;
+
+end.
+unit WorkU;
+
+interface
+
+uses
+ Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+ Dialogs, StdCtrls, ComCtrls, NewPanels, Grids, Clipbrd,
+ IntEdit, ExtCtrls, Menus, YTools, CompEx, PlutoConst,
+ XReg, Clock, Colors, ShellAPI, IniFiles, Math,
+ keybrd, Buttons, YTypes, LinkLabel, start,
+ PrefTools, ImgList, PHexMemo, PipelineTh, DropSource, DropTarget,
+ CrackTools;
+
+type
+ TColorStringFmt = (csfThreeSpacedDecimals);
+
+ TWorkWin = class(TForm)
+ StringPU: TPopupMenu;
+ SpaceMI: TMenuItem;
+ FileMI: TMenuItem;
+ FileOpenD: TOpenDialog;
+ MainPC: TPageControl;
+ HintPage: TTabSheet;
+ Splitter1: TSplitter;
+ HintLB: TListBox;
+ InfoMemo: TMemo;
+ WorkPage: TTabSheet;
+ WorkP: TPanel;
+ ShowPC: TPageControl;
+ StringPage: TTabSheet;
+ BorderPanel1: TBorderPanel;
+ StringE: TEdit;
+ OKStringB: TButton;
+ BoolStrCB: TCheckBox;
+ CancelStringB: TButton;
+ StringAsColorP: TPanel;
+ StringAsFileP: TBorderPanel;
+ IconImage: TImage;
+ IntPage: TTabSheet;
+ BorderPanel5: TBorderPanel;
+ OKIntB: TButton;
+ CardBoolCB: TCheckBox;
+ CancelIntB: TButton;
+ BinaryPage: TTabSheet;
+ BorderPanel6: TBorderPanel;
+ Panel2: TPanel;
+ Label5: TLabel;
+ OffsetHE: THexEdit;
+ OKBinaryB: TButton;
+ CancelBinaryB: TButton;
+ StringTypeRG: TRadioGroup;
+ SpyPage: TTabSheet;
+ BorderPanel2: TBorderPanel;
+ SpyResumeB: TButton;
+ SpySuspendB: TButton;
+ SpyLB: TListBox;
+ Label4: TLabel;
+ Label7: TLabel;
+ CardTypeRG: TRadioGroup;
+ MultiStringPage: TTabSheet;
+ BorderPanel7: TBorderPanel;
+ OKMultiStringB: TButton;
+ CancelMultiStringB: TButton;
+ MultiStringM: TMemo;
+ DataTypeComB: TComboBox;
+ CardinalE: TCardEdit;
+ ColorDlg: TColorDialog;
+ MultiStringOpenD: TOpenDialog;
+ MultiStringSaveD: TSaveDialog;
+ MultiStringPU: TPopupMenu;
+ LadenMI: TMenuItem;
+ SpeichernMI: TMenuItem;
+ Hinzufgen1: TMenuItem;
+ N1: TMenuItem;
+ SisyPage: TTabSheet;
+ SpyClearTracesB: TButton;
+ Label11: TLabel;
+ HexEdit1: THexEdit;
+ Label12: TLabel;
+ Label13: TLabel;
+ SortMultiStringMI: TMenuItem;
+ SpyTestL: TLabel;
+ Panel3: TPanel;
+ CurValueE: TEdit;
+ BorderPanel8: TBorderPanel;
+ BorderPanel9: TBorderPanel;
+ SisyTV: TTreeView;
+ TabImages: TImageList;
+ ChangeImages: TImageList;
+ Panel7: TPanel;
+ ColorPanel1: TColorPanel;
+ Splitter2: TSplitter;
+ SpyDelayIE: TPrefIntEdit;
+ ListTracesCB: TPrefCheckBox;
+ Panel5: TPanel;
+ Panel8: TPanel;
+ SisyExpandGroupsCB: TPrefCheckBox;
+ ClearChangesB: TButton;
+ FilterChangesB: TButton;
+ SisyTVPU: TPopupMenu;
+ SisyGotoKeyMI: TMenuItem;
+ SisyDeleteChangeMI: TMenuItem;
+ SisyActivateChangeMI: TMenuItem;
+ N3: TMenuItem;
+ SisyCopyPathMI: TMenuItem;
+ N4: TMenuItem;
+ Panel9: TPanel;
+ ExternalEditB: TButton;
+ LoadExternalB: TButton;
+ ReloadStringB: TButton;
+ BinaryHM: TPHexMemo;
+ PipelineCB: TCheckBox;
+ ReloadDWordB: TButton;
+ ReloadBinaryB: TButton;
+ ReloadMultiStringB: TButton;
+ DescL: TLabel;
+ SisyHKUCB: TPrefCheckBox;
+ SisyHKLMCB: TPrefCheckBox;
+ SisyHKUL: TLabel;
+ SisyHKLML: TLabel;
+ SisyListCB: TPrefCheckBox;
+ CardSpecial0B: TButton;
+ CardSpecial1B: TButton;
+ CardSpecial_1B: TButton;
+ CardSpecial7FB: TButton;
+ SisyPU: TPopupMenu;
+ Idle1: TMenuItem;
+ Lowest1: TMenuItem;
+ Lower1: TMenuItem;
+ Normal1: TMenuItem;
+ Higher1: TMenuItem;
+ Highes1: TMenuItem;
+ SisyShowCurrentPathMI: TMenuItem;
+ N5: TMenuItem;
+ MultiStringTypeRG: TRadioGroup;
+ SeparatorE: TEdit;
+ Label1: TLabel;
+ MultiStringCountL: TLabel;
+ DropFileTarget: TDropFileTarget;
+ CryptoPage: TTabSheet;
+ BorderPanel3: TBorderPanel;
+ CryptoE: TEdit;
+ OKCryptoB: TButton;
+ CancelCryptoB: TButton;
+ ReloadCryptoB: TButton;
+ CryptoTypeRG: TRadioGroup;
+ Label2: TLabel;
+ LinkLabel2: TLinkLabel;
+ procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure SpyResumeBClick(Sender: TObject);
+ procedure SpySuspendBClick(Sender: TObject);
+ procedure ArrPlutoBClick(Sender: TObject);
+ procedure ArrRegEdBClick(Sender: TObject);
+ procedure ArrFreeBClick(Sender: TObject);
+ procedure ArrBigValBClick(Sender: TObject);
+
+ procedure SpaceMIClick(Sender: TObject);
+ procedure FileMIClick(Sender: TObject);
+ procedure HintLBClick(Sender: TObject);
+ procedure MainPCDrawTab(Control: TCustomTabControl; TabIndex: Integer; const Rect: TRect; Active: Boolean);
+ procedure ValueMIClick(Sender: TObject);
+ procedure StringEKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure StringEChange(Sender: TObject);
+ procedure OKStringBClick(Sender: TObject);
+ procedure BoolStrCBClick(Sender: TObject);
+ procedure CardinalEChange(Sender: TObject);
+ procedure CardBoolCBClick(Sender: TObject);
+ procedure CardinalEKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure OKIntBClick(Sender: TObject);
+ procedure ShowPCChange(Sender: TObject);
+ procedure ShowPCChanging(Sender: TObject; var AllowChange: Boolean);
+ procedure ShowPCDrawTab(Control: TCustomTabControl; TabIndex: Integer; const Rect: TRect; Active: Boolean);
+ procedure ShowPCMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
+ procedure FormCreate(Sender: TObject);
+ procedure OKBinaryBClick(Sender: TObject);
+ procedure HexGrid1Click(Sender: TObject);
+ procedure HexGrid1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure BoolStrPopup(Sender: TObject);
+ procedure StringPageEnter(Sender: TObject);
+ procedure IntPageEnter(Sender: TObject);
+ procedure BinaryPageEnter(Sender: TObject);
+ procedure ReInitShowPC;
+ procedure ActivateIt(Sender: TObject);
+ procedure DeActivateIt(Sender: TObject);
+ procedure FormDeactivate(Sender: TObject);
+ procedure FormActivate(Sender: TObject);
+ procedure MultiStringMChange(Sender: TObject);
+ procedure OKMultiStringBClick(Sender: TObject);
+ procedure StringAsColorPDblClick(Sender: TObject);
+ procedure MultiStringMEnter(Sender: TObject);
+ procedure LadenMIClick(Sender: TObject);
+ procedure SpeichernMIClick(Sender: TObject);
+ procedure Hinzufgen1Click(Sender: TObject);
+ procedure CancelBClick(Sender: TObject);
+ procedure HexGrid1Enter(Sender: TObject);
+ procedure SpyClearTracesBClick(Sender: TObject);
+ procedure SpyLBKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ //procedure BinLMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
+ procedure BinLClick(Sender: TObject);
+ procedure HexGrid1KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure ValueViewChanged(Sender: TObject);
+ procedure HexEdit1Change(Sender: TObject);
+ procedure SortMultiStringMIClick(Sender: TObject);
+ procedure SpyTestLClick(Sender: TObject);
+ procedure FocusForEditing;
+ procedure CurValueEKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure CurValueEEnter(Sender: TObject);
+
+ procedure AddAHint(const Hint: string);
+ procedure SisyTVGetSelectedIndex(Sender: TObject; Node: TTreeNode);
+ procedure SisyTVDblClick(Sender: TObject);
+ procedure SisyTVKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure SisyCBClick(Sender: TObject);
+ procedure BinaryHMLineChange(NewLine: Cardinal);
+ procedure OffsetHEChange(Sender: TObject);
+ procedure SpyDelayIEChange(Sender: TObject);
+ procedure SisyTVExpanded(Sender: TObject; Node: TTreeNode);
+ procedure ClearChangesBClick(Sender: TObject);
+ procedure FilterChangesBClick(Sender: TObject);
+ procedure SisyTVPUPopup(Sender: TObject);
+ procedure SisyActivateChangeMIClick(Sender: TObject);
+ procedure SisyDeleteChangeMIClick(Sender: TObject);
+ procedure SisyCopyPathMIClick(Sender: TObject);
+ procedure ExternalEditBClick(Sender: TObject);
+ procedure LoadExternalBClick(Sender: TObject);
+ procedure ReloadBClick(Sender: TObject);
+ procedure PipelineCBClick(Sender: TObject);
+ procedure BinaryHMEnter(Sender: TObject);
+ procedure xUseExtendedModelCBClick(Sender: TObject);
+ procedure SeparatorEChange(Sender: TObject);
+ procedure HintLBKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
+ procedure DWORDSpecialBClick(Sender: TObject);
+ procedure Button1Click(Sender: TObject);
+ procedure SisyPUPopup(Sender: TObject);
+ procedure SisyPriorityMIClick(Sender: TObject);
+ procedure SisyShowCurrentPathMIClick(Sender: TObject);
+ procedure DropFileTargetDrop(Sender: TObject; ShiftState: TShiftState;
+ Point: TPoint; var Effect: Integer);
+ procedure FormClose(Sender: TObject; var Action: TCloseAction);
+ procedure FormResize(Sender: TObject);
+ procedure IconImageDblClick(Sender: TObject);
+ procedure SisyTVCustomDrawItem(Sender: TCustomTreeView;
+ Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean);
+ procedure SisyTVMouseDown(Sender: TObject; Button: TMouseButton;
+ Shift: TShiftState; X, Y: Integer);
+ procedure OKCryptoBClick(Sender: TObject);
+ procedure CryptoEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+ private
+ PipelineThread: TPipelineThread;
+ BoolStr: array of array[Boolean] of string;
+ HexEditAutoChange: Boolean;
+ TargetPage: TTabSheet;
+ procedure DeleteChange(Node: TTreeNode);
+ procedure DeactivateChange(Node: TTreeNode);
+ procedure CopySelectedChangeName;
+ procedure ClearChanges;
+ public
+ ShowAsBinary: Boolean;
+ function LastHint: string;
+ function LoadBoolStr: Boolean;
+ function LoadSisyFilter: Boolean;
+ procedure ShowValues(Reg: TXRegistry);
+ procedure UpdateWriteButtons;
+ procedure EditData;
+ end;
+
+var
+ WorkWin: TWorkWin;
+ ShowPC: TPageControl;
+ MainPC: TPageControl;
+
+implementation
+
+uses TreeU, ValuesU, plutomain, splash, SisyphusTH, PrefU, ShellEx;
+
+{$R *.dfm}
+
+function ColorOfString(s: string; Format: TColorStringFmt;
+ Default: TColor = clBlack): TColor;
+var
+ SA: TStrA;
+ i: Integer;
+begin
+ Result := Default;
+ SA := nil;
+
+ case Format of
+ csfThreeSpacedDecimals: begin
+ SA := Split(s, ' ');
+ if Length(SA) <> 3 then
+ Exit;
+ for i := 0 to 2 do
+ if not (IsValidInteger(SA[i]) and (StrToIntDef(SA[i], -1) in [0..255])) then
+ Exit;
+ Result := ColorOfRGB(StrToIntDef(SA[0], 0),
+ StrToIntDef(SA[1], 0),
+ StrToIntDef(SA[2], 0));
+ end;
+ end;
+end;
+
+function StringOfColor(Color: TColor; Format: TColorStringFmt): string;
+var
+ RGB: TRGB;
+begin
+ Result := '';
+
+ RGB := RGBOfColor(Color);
+ case Format of
+ csfThreeSpacedDecimals: begin
+ with RGB do
+ Result := IntToStr(R) + ' ' + IntToStr(G) + ' ' + IntToStr(B);
+ end;
+ end;
+end;
+
+function TWorkWin.LastHint: string;
+begin
+ with HintLB.Items do
+ if Count > 0 then
+ Result := Strings[Count-1]
+ else
+ Result := '';
+end;
+
+procedure TWorkWin.AddAHint(const Hint: string);
+begin
+ if not Assigned(HintLB) then
+ Exit;
+
+ with HintLB.Items do begin
+ if Count > 0 then begin
+ if StrAtBegin(LastHint, Hint) then begin //same hint again
+ with HintLB do
+ Tag := Tag + 1;
+ Strings[Count-1] := Format('%s (%d)', [Hint, HintLB.Tag]);
+ Exit end else
+ HintLB.Tag := 1;
+ end;
+ Add(Hint);
+ end;
+ Application.ProcessMessages; //draw
+// Sleep(1000); //wait to read hints
+end;
+
+procedure TWorkWin.ReInitShowPC;
+begin
+ with CurValueE do begin
+ Text := NoValueCaption;
+ Font.Color := clSilver;
+ Enabled := False;
+ end;
+
+ ShowPC.ActivePage := nil;
+
+ StringE.Text := '';
+ StringTypeRG.ItemIndex := 0;
+
+ MultiStringTypeRG.Buttons[1].Enabled := False;
+
+ CardinalE.Value := 0;
+ CardTypeRG.ItemIndex := 0;
+
+ BinaryHM.Data := nil;
+ PipelineCB.Checked := False;
+
+ DataTypeComB.ItemIndex := Integer(rdBinary);
+
+ MultiStringM.Clear;
+end;
+
+procedure TWorkWin.FormKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ MainWin.FormKeyDown(Sender, Key, Shift);
+end;
+
+procedure TWorkWin.SpyResumeBClick(Sender: TObject);
+begin
+ SpyThread.Resume;
+ SpyTestLClick(Sender);
+end;
+
+procedure TWorkWin.SpySuspendBClick(Sender: TObject);
+begin
+ SpyThread.Suspend;
+ SpyTestLClick(Sender);
+end;
+
+procedure TWorkWin.ArrPlutoBClick(Sender: TObject);
+begin
+ ArrangePlutoStyle;
+end;
+
+procedure TWorkWin.ArrRegEdBClick(Sender: TObject);
+begin
+ ArrangeRegEdStyle;
+end;
+
+procedure TWorkWin.ArrFreeBClick(Sender: TObject);
+begin
+ ArrangeFreeStyle;
+end;
+
+procedure TWorkWin.ArrBigValBClick(Sender: TObject);
+begin
+ ArrangeBigValStyle;
+end;
+
+procedure TWorkWin.SpaceMIClick(Sender: TObject);
+begin
+ StringE.Text := '';
+end;
+
+procedure TWorkWin.HintLBClick(Sender: TObject);
+begin
+ StatusBar.Panels[0].Text := GetSel(HintLB);
+ WorkWin.InfoMemo.Text := StatusBar.Panels[0].Text;
+end;
+
+procedure TWorkWin.MainPCDrawTab(Control: TCustomTabControl; TabIndex: Integer;
+ const Rect: TRect; Active: Boolean);
+var
+ PC: TPageControl;
+ Page: TTabSheet;
+begin
+ PC := TPageControl(Control);
+ Page := PC.Pages[TabIndex];
+ with PC.Canvas.Font do begin
+ if Page.Caption = 'Hint' then
+ Color := clBrightRed
+ else if Page.Caption = 'Edit' then
+ Color := clBrightGreen
+ else if Page.Caption = 'Spy' then
+ Color := clBrightBlue
+ else if Page.Caption = 'Sisyphus' then
+ Color := clBrightCyan
+ else
+ Color := clWhite;
+ end;
+
+ with PC.Canvas do
+ if Active then begin
+ Font.Style := [fsBold];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 18 + 5, Rect.Top + 3, Page.Caption);
+ PC.Images.Draw(PC.Canvas, Rect.Left + 4, Rect.Top + 2, Page.ImageIndex);
+ end else begin
+ Font.Style := [];
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 18 + 3, Rect.Top + 2, Page.Caption);
+ PC.Images.Draw(PC.Canvas, Rect.Left + 1, Rect.Top + 1, Page.ImageIndex);
+ end;
+end;
+
+procedure TWorkWin.ValueMIClick(Sender: TObject);
+begin
+ StringE.Text := UntilStr(TMenuItem(Sender).Caption,' = ');
+ OKStringBClick(Sender);
+end;
+
+procedure TWorkWin.StringEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if key = VK_RETURN then begin
+ OKStringBClick(Sender);
+ ValuesWin.FocusControl(ValueList);
+ end;
+ if key = VK_ESCAPE then
+ CancelBClick(Sender);
+end;
+
+procedure TWorkWin.StringEChange(Sender: TObject);
+var
+ i: Integer;
+ State: TCheckBoxState;
+ Desc: string;
+begin
+ IconImage.Picture := nil;
+
+ with StringAsColorP do begin
+ Color := ColorOfString(StringE.Text, csfThreeSpacedDecimals, -1);
+ Visible := Color <> -1;
+ end;
+
+ try
+ with IconImage.Picture.Icon do begin
+ ReleaseHandle;
+ Handle := GetIconFromFile(StringE.Text);
+ StringAsFileP.Visible := Handle <> 0;
+ end;
+ except
+ end;
+
+ State := cbGrayed;
+ for i := 0 to High(BoolStr) do begin
+ if StringE.Text = BoolStr[i][False] then
+ State := cbUnchecked
+ else if StringE.Text = BoolStr[i][True] then
+ State := cbChecked
+ else
+ Continue;
+ Break;
+ end;
+
+ BoolStrCB.Visible := State in [cbChecked, cbUnchecked];
+ BoolStrCB.State := State;
+
+ Desc := StringE.Text;
+ Desc := RegNameOfCLSID(Desc);
+ with DescL do begin
+ Visible := (Desc <> '');
+ if Visible then
+ Caption := 'CLSID is: ' + Desc;
+ end;
+end;
+
+procedure TWorkWin.OKStringBClick(Sender: TObject);
+var
+ i: Integer;
+begin
+ try
+ OpenCurKey;
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do begin
+ case StringTypeRG.ItemIndex of
+ 0: MainReg.WriteString(Strings[i], StringE.Text);
+ 1: MainReg.WriteExpandString(Strings[i], StringE.Text);
+ end;
+ end;
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+ ValuesWin.ValueListDblClick(Sender);
+end;
+
+procedure TWorkWin.BoolStrCBClick(Sender: TObject);
+var
+ i: Integer;
+begin
+ for i := 0 to High(BoolStr) do begin
+ if (BoolStr[i, False] = StringE.Text)
+ or (BoolStr[i, True] = StringE.Text) then
+ Break;
+ end;
+
+ if i > High(BoolStr) then
+ Exit;
+
+ StringE.Text := BoolStr[i][BoolStrCB.Checked];
+end;
+
+procedure TWorkWin.CardinalEChange(Sender: TObject);
+begin
+ HexEditAutoChange := True;
+ with CardBoolCB do begin
+ Enabled := True;
+ case CardinalE.Value of
+ 1: Checked := True;
+ 0: Checked := False;
+ else
+ Enabled := False;
+ end;
+ end;
+ HexEdit1.Value := CardinalE.Value;
+ HexEditAutoChange := False;
+end;
+
+procedure TWorkWin.CardBoolCBClick(Sender: TObject);
+begin
+ if HexEditAutoChange then
+ Exit;
+ CardinalE.Value := Ord(CardBoolCB.Checked);
+end;
+
+procedure TWorkWin.CardinalEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if key = VK_RETURN then begin
+ OKIntBClick(Sender);
+ ValuesWin.FocusControl(ValueList);
+ end;
+
+ if key = VK_ESCAPE then
+ CancelBClick(Sender);
+end;
+
+procedure TWorkWin.OKIntBClick(Sender: TObject);
+var
+ i: Integer;
+
+ procedure Write4BB(const ValueName: string; Value: Cardinal);
+ var
+ Typ: TRegDataType;
+ begin
+ if MainReg.ValueReallyExists(ValueName) then
+ Typ := MainReg.GetDataType(ValueName)
+ else
+ Typ := rdBinary;
+
+ if Typ in rdCardTypes then
+ Typ := rdBinary;
+
+ MainReg.WriteBinType(ValueName, ByteAOfInt(CardinalE.Value), Typ);
+ end;
+
+begin
+ try
+ OpenCurKey;
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do begin
+ case CardTypeRG.ItemIndex of
+ 0: MainReg.WriteCardinal(Strings[i], CardinalE.Value);
+ 1: MainReg.WriteCardinal(Strings[i], CardinalE.Value, True);
+ 2: Write4BB(Strings[i], CardinalE.Value);
+ end;
+ end;
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+end;
+
+procedure TWorkWin.ShowPCChange(Sender: TObject);
+begin
+ FocusControl(TObject(ShowPC.ActivePage.Tag) as TWinControl);
+end;
+
+procedure TWorkWin.ShowPCChanging(Sender: TObject; var AllowChange: Boolean);
+
+ function ByteAOfDWORD(a: DWORD): TByteA;
+ begin
+ SetLength(Result, SizeOf(DWORD));
+ Move(a, Pointer(Result)^, SizeOf(DWORD));
+ end;
+
+var
+ SourcePage: TTabSheet;
+ ValueName: string;
+begin
+ SourcePage := ShowPC.ActivePage;
+ if SourcePage = IntPage then begin
+
+ if TargetPage = StringPage then begin
+ AddHint('Converting: DWORD --> String');
+ StringE.Text := CardinalE.Text;
+ end else if TargetPage = BinaryPage then begin
+ AddHint('Converting: DWORD --> Binary');
+ BinaryHM.Data := ByteAOfDWORD(CardinalE.Value);
+ end else
+ AllowChange := False;
+
+ end else if SourcePage = StringPage then begin
+ if TargetPage = IntPage then begin
+ if IsValidCardinal(StringE.Text) then begin
+ AddHint('Converting: String --> DWORD');
+ CardinalE.Text := StringE.Text;
+ end else begin
+ AddHint('This no valid DWORD; Converting aborted.', True);
+ AllowChange := False;
+ end;
+ end else if TargetPage = BinaryPage then begin
+ AddHint('Converting: String --> Binary');
+ BinaryHM.Data := TByteA(StringE.Text);
+ end else if TargetPage = MultiStringPage then begin
+ AddHint('Converting: String --> MultiString');
+ if SeparatorE.Text = '' then
+ MultiStringM.Text := StringE.Text;
+ SeparatorEChange(Sender);
+ end else
+ AllowChange := False;
+
+ end else if SourcePage = BinaryPage then begin
+ if TargetPage = StringPage then begin
+ AddHint('Converting: Binary --> String');
+ StringE.Text := FriendlyStr(string(BinaryHM.Data));
+ end else if TargetPage = IntPage then begin
+ if Length(BinaryHM.Data) >= SizeOf(DWORD) then begin
+ AddHint('Converting: Binary --> DWORD');
+ CardinalE.Value := PDWORD(BinaryHM.Data)^;
+ end else begin
+ AddHint('Binary value not long enough (4 Byte); Converting aborted.', True);
+ AllowChange := False;
+ end;
+ end else if TargetPage = CryptoPage then begin
+ if ValuesWin.ValueNames.Count = 1 then begin
+ ValueName := ValuesWin.ValueNames[0];
+ with CryptoTypeRG do begin
+ ItemIndex := -1;
+ if SameText(ValueName, 'ScreenSave_Data') then begin
+ ItemIndex := 0;
+ CryptoE.Text := DecodeScreenSaver(BinaryHM.Data);
+ end else if SameText(ValueName, 'parm1enc')
+ or SameText(ValueName, 'parm2enc') then begin
+ ItemIndex := 1;
+ CryptoE.Text := DecodeSharedFolder(BinaryHM.Data);
+ end;
+ end;
+ if CryptoTypeRG.ItemIndex = -1 then
+ AllowChange := False;
+ end;
+ end else
+ AllowChange := False;
+
+ end else if SourcePage = MultiStringPage then begin
+ if TargetPage = StringPage then begin
+ AddHint('Converting: MultiString --> String ');
+ if SeparatorE.Text = '' then
+ StringE.Text := MultiStringM.Text
+ else
+ StringE.Text := Join(MultiStringM.Lines, SeparatorE.Text);
+ //end else if TargetPage = BinaryPage then begin
+ end else
+ AllowChange := False;
+
+ end else
+ AllowChange := False;
+end;
+
+procedure TWorkWin.ShowPCDrawTab(Control: TCustomTabControl; TabIndex: Integer;
+ const Rect: TRect; Active: Boolean);
+var
+ PC: TPageControl;
+ Page: TTabSheet;
+begin
+ PC := TPageControl(Control);
+ Page := PC.Pages[TabIndex];
+ with PC.Canvas.Font do begin
+ if Page = StringPage then
+ Color := clBrightRed
+ else if Page = MultiStringPage then
+ Color := clBrightPurple
+ else if Page = IntPage then
+ Color := clBrightBlue
+ else if Page = BinaryPage then
+ Color := clBrightGreen
+ else if Page = CryptoPage then
+ Color := clBrightCyan;
+ end;
+
+ with PC.Canvas do begin
+ if Active then
+ Brush.Color := clGray
+ else
+ Brush.Color := clDarkGray;
+ FillRect(Rect);
+ TextOut(Rect.Left + 18 + 3, Rect.Top, Page.Caption);
+ MainWin.ImageList1.Draw(Control.Canvas, Rect.Left - 1, Rect.Top - 1, Page.ImageIndex);
+ end;
+end;
+
+procedure TWorkWin.ShowPCMouseDown(Sender: TObject; Button: TMouseButton;
+ Shift: TShiftState; X, Y: Integer);
+begin
+ with ShowPC do
+ if htOnItem in GetHitTestInfoAt(X, Y) then
+ TargetPage := Pages[IndexOfTabAt(X, Y)];
+end;
+
+procedure TWorkWin.FormCreate(Sender: TObject);
+var
+ i: Integer;
+begin
+ WorkU.ShowPC := ShowPC;
+ WorkU.MainPC := MainPC;
+
+ //Zeromize
+ ShowPC.ActivePage := nil;
+ InfoMemo.Text := '';
+ MultiStringM.Clear;
+ SisyTV.Items.Clear;
+ CurValueE.Text := NoValueCaption;
+ HexEditAutoChange := False;
+ TargetPage := nil;
+
+ //Tagging
+ StringPage.Tag := Integer(StringE);
+ IntPage.Tag := Integer(CardinalE);
+ BinaryPage.Tag := Integer(BinaryHM);
+ MultiStringPage.Tag := Integer(MultiStringM);
+ ShowAsBinary := False;
+
+ if not Win9x then
+ CryptoPage.TabVisible := False;
+
+ MainPC.ActivePage := HintPage;
+ ShowPC.ActivePage := nil;
+
+ DropFileTarget.register(StringE);
+
+ with StringTypeRG do
+ for i := 0 to ControlCount-1 do
+ (Controls[i] as TRadioButton).OnKeyDown := StringEKeyDown;
+
+ ExternalEditB.Enabled := FileEx(PrefWin.ExternalHexEditE.Text);
+
+ PipelineThread := TPipelineThread.CreateIt(tpIdle, '', BinaryHM);
+ PipelineThread.OnChange := LoadExternalBClick;
+end;
+
+procedure TWorkWin.OKBinaryBClick(Sender: TObject);
+var
+ Typ: Cardinal;
+ i: Integer;
+begin
+ try
+ Typ := StrToIntDef(UntilChar(DataTypeComB.Text, ' '), Integer(rdBinary));
+ OpenCurKey;
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do
+ MainReg.WriteBinType(Strings[i], BinaryHM.Data, Typ);
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+end;
+
+procedure TWorkWin.HexGrid1Click(Sender: TObject);
+begin
+ {with BinaryHM do begin
+ with BinL, Font do
+ if ActiveByte < ByteCount then
+ Color := clBrightGreen
+ else begin
+ Color := clSilver;
+ Caption := '00000000';
+ end;
+ BinL.Caption := IntToBinFill(CurrentByte, 8);
+ end; }
+end;
+
+procedure TWorkWin.HexGrid1KeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if key = VK_RETURN then begin
+ OKBinaryBClick(Sender);
+ ValuesWin.FocusControl(ValueList);
+ end;
+ if key = VK_ESCAPE then
+ CancelBClick(Sender);
+end;
+
+procedure TWorkWin.BoolStrPopup(Sender: TObject);
+begin
+ StringE.Text := TMenuItem(Sender).Caption;
+end;
+
+procedure TWorkWin.StringPageEnter(Sender: TObject);
+begin
+ FocusControl(StringE);
+end;
+
+procedure TWorkWin.IntPageEnter(Sender: TObject);
+begin
+ FocusControl(CardinalE);
+end;
+
+procedure TWorkWin.BinaryPageEnter(Sender: TObject);
+begin
+ FocusControl(BinaryHM);
+end;
+
+procedure TWorkWin.ActivateIt(Sender: TObject);
+begin
+ ActivateThis(Sender);
+end;
+
+procedure TWorkWin.DeActivateIt(Sender: TObject);
+begin
+ DeActivateThis(Sender);
+end;
+
+procedure TWorkWin.FormDeactivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ TEdit(ActiveControl).OnExit(Sender);
+end;
+
+procedure TWorkWin.FormActivate(Sender: TObject);
+begin
+ if Assigned(ActiveControl) and (ActiveControl.Tag = EditControlFlag) then
+ TEdit(ActiveControl).OnEnter(Sender);
+end;
+
+procedure TWorkWin.MultiStringMChange(Sender: TObject);
+begin
+ MultiStringCountL.Caption := StrNumerus(MultiStringM.Lines.Count,
+ 'Line', 'Lines', 'No');
+end;
+
+procedure TWorkWin.OKMultiStringBClick(Sender: TObject);
+var
+ UseExtendedModel: Boolean;
+ i: Integer;
+ JoinedText: string;
+begin
+ if (MultiStringTypeRG.ItemIndex = 1) then begin
+ if ValuesWin.ValueCommonType = rdMultiString then
+ if mrYes<>MessageDlg('Do you want to change the type of this value?' + EOL +
+ 'MultiString --> String', mtWarning, [mbYes, mbCancel], 0) then
+ Exit;
+
+ try
+ OpenCurKey;
+ JoinedText := Join(MultiStringM.Lines, SeparatorE.Text);
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do
+ MainReg.WriteString(Strings[i], JoinedText);
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+ Exit; end;
+
+ UseExtendedModel := True;
+ if ContainsEmptyLines(MultiStringM.Lines) then
+ case MessageDlg('This text contains empty lines.' + EOL +
+ 'These are not allowed in the standard MultiString model.' + EOL +
+ 'Do you want to delete them?' + EOL +
+ EOL +
+ 'Yes: Delete empty lines' + EOL +
+ 'No: Use the Extended Model',
+ mtWarning, [mbYes, mbNo, mbCancel], 0) of
+
+ mrNo: UseExtendedModel := True;
+
+ mrYes: begin
+ with MultiStringM do begin
+ Lines.BeginUpdate;
+ DeleteEmptyLines(Lines);
+ Lines.EndUpdate;
+ end;
+ end;
+
+ else Exit;
+
+ end;
+
+ try
+ OpenCurKey;
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do begin
+ if MainReg.GetDataType(Strings[i]) <> rdMultiString then
+ if mrYes <> MessageDlg('Do you want to change the type of this value?' + EOL +
+ '--> MultiString', mtWarning, [mbYes, mbCancel], 0) then
+ Exit;
+ if UseExtendedModel then
+ MainReg.WriteStringList(Strings[i], MultiStringM.Lines)
+ else
+ MainReg.WriteMultiString(Strings[i], MultiStringM.Lines);
+ end;
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+
+ ValuesWin.ValueListDblClick(Sender);
+end;
+
+procedure TWorkWin.StringAsColorPDblClick(Sender: TObject);
+begin
+ if ColorDlg.Execute then
+ StringE.Text := StringOfColor(ColorDlg.Color, csfThreeSpacedDecimals);
+end;
+
+procedure TWorkWin.MultiStringMEnter(Sender: TObject);
+begin
+ MultiStringM.SelectAll;
+ ActivateIt(MultiStringM);
+end;
+
+procedure TWorkWin.LadenMIClick(Sender: TObject);
+begin
+ with MultiStringOpenD do begin
+ InitialDir := ExtractFileDrive(MyDir);
+ if Execute then
+ MultiStringM.Lines.LoadFromFile(FileName);
+ end;
+end;
+
+procedure TWorkWin.SpeichernMIClick(Sender: TObject);
+begin
+ with MultiStringSaveD do begin
+ InitialDir := ExtractFileDrive(MyDir);
+ if Execute then
+ MultiStringM.Lines.SaveToFile(FileName);
+ end;
+end;
+
+procedure TWorkWin.Hinzufgen1Click(Sender: TObject);
+var
+ SL: TStringList;
+begin
+ with MultiStringOpenD do begin
+ InitialDir := ExtractFileDrive(MyDir);
+ if Execute then begin
+ SL := TStringList.Create;
+ SL.LoadFromFile(FileName);
+ MultiStringM.Lines.AddStrings(SL);
+ SL.Free;
+ end;
+ end;
+end;
+
+procedure TWorkWin.CancelBClick(Sender: TObject);
+begin
+ ValuesWin.FocusControl(ValueList);
+ ValuesWin.ValueListChange(Sender, ValueList.Selected, ctState);
+end;
+
+procedure TWorkWin.HexGrid1Enter(Sender: TObject);
+begin
+ HexGrid1Click(Sender);
+end;
+
+procedure TWorkWin.SpyClearTracesBClick(Sender: TObject);
+begin
+ SpyLB.Clear;
+end;
+
+procedure TWorkWin.SpyLBKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if (ssShift in Shift) and (key = VK_DELETE) then begin
+ key := 0;
+ SpyLB.Clear;
+ Exit; end;
+
+ if key = VK_F9 then begin
+ key := 0;
+ SwapFonts(SpyLB);
+ Exit; end;
+end;
+
+procedure TWorkWin.BinLClick(Sender: TObject);
+begin
+ // with HexGrid1 do
+ // Byt[ActiveByte] := IntOfBin(BinL.Caption);
+end;
+
+procedure TWorkWin.HexGrid1KeyUp(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ //HexGrid1Click(Sender);
+end;
+
+procedure TWorkWin.ValueViewChanged(Sender: TObject);
+var
+ i: Integer;
+begin
+ if not Started then
+ Exit;
+
+ SpyThread.Suspend;
+ OpenCurKey;
+ for i := 0 to ValueList.Items.Count-1 do
+ ValuesWin.UpdateValue(MainReg, ValueList.Items[i]);
+
+ MainReg.CloseKey;
+ SpyThread.Resume;
+end;
+
+procedure TWorkWin.HexEdit1Change(Sender: TObject);
+begin
+ if not HexEditAutoChange then
+ CardinalE.Value := HexEdit1.Value;
+end;
+
+procedure TWorkWin.SortMultiStringMIClick(Sender: TObject);
+var
+ SL: TStringList;
+begin
+ SL := TStringList.Create;
+ with SL do begin
+ Assign(MultiStringM.Lines);
+ Sort;
+ end;
+ MultiStringM.Lines.Assign(SL);
+ SL.Free;
+end;
+
+procedure TWorkWin.SpyTestLClick(Sender: TObject);
+begin
+ SpyTestL.Caption := StrOfBool(SpyThread.Suspended, 'No Spy.', 'Spy active.');
+end;
+
+procedure TWorkWin.FocusForEditing;
+begin
+ FocusControl(MainPC);
+end;
+
+function TWorkWin.LoadBoolStr: Boolean;
+var
+ SL: TStringList;
+ FileName: string;
+ i, p: Integer;
+begin
+ Result := True;
+
+ AddHint('Loading Boolean Strings...');
+
+ FileName := PlutoDir + BoolStrFileName;
+ if not FileEx(FileName) then begin
+ AddToLastHint('not found:');
+ AddHint(FileName);
+ Result := False;
+ end else begin
+ SL := TStringList.Create;
+ try
+ SL.LoadFromFile(FileName);
+ DeleteCommentLines(SL);
+ BoolStr := nil;
+ SetLength(BoolStr, SL.Count);
+ for i := 0 to SL.Count-1 do begin
+ //Split the string by the '|'-sign
+ p := Pos('|', SL[i]);
+ BoolStr[i][False] := Copy(SL[i], 1, p-1);
+ BoolStr[i][True] := Copy(SL[i], p+1, Length(SL[i]) - p);
+ end;
+ finally
+ SL.Free;
+ AddToLastHint('OK');
+ end;
+ end;
+end;
+
+function TWorkWin.LoadSisyFilter: Boolean;
+var
+ SL: TStringList;
+ FileName: string;
+ i: Integer;
+begin
+ Result := True;
+
+ FileName := PlutoDir + SisyFilterFileName;
+ if not FileEx(FileName) then
+ Result := False
+ else begin
+ AddHint('Loading Sisyphus Filter Settings...');
+ SL := TStringList.Create;
+ try
+ SL.LoadFromFile(FileName);
+ DeleteCommentLines(SL, '#');
+ for i := 0 to SL.Count-1 do
+ SL[i] := TrimLeft(SL[i]);
+
+ SisyFilter.Clear;
+ SisyFilter.AddStrings(SL);
+ finally
+ SL.Free;
+ AddToLastHint('OK');
+ end;
+ end;
+end;
+
+procedure TWorkWin.SisyTVGetSelectedIndex(Sender: TObject; Node: TTreeNode);
+begin
+ Node.SelectedIndex := Node.ImageIndex;
+end;
+
+procedure TWorkWin.SisyTVDblClick(Sender: TObject);
+var
+ Node: TTreeNode;
+ Path: string;
+begin
+ Node := SisyTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ Path := RootOfNode(Node).Text;
+
+ if Node.Level > 0 then begin
+ if Node.Level = 2 then
+ Node := Node.Parent;
+ if Node.HasChildren then
+ Path := Path + '\\' + Node.Text //Value
+ else
+ Path := Path + '\' + Node.Text //SubKey
+ end;
+
+ MainWin.GotoKey(Path);
+end;
+
+procedure TWorkWin.DeleteChange(Node: TTreeNode);
+var
+ SubNode: TTreeNode;
+
+ procedure FreeSisyChangeNode(Node: TTreeNode);
+ begin
+ try
+ with (TObject(Node.Data) as TSisyChange) do
+ Free;
+ except
+ ReportFmt('errors', 'Context could not be freed: "%s"', [Node.Text]);
+ end;
+
+ Node.Delete;
+ end;
+
+begin
+ if not Assigned(Node) then
+ Exit;
+
+ if Node.Level = 2 then
+ Node := Node.Parent;
+
+ if Node.Level = 0 then begin
+ SisyTV.Selected := GetNextBest(RootOfNode(Node));
+ SubNode := Node.GetFirstChild;
+ while Assigned(SubNode) do begin
+ FreeSisyChangeNode(SubNode);
+ SubNode := Node.GetFirstChild; end;
+ Node.Delete;
+ end else begin
+ SisyTV.Selected := GetNextBest(Node);
+ FreeSisyChangeNode(Node);
+ end;
+end;
+
+procedure TWorkWin.DeactivateChange(Node: TTreeNode);
+begin
+ Node := RootOfNode(Node);
+
+ if not Assigned(Node) then
+ Exit;
+
+ if SisyChangeActivated(Node) then begin
+ SetSisyChangeState(Node, False);
+ Node.Cut := True;
+ end else begin
+ SetSisyChangeState(Node, True);
+ Node.Cut := False;
+ end;
+ SisyTV.Repaint;
+end;
+
+procedure TWorkWin.CopySelectedChangeName;
+var
+ Node: TTreeNode;
+begin
+ Node := SisyTV.Selected;
+ if not Assigned(Node) then
+ Exit;
+
+ Clipboard.AsText := Node.Text;
+end;
+
+procedure TWorkWin.SisyTVKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+var
+ Node: TTreeNode;
+begin
+ Node := RootOfNode(SisyTV.Selected);
+ if not Assigned(Node) then
+ Exit;
+
+ {if Key = VK_RETURN then
+ SisyTVDblCLick(Sender);
+
+ if Key = VK_DELETE then
+ if (ssCtrl in Shift) and (Key = VK_DELETE) then
+ DeactivateChange(Node)
+ else
+ DeleteChange(Node);
+
+ if (ssCtrl in Shift) and (Char(Key) = 'C') then
+ CopySelectedChangeName;}
+end;
+
+procedure TWorkWin.SisyCBClick(Sender: TObject);
+begin
+ if not Started then
+ Exit;
+
+ with TCheckBox(Sender), TSisyThread(Sisys[Tag]) do begin
+ if Checked then
+ Resume
+ else
+ Suspend;
+ end;
+end;
+
+procedure TWorkWin.CurValueEEnter(Sender: TObject);
+begin
+ CurValueE.Text := RealValueName(ValueList.ItemFocused);
+ CurValueE.SelectAll;
+end;
+
+procedure TWorkWin.CurValueEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+
+ procedure RenameValue(NewName: string);
+ var
+ Item: TListItem;
+ begin
+ Item := ValueList.ItemFocused;
+ if ValuesWin.TryRenameValue(CurKey.Value, NewName) then
+ SetRealValueName(Item, NewName);
+ end;
+
+begin
+ if Key = VK_RETURN then begin
+ SpyThread.Suspend;
+ try
+ RenameValue(CurValueE.Text);
+ ValuesWin.ValueListDblClick(Self);
+ FocusControl(CurValueE);
+ finally
+ SpyThread.Restart := True;
+ SpyThread.Resume;
+ end;
+ Key := 0;
+ //CurValueE.SelectAll;
+ end else if Key = VK_ESCAPE then begin
+ ValuesWin.ValueListDblClick(Self);
+ end;
+end;
+
+procedure TWorkWin.BinaryHMLineChange(NewLine: Cardinal);
+begin
+ OffsetHE.Value := BinaryHM.Pos;
+ // BinaryAsIntL.Value := Integer(BinaryHM.CurentCard);
+end;
+
+procedure TWorkWin.OffsetHEChange(Sender: TObject);
+begin
+ BinaryHM.Pos := OffsetHE.Value;
+end;
+
+procedure TWorkWin.SpyDelayIEChange(Sender: TObject);
+begin
+ if Assigned(SpyThread) then
+ SpyThread.Delay := SpyDelayIE.Value;
+end;
+
+procedure TWorkWin.SisyTVExpanded(Sender: TObject; Node: TTreeNode);
+begin
+ if Node.ImageIndex = 8 then
+ Node.ImageIndex := 7;
+end;
+
+procedure TWorkWin.ClearChanges;
+var
+ Node: TTreeNode;
+begin
+ with SisyTV.Items do begin
+ Node := GetFirstNode;
+ while Assigned(Node) do begin
+ DeleteChange(Node);
+ Node := GetFirstNode;
+ end;
+ end;
+end;
+
+procedure TWorkWin.ClearChangesBClick(Sender: TObject);
+begin
+ if mrOK <> MessageDlg('Do you really want to clear all changes?',
+ mtWarning, [mbOK, mbCancel], 0) then
+ Exit;
+
+ ClearChanges;
+end;
+
+procedure TWorkWin.FilterChangesBClick(Sender: TObject);
+begin
+ NotePad(PlutoDir + SisyFilterFileName);
+ ShowMessage('Click OK when you finished editing.' + EOL +
+ '(Pluto will reload the filter settings then.)');
+ LoadSisyFilter;
+end;
+
+procedure TWorkWin.SisyTVPUPopup(Sender: TObject);
+var
+ KeySelected: Boolean;
+ Node: TTreeNode;
+begin
+ Node := SisyTV.Selected;
+ KeySelected := Assigned(Node);
+
+ SisyGoToKeyMI.Enabled := KeySelected;
+ SisyDeleteChangeMI.Enabled := KeySelected;
+ SisyActivateChangeMI.Enabled := KeySelected;
+ SisyCopyPathMI.Enabled := KeySelected;
+ if not KeySelected then
+ Exit;
+
+ SisyActivateChangeMI.Checked := SisyChangeActivated(RootOfNode(Node));
+end;
+
+procedure TWorkWin.SisyActivateChangeMIClick(Sender: TObject);
+begin
+ DeactivateChange(SisyTV.Selected)
+end;
+
+procedure TWorkWin.SisyDeleteChangeMIClick(Sender: TObject);
+begin
+ DeleteChange(SisyTV.Selected)
+end;
+
+procedure TWorkWin.SisyCopyPathMIClick(Sender: TObject);
+begin
+ CopySelectedChangeName;
+end;
+
+procedure TWorkWin.FileMIClick(Sender: TObject);
+var
+ s: string;
+begin
+ with FileOpenD do begin
+ s := ExtractPath(StringE.Text);
+ if s <> '' then
+ InitialDir := s
+ else
+ InitialDir := MyDir;
+
+ s := ExtractFileName(StringE.Text);
+ s := DeleteChars(s, '/');
+ if s <> '' then
+ FileName := s;
+
+ if Execute then
+ StringE.Text := FileName;
+ end;
+end;
+
+procedure TWorkWin.ExternalEditBClick(Sender: TObject);
+var
+ FileName: string;
+begin
+ FileName := TempDir + '~' + DeleteChars(CurValueE.Text, FileNameEnemies) +
+ '.bin';
+ if SaveByteA(BinaryHM.Data, FileName) then
+ ExecFileWith(PrefWin.ExternalHexEditE.Text, FileName)
+ else
+ ShowMessage('Could not write into file:' + EOL + FileName);
+
+ PipelineThread.FileName := FileName;
+end;
+
+procedure TWorkWin.LoadExternalBClick(Sender: TObject);
+var
+ FileName: string;
+ Data: TByteA;
+ i: Integer;
+begin
+ Data := nil;
+
+ FileName := TempDir + '~' + CurValueE.Text + '.bin';
+ if not FileEx(FileName) then begin
+ {ShowMessage('File not found:' + EOL +
+ FileName);}
+ Exit;
+ end;
+
+ Data := LoadByteA(FileName);
+ if Length(Data) = Length(BinaryHM.Data) then begin
+ for i := 0 to High(Data) do
+ if Data[i] <> BinaryHM.Data[i] then begin
+ BinaryHM.Data := Data;
+ Exit;
+ end;
+ end else
+ BinaryHM.Data := Data;
+end;
+
+procedure TWorkWin.PipelineCBClick(Sender: TObject);
+begin
+ with PipelineThread, PipelineCB do
+ if Checked then begin
+ if Suspended then
+ Resume;
+ end else
+ if not Suspended then
+ Suspend;
+end;
+
+procedure TWorkWin.ReloadBClick(Sender: TObject);
+begin
+ ValuesWin.ValueListDblClick(Self);
+end;
+
+procedure TWorkWin.BinaryHMEnter(Sender: TObject);
+begin
+ PipelineCB.Checked := False;
+end;
+
+procedure TWorkWin.xUseExtendedModelCBClick(Sender: TObject);
+begin
+ PrefWin.UseExtendedModelCB.Load;
+end;
+
+procedure TWorkWin.SeparatorEChange(Sender: TObject);
+begin
+ if not SeparatorE.Enabled then
+ Exit;
+
+ if SeparatorE.Text = '' then begin
+ if StringE.Text = '' then
+ Exit
+ else
+ MultiStringM.Text := StringE.Text;
+ MultiStringTypeRG.Buttons[1].Enabled := False;
+ MultiStringTypeRG.ItemIndex := 0;
+ end else begin
+ if StringE.Text = '' then
+ StringE.Text := Join(MultiStringM.Lines, SeparatorE.Text);
+ MultiStringTypeRG.Buttons[1].Enabled := True;
+ MultiStringTypeRG.ItemIndex := 1;
+ Split(StringE.Text, SeparatorE.Text, MultiStringM.Lines, False);
+ end;
+end;
+
+procedure TWorkWin.HintLBKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if (Key = Byte('C')) and (ssCtrl in Shift) then
+ with HintLb do
+ if ItemIndex >= 0 then
+ Clipboard.AsText := Items[ItemIndex];
+end;
+
+procedure TWorkWin.DWORDSpecialBClick(Sender: TObject);
+begin
+ CardinalE.Value := StrToIntDef((Sender as TButton).Caption, 0);
+end;
+
+procedure TWorkWin.Button1Click(Sender: TObject);
+begin
+ ShowPC.SelectNextPage(True);
+end;
+
+procedure TWorkWin.SisyPUPopup(Sender: TObject);
+begin
+ with SisyPU, TSisyThread(Sisys[PopupComponent.Tag]) do
+ Items[Integer(Priority)].Checked := True;
+end;
+
+procedure TWorkWin.SisyPriorityMIClick(Sender: TObject);
+begin
+ with TSisyThread(Sisys[SisyPU.PopupComponent.Tag]) do begin
+ Priority := TThreadPriority(TMenuItem(Sender).MenuIndex);
+ if Priority <= tpNormal then
+ Uni.WriteInteger('Priority', Integer(Priority));
+ end;
+end;
+
+procedure TWorkWin.SisyShowCurrentPathMIClick(Sender: TObject);
+begin
+ with SisyPU, TSisyThread(Sisys[PopupComponent.Tag]) do begin
+ Suspend;
+ ShowMessage(CurrentSpyKey.Path);
+ Resume;
+ end;
+end;
+
+procedure TWorkWin.DropFileTargetDrop(Sender: TObject;
+ ShiftState: TShiftState; Point: TPoint; var Effect: Integer);
+begin
+ StringE.Text := DropFileTarget.Files[0];
+end;
+
+procedure TWorkWin.FormClose(Sender: TObject; var Action: TCloseAction);
+begin
+// Action := caNone;
+ DropFileTarget.Unregister;
+ ClearChanges;
+end;
+
+procedure TWorkWin.FormResize(Sender: TObject);
+begin
+ Realign;
+end;
+
+procedure TWorkWin.IconImageDblClick(Sender: TObject);
+var
+ Filename: string;
+begin
+ FileName := GetFileNew(StringE.Text);
+ if FileName <> '' then
+ ExecFile(FileName);
+end;
+
+procedure TWorkWin.ShowValues(Reg: TXRegistry);
+var
+ MainValueName: string;
+ ValueCommonType: TRegDataType;
+
+ procedure ShowValueAsBinary(const ValueName: string;
+ Smart4BB: Boolean = True);
+ begin
+ if Smart4BB
+ and PrefWin.Smart4BBCB.Checked
+ and (Reg.GetDataSize(ValueName) = 4) then begin
+ CardinalE.Value := Reg.ReadCardinal(ValueName);
+ CardTypeRG.ItemIndex := 2;
+ ShowPC.ActivePage := IntPage;
+ Exit; end;
+ BinaryHM.Data := Reg.ReadBin(ValueName);
+ DataTypeComB.ItemIndex := ValueCommonType;
+ if IsValidDataType(ValueCommonType) then
+ DataTypeComB.ItemIndex := ValueCommonType
+ else begin
+ DataTypeComB.Text := IntToStr(ValueCommonType);
+ AddHint('Value has unknown data type (' + DataTypeComB.Text + '): ' +
+ Quote(ValueName));
+ end;
+ ShowPC.ActivePage := BinaryPage;
+ end;
+
+begin
+ with ValuesWin do begin
+ if not Assigned(ValueNames) or (ValueNames.Count = 0) then
+ raise EReadError.Create('ValueNameList error');
+ MainValueName := ValueNames[0];
+ end;
+ ValueCommonType := ValuesWin.ValueCommonType;
+
+ with CurValueE do begin
+ Enabled := True;
+ if ValuesWin.ValueNames.Count = 1 then
+ Text := MainValueName
+ else
+ Text := Copy(ValuesWin.ValueNames.CommaText, 1, 255);
+
+ Font.Color := ColorOfDataType(ValueCommonType);
+ end;
+
+ if KeyIsDown(VK_MENU) or ShowAsBinary then begin
+ ShowValueAsBinary(MainValueName, False);
+ end else if ValueCommonType in rdStringTypes then begin
+ StringE.Text := Reg.ReadString(MainValueName);
+ case ValueCommonType of
+ rdString: StringTypeRG.ItemIndex := 0;
+ rdExpandString: StringTypeRG.ItemIndex := 1;
+ end;
+ ShowPC.ActivePage := StringPage;
+ end else if ValueCommonType in rdCardTypes then begin
+ CardinalE.Value := Reg.ReadCardinal(MainValueName);
+ case ValueCommonType of
+ rdCardinal: StringTypeRG.ItemIndex := 0;
+ rdCardBigEndian: StringTypeRG.ItemIndex := 1;
+ end;
+ ShowPC.ActivePage := IntPage;
+ end else if ValueCommonType = rdMultiString then begin
+ MultiStringM.Clear;
+ Reg.ReadMultiString(MainValueName, MultiStringM.Lines, PrefWin.UseExtendedModelCB.Checked);
+ SeparatorEChange(Self);
+ MultiStringTypeRG.ItemIndex := 0;
+ ShowPC.ActivePage := MultiStringPage;
+ end else begin
+ ShowValueAsBinary(MainValueName);
+ end;
+
+ ShowAsBinary := False;
+
+ UpdateWriteButtons;
+end;
+
+procedure TWorkWin.UpdateWriteButtons;
+const
+ BtnTextOfMultiEdit: array[Boolean] of string = ('Write', 'Write all');
+var
+ BtnText: string;
+begin
+ BtnText := BtnTextOfMultiEdit[ValuesWin.ValueNames.Count > 1];
+ OKStringB.Caption := BtnText;
+ OKIntB.Caption := BtnText;
+ OKMultiStringB.Caption := BtnText;
+ OKBinaryB.Caption := BtnText;
+end;
+
+procedure TWorkWin.EditData;
+begin
+ AddHint('Edit');
+ MainPC.ActivePage := WorkPage;
+
+ with ShowPC do
+ if ActivePage = nil then
+ Exit
+ else if ActivePage = WorkWin.StringPage then begin
+ FocusControl(StringE);
+ StringE.SelectAll;
+ end
+ else if ActivePage = WorkWin.IntPage then
+ FocusControl(CardinalE)
+ else if ActivePage = WorkWin.MultiStringPage then
+ FocusControl(MultiStringM)
+ else if ActivePage = WorkWin.BinaryPage then
+ FocusControl(BinaryHM)
+ else
+ ShowMessage('Error: ShowPC.ActivePage!');
+end;
+
+procedure TWorkWin.SisyTVCustomDrawItem(Sender: TCustomTreeView;
+ Node: TTreeNode; State: TCustomDrawState; var DefaultDraw: Boolean);
+begin
+ with TTreeView(Sender).Canvas.Font do begin
+ if Node.Cut then
+ Color := $AAAAAA
+ else
+ Color := clWhite;
+ end;
+end;
+
+procedure TWorkWin.SisyTVMouseDown(Sender: TObject; Button: TMouseButton;
+ Shift: TShiftState; X, Y: Integer);
+var
+ Node: TTreeNode;
+ RelX, RelY: Integer;
+begin
+ with SisyTV do begin
+ RelX := ScreenToClient(Mouse.CursorPos).X;
+ RelY := ScreenToClient(Mouse.CursorPos).Y;
+ Node := GetNodeAt(RelX, RelY);
+ end;
+ if not Assigned(Node) then
+ Exit;
+
+ if not Node.Selected then
+ Node.Selected := True;
+end;
+
+procedure TWorkWin.OKCryptoBClick(Sender: TObject);
+var
+ i: Integer;
+begin
+ try
+ OpenCurKey;
+ with ValuesWin.ValueNames do
+ for i := 0 to Count-1 do begin
+ case CryptoTypeRG.ItemIndex of
+ 0: MainReg.WriteBin(Strings[i], EncodeScreenSaver(CryptoE.Text));
+ 1: MainReg.WriteBin(Strings[i], EncodeSharedFolder(CryptoE.Text));
+ end;
+ end;
+ ValuesWin.UpdateValues(True);
+ finally
+ MainReg.CloseKey;
+ end;
+ ValuesWin.ValueListDblClick(Sender);
+end;
+
+procedure TWorkWin.CryptoEKeyDown(Sender: TObject; var Key: Word;
+ Shift: TShiftState);
+begin
+ if Key = VK_RETURN then begin
+ OKCryptoBClick(Sender);
+ ValuesWin.FocusControl(ValueList);
+ end;
+ if Key = VK_ESCAPE then
+ CancelBClick(Sender);
+end;
+
+end.
diff --git a/test/delphi/pluto.out.raydebug b/test/delphi/pluto.out.raydebug new file mode 100644 index 0000000..032e8d4 --- /dev/null +++ b/test/delphi/pluto.out.raydebug @@ -0,0 +1,10829 @@ +reserved(unit) ident(FindTH)operator(;) + +reserved(interface) + +reserved(uses) + ident(Classes)operator(,) ident(windows)operator(,) ident(Dialogs)operator(,) ident(ComCtrls)operator(,) ident(CompEx)operator(,) ident(SysUtils)operator(,) ident(YTools)operator(,) ident(YTypes)operator(,) + ident(clock)operator(,) ident(plutoconst)operator(,) ident(StdCtrls)operator(,) ident(Masks)operator(,) ident(Forms)operator(,) ident(XReg)operator(;) + +reserved(const) + ident(RegMoleVersion) operator(=) string<delimiter(')content(1.1)delimiter(')>operator(;) + +reserved(type) + ident(TFindThreadProgress) operator(=) operator(()ident(fpNone)operator(,) ident(fpEvery512th)operator(,) ident(fpEach)operator(\);) + + ident(TRegFindThread) operator(=) reserved(class)operator(()ident(TThread)operator(\)) + directive(private) + ident(SearchText)operator(:) reserved(string)operator(;) + ident(SearchFor)operator(:) ident(TSearchOptions)operator(;) + ident(Progress)operator(:) ident(TFindThreadProgress)operator(;) + ident(FindNodeText)operator(:) reserved(string)operator(;) + ident(TimeElapsed)operator(:) ident(Double)operator(;) + ident(syncIcon)operator(:) ident(Integer)operator(;) + ident(syncStatusText)operator(:) reserved(string)operator(;) + ident(CurrentPath)operator(:) reserved(string)operator(;) + ident(KeysScanned)operator(:) ident(Integer)operator(;) + ident(Mask)operator(:) ident(TMask)operator(;) + ident(dwordVal)operator(:) ident(DWORD)operator(;) + ident(SearchForValues)operator(:) ident(Boolean)operator(;) + + reserved(procedure) ident(Find)operator(;) + + comment(//Synchronizers) + reserved(procedure) ident(Start)operator(;) + reserved(procedure) ident(Add)operator(;) + reserved(procedure) ident(UpdateStatus)operator(;) + reserved(procedure) ident(Finish)operator(;) + directive(protected) + reserved(procedure) ident(Execute)operator(;) directive(override)operator(;) + directive(public) + ident(SpecialPath)operator(:) reserved(string)operator(;) + ident(FindNode)operator(:) ident(TTreeNode)operator(;) + ident(ListTV)operator(:) ident(TTreeView)operator(;) + ident(ObjectsFound)operator(,) ident(KeysFound)operator(,) ident(ValuesFound)operator(,) ident(DataFound)operator(:) ident(Integer)operator(;) + ident(Ranges)operator(:) ident(TRanges)operator(;) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(constructor) ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(;) ident(s)operator(:) reserved(string)operator(;) + ident(SearchFor)operator(:) ident(TSearchOptions)operator(;) ident(Progress)operator(:) ident(TFindThreadProgress)operator(\);) + reserved(end)operator(;) + +reserved(implementation) + +reserved(uses) + ident(ValuesU)operator(,) ident(StrUtils)operator(;) + +comment({ TRegFindThread }) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(Add)operator(;) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + reserved(with) ident(ListTV) reserved(do) reserved(begin) + comment(//Items.BeginUpdate;) + ident(Node) operator(:=) ident(TTreeNode)operator(.)ident(Create)operator(()ident(Items)operator(\);) + ident(SetTNImage)operator(()ident(Node)operator(,) ident(syncIcon)operator(\);) + ident(Items)operator(.)ident(AddNode)operator(()ident(Node)operator(,) ident(FindNode)operator(,) ident(Copy)operator(()ident(CurrentPath)operator(,) integer(1)operator(,) integer(255)operator(\),) reserved(nil)operator(,) + ident(naAddChildFirst)operator(\);) + reserved(if) reserved(not) ident(FindNode)operator(.)ident(Expanded) reserved(and) operator(()ident(FindNode)operator(.)ident(Count) operator(=) integer(1)operator(\)) reserved(then) comment(//First Node) + ident(FindNode)operator(.)ident(Expand)operator(()ident(False)operator(\);) + comment(//Items.EndUpdate;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(constructor) ident(TRegFindThread)operator(.)ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(;) ident(s)operator(:) reserved(string)operator(;) + ident(SearchFor)operator(:) ident(TSearchOptions)operator(;) ident(Progress)operator(:) ident(TFindThreadProgress)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(()ident(True)operator(\);) comment(// Create thread suspended) + ident(Priority) operator(:=) ident(PriorityLevel)operator(;) comment(// Set Priority Level) + ident(FreeOnTerminate) operator(:=) ident(True)operator(;) comment(// Thread Free Itself when terminated) + + ident(SearchText) operator(:=) ident(s)operator(;) + ident(Ranges) operator(:=) reserved(nil)operator(;) + ident(Self)operator(.)ident(SearchFor) operator(:=) ident(SearchFor)operator(;) + ident(Self)operator(.)ident(Progress) operator(:=) ident(Progress)operator(;) +reserved(end)operator(;) + +reserved(destructor) ident(TRegFindThread)operator(.)ident(Destroy)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(FindNode)operator(\)) reserved(then) + ident(FindNode)operator(.)ident(Data) operator(:=) reserved(nil)operator(;) + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(Execute)operator(;) +reserved(begin) + ident(Synchronize)operator(()ident(Start)operator(\);) + ident(Find)operator(;) + ident(Synchronize)operator(()ident(Finish)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(Find)operator(;) +reserved(var) + ident(SpecialKey)operator(:) ident(HKEY)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(Path)operator(:) reserved(string)operator(;) reserved(const) ident(Icon)operator(:) ident(Integer)operator(\);) + reserved(var) + ident(zCurrentPath)operator(:) reserved(string)operator(;) + reserved(begin) + ident(zCurrentPath) operator(:=) ident(CurrentPath)operator(;) + + ident(CurrentPath) operator(:=) ident(Path)operator(;) + ident(syncIcon) operator(:=) ident(Icon)operator(;) + ident(Synchronize)operator(()ident(Self)operator(.)ident(Add)operator(\);) + + ident(CurrentPath) operator(:=) ident(zCurrentPath)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(AddValueName)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) ident(Typ)operator(:) ident(TRegDataType)operator(\);) + reserved(begin) + ident(Add)operator(()ident(CurrentPath) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(ValueName)operator(,) ident(IconOfDataType)operator(()ident(Typ)operator(\)\);) + reserved(end)operator(;) + + reserved(procedure) ident(AddValueData)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) ident(Context)operator(:) ident(TRegContext)operator(\);) + reserved(begin) + ident(Add)operator(()ident(CurrentPath) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(ValueName) operator(+) string<delimiter(')content( = )delimiter(')> operator(+) ident(DataPreviewOfContext)operator(()ident(Context)operator(\),) + ident(IconOfDataType)operator(()ident(Context)operator(.)ident(Typ)operator(\)\);) + reserved(end)operator(;) + + reserved(function) ident(FoundInStr)operator(()reserved(const) ident(Data)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(if) ident(SearchText) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Exit)operator(;) + + reserved(if) operator(()ident(Data) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(and) reserved(not) operator(()ident(sfWildCards) reserved(in) ident(SearchFor)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(sfWildCards) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Mask)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Mask)operator(.)ident(Matches)operator(()ident(Data)operator(\);) + reserved(end) reserved(else) reserved(begin) + comment({if not (sfFileNames in SearchFor\) then begin + if TextBegin(SearchText, UntilChar(Data, '~'\)\) and FileExists(Data\) then + Result := SameFileName(SearchText, GetFileNew(Data\)\); + Exit; + end; }) + + reserved(if) operator([)ident(sfParts)operator(,) ident(sfIgnoreCase)operator(]) operator(<=) ident(SearchFor) reserved(then) + reserved(if) ident(SfUseLocales) reserved(in) ident(SearchFor) reserved(then) + ident(Result) operator(:=) integer(0)operator(<)ident(PosEx)operator(()ident(SearchText)operator(,) ident(AnsiLowerCase)operator(()ident(Data)operator(\)\)) + reserved(else) + ident(Result) operator(:=) integer(0)operator(<)ident(PosExText)operator(()ident(SearchText)operator(,) ident(Data)operator(\)) + reserved(else) reserved(if) ident(sfParts) reserved(in) ident(SearchFor) reserved(then) + ident(Result) operator(:=) integer(0)operator(<)ident(PosEx)operator(()ident(SearchText)operator(,) ident(Data)operator(\)) + reserved(else) reserved(if) ident(sfIgnoreCase) reserved(in) ident(SearchFor) reserved(then) + reserved(if) ident(SfUseLocales) reserved(in) ident(SearchFor) reserved(then) + ident(Result) operator(:=) operator(()ident(AnsiLowerCase)operator(()ident(Data)operator(\)) operator(=) ident(SearchText)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(SameText)operator(()ident(Data)operator(,) ident(SearchText)operator(\)) + reserved(else) + ident(Result) operator(:=) operator(()ident(SearchText) operator(=) ident(Data)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(function) ident(FoundInByteA)operator(()reserved(const) ident(Data)operator(:) ident(TByteA)operator(\):) ident(Boolean)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(FoundInStr)operator(()ident(StrOfByteA)operator(()ident(Data)operator(\)\);) + reserved(end)operator(;) + + reserved(procedure) ident(ScanValues)operator(()ident(Key)operator(:) ident(HKEY)operator(;) ident(Info)operator(:) ident(TRegKeyInfo)operator(\);) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(MaxLen)operator(,) ident(NameLen)operator(,) ident(Len)operator(,) ident(Typ)operator(:) ident(Cardinal)operator(;) + ident(Buffer)operator(:) ident(PByte)operator(;) + ident(ValueName)operator(:) ident(PChar)operator(;) + + reserved(procedure) ident(ScanValue)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) reserved(const) ident(Typ)operator(:) ident(TRegDataType)operator(;) + reserved(const) ident(Data)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) operator(()ident(sfSpecialTypes) reserved(in) ident(SearchFor)operator(\)) reserved(and) reserved(not) ident(InRanges)operator(()ident(Ranges)operator(,) ident(Typ)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(case) ident(Typ) reserved(of) + ident(rdString)operator(,) ident(rdExpandString)operator(:) reserved(if) ident(sfString) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + reserved(if) ident(FoundInStr)operator(()ident(Data)operator(\)) reserved(then) reserved(begin) + ident(Inc)operator(()ident(DataFound)operator(\);) + ident(AddValueData)operator(()ident(ValueName)operator(,) + ident(RegContext)operator(()ident(Typ)operator(,) ident(TByteA)operator(()ident(Copy)operator(()ident(Data)operator(,) integer(1)operator(,) ident(Length)operator(()ident(Data)operator(\)-)integer(1)operator(\)\)\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(rdCardinal)operator(,) ident(rdCardBigEndian)operator(:) reserved(if) ident(sfDWord) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + reserved(if) operator(()ident(Length)operator(()ident(Data)operator(\)) operator(>=) ident(SizeOf)operator(()ident(Cardinal)operator(\)\)) reserved(and) + operator(()ident(dwordVal) operator(=) ident(PCardinal)operator(()ident(Copy)operator(()ident(Data)operator(,) integer(1)operator(,) ident(SizeOf)operator(()ident(Cardinal)operator(\)\)\)^\)) reserved(then) reserved(begin) + ident(Inc)operator(()ident(DataFound)operator(\);) + ident(AddValueData)operator(()ident(ValueName)operator(,) + ident(RegContext)operator(()ident(Typ)operator(,) ident(ByteAOfStr)operator(()ident(Data)operator(\)\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(else) + reserved(if) ident(sfOtherTypes) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + reserved(if) ident(FoundInStr)operator(()ident(Data)operator(\)) reserved(then) reserved(begin) + ident(Inc)operator(()ident(DataFound)operator(\);) + ident(AddValueData)operator(()ident(ValueName)operator(,) + ident(RegContext)operator(()ident(Typ)operator(,) ident(ByteAOfStr)operator(()ident(Data)operator(\)\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(begin) + ident(MaxLen) operator(:=) ident(Info)operator(.)ident(MaxValueLen) operator(+) integer(1)operator(;) comment(//Include Nullbyte) + + ident(Buffer) operator(:=) reserved(nil)operator(;) + reserved(if) ident(sfValueData) reserved(in) ident(SearchFor) reserved(then) + ident(GetMem)operator(()ident(Buffer)operator(,) ident(Info)operator(.)ident(MaxDataLen)operator(\);) + + ident(GetMem)operator(()ident(ValueName)operator(,) ident(MaxLen)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Info)operator(.)ident(NumValues)operator(-)integer(1) reserved(do) reserved(begin) + ident(NameLen) operator(:=) ident(MaxLen)operator(;) + ident(Len) operator(:=) ident(Info)operator(.)ident(MaxDataLen)operator(;) + reserved(if) reserved(not) ident(Success)operator(()ident(RegEnumValue)operator(()ident(Key)operator(,) ident(i)operator(,) ident(ValueName)operator(,) ident(NameLen)operator(,) reserved(nil)operator(,) operator(@)ident(Typ)operator(,) + ident(Buffer)operator(,) operator(@)ident(Len)operator(\)\)) reserved(then) + ident(Continue)operator(;) + + reserved(if) ident(sfValueNames) reserved(in) ident(SearchFor) reserved(then) + reserved(if) ident(FoundInStr)operator(()ident(ValueName)operator(\)) reserved(then) reserved(begin) + ident(Inc)operator(()ident(ValuesFound)operator(\);) + ident(AddValueName)operator(()ident(ValueName)operator(,) ident(Typ)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(sfValueData) reserved(in) ident(SearchFor) reserved(then) + ident(ScanValue)operator(()ident(ValueName)operator(,) ident(Typ)operator(,) reserved(string)operator(()ident(Copy)operator(()ident(TByteA)operator(()ident(Buffer)operator(\),) integer(0)operator(,) ident(Len)operator(\)\)\);) + reserved(end)operator(;) + + ident(FreeMem)operator(()ident(ValueName)operator(,) ident(MaxLen)operator(\);) + reserved(if) ident(sfValueData) reserved(in) ident(SearchFor) reserved(then) + ident(FreeMem)operator(()ident(Buffer)operator(,) ident(Info)operator(.)ident(MaxDataLen)operator(\);) + reserved(end)operator(;) + + reserved(procedure) ident(ScanKey)operator(()ident(Key)operator(:) ident(HKEY)operator(;) reserved(const) ident(KeyName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) + reserved(var) + ident(p)operator(:) ident(PChar)operator(;) + ident(i)operator(,) ident(z)operator(:) ident(Integer)operator(;) + ident(l)operator(,) ident(Len)operator(:) ident(DWORD)operator(;) + ident(NewKey)operator(:) ident(HKEY)operator(;) + ident(Info)operator(:) ident(TRegKeyInfo)operator(;) + reserved(begin) + reserved(if) ident(Terminated) reserved(then) ident(Exit)operator(;) + + ident(Inc)operator(()ident(KeysScanned)operator(\);) + reserved(if) ident(Progress) operator(<>) ident(fpNone) reserved(then) + reserved(if) operator(()ident(Progress) operator(=) ident(fpEach)operator(\)) reserved(or) + operator((()ident(Progress) operator(=) ident(fpEvery512th)operator(\)) reserved(and) operator((()ident(KeysScanned) reserved(and) hex($1FF)operator(\)) operator(=) integer(0)operator(\)\)) reserved(then) reserved(begin) + ident(syncStatusText) operator(:=) char<delimiter(')content(()delimiter(')> operator(+) ident(IntToStr)operator(()ident(KeysScanned)operator(\)) operator(+) string<delimiter(')content( k\) )delimiter(')> operator(+) ident(CurrentPath)operator(;) + ident(Synchronize)operator(()ident(UpdateStatus)operator(\);) + reserved(end)operator(;) + + reserved(with) ident(Info) reserved(do) + reserved(if) reserved(not) ident(Success)operator(()ident(RegQueryInfoKey)operator(()ident(Key)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) operator(@)ident(NumSubKeys)operator(,) + operator(@)ident(MaxSubKeyLen)operator(,) reserved(nil)operator(,) operator(@)ident(NumValues)operator(,) operator(@)ident(MaxValueLen)operator(,) operator(@)ident(MaxDataLen)operator(,) + reserved(nil)operator(,) reserved(nil)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) operator(()ident(Info)operator(.)ident(NumValues) operator(>) integer(0)operator(\)) reserved(and) ident(SearchForValues) reserved(then) + ident(ScanValues)operator(()ident(Key)operator(,) ident(Info)operator(\);) + + reserved(if) ident(Info)operator(.)ident(NumSubKeys) operator(<=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Len) operator(:=) ident(Info)operator(.)ident(MaxSubKeyLen) operator(+) integer(1)operator(;) + ident(GetMem)operator(()ident(p)operator(,) ident(Len)operator(\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Info)operator(.)ident(NumSubKeys)operator(-)integer(1) reserved(do) reserved(begin) + ident(l) operator(:=) ident(Len)operator(;) + ident(RegEnumKeyEx)operator(()ident(Key)operator(,) ident(i)operator(,) ident(p)operator(,) ident(l)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(\);) + reserved(if) ident(sfKeys) reserved(in) ident(SearchFor) reserved(then) + reserved(if) ident(FoundInStr)operator(()ident(p)operator(\)) reserved(then) reserved(begin) + ident(Inc)operator(()ident(KeysFound)operator(\);) + ident(Add)operator(()ident(CurrentPath) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(p)operator(,) ident(iconKeyMiddle)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Success)operator(()ident(RegOpenKey)operator(()ident(Key)operator(,) ident(p)operator(,) ident(NewKey)operator(\)\)) reserved(then) reserved(begin) + ident(z) operator(:=) ident(Length)operator(()ident(CurrentPath)operator(\);) + ident(CurrentPath) operator(:=) ident(CurrentPath) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(p)operator(;) + + reserved(try) + ident(ScanKey)operator(()ident(NewKey)operator(,) ident(p)operator(\);) + reserved(finally) + ident(RegCloseKey)operator(()ident(NewKey)operator(\);) + reserved(end)operator(;) + + ident(SetLength)operator(()ident(CurrentPath)operator(,) ident(z)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Terminated) reserved(then) ident(Break)operator(;) + reserved(end)operator(;) + + ident(FreeMem)operator(()ident(p)operator(,) ident(Len)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(with) ident(TClock)operator(.)ident(Create) reserved(do) reserved(begin) + ident(FindNode)operator(.)ident(Text) operator(:=) ident(FindNodeText) operator(+) string<delimiter(')content(: )delimiter(')>operator(;) + + reserved(try) + reserved(if) ident(sfHKU) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + ident(CurrentPath) operator(:=) string<delimiter(')content(HKU)delimiter(')>operator(;) + ident(ScanKey)operator(()ident(HKEY_USERS)operator(\);) + reserved(end)operator(;) + reserved(if) ident(sfHKLM) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + ident(CurrentPath) operator(:=) string<delimiter(')content(HKLM)delimiter(')>operator(;) + ident(ScanKey)operator(()ident(HKEY_LOCAL_MACHINE)operator(\);) + reserved(end)operator(;) + reserved(if) ident(sfHKDD) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + ident(CurrentPath) operator(:=) string<delimiter(')content(HKDD)delimiter(')>operator(;) + ident(ScanKey)operator(()ident(HKEY_DYN_DATA)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(SpecialPath) operator(<>) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + reserved(if) ident(Success)operator(()ident(RegOpenKey)operator(()ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(SpecialPath)operator(\)\),) + ident(PChar)operator(()ident(ExRegKey)operator(()ident(SpecialPath)operator(\)\),) ident(SpecialKey)operator(\)\)) reserved(then) reserved(begin) + ident(CurrentPath) operator(:=) ident(LWPSolve)operator(()ident(SpecialPath)operator(\);) + ident(ScanKey)operator(()ident(SpecialKey)operator(\);) + ident(RegCloseKey)operator(()ident(SpecialKey)operator(\);) + reserved(end) reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Could not open)delimiter(')> operator(+) ident(EOL) operator(+) + ident(Quote)operator(()ident(SpecialPath)operator(\)\);) + reserved(end)operator(;) + reserved(except) + ident(syncStatusText) operator(:=) char<delimiter(')content(()delimiter(')> operator(+) ident(IntToStr)operator(()ident(KeysScanned)operator(\)) operator(+) string<delimiter(')content( k\) )delimiter(')> operator(+) ident(CurrentPath) operator(+) + string<delimiter(')content(Error --> Terminated.)delimiter(')>operator(;) + ident(Synchronize)operator(()ident(UpdateStatus)operator(\);) + ident(Sleep)operator(()integer(1000)operator(\);) + reserved(end)operator(;) + + ident(TimeElapsed) operator(:=) ident(SecondsPassed)operator(;) + ident(Free)operator(;) reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrOfSearchOptions)operator(()reserved(const) ident(Options)operator(:) ident(TSearchOptions)operator(\):) reserved(string)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(s)operator(:) reserved(string)operator(\);) + reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(s)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(AddOption)operator(()reserved(const) ident(Option)operator(:) reserved(string)operator(;) reserved(const) ident(Flag)operator(:) ident(TSearchVar)operator(;) + reserved(const) ident(Optional)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) + reserved(begin) + reserved(if) ident(Flag) reserved(in) ident(Options) reserved(then) + ident(Add)operator(()ident(Option)operator(\)) + reserved(else) + reserved(if) reserved(not) ident(Optional) reserved(then) + ident(Add)operator(()char<delimiter(')content(^)delimiter(')> operator(+) ident(Option)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(Add)operator(()char<delimiter(')content([)delimiter(')>operator(\);) + ident(AddOption)operator(()char<delimiter(')content(H)delimiter(')>operator(,) ident(sfAsHex)operator(,) ident(True)operator(\);) + ident(AddOption)operator(()string<delimiter(')content(W )delimiter(')>operator(,) ident(sfWildcards)operator(,) ident(True)operator(\);) + + ident(AddOption)operator(()char<delimiter(')content(C)delimiter(')>operator(,) ident(sfIgnoreCase)operator(\);) + ident(AddOption)operator(()char<delimiter(')content(L)delimiter(')>operator(,) ident(sfUseLocales)operator(\);) + ident(AddOption)operator(()string<delimiter(')content(P )delimiter(')>operator(,) ident(sfParts)operator(\);) + + ident(AddOption)operator(()char<delimiter(')content(K)delimiter(')>operator(,) ident(sfKeys)operator(\);) + ident(AddOption)operator(()char<delimiter(')content(N)delimiter(')>operator(,) ident(sfValueNames)operator(\);) + ident(AddOption)operator(()string<delimiter(')content(D )delimiter(')>operator(,) ident(sfValueData)operator(\);) + + ident(AddOption)operator(()char<delimiter(')content(S)delimiter(')>operator(,) ident(sfString)operator(\);) + ident(AddOption)operator(()char<delimiter(')content(D)delimiter(')>operator(,) ident(sfDWORD)operator(\);) + ident(AddOption)operator(()char<delimiter(')content(O)delimiter(')>operator(,) ident(sfOtherTypes)operator(\);) + ident(AddOption)operator(()char<delimiter(')content(?)delimiter(')>operator(,) ident(sfSpecialTypes)operator(\);) + + ident(Add)operator(()string<delimiter(')content(] [)delimiter(')>operator(\);) + + reserved(if) operator([)ident(sfHKU)operator(,) ident(sfHKLM)operator(,) ident(sfHKDD)operator(]) operator(<=) ident(Options) reserved(then) + ident(Add)operator(()string<delimiter(')content(ALL)delimiter(')>operator(\)) + reserved(else) reserved(begin) + ident(AddOption)operator(()string<delimiter(')content(HKU )delimiter(')>operator(,) ident(sfHKU)operator(,) ident(True)operator(\);) + ident(AddOption)operator(()string<delimiter(')content(HKLM )delimiter(')>operator(,) ident(sfHKLM)operator(,) ident(True)operator(\);) + ident(AddOption)operator(()string<delimiter(')content(HKDD )delimiter(')>operator(,) ident(sfHKDD)operator(,) ident(True)operator(\);) + ident(Result) operator(:=) ident(TrimRight)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Add)operator(()char<delimiter(')content(])delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(Start)operator(;) +reserved(begin) + ident(Mask) operator(:=) reserved(nil)operator(;) + ident(KeysFound) operator(:=) integer(0)operator(;) + ident(ValuesFound) operator(:=) integer(0)operator(;) + ident(DataFound) operator(:=) integer(0)operator(;) + ident(KeysScanned) operator(:=) integer(0)operator(;) + + comment(//Prepare for options) + reserved(if) ident(sfAsHex) reserved(in) ident(SearchFor) reserved(then) reserved(begin) + ident(SearchText) operator(:=) reserved(string)operator(()ident(ByteAOfHex)operator(()ident(SearchText)operator(\)\);) + ident(SearchFor) operator(:=) ident(SearchFor) operator(-) operator([)ident(sfDWord)operator(,) ident(sfIgnoreCase)operator(];) + reserved(end) reserved(else) reserved(begin) + reserved(if) ident(SfUseLocales) reserved(in) ident(SearchFor) reserved(then) + ident(SearchText) operator(:=) ident(AnsiLowerCase)operator(()ident(SearchText)operator(\);) + + ident(dwordVal) operator(:=) integer(0)operator(;) + reserved(if) ident(sfDWord) reserved(in) ident(SearchFor) reserved(then) + reserved(if) ident(IsValidInteger)operator(()ident(SearchText)operator(\)) reserved(then) + ident(dwordVal) operator(:=) ident(StrToInt)operator(()ident(SearchText)operator(\)) + reserved(else) + ident(Exclude)operator(()ident(SearchFor)operator(,) ident(sfDWord)operator(\);) + + reserved(if) ident(sfWildCards) reserved(in) ident(SearchFor) reserved(then) + reserved(try) + ident(Mask) operator(:=) ident(TMask)operator(.)ident(Create)operator(()ident(SearchText)operator(\);) + reserved(except) + ident(Mask)operator(.)ident(Free)operator(;) + ident(Mask) operator(:=) reserved(nil)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(SearchForValues) operator(:=) operator(()ident(sfValueNames) reserved(in) ident(SearchFor)operator(\)) + reserved(or) operator(()ident(sfValueData) reserved(in) ident(SearchFor)operator(\);) + + ident(FindNodeText) operator(:=) string<delimiter(')content(Find )delimiter(')> operator(+) ident(Quote)operator(()ident(FriendlyStr)operator(()ident(SearchText)operator(\)\)) operator(+) char<delimiter(')content( )delimiter(')> operator(+) + ident(StrOfSearchOptions)operator(()ident(SearchFor)operator(\);) + + reserved(with) ident(ListTV)operator(.)ident(Items) reserved(do) reserved(begin) + ident(BeginUpdate)operator(;) + ident(FindNode) operator(:=) ident(AddChildObject)operator(()reserved(nil)operator(,) ident(FindNodeText) operator(+) string<delimiter(')content(...)delimiter(')>operator(,) reserved(nil)operator(\);) + ident(FindNode)operator(.)ident(Data) operator(:=) ident(Self)operator(;) + ident(SetTNImage)operator(()ident(FindNode)operator(,) ident(iconHostReg)operator(\);) + ident(EndUpdate)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(UpdateStatus)operator(;) +reserved(begin) + ident(FindNode)operator(.)ident(Text) operator(:=) ident(FindNodeText) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(syncStatusText)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegFindThread)operator(.)ident(Finish)operator(;) +reserved(var) + ident(Found)operator(:) reserved(string)operator(;) +reserved(begin) + ident(ObjectsFound) operator(:=) ident(KeysFound) operator(+) ident(ValuesFound) operator(+) ident(DataFound)operator(;) + + ident(Found) operator(:=) ident(StrNumerus)operator(()ident(ObjectsFound)operator(,) string<delimiter(')content(object)delimiter(')>operator(,) string<delimiter(')content(objects)delimiter(')>operator(,) string<delimiter(')content(No)delimiter(')>operator(\);) + reserved(if) ident(ObjectsFound) operator(<) integer(2) reserved(then) + ident(Found) operator(:=) ident(Found) operator(+) string<delimiter(')content( found.)delimiter(')> + reserved(else) reserved(begin) + ident(Found) operator(:=) ident(Found) operator(+) string<delimiter(')content( found: )delimiter(')>operator(;) + reserved(if) ident(KeysFound) operator(>) integer(0) reserved(then) + ident(Found) operator(:=) ident(Found) operator(+) ident(StrNumerus)operator(()ident(KeysFound)operator(,) string<delimiter(')content(KeyName, )delimiter(')>operator(,) string<delimiter(')content(KeyNames, )delimiter(')>operator(,) string<delimiter(')content(No)delimiter(')>operator(\);) + reserved(if) ident(ValuesFound) operator(>) integer(0) reserved(then) + ident(Found) operator(:=) ident(Found) operator(+) ident(StrNumerus)operator(()ident(ValuesFound)operator(,) string<delimiter(')content(ValueName, )delimiter(')>operator(,) string<delimiter(')content(ValueNames, )delimiter(')>operator(,) + string<delimiter(')content(No)delimiter(')>operator(\);) + reserved(if) ident(DataFound) operator(>) integer(0) reserved(then) + ident(Found) operator(:=) ident(Found) operator(+) ident(StrNumerus)operator(()ident(DataFound)operator(,) string<delimiter(')content(Data)delimiter(')>operator(,) string<delimiter(')content(Datas)delimiter(')>operator(,) string<delimiter(')content(No)delimiter(')>operator(\);) + + reserved(if) ident(RightStr)operator(()ident(Found)operator(,) integer(2)operator(\)) operator(=) string<delimiter(')content(, )delimiter(')> reserved(then) + ident(Delete)operator(()ident(Found)operator(,) ident(Length)operator(()ident(Found)operator(\)) operator(-) integer(1)operator(,) integer(2)operator(\);) + reserved(end)operator(;) + + ident(FindNode)operator(.)ident(Text) operator(:=) ident(FindNodeText) operator(+) ident(Format)operator(()string<delimiter(')content( OK (%0.1f s\) %s)delimiter(')>operator(,) + operator([)ident(TimeElapsed)operator(,) ident(Found)operator(]\);) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(FindWinU)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) ident(Dialogs)operator(,) + ident(ComCtrls)operator(,) ident(StdCtrls)operator(,) ident(ExtCtrls)operator(,) ident(Clipbrd)operator(,) ident(NewPanels)operator(,) ident(plutoconst)operator(,) ident(FindTH)operator(,) ident(YTools)operator(,) + ident(PrefTools)operator(,) ident(Menus)operator(,) ident(XReg)operator(,) ident(RangeEdit)operator(;) + +reserved(type) + ident(TFindWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(ListTV)operator(:) ident(TTreeView)operator(;) + ident(FindP)operator(:) ident(TPanel)operator(;) + ident(FindE)operator(:) ident(TEdit)operator(;) + ident(ColorPanel1)operator(:) ident(TColorPanel)operator(;) + ident(ResultsPopup)operator(:) ident(TPopupMenu)operator(;) + ident(Copy1)operator(:) ident(TMenuItem)operator(;) + ident(ColorPanel2)operator(:) ident(TColorPanel)operator(;) + ident(FindPrefP)operator(:) ident(TPanel)operator(;) + ident(CommonGB)operator(:) ident(TGroupBox)operator(;) + ident(Label4)operator(:) ident(TLabel)operator(;) + ident(SfWildCardsCB)operator(:) ident(TCheckBox)operator(;) + ident(SfPartsCB)operator(:) ident(TCheckBox)operator(;) + ident(SfIgnoreCaseCB)operator(:) ident(TCheckBox)operator(;) + ident(SfAsHexCB)operator(:) ident(TCheckBox)operator(;) + ident(SfAsDWord)operator(:) ident(TCheckBox)operator(;) + ident(SfUseLocalesCB)operator(:) ident(TCheckBox)operator(;) + ident(FindGB)operator(:) ident(TGroupBox)operator(;) + ident(SfHKUCB)operator(:) ident(TCheckBox)operator(;) + ident(SfHKLMCB)operator(:) ident(TCheckBox)operator(;) + ident(SfHKDDCB)operator(:) ident(TCheckBox)operator(;) + ident(SfRootKeyRB)operator(:) ident(TRadioButton)operator(;) + ident(SfCurKeyRB)operator(:) ident(TRadioButton)operator(;) + ident(SfCLSIDCB)operator(:) ident(TCheckBox)operator(;) + ident(SfInterfaceCB)operator(:) ident(TCheckBox)operator(;) + ident(SfKeysCb)operator(:) ident(TCheckBox)operator(;) + ident(SfValuesCB)operator(:) ident(TCheckBox)operator(;) + ident(SfDataCB)operator(:) ident(TCheckBox)operator(;) + ident(SfStringCB)operator(:) ident(TCheckBox)operator(;) + ident(SfOtherCB)operator(:) ident(TCheckBox)operator(;) + ident(SfDWordCB)operator(:) ident(TCheckBox)operator(;) + ident(Panel2)operator(:) ident(TPanel)operator(;) + ident(GroupBox1)operator(:) ident(TGroupBox)operator(;) + ident(Label1)operator(:) ident(TLabel)operator(;) + ident(ThreadPriorityComB)operator(:) ident(TComboBox)operator(;) + ident(ProgressRG)operator(:) ident(TRadioGroup)operator(;) + ident(Panel5)operator(:) ident(TPanel)operator(;) + ident(BorderPanel1)operator(:) ident(TBorderPanel)operator(;) + ident(MoleLogoI)operator(:) ident(TImage)operator(;) + ident(TypeRangeE)operator(:) ident(TRangeEdit)operator(;) + ident(SfTypesCB)operator(:) ident(TCheckBox)operator(;) + ident(Panel1)operator(:) ident(TPanel)operator(;) + ident(TransparentCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(StayOnTopCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(FindB)operator(:) ident(TButton)operator(;) + ident(FindPrefB)operator(:) ident(TButton)operator(;) + reserved(procedure) ident(FindBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ListTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(FindEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(SfWildCardsCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StayOnTopCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SfRootKeysUpdate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FindPrefBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(CloseFindPrefP)operator(;) + reserved(procedure) ident(OpenFindPrefP)operator(;) + reserved(procedure) ident(FindEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SfDataCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ListTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SfAsHexCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Copy1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SfIgnoreCaseCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SfTypesCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(end)operator(;) + +reserved(const) + ident(fpbOpen) operator(=) integer(0)operator(;) + ident(fpbCloseCaption) operator(=) string<delimiter(')content(Params &<<)delimiter(')>operator(;) + + ident(fpbClosed) operator(=) integer(1)operator(;) + ident(fpbOpenCaption) operator(=) string<delimiter(')content(Params &>>)delimiter(')>operator(;) + +reserved(var) + ident(FindWin)operator(:) ident(TFindWin)operator(;) + +reserved(implementation) + +reserved(uses) ident(plutomain)operator(,) ident(PrefU)operator(,) ident(ValuesU)operator(;) + +preprocessor({$R *.DFM}) + +reserved(procedure) ident(TFindWin)operator(.)ident(FindBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(SearchFor)operator(:) ident(TSearchOptions)operator(;) + ident(FindThread)operator(:) ident(TRegFindThread)operator(;) + + reserved(procedure) ident(AddOption)operator(()ident(CheckBox)operator(:) ident(TCustomCheckBox)operator(;) ident(Flag)operator(:) ident(TSearchVar)operator(\);) + reserved(begin) + reserved(with) ident(CheckBox) reserved(as) ident(TCheckBox) reserved(do) + reserved(if) ident(Enabled) reserved(and) ident(Checked) reserved(then) + ident(Include)operator(()ident(SearchFor)operator(,) ident(Flag)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(SearchFor) operator(:=) operator([];) + + ident(AddOption)operator(()ident(SfKeysCB)operator(,) ident(sfKeys)operator(\);) + + ident(AddOption)operator(()ident(SfValuesCB)operator(,) ident(sfValueNames)operator(\);) + ident(AddOption)operator(()ident(SfDataCB)operator(,) ident(sfValueData)operator(\);) + + ident(AddOption)operator(()ident(SfStringCB)operator(,) ident(sfString)operator(\);) + ident(AddOption)operator(()ident(SfDWordCB)operator(,) ident(sfDWord)operator(\);) + ident(AddOption)operator(()ident(SfOtherCB)operator(,) ident(sfOtherTypes)operator(\);) + + reserved(if) ident(SfRootKeyRB)operator(.)ident(Checked) reserved(then) reserved(begin) + ident(AddOption)operator(()ident(SfHKUCB)operator(,) ident(sfHKU)operator(\);) + ident(AddOption)operator(()ident(SfHKLMCB)operator(,) ident(sfHKLM)operator(\);) + ident(AddOption)operator(()ident(SfHKDDCB)operator(,) ident(sfHKDD)operator(\);) + reserved(end)operator(;) + + ident(AddOption)operator(()ident(SfAsHexCB)operator(,) ident(sfAsHex)operator(\);) + ident(AddOption)operator(()ident(SfWildCardsCB)operator(,) ident(sfWildCards)operator(\);) + ident(AddOption)operator(()ident(SfPartsCB)operator(,) ident(sfParts)operator(\);) + ident(AddOption)operator(()ident(SfIgnoreCaseCB)operator(,) ident(sfIgnoreCase)operator(\);) + ident(AddOption)operator(()ident(SfUseLocalesCB)operator(,) ident(sfUseLocales)operator(\);) + + comment({AddOption(SfCLSIDCB, sfCLSID\); + AddOption(SfInterfaceCB, sfInterface\);}) + + reserved(if) ident(SfTypesCB)operator(.)ident(Checked) reserved(and) reserved(not) ident(TypeRangeE)operator(.)ident(RangeMaximal) reserved(then) + ident(Include)operator(()ident(SearchFor)operator(,) ident(sfSpecialTypes)operator(\);) + + ident(FindThread) operator(:=) ident(TRegFindThread)operator(.)ident(CreateIt)operator(() + ident(TThreadPriority)operator(()ident(ThreadPriorityComB)operator(.)ident(ItemIndex)operator(\),) ident(FindE)operator(.)ident(Text)operator(,) ident(SearchFor)operator(,) + ident(TFindThreadProgress)operator(()ident(ProgressRG)operator(.)ident(ItemIndex)operator(\)\);) + + ident(FindThread)operator(.)ident(ListTV) operator(:=) ident(ListTV)operator(;) + + reserved(if) ident(sfSpecialTypes) reserved(in) ident(SearchFor) reserved(then) + ident(FindThread)operator(.)ident(Ranges) operator(:=) ident(TypeRangeE)operator(.)ident(Value)operator(;) + + reserved(if) ident(SfCurKeyRB)operator(.)ident(Checked) reserved(then) + ident(FindThread)operator(.)ident(SpecialPath) operator(:=) + ident(LWPSolve)operator(()ident(StrOfRegPath)operator(()ident(CurKey)operator(()ident(uhNonSystemShortcuts)operator(\)\)\);) + + ident(FindThread)operator(.)ident(Resume)operator(;) + ident(CloseFindPrefP)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(ListTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + + reserved(procedure) ident(TerminateFindThread)operator(;) + reserved(var) + ident(FindThread)operator(:) ident(TRegFindThread)operator(;) + reserved(begin) + reserved(if) operator(()ident(Node)operator(.)ident(Level) operator(=) integer(0)operator(\)) reserved(then) reserved(begin) + ident(FindThread) operator(:=) ident(TRegFindThread)operator(()ident(Node)operator(.)ident(Data)operator(\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(FindThread)operator(\)) reserved(then) + ident(Node)operator(.)ident(Delete) + reserved(else) + reserved(try) + ident(FindThread)operator(.)ident(Terminate)operator(;) + reserved(except) + ident(Node)operator(.)ident(Text) operator(:=) string<delimiter(')content(Error: couldn)char('')content(t terminate thread!)delimiter(')>operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) + ident(Node)operator(.)ident(Delete)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Node) operator(:=) ident(ListTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(case) ident(Key) reserved(of) + ident(VK_F12)operator(:) reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) + ident(Node)operator(.)ident(Parent)operator(.)ident(AlphaSort)operator(;) + + ident(VK_RETURN)operator(:) ident(ListTVDblClick)operator(()ident(Sender)operator(\);) + + ident(VK_DELETE)operator(:) ident(TerminateFindThread)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FindEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_RETURN) reserved(then) + ident(FindBClick)operator(()ident(Sender)operator(\);) + + reserved(if) ident(Key) operator(=) ident(VK_UP) reserved(then) reserved(begin) + ident(CloseFindPrefP)operator(;) + ident(Key) operator(:=) integer(0)operator(;) + reserved(end) reserved(else) reserved(if) ident(Key) operator(=) ident(VK_Down) reserved(then) reserved(begin) + ident(OpenFindPrefP)operator(;) + ident(Key) operator(:=) integer(0)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(DeActivateThis)operator(()ident(ActiveControl)operator(\);) + + ident(AlphaBlend) operator(:=) ident(TransparentCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(ActivateThis)operator(()ident(ActiveControl)operator(\);) + + ident(AlphaBlend) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(Close)operator(;) + ident(MainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(,) ident(Key)operator(,) ident(Shift)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfWildCardsCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SfPartsCB)operator(.)ident(Enabled) operator(:=) reserved(not) ident(SfWildcardsCB)operator(.)ident(Checked)operator(;) + ident(SfIgnoreCaseCB)operator(.)ident(Enabled) operator(:=) reserved(not) ident(SfWildcardsCB)operator(.)ident(Checked)operator(;) + ident(SfUseLocalesCB)operator(.)ident(Enabled) operator(:=) ident(SfIgnoreCaseCB)operator(.)ident(Checked) reserved(and) reserved(not) ident(SfWildcardsCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(StayOnTopCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(StayOnTopCB)operator(.)ident(Checked) reserved(then) + ident(FormStyle) operator(:=) ident(fsStayOnTop) + reserved(else) + ident(FormStyle) operator(:=) ident(fsNormal)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfRootKeysUpdate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SfRootKeyRB) reserved(do) reserved(begin) + ident(SfHKLMCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + ident(SfHKUCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + ident(SfHKDDCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FindPrefBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(case) ident(FindPrefB)operator(.)ident(Tag) reserved(of) + ident(fpbOpen)operator(:) + ident(CloseFindPrefP)operator(;) + ident(fpbClosed)operator(:) + ident(OpenFindPrefP)operator(;) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Fehler: FindPrefB hat unbekanntes Tag)delimiter(')>operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(CloseFindPrefP)operator(;) +reserved(begin) + reserved(with) ident(FindPrefB) reserved(do) reserved(begin) + ident(Tag) operator(:=) ident(fpbClosed)operator(;) + ident(Caption) operator(:=) ident(fpbOpenCaption)operator(;) + reserved(end)operator(;) + ident(FindPrefP)operator(.)ident(Visible) operator(:=) ident(False)operator(;) + ident(ListTV)operator(.)ident(Repaint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(OpenFindPrefP)operator(;) +reserved(begin) + reserved(with) ident(FindPrefB) reserved(do) reserved(begin) + ident(Tag) operator(:=) ident(fpbOpen)operator(;) + ident(Caption) operator(:=) ident(fpbCloseCaption)operator(;) + reserved(end)operator(;) + ident(FindPrefP)operator(.)ident(Visible) operator(:=) ident(True)operator(;) + ident(ListTV)operator(.)ident(Repaint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FindEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(IsValidInteger)operator(()ident(FindE)operator(.)ident(Text)operator(\)) reserved(then) + ident(SfDWORDCB)operator(.)ident(Caption) operator(:=) string<delimiter(')content(D&WORD OK)delimiter(')> + reserved(else) + ident(SfDWORDCB)operator(.)ident(Caption) operator(:=) string<delimiter(')content(D&WORD ??)delimiter(')>operator(;) + + ident(SfAsHexCB)operator(.)ident(Enabled) operator(:=) operator(()ident(FindE)operator(.)ident(Text) operator(<>) string<delimiter(')delimiter(')>operator(\)) + reserved(and) reserved(not) ident(CharIn)operator(()ident(FindE)operator(.)ident(Text)operator(,) ident(AllChars) operator(-) ident(HexadecimalChars) operator(-) operator([)char<delimiter(')content( )delimiter(')>operator(]\);) + ident(SfAsDWord)operator(.)ident(Enabled) operator(:=) ident(SfAsHexCB)operator(.)ident(Enabled) reserved(and) operator(()ident(Length)operator(()ident(TrimAll)operator(()ident(FindE)operator(.)ident(Text)operator(\)\)) operator(<) integer(8)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfDataCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SfDataCB) reserved(do) reserved(begin) + ident(SfStringCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + ident(SfDWordCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + ident(SfOtherCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(ListTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(ListTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(or) operator(()ident(Node)operator(.)ident(Level) operator(=) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(MainWin)operator(.)ident(GotoKey)operator(()ident(UntilLastChar)operator(()ident(Node)operator(.)ident(Text)operator(,) char<delimiter(')content(=)delimiter(')>operator(\)\)) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfAsHexCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SfAsHexCB) reserved(do) reserved(begin) + ident(SfIgnoreCaseCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + ident(SfWildCardsCB)operator(.)ident(Enabled) operator(:=) ident(Checked)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(Copy1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(ListTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(Node)operator(.)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfIgnoreCaseCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SfUseLocalesCB)operator(.)ident(Enabled) operator(:=) ident(SfIgnoreCaseCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(ImageFile)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Caption) operator(:=) string<delimiter(')content(Pluto.RegMole )delimiter(')> operator(+) ident(RegMoleVersion) operator(+) + string<delimiter(')content( - The fastest registry search engine for Win9x)delimiter(')>operator(;) + + ident(ImageFile) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(mole.bmp)delimiter(')>operator(;) + reserved(if) ident(FileExists)operator(()ident(ImageFile)operator(\)) reserved(then) + ident(MoleLogoI)operator(.)ident(Picture)operator(.)ident(LoadFromFile)operator(()ident(ImageFile)operator(\);) + + ident(Width) operator(:=) ident(Screen)operator(.)ident(WorkAreaWidth) operator(-) integer(100)operator(;) + + ident(CloseFindPrefP)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Top) operator(:=) ident(Screen)operator(.)ident(WorkAreaHeight) operator(-) integer(450)operator(;) + ident(Height) operator(:=) ident(Screen)operator(.)ident(WorkAreaHeight) operator(-) ident(Top)operator(;) + ident(Left) operator(:=) operator(()ident(Screen)operator(.)ident(WorkAreaWidth) operator(-) ident(Width)operator(\)) reserved(div) integer(2)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFindWin)operator(.)ident(SfTypesCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(TypeRangeE)operator(.)ident(Enabled) operator(:=) ident(SfTypesCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(Plutoconst)operator(;) + +reserved(interface) + +reserved(uses) ident(ComCtrls)operator(,) ident(Classes)operator(,) ident(XReg)operator(,) ident(UniKey)operator(,) ident(YTools)operator(;) + +reserved(var) + ident(Started)operator(:) ident(Boolean) operator(=) ident(False)operator(;) + ident(MurphyMode)operator(:) ident(Boolean) operator(=) ident(False)operator(;) + ident(PlutoKey)operator(:) ident(TUniKey)operator(;) + +reserved(const) + ident(Version) operator(=) string<delimiter(')content(1.6 -nium Alpha)delimiter(')>operator(;) + ident(Overnight) operator(=) ident(True)operator(;) + ident(Codename) operator(=) string<delimiter(')content(Phoenix)delimiter(')>operator(;) + comment(//Generation.Version-Release-Beta) + comment(// GG.VVRRBB) + ident(VersionNum)operator(:) ident(Double) operator(=) float(1.600000)operator(;) + comment(//Must be Double!) + +reserved(const) + ident(iconKey) operator(=) integer(0)operator(;) + + ident(iconFirstHKEY) operator(=) integer(2)operator(;) + ident(iconHKLM) operator(=) ident(iconFirstHKEY)operator(;) + ident(iconHKU) operator(=) ident(iconFirstHKEY) operator(+) integer(2)operator(;) + + ident(iconFirstShortcut) operator(=) ident(iconFirstHKEY) operator(+) integer(4)operator(;) + ident(iconHKCC) operator(=) ident(iconFirstShortcut)operator(;) + ident(iconHKCU) operator(=) ident(iconFirstShortcut) operator(+) integer(2)operator(;) + ident(iconHKCR) operator(=) ident(iconFirstShortcut) operator(+) integer(4)operator(;) + ident(iconHKDD) operator(=) ident(iconFirstShortcut) operator(+) integer(6)operator(;) + ident(iconHKPD) operator(=) ident(iconFirstShortcut) operator(+) integer(8)operator(;) + ident(iconHKWM) operator(=) ident(iconFirstShortcut) operator(+) integer(10)operator(;) + ident(iconHKWU) operator(=) ident(iconFirstShortcut) operator(+) integer(12)operator(;) + ident(iconShortcut) operator(=) ident(iconFirstShortcut) operator(+) integer(14)operator(;) + ident(nHKeyIcons) operator(=) integer(16)operator(;) + + ident(iconFirstType) operator(=) ident(iconFirstShortcut) operator(+) ident(nHKeyIcons)operator(;) + ident(iconNone) operator(=) ident(iconFirstType) operator(+) integer(0)operator(;) + ident(iconString) operator(=) ident(iconFirstType) operator(+) integer(1)operator(;) + ident(iconExpandString) operator(=)ident(iconFirstType) operator(+) integer(2)operator(;) + ident(iconBinary) operator(=) ident(iconFirstType) operator(+) integer(3)operator(;) + ident(iconCardinal) operator(=) ident(iconFirstType) operator(+) integer(4)operator(;) + ident(iconCardBigEndian)operator(=)ident(iconFirstType) operator(+) integer(5)operator(;) + ident(iconLink) operator(=) ident(iconFirstType) operator(+) integer(6)operator(;) + ident(iconMultiString) operator(=) ident(iconFirstType) operator(+) integer(7)operator(;) + ident(iconResList) operator(=) ident(iconFirstType) operator(+) integer(8)operator(;) + ident(iconFullResDesc) operator(=) ident(iconFirstType) operator(+) integer(9)operator(;) + ident(iconResReqList) operator(=) ident(iconFirstType) operator(+) integer(10)operator(;) + ident(iconUnknownType) operator(=) ident(iconFirstType) operator(+) integer(11)operator(;) + ident(nTypeIcons) operator(=) integer(12)operator(;) + + ident(iconFirstValue) operator(=) ident(iconFirstType) operator(+) ident(nTypeIcons)operator(;) + ident(iconValueElse) operator(=) ident(iconFirstValue)operator(;) + ident(iconValueEdit) operator(=) ident(iconFirstValue) operator(+) integer(1)operator(;) + ident(iconValueEditBinary) operator(=) ident(iconFirstValue) operator(+) integer(2)operator(;) + ident(iconValueZeromize) operator(=) ident(iconFirstValue) operator(+) integer(3)operator(;) + ident(iconValueDublicate) operator(=) ident(iconFirstValue) operator(+) integer(4)operator(;) + ident(iconMainValue) operator(=) ident(iconFirstValue) operator(+) integer(5)operator(;) + ident(iconTakeAsMainValue) operator(=) ident(iconFirstValue) operator(+) integer(6)operator(;) + ident(nValueIcons) operator(=) integer(7)operator(;) + + ident(iconFirstKey) operator(=) ident(iconFirstValue) operator(+) ident(nValueIcons)operator(;) + ident(iconKeyInfos) operator(=) ident(iconFirstKey)operator(;) + ident(iconSubKey) operator(=) ident(iconFirstKey) operator(+) integer(1)operator(;) + ident(iconKeyDublicate) operator(=) ident(iconFirstKey) operator(+) integer(2)operator(;) + ident(iconKeyFind) operator(=) ident(iconFirstKey) operator(+) integer(3)operator(;) + ident(iconKeyTrace) operator(=) ident(iconFirstKey) operator(+) integer(4)operator(;) + ident(nKeyIcons) operator(=) integer(5)operator(;) + + ident(iconFirstContextMenues) operator(=) ident(iconFirstKey) operator(+) ident(nKeyIcons)operator(;) + ident(iconRename) operator(=) ident(iconFirstContextMenues)operator(;) + ident(iconDelete) operator(=) ident(iconFirstContextMenues) operator(+) integer(1)operator(;) + ident(nContextMenuesIcon) operator(=) integer(2)operator(;) + + ident(iconFirstIni) operator(=) ident(iconFirstContextMenues) operator(+) ident(nContextMenuesIcon)operator(;) + ident(iconIniSection) operator(=) ident(iconFirstIni)operator(;) + ident(nIniIcons) operator(=) integer(1)operator(;) + + ident(iconFirstHost) operator(=) ident(iconFirstIni) operator(+) ident(nIniIcons)operator(;) + ident(iconHostReg) operator(=) ident(iconFirstHost)operator(;) + ident(iconHostIni) operator(=) ident(iconFirstHost) operator(+) integer(1)operator(;) + ident(iconHostUni) operator(=) ident(iconFirstHost) operator(+) integer(2)operator(;) + ident(iconHostUni2) operator(=) ident(iconFirstHost) operator(+) integer(3)operator(;) + ident(nHostIcons) operator(=) integer(4)operator(;) + + ident(iconFirstOther) operator(=) ident(iconFirstHost) operator(+) ident(nHostIcons)operator(;) + + ident(iconSortArrowAsc) operator(=) ident(iconFirstOther) operator(+) integer(0)operator(;) + ident(iconSortArrowDesc) operator(=) ident(iconFirstOther) operator(+) integer(1)operator(;) + ident(iconKeyMiddle) operator(=) ident(iconFirstOther) operator(+) integer(2)operator(;) + ident(iconLock) operator(=) ident(iconFirstOther) operator(+) integer(3)operator(;) + + comment(//iconDefect = iconFirstOther;) + + comment({ WorkWin.ChangeImages }) + ident(iconFirstChange) operator(=) integer(0)operator(;) + ident(iconCKeyPlus) operator(=) ident(iconFirstChange)operator(;) + ident(iconCKeyMinus) operator(=) ident(iconFirstChange) operator(+) integer(1)operator(;) + ident(iconCValuePlus) operator(=) ident(iconFirstChange) operator(+) integer(2)operator(;) + ident(iconCValueMinus) operator(=) ident(iconFirstChange) operator(+) integer(3)operator(;) + ident(iconCContext) operator(=) ident(iconFirstChange) operator(+) integer(4)operator(;) + ident(iconOldContext) operator(=) ident(iconFirstChange) operator(+) integer(5)operator(;) + ident(iconNewContext) operator(=) ident(iconFirstChange) operator(+) integer(6)operator(;) + ident(iconGroup) operator(=) ident(iconFirstChange) operator(+) integer(7)operator(;) + ident(iconGroupBlinking) operator(=) ident(iconFirstChange) operator(+) integer(8)operator(;) + ident(nChangeIcons) operator(=) integer(7)operator(;) + + ident(DefaultValueFlag) operator(=) ident(Pointer)operator(()integer(1)operator(\);) + ident(MultiEditFlag) operator(=) ident(Pointer)operator(()integer(2)operator(\);) + + ident(NoValueCaption) operator(=) string<delimiter(')content([No Value])delimiter(')>operator(;) + + ident(EditControlFlag) operator(=) integer(100)operator(;) + + ident(MaxPreviewLen) operator(=) integer(255)operator(;) + ident(RegMaxDataSize) operator(=) hex($FFFF)operator(;) comment(//64 KB) + +reserved(const) + ident(BoolStrFileName) operator(=) string<delimiter(')content(Boolean Strings.txt)delimiter(')>operator(;) + ident(ShortcutsFileName) operator(=) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(;) + ident(StandardShortcutsFileName) operator(=) string<delimiter(')content(StandardShortcuts.ini)delimiter(')>operator(;) + ident(SisyFilterFileName) operator(=) string<delimiter(')content(sisy filter.txt)delimiter(')>operator(;) + + ident(clDarkGray) operator(=) hex($00404040)operator(;) + ident(clBrightRed) operator(=) hex($00BBBBFF)operator(;) + ident(clVeryBrightRed) operator(=) hex($00DDDDFF)operator(;) + ident(clBrightBlue) operator(=) hex($00FFBBBB)operator(;) + ident(clBrightGreen) operator(=) hex($00BBFFBB)operator(;) + ident(clCyan) operator(=) hex($00FFFF44)operator(;) + ident(clBrightCyan) operator(=) hex($00FFFFBB)operator(;) + ident(clVeryBrightCyan) operator(=) hex($00FFFFDD)operator(;) + ident(clBrightYellow) operator(=) hex($00BBFFFF)operator(;) + ident(clVeryBrightYellow) operator(=) hex($00DDFFFF)operator(;) + ident(clBrightPurple) operator(=) hex($00FFBBFF)operator(;) + ident(clBrightSilver) operator(=) hex($00DDDDDD)operator(;) + ident(clGold) operator(=) hex($0055CCEE)operator(;) + + ident(clVeryBrightBlue) operator(=) hex($00FFDDDD)operator(;) + +reserved(type) + ident(TValueListColumn) operator(=) operator(()ident(vlcName)operator(,) ident(vlcSize)operator(,) ident(vlcType)operator(,) ident(vlcData)operator(\);) + +reserved(const) + ident(ValueListColumnRange) operator(=) operator([)ident(Low)operator(()ident(TValueListColumn)operator(\)..)ident(High)operator(()ident(TValueListColumn)operator(\)];) + +reserved(type) + ident(TSearchVar) operator(=) operator(()ident(sfKeys)operator(,) ident(sfValueNames)operator(,) ident(sfValueData)operator(,) + ident(sfAsHex)operator(,) ident(sfAsDWord)operator(,) + ident(sfWildCards)operator(,) ident(sfParts)operator(,) ident(sfIgnoreCase)operator(,) ident(SfUseLocales)operator(,) + ident(sfHKU)operator(,) ident(sfHKLM)operator(,) ident(sfHKDD)operator(,//) ident(sfCLSID)operator(,) ident(sfInterface)operator(,) + ident(sfString)operator(,) ident(sfDWord)operator(,) ident(sfOtherTypes)operator(,) ident(sfSpecialTypes)operator(\);) + + ident(TSearchOptions) operator(=) reserved(set) reserved(of) ident(TSearchVar)operator(;) + + comment(//be carefull: used in with!) + ident(TKeyShortcut) operator(=) reserved(record) + ident(Alias)operator(:) reserved(string)operator(;) + ident(RealPath)operator(:) reserved(string)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(end)operator(;) + ident(PKeyShortcut) operator(=) operator(^)ident(TKeyShortcut)operator(;) + ident(TShortcutA) operator(=) reserved(array) reserved(of) ident(TKeyShortcut)operator(;) + + ident(TOpenNode) operator(=) reserved(function) operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) + ident(TCheckNode) operator(=) reserved(procedure) operator(()ident(Node)operator(:) ident(TTreeNode)operator(;) ident(OnlyOnce)operator(:) ident(Boolean) operator(=) ident(True)operator(\);) + + comment(//NodeInfo System) + ident(TNodeFlag) operator(=) operator(()ident(nfDefect)operator(,) ident(nfReadOnly)operator(,) ident(nfChecked)operator(,) + ident(nfCopy)operator(,) ident(nfCut)operator(,) ident(nfPaste)operator(\);) + ident(TNodeFlags) operator(=) reserved(set) reserved(of) ident(TNodeFlag)operator(;) + + ident(TUniHostType) operator(=) operator(()ident(uhNone)operator(,) + ident(uhReg)operator(,) ident(uhIni)operator(,) ident(uhRegFile)operator(,) + ident(uhUserShortcut)operator(,) ident(uhStandardShortcut)operator(,) ident(uhSystemShortcut)operator(\);) + ident(TUniHostTypes) operator(=) reserved(set) reserved(of) ident(TUniHostType)operator(;) + +reserved(const) + ident(uhShortcuts) operator(=) operator([)ident(uhUserShortcut)operator(,) ident(uhStandardShortcut)operator(,) ident(uhSystemShortcut)operator(];) + ident(uhNonSystemShortcuts) operator(=) operator([)ident(uhUserShortcut)operator(,) ident(uhStandardShortcut)operator(];) + + ident(NodeFlagStrings)operator(:) reserved(array)operator([)ident(TNodeFlag)operator(]) reserved(of) reserved(string) operator(=) operator(() + string<delimiter(')content(nfDefect)delimiter(')>operator(,) string<delimiter(')content(nfReadOnly)delimiter(')>operator(,) string<delimiter(')content(nfChecked)delimiter(')>operator(,) + string<delimiter(')content(nfCopy)delimiter(')>operator(,) string<delimiter(')content(nfCut)delimiter(')>operator(,) string<delimiter(')content(nfPaste)delimiter(')>operator(\);) + + ident(HostTypeStrings)operator(:) reserved(array)operator([)ident(TUniHostType)operator(]) reserved(of) reserved(string) operator(=) operator(()string<delimiter(')content(uhNone)delimiter(')>operator(,) + string<delimiter(')content(uhReg)delimiter(')>operator(,) string<delimiter(')content(uhIni)delimiter(')>operator(,) string<delimiter(')content(uhRegFile)delimiter(')>operator(,) + string<delimiter(')content(uhUserShortcut)delimiter(')>operator(,) string<delimiter(')content(uhStandardShortcut)delimiter(')>operator(,) string<delimiter(')content(uhSystemShortcut)delimiter(')>operator(\);) + +reserved(type) + ident(TNodeInfo) operator(=) reserved(packed) reserved(class) + directive(public) + ident(HostType)operator(:) ident(TUniHostType)operator(;) + ident(Flags)operator(:) ident(TNodeFlags)operator(;) + reserved(constructor) ident(Create)operator(()ident(HostType)operator(:) ident(TUniHostType) operator(=) ident(uhNone)operator(;) ident(Flags)operator(:) ident(TNodeFlags) operator(=) operator([]\);) + + reserved(procedure) ident(IncludeFlag)operator(()ident(Flag)operator(:) ident(TNodeFlag)operator(\);) + reserved(procedure) ident(ExcludeFlag)operator(()ident(Flag)operator(:) ident(TNodeFlag)operator(\);) + + reserved(function) ident(IsHost)operator(:) ident(Boolean)operator(;) + reserved(function) ident(IsShortcut)operator(:) ident(Boolean)operator(;) + + reserved(function) ident(ReadOnly)operator(:) ident(Boolean)operator(;) + reserved(function) ident(Checked)operator(:) ident(Boolean)operator(;) + reserved(function) ident(Defect)operator(:) ident(Boolean)operator(;) + reserved(end)operator(;) + +reserved(function) ident(NodeInfo)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(TNodeInfo)operator(;) +reserved(procedure) ident(ReportStatus)operator(()reserved(const) ident(s)operator(:) reserved(string)operator(\);) + +reserved(const) + ident(PlatformStrings)operator(:) reserved(array)operator([)integer(0)operator(..)integer(2)operator(]) reserved(of) reserved(string) operator(=) + operator(()string<delimiter(')content(VER_PLATFORM_WIN32s)delimiter(')>operator(,) string<delimiter(')content(VER_PLATFORM_WIN32_WINDOWS)delimiter(')>operator(,) string<delimiter(')content(VER_PLATFORM_WIN32_NT)delimiter(')>operator(\);) + +reserved(var) + ident(PlutoDir)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + +reserved(implementation) + +reserved(uses) ident(SysUtils)operator(;) + +reserved(function) ident(NodeInfo)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(TNodeInfo)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) reserved(nil)operator(;) + ident(Exit) reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(.)ident(Data)operator(\)) reserved(then) + ident(Node)operator(.)ident(Data) operator(:=) ident(TNodeInfo)operator(.)ident(Create)operator(;) + ident(Result) operator(:=) ident(TNodeInfo)operator(()ident(Node)operator(.)ident(Data)operator(\);) +reserved(end)operator(;) + +comment({ TNodeInfo }) + +reserved(constructor) ident(TNodeInfo)operator(.)ident(Create)operator(()ident(HostType)operator(:) ident(TUniHostType)operator(;) ident(Flags)operator(:) ident(TNodeFlags)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(;) + ident(Self)operator(.)ident(HostType) operator(:=) ident(HostType)operator(;) + ident(Self)operator(.)ident(Flags) operator(:=) ident(Flags)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TNodeInfo)operator(.)ident(Checked)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(nfChecked) reserved(in) ident(Flags)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TNodeInfo)operator(.)ident(ReadOnly)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(nfReadOnly) reserved(in) ident(Flags)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TNodeInfo)operator(.)ident(Defect)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(nfDefect) reserved(in) ident(Flags)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TNodeInfo)operator(.)ident(IncludeFlag)operator(()ident(Flag)operator(:) ident(TNodeFlag)operator(\);) +reserved(begin) + ident(Include)operator(()ident(Flags)operator(,) ident(Flag)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TNodeInfo)operator(.)ident(ExcludeFlag)operator(()ident(Flag)operator(:) ident(TNodeFlag)operator(\);) +reserved(begin) + ident(Exclude)operator(()ident(Flags)operator(,) ident(Flag)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TNodeInfo)operator(.)ident(IsHost)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(HostType) operator(<>) ident(uhNone)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TNodeInfo)operator(.)ident(IsShortcut)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(HostType) reserved(in) ident(uhShortcuts)operator(;) +reserved(end)operator(;) + +reserved(function) ident(GetPlutoDir)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(LWPSlash)operator(()ident(GetParam)operator(()string<delimiter(')content(-imports=)delimiter(')>operator(,) ident(MyDir)operator(\)\);) + reserved(if) reserved(not) ident(DirectoryExists)operator(()ident(Result)operator(\)) reserved(then) reserved(begin) + ident(ReportStatus)operator(()string<delimiter(')content(PlutoDir ")delimiter(')> operator(+) ident(Result) operator(+) string<delimiter(')content(" not found -> setting to default (MyDir\).)delimiter(')>operator(\);) + ident(Result) operator(:=) ident(MyDir)operator(;) + reserved(end)operator(;) + ident(ReportStatus)operator(()string<delimiter(')content(PlutoDir=)delimiter(')> operator(+) ident(Result)operator(\);) +reserved(end)operator(;) + +reserved(var) + ident(ReportSL)operator(:) ident(TStringList)operator(;) + ident(ReportFileName)operator(:) reserved(string)operator(;) + +reserved(procedure) ident(ReportStatus)operator(()reserved(const) ident(s)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(ReportSL)operator(.)ident(Add)operator(()ident(s)operator(\);) + reserved(try) + ident(ReportSL)operator(.)ident(SaveToFile)operator(()ident(ReportFileName)operator(\);) + reserved(except) reserved(end)operator(;) +reserved(end)operator(;) + +reserved(initialization) + ident(ReportFileName) operator(:=) ident(MyDir) operator(+) string<delimiter(')content(loadreport.txt)delimiter(')>operator(;) + ident(ReportSL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(PlutoDir) operator(:=) ident(GetPlutoDir)operator(;) + +reserved(end)operator(.) +comment(//winampviscolor <viscolor.txt>:) +reserved(unit) ident(plutomain)operator(;) +preprocessor({$DEFINE UNIKEY}) +preprocessor({$DEFINE CYCFS}) + +comment({=============================================================================== + + cYcnus.Pluto 1.57 Beta 14 + by Murphy + + ©2000-2003 by cYcnus + visit www.cYcnus.de + + murphy@cYcnus.de (Kornelius Kalnbach\) + + this programm is published under the terms of the GPL + +===============================================================================}) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) ident(Dialogs)operator(,) + ident(StdCtrls)operator(,) ident(ImgList)operator(,) ident(ComCtrls)operator(,) ident(ExtCtrls)operator(,) ident(Menus)operator(,) ident(Clipbrd)operator(,) ident(IniFiles)operator(,) + ident(ShellAPI)operator(,) ident(Grids)operator(,) + comment(//Components) + ident(NewPanels)operator(,) + comment(//Units) + ident(YTools)operator(,) ident(YTypes)operator(,) ident(UniKey)operator(,) ident(XReg)operator(,) + comment(//Pluto) + ident(Plutoconst)operator(,) + ident(SpyTH)operator(,) ident(SisyphusTH)operator(;) + +reserved(const) + ident(NoPreBlinkHint) operator(=) char(#1)operator(;) + +reserved(type) + ident(TMainWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(StatusBar)operator(:) ident(TStatusBar)operator(;) + ident(StatusBarPU)operator(:) ident(TPopupMenu)operator(;) + ident(CopyPath)operator(:) ident(TMenuItem)operator(;) + ident(InsertPath)operator(:) ident(TMenuItem)operator(;) + ident(ShowRealPathMI)operator(:) ident(TMenuItem)operator(;) + ident(PathP)operator(:) ident(TPanel)operator(;) + ident(N1)operator(:) ident(TMenuItem)operator(;) + ident(MainMenu1)operator(:) ident(TMainMenu)operator(;) + ident(Desktop1)operator(:) ident(TMenuItem)operator(;) + ident(Pluto1)operator(:) ident(TMenuItem)operator(;) + ident(RegEdit1)operator(:) ident(TMenuItem)operator(;) + ident(Free1)operator(:) ident(TMenuItem)operator(;) + ident(BigVal1)operator(:) ident(TMenuItem)operator(;) + ident(Hilfe1)operator(:) ident(TMenuItem)operator(;) + ident(History1)operator(:) ident(TMenuItem)operator(;) + ident(SplashScreen1)operator(:) ident(TMenuItem)operator(;) + ident(wwwcYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(Credits1)operator(:) ident(TMenuItem)operator(;) + ident(Optionen1)operator(:) ident(TMenuItem)operator(;) + ident(PrefMI)operator(:) ident(TMenuItem)operator(;) + ident(EditBoolStrMI)operator(:) ident(TMenuItem)operator(;) + ident(N4)operator(:) ident(TMenuItem)operator(;) + ident(ImageList1)operator(:) ident(TImageList)operator(;) + ident(Plutoini1)operator(:) ident(TMenuItem)operator(;) + ident(About1)operator(:) ident(TMenuItem)operator(;) + ident(kornycYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(ools1)operator(:) ident(TMenuItem)operator(;) + ident(NotePad1)operator(:) ident(TMenuItem)operator(;) + ident(RegEdit2)operator(:) ident(TMenuItem)operator(;) + ident(SysEdit1)operator(:) ident(TMenuItem)operator(;) + ident(WordPad1)operator(:) ident(TMenuItem)operator(;) + ident(N3)operator(:) ident(TMenuItem)operator(;) + ident(N5)operator(:) ident(TMenuItem)operator(;) + ident(Suchen1)operator(:) ident(TMenuItem)operator(;) + ident(Find1)operator(:) ident(TMenuItem)operator(;) + ident(File1)operator(:) ident(TMenuItem)operator(;) + ident(ExitPluto1)operator(:) ident(TMenuItem)operator(;) + ident(OpenProgramFolder1)operator(:) ident(TMenuItem)operator(;) + ident(N6)operator(:) ident(TMenuItem)operator(;) + ident(OpenWinDir1)operator(:) ident(TMenuItem)operator(;) + ident(HintBlinkT)operator(:) ident(TTimer)operator(;) + ident(FindCLSID1)operator(:) ident(TMenuItem)operator(;) + ident(Clipboard1)operator(:) ident(TMenuItem)operator(;) + ident(GotoCLSID1)operator(:) ident(TMenuItem)operator(;) + ident(CommandLineParameters1)operator(:) ident(TMenuItem)operator(;) + ident(plutocYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(N7)operator(:) ident(TMenuItem)operator(;) + ident(heinzcYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(kornycYcnusde2)operator(:) ident(TMenuItem)operator(;) + ident(N8)operator(:) ident(TMenuItem)operator(;) + ident(ExternalHexEditMI)operator(:) ident(TMenuItem)operator(;) + ident(Cleanup1)operator(:) ident(TMenuItem)operator(;) + ident(DeleteTempFolder1)operator(:) ident(TMenuItem)operator(;) + ident(Debug1)operator(:) ident(TMenuItem)operator(;) + ident(CurrentDir1)operator(:) ident(TMenuItem)operator(;) + ident(RepairPluto155bBug1)operator(:) ident(TMenuItem)operator(;) + ident(BackupRegistryscanreg1)operator(:) ident(TMenuItem)operator(;) + ident(Username1)operator(:) ident(TMenuItem)operator(;) + ident(SupportMI)operator(:) ident(TMenuItem)operator(;) + ident(MurphyMI)operator(:) ident(TMenuItem)operator(;) + ident(ToDoMI)operator(:) ident(TMenuItem)operator(;) + ident(Beta1)operator(:) ident(TMenuItem)operator(;) + ident(UniKeycYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(YToolscYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(YPanelscYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(Usedenginescomponents1)operator(:) ident(TMenuItem)operator(;) + ident(PrefToolscYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(BugReportsRequests1)operator(:) ident(TMenuItem)operator(;) + ident(murphycYcnusde1)operator(:) ident(TMenuItem)operator(;) + ident(Credits2)operator(:) ident(TMenuItem)operator(;) + ident(News1)operator(:) ident(TMenuItem)operator(;) + ident(cYcnus1)operator(:) ident(TMenuItem)operator(;) + ident(Contact1)operator(:) ident(TMenuItem)operator(;) + ident(N2)operator(:) ident(TMenuItem)operator(;) + ident(IjustwantCONTACT1)operator(:) ident(TMenuItem)operator(;) + ident(N9)operator(:) ident(TMenuItem)operator(;) + ident(AnotherPluto1)operator(:) ident(TMenuItem)operator(;) + ident(UniKeyDemoMI)operator(:) ident(TMenuItem)operator(;) + ident(Path1)operator(:) ident(TMenuItem)operator(;) + ident(RegisterPlugIns1)operator(:) ident(TMenuItem)operator(;) + ident(UniPluginOD)operator(:) ident(TOpenDialog)operator(;) + ident(SwapLM_CUB)operator(:) ident(TButton)operator(;) + ident(PathE)operator(:) ident(TEdit)operator(;) + ident(ShowLoadreport1)operator(:) ident(TMenuItem)operator(;) + ident(KillPluto1)operator(:) ident(TMenuItem)operator(;) + ident(ShowPlatform1)operator(:) ident(TMenuItem)operator(;) + ident(MSConfig1)operator(:) ident(TMenuItem)operator(;) + ident(TimetoRelaxMI)operator(:) ident(TMenuItem)operator(;) + ident(N10)operator(:) ident(TMenuItem)operator(;) + + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) + reserved(procedure) ident(InsertPathClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(StatusBarResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StatusBarDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StatusBarUpdate)operator(;) + reserved(procedure) ident(CopyPathClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(SetStatus)operator(;) + reserved(procedure) ident(GotoKey)operator(()ident(Key)operator(:) reserved(string)operator(\);) + reserved(procedure) ident(FindCLSID)operator(;) + reserved(procedure) ident(GotoCLSID)operator(;) + reserved(procedure) ident(UserGotoKey)operator(;) + reserved(procedure) ident(ShowRealPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(PathEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(PathEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(PathEExit)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(AppActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(PathEKeyUp)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Pluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegEdit1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Free1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BigVal1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SplashScreen1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HistoryClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Credits1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(function) ident(Greeting)operator(()ident(Name)operator(:) reserved(string) operator(=) ident(NoPreBlinkHint)operator(\):) reserved(string)operator(;) + reserved(procedure) ident(PrefMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(EditBoolStrMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormCloseQuery)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(CanClose)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(SisyTerminate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OnSisyChange)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) + reserved(procedure) ident(OnSisyValuePlus)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) + reserved(procedure) ident(OnSisyValueMinus)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) + reserved(procedure) ident(OnSisyContextChange)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) + + reserved(procedure) ident(Plutoini1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegEdit2Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SysEdit1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NotePad1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(WordPad1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OpenWinDir1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OpenProgramFolder1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ExitPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Find1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormPaint)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(Load)operator(;) + reserved(procedure) ident(StatusBarDrawPanel)operator(()ident(StatusBar)operator(:) ident(TStatusBar)operator(;) + ident(Panel)operator(:) ident(TStatusPanel)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(\);) + reserved(procedure) ident(PathEKeyPress)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Char)operator(\);) + reserved(procedure) ident(HintBlinkTTimer)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FindCLSID1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(GotoCLSID1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CommandLineParameters1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(WebLinkMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DeleteTempFolder1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CurrentDir1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RepairPluto155bBug1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BackupRegistryscanreg1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyStarted)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StopHintBlinking)operator(;) + reserved(procedure) ident(Username1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SupportMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ToDoMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MailLinkMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(IjustwantCONTACT1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ExternalHexEditMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(AnotherPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Path1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegisterPlugIns1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SwapLM_CUBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowLoadreport1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(KillPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowPlatform1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MSConfig1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(TimetoRelaxMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + directive(private) + ident(DoAutoComplete)operator(:) ident(Boolean)operator(;) + ident(MainWinLoaded)operator(:) ident(Boolean)operator(;) + ident(DontSavePrefs)operator(:) ident(Boolean)operator(;) + ident(PreBlinkHint)operator(:) reserved(string)operator(;) + reserved(end)operator(;) + +reserved(var) + ident(MainWin)operator(:) ident(TMainWin)operator(;) + + ident(StatusBar)operator(:) ident(TStatusBar)operator(;) + ident(MainReg)operator(:) ident(TXRegistry)operator(;) + + ident(SpyThread)operator(:) ident(TRegSpyThread)operator(;) + ident(Sisys)operator(:) ident(TList)operator(;) + +reserved(function) ident(TempDir)operator(:) reserved(string)operator(;) +reserved(function) ident(PlutoUniPath)operator(:) reserved(string)operator(;) +reserved(function) ident(PlutoIniFileName)operator(:) reserved(string)operator(;) + +reserved(function) ident(PathOfNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) reserved(string)operator(;) +reserved(function) ident(CurKey)operator(()ident(AllowedShortcutTypes)operator(:) ident(TUniHostTypes) operator(=) operator([]\):) ident(TRegPath)operator(;) + +reserved(procedure) ident(ArrangePlutoStyle)operator(;) +reserved(procedure) ident(ArrangeRegEdStyle)operator(;) +reserved(procedure) ident(ArrangeFreeStyle)operator(;) +reserved(procedure) ident(ArrangeBigValStyle)operator(;) + +reserved(procedure) ident(ActivateThis)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(procedure) ident(DeActivateThis)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + +reserved(procedure) ident(SwapFonts)operator(()ident(Sender)operator(:) ident(TWinControl)operator(\);) + +reserved(procedure) ident(AddHint)operator(()reserved(const) ident(Hint)operator(:) reserved(string)operator(;) ident(Blinking)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) +reserved(procedure) ident(AddToLastHint)operator(()ident(Appendix)operator(:) reserved(string)operator(\);) +reserved(procedure) ident(ChangeLastHint)operator(()ident(NewHint)operator(:) reserved(string)operator(\);) + +reserved(implementation) + +reserved(uses) + comment(//Forms) + ident(FindWinU)operator(,) ident(valuesU)operator(,) ident(TreeU)operator(,) ident(WorkU)operator(,) ident(splash)operator(,) ident(PrefU)operator(,) + comment(//Units) + ident(Clock)operator(,) ident(Start)operator(,) ident(keybrd)operator(,) ident(CompEx)operator(,) ident(Colors)operator(,) ident(FindAllThread)operator(,) + ident(PrefTools)operator(;) + +preprocessor({$R *.DFM}) + +reserved(var) + ident(SavedPlutoIniFileName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + +reserved(procedure) ident(AddHint)operator(()reserved(const) ident(Hint)operator(:) reserved(string)operator(;) ident(Blinking)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(WorkWin)operator(\)) reserved(then) + ident(WorkWin)operator(.)ident(AddAHint)operator(()ident(Hint)operator(\);) + + reserved(with) ident(MainWin) reserved(do) reserved(begin) + ident(StopHintBlinking)operator(;) + + reserved(if) ident(Blinking) reserved(then) reserved(begin) + ident(HintBlinkT)operator(.)ident(Enabled) operator(:=) ident(True)operator(;) + reserved(if) ident(PreBlinkHint) operator(=) ident(NoPreBlinkHint) reserved(then) + ident(PreBlinkHint) operator(:=) ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text)operator(;) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text) operator(:=) ident(WorkWin)operator(.)ident(LastHint)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(AddToLastHint)operator(()ident(Appendix)operator(:) reserved(string)operator(\);) +reserved(begin) + reserved(with) ident(WorkWin)operator(.)ident(HintLB)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(if) ident(Count) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Strings)operator([)ident(Count)operator(-)integer(1)operator(]) operator(:=) ident(Strings)operator([)ident(Count)operator(-)integer(1)operator(]) operator(+) ident(Appendix)operator(;) + reserved(end)operator(;) + ident(Application)operator(.)ident(ProcessMessages)operator(;) +comment(// Sleep(1000\);) +reserved(end)operator(;) + +reserved(procedure) ident(ChangeLastHint)operator(()ident(NewHint)operator(:) reserved(string)operator(\);) +reserved(begin) + reserved(with) ident(WorkWin)operator(.)ident(HintLB)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(if) ident(Count) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Strings)operator([)ident(Count)operator(-)integer(1)operator(]) operator(:=) ident(NewHint)operator(;) + reserved(end)operator(;) + ident(Application)operator(.)ident(ProcessMessages)operator(;) +comment(// Sleep(1000\);) +reserved(end)operator(;) + +reserved(function) ident(CurKey)operator(()ident(AllowedShortcutTypes)operator(:) ident(TUniHostTypes) operator(=) operator([]\):) ident(TRegPath)operator(;) +reserved(var) + ident(s)operator(:) reserved(string)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)) reserved(then) reserved(begin) + ident(s) operator(:=) ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\);) + reserved(if) ident(AllowedShortcutTypes) operator(<>) operator([]) reserved(then) + ident(s) operator(:=) ident(TraceKey)operator(()ident(s)operator(,) ident(AllowedShortcutTypes)operator(\);) + ident(Result)operator(.)ident(Root) operator(:=) ident(ExRegRoot)operator(()ident(s)operator(\);) + ident(Result)operator(.)ident(Key) operator(:=) ident(ExRegKey)operator(()ident(s)operator(\);) + + ident(Item) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + reserved(if) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) + ident(Result)operator(.)ident(Value) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\);) + ident(Result)operator(.)ident(ValueSet) operator(:=) ident(Assigned)operator(()ident(Item)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PathOfNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) + ident(Result) operator(:=) ident(LWPSlash)operator(()ident(PathOfNode)operator(()ident(Node)operator(.)ident(Parent)operator(\)\)) operator(+) ident(Node)operator(.)ident(Text) + reserved(else) + ident(Result) operator(:=) ident(Node)operator(.)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(AppActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(ActForm)operator(:) ident(TCustomForm)operator(;) + + reserved(procedure) ident(TryShow)operator(()ident(Win)operator(:) ident(TCustomForm)operator(\);) + reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Win)operator(\)) reserved(and) ident(Win)operator(.)ident(Visible) reserved(then) + ident(Win)operator(.)ident(Show)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(ActForm) operator(:=) ident(Screen)operator(.)ident(ActiveCustomForm)operator(;) comment(//LastActiveForm;) + ident(TryShow)operator(()ident(ValuesWin)operator(\);) + ident(TryShow)operator(()ident(WorkWin)operator(\);) + ident(TryShow)operator(()ident(TreeWin)operator(\);) + ident(TryShow)operator(()ident(FindWin)operator(\);) + ident(TryShow)operator(()ident(SplashWin)operator(\);) + ident(TryShow)operator(()ident(MainWin)operator(\);) + ident(TryShow)operator(()ident(ActForm)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(InitHKEYString)operator(()reserved(var) ident(H)operator(:) ident(THKEYString)operator(;) reserved(const) ident(Long)operator(,) ident(Short)operator(:) reserved(string)operator(;) + ident(Handle)operator(:) ident(Integer) operator(=) integer(0)operator(;) ident(IsDefault)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) + reserved(begin) + ident(H)operator(.)ident(Long) operator(:=) ident(Long)operator(;) + ident(H)operator(.)ident(Short) operator(:=) ident(Short)operator(;) + ident(H)operator(.)ident(Handle) operator(:=) ident(Handle)operator(;) + ident(H)operator(.)ident(IsDefault) operator(:=) ident(IsDefault)operator(;) + reserved(end)operator(;) + +reserved(begin) +preprocessor({$IFDEF UNIKEY}) +preprocessor({$IFDEF CYCFS}) + ident(RegisterUniClass)operator(()string<delimiter(')content(Y:\\programme\\unikey\\cyc_fs.uni)delimiter(')>operator(\);) +preprocessor({$ENDIF}) +preprocessor({$ENDIF}) + + ident(Application)operator(.)ident(OnActivate) operator(:=) ident(AppActivate)operator(;) + ident(PlutoMain)operator(.)ident(StatusBar) operator(:=) ident(StatusBar)operator(;) + + comment(//Creating) + ident(MainReg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + + comment(//Initialize) + ident(Caption) operator(:=) string<delimiter(')content(cYcnus.Pluto )delimiter(')> operator(+) ident(Version)operator(;) + ident(PreBlinkHint) operator(:=) ident(NoPreBlinkHint)operator(;) + + ident(SetLength)operator(()ident(HKEYStrings)operator(,) ident(Length)operator(()ident(HKEYStrings)operator(\)) operator(+) integer(2)operator(\);) + ident(InitHKEYString)operator(()ident(HKEYStrings)operator([)ident(LastDefaultHKEYString) operator(+) integer(1)operator(],) + string<delimiter(')content(HKEY_WindowsMachine)delimiter(')>operator(,) string<delimiter(')content(HKWM)delimiter(')>operator(\);) + + ident(InitHKEYString)operator(()ident(HKEYStrings)operator([)ident(LastDefaultHKEYString) operator(+) integer(2)operator(],) + string<delimiter(')content(HKEY_WindowsUser)delimiter(')>operator(,) string<delimiter(')content(HKWU)delimiter(')>operator(\);) + + ident(Application)operator(.)ident(HintHidePause) operator(:=) operator(-)integer(1)operator(;) comment(//that's approximately 136 years :D) + + ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Width) operator(:=) ident(Screen)operator(.)ident(Width) reserved(div) integer(6)operator(;) + + ident(MurphyMI)operator(.)ident(Visible) operator(:=) ident(MurphyMode)operator(;) + +preprocessor({$IFDEF UNIKEY}) + ident(UniPluginOD)operator(.)ident(InitialDir) operator(:=) ident(MyDir)operator(;) +preprocessor({$ELSE}) + ident(UniKeyDemoMI)operator(.)ident(Visible) operator(:=) ident(False)operator(;) +preprocessor({$ENDIF}) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(GotoKey)operator(()ident(Key)operator(:) reserved(string)operator(\);) +reserved(var) + ident(Full)operator(:) ident(TregPath)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(keySA)operator(:) ident(TStrA)operator(;) + ident(i)operator(:) ident(integer)operator(;) + + reserved(function) ident(NodeOfRoot)operator(()ident(Root)operator(:) reserved(string)operator(\):) ident(TTreeNode)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(Result) operator(:=) reserved(nil)operator(;) + ident(Root) operator(:=) ident(LongHKEY)operator(()ident(Root)operator(\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(RootNodes)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(SameText)operator(()ident(TTreeNode)operator(()ident(RootNodes)operator([)ident(i)operator(]\).)ident(Text)operator(,) ident(Root)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(TTreeNode)operator(()ident(RootNodes)operator([)ident(i)operator(]\);) + ident(Break)operator(;) reserved(end)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Shortcuts)operator(\)) reserved(do) + reserved(if) ident(SameText)operator(()ident(Shortcuts)operator([)ident(i)operator(].)ident(Alias)operator(,) ident(Full)operator(.)ident(Root)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Shortcuts)operator([)ident(i)operator(].)ident(Node)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(keySA) operator(:=) reserved(nil)operator(;) + + comment(//Get FullPath of the Key) + ident(Key) operator(:=) ident(TrimLeft)operator(()ident(Key)operator(\);) + reserved(if) ident(TextAtPos)operator(()ident(Key)operator(,) integer(1)operator(,) string<delimiter(')content(Reg:)delimiter(')>operator(\)) reserved(then) + ident(Key) operator(:=) ident(TrimLeft)operator(()ident(FromChar)operator(()ident(Key)operator(,) char<delimiter(')content(:)delimiter(')>operator(\)\);) + ident(Key) operator(:=) ident(UnQuote)operator(()ident(Key)operator(\);) + + ident(Full) operator(:=) ident(RegPathOfStr)operator(()ident(Key)operator(\);) + reserved(if) ident(Trim)operator(()ident(Full)operator(.)ident(Root)operator(\)) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Empty Path.)delimiter(')>operator(,) ident(True)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + comment(//Get Root Node) + ident(Node) operator(:=) ident(NodeOfRoot)operator(()ident(Full)operator(.)ident(Root)operator(\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(PathE)operator(.)ident(Focused) reserved(then) + ident(AddHint)operator(()string<delimiter(')content(Key not found:)delimiter(')> operator(+) ident(EOL) operator(+) ident(Key)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + comment(//Create an array of all SubKeys) + ident(keySA) operator(:=) ident(Split)operator(()ident(Full)operator(.)ident(Key)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\);) + + comment(//Avoid SmartExpand) + ident(TreeWin)operator(.)ident(DoSmartExpand) operator(:=) ident(False)operator(;) reserved(begin) + + comment(//Open all SubKeys) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(keySA)operator(\)) reserved(do) reserved(begin) + comment(//Open the Node if neccessary) + reserved(if) reserved(not) ident(Node)operator(.)ident(Expanded) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(Node)operator(.)ident(Selected) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(;) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + comment(//TreeWin.RegTVChange(Self, Node\);) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + reserved(end)operator(;) + + comment(//Get Node of the SubKey) + ident(Node) operator(:=) ident(FindNodeText)operator(()ident(Node)operator(,) ident(keySA)operator([)ident(i)operator(]\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(PathE)operator(.)ident(Focused) reserved(then) + ident(AddHint)operator(()string<delimiter(')content(Goto Key not found: )delimiter(')> operator(+) ident(KeySA)operator([)ident(i)operator(],) ident(True)operator(\);) + ident(Exit)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(end)operator(;) ident(TreeWin)operator(.)ident(DoSmartExpand) operator(:=) ident(True)operator(;) + + reserved(if) ident(Node) operator(<>) ident(RegTV)operator(.)ident(Selected) reserved(then) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(;) + ident(TreeWin)operator(.)ident(RegTVChange)operator(()ident(Self)operator(,) ident(Node)operator(\);) + reserved(end)operator(;) + + ident(Application)operator(.)ident(ProcessMessages)operator(;) + + reserved(if) ident(Full)operator(.)ident(ValueSet) reserved(then) + ident(ValuesWin)operator(.)ident(FocusItem)operator(()ident(Full)operator(.)ident(Value)operator(,) reserved(not) operator(()ident(Active) reserved(and) ident(PathE)operator(.)ident(Focused)operator(\)\)) + reserved(else) reserved(begin) + reserved(if) reserved(not) operator(()ident(Active) reserved(and) ident(PathE)operator(.)ident(Focused)operator(\)) reserved(then) comment(//if not user is currently editing the path) + ident(TreeWin)operator(.)ident(FocusControl)operator(()ident(RegTV)operator(\);) + + reserved(if) ident(LastChar)operator(()ident(Full)operator(.)ident(Key)operator(\)) operator(=) char<delimiter(')content(\\)delimiter(')> reserved(then) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(SwapFonts)operator(()ident(Sender)operator(:) ident(TWinControl)operator(\);) + + reserved(function) ident(OtherFont)operator(()ident(N)operator(:) ident(TFontName)operator(\):) ident(TFontName)operator(;) + reserved(begin) + ident(Result) operator(:=) string<delimiter(')content(Courier New)delimiter(')>operator(;) + reserved(if) ident(N) operator(=) ident(Result) reserved(then) + ident(Result) operator(:=) string<delimiter(')content(Arial)delimiter(')>operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(TEdit)operator(()ident(Sender)operator(\).)ident(Font)operator(.)ident(Name) operator(:=) ident(OtherFont)operator(()ident(TTreeView)operator(()ident(Sender)operator(\).)ident(Font)operator(.)ident(Name)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(ActivateThis)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Sender)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(TEdit)operator(()ident(Sender)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(Tag) operator(<>) ident(EditControlFlag) reserved(then) + ident(Exit)operator(;) + ident(Color) operator(:=) ident(RealColor)operator(()ident(clVeryBrightBlue)operator(\);) + ident(Font)operator(.)ident(Color) operator(:=) ident(clBlack)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(DeActivateThis)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Sender)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(TEdit)operator(()ident(Sender)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(Tag) operator(<>) ident(EditControlFlag) reserved(then) + ident(Exit)operator(;) + ident(Color) operator(:=) ident(RealColor)operator(()ident(clDarkGray)operator(\);) + ident(Font)operator(.)ident(Color) operator(:=) ident(clWhite)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(CreateSisyThreads)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(CreateSisyThread)operator(()reserved(const) ident(Name)operator(:) reserved(string)operator(;) reserved(const) ident(KeyName)operator(:) reserved(string)operator(;) + ident(Key)operator(:) ident(HKEY)operator(;) ident(StatusLabel)operator(:) ident(TLabel)operator(\);) + reserved(var) + ident(Sisy)operator(:) ident(TSisyThread)operator(;) + reserved(begin) + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating )delimiter(')> operator(+) ident(Name) operator(+) string<delimiter(')content(...)delimiter(')>operator(\);) + ident(Sisy) operator(:=) ident(TSisyThread)operator(.)ident(CreateIt)operator(()ident(Name)operator(,) ident(KeyName)operator(,) ident(Key)operator(,) ident(StatusLabel)operator(,) ident(PlutoKey)operator(\);) + ident(Sisy)operator(.)ident(OnChange) operator(:=) ident(MainWin)operator(.)ident(OnSisyChange)operator(;) +comment(// Sisy.OnSpecialChange[cValuePlus] := MainWin.OnSisyValuePlus;) +comment(// Sisy.OnSpecialChange[cValueMinus] := MainWin.OnSisyValueMinus;) +comment(// Sisy.OnSpecialChange[cContextChange] := MainWin.OnSisyContextChange;) + ident(Sisys)operator(.)ident(Add)operator(()ident(Sisy)operator(\);) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Starting Sisyphus )delimiter(')> operator(+) ident(SisyVersion) operator(+) string<delimiter(')content(...)delimiter(')>operator(\);) + + ident(Sisys) operator(:=) ident(TSisyList)operator(.)ident(Create)operator(;) + ident(WorkWin)operator(.)ident(LoadSisyFilter)operator(;) + + ident(CreateSisyThread)operator(()string<delimiter(')content(Sisy HKU)delimiter(')>operator(,) string<delimiter(')content(HKU)delimiter(')>operator(,) ident(HKU)operator(,) ident(WorkWin)operator(.)ident(SisyHKUL)operator(\);) + ident(CreateSisyThread)operator(()string<delimiter(')content(Sisy HKLM)delimiter(')>operator(,) string<delimiter(')content(HKLM)delimiter(')>operator(,) ident(HKLM)operator(,) ident(WorkWin)operator(.)ident(SisyHKLML)operator(\);) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Initializing Sisyphus...)delimiter(')>operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Sisys)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(with) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(i)operator(]\)) reserved(do) reserved(begin) + reserved(if) ident(Name) operator(=) string<delimiter(')content(Sisy HKU)delimiter(')> reserved(then) + reserved(with) ident(WorkWin)operator(.)ident(SisyHKUCB) reserved(do) reserved(begin) + ident(Settings)operator(.)ident(KeyName) operator(:=) ident(StrOfUni)operator(()ident(Uni)operator(.)ident(Path)operator(\);) + ident(Settings)operator(.)ident(Load)operator(;) + ident(Settings)operator(.)ident(AutoSave) operator(:=) ident(True)operator(;) + reserved(if) ident(Checked) reserved(then) + ident(Resume)operator(;) + reserved(end) + reserved(else) reserved(if) ident(Name) operator(=) string<delimiter(')content(Sisy HKLM)delimiter(')> reserved(then) + reserved(with) ident(WorkWin)operator(.)ident(SisyHKLMCB) reserved(do) reserved(begin) + ident(Settings)operator(.)ident(KeyName) operator(:=) ident(StrOfUni)operator(()ident(Uni)operator(.)ident(Path)operator(\);) + ident(Settings)operator(.)ident(Load)operator(;) + ident(Settings)operator(.)ident(AutoSave) operator(:=) ident(True)operator(;) + reserved(if) ident(Checked) reserved(then) + ident(Resume)operator(;) + reserved(end)operator(;) + ident(OnStarted) operator(:=) ident(MainWin)operator(.)ident(SisyStarted)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(CreateSpyThread)operator(;) +reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Creating SpyThread...)delimiter(')>operator(\);) + ident(SpyThread) operator(:=) ident(TRegSpyThread)operator(.)ident(CreateIt)operator(()ident(tpLowest)operator(\);) + ident(WorkWin)operator(.)ident(SpyDelayIEChange)operator(()ident(MainWin)operator(\);) + ident(WorkWin)operator(.)ident(SpyTestLClick)operator(()ident(MainWin)operator(\);) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(ShowParams)operator(;) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + reserved(if) ident(Switch)operator(()string<delimiter(')content(params?)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(GetParams)operator(()ident(SL)operator(\);) + ident(ShowMessage)operator(()ident(SL)operator(.)ident(Text)operator(\);) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(GotoParamKey)operator(;) +reserved(var) + ident(s)operator(:) reserved(string)operator(;) +reserved(begin) + ident(s) operator(:=) ident(ParamStr)operator(()integer(1)operator(\);) + reserved(if) operator(()ident(s) operator(<>) string<delimiter(')delimiter(')>operator(\)) + reserved(and) operator(()ident(s)operator([)integer(1)operator(]) operator(<>) char<delimiter(')content(-)delimiter(')>operator(\)) reserved(then) reserved(begin) comment(//Params have '-' as prefix) + ident(AddHint)operator(()string<delimiter(')content(Goto Key )delimiter(')> operator(+) ident(Quote)operator(()ident(s)operator(\)) operator(+) string<delimiter(')content(...)delimiter(')>operator(\);) + ident(MainWin)operator(.)ident(GotoKey)operator(()ident(s)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(RegTV)operator(.)ident(TopItem)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Load)operator(;) +reserved(begin) + ident(TreeWin)operator(.)ident(Load)operator(;) + ident(WorkWin)operator(.)ident(LoadBoolStr)operator(;) + + ident(CreateSpyThread)operator(;) + ident(CreateSisyThreads)operator(;) + + ident(AddHint)operator(()ident(Greeting)operator(,) ident(True)operator(\);) + + ident(ShowParams)operator(;) + ident(GotoParamKey)operator(;) + + reserved(if) ident(Assigned)operator(()ident(SplashWin)operator(\)) reserved(and) ident(SplashWin)operator(.)ident(Visible) reserved(then) + ident(SplashWin)operator(.)ident(SetFocus)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(CopyPathClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(StatusBar)operator(.)ident(Panels)operator([)integer(1)operator(].)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) operator(()ident(ssAlt) reserved(in) ident(shift)operator(\)) reserved(and) operator(()ident(Key) operator(=) ident(VK_F4)operator(\)) reserved(then) reserved(begin) + ident(Key) operator(:=) integer(0)operator(;) + ident(Close)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(ssCtrl) reserved(in) ident(Shift) reserved(then) + reserved(case) ident(Key) reserved(of) + ident(Byte)operator(()char<delimiter(')content(W)delimiter(')>operator(\):) reserved(begin) + ident(MainPC)operator(.)ident(ActivePage) operator(:=) ident(WorkWin)operator(.)ident(WorkPage)operator(;) + reserved(if) ident(Assigned)operator(()ident(MainPC)operator(.)ident(ActivePage)operator(\)) reserved(then) + ident(WorkWin)operator(.)ident(FocusControl)operator(()ident(TWinControl)operator(()ident(ShowPC)operator(.)ident(ActivePage)operator(.)ident(Tag)operator(\)\)) + reserved(end)operator(;) + + ident(Byte)operator(()char<delimiter(')content(H)delimiter(')>operator(\):) ident(MainPC)operator(.)ident(ActivePage) operator(:=) ident(WorkWin)operator(.)ident(HintPage)operator(;) + + ident(Byte)operator(()char<delimiter(')content(L)delimiter(')>operator(\):) ident(MainWin)operator(.)ident(FindCLSID)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Shift) operator(=) operator([]) reserved(then) + reserved(case) ident(Key) reserved(of) + ident(VK_F6)operator(:) ident(TreeWin)operator(.)ident(FocusControl)operator(()ident(RegTV)operator(\);) + + ident(VK_F7)operator(:) reserved(with) ident(ValueList) reserved(do) reserved(begin) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(if) operator(()ident(Selected) operator(=) reserved(nil)operator(\)) reserved(and) operator(()ident(Items)operator(.)ident(Count) operator(>) integer(0)operator(\)) reserved(then) reserved(begin) + ident(Selected) operator(:=) ident(Items)operator([)integer(0)operator(];) + ident(ItemFocused) operator(:=) ident(Selected)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(VK_F8)operator(:) ident(WorkWin)operator(.)ident(FocusControl)operator(()ident(MainPC)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Key) operator(=) ident(VK_SCROLL) reserved(then) reserved(begin) + ident(TreeWin)operator(.)ident(CheckRegTVHotTrack)operator(;) + ident(ValuesWin)operator(.)ident(CheckValueListHotTrack)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(StatusBarResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(StatusBar) reserved(do) + ident(Panels)operator([)integer(1)operator(].)ident(Width) operator(:=) + ident(Width) operator(-) operator(()ident(Panels)operator([)integer(0)operator(].)ident(Width) operator(+) ident(Panels)operator([)integer(2)operator(].)ident(Width) operator(+) ident(Panels)operator([)integer(3)operator(].)ident(Width)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(StatusBarDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowRealPathMIClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(InsertPathClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(GotoKey)operator(()ident(Clipboard)operator(.)ident(AsText)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SetStatus)operator(;) +reserved(begin) + ident(StatusBarUpdate)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(StatusBarUpdate)operator(;) +reserved(var) + ident(Inf)operator(:) ident(TRegKeyInfo)operator(;) +reserved(begin) + ident(OpenCurKey)operator(;) + ident(MainReg)operator(.)ident(GetKeyInfo)operator(()ident(Inf)operator(\);) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + + ident(StatusBar)operator(.)ident(Panels)operator([)integer(2)operator(].)ident(Text) operator(:=) ident(StrNumerus)operator(()ident(Inf)operator(.)ident(NumSubKeys)operator(,) string<delimiter(')content(key)delimiter(')>operator(,) string<delimiter(')content(keys)delimiter(')>operator(,) string<delimiter(')content(no)delimiter(')>operator(\);) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(3)operator(].)ident(Text) operator(:=) ident(StrNumerus)operator(()ident(Inf)operator(.)ident(NumValues)operator(,) string<delimiter(')content(value)delimiter(')>operator(,) string<delimiter(')content(values)delimiter(')>operator(,) string<delimiter(')content(no)delimiter(')>operator(\);) + + reserved(if) ident(ShowRealPathMI)operator(.)ident(Checked) reserved(then) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(1)operator(].)ident(Text) operator(:=) ident(StrOfRegPath)operator(()ident(CurKey)operator(()ident(uhShortcuts)operator(\)\)) + reserved(else) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(1)operator(].)ident(Text) operator(:=) ident(StrOfRegPath)operator(()ident(CurKey)operator(()ident(uhNonSystemShortcuts)operator(\)\);) + + reserved(if) reserved(not) ident(PathE)operator(.)ident(Focused) reserved(then) + ident(PathE)operator(.)ident(Text) operator(:=) ident(StrOfRegPath)operator(()ident(CurKey)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ShowRealPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowRealPathMI)operator(.)ident(Checked) operator(:=) reserved(not) ident(ShowRealPathMI)operator(.)ident(Checked)operator(;) + ident(StatusBarUpdate)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PathEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(var) + ident(Pos)operator(:) ident(Integer)operator(;) + ident(s)operator(:) reserved(string)operator(;) +reserved(begin) + ident(DoAutoComplete) operator(:=) reserved(not) operator(()ident(Key) reserved(in) operator([)ident(VK_DELETE)operator(,) ident(VK_BACK)operator(,) ident(VK_ESCAPE)operator(]\);) + + reserved(case) ident(Key) reserved(of) + ident(VK_BACK)operator(:) + reserved(begin) + ident(s) operator(:=) ident(PathE)operator(.)ident(Text)operator(;) + ident(Pos) operator(:=) ident(PathE)operator(.)ident(SelStart)operator(;) + + reserved(if) ident(ssCtrl) reserved(in) ident(Shift) reserved(then) + reserved(repeat) + ident(Dec)operator(()ident(Pos)operator(\);) + reserved(until) operator(()ident(Pos) operator(<) integer(1)operator(\)) reserved(or) operator(()ident(s)operator([)ident(Pos)operator(]) operator(=) char<delimiter(')content(\\)delimiter(')>operator(\)) + reserved(else) reserved(if) ident(PathE)operator(.)ident(SelLength) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(PathE)operator(.)ident(Text) operator(:=) ident(Copy)operator(()ident(s)operator(,) integer(1)operator(,) ident(Pos)operator(\);) + ident(PathE)operator(.)ident(SelStart) operator(:=) ident(Length)operator(()ident(s)operator(\);) + ident(Key) operator(:=) integer(0)operator(;) + ident(UserGotoKey)operator(;) + reserved(end)operator(;) + + ident(VK_ESCAPE)operator(:) + reserved(with) ident(PathE) reserved(do) reserved(begin) + reserved(if) ident(SelLength) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + ident(Text) operator(:=) ident(StrOfRegPath)operator(()ident(CurKey)operator(\);) + ident(SelStart) operator(:=) ident(Length)operator(()ident(Text)operator(\);) + reserved(end)operator(;) + + ident(VK_RETURN)operator(:) reserved(begin) + reserved(if) ident(CurKey)operator(.)ident(ValueSet) reserved(then) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Self)operator(\);) + ident(Key) operator(:=) integer(0)operator(;) + reserved(end)operator(;) + + ident(VK_RIGHT)operator(:) reserved(begin) + reserved(if) reserved(not) operator(()ident(ssCtrl) reserved(in) ident(Shift)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Key) operator(:=) integer(0)operator(;) + + ident(s) operator(:=) ident(PathE)operator(.)ident(Text)operator(;) + ident(Pos) operator(:=) ident(PathE)operator(.)ident(SelStart) operator(+) integer(1)operator(;) + reserved(repeat) + ident(Inc)operator(()ident(Pos)operator(\);) + reserved(until) operator(()ident(Pos) operator(>) ident(Length)operator(()ident(s)operator(\)\)) reserved(or) operator(()ident(s)operator([)ident(Pos)operator(]) operator(=) char<delimiter(')content(\\)delimiter(')>operator(\);) + + ident(PathE)operator(.)ident(SelStart) operator(:=) ident(Pos) operator(-) integer(1)operator(;) + reserved(end)operator(;) + + ident(VK_LEFT)operator(:) reserved(begin) + reserved(if) reserved(not) operator(()ident(ssCtrl) reserved(in) ident(Shift)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(PathE) reserved(do) reserved(begin) + ident(Key) operator(:=) integer(0)operator(;) + + ident(s) operator(:=) ident(Text)operator(;) + ident(Pos) operator(:=) ident(SelStart)operator(;) + reserved(repeat) + ident(Dec)operator(()ident(Pos)operator(\);) + reserved(until) operator(()ident(Pos) operator(<) integer(1)operator(\)) reserved(or) operator(()ident(s)operator([)ident(Pos)operator(]) operator(=) char<delimiter(')content(\\)delimiter(')>operator(\);) + + reserved(if) ident(Pos) operator(<) integer(1) reserved(then) + ident(Pos) operator(:=) integer(1)operator(;) + + ident(SelStart) operator(:=) ident(Pos) operator(-) integer(1)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(UserGotoKey)operator(;) +reserved(begin) + ident(GotoKey)operator(()ident(PathE)operator(.)ident(Text)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PathEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Prefix)operator(,) ident(Suffix)operator(,) ident(Key)operator(,) ident(Path)operator(,) ident(Root)operator(:) reserved(string)operator(;) + ident(i)operator(,) ident(p)operator(,) ident(Len)operator(:) ident(Integer)operator(;) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(CompleteKind)operator(:) operator(()ident(ckRoots)operator(,) ident(ckKeys)operator(,) ident(ckValues)operator(\);) + + reserved(procedure) ident(GetRootNames)operator(()ident(Strings)operator(:) ident(TStrings)operator(\);) + reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(begin) + ident(SL)operator(.)ident(Clear)operator(;) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(GetFirstNode)operator(;) + reserved(while) ident(Assigned)operator(()ident(Node)operator(\)) reserved(do) reserved(begin) + ident(SL)operator(.)ident(Add)operator(()ident(Node)operator(.)ident(Text)operator(\);) + ident(Node) operator(:=) ident(Node)operator(.)ident(GetNextSibling)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) ident(DoAutoComplete) reserved(then) + ident(Exit)operator(;) + + ident(Key) operator(:=) ident(PathE)operator(.)ident(Text)operator(;) + ident(Root) operator(:=) ident(TraceKey)operator(()ident(ExRegRoot)operator(()ident(Key)operator(\)\);) + + reserved(if) reserved(not) ident(CharIn)operator(()ident(Key)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\)) reserved(then) + ident(CompleteKind) operator(:=) ident(ckRoots) + reserved(else) reserved(if) ident(ExRegValueSet)operator(()ident(Key)operator(\)) reserved(then) + ident(CompleteKind) operator(:=) ident(ckValues) + reserved(else) + ident(CompleteKind) operator(:=) ident(ckKeys)operator(;) + + reserved(case) ident(CompleteKind) reserved(of) + ident(ckRoots)operator(:) reserved(begin) + ident(Prefix) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(Suffix) operator(:=) ident(Key)operator(;) + reserved(end)operator(;) + + ident(ckKeys)operator(:) reserved(begin) + ident(Path) operator(:=) ident(ExRegFullKey)operator(()ident(Key)operator(\);) + ident(Prefix) operator(:=) ident(UntilLastChar)operator(()ident(Path)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\);) + ident(Suffix) operator(:=) ident(FromLastChar)operator(()ident(Path)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\);) + reserved(end)operator(;) + + ident(ckValues)operator(:) reserved(begin) + ident(p) operator(:=) ident(Pos)operator(()string<delimiter(')content(\\\\)delimiter(')>operator(,) ident(Key)operator(\);) + ident(Prefix) operator(:=) ident(Copy)operator(()ident(Key)operator(,) integer(1)operator(,) ident(p) operator(-) integer(1)operator(\);) + ident(Suffix) operator(:=) ident(Copy)operator(()ident(Key)operator(,) ident(p) operator(+) integer(2)operator(,) ident(Length)operator(()ident(Key)operator(\)) operator(-) ident(p) operator(-) integer(1)operator(\);) + reserved(end)operator(;) + + reserved(else) + reserved(end)operator(;) + + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + + reserved(if) ident(CompleteKind) reserved(in) operator([)ident(ckKeys)operator(,) ident(ckValues)operator(]) reserved(then) + reserved(with) ident(MainReg) reserved(do) reserved(begin) + ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Root)operator(\)\);) + ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Root)operator(\)\);) + ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Prefix)operator(\)\);) + + reserved(if) ident(CompleteKind) operator(=) ident(ckValues) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(HasValues) reserved(then) + ident(Exit)operator(;) + ident(GetValueNames)operator(()ident(SL)operator(\);) + reserved(end) reserved(else) reserved(if) ident(CompleteKind) operator(=) ident(ckKeys) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(HasSubKeys) reserved(then) + ident(Exit)operator(;) + ident(GetKeyNames)operator(()ident(SL)operator(\);) + reserved(end)operator(;) + + ident(CloseKey)operator(;) + reserved(end) + reserved(else) reserved(begin) + ident(GetRootNames)operator(()ident(SL)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Suffix) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + reserved(if) operator(()ident(SL)operator(.)ident(Count) operator(>) integer(0)operator(\)) reserved(and) reserved(not) ident(StrIn)operator(()ident(SL)operator(,) string<delimiter(')delimiter(')>operator(\)) reserved(then) + ident(Suffix) operator(:=) ident(SL)operator([)integer(0)operator(];) + reserved(end) reserved(else) reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(TextAtBegin)operator(()ident(SL)operator([)ident(i)operator(],) ident(Suffix)operator(\)) reserved(then) reserved(begin) + ident(Suffix) operator(:=) ident(SL)operator([)ident(i)operator(];) + ident(Break)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + ident(Len) operator(:=) ident(Length)operator(()ident(PathE)operator(.)ident(Text)operator(\);) + + reserved(if) ident(CompleteKind) operator(=) ident(ckValues) reserved(then) + ident(Prefix) operator(:=) ident(Prefix) operator(+) string<delimiter(')content(\\\\)delimiter(')> + reserved(else) reserved(if) ident(CompleteKind) operator(=) ident(ckKeys) reserved(then) + ident(Prefix) operator(:=) ident(Prefix) operator(+) char<delimiter(')content(\\)delimiter(')>operator(;) + + reserved(with) ident(PathE) reserved(do) reserved(begin) + ident(DoAutoComplete) operator(:=) ident(False)operator(;) comment(//Avoid Recursion) + ident(Text) operator(:=) ident(Prefix) operator(+) ident(Suffix)operator(;) + ident(DoAutoComplete) operator(:=) ident(True)operator(;) + + ident(SelStart) operator(:=) ident(Len)operator(;) + ident(SelLength) operator(:=) ident(Length)operator(()ident(Text)operator(\)) operator(-) ident(Len)operator(;) + reserved(end)operator(;) + + ident(SL)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PathEExit)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeActivateThis)operator(()ident(PathE)operator(\);) + ident(DoAutoComplete) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(ArrangePlutoStyle)operator(;) +reserved(begin) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(MainWin)operator(.)ident(ClientHeight) reserved(div) integer(3)operator(;) + ident(Top) operator(:=) ident(MainWin)operator(.)ident(ClientHeight) operator(-) ident(Height) operator(-) integer(43)operator(;) + ident(Left) operator(:=) integer(0)operator(;) + ident(Width) operator(:=) ident(MainWin)operator(.)ident(ClientWidth) operator(-) integer(4)operator(;) + comment(//Align := alBottom;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) reserved(begin) + ident(Top) operator(:=) integer(0)operator(;) + ident(Width) operator(:=) ident(Max)operator(()ident(MainWin)operator(.)ident(ClientWidth) reserved(div) integer(3)operator(,) ident(WorkWin)operator(.)ident(Constraints)operator(.)ident(MinWidth)operator(\);) + ident(Left) operator(:=) ident(ValuesWin)operator(.)ident(Width) operator(-) ident(Width)operator(;) + ident(Height) operator(:=) ident(MainWin)operator(.)ident(ClientHeight) operator(-) integer(43) operator(-) ident(ValuesWin)operator(.)ident(Height)operator(;) + comment(//Align := alRight;) + reserved(end)operator(;) + + reserved(with) ident(TreeWin) reserved(do) reserved(begin) + ident(Top) operator(:=) integer(0)operator(;) + ident(Height) operator(:=) ident(WorkWin)operator(.)ident(Height)operator(;) + ident(Left) operator(:=) integer(0)operator(;) + ident(Width) operator(:=) ident(ValuesWin)operator(.)ident(Width) operator(-) ident(WorkWin)operator(.)ident(Width)operator(;) + reserved(end)operator(;) + + comment({TreeWin.Align := alNone; + WorkWin.Align := alNone; + ValuesWin.Align := alNone;}) +reserved(end)operator(;) + +reserved(procedure) ident(ArrangeFreeStyle)operator(;) +reserved(const) + ident(Space) operator(=) integer(10)operator(;) +reserved(begin) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(Screen)operator(.)ident(Height) reserved(div) integer(3)operator(;) + ident(Align) operator(:=) ident(alBottom)operator(;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) reserved(begin) + ident(Width) operator(:=) ident(Max)operator(()ident(Screen)operator(.)ident(WorkAreaWidth) reserved(div) integer(3)operator(,) ident(Constraints)operator(.)ident(MinWidth) operator(+) integer(2) operator(*) ident(Space)operator(\);) + ident(Align) operator(:=) ident(alRight)operator(;) + reserved(end)operator(;) + + reserved(with) ident(TreeWin) reserved(do) reserved(begin) + ident(Align) operator(:=) ident(alClient)operator(;) + reserved(end)operator(;) + + ident(TreeWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) + ident(WorkWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) + ident(ValuesWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) + + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(Height) operator(-) integer(2) operator(*) ident(Space)operator(;) + ident(Width) operator(:=) ident(Width) operator(-) integer(2) operator(*) ident(Space)operator(;) + ident(Top) operator(:=) ident(Top) operator(+) ident(Space)operator(;) + ident(Left) operator(:=) ident(Left) operator(+) ident(Space)operator(;) + reserved(end)operator(;) + + reserved(with) ident(TreeWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(Height) operator(-) integer(1) operator(*) ident(Space)operator(;) + ident(Width) operator(:=) ident(Width) operator(-) integer(1) operator(*) ident(Space)operator(;) + ident(Top) operator(:=) ident(Top) operator(+) ident(Space)operator(;) + ident(Left) operator(:=) ident(Left) operator(+) ident(Space)operator(;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(Height) operator(-) integer(1) operator(*) ident(Space)operator(;) + ident(Width) operator(:=) ident(Width) operator(-) integer(2) operator(*) ident(Space)operator(;) + ident(Top) operator(:=) ident(Top) operator(+) ident(Space)operator(;) + ident(Left) operator(:=) ident(Left) operator(+) ident(Space)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(ArrangeBigValStyle)operator(;) +reserved(var) + ident(MinHeight)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(MinHeight) operator(:=) ident(WorkWin)operator(.)ident(Constraints)operator(.)ident(MinHeight) operator(+) + ident(MainWin)operator(.)ident(Constraints)operator(.)ident(MinHeight)operator(;) + + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Height) operator(:=) ident(Screen)operator(.)ident(WorkAreaHeight) operator(-) ident(Max)operator(()ident(Screen)operator(.)ident(Height) reserved(div) integer(3)operator(,) ident(MinHeight)operator(\);) + ident(Align) operator(:=) ident(alBottom)operator(;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) reserved(begin) + ident(Width) operator(:=) ident(Screen)operator(.)ident(WorkAreaWidth) reserved(div) integer(3)operator(;) + ident(Align) operator(:=) ident(alRight)operator(;) + reserved(end)operator(;) + + reserved(with) ident(TreeWin) reserved(do) reserved(begin) + ident(Align) operator(:=) ident(alClient)operator(;) + reserved(end)operator(;) + + ident(TreeWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) + ident(WorkWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) + ident(ValuesWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(ArrangeRegEdStyle)operator(;) +reserved(begin) + reserved(with) ident(TreeWin) reserved(do) reserved(begin) + ident(Width) operator(:=) ident(Screen)operator(.)ident(WorkAreaWidth) reserved(div) integer(4)operator(;) + ident(Align) operator(:=) ident(alLeft)operator(;) + reserved(end)operator(;) + + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Align) operator(:=) ident(alClient)operator(;) + ident(Align) operator(:=) ident(alNone)operator(;) + ident(Height) operator(:=) ident(Height) operator(-) ident(WorkWin)operator(.)ident(Constraints)operator(.)ident(MinHeight)operator(;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) reserved(begin) + ident(Top) operator(:=) ident(ValuesWin)operator(.)ident(Top) operator(+) ident(ValuesWin)operator(.)ident(Height)operator(;) + ident(Left) operator(:=) ident(ValuesWin)operator(.)ident(Left)operator(;) + ident(Height) operator(:=) ident(Constraints)operator(.)ident(MinHeight)operator(;) + ident(Width) operator(:=) ident(ValuesWin)operator(.)ident(Width)operator(;) + reserved(end)operator(;) + + ident(TreeWin)operator(.)ident(Align) operator(:=) ident(alNone)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PathEKeyUp)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) reserved(not) operator(()ident(Key) reserved(in) operator([)ident(VK_DELETE)operator(,) ident(VK_BACK)operator(,) ident(VK_ESCAPE)operator(]\)) reserved(then) + ident(UserGotoKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(ActivateThis)operator(()ident(ActiveControl)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(DeActivateThis)operator(()ident(ActiveControl)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Pluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangePlutoStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(RegEdit1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeRegEdStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Free1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeFreeStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(BigVal1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeBigValStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SplashScreen1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SplashWin)operator(.)ident(Show)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(HistoryClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(version.txt)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(WebLinkMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Browse)operator(()string<delimiter(')content(http://)delimiter(')> operator(+) ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(Caption)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SupportMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Browse)operator(()string<delimiter(')content(http://cYcnus.de/php/phpbb/viewforum.php?f=1)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Credits1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(FileName)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(credits deluxe.htm)delimiter(')>operator(;) + reserved(if) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(then) + ident(ExecFile)operator(()ident(FileName)operator(\)) + reserved(else) reserved(begin) + ident(FileName) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(credits.htm)delimiter(')>operator(;) + reserved(if) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(then) + ident(ExecFile)operator(()ident(FileName)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(GetCLSIDFromClipboard)operator(:) reserved(string)operator(;) +reserved(var) + ident(CLSID)operator(:) reserved(string)operator(;) +reserved(begin) + ident(CLSID) operator(:=) ident(BetweenChars)operator(()ident(Clipboard)operator(.)ident(AsText)operator(,) char<delimiter(')content({)delimiter(')>operator(,) char<delimiter(')content(})delimiter(')>operator(,) ident(True)operator(\);) + reserved(if) ident(CLSID) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Clipboard)operator(.)ident(AsText)operator(;) + ident(InputQuery)operator(()string<delimiter(')content(No CLSID in Clipboard.)delimiter(')>operator(,) + string<delimiter(')content(Use following format:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content({00000000-0000-0000-0000-000000000000})delimiter(')>operator(,) ident(Result)operator(\);) + ident(Exit)operator(;) reserved(end) reserved(else) + ident(Result) operator(:=) ident(CLSID)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FindCLSID)operator(;) +reserved(var) + ident(CLSID)operator(,) ident(Desc)operator(:) reserved(string)operator(;) +reserved(begin) + ident(CLSID) operator(:=) ident(GetCLSIDFromClipboard)operator(;) + ident(Desc) operator(:=) ident(RegNameOfCLSID)operator(()ident(CLSID)operator(\);) + reserved(if) ident(Desc) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(InputQuery)operator(()string<delimiter(')content(Your CLSID is...)delimiter(')>operator(,) ident(CLSID)operator(,) ident(Desc)operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(CLSID not found: )delimiter(')> operator(+) ident(CLSID) operator(+) char<delimiter(')content(.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(GotoCLSID)operator(;) +reserved(var) + ident(CLSID)operator(,) ident(Desc)operator(:) reserved(string)operator(;) +reserved(begin) + ident(CLSID) operator(:=) ident(GetCLSIDFromClipboard)operator(;) + ident(Desc) operator(:=) ident(RegNameOfCLSID)operator(()ident(CLSID)operator(\);) + reserved(if) ident(Desc) operator(<>) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(GotoKey)operator(()string<delimiter(')content(HKCR\\CLSID\\)delimiter(')> operator(+) ident(CLSID)operator(\);) + ident(TreeWin)operator(.)ident(FocusControl)operator(()ident(RegTV)operator(\);) + reserved(end) reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(CLSID not found: )delimiter(')> operator(+) ident(CLSID) operator(+) char<delimiter(')content(.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TMainWin)operator(.)ident(Greeting)operator(()ident(Name)operator(:) reserved(string) operator(=) ident(NoPreBlinkHint)operator(\):) reserved(string)operator(;) +reserved(const) + ident(Alias)operator(:) reserved(array)operator([)integer(0)operator(..)integer(4)operator(]) reserved(of) reserved(string) operator(=) + operator(()string<delimiter(')content(Licenser)delimiter(')>operator(,) string<delimiter(')content(Murphy)delimiter(')>operator(,) string<delimiter(')content(Sleeper)delimiter(')>operator(,) string<delimiter(')content(Leon)delimiter(')>operator(,) string<delimiter(')content(Great Admin)delimiter(')>operator(\);) + ident(RealNames)operator(:) reserved(array)operator([)integer(0)operator(..)integer(4)operator(]) reserved(of) reserved(string) operator(=) + operator(()string<delimiter(')content(Heinz)delimiter(')>operator(,) string<delimiter(')content(Korny)delimiter(')>operator(,) string<delimiter(')content(Sven)delimiter(')>operator(,) string<delimiter(')content(Simon)delimiter(')>operator(,) string<delimiter(')content(Korny ;-\))delimiter(')>operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(s)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(Name) operator(=) ident(NoPreBlinkHint) reserved(then) + ident(Name) operator(:=) ident(PrefWin)operator(.)ident(UserNameE)operator(.)ident(Text)operator(;) + + reserved(if) ident(Trim)operator(()ident(Name)operator(\)) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(s) operator(:=) string<delimiter(')content(No name?)delimiter(')> + reserved(else) reserved(if) ident(SameText)operator(()ident(Trim)operator(()ident(Name)operator(\),) string<delimiter(')content(Pluto-User)delimiter(')>operator(\)) reserved(then) + ident(s) operator(:=) string<delimiter(')content(Hi!)delimiter(')> + reserved(else) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) integer(4) reserved(do) + reserved(if) ident(SameText)operator(()ident(Name)operator(,) ident(Alias)operator([)ident(i)operator(]\)) reserved(then) reserved(begin) + ident(s) operator(:=) string<delimiter(')content(Hi )delimiter(')> operator(+) ident(RealNames)operator([)ident(i)operator(]) operator(+) string<delimiter(')content(! This is a cYcnus.EasterEgg)delimiter(')>operator(;) + ident(Break)operator(;) reserved(end) + reserved(else) reserved(if) ident(Length)operator(()ident(Name)operator(\)) operator(>) integer(20) reserved(then) + ident(s) operator(:=) string<delimiter(')content(Hi )delimiter(')> operator(+) ident(Name) operator(+) + string<delimiter(')content(. What a name.)delimiter(')> + reserved(else) + ident(s) operator(:=) string<delimiter(')content(Hi )delimiter(')> operator(+) ident(Name) operator(+) char<delimiter(')content(!)delimiter(')>operator(;) + + ident(Result) operator(:=) ident(s)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PrefMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PrefWin)operator(.)ident(Show)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TempDir)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(temp\\)delimiter(')>operator(;) + reserved(if) reserved(not) operator(()ident(DirectoryExists)operator(()ident(Result)operator(\)) reserved(or) ident(CreateDir)operator(()ident(Result)operator(\)\)) reserved(then) + ident(Result) operator(:=) ident(PlutoDir)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PlutoIniFileName)operator(:) reserved(string)operator(;) + + reserved(function) ident(Default)operator(:) reserved(string)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(MyDir) operator(+) string<delimiter(')content(pluto.ini)delimiter(')>operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) ident(SavedPlutoIniFileName)operator(;) + reserved(if) ident(Result) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(Exit)operator(;) + +comment(// Result := Params.ReadString('ini', ''\);) + + reserved(if) ident(IsValidFileName)operator(()ident(Result)operator(\)) reserved(then) + ident(Result) operator(:=) ident(PlutoDir) operator(+) ident(Result) + reserved(else) + ident(Result) operator(:=) ident(Default)operator(;) + + ident(SavedPlutoIniFileName) operator(:=) ident(Result)operator(;) comment(//Faster in future calls) +reserved(end)operator(;) + +reserved(function) ident(PlutoUniPath)operator(:) reserved(string)operator(;) +reserved(begin) + comment(//Result := 'Reg: HKCU\\Software\\Pluto\\';) + ident(Result) operator(:=) string<delimiter(')content(Ini <)delimiter(')> operator(+) ident(PlutoIniFileName) operator(+) string<delimiter(')content(>:)delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(EditBoolStrMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoDir) operator(+) ident(BoolStrFileName)operator(\);) + ident(ShowMessage)operator(()string<delimiter(')content(Click OK when you finished editing.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content((Pluto will reload the Boolean Strings.\))delimiter(')>operator(\);) + ident(WorkWin)operator(.)ident(LoadBoolStr)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SisyStarted)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +comment({var + NextSisyIndex: Integer; + NextSisy: TSisyThread; }) +reserved(begin) + comment({NextSisy := nil; + + with TSisyThread(Sender\) do begin + //AddHint(Format('%s started after %0.1f seconds', [Name, SecsPerRound]\), True\); + + with Sisys do begin + NextSisyIndex := IndexOf(Sender\) + 1; + if NextSisyIndex < Count then + NextSisy := Items[NextSisyIndex]; + end; + + if Assigned(NextSisy\) then + with NextSisy do + if not Started and Suspended then + Resume; + end; }) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SisyTerminate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Sisys)operator(\)) reserved(then) + ident(Sisys)operator(.)ident(Delete)operator(()ident(Sisys)operator(.)ident(IndexOf)operator(()ident(Sender)operator(\)\);) + ident(AddHint)operator(()string<delimiter(')content(Sisyphus )delimiter(')> operator(+) ident(Quote)operator(()ident(TSisyThread)operator(()ident(Sender)operator(\).)ident(Name)operator(\)) operator(+) string<delimiter(')content( destroyed.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormCloseQuery)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(CanClose)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(TerminateThread)operator(()ident(Thread)operator(:) ident(TThread)operator(;) ident(Name)operator(:) reserved(string)operator(\);) + reserved(const) + ident(ThreadTimeOut) operator(=) integer(3000)operator(;) + reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Thread)operator(\)) reserved(then) + reserved(with) ident(Thread) reserved(do) reserved(begin) + ident(Priority) operator(:=) ident(tpNormal)operator(;) + ident(Terminate)operator(;) + reserved(while) ident(Suspended) reserved(do) ident(Resume)operator(;) comment(// ensure running) + reserved(if) integer(0) operator(<>) ident(WaitForSingleObject)operator(()ident(Handle)operator(,) ident(ThreadTimeOut)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Timeout: Killing Thread: )delimiter(')> operator(+) ident(Name) operator(+) ident(EOL) operator(+) + string<delimiter(')content(This is a critical error and may cause memory leaks and crashes.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(We recommend to reboot your system before you continue.)delimiter(')>operator(\);) + ident(Windows)operator(.)ident(TerminateThread)operator(()ident(Handle)operator(,) integer(0)operator(\);) + reserved(end) reserved(else) + ident(Thread)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(CanClose) operator(:=) ident(False)operator(;) + + reserved(try) + ident(AddHint)operator(()string<delimiter(')content(Stopping SisyphusThreads...)delimiter(')>operator(\);) + reserved(if) ident(Assigned)operator(()ident(Sisys)operator(\)) reserved(then) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Sisys)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(TSisyThread)operator(()ident(Sisys)operator([)ident(i)operator(]\).)ident(Suspend)operator(;) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + + ident(AddHint)operator(()string<delimiter(')content(Wait for SpyThread...)delimiter(')>operator(\);) + ident(TerminateThread)operator(()ident(SpyThread)operator(,) string<delimiter(')content(SpyThread)delimiter(')>operator(\);) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + + ident(AddHint)operator(()string<delimiter(')content(Wait for SisyphusThreads...)delimiter(')>operator(\);) + reserved(if) ident(Assigned)operator(()ident(Sisys)operator(\)) reserved(then) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Sisys)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(ChangeLastHint)operator(()string<delimiter(')content(Wait for SisyphusThreads...)delimiter(')> operator(+) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(i)operator(]\).)ident(Name)operator(\);) + ident(TerminateThread)operator(()ident(TSisyThread)operator(()ident(Sisys)operator([)ident(i)operator(]\),) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(i)operator(]\).)ident(Name)operator(\);) + reserved(end)operator(;) + ident(ChangeLastHint)operator(()string<delimiter(')content(Wait for SisyphusThreads...OK)delimiter(')>operator(\);) + reserved(except) + reserved(with) ident(WorkWin)operator(.)ident(HintLB)operator(.)ident(Items) reserved(do) + ident(ShowMessage)operator(()string<delimiter(')content(Error while trying to terminate threads.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Last Message:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(Strings)operator([)ident(Count) operator(-) integer(1)operator(]\);) + ident(CanClose) operator(:=) ident(True)operator(;) + reserved(end)operator(;) + + ident(AddHint)operator(()string<delimiter(')content(Terminating successfull.)delimiter(')>operator(\);) + ident(CanClose) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) + + reserved(procedure) ident(TryClose)operator(()ident(Win)operator(:) ident(TCustomForm)operator(\);) + reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Win)operator(\)) reserved(and) ident(Win)operator(.)ident(Visible) reserved(then) + ident(Win)operator(.)ident(Close)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(MainReg)operator(.)ident(Free)operator(;) + + ident(Action) operator(:=) ident(caFree)operator(;) + + reserved(if) ident(DontSavePrefs) reserved(then) + ident(Exit)operator(;) + + ident(AddHint)operator(()string<delimiter(')content(Saving settings...)delimiter(')>operator(\);) + + reserved(try) + ident(TryClose)operator(()ident(WorkWin)operator(\);) + ident(TryClose)operator(()ident(ValuesWin)operator(\);) + ident(TryClose)operator(()ident(TreeWin)operator(\);) + ident(TryClose)operator(()ident(FindWin)operator(\);) + ident(TryClose)operator(()ident(SplashWin)operator(\);) + ident(TryClose)operator(()ident(PrefWin)operator(\);) + reserved(except) + ident(DontSavePrefs) operator(:=) ident(True)operator(;) comment(//try again without pref saving) + reserved(end)operator(;) + + reserved(with) ident(PlutoKey)operator(.)ident(GetKey)operator(()string<delimiter(')content(Window)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(WriteBool)operator(()string<delimiter(')content(Maximized)delimiter(')>operator(,) ident(WindowState) operator(=) ident(wsMaximized)operator(\);) + reserved(if) ident(WindowState) operator(=) ident(wsNormal) reserved(then) reserved(begin) + ident(WriteInteger)operator(()string<delimiter(')content(Left)delimiter(')>operator(,) ident(Left)operator(\);) + ident(WriteInteger)operator(()string<delimiter(')content(Top)delimiter(')>operator(,) ident(Top)operator(\);) + ident(WriteInteger)operator(()string<delimiter(')content(Width)delimiter(')>operator(,) ident(Width)operator(\);) + ident(WriteInteger)operator(()string<delimiter(')content(Height)delimiter(')>operator(,) ident(Height)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Plutoini1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoIniFileName)operator(\);) + ident(ShowMessage)operator(()string<delimiter(')content(Click OK when you finished editing.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content((Pluto will reload )delimiter(')> operator(+) ident(PlutoIniFileName) operator(+) char<delimiter(')content(\))delimiter(')>operator(\);) + ident(PrefWin)operator(.)ident(PrefHost)operator(.)ident(Load)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(RegEdit2Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(RegEdit)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SysEdit1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SysEdit)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(NotePad1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(WordPad1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(WordPad)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OpenWinDir1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExploreFolder)operator(()ident(WinDir)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OpenProgramFolder1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExploreFolder)operator(()ident(MyDir)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ExitPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Close)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Find1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FindWin)operator(.)ident(SfRootKeyRB)operator(.)ident(Checked) operator(:=) ident(True)operator(;) + ident(FindWin)operator(.)ident(Show)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormPaint)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Started) reserved(and) reserved(not) ident(MainWinLoaded) reserved(then) reserved(begin) + ident(MainWinLoaded) operator(:=) ident(True)operator(;) + ident(Load)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(StatusBarDrawPanel)operator(()ident(StatusBar)operator(:) ident(TStatusBar)operator(;) + ident(Panel)operator(:) ident(TStatusPanel)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(\);) +reserved(begin) + reserved(with) ident(StatusBar)operator(.)ident(Canvas) reserved(do) reserved(begin) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clBlack)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + reserved(with) ident(Font) reserved(do) reserved(begin) + ident(Name) operator(:=) string<delimiter(')content(MS Sans Serif)delimiter(')>operator(;) + ident(Style) operator(:=) operator([];) + reserved(case) ident(Panel)operator(.)ident(Index) reserved(of) + integer(0)operator(:) reserved(if) ident(HintBlinkT)operator(.)ident(Enabled) reserved(then) + ident(Color) operator(:=) ident(clBrightRed) + reserved(else) + ident(Color) operator(:=) ident(clBrightSilver)operator(;) + integer(1)operator(:) ident(Color) operator(:=) ident(clWhite)operator(;) + integer(2)operator(:) ident(Color) operator(:=) ident(clCyan)operator(;) + integer(3)operator(:) ident(Color) operator(:=) ident(clBrightPurple)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Panel)operator(.)ident(Alignment) operator(=) ident(taRightJustify) reserved(then) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Right) operator(-) ident(TextWidth)operator(()ident(Panel)operator(.)ident(Text)operator(\),) ident(Rect)operator(.)ident(Top)operator(,) ident(Panel)operator(.)ident(Text)operator(\)) + reserved(else) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left)operator(,) ident(Rect)operator(.)ident(Top)operator(,) ident(Panel)operator(.)ident(Text)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(PathEKeyPress)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Char)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) char(#127) reserved(then) comment(//Silly key management) + ident(Key) operator(:=) char(#0)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(HintBlinkTTimer)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text) operator(:=) string<delimiter(')content(Ready)delimiter(')>operator(;) + ident(StopHintBlinking)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(StopHintBlinking)operator(;) +reserved(begin) + ident(HintBlinkT)operator(.)ident(Enabled) operator(:=) ident(False)operator(;) + ident(PreBlinkHint) operator(:=) ident(NoPreBlinkHint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FindCLSID1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FindCLSID)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(GotoCLSID1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(GotoCLSID)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(CommandLineParameters1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Params.txt)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(DeleteTempFolder1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(mrYes) operator(=) ident(MessageDlg)operator(()string<delimiter(')content(Deleting )delimiter(')> operator(+) ident(Quote)operator(()ident(TempDir) operator(+) string<delimiter(')content(*.*)delimiter(')> operator(+) ident(EOL)operator(,) char<delimiter(')content(")delimiter(')>operator(\)) operator(+) + string<delimiter(')content(Are you sure?)delimiter(')>operator(,) ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) + ident(DeleteFiles)operator(()ident(TempDir) operator(+) string<delimiter(')content(*.*)delimiter(')>operator(,) ident(False)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(CurrentDir1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(MyDir: )delimiter(')> operator(+) ident(MyDir) operator(+) ident(EOL) operator(+) + string<delimiter(')content(PlutoDir: )delimiter(')> operator(+) ident(PlutoDir) operator(+) ident(EOL) operator(+) + string<delimiter(')content(CurrentDir: )delimiter(')> operator(+) ident(GetCurrentDir) operator(+) ident(EOL) operator(+) + string<delimiter(')content(Params: )delimiter(')> operator(+) ident(EOL) operator(+) + ident(GetParams)operator(()ident(EOL)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(RepairPluto155bBug1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Msg)operator(:) reserved(string)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) +reserved(begin) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + + reserved(try) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKCU)operator(;) + ident(Reg)operator(.)ident(OpenKey)operator(()string<delimiter(')content(Software)delimiter(')>operator(\);) + ident(Msg) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Sisyphus)delimiter(')>operator(\)) reserved(then) + ident(Msg) operator(:=) ident(Msg) operator(+) string<delimiter(')content(HKCU\\Software\\Sisyphus)delimiter(')> operator(+) ident(EOL)operator(;) + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Main)delimiter(')>operator(\)) reserved(then) + ident(Msg) operator(:=) ident(Msg) operator(+) string<delimiter(')content(HKCU\\Software\\Main)delimiter(')> operator(+) ident(EOL)operator(;) + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Spy)delimiter(')>operator(\)) reserved(then) + ident(Msg) operator(:=) ident(Msg) operator(+) string<delimiter(')content(HKCU\\Software\\Spy)delimiter(')> operator(+) ident(EOL)operator(;) + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(View)delimiter(')>operator(\)) reserved(then) + ident(Msg) operator(:=) ident(Msg) operator(+) string<delimiter(')content(HKCU\\Software\\View)delimiter(')> operator(+) ident(EOL)operator(;) + reserved(if) ident(Msg) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(No bug detected :-\))delimiter(')>operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Msg) operator(:=) + string<delimiter(')content(Hi folks!)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(We are very sorry: A bug in Pluto made some components in the Edit)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(window save their values to the regsitry instead of the ini file.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(If you want to repair that, you have to delete the following keys:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + ident(Msg) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(This is not dangerous at all, but if you are interested in having)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(a clean registry, you should delete this useless keys.)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(You surely noticed that this key names are rubish because they are)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(in the level that is normally used by programs.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(If you have programs installed that use this keys for their)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(preferences, you may get problems when deleting the keys!)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(So, now you have to decide what to do:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(Yes: Delete the keys. You have to confirm the deleting of each key.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(No: Jump to the Software key and delete manually.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Cancel: Do nothing.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Yes to All: Delete all keys.)delimiter(')>operator(;) + + reserved(case) ident(MessageDlg)operator(()ident(Msg)operator(,) ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(,) ident(mbYesToAll)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(of) + ident(mrYes)operator(:) reserved(begin) + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Main)delimiter(')>operator(\)) + reserved(and) operator(()ident(mrYes)operator(=)ident(MessageDlg)operator(()string<delimiter(')content(Delete HKU\\Software\\Main ?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)\)) reserved(then) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Main)delimiter(')>operator(\);) + + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Sisyphus)delimiter(')>operator(\)) + reserved(and) operator(()ident(mrYes)operator(=)ident(MessageDlg)operator(()string<delimiter(')content(Delete HKU\\Software\\Sisyphus ?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)\)) reserved(then) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Sisyphus)delimiter(')>operator(\);) + + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(Spy)delimiter(')>operator(\)) + reserved(and) operator(()ident(mrYes)operator(=)ident(MessageDlg)operator(()string<delimiter(')content(Delete HKU\\Software\\Spy ?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)\)) reserved(then) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Spy)delimiter(')>operator(\);) + + reserved(if) ident(Reg)operator(.)ident(KeyExists)operator(()string<delimiter(')content(View)delimiter(')>operator(\)) + reserved(and) operator(()ident(mrYes)operator(=)ident(MessageDlg)operator(()string<delimiter(')content(Delete HKU\\Software\\View ?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)\)) reserved(then) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(View)delimiter(')>operator(\);) + reserved(end)operator(;) + + ident(mrYesToAll)operator(:) reserved(begin) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Main)delimiter(')>operator(\);) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Sisyphus)delimiter(')>operator(\);) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(Spy)delimiter(')>operator(\);) + ident(Reg)operator(.)ident(DeleteKey)operator(()string<delimiter(')content(View)delimiter(')>operator(\);) + reserved(end)operator(;) + + ident(mrNo)operator(:) reserved(begin) + ident(TreeWin)operator(.)ident(SetFocus)operator(;) + ident(GotoKey)operator(()string<delimiter(')content(HKCU\\Software\\)delimiter(')>operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(BackupRegistryscanreg1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExecFile)operator(()string<delimiter(')content(scanreg)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Username1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowMessage)operator(()ident(UserName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ToDoMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(ToDo.txt)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(MailLinkMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MailTo)operator(()ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(Caption)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(IjustwantCONTACT1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MailTo)operator(()string<delimiter(')content(pluto@cYcnus.de)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ExternalHexEditMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExecFile)operator(()ident(PrefWin)operator(.)ident(ExternalHexEditE)operator(.)ident(Text)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(AnotherPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExecFile)operator(()ident(Application)operator(.)ident(ExeName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(Path1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) +preprocessor({$IFDEF UNIKEY}) + ident(UserUniPath) operator(:=) ident(InputBox)operator(()string<delimiter(')content(UniKey)delimiter(')>operator(,) string<delimiter(')content(Input an UniPath.)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(No idea? Try one of these: )delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(WinAmpVisColor <viscolor.txt>:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Params:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Reg: HKCU)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Ini <)delimiter(')> operator(+) ident(MyDir) operator(+) string<delimiter(')content(pluto.ini>:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Ini <)delimiter(')> operator(+) ident(MyDir) operator(+) string<delimiter(')content(pluto.ini>:[View])delimiter(')> operator(+) ident(EOL)operator(,) + ident(UserUniPath)operator(\);) +preprocessor({$ENDIF}) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(RegisterPlugIns1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) +preprocessor({$IFDEF UNIKEY}) + reserved(if) ident(UniPluginOD)operator(.)ident(Execute) reserved(then) + ident(RegisterUniClass)operator(()ident(UniPluginOD)operator(.)ident(FileName)operator(\);) +preprocessor({$ENDIF}) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(FormResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeIcons)operator(;) + ident(ArrangePlutoStyle)operator(;) + ident(WorkWin)operator(.)ident(WindowState) operator(:=) ident(wsNormal)operator(;) + ident(ValuesWin)operator(.)ident(WindowState) operator(:=) ident(wsNormal)operator(;) + ident(TreeWin)operator(.)ident(WindowState) operator(:=) ident(wsNormal)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(SwapLM_CUBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Path)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Path) operator(:=) ident(TraceKey)operator(()ident(PathE)operator(.)ident(Text)operator(,) ident(uhShortcuts)operator(\);) + reserved(if) ident(SwapHKU_HKLM)operator(()ident(Path)operator(\)) reserved(then) reserved(begin) + ident(PathE)operator(.)ident(Text) operator(:=) ident(Path)operator(;) + ident(UserGotoKey)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ShowLoadreport1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(MyDir) operator(+) string<delimiter(')content(loadreport.txt)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(KillPluto1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Application)operator(.)ident(Terminate)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(ShowPlatform1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowMessage)operator(()ident(Format)operator(()string<delimiter(')content(Platform: %s)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Versin: %d.%d Build %d)delimiter(')>operator(,) + operator([)ident(PlatformStrings)operator([)ident(Win32Platform)operator(],) + ident(Win32MajorVersion)operator(,) ident(Win32MinorVersion)operator(,) ident(Win32BuildNumber)operator(]\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(MSConfig1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ExecFile)operator(()string<delimiter(')content(msconfig)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(TimetoRelaxMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(RelaxFile)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(with) ident(PlutoKey)operator(.)ident(GetKey)operator(()string<delimiter(')content(Main)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(RelaxFile) operator(:=) ident(ReadString)operator(()string<delimiter(')content(Relax)delimiter(')>operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) + + reserved(if) ident(RelaxFile) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(ShowMessage)operator(()string<delimiter(')content(This menu item can be used for something that lets you relax,)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(for example Diablo2, you favorite song or the latest news about the)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(decreasing AOL member numbers.)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(Feel free to use everything you want.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Open the pluto.ini (CTRL+I\) and add a new value "Relax" in the "Main")delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(section.)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(And don)char('')content(t forget:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(R E L A X ! ! !)delimiter(')>operator(\)) + reserved(else) + ident(ExecFile)operator(()ident(RelaxFile)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OnSisyChange)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) + + reserved(procedure) ident(UpdateValue)operator(;) + reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Index)operator(:) ident(Integer)operator(;) + reserved(begin) + reserved(if) reserved(not) ident(SameRegPath)operator(()ident(ExRegFullKey)operator(()ident(Change)operator(.)ident(Path)operator(\),) ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Reg)operator(.)ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Change)operator(.)ident(Path)operator(\)\)) reserved(then) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Index) operator(:=) ident(FindItemByRealName)operator(()ident(ExRegValue)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Index) operator(>) operator(-)integer(1) reserved(then) reserved(begin) + reserved(if) ident(Change)operator(.)ident(Typ) operator(=) ident(cValueMinus) reserved(then) + ident(ValueList)operator(.)ident(Items)operator(.)ident(Delete)operator(()ident(Index)operator(\)) + reserved(else) reserved(if) ident(Change)operator(.)ident(Typ) operator(=) ident(cContextChange) reserved(then) + ident(UpdateValue)operator(()ident(Reg)operator(,) ident(ValueList)operator(.)ident(Items)operator([)ident(Index)operator(]\);) + reserved(end) reserved(else) reserved(if) ident(Change)operator(.)ident(Typ) operator(=) ident(cValuePlus) reserved(then) + ident(AddValue)operator(()ident(Reg)operator(,) ident(ExRegValue)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(AddHint)operator(()ident(Sender)operator(.)ident(Name) operator(+) string<delimiter(')content( notified )delimiter(')> operator(+) ident(Change)operator(.)ident(Path)operator(\);) + reserved(if) ident(Change)operator(.)ident(Typ) reserved(in) operator([)ident(cValueMinus)operator(,) ident(cValuePlus)operator(,) ident(cContextChange)operator(]) reserved(then) + ident(UpdateValue)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OnSisyValuePlus)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) +reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(SameRegPath)operator(()ident(ExRegFullKey)operator(()ident(Change)operator(.)ident(Path)operator(\),) ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Reg)operator(.)ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Change)operator(.)ident(Path)operator(\)\)) reserved(then) + ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(Reg)operator(,) ident(ExRegValue)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OnSisyValueMinus)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) +reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Index)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(SameRegPath)operator(()ident(ExRegFullKey)operator(()ident(Change)operator(.)ident(Path)operator(\),) ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Reg)operator(.)ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Change)operator(.)ident(Path)operator(\)\)) reserved(then) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Index) operator(:=) ident(FindItemByRealName)operator(()ident(ExRegValue)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Index) operator(>) operator(-)integer(1) reserved(then) + ident(ValueList)operator(.)ident(Items)operator(.)ident(Delete)operator(()ident(Index)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TMainWin)operator(.)ident(OnSisyContextChange)operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\);) +reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Index)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(SameRegPath)operator(()ident(ExRegFullKey)operator(()ident(Change)operator(.)ident(Path)operator(\),) ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Reg)operator(.)ident(OpenKey)operator(()ident(ExRegKey)operator(()ident(Change)operator(.)ident(Path)operator(\)\)) reserved(then) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(Index) operator(:=) ident(FindItemByRealName)operator(()ident(ExRegValue)operator(()ident(Change)operator(.)ident(Path)operator(\)\);) + reserved(if) ident(Index) operator(>) operator(-)integer(1) reserved(then) + ident(UpdateValue)operator(()ident(Reg)operator(,) ident(ValueList)operator(.)ident(Items)operator([)ident(Index)operator(]\);) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(PrefU)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Variants)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) + ident(Dialogs)operator(,) ident(ComCtrls)operator(,) ident(ExtCtrls)operator(,) ident(StdCtrls)operator(,) ident(PlutoConst)operator(,) ident(NewPanels)operator(,) ident(PrefTools)operator(,) + ident(YTools)operator(,) ident(YTypes)operator(,) ident(start)operator(,) ident(XReg)operator(,) ident(LinkLabel)operator(;) + +reserved(type) + ident(TPrefWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(PrefPC)operator(:) ident(TPageControl)operator(;) + ident(CommonPage)operator(:) ident(TTabSheet)operator(;) + ident(KeyPage)operator(:) ident(TTabSheet)operator(;) + ident(DataPage)operator(:) ident(TTabSheet)operator(;) + ident(KeysBP)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox3)operator(:) ident(TGroupBox)operator(;) + ident(MainPrevBP)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox4)operator(:) ident(TGroupBox)operator(;) + ident(BorderPanel6)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox6)operator(:) ident(TGroupBox)operator(;) + ident(SortKeysCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(PrefHost)operator(:) ident(TPrefHost)operator(;) + ident(MainPreviewCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(SplashScreenCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(PrefValuesPC)operator(:) ident(TPageControl)operator(;) + ident(StringPage)operator(:) ident(TTabSheet)operator(;) + ident(MultiStringPage)operator(:) ident(TTabSheet)operator(;) + ident(IntPage)operator(:) ident(TTabSheet)operator(;) + ident(BinaryPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel8)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox8)operator(:) ident(TGroupBox)operator(;) + ident(ShowDwordAsHex)operator(:) ident(TPrefCheckBox)operator(;) + ident(BorderPanel7)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox7)operator(:) ident(TGroupBox)operator(;) + ident(CountZeroByteCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(BorderPanel1)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox2)operator(:) ident(TGroupBox)operator(;) + ident(UseExtendedModelCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(BorderPanel2)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox1)operator(:) ident(TGroupBox)operator(;) + ident(ShowAsBinaryCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ShowBinaryAsRG)operator(:) ident(TPrefRadioGroup)operator(;) + ident(Smart4BBCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(DWordPreviewL)operator(:) ident(TLabel)operator(;) + ident(Label4)operator(:) ident(TLabel)operator(;) + ident(Label5)operator(:) ident(TLabel)operator(;) + ident(Label6)operator(:) ident(TLabel)operator(;) + ident(Label7)operator(:) ident(TLabel)operator(;) + ident(UserNameE)operator(:) ident(TPrefEdit)operator(;) + ident(Label8)operator(:) ident(TLabel)operator(;) + ident(MainPreviewE)operator(:) ident(TPrefEdit)operator(;) + ident(Label12)operator(:) ident(TLabel)operator(;) + ident(DefaultIconPreviewCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(KeyInfoPreviewCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(SelectExternalHexEditOD)operator(:) ident(TOpenDialog)operator(;) + ident(BorderPanel3)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox9)operator(:) ident(TGroupBox)operator(;) + ident(IntegrationPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel4)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox5)operator(:) ident(TGroupBox)operator(;) + ident(Label11)operator(:) ident(TLabel)operator(;) + ident(SelectExternalHexEditB)operator(:) ident(TButton)operator(;) + ident(RunExternalHexEditB)operator(:) ident(TButton)operator(;) + ident(ExternalHexEditE)operator(:) ident(TPrefEdit)operator(;) + ident(Label13)operator(:) ident(TLabel)operator(;) + ident(BorderPanel5)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox10)operator(:) ident(TGroupBox)operator(;) + ident(Label15)operator(:) ident(TLabel)operator(;) + ident(RegisterAppCB)operator(:) ident(TCheckBox)operator(;) + ident(Label3)operator(:) ident(TLabel)operator(;) + ident(Memo1)operator(:) ident(TMemo)operator(;) + ident(ExpandStringsRG)operator(:) ident(TPrefRadioGroup)operator(;) + ident(QuotersE)operator(:) ident(TPrefEdit)operator(;) + ident(Label1)operator(:) ident(TLabel)operator(;) + ident(StringPreviewL)operator(:) ident(TLabel)operator(;) + ident(ShowLineCountCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ShowTreeViewLinesCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ValuePage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel10)operator(:) ident(TBorderPanel)operator(;) + ident(GroupBox12)operator(:) ident(TGroupBox)operator(;) + ident(ShowListViewGridCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(Label9)operator(:) ident(TLabel)operator(;) + ident(DefaultValueNameE)operator(:) ident(TPrefEdit)operator(;) + ident(Label10)operator(:) ident(TLabel)operator(;) + ident(GotoPlutoKeyB)operator(:) ident(TButton)operator(;) + ident(ColorPanel2)operator(:) ident(TColorPanel)operator(;) + ident(LinkLabel1)operator(:) ident(TLinkLabel)operator(;) + ident(SmartExpandCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(KeysSingleClickCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ValuesSingleClickCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ShowProgressCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ColorPanel1)operator(:) ident(TColorPanel)operator(;) + ident(Label2)operator(:) ident(TLabel)operator(;) + ident(ReloadB)operator(:) ident(TButton)operator(;) + ident(DefaultB)operator(:) ident(TButton)operator(;) + ident(SaveB)operator(:) ident(TButton)operator(;) + reserved(procedure) ident(PrefPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) + ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(PrefHostLoaded)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StandardPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DataPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(UserNameEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(PrefValuesPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) + ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ShowDwordAsHexClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MainPreviewEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ReloadBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RunExternalHexEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SelectExternalHexEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ExternalHexEditEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DefaultBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegisterAppCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SaveBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StringPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowTreeViewLinesCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowListViewGridCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DefaultValueNameEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(LoadPrefs)operator(;) + reserved(procedure) ident(UseExtendedModelCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(IntegrationPageShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(GotoPlutoKeyBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(KeysSingleClickCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ValuesSingleClickCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(QuotersEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SplashScreenCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SaveBMouseMove)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) + ident(Y)operator(:) ident(Integer)operator(\);) + directive(public) + ident(StringQuoterBegin)operator(,) ident(StringQuoterEnd)operator(:) reserved(string)operator(;) + reserved(end)operator(;) + +reserved(var) + ident(PrefWin)operator(:) ident(TPrefWin)operator(;) + +reserved(implementation) + +reserved(uses) + ident(TreeU)operator(,) ident(ValuesU)operator(,) ident(Splash)operator(,) ident(plutomain)operator(,) ident(WorkU)operator(;) + +preprocessor({$R *.dfm}) + +reserved(procedure) ident(TPrefWin)operator(.)ident(PrefPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) + ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(PC)operator(:) ident(TPageControl)operator(;) + ident(Page)operator(:) ident(TTabSheet)operator(;) +reserved(begin) + ident(PC) operator(:=) ident(TPageControl)operator(()ident(Control)operator(\);) + ident(Page) operator(:=) ident(PC)operator(.)ident(Pages)operator([)ident(TabIndex)operator(];) + reserved(with) ident(PC)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Common)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clWhite) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Keys)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightCyan) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Values)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightPurple) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Data)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightBlue) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(System)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightYellow) + reserved(else) + ident(Color) operator(:=) ident(clWhite)operator(;) + reserved(end)operator(;) + + reserved(with) ident(PC)operator(.)ident(Canvas) reserved(do) + reserved(if) ident(Active) reserved(then) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([)ident(fsBold)operator(];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(5)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(3)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(3)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(2)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(PrefHostLoaded)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PrefHost)operator(.)ident(KeyName) operator(:=) ident(PlutoUniPath)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(StandardPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Started) reserved(then) + ident(RegTV)operator(.)ident(Repaint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(DataPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + + ident(ValuesWin)operator(.)ident(UpdateValues)operator(;) + ident(RegTV)operator(.)ident(Repaint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(UserNameEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text) operator(:=) ident(MainWin)operator(.)ident(Greeting)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(Close)operator(;) + + reserved(if) ident(Key) operator(=) ident(VK_SCROLL) reserved(then) + ident(MainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(,) ident(Key)operator(,) ident(Shift)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag) reserved(then) + ident(DeActivateThis)operator(()ident(ActiveControl)operator(\);) + + ident(AlphaBlendValue) operator(:=) integer(127)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Started) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(ActivateThis)operator(()ident(ActiveControl)operator(\);) + + ident(AlphaBlendValue) operator(:=) integer(255)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(PrefValuesPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) + ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(PC)operator(:) ident(TPageControl)operator(;) + ident(Page)operator(:) ident(TTabSheet)operator(;) +reserved(begin) + ident(PC) operator(:=) ident(TPageControl)operator(()ident(Control)operator(\);) + ident(Page) operator(:=) ident(PC)operator(.)ident(Pages)operator([)ident(TabIndex)operator(];) + reserved(with) ident(PC)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Page) operator(=) ident(StringPage) reserved(then) + ident(Color) operator(:=) ident(clBrightRed) + reserved(else) reserved(if) ident(Page) operator(=) ident(MultiStringPage) reserved(then) + ident(Color) operator(:=) ident(clBrightPurple) + reserved(else) reserved(if) ident(Page) operator(=) ident(IntPage) reserved(then) + ident(Color) operator(:=) ident(clBrightBlue) + reserved(else) reserved(if) ident(Page) operator(=) ident(BinaryPage) reserved(then) + ident(Color) operator(:=) ident(clBrightGreen)operator(;) + reserved(end)operator(;) + + reserved(with) ident(PC)operator(.)ident(Canvas) reserved(do) + reserved(if) ident(Active) reserved(then) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([)ident(fsBold)operator(];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(18) operator(+) integer(5)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(3)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + ident(PC)operator(.)ident(Images)operator(.)ident(Draw)operator(()ident(PC)operator(.)ident(Canvas)operator(,) ident(Rect)operator(.)ident(Left) operator(+) integer(4)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(2)operator(,) ident(Page)operator(.)ident(ImageIndex)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(18) operator(+) integer(3)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(2)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + ident(PC)operator(.)ident(Images)operator(.)ident(Draw)operator(()ident(PC)operator(.)ident(Canvas)operator(,) ident(Rect)operator(.)ident(Left) operator(+) integer(1)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(1)operator(,) ident(Page)operator(.)ident(ImageIndex)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ShowDwordAsHexClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DWordPreviewL)operator(.)ident(Caption) operator(:=) string<delimiter(')content(Preview: )delimiter(')> operator(+) ident(ValuesU)operator(.)ident(DataPreviewOfContext)operator(() + ident(RegContext)operator(()ident(rdCardinal)operator(,) ident(Reverse)operator(()ident(ByteAOfHex)operator(()ident(HexOfCard)operator(()integer(1234567890)operator(,) integer(8)operator(\)\)\)\)\);) + ident(DataPreviewChange)operator(()ident(Self)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(MainPreviewEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(MainPreviewE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(MainPreviewCB)operator(.)ident(Caption) operator(:=) string<delimiter(')content(&Show Preview for Default Value)delimiter(')> + reserved(else) + ident(MainPreviewCB)operator(.)ident(Caption) operator(:=) string<delimiter(')content(&Show Preview for )delimiter(')> operator(+) + ident(Quote)operator(()ident(MainPreviewE)operator(.)ident(Text)operator(\);) + + ident(StandardPreviewChange)operator(()ident(Self)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(UserNameE)operator(.)ident(DefaultValue) operator(:=) ident(UserName)operator(;) + ident(MainPreviewEChange)operator(()ident(Self)operator(\);) + ident(PrefPC)operator(.)ident(ActivePageIndex) operator(:=) integer(0)operator(;) + ident(PrefValuesPC)operator(.)ident(ActivePageIndex) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ReloadBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(LoadPrefs)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(RunExternalHexEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(FileName)operator(,) ident(TestValue)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(TempDir) operator(+) string<delimiter(')content(~test.bin)delimiter(')>operator(;) + ident(TestValue) operator(:=) string<delimiter(')content(This is only a test.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Everything seems to be OK.)delimiter(')>operator(;) + reserved(if) ident(SaveByteA)operator(()ident(ByteAOfStr)operator(()ident(TestValue)operator(\),) ident(FileName)operator(\)) reserved(then) + ident(ExecFileWith)operator(()ident(ExternalHexEditE)operator(.)ident(Text)operator(,) ident(FileName)operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Could not write into file:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(SelectExternalHexEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SelectExternalHexEditOD) reserved(do) reserved(begin) + ident(InitialDir) operator(:=) ident(ExtractPath)operator(()ident(ExternalHexEditE)operator(.)ident(Text)operator(\);) + ident(FileName) operator(:=) ident(ExtractFileName)operator(()ident(ExternalHexEditE)operator(.)ident(Text)operator(\);) + reserved(if) ident(Execute) reserved(and) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(then) + ident(ExternalHexEditE)operator(.)ident(Text) operator(:=) ident(FileName)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ExternalHexEditEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(RunExternalHexEditB)operator(.)ident(Enabled) operator(:=) ident(FileExists)operator(()ident(ExternalHexEditE)operator(.)ident(Text)operator(\);) + reserved(if) ident(Assigned)operator(()ident(WorkWin)operator(\)) reserved(then) + ident(WorkWin)operator(.)ident(ExternalEditB)operator(.)ident(Enabled) operator(:=) ident(RunExternalHexEditB)operator(.)ident(Enabled)operator(;) + reserved(if) ident(Assigned)operator(()ident(MainWin)operator(\)) reserved(then) + ident(MainWin)operator(.)ident(ExternalHexEditMI)operator(.)ident(Enabled) operator(:=) ident(RunExternalHexEditB)operator(.)ident(Enabled)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(DefaultBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(mrYes)operator(=)ident(MessageDlg)operator(()string<delimiter(')content(Do you really want to reset the preferences)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(to their defaults?)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content((This can not be undone.\))delimiter(')>operator(,) ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) reserved(begin) + ident(CopyFile)operator(()ident(PChar)operator(()ident(PlutoIniFileName)operator(\),) ident(PChar)operator(()ident(PlutoIniFileName) operator(+) string<delimiter(')content(.backup)delimiter(')>operator(\),) ident(False)operator(\);) + comment(//PrefHost.KeyName := 'Ini <' + PlutoIniFileName + '.backup>:';) + comment(//PrefHost.Save;) + comment(//PrefHost.KeyName := PlutoUniPath;) + ident(PrefHost)operator(.)ident(BackUp)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(RegisterAppCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(TXRegistry)operator(.)ident(Create) reserved(do) + reserved(try) + ident(RootKey) operator(:=) ident(HKLM)operator(;) + ident(OpenKey)operator(()string<delimiter(')content(Software\\Microsoft\\Windows\\CurrentVersion\\App Paths)delimiter(')>operator(\);) + reserved(if) ident(RegisterAppCB)operator(.)ident(Checked) reserved(then) reserved(begin) + ident(OpenKey)operator(()string<delimiter(')content(pluto.exe)delimiter(')>operator(,) ident(True)operator(\);) + ident(WriteString)operator(()string<delimiter(')delimiter(')>operator(,) ident(GetFileNew)operator(()ident(Application)operator(.)ident(ExeName)operator(\)\);) + reserved(end) reserved(else) + ident(DeleteKey)operator(()string<delimiter(')content(pluto.exe)delimiter(')>operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(SaveBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PrefHost)operator(.)ident(Save)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(StringPreviewChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StringPreviewL)operator(.)ident(Caption) operator(:=) string<delimiter(')content(Preview: )delimiter(')> operator(+) ident(ValuesU)operator(.)ident(DataPreviewOfContext)operator(() + ident(RegContext)operator(()ident(rdString)operator(,) ident(ByteAOfStr)operator(()string<delimiter(')content(%windir%)delimiter(')>operator(\)\)\);) + ident(DataPreviewChange)operator(()ident(Self)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ShowTreeViewLinesCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(RegTV) reserved(do) reserved(begin) + ident(ShowLines) operator(:=) ident(ShowTreeViewLinesCB)operator(.)ident(Checked)operator(;) + ident(ShowButtons) operator(:=) ident(ShowLines)operator(;) + reserved(end)operator(;) + ident(StandardPreviewChange)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ShowListViewGridCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValueList)operator(.)ident(GridLines) operator(:=) ident(ShowListViewGridCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(DefaultValueNameEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DefaultValueCaption) operator(:=) ident(DefaultValueNameE)operator(.)ident(Text)operator(;) + reserved(if) ident(Started) reserved(then) + ident(TreeWin)operator(.)ident(RegTVChange)operator(()ident(Self)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(LoadPrefs)operator(;) +reserved(begin) + ident(PrefHost)operator(.)ident(Load)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(UseExtendedModelCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(WorkWin)operator(.)ident(MultiStringTypeRG)operator(.)ident(ItemIndex) operator(:=) ident(Integer)operator(()ident(UseExtendedModelCB)operator(.)ident(Checked)operator(\);) + ident(DataPreviewChange)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(IntegrationPageShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(TXRegistry)operator(.)ident(Create) reserved(do) + reserved(try) + ident(RootKey) operator(:=) ident(HKLM)operator(;) + ident(OpenKey)operator(()string<delimiter(')content(Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\pluto.exe)delimiter(')>operator(\);) + ident(RegisterAppCB)operator(.)ident(Checked) operator(:=) ident(SameFileName)operator(()ident(GetFileNew)operator(()ident(ReadString)operator(()string<delimiter(')delimiter(')>operator(\)\),) + ident(GetFileNew)operator(()ident(Application)operator(.)ident(ExeName)operator(\)\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(GotoPlutoKeyBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MainWin)operator(.)ident(GotoKey)operator(()string<delimiter(')content(HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\pluto.exe)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PrefHost)operator(.)ident(Load)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(KeysSingleClickCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(TreeWin)operator(.)ident(CheckRegTVHotTrack)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(ValuesSingleClickCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValuesWin)operator(.)ident(CheckValueListHotTrack)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(QuotersEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(QBegin)operator(,) ident(QEnd)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(with) ident(QuotersE) reserved(do) reserved(begin) + reserved(if) ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(QBegin) operator(:=) string<delimiter(')delimiter(')> + reserved(else) + ident(QBegin) operator(:=) ident(Text)operator([)integer(1)operator(];) + reserved(if) ident(Length)operator(()ident(Text)operator(\)) operator(<) integer(2) reserved(then) + ident(QEnd) operator(:=) ident(QBegin) + reserved(else) + ident(QEnd) operator(:=) ident(Text)operator([)integer(2)operator(];) + reserved(end)operator(;) + + reserved(if) operator(()ident(QBegin) operator(<>) ident(StringQuoterBegin)operator(\)) reserved(or) operator(()ident(QEnd) operator(<>) ident(StringQuoterEnd)operator(\)) reserved(then) reserved(begin) + ident(StringQuoterBegin) operator(:=) ident(QBegin)operator(;) + ident(StringQuoterEnd) operator(:=) ident(QEnd)operator(;) + ident(StringPreviewChange)operator(()ident(Self)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(SplashScreenCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Started) reserved(and) ident(Assigned)operator(()ident(SplashWin)operator(\)) reserved(then) + ident(SplashWin)operator(.)ident(SplashScreenCB)operator(.)ident(Checked) operator(:=) ident(SplashScreenCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TPrefWin)operator(.)ident(SaveBMouseMove)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) + ident(Y)operator(:) ident(Integer)operator(\);) +reserved(begin) + ident(Label2)operator(.)ident(Font)operator(.)ident(Color) operator(:=) ident(clBrightRed)operator(;) + ident(Application)operator(.)ident(ProcessMessages)operator(;) + ident(Sleep)operator(()integer(200)operator(\);) + ident(Label2)operator(.)ident(Font)operator(.)ident(Color) operator(:=) ident(clWhite)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(RegScanner)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(SysUtils)operator(,) ident(Dialogs)operator(,) ident(Classes)operator(,) + ident(YTools)operator(,) ident(YTypes)operator(,) ident(XReg)operator(,) ident(Clock)operator(;) + +reserved(type) + ident(TRegScanThread) operator(=) reserved(class)operator(;) + + ident(TRegScanKeyEvent) operator(=) reserved(procedure) operator(()ident(Sender)operator(:) ident(TRegScanThread)operator(;) reserved(const) ident(KeyName)operator(:) reserved(string)operator(;) ident(Key)operator(:) ident(HKEY)operator(;) ident(Info)operator(:) ident(TRegKeyInfo)operator(\)) reserved(of) reserved(object)operator(;) + ident(TRegScanValueEvent) operator(=) reserved(procedure) operator(()ident(Sender)operator(:) ident(TRegScanThread)operator(;) reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) ident(Context)operator(:) ident(TRegContext)operator(\)) reserved(of) reserved(object)operator(;) + + ident(TRegScanTask) operator(=) reserved(record) + ident(Root)operator(:) reserved(string)operator(;) + ident(Key)operator(:) ident(HKEY)operator(;) + reserved(end)operator(;) + ident(TRegScanTasks) operator(=) reserved(array) reserved(of) ident(TRegScanTask)operator(;) + + ident(TRegScanThread) operator(=) reserved(class)operator(()ident(TThread)operator(\)) + directive(private) + ident(Keys)operator(,) ident(KeysOK)operator(,) ident(Values)operator(,) ident(ValuesOK)operator(:) ident(Integer)operator(;) + ident(DoScanValues)operator(:) ident(Boolean)operator(;) + ident(FOnKey)operator(:) ident(TRegScanKeyEvent)operator(;) + ident(FOnValue)operator(:) ident(TRegScanValueEvent)operator(;) + ident(FOnFaileKey)operator(:) ident(TRegScanKeyEvent)operator(;) + directive(protected) + reserved(procedure) ident(ScanKey)operator(()ident(Key)operator(:) ident(HKEY)operator(;) reserved(const) ident(KeyName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) directive(virtual)operator(;) + reserved(procedure) ident(ScanValues)operator(()ident(Key)operator(:) ident(HKEY)operator(;) ident(Info)operator(:) ident(TRegKeyInfo)operator(\);) directive(virtual)operator(;) + + directive(public) + ident(Path)operator(:) reserved(string)operator(;) + ident(CurrentTask)operator(:) ident(TRegScanTask)operator(;) + ident(Tasks)operator(:) ident(TRegScanTasks)operator(;) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(procedure) ident(Execute)operator(;) directive(override)operator(;) + reserved(procedure) ident(ScanAll)operator(;) + reserved(function) ident(CurrentPath)operator(:) reserved(string)operator(;) + directive(published) + reserved(constructor) ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(;) + ident(DoScanValues)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(Tasks)operator(:) ident(TRegScanTasks) operator(=) reserved(nil)operator(\);) + + reserved(property) ident(OnKey)operator(:) ident(TRegScanKeyEvent) directive(read) ident(FOnKey) directive(write) ident(FOnKey)operator(;) + reserved(property) ident(OnValue)operator(:) ident(TRegScanValueEvent) directive(read) ident(FOnValue) directive(write) ident(FOnValue)operator(;) + reserved(property) ident(OnFaileKey)operator(:) ident(TRegScanKeyEvent) directive(read) ident(FOnFaileKey) directive(write) ident(FOnFaileKey)operator(;) + reserved(end)operator(;) + +reserved(implementation) + +comment({ TRegScanThread }) + +reserved(constructor) ident(TRegScanThread)operator(.)ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(;) + ident(DoScanValues)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(Tasks)operator(:) ident(TRegScanTasks) operator(=) reserved(nil)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(()ident(True)operator(\);) + ident(Priority) operator(:=) ident(PriorityLevel)operator(;) + ident(FreeOnTerminate) operator(:=) ident(False)operator(;) + ident(Self)operator(.)ident(DoScanValues) operator(:=) ident(DoScanValues)operator(;) + ident(Self)operator(.)ident(Tasks) operator(:=) ident(Tasks)operator(;) +reserved(end)operator(;) + +reserved(destructor) ident(TRegScanThread)operator(.)ident(Destroy)operator(;) +reserved(begin) + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegScanThread)operator(.)ident(ScanAll)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Keys) operator(:=) integer(0)operator(;) + ident(KeysOK) operator(:=) integer(0)operator(;) + ident(Values) operator(:=) integer(0)operator(;) + ident(ValuesOK) operator(:=) integer(0)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Tasks)operator(\)) reserved(do) reserved(begin) + ident(CurrentTask) operator(:=) ident(Tasks)operator([)ident(i)operator(];) + reserved(with) ident(CurrentTask) reserved(do) reserved(begin) + ident(Inc)operator(()ident(Keys)operator(\);) + ident(ScanKey)operator(()ident(Key)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Terminated) reserved(then) ident(Break)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegScanThread)operator(.)ident(ScanValues)operator(()ident(Key)operator(:) ident(HKEY)operator(;) ident(Info)operator(:) ident(TRegKeyInfo)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(MaxLen)operator(,) ident(NameLen)operator(,) ident(Len)operator(,) ident(Typ)operator(:) ident(Cardinal)operator(;) + ident(p)operator(:) ident(PChar)operator(;) + ident(Buffer)operator(:) ident(TByteA)operator(;) + + reserved(procedure) ident(ScanValue)operator(()ident(ValueName)operator(:) reserved(string)operator(;) ident(Typ)operator(:) ident(TRegDataType)operator(;) ident(Data)operator(:) ident(TByteA)operator(\);) + reserved(begin) + reserved(if) ident(Assigned)operator(()ident(OnValue)operator(\)) reserved(then) + ident(OnValue)operator(()ident(Self)operator(,) ident(ValueName)operator(,) ident(RegContext)operator(()ident(Typ)operator(,) ident(Data)operator(\)\);) + ident(Inc)operator(()ident(ValuesOK)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(MaxLen) operator(:=) ident(Info)operator(.)ident(MaxValueLen) operator(+) integer(1)operator(;) comment(//Include Nullbyte) + ident(SetLength)operator(()ident(Buffer)operator(,) ident(Info)operator(.)ident(MaxDataLen)operator(\);) + ident(GetMem)operator(()ident(p)operator(,) ident(MaxLen)operator(\);) + + ident(Inc)operator(()ident(Values)operator(,) ident(Info)operator(.)ident(NumValues)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Info)operator(.)ident(NumValues)operator(-)integer(1) reserved(do) reserved(begin) + ident(NameLen) operator(:=) ident(MaxLen)operator(;) + ident(Len) operator(:=) ident(Info)operator(.)ident(MaxDataLen)operator(;) + reserved(if) ident(Success)operator(()ident(RegEnumValue)operator(()ident(Key)operator(,) ident(i)operator(,) ident(p)operator(,) ident(NameLen)operator(,) reserved(nil)operator(,) operator(@)ident(Typ)operator(,) ident(Pointer)operator(()ident(Buffer)operator(\),) + operator(@)ident(Len)operator(\)\)) reserved(then) + ident(ScanValue)operator(()ident(Copy)operator(()ident(p)operator(,) integer(0)operator(,) ident(NameLen)operator(\),) ident(Typ)operator(,) ident(Copy)operator(()ident(Buffer)operator(,) integer(0)operator(,) ident(Len)operator(\)\)) + reserved(else) + ident(Yield)operator(;) + reserved(end)operator(;) + ident(FreeMem)operator(()ident(p)operator(,) ident(MaxLen)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TRegScanThread)operator(.)ident(ScanKey)operator(()ident(Key)operator(:) ident(HKEY)operator(;) reserved(const) ident(KeyName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(NewHKEY)operator(:) ident(HKEY)operator(;) + ident(Info)operator(:) ident(TRegKeyInfo)operator(;) + ident(l)operator(,) ident(Len)operator(:) ident(DWORD)operator(;) + ident(p)operator(:) ident(PChar)operator(;) + ident(z)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Terminated) reserved(then) ident(Exit)operator(;) + + reserved(with) ident(Info) reserved(do) reserved(begin) + reserved(if) reserved(not) ident(Success)operator(()ident(RegQueryInfoKey)operator(()ident(Key)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) operator(@)ident(NumSubKeys)operator(,) + operator(@)ident(MaxSubKeyLen)operator(,) reserved(nil)operator(,) operator(@)ident(NumValues)operator(,) operator(@)ident(MaxValueLen)operator(,) operator(@)ident(MaxDataLen)operator(,) + reserved(nil)operator(,) reserved(nil)operator(\)\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Assigned)operator(()ident(OnKey)operator(\)) reserved(then) + ident(OnKey)operator(()ident(Self)operator(,) ident(KeyName)operator(,) ident(Key)operator(,) ident(Info)operator(\);) + reserved(if) ident(DoScanValues) reserved(and) operator(()ident(NumValues) operator(>) integer(0)operator(\)) reserved(then) + ident(ScanValues)operator(()ident(Key)operator(,) ident(Info)operator(\);) + + reserved(if) ident(Info)operator(.)ident(NumSubKeys) operator(>) integer(0) reserved(then) reserved(begin) + ident(Inc)operator(()ident(Keys)operator(,) ident(NumSubKeys)operator(\);) + + ident(Len) operator(:=) ident(MaxSubKeyLen) operator(+) integer(1)operator(;) + ident(GetMem)operator(()ident(p)operator(,) ident(Len)operator(\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(NumSubKeys)operator(-)integer(1) reserved(do) reserved(begin) + ident(l) operator(:=) ident(Len)operator(;) + ident(RegEnumKeyEx)operator(()ident(Key)operator(,) ident(i)operator(,) ident(p)operator(,) ident(l)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(\);) + reserved(if) ident(Success)operator(()ident(RegOpenKey)operator(()ident(Key)operator(,) ident(p)operator(,) ident(NewHKEY)operator(\)\)) reserved(then) reserved(begin) + ident(z) operator(:=) ident(Length)operator(()ident(Path)operator(\);) + ident(Path) operator(:=) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(p)operator(;) + ident(ScanKey)operator(()ident(NewHKEY)operator(,) ident(p)operator(\);) + ident(RegCloseKey)operator(()ident(NewHKEY)operator(\);) + ident(SetLength)operator(()ident(Path)operator(,) ident(z)operator(\);) + reserved(end) reserved(else) + reserved(if) ident(Assigned)operator(()ident(OnFaileKey)operator(\)) reserved(then) + ident(OnFaileKey)operator(()ident(Self)operator(,) ident(p)operator(,) ident(Key)operator(,) ident(Info)operator(\);) + + reserved(if) ident(Terminated) reserved(then) + ident(Break)operator(;) + reserved(end)operator(;) + ident(FreeMem)operator(()ident(p)operator(,) ident(Len)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(Inc)operator(()ident(KeysOK)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TRegScanThread)operator(.)ident(Execute)operator(;) +reserved(var) + ident(Secs)operator(:) ident(Double)operator(;) +reserved(begin) + reserved(with) ident(TClock)operator(.)ident(Create) reserved(do) reserved(begin) + ident(ScanAll)operator(;) + ident(Secs) operator(:=) ident(SecondsPassed)operator(;) + ident(Free)operator(;) + reserved(end)operator(;) + + ident(WriteLn)operator(()string<delimiter(')content(finished.)delimiter(')>operator(\);) + ident(WriteLn)operator(() ident(Format)operator(()string<delimiter(')content(Keys: %6d counted (%3d failed\))delimiter(')>operator(,) operator([)ident(Keys)operator(,) ident(Keys) operator(-) ident(KeysOK)operator(]\)\);) + reserved(if) ident(DoScanValues) reserved(then) + ident(WriteLn)operator(()ident(Format)operator(()string<delimiter(')content(Values: %6d counted (%3d failed\))delimiter(')>operator(,) operator([)ident(Values)operator(,) ident(Values) operator(-) ident(ValuesOK)operator(]\)\);) + ident(WriteLn)operator(()string<delimiter(')content(t )delimiter(')> operator(+) ident(Format)operator(()string<delimiter(')content(%.2f)delimiter(')>operator(,) operator([)ident(Secs)operator(]\)) operator(+) string<delimiter(')content( seconds)delimiter(')>operator(\);) + reserved(if) ident(Secs) operator(>) integer(0) reserved(then) + ident(WriteLn)operator(()string<delimiter(')content(r )delimiter(')> operator(+) ident(Format)operator(()string<delimiter(')content(%.0f)delimiter(')>operator(,) operator([)ident(Keys) operator(/) ident(Secs)operator(]\)) operator(+) string<delimiter(')content( k/s)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TRegScanThread)operator(.)ident(CurrentPath)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(CurrentTask)operator(.)ident(Root) operator(+) ident(Path)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(RegTV)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) ident(Dialogs)operator(,) + ident(ComCtrls)operator(;) + +reserved(type) + ident(TRegTV) operator(=) reserved(class)operator(()ident(TTreeView)operator(\)) + directive(private) + comment({ Private-Deklarationen }) + directive(protected) + comment({ Protected-Deklarationen }) + directive(public) + comment({ Public-Deklarationen }) + directive(published) + comment({ Published-Deklarationen }) + reserved(end)operator(;) + +reserved(procedure) ident(Register)operator(;) + +reserved(implementation) + +reserved(procedure) ident(Register)operator(;) +reserved(begin) + ident(RegisterComponents)operator(()string<delimiter(')content(pluto)delimiter(')>operator(,) operator([)ident(TRegTV)operator(]\);) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(Sisyphus)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Classes)operator(,) ident(SysUtils)operator(,) ident(XReg)operator(,) ident(YTools)operator(,) ident(YTypes)operator(,) ident(Clock)operator(;) + +reserved(type) + ident(TSpyValue) operator(=) reserved(class) + ident(Name)operator(:) reserved(string)operator(;) + ident(Next)operator(:) ident(TSpyValue)operator(;) + comment(//DIC: TByteA;) + ident(Typ)operator(:) ident(TXRegDataType)operator(;) + ident(Data)operator(:) ident(TByteA)operator(;) + reserved(constructor) ident(Create)operator(()ident(AName)operator(:) reserved(string)operator(\);) + reserved(end)operator(;) + + ident(TSpyKey) operator(=) reserved(class) + directive(public) + ident(Parent)operator(:) ident(TSpyKey)operator(;) + ident(Name)operator(:) reserved(string)operator(;) + ident(Next)operator(:) ident(TSpyKey)operator(;) + ident(Keys)operator(:) ident(TSpyKey)operator(;) + ident(Values)operator(:) ident(TSpyValue)operator(;) + reserved(procedure) ident(Spy)operator(()ident(AHKEY)operator(:) ident(HKEY)operator(\);) + reserved(function) ident(Path)operator(:) reserved(string)operator(;) + reserved(constructor) ident(Create)operator(()ident(AParent)operator(:) ident(TSpyKey)operator(;) ident(AName)operator(:) reserved(string)operator(\);) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(end)operator(;) + +reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(HKLMSpyKey)operator(,) ident(HKUSpyKey)operator(:) ident(TSpyKey)operator(;) + ident(Started)operator(:) ident(Boolean) operator(=) ident(False)operator(;) + +reserved(implementation) + +reserved(uses) + ident(Plutomain)operator(;) + +reserved(procedure) ident(AddChange)operator(()ident(M)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(Yield)operator(;) + comment(//AddHint(M\);) +reserved(end)operator(;) + +comment({ TSpyValue }) + +reserved(constructor) ident(TSpyValue)operator(.)ident(Create)operator(()ident(AName)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(Name) operator(:=) ident(AName)operator(;) + ident(Next) operator(:=) reserved(nil)operator(;) +reserved(end)operator(;) + +comment({ TSpyKey }) + +reserved(constructor) ident(TSpyKey)operator(.)ident(Create)operator(()ident(AParent)operator(:) ident(TSpyKey)operator(;) ident(AName)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(Name) operator(:=) ident(AName)operator(;) + ident(Parent) operator(:=) ident(AParent)operator(;) + + ident(Next) operator(:=) reserved(nil)operator(;) + ident(Keys) operator(:=) reserved(nil)operator(;) + ident(Values) operator(:=) reserved(nil)operator(;) +reserved(end)operator(;) + +reserved(destructor) ident(TSpyKey)operator(.)ident(Destroy)operator(;) +reserved(var) + ident(Value)operator(,) ident(NextValue)operator(:) ident(TSpyValue)operator(;) + ident(Key)operator(,) ident(NextKey)operator(:) ident(TSpyKey)operator(;) +reserved(begin) + ident(Value) operator(:=) ident(Values)operator(;) + reserved(while) ident(Value) operator(<>) reserved(nil) reserved(do) reserved(begin) + ident(NextValue) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + ident(Value)operator(.)ident(Free)operator(;) + ident(Value) operator(:=) ident(NextValue)operator(;) + reserved(end)operator(;) + + ident(Key) operator(:=) ident(Keys)operator(;) + reserved(while) ident(Key) operator(<>) reserved(nil) reserved(do) reserved(begin) + ident(NextKey) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + ident(Key)operator(.)ident(Free)operator(;) + ident(Key) operator(:=) ident(NextKey)operator(;) + reserved(end)operator(;) + + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TSpyKey)operator(.)ident(Path)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Parent)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Parent)operator(.)ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> + reserved(else) + ident(Result) operator(:=) string<delimiter(')content(Reg: )delimiter(')>operator(;) + + ident(Result) operator(:=) ident(Result) operator(+) ident(Name)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSpyKey)operator(.)ident(Spy)operator(()ident(AHKEY)operator(:) ident(HKEY)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + + reserved(procedure) ident(CompareValues)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Value)operator(,) ident(LastValue)operator(,) ident(NewValue)operator(,) ident(SearchValue)operator(:) ident(TSpyValue)operator(;) + reserved(begin) + comment(//OK, this part is a little bit complicate. So I will comment very much.) + comment(//First, two terms are important:) + comment(//<REAL> means the list of values that will be read from the registry now:) + ident(Reg)operator(.)ident(GetValueNames)operator(()ident(SL)operator(\);) + comment(//So <REAL> is TStringList.) + + comment(//<CURRENT> means the image that was saved before.) + comment(//Here, it is a linear list of TSpyValue objects. That means that you can) + comment(//only get X.Next and not X.Prev! However, I use "X.Prev" to simplify) + comment(//some comments.) + + comment(//!!! Comparing means: Make <CURRENT> fit <REAL> !!!) + + comment(//If <CURRENT> wasn't saved before, it is just empty.) + + comment(//!!! There is no difference in comparing and saving in this method !!!) + + comment(//Building means: Comparing with an empty image.) + + comment(//We go through <REAL> and make <CURRENT> fit it) + + comment(//The following rules are important:) + comment(//Value = "The currently interesting value.) + comment(//LastValue = "The value with X.Next = Value" = "Value.Pref") + + ident(LastValue) operator(:=) reserved(nil)operator(;) comment(// := "Values.Prev") + ident(Value) operator(:=) ident(Values)operator(;) comment(// := "LastValue.Next") + + comment(//Now compare step by step) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Value)operator(\)) reserved(and) operator(()ident(SL)operator([)ident(i)operator(]) operator(=) ident(Value)operator(.)ident(Name)operator(\)) reserved(then) reserved(begin) + comment(//cV= Normally (0.9999\) everything's the same) + ident(LastValue) operator(:=) ident(Value)operator(;) + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + reserved(end) reserved(else) reserved(begin) comment(//Something's different? Yes, the IMPORTANT rest (0.0001\)\)) + comment(//Because the list finally must exactly fit SL, the "SL[i] value" hast) + comment(//to be inserted right here. But first let's look...) + + comment(//Maybe it was just moved? So search for it...) + ident(NewValue) operator(:=) reserved(nil)operator(;) + reserved(if) ident(Assigned)operator(()ident(Value)operator(\)) reserved(then) reserved(begin) + ident(SearchValue) operator(:=) ident(Value)operator(;) + reserved(while) ident(Assigned)operator(()ident(SearchValue)operator(.)ident(Next)operator(\)) reserved(do) + reserved(if) operator(()ident(SearchValue)operator(.)ident(Next)operator(.)ident(Name) operator(=) ident(SL)operator([)ident(i)operator(]\)) reserved(then) reserved(begin) + comment(//cV\\) + ident(NewValue) operator(:=) ident(SearchValue)operator(.)ident(Next)operator(;) + ident(AddChange)operator(()string<delimiter(')content(cV\\ )delimiter(')> operator(+) ident(Path)operator(\);) + ident(SearchValue)operator(.)ident(Next) operator(:=) ident(SearchValue)operator(.)ident(Next)operator(.)ident(Next)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(NewValue)operator(\)) reserved(then) reserved(begin) + comment(//cV+ No, not found! So it is new...) + ident(NewValue) operator(:=) ident(TSpyValue)operator(.)ident(Create)operator(()ident(SL)operator([)ident(i)operator(]\);) + ident(AddChange)operator(()string<delimiter(')content(cV+ )delimiter(')> operator(+) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(NewValue)operator(.)ident(Name)operator(\);) + reserved(with) ident(NewValue) reserved(do) reserved(begin) + ident(Typ) operator(:=) ident(Reg)operator(.)ident(GetDataType)operator(()ident(SL)operator([)ident(i)operator(]\);) + ident(Data) operator(:=) ident(Reg)operator(.)ident(ReadBin)operator(()ident(SL)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//The new object now must be placed after the last value) + reserved(if) ident(Assigned)operator(()ident(LastValue)operator(\)) reserved(then) reserved(begin) + ident(LastValue)operator(.)ident(Next) operator(:=) ident(NewValue)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//If it's the first value, we don't have LastValue defined) + comment(//So we have to set the "Root" to it) + ident(Values) operator(:=) ident(NewValue)operator(;) + reserved(end)operator(;) + comment(//Now the rest of <CURRENT> has to be placed after the new value) + ident(NewValue)operator(.)ident(Next) operator(:=) ident(Value)operator(;) + comment(//And LastValue also has to refreshed: It is "Value.Pref" = NewValue!) + ident(LastValue) operator(:=) ident(NewValue)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//Because the whole <CURRENT> before Value is exactly <REAL>, the rest) + comment(//(if there is one\) must have been deleted!) + + comment(//So first let's ensure that <CURRENT> ends here:) + reserved(if) ident(Assigned)operator(()ident(LastValue)operator(\)) reserved(then) reserved(begin) + ident(LastValue)operator(.)ident(Next) operator(:=) reserved(nil)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//Another time: <CURRENT> is empty now, so set Values instead) + ident(Values) operator(:=) reserved(nil)operator(;) + reserved(end)operator(;) + + comment(//Now, the first value that maybe was "cut" off is Value:) + reserved(while) ident(Assigned)operator(()ident(Value)operator(\)) reserved(do) reserved(begin) + comment(//cV- So, here really something HAS been deleted) + ident(LastValue) operator(:=) ident(Value)operator(;) + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + ident(AddChange)operator(()string<delimiter(')content(cV- )delimiter(')> operator(+) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(LastValue)operator(.)ident(Name)operator(\);) + ident(LastValue)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(CompareData)operator(;) + reserved(var) + ident(Value)operator(:) ident(TSpyValue)operator(;) + ident(Typ)operator(:) ident(TXRegDataType)operator(;) + ident(Data)operator(:) ident(TByteA)operator(;) + reserved(begin) + comment(//So, finally <CURRENT> = <REAL>. That means we now can compare the data:) + ident(Value) operator(:=) ident(Values)operator(;) + reserved(while) ident(Assigned)operator(()ident(Value)operator(\)) reserved(do) reserved(begin) + ident(Typ) operator(:=) ident(Reg)operator(.)ident(GetDataType)operator(()ident(Value)operator(.)ident(Name)operator(\);) + ident(Data) operator(:=) ident(Reg)operator(.)ident(ReadBin)operator(()ident(Value)operator(.)ident(Name)operator(\);) + reserved(if) ident(Typ) operator(<>) ident(Value)operator(.)ident(Typ) reserved(then) reserved(begin) + comment(//cT#) + ident(AddChange)operator(()string<delimiter(')content(cT# )delimiter(')> operator(+) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(Value)operator(.)ident(Name)operator(\);) + ident(Value)operator(.)ident(Typ) operator(:=) ident(Typ)operator(;) + reserved(end)operator(;) + reserved(if) reserved(not) ident(SameByteA)operator(()ident(Data)operator(,) ident(Value)operator(.)ident(Data)operator(\)) reserved(then) reserved(begin) + comment(//cD#) + ident(AddChange)operator(()string<delimiter(')content(cD# )delimiter(')> operator(+) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(Value)operator(.)ident(Name)operator(\);) + ident(Value)operator(.)ident(Data) operator(:=) ident(Data)operator(;) + reserved(end)operator(;) + + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(CompareKeys)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Key)operator(,) ident(LastKey)operator(,) ident(NewKey)operator(,) ident(SearchKey)operator(:) ident(TSpyKey)operator(;) + ident(NewHKEY)operator(:) ident(HKEY)operator(;) + reserved(begin) + comment(//OK, this part is a little bit complicate. So I will comment very much.) + comment(//First, two terms are important:) + comment(//<REAL> means the list of keys that will be read from the registry now:) + ident(Reg)operator(.)ident(GetKeyNames)operator(()ident(SL)operator(\);) + comment(//So <REAL> is TStringList.) + + comment(//<CURRENT> means the image that was saved before.) + comment(//Here, it is a linear list of TSpyKey objects. That means that you can) + comment(//only get X.Next and not X.Prev! However, I use "X.Prev" to simplify) + comment(//some comments.) + + comment(//!!! Comparing means: Make <CURRENT> fit <REAL> !!!) + + comment(//If <CURRENT> wasn't saved before, it is just empty.) + + comment(//!!! There is no difference in comparing and saving in this method !!!) + + comment(//Building means: Comparing with an empty image.) + + comment(//We go through <REAL> and make <CURRENT> fit it) + + comment(//The following rules are important:) + comment(//Key = "The currently interesting key.) + comment(//LastKey = "The key with X.Next = Key" = "Key.Pref") + + ident(LastKey) operator(:=) reserved(nil)operator(;) comment(// := "Keys.Prev") + ident(Key) operator(:=) ident(Keys)operator(;) comment(// := "LastKey.Next") + + comment(//Now compare step by step) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Key)operator(\)) reserved(and) operator(()ident(SL)operator([)ident(i)operator(]) operator(=) ident(Key)operator(.)ident(Name)operator(\)) reserved(then) reserved(begin) + comment(//cK= Normally (0.9999\) everything's the same) + ident(RegOpenKey)operator(()ident(AHKEY)operator(,) ident(PChar)operator(()ident(SL)operator([)ident(i)operator(]\),) ident(NewHKEY)operator(\);) + ident(Key)operator(.)ident(Spy)operator(()ident(NewHKEY)operator(\);) + ident(LastKey) operator(:=) ident(Key)operator(;) + ident(Key) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + reserved(end) reserved(else) reserved(begin) comment(//Something's different? Yes, the IMPORTANT rest (0.0001\)\)) + comment(//Because the list finally must exactly fit SL, the "SL[i] key" hast) + comment(//to be inserted right here. But first let's look...) + + comment(//Maybe it was just moved? So search for it...) + ident(NewKey) operator(:=) reserved(nil)operator(;) + reserved(if) ident(Assigned)operator(()ident(Key)operator(\)) reserved(then) reserved(begin) + ident(SearchKey) operator(:=) ident(Key)operator(;) + reserved(while) ident(Assigned)operator(()ident(SearchKey)operator(.)ident(Next)operator(\)) reserved(do) + reserved(if) operator(()ident(SearchKey)operator(.)ident(Next)operator(.)ident(Name) operator(=) ident(SL)operator([)ident(i)operator(]\)) reserved(then) reserved(begin) + comment(//cK\\) + ident(NewKey) operator(:=) ident(SearchKey)operator(.)ident(Next)operator(;) + ident(AddChange)operator(()string<delimiter(')content(cK\\ )delimiter(')> operator(+) ident(Path)operator(\);) + ident(SearchKey)operator(.)ident(Next) operator(:=) ident(SearchKey)operator(.)ident(Next)operator(.)ident(Next)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(NewKey)operator(\)) reserved(then) reserved(begin) + comment(//cK+ No, not found! So it is new...) + ident(NewKey) operator(:=) ident(TSpyKey)operator(.)ident(Create)operator(()ident(Self)operator(,) ident(SL)operator([)ident(i)operator(]\);) + ident(AddChange)operator(()string<delimiter(')content(cK+ )delimiter(')> operator(+) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(NewKey)operator(.)ident(Name)operator(\);) + + ident(RegOpenKey)operator(()ident(AHKEY)operator(,) ident(PChar)operator(()ident(SL)operator([)ident(i)operator(]\),) ident(NewHKEY)operator(\);) + ident(NewKey)operator(.)ident(Spy)operator(()ident(NewHKEY)operator(\);) + reserved(end)operator(;) + + comment(//The new object now must be placed after the last key) + reserved(if) ident(Assigned)operator(()ident(LastKey)operator(\)) reserved(then) reserved(begin) + ident(LastKey)operator(.)ident(Next) operator(:=) ident(NewKey)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//If it's the first key, we don't have LastKey defined) + comment(//So we have to set the "Root" to it) + ident(Keys) operator(:=) ident(NewKey)operator(;) + reserved(end)operator(;) + comment(//Now the rest of <CURRENT> has to be placed after the new key) + ident(NewKey)operator(.)ident(Next) operator(:=) ident(Key)operator(;) + comment(//And LastKey also has to refreshed: It is "Key.Pref" = NewKey!) + ident(LastKey) operator(:=) ident(NewKey)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//Because the whole <CURRENT> before Key is exactly <REAL>, the rest) + comment(//(if there is one\) must have been deleted!) + + comment(//So first let's ensure that <CURRENT> ends here:) + reserved(if) ident(Assigned)operator(()ident(LastKey)operator(\)) reserved(then) reserved(begin) + ident(LastKey)operator(.)ident(Next) operator(:=) reserved(nil)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//Another time: <CURRENT> is empty now, so set Keys instead) + ident(Keys) operator(:=) reserved(nil)operator(;) + reserved(end)operator(;) + + comment(//Now, the first key that maybe was "cut" off is Key:) + reserved(while) ident(Assigned)operator(()ident(Key)operator(\)) reserved(do) reserved(begin) + comment(//cV- So, here really something HAS been deleted) + ident(LastKey) operator(:=) ident(Key)operator(;) + ident(Key) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + ident(AddChange)operator(()string<delimiter(')content(cK- )delimiter(')> operator(+) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(LastKey)operator(.)ident(Name)operator(\);) + ident(LastKey)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + +reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + + reserved(try) + ident(Reg)operator(.)ident(CurrentKey) operator(:=) ident(AHKEY)operator(;) + + ident(CompareValues)operator(;) + + ident(CompareData)operator(;) + + ident(CompareKeys)operator(;) + + reserved(finally) + ident(RegCloseKey)operator(()ident(AHKEY)operator(\);) + reserved(end)operator(;) + + ident(SL)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(initialization) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + ident(HKLMSpyKey) operator(:=) ident(TSpyKey)operator(.)ident(Create)operator(()reserved(nil)operator(,) string<delimiter(')content(HKEY_LOCAL_MACHINE)delimiter(')>operator(\);) + ident(HKUSpyKey) operator(:=) ident(TSpyKey)operator(.)ident(Create)operator(()reserved(nil)operator(,) string<delimiter(')content(HKEY_USERS)delimiter(')>operator(\);) + +reserved(finalization) + ident(Reg)operator(.)ident(Free)operator(;) + ident(HKLMSpyKey)operator(.)ident(Free)operator(;) + ident(HKUSpyKey)operator(.)ident(Free)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(SisyphusTH)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Classes)operator(,) ident(StdCtrls)operator(,) ident(Dialogs)operator(,) ident(SysUtils)operator(,) ident(XReg)operator(,) ident(YTools)operator(,) ident(YTypes)operator(,) ident(Clock)operator(,) + ident(ComCtrls)operator(,) ident(PlutoConst)operator(,) ident(UniKey)operator(,) ident(CompEx)operator(;) + +reserved(const) + ident(SisyVersion) operator(=) string<delimiter(')content(1.2 b3)delimiter(')>operator(;) + ident(StatusPoints) operator(=) integer(25)operator(;) + +reserved(type) + ident(TSisyChangeType) operator(=) operator(()ident(cNone)operator(,) ident(cError)operator(,) + ident(cKeyPlus)operator(,) ident(cKeyMinus)operator(,) + ident(cValuePlus)operator(,) ident(cValueMinus)operator(,) + ident(cContextChange)operator(\);) + +reserved(const) + ident(SisyChangeStrings)operator(:) reserved(array)operator([)ident(TSisyChangeType)operator(]) reserved(of) reserved(string) operator(=) + operator(()char<delimiter(')content(?)delimiter(')>operator(,) string<delimiter(')content(Error)delimiter(')>operator(,) + string<delimiter(')content(cK+)delimiter(')>operator(,) string<delimiter(')content(cK-)delimiter(')>operator(,) + string<delimiter(')content(cV+)delimiter(')>operator(,) string<delimiter(')content(cV-)delimiter(')>operator(,) + string<delimiter(')content(cC)delimiter(')>operator(\);) + +reserved(type) + ident(TSpyValue) operator(=) reserved(class) + ident(Name)operator(:) reserved(string)operator(;) + ident(Next)operator(:) ident(TSpyValue)operator(;) + ident(Context)operator(:) ident(TRegContext)operator(;) + reserved(constructor) ident(Create)operator(()reserved(const) ident(Name)operator(:) reserved(string)operator(;) ident(Context)operator(:) ident(TRegContext)operator(\);) + reserved(end)operator(;) + + ident(TSisyThread) operator(=) reserved(class)operator(;) + + ident(TSpyKey) operator(=) reserved(class) + directive(public) + ident(Parent)operator(:) ident(TSpyKey)operator(;) + ident(Name)operator(:) reserved(string)operator(;) + ident(Next)operator(:) ident(TSpyKey)operator(;) + ident(Keys)operator(:) ident(TSpyKey)operator(;) + ident(Values)operator(:) ident(TSpyValue)operator(;) + reserved(procedure) ident(Spy)operator(()ident(AHKEY)operator(:) ident(HKEY)operator(;) ident(Sisy)operator(:) ident(TSisyThread)operator(\);) + reserved(function) ident(Path)operator(:) reserved(string)operator(;) + reserved(constructor) ident(Create)operator(()ident(AParent)operator(:) ident(TSpyKey)operator(;) ident(AName)operator(:) reserved(string)operator(\);) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(end)operator(;) + + ident(TSisyChange) operator(=) reserved(class) + directive(public) + ident(Typ)operator(:) ident(TSisyChangeType)operator(;) + ident(Path)operator(:) reserved(string)operator(;) + ident(Old)operator(,) ident(New)operator(:) ident(TRegContext)operator(;) + reserved(constructor) ident(Create)operator(()ident(ATyp)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(APath)operator(:) reserved(string)operator(;) + ident(AOldContext)operator(:) ident(TRegContext)operator(;) ident(ANewContext)operator(:) ident(TRegContext)operator(\);) + reserved(procedure) ident(ReportToPluto)operator(;) + reserved(end)operator(;) + + ident(TSisyChangeEvent) operator(=) reserved(procedure) operator(()ident(Sender)operator(:) ident(TSisyThread)operator(;) ident(Change)operator(:) ident(TSisyChange)operator(\)) reserved(of) reserved(object)operator(;) + ident(TSisyThread) operator(=) reserved(class)operator(()ident(TThread)operator(\)) + directive(private) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Key)operator(:) ident(TSpyKey)operator(;) + ident(KeyHKEY)operator(:) ident(HKEY)operator(;) + ident(CurrentChange)operator(:) ident(TSisyChange)operator(;) + ident(FOnChange)operator(:) ident(TSisyChangeEvent)operator(;) + ident(FOnSpecialChanges)operator(:) reserved(array)operator([)ident(TSisyChangeType)operator(]) reserved(of) ident(TSisyChangeEvent)operator(;) + reserved(procedure) ident(FreeKey)operator(;) + reserved(procedure) ident(IncKeyCount)operator(;) + reserved(procedure) ident(IncKeyIndex)operator(;) + reserved(function) ident(GetSpecialChange)operator(()ident(ChangeType)operator(:) ident(TSisyChangeType)operator(\):) ident(TSisyChangeEvent)operator(;) + reserved(procedure) ident(SetSpecialChange)operator(()ident(ChangeType)operator(:) ident(TSisyChangeType)operator(;) + reserved(const) ident(Value)operator(:) ident(TSisyChangeEvent)operator(\);) + directive(protected) + reserved(procedure) ident(AddValueChange)operator(()ident(Typ)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(Path)operator(:) reserved(string)operator(;) + ident(Old)operator(,) ident(New)operator(:) ident(TRegContext)operator(\);) + reserved(procedure) ident(AddKeyChange)operator(()ident(Typ)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(Path)operator(:) reserved(string)operator(\);) + reserved(procedure) ident(Execute)operator(;) directive(override)operator(;) + reserved(procedure) ident(ShowInfo)operator(;) + reserved(procedure) ident(NotifyChange)operator(;) + reserved(procedure) ident(ReportCurrentChange)operator(;) + directive(public) + ident(CurrentSpyKey)operator(:) ident(TSpyKey)operator(;) + ident(StatusLabel)operator(:) ident(TLabel)operator(;) + ident(Name)operator(:) reserved(string)operator(;) + ident(Started)operator(:) ident(Boolean)operator(;) + ident(DoReport)operator(:) ident(Boolean)operator(;) + ident(SecsPerRound)operator(:) ident(Double)operator(;) + ident(InfoForShow)operator(:) reserved(string)operator(;) + ident(OnStarted)operator(:) ident(TNotifyEvent)operator(;) + ident(KeyCount)operator(:) ident(Integer)operator(;) + ident(PrevKeyCount)operator(:) ident(Integer)operator(;) + ident(KeyIndex)operator(:) ident(Integer)operator(;) + ident(TheClock)operator(:) ident(TClock)operator(;) + ident(Uni)operator(:) ident(TUniKey)operator(;) + ident(MaxValueCountToScan)operator(,) ident(MaxKeyCountToScan)operator(,) ident(MaxDataLenToScan)operator(:) ident(Cardinal)operator(;) + reserved(constructor) ident(CreateIt)operator(()reserved(const) ident(AName)operator(,) ident(AKeyName)operator(:) reserved(string)operator(;) ident(AHKEY)operator(:) ident(HKEY)operator(;) + ident(ALabel)operator(:) ident(TLabel)operator(;) ident(AUniKey)operator(:) ident(TUniKey)operator(\);) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + + reserved(property) ident(OnChange)operator(:) ident(TSisyChangeEvent) directive(read) ident(FOnChange) directive(write) ident(FOnChange)operator(;) + reserved(property) ident(OnSpecialChange)operator([)ident(ChangeType)operator(:) ident(TSisyChangeType)operator(]:) ident(TSisyChangeEvent) + directive(read) ident(GetSpecialChange) directive(write) ident(SetSpecialChange)operator(;) + reserved(end)operator(;) + + ident(TSisyList) operator(=) reserved(class)operator(()ident(TList)operator(\)) + directive(protected) + reserved(function) ident(GetSisy)operator(()ident(Index)operator(:) ident(Integer)operator(\):) ident(TSisyThread)operator(;) + reserved(procedure) ident(PutSisy)operator(()ident(Index)operator(:) ident(Integer)operator(;) ident(Sisy)operator(:) ident(TSisyThread)operator(\);) + directive(public) + reserved(procedure) ident(Suspend)operator(;) + reserved(procedure) ident(Resume)operator(;) + reserved(property) ident(Items)operator([)ident(Index)operator(:) ident(Integer)operator(]:) ident(TSisyThread) directive(read) ident(GetSisy) directive(write) ident(PutSisy)operator(;) ident(default)operator(;) + reserved(end)operator(;) + +reserved(procedure) ident(SetSisyChangeState)operator(()ident(Node)operator(:) ident(TTreeNode)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(function) ident(SisyChangeActivated)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) + +reserved(var) + ident(SisyFilter)operator(:) ident(TStringList)operator(;) + +reserved(implementation) + +reserved(uses) ident(plutomain)operator(,) ident(workU)operator(,) ident(ValuesU)operator(;) + +reserved(procedure) ident(SetSisyChangeState)operator(()ident(Node)operator(:) ident(TTreeNode)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(begin) + ident(Node)operator(.)ident(Data) operator(:=) ident(Pointer)operator(()reserved(not) ident(Active)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(SisyChangeActivated)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Node)operator(.)ident(Data) operator(=) ident(Pointer)operator(()ident(False)operator(\);) +reserved(end)operator(;) + +comment({ TSisyThread }) + +reserved(constructor) ident(TSisyThread)operator(.)ident(CreateIt)operator(()reserved(const) ident(AName)operator(,) ident(AKeyName)operator(:) reserved(string)operator(;) + ident(AHKEY)operator(:) ident(HKEY)operator(;) ident(ALabel)operator(:) ident(TLabel)operator(;) ident(AUniKey)operator(:) ident(TUniKey)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(()ident(True)operator(\);) comment(// Create thread suspended) + + ident(Started) operator(:=) ident(False)operator(;) + ident(DoReport) operator(:=) ident(True)operator(;) + ident(KeyCount) operator(:=) integer(0)operator(;) + ident(FreeOnTerminate) operator(:=) ident(False)operator(;) comment(// Thread frees itself not when terminated) + + ident(KeyHKEY) operator(:=) ident(AHKEY)operator(;) + ident(Name) operator(:=) ident(AName)operator(;) + ident(StatusLabel) operator(:=) ident(ALabel)operator(;) + ident(StatusLabel)operator(.)ident(Caption) operator(:=) string<delimiter(')content(Zzzzzzz...)delimiter(')>operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + ident(TheClock) operator(:=) ident(TClock)operator(.)ident(Create)operator(;) + + ident(Uni) operator(:=) ident(AUniKey)operator(.)ident(GetKey)operator(()ident(Name)operator(\);) + ident(Priority) operator(:=) ident(TThreadPriority)operator(()ident(Uni)operator(.)ident(ReadInteger)operator(()string<delimiter(')content(Priority)delimiter(')>operator(,) ident(Integer)operator(()ident(tpLowest)operator(\)\)\);) + ident(PrevKeyCount) operator(:=) ident(Uni)operator(.)ident(ReadInteger)operator(()string<delimiter(')content(KeyCount)delimiter(')>operator(,) integer(0)operator(\);) + + ident(MaxKeyCountToScan) operator(:=) ident(Cardinal)operator(()ident(Uni)operator(.)ident(ReadInteger)operator(()string<delimiter(')content(ScanTuner: MaxKeys)delimiter(')>operator(,) operator(-)integer(1)operator(\)\);) + ident(MaxValueCountToScan) operator(:=) ident(Cardinal)operator(()ident(Uni)operator(.)ident(ReadInteger)operator(()string<delimiter(')content(ScanTuner: MaxValues)delimiter(')>operator(,) operator(-)integer(1)operator(\)\);) + ident(MaxDataLenToScan) operator(:=) ident(Cardinal)operator(()ident(Uni)operator(.)ident(ReadInteger)operator(()string<delimiter(')content(ScanTuner: MaxDataLen)delimiter(')>operator(,) operator(-)integer(1)operator(\)\);) + + ident(Key) operator(:=) ident(TSpyKey)operator(.)ident(Create)operator(()reserved(nil)operator(,) ident(AKeyName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(FreeKey)operator(;) +reserved(begin) + ident(Reg)operator(.)ident(Free)operator(;) + ident(TheClock)operator(.)ident(Free)operator(;) + ident(Key)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(destructor) ident(TSisyThread)operator(.)ident(Destroy)operator(;) +reserved(begin) + ident(Synchronize)operator(()ident(FreeKey)operator(\);) + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(Execute)operator(;) +reserved(begin) + ident(InfoForShow) operator(:=) ident(Name) operator(+) string<delimiter(')content( initializing...)delimiter(')>operator(;) + ident(Synchronize)operator(()ident(ShowInfo)operator(\);) + + ident(TheClock)operator(.)ident(Restart)operator(;) + ident(Started) operator(:=) ident(False)operator(;) + reserved(while) reserved(not) ident(Terminated) reserved(do) + reserved(try) + ident(KeyIndex) operator(:=) integer(0)operator(;) + + comment({ ===================== }) + ident(Key)operator(.)ident(Spy)operator(()ident(KeyHKEY)operator(,) ident(Self)operator(\);) + comment({ ===================== }) + + reserved(if) ident(Terminated) reserved(then) + ident(Continue)operator(;) comment(//= Exit) + + ident(SecsPerRound) operator(:=) ident(TheClock)operator(.)ident(SecondsPassed)operator(;) + ident(TheClock)operator(.)ident(Restart)operator(;) + reserved(if) reserved(not) ident(Started) reserved(then) reserved(begin) + ident(Started) operator(:=) ident(True)operator(;) + ident(Uni)operator(.)ident(WriteInteger)operator(()string<delimiter(')content(KeyCount)delimiter(')>operator(,) ident(KeyCount)operator(\);) + reserved(if) ident(Assigned)operator(()ident(OnStarted)operator(\)) reserved(then) + ident(OnStarted)operator(()ident(Self)operator(\);) + reserved(end)operator(;) + reserved(except) + ident(ShowMessage)operator(()string<delimiter(')content(Error in Sisyphus)delimiter(')>operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(AddValueChange)operator(()ident(Typ)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(Path)operator(:) reserved(string)operator(;) + ident(Old)operator(,) ident(New)operator(:) ident(TRegContext)operator(\);) + + reserved(procedure) ident(TryNotify)operator(()ident(Event)operator(:) ident(TSisyCHangeEvent)operator(\);) + reserved(begin) + + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) operator(()ident(Started) reserved(and) ident(DoReport)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(CurrentChange) operator(:=) ident(TSisyChange)operator(.)ident(Create)operator(()ident(Typ)operator(,) ident(Path)operator(,) ident(Old)operator(,) ident(New)operator(\);) + ident(Synchronize)operator(()ident(ReportCurrentChange)operator(\);) + ident(Synchronize)operator(()ident(NotifyChange)operator(\);) + +comment(// CurrentChange.Free; //this makes Pluto itself) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(AddKeyChange)operator(()ident(Typ)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(Path)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(AddValueChange)operator(()ident(Typ)operator(,) ident(Path)operator(,) ident(ZeroRegContext)operator(,) ident(ZeroRegContext)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(ShowInfo)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(StatusLabel)operator(\)) reserved(then) + ident(StatusLabel)operator(.)ident(Caption) operator(:=) ident(InfoForShow)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(ReportCurrentChange)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(CurrentChange)operator(\)) reserved(then) + ident(CurrentChange)operator(.)ident(ReportToPluto)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(IncKeyCount)operator(;) +reserved(var) + ident(c)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Started) reserved(then) + ident(Exit)operator(;) + + ident(Inc)operator(()ident(KeyCount)operator(\);) + + reserved(if) operator(()ident(KeyCount) reserved(and) hex($1FF)operator(\)) operator(=) integer(0) reserved(then) reserved(begin) + reserved(if) ident(KeyCount) operator(>) ident(PrevKeyCount) reserved(then) + ident(PrevKeyCount) operator(:=) ident(KeyCount)operator(;) + + ident(c) operator(:=) integer(0)operator(;) + reserved(if) ident(PrevkeyCount) operator(>) integer(0) reserved(then) + ident(c) operator(:=) ident(Round)operator((()ident(KeyCount) operator(*) ident(StatusPoints)operator(\)) operator(/) ident(PrevKeyCount)operator(\);) + ident(InfoForShow) operator(:=) char<delimiter(')content(|)delimiter(')> operator(+) ident(MulStr)operator(()char<delimiter(')content(.)delimiter(')>operator(,) ident(c)operator(\)) operator(+) ident(MulStr)operator(()char<delimiter(')content( )delimiter(')>operator(,) ident(StatusPoints) operator(-) ident(c)operator(\)) operator(+) char<delimiter(')content(|)delimiter(')> operator(+) + ident(Format)operator(()string<delimiter(')content( (%0.1f s\) %d/%d k )delimiter(')>operator(,) + operator([)ident(TheClock)operator(.)ident(SecondsPassed)operator(,) ident(KeyCount)operator(,) ident(PrevKeyCount)operator(]\);) + + ident(Synchronize)operator(()ident(ShowInfo)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(IncKeyIndex)operator(;) +reserved(var) + ident(c)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + + ident(Inc)operator(()ident(KeyIndex)operator(\);) + + reserved(if) operator((()ident(KeyIndex) reserved(and) hex($1FF)operator(\)) operator(=) integer(0)operator(\)) reserved(and) operator(()ident(KeyCount) operator(>) integer(0)operator(\)) reserved(then) reserved(begin) + reserved(if) ident(KeyIndex) operator(>) ident(KeyCount) reserved(then) + ident(KeyCount) operator(:=) ident(KeyIndex)operator(;) + + ident(c) operator(:=) integer(0)operator(;) + reserved(if) ident(KeyCount) operator(>) integer(0) reserved(then) + ident(c) operator(:=) ident(Round)operator((()ident(KeyIndex) operator(*) ident(StatusPoints)operator(\)) operator(/) ident(KeyCount)operator(\);) + + ident(InfoForShow) operator(:=) char<delimiter(')content(|)delimiter(')> operator(+) ident(MulStr)operator(()char<delimiter(')content(:)delimiter(')>operator(,) ident(c)operator(\)) operator(+) ident(MulStr)operator(()char<delimiter(')content(.)delimiter(')>operator(,) ident(StatusPoints) operator(-) ident(c)operator(\)) operator(+) char<delimiter(')content(|)delimiter(')> operator(+) + ident(Format)operator(()string<delimiter(')content( (%0.1f s\) %d/%d k )delimiter(')>operator(,) operator([)ident(SecsPerRound)operator(,) ident(KeyIndex)operator(,) ident(KeyCount)operator(]\);) + + ident(Synchronize)operator(()ident(ShowInfo)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TSisyThread)operator(.)ident(GetSpecialChange)operator(()ident(ChangeType)operator(:) ident(TSisyChangeType)operator(\):) + ident(TSisyChangeEvent)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(FOnSpecialChanges)operator([)ident(ChangeType)operator(];) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(SetSpecialChange)operator(()ident(ChangeType)operator(:) ident(TSisyChangeType)operator(;) + reserved(const) ident(Value)operator(:) ident(TSisyChangeEvent)operator(\);) +reserved(begin) + ident(FOnSpecialChanges)operator([)ident(ChangeType)operator(]) operator(:=) ident(Value)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyThread)operator(.)ident(NotifyChange)operator(;) +reserved(var) + ident(Event)operator(:) ident(TSisyChangeEvent)operator(;) +reserved(begin) + ident(Event) operator(:=) ident(FOnSpecialChanges)operator([)ident(CurrentChange)operator(.)ident(Typ)operator(];) + reserved(if) ident(Assigned)operator(()ident(Event)operator(\)) reserved(then) + ident(Event)operator(()ident(Self)operator(,) ident(CurrentChange)operator(\);) + + reserved(if) ident(Assigned)operator(()ident(FOnChange)operator(\)) reserved(then) + ident(FOnChange)operator(()ident(Self)operator(,) ident(CurrentChange)operator(\);) +reserved(end)operator(;) + +comment({ TSpyValue }) + +reserved(constructor) ident(TSpyValue)operator(.)ident(Create)operator(()reserved(const) ident(Name)operator(:) reserved(string)operator(;) ident(Context)operator(:) ident(TRegContext)operator(\);) +reserved(begin) + ident(Self)operator(.)ident(Name) operator(:=) ident(Name)operator(;) + ident(Next) operator(:=) reserved(nil)operator(;) + ident(Self)operator(.)ident(Context) operator(:=) ident(Context)operator(;) +reserved(end)operator(;) + +comment({ TSpyKey }) + +reserved(constructor) ident(TSpyKey)operator(.)ident(Create)operator(()ident(AParent)operator(:) ident(TSpyKey)operator(;) ident(AName)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(Name) operator(:=) ident(AName)operator(;) + ident(Parent) operator(:=) ident(AParent)operator(;) + + ident(Next) operator(:=) reserved(nil)operator(;) + ident(Keys) operator(:=) reserved(nil)operator(;) + ident(Values) operator(:=) reserved(nil)operator(;) +reserved(end)operator(;) + +reserved(destructor) ident(TSpyKey)operator(.)ident(Destroy)operator(;) +reserved(var) + ident(Value)operator(,) ident(NextValue)operator(:) ident(TSpyValue)operator(;) + ident(Key)operator(,) ident(NextKey)operator(:) ident(TSpyKey)operator(;) +reserved(begin) + ident(Value) operator(:=) ident(Values)operator(;) + reserved(while) ident(Assigned)operator(()ident(Value)operator(\)) reserved(do) reserved(begin) + ident(NextValue) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + ident(Value)operator(.)ident(Free)operator(;) + ident(Value) operator(:=) ident(NextValue)operator(;) + reserved(end)operator(;) + + ident(Key) operator(:=) ident(Keys)operator(;) + reserved(while) ident(Assigned)operator(()ident(Key)operator(\)) reserved(do) reserved(begin) + ident(NextKey) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + ident(Key)operator(.)ident(Free)operator(;) + ident(Key) operator(:=) ident(NextKey)operator(;) + reserved(end)operator(;) + + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TSpyKey)operator(.)ident(Path)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Parent)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Parent)operator(.)ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> + reserved(else) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(Result) operator(:=) ident(Result) operator(+) ident(Name)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSpyKey)operator(.)ident(Spy)operator(()ident(AHKEY)operator(:) ident(HKEY)operator(;) ident(Sisy)operator(:) ident(TSisyThread)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(LastKey)operator(:) ident(TSpyKey)operator(;) + + reserved(procedure) ident(CompareValues)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Value)operator(,) ident(LastValue)operator(,) ident(NewValue)operator(,) ident(SearchValue)operator(,) ident(SearchValue_Prev)operator(:) ident(TSpyValue)operator(;) + reserved(begin) + comment(//OK, this part is a little bit complicate. So I will comment very much.) + comment(//First, two terms are important:) + comment(//<REAL> means the list of values that will be read from the registry now:) + ident(Sisy)operator(.)ident(Reg)operator(.)ident(GetValueNames)operator(()ident(SL)operator(\);) + reserved(if) ident(Cardinal)operator(()ident(SL)operator(.)ident(Count)operator(\)) operator(>) ident(Sisy)operator(.)ident(MaxValueCountToScan) reserved(then) + ident(Exit)operator(;) + comment(//So <REAL> is TStringList.) + + comment(//<CURRENT> means the image that was saved before.) + comment(//Here, it is a linear list of TSpyValue objects. That means that you can) + comment(//only get X.Next and not X.Prev! However, I use "X.Prev" to simplify) + comment(//some comments.) + + comment(//!!! Comparing means: Make <CURRENT> fit <REAL> !!!) + + comment(//If <CURRENT> wasn't saved before, it is just empty.) + + comment(//!!! There is no difference in comparing and saving in this method !!!) + + comment(//Building means: Comparing with an empty image.) + + comment(//We go through <REAL> and make <CURRENT> fit it) + + comment(//The following rules are important:) + comment(//Value = "The currently interesting value.) + comment(//LastValue = "The value with X.Next = Value" = "Value.Pref") + + ident(LastValue) operator(:=) reserved(nil)operator(;) comment(// := "Values.Prev") + ident(Value) operator(:=) ident(Values)operator(;) comment(// := "LastValue.Next") + + comment(//Now compare step by step) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Value)operator(\)) reserved(and) operator(()ident(SL)operator([)ident(i)operator(]) operator(=) ident(Value)operator(.)ident(Name)operator(\)) reserved(then) reserved(begin) + comment(//cV= Normally (0.9999\) everything's the same) + ident(LastValue) operator(:=) ident(Value)operator(;) + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + reserved(end) reserved(else) reserved(begin) comment(//Something's different? Yes, the IMPORTANT rest (0.0001\)\)) + comment(//Because the list finally must exactly fit SL, the "SL[i] value" hast) + comment(//to be inserted right here. But first let's look...) + + comment(//Maybe it was just moved? So search for it...) + ident(NewValue) operator(:=) reserved(nil)operator(;) + reserved(if) ident(Assigned)operator(()ident(Value)operator(\)) reserved(then) reserved(begin) + ident(SearchValue_Prev) operator(:=) ident(Value)operator(;) + ident(SearchValue) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + reserved(while) ident(Assigned)operator(()ident(SearchValue)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(SearchValue)operator(.)ident(Name) operator(=) ident(SL)operator([)ident(i)operator(]) reserved(then) reserved(begin) comment(//we found our moved value) + ident(SearchValue_Prev)operator(.)ident(Next) operator(:=) ident(SearchValue)operator(.)ident(Next)operator(;) comment(//delete it from <CURRENT>) + ident(NewValue) operator(:=) ident(SearchValue)operator(;) comment(//save that we found it) + ident(Break) reserved(end)operator(;) + ident(SearchValue_Prev) operator(:=) ident(SearchValue)operator(;) + ident(SearchValue) operator(:=) ident(SearchValue)operator(.)ident(Next)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(NewValue)operator(\)) reserved(then) reserved(begin) + comment(//cV+ No, not found! So it is new...) + ident(NewValue) operator(:=) ident(TSpyValue)operator(.)ident(Create)operator(()ident(SL)operator([)ident(i)operator(],) ident(Sisy)operator(.)ident(Reg)operator(.)ident(ReadContext)operator(()ident(SL)operator([)ident(i)operator(]\)\);) + comment({ ================ cV+ ================ }) + reserved(if) ident(Sisy)operator(.)ident(Started) reserved(and) ident(Sisy)operator(.)ident(Reg)operator(.)ident(ValueReallyExists)operator(()ident(SL)operator([)ident(i)operator(]\)) reserved(then) + ident(Sisy)operator(.)ident(AddValueChange)operator(()ident(cValuePlus)operator(,) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(NewValue)operator(.)ident(Name)operator(,) + ident(ZeroRegContext)operator(,) ident(NewValue)operator(.)ident(Context)operator(\);) + reserved(end)operator(;) + + comment(//The new object now must be placed after the last value) + reserved(if) ident(Assigned)operator(()ident(LastValue)operator(\)) reserved(then) + ident(LastValue)operator(.)ident(Next) operator(:=) ident(NewValue) + reserved(else) + comment(//If it's the first value, we don't have LastValue defined) + comment(//So we have to set the "Root" to it) + ident(Values) operator(:=) ident(NewValue)operator(;) + + comment(//Now the rest of <CURRENT> has to be placed after the new value) + ident(NewValue)operator(.)ident(Next) operator(:=) ident(Value)operator(;) + comment(//And LastValue also has to refreshed: It is "Value.Pref" = NewValue!) + ident(LastValue) operator(:=) ident(NewValue)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//Because the whole <CURRENT> before Value is exactly <REAL>, the rest) + comment(//(if there is one\) must have been deleted!) + + comment(//So first let's ensure that <CURRENT> ends here:) + reserved(if) ident(Assigned)operator(()ident(LastValue)operator(\)) reserved(then) + ident(LastValue)operator(.)ident(Next) operator(:=) reserved(nil) + reserved(else) + comment(//Another time: <CURRENT> is empty now, so set Values instead) + ident(Values) operator(:=) reserved(nil)operator(;) + + comment(//Now, the first value that maybe was "cut" off is Value:) + reserved(while) ident(Assigned)operator(()ident(Value)operator(\)) reserved(do) reserved(begin) + comment(//cV- So, here really something HAS been deleted) + ident(LastValue) operator(:=) ident(Value)operator(;) + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + comment({ ================ cV- ================ }) + reserved(if) ident(Sisy)operator(.)ident(Started) reserved(and) reserved(not) ident(Sisy)operator(.)ident(Reg)operator(.)ident(ValueReallyExists)operator(()ident(LastValue)operator(.)ident(Name)operator(\)) reserved(then) + ident(Sisy)operator(.)ident(AddValueChange)operator(()ident(cValueMinus)operator(,) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(LastValue)operator(.)ident(Name)operator(,) + ident(LastValue)operator(.)ident(Context)operator(,) ident(ZeroRegContext)operator(\);) + ident(LastValue)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(CompareData)operator(;) + reserved(var) + ident(Value)operator(:) ident(TSpyValue)operator(;) + ident(Context)operator(:) ident(TRegContext)operator(;) + ident(Size)operator(:) ident(Cardinal)operator(;) + reserved(begin) + ident(Context) operator(:=) ident(ZeroRegContext)operator(;) comment(//Initialize) + comment(//So, finally <CURRENT> = <REAL>. That means we now can compare the data:) + ident(Value) operator(:=) ident(Values)operator(;) + reserved(while) ident(Assigned)operator(()ident(Value)operator(\)) reserved(and) reserved(not) ident(Sisy)operator(.)ident(Terminated) reserved(do) reserved(begin) + ident(Size) operator(:=) ident(Sisy)operator(.)ident(Reg)operator(.)ident(GetDataSize)operator(()ident(Value)operator(.)ident(Name)operator(\);) + reserved(if) operator(()ident(Size) operator(=) ident(Cardinal)operator((-)integer(1)operator(\)\)) reserved(or) + operator(()ident(Size) operator(<=) ident(Sisy)operator(.)ident(MaxDataLenToScan)operator(\)) reserved(then) reserved(begin) + ident(Context) operator(:=) ident(Sisy)operator(.)ident(Reg)operator(.)ident(ReadContext)operator(()ident(Value)operator(.)ident(Name)operator(\);) + reserved(if) reserved(not) ident(SameContext)operator(()ident(Context)operator(,) ident(Value)operator(.)ident(Context)operator(\)) reserved(then) reserved(begin) + comment({ ================ cC ================ }) + ident(Sisy)operator(.)ident(AddValueChange)operator(()ident(cContextChange)operator(,) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(Value)operator(.)ident(Name)operator(,) + ident(Value)operator(.)ident(Context)operator(,) ident(Context)operator(\);) + ident(Value)operator(.)ident(Context) operator(:=) ident(Context)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(Value) operator(:=) ident(Value)operator(.)ident(Next)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(CompareKeys)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Key)operator(,) ident(LastKey)operator(,) ident(NewKey)operator(,) ident(SearchKey)operator(,) ident(SearchKey_Prev)operator(:) ident(TSpyKey)operator(;) + ident(SavedDoReport)operator(:) ident(Boolean)operator(;) + ident(NewHKEY)operator(:) ident(HKEY)operator(;) + reserved(begin) + comment(//OK, this part is a little bit complicate. So I will comment very much.) + comment(//First, two terms are important:) + comment(//<REAL> means the list of keys that will be read from the registry now:) + + ident(Sisy)operator(.)ident(Reg)operator(.)ident(GetKeyNames)operator(()ident(SL)operator(\);) + reserved(if) ident(Cardinal)operator(()ident(SL)operator(.)ident(Count)operator(\)) operator(>) ident(Sisy)operator(.)ident(MaxKeyCountToScan) reserved(then) + ident(Exit)operator(;) + comment(//So <REAL> is TStringList.) + + comment(//<CURRENT> means the image that was saved before.) + comment(//Here, it is a linear list of TSpyKey objects. That means that you can) + comment(//only get X.Next and not X.Prev! However, I use "X.Prev" to simplify) + comment(//some comments.) + + comment(//!!! Comparing means: Make <CURRENT> fit <REAL> !!!) + + comment(//If <CURRENT> wasn't saved before, it is just empty.) + + comment(//!!! There is no difference in comparing and saving in this method !!!) + + comment(//Building means: Comparing with an empty image.) + + comment(//We go through <REAL> and make <CURRENT> fit it) + + comment(//The following rules are important:) + comment(//Key = "The currently interesting key.) + comment(//LastKey = "The key with X.Next = Key" = "Key.Pref") + + ident(LastKey) operator(:=) reserved(nil)operator(;) comment(// := "Keys.Prev") + ident(Key) operator(:=) ident(Keys)operator(;) comment(// := "LastKey.Next") + + comment(//Now compare step by step) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Key)operator(\)) reserved(and) operator(()ident(SL)operator([)ident(i)operator(]) operator(=) ident(Key)operator(.)ident(Name)operator(\)) reserved(then) reserved(begin) + comment(//cK= Normally (0.9999\) everything's the same) + reserved(if) ident(Success)operator(()ident(RegOpenKey)operator(()ident(AHKEY)operator(,) ident(PChar)operator(()ident(SL)operator([)ident(i)operator(]\),) ident(NewHKEY)operator(\)\)) reserved(then) + reserved(try) + ident(Key)operator(.)ident(Spy)operator(()ident(NewHKEY)operator(,) ident(Sisy)operator(\);) + reserved(finally) + ident(RegCloseKey)operator(()ident(NewHKEY)operator(\);) + reserved(end)operator(;) + reserved(if) ident(Sisy)operator(.)ident(Terminated) reserved(then) + ident(Exit)operator(;) + + ident(LastKey) operator(:=) ident(Key)operator(;) + ident(Key) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + reserved(end) reserved(else) reserved(begin) comment(//Something's different? Yes, the IMPORTANT rest (0.0001\)\)) + comment(//Because the list finally must exactly fit SL, the "SL[i] key" has) + comment(//to be inserted right here. But first let's look...) + + comment(//Maybe it was just moved? So search for it...) + ident(NewKey) operator(:=) reserved(nil)operator(;) + reserved(if) ident(Assigned)operator(()ident(Key)operator(\)) reserved(then) reserved(begin) + ident(SearchKey_Prev) operator(:=) ident(Key)operator(;) + ident(SearchKey) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + reserved(while) ident(Assigned)operator(()ident(SearchKey)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(SearchKey)operator(.)ident(Name) operator(=) ident(SL)operator([)ident(i)operator(]) reserved(then) reserved(begin) comment(//we found our moved key) + ident(SearchKey_Prev)operator(.)ident(Next) operator(:=) ident(SearchKey)operator(.)ident(Next)operator(;) comment(//delete it from <CURRENT>) + ident(NewKey) operator(:=) ident(SearchKey)operator(;) comment(//save that we found it) + ident(Break) reserved(end)operator(;) + ident(SearchKey_Prev) operator(:=) ident(SearchKey)operator(;) + ident(SearchKey) operator(:=) ident(SearchKey)operator(.)ident(Next)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(NewKey)operator(\)) reserved(then) reserved(begin) comment(//if we didn't find it) + comment(//cK+ No, not found! So it is new...) + ident(NewKey) operator(:=) ident(TSpyKey)operator(.)ident(Create)operator(()ident(Self)operator(,) ident(SL)operator([)ident(i)operator(]\);) + ident(Sisy)operator(.)ident(IncKeyCount)operator(;) + ident(Sisy)operator(.)ident(Reg)operator(.)ident(CurrentKey) operator(:=) ident(AHKEY)operator(;) + comment({ ================ cK+ ================ }) + reserved(if) ident(Sisy)operator(.)ident(Started) reserved(and) ident(Sisy)operator(.)ident(Reg)operator(.)ident(KeyExists)operator(()ident(SL)operator([)ident(i)operator(]\)) reserved(then) + ident(Sisy)operator(.)ident(AddKeyChange)operator(()ident(cKeyPlus)operator(,) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(NewKey)operator(.)ident(Name)operator(\);) + + ident(SavedDoReport) operator(:=) ident(Sisy)operator(.)ident(DoReport)operator(;) + reserved(if) ident(Success)operator(()ident(RegOpenKey)operator(()ident(AHKEY)operator(,) ident(PChar)operator(()ident(SL)operator([)ident(i)operator(]\),) ident(NewHKEY)operator(\)\)) reserved(then) + reserved(try) + ident(Sisy)operator(.)ident(DoReport) operator(:=) ident(False)operator(;) + ident(NewKey)operator(.)ident(Spy)operator(()ident(NewHKEY)operator(,) ident(Sisy)operator(\);) comment(//<-- recursion itself) + reserved(finally) + ident(RegCloseKey)operator(()ident(NewHKEY)operator(\);) + ident(Sisy)operator(.)ident(DoReport) operator(:=) ident(SavedDoReport)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Sisy)operator(.)ident(Terminated) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + + comment(//The new key now must be placed after the last key) + reserved(if) ident(Assigned)operator(()ident(LastKey)operator(\)) reserved(then) + ident(LastKey)operator(.)ident(Next) operator(:=) ident(NewKey) + reserved(else) + comment(//If it's the first key, we don't have LastKey defined) + comment(//So we have to set the "Root" to it) + ident(Keys) operator(:=) ident(NewKey)operator(;) + + comment(//Now the rest of <CURRENT> has to be placed after the new key) + ident(NewKey)operator(.)ident(Next) operator(:=) ident(Key)operator(;) + comment(//And LastKey also has to refreshed: It is "Key.Pref" = NewKey!) + ident(LastKey) operator(:=) ident(NewKey)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//Because the whole <CURRENT> before Key is exactly <REAL>, the rest) + comment(//(if there is one\) must have been deleted!) + + comment(//So first let's ensure that <CURRENT> ends here:) + reserved(if) ident(Assigned)operator(()ident(LastKey)operator(\)) reserved(then) + ident(LastKey)operator(.)ident(Next) operator(:=) reserved(nil) + reserved(else) + comment(//Another time: <CURRENT> is empty now, so set Keys instead) + ident(Keys) operator(:=) reserved(nil)operator(;) + + comment(//Now, the first key that maybe was "cut" off is Key:) + reserved(while) ident(Assigned)operator(()ident(Key)operator(\)) reserved(do) reserved(begin) + comment(//cV- So, here really something HAS been deleted) + ident(LastKey) operator(:=) ident(Key)operator(;) + ident(Key) operator(:=) ident(Key)operator(.)ident(Next)operator(;) + ident(Sisy)operator(.)ident(Reg)operator(.)ident(CurrentKey) operator(:=) ident(AHKEY)operator(;) + comment({ ================ cK- ================ }) + reserved(if) ident(Sisy)operator(.)ident(Started) reserved(and) reserved(not) ident(Sisy)operator(.)ident(Reg)operator(.)ident(KeyExists)operator(()ident(LastKey)operator(.)ident(Name)operator(\)) reserved(then) + ident(Sisy)operator(.)ident(AddKeyChange)operator(()ident(cKeyMinus)operator(,) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(LastKey)operator(.)ident(Name)operator(\);) + ident(LastKey)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + +reserved(begin) + reserved(if) ident(Sisy)operator(.)ident(Terminated) reserved(or) operator(()ident(AHKEY) operator(=) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + ident(LastKey) operator(:=) ident(Sisy)operator(.)ident(CurrentSpyKey)operator(;) + ident(Sisy)operator(.)ident(CurrentSpyKey) operator(:=) ident(Self)operator(;) + + ident(Sisy)operator(.)ident(IncKeyIndex)operator(;) + + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(Sisy)operator(.)ident(Reg)operator(.)ident(CurrentKey) operator(:=) ident(AHKEY)operator(;) + ident(CompareValues)operator(;) + reserved(if) ident(Sisy)operator(.)ident(Started) reserved(then) ident(CompareData)operator(;) + ident(CompareKeys)operator(;) + reserved(finally) + ident(Sisy)operator(.)ident(Reg)operator(.)ident(CurrentKey) operator(:=) integer(0)operator(;) + ident(SL)operator(.)ident(Free)operator(;) + ident(Sisy)operator(.)ident(CurrentSpyKey) operator(:=) ident(LastKey)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +comment({ TSisyChange }) + +reserved(constructor) ident(TSisyChange)operator(.)ident(Create)operator(()ident(ATyp)operator(:) ident(TSisyChangeType)operator(;) reserved(const) ident(APath)operator(:) reserved(string)operator(;) + ident(AOldContext)operator(:) ident(TRegContext)operator(;) ident(ANewContext)operator(:) ident(TRegContext)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(;) + ident(Typ) operator(:=) ident(ATyp)operator(;) + ident(Path) operator(:=) ident(APath)operator(;) + ident(Old) operator(:=) ident(AOldContext)operator(;) + ident(New) operator(:=) ident(ANewContext)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyChange)operator(.)ident(ReportToPluto)operator(;) +reserved(var) + ident(Node)operator(,) ident(RootNode)operator(:) ident(TTreeNode)operator(;) + ident(Root)operator(,) ident(SubPath)operator(:) reserved(string)operator(;) + ident(NewNode)operator(:) ident(Boolean)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(function) ident(IconOfSisyChangeType)operator(()ident(Typ)operator(:) ident(TSisyChangeType)operator(\):) ident(Integer)operator(;) + reserved(begin) + ident(Result) operator(:=) operator(-)integer(1)operator(;) + reserved(case) ident(Typ) reserved(of) + comment(//cNone, cError: Result := -1;) + ident(cKeyPlus)operator(..)ident(cContextChange)operator(:) ident(Result) operator(:=) ident(Integer)operator(()ident(Typ)operator(\)) operator(-) integer(2)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(function) ident(FindNode)operator(()ident(Text)operator(:) reserved(string)operator(\):) ident(TTreeNode)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(WorkWin)operator(.)ident(SisyTV)operator(.)ident(Items)operator(.)ident(GetFirstNode)operator(;) + reserved(while) ident(Assigned)operator(()ident(Result)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(SameText)operator(()ident(Result)operator(.)ident(Text)operator(,) ident(Text)operator(\)) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) ident(Result)operator(.)ident(GetNextSibling)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) ident(WorkWin)operator(.)ident(SisyListCB)operator(.)ident(Checked) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Typ) reserved(in) operator([)ident(cContextChange)operator(,) ident(cValueMinus)operator(,) ident(cValuePlus)operator(]) reserved(then) reserved(begin) + ident(Root) operator(:=) ident(ExRegFullKey)operator(()ident(Path)operator(\);) + ident(SubPath) operator(:=) ident(ExRegValue)operator(()ident(Path)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Root) operator(:=) ident(UntilLastChar)operator(()ident(ExRegFullKey)operator(()ident(Path)operator(\),) char<delimiter(')content(\\)delimiter(')>operator(\);) + ident(SubPath) operator(:=) ident(FromLastChar)operator(()ident(ExRegFullKey)operator(()ident(Path)operator(\),) char<delimiter(')content(\\)delimiter(')>operator(\);) + reserved(end)operator(;) + + reserved(with) ident(WorkWin) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SisyFilter)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(TextAtPos)operator(()ident(Root)operator(,) integer(1)operator(,) ident(SisyFilter)operator([)ident(i)operator(]\)) reserved(then) reserved(begin) + comment(//show that it's working) + reserved(with) ident(FilterChangesB) reserved(do) reserved(begin) + ident(Caption) operator(:=) string<delimiter(')content(Filter..!)delimiter(')>operator(;) + ident(Repaint)operator(;) + ident(Caption) operator(:=) string<delimiter(')content(Filter...)delimiter(')>operator(;) + ident(Repaint)operator(;) + reserved(end)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + reserved(with) ident(WorkWin)operator(.)ident(SisyTV)operator(.)ident(Items) reserved(do) reserved(begin) + ident(BeginUpdate)operator(;) + reserved(try) + ident(RootNode) operator(:=) ident(FindNode)operator(()ident(Root)operator(\);) + ident(NewNode) operator(:=) reserved(not) ident(Assigned)operator(()ident(RootNode)operator(\);) + reserved(if) ident(NewNode) reserved(then) reserved(begin) + ident(RootNode) operator(:=) ident(AddChild)operator(()reserved(nil)operator(,) ident(Root)operator(\);) + ident(RootNode)operator(.)ident(ImageIndex) operator(:=) ident(iconGroup)operator(;) + reserved(end) reserved(else) reserved(if) reserved(not) ident(SisyChangeActivated)operator(()ident(RootNode)operator(\)) reserved(then) reserved(begin) + ident(EndUpdate)operator(;) + ident(Exit) reserved(end)operator(;) + + ident(Node) operator(:=) ident(AddChildObject)operator(()ident(RootNode)operator(,) ident(SubPath)operator(,) ident(Self)operator(\);) + ident(Node)operator(.)ident(ImageIndex) operator(:=) ident(IconOfSisyChangeType)operator(()ident(Typ)operator(\);) + reserved(if) ident(Typ) operator(=) ident(cContextChange) reserved(then) reserved(begin) + ident(AddChild)operator(()ident(Node)operator(,) ident(DataPreviewOfContext)operator(()ident(Old)operator(\)\).)ident(ImageIndex) operator(:=) ident(iconOldContext)operator(;) + ident(AddChild)operator(()ident(Node)operator(,) ident(DataPreviewOfContext)operator(()ident(New)operator(\)\).)ident(ImageIndex) operator(:=) ident(iconNewContext)operator(;) + reserved(end)operator(;) + reserved(finally) + ident(EndUpdate)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(NewNode) reserved(and) ident(WorkWin)operator(.)ident(SisyExpandGroupsCB)operator(.)ident(Checked) reserved(then) + ident(RootNode)operator(.)ident(Expand)operator(()ident(False)operator(\);) + + reserved(if) reserved(not) ident(RootNode)operator(.)ident(Expanded) reserved(then) + ident(RootNode)operator(.)ident(ImageIndex) operator(:=) ident(iconGroupBlinking)operator(;) +reserved(end)operator(;) + +comment({ TSisyList }) + +reserved(function) ident(TSisyList)operator(.)ident(GetSisy)operator(()ident(Index)operator(:) ident(Integer)operator(\):) ident(TSisyThread)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Get)operator(()ident(Index)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyList)operator(.)ident(PutSisy)operator(()ident(Index)operator(:) ident(Integer)operator(;) ident(Sisy)operator(:) ident(TSisyThread)operator(\);) +reserved(begin) + ident(Put)operator(()ident(Index)operator(,) ident(Sisy)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyList)operator(.)ident(Resume)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(Items)operator([)ident(i)operator(].)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSisyList)operator(.)ident(Suspend)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(Items)operator([)ident(i)operator(].)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(initialization) + ident(SisyFilter) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(SisyFilter)operator(.)ident(Sorted) operator(:=) ident(True)operator(;) + ident(SisyFilter)operator(.)ident(Duplicates) operator(:=) ident(dupIgnore)operator(;) + +reserved(finalization) + ident(SisyFilter)operator(.)ident(Free)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(splash)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) ident(Dialogs)operator(,) + ident(ExtCtrls)operator(,) ident(StdCtrls)operator(,) ident(ImgList)operator(,) ident(YTools)operator(,) ident(IniFiles)operator(,) ident(LinkLabel)operator(,) ident(PrefTools)operator(,) + ident(PlutoConst)operator(;) + +reserved(type) + ident(TSplashWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(Image1)operator(:) ident(TImage)operator(;) + ident(StartB)operator(:) ident(TButton)operator(;) + ident(SplashScreenCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(LinkLabel1)operator(:) ident(TLinkLabel)operator(;) + ident(LinkLabel2)operator(:) ident(TLinkLabel)operator(;) + ident(LogoL)operator(:) ident(TLabel)operator(;) + reserved(procedure) ident(StartBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormHide)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(SplashScreenCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(end)operator(;) + +reserved(var) + ident(SplashWin)operator(:) ident(TSplashWin)operator(;) + +reserved(implementation) + +reserved(uses) ident(plutomain)operator(,) ident(TreeU)operator(,) ident(WorkU)operator(,) ident(PrefU)operator(;) + +preprocessor({$R *.DFM}) + +reserved(procedure) ident(TSplashWin)operator(.)ident(StartBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Close)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSplashWin)operator(.)ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(const) + ident(Messages)operator(:) reserved(array)operator([)integer(0)operator(..)integer(12)operator(]) reserved(of) reserved(string) operator(=) operator(()string<delimiter(')content(Let)char('')content(s see...)delimiter(')>operator(,) + string<delimiter(')content(Ready)delimiter(')>operator(,) + string<delimiter(')content(Hello World!)delimiter(')>operator(,) + string<delimiter(')content(Start)delimiter(')>operator(,) + string<delimiter(')content(OK)delimiter(')>operator(,) + string<delimiter(')content(Pluto!)delimiter(')>operator(,) + string<delimiter(')content(Go Go Go)delimiter(')>operator(,) + string<delimiter(')content(Everything)char('')content(s OK)delimiter(')>operator(,) + string<delimiter(')content(Yes!)delimiter(')>operator(,) + string<delimiter(')content(God save the Queen)delimiter(')>operator(,) + string<delimiter(')content(Oh yeah)delimiter(')>operator(,) + string<delimiter(')content(Yabadabadoo!)delimiter(')>operator(,) + string<delimiter(')content(Don)char('')content(t worry, be happy!)delimiter(')> + operator(\);) +reserved(var) + ident(ImageFile)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Left) operator(:=) operator(()ident(Screen)operator(.)ident(Width) operator(-) ident(Width)operator(\)) reserved(div) integer(2)operator(;) + ident(Top) operator(:=) operator(()ident(Screen)operator(.)ident(Height) operator(-) ident(Height)operator(\)) reserved(div) integer(2)operator(;) + + ident(StartB)operator(.)ident(Caption) operator(:=) ident(Messages)operator([)ident(Random)operator(()ident(Length)operator(()ident(Messages)operator(\)\)];) + ident(SplashWin)operator(.)ident(SplashScreenCB)operator(.)ident(Load)operator(;) + + ident(Caption) operator(:=) string<delimiter(')content(cYcnus.Pluto )delimiter(')> operator(+) ident(Version) operator(+) string<delimiter(')content( says )delimiter(')> operator(+) ident(MainWin)operator(.)ident(Greeting)operator(;) + + reserved(try) + ident(ImageFile) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(logo deluxe.bmp)delimiter(')>operator(;) + reserved(if) ident(FileEx)operator(()ident(ImageFile)operator(\)) reserved(then) reserved(begin) + reserved(with) ident(Image1)operator(.)ident(Picture) reserved(do) + reserved(if) ident(Graphic) operator(=) reserved(nil) reserved(then) + ident(LoadFromFile)operator(()ident(ImageFile)operator(\);) + reserved(if) reserved(not) ident(Switch)operator(()string<delimiter(')content(MurphyMode)delimiter(')>operator(\)) reserved(then) + ident(LogoL)operator(.)ident(Visible) operator(:=) ident(False)operator(;) + ident(Exit)operator(;) + reserved(end)operator(;) + + ident(ImageFile) operator(:=) ident(PlutoDir) operator(+) string<delimiter(')content(logo.bmp)delimiter(')>operator(;) + reserved(if) ident(FileEx)operator(()ident(ImageFile)operator(\)) reserved(then) reserved(begin) + reserved(with) ident(Image1)operator(.)ident(Picture) reserved(do) + reserved(if) ident(Graphic) operator(=) reserved(nil) reserved(then) + ident(LoadFromFile)operator(()ident(ImageFile)operator(\);) + reserved(end)operator(;) + reserved(except) + ident(ShowMessage)operator(()string<delimiter(')content(Could not load Splash Screen image!)delimiter(')>operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSplashWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Hide)operator(;) + ident(Randomize)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSplashWin)operator(.)ident(FormHide)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + comment(//Image1.Picture.Bitmap.FreeImage;) +reserved(end)operator(;) + +reserved(procedure) ident(TSplashWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(Close)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TSplashWin)operator(.)ident(SplashScreenCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Started) reserved(then) + ident(PrefWin)operator(.)ident(SplashScreenCB)operator(.)ident(Checked) operator(:=) ident(SplashScreenCB)operator(.)ident(Checked)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(SpyTH)operator(;) + +reserved(interface) + +reserved(uses) + ident(Classes)operator(,) ident(Windows)operator(,) ident(Dialogs)operator(,) ident(ComCtrls)operator(,) ident(CompEx)operator(,) ident(SysUtils)operator(,) ident(YTools)operator(,) ident(clock)operator(,) + ident(plutoconst)operator(,) ident(StdCtrls)operator(,) ident(forms)operator(,) ident(XReg)operator(,) ident(stringcomp)operator(;) + +reserved(type) + ident(TChildren) operator(=) reserved(array) reserved(of) ident(TTreeNode)operator(;) + + ident(TRegSpyThread) operator(=) reserved(class)operator(()ident(TThread)operator(\)) + directive(private) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(CurNode)operator(:) ident(TTreeNode)operator(;) + ident(Dead)operator(:) ident(Boolean)operator(;) + ident(Dif)operator(:) ident(TSLComp)operator(;) + ident(CurChildren)operator(:) ident(TChildren)operator(;) + directive(protected) + reserved(procedure) ident(Execute)operator(;) directive(override)operator(;) + + reserved(procedure) ident(SaveCheckNode)operator(;) + reserved(procedure) ident(SaveGetDif)operator(;) + reserved(procedure) ident(SaveDeleteDead)operator(;) + reserved(procedure) ident(SaveGetChildren)operator(;) + reserved(procedure) ident(SaveAddNew)operator(;) + directive(public) + ident(Restart)operator(:) ident(Boolean)operator(;) + ident(Mess)operator(:) reserved(string)operator(;) + ident(Delay)operator(:) ident(Integer)operator(;) + reserved(function) ident(Alive)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) + reserved(procedure) ident(Spy)operator(;) + reserved(procedure) ident(Reload)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(ReloadValues)operator(;) + reserved(procedure) ident(AddTrace)operator(()ident(Trace)operator(:) reserved(string)operator(\);) + reserved(constructor) ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(\);) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(end)operator(;) + +reserved(implementation) + +reserved(uses) ident(plutomain)operator(,) ident(TreeU)operator(,) ident(WorkU)operator(,) ident(ValuesU)operator(;) + +comment({ TRegSpyThread }) + +reserved(constructor) ident(TRegSpyThread)operator(.)ident(CreateIt)operator(()ident(PriorityLevel)operator(:) ident(TThreadPriority)operator(\);) +reserved(begin) + reserved(inherited) ident(Create)operator(()ident(True)operator(\);) comment(// Create thread suspended) + ident(Priority) operator(:=) ident(PriorityLevel)operator(;) comment(// Set Priority Level) + ident(FreeOnTerminate) operator(:=) ident(False)operator(;) comment(// Thread frees itself when terminated) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + ident(Delay) operator(:=) integer(100)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(Execute)operator(;) +reserved(begin) + reserved(while) reserved(not) ident(Terminated) reserved(do) reserved(begin) + ident(Restart) operator(:=) ident(False)operator(;) + reserved(try) + reserved(if) reserved(not) ident(Terminated) reserved(then) + ident(Sleep)operator(()ident(Delay)operator(\);) + reserved(if) reserved(not) ident(Terminated) reserved(then) + ident(Spy)operator(;) + reserved(except) reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TRegSpyThread)operator(.)ident(Alive)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + + reserved(if) ident(Restart) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + reserved(try) + reserved(if) operator(()ident(Node)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) ident(True)operator(;) + reserved(except) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(SaveCheckNode)operator(;) +reserved(begin) + ident(Dead) operator(:=) reserved(not) ident(Alive)operator(()ident(CurNode)operator(\);) + reserved(if) ident(Dead) reserved(then) + ident(Exit)operator(;) + + ident(CheckNode)operator(()ident(CurNode)operator(,) ident(False)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(SaveGetDif)operator(;) +reserved(var) + ident(Real)operator(,) ident(Cur)operator(:) ident(TStringList)operator(;) +reserved(begin) + ident(Dead) operator(:=) reserved(not) ident(Alive)operator(()ident(CurNode)operator(\);) + reserved(if) ident(Dead) reserved(then) + ident(Exit)operator(;) + + ident(dif) operator(:=) reserved(nil)operator(;) + + reserved(if) reserved(not) ident(CurNode)operator(.)ident(Expanded) reserved(then) reserved(begin) + ident(Dead) operator(:=) ident(True)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) reserved(not) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(CurNode)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Real) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + + ident(Reg)operator(.)ident(GetKeyNames)operator(()ident(Real)operator(\);) + ident(Reg)operator(.)ident(CloseKey)operator(;) + + ident(Cur) operator(:=) ident(GetChildNames)operator(()ident(CurNode)operator(\);) + + reserved(if) operator(()ident(Cur)operator(.)ident(Count) operator(=) integer(0)operator(\)) reserved(and) operator(()ident(Real)operator(.)ident(Count) operator(=) integer(0)operator(\)) reserved(then) + ident(Dead) operator(:=) ident(True)operator(;) + + ident(dif) operator(:=) ident(TSLComp)operator(.)ident(Create)operator(()ident(Cur)operator(,) ident(Real)operator(,) ident(False)operator(\);) + + ident(Cur)operator(.)ident(Free)operator(;) + ident(Real)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(SaveDeleteDead)operator(;) +reserved(var) + ident(TN)operator(:) ident(TTreeNode)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Dead) operator(:=) reserved(not) ident(Alive)operator(()ident(CurNode)operator(\);) + reserved(if) ident(Dead) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(dif)operator(\)) reserved(or) reserved(not) ident(Assigned)operator(()ident(dif)operator(.)ident(OnlyA)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(CurNode)operator(.)ident(Expanded) reserved(then) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(dif)operator(.)ident(OnlyA)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(TN) operator(:=) ident(FindNode)operator(()ident(CurNode)operator(,) ident(dif)operator(.)ident(OnlyA)operator([)ident(i)operator(]\);) + reserved(if) ident(Assigned)operator(()ident(TN)operator(\)) reserved(then) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(GetNextBest)operator(()ident(TN)operator(\);) + ident(TN)operator(.)ident(Delete)operator(;) + ident(AddTrace)operator(()string<delimiter(')content(Key deleted: )delimiter(')> operator(+) ident(dif)operator(.)ident(OnlyA)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + reserved(end) + reserved(else) + ident(Exit)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(SaveGetChildren)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(TN)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Dead) operator(:=) reserved(not) ident(Alive)operator(()ident(CurNode)operator(\);) + reserved(if) ident(Dead) reserved(then) + ident(Exit)operator(;) + + ident(CurChildren) operator(:=) reserved(nil)operator(;) + ident(SetLength)operator(()ident(CurChildren)operator(,) ident(CurNode)operator(.)ident(Count)operator(\);) + + ident(i) operator(:=) integer(0)operator(;) + ident(TN) operator(:=) ident(CurNode)operator(.)ident(GetFirstChild)operator(;) + reserved(while) ident(Assigned)operator(()ident(TN)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(i) operator(<=) ident(High)operator(()ident(CurChildren)operator(\)) reserved(then) + ident(CurChildren)operator([)ident(i)operator(]) operator(:=) ident(TN) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Too much children)delimiter(')>operator(\);) + ident(Inc)operator(()ident(i)operator(\);) + ident(TN) operator(:=) ident(CurNode)operator(.)ident(GetNextChild)operator(()ident(TN)operator(\)) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(SaveAddNew)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Dead) operator(:=) reserved(not) ident(Alive)operator(()ident(CurNode)operator(\);) + reserved(if) ident(Dead) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Dif)operator(\)) reserved(or) reserved(not) ident(Assigned)operator(()ident(Dif)operator(.)ident(OnlyB)operator(\)) reserved(or) operator(()ident(Dif)operator(.)ident(OnlyB)operator(.)ident(Count) operator(=) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Dif)operator(.)ident(OnlyB)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) comment(//Erstellt/hinbenannt) + ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(CurNode)operator(,) ident(Dif)operator(.)ident(OnlyB)operator([)ident(i)operator(]\);) + ident(AddTrace)operator(()string<delimiter(')content(New Key: )delimiter(')> operator(+) ident(dif)operator(.)ident(OnlyB)operator([)ident(i)operator(]\);) + ident(MainWin)operator(.)ident(StatusBarUpdate)operator(;) + comment(//AddHint('Neuer Schlüssel: ' + CurNode.Text + '\\' + Dif.OnlyB[i]\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(Reload)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(TN)operator(:) ident(TTreeNode)operator(;) + ident(zCurNode)operator(:) ident(TTreeNode)operator(;) + ident(MyChildren)operator(:) ident(TChildren)operator(;) +reserved(begin) + reserved(if) ident(Terminated) reserved(or) ident(Restart) reserved(then) + ident(Exit)operator(;) + + ident(CurNode) operator(:=) ident(Node)operator(;) + + ident(zCurNode) operator(:=) ident(CurNode)operator(;) + reserved(try) + comment(//Mess := 'SaveCheckNode';) + ident(Synchronize)operator(()ident(SaveCheckNode)operator(\);) + reserved(if) ident(Dead) reserved(or) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + comment(//Mess := 'SaveGetDif';) + ident(Synchronize)operator(()ident(SaveGetDif)operator(\);) + reserved(if) ident(Dead) reserved(or) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + comment(//Mess := 'SaveDeleteDead';) + ident(Synchronize)operator(()ident(SaveDeleteDead)operator(\);) + reserved(if) ident(Dead) reserved(or) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + comment(//Mess := 'SaveGetChildren';) + ident(Synchronize)operator(()ident(SaveGetChildren)operator(\);) + reserved(if) ident(Dead) reserved(or) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + comment(//Mess := 'SaveGetChildren';) + ident(Synchronize)operator(()ident(SaveAddNew)operator(\);) + reserved(if) ident(Dead) reserved(or) ident(Terminated) reserved(then) + ident(Exit)operator(;) + + ident(Dif)operator(.)ident(Free)operator(;) + + comment(//Mess := 'MyChildren';) + ident(SetLength)operator(()ident(MyChildren)operator(,) ident(Length)operator(()ident(CurChildren)operator(\)\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(MyChildren)operator(\)) reserved(do) + ident(MyChildren)operator([)ident(i)operator(]) operator(:=) ident(CurChildren)operator([)ident(i)operator(];) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(MyChildren)operator(\)) reserved(do) reserved(begin) + ident(TN) operator(:=) ident(MyChildren)operator([)ident(i)operator(];) + reserved(if) ident(Alive)operator(()ident(TN)operator(\)) reserved(then) + comment(//if TN.Expanded then) + comment(//if NodeVisible(TN\) then) + ident(Reload)operator(()ident(TN)operator(\);) + comment(//else) + comment(//Break;) + reserved(if) ident(Restart) reserved(or) ident(Terminated) reserved(then) + ident(Break)operator(;) + reserved(end)operator(;) + ident(MyChildren) operator(:=) reserved(nil)operator(;) + + reserved(except) + reserved(if) ident(Terminated) reserved(then) + ident(Exit)operator(;) + ident(AddHint)operator(()string<delimiter(')content(Error in Spy: )delimiter(')> operator(+) ident(Mess)operator(\);) + ident(WorkWin)operator(.)ident(Label7)operator(.)ident(Caption) operator(:=) string<delimiter(')content(ERROR)delimiter(')>operator(;) + reserved(end)operator(;) + ident(CurNode) operator(:=) ident(zCurNode)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FindItemByRealName)operator(()ident(LV)operator(:) ident(TListView)operator(;) ident(Text)operator(:) reserved(string)operator(\):) ident(TListItem)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) reserved(nil)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(LV)operator(.)ident(Items)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(LV)operator(.)ident(Items)operator([)ident(i)operator(].)ident(Caption) operator(=) ident(Text) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(LV)operator(.)ident(Items)operator([)ident(i)operator(];) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(LV)operator(.)ident(Items)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(SameText)operator(()ident(RealValueName)operator(()ident(LV)operator(.)ident(Items)operator([)ident(i)operator(]\),) ident(Text)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(LV)operator(.)ident(Items)operator([)ident(i)operator(];) + ident(Break)operator(;) reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(ReloadValues)operator(;) +reserved(var) + ident(Item)operator(:) ident(TListItem)operator(;) + ident(Real)operator(,) ident(Cur)operator(:) ident(TStringList)operator(;) + ident(Dif)operator(:) ident(TSLComp)operator(;) + ident(i)operator(:) ident(integer)operator(;) +reserved(begin) + reserved(if) ident(Terminated) reserved(or) ident(Restart) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Real) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(Reg)operator(.)ident(GetValueNames)operator(()ident(Real)operator(\);) + + ident(Cur) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(Cur)operator(.)ident(Add)operator(()ident(RealValueName)operator(()ident(Item)operator([)ident(i)operator(]\)\);) + + ident(Dif) operator(:=) ident(TSLComp)operator(.)ident(Create)operator(()ident(Cur)operator(,) ident(Real)operator(,) ident(False)operator(\);) + ident(Real)operator(.)ident(Free)operator(;) + ident(Cur)operator(.)ident(Free)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Dif)operator(.)ident(OnlyA)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) comment(//Gelöscht/wegbenannt) + ident(Item) operator(:=) ident(FindItemByRealName)operator(()ident(ValueList)operator(,) ident(Dif)operator(.)ident(OnlyA)operator([)ident(i)operator(]\);) + reserved(if) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) reserved(begin) + ident(Item)operator(.)ident(Delete)operator(;) + ident(AddTrace)operator(()string<delimiter(')content(Value deleted: )delimiter(')> operator(+) ident(Dif)operator(.)ident(OnlyA)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(ValueList)operator(.)ident(Items)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) comment(//Daten) + ident(Item) operator(:=) ident(ValueList)operator(.)ident(Items)operator([)ident(i)operator(];) + comment({if Item.SubItems.Count < 2 then begin + ShowMessage('Fehler in Sync.'\); + Exit end; }) + reserved(if) ident(ValuesWin)operator(.)ident(UpdateValue)operator(()ident(Reg)operator(,) ident(Item)operator(\)) reserved(then) + ident(AddTrace)operator(()string<delimiter(')content(Value Changed: )delimiter(')> operator(+) ident(Item)operator(.)ident(Caption) operator(+) string<delimiter(')content( = )delimiter(')> operator(+) + ident(ValueDataPreview)operator(()ident(Reg)operator(.)ident(ReadContext)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)\)\);) + reserved(end)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(dif)operator(.)ident(OnlyB)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) comment(//Erstellt/hinbenannt) + ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(Reg)operator(,) ident(dif)operator(.)ident(OnlyB)operator([)ident(i)operator(]\);) + ident(AddTrace)operator(()string<delimiter(')content(New Value: )delimiter(')> operator(+) ident(Dif)operator(.)ident(OnlyB)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + + ident(Reg)operator(.)ident(CloseKey)operator(;) + ident(Dif)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(Spy)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(a)operator(:) ident(Real)operator(;) +reserved(begin) + reserved(with) ident(TClock)operator(.)ident(Create) reserved(do) reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(RootNodes)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(Reload)operator(()ident(TTreeNode)operator(()ident(RootNodes)operator([)ident(i)operator(]\)\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Shortcuts)operator(\)) reserved(do) + ident(Reload)operator(()ident(Shortcuts)operator([)ident(i)operator(].)ident(Node)operator(\);) + ident(Synchronize)operator(()ident(ReloadValues)operator(\);) + ident(a) operator(:=) ident(SecondsPassed) operator(*) integer(1000)operator(;) + ident(Free)operator(;) reserved(end)operator(;) + + reserved(if) ident(a) operator(>) integer(0) reserved(then) + ident(WorkWin)operator(.)ident(Label7)operator(.)ident(Caption) operator(:=) string<delimiter(')content(Spy: )delimiter(')> operator(+) ident(Format)operator(()string<delimiter(')content(%0.2f)delimiter(')>operator(,) operator([)ident(a)operator(]\)) operator(+) string<delimiter(')content( s)delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TRegSpyThread)operator(.)ident(AddTrace)operator(()ident(Trace)operator(:) reserved(string)operator(\);) +reserved(begin) + reserved(with) ident(WorkWin) reserved(do) + reserved(if) ident(ListTracesCB)operator(.)ident(Checked) reserved(then) + ident(SpyLB)operator(.)ident(Items)operator(.)ident(Add)operator(()ident(Trace)operator(\);) +reserved(end)operator(;) + +reserved(destructor) ident(TRegSpyThread)operator(.)ident(Destroy)operator(;) +reserved(begin) + ident(Dif)operator(.)ident(Free)operator(;) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(TreeU)operator(;) +preprocessor({$DEFINE UNIKEY}) +preprocessor({$DEFINE CYCFS}) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Variants)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) + ident(ComCtrls)operator(,) ident(Menus)operator(,) ident(Clipbrd)operator(,) ident(keybrd)operator(,) ident(Dialogs)operator(,) ident(YTools)operator(,) ident(PlutoConst)operator(,) ident(CompEx)operator(,) + ident(IniFiles)operator(,) ident(XReg)operator(,) ident(Colors)operator(,) ident(Clock)operator(,) + ident(ToolWin)operator(,) ident(RegFiles) preprocessor({$IFDEF UNIKEY})operator(,) ident(UniKey)operator(,) ident(ImgList) preprocessor({$ENDIF})operator(;) + +reserved(type) + ident(TTreeWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(RegTVPU)operator(:) ident(TPopupMenu)operator(;) + ident(NewSubKeyMI)operator(:) ident(TMenuItem)operator(;) + ident(NewKeyMI)operator(:) ident(TMenuItem)operator(;) + ident(CreateShortcutMI)operator(:) ident(TMenuItem)operator(;) + ident(TraceMI)operator(:) ident(TMenuItem)operator(;) + ident(N3)operator(:) ident(TMenuItem)operator(;) + ident(DeleteMI)operator(:) ident(TMenuItem)operator(;) + ident(DublicateMI)operator(:) ident(TMenuItem)operator(;) + ident(N4)operator(:) ident(TMenuItem)operator(;) + ident(FindMI)operator(:) ident(TMenuItem)operator(;) + ident(RegTV)operator(:) ident(TTreeView)operator(;) + ident(PastePathMI)operator(:) ident(TMenuItem)operator(;) + ident(N1)operator(:) ident(TMenuItem)operator(;) + ident(InsertPathMI)operator(:) ident(TMenuItem)operator(;) + ident(RenameMI)operator(:) ident(TMenuItem)operator(;) + ident(CopyPathMI)operator(:) ident(TMenuItem)operator(;) + ident(CutPathMI)operator(:) ident(TMenuItem)operator(;) + ident(EditShortcutMI)operator(:) ident(TMenuItem)operator(;) + ident(N2)operator(:) ident(TMenuItem)operator(;) + ident(Export1)operator(:) ident(TMenuItem)operator(;) + ident(SubKeylist1)operator(:) ident(TMenuItem)operator(;) + ident(ValueNameslist1)operator(:) ident(TMenuItem)operator(;) + ident(KeyInfosMI)operator(:) ident(TMenuItem)operator(;) + ident(N5)operator(:) ident(TMenuItem)operator(;) + ident(ExportAsReg)operator(:) ident(TMenuItem)operator(;) + ident(ExportD)operator(:) ident(TSaveDialog)operator(;) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVChange)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(RegTVChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVCollapsing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(AllowCollapse)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVDeletion)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(RegTVDragDrop)operator(()ident(Sender)operator(,) ident(Source)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(RegTVDragOver)operator(()ident(Sender)operator(,) ident(Source)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(;) ident(State)operator(:) ident(TDragState)operator(;) reserved(var) ident(Accept)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVEdited)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(S)operator(:) ident(String)operator(\);) + reserved(procedure) ident(RegTVEditing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(AllowEdit)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVEndDrag)operator(()ident(Sender)operator(,) ident(Target)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(RegTVEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVExpanded)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(RegTVExpanding)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(AllowExpansion)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RegTVGetSelectedIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(RegTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(RegTVMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(RegTVStartDrag)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(DragObject)operator(:) ident(TDragObject)operator(\);) + + reserved(function) ident(CreateKey)operator(()ident(Subkey)operator(:) ident(Boolean)operator(\):) ident(Boolean)operator(;) + reserved(procedure) ident(CloneKey)operator(;) + reserved(procedure) ident(DeleteKey)operator(;) + reserved(procedure) ident(NewShortcut)operator(;) + reserved(procedure) ident(MoveKey)operator(()reserved(const) ident(Src)operator(,) ident(Trg)operator(:) ident(TRegPath)operator(;) ident(CopyWanted)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(MoveValues)operator(()ident(SrcNode)operator(,) ident(TrgNode)operator(:) ident(TTreeNode)operator(;) ident(CopyWanted)operator(:) ident(Boolean)operator(\);) + + reserved(procedure) ident(NewSubKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CreateShortcutMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(TraceMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DeleteMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DublicateMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FindMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(RegTVKeyPress)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Char)operator(\);) + reserved(procedure) ident(RegTVAdvancedCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) ident(Stage)operator(:) ident(TCustomDrawStage)operator(;) + reserved(var) ident(PaintImages)operator(,) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(RenameMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(InsertPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RegTVGetImageIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(CheckRegTVHotTrack)operator(;) + reserved(procedure) ident(PasteKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CutPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(OpenNextLevel)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(EditShortcutMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SubKeylist1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ValueNameslist1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(KeyInfosMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(function) ident(GetKeyInfos)operator(:) reserved(string)operator(;) + reserved(procedure) ident(ExportAsRegClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) + + reserved(procedure) ident(Load)operator(;) + reserved(procedure) ident(Reg4WriterTerminate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + directive(private) + ident(DragNode)operator(:) ident(TTreeNode)operator(;) + ident(NoAsterisk)operator(:) ident(Boolean)operator(;) comment(//To prevent NumPadMULTIPLY and asterisk errors) + ident(UserCopyKeyFlag)operator(:) ident(Boolean)operator(;) + ident(SpaceCount)operator(:) ident(Integer)operator(;) comment(//EasterEgg) + directive(public) + ident(CantWrite)operator(:) ident(Boolean)operator(;) + ident(DoSmartExpand)operator(:) ident(Boolean)operator(;) + reserved(end)operator(;) + +reserved(procedure) ident(CheckNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(;) ident(OnlyOnce)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(TakeNodeSelected)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) + +reserved(function) ident(AddShortcut)operator(()ident(Alias)operator(,) ident(RealPath)operator(:) reserved(string)operator(;) ident(Icon)operator(:) ident(Integer)operator(;) + ident(AHostType)operator(:) ident(TUniHostType) operator(=) ident(uhUserShortcut)operator(;) ident(WriteIni)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(TTreeNode)operator(;) +reserved(function) ident(ShortcutIndex)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Integer)operator(;) + +reserved(function) ident(TraceKey)operator(()reserved(const) ident(Path)operator(:) reserved(string)operator(;) ident(AllowedShortcutTypes)operator(:) ident(TUniHostTypes) operator(=) + ident(uhNonSystemShortcuts)operator(\):) reserved(string)operator(;) + +reserved(type) + ident(TOpenNodeMode) operator(=) operator(()ident(onNodeNil)operator(,) ident(onError)operator(,) ident(onReadOnly)operator(,) ident(onFull)operator(\);) + +reserved(const) + ident(onOK) operator(=) operator([)ident(onFull)operator(,) ident(onReadOnly)operator(];) + +reserved(function) ident(OpenNode)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(TOpenNodeMode)operator(;) +reserved(function) ident(OpenNodeOK)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(OpenCurKey)operator(:) ident(Boolean)operator(;) +reserved(function) ident(OpenCurParent)operator(:) ident(Boolean)operator(;) + +reserved(var) + ident(TreeWin)operator(:) ident(TTreeWin)operator(;) + + ident(RegTV)operator(:) ident(TTreeView)operator(;) comment(//Shortcut for other units, equals TreeWin.RegTV) + +preprocessor({$IFDEF UNIKEY}) + ident(UserUniPath)operator(:) reserved(string) preprocessor({$IFDEF CYCFS}) operator(=) string<delimiter(')content(cYcFS <y:\\programme\\cYcFS\\test>)delimiter(')>preprocessor({$ENDIF})operator(;) +preprocessor({$ENDIF}) + ident(Shortcuts)operator(:) ident(TShortcutA)operator(;) + ident(RootNodes)operator(:) ident(TList)operator(;) comment(//list of TTreeNode;) + +reserved(implementation) + +reserved(uses) + ident(PlutoMain)operator(,) ident(ValuesU)operator(,) ident(FindWinU)operator(,) ident(WorkU)operator(,) ident(PrefU)operator(,) ident(ShellEx)operator(,) ident(Types)operator(;) + +preprocessor({$R *.dfm}) + +preprocessor({$IFDEF UNIKEY}) +reserved(function) ident(UniOfNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(TUniKey)operator(;) +reserved(var) + ident(UniPath)operator(:) ident(TUniPath)operator(;) +reserved(begin) + ident(UniPath) operator(:=) ident(UniOfStr)operator(()ident(UserUniPath)operator(\);) + ident(UniPath)operator(.)ident(Path) operator(:=) ident(Join)operator(()ident(Copy)operator(()ident(NodePath)operator(()ident(Node)operator(\),) integer(1)operator(,) ident(MaxInt)operator(\),) char<delimiter(')content(/)delimiter(')>operator(\);) + ident(Result) operator(:=) ident(TUniKey)operator(.)ident(CreateU)operator(()ident(UniPath)operator(,) ident(reTryToSolve)operator(\);) +reserved(end)operator(;) +preprocessor({$ENDIF}) + +reserved(procedure) ident(TTreeWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(TreeU)operator(.)ident(RegTV) operator(:=) ident(RegTV)operator(;) + + ident(DragNode) operator(:=) reserved(nil)operator(;) + ident(NoAsterisk) operator(:=) ident(False)operator(;) + ident(DoSmartExpand) operator(:=) ident(True)operator(;) + ident(UserCopyKeyFlag) operator(:=) ident(True)operator(;) + ident(SpaceCount) operator(:=) integer(0)operator(;) comment(//EasterEgg) + + ident(RegTV)operator(.)ident(Items)operator(.)ident(Clear)operator(;) + ident(CheckRegTVHotTrack)operator(;) + + ident(KeyInfosMI)operator(.)ident(ImageIndex) operator(:=) ident(iconKeyInfos)operator(;) + + ident(NewSubKeyMI)operator(.)ident(ImageIndex) operator(:=) ident(iconSubKey)operator(;) + ident(NewKeyMI)operator(.)ident(ImageIndex) operator(:=) ident(iconKey)operator(;) + ident(CreateShortcutMI)operator(.)ident(ImageIndex) operator(:=) ident(iconShortcut)operator(;) + + ident(RenameMI)operator(.)ident(ImageIndex) operator(:=) ident(iconRename)operator(;) + ident(DeleteMI)operator(.)ident(ImageIndex) operator(:=) ident(iconDelete)operator(;) + ident(DublicateMI)operator(.)ident(ImageIndex) operator(:=) ident(iconKeyDublicate)operator(;) + + ident(FindMI)operator(.)ident(ImageIndex) operator(:=) ident(iconKeyFind)operator(;) + ident(TraceMI)operator(.)ident(ImageIndex) operator(:=) ident(iconKeyTrace)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(KeyIsDown)operator(()ident(VK_CONTROL)operator(\)) reserved(then) reserved(begin) + ident(TraceMIClick)operator(()ident(Sender)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVChange)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(var) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(OpenRe)operator(:) ident(TOpenNodeMode)operator(;) + +preprocessor({$IFDEF UNIKEY}) + ident(Uni)operator(:) ident(TUniKey)operator(;) + ident(ValueNames)operator(:) ident(TStringList)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(AppendSubItemData)operator(()ident(SubItems)operator(:) ident(TStrings)operator(;) ident(Uni)operator(:) ident(TUniKey)operator(;) + reserved(const) ident(ValueName)operator(:) reserved(string)operator(\);) + reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(s)operator(:) reserved(string)operator(\);) + reserved(begin) + ident(SubItems)operator(.)ident(Append)operator(()ident(s)operator(\);) + reserved(end)operator(;) + + reserved(begin) + ident(SL) operator(:=) reserved(nil)operator(;) + reserved(try) + ident(Add)operator(()string<delimiter(')content(beta)delimiter(')>operator(\);) + + reserved(case) ident(Uni)operator(.)ident(GetDataType)operator(()ident(ValueName)operator(\)) reserved(of) + + ident(udString)operator(,) ident(udExpandString)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(String)delimiter(')>operator(\);) + ident(Add)operator(()ident(Uni)operator(.)ident(ReadString)operator(()ident(ValueName)operator(\)\);) + reserved(end)operator(;) + + ident(udCardinal)operator(,) ident(udCardBigEndian)operator(,) ident(udInteger)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(Numeric)delimiter(')>operator(\);) + ident(Add)operator(()ident(IntToStr)operator(()ident(Uni)operator(.)ident(ReadInteger)operator(()ident(ValueName)operator(\)\)\);) + reserved(end)operator(;) + + ident(udBinary)operator(,) ident(udNone)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(Binary)delimiter(')>operator(\);) + ident(Add)operator(()ident(FriendlyStr)operator(()ident(Uni)operator(.)ident(ReadBinary)operator(()ident(ValueName)operator(\)\)\);) + reserved(end)operator(;) + + ident(udBoolean)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(Boolean)delimiter(')>operator(\);) + ident(Add)operator(()ident(StrOfBool)operator(()ident(Uni)operator(.)ident(ReadBool)operator(()ident(ValueName)operator(\)\)\);) + reserved(end)operator(;) + + ident(udStringList)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(List)delimiter(')>operator(\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(SL)operator(\)) reserved(then) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create) + reserved(else) + ident(SL)operator(.)ident(Clear)operator(;) + ident(Uni)operator(.)ident(ReadStringList)operator(()ident(ValueName)operator(,) ident(SL)operator(\);) + ident(Add)operator(()ident(Join)operator(()ident(SL)operator(,) ident(MultiStringSeparator)operator(\)\);) + reserved(end)operator(;) + + ident(udColor)operator(:) reserved(begin) + ident(Add)operator(()string<delimiter(')content(Color)delimiter(')>operator(\);) + ident(Add)operator(()ident(ColorToString)operator(()ident(Uni)operator(.)ident(ReadColor)operator(()ident(ValueName)operator(\)\)\);) + reserved(end)operator(;) + + reserved(else) + ident(Add)operator(()string<delimiter(')content(Unsupported Data Type: )delimiter(')> operator(+) + ident(IntToStr)operator(()ident(Cardinal)operator(()ident(Uni)operator(.)ident(GetDataType)operator(()ident(ValueName)operator(\)\)\)\);) + reserved(end)operator(;) comment(//case) + + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + +preprocessor({$ENDIF}) + +reserved(begin) + ident(SpaceCount) operator(:=) integer(0)operator(;) comment(//Easteregg) + + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + ident(CantWrite) operator(:=) ident(False)operator(;) + + reserved(try) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + +preprocessor({$IFDEF UNIKEY}) + reserved(if) ident(RootOfNode)operator(()ident(Node)operator(\).)ident(ImageIndex) operator(=) ident(iconHostUni) reserved(then) reserved(begin) + ident(ValueNames) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(ValueList)operator(.)ident(Clear)operator(;) + + ident(Uni) operator(:=) ident(UniOfNode)operator(()ident(Node)operator(\);) + comment({Uni := CreateUniSubKey(UserUniPath, Copy(NodePath(Node\), 1, MaxInt\), + reFaile\); }) + reserved(if) ident(Assigned)operator(()ident(Uni)operator(\)) reserved(then) + reserved(try) + ident(Uni)operator(.)ident(GetValueNames)operator(()ident(ValueNames)operator(\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(ValueNames)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(Item) operator(:=) ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(Reg)operator(,) ident(ValueNames)operator([)ident(i)operator(],) ident(False)operator(\);) + ident(Item)operator(.)ident(ImageIndex) operator(:=) ident(iconHostUni2)operator(;) + ident(AppendSubItemData)operator(()ident(Item)operator(.)ident(SubItems)operator(,) ident(Uni)operator(,) ident(ValueNames)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + + reserved(finally) + ident(Uni)operator(.)ident(Free)operator(;) + ident(ValueNames)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(end) reserved(else) reserved(begin) +preprocessor({$ENDIF}) + + ident(OpenRe) operator(:=) ident(OpenNode)operator(()ident(Reg)operator(,) ident(Node)operator(\);) + reserved(if) ident(OpenRe) reserved(in) ident(onOK) reserved(then) reserved(begin) + ident(ValuesWin)operator(.)ident(LoadValues)operator(()ident(Reg)operator(\);) + reserved(if) ident(OpenRe) operator(=) ident(onReadOnly) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Read only)delimiter(')>operator(,) ident(True)operator(\);) + ident(CantWrite) operator(:=) ident(True)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) reserved(if) ident(OpenRe) operator(=) ident(onError) reserved(then) reserved(begin) + ident(ValueList)operator(.)ident(Clear)operator(;) + ident(CantWrite) operator(:=) ident(True)operator(;) + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(0) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Shortcut target not found)delimiter(')>operator(,) ident(True)operator(\);) + reserved(end) reserved(else) + ident(AddHint)operator(()string<delimiter(')content(Key not found: )delimiter(')> operator(+) ident(Node)operator(.)ident(Text)operator(,) ident(True)operator(\);) + reserved(end)operator(;) + +preprocessor({$IFDEF UNIKEY}) + reserved(end)operator(;) +preprocessor({$ENDIF}) + + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + ident(CantWrite) operator(:=) ident(CantWrite) reserved(or) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) + reserved(or) ident(NodeInfo)operator(() ident(Node) operator(\).)ident(ReadOnly) comment(//Node itself) + reserved(or) ident(NodeInfo)operator(()ident(RootOfNode)operator(()ident(Node)operator(\)\).)ident(ReadOnly) comment(//or host) + reserved(or) operator(()ident(SameText)operator(()ident(CurKey)operator(()ident(uhNonSystemShortcuts)operator(\).)ident(Root)operator(,) string<delimiter(')content(HKEY_DYN_DATA)delimiter(')>operator(\)\);) + + ident(MainWin)operator(.)ident(SetStatus)operator(;) + ident(WorkWin)operator(.)ident(InfoMemo)operator(.)ident(Text) operator(:=) ident(GetKeyInfos)operator(;) + reserved(finally) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) +reserved(begin) + ident(CantWrite) operator(:=) ident(False)operator(;) + ident(AllowChange) operator(:=) ident(Assigned)operator(()ident(Node)operator(\);) + comment(// CheckNode(Node, True\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVCollapsing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(var) ident(AllowCollapse)operator(:) ident(Boolean)operator(\);) +reserved(begin) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(Node)operator(.)ident(DeleteChildren)operator(;) + ident(RegTVChange)operator(()ident(Sender)operator(,) ident(Node)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(Info)operator(:) ident(TNodeInfo)operator(;) +reserved(begin) + comment({if Node.Text = '' then begin + ShowMessage('Error: Key has empty name.'\); + Node.Delete; + Exit; end;}) + + ident(Info) operator(:=) ident(NodeInfo)operator(()ident(Node)operator(\);) + reserved(with) ident(TTreeView)operator(()ident(Sender)operator(\).)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Info)operator(.)ident(Defect) reserved(then) reserved(begin) + ident(Style) operator(:=) operator([];) + ident(Color) operator(:=) hex($AAAAAA) + reserved(end) reserved(else) reserved(begin) + reserved(case) ident(Info)operator(.)ident(HostType) reserved(of) + + ident(uhReg)operator(:) reserved(begin) + ident(Style) operator(:=) operator([)ident(fsBold)operator(];) + ident(Color) operator(:=) ident(clCyan)operator(;) + reserved(end)operator(;) + + comment({uhIni: begin + Style := [fsBold]; + Color := clBrightYellow; + end; + + uhRegFile: begin + Style := [fsBold]; + Color := clBrightGreen; + end; }) + + ident(uhSystemShortcut)operator(:) reserved(begin) + ident(Style) operator(:=) operator([];) + ident(Color) operator(:=) ident(clBrightCyan)operator(;) + reserved(end)operator(;) + + ident(uhStandardShortcut)operator(:) reserved(begin) + ident(Style) operator(:=) operator([)ident(fsBold)operator(];) + ident(Color) operator(:=) hex($EEEEEE)operator(;) + reserved(end)operator(;) + + ident(uhUserShortcut)operator(:) reserved(begin) + ident(Style) operator(:=) operator([];) + ident(Color) operator(:=) hex($EEEEEE)operator(;) + reserved(end)operator(;) + + reserved(else) + ident(Style) operator(:=) operator([];) + reserved(if) ident(Info)operator(.)ident(ReadOnly) reserved(then) + ident(Color) operator(:=) ident(clBrightRed) + reserved(else) + ident(Color) operator(:=) ident(clWhite)operator(;) + reserved(end)operator(;) + + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(MouseX)operator(:) ident(Integer)operator(;) + ident(NodeRect)operator(:) ident(TRect)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(MouseX) operator(:=) ident(RegTV)operator(.)ident(ScreenToClient)operator(()ident(Mouse)operator(.)ident(CursorPos)operator(\).)ident(X)operator(;) + ident(NodeRect) operator(:=) ident(Node)operator(.)ident(DisplayRect)operator(()ident(True)operator(\);) + reserved(if) ident(MouseX) operator(>) ident(NodeRect)operator(.)ident(Right) reserved(then) reserved(begin) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + ident(FocusItem)operator(()ident(PrefWin)operator(.)ident(MainPreviewE)operator(.)ident(Text)operator(\);) + ident(ValueListDblClick)operator(()ident(Self)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVDeletion)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(SpyThread)operator(\)) reserved(then) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + reserved(if) ident(Node)operator(.)ident(Selected) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(GetNextBest)operator(()ident(Node)operator(\);) + ident(NodeInfo)operator(()ident(Node)operator(\).)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVDragDrop)operator(()ident(Sender)operator(,) ident(Source)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + + reserved(procedure) ident(DragKey)operator(;) + reserved(var) + ident(Src)operator(,) ident(Trg)operator(:) ident(TRegPath)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(begin) + ident(Src) operator(:=) ident(RegPathOfStr)operator(()ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(DragNode)operator(\)\)\);) + ident(Trg) operator(:=) ident(RegPathOfStr)operator(()ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(DropTarget)operator(\)\)\);) + ident(Trg)operator(.)ident(Key) operator(:=) ident(Trg)operator(.)ident(Key) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(DragNode)operator(.)ident(Text)operator(;) + + ident(MoveKey)operator(()ident(Src)operator(,) ident(Trg)operator(,) ident(KeyIsDown)operator(()ident(VK_CONTROL)operator(\)\);) + + ident(Node) operator(:=) ident(RegTV)operator(.)ident(DropTarget)operator(;) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(Node)operator(.)ident(Collapse)operator(()ident(False)operator(\);) + ident(Node)operator(.)ident(Expanded) operator(:=) ident(False)operator(;) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(,) ident(True)operator(\);) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + reserved(end)operator(;) + + reserved(procedure) ident(DragValues)operator(;) + reserved(begin) + ident(MoveValues)operator(()ident(RegTV)operator(.)ident(Selected)operator(,) ident(RegTV)operator(.)ident(DropTarget)operator(,) ident(KeyIsDown)operator(()ident(VK_CONTROL)operator(\)\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(Source) reserved(is) ident(TTreeView) reserved(then) + ident(DragKey) + reserved(else) reserved(if) ident(Source) reserved(is) ident(TListView) reserved(then) + ident(DragValues)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVDragOver)operator(()ident(Sender)operator(,) ident(Source)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(;) + ident(State)operator(:) ident(TDragState)operator(;) reserved(var) ident(Accept)operator(:) ident(Boolean)operator(\);) +reserved(begin) + ident(Accept) operator(:=) ident(False)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(RegTV)operator(.)ident(DropTarget)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Source) reserved(is) ident(TTreeView) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(DragNode)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(if) reserved(not) ident(KeyIsDown)operator(()ident(VK_CONTROL)operator(\)) reserved(then) reserved(begin) + reserved(if) operator(()ident(DragNode) operator(=) ident(RegTV)operator(.)ident(DropTarget)operator(\)) + reserved(or) ident(RegTV)operator(.)ident(DropTarget)operator(.)ident(HasAsParent)operator(()ident(DragNode)operator(\)) reserved(then) + ident(Exit)operator(;) comment(//avoid recursive moving) + reserved(end)operator(;) + reserved(end) reserved(else) reserved(if) ident(Source) reserved(is) ident(TListView) reserved(then) reserved(begin) + comment(//accept) + reserved(end)operator(;) + ident(Accept) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVEdited)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) reserved(var) ident(S)operator(:) reserved(string)operator(\);) +reserved(var) + ident(old)operator(,) ident(tmp)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(Shortcut)operator(:) ident(PKeyShortcut)operator(;) +reserved(begin) + reserved(if) ident(s) operator(=) ident(Node)operator(.)ident(Text) reserved(then) + ident(Exit)operator(;) + + ident(Old) operator(:=) ident(Node)operator(.)ident(Text)operator(;) + + reserved(if) ident(NodeInfo)operator(()ident(Node)operator(\).)ident(HostType) operator(=) ident(uhUserShortcut) reserved(then) reserved(begin) + ident(i) operator(:=) ident(ShortcutIndex)operator(()ident(Node)operator(\);) + reserved(if) ident(i) operator(=) operator(-)integer(1) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Shortcut not found!)delimiter(')>operator(\);) + ident(s) operator(:=) ident(old)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Shortcut) operator(:=) operator(@)ident(Shortcuts)operator([)ident(i)operator(];) + ident(Shortcut)operator(.)ident(Alias) operator(:=) ident(s)operator(;) + + reserved(with) ident(TIniFile)operator(.)ident(Create)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(DeleteKey)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Old)operator(\);) + ident(WriteString)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Shortcut)operator(.)ident(Alias)operator(,) ident(Shortcut)operator(.)ident(RealPath)operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) + ident(Node)operator(.)ident(Text) operator(:=) ident(s)operator(;) + ident(RegTVChange)operator(()ident(Self)operator(,) ident(Node)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(s) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(KeyNames cannot be empty.)delimiter(')>operator(\);) + ident(s) operator(:=) ident(old)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(Node)operator(.)ident(Text) operator(:=) ident(s)operator(;) + + reserved(if) ident(Length)operator(()ident(s)operator(\)) operator(>) ident(RegMaxKeyLen) reserved(then) reserved(begin) + ident(s) operator(:=) ident(Copy)operator(()ident(s)operator(,) integer(1)operator(,) ident(RegMaxKeyLen)operator(\);) + reserved(if) ident(MessageDlg)operator(() + string<delimiter(')content(The maximum size of a key name is )delimiter(')> operator(+) ident(IntToStr)operator(()ident(RegMaxKeyLen)operator(\)) operator(+) string<delimiter(')content( characters.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Shorten the key name to:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(Quote)operator(()ident(StringWrap)operator(()ident(s)operator(,) integer(80)operator(\)\),) + ident(mtConfirmation)operator(,) operator([)ident(mbOK)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) operator(<>) ident(mrOK) reserved(then) reserved(begin) + ident(s) operator(:=) ident(Old)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + ident(Exit)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(CharIn)operator(()ident(s)operator(,) operator([)char(#0)operator(..)char(#31)operator(,) char<delimiter(')content(\\)delimiter(')>operator(]\)) reserved(then) reserved(begin) + ident(s) operator(:=) ident(ReplaceChars)operator(()ident(s)operator(,) operator([)char(#0)operator(..)char(#31)operator(],) char<delimiter(')content(#)delimiter(')>operator(\);) + ident(s) operator(:=) ident(ReplaceChars)operator(()ident(s)operator(,) char<delimiter(')content(\\)delimiter(')>operator(,) char<delimiter(')content(-)delimiter(')>operator(\);) + + reserved(if) ident(MessageDlg)operator(()string<delimiter(')content(The following characters are not allowed in KeyNames:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(- Control chars (0-31\))delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(- )delimiter(')> operator(+) ident(Quote)operator(()char<delimiter(')content(\\)delimiter(')>operator(\)) operator(+) ident(EOL) operator(+) + string<delimiter(')content(The following name is allowed:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(s) operator(+) ident(EOL) operator(+) + string<delimiter(')content(Use this name instead?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)) operator(<>) ident(mrYes) reserved(then) reserved(begin) + ident(s) operator(:=) ident(Old)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + ident(Exit)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(try) + ident(OpenCurParent)operator(;) + reserved(if) reserved(not) ident(SameText)operator(()ident(s)operator(,) ident(Old)operator(\)) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(MainReg)operator(.)ident(KeyExists)operator(()ident(s)operator(\)) reserved(or) + operator(()ident(mrIgnore) operator(=) ident(MessageDlg)operator(() + string<delimiter(')content(Key already exists.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Click Ignore to overwrite the key.)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbCancel)operator(,) ident(mbIgnore)operator(],) integer(0)operator(\)) + operator(\)) reserved(then) reserved(begin) + ident(MainReg)operator(.)ident(DeleteKey)operator(()ident(s)operator(\);) + ident(MainReg)operator(.)ident(MoveKey)operator(()ident(Old)operator(,) ident(s)operator(,) ident(True)operator(\);) + ident(Node)operator(.)ident(Text) operator(:=) ident(Old)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(s) operator(:=) ident(Old)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) reserved(begin) comment(//change CharCase) + ident(tmp) operator(:=) ident(MainReg)operator(.)ident(GetFreeKeyName)operator(;) + ident(AddHint)operator(()string<delimiter(')content(Forced change of case using temporary key )delimiter(')> operator(+) ident(Quote)operator(()ident(tmp)operator(\)\);) + ident(MainReg)operator(.)ident(MoveKey)operator(()ident(Old)operator(,) ident(tmp)operator(,) ident(True)operator(\);) + ident(MainReg)operator(.)ident(MoveKey)operator(()ident(tmp)operator(,) ident(s)operator(,) ident(True)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + + ident(Node)operator(.)ident(Text) operator(:=) ident(s)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + ident(RegTVChange)operator(()ident(Sender)operator(,) ident(Node)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVEditing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(var) ident(AllowEdit)operator(:) ident(Boolean)operator(\);) +reserved(begin) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + reserved(if) ident(RegTV)operator(.)ident(Selected) operator(<>) ident(Node) reserved(then) + ident(Exit)operator(;) + ident(AllowEdit) operator(:=) operator(()ident(NodeInfo)operator(()ident(Node)operator(\).)ident(HostType) reserved(in) operator([)ident(uhNone)operator(,) ident(uhUserShortcut)operator(]\)) + reserved(and) operator(()reserved(not) ident(CantWrite)operator(\)) + reserved(and) ident(OpenCurKey)operator(;) + ident(MainReg)operator(.)ident(CloseKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVEndDrag)operator(()ident(Sender)operator(,) ident(Target)operator(:) ident(TObject)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) +reserved(begin) + ident(DragNode) operator(:=) reserved(nil)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + ident(ValueList)operator(.)ident(ItemFocused) operator(:=) reserved(nil)operator(;) + ident(MainWin)operator(.)ident(SetStatus)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVExpanded)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(DoSmartExpand) reserved(or) reserved(not) ident(PrefWin)operator(.)ident(SmartExpandCB)operator(.)ident(Checked) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(RegTVChange)operator(()ident(Sender)operator(,) ident(Node)operator(\);) + + comment(//SmartExpand) + reserved(if) operator(()ident(Node)operator(.)ident(Count) operator(>) integer(0)operator(\)) reserved(and) operator(()ident(ValueList)operator(.)ident(Items)operator(.)ident(Count) operator(=) integer(0)operator(\)) reserved(then) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(.)ident(GetFirstChild)operator(;) + ident(RegTVChange)operator(()ident(Sender)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Node)operator(.)ident(Count) operator(=) integer(1) reserved(then) + ident(Node)operator(.)ident(GetFirstChild)operator(.)ident(Expand)operator(()ident(False)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVExpanding)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(var) ident(AllowExpansion)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Clock)operator(:) ident(TClock)operator(;) +preprocessor({$IFDEF UNIKEY}) + ident(Uni)operator(:) ident(TUniKey)operator(;) +preprocessor({$ENDIF}) + + reserved(procedure) ident(AddKeys)operator(()ident(TreeView)operator(:) ident(TTreeView)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) ident(SL)operator(:) ident(TStrings)operator(\);) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(TreeView)operator(.)ident(Items)operator(.)ident(AddNode)operator(()ident(TTreeNode)operator(.)ident(Create)operator(()ident(TreeView)operator(.)ident(Items)operator(\),) ident(Node)operator(,) ident(SL)operator([)ident(i)operator(],) + reserved(nil)operator(,) ident(naAddChild)operator(\);) + reserved(end)operator(;) + + reserved(procedure) ident(AddKeysProgressive)operator(()ident(TreeView)operator(:) ident(TTreeView)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(SL)operator(:) ident(TStrings)operator(\);) + reserved(var) + ident(i)operator(,) ident(delta)operator(:) ident(Integer)operator(;) + ident(GaugeRect)operator(,) ident(FullRect)operator(:) ident(TRect)operator(;) + ident(GaugeWidth)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(delta) operator(:=) ident(SL)operator(.)ident(Count) reserved(div) integer(100)operator(;) + ident(GaugeWidth) operator(:=) integer(100)operator(;) + reserved(with) ident(TreeView)operator(.)ident(Canvas) reserved(do) reserved(begin) + ident(FullRect) operator(:=) ident(Node)operator(.)ident(DisplayRect)operator(()ident(True)operator(\);) + reserved(with) ident(FullRect) reserved(do) reserved(begin) + ident(Left) operator(:=) ident(Right) operator(+) integer(40)operator(;) + ident(Right) operator(:=) ident(Left) operator(+) ident(GaugeWidth) operator(+) integer(2)operator(;) + ident(Inc)operator(()ident(Top)operator(,) integer(5)operator(\);) + ident(Dec)operator(()ident(Bottom)operator(,) integer(5)operator(\);) + reserved(end)operator(;) + reserved(with) ident(Pen) reserved(do) reserved(begin) + ident(Width) operator(:=) integer(1)operator(;) + ident(Style) operator(:=) ident(psSolid)operator(;) + reserved(end)operator(;) + ident(Pen)operator(.)ident(Color) operator(:=) ident(clBrightBlue)operator(;) + ident(Brush)operator(.)ident(Style) operator(:=) ident(bsClear)operator(;) + ident(Rectangle)operator(()ident(FullRect)operator(\);) + ident(Pen)operator(.)ident(Style) operator(:=) ident(psClear)operator(;) + reserved(end)operator(;) + + ident(GaugeRect) operator(:=) ident(FullRect)operator(;) + reserved(with) ident(GaugeRect) reserved(do) reserved(begin) + ident(Inc)operator(()ident(Left)operator(\);) + ident(Inc)operator(()ident(Top)operator(\);) + ident(Dec)operator(()ident(Bottom)operator(\);) + reserved(end)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(TreeView)operator(.)ident(Items)operator(.)ident(AddNode)operator(()ident(TTreeNode)operator(.)ident(Create)operator(()ident(TreeView)operator(.)ident(Items)operator(\),) ident(Node)operator(,) ident(SL)operator([)ident(i)operator(],) + reserved(nil)operator(,) ident(naAddChild)operator(\);) + + reserved(if) operator((()ident(i) operator(+) integer(1)operator(\)) reserved(mod) ident(delta)operator(\)) operator(=) integer(0) reserved(then) reserved(begin) + reserved(with) ident(TreeView)operator(.)ident(Canvas) reserved(do) reserved(begin) + ident(GaugeRect)operator(.)ident(Right) operator(:=) ident(GaugeRect)operator(.)ident(Left) operator(+) operator(()ident(GaugeWidth) operator(*) ident(i)operator(\)) reserved(div) ident(SL)operator(.)ident(Count)operator(;) + ident(Brush)operator(.)ident(Color) operator(:=) ident(GadientAqua)operator(()integer(90) operator(+) ident(Round)operator(()integer(100) operator(*) operator((()ident(i)operator(+)integer(1)operator(\)) operator(/) ident(SL)operator(.)ident(Count)operator(\)\)\);) + ident(FillRect)operator(()ident(GaugeRect)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(with) ident(TreeView)operator(.)ident(Canvas) reserved(do) reserved(begin) + ident(Pen)operator(.)ident(Color) operator(:=) ident(clVeryBrightBlue)operator(;) + ident(Pen)operator(.)ident(Style) operator(:=) ident(psSolid)operator(;) + ident(Brush)operator(.)ident(Color) operator(:=) ident(GadientAqua)operator(()integer(200)operator(\);) + ident(Rectangle)operator(()ident(FullRect)operator(\);) + ident(Brush)operator(.)ident(Style) operator(:=) ident(bsClear)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(Exit)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(Clock) operator(:=) ident(TClock)operator(.)ident(Create)operator(;) + + reserved(try) + +preprocessor({$IFDEF UNIKEY}) + reserved(if) ident(RootOfNode)operator(()ident(Node)operator(\).)ident(ImageIndex) operator(=) ident(iconHostUni) reserved(then) reserved(begin) + ident(Uni) operator(:=) ident(UniOfNode)operator(()ident(Node)operator(\);) + reserved(if) ident(Assigned)operator(()ident(Uni)operator(\)) reserved(then) + reserved(try) + ident(Uni)operator(.)ident(GetKeyNames)operator(()ident(SL)operator(\);) + reserved(finally) + ident(Uni)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(end) reserved(else) reserved(begin) +preprocessor({$ENDIF}) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(Node)operator(\)) reserved(then) + ident(Reg)operator(.)ident(GetKeyNames)operator(()ident(SL)operator(\);) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + +preprocessor({$IFDEF UNIKEY}) + reserved(end)operator(;) +preprocessor({$ENDIF}) + + ident(Node)operator(.)ident(DeleteChildren)operator(;) + reserved(if) ident(PrefWin)operator(.)ident(ShowProgressCB)operator(.)ident(Checked) reserved(and) operator(()ident(SL)operator(.)ident(Count) operator(>) integer(100)operator(\)) reserved(then) + ident(AddKeysProgressive)operator(()ident(RegTV)operator(,) ident(Node)operator(,) ident(SL)operator(\)) + reserved(else) + ident(AddKeys)operator(()ident(RegTV)operator(,) ident(Node)operator(,) ident(SL)operator(\);) + + reserved(if) ident(PrefWin)operator(.)ident(SortKeysCB)operator(.)ident(Checked) reserved(then) + ident(Node)operator(.)ident(AlphaSort)operator(;) + + reserved(if) ident(MurphyMode) reserved(then) reserved(begin) + ident(Clock)operator(.)ident(Stop)operator(;) + ident(AddHint)operator(()ident(Format)operator(()string<delimiter(')content([MM] Key opened after %0.2f s.)delimiter(')>operator(,) operator([)ident(Clock)operator(.)ident(SecondsPassed)operator(]\)\);) + reserved(end)operator(;) + reserved(finally) + ident(Clock)operator(.)ident(Free)operator(;) + ident(SL)operator(.)ident(Free)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVGetSelectedIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + ident(Node)operator(.)ident(SelectedIndex) operator(:=) ident(Node)operator(.)ident(ImageIndex)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_SCROLL) reserved(then) + ident(CheckRegTVHotTrack)operator(;) + + reserved(if) ident(RegTV)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(ssShift) reserved(in) ident(Shift) reserved(then) + reserved(case) ident(Key) reserved(of) + ident(VK_DOWN)operator(:) reserved(begin) + ident(Node) operator(:=) ident(Node)operator(.)ident(GetNextSibling)operator(;) + reserved(if) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_UP)operator(:) reserved(begin) + ident(Node) operator(:=) ident(Node)operator(.)ident(GetPrevSibling)operator(;) + reserved(if) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_RIGHT)operator(:) ident(Key) operator(:=) ident(VK_MULTIPLY)operator(;) + ident(VK_LEFT)operator(:) ident(Key) operator(:=) ident(VK_DIVIDE)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) reserved(begin) + reserved(case) ident(Key) reserved(of) + ident(VK_END)operator(:) + reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(.)ident(Parent)operator(.)ident(GetLastChild)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_HOME)operator(:) + reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(.)ident(Parent)operator(.)ident(GetFirstChild)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(case) ident(Key) reserved(of) + integer(0)operator(:) ident(Exit)operator(;) + ident(VK_RETURN)operator(:) ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + ident(VK_DELETE)operator(:) ident(DeleteMIClick)operator(()ident(Sender)operator(\);) + ident(VK_SPACE)operator(:) reserved(begin) + ident(JumpToSel)operator(()ident(RegTV)operator(\);) + ident(Inc)operator(()ident(SpaceCount)operator(\);) + reserved(if) ident(SpaceCount) operator(>) integer(10) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(YES!)delimiter(')>operator(\);) + ident(SpaceCount) operator(:=) integer(0)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + ident(VK_F9)operator(:) ident(SwapFonts)operator(()ident(RegTV)operator(\);) + + ident(VK_F12)operator(:) + reserved(if) ident(ssShift) reserved(in) ident(Shift) reserved(then) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) ident(Node)operator(.)ident(Parent)operator(.)ident(AlphaSort)operator(;) + reserved(end) reserved(else) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) ident(Node)operator(.)ident(AlphaSort)operator(;) + + ident(VK_LEFT)operator(,) ident(VK_SUBTRACT)operator(:) + reserved(begin) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(Node)operator(.)ident(Collapse)operator(()ident(False)operator(\)) + reserved(else) reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(.)ident(Parent)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_RIGHT)operator(,) ident(VK_ADD)operator(:) + reserved(begin) + reserved(if) reserved(not) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(TreeWin)operator(.)ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(Node)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(.)ident(GetFirstChild) + reserved(else) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_MULTIPLY)operator(:) + reserved(begin) + ident(NoAsterisk) operator(:=) ident(True)operator(;) + ident(OpenNextLevel)operator(()ident(Node)operator(\);) + ident(JumpToSel)operator(()ident(RegTV)operator(\);) + ident(AddHint)operator(()string<delimiter(')content(Press the Multiply Key again to open the next level.)delimiter(')>operator(\);) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + + ident(VK_DIVIDE)operator(:) + reserved(begin) + ident(DoSmartExpand) operator(:=) ident(False)operator(;) + ident(Node)operator(.)ident(Collapse)operator(()ident(true)operator(\);) + ident(DoSmartExpand) operator(:=) ident(True)operator(;) + ident(Key) operator(:=) integer(0)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(ssctrl) reserved(in) ident(Shift) reserved(then) + reserved(case) ident(Key) reserved(of) + ident(Ord)operator(()char<delimiter(')content(C)delimiter(')>operator(\):) ident(CopyPathMIClick)operator(()ident(Sender)operator(\);) + ident(Ord)operator(()char<delimiter(')content(X)delimiter(')>operator(\):) ident(CutPathMIClick)operator(()ident(Sender)operator(\);) + ident(Ord)operator(()char<delimiter(')content(V)delimiter(')>operator(\):) ident(PasteKeyMIClick)operator(()ident(Sender)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(RelX)operator(,) ident(RelY)operator(:) ident(Integer)operator(;) + ident(NodeRect)operator(:) ident(TRect)operator(;) +reserved(begin) + ident(CheckRegTVHotTrack)operator(;) + + reserved(if) reserved(not) ident(Active) reserved(then) + ident(Exit)operator(;) + + ident(RelX) operator(:=) ident(RegTV)operator(.)ident(ScreenToClient)operator(()ident(Mouse)operator(.)ident(CursorPos)operator(\).)ident(X)operator(;) + ident(RelY) operator(:=) ident(RegTV)operator(.)ident(ScreenToClient)operator(()ident(Mouse)operator(.)ident(CursorPos)operator(\).)ident(Y)operator(;) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(GetNodeAt)operator(()ident(RelX)operator(,) ident(RelY)operator(\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Node)operator(.)ident(Selected) reserved(then) + ident(Node)operator(.)ident(Selected) operator(:=) ident(True)operator(;) + + reserved(if) ident(Button) operator(=) ident(mbLeft) reserved(then) reserved(begin) + ident(NodeRect) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(.)ident(DisplayRect)operator(()ident(True)operator(\);) + reserved(if) ident(RegTV)operator(.)ident(HotTrack) + reserved(or) operator(()ident(RelX) operator(<) ident(NodeRect)operator(.)ident(Left)operator(\)) reserved(and) operator(()ident(RelX) operator(>) ident(NodeRect)operator(.)ident(Left) operator(-) integer(20)operator(\)) reserved(then) reserved(begin) + comment(//4px more to the left (friendlier for the user\)) + reserved(if) reserved(not) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(Node)operator(,) string<delimiter(')delimiter(')>operator(\);) + ident(DoSmartExpand) operator(:=) ident(False)operator(;) + reserved(with) ident(Node) reserved(do) + reserved(if) reserved(not) ident(Expanded) reserved(then) + ident(Expand)operator(()ident(False)operator(\)) + reserved(else) + ident(Collapse)operator(()ident(False)operator(\);) + ident(DoSmartExpand) operator(:=) ident(True)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVStartDrag)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(DragObject)operator(:) ident(TDragObject)operator(\);) +reserved(begin) + ident(DragNode) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) ident(NodeInfo)operator(()ident(DragNode)operator(\).)ident(IsHost) reserved(then) + ident(DragNode) operator(:=) reserved(nil)operator(;) +reserved(end)operator(;) + +reserved(function) ident(OpenNodeError)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(;) + reserved(out) ident(Mode)operator(:) ident(TOpenNodeMode)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(Key)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(ERROR_SUCCESS)operator(;) + ident(Mode) operator(:=) ident(onNodeNil)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Reg)operator(.)ident(CloseKey)operator(;) + ident(Key) operator(:=) ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\);) + ident(Reg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(ExRegRoot)operator(()ident(Key)operator(\)\);) + ident(Result) operator(:=) ident(Reg)operator(.)ident(OpenKeyError)operator(()ident(ExRegKey)operator(()ident(Key)operator(\),) ident(False)operator(,) ident(True)operator(\);) + reserved(if) ident(Success)operator(()ident(Result)operator(\)) reserved(then) + reserved(if) ident(Reg)operator(.)ident(RootKey) operator(=) ident(HKDD) reserved(then) + ident(Mode) operator(:=) ident(onReadOnly) + reserved(else) + ident(Mode) operator(:=) ident(onFull) + reserved(else) reserved(if) ident(Reg)operator(.)ident(OpenKeyReadOnly)operator(()ident(ExRegKey)operator(()ident(Key)operator(\)\)) reserved(then) + ident(Mode) operator(:=) ident(onReadOnly) + reserved(else) + ident(Mode) operator(:=) ident(onError)operator(;) +reserved(end)operator(;) + +reserved(function) ident(OpenNode)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(TOpenNodeMode)operator(;) +reserved(begin) + ident(OpenNodeError)operator(()ident(Reg)operator(,) ident(Node)operator(,) ident(Result)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(OpenNodeOK)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(OpenNode)operator(()ident(Reg)operator(,) ident(Node)operator(\)) reserved(in) ident(onOK)operator(;) +reserved(end)operator(;) + +reserved(function) ident(OpenCurKey)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(OpenNodeOK)operator(()ident(MainReg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(OpenCurParent)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Assigned)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)) + reserved(and) ident(OpenNodeOK)operator(()ident(MainReg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(.)ident(Parent)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TTreeWin)operator(.)ident(CreateKey)operator(()ident(Subkey)operator(:) ident(Boolean)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(Node)operator(,) ident(NewNode)operator(:) ident(TTreeNode)operator(;) + ident(KeyName)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + + reserved(if) ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Subkey) reserved(then) reserved(begin) + comment(//key shall be created on same level...) + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(0) reserved(then) reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\)) operator(<>) ident(PathOfNode)operator(()ident(Node)operator(\)) reserved(then) + comment(//check for shortcut: shortcuts are unequal to their trace) + reserved(if) ident(mrOK) operator(=) ident(MessageDlg)operator(() + string<delimiter(')content(You are trying to create a Key in the shortcut)char('')content(s level.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Pluto needs to jump to the target of the shortcut to do this.)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbOK)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) reserved(begin) + ident(MainWin)operator(.)ident(GotoKey)operator(()ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\)\);) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(.)ident(Parent)operator(;) + reserved(end) reserved(else) ident(Exit) + reserved(else) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Key is a HKEY.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(It is not possible to create Keys on HKEY level.)delimiter(')>operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(end) reserved(else) + ident(Node) operator(:=) ident(Node)operator(.)ident(Parent)operator(;) comment(//set reference key to parent) + reserved(end)operator(;) + + reserved(try) + + reserved(case) ident(OpenNode)operator(()ident(MainReg)operator(,) ident(Node)operator(\)) reserved(of) + + ident(onFull)operator(:) reserved(begin) + ident(KeyName) operator(:=) string<delimiter(')content(New)delimiter(')>operator(;) comment(//find best free name) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(MainReg)operator(.)ident(KeyExists)operator(()ident(KeyName)operator(\)) reserved(do) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(KeyName) operator(:=) string<delimiter(')content(New )delimiter(')> operator(+) ident(IntToStr)operator(()ident(i)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(MainReg)operator(.)ident(CreateKey)operator(()ident(KeyName)operator(\)) reserved(and) ident(MainReg)operator(.)ident(KeyExists)operator(()ident(KeyName)operator(\);) + comment(// ^-- CREATE KEY) + + reserved(if) reserved(not) ident(Result) reserved(then) comment(// <-- FAILED) + ident(ShowMessage)operator(()string<delimiter(')content(Could not create key!)delimiter(')>operator(\);) + reserved(end)operator(;) + + ident(onReadOnly)operator(:) ident(ShowMessage)operator(()string<delimiter(')content(Key is read-only.)delimiter(')>operator(\);) + + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Couldn)char('')content(t open key.)delimiter(')>operator(\);) + + reserved(end)operator(;) comment(//case) + + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Result) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Node)operator(.)ident(Expanded) reserved(then) reserved(begin) comment(//find the node, if Parent not Expanded) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + ident(DoSmartExpand) operator(:=) ident(False)operator(;) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + ident(DoSmartExpand) operator(:=) ident(True)operator(;) + ident(NewNode) operator(:=) ident(FindNode)operator(()ident(Node)operator(,) ident(KeyName)operator(\);) + reserved(end) reserved(else) + ident(NewNode) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(Node)operator(,) ident(KeyName)operator(\);) comment(//else create a new node) + + ident(Result) operator(:=) ident(Assigned)operator(()ident(NewNode)operator(\);) + reserved(if) reserved(not) ident(Result) reserved(then) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Could not find created key.)delimiter(')>operator(\);) + + reserved(if) ident(Result) reserved(then) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(NewNode)operator(;) + ident(RegTV)operator(.)ident(Selected)operator(.)ident(EditText)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(CloneKey)operator(;) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(Full)operator(:) ident(TRegPath)operator(;) + ident(MainKey)operator(,) ident(SubKey)operator(,) ident(NewKey)operator(,) ident(zKey)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(integer)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + + reserved(if) ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(NodeInfo)operator(()ident(Node)operator(\).)ident(IsHost) reserved(then) + ident(Exit)operator(;) + + ident(Full) operator(:=) ident(CurKey)operator(()ident(uhNonSystemShortcuts)operator(\);) + ident(MainKey) operator(:=) ident(LWPSolve)operator(()ident(Full)operator(.)ident(Key)operator(\);) + ident(SubKey) operator(:=) ident(FromLastChar)operator(()ident(MainKey)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\);) + ident(MainKey) operator(:=) ident(UntilLastChar)operator(()ident(MainKey)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\);) + reserved(if) ident(SubKey) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) comment(//Directly beyound HKEY) + ident(SubKey) operator(:=) ident(MainKey)operator(;) + ident(MainKey) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(end)operator(;) + + reserved(try) + ident(MainReg)operator(.)ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(Full)operator(.)ident(Root)operator(\);) + reserved(if) reserved(not) ident(MainReg)operator(.)ident(OpenKey)operator(()ident(MainKey)operator(,) ident(False)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Couldn)char('')content(t not open Key: )delimiter(')> operator(+) ident(MainKey)operator(\);) + ident(Exit) reserved(end)operator(;) + reserved(if) ident(Copy)operator(()ident(SubKey)operator(,) integer(1)operator(,) integer(3)operator(\)) operator(<>) string<delimiter(')content(New)delimiter(')> reserved(then) + ident(NewKey) operator(:=) string<delimiter(')content(New )delimiter(')> operator(+) ident(SubKey) + reserved(else) + ident(NewKey) operator(:=) ident(SubKey)operator(;) + + ident(zKey) operator(:=) ident(Trim)operator(()ident(FromLastChar)operator(()ident(NewKey)operator(,) char<delimiter(')content( )delimiter(')>operator(\)\);) + + ident(i) operator(:=) ident(StrToIntDef)operator(()ident(zKey)operator(,) integer(0)operator(\);) + reserved(if) ident(IsValidInteger)operator(()ident(zKey)operator(\)) reserved(then) + ident(zKey) operator(:=) ident(Trim)operator(()ident(UntilLastChar)operator(()ident(NewKey)operator(,) char<delimiter(')content( )delimiter(')>operator(\)\)) + reserved(else) + ident(zKey) operator(:=) ident(NewKey)operator(;) + + reserved(while) ident(MainReg)operator(.)ident(KeyExists)operator(()ident(NewKey)operator(\)) reserved(do) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(NewKey) operator(:=) ident(zKey) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(IntToStr)operator(()ident(i)operator(\);) + reserved(end)operator(;) + + ident(MainReg)operator(.)ident(MoveKey)operator(()ident(SubKey)operator(,) ident(NewKey)operator(,) ident(False)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(Add)operator(()ident(Node)operator(,) ident(NewKey)operator(\);) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node)operator(;) + ident(Node)operator(.)ident(EditText)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(NewShortcut)operator(;) +reserved(var) + ident(Node)operator(,) ident(ShortCutNode)operator(:) ident(TTreeNode)operator(;) + ident(ScName)operator(,) ident(ScRealPath)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(0) reserved(then) + ident(ScName) operator(:=) string<delimiter(')content(new )delimiter(')> operator(+) ident(Node)operator(.)ident(Text) + reserved(else) + ident(ScName) operator(:=) string<delimiter(')delimiter(')> operator(+) ident(Node)operator(.)ident(Text)operator(;) + + ident(ScRealPath) operator(:=) ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\);) + reserved(if) reserved(not) ident(InputQuery)operator(()string<delimiter(')content(New shortcut to )delimiter(')>operator(,) ident(ScRealPath)operator(,) ident(ScName)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(ShortCuts)operator(\)) reserved(do) + reserved(if) ident(SameText)operator(()ident(ScName)operator(,) ident(ShortCuts)operator([)ident(i)operator(].)ident(Alias)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Name already in use.)delimiter(')>operator(\);) + ident(NewShortcut)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(ShortCutNode) operator(:=) ident(AddShortcut)operator(()ident(ScName)operator(,) ident(ScRealPath)operator(,) ident(iconShortcut)operator(,) ident(uhUserShortcut)operator(,) + ident(True)operator(\);) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(ShortCutNode)operator(;) +reserved(end)operator(;) + +reserved(function) ident(AddShortcut)operator(()ident(Alias)operator(,) ident(RealPath)operator(:) reserved(string)operator(;) ident(Icon)operator(:) ident(Integer)operator(;) + ident(AHostType)operator(:) ident(TUniHostType) operator(=) ident(uhUserShortcut)operator(;) + ident(WriteIni)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(TTreeNode)operator(;) +reserved(var) + ident(Last)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(RealPath) operator(:=) ident(TraceKey)operator(()ident(RealPath)operator(\);) comment(//Important: do this BEFORE adding a new,) + comment(//empty shortcut to ShortCuts) + + ident(SetLength)operator(()ident(ShortCuts)operator(,) ident(Length)operator(()ident(ShortCuts)operator(\)) operator(+) integer(1)operator(\);) + ident(Last) operator(:=) ident(High)operator(()ident(Shortcuts)operator(\);) + ident(ShortCuts)operator([)ident(Last)operator(].)ident(Alias) operator(:=) ident(Alias)operator(;) + ident(ShortCuts)operator([)ident(Last)operator(].)ident(RealPath) operator(:=) ident(RealPath)operator(;) + + ident(Result) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(Add)operator(()reserved(nil)operator(,) ident(Alias)operator(\);) + ident(ShortCuts)operator([)ident(Last)operator(].)ident(Node) operator(:=) ident(Result)operator(;) + + reserved(if) ident(Alias) operator(=) string<delimiter(')content(HKEY_WindowsMachine)delimiter(')> reserved(then) + ident(Icon) operator(:=) ident(iconHKWM) + reserved(else) reserved(if) ident(Alias) operator(=) string<delimiter(')content(HKEY_WindowsUser)delimiter(')> reserved(then) + ident(Icon) operator(:=) ident(iconHKWU)operator(;) + ident(SetTNImage)operator(()ident(Result)operator(,) ident(Icon)operator(\);) + + ident(NodeInfo)operator(()ident(Result)operator(\).)ident(HostType) operator(:=) ident(AHostType)operator(;) + + reserved(if) ident(WriteIni) reserved(then) + reserved(with) ident(TIniFile)operator(.)ident(Create)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(WriteString)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Alias)operator(,) ident(RealPath)operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(DeleteKey)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Node)operator(,) ident(Node2)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + + + ident(i) operator(:=) ident(ShortcutIndex)operator(()ident(Node)operator(\);) + reserved(if) operator(()ident(i) operator(>) operator(-)integer(1)operator(\)) reserved(then) reserved(begin) + reserved(if) operator(()ident(mrYes) operator(=) ident(MessageDlg)operator(()string<delimiter(')content(This is a Pluto shortcut to a real key.)delimiter(')>char(#13)char(#10) operator(+) + string<delimiter(')content(Do you really want to delete the shortcut?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)\)) reserved(then) reserved(begin) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + reserved(with) ident(TIniFile)operator(.)ident(Create)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(DeleteKey)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Shortcuts)operator([)ident(i)operator(].)ident(Alias)operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) + ident(Shortcuts)operator([)ident(i)operator(]) operator(:=) ident(Shortcuts)operator([)ident(High)operator(()ident(Shortcuts)operator(\)];) + ident(SetLength)operator(()ident(Shortcuts)operator(,) ident(Length)operator(()ident(Shortcuts)operator(\)-)integer(1)operator(\);) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(GetNextBest)operator(()ident(Node)operator(\);) + ident(Node)operator(.)ident(Delete)operator(;) + ident(RegTVChange)operator(()ident(Self)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) + ident(SpyThread)operator(.)ident(Resume)operator(;) + reserved(end)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(NodeInfo)operator(()ident(Node)operator(\).)ident(IsHost) reserved(then) + ident(Exit)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + + ident(Node2) operator(:=) ident(GetNextBest)operator(()ident(Node)operator(\);) + + reserved(if) ident(MessageDlg)operator(()string<delimiter(')content(Do you really want to delete this key?)delimiter(')>operator(,) ident(mtConfirmation)operator(,) + operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) operator(=) ident(mrYes) reserved(then) + reserved(try) + reserved(if) ident(OpenCurParent) reserved(then) reserved(begin) + reserved(if) reserved(not) ident(MainReg)operator(.)ident(DeleteKey)operator(()ident(Node)operator(.)ident(Text)operator(\)) reserved(then) comment(//<-- DELETE KEY) + ident(ShowMessage)operator(()string<delimiter(')content(Key could not be deleted.)delimiter(')>operator(\)) + reserved(else) reserved(begin) + ident(RegTV)operator(.)ident(Selected) operator(:=) ident(Node2)operator(;) + reserved(if) ident(Assigned)operator(()ident(Node)operator(.)ident(Parent)operator(\)) reserved(and) operator(()ident(Node2) operator(=) ident(Node)operator(.)ident(Parent)operator(\)) reserved(then) + ident(Node)operator(.)ident(Parent)operator(.)ident(Collapse)operator(()ident(False)operator(\);) + ident(Node)operator(.)ident(Delete)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + + ident(RegTVChange)operator(()ident(Self)operator(,) ident(Node2)operator(\);) + + ident(SpyThread)operator(.)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(MoveKey)operator(()reserved(const) ident(Src)operator(,) ident(Trg)operator(:) ident(TRegPath)operator(;) ident(CopyWanted)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(TrgReg)operator(:) ident(TXRegistry)operator(;) +reserved(begin) + reserved(with) ident(MainReg) reserved(do) reserved(begin) + ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(Src)operator(.)ident(Root)operator(\);) + ident(OpenKey)operator(()string<delimiter(')delimiter(')>operator(\);) + + reserved(if) reserved(not) ident(KeyExists)operator(()ident(Src)operator(.)ident(Key)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Source not found.)delimiter(')>operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + ident(TrgReg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(with) ident(TrgReg) reserved(do) reserved(begin) + ident(RootKey) operator(:=) ident(HKEYOfStr)operator(()ident(Trg)operator(.)ident(Root)operator(\);) + ident(OpenKey)operator(()string<delimiter(')delimiter(')>operator(\);) + reserved(if) ident(KeyExists)operator(()ident(Trg)operator(.)ident(Key)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Target already existing.)delimiter(')>operator(\);) + ident(TrgReg)operator(.)ident(Free)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(CopyWanted) reserved(then) + reserved(if) ident(mrYes) operator(<>) ident(MessageDlg)operator(()string<delimiter(')content(From source: )delimiter(')> operator(+) ident(StrOfRegPath)operator(()ident(Src)operator(\)) operator(+) ident(EOL) operator(+) + string<delimiter(')content(To target: )delimiter(')> operator(+) ident(StrOfRegPath)operator(()ident(Trg)operator(\)) operator(+) ident(EOL) operator(+) + string<delimiter(')content(Do you really want to move this key?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) + reserved(then) + ident(Exit)operator(;) + + reserved(try) + ident(MainReg)operator(.)ident(MoveKey)operator(()ident(Src)operator(.)ident(Key)operator(,) ident(TrgReg)operator(,) ident(Trg)operator(.)ident(Key)operator(,) reserved(not) ident(CopyWanted)operator(\);) comment(//<-- MOVE KEY) + reserved(except) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(TrgReg)operator(.)ident(OpenKey)operator(()ident(Trg)operator(.)ident(Key)operator(,) ident(False)operator(\)) reserved(then) + ident(ShowMessage)operator(()string<delimiter(')content(Could not move key!)delimiter(')>operator(\)) + reserved(else) + reserved(if) reserved(not) ident(CopyWanted) reserved(then) + ident(DragNode)operator(.)ident(Delete)operator(;) + + + ident(TrgReg)operator(.)ident(Free)operator(;) + + ident(MainReg)operator(.)ident(CloseKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(MoveValues)operator(()ident(SrcNode)operator(,) ident(TrgNode)operator(:) ident(TTreeNode)operator(;) + ident(CopyWanted)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(SrcReg)operator(,) ident(TrgReg)operator(:) ident(TXRegistry)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(ValueName)operator(:) reserved(string)operator(;) + ident(AnswerToAll)operator(:) ident(Integer)operator(;) + + reserved(function) ident(AskForReplacing)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) + reserved(begin) + reserved(if) ident(AnswerToAll) operator(=) operator(-)integer(1) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(MessageDlg)operator(() + string<delimiter(')content(Value )delimiter(')> operator(+) ident(Quote)operator(()ident(ValueName)operator(\)) operator(+) string<delimiter(')content(already exists in target key.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Do you want to replace it?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbNo)operator(,) ident(mbYes)operator(,) ident(mbNoToAll)operator(,) ident(mbYesToAll)operator(,) ident(mbAbort)operator(],) integer(0)operator(\);) + reserved(if) ident(Result) reserved(in) operator([)ident(mrNoToAll)operator(,) ident(mrYesToAll)operator(]) reserved(then) reserved(begin) + reserved(if) ident(Result) operator(=) ident(mrYesToAll) reserved(then) + ident(Result) operator(:=) ident(mrYes) + reserved(else) reserved(if) ident(Result) operator(=) ident(mrNoToAll) reserved(then) + ident(Result) operator(:=) ident(mrNo)operator(;) + ident(AnswerToAll) operator(:=) ident(Result)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) ident(Result) operator(:=) ident(AnswerToAll)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(AnswerToAll) operator(:=) operator(-)integer(1)operator(;) + + reserved(if) reserved(not) ident(CopyWanted) reserved(then) + reserved(if) ident(mrYes)operator(<>)ident(MessageDlg)operator(() + ident(Format)operator(() + string<delimiter(')content(Do you really want to move %s)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(from: %s)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(to: %s)delimiter(')>operator(,) + operator([)ident(StrNumerus)operator(()ident(ValueList)operator(.)ident(SelCount)operator(,) string<delimiter(')content(value)delimiter(')>operator(,) string<delimiter(')content(values)delimiter(')>operator(\),) + ident(PathOfNode)operator(()ident(SrcNode)operator(\),) ident(PathOfNode)operator(()ident(TrgNode)operator(\)]) + operator(\),) ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbAbort)operator(],) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(SrcReg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) reserved(not) operator(()ident(OpenNode)operator(()ident(SrcReg)operator(,) ident(SrcNode)operator(\)) reserved(in) ident(onOK)operator(\)) reserved(then) + ident(MessageDlg)operator(()string<delimiter(')content(Couldn)char('')content(t open source key: )delimiter(')> operator(+) ident(PathOfNode)operator(()ident(SrcNode)operator(\),) + ident(mtError)operator(,) operator([)ident(mbOK)operator(],) integer(0)operator(\);) + + ident(TrgReg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) reserved(not) operator(()ident(OpenNode)operator(()ident(TrgReg)operator(,) ident(TrgNode)operator(\)) reserved(in) ident(onOK)operator(\)) reserved(then) + ident(MessageDlg)operator(()string<delimiter(')content(Couldn)char('')content(t open target key: )delimiter(')> operator(+) ident(PathOfNode)operator(()ident(TrgNode)operator(\),) + ident(mtError)operator(,) operator([)ident(mbOK)operator(],) integer(0)operator(\);) + + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) reserved(not) ident(Item)operator([)ident(i)operator(].)ident(Selected) reserved(then) + ident(Continue)operator(;) + ident(ValueName) operator(:=) ident(RealValueName)operator(()ident(Item)operator([)ident(i)operator(]\);) + + reserved(if) ident(TrgReg)operator(.)ident(ValueExists)operator(()ident(ValueName)operator(\)) reserved(then) reserved(begin) + reserved(case) ident(AskForReplacing)operator(()ident(ValueName)operator(\)) reserved(of) + ident(mrYes)operator(:) operator(;) + ident(mrNo)operator(:) ident(Continue)operator(;) + ident(mrAbort)operator(:) ident(Break)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(TrgReg)operator(.)ident(WriteContext)operator(()ident(ValueName)operator(,) ident(SrcReg)operator(.)ident(ReadContext)operator(()ident(ValueName)operator(\)\);) + reserved(if) reserved(not) ident(CopyWanted) reserved(then) + ident(SrcReg)operator(.)ident(DeleteValue)operator(()ident(ValueName)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(finally) + ident(TrgReg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(finally) + ident(SrcReg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(CopyWanted) reserved(then) + ident(ValuesWin)operator(.)ident(Reload)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(NewSubKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateKey)operator(()ident(True)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(NewKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateKey)operator(()ident(False)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(CreateShortcutMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NewShortcut)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(TraceMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(NodeInfo)operator(()ident(RegTV)operator(.)ident(Selected)operator(\).)ident(IsShortcut) reserved(then) + ident(MainWin)operator(.)ident(GotoKey)operator(()ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(DeleteMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(RegTV)operator(.)ident(IsEditing) reserved(then) + ident(DeleteKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(DublicateMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CloneKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(FindMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FindWin)operator(.)ident(SfCurKeyRB)operator(.)ident(Checked) operator(:=) ident(True)operator(;) + ident(FindWin)operator(.)ident(Show)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(RegTVChange)operator(()ident(Sender)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) + reserved(with) ident(NodeInfo)operator(()ident(RegTV)operator(.)ident(Selected)operator(\)) reserved(do) reserved(begin) + ident(NewSubKeyMI)operator(.)ident(Enabled) operator(:=) reserved(not) ident(CantWrite)operator(;) + ident(NewKeyMI)operator(.)ident(Enabled) operator(:=) reserved(not) ident(CantWrite) reserved(and) operator(()reserved(not) ident(IsHost) reserved(or) ident(IsShortcut)operator(\);) + ident(DublicateMI)operator(.)ident(Enabled) operator(:=) reserved(not) ident(CantWrite) reserved(and) reserved(not) ident(IsHost)operator(;) + + reserved(with) ident(DeleteMI) reserved(do) + reserved(if) ident(HostType) operator(=) ident(uhUserShortcut) reserved(then) reserved(begin) + ident(Caption) operator(:=) string<delimiter(')content(&Delete Shortcut)delimiter(')>operator(;) + ident(Enabled) operator(:=) ident(True)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(Caption) operator(:=) string<delimiter(')content(&Delete)delimiter(')>operator(;) + ident(Enabled) operator(:=) reserved(not) ident(CantWrite) reserved(and) reserved(not) ident(IsHost)operator(;) + reserved(end)operator(;) + + ident(RenameMI)operator(.)ident(Enabled) operator(:=) reserved(not) ident(CantWrite) reserved(and) operator(()ident(HostType) reserved(in) operator([)ident(uhNone)operator(,) ident(uhUserShortcut)operator(]\);) + ident(TraceMI)operator(.)ident(Visible) operator(:=) ident(IsShortcut)operator(;) + ident(EditShortcutMI)operator(.)ident(Visible) operator(:=) ident(HostType) operator(=) ident(uhUserShortcut)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(CheckNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(;) ident(OnlyOnce)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(TakeNodeSelected)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) +reserved(var) + ident(CurIcon)operator(,) ident(NewIcon)operator(:) ident(Integer)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(OpenMode)operator(:) ident(TOpenNodeMode)operator(;) + ident(Info)operator(:) ident(TNodeInfo)operator(;) +preprocessor({$IFDEF UNIKEY}) + ident(Uni)operator(:) ident(TUniKey)operator(;) +preprocessor({$ENDIF}) + ident(KeyHasChildren)operator(:) ident(Boolean)operator(;) + + reserved(procedure) ident(SetShortcutIcon)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(var) + ident(Full)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(Full) operator(:=) ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\);) + reserved(for) ident(i) operator(:=) ident(Low)operator(()ident(Shortcuts)operator(\)) reserved(to) ident(High)operator(()ident(Shortcuts)operator(\)) reserved(do) + reserved(if) ident(Full) operator(=) ident(Shortcuts)operator([)ident(i)operator(].)ident(RealPath) reserved(then) reserved(begin) + ident(CurIcon) operator(:=) ident(Shortcuts)operator([)ident(i)operator(].)ident(Node)operator(.)ident(ImageIndex)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(if) ident(Node)operator(.)ident(ImageIndex) reserved(in) operator([)ident(iconShortcut)operator(,) ident(iconShortcut) operator(+) integer(1)operator(]) reserved(then) + ident(CurIcon) operator(:=) ident(iconKey) operator(+) operator(()ident(CurIcon) operator(-) ident(iconShortcut)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Info) operator(:=) ident(NodeInfo)operator(()ident(Node)operator(\);) + reserved(if) ident(OnlyOnce) reserved(and) ident(Info)operator(.)ident(Checked) reserved(then) + ident(Exit)operator(;) + + ident(CurIcon) operator(:=) ident(Node)operator(.)ident(ImageIndex)operator(;) + reserved(if) operator(()ident(CurIcon) operator(>) ident(iconFirstType)operator(\)) reserved(then) reserved(begin) +preprocessor({$IFDEF UNIKEY}) + reserved(if) ident(RootOfNode)operator(()ident(Node)operator(\).)ident(ImageIndex) operator(<>) ident(iconHostUni) reserved(then) reserved(begin) + ident(SetShortcutIcon)operator(()ident(Node)operator(\);) + ident(CurIcon) operator(:=) operator(()ident(CurIcon) reserved(div) integer(2)operator(\)) operator(*) integer(2)operator(;) + reserved(end)operator(;) +preprocessor({$ELSE}) + ident(Exit)operator(;) +preprocessor({$ENDIF}) + reserved(end) reserved(else) reserved(begin) + ident(SetShortcutIcon)operator(()ident(Node)operator(\);) + ident(CurIcon) operator(:=) operator(()ident(CurIcon) reserved(div) integer(2)operator(\)) operator(*) integer(2)operator(;) + reserved(end)operator(;) + ident(NewIcon) operator(:=) ident(CurIcon)operator(;) + + ident(Info)operator(.)ident(ExcludeFlag)operator(()ident(nfDefect)operator(\);) + ident(Info)operator(.)ident(ExcludeFlag)operator(()ident(nfReadOnly)operator(\);) + +preprocessor({$IFDEF UNIKEY}) + ident(KeyHasChildren) operator(:=) ident(False)operator(;) + + reserved(if) ident(RootOfNode)operator(()ident(Node)operator(\).)ident(ImageIndex) operator(=) ident(iconHostUni) reserved(then) reserved(begin) + ident(Uni) operator(:=) ident(UniOfNode)operator(()ident(Node)operator(\);) + reserved(if) ident(Assigned)operator(()ident(Uni)operator(\)) reserved(then) + reserved(try) + ident(KeyHasChildren) operator(:=) ident(Uni)operator(.)ident(HasKeys)operator(;) + reserved(if) ident(usReadOnly) operator(>=) ident(Uni)operator(.)ident(Skills) reserved(then) + ident(OpenMode) operator(:=) ident(onReadOnly) + reserved(else) + ident(OpenMode) operator(:=) ident(onFull)operator(;) + reserved(finally) + ident(Uni)operator(.)ident(Free)operator(;) + reserved(end) + reserved(else) + ident(OpenMode) operator(:=) ident(onError)operator(;) + reserved(end) reserved(else) reserved(begin) +preprocessor({$ENDIF}) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + ident(OpenMode) operator(:=) ident(OpenNode)operator(()ident(Reg)operator(,) ident(Node)operator(\);) + ident(KeyHasChildren) operator(:=) ident(Reg)operator(.)ident(HasSubKeys)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +preprocessor({$IFDEF UNIKEY}) + reserved(end)operator(;) +preprocessor({$ENDIF}) + + reserved(if) ident(OpenMode) operator(=) ident(onReadOnly) reserved(then) + ident(Info)operator(.)ident(IncludeFlag)operator(()ident(nfReadOnly)operator(\);) + + reserved(if) ident(OpenMode) reserved(in) ident(onOK) reserved(then) reserved(begin) + comment(//OK, could open) + reserved(if) reserved(not) ident(Node)operator(.)ident(Expanded) reserved(then) reserved(begin) comment(//Collapsed) + reserved(if) ident(KeyHasChildren) reserved(then) reserved(begin) comment(//HasSubKeys) + reserved(if) reserved(not) ident(Node)operator(.)ident(HasChildren) reserved(then) reserved(begin) + comment(//Update: Ensure HasChildren) + reserved(if) ident(TakeNodeSelected) reserved(or) ident(Node)operator(.)ident(Selected) reserved(then) + ident(TreeWin)operator(.)ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(Node)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(end)operator(;) + comment(//Ensure Plus-Icon) + ident(NewIcon) operator(:=) ident(CurIcon) operator(+) integer(1)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//Has still Children?) + reserved(if) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(Node)operator(.)ident(DeleteChildren)operator(;) + reserved(end)operator(;) + + reserved(end) reserved(else) reserved(begin) comment(//Expanded) + comment(//HasSubKeys?) + reserved(if) ident(KeyHasChildren) reserved(then) reserved(begin) + comment(//OK) + ident(NewIcon) operator(:=) ident(CurIcon) operator(+) integer(1)operator(;) + reserved(end) reserved(else) reserved(begin) + comment(//not OK --> update) + ident(Node)operator(.)ident(Collapse)operator(()ident(True)operator(\);) + ident(Node)operator(.)ident(DeleteChildren)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + comment(//not OK, couldn't open) + reserved(end) reserved(else) reserved(begin) comment(//defect) + reserved(if) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(Node)operator(.)ident(DeleteChildren)operator(;) + ident(Info)operator(.)ident(IncludeFlag)operator(()ident(nfDefect)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Node)operator(.)ident(ImageIndex) operator(<>) ident(iconHostUni) reserved(then) comment(//don't change icon of UniHosts) + ident(Node)operator(.)ident(ImageIndex) operator(:=) ident(NewIcon)operator(;) + + ident(Info)operator(.)ident(IncludeFlag)operator(()ident(nfChecked)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + ident(MainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(,) ident(Key)operator(,) ident(Shift)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ShortcutIndex)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Integer)operator(;) +comment(//If Node is a Shortcut,) +comment(//S. returns its index in the Shortcuts array) +comment(//else -1) +reserved(begin) + reserved(if) ident(Node)operator(.)ident(Level) operator(>) integer(0) reserved(then) reserved(begin) + ident(Result) operator(:=) operator(-)integer(1)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(for) ident(Result) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Shortcuts)operator(\)) reserved(do) + reserved(if) ident(Shortcuts)operator([)ident(Result)operator(].)ident(Node) operator(=) ident(Node) reserved(then) reserved(begin) + ident(Exit)operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TraceKey)operator(()reserved(const) ident(Path)operator(:) reserved(string)operator(;) ident(AllowedShortcutTypes)operator(:) ident(TUniHostTypes) operator(=) + ident(uhNonSystemShortcuts)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(isAim)operator(:) ident(Boolean)operator(;) + + reserved(function) ident(NodeOkForTracing)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\):) ident(Boolean)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(Assigned)operator(()ident(Node)operator(\)) reserved(and) + operator(()ident(NodeInfo)operator(()ident(Node)operator(\).)ident(HostType) reserved(in) ident(AllowedShortcutTypes)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) ident(MakeLongHKEY)operator(()ident(Path)operator(\);) + reserved(repeat) + ident(isAim) operator(:=) ident(True)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(ShortCuts)operator(\)) reserved(do) reserved(begin) + reserved(with) ident(Shortcuts)operator([)ident(i)operator(]) reserved(do) + reserved(if) ident(NodeOkForTracing)operator(()ident(Node)operator(\)) reserved(and) + ident(SameText)operator(()ident(UntilChar)operator(()ident(Result)operator(,) char<delimiter(')content(\\)delimiter(')>operator(\),) ident(Alias)operator(\)) reserved(then) reserved(begin) + reserved(if) ident(Alias) operator(=) ident(RealPath) reserved(then) + ident(Break)operator(;) + ident(Delete)operator(()ident(Result)operator(,) integer(1)operator(,) ident(Length)operator(()ident(Alias)operator(\)\);) + ident(Result) operator(:=) ident(RealPath) operator(+) ident(Result)operator(;) + ident(isAim) operator(:=) ident(False)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + reserved(until) ident(isAim)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVKeyPress)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Char)operator(\);) +reserved(begin) + reserved(if) operator(()ident(Key) operator(=) char<delimiter(')content(*)delimiter(')>operator(\)) reserved(and) ident(NoAsterisk) reserved(then) reserved(begin) + ident(Key) operator(:=) char(#0)operator(;) + ident(NoAsterisk) operator(:=) ident(False)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVAdvancedCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) ident(Stage)operator(:) ident(TCustomDrawStage)operator(;) + reserved(var) ident(PaintImages)operator(,) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(Rect)operator(:) ident(TRect)operator(;) + ident(MainValueName)operator(:) reserved(string)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Info)operator(:) ident(TRegKeyInfo)operator(;) + ident(PreviewPosX)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(DefaultIconPreview)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(\);) + reserved(var) + ident(Icon)operator(:) ident(HICON)operator(;) + ident(IconFile)operator(:) reserved(string)operator(;) + reserved(begin) + reserved(if) operator(()ident(Node)operator(.)ident(Level) operator(=) integer(0)operator(\)) reserved(and) reserved(not) ident(RegTV)operator(.)ident(ShowLines) reserved(then) + ident(Exit)operator(;) + + ident(IconFile) operator(:=) ident(Reg)operator(.)ident(ReadDefaultIcon)operator(;) + reserved(if) ident(IconFile) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Exit)operator(;) + + ident(Icon) operator(:=) ident(GetIconFromFile)operator(()ident(ExpandString)operator(()ident(IconFile)operator(\)\);) + reserved(if) ident(Icon) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(Rect) reserved(do) reserved(begin) + ident(Dec)operator(()ident(Left)operator(,) ident(TTreeView)operator(()ident(Sender)operator(\).)ident(Indent) operator(+) integer(16)operator(\);) + ident(DrawIconEx)operator(()ident(Sender)operator(.)ident(Canvas)operator(.)ident(Handle)operator(,) ident(Left)operator(,) ident(Top)operator(,) + ident(Icon)operator(,) integer(16)operator(,) integer(16)operator(,) + integer(0)operator(,) integer(0)operator(,) ident(DI_NORMAL)operator(\);) + ident(DestroyIcon)operator(()ident(Icon)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(AddPreview)operator(()reserved(const) ident(PreviewText)operator(:) reserved(string)operator(;) ident(Color)operator(:) ident(TColor)operator(\);) + reserved(begin) + reserved(with) ident(Sender)operator(.)ident(Canvas) reserved(do) reserved(begin) + ident(SetTextColor)operator(()ident(Handle)operator(,) ident(Color)operator(\);) + ident(ExtTextOut)operator(()ident(Handle)operator(,) ident(PreviewPosX)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(1)operator(,) ident(TextFlags)operator(,) reserved(nil)operator(,) + ident(PChar)operator(()ident(PreviewText)operator(\),) ident(Length)operator(()ident(PreviewText)operator(\),) reserved(nil)operator(\);) + ident(Inc)operator(()ident(PreviewPosX)operator(,) ident(TextWidth)operator(()ident(PreviewText)operator(\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(Stage) operator(<>) ident(cdPostPaint) reserved(then) + ident(Exit)operator(;) + + ident(MainValueName) operator(:=) ident(PrefWin)operator(.)ident(MainPreviewE)operator(.)ident(Text)operator(;) + + ident(Rect) operator(:=) ident(Node)operator(.)ident(DisplayRect)operator(()ident(True)operator(\);) + ident(PreviewPosX) operator(:=) ident(Rect)operator(.)ident(Right) operator(+) integer(5)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(()ident(KEY_READ)operator(\);) + reserved(try) + reserved(if) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(Node)operator(\)) reserved(then) reserved(begin) +comment(// Sender.Canvas.Font.Style := [];) + reserved(if) ident(PrefWin)operator(.)ident(KeyInfoPreviewCB)operator(.)ident(Checked) reserved(and) ident(Reg)operator(.)ident(GetKeyInfo)operator(()ident(Info)operator(\)) reserved(then) + reserved(with) ident(Info) reserved(do) reserved(begin) + reserved(if) ident(NumSubKeys) operator(>) integer(0) reserved(then) + ident(AddPreview)operator(()ident(IntToStr)operator(()ident(NumSubKeys)operator(\)) operator(+) string<delimiter(')content(k )delimiter(')>operator(,) ident(clCyan)operator(\);) + reserved(if) ident(NumValues) operator(>) integer(0) reserved(then) + ident(AddPreview)operator(()ident(IntToStr)operator(()ident(NumValues)operator(\)) operator(+) string<delimiter(')content(v )delimiter(')>operator(,) ident(clBrightPurple)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(PrefWin)operator(.)ident(MainPreviewCB)operator(.)ident(Checked) reserved(then) + reserved(if) ident(Reg)operator(.)ident(ValueReallyExists)operator(()ident(MainValueName)operator(\)) reserved(then) + ident(AddPreview)operator(()ident(DataPreviewOfContext)operator(()ident(Reg)operator(.)ident(ReadContext)operator(()ident(MainValueName)operator(\)\),) hex($00AAFFFF)operator(\);) + comment({clBrightYellow}) + reserved(if) ident(PrefWin)operator(.)ident(DefaultIconPreviewCB)operator(.)ident(Checked) reserved(then) + ident(DefaultIconPreview)operator(()ident(Reg)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + comment({if nfCopy in NodeInfo(Node\).Flags then begin + //Node.StateIndex := 2; + Brush.Style := bsClear; + with Font do begin + Style := [fsItalic, fsBold]; + Color := clRed; + end; + //TextOut(Rect.Left - 10, Rect.Top + 3, 'c'\); + end;}) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RenameMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(RegTV)operator(.)ident(Selected)operator(.)ident(EditText)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(CopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(UserCopyKeyFlag) operator(:=) ident(True)operator(;) + ident(MainWin)operator(.)ident(CopyPathClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(InsertPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MainWin)operator(.)ident(InsertPathClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(RegTVGetImageIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(NodeInfo)operator(()ident(Node)operator(\).)ident(Checked) reserved(then) + ident(CheckNode)operator(()ident(Node)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(CheckRegTVHotTrack)operator(;) +reserved(const) + ident(FindCursorOfSwitch)operator(:) reserved(array)operator([)ident(Boolean)operator(]) reserved(of) ident(TCursor) operator(=) operator(()ident(crArrow)operator(,) ident(crHandPoint)operator(\);) +reserved(var) + ident(NewHotTrack)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(NewHotTrack) operator(:=) ident(ScrollON) reserved(xor) ident(PrefWin)operator(.)ident(KeysSingleClickCB)operator(.)ident(Checked)operator(;) + reserved(if) ident(NewHotTrack) operator(=) ident(RegTV)operator(.)ident(HotTrack) reserved(then) ident(Exit)operator(;) + + reserved(with) ident(RegTV) reserved(do) reserved(begin) + ident(HotTrack) operator(:=) ident(NewHotTrack)operator(;) + ident(Cursor) operator(:=) ident(FindCursorOfSwitch)operator([)ident(HotTrack)operator(];) + ident(Mouse)operator(.)ident(CursorPos) operator(:=) ident(Mouse)operator(.)ident(CursorPos)operator(;) comment(//update cursor) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(PasteKeyMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Src)operator(,) ident(Trg)operator(:) ident(TRegPath)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Src) operator(:=) ident(RegPathOfStr)operator(()ident(Clipboard)operator(.)ident(AsText)operator(\);) + ident(Trg) operator(:=) ident(CurKey)operator(()ident(uhNonSystemShortcuts)operator(\);) + ident(Trg)operator(.)ident(Key) operator(:=) ident(Trg)operator(.)ident(Key) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(FromLastChar)operator(()ident(Src)operator(.)ident(Key)operator(,) char<delimiter(')content(\\)delimiter(')>operator(,) ident(True)operator(\);) + + ident(MoveKey)operator(()ident(Src)operator(,) ident(Trg)operator(,) ident(UserCopyKeyFlag)operator(\);) + + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(Node)operator(.)ident(Collapse)operator(()ident(False)operator(\);) + ident(Node)operator(.)ident(Expanded) operator(:=) ident(False)operator(;) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(\);) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\);) + + reserved(if) reserved(not) ident(UserCopyKeyFlag) reserved(then) + ident(RegTV)operator(.)ident(Repaint)operator(;) comment(// CheckNode(Node, False\);) + + ident(UserCopyKeyFlag) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(CutPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(UserCopyKeyFlag) operator(:=) ident(False)operator(;) + ident(MainWin)operator(.)ident(CopyPathClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(OpenNextLevel)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + + reserved(procedure) ident(ExpandKeys)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(begin) + ident(CheckNode)operator(()ident(Node)operator(,) ident(False)operator(,) ident(True)operator(\);) + reserved(if) reserved(not) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(Exit)operator(;) + reserved(if) reserved(not) ident(Node)operator(.)ident(Expanded) reserved(then) + ident(Node)operator(.)ident(Expand)operator(()ident(False)operator(\)) + reserved(else) reserved(begin) + ident(Node) operator(:=) ident(Node)operator(.)ident(GetFirstChild)operator(;) + reserved(while) ident(Assigned)operator(()ident(Node)operator(\)) reserved(do) reserved(begin) + ident(ExpandKeys)operator(()ident(Node)operator(\);) + ident(Node) operator(:=) ident(Node)operator(.)ident(GetNextSibling)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(DoSmartExpand) operator(:=) ident(False)operator(;) + ident(ExpandKeys)operator(()ident(Node)operator(\);) + ident(DoSmartExpand) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(EditShortcutMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(NewPath)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(Shortcut)operator(:) ident(PKeyShortcut)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(if) ident(NodeInfo)operator(()ident(Node)operator(\).)ident(HostType) operator(<>) ident(uhUserShortcut) reserved(then) + ident(Exit)operator(;) + + ident(i) operator(:=) ident(ShortcutIndex)operator(()ident(Node)operator(\);) + reserved(if) ident(i) operator(=) operator(-)integer(1) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(TIniFile)operator(.)ident(Create)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(NewPath) operator(:=) ident(ReadString)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Shortcuts)operator([)ident(i)operator(].)ident(Alias)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(InputQuery)operator(()string<delimiter(')content(Edit Shortcut)delimiter(')>operator(,) string<delimiter(')content(Shortcut to...)delimiter(')>operator(,) ident(NewPath)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Node)operator(.)ident(Collapse)operator(()ident(False)operator(\);) + ident(Shortcut) operator(:=) operator(@)ident(Shortcuts)operator([)ident(i)operator(];) + ident(Shortcut)operator(.)ident(RealPath) operator(:=) ident(TraceKey)operator(()ident(NewPath)operator(\);) + reserved(with) ident(TIniFile)operator(.)ident(Create)operator(()ident(PlutoDir) operator(+) string<delimiter(')content(Shortcuts.ini)delimiter(')>operator(\)) reserved(do) + reserved(try) + ident(WriteString)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(Shortcut)operator(.)ident(Alias)operator(,) ident(Shortcut)operator(.)ident(RealPath)operator(\);) + reserved(finally) + ident(Free)operator(;) + reserved(end)operator(;) + + ident(RegTVChange)operator(()ident(Self)operator(,) ident(Node)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(SubKeylist1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(if) ident(OpenCurKey) reserved(then) + reserved(try) + ident(MainReg)operator(.)ident(GetKeyNames)operator(()ident(SL)operator(\);) + reserved(if) ident(PrefWin)operator(.)ident(SortKeysCB)operator(.)ident(Checked) reserved(then) + ident(SL)operator(.)ident(Sort)operator(;) + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(SL)operator(.)ident(Text)operator(;) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(ValueNameslist1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(if) ident(OpenCurKey) reserved(then) + reserved(try) + ident(MainReg)operator(.)ident(GetValueNames)operator(()ident(SL)operator(\);) + reserved(if) ident(PrefWin)operator(.)ident(SortKeysCB)operator(.)ident(Checked) reserved(then) + ident(SL)operator(.)ident(Sort)operator(;) + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(SL)operator(.)ident(Text)operator(;) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(KeyInfosMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MessageDlg)operator(()ident(GetKeyInfos)operator(,) ident(mtInformation)operator(,) operator([)ident(mbOK)operator(],) integer(0)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TTreeWin)operator(.)ident(GetKeyInfos)operator(:) reserved(string)operator(;) +reserved(const) + ident(sErrorMsg) operator(=) string<delimiter(')content(Error! No: %d Msg: %s)delimiter(')>operator(;) + +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + ident(Mode)operator(:) ident(TOpenNodeMode)operator(;) + ident(Error)operator(:) ident(Integer)operator(;) + ident(Info)operator(:) ident(TNodeInfo)operator(;) + ident(Flag)operator(:) ident(TNodeFlag)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(S)operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(AddLn)operator(()reserved(const) ident(S)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) + reserved(begin) + ident(Add)operator(()ident(S) operator(+) ident(EOL)operator(\);) + reserved(end)operator(;) + + reserved(procedure) ident(AddNodeInfo)operator(()ident(Key)operator(:) ident(HKEY)operator(\);) + reserved(var) + ident(KeyInfo)operator(:) ident(TRegKeyInfo)operator(;) + ident(Res)operator(:) ident(Integer)operator(;) + ident(KeyAge)operator(:) ident(TDateTime)operator(;) + reserved(begin) + ident(FillChar)operator(()ident(KeyInfo)operator(,) ident(SizeOf)operator(()ident(TRegKeyInfo)operator(\),) integer(0)operator(\);) + reserved(with) ident(KeyInfo) reserved(do) reserved(begin) + ident(Res) operator(:=) ident(RegQueryInfoKey)operator(()ident(Reg)operator(.)ident(CurrentKey)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) reserved(nil)operator(,) operator(@)ident(NumSubKeys)operator(,) + operator(@)ident(MaxSubKeyLen)operator(,) reserved(nil)operator(,) operator(@)ident(NumValues)operator(,) operator(@)ident(MaxValueLen)operator(,) + operator(@)ident(MaxDataLen)operator(,) reserved(nil)operator(,) operator(@)ident(LastWriteTime)operator(\);) + + reserved(if) ident(Res) operator(=) ident(ERROR_SUCCESS) reserved(then) reserved(begin) + ident(Add)operator(()ident(Format)operator(() + string<delimiter(')content(Subkeys: %0:d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Values: %2:d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Max subkeys length: %1:d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Max value name length: %3:d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Max data length: %4:d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')delimiter(')>operator(,) + operator([)ident(NumSubKeys)operator(,) ident(MaxSubKeyLen)operator(,) ident(NumValues)operator(,) ident(MaxValueLen)operator(,) ident(MaxDataLen)operator(]\)\);) + ident(KeyAge) operator(:=) ident(DateTimeOfFileTime)operator(()ident(LastWriteTime)operator(\);) + reserved(if) ident(KeyAge) operator(>) integer(0) reserved(then) + ident(AddLn)operator(()string<delimiter(')content(Last write time: )delimiter(')> operator(+) ident(DateTimeToStr)operator(()ident(KeyAge)operator(\)\);) + reserved(end) reserved(else) + ident(AddLn)operator(()string<delimiter(')content(Couldn)char('')content(t get key info.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Error Code: )delimiter(')> operator(+) ident(IntToStr)operator(()ident(Res)operator(\)) operator(+) ident(EOL) operator(+) + string<delimiter(')content(Message: )delimiter(')> operator(+) ident(SysErrorMessage)operator(()ident(Res)operator(\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(()ident(KEY_READ)operator(\);) + reserved(try) + reserved(try) + ident(Error) operator(:=) ident(OpenNodeError)operator(()ident(Reg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(,) ident(Mode)operator(\);) + + reserved(case) ident(Mode) reserved(of) + ident(onFull)operator(:) ident(AddLn)operator(()string<delimiter(')content(Full Access)delimiter(')>operator(\);) + ident(onReadOnly)operator(:) ident(AddLn)operator(()string<delimiter(')content(Read only)delimiter(')>operator(\);) + ident(onError)operator(:) + ident(AddLn)operator(()ident(Format)operator(()ident(sErrorMsg)operator(,) operator([)ident(Error)operator(,) ident(SysErrorMessage)operator(()ident(Error)operator(\)]\)\);) + ident(onNodeNil)operator(:) ident(AddLn)operator(()string<delimiter(')content(Node is nil!)delimiter(')>operator(\);) + + reserved(else) + ident(AddLn)operator(()string<delimiter(')content(Unknown Mode: )delimiter(')> operator(+) ident(IntToStr)operator(()ident(Integer)operator(()ident(Mode)operator(\)\)\);) + reserved(end)operator(;) + + reserved(if) ident(Mode) reserved(in) ident(onOK) reserved(then) + ident(AddNodeInfo)operator(()ident(Reg)operator(.)ident(CurrentKey)operator(\);) + + reserved(except) + directive(on) ident(E)operator(:) ident(Exception) reserved(do) reserved(begin) + ident(Error) operator(:=) ident(GetLastError)operator(;) + reserved(if) ident(Error) operator(<>) ident(ERROR_SUCCESS) reserved(then) + ident(AddLn)operator(()ident(Format)operator(()string<delimiter(')content(Error! No: %d Msg: %s)delimiter(')>operator(,) operator([)ident(Error)operator(,) ident(SysErrorMessage)operator(()ident(Error)operator(\)]\)\)) + reserved(else) + ident(AddLn)operator(()ident(E)operator(.)ident(Message)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(if) ident(MurphyMode) reserved(then) reserved(begin) + ident(AddLn)operator(()string<delimiter(')content([MM] ImageIndex: )delimiter(')> operator(+) ident(IntToStr)operator(()ident(Node)operator(.)ident(ImageIndex)operator(\)\);) + ident(Info) operator(:=) ident(NodeInfo)operator(()ident(Node)operator(\);) + + reserved(if) ident(Info)operator(.)ident(HostType) reserved(in) operator([)ident(uhNone)operator(..)ident(High)operator(()ident(HostTypeStrings)operator(\)]) reserved(then) + ident(AddLn)operator(()string<delimiter(')content([MM] HostType: )delimiter(')> operator(+) ident(HostTypeStrings)operator([)ident(Info)operator(.)ident(HostType)operator(]\)) + reserved(else) + ident(AddLn)operator(()string<delimiter(')content([MM] Unknown HostType: )delimiter(')> operator(+) ident(IntToStr)operator(()ident(Integer)operator(()ident(Info)operator(.)ident(HostType)operator(\)\)\);) + ident(Add)operator(()string<delimiter(')content([MM] Flags: )delimiter(')>operator(\);) + reserved(for) ident(Flag) operator(:=) ident(Low)operator(()ident(TNodeFlag)operator(\)) reserved(to) ident(High)operator(()ident(TNodeFlag)operator(\)) reserved(do) + reserved(if) ident(Flag) reserved(in) ident(Info)operator(.)ident(Flags) reserved(then) + ident(Add)operator(()ident(NodeFlagStrings)operator([)ident(Flag)operator(]) operator(+) char<delimiter(')content( )delimiter(')>operator(\);) + ident(AddLn)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(ExportAsRegClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + + reserved(procedure) ident(ExportAsReg4)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(const) ident(FileName)operator(:) reserved(string)operator(\);) + reserved(var) + ident(Reg4Writer)operator(:) ident(TReg4Writer)operator(;) + reserved(begin) + ident(Reg4Writer) operator(:=) ident(TReg4Writer)operator(.)ident(Create)operator(()ident(tpNormal)operator(,) ident(FileName)operator(,) + ident(TraceKey)operator(()ident(PathOfNode)operator(()ident(Node)operator(\)\),) ident(Reg)operator(.)ident(DeliverKey)operator(\);) + reserved(with) ident(Reg4Writer) reserved(do) reserved(begin) + ident(OnTerminate) operator(:=) ident(Reg4WriterTerminate)operator(;) + reserved(try) + ident(AddHint)operator(()ident(Format)operator(()string<delimiter(')content(starting .reg-export: %s...)delimiter(')>operator(,) + operator([)ident(Root) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(Path)operator(]\)\);) + ident(Resume)operator(;) + reserved(except) + ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + ident(AddToLastHint)operator(()string<delimiter(')content(started.)delimiter(')>operator(\);) + reserved(end)operator(;) + + + reserved(procedure) ident(ExportAsHive)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(const) ident(FileName)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) ident(Reg)operator(.)ident(SaveKey)operator(()string<delimiter(')delimiter(')>operator(,) ident(FileName)operator(\)) reserved(then) + ident(AddHint)operator(()string<delimiter(')content(hive export successfull.)delimiter(')>operator(\)) + reserved(else) + ident(AddHint)operator(()ident(Format)operator(()string<delimiter(')content(hive export failed: %s)delimiter(')>operator(,) + operator([)ident(SysErrorMessage)operator(()ident(LastSuccessRes)operator(\)]\)\);) + reserved(end)operator(;) + +reserved(begin) + ident(Node) operator(:=) ident(RegTV)operator(.)ident(Selected)operator(;) + reserved(with) ident(ExportD) reserved(do) reserved(begin) + ident(FileName) operator(:=) ident(MakeValidFileName)operator(()ident(Node)operator(.)ident(Text)operator(,) string<delimiter(')content(key)delimiter(')>operator(\);) + + reserved(if) ident(Execute) reserved(then) reserved(begin) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(Node)operator(\)) reserved(then) reserved(begin) + reserved(if) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(and) operator(()ident(mrYes)operator(=)ident(MessageDlg)operator(() + string<delimiter(')content(File already exists.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Delete existing file?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)\)) reserved(then) reserved(begin) + ident(FileSetAttr)operator(()ident(FileName)operator(,) integer(0)operator(\);) + ident(DeleteFile)operator(()ident(FileName)operator(\);) + reserved(end)operator(;) + reserved(case) ident(FilterIndex) reserved(of) + integer(1)operator(:) ident(ExportAsReg4)operator(()ident(Reg)operator(,) ident(FileName)operator(\);) + integer(2)operator(:) ident(ExportAsHive)operator(()ident(Reg)operator(,) ident(FileName)operator(\);) + reserved(else) + ident(ShowMessage)operator(()ident(Format)operator(()string<delimiter(')content(Wrong Filter: %d)delimiter(')>operator(,) operator([)ident(FilterIndex)operator(]\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) +reserved(begin) +comment(// Action := caNone;) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(Load)operator(;) +reserved(var) + ident(NodeHKLM)operator(,) ident(NodeHKU)operator(,) ident(NodeHKDD)operator(,) ident(NodeHKPD)operator(:) ident(TTreeNode)operator(;) + ident(NodeHostReg)operator(:) ident(TTreeNode)operator(;) + + reserved(procedure) ident(LoadShortcuts)operator(()ident(FileName)operator(:) reserved(string)operator(;) ident(HostType)operator(:) ident(TUniHostType)operator(\);) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(ShortcutIni)operator(:) ident(TIniFile)operator(;) + reserved(begin) + reserved(if) reserved(not) ident(FileEx)operator(()ident(FileName)operator(\)) reserved(then) reserved(begin) + ident(AddToLastHint)operator(()string<delimiter(')content(not found:)delimiter(')>operator(\);) + ident(AddHint)operator(()ident(FileName)operator(\);) + ident(Exit) reserved(end)operator(;) + + ident(ShortcutIni) operator(:=) ident(TIniFile)operator(.)ident(Create)operator(()ident(FileName)operator(\);) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + + reserved(try) + ident(ShortcutIni)operator(.)ident(ReadSectionValues)operator(()string<delimiter(')content(Shortcuts)delimiter(')>operator(,) ident(SL)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(AddShortcut)operator(()ident(SL)operator(.)ident(Names)operator([)ident(i)operator(],) ident(SL)operator(.)ident(Values)operator([)ident(SL)operator(.)ident(Names)operator([)ident(i)operator(]],) ident(iconShortcut)operator(,) + ident(HostType)operator(\);) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + ident(ShortcutIni)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(NodeHostReg) operator(:=) reserved(nil)operator(;) + + ident(AddHint)operator(()string<delimiter(')content(Creating Hosts...)delimiter(')>operator(\);) + ident(RootNodes) operator(:=) ident(TList)operator(.)ident(Create)operator(;) + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_LOCAL_MACHINE)delimiter(')>operator(\);) + ident(NodeHKLM) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(NodeHostReg)operator(,) string<delimiter(')content(HKEY_LOCAL_MACHINE)delimiter(')>operator(\);) + ident(SetTNImage)operator(()ident(NodeHKLM)operator(,) ident(iconHKLM)operator(\);) + ident(NodeInfo)operator(()ident(NodeHKLM)operator(\).)ident(HostType) operator(:=) ident(uhReg)operator(;) + ident(RootNodes)operator(.)ident(Add)operator(()ident(NodeHKLM)operator(\);) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_USERS)delimiter(')>operator(\);) + ident(NodeHKU) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()ident(NodeHostReg)operator(,) string<delimiter(')content(HKEY_USERS)delimiter(')>operator(\);) + ident(SetTNImage)operator(()ident(NodeHKU)operator(,) ident(iconHKU)operator(\);) + ident(NodeInfo)operator(()ident(NodeHKU)operator(\).)ident(HostType) operator(:=) ident(uhReg)operator(;) + ident(RootNodes)operator(.)ident(Add)operator(()ident(NodeHKU)operator(\);) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_CURRENT_USER)delimiter(')>operator(\);) + reserved(if) ident(RegRealPath)operator(()string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')>operator(\)) operator(=) string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')> reserved(then) + comment(//could not dereference hkcu) + ident(AddShortcut)operator(()string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')>operator(,) string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')>operator(,) + ident(iconHKCU)operator(,) ident(uhReg)operator(\)) + reserved(else) + ident(AddShortcut)operator(()string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')>operator(,) ident(RegRealPath)operator(()string<delimiter(')content(HKEY_CURRENT_USER)delimiter(')>operator(\),) + ident(iconHKCU)operator(,) ident(uhSystemShortcut)operator(\);) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_CURRENT_CONFIG)delimiter(')>operator(\);) + ident(AddShortcut)operator(()string<delimiter(')content(HKEY_CURRENT_CONFIG)delimiter(')>operator(,) ident(RegRealPath)operator(()string<delimiter(')content(HKEY_CURRENT_CONFIG)delimiter(')>operator(\),) + ident(iconHKCC)operator(,) ident(uhSystemShortcut)operator(\);) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_CLASSES_ROOT)delimiter(')>operator(\);) + ident(AddShortcut)operator(()string<delimiter(')content(HKEY_CLASSES_ROOT)delimiter(')>operator(,) ident(RegRealPath)operator(()string<delimiter(')content(HKEY_CLASSES_ROOT)delimiter(')>operator(\),) + ident(iconHKCR)operator(,) ident(uhSystemShortcut)operator(\);) + + ident(MainReg)operator(.)ident(RootKey) operator(:=) ident(HKEY_DYN_DATA)operator(;) + reserved(if) ident(MainReg)operator(.)ident(OpenKeyReadOnly)operator(()string<delimiter(')delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_DYN_DATA)delimiter(')>operator(\);) + ident(NodeHKDD) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()reserved(nil)operator(,) string<delimiter(')content(HKEY_DYN_DATA)delimiter(')>operator(\);) + ident(NodeInfo)operator(()ident(NodeHKDD)operator(\).)ident(HostType) operator(:=) ident(uhReg)operator(;) + ident(NodeInfo)operator(()ident(NodeHKDD)operator(\).)ident(IncludeFlag)operator(()ident(nfReadOnly)operator(\);) + ident(SetTNImage)operator(()ident(NodeHKDD)operator(,) ident(iconHKDD)operator(\);) + ident(RootNodes)operator(.)ident(Add)operator(()ident(NodeHKDD)operator(\);) + reserved(end)operator(;) + + ident(MainReg)operator(.)ident(RootKey) operator(:=) ident(HKEY_PERFORMANCE_DATA)operator(;) + reserved(if) ident(MainReg)operator(.)ident(OpenKeyReadOnly)operator(()string<delimiter(')delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Hosts...HKEY_PERFORMANCE_DATA)delimiter(')>operator(\);) + ident(NodeHKPD) operator(:=) ident(RegTV)operator(.)ident(Items)operator(.)ident(AddChild)operator(()reserved(nil)operator(,) string<delimiter(')content(HKEY_PERFORMANCE_DATA)delimiter(')>operator(\);) + ident(NodeInfo)operator(()ident(NodeHKPD)operator(\).)ident(HostType) operator(:=) ident(uhReg)operator(;) + ident(SetTNImage)operator(()ident(NodeHKPD)operator(,) ident(iconHKPD)operator(\);) + ident(RootNodes)operator(.)ident(Add)operator(()ident(NodeHKPD)operator(\);) + reserved(end)operator(;) + + ident(ChangeLastHint)operator(()string<delimiter(')content(Creating Host...OK)delimiter(')>operator(\);) + + ident(AddHint)operator(()string<delimiter(')content(Loading Standard Shortcuts...)delimiter(')>operator(\);) + ident(LoadShortcuts)operator(()ident(PlutoDir) operator(+) ident(StandardShortcutsFileName)operator(,) ident(uhStandardShortcut)operator(\);) + + ident(AddHint)operator(()string<delimiter(')content(Loading User Shortcuts...)delimiter(')>operator(\);) + ident(LoadShortcuts)operator(()ident(PlutoDir) operator(+) ident(ShortcutsFileName)operator(,) ident(uhUserShortcut)operator(\);) + +preprocessor({$IFDEF UNIKEY}) + ident(AddShortcut)operator(()string<delimiter(')content(Uni)delimiter(')>operator(,) string<delimiter(')delimiter(')>operator(,) ident(iconHostUni)operator(\);) +preprocessor({$ENDIF}) +reserved(end)operator(;) + +reserved(procedure) ident(TTreeWin)operator(.)ident(Reg4WriterTerminate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(Sender) reserved(as) ident(TRegFileWriter) reserved(do) + ident(AddHint)operator(()ident(Format)operator(()string<delimiter(')content(.reg-export finished (%0.2f s\): %s)delimiter(')>operator(,) + operator([)ident(Clk)operator(.)ident(SecsPassed)operator(,) ident(Root) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(Path)operator(]\)\);) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(valuesU)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Variants)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) + ident(ComCtrls)operator(,) ident(Menus)operator(,) ident(Clipbrd)operator(,) ident(XReg)operator(,) ident(CompEx)operator(,) ident(Math)operator(,) ident(YTools)operator(,) ident(Dialogs)operator(,) ident(YTypes)operator(,) + ident(PlutoConst)operator(,) ident(keybrd)operator(,) ident(ImgList)operator(,) ident(clock)operator(;) + +reserved(type) + ident(TValuesWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(ValueListPU)operator(:) ident(TPopupMenu)operator(;) + ident(NewStringMI)operator(:) ident(TMenuItem)operator(;) + ident(NewDWORDMI)operator(:) ident(TMenuItem)operator(;) + ident(NewBinaryMI)operator(:) ident(TMenuItem)operator(;) + ident(ConvertToMI)operator(:) ident(TMenuItem)operator(;) + ident(ConvStringMI)operator(:) ident(TMenuItem)operator(;) + ident(ConvDWORDMI)operator(:) ident(TMenuItem)operator(;) + ident(ConvBinaryMI)operator(:) ident(TMenuItem)operator(;) + ident(ValueList)operator(:) ident(TListView)operator(;) + ident(DeleteMI)operator(:) ident(TMenuItem)operator(;) + ident(N1)operator(:) ident(TMenuItem)operator(;) + ident(RenameMI)operator(:) ident(TMenuItem)operator(;) + ident(NewElseMI)operator(:) ident(TMenuItem)operator(;) + ident(NewMultiStringMI)operator(:) ident(TMenuItem)operator(;) + ident(REGNONE1)operator(:) ident(TMenuItem)operator(;) + ident(LINK1)operator(:) ident(TMenuItem)operator(;) + ident(NewExpandStringMI)operator(:) ident(TMenuItem)operator(;) + ident(N3BINARY1)operator(:) ident(TMenuItem)operator(;) + ident(N4DWORD1)operator(:) ident(TMenuItem)operator(;) + ident(N4DWORDLITTLEEDIAN1)operator(:) ident(TMenuItem)operator(;) + ident(NewBigEndianMI)operator(:) ident(TMenuItem)operator(;) + ident(N6LINK1)operator(:) ident(TMenuItem)operator(;) + ident(N7MULTISZ1)operator(:) ident(TMenuItem)operator(;) + ident(RESOURCELIST1)operator(:) ident(TMenuItem)operator(;) + ident(N9FULLRESOURCEDESCRIPTOR1)operator(:) ident(TMenuItem)operator(;) + ident(ARESOURCEREQUIREMENTSLIST1)operator(:) ident(TMenuItem)operator(;) + ident(NewDefaultValueMI)operator(:) ident(TMenuItem)operator(;) + ident(EditMI)operator(:) ident(TMenuItem)operator(;) + ident(EditBinaryMI)operator(:) ident(TMenuItem)operator(;) + ident(N3)operator(:) ident(TMenuItem)operator(;) + ident(CopyDataPreviewMI)operator(:) ident(TMenuItem)operator(;) + ident(DublicateMI)operator(:) ident(TMenuItem)operator(;) + ident(MultiString1)operator(:) ident(TMenuItem)operator(;) + ident(ZeromizeMI)operator(:) ident(TMenuItem)operator(;) + ident(N4)operator(:) ident(TMenuItem)operator(;) + ident(CopyPathMI)operator(:) ident(TMenuItem)operator(;) + ident(TakeAsMainValueMI)operator(:) ident(TMenuItem)operator(;) + ident(SelectAllMI)operator(:) ident(TMenuItem)operator(;) + ident(InvertSelectionMI)operator(:) ident(TMenuItem)operator(;) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(InitListColumnTags)operator(;) + + reserved(procedure) ident(NewStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewDWORDMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewBinaryMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ConvertValue)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(CreateValue)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\);) + reserved(procedure) ident(ZeromizeValue)operator(;) + reserved(procedure) ident(DeleteValue)operator(;) + reserved(procedure) ident(CloneValue)operator(;) + reserved(function) ident(TryRenameValue)operator(()ident(OldName)operator(:) reserved(string)operator(;) reserved(var) ident(NewName)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + + reserved(procedure) ident(ValueListChange)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) ident(Change)operator(:) ident(TItemChange)operator(\);) + reserved(procedure) ident(ValueListCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomListView)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ValueListDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ValueListEditing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) reserved(var) ident(AllowEdit)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ValueListEdited)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) reserved(var) ident(S)operator(:) ident(String)operator(\);) + reserved(procedure) ident(ValueListKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(ValueListResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(function) ident(UpdateValue)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) + reserved(procedure) ident(UpdateValues)operator(()ident(SelectedOnly)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) + reserved(procedure) ident(Reload)operator(()ident(JumpToNewValue)operator(:) ident(Boolean) operator(=) ident(False)operator(;) ident(ValueName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) + reserved(procedure) ident(LoadValues)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(\);) + + reserved(function) ident(AddValue)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) ident(AppendInfos)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(TListItem)operator(;) + reserved(procedure) ident(ValueListPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(ValueListDeletion)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(\);) + reserved(procedure) ident(DeleteMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(RenameMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewBigEndianMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewExpandStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewMultiStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewStrangeTypeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(NewDefaultValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ValueListChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) ident(Change)operator(:) ident(TItemChange)operator(;) reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ValueListMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(EditBinaryMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(EditMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ValueListCustomDrawSubItem)operator(()ident(Sender)operator(:) ident(TCustomListView)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) ident(SubItem)operator(:) ident(Integer)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ValueListCompare)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item1)operator(,) ident(Item2)operator(:) ident(TListItem)operator(;) ident(Data)operator(:) ident(Integer)operator(;) reserved(var) ident(Compare)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(ValueListColumnClick)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Column)operator(:) ident(TListColumn)operator(\);) + reserved(procedure) ident(DublicateMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CopyDataPreviewMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CopyDataPreview)operator(;) + reserved(procedure) ident(ZeromizeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(function) ident(FindItemByRealName)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) + + reserved(function) ident(FocusItem)operator(()ident(ARealValueName)operator(:) reserved(string)operator(;) + ident(FocusValueList)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(Boolean)operator(;) + reserved(procedure) ident(TakeAsMainValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) + reserved(procedure) ident(ValueListClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CheckValueListHotTrack)operator(;) + reserved(procedure) ident(SelectAllMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(InvertSelectionMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormDestroy)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + directive(private) + ident(ValueLabelClicked)operator(:) ident(Boolean)operator(;) + ident(SortBy)operator(:) ident(TValueListColumn)operator(;) + ident(SortByColumn)operator(:) ident(TListColumn)operator(;) + ident(SubItemIndex)operator(:) reserved(array)operator([)ident(TValueListColumn)operator(]) reserved(of) ident(Integer)operator(;) + directive(public) + ident(ValueNames)operator(:) ident(TStringList)operator(;) + ident(ValuesCommon)operator(:) ident(Boolean)operator(;) + ident(ValueCommonType)operator(:) ident(TRegDataType)operator(;) + reserved(end)operator(;) + +reserved(var) + ident(ValuesWin)operator(:) ident(TValuesWin)operator(;) + ident(ValueList)operator(:) ident(TListView)operator(;) + + ident(DefaultValueCaption)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + +reserved(function) ident(ItemIsDefaultValue)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(RealValueName)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) reserved(string)operator(;) +reserved(procedure) ident(SetRealValueName)operator(()ident(Item)operator(:) ident(TListItem)operator(;) ident(Caption)operator(:) reserved(string)operator(\);) +reserved(function) ident(IconOfDataType)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\):) ident(Integer)operator(;) +reserved(function) ident(IsMainValue)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) + +reserved(function) ident(ColorOfDataType)operator(()ident(DataType)operator(:) ident(TRegDataType)operator(;) + ident(DefaultColor)operator(:) ident(TColor) operator(=) ident(clWhite)operator(\):) ident(TColor)operator(;) +reserved(function) ident(DataPreviewOfContext)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + +reserved(function) ident(ValueDataSize)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(function) ident(ValueDataType)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(function) ident(ValueDataPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(function) ident(ValueTypeIcon)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) ident(Integer)operator(;) + +reserved(function) ident(StrOfRegDataType)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\):) reserved(string)operator(;) + +reserved(implementation) + +reserved(uses) ident(PlutoMain)operator(,) ident(TreeU)operator(,) ident(WorkU)operator(,) ident(PrefU)operator(;) + +preprocessor({$R *.dfm}) + +reserved(function) ident(ItemIsDefaultValue)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Item)operator(.)ident(Data) operator(=) ident(Pointer)operator(()ident(DefaultValueFlag)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(RealValueName)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(ItemIsDefaultValue)operator(()ident(Item)operator(\)) reserved(then) + ident(Result) operator(:=) string<delimiter(')delimiter(')> + reserved(else) + ident(Result) operator(:=) ident(Item)operator(.)ident(Caption)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(SetRealValueName)operator(()ident(Item)operator(:) ident(TListItem)operator(;) ident(Caption)operator(:) reserved(string)operator(\);) +reserved(begin) + reserved(if) ident(Caption) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Item)operator(.)ident(Caption) operator(:=) ident(DefaultValueCaption)operator(;) + ident(Item)operator(.)ident(Data) operator(:=) ident(Pointer)operator(()ident(DefaultValueFlag)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Item)operator(.)ident(Caption) operator(:=) ident(Caption)operator(;) + ident(Item)operator(.)ident(Data) operator(:=) reserved(nil)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(IsMainValue)operator(()ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(if) ident(csDestroying) reserved(in) ident(PrefWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\)) operator(=) ident(PrefWin)operator(.)ident(MainPreviewE)operator(.)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ColorOfDataType)operator(()ident(DataType)operator(:) ident(TRegDataType)operator(;) + ident(DefaultColor)operator(:) ident(TColor) operator(=) ident(clWhite)operator(\):) ident(TColor)operator(;) +reserved(begin) + reserved(if) ident(DataType) reserved(in) ident(rdStringTypes) reserved(then) ident(Result) operator(:=) ident(clBrightRed) + reserved(else) reserved(if) ident(DataType) operator(=) ident(rdMultiString) reserved(then) ident(Result) operator(:=) ident(clBrightPurple) + reserved(else) reserved(if) ident(DataType) reserved(in) ident(rdCardTypes) reserved(then) ident(Result) operator(:=) ident(clBrightBlue) + reserved(else) reserved(if) ident(DataType) operator(=) ident(rdBinary) reserved(then) ident(Result) operator(:=) ident(clBrightGreen) + reserved(else) ident(Result) operator(:=) ident(DefaultColor)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrOfRegDataType)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\):) reserved(string)operator(;) +reserved(const) + ident(RegDataTypeStrings)operator(:) reserved(array)operator([)ident(rdNone)operator(..)ident(rdLastType)operator(]) reserved(of) reserved(string) operator(=) operator(() + string<delimiter(')content(NONE)delimiter(')>operator(,) + string<delimiter(')content(SZ)delimiter(')>operator(,) + string<delimiter(')content(EXPAND_SZ)delimiter(')>operator(,) + string<delimiter(')content(BINARY)delimiter(')>operator(,) + string<delimiter(')content(DWORD)delimiter(')>operator(,) + string<delimiter(')content(DWORD_BIG_ENDIAN)delimiter(')>operator(,) + string<delimiter(')content(LINK)delimiter(')>operator(,) + string<delimiter(')content(MULTI_SZ)delimiter(')>operator(,) + string<delimiter(')content(RESOURCE_LIST)delimiter(')>operator(,) + string<delimiter(')content(FULL_RESOURCE_DESCRIPTOR)delimiter(')>operator(,) + string<delimiter(')content(RESOURCE_REQUIREMENTS_LIST)delimiter(')>operator(,) + string<delimiter(')content(QUAD_WORD)delimiter(')> + operator(\);) +reserved(begin) + reserved(if) ident(Typ) reserved(in) operator([)ident(rdNone)operator(..)ident(rdLastType)operator(]) reserved(then) + ident(Result) operator(:=) ident(RegDataTypeStrings)operator([)ident(Typ)operator(]) + reserved(else) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(Typ)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdString)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewDWORDMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdCardinal)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewBinaryMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdBinary)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CreateValue)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\);) +reserved(var) + ident(Item)operator(:) ident(TListItem)operator(;) + ident(ValueName)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) operator(()ident(TreeWin)operator(.)ident(ComponentState) operator(+) ident(MainWin)operator(.)ident(ComponentState)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(TreeWin)operator(.)ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(MainReg) reserved(do) reserved(begin) + reserved(try) + ident(OpenCurKey)operator(;) + + ident(ValueName) operator(:=) string<delimiter(')content(New)delimiter(')>operator(;) comment(// find free name) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(ValueExists)operator(()ident(ValueName)operator(\)) reserved(do) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(ValueName) operator(:=) string<delimiter(')content(New )delimiter(')> operator(+) ident(IntToStr)operator(()ident(i)operator(\);) + reserved(end)operator(;) + + reserved(case) ident(Typ) reserved(of) + ident(rdString)operator(:) reserved(begin) + ident(WriteString)operator(()ident(ValueName)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(end)operator(;) + ident(rdExpandString)operator(:) reserved(begin) + ident(WriteExpandString)operator(()ident(ValueName)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(end)operator(;) + ident(rdCardinal)operator(:) reserved(begin) + ident(WriteCardinal)operator(()ident(ValueName)operator(,) integer(0)operator(\);) + reserved(end)operator(;) + ident(rdCardBigEndian)operator(:) reserved(begin) + ident(WriteCardinal)operator(()ident(ValueName)operator(,) integer(0)operator(,) ident(True)operator(\);) + reserved(end)operator(;) + ident(rdMultiString)operator(:) reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(WriteMultiString)operator(()ident(ValueName)operator(,) ident(SL)operator(\);) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + ident(rdBinary)operator(:) reserved(begin) + ident(WriteBin)operator(()ident(ValueName)operator(,) reserved(nil)operator(\);) + reserved(end)operator(;) + reserved(else) + ident(WriteBinType)operator(()ident(ValueName)operator(,) reserved(nil)operator(,) ident(Typ)operator(\);) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(ValueExists)operator(()ident(ValueName)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Could not create Value.)delimiter(')>operator(\);) + ident(CloseKey)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(MainReg)operator(,) ident(ValueName)operator(\);) + reserved(finally) + ident(CloseKey)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(Item) operator(:=) ident(FindItem)operator(()ident(ValueList)operator(,) ident(ValueName)operator(\);) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Error, Value not found: )delimiter(')> operator(+) ident(ValueName)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(SelectItemOnly)operator(()ident(ValueList)operator(,) ident(Item)operator(\);) + ident(MainWin)operator(.)ident(StatusBarUpdate)operator(;) + ident(ValueLabelClicked) operator(:=) ident(True)operator(;) + ident(Item)operator(.)ident(EditCaption)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValuesU)operator(.)ident(ValueList) operator(:=) ident(ValueList)operator(;) + + ident(DefaultValueCaption) operator(:=) ident(PrefWin)operator(.)ident(DefaultValueNameE)operator(.)ident(Text)operator(;) + ident(ValueLabelClicked) operator(:=) ident(False)operator(;) + ident(SortBy) operator(:=) ident(vlcName)operator(;) + ident(SortByColumn) operator(:=) reserved(nil)operator(;) + + ident(ValueListResize)operator(()ident(Sender)operator(\);) + ident(ValueList)operator(.)ident(Items)operator(.)ident(Clear)operator(;) + ident(CheckValueListHotTrack)operator(;) + + ident(ValueNames) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(ValuesCommon) operator(:=) ident(False)operator(;) + ident(ValueCommonType) operator(:=) integer(0)operator(;) + + ident(NewDefaultValueMI)operator(.)ident(ImageIndex) operator(:=) ident(iconMainValue)operator(;) + ident(NewStringMI)operator(.)ident(ImageIndex) operator(:=) ident(iconString)operator(;) + ident(NewDWORDMI)operator(.)ident(ImageIndex) operator(:=) ident(iconCardinal)operator(;) + ident(NewBinaryMI)operator(.)ident(ImageIndex) operator(:=) ident(iconBinary)operator(;) + ident(NewMultiStringMI)operator(.)ident(ImageIndex) operator(:=) ident(iconMultiString)operator(;) + ident(NewElseMI)operator(.)ident(ImageIndex) operator(:=) ident(iconValueElse)operator(;) + + ident(DublicateMI)operator(.)ident(ImageIndex) operator(:=) ident(iconValueDublicate)operator(;) + ident(DeleteMI)operator(.)ident(ImageIndex) operator(:=) ident(iconDelete)operator(;) + ident(ZeromizeMI)operator(.)ident(ImageIndex) operator(:=) ident(iconValueZeromize)operator(;) + + ident(EditMI)operator(.)ident(ImageIndex) operator(:=) ident(iconValueEdit)operator(;) + ident(EditBinaryMI)operator(.)ident(ImageIndex) operator(:=) ident(iconValueEditBinary)operator(;) + ident(RenameMI)operator(.)ident(ImageIndex) operator(:=) ident(iconRename)operator(;) + + ident(TakeAsMainValueMI)operator(.)ident(ImageIndex) operator(:=) ident(iconTakeAsMainValue)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ConvertValue)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +comment({var + Allow: Boolean; + OldActive: Integer; }) +reserved(begin) +comment({ TargetPage := ShowPC.Pages[TMenuItem(Sender\).Tag]; + + OldActive := ShowPC.ActivePageIndex; + ShowPC.ActivePageIndex := TMenuItem(Sender\).Tag; + WorkWin.ShowPCChanging(Sender, Allow\); + if not Allow then + ShowPC.ActivePageIndex := OldActive; }) +reserved(end)operator(;) + +reserved(function) ident(ValueDataSize)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Typ)operator(:) ident(TRegDataType)operator(;) + ident(Size)operator(:) ident(Integer)operator(;) +comment(// ValueName: string;) +comment(// SL: TStringList;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(PrefWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + +comment(// ValueName := RealValueName(Item\);) + ident(Typ) operator(:=) ident(Context)operator(.)ident(Typ)operator(;) + ident(Size) operator(:=) ident(Length)operator(()ident(Context)operator(.)ident(Data)operator(\);) + + reserved(if) ident(Typ) reserved(in) ident(rdStringTypes) reserved(then) + reserved(if) reserved(not) ident(PrefWin)operator(.)ident(CountZeroByteCB)operator(.)ident(Checked) reserved(then) + ident(Dec)operator(()ident(Size)operator(\);) + + reserved(if) ident(Typ) operator(=) ident(rdMultiString) reserved(then) + reserved(if) ident(PrefWin)operator(.)ident(ShowLineCountCB)operator(.)ident(Checked) reserved(then) reserved(begin) + ident(Size) operator(:=) ident(CharCount)operator(()ident(StrOfByteA)operator(()ident(Context)operator(.)ident(Data)operator(\),) char(#0)operator(\)) operator(-) integer(2)operator(;) +comment({ SL := TStringList.Create; + try + Reg.ReadMultiString(ValueName, SL, PrefWin.UseExtendedModelCB.Checked\); + Size := SL.Count; + finally + SL.Free; + end; }) + ident(Result) operator(:=) char<delimiter(')content(#)delimiter(')>operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(Result) operator(+) ident(IntToStr)operator(()ident(Size)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ValueDataType)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(StrOfRegDataType)operator(()ident(Context)operator(.)ident(Typ)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(DataPreviewOfContext)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + + reserved(function) ident(DWORDPreview)operator(()ident(Value)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) + reserved(begin) + reserved(if) ident(PrefWin)operator(.)ident(ShowDwordAsHex)operator(.)ident(Checked) reserved(then) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(Value)operator(\)) operator(+) string<delimiter(')content( = $)delimiter(')> operator(+) ident(IntToHex)operator(()ident(Value)operator(,) integer(8)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(Value)operator(\)) + reserved(end)operator(;) + + reserved(function) ident(BinaryPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + reserved(var) + ident(z)operator(:) reserved(string)operator(;) + + reserved(function) ident(DWORDStringOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(AddBinary)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) + reserved(var) + ident(piece)operator(:) ident(TByteA)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(i) operator(:=) integer(0)operator(;) + reserved(while) operator(()ident(i) operator(<=) ident(High)operator(()ident(a)operator(\)\)) reserved(and) operator(()ident(Length)operator(()ident(Result)operator(\)) operator(<) ident(MaxPreviewLen)operator(\)) reserved(do) reserved(begin) + ident(piece) operator(:=) ident(Copy)operator(()ident(a)operator(,) ident(i)operator(,) integer(4)operator(\);) + reserved(if) ident(AddBinary) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(FriendlyStr)operator(()ident(piece)operator(\)) operator(+) char<delimiter(')content(=)delimiter(')>operator(;) + ident(SetLength)operator(()ident(piece)operator(,) integer(4)operator(\);) + ident(Result) operator(:=) ident(Result) operator(+) ident(IntToStr)operator(()ident(PInteger)operator(()ident(piece)operator(\)^\)) operator(+) string<delimiter(')content( )delimiter(')>operator(;) + ident(Inc)operator(()ident(i)operator(,) ident(SizeOf)operator(()ident(Integer)operator(\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(begin) + reserved(with) ident(Context) reserved(do) reserved(begin) + ident(Data) operator(:=) ident(Copy)operator(()ident(Data)operator(,) integer(0)operator(,) ident(MaxPreviewLen)operator(\);) + reserved(case) ident(PrefWin)operator(.)ident(ShowBinaryAsRG)operator(.)ident(ItemIndex) reserved(of) + integer(0)operator(:) ident(z) operator(:=) ident(FriendlyStr)operator(()ident(Data)operator(\);) + integer(1)operator(:) ident(z) operator(:=) ident(DWORDStringOfByteA)operator(()ident(Data)operator(\);) + integer(2)operator(:) ident(z) operator(:=) ident(DWORDStringOfByteA)operator(()ident(Data)operator(,) ident(True)operator(\);) + integer(3)operator(:) ident(z) operator(:=) ident(BinOfByteA)operator(()ident(Data)operator(,) integer(8)operator(,) string<delimiter(')content( )delimiter(')>operator(\);) + integer(4)operator(:) ident(z) operator(:=) ident(HexOfByteA)operator(()ident(Data)operator(,) integer(0)operator(\);) + integer(5)operator(:) ident(z) operator(:=) ident(HexOfByteA)operator(()ident(Data)operator(,) integer(1)operator(\);) + integer(6)operator(:) ident(z) operator(:=) ident(HexOfByteA)operator(()ident(Data)operator(,) integer(2)operator(\);) + integer(7)operator(:) ident(z) operator(:=) ident(HexOfByteA)operator(()ident(Data)operator(,) integer(4)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(Copy)operator(()ident(z)operator(,) integer(1)operator(,) ident(MaxPreviewLen)operator(\);) + reserved(end)operator(;) + + reserved(function) ident(StringPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + reserved(var) + ident(s)operator(:) reserved(string)operator(;) + ident(Expanded)operator(:) reserved(string)operator(;) + ident(DoExpand)operator(:) ident(Boolean)operator(;) + reserved(begin) + ident(s) operator(:=) ident(PChar)operator(()ident(Context)operator(.)ident(Data)operator(\);) + reserved(with) ident(PrefWin) reserved(do) + ident(Result) operator(:=) ident(StringQuoterBegin) operator(+) ident(FriendlyStr)operator(()ident(s)operator(\)) operator(+) ident(StringQuoterEnd)operator(;) + reserved(if) ident(s) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Exit)operator(;) + + reserved(case) ident(PrefWin)operator(.)ident(ExpandStringsRG)operator(.)ident(ItemIndex) reserved(of) + integer(0)operator(:) ident(DoExpand) operator(:=) ident(False)operator(;) + integer(1)operator(:) ident(DoExpand) operator(:=) operator(()ident(Context)operator(.)ident(Typ) operator(=) ident(rdExpandString)operator(\)) reserved(and) operator(()ident(CharCount)operator(()ident(s)operator(,) char<delimiter(')content(%)delimiter(')>operator(\)) operator(>=) integer(2)operator(\);) + integer(2)operator(:) ident(DoExpand) operator(:=) ident(True)operator(;) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Unknown PrefWin.ExpandStringsRG.ItemIndex!)delimiter(')>operator(\);) + ident(PrefWin)operator(.)ident(ExpandStringsRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + ident(Exit)operator(;) + reserved(end)operator(;) + + reserved(if) ident(DoExpand) reserved(then) reserved(begin) + ident(Expanded) operator(:=) ident(ExpandString)operator(()ident(s)operator(\);) + reserved(if) ident(s) operator(<>) ident(Expanded) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) string<delimiter(')content( <)delimiter(')> operator(+) ident(Expanded) operator(+) char<delimiter(')content(>)delimiter(')>operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(function) ident(IntegerPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + reserved(begin) + reserved(if) ident(Length)operator(()ident(Context)operator(.)ident(Data)operator(\)) operator(>=) ident(SizeOf)operator(()ident(Cardinal)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(DWORDPreview)operator(()ident(PInteger)operator(()ident(Context)operator(.)ident(Data)operator(\)^\);) + reserved(end) reserved(else) + ident(Result) operator(:=) ident(BinaryPreview)operator(()ident(Context)operator(\);) + reserved(end)operator(;) + + reserved(function) ident(MultiStringPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) + reserved(var) + ident(z)operator(:) reserved(string)operator(;) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(z) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(RegMultiStringOfByteA)operator(()ident(Context)operator(.)ident(Data)operator(,) ident(SL)operator(,) ident(PrefWin)operator(.)ident(UseExtendedModelCB)operator(.)ident(Checked)operator(\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(z) operator(:=) ident(z) operator(+) ident(SL)operator([)ident(i)operator(]) operator(+) string<delimiter(')content( )delimiter(')>operator(;) + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(Copy)operator(()ident(FriendlyStr)operator(()ident(z)operator(\),) integer(1)operator(,) ident(MaxPreviewLen)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(PrefWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(if) operator(()ident(Context)operator(.)ident(Data) operator(=) reserved(nil)operator(\)) reserved(or) operator(()ident(Length)operator(()ident(Context)operator(.)ident(Data)operator(\)) operator(>) ident(RegMaxDataSize)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Length)operator(()ident(Context)operator(.)ident(Data)operator(\)) operator(>) ident(MaxPreviewLen) reserved(then) + ident(SetLength)operator(()ident(Context)operator(.)ident(Data)operator(,) ident(MaxPreviewLen)operator(\);) + + reserved(if) ident(PrefWin)operator(.)ident(ShowAsBinaryCB)operator(.)ident(Checked) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(BinaryPreview)operator(()ident(Context)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(case) ident(Context)operator(.)ident(Typ) reserved(of) + ident(rdExpandString)operator(,) ident(rdString)operator(:) ident(Result) operator(:=) ident(StringPreview)operator(()ident(Context)operator(\);) + ident(rdCardinal)operator(,) ident(rdCardBigEndian)operator(:) ident(Result) operator(:=) ident(IntegerPreview)operator(()ident(Context)operator(\);) + ident(rdMultiString)operator(:) ident(Result) operator(:=) ident(MultiStringPreview)operator(()ident(Context)operator(\);) + reserved(else) + reserved(if) ident(PrefWin)operator(.)ident(Smart4BBCB)operator(.)ident(Checked) reserved(and) operator(()ident(Length)operator(()ident(Context)operator(.)ident(Data)operator(\)) operator(=) integer(4)operator(\)) reserved(then) + ident(Result) operator(:=) ident(IntegerPreview)operator(()ident(Context)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(BinaryPreview)operator(()ident(Context)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ValueDataPreview)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(DataPreviewOfContext)operator(()ident(Context)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(IconOfDataType)operator(()ident(Typ)operator(:) ident(TRegDataType)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Typ) reserved(in) operator([)ident(rdNone)operator(..)ident(rdLastType)operator(]) reserved(then) + ident(Result) operator(:=) ident(iconFirstType) operator(+) ident(Ord)operator(()ident(Typ)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(iconUnknownType)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ValueTypeIcon)operator(()ident(Context)operator(:) ident(TRegContext)operator(\):) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(IconOfDataType)operator(()ident(Context)operator(.)ident(Typ)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TValuesWin)operator(.)ident(UpdateValue)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) ident(Item)operator(:) ident(TListItem)operator(\):) ident(Boolean)operator(;) +comment(//Return Value: True if something has changed) +reserved(var) + ident(Size)operator(,) ident(Typ)operator(,) ident(Data)operator(:) reserved(string)operator(;) + ident(Icon)operator(:) ident(Integer)operator(;) + ident(Context)operator(:) ident(TRegContext)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Context) operator(:=) ident(Reg)operator(.)ident(ReadContext)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\);) + ident(Data) operator(:=) ident(ValueDataPreview)operator(()ident(Context)operator(\);) + ident(Size) operator(:=) ident(ValueDataSize)operator(()ident(Context)operator(\);) + ident(Typ) operator(:=) ident(ValueDataType)operator(()ident(Context)operator(\);) + ident(Icon) operator(:=) ident(ValueTypeIcon)operator(()ident(Context)operator(\);) + + reserved(if) ident(Icon) operator(<>) ident(Item)operator(.)ident(ImageIndex) reserved(then) reserved(begin) + ident(Item)operator(.)ident(ImageIndex) operator(:=) ident(Icon)operator(;) + ident(Result) operator(:=) ident(True)operator(;) + reserved(end)operator(;) + + reserved(while) ident(Item)operator(.)ident(SubItems)operator(.)ident(Count) operator(<) ident(Integer)operator(()ident(High)operator(()ident(TValueListColumn)operator(\)\)) reserved(do) + ident(Item)operator(.)ident(SubItems)operator(.)ident(Add)operator(()string<delimiter(')delimiter(')>operator(\);) + + reserved(if) ident(Size) operator(<>) ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcSize)operator(]]) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcSize)operator(]]) operator(:=) ident(Size)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Typ) operator(<>) ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcType)operator(]]) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcType)operator(]]) operator(:=) ident(Typ)operator(;) + reserved(end)operator(;) + + reserved(if) operator(()ident(Data) operator(<>) ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcData)operator(]]\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + ident(Item)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcData)operator(]]) operator(:=) ident(Data)operator(;) + reserved(if) ident(IsMainValue)operator(()ident(Item)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Repaint)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(AppendNewValueInfos)operator(()ident(Item)operator(:) ident(TListItem)operator(;) ident(Context)operator(:) ident(TRegContext)operator(\);) +reserved(begin) + ident(Item)operator(.)ident(ImageIndex) operator(:=) ident(ValueTypeIcon)operator(()ident(Context)operator(\);) + reserved(with) ident(Item)operator(.)ident(SubItems) reserved(do) reserved(begin) + ident(Append)operator(()ident(ValueDataSize)operator(()ident(Context)operator(\)\);) + ident(Append)operator(()ident(ValueDataType)operator(()ident(Context)operator(\)\);) + ident(Append)operator(()ident(ValueDataPreview)operator(()ident(Context)operator(\)\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TValuesWin)operator(.)ident(AddValue)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) + ident(AppendInfos)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(TListItem)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(ValueList)operator(.)ident(Items)operator(.)ident(AddItem)operator(()reserved(nil)operator(,) operator(-)integer(1)operator(\);) + ident(Result)operator(.)ident(Indent) operator(:=) operator(-)integer(1)operator(;) + ident(SetRealValueName)operator(()ident(Result)operator(,) ident(ValueName)operator(\);) + reserved(if) ident(AppendInfos) reserved(then) + ident(AppendNewValueInfos)operator(()ident(Result)operator(,) ident(Reg)operator(.)ident(ReadContext)operator(()ident(ValueName)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListChange)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) + ident(Change)operator(:) ident(TItemChange)operator(\);) +reserved(var) + ident(ValueName)operator(:) reserved(string)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) + + reserved(function) ident(ComputeValuesCommon)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(var) ident(DataType)operator(:) ident(TRegDataType)operator(\):) ident(Boolean)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(ItemType)operator(:) ident(TRegDataType)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + + ident(i) operator(:=) integer(0)operator(;) + ident(DataType) operator(:=) integer(0)operator(;) + reserved(while) ident(i) operator(<) ident(ValueList)operator(.)ident(Items)operator(.)ident(Count) reserved(do) reserved(begin) + ident(Item) operator(:=) ident(ValueList)operator(.)ident(Items)operator([)ident(i)operator(];) + reserved(if) reserved(not) ident(Item)operator(.)ident(Selected) reserved(then) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(Continue)operator(;) reserved(end)operator(;) + + ident(ValueName) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\);) + reserved(if) ident(Reg)operator(.)ident(ValueReallyExists)operator(()ident(ValueName)operator(\)) reserved(then) reserved(begin) + + ident(ItemType) operator(:=) ident(Reg)operator(.)ident(GetDataType)operator(()ident(ValueName)operator(\);) + reserved(if) reserved(not) ident(Result) reserved(then) reserved(begin) + ident(DataType) operator(:=) ident(ItemType)operator(;) + ident(Result) operator(:=) ident(True)operator(;) + reserved(end) reserved(else) reserved(if) ident(ItemType) operator(<>) ident(DataType) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + ident(DataType) operator(:=) integer(0)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + + reserved(with) ident(ValueNames) reserved(do) + reserved(if) ident(Item)operator(.)ident(Focused) reserved(then) + ident(Insert)operator(()integer(0)operator(,) ident(ValueName)operator(\)) + reserved(else) + ident(Add)operator(()ident(ValueName)operator(\);) + + reserved(end) reserved(else) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Value has been deleted!)delimiter(')>operator(\);) + ident(DataType) operator(:=) integer(0)operator(;) + ident(Result) operator(:=) ident(False)operator(;) + ident(Reload)operator(;) + ident(Break)operator(;) reserved(end)operator(;) + + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Item)operator(\)) reserved(or) ident(ValueList)operator(.)ident(IsEditing) reserved(or) reserved(not) ident(ValueList)operator(.)ident(Enabled) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Change) operator(<>) ident(ctState) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(WorkWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(if) operator(()ident(ValueList)operator(.)ident(SelCount) operator(=) integer(0)operator(\)) reserved(then) reserved(begin) + ident(ValueNames)operator(.)ident(Clear)operator(;) + ident(WorkWin)operator(.)ident(ReInitShowPC)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) reserved(not) ident(Item)operator(.)ident(Focused) reserved(then) + ident(Exit)operator(;) + + ident(WorkWin)operator(.)ident(ReInitShowPC)operator(;) + + ident(ValueNames)operator(.)ident(Clear)operator(;) + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\)) reserved(then) reserved(begin) + ident(ValuesCommon) operator(:=) ident(ComputeValuesCommon)operator(()ident(Reg)operator(,) ident(ValueCommonType)operator(\);) + reserved(if) ident(ValuesCommon) reserved(then) + ident(WorkWin)operator(.)ident(ShowValues)operator(()ident(Reg)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(MainWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(ActiveControl) operator(=) ident(ValueList) reserved(then) + ident(MainWin)operator(.)ident(SetStatus)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomListView)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) +reserved(begin) + reserved(with) ident(ValueList)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Item)operator(.)ident(Focused) reserved(then) + ident(Style) operator(:=) ident(Style) operator(+) operator([)ident(fsBold)operator(];) + reserved(if) ident(ItemIsDefaultValue)operator(()ident(Item)operator(\)) reserved(then) + ident(Color) operator(:=) ident(clBrightYellow) + reserved(else) + ident(Color) operator(:=) ident(ColorOfDataType)operator(()ident(TRegDataType)operator(()ident(Item)operator(.)ident(ImageIndex) operator(-) ident(iconFirstType)operator(\)\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValueListChange)operator(()ident(Sender)operator(,) ident(ValueList)operator(.)ident(ItemFocused)operator(,) ident(ctState)operator(\);) + ident(MainPC)operator(.)ident(ActivePage) operator(:=) ident(WorkWin)operator(.)ident(WorkPage)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(WorkWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(WorkWin)operator(.)ident(EditData)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListEditing)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) + reserved(var) ident(AllowEdit)operator(:) ident(Boolean)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(ValueLabelClicked) reserved(then) reserved(begin) + ident(AllowEdit) operator(:=) ident(False)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(ItemIsDefaultValue)operator(()ident(Item)operator(\)) reserved(then) comment(//unschön, aber beste Lösung bisher) + ident(Keyboard)operator(.)ident(SimKey)operator(()ident(VK_DELETE)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListEdited)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) + reserved(var) ident(S)operator(:) reserved(string)operator(\);) +reserved(var) + ident(Old)operator(:) reserved(string)operator(;) + ident(OldCaption)operator(:) reserved(string)operator(;) +reserved(begin) + ident(OldCaption) operator(:=) ident(Item)operator(.)ident(Caption)operator(;) + ident(Old) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\);) + + reserved(if) ident(s) operator(=) ident(Old) reserved(then) reserved(begin) + reserved(if) ident(ItemIsDefaultValue)operator(()ident(Item)operator(\)) reserved(then) + ident(s) operator(:=) ident(DefaultValueCaption)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + reserved(try) + ident(Item)operator(.)ident(Caption) operator(:=) ident(s)operator(;) + + reserved(if) ident(TryRenameValue)operator(()ident(Old)operator(,) ident(s)operator(\)) reserved(then) reserved(begin) + ident(SetRealValueName)operator(()ident(Item)operator(,) ident(s)operator(\);) comment(//Sichere Zuweisung des Standard-Flags) + ident(s) operator(:=) ident(Item)operator(.)ident(Caption)operator(;) comment(//Anschließend externer Aufruf "Item.Caption := s"!) + reserved(end) reserved(else) reserved(begin) + ident(s) operator(:=) ident(OldCaption)operator(;) + reserved(end)operator(;) + + reserved(finally) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(var) + ident(T)operator(:) reserved(string)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) +reserved(begin) + reserved(if) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(TreeWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(Item) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + + reserved(case) ident(Key) reserved(of) + ident(VK_SPACE)operator(:) ident(JumpToSel)operator(()ident(ValueList)operator(\);) + + ident(VK_F9)operator(:) ident(SwapFonts)operator(()ident(ValueList)operator(\);) + + ident(VK_F5)operator(:) ident(Reload)operator(;) + + ident(VK_F12)operator(:) reserved(begin) comment(//Sort) + reserved(if) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) + ident(T) operator(:=) ident(Item)operator(.)ident(Caption)operator(;) + ident(ValueList)operator(.)ident(SortType) operator(:=) ident(TSortType)operator(()integer(2) operator(-) operator(()ident(Integer)operator(()ident(ValueList)operator(.)ident(SortType)operator(\)\)\);) + reserved(if) ident(ValueList)operator(.)ident(SortType) operator(=) ident(stNone) reserved(then) + ident(TreeWin)operator(.)ident(RegTVChange)operator(()ident(Sender)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) + ident(ValueList)operator(.)ident(ItemFocused) operator(:=) ident(FindItem)operator(()ident(ValueList)operator(,) ident(T)operator(\);) + reserved(if) ident(Assigned)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\)) reserved(then) + ident(ValueList)operator(.)ident(ItemFocused)operator(.)ident(MakeVisible)operator(()ident(True)operator(\);) + reserved(end)operator(;) + + ident(VK_DELETE)operator(:) ident(DeleteMIClick)operator(()ident(Sender)operator(\);) + + ident(VK_RETURN)operator(:) ident(ValueListDblCLick)operator(()ident(Sender)operator(\);) + + ident(Ord)operator(()char<delimiter(')content(C)delimiter(')>operator(\):) + reserved(if) reserved(not) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(CopyPathMIClick)operator(()ident(Sender)operator(\);) + + ident(VK_SCROLL)operator(:) ident(CheckValueListHotTrack)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(ValueList) reserved(do) + ident(Columns)operator([)integer(3)operator(].)ident(Width) operator(:=) ident(ClientWidth) operator(-) operator(()integer(0) operator(+) + ident(Columns)operator([)integer(0)operator(].)ident(Width) operator(+) ident(Columns)operator([)integer(1)operator(].)ident(Width) operator(+) ident(Columns)operator([)integer(2)operator(].)ident(Width)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(DeleteValue)operator(;) +reserved(var) + ident(Item)operator(,) ident(NewSel)operator(:) ident(TListItem)operator(;) + ident(YesToAll)operator(:) ident(Boolean)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(DeleteIt)operator(()ident(Item)operator(:) ident(TListItem)operator(\);) + reserved(begin) + ident(OpenCurKey)operator(;) + reserved(if) ident(MainReg)operator(.)ident(DeleteValue)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)) + reserved(and) reserved(not) ident(MainReg)operator(.)ident(ValueReallyExists)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)) reserved(then) reserved(begin) + ident(Item)operator(.)ident(Delete)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Could not delete Value )delimiter(')> operator(+) ident(Quote)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)\);) + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + + reserved(if) ident(IsMainValue)operator(()ident(Item)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Repaint)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + + ident(NewSel) operator(:=) ident(GetNextBestNotSelected)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\);) + + ident(YesToAll) operator(:=) ident(False)operator(;) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(i) operator(<) ident(ValueList)operator(.)ident(Items)operator(.)ident(Count) reserved(do) reserved(begin) + ident(Item) operator(:=) ident(ValueList)operator(.)ident(Items)operator([)ident(i)operator(];) + reserved(if) reserved(not) ident(Item)operator(.)ident(Selected) reserved(then) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(Continue)operator(;) reserved(end)operator(;) + + reserved(if) ident(YesToAll) reserved(then) + ident(DeleteIt)operator(()ident(Item)operator(\)) + reserved(else) reserved(begin) + reserved(case) ident(MessageDlg)operator(()string<delimiter(')content(Do you really want to delete the Value )delimiter(')> operator(+) + ident(Quote)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)) operator(+) char<delimiter(')content(?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbYesToAll)operator(,) ident(mbNo)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(of) + ident(mrYes)operator(:) ident(DeleteIt)operator(()ident(Item)operator(\);) + ident(mrYesToAll)operator(:) ident(YesToAll) operator(:=) ident(True)operator(;) + ident(mrCancel)operator(:) ident(Exit)operator(;) + ident(mrNo)operator(:) reserved(begin) + ident(Item)operator(.)ident(Selected) operator(:=) ident(False)operator(;) + ident(NewSel) operator(:=) ident(Item)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Assigned)operator(()ident(NewSel)operator(\)) reserved(then) reserved(begin) + ident(ValueList)operator(.)ident(ItemFocused) operator(:=) ident(NewSel)operator(;) + ident(NewSel)operator(.)ident(Selected) operator(:=) ident(True)operator(;) + reserved(end) reserved(else) + ident(WorkWin)operator(.)ident(ReInitShowPC)operator(;) + + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ZeromizeValue)operator(;) +reserved(var) + ident(Item)operator(:) ident(TListItem)operator(;) + ident(YesToAll)operator(:) ident(Boolean)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(ZeromizeIt)operator(()ident(Item)operator(:) ident(TListItem)operator(\);) + reserved(begin) + reserved(with) ident(MainReg) reserved(do) reserved(begin) + ident(OpenCurKey)operator(;) + ident(ZeromizeValue)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\);) + ident(UpdateValue)operator(()ident(MainReg)operator(,) ident(Item)operator(\);) + ident(CloseKey)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + + ident(YesToAll) operator(:=) ident(False)operator(;) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(i) operator(<) ident(ValueList)operator(.)ident(Items)operator(.)ident(Count) reserved(do) reserved(begin) + ident(Item) operator(:=) ident(ValueList)operator(.)ident(Items)operator([)ident(i)operator(];) + reserved(if) reserved(not) ident(Item)operator(.)ident(Selected) reserved(then) reserved(begin) + ident(Inc)operator(()ident(i)operator(\);) + ident(Continue)operator(;) reserved(end)operator(;) + + reserved(if) ident(YesToAll) reserved(then) + ident(ZeromizeIt)operator(()ident(Item)operator(\)) + reserved(else) + reserved(case) ident(MessageDlg)operator(()string<delimiter(')content(Do you really want to zeromize ValueData of )delimiter(')> operator(+) + ident(Quote)operator(()ident(RealValueName)operator(()ident(Item)operator(\)\)) operator(+) string<delimiter(')content( ?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbYesToAll)operator(,) ident(mbNo)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(of) + + ident(mrYes)operator(:) reserved(begin) + ident(ZeromizeIt)operator(()ident(Item)operator(\);) + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) + + ident(mrYesToAll)operator(:) reserved(begin) + ident(YesToAll) operator(:=) ident(True)operator(;) + ident(ZeromizeIt)operator(()ident(Item)operator(\);) + reserved(end)operator(;) + ident(mrCancel)operator(:) ident(Exit)operator(;) + reserved(end)operator(;) + + reserved(if) ident(IsMainValue)operator(()ident(Item)operator(\)) reserved(then) + ident(RegTV)operator(.)ident(Repaint)operator(;) + reserved(end)operator(;) + + + ident(SpyThread)operator(.)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Writable)operator(,) ident(ValueOK)operator(,) ident(OnlyOneValue)operator(,) ident(OneValueOK)operator(:) ident(Boolean)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\)) reserved(then) + ident(ValueList)operator(.)ident(ItemFocused)operator(.)ident(Selected) operator(:=) ident(True)operator(;) + + reserved(if) ident(csDestroying) reserved(in) operator(()ident(TreeWin)operator(.)ident(ComponentState) operator(+) ident(PrefWin)operator(.)ident(ComponentState)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Writable) operator(:=) reserved(not) ident(TreeWin)operator(.)ident(CantWrite)operator(;) + ident(NewDefaultValueMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + ident(NewStringMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + ident(NewDWORDMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + ident(NewBinaryMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + ident(NewMultiStringMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + ident(NewElseMI)operator(.)ident(Visible) operator(:=) ident(Writable)operator(;) + + ident(ValueOK) operator(:=) ident(Writable) reserved(and) operator(()ident(ValueList)operator(.)ident(ItemFocused) operator(<>) reserved(nil)operator(\);) + ident(OnlyOneValue) operator(:=) ident(ValueList)operator(.)ident(SelCount) operator(=) integer(1)operator(;) + ident(OneValueOK) operator(:=) ident(OnlyOneValue) reserved(and) ident(ValueOK)operator(;) + + ident(EditMI)operator(.)ident(Visible) operator(:=) ident(ValueOK)operator(;) + ident(EditBinaryMI)operator(.)ident(Visible) operator(:=) ident(ValueOK)operator(;) + ident(DublicateMI)operator(.)ident(Visible) operator(:=) ident(OneValueOK)operator(;) + ident(CopyPathMI)operator(.)ident(Visible) operator(:=) ident(OnlyOneValue)operator(;) + ident(CopyDataPreviewMI)operator(.)ident(Visible) operator(:=) ident(OnlyOneValue)operator(;) + ident(TakeAsMainValueMI)operator(.)ident(Visible) operator(:=) ident(OnlyOneValue)operator(;) + ident(RenameMI)operator(.)ident(Visible) operator(:=) ident(OneValueOK)operator(;) + ident(DeleteMI)operator(.)ident(Visible) operator(:=) ident(ValueOK)operator(;) + ident(ZeromizeMI)operator(.)ident(Visible) operator(:=) ident(ValueOK)operator(;) + + ident(Item) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(TakeAsMainValueMI)operator(.)ident(Checked) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\)) operator(=) ident(PrefWin)operator(.)ident(MainPreviewE)operator(.)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(MainWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + ident(MainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(,) ident(Key)operator(,) ident(Shift)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListDeletion)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(SpyThread)operator(\)) reserved(then) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(WorkWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Assigned)operator(()ident(ShowPC)operator(.)ident(ActivePage)operator(\)) + reserved(and) ident(Item)operator(.)ident(Selected) reserved(and) ident(Item)operator(.)ident(Focused) reserved(then) reserved(begin) + ident(ValueList)operator(.)ident(ItemFocused) operator(:=) ident(GetNextBest)operator(()ident(Item)operator(\);) + ident(WorkWin)operator(.)ident(ReInitShowPC)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(DeleteMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + ident(DeleteValue)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(RenameMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\)) reserved(then) reserved(begin) + ident(ValueLabelClicked) operator(:=) ident(True)operator(;) + ident(ValueList)operator(.)ident(ItemFocused)operator(.)ident(EditCaption)operator(;) + ident(ValueLabelClicked) operator(:=) ident(False)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewBigEndianMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdCardBigEndian)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewExpandStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdExpandString)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewMultiStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(rdMultiString)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewStrangeTypeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CreateValue)operator(()ident(TRegDataType)operator(()ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(Tag)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(NewDefaultValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(DefaultItem)operator(:) ident(TListItem)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) operator(()ident(TreeWin)operator(.)ident(ComponentState) operator(+) ident(MainWin)operator(.)ident(ComponentState)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(if) ident(TreeWin)operator(.)ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(MainReg) reserved(do) reserved(begin) + reserved(try) + ident(OpenCurKey)operator(;) + + reserved(if) ident(StandardValueExists) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Default Value already exists.)delimiter(')>operator(\);) + ident(CloseKey)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(WriteString)operator(()string<delimiter(')delimiter(')>operator(,) string<delimiter(')delimiter(')>operator(\);) + + reserved(if) reserved(not) ident(StandardValueExists) reserved(then) reserved(begin) + ident(ShowMessage)operator(()string<delimiter(')content(Could not create Default Value.)delimiter(')>operator(\);) + ident(CloseKey)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(MainReg)operator(,) string<delimiter(')delimiter(')>operator(\);) + reserved(finally) + ident(CloseKey)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) reserved(begin) + ident(DefaultItem) operator(:=) reserved(nil)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(ItemIsDefaultValue)operator(()ident(Item)operator([)ident(i)operator(]\)) reserved(then) + ident(Break)operator(;) + + reserved(if) ident(i) operator(<) ident(Count) reserved(then) + ident(DefaultItem) operator(:=) ident(Item)operator([)ident(i)operator(];) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(DefaultItem)operator(\)) reserved(then) + ident(ShowMessage)operator(()string<delimiter(')content(Error: Lost Default Value!)delimiter(')>operator(\)) + reserved(else) reserved(begin) + ident(SelectItemOnly)operator(()ident(ValueList)operator(,) ident(DefaultItem)operator(\);) + ident(MainWin)operator(.)ident(StatusBarUpdate)operator(;) + ident(ValueListDblClick)operator(()ident(Sender)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item)operator(:) ident(TListItem)operator(;) + ident(Change)operator(:) ident(TItemChange)operator(;) reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) +reserved(begin) + reserved(if) ident(Item) operator(=) reserved(nil) reserved(then) + ident(AllowChange) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) +reserved(begin) + ident(ValueLabelClicked) operator(:=) ident(False)operator(;) + reserved(with) ident(ValueList) reserved(do) + reserved(if) operator(([)ident(htOnIcon)operator(,) ident(htOnLabel)operator(]) operator(*) ident(GetHitTestInfoAt)operator(()ident(X)operator(,) ident(Y)operator(\)\)) operator(<>) operator([]) reserved(then) + ident(ValueLabelClicked) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(EditBinaryMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(WorkWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(WorkWin)operator(.)ident(ShowAsBinary) operator(:=) ident(True)operator(;) + ident(ValueListChange)operator(()ident(Sender)operator(,) ident(ValueList)operator(.)ident(ItemFocused)operator(,) ident(ctState)operator(\);) + ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(EditMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListCustomDrawSubItem)operator(()ident(Sender)operator(:) ident(TCustomListView)operator(;) + ident(Item)operator(:) ident(TListItem)operator(;) ident(SubItem)operator(:) ident(Integer)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) + reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) +reserved(begin) + reserved(with) ident(ValueList)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + ident(Style) operator(:=) operator([];) + reserved(if) ident(SubItem) operator(=) integer(1) reserved(then) + ident(Color) operator(:=) ident(clSilver) + reserved(else) + ident(Color) operator(:=) ident(ColorOfDataType)operator(()ident(TRegDataType)operator(()ident(Item)operator(.)ident(ImageIndex) operator(-) ident(iconFirstType)operator(\)\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListCompare)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Item1)operator(,) ident(Item2)operator(:) ident(TListItem)operator(;) + ident(Data)operator(:) ident(Integer)operator(;) reserved(var) ident(Compare)operator(:) ident(Integer)operator(\);) +reserved(begin) + reserved(case) ident(SortBy) reserved(of) + ident(vlcName)operator(:) ident(Compare) operator(:=) ident(AnsiCompareText)operator(()ident(RealValueName)operator(()ident(Item1)operator(\),) ident(RealValueName)operator(()ident(Item2)operator(\)\);) + ident(vlcSize)operator(:) ident(Compare) operator(:=) ident(Integer)operator(() + ident(StrToIntDef)operator(()ident(Item1)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcSize)operator(]],) operator(-)integer(1)operator(\)) operator(>) + ident(StrToIntDef)operator(()ident(Item2)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcSize)operator(]],) operator(-)integer(1)operator(\)\);) + ident(vlcData)operator(:) ident(Compare) operator(:=) ident(Integer)operator(()ident(Item1)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcData)operator(]]) operator(>) + ident(Item2)operator(.)ident(SubItems)operator([)ident(SubItemIndex)operator([)ident(vlcData)operator(]]\);) + ident(vlcType)operator(:) ident(Compare) operator(:=) ident(Integer)operator(()ident(Item1)operator(.)ident(ImageIndex) operator(>) ident(Item2)operator(.)ident(ImageIndex)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(Assigned)operator(()ident(SortByColumn)operator(\)) + reserved(and) operator(()ident(SortByColumn)operator(.)ident(ImageIndex) operator(=) ident(iconSortArrowDesc)operator(\)) reserved(then) + ident(Compare) operator(:=) integer(1) operator(-) ident(Compare)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListColumnClick)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Column)operator(:) ident(TListColumn)operator(\);) +reserved(begin) + reserved(case) ident(Column)operator(.)ident(ImageIndex) reserved(of) + ident(iconSortArrowAsc)operator(:) ident(Column)operator(.)ident(ImageIndex) operator(:=) ident(iconSortArrowDesc)operator(;) + ident(iconSortArrowDesc)operator(:) ident(Column)operator(.)ident(ImageIndex) operator(:=) operator(-)integer(1)operator(;) + reserved(else) + reserved(if) ident(Assigned)operator(()ident(SortByColumn)operator(\)) reserved(then) + ident(SortByColumn)operator(.)ident(ImageIndex) operator(:=) operator(-)integer(1)operator(;) + reserved(if) ident(TValueListColumn)operator(()ident(Column)operator(.)ident(Tag)operator(\)) reserved(in) ident(ValueListColumnRange) reserved(then) + ident(SortBy) operator(:=) ident(TValueListColumn)operator(()ident(Column)operator(.)ident(Tag)operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Unknown Column Tag)delimiter(')>operator(\);) + ident(Column)operator(.)ident(ImageIndex) operator(:=) ident(iconSortArrowAsc)operator(;) + reserved(end)operator(;) + + reserved(if) ident(Column)operator(.)ident(ImageIndex) operator(=) operator(-)integer(1) reserved(then) + ident(ValueList)operator(.)ident(SortType) operator(:=) ident(stNone) + reserved(else) reserved(begin) + ident(ValueList)operator(.)ident(SortType) operator(:=) ident(stData)operator(;) + ident(SortByColumn) operator(:=) ident(Column)operator(;) + reserved(end)operator(;) + + ident(Update)operator(;) + ident(ValueList)operator(.)ident(AlphaSort)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CloneValue)operator(;) +reserved(var) + ident(OldName)operator(,) ident(NewName)operator(:) reserved(string)operator(;) + + reserved(function) ident(GetNewName)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(;) reserved(const) ident(OldName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Prefix)operator(:) reserved(string)operator(;) + reserved(begin) + reserved(if) ident(OldName) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Result) operator(:=) string<delimiter(')content(New Default Value)delimiter(')> + reserved(else) reserved(if) ident(Copy)operator(()ident(OldName)operator(,) integer(1)operator(,) integer(4)operator(\)) operator(<>) string<delimiter(')content(New )delimiter(')> reserved(then) + ident(Result) operator(:=) string<delimiter(')content(New )delimiter(')> operator(+) ident(OldName) + reserved(else) + ident(Result) operator(:=) ident(OldName)operator(;) + + ident(Prefix) operator(:=) ident(Result)operator(;) + ident(i) operator(:=) integer(1)operator(;) + reserved(while) ident(Reg)operator(.)ident(ValueExists)operator(()ident(Result)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(Prefix) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(IntToStr)operator(()ident(i)operator(\);) + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(TreeWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(TreeWin)operator(.)ident(CantWrite) reserved(then) + ident(Exit)operator(;) + + ident(OldName) operator(:=) ident(RealValueName)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\);) + + reserved(try) + ident(OpenCurKey)operator(;) + + ident(NewName) operator(:=) ident(GetNewName)operator(()ident(MainReg)operator(,) ident(OldName)operator(\);) + ident(MainReg)operator(.)ident(CopyValue)operator(()ident(OldName)operator(,) ident(NewName)operator(\);) + ident(AddValue)operator(()ident(MainReg)operator(,) ident(NewName)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(DublicateMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CloneValue)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CopyDataPreviewMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + ident(CopyDataPreview)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CopyDataPreview)operator(;) +reserved(begin) + ident(OpenCurKey)operator(;) + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(DataPreviewOfContext)operator(()ident(MainReg)operator(.)ident(ReadContext)operator(() + ident(RealValueName)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\)\)\);) + ident(MainReg)operator(.)ident(CloseKey)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(UpdateValues)operator(()ident(SelectedOnly)operator(:) ident(Boolean) operator(=) ident(False)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(Reg)operator(:) ident(TXRegistry)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + + ident(Reg) operator(:=) ident(TXRegistry)operator(.)ident(Create)operator(;) + reserved(try) + reserved(if) ident(OpenNodeOK)operator(()ident(Reg)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\)) reserved(then) + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(SelectedOnly) reserved(and) reserved(not) ident(Item)operator([)ident(i)operator(].)ident(Selected) reserved(then) + ident(Continue)operator(;) + ident(UpdateValue)operator(()ident(Reg)operator(,) ident(Item)operator([)ident(i)operator(]\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(finally) + ident(Reg)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + ident(SpyThread)operator(.)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TValuesWin)operator(.)ident(TryRenameValue)operator(()ident(OldName)operator(:) reserved(string)operator(;) + reserved(var) ident(NewName)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(x)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(if) ident(OldName) operator(=) ident(NewName) reserved(then) + ident(Exit)operator(;) + + reserved(if) operator(()ident(Length)operator(()ident(NewName)operator(\)) operator(>) ident(RegMaxValueNameLen)operator(\)) reserved(then) reserved(begin) + ident(NewName) operator(:=) ident(Copy)operator(()ident(NewName)operator(,) integer(1)operator(,) ident(RegMaxValueNameLen)operator(\);) + reserved(if) ident(MessageDlg)operator(() + string<delimiter(')content(The maximum size of a value name is )delimiter(')> operator(+) ident(IntToStr)operator(()ident(RegMaxValueNameLen)operator(\)) operator(+) string<delimiter(')content( characters.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Shorten the value name to:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(Quote)operator(()ident(StringWrap)operator(()ident(NewName)operator(,) integer(80)operator(\)\),) + ident(mtConfirmation)operator(,) operator([)ident(mbOK)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) operator(<>) ident(mrOK) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + + reserved(if) ident(CharIn)operator(()ident(NewName)operator(,) operator([)char(#0)operator(..)char(#31)operator(]\)) reserved(then) reserved(begin) + ident(NewName) operator(:=) ident(ReplaceChars)operator(()ident(NewName)operator(,) operator([)char(#0)operator(..)char(#31)operator(],) char<delimiter(')content(#)delimiter(')>operator(\);) + reserved(if) ident(MessageDlg)operator(()string<delimiter(')content(The following chars are not allowed in ValueNames:)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(- Control chars (#0..#31\))delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(The following name is allowed:)delimiter(')> operator(+) ident(EOL) operator(+) + ident(NewName) operator(+) ident(EOL) operator(+) + string<delimiter(')content(Use this name instead?)delimiter(')>operator(,) + ident(mtConfirmation)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(],) integer(0)operator(\)) operator(<>) ident(mrYes) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + + reserved(if) reserved(not) ident(OpenCurKey) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(SameText)operator(()ident(OldName)operator(,) ident(NewName)operator(\)) reserved(then) reserved(begin) comment(//CharCase ändern) + ident(x) operator(:=) ident(MainReg)operator(.)ident(GetFreeValueName)operator(;) + ident(MainReg)operator(.)ident(RenameValue)operator(()ident(OldName)operator(,) ident(x)operator(\);) + ident(MainReg)operator(.)ident(RenameValue)operator(()ident(x)operator(,) ident(NewName)operator(\);) + reserved(end) reserved(else) reserved(begin) + reserved(if) reserved(not) ident(MainReg)operator(.)ident(ValueReallyExists)operator(()ident(NewName)operator(\)) reserved(then) reserved(begin) + ident(MainReg)operator(.)ident(RenameValue)operator(()ident(OldName)operator(,) ident(NewName)operator(\);) + reserved(end) reserved(else) reserved(begin) + reserved(if) ident(NewName) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(ShowMessage)operator(()string<delimiter(')content(Default value already exists.)delimiter(')>operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Value )delimiter(')> operator(+) ident(Quote)operator(()ident(NewName)operator(\)) operator(+) string<delimiter(')content( already exists.)delimiter(')>operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(end)operator(;) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + + reserved(if) ident(TextIn)operator(()ident(NewName)operator(,) string<delimiter(')content(default)delimiter(')>operator(\)) reserved(then) + ident(AddHint)operator(()string<delimiter(')content(You can create default values by empty string ValueNames.)delimiter(')>operator(\);) + + ident(Result) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ZeromizeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ZeromizeValue)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(ValueList)operator(.)ident(IsEditing) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(csDestroying) reserved(in) ident(MainWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(MainWin)operator(.)ident(CopyPathClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TValuesWin)operator(.)ident(FindItemByRealName)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(for) ident(Result) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(SameText)operator(()ident(RealValueName)operator(()ident(Item)operator([)ident(Result)operator(]\),) ident(ValueName)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TValuesWin)operator(.)ident(FocusItem)operator(()ident(ARealValueName)operator(:) reserved(string)operator(;) + ident(FocusValueList)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(with) ident(ValueList) reserved(do) reserved(begin) + ident(i) operator(:=) ident(FindItemByRealName)operator(()ident(ARealValueName)operator(\);) + + reserved(if) operator(()ident(i) operator(>) operator(-)integer(1)operator(\)) reserved(and) operator(()ident(i) operator(<) ident(Items)operator(.)ident(Count)operator(\)) reserved(then) + ident(Selected) operator(:=) ident(Items)operator([)ident(i)operator(]) + reserved(else) + ident(Selected) operator(:=) reserved(nil)operator(;) + + ident(ItemFocused) operator(:=) ident(Selected)operator(;) + + ident(Result) operator(:=) ident(Assigned)operator(()ident(Selected)operator(\);) + reserved(if) ident(Result) reserved(then) + ident(JumpToSel)operator(()ident(ValueList)operator(\);) + + reserved(if) ident(FocusValueList) reserved(then) + ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(TakeAsMainValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Item)operator(:) ident(TListItem)operator(;) + ident(ValueName)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(PrefWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(Item) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Item)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(ValueName) operator(:=) ident(RealValueName)operator(()ident(Item)operator(\);) + reserved(with) ident(PrefWin)operator(.)ident(MainPreviewE) reserved(do) + reserved(if) ident(ValueName) operator(=) ident(Text) reserved(then) + ident(Text) operator(:=) string<delimiter(')delimiter(')> + reserved(else) + ident(Text) operator(:=) ident(ValueName)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(InitListColumnTags)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(ValueList)operator(.)ident(Columns)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(with) ident(ValueList)operator(.)ident(Columns)operator(.)ident(Items)operator([)ident(i)operator(]) reserved(do) reserved(begin) + ident(Tag) operator(:=) operator(-)integer(1)operator(;) + reserved(if) ident(Caption) operator(=) string<delimiter(')content(Name)delimiter(')> reserved(then) + ident(Tag) operator(:=) ident(Integer)operator(()ident(vlcName)operator(\)) + reserved(else) reserved(if) ident(Caption) operator(=) string<delimiter(')content(Size)delimiter(')> reserved(then) + ident(Tag) operator(:=) ident(Integer)operator(()ident(vlcSize)operator(\)) + reserved(else) reserved(if) ident(Caption) operator(=) string<delimiter(')content(Type)delimiter(')> reserved(then) + ident(Tag) operator(:=) ident(Integer)operator(()ident(vlcType)operator(\)) + reserved(else) reserved(if) ident(Caption) operator(=) string<delimiter(')content(Data)delimiter(')> reserved(then) + ident(Tag) operator(:=) ident(Integer)operator(()ident(vlcData)operator(\)) + reserved(else) + ident(ShowMessage)operator(()ident(Format)operator(()string<delimiter(')content(Error: Unknown ValueList.Columns[%d].Caption = "%s")delimiter(')>operator(,) + operator([)ident(Index)operator(,) ident(Caption)operator(]\)\);) + reserved(if) ident(Tag) operator(>) operator(-)integer(1) reserved(then) + ident(SubItemIndex)operator([)ident(TValueListColumn)operator(()ident(Tag)operator(\)]) operator(:=) ident(Index) operator(-) integer(1)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(FormShow)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(InitListColumnTags)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(Reload)operator(()ident(JumpToNewValue)operator(:) ident(Boolean) operator(=) ident(False)operator(;) + ident(ValueName)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) +reserved(var) + ident(Sel)operator(:) ident(TListItem)operator(;) + ident(SelIndex)operator(:) ident(Integer)operator(;) + ident(SelRealValueName)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(TreeWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(SelIndex) operator(:=) operator(-)integer(1)operator(;) + reserved(if) ident(JumpToNewValue) reserved(then) + ident(SelRealValueName) operator(:=) ident(ValueName) + reserved(else) reserved(begin) + ident(Sel) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + reserved(if) ident(Assigned)operator(()ident(Sel)operator(\)) reserved(then) + ident(SelIndex) operator(:=) ident(Sel)operator(.)ident(Index)operator(;) + + reserved(if) ident(SelIndex) operator(>) operator(-)integer(1) reserved(then) + ident(SelRealValueName) operator(:=) ident(RealValueName)operator(()ident(ValueList)operator(.)ident(Items)operator([)ident(SelIndex)operator(]\);) + reserved(end)operator(;) + + ident(TreeWin)operator(.)ident(RegTVChange)operator(()ident(Self)operator(,) ident(RegTV)operator(.)ident(Selected)operator(\);) + + reserved(if) ident(SelIndex) operator(>) operator(-)integer(1) reserved(then) + reserved(if) reserved(not) ident(FocusItem)operator(()ident(SelRealValueName)operator(,) ident(True)operator(\)) reserved(then) reserved(begin) + ident(SelIndex) operator(:=) ident(GetBestIndex)operator(()ident(ValueList)operator(,) ident(SelIndex)operator(\);) + reserved(if) ident(SelIndex) operator(>) operator(-)integer(1) reserved(then) + reserved(with) ident(ValueList) reserved(do) reserved(begin) + ident(Selected) operator(:=) ident(Items)operator([)ident(SelIndex)operator(];) + ident(ItemFocused) operator(:=) ident(Selected)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(LoadValues)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(Clock)operator(:) ident(TClock)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(WorkWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) reserved(begin) + ident(Clock) operator(:=) ident(TClock)operator(.)ident(Create)operator(()integer(1)operator(,) ident(tfSecs)operator(\);) + ident(ValueList)operator(.)ident(Enabled) operator(:=) ident(False)operator(;) + ident(BeginUpdate)operator(;) + reserved(try) + ident(Clear)operator(;) + ident(WorkWin)operator(.)ident(ReInitShowPC)operator(;) + + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(Reg)operator(.)ident(GetValueNames)operator(()ident(SL)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(ValuesWin)operator(.)ident(AddValue)operator(()ident(Reg)operator(,) ident(SL)operator([)ident(i)operator(]\);) + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + + reserved(finally) + ident(EndUpdate)operator(;) + ident(ValueList)operator(.)ident(Enabled) operator(:=) ident(True)operator(;) + ident(Clock)operator(.)ident(Stop)operator(;) + reserved(if) ident(MurphyMode) reserved(then) + ident(AddHint)operator(()ident(Format)operator(()string<delimiter(')content(Values loaded after %0.2f secs.)delimiter(')>operator(,) operator([)ident(Clock)operator(.)ident(SecsPassed)operator(]\)\);) + ident(Clock)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) +reserved(begin) +comment(// Action := caNone;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(ValueListClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CheckValueListHotTrack)operator(;) + reserved(if) ident(ValueList)operator(.)ident(HotTrack) reserved(then) + ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(CheckValueListHotTrack)operator(;) +reserved(const) + ident(StyleOfSwitch)operator(:) reserved(array)operator([)ident(Boolean)operator(]) reserved(of) ident(TListHotTrackStyles) operator(=) operator(() + operator([],) operator([)ident(htHandPoint)operator(,) ident(htUnderlineHot)operator(]) operator(\);) +reserved(var) + ident(NewHotTrack)operator(:) ident(Boolean)operator(;) +reserved(begin) + reserved(if) ident(csDestroying) reserved(in) ident(PrefWin)operator(.)ident(ComponentState) reserved(then) + ident(Exit)operator(;) + + ident(NewHotTrack) operator(:=) ident(ScrollON) reserved(xor) ident(PrefWin)operator(.)ident(ValuesSingleClickCB)operator(.)ident(Checked)operator(;) + reserved(if) ident(NewHotTrack) operator(=) ident(ValueList)operator(.)ident(HotTrack) reserved(then) ident(Exit)operator(;) + + reserved(with) ident(ValueList) reserved(do) reserved(begin) + ident(HotTrack) operator(:=) ident(NewHotTrack)operator(;) + ident(HotTrackStyles) operator(:=) ident(StyleOfSwitch)operator([)ident(HotTrack)operator(];) + ident(Mouse)operator(.)ident(CursorPos) operator(:=) ident(Mouse)operator(.)ident(CursorPos)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(SelectAllMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(Item)operator([)ident(i)operator(].)ident(Selected) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(InvertSelectionMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(with) ident(ValueList)operator(.)ident(Items) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(Item)operator([)ident(i)operator(].)ident(Selected) operator(:=) reserved(not) ident(Item)operator([)ident(i)operator(].)ident(Selected)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TValuesWin)operator(.)ident(FormDestroy)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValueNames)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) +reserved(unit) ident(WorkU)operator(;) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(Messages)operator(,) ident(SysUtils)operator(,) ident(Variants)operator(,) ident(Classes)operator(,) ident(Graphics)operator(,) ident(Controls)operator(,) ident(Forms)operator(,) + ident(Dialogs)operator(,) ident(StdCtrls)operator(,) ident(ComCtrls)operator(,) ident(NewPanels)operator(,) ident(Grids)operator(,) ident(Clipbrd)operator(,) + ident(IntEdit)operator(,) ident(ExtCtrls)operator(,) ident(Menus)operator(,) ident(YTools)operator(,) ident(CompEx)operator(,) ident(PlutoConst)operator(,) + ident(XReg)operator(,) ident(Clock)operator(,) ident(Colors)operator(,) ident(ShellAPI)operator(,) ident(IniFiles)operator(,) ident(Math)operator(,) + ident(keybrd)operator(,) ident(Buttons)operator(,) ident(YTypes)operator(,) ident(LinkLabel)operator(,) ident(start)operator(,) + ident(PrefTools)operator(,) ident(ImgList)operator(,) ident(PHexMemo)operator(,) ident(PipelineTh)operator(,) ident(DropSource)operator(,) ident(DropTarget)operator(,) + ident(CrackTools)operator(;) + +reserved(type) + ident(TColorStringFmt) operator(=) operator(()ident(csfThreeSpacedDecimals)operator(\);) + + ident(TWorkWin) operator(=) reserved(class)operator(()ident(TForm)operator(\)) + ident(StringPU)operator(:) ident(TPopupMenu)operator(;) + ident(SpaceMI)operator(:) ident(TMenuItem)operator(;) + ident(FileMI)operator(:) ident(TMenuItem)operator(;) + ident(FileOpenD)operator(:) ident(TOpenDialog)operator(;) + ident(MainPC)operator(:) ident(TPageControl)operator(;) + ident(HintPage)operator(:) ident(TTabSheet)operator(;) + ident(Splitter1)operator(:) ident(TSplitter)operator(;) + ident(HintLB)operator(:) ident(TListBox)operator(;) + ident(InfoMemo)operator(:) ident(TMemo)operator(;) + ident(WorkPage)operator(:) ident(TTabSheet)operator(;) + ident(WorkP)operator(:) ident(TPanel)operator(;) + ident(ShowPC)operator(:) ident(TPageControl)operator(;) + ident(StringPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel1)operator(:) ident(TBorderPanel)operator(;) + ident(StringE)operator(:) ident(TEdit)operator(;) + ident(OKStringB)operator(:) ident(TButton)operator(;) + ident(BoolStrCB)operator(:) ident(TCheckBox)operator(;) + ident(CancelStringB)operator(:) ident(TButton)operator(;) + ident(StringAsColorP)operator(:) ident(TPanel)operator(;) + ident(StringAsFileP)operator(:) ident(TBorderPanel)operator(;) + ident(IconImage)operator(:) ident(TImage)operator(;) + ident(IntPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel5)operator(:) ident(TBorderPanel)operator(;) + ident(OKIntB)operator(:) ident(TButton)operator(;) + ident(CardBoolCB)operator(:) ident(TCheckBox)operator(;) + ident(CancelIntB)operator(:) ident(TButton)operator(;) + ident(BinaryPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel6)operator(:) ident(TBorderPanel)operator(;) + ident(Panel2)operator(:) ident(TPanel)operator(;) + ident(Label5)operator(:) ident(TLabel)operator(;) + ident(OffsetHE)operator(:) ident(THexEdit)operator(;) + ident(OKBinaryB)operator(:) ident(TButton)operator(;) + ident(CancelBinaryB)operator(:) ident(TButton)operator(;) + ident(StringTypeRG)operator(:) ident(TRadioGroup)operator(;) + ident(SpyPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel2)operator(:) ident(TBorderPanel)operator(;) + ident(SpyResumeB)operator(:) ident(TButton)operator(;) + ident(SpySuspendB)operator(:) ident(TButton)operator(;) + ident(SpyLB)operator(:) ident(TListBox)operator(;) + ident(Label4)operator(:) ident(TLabel)operator(;) + ident(Label7)operator(:) ident(TLabel)operator(;) + ident(CardTypeRG)operator(:) ident(TRadioGroup)operator(;) + ident(MultiStringPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel7)operator(:) ident(TBorderPanel)operator(;) + ident(OKMultiStringB)operator(:) ident(TButton)operator(;) + ident(CancelMultiStringB)operator(:) ident(TButton)operator(;) + ident(MultiStringM)operator(:) ident(TMemo)operator(;) + ident(DataTypeComB)operator(:) ident(TComboBox)operator(;) + ident(CardinalE)operator(:) ident(TCardEdit)operator(;) + ident(ColorDlg)operator(:) ident(TColorDialog)operator(;) + ident(MultiStringOpenD)operator(:) ident(TOpenDialog)operator(;) + ident(MultiStringSaveD)operator(:) ident(TSaveDialog)operator(;) + ident(MultiStringPU)operator(:) ident(TPopupMenu)operator(;) + ident(LadenMI)operator(:) ident(TMenuItem)operator(;) + ident(SpeichernMI)operator(:) ident(TMenuItem)operator(;) + ident(Hinzufgen1)operator(:) ident(TMenuItem)operator(;) + ident(N1)operator(:) ident(TMenuItem)operator(;) + ident(SisyPage)operator(:) ident(TTabSheet)operator(;) + ident(SpyClearTracesB)operator(:) ident(TButton)operator(;) + ident(Label11)operator(:) ident(TLabel)operator(;) + ident(HexEdit1)operator(:) ident(THexEdit)operator(;) + ident(Label12)operator(:) ident(TLabel)operator(;) + ident(Label13)operator(:) ident(TLabel)operator(;) + ident(SortMultiStringMI)operator(:) ident(TMenuItem)operator(;) + ident(SpyTestL)operator(:) ident(TLabel)operator(;) + ident(Panel3)operator(:) ident(TPanel)operator(;) + ident(CurValueE)operator(:) ident(TEdit)operator(;) + ident(BorderPanel8)operator(:) ident(TBorderPanel)operator(;) + ident(BorderPanel9)operator(:) ident(TBorderPanel)operator(;) + ident(SisyTV)operator(:) ident(TTreeView)operator(;) + ident(TabImages)operator(:) ident(TImageList)operator(;) + ident(ChangeImages)operator(:) ident(TImageList)operator(;) + ident(Panel7)operator(:) ident(TPanel)operator(;) + ident(ColorPanel1)operator(:) ident(TColorPanel)operator(;) + ident(Splitter2)operator(:) ident(TSplitter)operator(;) + ident(SpyDelayIE)operator(:) ident(TPrefIntEdit)operator(;) + ident(ListTracesCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(Panel5)operator(:) ident(TPanel)operator(;) + ident(Panel8)operator(:) ident(TPanel)operator(;) + ident(SisyExpandGroupsCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(ClearChangesB)operator(:) ident(TButton)operator(;) + ident(FilterChangesB)operator(:) ident(TButton)operator(;) + ident(SisyTVPU)operator(:) ident(TPopupMenu)operator(;) + ident(SisyGotoKeyMI)operator(:) ident(TMenuItem)operator(;) + ident(SisyDeleteChangeMI)operator(:) ident(TMenuItem)operator(;) + ident(SisyActivateChangeMI)operator(:) ident(TMenuItem)operator(;) + ident(N3)operator(:) ident(TMenuItem)operator(;) + ident(SisyCopyPathMI)operator(:) ident(TMenuItem)operator(;) + ident(N4)operator(:) ident(TMenuItem)operator(;) + ident(Panel9)operator(:) ident(TPanel)operator(;) + ident(ExternalEditB)operator(:) ident(TButton)operator(;) + ident(LoadExternalB)operator(:) ident(TButton)operator(;) + ident(ReloadStringB)operator(:) ident(TButton)operator(;) + ident(BinaryHM)operator(:) ident(TPHexMemo)operator(;) + ident(PipelineCB)operator(:) ident(TCheckBox)operator(;) + ident(ReloadDWordB)operator(:) ident(TButton)operator(;) + ident(ReloadBinaryB)operator(:) ident(TButton)operator(;) + ident(ReloadMultiStringB)operator(:) ident(TButton)operator(;) + ident(DescL)operator(:) ident(TLabel)operator(;) + ident(SisyHKUCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(SisyHKLMCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(SisyHKUL)operator(:) ident(TLabel)operator(;) + ident(SisyHKLML)operator(:) ident(TLabel)operator(;) + ident(SisyListCB)operator(:) ident(TPrefCheckBox)operator(;) + ident(CardSpecial0B)operator(:) ident(TButton)operator(;) + ident(CardSpecial1B)operator(:) ident(TButton)operator(;) + ident(CardSpecial_1B)operator(:) ident(TButton)operator(;) + ident(CardSpecial7FB)operator(:) ident(TButton)operator(;) + ident(SisyPU)operator(:) ident(TPopupMenu)operator(;) + ident(Idle1)operator(:) ident(TMenuItem)operator(;) + ident(Lowest1)operator(:) ident(TMenuItem)operator(;) + ident(Lower1)operator(:) ident(TMenuItem)operator(;) + ident(Normal1)operator(:) ident(TMenuItem)operator(;) + ident(Higher1)operator(:) ident(TMenuItem)operator(;) + ident(Highes1)operator(:) ident(TMenuItem)operator(;) + ident(SisyShowCurrentPathMI)operator(:) ident(TMenuItem)operator(;) + ident(N5)operator(:) ident(TMenuItem)operator(;) + ident(MultiStringTypeRG)operator(:) ident(TRadioGroup)operator(;) + ident(SeparatorE)operator(:) ident(TEdit)operator(;) + ident(Label1)operator(:) ident(TLabel)operator(;) + ident(MultiStringCountL)operator(:) ident(TLabel)operator(;) + ident(DropFileTarget)operator(:) ident(TDropFileTarget)operator(;) + ident(CryptoPage)operator(:) ident(TTabSheet)operator(;) + ident(BorderPanel3)operator(:) ident(TBorderPanel)operator(;) + ident(CryptoE)operator(:) ident(TEdit)operator(;) + ident(OKCryptoB)operator(:) ident(TButton)operator(;) + ident(CancelCryptoB)operator(:) ident(TButton)operator(;) + ident(ReloadCryptoB)operator(:) ident(TButton)operator(;) + ident(CryptoTypeRG)operator(:) ident(TRadioGroup)operator(;) + ident(Label2)operator(:) ident(TLabel)operator(;) + ident(LinkLabel2)operator(:) ident(TLinkLabel)operator(;) + reserved(procedure) ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(SpyResumeBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpySuspendBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ArrPlutoBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ArrRegEdBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ArrFreeBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ArrBigValBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(SpaceMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FileMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HintLBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MainPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StringEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(StringEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OKStringBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BoolStrCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CardinalEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CardBoolCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CardinalEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(OKIntBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowPCChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ShowPCChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ShowPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) ident(TabIndex)operator(:) ident(Integer)operator(;) reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(ShowPCMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OKBinaryBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HexGrid1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HexGrid1KeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(BoolStrPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StringPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(IntPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BinaryPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ReInitShowPC)operator(;) + reserved(procedure) ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MultiStringMChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(OKMultiStringBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(StringAsColorPDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(MultiStringMEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(LadenMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpeichernMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Hinzufgen1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CancelBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HexGrid1Enter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpyClearTracesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpyLBKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + comment(//procedure BinLMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer\);) + reserved(procedure) ident(BinLClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HexGrid1KeyUp)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(ValueViewChanged)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HexEdit1Change)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SortMultiStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpyTestLClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FocusForEditing)operator(;) + reserved(procedure) ident(CurValueEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(CurValueEEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + + reserved(procedure) ident(AddAHint)operator(()reserved(const) ident(Hint)operator(:) reserved(string)operator(\);) + reserved(procedure) ident(SisyTVGetSelectedIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(SisyTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(SisyCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BinaryHMLineChange)operator(()ident(NewLine)operator(:) ident(Cardinal)operator(\);) + reserved(procedure) ident(OffsetHEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SpyDelayIEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyTVExpanded)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(ClearChangesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(FilterChangesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyTVPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyActivateChangeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyDeleteChangeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyCopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ExternalEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(LoadExternalBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(ReloadBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(PipelineCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(BinaryHMEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(xUseExtendedModelCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SeparatorEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(HintLBKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) ident(Shift)operator(:) ident(TShiftState)operator(\);) + reserved(procedure) ident(DWORDSpecialBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(Button1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyPriorityMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyShowCurrentPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(DropFileTargetDrop)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(ShiftState)operator(:) ident(TShiftState)operator(;) + ident(Point)operator(:) ident(TPoint)operator(;) reserved(var) ident(Effect)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) + reserved(procedure) ident(FormResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(IconImageDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(SisyTVCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) + reserved(procedure) ident(SisyTVMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) + reserved(procedure) ident(OKCryptoBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) + reserved(procedure) ident(CryptoEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) + directive(private) + ident(PipelineThread)operator(:) ident(TPipelineThread)operator(;) + ident(BoolStr)operator(:) reserved(array) reserved(of) reserved(array)operator([)ident(Boolean)operator(]) reserved(of) reserved(string)operator(;) + ident(HexEditAutoChange)operator(:) ident(Boolean)operator(;) + ident(TargetPage)operator(:) ident(TTabSheet)operator(;) + reserved(procedure) ident(DeleteChange)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(DeactivateChange)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(procedure) ident(CopySelectedChangeName)operator(;) + reserved(procedure) ident(ClearChanges)operator(;) + directive(public) + ident(ShowAsBinary)operator(:) ident(Boolean)operator(;) + reserved(function) ident(LastHint)operator(:) reserved(string)operator(;) + reserved(function) ident(LoadBoolStr)operator(:) ident(Boolean)operator(;) + reserved(function) ident(LoadSisyFilter)operator(:) ident(Boolean)operator(;) + reserved(procedure) ident(ShowValues)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(\);) + reserved(procedure) ident(UpdateWriteButtons)operator(;) + reserved(procedure) ident(EditData)operator(;) + reserved(end)operator(;) + +reserved(var) + ident(WorkWin)operator(:) ident(TWorkWin)operator(;) + ident(ShowPC)operator(:) ident(TPageControl)operator(;) + ident(MainPC)operator(:) ident(TPageControl)operator(;) + +reserved(implementation) + +reserved(uses) ident(TreeU)operator(,) ident(ValuesU)operator(,) ident(plutomain)operator(,) ident(splash)operator(,) ident(SisyphusTH)operator(,) ident(PrefU)operator(,) ident(ShellEx)operator(;) + +preprocessor({$R *.dfm}) + +reserved(function) ident(ColorOfString)operator(()ident(s)operator(:) reserved(string)operator(;) ident(Format)operator(:) ident(TColorStringFmt)operator(;) + ident(Default)operator(:) ident(TColor) operator(=) ident(clBlack)operator(\):) ident(TColor)operator(;) +reserved(var) + ident(SA)operator(:) ident(TStrA)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Default)operator(;) + ident(SA) operator(:=) reserved(nil)operator(;) + + reserved(case) ident(Format) reserved(of) + ident(csfThreeSpacedDecimals)operator(:) reserved(begin) + ident(SA) operator(:=) ident(Split)operator(()ident(s)operator(,) char<delimiter(')content( )delimiter(')>operator(\);) + reserved(if) ident(Length)operator(()ident(SA)operator(\)) operator(<>) integer(3) reserved(then) + ident(Exit)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) integer(2) reserved(do) + reserved(if) reserved(not) operator(()ident(IsValidInteger)operator(()ident(SA)operator([)ident(i)operator(]\)) reserved(and) operator(()ident(StrToIntDef)operator(()ident(SA)operator([)ident(i)operator(],) operator(-)integer(1)operator(\)) reserved(in) operator([)integer(0)operator(..)integer(255)operator(]\)\)) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) ident(ColorOfRGB)operator(()ident(StrToIntDef)operator(()ident(SA)operator([)integer(0)operator(],) integer(0)operator(\),) + ident(StrToIntDef)operator(()ident(SA)operator([)integer(1)operator(],) integer(0)operator(\),) + ident(StrToIntDef)operator(()ident(SA)operator([)integer(2)operator(],) integer(0)operator(\)\);) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StringOfColor)operator(()ident(Color)operator(:) ident(TColor)operator(;) ident(Format)operator(:) ident(TColorStringFmt)operator(\):) reserved(string)operator(;) +reserved(var) + ident(RGB)operator(:) ident(TRGB)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(RGB) operator(:=) ident(RGBOfColor)operator(()ident(Color)operator(\);) + reserved(case) ident(Format) reserved(of) + ident(csfThreeSpacedDecimals)operator(:) reserved(begin) + reserved(with) ident(RGB) reserved(do) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(R)operator(\)) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(IntToStr)operator(()ident(G)operator(\)) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(IntToStr)operator(()ident(B)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TWorkWin)operator(.)ident(LastHint)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(with) ident(HintLB)operator(.)ident(Items) reserved(do) + reserved(if) ident(Count) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Strings)operator([)ident(Count)operator(-)integer(1)operator(]) + reserved(else) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(AddAHint)operator(()reserved(const) ident(Hint)operator(:) reserved(string)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(HintLB)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(HintLB)operator(.)ident(Items) reserved(do) reserved(begin) + reserved(if) ident(Count) operator(>) integer(0) reserved(then) reserved(begin) + reserved(if) ident(StrAtBegin)operator(()ident(LastHint)operator(,) ident(Hint)operator(\)) reserved(then) reserved(begin) comment(//same hint again) + reserved(with) ident(HintLB) reserved(do) + ident(Tag) operator(:=) ident(Tag) operator(+) integer(1)operator(;) + ident(Strings)operator([)ident(Count)operator(-)integer(1)operator(]) operator(:=) ident(Format)operator(()string<delimiter(')content(%s (%d\))delimiter(')>operator(,) operator([)ident(Hint)operator(,) ident(HintLB)operator(.)ident(Tag)operator(]\);) + ident(Exit) reserved(end) reserved(else) + ident(HintLB)operator(.)ident(Tag) operator(:=) integer(1)operator(;) + reserved(end)operator(;) + ident(Add)operator(()ident(Hint)operator(\);) + reserved(end)operator(;) + ident(Application)operator(.)ident(ProcessMessages)operator(;) comment(//draw) +comment(// Sleep(1000\); //wait to read hints) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ReInitShowPC)operator(;) +reserved(begin) + reserved(with) ident(CurValueE) reserved(do) reserved(begin) + ident(Text) operator(:=) ident(NoValueCaption)operator(;) + ident(Font)operator(.)ident(Color) operator(:=) ident(clSilver)operator(;) + ident(Enabled) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) reserved(nil)operator(;) + + ident(StringE)operator(.)ident(Text) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(StringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + + ident(MultiStringTypeRG)operator(.)ident(Buttons)operator([)integer(1)operator(].)ident(Enabled) operator(:=) ident(False)operator(;) + + ident(CardinalE)operator(.)ident(Value) operator(:=) integer(0)operator(;) + ident(CardTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + + ident(BinaryHM)operator(.)ident(Data) operator(:=) reserved(nil)operator(;) + ident(PipelineCB)operator(.)ident(Checked) operator(:=) ident(False)operator(;) + + ident(DataTypeComB)operator(.)ident(ItemIndex) operator(:=) ident(Integer)operator(()ident(rdBinary)operator(\);) + + ident(MultiStringM)operator(.)ident(Clear)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + ident(MainWin)operator(.)ident(FormKeyDown)operator(()ident(Sender)operator(,) ident(Key)operator(,) ident(Shift)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpyResumeBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SpyThread)operator(.)ident(Resume)operator(;) + ident(SpyTestLClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpySuspendBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(SpyTestLClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ArrPlutoBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangePlutoStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ArrRegEdBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeRegEdStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ArrFreeBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeFreeStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ArrBigValBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ArrangeBigValStyle)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpaceMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StringE)operator(.)ident(Text) operator(:=) string<delimiter(')delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HintLBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text) operator(:=) ident(GetSel)operator(()ident(HintLB)operator(\);) + ident(WorkWin)operator(.)ident(InfoMemo)operator(.)ident(Text) operator(:=) ident(StatusBar)operator(.)ident(Panels)operator([)integer(0)operator(].)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(MainPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) ident(TabIndex)operator(:) ident(Integer)operator(;) + reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(PC)operator(:) ident(TPageControl)operator(;) + ident(Page)operator(:) ident(TTabSheet)operator(;) +reserved(begin) + ident(PC) operator(:=) ident(TPageControl)operator(()ident(Control)operator(\);) + ident(Page) operator(:=) ident(PC)operator(.)ident(Pages)operator([)ident(TabIndex)operator(];) + reserved(with) ident(PC)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Hint)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightRed) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Edit)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightGreen) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Spy)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightBlue) + reserved(else) reserved(if) ident(Page)operator(.)ident(Caption) operator(=) string<delimiter(')content(Sisyphus)delimiter(')> reserved(then) + ident(Color) operator(:=) ident(clBrightCyan) + reserved(else) + ident(Color) operator(:=) ident(clWhite)operator(;) + reserved(end)operator(;) + + reserved(with) ident(PC)operator(.)ident(Canvas) reserved(do) + reserved(if) ident(Active) reserved(then) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([)ident(fsBold)operator(];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(18) operator(+) integer(5)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(3)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + ident(PC)operator(.)ident(Images)operator(.)ident(Draw)operator(()ident(PC)operator(.)ident(Canvas)operator(,) ident(Rect)operator(.)ident(Left) operator(+) integer(4)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(2)operator(,) ident(Page)operator(.)ident(ImageIndex)operator(\);) + reserved(end) reserved(else) reserved(begin) + ident(Font)operator(.)ident(Style) operator(:=) operator([];) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(18) operator(+) integer(3)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(2)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + ident(PC)operator(.)ident(Images)operator(.)ident(Draw)operator(()ident(PC)operator(.)ident(Canvas)operator(,) ident(Rect)operator(.)ident(Left) operator(+) integer(1)operator(,) ident(Rect)operator(.)ident(Top) operator(+) integer(1)operator(,) ident(Page)operator(.)ident(ImageIndex)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ValueMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StringE)operator(.)ident(Text) operator(:=) ident(UntilStr)operator(()ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(Caption)operator(,)string<delimiter(')content( = )delimiter(')>operator(\);) + ident(OKStringBClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(StringEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(key) operator(=) ident(VK_RETURN) reserved(then) reserved(begin) + ident(OKStringBClick)operator(()ident(Sender)operator(\);) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(end)operator(;) + reserved(if) ident(key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(CancelBClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(StringEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(State)operator(:) ident(TCheckBoxState)operator(;) + ident(Desc)operator(:) reserved(string)operator(;) +reserved(begin) + ident(IconImage)operator(.)ident(Picture) operator(:=) reserved(nil)operator(;) + + reserved(with) ident(StringAsColorP) reserved(do) reserved(begin) + ident(Color) operator(:=) ident(ColorOfString)operator(()ident(StringE)operator(.)ident(Text)operator(,) ident(csfThreeSpacedDecimals)operator(,) operator(-)integer(1)operator(\);) + ident(Visible) operator(:=) ident(Color) operator(<>) operator(-)integer(1)operator(;) + reserved(end)operator(;) + + reserved(try) + reserved(with) ident(IconImage)operator(.)ident(Picture)operator(.)ident(Icon) reserved(do) reserved(begin) + ident(ReleaseHandle)operator(;) + ident(Handle) operator(:=) ident(GetIconFromFile)operator(()ident(StringE)operator(.)ident(Text)operator(\);) + ident(StringAsFileP)operator(.)ident(Visible) operator(:=) ident(Handle) operator(<>) integer(0)operator(;) + reserved(end)operator(;) + reserved(except) + reserved(end)operator(;) + + ident(State) operator(:=) ident(cbGrayed)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(BoolStr)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(StringE)operator(.)ident(Text) operator(=) ident(BoolStr)operator([)ident(i)operator(][)ident(False)operator(]) reserved(then) + ident(State) operator(:=) ident(cbUnchecked) + reserved(else) reserved(if) ident(StringE)operator(.)ident(Text) operator(=) ident(BoolStr)operator([)ident(i)operator(][)ident(True)operator(]) reserved(then) + ident(State) operator(:=) ident(cbChecked) + reserved(else) + ident(Continue)operator(;) + ident(Break)operator(;) + reserved(end)operator(;) + + ident(BoolStrCB)operator(.)ident(Visible) operator(:=) ident(State) reserved(in) operator([)ident(cbChecked)operator(,) ident(cbUnchecked)operator(];) + ident(BoolStrCB)operator(.)ident(State) operator(:=) ident(State)operator(;) + + ident(Desc) operator(:=) ident(StringE)operator(.)ident(Text)operator(;) + ident(Desc) operator(:=) ident(RegNameOfCLSID)operator(()ident(Desc)operator(\);) + reserved(with) ident(DescL) reserved(do) reserved(begin) + ident(Visible) operator(:=) operator(()ident(Desc) operator(<>) string<delimiter(')delimiter(')>operator(\);) + reserved(if) ident(Visible) reserved(then) + ident(Caption) operator(:=) string<delimiter(')content(CLSID is: )delimiter(')> operator(+) ident(Desc)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OKStringBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(try) + ident(OpenCurKey)operator(;) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(case) ident(StringTypeRG)operator(.)ident(ItemIndex) reserved(of) + integer(0)operator(:) ident(MainReg)operator(.)ident(WriteString)operator(()ident(Strings)operator([)ident(i)operator(],) ident(StringE)operator(.)ident(Text)operator(\);) + integer(1)operator(:) ident(MainReg)operator(.)ident(WriteExpandString)operator(()ident(Strings)operator([)ident(i)operator(],) ident(StringE)operator(.)ident(Text)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BoolStrCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(BoolStr)operator(\)) reserved(do) reserved(begin) + reserved(if) operator(()ident(BoolStr)operator([)ident(i)operator(,) ident(False)operator(]) operator(=) ident(StringE)operator(.)ident(Text)operator(\)) + reserved(or) operator(()ident(BoolStr)operator([)ident(i)operator(,) ident(True)operator(]) operator(=) ident(StringE)operator(.)ident(Text)operator(\)) reserved(then) + ident(Break)operator(;) + reserved(end)operator(;) + + reserved(if) ident(i) operator(>) ident(High)operator(()ident(BoolStr)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(StringE)operator(.)ident(Text) operator(:=) ident(BoolStr)operator([)ident(i)operator(][)ident(BoolStrCB)operator(.)ident(Checked)operator(];) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CardinalEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(HexEditAutoChange) operator(:=) ident(True)operator(;) + reserved(with) ident(CardBoolCB) reserved(do) reserved(begin) + ident(Enabled) operator(:=) ident(True)operator(;) + reserved(case) ident(CardinalE)operator(.)ident(Value) reserved(of) + integer(1)operator(:) ident(Checked) operator(:=) ident(True)operator(;) + integer(0)operator(:) ident(Checked) operator(:=) ident(False)operator(;) + reserved(else) + ident(Enabled) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + ident(HexEdit1)operator(.)ident(Value) operator(:=) ident(CardinalE)operator(.)ident(Value)operator(;) + ident(HexEditAutoChange) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CardBoolCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(HexEditAutoChange) reserved(then) + ident(Exit)operator(;) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(Ord)operator(()ident(CardBoolCB)operator(.)ident(Checked)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CardinalEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(key) operator(=) ident(VK_RETURN) reserved(then) reserved(begin) + ident(OKIntBClick)operator(()ident(Sender)operator(\);) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(CancelBClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OKIntBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(Write4BB)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) ident(Value)operator(:) ident(Cardinal)operator(\);) + reserved(var) + ident(Typ)operator(:) ident(TRegDataType)operator(;) + reserved(begin) + reserved(if) ident(MainReg)operator(.)ident(ValueReallyExists)operator(()ident(ValueName)operator(\)) reserved(then) + ident(Typ) operator(:=) ident(MainReg)operator(.)ident(GetDataType)operator(()ident(ValueName)operator(\)) + reserved(else) + ident(Typ) operator(:=) ident(rdBinary)operator(;) + + reserved(if) ident(Typ) reserved(in) ident(rdCardTypes) reserved(then) + ident(Typ) operator(:=) ident(rdBinary)operator(;) + + ident(MainReg)operator(.)ident(WriteBinType)operator(()ident(ValueName)operator(,) ident(ByteAOfInt)operator(()ident(CardinalE)operator(.)ident(Value)operator(\),) ident(Typ)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(try) + ident(OpenCurKey)operator(;) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(case) ident(CardTypeRG)operator(.)ident(ItemIndex) reserved(of) + integer(0)operator(:) ident(MainReg)operator(.)ident(WriteCardinal)operator(()ident(Strings)operator([)ident(i)operator(],) ident(CardinalE)operator(.)ident(Value)operator(\);) + integer(1)operator(:) ident(MainReg)operator(.)ident(WriteCardinal)operator(()ident(Strings)operator([)ident(i)operator(],) ident(CardinalE)operator(.)ident(Value)operator(,) ident(True)operator(\);) + integer(2)operator(:) ident(Write4BB)operator(()ident(Strings)operator([)ident(i)operator(],) ident(CardinalE)operator(.)ident(Value)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ShowPCChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FocusControl)operator(()ident(TObject)operator(()ident(ShowPC)operator(.)ident(ActivePage)operator(.)ident(Tag)operator(\)) reserved(as) ident(TWinControl)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ShowPCChanging)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(AllowChange)operator(:) ident(Boolean)operator(\);) + + reserved(function) ident(ByteAOfDWORD)operator(()ident(a)operator(:) ident(DWORD)operator(\):) ident(TByteA)operator(;) + reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(SizeOf)operator(()ident(DWORD)operator(\)\);) + ident(Move)operator(()ident(a)operator(,) ident(Pointer)operator(()ident(Result)operator(\)^,) ident(SizeOf)operator(()ident(DWORD)operator(\)\);) + reserved(end)operator(;) + +reserved(var) + ident(SourcePage)operator(:) ident(TTabSheet)operator(;) + ident(ValueName)operator(:) reserved(string)operator(;) +reserved(begin) + ident(SourcePage) operator(:=) ident(ShowPC)operator(.)ident(ActivePage)operator(;) + reserved(if) ident(SourcePage) operator(=) ident(IntPage) reserved(then) reserved(begin) + + reserved(if) ident(TargetPage) operator(=) ident(StringPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: DWORD --> String)delimiter(')>operator(\);) + ident(StringE)operator(.)ident(Text) operator(:=) ident(CardinalE)operator(.)ident(Text)operator(;) + reserved(end) reserved(else) reserved(if) ident(TargetPage) operator(=) ident(BinaryPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: DWORD --> Binary)delimiter(')>operator(\);) + ident(BinaryHM)operator(.)ident(Data) operator(:=) ident(ByteAOfDWORD)operator(()ident(CardinalE)operator(.)ident(Value)operator(\);) + reserved(end) reserved(else) + ident(AllowChange) operator(:=) ident(False)operator(;) + + reserved(end) reserved(else) reserved(if) ident(SourcePage) operator(=) ident(StringPage) reserved(then) reserved(begin) + reserved(if) ident(TargetPage) operator(=) ident(IntPage) reserved(then) reserved(begin) + reserved(if) ident(IsValidCardinal)operator(()ident(StringE)operator(.)ident(Text)operator(\)) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: String --> DWORD)delimiter(')>operator(\);) + ident(CardinalE)operator(.)ident(Text) operator(:=) ident(StringE)operator(.)ident(Text)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(This no valid DWORD; Converting aborted.)delimiter(')>operator(,) ident(True)operator(\);) + ident(AllowChange) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) reserved(if) ident(TargetPage) operator(=) ident(BinaryPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: String --> Binary)delimiter(')>operator(\);) + ident(BinaryHM)operator(.)ident(Data) operator(:=) ident(TByteA)operator(()ident(StringE)operator(.)ident(Text)operator(\);) + reserved(end) reserved(else) reserved(if) ident(TargetPage) operator(=) ident(MultiStringPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: String --> MultiString)delimiter(')>operator(\);) + reserved(if) ident(SeparatorE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(MultiStringM)operator(.)ident(Text) operator(:=) ident(StringE)operator(.)ident(Text)operator(;) + ident(SeparatorEChange)operator(()ident(Sender)operator(\);) + reserved(end) reserved(else) + ident(AllowChange) operator(:=) ident(False)operator(;) + + reserved(end) reserved(else) reserved(if) ident(SourcePage) operator(=) ident(BinaryPage) reserved(then) reserved(begin) + reserved(if) ident(TargetPage) operator(=) ident(StringPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: Binary --> String)delimiter(')>operator(\);) + ident(StringE)operator(.)ident(Text) operator(:=) ident(FriendlyStr)operator(()reserved(string)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\)\);) + reserved(end) reserved(else) reserved(if) ident(TargetPage) operator(=) ident(IntPage) reserved(then) reserved(begin) + reserved(if) ident(Length)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\)) operator(>=) ident(SizeOf)operator(()ident(DWORD)operator(\)) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: Binary --> DWORD)delimiter(')>operator(\);) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(PDWORD)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\)^;) + reserved(end) reserved(else) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Binary value not long enough (4 Byte\); Converting aborted.)delimiter(')>operator(,) ident(True)operator(\);) + ident(AllowChange) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) reserved(if) ident(TargetPage) operator(=) ident(CryptoPage) reserved(then) reserved(begin) + reserved(if) ident(ValuesWin)operator(.)ident(ValueNames)operator(.)ident(Count) operator(=) integer(1) reserved(then) reserved(begin) + ident(ValueName) operator(:=) ident(ValuesWin)operator(.)ident(ValueNames)operator([)integer(0)operator(];) + reserved(with) ident(CryptoTypeRG) reserved(do) reserved(begin) + ident(ItemIndex) operator(:=) operator(-)integer(1)operator(;) + reserved(if) ident(SameText)operator(()ident(ValueName)operator(,) string<delimiter(')content(ScreenSave_Data)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(ItemIndex) operator(:=) integer(0)operator(;) + ident(CryptoE)operator(.)ident(Text) operator(:=) ident(DecodeScreenSaver)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\);) + reserved(end) reserved(else) reserved(if) ident(SameText)operator(()ident(ValueName)operator(,) string<delimiter(')content(parm1enc)delimiter(')>operator(\)) + reserved(or) ident(SameText)operator(()ident(ValueName)operator(,) string<delimiter(')content(parm2enc)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(ItemIndex) operator(:=) integer(1)operator(;) + ident(CryptoE)operator(.)ident(Text) operator(:=) ident(DecodeSharedFolder)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(if) ident(CryptoTypeRG)operator(.)ident(ItemIndex) operator(=) operator(-)integer(1) reserved(then) + ident(AllowChange) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) + ident(AllowChange) operator(:=) ident(False)operator(;) + + reserved(end) reserved(else) reserved(if) ident(SourcePage) operator(=) ident(MultiStringPage) reserved(then) reserved(begin) + reserved(if) ident(TargetPage) operator(=) ident(StringPage) reserved(then) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Converting: MultiString --> String )delimiter(')>operator(\);) + reserved(if) ident(SeparatorE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(StringE)operator(.)ident(Text) operator(:=) ident(MultiStringM)operator(.)ident(Text) + reserved(else) + ident(StringE)operator(.)ident(Text) operator(:=) ident(Join)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(,) ident(SeparatorE)operator(.)ident(Text)operator(\);) + comment(//end else if TargetPage = BinaryPage then begin) + reserved(end) reserved(else) + ident(AllowChange) operator(:=) ident(False)operator(;) + + reserved(end) reserved(else) + ident(AllowChange) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ShowPCDrawTab)operator(()ident(Control)operator(:) ident(TCustomTabControl)operator(;) ident(TabIndex)operator(:) ident(Integer)operator(;) + reserved(const) ident(Rect)operator(:) ident(TRect)operator(;) ident(Active)operator(:) ident(Boolean)operator(\);) +reserved(var) + ident(PC)operator(:) ident(TPageControl)operator(;) + ident(Page)operator(:) ident(TTabSheet)operator(;) +reserved(begin) + ident(PC) operator(:=) ident(TPageControl)operator(()ident(Control)operator(\);) + ident(Page) operator(:=) ident(PC)operator(.)ident(Pages)operator([)ident(TabIndex)operator(];) + reserved(with) ident(PC)operator(.)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Page) operator(=) ident(StringPage) reserved(then) + ident(Color) operator(:=) ident(clBrightRed) + reserved(else) reserved(if) ident(Page) operator(=) ident(MultiStringPage) reserved(then) + ident(Color) operator(:=) ident(clBrightPurple) + reserved(else) reserved(if) ident(Page) operator(=) ident(IntPage) reserved(then) + ident(Color) operator(:=) ident(clBrightBlue) + reserved(else) reserved(if) ident(Page) operator(=) ident(BinaryPage) reserved(then) + ident(Color) operator(:=) ident(clBrightGreen) + reserved(else) reserved(if) ident(Page) operator(=) ident(CryptoPage) reserved(then) + ident(Color) operator(:=) ident(clBrightCyan)operator(;) + reserved(end)operator(;) + + reserved(with) ident(PC)operator(.)ident(Canvas) reserved(do) reserved(begin) + reserved(if) ident(Active) reserved(then) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clGray) + reserved(else) + ident(Brush)operator(.)ident(Color) operator(:=) ident(clDarkGray)operator(;) + ident(FillRect)operator(()ident(Rect)operator(\);) + ident(TextOut)operator(()ident(Rect)operator(.)ident(Left) operator(+) integer(18) operator(+) integer(3)operator(,) ident(Rect)operator(.)ident(Top)operator(,) ident(Page)operator(.)ident(Caption)operator(\);) + ident(MainWin)operator(.)ident(ImageList1)operator(.)ident(Draw)operator(()ident(Control)operator(.)ident(Canvas)operator(,) ident(Rect)operator(.)ident(Left) operator(-) integer(1)operator(,) ident(Rect)operator(.)ident(Top) operator(-) integer(1)operator(,) ident(Page)operator(.)ident(ImageIndex)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ShowPCMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) +reserved(begin) + reserved(with) ident(ShowPC) reserved(do) + reserved(if) ident(htOnItem) reserved(in) ident(GetHitTestInfoAt)operator(()ident(X)operator(,) ident(Y)operator(\)) reserved(then) + ident(TargetPage) operator(:=) ident(Pages)operator([)ident(IndexOfTabAt)operator(()ident(X)operator(,) ident(Y)operator(\)];) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormCreate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(WorkU)operator(.)ident(ShowPC) operator(:=) ident(ShowPC)operator(;) + ident(WorkU)operator(.)ident(MainPC) operator(:=) ident(MainPC)operator(;) + + comment(//Zeromize) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) reserved(nil)operator(;) + ident(InfoMemo)operator(.)ident(Text) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(MultiStringM)operator(.)ident(Clear)operator(;) + ident(SisyTV)operator(.)ident(Items)operator(.)ident(Clear)operator(;) + ident(CurValueE)operator(.)ident(Text) operator(:=) ident(NoValueCaption)operator(;) + ident(HexEditAutoChange) operator(:=) ident(False)operator(;) + ident(TargetPage) operator(:=) reserved(nil)operator(;) + + comment(//Tagging) + ident(StringPage)operator(.)ident(Tag) operator(:=) ident(Integer)operator(()ident(StringE)operator(\);) + ident(IntPage)operator(.)ident(Tag) operator(:=) ident(Integer)operator(()ident(CardinalE)operator(\);) + ident(BinaryPage)operator(.)ident(Tag) operator(:=) ident(Integer)operator(()ident(BinaryHM)operator(\);) + ident(MultiStringPage)operator(.)ident(Tag) operator(:=) ident(Integer)operator(()ident(MultiStringM)operator(\);) + ident(ShowAsBinary) operator(:=) ident(False)operator(;) + + reserved(if) reserved(not) ident(Win9x) reserved(then) + ident(CryptoPage)operator(.)ident(TabVisible) operator(:=) ident(False)operator(;) + + ident(MainPC)operator(.)ident(ActivePage) operator(:=) ident(HintPage)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) reserved(nil)operator(;) + + ident(DropFileTarget)operator(.)directive(register)operator(()ident(StringE)operator(\);) + + reserved(with) ident(StringTypeRG) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(ControlCount)operator(-)integer(1) reserved(do) + operator(()ident(Controls)operator([)ident(i)operator(]) reserved(as) ident(TRadioButton)operator(\).)ident(OnKeyDown) operator(:=) ident(StringEKeyDown)operator(;) + + ident(ExternalEditB)operator(.)ident(Enabled) operator(:=) ident(FileEx)operator(()ident(PrefWin)operator(.)ident(ExternalHexEditE)operator(.)ident(Text)operator(\);) + + ident(PipelineThread) operator(:=) ident(TPipelineThread)operator(.)ident(CreateIt)operator(()ident(tpIdle)operator(,) string<delimiter(')delimiter(')>operator(,) ident(BinaryHM)operator(\);) + ident(PipelineThread)operator(.)ident(OnChange) operator(:=) ident(LoadExternalBClick)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OKBinaryBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Typ)operator(:) ident(Cardinal)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(try) + ident(Typ) operator(:=) ident(StrToIntDef)operator(()ident(UntilChar)operator(()ident(DataTypeComB)operator(.)ident(Text)operator(,) char<delimiter(')content( )delimiter(')>operator(\),) ident(Integer)operator(()ident(rdBinary)operator(\)\);) + ident(OpenCurKey)operator(;) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(MainReg)operator(.)ident(WriteBinType)operator(()ident(Strings)operator([)ident(i)operator(],) ident(BinaryHM)operator(.)ident(Data)operator(,) ident(Typ)operator(\);) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HexGrid1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + comment({with BinaryHM do begin + with BinL, Font do + if ActiveByte < ByteCount then + Color := clBrightGreen + else begin + Color := clSilver; + Caption := '00000000'; + end; + BinL.Caption := IntToBinFill(CurrentByte, 8\); + end; }) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HexGrid1KeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(key) operator(=) ident(VK_RETURN) reserved(then) reserved(begin) + ident(OKBinaryBClick)operator(()ident(Sender)operator(\);) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(end)operator(;) + reserved(if) ident(key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(CancelBClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BoolStrPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(StringE)operator(.)ident(Text) operator(:=) ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(Caption)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(StringPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FocusControl)operator(()ident(StringE)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(IntPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FocusControl)operator(()ident(CardinalE)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BinaryPageEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(FocusControl)operator(()ident(BinaryHM)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(DeActivateIt)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeActivateThis)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormDeactivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(TEdit)operator(()ident(ActiveControl)operator(\).)ident(OnExit)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormActivate)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(ActiveControl)operator(\)) reserved(and) operator(()ident(ActiveControl)operator(.)ident(Tag) operator(=) ident(EditControlFlag)operator(\)) reserved(then) + ident(TEdit)operator(()ident(ActiveControl)operator(\).)ident(OnEnter)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(MultiStringMChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MultiStringCountL)operator(.)ident(Caption) operator(:=) ident(StrNumerus)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(.)ident(Count)operator(,) + string<delimiter(')content(Line)delimiter(')>operator(,) string<delimiter(')content(Lines)delimiter(')>operator(,) string<delimiter(')content(No)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OKMultiStringBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(UseExtendedModel)operator(:) ident(Boolean)operator(;) + ident(i)operator(:) ident(Integer)operator(;) + ident(JoinedText)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(if) operator(()ident(MultiStringTypeRG)operator(.)ident(ItemIndex) operator(=) integer(1)operator(\)) reserved(then) reserved(begin) + reserved(if) ident(ValuesWin)operator(.)ident(ValueCommonType) operator(=) ident(rdMultiString) reserved(then) + reserved(if) ident(mrYes)operator(<>)ident(MessageDlg)operator(()string<delimiter(')content(Do you want to change the type of this value?)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(MultiString --> String)delimiter(')>operator(,) ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(try) + ident(OpenCurKey)operator(;) + ident(JoinedText) operator(:=) ident(Join)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(,) ident(SeparatorE)operator(.)ident(Text)operator(\);) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) + ident(MainReg)operator(.)ident(WriteString)operator(()ident(Strings)operator([)ident(i)operator(],) ident(JoinedText)operator(\);) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(UseExtendedModel) operator(:=) ident(True)operator(;) + reserved(if) ident(ContainsEmptyLines)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(\)) reserved(then) + reserved(case) ident(MessageDlg)operator(()string<delimiter(')content(This text contains empty lines.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(These are not allowed in the standard MultiString model.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Do you want to delete them?)delimiter(')> operator(+) ident(EOL) operator(+) + ident(EOL) operator(+) + string<delimiter(')content(Yes: Delete empty lines)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(No: Use the Extended Model)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbNo)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(of) + + ident(mrNo)operator(:) ident(UseExtendedModel) operator(:=) ident(True)operator(;) + + ident(mrYes)operator(:) reserved(begin) + reserved(with) ident(MultiStringM) reserved(do) reserved(begin) + ident(Lines)operator(.)ident(BeginUpdate)operator(;) + ident(DeleteEmptyLines)operator(()ident(Lines)operator(\);) + ident(Lines)operator(.)ident(EndUpdate)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(else) ident(Exit)operator(;) + + reserved(end)operator(;) + + reserved(try) + ident(OpenCurKey)operator(;) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) ident(MainReg)operator(.)ident(GetDataType)operator(()ident(Strings)operator([)ident(i)operator(]\)) operator(<>) ident(rdMultiString) reserved(then) + reserved(if) ident(mrYes) operator(<>) ident(MessageDlg)operator(()string<delimiter(')content(Do you want to change the type of this value?)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(--> MultiString)delimiter(')>operator(,) ident(mtWarning)operator(,) operator([)ident(mbYes)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(if) ident(UseExtendedModel) reserved(then) + ident(MainReg)operator(.)ident(WriteStringList)operator(()ident(Strings)operator([)ident(i)operator(],) ident(MultiStringM)operator(.)ident(Lines)operator(\)) + reserved(else) + ident(MainReg)operator(.)ident(WriteMultiString)operator(()ident(Strings)operator([)ident(i)operator(],) ident(MultiStringM)operator(.)ident(Lines)operator(\);) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(StringAsColorPDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(ColorDlg)operator(.)ident(Execute) reserved(then) + ident(StringE)operator(.)ident(Text) operator(:=) ident(StringOfColor)operator(()ident(ColorDlg)operator(.)ident(Color)operator(,) ident(csfThreeSpacedDecimals)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(MultiStringMEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(MultiStringM)operator(.)ident(SelectAll)operator(;) + ident(ActivateIt)operator(()ident(MultiStringM)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(LadenMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(MultiStringOpenD) reserved(do) reserved(begin) + ident(InitialDir) operator(:=) ident(ExtractFileDrive)operator(()ident(MyDir)operator(\);) + reserved(if) ident(Execute) reserved(then) + ident(MultiStringM)operator(.)ident(Lines)operator(.)ident(LoadFromFile)operator(()ident(FileName)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpeichernMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(MultiStringSaveD) reserved(do) reserved(begin) + ident(InitialDir) operator(:=) ident(ExtractFileDrive)operator(()ident(MyDir)operator(\);) + reserved(if) ident(Execute) reserved(then) + ident(MultiStringM)operator(.)ident(Lines)operator(.)ident(SaveToFile)operator(()ident(FileName)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(Hinzufgen1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + reserved(with) ident(MultiStringOpenD) reserved(do) reserved(begin) + ident(InitialDir) operator(:=) ident(ExtractFileDrive)operator(()ident(MyDir)operator(\);) + reserved(if) ident(Execute) reserved(then) reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(SL)operator(.)ident(LoadFromFile)operator(()ident(FileName)operator(\);) + ident(MultiStringM)operator(.)ident(Lines)operator(.)ident(AddStrings)operator(()ident(SL)operator(\);) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CancelBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + ident(ValuesWin)operator(.)ident(ValueListChange)operator(()ident(Sender)operator(,) ident(ValueList)operator(.)ident(Selected)operator(,) ident(ctState)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HexGrid1Enter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(HexGrid1Click)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpyClearTracesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SpyLB)operator(.)ident(Clear)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpyLBKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) operator(()ident(ssShift) reserved(in) ident(Shift)operator(\)) reserved(and) operator(()ident(key) operator(=) ident(VK_DELETE)operator(\)) reserved(then) reserved(begin) + ident(key) operator(:=) integer(0)operator(;) + ident(SpyLB)operator(.)ident(Clear)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(key) operator(=) ident(VK_F9) reserved(then) reserved(begin) + ident(key) operator(:=) integer(0)operator(;) + ident(SwapFonts)operator(()ident(SpyLB)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BinLClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + comment(// with HexGrid1 do) + comment(// Byt[ActiveByte] := IntOfBin(BinL.Caption\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HexGrid1KeyUp)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + comment(//HexGrid1Click(Sender\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ValueViewChanged)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + + ident(SpyThread)operator(.)ident(Suspend)operator(;) + ident(OpenCurKey)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(ValueList)operator(.)ident(Items)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(ValuesWin)operator(.)ident(UpdateValue)operator(()ident(MainReg)operator(,) ident(ValueList)operator(.)ident(Items)operator([)ident(i)operator(]\);) + + ident(MainReg)operator(.)ident(CloseKey)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HexEdit1Change)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(HexEditAutoChange) reserved(then) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(HexEdit1)operator(.)ident(Value)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SortMultiStringMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(with) ident(SL) reserved(do) reserved(begin) + ident(Assign)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(\);) + ident(Sort)operator(;) + reserved(end)operator(;) + ident(MultiStringM)operator(.)ident(Lines)operator(.)ident(Assign)operator(()ident(SL)operator(\);) + ident(SL)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpyTestLClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(SpyTestL)operator(.)ident(Caption) operator(:=) ident(StrOfBool)operator(()ident(SpyThread)operator(.)ident(Suspended)operator(,) string<delimiter(')content(No Spy.)delimiter(')>operator(,) string<delimiter(')content(Spy active.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FocusForEditing)operator(;) +reserved(begin) + ident(FocusControl)operator(()ident(MainPC)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TWorkWin)operator(.)ident(LoadBoolStr)operator(:) ident(Boolean)operator(;) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(FileName)operator(:) reserved(string)operator(;) + ident(i)operator(,) ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + + ident(AddHint)operator(()string<delimiter(')content(Loading Boolean Strings...)delimiter(')>operator(\);) + + ident(FileName) operator(:=) ident(PlutoDir) operator(+) ident(BoolStrFileName)operator(;) + reserved(if) reserved(not) ident(FileEx)operator(()ident(FileName)operator(\)) reserved(then) reserved(begin) + ident(AddToLastHint)operator(()string<delimiter(')content(not found:)delimiter(')>operator(\);) + ident(AddHint)operator(()ident(FileName)operator(\);) + ident(Result) operator(:=) ident(False)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(SL)operator(.)ident(LoadFromFile)operator(()ident(FileName)operator(\);) + ident(DeleteCommentLines)operator(()ident(SL)operator(\);) + ident(BoolStr) operator(:=) reserved(nil)operator(;) + ident(SetLength)operator(()ident(BoolStr)operator(,) ident(SL)operator(.)ident(Count)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + comment(//Split the string by the '|'-sign) + ident(p) operator(:=) ident(Pos)operator(()char<delimiter(')content(|)delimiter(')>operator(,) ident(SL)operator([)ident(i)operator(]\);) + ident(BoolStr)operator([)ident(i)operator(][)ident(False)operator(]) operator(:=) ident(Copy)operator(()ident(SL)operator([)ident(i)operator(],) integer(1)operator(,) ident(p)operator(-)integer(1)operator(\);) + ident(BoolStr)operator([)ident(i)operator(][)ident(True)operator(]) operator(:=) ident(Copy)operator(()ident(SL)operator([)ident(i)operator(],) ident(p)operator(+)integer(1)operator(,) ident(Length)operator(()ident(SL)operator([)ident(i)operator(]\)) operator(-) ident(p)operator(\);) + reserved(end)operator(;) + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TWorkWin)operator(.)ident(LoadSisyFilter)operator(:) ident(Boolean)operator(;) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(FileName)operator(:) reserved(string)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + + ident(FileName) operator(:=) ident(PlutoDir) operator(+) ident(SisyFilterFileName)operator(;) + reserved(if) reserved(not) ident(FileEx)operator(()ident(FileName)operator(\)) reserved(then) + ident(Result) operator(:=) ident(False) + reserved(else) reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Loading Sisyphus Filter Settings...)delimiter(')>operator(\);) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(SL)operator(.)ident(LoadFromFile)operator(()ident(FileName)operator(\);) + ident(DeleteCommentLines)operator(()ident(SL)operator(,) char<delimiter(')content(#)delimiter(')>operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(SL)operator([)ident(i)operator(]) operator(:=) ident(TrimLeft)operator(()ident(SL)operator([)ident(i)operator(]\);) + + ident(SisyFilter)operator(.)ident(Clear)operator(;) + ident(SisyFilter)operator(.)ident(AddStrings)operator(()ident(SL)operator(\);) + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + ident(AddToLastHint)operator(()string<delimiter(')content(OK)delimiter(')>operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVGetSelectedIndex)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + ident(Node)operator(.)ident(SelectedIndex) operator(:=) ident(Node)operator(.)ident(ImageIndex)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(Path)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(SisyTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Path) operator(:=) ident(RootOfNode)operator(()ident(Node)operator(\).)ident(Text)operator(;) + + reserved(if) ident(Node)operator(.)ident(Level) operator(>) integer(0) reserved(then) reserved(begin) + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(2) reserved(then) + ident(Node) operator(:=) ident(Node)operator(.)ident(Parent)operator(;) + reserved(if) ident(Node)operator(.)ident(HasChildren) reserved(then) + ident(Path) operator(:=) ident(Path) operator(+) string<delimiter(')content(\\\\)delimiter(')> operator(+) ident(Node)operator(.)ident(Text) comment(//Value) + reserved(else) + ident(Path) operator(:=) ident(Path) operator(+) char<delimiter(')content(\\)delimiter(')> operator(+) ident(Node)operator(.)ident(Text) comment(//SubKey) + reserved(end)operator(;) + + ident(MainWin)operator(.)ident(GotoKey)operator(()ident(Path)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(DeleteChange)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(var) + ident(SubNode)operator(:) ident(TTreeNode)operator(;) + + reserved(procedure) ident(FreeSisyChangeNode)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) + reserved(begin) + reserved(try) + reserved(with) operator(()ident(TObject)operator(()ident(Node)operator(.)ident(Data)operator(\)) reserved(as) ident(TSisyChange)operator(\)) reserved(do) + ident(Free)operator(;) + reserved(except) + ident(ReportFmt)operator(()string<delimiter(')content(errors)delimiter(')>operator(,) string<delimiter(')content(Context could not be freed: "%s")delimiter(')>operator(,) operator([)ident(Node)operator(.)ident(Text)operator(]\);) + reserved(end)operator(;) + + ident(Node)operator(.)ident(Delete)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(2) reserved(then) + ident(Node) operator(:=) ident(Node)operator(.)ident(Parent)operator(;) + + reserved(if) ident(Node)operator(.)ident(Level) operator(=) integer(0) reserved(then) reserved(begin) + ident(SisyTV)operator(.)ident(Selected) operator(:=) ident(GetNextBest)operator(()ident(RootOfNode)operator(()ident(Node)operator(\)\);) + ident(SubNode) operator(:=) ident(Node)operator(.)ident(GetFirstChild)operator(;) + reserved(while) ident(Assigned)operator(()ident(SubNode)operator(\)) reserved(do) reserved(begin) + ident(FreeSisyChangeNode)operator(()ident(SubNode)operator(\);) + ident(SubNode) operator(:=) ident(Node)operator(.)ident(GetFirstChild)operator(;) reserved(end)operator(;) + ident(Node)operator(.)ident(Delete)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(SisyTV)operator(.)ident(Selected) operator(:=) ident(GetNextBest)operator(()ident(Node)operator(\);) + ident(FreeSisyChangeNode)operator(()ident(Node)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(DeactivateChange)operator(()ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + ident(Node) operator(:=) ident(RootOfNode)operator(()ident(Node)operator(\);) + + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(SisyChangeActivated)operator(()ident(Node)operator(\)) reserved(then) reserved(begin) + ident(SetSisyChangeState)operator(()ident(Node)operator(,) ident(False)operator(\);) + ident(Node)operator(.)ident(Cut) operator(:=) ident(True)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(SetSisyChangeState)operator(()ident(Node)operator(,) ident(True)operator(\);) + ident(Node)operator(.)ident(Cut) operator(:=) ident(False)operator(;) + reserved(end)operator(;) + ident(SisyTV)operator(.)ident(Repaint)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CopySelectedChangeName)operator(;) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(SisyTV)operator(.)ident(Selected)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(Node)operator(.)ident(Text)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(RootOfNode)operator(()ident(SisyTV)operator(.)ident(Selected)operator(\);) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + comment({if Key = VK_RETURN then + SisyTVDblCLick(Sender\); + + if Key = VK_DELETE then + if (ssCtrl in Shift\) and (Key = VK_DELETE\) then + DeactivateChange(Node\) + else + DeleteChange(Node\); + + if (ssCtrl in Shift\) and (Char(Key\) = 'C'\) then + CopySelectedChangeName;}) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(Started) reserved(then) + ident(Exit)operator(;) + + reserved(with) ident(TCheckBox)operator(()ident(Sender)operator(\),) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(Tag)operator(]\)) reserved(do) reserved(begin) + reserved(if) ident(Checked) reserved(then) + ident(Resume) + reserved(else) + ident(Suspend)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CurValueEEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CurValueE)operator(.)ident(Text) operator(:=) ident(RealValueName)operator(()ident(ValueList)operator(.)ident(ItemFocused)operator(\);) + ident(CurValueE)operator(.)ident(SelectAll)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CurValueEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) + + reserved(procedure) ident(RenameValue)operator(()ident(NewName)operator(:) reserved(string)operator(\);) + reserved(var) + ident(Item)operator(:) ident(TListItem)operator(;) + reserved(begin) + ident(Item) operator(:=) ident(ValueList)operator(.)ident(ItemFocused)operator(;) + reserved(if) ident(ValuesWin)operator(.)ident(TryRenameValue)operator(()ident(CurKey)operator(.)ident(Value)operator(,) ident(NewName)operator(\)) reserved(then) + ident(SetRealValueName)operator(()ident(Item)operator(,) ident(NewName)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_RETURN) reserved(then) reserved(begin) + ident(SpyThread)operator(.)ident(Suspend)operator(;) + reserved(try) + ident(RenameValue)operator(()ident(CurValueE)operator(.)ident(Text)operator(\);) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Self)operator(\);) + ident(FocusControl)operator(()ident(CurValueE)operator(\);) + reserved(finally) + ident(SpyThread)operator(.)ident(Restart) operator(:=) ident(True)operator(;) + ident(SpyThread)operator(.)ident(Resume)operator(;) + reserved(end)operator(;) + ident(Key) operator(:=) integer(0)operator(;) + comment(//CurValueE.SelectAll;) + reserved(end) reserved(else) reserved(if) ident(Key) operator(=) ident(VK_ESCAPE) reserved(then) reserved(begin) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Self)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BinaryHMLineChange)operator(()ident(NewLine)operator(:) ident(Cardinal)operator(\);) +reserved(begin) + ident(OffsetHE)operator(.)ident(Value) operator(:=) ident(BinaryHM)operator(.)ident(Pos)operator(;) + comment(// BinaryAsIntL.Value := Integer(BinaryHM.CurentCard\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OffsetHEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(BinaryHM)operator(.)ident(Pos) operator(:=) ident(OffsetHE)operator(.)ident(Value)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SpyDelayIEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(Assigned)operator(()ident(SpyThread)operator(\)) reserved(then) + ident(SpyThread)operator(.)ident(Delay) operator(:=) ident(SpyDelayIE)operator(.)ident(Value)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVExpanded)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Node)operator(:) ident(TTreeNode)operator(\);) +reserved(begin) + reserved(if) ident(Node)operator(.)ident(ImageIndex) operator(=) integer(8) reserved(then) + ident(Node)operator(.)ident(ImageIndex) operator(:=) integer(7)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ClearChanges)operator(;) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + reserved(with) ident(SisyTV)operator(.)ident(Items) reserved(do) reserved(begin) + ident(Node) operator(:=) ident(GetFirstNode)operator(;) + reserved(while) ident(Assigned)operator(()ident(Node)operator(\)) reserved(do) reserved(begin) + ident(DeleteChange)operator(()ident(Node)operator(\);) + ident(Node) operator(:=) ident(GetFirstNode)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ClearChangesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) ident(mrOK) operator(<>) ident(MessageDlg)operator(()string<delimiter(')content(Do you really want to clear all changes?)delimiter(')>operator(,) + ident(mtWarning)operator(,) operator([)ident(mbOK)operator(,) ident(mbCancel)operator(],) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(ClearChanges)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FilterChangesBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(NotePad)operator(()ident(PlutoDir) operator(+) ident(SisyFilterFileName)operator(\);) + ident(ShowMessage)operator(()string<delimiter(')content(Click OK when you finished editing.)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content((Pluto will reload the filter settings then.\))delimiter(')>operator(\);) + ident(LoadSisyFilter)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(KeySelected)operator(:) ident(Boolean)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) +reserved(begin) + ident(Node) operator(:=) ident(SisyTV)operator(.)ident(Selected)operator(;) + ident(KeySelected) operator(:=) ident(Assigned)operator(()ident(Node)operator(\);) + + ident(SisyGoToKeyMI)operator(.)ident(Enabled) operator(:=) ident(KeySelected)operator(;) + ident(SisyDeleteChangeMI)operator(.)ident(Enabled) operator(:=) ident(KeySelected)operator(;) + ident(SisyActivateChangeMI)operator(.)ident(Enabled) operator(:=) ident(KeySelected)operator(;) + ident(SisyCopyPathMI)operator(.)ident(Enabled) operator(:=) ident(KeySelected)operator(;) + reserved(if) reserved(not) ident(KeySelected) reserved(then) + ident(Exit)operator(;) + + ident(SisyActivateChangeMI)operator(.)ident(Checked) operator(:=) ident(SisyChangeActivated)operator(()ident(RootOfNode)operator(()ident(Node)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyActivateChangeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeactivateChange)operator(()ident(SisyTV)operator(.)ident(Selected)operator(\)) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyDeleteChangeMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(DeleteChange)operator(()ident(SisyTV)operator(.)ident(Selected)operator(\)) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyCopyPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CopySelectedChangeName)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FileMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(s)operator(:) reserved(string)operator(;) +reserved(begin) + reserved(with) ident(FileOpenD) reserved(do) reserved(begin) + ident(s) operator(:=) ident(ExtractPath)operator(()ident(StringE)operator(.)ident(Text)operator(\);) + reserved(if) ident(s) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(InitialDir) operator(:=) ident(s) + reserved(else) + ident(InitialDir) operator(:=) ident(MyDir)operator(;) + + ident(s) operator(:=) ident(ExtractFileName)operator(()ident(StringE)operator(.)ident(Text)operator(\);) + ident(s) operator(:=) ident(DeleteChars)operator(()ident(s)operator(,) char<delimiter(')content(/)delimiter(')>operator(\);) + reserved(if) ident(s) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(FileName) operator(:=) ident(s)operator(;) + + reserved(if) ident(Execute) reserved(then) + ident(StringE)operator(.)ident(Text) operator(:=) ident(FileName)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ExternalEditBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(FileName)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(TempDir) operator(+) char<delimiter(')content(~)delimiter(')> operator(+) ident(DeleteChars)operator(()ident(CurValueE)operator(.)ident(Text)operator(,) ident(FileNameEnemies)operator(\)) operator(+) + string<delimiter(')content(.bin)delimiter(')>operator(;) + reserved(if) ident(SaveByteA)operator(()ident(BinaryHM)operator(.)ident(Data)operator(,) ident(FileName)operator(\)) reserved(then) + ident(ExecFileWith)operator(()ident(PrefWin)operator(.)ident(ExternalHexEditE)operator(.)ident(Text)operator(,) ident(FileName)operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Could not write into file:)delimiter(')> operator(+) ident(EOL) operator(+) ident(FileName)operator(\);) + + ident(PipelineThread)operator(.)ident(FileName) operator(:=) ident(FileName)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(LoadExternalBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(FileName)operator(:) reserved(string)operator(;) + ident(Data)operator(:) ident(TByteA)operator(;) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Data) operator(:=) reserved(nil)operator(;) + + ident(FileName) operator(:=) ident(TempDir) operator(+) char<delimiter(')content(~)delimiter(')> operator(+) ident(CurValueE)operator(.)ident(Text) operator(+) string<delimiter(')content(.bin)delimiter(')>operator(;) + reserved(if) reserved(not) ident(FileEx)operator(()ident(FileName)operator(\)) reserved(then) reserved(begin) + comment({ShowMessage('File not found:' + EOL + + FileName\);}) + ident(Exit)operator(;) + reserved(end)operator(;) + + ident(Data) operator(:=) ident(LoadByteA)operator(()ident(FileName)operator(\);) + reserved(if) ident(Length)operator(()ident(Data)operator(\)) operator(=) ident(Length)operator(()ident(BinaryHM)operator(.)ident(Data)operator(\)) reserved(then) reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Data)operator(\)) reserved(do) + reserved(if) ident(Data)operator([)ident(i)operator(]) operator(<>) ident(BinaryHM)operator(.)ident(Data)operator([)ident(i)operator(]) reserved(then) reserved(begin) + ident(BinaryHM)operator(.)ident(Data) operator(:=) ident(Data)operator(;) + ident(Exit)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) + ident(BinaryHM)operator(.)ident(Data) operator(:=) ident(Data)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(PipelineCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(PipelineThread)operator(,) ident(PipelineCB) reserved(do) + reserved(if) ident(Checked) reserved(then) reserved(begin) + reserved(if) ident(Suspended) reserved(then) + ident(Resume)operator(;) + reserved(end) reserved(else) + reserved(if) reserved(not) ident(Suspended) reserved(then) + ident(Suspend)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ReloadBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Self)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(BinaryHMEnter)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PipelineCB)operator(.)ident(Checked) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(xUseExtendedModelCBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(PrefWin)operator(.)ident(UseExtendedModelCB)operator(.)ident(Load)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SeparatorEChange)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(if) reserved(not) ident(SeparatorE)operator(.)ident(Enabled) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(SeparatorE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + reserved(if) ident(StringE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Exit) + reserved(else) + ident(MultiStringM)operator(.)ident(Text) operator(:=) ident(StringE)operator(.)ident(Text)operator(;) + ident(MultiStringTypeRG)operator(.)ident(Buttons)operator([)integer(1)operator(].)ident(Enabled) operator(:=) ident(False)operator(;) + ident(MultiStringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + reserved(end) reserved(else) reserved(begin) + reserved(if) ident(StringE)operator(.)ident(Text) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(StringE)operator(.)ident(Text) operator(:=) ident(Join)operator(()ident(MultiStringM)operator(.)ident(Lines)operator(,) ident(SeparatorE)operator(.)ident(Text)operator(\);) + ident(MultiStringTypeRG)operator(.)ident(Buttons)operator([)integer(1)operator(].)ident(Enabled) operator(:=) ident(True)operator(;) + ident(MultiStringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(1)operator(;) + ident(Split)operator(()ident(StringE)operator(.)ident(Text)operator(,) ident(SeparatorE)operator(.)ident(Text)operator(,) ident(MultiStringM)operator(.)ident(Lines)operator(,) ident(False)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(HintLBKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) operator(()ident(Key) operator(=) ident(Byte)operator(()char<delimiter(')content(C)delimiter(')>operator(\)\)) reserved(and) operator(()ident(ssCtrl) reserved(in) ident(Shift)operator(\)) reserved(then) + reserved(with) ident(HintLb) reserved(do) + reserved(if) ident(ItemIndex) operator(>=) integer(0) reserved(then) + ident(Clipboard)operator(.)ident(AsText) operator(:=) ident(Items)operator([)ident(ItemIndex)operator(];) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(DWORDSpecialBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(StrToIntDef)operator((()ident(Sender) reserved(as) ident(TButton)operator(\).)ident(Caption)operator(,) integer(0)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(Button1Click)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(ShowPC)operator(.)ident(SelectNextPage)operator(()ident(True)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyPUPopup)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SisyPU)operator(,) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(PopupComponent)operator(.)ident(Tag)operator(]\)) reserved(do) + ident(Items)operator([)ident(Integer)operator(()ident(Priority)operator(\)].)ident(Checked) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyPriorityMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(SisyPU)operator(.)ident(PopupComponent)operator(.)ident(Tag)operator(]\)) reserved(do) reserved(begin) + ident(Priority) operator(:=) ident(TThreadPriority)operator(()ident(TMenuItem)operator(()ident(Sender)operator(\).)ident(MenuIndex)operator(\);) + reserved(if) ident(Priority) operator(<=) ident(tpNormal) reserved(then) + ident(Uni)operator(.)ident(WriteInteger)operator(()string<delimiter(')content(Priority)delimiter(')>operator(,) ident(Integer)operator(()ident(Priority)operator(\)\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyShowCurrentPathMIClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + reserved(with) ident(SisyPU)operator(,) ident(TSisyThread)operator(()ident(Sisys)operator([)ident(PopupComponent)operator(.)ident(Tag)operator(]\)) reserved(do) reserved(begin) + ident(Suspend)operator(;) + ident(ShowMessage)operator(()ident(CurrentSpyKey)operator(.)ident(Path)operator(\);) + ident(Resume)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(DropFileTargetDrop)operator(()ident(Sender)operator(:) ident(TObject)operator(;) + ident(ShiftState)operator(:) ident(TShiftState)operator(;) ident(Point)operator(:) ident(TPoint)operator(;) reserved(var) ident(Effect)operator(:) ident(Integer)operator(\);) +reserved(begin) + ident(StringE)operator(.)ident(Text) operator(:=) ident(DropFileTarget)operator(.)ident(Files)operator([)integer(0)operator(];) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormClose)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Action)operator(:) ident(TCloseAction)operator(\);) +reserved(begin) +comment(// Action := caNone;) + ident(DropFileTarget)operator(.)ident(Unregister)operator(;) + ident(ClearChanges)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(FormResize)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(begin) + ident(Realign)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(IconImageDblClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(Filename)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(GetFileNew)operator(()ident(StringE)operator(.)ident(Text)operator(\);) + reserved(if) ident(FileName) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(ExecFile)operator(()ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(ShowValues)operator(()ident(Reg)operator(:) ident(TXRegistry)operator(\);) +reserved(var) + ident(MainValueName)operator(:) reserved(string)operator(;) + ident(ValueCommonType)operator(:) ident(TRegDataType)operator(;) + + reserved(procedure) ident(ShowValueAsBinary)operator(()reserved(const) ident(ValueName)operator(:) reserved(string)operator(;) + ident(Smart4BB)operator(:) ident(Boolean) operator(=) ident(True)operator(\);) + reserved(begin) + reserved(if) ident(Smart4BB) + reserved(and) ident(PrefWin)operator(.)ident(Smart4BBCB)operator(.)ident(Checked) + reserved(and) operator(()ident(Reg)operator(.)ident(GetDataSize)operator(()ident(ValueName)operator(\)) operator(=) integer(4)operator(\)) reserved(then) reserved(begin) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(Reg)operator(.)ident(ReadCardinal)operator(()ident(ValueName)operator(\);) + ident(CardTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(2)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) ident(IntPage)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + ident(BinaryHM)operator(.)ident(Data) operator(:=) ident(Reg)operator(.)ident(ReadBin)operator(()ident(ValueName)operator(\);) + ident(DataTypeComB)operator(.)ident(ItemIndex) operator(:=) ident(ValueCommonType)operator(;) + reserved(if) ident(IsValidDataType)operator(()ident(ValueCommonType)operator(\)) reserved(then) + ident(DataTypeComB)operator(.)ident(ItemIndex) operator(:=) ident(ValueCommonType) + reserved(else) reserved(begin) + ident(DataTypeComB)operator(.)ident(Text) operator(:=) ident(IntToStr)operator(()ident(ValueCommonType)operator(\);) + ident(AddHint)operator(()string<delimiter(')content(Value has unknown data type ()delimiter(')> operator(+) ident(DataTypeComB)operator(.)ident(Text) operator(+) string<delimiter(')content(\): )delimiter(')> operator(+) + ident(Quote)operator(()ident(ValueName)operator(\)\);) + reserved(end)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) ident(BinaryPage)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(with) ident(ValuesWin) reserved(do) reserved(begin) + reserved(if) reserved(not) ident(Assigned)operator(()ident(ValueNames)operator(\)) reserved(or) operator(()ident(ValueNames)operator(.)ident(Count) operator(=) integer(0)operator(\)) reserved(then) + reserved(raise) ident(EReadError)operator(.)ident(Create)operator(()string<delimiter(')content(ValueNameList error)delimiter(')>operator(\);) + ident(MainValueName) operator(:=) ident(ValueNames)operator([)integer(0)operator(];) + reserved(end)operator(;) + ident(ValueCommonType) operator(:=) ident(ValuesWin)operator(.)ident(ValueCommonType)operator(;) + + reserved(with) ident(CurValueE) reserved(do) reserved(begin) + ident(Enabled) operator(:=) ident(True)operator(;) + reserved(if) ident(ValuesWin)operator(.)ident(ValueNames)operator(.)ident(Count) operator(=) integer(1) reserved(then) + ident(Text) operator(:=) ident(MainValueName) + reserved(else) + ident(Text) operator(:=) ident(Copy)operator(()ident(ValuesWin)operator(.)ident(ValueNames)operator(.)ident(CommaText)operator(,) integer(1)operator(,) integer(255)operator(\);) + + ident(Font)operator(.)ident(Color) operator(:=) ident(ColorOfDataType)operator(()ident(ValueCommonType)operator(\);) + reserved(end)operator(;) + + reserved(if) ident(KeyIsDown)operator(()ident(VK_MENU)operator(\)) reserved(or) ident(ShowAsBinary) reserved(then) reserved(begin) + ident(ShowValueAsBinary)operator(()ident(MainValueName)operator(,) ident(False)operator(\);) + reserved(end) reserved(else) reserved(if) ident(ValueCommonType) reserved(in) ident(rdStringTypes) reserved(then) reserved(begin) + ident(StringE)operator(.)ident(Text) operator(:=) ident(Reg)operator(.)ident(ReadString)operator(()ident(MainValueName)operator(\);) + reserved(case) ident(ValueCommonType) reserved(of) + ident(rdString)operator(:) ident(StringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + ident(rdExpandString)operator(:) ident(StringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(1)operator(;) + reserved(end)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) ident(StringPage)operator(;) + reserved(end) reserved(else) reserved(if) ident(ValueCommonType) reserved(in) ident(rdCardTypes) reserved(then) reserved(begin) + ident(CardinalE)operator(.)ident(Value) operator(:=) ident(Reg)operator(.)ident(ReadCardinal)operator(()ident(MainValueName)operator(\);) + reserved(case) ident(ValueCommonType) reserved(of) + ident(rdCardinal)operator(:) ident(StringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + ident(rdCardBigEndian)operator(:) ident(StringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(1)operator(;) + reserved(end)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) ident(IntPage)operator(;) + reserved(end) reserved(else) reserved(if) ident(ValueCommonType) operator(=) ident(rdMultiString) reserved(then) reserved(begin) + ident(MultiStringM)operator(.)ident(Clear)operator(;) + ident(Reg)operator(.)ident(ReadMultiString)operator(()ident(MainValueName)operator(,) ident(MultiStringM)operator(.)ident(Lines)operator(,) ident(PrefWin)operator(.)ident(UseExtendedModelCB)operator(.)ident(Checked)operator(\);) + ident(SeparatorEChange)operator(()ident(Self)operator(\);) + ident(MultiStringTypeRG)operator(.)ident(ItemIndex) operator(:=) integer(0)operator(;) + ident(ShowPC)operator(.)ident(ActivePage) operator(:=) ident(MultiStringPage)operator(;) + reserved(end) reserved(else) reserved(begin) + ident(ShowValueAsBinary)operator(()ident(MainValueName)operator(\);) + reserved(end)operator(;) + + ident(ShowAsBinary) operator(:=) ident(False)operator(;) + + ident(UpdateWriteButtons)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(UpdateWriteButtons)operator(;) +reserved(const) + ident(BtnTextOfMultiEdit)operator(:) reserved(array)operator([)ident(Boolean)operator(]) reserved(of) reserved(string) operator(=) operator(()string<delimiter(')content(Write)delimiter(')>operator(,) string<delimiter(')content(Write all)delimiter(')>operator(\);) +reserved(var) + ident(BtnText)operator(:) reserved(string)operator(;) +reserved(begin) + ident(BtnText) operator(:=) ident(BtnTextOfMultiEdit)operator([)ident(ValuesWin)operator(.)ident(ValueNames)operator(.)ident(Count) operator(>) integer(1)operator(];) + ident(OKStringB)operator(.)ident(Caption) operator(:=) ident(BtnText)operator(;) + ident(OKIntB)operator(.)ident(Caption) operator(:=) ident(BtnText)operator(;) + ident(OKMultiStringB)operator(.)ident(Caption) operator(:=) ident(BtnText)operator(;) + ident(OKBinaryB)operator(.)ident(Caption) operator(:=) ident(BtnText)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(EditData)operator(;) +reserved(begin) + ident(AddHint)operator(()string<delimiter(')content(Edit)delimiter(')>operator(\);) + ident(MainPC)operator(.)ident(ActivePage) operator(:=) ident(WorkPage)operator(;) + + reserved(with) ident(ShowPC) reserved(do) + reserved(if) ident(ActivePage) operator(=) reserved(nil) reserved(then) + ident(Exit) + reserved(else) reserved(if) ident(ActivePage) operator(=) ident(WorkWin)operator(.)ident(StringPage) reserved(then) reserved(begin) + ident(FocusControl)operator(()ident(StringE)operator(\);) + ident(StringE)operator(.)ident(SelectAll)operator(;) + reserved(end) + reserved(else) reserved(if) ident(ActivePage) operator(=) ident(WorkWin)operator(.)ident(IntPage) reserved(then) + ident(FocusControl)operator(()ident(CardinalE)operator(\)) + reserved(else) reserved(if) ident(ActivePage) operator(=) ident(WorkWin)operator(.)ident(MultiStringPage) reserved(then) + ident(FocusControl)operator(()ident(MultiStringM)operator(\)) + reserved(else) reserved(if) ident(ActivePage) operator(=) ident(WorkWin)operator(.)ident(BinaryPage) reserved(then) + ident(FocusControl)operator(()ident(BinaryHM)operator(\)) + reserved(else) + ident(ShowMessage)operator(()string<delimiter(')content(Error: ShowPC.ActivePage!)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVCustomDrawItem)operator(()ident(Sender)operator(:) ident(TCustomTreeView)operator(;) + ident(Node)operator(:) ident(TTreeNode)operator(;) ident(State)operator(:) ident(TCustomDrawState)operator(;) reserved(var) ident(DefaultDraw)operator(:) ident(Boolean)operator(\);) +reserved(begin) + reserved(with) ident(TTreeView)operator(()ident(Sender)operator(\).)ident(Canvas)operator(.)ident(Font) reserved(do) reserved(begin) + reserved(if) ident(Node)operator(.)ident(Cut) reserved(then) + ident(Color) operator(:=) hex($AAAAAA) + reserved(else) + ident(Color) operator(:=) ident(clWhite)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(SisyTVMouseDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) ident(Button)operator(:) ident(TMouseButton)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(;) ident(X)operator(,) ident(Y)operator(:) ident(Integer)operator(\);) +reserved(var) + ident(Node)operator(:) ident(TTreeNode)operator(;) + ident(RelX)operator(,) ident(RelY)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(with) ident(SisyTV) reserved(do) reserved(begin) + ident(RelX) operator(:=) ident(ScreenToClient)operator(()ident(Mouse)operator(.)ident(CursorPos)operator(\).)ident(X)operator(;) + ident(RelY) operator(:=) ident(ScreenToClient)operator(()ident(Mouse)operator(.)ident(CursorPos)operator(\).)ident(Y)operator(;) + ident(Node) operator(:=) ident(GetNodeAt)operator(()ident(RelX)operator(,) ident(RelY)operator(\);) + reserved(end)operator(;) + reserved(if) reserved(not) ident(Assigned)operator(()ident(Node)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Node)operator(.)ident(Selected) reserved(then) + ident(Node)operator(.)ident(Selected) operator(:=) ident(True)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(OKCryptoBClick)operator(()ident(Sender)operator(:) ident(TObject)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(try) + ident(OpenCurKey)operator(;) + reserved(with) ident(ValuesWin)operator(.)ident(ValueNames) reserved(do) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + reserved(case) ident(CryptoTypeRG)operator(.)ident(ItemIndex) reserved(of) + integer(0)operator(:) ident(MainReg)operator(.)ident(WriteBin)operator(()ident(Strings)operator([)ident(i)operator(],) ident(EncodeScreenSaver)operator(()ident(CryptoE)operator(.)ident(Text)operator(\)\);) + integer(1)operator(:) ident(MainReg)operator(.)ident(WriteBin)operator(()ident(Strings)operator([)ident(i)operator(],) ident(EncodeSharedFolder)operator(()ident(CryptoE)operator(.)ident(Text)operator(\)\);) + reserved(end)operator(;) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(UpdateValues)operator(()ident(True)operator(\);) + reserved(finally) + ident(MainReg)operator(.)ident(CloseKey)operator(;) + reserved(end)operator(;) + ident(ValuesWin)operator(.)ident(ValueListDblClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TWorkWin)operator(.)ident(CryptoEKeyDown)operator(()ident(Sender)operator(:) ident(TObject)operator(;) reserved(var) ident(Key)operator(:) ident(Word)operator(;) + ident(Shift)operator(:) ident(TShiftState)operator(\);) +reserved(begin) + reserved(if) ident(Key) operator(=) ident(VK_RETURN) reserved(then) reserved(begin) + ident(OKCryptoBClick)operator(()ident(Sender)operator(\);) + ident(ValuesWin)operator(.)ident(FocusControl)operator(()ident(ValueList)operator(\);) + reserved(end)operator(;) + reserved(if) ident(Key) operator(=) ident(VK_ESCAPE) reserved(then) + ident(CancelBClick)operator(()ident(Sender)operator(\);) +reserved(end)operator(;) + +reserved(end)operator(.) diff --git a/test/delphi/suite.rb b/test/delphi/suite.rb new file mode 100644 index 0000000..ace3fd2 --- /dev/null +++ b/test/delphi/suite.rb @@ -0,0 +1,3 @@ +class Delphi < CodeRay::TestCase + extension :pas +end diff --git a/test/delphi/ytools.in.pas b/test/delphi/ytools.in.pas new file mode 100644 index 0000000..8670459 --- /dev/null +++ b/test/delphi/ytools.in.pas @@ -0,0 +1,2708 @@ +// vim:ft=pascal
+
+unit YTools;
+
+{===============================================================================
+
+ cYcnus.YTools 1.0.3 Beta for Delphi 4+
+ by licenser and Murphy
+
+ ©2000-2003 by cYcnus
+ visit www.cYcnus.de
+
+ licenser@cYcnus.de (Heinz N. Gies)
+ murphy@cYcnus.de (Kornelius Kalnbach)
+
+ this unit is published under the terms of the GPL
+
+===============================================================================}
+
+interface
+
+uses
+ Windows, SysUtils, Classes, YTypes;
+
+const
+ BackSpace = #8;
+ Tab = #9;
+ LF = #10; //Line Feed
+ CR = #13; //Carriage Return
+ Space = #32;
+ EOLChars = [CR, LF];
+{$IFNDEF VER140}
+ sLineBreak = #13#10;
+ SwitchChars = ['/', '-'];
+{$ENDIF}
+ EOL = sLineBreak;
+ MaxCard = High(Cardinal);
+ AllChars = [#0..#255];
+ Alphabetical = ['A'..'Z', 'a'..'z'];
+ DecimalChars = ['0'..'9'];
+ AlphaNumerical = Alphabetical + DecimalChars;
+ StrangeChars = [#0..#31, #127, #129, #141..#144, #157, #158];
+
+ HexadecimalChars = DecimalChars + ['A'..'F', 'a'..'f'];
+ OctalChars = ['0'..'7'];
+ BinaryChars = ['0', '1'];
+
+ QuoteChars = ['''', '"'];
+ WildCards = ['*', '?'];
+ FileNameEnemies = WildCards + ['\', '/', ':', '<', '>', '|'];
+
+ HexChar: array[THex] of Char = (
+ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
+ LowerHexChar: array[THex] of Char = (
+ '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f');
+ BaseNChar: array[TBaseN] of Char = (
+ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H',
+ 'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z');
+
+ cYcnusOverlayColor = $050001;
+
+ faFindEveryFile = faReadOnly + faHidden + faSysFile + faArchive;
+
+ platWin9x = [VER_PLATFORM_WIN32s, VER_PLATFORM_WIN32_WINDOWS];
+
+
+{ Debugging }
+procedure ClearReport(const ReportName: string);
+procedure Report(const ReportName, Text: string);
+procedure ReportFmt(const ReportName, Fmt: string; const Args: array of const);
+
+{ Params }
+procedure GetParams(Strings: TStrings); overload;
+function GetParams(const Separator: string = ' '): string; overload;
+
+function ParamNum(const S: string): Integer;
+function ParamPrefixNum(const Prefix: string): Integer;
+function Param(const S: string): Boolean;
+function ParamPrefix(const Prefix: string): Boolean;
+
+function Switch(const Switch: string; const PrefixChars: TCharSet = SwitchChars;
+ IgnoreCase: Boolean = True): Boolean;
+function GetParam(const Prefix: string = ''; const Default: string = ''): string;
+
+{ Dirs & UserName}
+function GetMyDir(FullPath: Boolean = False): string;
+function WinDir: string;
+function SysDir: string;
+function UserName: string;
+
+{ Strings & Chars}
+function FirstChar(const S: string): Char;
+function LastChar(const S: string): Char;
+
+function CharPos(C: Char; const S: string; Offset: Integer = 1): Integer; overload;
+function CharPos(C: TCharSet; const S: string; Offset: Integer = 1): Integer; overload;
+function CharPosR(C: Char; const S: string; Offset: Integer = -1): Integer;
+function PosEx(const SubStr, S: string; Offset: Integer = 1): Integer;
+function PosExText(const SubStr, S: string; Offset: Integer = 1): Integer;
+function PosExAnsiText(const SubStr, S: string; Offset: Integer = 1): Integer;
+
+function UntilChar(const S: string; Brake: Char): string; overload;
+function UntilChar(const S: string; Brake: TCharSet): string; overload;
+function UntilLastChar(const S: string; Brake: Char;
+ IgnoreNoBrake: Boolean = True): string;
+
+function FromChar(const S: string; Brake: Char): string; overload;
+function FromChar(const S: string; Brake: TCharSet): string; overload;
+function FromLastChar(const S: string; Brake: Char;
+ IgnoreNoBrake: Boolean = False): string;
+
+function BetweenChars(const S: string; Start, Finish: Char;
+ Inclusive: Boolean = False): string;
+
+function UntilStr(const S: string; Brake: string): string;
+function FromStr(const S: string; Brake: string): string;
+
+function StringWrap(const S: string; Width: Integer; const LineEnd: string = EOL): string;
+
+{ Splitting & Combining }
+function Split(const S, Separator: string; IgnoreMultiSep: Boolean = True;
+ MinCount: Integer = 0): TStrA; overload;
+procedure Split(const S, Separator: string; Strings: TStrings;
+ IgnoreMultiSep: Boolean = True); overload;
+function Split(const S: string; Separators: TCharSet;
+ IgnoreMultiSep: Boolean = True; MinCount: Integer = 0): TStrA; overload;
+
+procedure TileStr(const S: string; BrakeStart: Integer; BrakeEnd: Integer;
+ out Left, Right: string);
+
+function Join(Strings: TStrings; Separator: string = ' '): string; overload;
+function Join(StrA: TStrA; Separator: string = ' '): string; overload;
+
+function MulStr(const S: string; Count: Integer): string;
+
+{ Strings ausrichten }
+function AlignR(const S: string; Width: Integer; Filler: Char = ' '): string;
+function MaxStr(const S: string; MaxLen: Integer): string;
+
+{ Stringing }
+function TrimAll(const S: string): string;
+
+function ControlChar(C: Char): Boolean;
+function FriendlyChar(C: Char): Char;
+
+function FriendlyStr(const S: string): string; overload;
+function FriendlyStr(a: TByteA): string; overload;
+
+function Quote(const S: string; Quoter: Char = '"'): string;
+function UnQuote(const S: string): string;
+function DeQuote(const S: string): string;
+
+function StrNumerus(const Value: Integer; const Singular, Plural: string;
+ const Zero: string = '0'): string;
+
+function MakeStr(const Items: array of const; Separator: string = ''): string;
+procedure ShowText(const Items: array of const; Separator: string = '');
+
+{ Delete }
+function DeleteChars(const S: string; C: Char): string; overload;
+function DeleteChars(const S: string; C: TCharSet): string; overload;
+function ExtractChars(const S: string; C: TCharSet): string;
+
+{ Find }
+function CharCount(const S: string; C: Char): Integer;
+
+function CharIn(const S: string; C: Char): Boolean; overload;
+function CharIn(const S: string; C: TCharSet): Boolean; overload;
+
+function StrAtPos(const S: string; Pos: Integer; const Str: string): Boolean;
+function StrAtBegin(const S, Str: string): Boolean;
+function StrIn(const S, SubStr: string): Boolean; overload;
+function StrIn(A: TStrA; const S: string): Boolean; overload;
+function StrIn(SL: TStrings; const S: string): Boolean; overload;
+function StrIndex(A: TStrA; const S: string): Integer; overload;
+function StrIndex(SL: TStrings; const S: string): Integer; overload;
+
+function TextAtPos(const S: string; Pos: Integer; const Text: string): Boolean;
+function TextAtBegin(const S, Text: string): Boolean;
+function TextIn(const S, Text: string): Boolean; overload;
+function TextIn(A: TStrA; const Text: string): Boolean; overload;
+function TextIn(SL: TStrings; const Text: string): Boolean; overload;
+function TextIndex(A: TStrA; const Text: string): Integer; overload;
+function TextIndex(SL: TStrings; const Text: string): Integer; overload;
+
+{ Replace }
+function ReplaceChars(const S: string; Old, New: Char): string; overload;
+function ReplaceChars(const S: string; Old: TCharSet; New: Char): string; overload;
+
+function Replace(const S, Old, New: string): string;
+
+{ TStrings }
+function SLOfFile(const FileName: string): TStringList;
+function ContainsEmptyLines(SL: TStrings): Boolean;
+procedure DeleteEmptyLines(SL: TStrings);
+procedure DeleteCommentLines(SL: TStrings; const CommentSign: string = '//');
+procedure WriteSL(Strings: TStrings; const Prefix: string = '';
+ const Suffix: string = '');
+
+function FindLine(SL: TStrings; const S: string): Integer;
+
+procedure QuickSortSL(SL: TStringList);
+
+{ TStrA }
+function IncStrA(StrA: TStrA): Integer;
+
+{ TByteA }
+function StrOfByteA(a: TByteA): string;
+function ByteAOfStr(const S: string): TByteA;
+function ByteAOfInt(i: Integer): TByteA;
+function IntOfByteA(A: TByteA): Integer;
+function ByteAOfHex(const Hex: string): TByteA;
+
+function SameByteA(const A, B: TByteA): Boolean;
+function Reverse(a: TByteA): TByteA;
+function SaveByteA(Data: TByteA; const FileName: string; Overwrite: Boolean = True): Boolean;
+function LoadByteA(const FileName: string): TByteA;
+
+function Endian(i: Integer): Integer;
+
+{ Files }
+function SizeOfFile(const FileName: string): Integer;
+function FileEx(const FileName: string; AllowFolders: Boolean = False): Boolean;
+function LWPSolve(const Dir: string): string;
+function LWPSlash(const Dir: string): string;
+
+function ExtractDrive(const FileName: string): string;
+function ExtractPath(const FileName: string): string;
+function ExtractPrefix(const FileName: string): string;
+function ExtractSuffix(const FileName: string): string;
+
+function IsValidFileName(const FileName: string): Boolean;
+function MakeValidFileName(FileName: string; const Default: string = 'File'): string;
+
+{ Converting }
+function IsValidInteger(const S: string): Boolean;
+function IsValidCardinal(const S: string): Boolean;
+
+function StrOfBool(flag: Boolean; const TrueStr: string = 'True';
+ const FalseStr: string = 'False'): string;
+function StrOfInt(i: Integer): string;
+function CardOfStr(const S: string): Cardinal;
+
+function HexOrd(Hex: Char): THex;
+function ByteOfHex(Hex: THexByteStr): Byte;
+
+function DecOfHex(const Hex: string): string;
+function HexOfByte(b: Byte): THexByteStr;
+function HexOfCard(i: Cardinal): string; overload;
+function HexOfCard(i: Cardinal; Digits: Integer): string; overload;
+
+function PascalHexArray(a: TByteA; Name: string): string;
+
+function HexOfByteA(a: TByteA; Blocks: Integer = 1;
+ const Splitter: string = ' '): string;
+function BinOfByteA(a: TByteA; Blocks: Integer = 4;
+ const Splitter: string = ' '): string;
+
+function CardOfHex(Hex: string): Cardinal;
+function IntOfBin(Bin: string): Cardinal;
+
+function BinOfIntFill(n: cardinal; MinCount: Integer = 8): string;
+function BinOfInt(n: cardinal): string;
+
+function BaseNOfInt(I: Cardinal; B: TBaseN): string;
+function IntOfBaseN(V: string; B: TBaseN): Cardinal;
+
+{ Ranges }
+function KeepIn(i, Bottom, Top: Variant): Variant;
+function InRange(Value, Bottom, Top: Variant): Boolean;
+function InStrictRange(Value, Bottom, Top: Variant): Boolean;
+function Min(const A, B: Integer): Integer; overload;
+function Min(const A: TIntA): Integer; overload;
+function Max(const A, B: Integer): Integer; overload;
+function Max(const A: TIntA): Integer; overload;
+
+const
+ RangesSeparator = ',';
+ RangeInnerSeparator = '-';
+ RangeInfinite = '*';
+ RangeSpecialChars = [RangesSeparator, RangeInnerSeparator, RangeInfinite];
+
+function RangesOfStr(const S: string): TRanges;
+function InRanges(Ranges: TRanges; TestValue: Cardinal): Boolean;
+
+function Success(Res: Integer; ResultOnSuccess: Integer = ERROR_SUCCESS): Boolean;
+function Failure(Res: Integer; ResultOnSuccess: Integer = ERROR_SUCCESS): Boolean;
+
+function ExpandString(const S: string): string;
+
+{ Files }
+procedure DeleteFiles(const Mask: string; ScanSubDirs: Boolean = True;
+ Attributes: Integer = faFindEveryFile);
+procedure FileNew(const FileName: string);
+function DateTimeOfFileTime(const FileTime: TFileTime): TDateTime;
+
+{ FileNames }
+function GetFileNew(FileName: string; NoFloppyDrives: Boolean = True): string;
+
+{ Finding Files }
+function FindAll(Strings: TStrings; const Mask: string;
+ ScanSubDirs: Boolean = True; Attributes: Integer = faFindEveryFile;
+ FileReturn: TFileNameFunc = nil): Boolean;
+function FindAllFirst(const Mask: string; ScanSubDirs: Boolean = True;
+ Attributes: Integer = faFindEveryFile): string;
+
+function FullOSInfo: string;
+function Win32PlatformStr: string;
+function Win9x: Boolean;
+function WinNT: Boolean;
+function Win2000: Boolean;
+function WinXP: Boolean;
+
+var
+ MyDir: string = '';
+ LastSuccessRes: Integer = 0;
+
+{ Backward compatibility }
+{$IFNDEF VER130}
+function SameText(const S1, S2: string): Boolean;
+{$ENDIF}
+
+implementation
+{$IFNDEF VER140}
+uses FileCtrl;
+{$ENDIF}
+
+{$IFNDEF VER130}
+function SameText(const S1, S2: string): Boolean;
+begin
+ Result := CompareText(S1, S2) = 0;
+end;
+{$ENDIF}
+
+procedure Report(const ReportName, Text: string);
+var
+ F: TextFile;
+ FileName: string;
+begin
+ FileName := MyDir + ReportName + '.rep';
+ Assign(F, FileName);
+ try
+ if not FileExists(FileName) then
+ Rewrite(F)
+ else
+ Append(F);
+ WriteLn(F, Text);
+ finally
+ Close(F);
+ end;
+end;
+
+procedure ClearReport(const ReportName: string);
+var
+ FileName: string;
+begin
+ FileName := MyDir + ReportName + '.rep';
+ DeleteFile(FileName);
+end;
+
+procedure ReportFmt(const ReportName, Fmt: string; const Args: array of const);
+begin
+ Report(ReportName, Format(Fmt, Args));
+end;
+
+procedure GetParams(Strings: TStrings);
+var
+ P: PChar;
+ Param: string;
+
+ function GetParamStr(var P: PChar; var Param: string): Boolean;
+ var
+ Quoted: Boolean;
+ begin
+ Param := '';
+
+ repeat
+ while (P[0] <> #0) and (P[0] <= ' ') do
+ Inc(P);
+
+ Quoted := False;
+ while P[0] <> #0 do begin
+ if P[0] = '"' then begin
+ Quoted := not Quoted;
+ Inc(P);
+ Continue; end;
+ if (P[0] <= ' ') and not Quoted then
+ Break;
+ Param := Param + P[0];
+ Inc(P);
+ end;
+ until (Param <> '') or (P[0] = #0);
+
+ Result := Param <> '';
+ end;
+
+begin
+ Strings.Clear;
+ P := GetCommandLine;
+ GetParamStr(P, Param);
+ while GetParamStr(P, Param) do
+ Strings.Add(Param);
+end;
+
+function GetParams(const Separator: string = ' '): string;
+var
+ SL: TStringList;
+begin
+ SL := TStringList.Create;
+ GetParams(SL);
+ Result := Join(SL, Separator);
+ SL.Free;
+end;
+
+function Switch(const Switch: string; const PrefixChars: TCharSet = SwitchChars;
+ IgnoreCase: Boolean = True): Boolean;
+//= SysUtils.FindCmdLineSwitch
+var
+ i: Integer;
+ s: string;
+begin
+ Result := True;
+
+ for i := 1 to ParamCount do begin
+ s := ParamStr(i);
+
+ if (s <> '') and (s[1] in PrefixChars) then begin
+ //i know that always s <> '', but this is saver
+ s := Copy(s, 2, MaxInt);
+ if (s = Switch) or (IgnoreCase and (0=AnsiCompareText(s, Switch))) then
+ Exit;
+ end;
+ end;
+
+ Result := False;
+end;
+
+function ParamNum(const S: string): Integer;
+begin
+ for Result := 1 to ParamCount do
+ if 0=AnsiCompareText(ParamStr(Result), S) then
+ Exit;
+
+ Result := 0;
+end;
+
+function ParamPrefixNum(const Prefix: string): Integer;
+var
+ Len: Integer;
+begin
+ Len := Length(Prefix);
+ for Result := 1 to ParamCount do
+ if 0=AnsiCompareText(Copy(ParamStr(Result), 1, Len), Prefix) then
+ Exit;
+
+ Result := 0;
+end;
+
+function Param(const S: string): Boolean;
+begin
+ Result := ParamNum(S) > 0;
+end;
+
+function ParamPrefix(const Prefix: string): Boolean;
+begin
+ Result := ParamPrefixNum(Prefix) > 0;
+end;
+
+function GetParam(const Prefix: string = ''; const Default: string = ''): string;
+var
+ i: Integer;
+begin
+ Result := Default;
+
+ if Prefix = '' then begin
+ Result := ParamStr(1);
+ Exit; end;
+
+ i := ParamPrefixNum(Prefix);
+ if i > 0 then
+ Result := Copy(ParamStr(i), Length(Prefix) + 1, MaxInt);
+end;
+
+function GetMyDir(FullPath: Boolean = False): string;
+var
+ Buffer: array[0..260] of Char;
+begin
+ Result := '';
+ SetString(Result, Buffer, GetModuleFileName(0, Buffer, SizeOf(Buffer)));
+ if FullPath then
+ Result := GetFileNew(Result);
+ Result := ExtractPath(Result);
+end;
+
+function WinDir: string;
+var
+ Res: PChar;
+begin
+ Result := '\';
+ GetMem(Res, MAX_PATH);
+ GetWindowsDirectory(Res, MAX_PATH);
+ Result := Res + '\';
+ FreeMem(Res, MAX_PATH);
+end;
+
+function SysDir: string;
+var
+ Res: PChar;
+begin
+ Result := '\';
+ GetMem(Res, MAX_PATH);
+ GetSystemDirectory(Res, MAX_PATH);
+ Result := Res + '\';
+ FreeMem(Res, MAX_PATH);
+end;
+
+function UserName: string;
+var
+ Len: Cardinal;
+ Res: PChar;
+begin
+ Result := '';
+ GetMem(Res, MAX_PATH);
+ Len := MAX_PATH;
+ GetUserName(Res, Len);
+ Result := Res;
+ FreeMem(Res, MAX_PATH);
+end;
+
+function FirstChar(const S: string): Char;
+begin
+ if s = '' then
+ Result := #0
+ else
+ Result := s[1];
+end;
+
+function LastChar(const S: string): Char;
+begin
+ if s = '' then
+ Result := #0
+ else
+ Result := s[Length(s)];
+end;
+
+function CharPos(C: Char; const S: string; Offset: Integer = 1): Integer;
+var
+ MaxPosToSearch: Integer;
+begin
+ Result := Offset;
+ MaxPosToSearch := Length(S);
+
+ while Result <= MaxPosToSearch do begin
+ if S[Result] = C then
+ Exit;
+ Inc(Result);
+ end;
+
+ Result := 0;
+end;
+
+function CharPos(C: TCharSet; const S: string; Offset: Integer = 1): Integer;
+var
+ MaxPosToSearch: Integer;
+begin
+ Result := Offset;
+ MaxPosToSearch := Length(S);
+
+ while Result <= MaxPosToSearch do begin
+ if S[Result] in C then
+ Exit;
+ Inc(Result);
+ end;
+
+ Result := 0;
+end;
+
+function CharPosR(C: Char; const S: string; Offset: Integer = -1): Integer;
+begin
+ if Offset < 0 then
+ Result := Length(S) + 1 - Offset
+ else
+ Result := Offset;
+ if Result > Length(S) then
+ Result := Length(S);
+
+ while Result > 0 do begin
+ if S[Result] = C then
+ Exit;
+ Dec(Result);
+ end;
+end;
+
+function PosEx(const SubStr, S: string; Offset: Integer = 1): Integer;
+var
+ MaxPosToSearch, LenSubStr, i: Integer;
+begin
+ if SubStr = '' then begin
+ Result := 0;
+ Exit; end;
+
+ if Offset < 1 then
+ Result := 1
+ else
+ Result := Offset;
+
+ LenSubStr := Length(SubStr);
+ MaxPosToSearch := Length(S) - LenSubStr + 1;
+
+ while Result <= MaxPosToSearch do begin
+ if S[Result] = SubStr[1] then begin
+ i := 1;
+
+ while (i < LenSubStr)
+ and (S[Result + i] = SubStr[i + 1]) do
+ Inc(i);
+
+ if i = LenSubStr then
+ Exit;
+ end;
+ Inc(Result);
+ end;
+
+ Result := 0;
+end;
+
+function PosExText(const SubStr, S: string; Offset: Integer = 1): Integer;
+var
+ MaxPosToSearch, LenSubStr, i: Integer;
+
+ function SameChar(a, b: Char): Boolean;
+ begin
+ Result := UpCase(a) = UpCase(b)
+ end;
+
+begin
+ if SubStr = '' then begin
+ Result := 0;
+ Exit; end;
+
+ if Offset < 1 then
+ Result := 1
+ else
+ Result := Offset;
+
+ LenSubStr := Length(SubStr);
+ MaxPosToSearch := Length(S) - LenSubStr + 1;
+
+ while Result <= MaxPosToSearch do begin
+ if SameChar(S[Result], SubStr[1]) then begin
+ i := 1;
+
+ while (i < LenSubStr)
+ and (SameChar(S[Result + i], SubStr[i + 1])) do
+ Inc(i);
+
+ if i = LenSubStr then
+ Exit;
+ end;
+ Inc(Result);
+ end;
+
+ Result := 0;
+end;
+
+function PosExAnsiText(const SubStr, S: string; Offset: Integer = 1): Integer;
+var
+ MaxPosToSearch, LenSubStr, i: Integer;
+
+ function SameChar(a, b: Char): Boolean;
+ begin
+ Result := CharLower(PChar(a)) = CharLower(PChar(b));
+ end;
+
+begin
+ if SubStr = '' then begin
+ Result := 0;
+ Exit; end;
+
+ if Offset < 1 then
+ Result := 1
+ else
+ Result := Offset;
+
+ LenSubStr := Length(SubStr);
+ MaxPosToSearch := Length(S) - LenSubStr + 1;
+
+ while Result <= MaxPosToSearch do begin
+ if SameChar(S[Result], SubStr[1]) then begin
+ i := 1;
+
+ while (i < LenSubStr)
+ and (SameChar(S[Result + i], SubStr[i + 1])) do
+ Inc(i);
+
+ if i = LenSubStr then
+ Exit;
+ end;
+ Inc(Result);
+ end;
+
+ Result := 0;
+end;
+
+function UntilChar(const S: string; Brake: Char): string;
+var
+ p: Integer;
+begin
+ p := CharPos(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, 1, p - 1)
+ else
+ Result := S;
+end;
+
+function UntilChar(const S: string; Brake: TCharSet): string;
+var
+ p: Integer;
+begin
+ Result := '';
+ p := CharPos(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, 1, p - 1)
+ else
+ Result := S;
+end;
+
+function UntilLastChar(const S: string; Brake: Char;
+ IgnoreNoBrake: Boolean = True): string;
+var
+ p: Integer;
+begin
+ Result := '';
+ p := CharPosR(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, 1, p - 1)
+ else if IgnoreNoBrake then
+ Result := S;
+end;
+
+function FromChar(const S: string; Brake: Char): string;
+var
+ p: Integer;
+begin
+ Result := '';
+ p := CharPos(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, p + 1, Length(S) - p);
+end;
+
+function FromChar(const S: string; Brake: TCharSet): string;
+var
+ p: Integer;
+begin
+ Result := '';
+ p := CharPos(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, p + 1, Length(S) - p);
+end;
+
+function FromLastChar(const S: string; Brake: Char;
+ IgnoreNoBrake: Boolean = False): string;
+var
+ p: Integer;
+begin
+ Result := '';
+ p := CharPosR(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, p + 1, Length(S) - p)
+ else if IgnoreNoBrake then
+ Result := S;
+end;
+
+function BetweenChars(const S: string; Start, Finish: Char;
+ Inclusive: Boolean = False): string;
+var
+ p, fin: Integer;
+begin
+ Result := '';
+
+ p := CharPos(Start, S);
+ if p = 0 then
+ Exit;
+
+ fin := CharPos(Finish, S, p + 1);
+ if fin = 0 then
+ Exit;
+
+ if not Inclusive then begin
+ Inc(p);
+ Dec(fin);
+ end;
+
+ Result := Copy(S, p, fin - p + 1);
+end;
+
+function UntilStr(const S: string; Brake: string): string;
+var
+ p: Integer;
+begin
+ if Length(Brake) = 1 then begin
+ Result := UntilChar(S, Brake[1]);
+ Exit; end;
+
+ p := PosEx(Brake, S);
+
+ if p > 0 then
+ Result := Copy(S, 1, p - 1)
+ else
+ Result := S;
+end;
+
+function FromStr(const S: string; Brake: string): string;
+var
+ p: Integer;
+begin
+ if Length(Brake) = 1 then begin
+ Result := FromChar(S, Brake[1]);
+ Exit; end;
+
+ Result := '';
+ p := PosEx(Brake, s);
+
+ if p > 0 then begin
+ Inc(p, Length(Brake));
+ Result := Copy(S, p, Length(S) - p + 1);
+ end;
+end;
+
+function StringWrap(const S: string; Width: Integer; const LineEnd: string = EOL): string;
+var
+ i: Integer;
+begin
+ Result := '';
+ if (S = '') or (Width < 1) then
+ Exit;
+
+ i := 1;
+ while True do begin
+ Result := Result + Copy(S, i, Width);
+ Inc(i, Width);
+ if i <= Length(S) then
+ Result := Result + LineEnd
+ else
+ Exit;
+ end;
+end;
+
+function Split(const S, Separator: string; IgnoreMultiSep: Boolean = True;
+ MinCount: Integer = 0): TStrA;
+var
+ p, fin, SepLen: Integer;
+
+ procedure Add(const S: string);
+ begin
+ if IgnoreMultiSep and (S = '') then
+ Exit;
+ SetLength(Result, Length(Result) + 1);
+ Result[High(Result)] := S;
+ end;
+
+begin
+ if S = '' then begin
+ if Length(Result) < MinCount then
+ SetLength(Result, MinCount);
+ Exit; end;
+
+ Result := nil;
+ SepLen := Length(Separator);
+
+ p := 1;
+ fin := PosEx(Separator, S);
+ while fin > 0 do begin
+ Add(Copy(S, p, fin - p));
+ p := fin + SepLen;
+ fin := PosEx(Separator, S, p);
+ end;
+ Add(Copy(S, p, Length(S) - p + 1));
+
+ if Length(Result) < MinCount then
+ SetLength(Result, MinCount);
+end;
+
+procedure Split(const S, Separator: string; Strings: TStrings;
+ IgnoreMultiSep: Boolean = True);
+var
+ p, fin, SepLen: Integer;
+
+ procedure Add(const S: string);
+ begin
+ if IgnoreMultiSep and (S = '') then
+ Exit;
+ Strings.Add(S);
+ end;
+
+begin
+ if S = '' then
+ Exit;
+
+ Strings.BeginUpdate;
+ SepLen := Length(Separator);
+ p := 1;
+ fin := PosEx(Separator, S);
+ while fin > 0 do begin
+ Add(Copy(S, p, fin - p));
+ p := fin + SepLen;
+ fin := PosEx(Separator, S, p);
+ end;
+ Add(Copy(S, p, Length(S) - p + 1));
+ Strings.EndUpdate;
+end;
+
+function Split(const S: string; Separators: TCharSet;
+ IgnoreMultiSep: Boolean = True; MinCount: Integer = 0): TStrA;
+var
+ p, fin: Integer;
+
+ procedure Add(const S: string);
+ begin
+ if IgnoreMultiSep and (S = '') then
+ Exit;
+ SetLength(Result, Length(Result) + 1);
+ Result[High(Result)] := S;
+ end;
+
+begin
+ if S = '' then begin
+ if Length(Result) < MinCount then
+ SetLength(Result, MinCount);
+ Exit; end;
+
+ Result := nil;
+
+ p := 1;
+ fin := CharPos(Separators, S);
+ while fin > 0 do begin
+ Add(Copy(S, p, fin - p));
+ p := fin + 1;
+ fin := CharPos(Separators, S, p);
+ end;
+ Add(Copy(S, p, Length(S) - p + 1));
+
+ if Length(Result) < MinCount then
+ SetLength(Result, MinCount);
+end;
+
+procedure TileStr(const S: string; BrakeStart: Integer; BrakeEnd: Integer;
+ out Left, Right: string);
+begin
+ Left := Copy(S, 1, BrakeStart-1);
+ Right := Copy(S, BrakeEnd + 1, MaxInt);
+end;
+
+function Join(Strings: TStrings; Separator: string = ' '): string;
+var
+ i, imax: Integer;
+begin
+ Result := '';
+ imax := Strings.Count-1;
+ for i := 0 to imax do begin
+ Result := Result + Strings[i];
+ if i < imax then
+ Result := Result + Separator;
+ end;
+end;
+
+function Join(StrA: TStrA; Separator: string = ' '): string; overload;
+var
+ i: Integer;
+begin
+ Result := '';
+ for i := 0 to High(StrA) do begin
+ Result := Result + StrA[i];
+ if i < High(StrA) then
+ Result := Result + Separator;
+ end;
+end;
+
+function MulStr(const S: string; Count: Integer): string;
+var
+ P: PChar;
+ Len, i: Integer;
+begin
+ Result := '';
+ if Count = 0 then
+ Exit;
+
+ Len := Length(S);
+ SetLength(Result, Len * Count);
+
+ P := Pointer(Result);
+ for i := 1 to Count do begin
+ Move(Pointer(S)^, P^, Len);
+ Inc(P, Len);
+ end;
+end;
+
+function AlignR(const S: string; Width: Integer; Filler: Char = ' '): string;
+begin
+ Result := MulStr(Filler, Width - Length(S)) + S;
+end;
+
+function MaxStr(const S: string; MaxLen: Integer): string;
+var
+ Len: Integer;
+begin
+ Len := Length(S);
+ if Len <= MaxLen then begin
+ Result := S;
+ Exit end;
+
+ Result := Copy(S, 1, MaxLen - 3) + '...';
+end;
+
+function TrimAll(const S: string): string;
+var
+ i: Integer;
+begin
+ for i := 1 to Length(S) do
+ if S[i] > #32 then
+ Result := Result + S[i];
+end;
+
+function ControlChar(C: Char): Boolean;
+begin
+ Result := C in StrangeChars;
+end;
+
+function FriendlyChar(C: Char): Char;
+begin
+ case C of
+ #0: Result := '.';
+ #1..#31: Result := '?';
+ #255: Result := '#';
+ else
+ Result := C;
+ end;
+end;
+
+function FriendlyStr(const S: string): string;
+var
+ i: Integer;
+begin
+ SetLength(Result, Length(S));
+ for i := 1 to Length(S) do
+ Result[i] := FriendlyChar(S[i]);
+end;
+
+function FriendlyStr(a: TByteA): string;
+var
+ i: Integer;
+begin
+ SetLength(Result, Length(a));
+ for i := 0 to High(a) do
+ Result[i + 1] := FriendlyChar(Char(a[i]));
+end;
+
+function Quote(const S: string; Quoter: Char = '"'): string;
+begin
+ Result := S;
+
+ if FirstChar(S) <> Quoter then
+ Result := Quoter + Result;
+
+ if LastChar(S) <> Quoter then
+ Result := Result + Quoter;
+end;
+
+function DeQuote(const S: string): string;
+begin
+ Result := '';
+ if Length(S) > 2 then
+ Result := Copy(S, 2, Length(S) - 2);
+end;
+
+function UnQuote(const S: string): string;
+var
+ Start, Len: Integer;
+begin
+ Start := 1;
+ Len := Length(S);
+
+ if (S <> '') and (S[1] in ([#0..#32] + QuoteChars)) then begin
+ if (LastChar(S) = S[1]) then
+ Dec(Len);
+ Inc(Start);
+ end;
+
+ Result := Copy(S, Start, Len - Start + 1);
+end;
+
+function StrNumerus(const Value: Integer; const Singular, Plural: string;
+ const Zero: string = '0'): string;
+begin
+ if Abs(Value) = 1 then
+ Result := IntToStr(Value) + ' ' + Singular
+ else if Value = 0 then
+ Result := Zero + ' ' + Plural
+ else
+ Result := IntToStr(Value) + ' ' + Plural;
+end;
+
+function MakeStr(const Items: array of const; Separator: string = ''): string;
+const
+ BoolStrings: array[Boolean] of string = ('False', 'True');
+
+var
+ i: Integer;
+
+ function StrOfP(P: Pointer): string;
+ begin
+ if P = nil then
+ Result := '[nil]'
+ else
+ Result := '[' + IntToStr(Cardinal(P)) + ']';
+ end;
+
+ procedure Add(const S: string);
+ begin
+ Result := Result + s + Separator;
+ end;
+
+begin
+ Result := '';
+ for i := 0 to High(Items) do
+ with Items[i] do
+ case VType of
+ vtString: Add(VString^);
+ vtInteger: Add(IntToStr(VInteger));
+ vtBoolean: Add(BoolStrings[VBoolean]);
+ vtChar: Add(VChar);
+ vtPChar: Add(VPChar);
+ vtExtended: Add(FloatToStr(VExtended^));
+ vtObject: if VObject is TComponent then
+ Add(TComponent(VObject).Name)
+ else
+ Add(VObject.ClassName);
+ vtClass: Add(VClass.ClassName);
+ vtAnsiString: Add(string(VAnsiString));
+ vtCurrency: Add(CurrToStr(VCurrency^));
+ vtInt64: Add(IntToStr(VInt64^));
+ vtVariant: Add(string(VVariant^));
+
+ vtWideChar: Add(VWideChar);
+ vtPWideChar: Add(VPWideChar);
+ vtInterface: Add(StrOfP(VInterface));
+ vtPointer: Add(StrOfP(VPointer));
+ vtWideString: Add(WideString(VWideString));
+ end;
+ if Result <> '' then
+ SetLength(result, Length(Result) - Length(Separator));
+end;
+
+procedure ShowText(const Items: array of const; Separator: string = '');
+var
+ Text: string;
+begin
+ Text := MakeStr(Items, Separator);
+
+ MessageBox(0, PChar(Text), 'Info', MB_OK and MB_APPLMODAL);
+end;
+
+function DeleteChars(const S: string; C: Char): string;
+var
+ i: Integer;
+begin
+ Result := '';
+ for i := 1 to Length(S) do
+ if S[i] <> C then
+ Result := Result + S[i];
+end;
+
+function DeleteChars(const S: string; C: TCharSet): string;
+var
+ i: Integer;
+begin
+ Result := '';
+ for i := 1 to Length(S) do
+ if not (S[i] in C) then
+ Result := Result + S[i];
+end;
+
+function ExtractChars(const S: string; C: TCharSet): string;
+var
+ i: Integer;
+begin
+ Result := '';
+ for i := 1 to Length(S) do
+ if S[i] in C then
+ Result := Result + S[i];
+end;
+
+function CharCount(const S: string; C: Char): Integer;
+var
+ i: Integer;
+begin
+ Result := 0;
+ for i := 1 to Length(S) do
+ if S[i] = C then
+ Inc(Result);
+end;
+
+function StrAtPos(const S: string; Pos: Integer; const Str: string): Boolean;
+begin
+ Result := (Str <> '') and (Str = Copy(S, Pos, Length(Str)));
+end;
+
+function TextAtPos(const S: string; Pos: Integer; const Text: string): Boolean;
+begin
+ Result := (Text <> '') and SameText(Text, Copy(S, Pos, Length(Text)));
+end;
+
+function StrAtBegin(const S, Str: string): Boolean;
+begin
+ Result := StrAtPos(S, 1, Str);
+end;
+
+function TextAtBegin(const S, Text: string): Boolean;
+begin
+ Result := TextAtPos(S, 1, Text);
+end;
+
+function CharIn(const S: string; C: Char): Boolean;
+var
+ i: Integer;
+begin
+ Result := True;
+ for i := 1 to Length(S) do
+ if S[i] = C then Exit;
+ Result := False;
+end;
+
+function CharIn(const S: string; C: TCharSet): Boolean;
+var
+ i: Integer;
+begin
+ Result := False;
+ for i := 1 to Length(S) do begin
+ Result := S[i] in C;
+ if Result then
+ Exit;
+ end;
+end;
+
+function StrIn(const S, SubStr: string): Boolean;
+begin
+ Result := PosEx(SubStr, S) > 0;
+end;
+
+function StrIn(SL: TStrings; const S: string): Boolean;
+var
+ i: Integer;
+begin
+ Result := False;
+ for i := 0 to SL.Count-1 do begin
+ Result := (S = SL[i]);
+ if Result then
+ Exit;
+ end;
+end;
+
+function StrIn(A: TStrA; const S: string): Boolean;
+var
+ i: Integer;
+begin
+ Result := False;
+ for i := Low(A) to High(A) do begin
+ Result := (S = A[i]);
+ if Result then
+ Exit;
+ end;
+end;
+
+function TextIn(const S, Text: string): Boolean;
+begin
+ Result := PosExText(Text, S) > 0;
+end;
+
+function TextIn(SL: TStrings; const Text: string): Boolean;
+var
+ i: Integer;
+begin
+ Result := False;
+ for i := 0 to SL.Count-1 do begin
+ Result := SameText(Text, SL[i]);
+ if Result then
+ Exit;
+ end;
+end;
+
+function TextIn(A: TStrA; const Text: string): Boolean;
+var
+ i: Integer;
+begin
+ Result := False;
+ for i := Low(A) to High(A) do begin
+ Result := SameText(Text, A[i]);
+ if Result then
+ Exit;
+ end;
+end;
+
+function StrIndex(SL: TStrings; const S: string): Integer;
+begin
+ for Result := 0 to SL.Count-1 do
+ if S = SL[Result] then
+ Exit;
+ Result := -1;
+end;
+
+function StrIndex(A: TStrA; const S: string): Integer;
+begin
+ for Result := Low(A) to High(A) do
+ if S = A[Result] then
+ Exit;
+ Result := -1;
+end;
+
+function TextIndex(SL: TStrings; const Text: string): Integer;
+begin
+ for Result := 0 to SL.Count-1 do
+ if SameText(Text, SL[Result]) then
+ Exit;
+ Result := -1;
+end;
+
+function TextIndex(A: TStrA; const Text: string): Integer;
+begin
+ for Result := Low(A) to High(A) do
+ if SameText(Text, A[Result]) then
+ Exit;
+ Result := -1;
+end;
+
+function ReplaceChars(const S: string; Old, New: Char): string;
+var
+ i: Integer;
+begin
+ Result := S;
+ for i := 1 to Length(Result) do
+ if Result[i] = Old then
+ Result[i] := New;
+end;
+
+function ReplaceChars(const S: string; Old: TCharSet; New: Char): string;
+var
+ i: Integer;
+begin
+ Result := S;
+ for i := 1 to Length(Result) do
+ if Result[i] in Old then
+ Result[i] := New;
+end;
+
+function Replace(const S, Old, New: string): string;
+var
+ oldp, ps: Integer;
+begin
+ ps := 1;
+ Result := '';
+ while True do begin
+ oldp := ps;
+ ps := PosEx(Old, S, oldp);
+ if ps = 0 then begin
+ Result := Result + Copy(S, oldp, Length(S) - oldp + 1);
+ Exit; end;
+ Result := Result + Copy(S, oldp, ps - oldp) + New;
+ Inc(ps, Length(Old));
+ end;
+end;
+
+function SLOfFile(const FileName: string): TStringList;
+begin
+ Result := TStringList.Create;
+ if FileExists(FileName) then
+ Result.LoadFromFile(FileName);
+end;
+
+function ContainsEmptyLines(SL: TStrings): Boolean;
+begin
+ Result := StrIn(SL, '');
+end;
+
+procedure DeleteEmptyLines(SL: TStrings);
+var
+ i: Integer;
+begin
+ i := 0;
+ while i < SL.Count do begin
+ if SL[i] = '' then
+ SL.Delete(i)
+ else
+ Inc(i);
+ end;
+end;
+
+procedure DeleteCommentLines(SL: TStrings; const CommentSign: string = '//');
+var
+ i: Integer;
+begin
+ i := 0;
+ while i < SL.Count do begin
+ if (SL[i] = '') or (StrAtBegin(TrimLeft(SL[i]), CommentSign)) then
+ SL.Delete(i)
+ else
+ Inc(i);
+ end;
+end;
+
+function FindLine(SL: TStrings; const S: string): Integer;
+begin
+ for Result := 0 to SL.Count-1 do
+ if TextAtBegin(SL[Result], S) then
+ Exit;
+ Result := -1;
+end;
+
+procedure QuickSortSL(SL: TStringList);
+
+ procedure Sort(l, r: Integer);
+ var
+ i,j: Integer;
+ z,x: string;
+ begin
+ i := l;
+ j := r;
+ x := SL[(j + i) div 2];
+ repeat
+ while SL[i] < x do Inc(i);
+ while SL[j] > x do Dec(j);
+ if i <= j then begin
+ z := SL[i];
+ SL[i] := SL[j];
+ SL[j] := z;
+ Inc(i); Dec(j);
+ end;
+ until i > j;
+ if j > l then Sort(l, j);
+ if i < r then Sort(i, r);
+ end;
+
+begin
+ if SL.Count > 0 then
+ Sort(0, SL.Count-1);
+end;
+
+function IncStrA(StrA: TStrA): Integer;
+begin
+ SetLength(StrA, Length(StrA) + 1);
+ Result := High(StrA);
+end;
+
+function StrOfByteA(a: TByteA): string;
+begin
+ Result := string(Copy(a, 0, Length(a)));
+end;
+
+function ByteAOfStr(const S: string): TByteA;
+begin
+ Result := TByteA(Copy(S, 1, Length(s)));
+end;
+
+function ByteAOfInt(i: Integer): TByteA;
+begin
+ SetLength(Result, SizeOf(Integer));
+ Move(i, Pointer(Result)^, SizeOf(Integer));
+end;
+
+function IntOfByteA(A: TByteA): Integer;
+begin
+ Result := 0;
+ Move(Pointer(A)^, Result, Min(Length(A), SizeOf(Integer)));
+end;
+
+function ByteAOfHex(const Hex: string): TByteA;
+var
+ i: Integer;
+ h: string;
+begin
+ h := ExtractChars(Hex, HexadecimalChars);
+ SetLength(Result, Length(h) div 2);
+ for i := 0 to High(Result) do
+ Result[i] := ByteOfHex(Copy(h, (i shl 1) + 1, 2));
+end;
+
+function SizeOfFile(const FileName: string): Integer;
+var
+ F: file;
+begin
+ AssignFile(F, FileName);
+ {$I-}Reset(F, 1);{$I+}
+ if IOResult = 0 then begin
+ Result := FileSize(F);
+ CloseFile(F);
+ end else
+ Result := 0;
+end;
+
+function FileEx(const FileName: string; AllowFolders: Boolean = False): Boolean;
+var
+ FindData: TWin32FindData;
+begin
+ if FileName = '' then begin
+ Result := False;
+ Exit; end;
+
+ Result := (AllowFolders and DirectoryExists(FileName)) or
+ (FindFirstFile(PChar(FileName), FindData) <> INVALID_HANDLE_VALUE);
+ Result := Result and not CharIn(FileName, WildCards);
+ Result := Result and (AllowFolders
+ or ((FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY) = 0));
+end;
+
+function LWPSolve(const Dir: string): string;
+begin
+ if (Dir <> '') and (Dir[Length(Dir)] = '\') then begin
+ Result := Copy(Dir, 1, Length(Dir) - 1);
+ end else
+ Result := Dir;
+end;
+
+function LWPSlash(const Dir: string): string;
+begin
+ if (Dir <> '') and (Dir[Length(Dir)] = '\') then begin
+ Result := Copy(Dir, 1, Length(Dir));
+ end else
+ Result := Dir + '\';
+end;
+
+function ExtractDrive(const FileName: string): string;
+begin
+ Result := '';
+ if (Length(FileName) >= 2) and (FileName[2] = ':') then
+ Result := UpperCase(FileName[1] + ':\');
+end;
+
+function ExtractPath(const FileName: string): string;
+var
+ p: Integer;
+begin
+ p := CharPosR('\', FileName);
+ if P > 0 then
+ Result := Copy(FileName, 1, p)
+ else
+ Result := FileName;
+end;
+
+function ExtractPrefix(const FileName: string): string;
+begin
+ Result := UntilLastChar(ExtractFileName(FileName), '.');
+end;
+
+function ExtractSuffix(const FileName: string): string;
+begin
+ Result := FromLastChar(ExtractFileName(FileName), '.');
+end;
+
+function SameByteA(const A, B: TByteA): Boolean;
+begin
+ Result := (A = B) or ((Length(A) = Length(B)) and CompareMem(A, B, Length(A)));
+end;
+
+function Reverse(A: TByteA): TByteA;
+var
+ i: Integer;
+begin
+ SetLength(Result, Length(A));
+
+ for i := 0 to High(A) do
+ Result[High(Result) - i] := A[i];
+end;
+
+function Endian(i: Integer): Integer;
+type
+ EndianArray = packed array[0..3] of Byte;
+var
+ a, b: EndianArray;
+begin
+ a := EndianArray(i);
+ b[0] := a[3];
+ b[1] := a[2];
+ b[2] := a[1];
+ b[3] := a[0];
+ Result := Integer(b);
+end;
+
+function SaveByteA(Data: TByteA; const FileName: string;
+ Overwrite: Boolean = True): Boolean;
+var
+ F: file;
+begin
+ if FileExists(FileName) and not Overwrite then begin
+ Result := False;
+ Exit end;
+
+ AssignFile(F, FileName);
+ {$I-}Rewrite(F, 1);{$I+}
+ if IOResult = 0 then begin
+ if Length(Data) > 0 then
+ BlockWrite(F, Data[0], Length(Data));
+ CloseFile(F);
+ Result := True;
+ end else
+ Result := False;
+end;
+
+function LoadByteA(const FileName: string): TByteA;
+var
+ F: file;
+begin
+ AssignFile(F, FileName);
+ {$I-}Reset(F, 1);{$I+}
+ if IOResult = 0 then begin
+ SetLength(Result, FileSize(F));
+ if Length(Result) > 0 then
+ BlockRead(F, Result[0], FileSize(F));
+ CloseFile(F);
+ end else
+ SetLength(Result, 0);
+end;
+
+function IsValidFileName(const FileName: string): Boolean;
+begin
+ Result := (FileName <> '') and not CharIn(FileName, FileNameEnemies)
+ and CharIn(Trim(FileName), AllChars - ['.']);
+end;
+
+function MakeValidFileName(FileName: string; const Default: string = 'File'): string;
+begin
+ if FileName = '' then
+ FileName := Default;
+
+ if CharIn(FileName, FileNameEnemies) then
+ Result := ReplaceChars(FileName, FileNameEnemies, '_')
+ else if not CharIn(Trim(FileName), AllChars - ['.']) then
+ Result := Default
+ else
+ Result := FileName;
+end;
+
+function IsValidInteger(const S: string): Boolean;
+{const
+ LowInt = '2147483648';
+ HighInt = '2147483647';
+var
+ len, RealLen, i, o: Integer;
+ c: Char;
+begin
+ Result := False;
+ if S = '' then
+ Exit;
+
+ len := Length(S);
+ o := 1;
+
+ if S[1] = '-' then begin
+ if len = 1 then
+ Exit;
+ Inc(o);
+ while (o <= len) and (S[o] = '0') do
+ Inc(o);
+ if o > len then
+ Exit;
+ if o < len then begin
+ RealLen := len - o + 1;
+ if RealLen > Length(LowInt) then
+ Exit
+ else if RealLen = Length(LowInt) then begin
+ for i := 1 to Length(LowInt) do begin
+ c := S[i + o - 1];
+ if (c < '0') or (c > LowInt[i]) then
+ Exit;
+ if c in ['0'..Char((Byte(LowInt[i])-1))] then
+ Break;
+ end;
+ Inc(o, i);
+ end;
+ end;
+ end else begin
+ while (o <= len) and (S[o] = '0') do
+ Inc(o);
+ if o <= len then begin
+ RealLen := len - o + 1;
+ if RealLen > Length(HighInt) then
+ Exit
+ else if RealLen = Length(HighInt) then begin
+ for i := 1 to Length(HighInt) do begin
+ c := S[i + o - 1];
+ if (c < '0') or (c > HighInt[i]) then
+ Exit;
+ if c in ['0'..Char((Byte(HighInt[i])-1))] then
+ Break;
+ end;
+ Inc(o, i);
+ end;
+ end;
+ end;
+
+ for i := o to len do
+ if not (S[i] in ['0'..'9']) then
+ Exit;
+
+ Result := True; }
+var
+ i: Int64;
+begin
+ i := StrToInt64Def(S, High(Int64));
+ Result := (i >= Low(Integer)) and (i <= High(Integer));
+end;
+
+function IsValidCardinal(const S: string): Boolean;
+{const
+ HighCard = '4294967295';
+var
+ len, RealLen, i, o: Integer;
+begin
+ Result := False;
+ if S = '' then
+ Exit;
+
+ len := Length(S);
+ o := 1;
+
+ while (o <= len) and (S[o] = '0') do
+ Inc(o);
+ if o <= len then begin
+ RealLen := len - o + 1;
+ if RealLen > Length(HighCard) then
+ Exit
+ else if RealLen = Length(HighCard) then begin
+ for i := 1 to Length(HighCard) do begin
+ if S[i + o - 1] > HighCard[i] then
+ Exit;
+ if S[i + o - 1] in ['0'..Char((Byte(HighCard[i])-1))] then
+ Break;
+ end;
+ Inc(o, i);
+ end;
+ end;
+
+ for i := o to len do
+ if not (S[i] in ['0'..'9']) then
+ Exit;
+
+ Result := True; }
+var
+ i: Int64;
+begin
+ i := StrToInt64Def(S, -1);
+ Result := (i >= 0) and (i <= High(Cardinal));
+end;
+
+function StrOfBool(flag: Boolean; const TrueStr: string = 'True';
+ const FalseStr: string = 'False'): string;
+begin
+ if Flag then
+ Result := TrueStr
+ else
+ Result := FalseStr;
+end;
+
+function StrOfInt(i: Integer): string;
+begin
+{ if i = 0 then begin
+ Result := '0';
+ Exit end;
+
+ while i > 0 do begin
+ Result := Char(Byte('0') + (i mod 10)) + Result;
+ i := i div 10;
+ end;}
+ Result := IntToStr(i);
+end;
+
+function CardOfStr(const S: string): Cardinal;
+var
+ Res: Int64;
+begin
+ Res := StrToInt64Def(S, -1);
+ if Res > High(Cardinal) then
+ Res := High(Cardinal)
+ else if Res < 0 then
+ Res := 0;
+ Result := Cardinal(Res);
+end;
+
+function HexOrd(Hex: Char): THex;
+begin
+ case Hex of
+ '0'..'9':
+ Result := Byte(Hex) - 48;
+ 'A'..'F':
+ Result := Byte(Hex) - 55;
+ 'a'..'f':
+ Result := Byte(Hex) - 87;
+ else
+ Result := 0;
+ end;
+end;
+
+function ByteOfHex(Hex: THexByteStr): Byte;
+begin
+ Result := (HexOrd(Hex[1]) shl 4) + HexOrd(Hex[2]);
+end;
+
+function DecOfHex(const Hex: string): string;
+begin
+ Result := IntToStr(CardOfHex(Hex));
+end;
+
+function HexOfByte(b: Byte): THexByteStr;
+begin
+ Result := HexChar[(b and $F0) shr 4]
+ + HexChar[ b and $0F ];
+end;
+
+{function HexOfCard2(c: Cardinal): string;
+var
+ Data: array[0..(1 shl 4) - 1] of Char;
+ i: Integer;
+begin
+ for i := 0 to (1 shl 4) - 1 do
+ if i < 10 then
+ Data[i] := Char(Ord('0') + i)
+ else
+ Data[i] := Char(Ord('A') + i - 10);
+
+ Result := Data[(c and (((1 shl (1 shl 2)) - 1) shl (7 shl 2))) shr (7 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (6 shl 2))) shr (6 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (5 shl 2))) shr (5 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (4 shl 2))) shr (4 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (3 shl 2))) shr (3 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (2 shl 2))) shr (2 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (1 shl 2))) shr (1 shl 2)]
+ + Data[(c and (((1 shl (1 shl 2)) - 1) shl (0 shl 2))) shr (0 shl 2)];
+end; }
+
+function HexOfCard(i: Cardinal): string;
+var
+ a: Cardinal;
+begin
+ Result := '';
+ while i > 0 do begin
+ a := i and $F;
+ Result := HexChar[a] + Result;
+ i := i shr 4;
+ end;
+end;
+
+function HexOfCard(i: Cardinal; Digits: Integer): string;
+var
+ a: Cardinal;
+begin
+ Result := '';
+ while i > 0 do begin
+ a := i and $F;
+ Result := HexChar[a] + Result;
+ i := i shr 4;
+ end;
+ Result := MulStr('0', Digits - Length(Result)) + Result;
+end;
+
+function PascalHexArray(a: TByteA; Name: string): string;
+var
+ i, len: Integer;
+begin
+ Result := 'const' + EOL +
+ ' ' + Name + ': array[0..' + IntToStr(High(a)) + '] of Byte = (';
+
+ len := Length(a);
+ for i := 0 to len-1 do begin
+ if (i mod 19) = 0 then
+ Result := Result + EOL + ' ' + ' ';
+ Result := Result + '$' + HexOfByte(a[i]);
+ if i < len-1 then
+ Result := Result + ',';
+ end;
+ Result := Result + EOL + ' );';
+end;
+
+function HexOfByteA(a: TByteA; Blocks: Integer = 1;
+ const Splitter: string = ' '): string;
+var
+ i: Integer;
+begin
+ Result := '';
+
+ if Blocks > 0 then
+ for i := 0 to High(a) do begin
+ Result := Result + HexOfByte(a[i]);
+ if i < High(a) then
+ if ((i+1) mod Blocks) = 0 then
+ Result := Result + Splitter;
+ end
+ else
+ for i := 0 to High(a) do
+ Result := Result + HexOfByte(a[i]);
+end;
+
+function BinOfByteA(a: TByteA; Blocks: Integer = 4;
+ const Splitter: string = ' '): string;
+var
+ i, max: Integer;
+ Bit: Boolean;
+begin
+ Result := '';
+
+ if Blocks > 0 then begin
+ max := 8 * (High(a)) + 7;
+ for i := 0 to max do begin
+ Bit := 7-(i mod 8) in TBitSet(a[i div 8]);
+ Result := Result + Char(Byte('0') + Byte(Bit));
+ if i < max then
+ if ((i+1) mod Blocks) = 0 then
+ Result := Result + Splitter;
+ end;
+ end else
+ for i := 0 to High(a) do
+ Result := Result + Char(Byte('0') + a[i] shr (i and 8));
+end;
+
+function CardOfHex(Hex: string): Cardinal;
+var
+ i: Integer;
+begin
+ Result := 0;
+ Hex := Copy(ExtractChars(Hex, HexadecimalChars), 1, 8);
+
+ for i := 1 to Length(Hex) do
+ if Hex[i] <> '0' then
+ Inc(Result, HexOrd(Hex[i]) shl ((Length(Hex) - i) shl 2));
+end;
+
+function IntOfBin(Bin: string): Cardinal;
+var
+ i: Integer;
+begin
+ Result := 0;
+ Bin := Copy(ExtractChars(Bin, BinaryChars), 1, 32);
+
+ for i := Length(Bin) downto 1 do
+ if Bin[i] = '1' then
+ Inc(Result, 1 shl (Length(Bin) - i));
+end;
+
+function BinOfInt(n: Cardinal): string;
+var
+ a: Integer;
+begin
+ if n = 0 then begin
+ Result := '0';
+ exit; end;
+
+ Result := '';
+ while n > 0 do begin
+ a := n and 1;
+ Result := Char(a + Byte('0')) + Result;
+ n := n shr 1;
+ end;
+end;
+
+function BinOfIntFill(n: Cardinal; MinCount: Integer = 8): string;
+var
+ a: Integer;
+begin
+ if n = 0 then begin
+ Result := MulStr('0', MinCount);
+ Exit; end;
+
+ Result := '';
+ while n > 0 do begin
+ a := n and 1;
+ Result := Char(a + Byte('0')) + Result;
+ n := n shr 1;
+ end;
+ Result := MulStr('0', MinCount - Length(Result)) + Result;
+end;
+
+function BaseNOfInt(I: Cardinal; B: TBaseN): string;
+var
+ a: Integer;
+begin
+ if (B < 2) or (i = 0) then begin
+ Result := '0';
+ Exit; end;
+
+ Result := '';
+ while i > 0 do begin
+ a := i mod B;
+ Result := BaseNChar[a] + Result;
+ i := i div B;
+ end;
+end;
+
+function IntOfBaseN(V: string; B: TBaseN): Cardinal;
+var
+ i: Integer;
+ F: Cardinal;
+ c: Byte;
+begin
+ Result := 0;
+ V := TrimAll(V);
+ F := 1;
+ for i := Length(V) downto 1 do begin
+ c := Byte(UpCase(V[i]));
+ case Char(c) of
+ '0'..'9': c := c - 48;
+ 'A'..'Z': c := c - 55;
+ end;
+ if c < B then
+ Result := Result + Byte(c) * F;
+ F := F * B;
+ end;
+end;
+
+function KeepIn(i, Bottom, Top: Variant): Variant;
+begin
+ Result := i;
+ if Result > Top then
+ Result := Top
+ else if Result < Bottom then
+ Result := Bottom;
+end;
+
+function InRange(Value, Bottom, Top: Variant): Boolean;
+begin
+ Result := (Value >= Bottom) and (Value <= Top);
+end;
+
+function InStrictRange(Value, Bottom, Top: Variant): Boolean;
+begin
+ Result := (Value > Bottom) and (Value < Top);
+end;
+
+function Min(const A, B: Integer): Integer;
+begin
+ if A < B then
+ Result := A
+ else
+ Result := B;
+end;
+
+function Min(const A: TIntA): Integer;
+var
+ i: Integer;
+begin
+ Result := 0;
+ if Length(A) = 0 then
+ Exit;
+
+ Result := A[0];
+ for i := 1 to High(A) do
+ if A[i] < Result then
+ Result := A[i];
+end;
+
+function Max(const A, B: Integer): Integer;
+begin
+ if A > B then
+ Result := A
+ else
+ Result := B;
+end;
+
+function Max(const A: TIntA): Integer;
+var
+ i: Integer;
+begin
+ Result := 0;
+ if Length(A) = 0 then
+ Exit;
+
+ Result := A[0];
+ for i := 1 to High(A) do
+ if A[i] > Result then
+ Result := A[i];
+end;
+
+function RangesOfStr(const S: string): TRanges;
+var
+ SL: TStringList;
+ r, b, t: string;
+ i, p: Integer;
+
+ function TryStrToCard(const S: string; out Value: Cardinal): Boolean;
+ var
+ E: Integer;
+ begin
+ Val(S, Value, E);
+ Result := E = 0;
+ end;
+
+begin
+ Result := nil;
+ SL := TStringList.Create;
+ try
+ Split(S, RangesSeparator, SL);
+ SetLength(Result, SL.Count);
+ for i := 0 to SL.Count-1 do begin
+ r := SL[i];
+ with Result[i] do begin
+ p := CharPos(RangeInnerSeparator, r);
+ Simple := p = 0; // no '-' found
+ if Simple then begin
+ if r = RangeInfinite then begin // * --> *-*
+ Simple := False;
+ Bottom := Low(Bottom);
+ Top := High(Top);
+ end else if not TryStrToCard(r, Value) then
+ Break;
+
+ end else begin
+ TileStr(r, p, p, b, t);
+
+ if b = RangeInfinite then
+ Bottom := Low(Bottom)
+ else if not TryStrToCard(b, Bottom) then
+ Break;
+
+ if t = RangeInfinite then
+ Top := High(Top)
+ else if not TryStrToCard(t, Top) then
+ Break;
+ if Bottom > Top then begin
+ p := Bottom; Bottom := Top; Top := p;
+ end;
+ end;
+ end;
+ end;
+
+ if i <> SL.Count then
+ Result := nil;
+
+ finally
+ SL.Free;
+ end;
+end;
+
+function InRanges(Ranges: TRanges; TestValue: Cardinal): Boolean;
+var
+ i: Integer;
+begin
+ Result := True;
+
+ for i := 0 to High(Ranges) do
+ with Ranges[i] do
+ if Simple then begin
+ if TestValue = Value then
+ Exit;
+ end else begin
+ if InRange(TestValue, Bottom, Top) then
+ Exit;
+ end;
+
+ Result := False;
+end;
+
+procedure WriteSL(Strings: TStrings; const Prefix: string = '';
+ const Suffix: string = '');
+var
+ i: Integer;
+begin
+ for i := 0 to Strings.Count-1 do
+ WriteLn(Prefix + Strings[i] + Suffix);
+end;
+
+function Success(Res: Integer; ResultOnSuccess: Integer = ERROR_SUCCESS): Boolean;
+begin
+ Result := (Res = ResultOnSuccess);
+ LastSuccessRes := Res;
+end;
+
+function Failure(Res: Integer; ResultOnSuccess: Integer = ERROR_SUCCESS): Boolean;
+begin
+ Result := not Success(Res, ResultOnSuccess);
+end;
+
+function ExpandString(const S: string): string;
+var
+ Len: Integer;
+ P, Res: PChar;
+begin
+ Result := '';
+ P := PChar(S);
+ Len := ExpandEnvironmentStrings(P, nil, 0);
+ if Len = 0 then
+ Exit;
+
+ GetMem(Res, Len);
+ ExpandEnvironmentStrings(P, Res, Len);
+
+ Result := Res;
+ FreeMem(Res, Len);
+end;
+
+function FindAll(Strings: TStrings; const Mask: string;
+ ScanSubDirs: Boolean = True; Attributes: Integer = faFindEveryFile;
+ FileReturn: TFileNameFunc = nil): Boolean;
+var
+ Path, FileName: string;
+
+ procedure ScanDir(const Path, FileName: string);
+ var
+ PSR: TSearchRec;
+ Res: Integer;
+
+ procedure Add(const S: string);
+ begin
+ if S <> '' then
+ Strings.Add(S);
+ end;
+
+ begin
+ Res := FindFirst(Path + FileName, Attributes, PSR);
+ while Success(Res, 0) do begin
+ if Assigned(FileReturn) then
+ Add(FileReturn(Path + PSR.Name))
+ else
+ Add(Path + PSR.Name);
+ Res := FindNext(PSR);
+ end;
+ FindClose(PSR);
+ if not ScanSubDirs then
+ Exit;
+
+ Res := FindFirst(Path + '*', faDirectory, PSR);
+ while Success(Res, 0) do begin
+ if (PSR.Attr and faDirectory > 0)
+ and (PSR.Name <> '.') and (PSR.Name <> '..') then
+ ScanDir(Path + PSR.Name + '\', FileName);
+ Res := FindNext(PSR);
+ end;
+ FindClose(PSR);
+ end;
+
+begin
+ Strings.Clear;
+ Path := ExtractPath(Mask);
+ FileName := ExtractFileName(Mask);
+ ScanDir(Path, FileName);
+ Result := Strings.Count > 0;
+end;
+
+function FindAllFirst(const Mask: string; ScanSubDirs: Boolean = True;
+ Attributes: Integer = faFindEveryFile): string;
+var
+ Path, FileName: string;
+
+ function ScanDir(const Path, FileName: string): Boolean;
+ var
+ PSR: TSearchRec;
+ Res: Integer;
+ begin
+ Result := False;
+ if Success(FindFirst(Path + FileName, Attributes, PSR), 0) then begin
+ FindAllFirst := Path + PSR.Name;
+ Result := True;
+ FindClose(PSR);
+ Exit; end;
+ if not ScanSubDirs then
+ Exit;
+
+ Res := FindFirst(Path + '*', faDirectory, PSR);
+ while not Result and Success(Res, 0) do begin
+ if (PSR.Attr and faDirectory > 0)
+ and (PSR.Name <> '.') and (PSR.Name <> '..') then
+ Result := ScanDir(Path + PSR.Name + '\', FileName);
+ Res := FindNext(PSR);
+ end;
+ FindClose(PSR);
+ end;
+begin
+ Result := '';
+ Path := ExtractPath(Mask);
+ FileName := ExtractFileName(Mask);
+ ScanDir(Path, FileName);
+end;
+
+procedure DeleteFiles(const Mask: string; ScanSubDirs: Boolean = True;
+ Attributes: Integer = faFindEveryFile);
+var
+ Path, FileName: string;
+
+ procedure ScanDir(const Path, FileName: string);
+ var
+ PSR: TSearchRec;
+ Res: Integer;
+
+ procedure TryDeleteFile(const FileName: string);
+ begin
+ try
+ DeleteFile(Path + PSR.Name);
+ except
+ end;
+ end;
+
+ begin
+ Res := FindFirst(Path + FileName, Attributes, PSR);
+ while Success(Res, 0) do begin
+ TryDeleteFile(Path + PSR.Name);
+ Res := FindNext(PSR);
+ end;
+ FindClose(PSR);
+ if not ScanSubDirs then
+ Exit;
+
+ Res := FindFirst(Path + '*', faDirectory, PSR);
+ while Success(Res, 0) do begin
+ if (PSR.Attr and faDirectory > 0)
+ and (PSR.Name <> '.') and (PSR.Name <> '..') then begin
+ ScanDir(Path + PSR.Name + '\', FileName);
+ TryDeleteFile(Path + PSR.Name);
+ end;
+ Res := FindNext(PSR);
+ end;
+ FindClose(PSR);
+ end;
+begin
+ Path := ExtractPath(Mask);
+ FileName := ExtractFileName(Mask);
+ ScanDir(Path, FileName);
+end;
+
+function GetFileNew(FileName: string; NoFloppyDrives: Boolean = True): string;
+var
+ Drive: string;
+ pf, pd, Len: Integer;
+ PSR: TSearchRec;
+begin
+ Result := '';
+ FileName := Trim(FileName);
+ if Length(FileName) < 2 then
+ Exit;
+
+ Drive := ExtractDrive(FileName);
+ if not DirectoryExists(Drive) then
+ Exit;
+
+ if NoFloppyDrives and (Drive[1] in ['A', 'B']) then
+ Exit;
+
+ Len := Length(FileName);
+ Result := Drive;
+ pf := Length(Drive) + 1;
+ while pf <= Len do begin
+ if FileName[pf] = '\' then begin
+ Result := Result + '\';
+ Inc(pf);
+ Continue; end;
+
+ pd := CharPos('\', FileName, pf);
+ if pd = 0 then begin
+ if 0=FindFirst(Result + Copy(FileName, pf, MaxInt), faFindEveryFile, PSR) then begin
+ Result := Result + PSR.Name;
+ Break; end else begin
+ FindClose(PSR);
+ if 0=FindFirst(Result + Copy(FileName, pf, MaxInt), faDirectory, PSR) then
+ Result := Result + PSR.Name + '\'
+ else
+ Result := '';
+ FindClose(PSR);
+ if Result = '' then
+ Break;
+ end;
+ end;
+
+ if 0=FindFirst(Result + Copy(FileName, pf, pd - pf), faDirectory, PSR) then
+ Result := Result + PSR.Name + '\'
+ else
+ Result := '';
+ FindClose(PSR);
+ if Result = '' then
+ Break;
+
+ pf := pd + 1;
+ end;
+
+ if (Result <> '') and not FileEx(Result, True) then
+ Result := '';
+end;
+
+function DateTimeOfFileTime(const FileTime: TFileTime): TDateTime;
+var
+ LocalFileTime: TFileTime;
+ Res: Integer;
+begin
+ Result := 0;
+
+ FileTimeToLocalFileTime(FileTime, LocalFileTime);
+ if not FileTimeToDosDateTime(LocalFileTime, LongRec(Res).Hi,
+ LongRec(Res).Lo) then
+ Res := -1;
+
+ if (Res = -1) or (Res = 0) then
+ Exit;
+ try
+ Result := FileDateToDateTime(Res);
+ except
+ end;
+end;
+
+procedure FileNew(const FileName: string);
+var
+ Handle: Integer;
+begin
+ Handle := FileCreate(FileName);
+ FileClose(Handle);
+end;
+
+function Win32PlatformStr: string;
+const
+ PlatformStrings: array[VER_PLATFORM_WIN32s..VER_PLATFORM_WIN32_NT] of string =
+ ('VER_PLATFORM_WIN32s', 'VER_PLATFORM_WIN32_WINDOWS', 'VER_PLATFORM_WIN32_NT');
+begin
+ Result := PlatformStrings[Win32Platform];
+end;
+
+function FullOSInfo: string;
+begin
+ Result := Format(
+ 'Platform: %s' + EOL +
+ 'Version: %d.%d Build %d' + EOL +
+ 'CSD: %s',
+ [
+ Win32PlatformStr,
+ Win32MajorVersion, Win32MinorVersion, Win32BuildNumber,
+ Win32CSDVersion
+ ]
+ );
+end;
+
+function Win9x: Boolean;
+begin
+ Result := Win32Platform = VER_PLATFORM_WIN32_WINDOWS;
+end;
+
+function WinNT: Boolean;
+begin
+ Result := Win32Platform = VER_PLATFORM_WIN32_NT;
+end;
+
+function Win2000: Boolean;
+begin
+ Result := (Win32Platform = VER_PLATFORM_WIN32_NT)
+ and (Win32MajorVersion = 4);
+end;
+
+function WinXP: Boolean;
+begin
+ Result := Win32MajorVersion >= 5;
+end;
+
+initialization
+ MyDir := GetMyDir;
+
+end.
+
+unit FifoStream;
+
+interface
+
+uses Classes, windows, Dialogs;
+
+const
+ DefaultChunksize = 32768; // 32kb per chunk as default.
+
+type
+ PMemChunk = ^TMemChunk;
+ TMemChunk = record
+ Filled: Longword;
+ Read: Longword;
+ Data: pointer;
+ end;
+
+ TFifo = class
+ private
+ FBuffers: TList;
+ FChunksize: Longword;
+ FCritSect: TRTLCriticalSection;
+ FIsWinNT: boolean;
+ FBytesInFifo: LongWord;
+ protected
+ function GetBytesInFifo: LongWord;
+ public
+ constructor Create;
+ destructor Destroy; override;
+ procedure Write(Data: pointer; Size: LongWord);
+ procedure Read(Buff: pointer; var ReqSize: LongWord);
+ procedure PeekData(Buff: pointer; var ReqSize: LongWord);
+ published
+ property BytesInFifo: LongWord read FBytesInFifo;
+ end;
+
+implementation
+
+constructor TFifo.Create;
+begin
+ inherited;
+ FBuffers := TList.Create;
+ // set default chunksize...
+ FChunksize := DefaultChunksize;
+ InitializeCriticalSection(FCritSect);
+end;
+
+destructor TFifo.Destroy;
+var
+ I: Integer;
+begin
+ EnterCriticalSection(FCritSect);
+ for I := 0 to FBuffers.count - 1 do
+ begin
+ FreeMem(PMemChunk(Fbuffers[I]).Data);
+ Dispose(PMemChunk(Fbuffers[I]));
+ end;
+ FBuffers.Clear;
+ FBuffers.Free;
+ LeaveCriticalSection(FCritSect);
+
+ DeleteCriticalSection(FCritSect);
+ inherited;
+end;
+
+function TFifo.GetBytesInFifo: LongWord;
+begin
+ Result := 0;
+ if FBuffers.Count = 0 then
+ begin
+ exit;
+ end
+ else
+ begin
+ if FBuffers.Count > 1 then
+ Inc(Result, (FBuffers.Count - 1) * FChunkSize);
+ Inc(Result, PMemChunk(FBuffers[Fbuffers.Count - 1]).Filled);
+ Dec(Result, PMemChunk(FBuffers[0]).Read);
+ end;
+end;
+
+procedure TFifo.Write(Data: pointer; Size: LongWord);
+var
+ Privpointer: pointer;
+ PrivSize: LongWord;
+ Chunk: PMemChunk;
+ PosInChunk: pointer;
+begin
+ if LongWord(Data) = 0 then
+ begin
+ // null pointer? somebody is trying to fool us, get out...
+ Exit;
+ end;
+ EnterCriticalSection(FCritSect);
+ PrivPointer := Data;
+ PrivSize := 0;
+ // are already buffers there?
+ if FBuffers.count > 0 then
+ begin
+ // is the last one of them not completely filled?
+ if PMemChunk(FBuffers[FBuffers.count - 1]).filled < FChunksize then
+ // not completely filled, so fill up the buffer.
+ begin
+ Chunk := PMemChunk(FBuffers[FBuffers.count - 1]);
+ // fetch chunkdata.
+ PosInChunk := Chunk.Data;
+ // move to current fill pos...
+ Inc(LongWord(PosInChunk), Chunk.Filled);
+ // can we fill the chunk completely?
+ if Size > FChunksize - Chunk.Filled then
+ begin
+ // yes we can.
+ Move(PrivPointer^, PosInChunk^, FChunksize - Chunk.Filled);
+ Inc(PrivSize, FChunksize - Chunk.Filled);
+ Inc(LongWord(PrivPointer), FChunksize - Chunk.Filled);
+ Chunk.Filled := FChunkSize;
+ end
+ else
+ // we have to less data for filling the chunk completely,
+ // just put everything in.
+ begin
+ Move(PrivPointer^, PosInChunk^, Size);
+ Inc(PrivSize, Size);
+ Inc(Chunk.Filled, Size);
+ end;
+ end;
+ end;
+ // as long as we have remaining stuff put it into new chunks.
+ while (PrivSize < Size) do
+ begin
+ new(Chunk);
+ GetMem(Chunk.Data, FChunksize);
+ Chunk.Read := 0;
+ // can we fill an entire chunk with the remaining data?
+ if Privsize + FChunksize < Size then
+ begin
+ // yes we can, so put the stuff in.
+ Move(Privpointer^, Chunk.Data^, FChunksize);
+ Inc(LongWord(PrivPointer), FChunksize);
+ Inc(PrivSize, FChunksize);
+ Chunk.Filled := FChunksize;
+ end
+ else // we have to less data to fill the entire chunk, just put the remaining stuff in.
+ begin
+ Move(Privpointer^, Chunk.Data^, Size - Privsize);
+ Chunk.Filled := Size - Privsize;
+ Inc(PrivSize, Size - Privsize);
+ end;
+ Fbuffers.Add(Chunk);
+ end;
+ if Size <> Privsize then
+ Showmessage('miscalculation in TFifo.write');
+ FBytesInFifo := GetBytesInFifo;
+ LeaveCriticalSection(FCritSect);
+end;
+
+procedure TFifo.Read(Buff: pointer; var ReqSize: LongWord);
+var
+ PrivSize: Integer;
+ Privpos: pointer;
+ Chunk: PMemChunk;
+ ChunkPos: pointer;
+begin
+ if LongWord(Buff) = 0 then
+ begin
+ // null pointer? somebody is trying to fool us, get out...
+ Exit;
+ end;
+ EnterCriticalSection(FCritSect);
+ PrivSize := 0;
+ Privpos := Buff;
+ while FBuffers.Count > 0 do
+ begin
+ Chunk := PMemChunk(FBuffers[0]);
+ ChunkPos := Chunk.data;
+ Inc(LongWord(ChunkPos), Chunk.Read);
+ // does the remaining part of the chunk fit into the buffer?
+ if PrivSize + (Chunk.Filled - Chunk.read) < ReqSize then
+ begin // yep, it fits
+ Move(ChunkPos^, Privpos^, Chunk.Filled - Chunk.read);
+ Inc(PrivSize, Chunk.Filled - Chunk.read);
+ FreeMem(Chunk.Data);
+ Dispose(Chunk);
+ FBuffers.Delete(0);
+ end
+ else // remaining part didn't fit, get as much as we can and increment the
+ // read attribute.
+ begin
+ Move(ChunkPos^, Privpos^, ReqSize - PrivSize);
+ Inc(Chunk.read, ReqSize - PrivSize);
+ Inc(PrivSize, ReqSize - PrivSize);
+ // as we filled the buffer, we'll have to break here.
+ break;
+ end;
+ end;
+ FBytesInFifo := GetBytesInFifo;
+ LeaveCriticalSection(FCritSect);
+ ReqSize := PrivSize;
+end;
+
+// read Data from Stream without removing it from the Stream...
+
+procedure TFifo.PeekData(Buff: pointer; var ReqSize: LongWord);
+var
+ PrivSize: Integer;
+ Privpos: pointer;
+ Chunk: PMemChunk;
+ ChunkPos: pointer;
+ ChunkNr: Integer;
+begin
+ if LongWord(Buff) = 0 then
+ begin
+ // null pointer? somebody is trying to fool us, get out...
+ Exit;
+ end;
+ EnterCriticalSection(FCritSect);
+ PrivSize := 0;
+ Privpos := Buff;
+ ChunkNr := 0;
+ while FBuffers.Count > ChunkNr do
+ begin
+ Chunk := PMemChunk(FBuffers[ChunkNr]);
+ ChunkPos := Chunk.data;
+ Inc(LongWord(ChunkPos), Chunk.Read);
+ // does the remaining part of the chunk fit into the buffer?
+ if PrivSize + (Chunk.Filled - Chunk.read) < ReqSize then
+ begin // yep, it fits
+ Move(ChunkPos^, Privpos^, Chunk.Filled - Chunk.read);
+ Inc(PrivSize, Chunk.Filled - Chunk.read);
+ Inc(ChunkNr);
+ end
+ else // remaining part didn't fit, get as much as we can and increment the
+ // read attribute.
+ begin
+ Move(ChunkPos^, Privpos^, ReqSize - PrivSize);
+ Inc(PrivSize, ReqSize - PrivSize);
+ // as we filled the buffer, we'll have to break here.
+ break;
+ end;
+ end;
+ LeaveCriticalSection(FCritSect);
+ ReqSize := PrivSize;
+end;
+
+end.
diff --git a/test/delphi/ytools.out.raydebug b/test/delphi/ytools.out.raydebug new file mode 100644 index 0000000..f1621fd --- /dev/null +++ b/test/delphi/ytools.out.raydebug @@ -0,0 +1,2708 @@ +comment(// vim:ft=pascal) + +reserved(unit) ident(YTools)operator(;) + +comment({=============================================================================== + + cYcnus.YTools 1.0.3 Beta for Delphi 4+ + by licenser and Murphy + + ©2000-2003 by cYcnus + visit www.cYcnus.de + + licenser@cYcnus.de (Heinz N. Gies\) + murphy@cYcnus.de (Kornelius Kalnbach\) + + this unit is published under the terms of the GPL + +===============================================================================}) + +reserved(interface) + +reserved(uses) + ident(Windows)operator(,) ident(SysUtils)operator(,) ident(Classes)operator(,) ident(YTypes)operator(;) + +reserved(const) + ident(BackSpace) operator(=) char(#8)operator(;) + ident(Tab) operator(=) char(#9)operator(;) + ident(LF) operator(=) char(#10)operator(;) comment(//Line Feed) + ident(CR) operator(=) char(#13)operator(;) comment(//Carriage Return) + ident(Space) operator(=) char(#32)operator(;) + ident(EOLChars) operator(=) operator([)ident(CR)operator(,) ident(LF)operator(];) +preprocessor({$IFNDEF VER140}) + ident(sLineBreak) operator(=) char(#13)char(#10)operator(;) + ident(SwitchChars) operator(=) operator([)char<delimiter(')content(/)delimiter(')>operator(,) char<delimiter(')content(-)delimiter(')>operator(];) +preprocessor({$ENDIF}) + ident(EOL) operator(=) ident(sLineBreak)operator(;) + ident(MaxCard) operator(=) ident(High)operator(()ident(Cardinal)operator(\);) + ident(AllChars) operator(=) operator([)char(#0)operator(..)char(#255)operator(];) + ident(Alphabetical) operator(=) operator([)char<delimiter(')content(A)delimiter(')>operator(..)char<delimiter(')content(Z)delimiter(')>operator(,) char<delimiter(')content(a)delimiter(')>operator(..)char<delimiter(')content(z)delimiter(')>operator(];) + ident(DecimalChars) operator(=) operator([)char<delimiter(')content(0)delimiter(')>operator(..)char<delimiter(')content(9)delimiter(')>operator(];) + ident(AlphaNumerical) operator(=) ident(Alphabetical) operator(+) ident(DecimalChars)operator(;) + ident(StrangeChars) operator(=) operator([)char(#0)operator(..)char(#31)operator(,) char(#127)operator(,) char(#129)operator(,) char(#141)operator(..)char(#144)operator(,) char(#157)operator(,) char(#158)operator(];) + + ident(HexadecimalChars) operator(=) ident(DecimalChars) operator(+) operator([)char<delimiter(')content(A)delimiter(')>operator(..)char<delimiter(')content(F)delimiter(')>operator(,) char<delimiter(')content(a)delimiter(')>operator(..)char<delimiter(')content(f)delimiter(')>operator(];) + ident(OctalChars) operator(=) operator([)char<delimiter(')content(0)delimiter(')>operator(..)char<delimiter(')content(7)delimiter(')>operator(];) + ident(BinaryChars) operator(=) operator([)char<delimiter(')content(0)delimiter(')>operator(,) char<delimiter(')content(1)delimiter(')>operator(];) + + ident(QuoteChars) operator(=) operator([)char<delimiter(')content('')delimiter(')>operator(,) char<delimiter(')content(")delimiter(')>operator(];) + ident(WildCards) operator(=) operator([)char<delimiter(')content(*)delimiter(')>operator(,) char<delimiter(')content(?)delimiter(')>operator(];) + ident(FileNameEnemies) operator(=) ident(WildCards) operator(+) operator([)char<delimiter(')content(\\)delimiter(')>operator(,) char<delimiter(')content(/)delimiter(')>operator(,) char<delimiter(')content(:)delimiter(')>operator(,) char<delimiter(')content(<)delimiter(')>operator(,) char<delimiter(')content(>)delimiter(')>operator(,) char<delimiter(')content(|)delimiter(')>operator(];) + + ident(HexChar)operator(:) reserved(array)operator([)ident(THex)operator(]) reserved(of) ident(Char) operator(=) operator(() + char<delimiter(')content(0)delimiter(')>operator(,)char<delimiter(')content(1)delimiter(')>operator(,)char<delimiter(')content(2)delimiter(')>operator(,)char<delimiter(')content(3)delimiter(')>operator(,)char<delimiter(')content(4)delimiter(')>operator(,)char<delimiter(')content(5)delimiter(')>operator(,)char<delimiter(')content(6)delimiter(')>operator(,)char<delimiter(')content(7)delimiter(')>operator(,)char<delimiter(')content(8)delimiter(')>operator(,)char<delimiter(')content(9)delimiter(')>operator(,)char<delimiter(')content(A)delimiter(')>operator(,)char<delimiter(')content(B)delimiter(')>operator(,)char<delimiter(')content(C)delimiter(')>operator(,)char<delimiter(')content(D)delimiter(')>operator(,)char<delimiter(')content(E)delimiter(')>operator(,)char<delimiter(')content(F)delimiter(')>operator(\);) + ident(LowerHexChar)operator(:) reserved(array)operator([)ident(THex)operator(]) reserved(of) ident(Char) operator(=) operator(() + char<delimiter(')content(0)delimiter(')>operator(,)char<delimiter(')content(1)delimiter(')>operator(,)char<delimiter(')content(2)delimiter(')>operator(,)char<delimiter(')content(3)delimiter(')>operator(,)char<delimiter(')content(4)delimiter(')>operator(,)char<delimiter(')content(5)delimiter(')>operator(,)char<delimiter(')content(6)delimiter(')>operator(,)char<delimiter(')content(7)delimiter(')>operator(,)char<delimiter(')content(8)delimiter(')>operator(,)char<delimiter(')content(9)delimiter(')>operator(,)char<delimiter(')content(a)delimiter(')>operator(,)char<delimiter(')content(b)delimiter(')>operator(,)char<delimiter(')content(c)delimiter(')>operator(,)char<delimiter(')content(d)delimiter(')>operator(,)char<delimiter(')content(e)delimiter(')>operator(,)char<delimiter(')content(f)delimiter(')>operator(\);) + ident(BaseNChar)operator(:) reserved(array)operator([)ident(TBaseN)operator(]) reserved(of) ident(Char) operator(=) operator(() + char<delimiter(')content(0)delimiter(')>operator(,)char<delimiter(')content(1)delimiter(')>operator(,)char<delimiter(')content(2)delimiter(')>operator(,)char<delimiter(')content(3)delimiter(')>operator(,)char<delimiter(')content(4)delimiter(')>operator(,)char<delimiter(')content(5)delimiter(')>operator(,)char<delimiter(')content(6)delimiter(')>operator(,)char<delimiter(')content(7)delimiter(')>operator(,)char<delimiter(')content(8)delimiter(')>operator(,)char<delimiter(')content(9)delimiter(')>operator(,)char<delimiter(')content(A)delimiter(')>operator(,)char<delimiter(')content(B)delimiter(')>operator(,)char<delimiter(')content(C)delimiter(')>operator(,)char<delimiter(')content(D)delimiter(')>operator(,)char<delimiter(')content(E)delimiter(')>operator(,)char<delimiter(')content(F)delimiter(')>operator(,)char<delimiter(')content(G)delimiter(')>operator(,)char<delimiter(')content(H)delimiter(')>operator(,) + char<delimiter(')content(I)delimiter(')>operator(,)char<delimiter(')content(J)delimiter(')>operator(,)char<delimiter(')content(K)delimiter(')>operator(,)char<delimiter(')content(L)delimiter(')>operator(,)char<delimiter(')content(M)delimiter(')>operator(,)char<delimiter(')content(N)delimiter(')>operator(,)char<delimiter(')content(O)delimiter(')>operator(,)char<delimiter(')content(P)delimiter(')>operator(,)char<delimiter(')content(Q)delimiter(')>operator(,)char<delimiter(')content(R)delimiter(')>operator(,)char<delimiter(')content(S)delimiter(')>operator(,)char<delimiter(')content(T)delimiter(')>operator(,)char<delimiter(')content(U)delimiter(')>operator(,)char<delimiter(')content(V)delimiter(')>operator(,)char<delimiter(')content(W)delimiter(')>operator(,)char<delimiter(')content(X)delimiter(')>operator(,)char<delimiter(')content(Y)delimiter(')>operator(,)char<delimiter(')content(Z)delimiter(')>operator(\);) + + ident(cYcnusOverlayColor) operator(=) hex($050001)operator(;) + + ident(faFindEveryFile) operator(=) ident(faReadOnly) operator(+) ident(faHidden) operator(+) ident(faSysFile) operator(+) ident(faArchive)operator(;) + + ident(platWin9x) operator(=) operator([)ident(VER_PLATFORM_WIN32s)operator(,) ident(VER_PLATFORM_WIN32_WINDOWS)operator(];) + + +comment({ Debugging }) +reserved(procedure) ident(ClearReport)operator(()reserved(const) ident(ReportName)operator(:) reserved(string)operator(\);) +reserved(procedure) ident(Report)operator(()reserved(const) ident(ReportName)operator(,) ident(Text)operator(:) reserved(string)operator(\);) +reserved(procedure) ident(ReportFmt)operator(()reserved(const) ident(ReportName)operator(,) ident(Fmt)operator(:) reserved(string)operator(;) reserved(const) ident(Args)operator(:) reserved(array) reserved(of) reserved(const)operator(\);) + +comment({ Params }) +reserved(procedure) ident(GetParams)operator(()ident(Strings)operator(:) ident(TStrings)operator(\);) directive(overload)operator(;) +reserved(function) ident(GetParams)operator(()reserved(const) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) directive(overload)operator(;) + +reserved(function) ident(ParamNum)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(function) ident(ParamPrefixNum)operator(()reserved(const) ident(Prefix)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(function) ident(Param)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(ParamPrefix)operator(()reserved(const) ident(Prefix)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + +reserved(function) ident(Switch)operator(()reserved(const) ident(Switch)operator(:) reserved(string)operator(;) reserved(const) ident(PrefixChars)operator(:) ident(TCharSet) operator(=) ident(SwitchChars)operator(;) + ident(IgnoreCase)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(GetParam)operator(()reserved(const) ident(Prefix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) reserved(const) ident(Default)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\):) reserved(string)operator(;) + +comment({ Dirs & UserName}) +reserved(function) ident(GetMyDir)operator(()ident(FullPath)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) +reserved(function) ident(WinDir)operator(:) reserved(string)operator(;) +reserved(function) ident(SysDir)operator(:) reserved(string)operator(;) +reserved(function) ident(UserName)operator(:) reserved(string)operator(;) + +comment({ Strings & Chars}) +reserved(function) ident(FirstChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Char)operator(;) +reserved(function) ident(LastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Char)operator(;) + +reserved(function) ident(CharPos)operator(()ident(C)operator(:) ident(Char)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(CharPos)operator(()ident(C)operator(:) ident(TCharSet)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(CharPosR)operator(()ident(C)operator(:) ident(Char)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) operator(-)integer(1)operator(\):) ident(Integer)operator(;) +reserved(function) ident(PosEx)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(function) ident(PosExText)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(function) ident(PosExAnsiText)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) + +reserved(function) ident(UntilChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(UntilChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(UntilLastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(;) + ident(IgnoreNoBrake)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) reserved(string)operator(;) + +reserved(function) ident(FromChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(FromChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(FromLastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(;) + ident(IgnoreNoBrake)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) + +reserved(function) ident(BetweenChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Start)operator(,) ident(Finish)operator(:) ident(Char)operator(;) + ident(Inclusive)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) + +reserved(function) ident(UntilStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(FromStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(StringWrap)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Width)operator(:) ident(Integer)operator(;) reserved(const) ident(LineEnd)operator(:) reserved(string) operator(=) ident(EOL)operator(\):) reserved(string)operator(;) + +comment({ Splitting & Combining }) +reserved(function) ident(Split)operator(()reserved(const) ident(S)operator(,) ident(Separator)operator(:) reserved(string)operator(;) ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(MinCount)operator(:) ident(Integer) operator(=) integer(0)operator(\):) ident(TStrA)operator(;) directive(overload)operator(;) +reserved(procedure) ident(Split)operator(()reserved(const) ident(S)operator(,) ident(Separator)operator(:) reserved(string)operator(;) ident(Strings)operator(:) ident(TStrings)operator(;) + ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(\);) directive(overload)operator(;) +reserved(function) ident(Split)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Separators)operator(:) ident(TCharSet)operator(;) + ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(MinCount)operator(:) ident(Integer) operator(=) integer(0)operator(\):) ident(TStrA)operator(;) directive(overload)operator(;) + +reserved(procedure) ident(TileStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(BrakeStart)operator(:) ident(Integer)operator(;) ident(BrakeEnd)operator(:) ident(Integer)operator(;) + reserved(out) ident(Left)operator(,) ident(Right)operator(:) reserved(string)operator(\);) + +reserved(function) ident(Join)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(Join)operator(()ident(StrA)operator(:) ident(TStrA)operator(;) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) directive(overload)operator(;) + +reserved(function) ident(MulStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Count)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) + +comment({ Strings ausrichten }) +reserved(function) ident(AlignR)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Width)operator(:) ident(Integer)operator(;) ident(Filler)operator(:) ident(Char) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(function) ident(MaxStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(MaxLen)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) + +comment({ Stringing }) +reserved(function) ident(TrimAll)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(ControlChar)operator(()ident(C)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(FriendlyChar)operator(()ident(C)operator(:) ident(Char)operator(\):) ident(Char)operator(;) + +reserved(function) ident(FriendlyStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(FriendlyStr)operator(()ident(a)operator(:) ident(TByteA)operator(\):) reserved(string)operator(;) directive(overload)operator(;) + +reserved(function) ident(Quote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Quoter)operator(:) ident(Char) operator(=) char<delimiter(')content(")delimiter(')>operator(\):) reserved(string)operator(;) +reserved(function) ident(UnQuote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(DeQuote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(StrNumerus)operator(()reserved(const) ident(Value)operator(:) ident(Integer)operator(;) reserved(const) ident(Singular)operator(,) ident(Plural)operator(:) reserved(string)operator(;) + reserved(const) ident(Zero)operator(:) reserved(string) operator(=) char<delimiter(')content(0)delimiter(')>operator(\):) reserved(string)operator(;) + +reserved(function) ident(MakeStr)operator(()reserved(const) ident(Items)operator(:) reserved(array) reserved(of) reserved(const)operator(;) ident(Separator)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\):) reserved(string)operator(;) +reserved(procedure) ident(ShowText)operator(()reserved(const) ident(Items)operator(:) reserved(array) reserved(of) reserved(const)operator(;) ident(Separator)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) + +comment({ Delete }) +reserved(function) ident(DeleteChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(DeleteChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(ExtractChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) + +comment({ Find }) +reserved(function) ident(CharCount)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) ident(Integer)operator(;) + +reserved(function) ident(CharIn)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(CharIn)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) + +reserved(function) ident(StrAtPos)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Pos)operator(:) ident(Integer)operator(;) reserved(const) ident(Str)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(StrAtBegin)operator(()reserved(const) ident(S)operator(,) ident(Str)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(StrIn)operator(()reserved(const) ident(S)operator(,) ident(SubStr)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(StrIn)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(StrIn)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(StrIndex)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(StrIndex)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) + +reserved(function) ident(TextAtPos)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Pos)operator(:) ident(Integer)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(TextAtBegin)operator(()reserved(const) ident(S)operator(,) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(TextIn)operator(()reserved(const) ident(S)operator(,) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(TextIn)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(TextIn)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) directive(overload)operator(;) +reserved(function) ident(TextIndex)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(TextIndex)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) + +comment({ Replace }) +reserved(function) ident(ReplaceChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Old)operator(,) ident(New)operator(:) ident(Char)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(ReplaceChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Old)operator(:) ident(TCharSet)operator(;) ident(New)operator(:) ident(Char)operator(\):) reserved(string)operator(;) directive(overload)operator(;) + +reserved(function) ident(Replace)operator(()reserved(const) ident(S)operator(,) ident(Old)operator(,) ident(New)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +comment({ TStrings }) +reserved(function) ident(SLOfFile)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(TStringList)operator(;) +reserved(function) ident(ContainsEmptyLines)operator(()ident(SL)operator(:) ident(TStrings)operator(\):) ident(Boolean)operator(;) +reserved(procedure) ident(DeleteEmptyLines)operator(()ident(SL)operator(:) ident(TStrings)operator(\);) +reserved(procedure) ident(DeleteCommentLines)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(CommentSign)operator(:) reserved(string) operator(=) string<delimiter(')content(//)delimiter(')>operator(\);) +reserved(procedure) ident(WriteSL)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) reserved(const) ident(Prefix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + reserved(const) ident(Suffix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) + +reserved(function) ident(FindLine)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) + +reserved(procedure) ident(QuickSortSL)operator(()ident(SL)operator(:) ident(TStringList)operator(\);) + +comment({ TStrA }) +reserved(function) ident(IncStrA)operator(()ident(StrA)operator(:) ident(TStrA)operator(\):) ident(Integer)operator(;) + +comment({ TByteA }) +reserved(function) ident(StrOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(\):) reserved(string)operator(;) +reserved(function) ident(ByteAOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) +reserved(function) ident(ByteAOfInt)operator(()ident(i)operator(:) ident(Integer)operator(\):) ident(TByteA)operator(;) +reserved(function) ident(IntOfByteA)operator(()ident(A)operator(:) ident(TByteA)operator(\):) ident(Integer)operator(;) +reserved(function) ident(ByteAOfHex)operator(()reserved(const) ident(Hex)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) + +reserved(function) ident(SameByteA)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(TByteA)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(Reverse)operator(()ident(a)operator(:) ident(TByteA)operator(\):) ident(TByteA)operator(;) +reserved(function) ident(SaveByteA)operator(()ident(Data)operator(:) ident(TByteA)operator(;) reserved(const) ident(FileName)operator(:) reserved(string)operator(;) ident(Overwrite)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(LoadByteA)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) + +reserved(function) ident(Endian)operator(()ident(i)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) + +comment({ Files }) +reserved(function) ident(SizeOfFile)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(function) ident(FileEx)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(;) ident(AllowFolders)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(LWPSolve)operator(()reserved(const) ident(Dir)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(LWPSlash)operator(()reserved(const) ident(Dir)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(ExtractDrive)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(ExtractPath)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(ExtractPrefix)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(ExtractSuffix)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(IsValidFileName)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(MakeValidFileName)operator(()ident(FileName)operator(:) reserved(string)operator(;) reserved(const) ident(Default)operator(:) reserved(string) operator(=) string<delimiter(')content(File)delimiter(')>operator(\):) reserved(string)operator(;) + +comment({ Converting }) +reserved(function) ident(IsValidInteger)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(IsValidCardinal)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + +reserved(function) ident(StrOfBool)operator(()ident(flag)operator(:) ident(Boolean)operator(;) reserved(const) ident(TrueStr)operator(:) reserved(string) operator(=) string<delimiter(')content(True)delimiter(')>operator(;) + reserved(const) ident(FalseStr)operator(:) reserved(string) operator(=) string<delimiter(')content(False)delimiter(')>operator(\):) reserved(string)operator(;) +reserved(function) ident(StrOfInt)operator(()ident(i)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) +reserved(function) ident(CardOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) + +reserved(function) ident(HexOrd)operator(()ident(Hex)operator(:) ident(Char)operator(\):) ident(THex)operator(;) +reserved(function) ident(ByteOfHex)operator(()ident(Hex)operator(:) ident(THexByteStr)operator(\):) ident(Byte)operator(;) + +reserved(function) ident(DecOfHex)operator(()reserved(const) ident(Hex)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(function) ident(HexOfByte)operator(()ident(b)operator(:) ident(Byte)operator(\):) ident(THexByteStr)operator(;) +reserved(function) ident(HexOfCard)operator(()ident(i)operator(:) ident(Cardinal)operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(function) ident(HexOfCard)operator(()ident(i)operator(:) ident(Cardinal)operator(;) ident(Digits)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) directive(overload)operator(;) + +reserved(function) ident(PascalHexArray)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Name)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +reserved(function) ident(HexOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Blocks)operator(:) ident(Integer) operator(=) integer(1)operator(;) + reserved(const) ident(Splitter)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(function) ident(BinOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Blocks)operator(:) ident(Integer) operator(=) integer(4)operator(;) + reserved(const) ident(Splitter)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) + +reserved(function) ident(CardOfHex)operator(()ident(Hex)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) +reserved(function) ident(IntOfBin)operator(()ident(Bin)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) + +reserved(function) ident(BinOfIntFill)operator(()ident(n)operator(:) ident(cardinal)operator(;) ident(MinCount)operator(:) ident(Integer) operator(=) integer(8)operator(\):) reserved(string)operator(;) +reserved(function) ident(BinOfInt)operator(()ident(n)operator(:) ident(cardinal)operator(\):) reserved(string)operator(;) + +reserved(function) ident(BaseNOfInt)operator(()ident(I)operator(:) ident(Cardinal)operator(;) ident(B)operator(:) ident(TBaseN)operator(\):) reserved(string)operator(;) +reserved(function) ident(IntOfBaseN)operator(()ident(V)operator(:) reserved(string)operator(;) ident(B)operator(:) ident(TBaseN)operator(\):) ident(Cardinal)operator(;) + +comment({ Ranges }) +reserved(function) ident(KeepIn)operator(()ident(i)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Variant)operator(;) +reserved(function) ident(InRange)operator(()ident(Value)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(InStrictRange)operator(()ident(Value)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(Min)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(Min)operator(()reserved(const) ident(A)operator(:) ident(TIntA)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(Max)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) +reserved(function) ident(Max)operator(()reserved(const) ident(A)operator(:) ident(TIntA)operator(\):) ident(Integer)operator(;) directive(overload)operator(;) + +reserved(const) + ident(RangesSeparator) operator(=) char<delimiter(')content(,)delimiter(')>operator(;) + ident(RangeInnerSeparator) operator(=) char<delimiter(')content(-)delimiter(')>operator(;) + ident(RangeInfinite) operator(=) char<delimiter(')content(*)delimiter(')>operator(;) + ident(RangeSpecialChars) operator(=) operator([)ident(RangesSeparator)operator(,) ident(RangeInnerSeparator)operator(,) ident(RangeInfinite)operator(];) + +reserved(function) ident(RangesOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(TRanges)operator(;) +reserved(function) ident(InRanges)operator(()ident(Ranges)operator(:) ident(TRanges)operator(;) ident(TestValue)operator(:) ident(Cardinal)operator(\):) ident(Boolean)operator(;) + +reserved(function) ident(Success)operator(()ident(Res)operator(:) ident(Integer)operator(;) ident(ResultOnSuccess)operator(:) ident(Integer) operator(=) ident(ERROR_SUCCESS)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(Failure)operator(()ident(Res)operator(:) ident(Integer)operator(;) ident(ResultOnSuccess)operator(:) ident(Integer) operator(=) ident(ERROR_SUCCESS)operator(\):) ident(Boolean)operator(;) + +reserved(function) ident(ExpandString)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) + +comment({ Files }) +reserved(procedure) ident(DeleteFiles)operator(()reserved(const) ident(Mask)operator(:) reserved(string)operator(;) ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(\);) +reserved(procedure) ident(FileNew)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\);) +reserved(function) ident(DateTimeOfFileTime)operator(()reserved(const) ident(FileTime)operator(:) ident(TFileTime)operator(\):) ident(TDateTime)operator(;) + +comment({ FileNames }) +reserved(function) ident(GetFileNew)operator(()ident(FileName)operator(:) reserved(string)operator(;) ident(NoFloppyDrives)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) reserved(string)operator(;) + +comment({ Finding Files }) +reserved(function) ident(FindAll)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) reserved(const) ident(Mask)operator(:) reserved(string)operator(;) + ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(;) + ident(FileReturn)operator(:) ident(TFileNameFunc) operator(=) reserved(nil)operator(\):) ident(Boolean)operator(;) +reserved(function) ident(FindAllFirst)operator(()reserved(const) ident(Mask)operator(:) reserved(string)operator(;) ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(\):) reserved(string)operator(;) + +reserved(function) ident(FullOSInfo)operator(:) reserved(string)operator(;) +reserved(function) ident(Win32PlatformStr)operator(:) reserved(string)operator(;) +reserved(function) ident(Win9x)operator(:) ident(Boolean)operator(;) +reserved(function) ident(WinNT)operator(:) ident(Boolean)operator(;) +reserved(function) ident(Win2000)operator(:) ident(Boolean)operator(;) +reserved(function) ident(WinXP)operator(:) ident(Boolean)operator(;) + +reserved(var) + ident(MyDir)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + ident(LastSuccessRes)operator(:) ident(Integer) operator(=) integer(0)operator(;) + +comment({ Backward compatibility }) +preprocessor({$IFNDEF VER130}) +reserved(function) ident(SameText)operator(()reserved(const) ident(S1)operator(,) ident(S2)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +preprocessor({$ENDIF}) + +reserved(implementation) +preprocessor({$IFNDEF VER140}) +reserved(uses) ident(FileCtrl)operator(;) +preprocessor({$ENDIF}) + +preprocessor({$IFNDEF VER130}) +reserved(function) ident(SameText)operator(()reserved(const) ident(S1)operator(,) ident(S2)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(CompareText)operator(()ident(S1)operator(,) ident(S2)operator(\)) operator(=) integer(0)operator(;) +reserved(end)operator(;) +preprocessor({$ENDIF}) + +reserved(procedure) ident(Report)operator(()reserved(const) ident(ReportName)operator(,) ident(Text)operator(:) reserved(string)operator(\);) +reserved(var) + ident(F)operator(:) ident(TextFile)operator(;) + ident(FileName)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(MyDir) operator(+) ident(ReportName) operator(+) string<delimiter(')content(.rep)delimiter(')>operator(;) + ident(Assign)operator(()ident(F)operator(,) ident(FileName)operator(\);) + reserved(try) + reserved(if) reserved(not) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(then) + ident(Rewrite)operator(()ident(F)operator(\)) + reserved(else) + ident(Append)operator(()ident(F)operator(\);) + ident(WriteLn)operator(()ident(F)operator(,) ident(Text)operator(\);) + reserved(finally) + ident(Close)operator(()ident(F)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(ClearReport)operator(()reserved(const) ident(ReportName)operator(:) reserved(string)operator(\);) +reserved(var) + ident(FileName)operator(:) reserved(string)operator(;) +reserved(begin) + ident(FileName) operator(:=) ident(MyDir) operator(+) ident(ReportName) operator(+) string<delimiter(')content(.rep)delimiter(')>operator(;) + ident(DeleteFile)operator(()ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(ReportFmt)operator(()reserved(const) ident(ReportName)operator(,) ident(Fmt)operator(:) reserved(string)operator(;) reserved(const) ident(Args)operator(:) reserved(array) reserved(of) reserved(const)operator(\);) +reserved(begin) + ident(Report)operator(()ident(ReportName)operator(,) ident(Format)operator(()ident(Fmt)operator(,) ident(Args)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(GetParams)operator(()ident(Strings)operator(:) ident(TStrings)operator(\);) +reserved(var) + ident(P)operator(:) ident(PChar)operator(;) + ident(Param)operator(:) reserved(string)operator(;) + + reserved(function) ident(GetParamStr)operator(()reserved(var) ident(P)operator(:) ident(PChar)operator(;) reserved(var) ident(Param)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + reserved(var) + ident(Quoted)operator(:) ident(Boolean)operator(;) + reserved(begin) + ident(Param) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(repeat) + reserved(while) operator(()ident(P)operator([)integer(0)operator(]) operator(<>) char(#0)operator(\)) reserved(and) operator(()ident(P)operator([)integer(0)operator(]) operator(<=) char<delimiter(')content( )delimiter(')>operator(\)) reserved(do) + ident(Inc)operator(()ident(P)operator(\);) + + ident(Quoted) operator(:=) ident(False)operator(;) + reserved(while) ident(P)operator([)integer(0)operator(]) operator(<>) char(#0) reserved(do) reserved(begin) + reserved(if) ident(P)operator([)integer(0)operator(]) operator(=) char<delimiter(')content(")delimiter(')> reserved(then) reserved(begin) + ident(Quoted) operator(:=) reserved(not) ident(Quoted)operator(;) + ident(Inc)operator(()ident(P)operator(\);) + ident(Continue)operator(;) reserved(end)operator(;) + reserved(if) operator(()ident(P)operator([)integer(0)operator(]) operator(<=) char<delimiter(')content( )delimiter(')>operator(\)) reserved(and) reserved(not) ident(Quoted) reserved(then) + ident(Break)operator(;) + ident(Param) operator(:=) ident(Param) operator(+) ident(P)operator([)integer(0)operator(];) + ident(Inc)operator(()ident(P)operator(\);) + reserved(end)operator(;) + reserved(until) operator(()ident(Param) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(or) operator(()ident(P)operator([)integer(0)operator(]) operator(=) char(#0)operator(\);) + + ident(Result) operator(:=) ident(Param) operator(<>) string<delimiter(')delimiter(')>operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Strings)operator(.)ident(Clear)operator(;) + ident(P) operator(:=) ident(GetCommandLine)operator(;) + ident(GetParamStr)operator(()ident(P)operator(,) ident(Param)operator(\);) + reserved(while) ident(GetParamStr)operator(()ident(P)operator(,) ident(Param)operator(\)) reserved(do) + ident(Strings)operator(.)ident(Add)operator(()ident(Param)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(GetParams)operator(()reserved(const) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) +reserved(begin) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + ident(GetParams)operator(()ident(SL)operator(\);) + ident(Result) operator(:=) ident(Join)operator(()ident(SL)operator(,) ident(Separator)operator(\);) + ident(SL)operator(.)ident(Free)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Switch)operator(()reserved(const) ident(Switch)operator(:) reserved(string)operator(;) reserved(const) ident(PrefixChars)operator(:) ident(TCharSet) operator(=) ident(SwitchChars)operator(;) + ident(IgnoreCase)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(Boolean)operator(;) +comment(//= SysUtils.FindCmdLineSwitch) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(s)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(ParamCount) reserved(do) reserved(begin) + ident(s) operator(:=) ident(ParamStr)operator(()ident(i)operator(\);) + + reserved(if) operator(()ident(s) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) operator(()ident(s)operator([)integer(1)operator(]) reserved(in) ident(PrefixChars)operator(\)) reserved(then) reserved(begin) + comment(//i know that always s <> '', but this is saver) + ident(s) operator(:=) ident(Copy)operator(()ident(s)operator(,) integer(2)operator(,) ident(MaxInt)operator(\);) + reserved(if) operator(()ident(s) operator(=) ident(Switch)operator(\)) reserved(or) operator(()ident(IgnoreCase) reserved(and) operator(()integer(0)operator(=)ident(AnsiCompareText)operator(()ident(s)operator(,) ident(Switch)operator(\)\)\)) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ParamNum)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) integer(1) reserved(to) ident(ParamCount) reserved(do) + reserved(if) integer(0)operator(=)ident(AnsiCompareText)operator(()ident(ParamStr)operator(()ident(Result)operator(\),) ident(S)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ParamPrefixNum)operator(()reserved(const) ident(Prefix)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(Len)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Len) operator(:=) ident(Length)operator(()ident(Prefix)operator(\);) + reserved(for) ident(Result) operator(:=) integer(1) reserved(to) ident(ParamCount) reserved(do) + reserved(if) integer(0)operator(=)ident(AnsiCompareText)operator(()ident(Copy)operator(()ident(ParamStr)operator(()ident(Result)operator(\),) integer(1)operator(,) ident(Len)operator(\),) ident(Prefix)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Param)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(ParamNum)operator(()ident(S)operator(\)) operator(>) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ParamPrefix)operator(()reserved(const) ident(Prefix)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(ParamPrefixNum)operator(()ident(Prefix)operator(\)) operator(>) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(GetParam)operator(()reserved(const) ident(Prefix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) reserved(const) ident(Default)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Default)operator(;) + + reserved(if) ident(Prefix) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) ident(ParamStr)operator(()integer(1)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(i) operator(:=) ident(ParamPrefixNum)operator(()ident(Prefix)operator(\);) + reserved(if) ident(i) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(ParamStr)operator(()ident(i)operator(\),) ident(Length)operator(()ident(Prefix)operator(\)) operator(+) integer(1)operator(,) ident(MaxInt)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(GetMyDir)operator(()ident(FullPath)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Buffer)operator(:) reserved(array)operator([)integer(0)operator(..)integer(260)operator(]) reserved(of) ident(Char)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(SetString)operator(()ident(Result)operator(,) ident(Buffer)operator(,) ident(GetModuleFileName)operator(()integer(0)operator(,) ident(Buffer)operator(,) ident(SizeOf)operator(()ident(Buffer)operator(\)\)\);) + reserved(if) ident(FullPath) reserved(then) + ident(Result) operator(:=) ident(GetFileNew)operator(()ident(Result)operator(\);) + ident(Result) operator(:=) ident(ExtractPath)operator(()ident(Result)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(WinDir)operator(:) reserved(string)operator(;) +reserved(var) + ident(Res)operator(:) ident(PChar)operator(;) +reserved(begin) + ident(Result) operator(:=) char<delimiter(')content(\\)delimiter(')>operator(;) + ident(GetMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) + ident(GetWindowsDirectory)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) + ident(Result) operator(:=) ident(Res) operator(+) char<delimiter(')content(\\)delimiter(')>operator(;) + ident(FreeMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(SysDir)operator(:) reserved(string)operator(;) +reserved(var) + ident(Res)operator(:) ident(PChar)operator(;) +reserved(begin) + ident(Result) operator(:=) char<delimiter(')content(\\)delimiter(')>operator(;) + ident(GetMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) + ident(GetSystemDirectory)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) + ident(Result) operator(:=) ident(Res) operator(+) char<delimiter(')content(\\)delimiter(')>operator(;) + ident(FreeMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(UserName)operator(:) reserved(string)operator(;) +reserved(var) + ident(Len)operator(:) ident(Cardinal)operator(;) + ident(Res)operator(:) ident(PChar)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(GetMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) + ident(Len) operator(:=) ident(MAX_PATH)operator(;) + ident(GetUserName)operator(()ident(Res)operator(,) ident(Len)operator(\);) + ident(Result) operator(:=) ident(Res)operator(;) + ident(FreeMem)operator(()ident(Res)operator(,) ident(MAX_PATH)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(FirstChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Char)operator(;) +reserved(begin) + reserved(if) ident(s) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Result) operator(:=) char(#0) + reserved(else) + ident(Result) operator(:=) ident(s)operator([)integer(1)operator(];) +reserved(end)operator(;) + +reserved(function) ident(LastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Char)operator(;) +reserved(begin) + reserved(if) ident(s) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Result) operator(:=) char(#0) + reserved(else) + ident(Result) operator(:=) ident(s)operator([)ident(Length)operator(()ident(s)operator(\)];) +reserved(end)operator(;) + +reserved(function) ident(CharPos)operator(()ident(C)operator(:) ident(Char)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(MaxPosToSearch)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Offset)operator(;) + ident(MaxPosToSearch) operator(:=) ident(Length)operator(()ident(S)operator(\);) + + reserved(while) ident(Result) operator(<=) ident(MaxPosToSearch) reserved(do) reserved(begin) + reserved(if) ident(S)operator([)ident(Result)operator(]) operator(=) ident(C) reserved(then) + ident(Exit)operator(;) + ident(Inc)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(CharPos)operator(()ident(C)operator(:) ident(TCharSet)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(MaxPosToSearch)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Offset)operator(;) + ident(MaxPosToSearch) operator(:=) ident(Length)operator(()ident(S)operator(\);) + + reserved(while) ident(Result) operator(<=) ident(MaxPosToSearch) reserved(do) reserved(begin) + reserved(if) ident(S)operator([)ident(Result)operator(]) reserved(in) ident(C) reserved(then) + ident(Exit)operator(;) + ident(Inc)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(CharPosR)operator(()ident(C)operator(:) ident(Char)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) operator(-)integer(1)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Offset) operator(<) integer(0) reserved(then) + ident(Result) operator(:=) ident(Length)operator(()ident(S)operator(\)) operator(+) integer(1) operator(-) ident(Offset) + reserved(else) + ident(Result) operator(:=) ident(Offset)operator(;) + reserved(if) ident(Result) operator(>) ident(Length)operator(()ident(S)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Length)operator(()ident(S)operator(\);) + + reserved(while) ident(Result) operator(>) integer(0) reserved(do) reserved(begin) + reserved(if) ident(S)operator([)ident(Result)operator(]) operator(=) ident(C) reserved(then) + ident(Exit)operator(;) + ident(Dec)operator(()ident(Result)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PosEx)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(MaxPosToSearch)operator(,) ident(LenSubStr)operator(,) ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(SubStr) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(Offset) operator(<) integer(1) reserved(then) + ident(Result) operator(:=) integer(1) + reserved(else) + ident(Result) operator(:=) ident(Offset)operator(;) + + ident(LenSubStr) operator(:=) ident(Length)operator(()ident(SubStr)operator(\);) + ident(MaxPosToSearch) operator(:=) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(LenSubStr) operator(+) integer(1)operator(;) + + reserved(while) ident(Result) operator(<=) ident(MaxPosToSearch) reserved(do) reserved(begin) + reserved(if) ident(S)operator([)ident(Result)operator(]) operator(=) ident(SubStr)operator([)integer(1)operator(]) reserved(then) reserved(begin) + ident(i) operator(:=) integer(1)operator(;) + + reserved(while) operator(()ident(i) operator(<) ident(LenSubStr)operator(\)) + reserved(and) operator(()ident(S)operator([)ident(Result) operator(+) ident(i)operator(]) operator(=) ident(SubStr)operator([)ident(i) operator(+) integer(1)operator(]\)) reserved(do) + ident(Inc)operator(()ident(i)operator(\);) + + reserved(if) ident(i) operator(=) ident(LenSubStr) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(Inc)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PosExText)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(MaxPosToSearch)operator(,) ident(LenSubStr)operator(,) ident(i)operator(:) ident(Integer)operator(;) + + reserved(function) ident(SameChar)operator(()ident(a)operator(,) ident(b)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(UpCase)operator(()ident(a)operator(\)) operator(=) ident(UpCase)operator(()ident(b)operator(\)) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(SubStr) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(Offset) operator(<) integer(1) reserved(then) + ident(Result) operator(:=) integer(1) + reserved(else) + ident(Result) operator(:=) ident(Offset)operator(;) + + ident(LenSubStr) operator(:=) ident(Length)operator(()ident(SubStr)operator(\);) + ident(MaxPosToSearch) operator(:=) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(LenSubStr) operator(+) integer(1)operator(;) + + reserved(while) ident(Result) operator(<=) ident(MaxPosToSearch) reserved(do) reserved(begin) + reserved(if) ident(SameChar)operator(()ident(S)operator([)ident(Result)operator(],) ident(SubStr)operator([)integer(1)operator(]\)) reserved(then) reserved(begin) + ident(i) operator(:=) integer(1)operator(;) + + reserved(while) operator(()ident(i) operator(<) ident(LenSubStr)operator(\)) + reserved(and) operator(()ident(SameChar)operator(()ident(S)operator([)ident(Result) operator(+) ident(i)operator(],) ident(SubStr)operator([)ident(i) operator(+) integer(1)operator(]\)\)) reserved(do) + ident(Inc)operator(()ident(i)operator(\);) + + reserved(if) ident(i) operator(=) ident(LenSubStr) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(Inc)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PosExAnsiText)operator(()reserved(const) ident(SubStr)operator(,) ident(S)operator(:) reserved(string)operator(;) ident(Offset)operator(:) ident(Integer) operator(=) integer(1)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(MaxPosToSearch)operator(,) ident(LenSubStr)operator(,) ident(i)operator(:) ident(Integer)operator(;) + + reserved(function) ident(SameChar)operator(()ident(a)operator(,) ident(b)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(CharLower)operator(()ident(PChar)operator(()ident(a)operator(\)\)) operator(=) ident(CharLower)operator(()ident(PChar)operator(()ident(b)operator(\)\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(SubStr) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + reserved(if) ident(Offset) operator(<) integer(1) reserved(then) + ident(Result) operator(:=) integer(1) + reserved(else) + ident(Result) operator(:=) ident(Offset)operator(;) + + ident(LenSubStr) operator(:=) ident(Length)operator(()ident(SubStr)operator(\);) + ident(MaxPosToSearch) operator(:=) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(LenSubStr) operator(+) integer(1)operator(;) + + reserved(while) ident(Result) operator(<=) ident(MaxPosToSearch) reserved(do) reserved(begin) + reserved(if) ident(SameChar)operator(()ident(S)operator([)ident(Result)operator(],) ident(SubStr)operator([)integer(1)operator(]\)) reserved(then) reserved(begin) + ident(i) operator(:=) integer(1)operator(;) + + reserved(while) operator(()ident(i) operator(<) ident(LenSubStr)operator(\)) + reserved(and) operator(()ident(SameChar)operator(()ident(S)operator([)ident(Result) operator(+) ident(i)operator(],) ident(SubStr)operator([)ident(i) operator(+) integer(1)operator(]\)\)) reserved(do) + ident(Inc)operator(()ident(i)operator(\);) + + reserved(if) ident(i) operator(=) ident(LenSubStr) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(Inc)operator(()ident(Result)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(UntilChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(p) operator(:=) ident(CharPos)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(p) operator(-) integer(1)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(UntilChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(CharPos)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(p) operator(-) integer(1)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(UntilLastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(;) + ident(IgnoreNoBrake)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(CharPosR)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(p) operator(-) integer(1)operator(\)) + reserved(else) reserved(if) ident(IgnoreNoBrake) reserved(then) + ident(Result) operator(:=) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FromChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(CharPos)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(p) operator(+) integer(1)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(FromChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(CharPos)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(p) operator(+) integer(1)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(FromLastChar)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) ident(Char)operator(;) + ident(IgnoreNoBrake)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(CharPosR)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(p) operator(+) integer(1)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p)operator(\)) + reserved(else) reserved(if) ident(IgnoreNoBrake) reserved(then) + ident(Result) operator(:=) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(BetweenChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Start)operator(,) ident(Finish)operator(:) ident(Char)operator(;) + ident(Inclusive)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(,) ident(fin)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + ident(p) operator(:=) ident(CharPos)operator(()ident(Start)operator(,) ident(S)operator(\);) + reserved(if) ident(p) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(fin) operator(:=) ident(CharPos)operator(()ident(Finish)operator(,) ident(S)operator(,) ident(p) operator(+) integer(1)operator(\);) + reserved(if) ident(fin) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + reserved(if) reserved(not) ident(Inclusive) reserved(then) reserved(begin) + ident(Inc)operator(()ident(p)operator(\);) + ident(Dec)operator(()ident(fin)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(fin) operator(-) ident(p) operator(+) integer(1)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(UntilStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Length)operator(()ident(Brake)operator(\)) operator(=) integer(1) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(UntilChar)operator(()ident(S)operator(,) ident(Brake)operator([)integer(1)operator(]\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(p) operator(:=) ident(PosEx)operator(()ident(Brake)operator(,) ident(S)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(p) operator(-) integer(1)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FromStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Brake)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(Length)operator(()ident(Brake)operator(\)) operator(=) integer(1) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(FromChar)operator(()ident(S)operator(,) ident(Brake)operator([)integer(1)operator(]\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(p) operator(:=) ident(PosEx)operator(()ident(Brake)operator(,) ident(s)operator(\);) + + reserved(if) ident(p) operator(>) integer(0) reserved(then) reserved(begin) + ident(Inc)operator(()ident(p)operator(,) ident(Length)operator(()ident(Brake)operator(\)\);) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p) operator(+) integer(1)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StringWrap)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Width)operator(:) ident(Integer)operator(;) reserved(const) ident(LineEnd)operator(:) reserved(string) operator(=) ident(EOL)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(if) operator(()ident(S) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(or) operator(()ident(Width) operator(<) integer(1)operator(\)) reserved(then) + ident(Exit)operator(;) + + ident(i) operator(:=) integer(1)operator(;) + reserved(while) ident(True) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(Copy)operator(()ident(S)operator(,) ident(i)operator(,) ident(Width)operator(\);) + ident(Inc)operator(()ident(i)operator(,) ident(Width)operator(\);) + reserved(if) ident(i) operator(<=) ident(Length)operator(()ident(S)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(LineEnd) + reserved(else) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Split)operator(()reserved(const) ident(S)operator(,) ident(Separator)operator(:) reserved(string)operator(;) ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(MinCount)operator(:) ident(Integer) operator(=) integer(0)operator(\):) ident(TStrA)operator(;) +reserved(var) + ident(p)operator(,) ident(fin)operator(,) ident(SepLen)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) ident(IgnoreMultiSep) reserved(and) operator(()ident(S) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(then) + ident(Exit)operator(;) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(Result)operator(\)) operator(+) integer(1)operator(\);) + ident(Result)operator([)ident(High)operator(()ident(Result)operator(\)]) operator(:=) ident(S)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(S) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + reserved(if) ident(Length)operator(()ident(Result)operator(\)) operator(<) ident(MinCount) reserved(then) + ident(SetLength)operator(()ident(Result)operator(,) ident(MinCount)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) reserved(nil)operator(;) + ident(SepLen) operator(:=) ident(Length)operator(()ident(Separator)operator(\);) + + ident(p) operator(:=) integer(1)operator(;) + ident(fin) operator(:=) ident(PosEx)operator(()ident(Separator)operator(,) ident(S)operator(\);) + reserved(while) ident(fin) operator(>) integer(0) reserved(do) reserved(begin) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(fin) operator(-) ident(p)operator(\)\);) + ident(p) operator(:=) ident(fin) operator(+) ident(SepLen)operator(;) + ident(fin) operator(:=) ident(PosEx)operator(()ident(Separator)operator(,) ident(S)operator(,) ident(p)operator(\);) + reserved(end)operator(;) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p) operator(+) integer(1)operator(\)\);) + + reserved(if) ident(Length)operator(()ident(Result)operator(\)) operator(<) ident(MinCount) reserved(then) + ident(SetLength)operator(()ident(Result)operator(,) ident(MinCount)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(Split)operator(()reserved(const) ident(S)operator(,) ident(Separator)operator(:) reserved(string)operator(;) ident(Strings)operator(:) ident(TStrings)operator(;) + ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(\);) +reserved(var) + ident(p)operator(,) ident(fin)operator(,) ident(SepLen)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) ident(IgnoreMultiSep) reserved(and) operator(()ident(S) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(then) + ident(Exit)operator(;) + ident(Strings)operator(.)ident(Add)operator(()ident(S)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(S) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Exit)operator(;) + + ident(Strings)operator(.)ident(BeginUpdate)operator(;) + ident(SepLen) operator(:=) ident(Length)operator(()ident(Separator)operator(\);) + ident(p) operator(:=) integer(1)operator(;) + ident(fin) operator(:=) ident(PosEx)operator(()ident(Separator)operator(,) ident(S)operator(\);) + reserved(while) ident(fin) operator(>) integer(0) reserved(do) reserved(begin) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(fin) operator(-) ident(p)operator(\)\);) + ident(p) operator(:=) ident(fin) operator(+) ident(SepLen)operator(;) + ident(fin) operator(:=) ident(PosEx)operator(()ident(Separator)operator(,) ident(S)operator(,) ident(p)operator(\);) + reserved(end)operator(;) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p) operator(+) integer(1)operator(\)\);) + ident(Strings)operator(.)ident(EndUpdate)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Split)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Separators)operator(:) ident(TCharSet)operator(;) + ident(IgnoreMultiSep)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(MinCount)operator(:) ident(Integer) operator(=) integer(0)operator(\):) ident(TStrA)operator(;) +reserved(var) + ident(p)operator(,) ident(fin)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) ident(IgnoreMultiSep) reserved(and) operator(()ident(S) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(then) + ident(Exit)operator(;) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(Result)operator(\)) operator(+) integer(1)operator(\);) + ident(Result)operator([)ident(High)operator(()ident(Result)operator(\)]) operator(:=) ident(S)operator(;) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(S) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + reserved(if) ident(Length)operator(()ident(Result)operator(\)) operator(<) ident(MinCount) reserved(then) + ident(SetLength)operator(()ident(Result)operator(,) ident(MinCount)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) reserved(nil)operator(;) + + ident(p) operator(:=) integer(1)operator(;) + ident(fin) operator(:=) ident(CharPos)operator(()ident(Separators)operator(,) ident(S)operator(\);) + reserved(while) ident(fin) operator(>) integer(0) reserved(do) reserved(begin) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(fin) operator(-) ident(p)operator(\)\);) + ident(p) operator(:=) ident(fin) operator(+) integer(1)operator(;) + ident(fin) operator(:=) ident(CharPos)operator(()ident(Separators)operator(,) ident(S)operator(,) ident(p)operator(\);) + reserved(end)operator(;) + ident(Add)operator(()ident(Copy)operator(()ident(S)operator(,) ident(p)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(p) operator(+) integer(1)operator(\)\);) + + reserved(if) ident(Length)operator(()ident(Result)operator(\)) operator(<) ident(MinCount) reserved(then) + ident(SetLength)operator(()ident(Result)operator(,) ident(MinCount)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TileStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(BrakeStart)operator(:) ident(Integer)operator(;) ident(BrakeEnd)operator(:) ident(Integer)operator(;) + reserved(out) ident(Left)operator(,) ident(Right)operator(:) reserved(string)operator(\);) +reserved(begin) + ident(Left) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(BrakeStart)operator(-)integer(1)operator(\);) + ident(Right) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(BrakeEnd) operator(+) integer(1)operator(,) ident(MaxInt)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(Join)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(,) ident(imax)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(imax) operator(:=) ident(Strings)operator(.)ident(Count)operator(-)integer(1)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(imax) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(Strings)operator([)ident(i)operator(];) + reserved(if) ident(i) operator(<) ident(imax) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Separator)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Join)operator(()ident(StrA)operator(:) ident(TStrA)operator(;) ident(Separator)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) directive(overload)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(StrA)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(StrA)operator([)ident(i)operator(];) + reserved(if) ident(i) operator(<) ident(High)operator(()ident(StrA)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Separator)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(MulStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Count)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) +reserved(var) + ident(P)operator(:) ident(PChar)operator(;) + ident(Len)operator(,) ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(if) ident(Count) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Len) operator(:=) ident(Length)operator(()ident(S)operator(\);) + ident(SetLength)operator(()ident(Result)operator(,) ident(Len) operator(*) ident(Count)operator(\);) + + ident(P) operator(:=) ident(Pointer)operator(()ident(Result)operator(\);) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Count) reserved(do) reserved(begin) + ident(Move)operator(()ident(Pointer)operator(()ident(S)operator(\)^,) ident(P)operator(^,) ident(Len)operator(\);) + ident(Inc)operator(()ident(P)operator(,) ident(Len)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(AlignR)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Width)operator(:) ident(Integer)operator(;) ident(Filler)operator(:) ident(Char) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(MulStr)operator(()ident(Filler)operator(,) ident(Width) operator(-) ident(Length)operator(()ident(S)operator(\)\)) operator(+) ident(S)operator(;) +reserved(end)operator(;) + +reserved(function) ident(MaxStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(MaxLen)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Len)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Len) operator(:=) ident(Length)operator(()ident(S)operator(\);) + reserved(if) ident(Len) operator(<=) ident(MaxLen) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(S)operator(;) + ident(Exit) reserved(end)operator(;) + + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(MaxLen) operator(-) integer(3)operator(\)) operator(+) string<delimiter(')content(...)delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(function) ident(TrimAll)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) ident(S)operator([)ident(i)operator(]) operator(>) char(#32) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(S)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(ControlChar)operator(()ident(C)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(C) reserved(in) ident(StrangeChars)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FriendlyChar)operator(()ident(C)operator(:) ident(Char)operator(\):) ident(Char)operator(;) +reserved(begin) + reserved(case) ident(C) reserved(of) + char(#0)operator(:) ident(Result) operator(:=) char<delimiter(')content(.)delimiter(')>operator(;) + char(#1)operator(..)char(#31)operator(:) ident(Result) operator(:=) char<delimiter(')content(?)delimiter(')>operator(;) + char(#255)operator(:) ident(Result) operator(:=) char<delimiter(')content(#)delimiter(')>operator(;) + reserved(else) + ident(Result) operator(:=) ident(C)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FriendlyStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(S)operator(\)\);) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + ident(Result)operator([)ident(i)operator(]) operator(:=) ident(FriendlyChar)operator(()ident(S)operator([)ident(i)operator(]\);) +reserved(end)operator(;) + +reserved(function) ident(FriendlyStr)operator(()ident(a)operator(:) ident(TByteA)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(a)operator(\)\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(a)operator(\)) reserved(do) + ident(Result)operator([)ident(i) operator(+) integer(1)operator(]) operator(:=) ident(FriendlyChar)operator(()ident(Char)operator(()ident(a)operator([)ident(i)operator(]\)\);) +reserved(end)operator(;) + +reserved(function) ident(Quote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Quoter)operator(:) ident(Char) operator(=) char<delimiter(')content(")delimiter(')>operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(S)operator(;) + + reserved(if) ident(FirstChar)operator(()ident(S)operator(\)) operator(<>) ident(Quoter) reserved(then) + ident(Result) operator(:=) ident(Quoter) operator(+) ident(Result)operator(;) + + reserved(if) ident(LastChar)operator(()ident(S)operator(\)) operator(<>) ident(Quoter) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Quoter)operator(;) +reserved(end)operator(;) + +reserved(function) ident(DeQuote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(if) ident(Length)operator(()ident(S)operator(\)) operator(>) integer(2) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) integer(2)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) integer(2)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(UnQuote)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Start)operator(,) ident(Len)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Start) operator(:=) integer(1)operator(;) + ident(Len) operator(:=) ident(Length)operator(()ident(S)operator(\);) + + reserved(if) operator(()ident(S) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) operator(()ident(S)operator([)integer(1)operator(]) reserved(in) operator(([)char(#0)operator(..)char(#32)operator(]) operator(+) ident(QuoteChars)operator(\)\)) reserved(then) reserved(begin) + reserved(if) operator(()ident(LastChar)operator(()ident(S)operator(\)) operator(=) ident(S)operator([)integer(1)operator(]\)) reserved(then) + ident(Dec)operator(()ident(Len)operator(\);) + ident(Inc)operator(()ident(Start)operator(\);) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(Copy)operator(()ident(S)operator(,) ident(Start)operator(,) ident(Len) operator(-) ident(Start) operator(+) integer(1)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(StrNumerus)operator(()reserved(const) ident(Value)operator(:) ident(Integer)operator(;) reserved(const) ident(Singular)operator(,) ident(Plural)operator(:) reserved(string)operator(;) + reserved(const) ident(Zero)operator(:) reserved(string) operator(=) char<delimiter(')content(0)delimiter(')>operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(Abs)operator(()ident(Value)operator(\)) operator(=) integer(1) reserved(then) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(Value)operator(\)) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(Singular) + reserved(else) reserved(if) ident(Value) operator(=) integer(0) reserved(then) + ident(Result) operator(:=) ident(Zero) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(Plural) + reserved(else) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(Value)operator(\)) operator(+) char<delimiter(')content( )delimiter(')> operator(+) ident(Plural)operator(;) +reserved(end)operator(;) + +reserved(function) ident(MakeStr)operator(()reserved(const) ident(Items)operator(:) reserved(array) reserved(of) reserved(const)operator(;) ident(Separator)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\):) reserved(string)operator(;) +reserved(const) + ident(BoolStrings)operator(:) reserved(array)operator([)ident(Boolean)operator(]) reserved(of) reserved(string) operator(=) operator(()string<delimiter(')content(False)delimiter(')>operator(,) string<delimiter(')content(True)delimiter(')>operator(\);) + +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + + reserved(function) ident(StrOfP)operator(()ident(P)operator(:) ident(Pointer)operator(\):) reserved(string)operator(;) + reserved(begin) + reserved(if) ident(P) operator(=) reserved(nil) reserved(then) + ident(Result) operator(:=) string<delimiter(')content([nil])delimiter(')> + reserved(else) + ident(Result) operator(:=) char<delimiter(')content([)delimiter(')> operator(+) ident(IntToStr)operator(()ident(Cardinal)operator(()ident(P)operator(\)\)) operator(+) char<delimiter(')content(])delimiter(')>operator(;) + reserved(end)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(s) operator(+) ident(Separator)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Items)operator(\)) reserved(do) + reserved(with) ident(Items)operator([)ident(i)operator(]) reserved(do) + reserved(case) ident(VType) reserved(of) + ident(vtString)operator(:) ident(Add)operator(()ident(VString)operator(^\);) + ident(vtInteger)operator(:) ident(Add)operator(()ident(IntToStr)operator(()ident(VInteger)operator(\)\);) + ident(vtBoolean)operator(:) ident(Add)operator(()ident(BoolStrings)operator([)ident(VBoolean)operator(]\);) + ident(vtChar)operator(:) ident(Add)operator(()ident(VChar)operator(\);) + ident(vtPChar)operator(:) ident(Add)operator(()ident(VPChar)operator(\);) + ident(vtExtended)operator(:) ident(Add)operator(()ident(FloatToStr)operator(()ident(VExtended)operator(^\)\);) + ident(vtObject)operator(:) reserved(if) ident(VObject) reserved(is) ident(TComponent) reserved(then) + ident(Add)operator(()ident(TComponent)operator(()ident(VObject)operator(\).)ident(Name)operator(\)) + reserved(else) + ident(Add)operator(()ident(VObject)operator(.)ident(ClassName)operator(\);) + ident(vtClass)operator(:) ident(Add)operator(()ident(VClass)operator(.)ident(ClassName)operator(\);) + ident(vtAnsiString)operator(:) ident(Add)operator(()reserved(string)operator(()ident(VAnsiString)operator(\)\);) + ident(vtCurrency)operator(:) ident(Add)operator(()ident(CurrToStr)operator(()ident(VCurrency)operator(^\)\);) + ident(vtInt64)operator(:) ident(Add)operator(()ident(IntToStr)operator(()ident(VInt64)operator(^\)\);) + ident(vtVariant)operator(:) ident(Add)operator(()reserved(string)operator(()ident(VVariant)operator(^\)\);) + + ident(vtWideChar)operator(:) ident(Add)operator(()ident(VWideChar)operator(\);) + ident(vtPWideChar)operator(:) ident(Add)operator(()ident(VPWideChar)operator(\);) + ident(vtInterface)operator(:) ident(Add)operator(()ident(StrOfP)operator(()ident(VInterface)operator(\)\);) + ident(vtPointer)operator(:) ident(Add)operator(()ident(StrOfP)operator(()ident(VPointer)operator(\)\);) + ident(vtWideString)operator(:) ident(Add)operator(()ident(WideString)operator(()ident(VWideString)operator(\)\);) + reserved(end)operator(;) + reserved(if) ident(Result) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(SetLength)operator(()ident(result)operator(,) ident(Length)operator(()ident(Result)operator(\)) operator(-) ident(Length)operator(()ident(Separator)operator(\)\);) +reserved(end)operator(;) + +reserved(procedure) ident(ShowText)operator(()reserved(const) ident(Items)operator(:) reserved(array) reserved(of) reserved(const)operator(;) ident(Separator)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) +reserved(var) + ident(Text)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Text) operator(:=) ident(MakeStr)operator(()ident(Items)operator(,) ident(Separator)operator(\);) + + ident(MessageBox)operator(()integer(0)operator(,) ident(PChar)operator(()ident(Text)operator(\),) string<delimiter(')content(Info)delimiter(')>operator(,) ident(MB_OK) reserved(and) ident(MB_APPLMODAL)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(DeleteChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) ident(S)operator([)ident(i)operator(]) operator(<>) ident(C) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(S)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(DeleteChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) reserved(not) operator(()ident(S)operator([)ident(i)operator(]) reserved(in) ident(C)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(S)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(ExtractChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) ident(S)operator([)ident(i)operator(]) reserved(in) ident(C) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(S)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(CharCount)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) ident(S)operator([)ident(i)operator(]) operator(=) ident(C) reserved(then) + ident(Inc)operator(()ident(Result)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(StrAtPos)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Pos)operator(:) ident(Integer)operator(;) reserved(const) ident(Str)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Str) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) operator(()ident(Str) operator(=) ident(Copy)operator(()ident(S)operator(,) ident(Pos)operator(,) ident(Length)operator(()ident(Str)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(TextAtPos)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Pos)operator(:) ident(Integer)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Text) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) ident(SameText)operator(()ident(Text)operator(,) ident(Copy)operator(()ident(S)operator(,) ident(Pos)operator(,) ident(Length)operator(()ident(Text)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(StrAtBegin)operator(()reserved(const) ident(S)operator(,) ident(Str)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(StrAtPos)operator(()ident(S)operator(,) integer(1)operator(,) ident(Str)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(TextAtBegin)operator(()reserved(const) ident(S)operator(,) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(TextAtPos)operator(()ident(S)operator(,) integer(1)operator(,) ident(Text)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(CharIn)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(Char)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) + reserved(if) ident(S)operator([)ident(i)operator(]) operator(=) ident(C) reserved(then) ident(Exit)operator(;) + ident(Result) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(function) ident(CharIn)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(C)operator(:) ident(TCharSet)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(S)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(S)operator([)ident(i)operator(]) reserved(in) ident(C)operator(;) + reserved(if) ident(Result) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrIn)operator(()reserved(const) ident(S)operator(,) ident(SubStr)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(PosEx)operator(()ident(SubStr)operator(,) ident(S)operator(\)) operator(>) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrIn)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(Result) operator(:=) operator(()ident(S) operator(=) ident(SL)operator([)ident(i)operator(]\);) + reserved(if) ident(Result) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrIn)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(for) ident(i) operator(:=) ident(Low)operator(()ident(A)operator(\)) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) operator(()ident(S) operator(=) ident(A)operator([)ident(i)operator(]\);) + reserved(if) ident(Result) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TextIn)operator(()reserved(const) ident(S)operator(,) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(PosExText)operator(()ident(Text)operator(,) ident(S)operator(\)) operator(>) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TextIn)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(SameText)operator(()ident(Text)operator(,) ident(SL)operator([)ident(i)operator(]\);) + reserved(if) ident(Result) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TextIn)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(for) ident(i) operator(:=) ident(Low)operator(()ident(A)operator(\)) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(SameText)operator(()ident(Text)operator(,) ident(A)operator([)ident(i)operator(]\);) + reserved(if) ident(Result) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrIndex)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(S) operator(=) ident(SL)operator([)ident(Result)operator(]) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrIndex)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) ident(Low)operator(()ident(A)operator(\)) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) + reserved(if) ident(S) operator(=) ident(A)operator([)ident(Result)operator(]) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TextIndex)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(SameText)operator(()ident(Text)operator(,) ident(SL)operator([)ident(Result)operator(]\)) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TextIndex)operator(()ident(A)operator(:) ident(TStrA)operator(;) reserved(const) ident(Text)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) ident(Low)operator(()ident(A)operator(\)) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) + reserved(if) ident(SameText)operator(()ident(Text)operator(,) ident(A)operator([)ident(Result)operator(]\)) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ReplaceChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Old)operator(,) ident(New)operator(:) ident(Char)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(S)operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(Result)operator(\)) reserved(do) + reserved(if) ident(Result)operator([)ident(i)operator(]) operator(=) ident(Old) reserved(then) + ident(Result)operator([)ident(i)operator(]) operator(:=) ident(New)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ReplaceChars)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) ident(Old)operator(:) ident(TCharSet)operator(;) ident(New)operator(:) ident(Char)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(S)operator(;) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(Result)operator(\)) reserved(do) + reserved(if) ident(Result)operator([)ident(i)operator(]) reserved(in) ident(Old) reserved(then) + ident(Result)operator([)ident(i)operator(]) operator(:=) ident(New)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Replace)operator(()reserved(const) ident(S)operator(,) ident(Old)operator(,) ident(New)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(oldp)operator(,) ident(ps)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(ps) operator(:=) integer(1)operator(;) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(True) reserved(do) reserved(begin) + ident(oldp) operator(:=) ident(ps)operator(;) + ident(ps) operator(:=) ident(PosEx)operator(()ident(Old)operator(,) ident(S)operator(,) ident(oldp)operator(\);) + reserved(if) ident(ps) operator(=) integer(0) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(Copy)operator(()ident(S)operator(,) ident(oldp)operator(,) ident(Length)operator(()ident(S)operator(\)) operator(-) ident(oldp) operator(+) integer(1)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + ident(Result) operator(:=) ident(Result) operator(+) ident(Copy)operator(()ident(S)operator(,) ident(oldp)operator(,) ident(ps) operator(-) ident(oldp)operator(\)) operator(+) ident(New)operator(;) + ident(Inc)operator(()ident(ps)operator(,) ident(Length)operator(()ident(Old)operator(\)\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(SLOfFile)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(TStringList)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(if) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(then) + ident(Result)operator(.)ident(LoadFromFile)operator(()ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ContainsEmptyLines)operator(()ident(SL)operator(:) ident(TStrings)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(StrIn)operator(()ident(SL)operator(,) string<delimiter(')delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(DeleteEmptyLines)operator(()ident(SL)operator(:) ident(TStrings)operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(i) operator(<) ident(SL)operator(.)ident(Count) reserved(do) reserved(begin) + reserved(if) ident(SL)operator([)ident(i)operator(]) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(SL)operator(.)ident(Delete)operator(()ident(i)operator(\)) + reserved(else) + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(DeleteCommentLines)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(CommentSign)operator(:) reserved(string) operator(=) string<delimiter(')content(//)delimiter(')>operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(i) operator(:=) integer(0)operator(;) + reserved(while) ident(i) operator(<) ident(SL)operator(.)ident(Count) reserved(do) reserved(begin) + reserved(if) operator(()ident(SL)operator([)ident(i)operator(]) operator(=) string<delimiter(')delimiter(')>operator(\)) reserved(or) operator(()ident(StrAtBegin)operator(()ident(TrimLeft)operator(()ident(SL)operator([)ident(i)operator(]\),) ident(CommentSign)operator(\)\)) reserved(then) + ident(SL)operator(.)ident(Delete)operator(()ident(i)operator(\)) + reserved(else) + ident(Inc)operator(()ident(i)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FindLine)operator(()ident(SL)operator(:) ident(TStrings)operator(;) reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(Result) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) + reserved(if) ident(TextAtBegin)operator(()ident(SL)operator([)ident(Result)operator(],) ident(S)operator(\)) reserved(then) + ident(Exit)operator(;) + ident(Result) operator(:=) operator(-)integer(1)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(QuickSortSL)operator(()ident(SL)operator(:) ident(TStringList)operator(\);) + + reserved(procedure) ident(Sort)operator(()ident(l)operator(,) ident(r)operator(:) ident(Integer)operator(\);) + reserved(var) + ident(i)operator(,)ident(j)operator(:) ident(Integer)operator(;) + ident(z)operator(,)ident(x)operator(:) reserved(string)operator(;) + reserved(begin) + ident(i) operator(:=) ident(l)operator(;) + ident(j) operator(:=) ident(r)operator(;) + ident(x) operator(:=) ident(SL)operator([()ident(j) operator(+) ident(i)operator(\)) reserved(div) integer(2)operator(];) + reserved(repeat) + reserved(while) ident(SL)operator([)ident(i)operator(]) operator(<) ident(x) reserved(do) ident(Inc)operator(()ident(i)operator(\);) + reserved(while) ident(SL)operator([)ident(j)operator(]) operator(>) ident(x) reserved(do) ident(Dec)operator(()ident(j)operator(\);) + reserved(if) ident(i) operator(<=) ident(j) reserved(then) reserved(begin) + ident(z) operator(:=) ident(SL)operator([)ident(i)operator(];) + ident(SL)operator([)ident(i)operator(]) operator(:=) ident(SL)operator([)ident(j)operator(];) + ident(SL)operator([)ident(j)operator(]) operator(:=) ident(z)operator(;) + ident(Inc)operator(()ident(i)operator(\);) ident(Dec)operator(()ident(j)operator(\);) + reserved(end)operator(;) + reserved(until) ident(i) operator(>) ident(j)operator(;) + reserved(if) ident(j) operator(>) ident(l) reserved(then) ident(Sort)operator(()ident(l)operator(,) ident(j)operator(\);) + reserved(if) ident(i) operator(<) ident(r) reserved(then) ident(Sort)operator(()ident(i)operator(,) ident(r)operator(\);) + reserved(end)operator(;) + +reserved(begin) + reserved(if) ident(SL)operator(.)ident(Count) operator(>) integer(0) reserved(then) + ident(Sort)operator(()integer(0)operator(,) ident(SL)operator(.)ident(Count)operator(-)integer(1)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(IncStrA)operator(()ident(StrA)operator(:) ident(TStrA)operator(\):) ident(Integer)operator(;) +reserved(begin) + ident(SetLength)operator(()ident(StrA)operator(,) ident(Length)operator(()ident(StrA)operator(\)) operator(+) integer(1)operator(\);) + ident(Result) operator(:=) ident(High)operator(()ident(StrA)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(StrOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) reserved(string)operator(()ident(Copy)operator(()ident(a)operator(,) integer(0)operator(,) ident(Length)operator(()ident(a)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(ByteAOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(TByteA)operator(()ident(Copy)operator(()ident(S)operator(,) integer(1)operator(,) ident(Length)operator(()ident(s)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(ByteAOfInt)operator(()ident(i)operator(:) ident(Integer)operator(\):) ident(TByteA)operator(;) +reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(SizeOf)operator(()ident(Integer)operator(\)\);) + ident(Move)operator(()ident(i)operator(,) ident(Pointer)operator(()ident(Result)operator(\)^,) ident(SizeOf)operator(()ident(Integer)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(IntOfByteA)operator(()ident(A)operator(:) ident(TByteA)operator(\):) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Move)operator(()ident(Pointer)operator(()ident(A)operator(\)^,) ident(Result)operator(,) ident(Min)operator(()ident(Length)operator(()ident(A)operator(\),) ident(SizeOf)operator(()ident(Integer)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(ByteAOfHex)operator(()reserved(const) ident(Hex)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(h)operator(:) reserved(string)operator(;) +reserved(begin) + ident(h) operator(:=) ident(ExtractChars)operator(()ident(Hex)operator(,) ident(HexadecimalChars)operator(\);) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(h)operator(\)) reserved(div) integer(2)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Result)operator(\)) reserved(do) + ident(Result)operator([)ident(i)operator(]) operator(:=) ident(ByteOfHex)operator(()ident(Copy)operator(()ident(h)operator(,) operator(()ident(i) reserved(shl) integer(1)operator(\)) operator(+) integer(1)operator(,) integer(2)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(SizeOfFile)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(F)operator(:) reserved(file)operator(;) +reserved(begin) + ident(AssignFile)operator(()ident(F)operator(,) ident(FileName)operator(\);) + preprocessor({$I-})ident(Reset)operator(()ident(F)operator(,) integer(1)operator(\);)preprocessor({$I+}) + reserved(if) ident(IOResult) operator(=) integer(0) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(FileSize)operator(()ident(F)operator(\);) + ident(CloseFile)operator(()ident(F)operator(\);) + reserved(end) reserved(else) + ident(Result) operator(:=) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FileEx)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(;) ident(AllowFolders)operator(:) ident(Boolean) operator(=) ident(False)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(FindData)operator(:) ident(TWin32FindData)operator(;) +reserved(begin) + reserved(if) ident(FileName) operator(=) string<delimiter(')delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) operator(()ident(AllowFolders) reserved(and) ident(DirectoryExists)operator(()ident(FileName)operator(\)\)) reserved(or) + operator(()ident(FindFirstFile)operator(()ident(PChar)operator(()ident(FileName)operator(\),) ident(FindData)operator(\)) operator(<>) ident(INVALID_HANDLE_VALUE)operator(\);) + ident(Result) operator(:=) ident(Result) reserved(and) reserved(not) ident(CharIn)operator(()ident(FileName)operator(,) ident(WildCards)operator(\);) + ident(Result) operator(:=) ident(Result) reserved(and) operator(()ident(AllowFolders) + reserved(or) operator((()ident(FindData)operator(.)ident(dwFileAttributes) reserved(and) ident(FILE_ATTRIBUTE_DIRECTORY)operator(\)) operator(=) integer(0)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(LWPSolve)operator(()reserved(const) ident(Dir)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) operator(()ident(Dir) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) operator(()ident(Dir)operator([)ident(Length)operator(()ident(Dir)operator(\)]) operator(=) char<delimiter(')content(\\)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Copy)operator(()ident(Dir)operator(,) integer(1)operator(,) ident(Length)operator(()ident(Dir)operator(\)) operator(-) integer(1)operator(\);) + reserved(end) reserved(else) + ident(Result) operator(:=) ident(Dir)operator(;) +reserved(end)operator(;) + +reserved(function) ident(LWPSlash)operator(()reserved(const) ident(Dir)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) operator(()ident(Dir) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) operator(()ident(Dir)operator([)ident(Length)operator(()ident(Dir)operator(\)]) operator(=) char<delimiter(')content(\\)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Copy)operator(()ident(Dir)operator(,) integer(1)operator(,) ident(Length)operator(()ident(Dir)operator(\)\);) + reserved(end) reserved(else) + ident(Result) operator(:=) ident(Dir) operator(+) char<delimiter(')content(\\)delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(function) ident(ExtractDrive)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(if) operator(()ident(Length)operator(()ident(FileName)operator(\)) operator(>=) integer(2)operator(\)) reserved(and) operator(()ident(FileName)operator([)integer(2)operator(]) operator(=) char<delimiter(')content(:)delimiter(')>operator(\)) reserved(then) + ident(Result) operator(:=) ident(UpperCase)operator(()ident(FileName)operator([)integer(1)operator(]) operator(+) string<delimiter(')content(:\\)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ExtractPath)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(p)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(p) operator(:=) ident(CharPosR)operator(()char<delimiter(')content(\\)delimiter(')>operator(,) ident(FileName)operator(\);) + reserved(if) ident(P) operator(>) integer(0) reserved(then) + ident(Result) operator(:=) ident(Copy)operator(()ident(FileName)operator(,) integer(1)operator(,) ident(p)operator(\)) + reserved(else) + ident(Result) operator(:=) ident(FileName)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ExtractPrefix)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(UntilLastChar)operator(()ident(ExtractFileName)operator(()ident(FileName)operator(\),) char<delimiter(')content(.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ExtractSuffix)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(FromLastChar)operator(()ident(ExtractFileName)operator(()ident(FileName)operator(\),) char<delimiter(')content(.)delimiter(')>operator(\);) +reserved(end)operator(;) + +reserved(function) ident(SameByteA)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(TByteA)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(A) operator(=) ident(B)operator(\)) reserved(or) operator((()ident(Length)operator(()ident(A)operator(\)) operator(=) ident(Length)operator(()ident(B)operator(\)\)) reserved(and) ident(CompareMem)operator(()ident(A)operator(,) ident(B)operator(,) ident(Length)operator(()ident(A)operator(\)\)\);) +reserved(end)operator(;) + +reserved(function) ident(Reverse)operator(()ident(A)operator(:) ident(TByteA)operator(\):) ident(TByteA)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(Length)operator(()ident(A)operator(\)\);) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) + ident(Result)operator([)ident(High)operator(()ident(Result)operator(\)) operator(-) ident(i)operator(]) operator(:=) ident(A)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(Endian)operator(()ident(i)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) +reserved(type) + ident(EndianArray) operator(=) reserved(packed) reserved(array)operator([)integer(0)operator(..)integer(3)operator(]) reserved(of) ident(Byte)operator(;) +reserved(var) + ident(a)operator(,) ident(b)operator(:) ident(EndianArray)operator(;) +reserved(begin) + ident(a) operator(:=) ident(EndianArray)operator(()ident(i)operator(\);) + ident(b)operator([)integer(0)operator(]) operator(:=) ident(a)operator([)integer(3)operator(];) + ident(b)operator([)integer(1)operator(]) operator(:=) ident(a)operator([)integer(2)operator(];) + ident(b)operator([)integer(2)operator(]) operator(:=) ident(a)operator([)integer(1)operator(];) + ident(b)operator([)integer(3)operator(]) operator(:=) ident(a)operator([)integer(0)operator(];) + ident(Result) operator(:=) ident(Integer)operator(()ident(b)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(SaveByteA)operator(()ident(Data)operator(:) ident(TByteA)operator(;) reserved(const) ident(FileName)operator(:) reserved(string)operator(;) + ident(Overwrite)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(F)operator(:) reserved(file)operator(;) +reserved(begin) + reserved(if) ident(FileExists)operator(()ident(FileName)operator(\)) reserved(and) reserved(not) ident(Overwrite) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + ident(Exit) reserved(end)operator(;) + + ident(AssignFile)operator(()ident(F)operator(,) ident(FileName)operator(\);) + preprocessor({$I-})ident(Rewrite)operator(()ident(F)operator(,) integer(1)operator(\);)preprocessor({$I+}) + reserved(if) ident(IOResult) operator(=) integer(0) reserved(then) reserved(begin) + reserved(if) ident(Length)operator(()ident(Data)operator(\)) operator(>) integer(0) reserved(then) + ident(BlockWrite)operator(()ident(F)operator(,) ident(Data)operator([)integer(0)operator(],) ident(Length)operator(()ident(Data)operator(\)\);) + ident(CloseFile)operator(()ident(F)operator(\);) + ident(Result) operator(:=) ident(True)operator(;) + reserved(end) reserved(else) + ident(Result) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(function) ident(LoadByteA)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(TByteA)operator(;) +reserved(var) + ident(F)operator(:) reserved(file)operator(;) +reserved(begin) + ident(AssignFile)operator(()ident(F)operator(,) ident(FileName)operator(\);) + preprocessor({$I-})ident(Reset)operator(()ident(F)operator(,) integer(1)operator(\);)preprocessor({$I+}) + reserved(if) ident(IOResult) operator(=) integer(0) reserved(then) reserved(begin) + ident(SetLength)operator(()ident(Result)operator(,) ident(FileSize)operator(()ident(F)operator(\)\);) + reserved(if) ident(Length)operator(()ident(Result)operator(\)) operator(>) integer(0) reserved(then) + ident(BlockRead)operator(()ident(F)operator(,) ident(Result)operator([)integer(0)operator(],) ident(FileSize)operator(()ident(F)operator(\)\);) + ident(CloseFile)operator(()ident(F)operator(\);) + reserved(end) reserved(else) + ident(SetLength)operator(()ident(Result)operator(,) integer(0)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(IsValidFileName)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(FileName) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) reserved(not) ident(CharIn)operator(()ident(FileName)operator(,) ident(FileNameEnemies)operator(\)) + reserved(and) ident(CharIn)operator(()ident(Trim)operator(()ident(FileName)operator(\),) ident(AllChars) operator(-) operator([)char<delimiter(')content(.)delimiter(')>operator(]\);) +reserved(end)operator(;) + +reserved(function) ident(MakeValidFileName)operator(()ident(FileName)operator(:) reserved(string)operator(;) reserved(const) ident(Default)operator(:) reserved(string) operator(=) string<delimiter(')content(File)delimiter(')>operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(FileName) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(FileName) operator(:=) ident(Default)operator(;) + + reserved(if) ident(CharIn)operator(()ident(FileName)operator(,) ident(FileNameEnemies)operator(\)) reserved(then) + ident(Result) operator(:=) ident(ReplaceChars)operator(()ident(FileName)operator(,) ident(FileNameEnemies)operator(,) char<delimiter(')content(_)delimiter(')>operator(\)) + reserved(else) reserved(if) reserved(not) ident(CharIn)operator(()ident(Trim)operator(()ident(FileName)operator(\),) ident(AllChars) operator(-) operator([)char<delimiter(')content(.)delimiter(')>operator(]\)) reserved(then) + ident(Result) operator(:=) ident(Default) + reserved(else) + ident(Result) operator(:=) ident(FileName)operator(;) +reserved(end)operator(;) + +reserved(function) ident(IsValidInteger)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +comment({const + LowInt = '2147483648'; + HighInt = '2147483647'; +var + len, RealLen, i, o: Integer; + c: Char; +begin + Result := False; + if S = '' then + Exit; + + len := Length(S\); + o := 1; + + if S[1] = '-' then begin + if len = 1 then + Exit; + Inc(o\); + while (o <= len\) and (S[o] = '0'\) do + Inc(o\); + if o > len then + Exit; + if o < len then begin + RealLen := len - o + 1; + if RealLen > Length(LowInt\) then + Exit + else if RealLen = Length(LowInt\) then begin + for i := 1 to Length(LowInt\) do begin + c := S[i + o - 1]; + if (c < '0'\) or (c > LowInt[i]\) then + Exit; + if c in ['0'..Char((Byte(LowInt[i]\)-1\)\)] then + Break; + end; + Inc(o, i\); + end; + end; + end else begin + while (o <= len\) and (S[o] = '0'\) do + Inc(o\); + if o <= len then begin + RealLen := len - o + 1; + if RealLen > Length(HighInt\) then + Exit + else if RealLen = Length(HighInt\) then begin + for i := 1 to Length(HighInt\) do begin + c := S[i + o - 1]; + if (c < '0'\) or (c > HighInt[i]\) then + Exit; + if c in ['0'..Char((Byte(HighInt[i]\)-1\)\)] then + Break; + end; + Inc(o, i\); + end; + end; + end; + + for i := o to len do + if not (S[i] in ['0'..'9']\) then + Exit; + + Result := True; }) +reserved(var) + ident(i)operator(:) ident(Int64)operator(;) +reserved(begin) + ident(i) operator(:=) ident(StrToInt64Def)operator(()ident(S)operator(,) ident(High)operator(()ident(Int64)operator(\)\);) + ident(Result) operator(:=) operator(()ident(i) operator(>=) ident(Low)operator(()ident(Integer)operator(\)\)) reserved(and) operator(()ident(i) operator(<=) ident(High)operator(()ident(Integer)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(IsValidCardinal)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) +comment({const + HighCard = '4294967295'; +var + len, RealLen, i, o: Integer; +begin + Result := False; + if S = '' then + Exit; + + len := Length(S\); + o := 1; + + while (o <= len\) and (S[o] = '0'\) do + Inc(o\); + if o <= len then begin + RealLen := len - o + 1; + if RealLen > Length(HighCard\) then + Exit + else if RealLen = Length(HighCard\) then begin + for i := 1 to Length(HighCard\) do begin + if S[i + o - 1] > HighCard[i] then + Exit; + if S[i + o - 1] in ['0'..Char((Byte(HighCard[i]\)-1\)\)] then + Break; + end; + Inc(o, i\); + end; + end; + + for i := o to len do + if not (S[i] in ['0'..'9']\) then + Exit; + + Result := True; }) +reserved(var) + ident(i)operator(:) ident(Int64)operator(;) +reserved(begin) + ident(i) operator(:=) ident(StrToInt64Def)operator(()ident(S)operator(,) operator(-)integer(1)operator(\);) + ident(Result) operator(:=) operator(()ident(i) operator(>=) integer(0)operator(\)) reserved(and) operator(()ident(i) operator(<=) ident(High)operator(()ident(Cardinal)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(StrOfBool)operator(()ident(flag)operator(:) ident(Boolean)operator(;) reserved(const) ident(TrueStr)operator(:) reserved(string) operator(=) string<delimiter(')content(True)delimiter(')>operator(;) + reserved(const) ident(FalseStr)operator(:) reserved(string) operator(=) string<delimiter(')content(False)delimiter(')>operator(\):) reserved(string)operator(;) +reserved(begin) + reserved(if) ident(Flag) reserved(then) + ident(Result) operator(:=) ident(TrueStr) + reserved(else) + ident(Result) operator(:=) ident(FalseStr)operator(;) +reserved(end)operator(;) + +reserved(function) ident(StrOfInt)operator(()ident(i)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) +reserved(begin) +comment({ if i = 0 then begin + Result := '0'; + Exit end; + + while i > 0 do begin + Result := Char(Byte('0'\) + (i mod 10\)\) + Result; + i := i div 10; + end;}) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(i)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(CardOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) +reserved(var) + ident(Res)operator(:) ident(Int64)operator(;) +reserved(begin) + ident(Res) operator(:=) ident(StrToInt64Def)operator(()ident(S)operator(,) operator(-)integer(1)operator(\);) + reserved(if) ident(Res) operator(>) ident(High)operator(()ident(Cardinal)operator(\)) reserved(then) + ident(Res) operator(:=) ident(High)operator(()ident(Cardinal)operator(\)) + reserved(else) reserved(if) ident(Res) operator(<) integer(0) reserved(then) + ident(Res) operator(:=) integer(0)operator(;) + ident(Result) operator(:=) ident(Cardinal)operator(()ident(Res)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(HexOrd)operator(()ident(Hex)operator(:) ident(Char)operator(\):) ident(THex)operator(;) +reserved(begin) + reserved(case) ident(Hex) reserved(of) + char<delimiter(')content(0)delimiter(')>operator(..)char<delimiter(')content(9)delimiter(')>operator(:) + ident(Result) operator(:=) ident(Byte)operator(()ident(Hex)operator(\)) operator(-) integer(48)operator(;) + char<delimiter(')content(A)delimiter(')>operator(..)char<delimiter(')content(F)delimiter(')>operator(:) + ident(Result) operator(:=) ident(Byte)operator(()ident(Hex)operator(\)) operator(-) integer(55)operator(;) + char<delimiter(')content(a)delimiter(')>operator(..)char<delimiter(')content(f)delimiter(')>operator(:) + ident(Result) operator(:=) ident(Byte)operator(()ident(Hex)operator(\)) operator(-) integer(87)operator(;) + reserved(else) + ident(Result) operator(:=) integer(0)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(ByteOfHex)operator(()ident(Hex)operator(:) ident(THexByteStr)operator(\):) ident(Byte)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(HexOrd)operator(()ident(Hex)operator([)integer(1)operator(]\)) reserved(shl) integer(4)operator(\)) operator(+) ident(HexOrd)operator(()ident(Hex)operator([)integer(2)operator(]\);) +reserved(end)operator(;) + +reserved(function) ident(DecOfHex)operator(()reserved(const) ident(Hex)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(IntToStr)operator(()ident(CardOfHex)operator(()ident(Hex)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(HexOfByte)operator(()ident(b)operator(:) ident(Byte)operator(\):) ident(THexByteStr)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(HexChar)operator([()ident(b) reserved(and) hex($F0)operator(\)) reserved(shr) integer(4)operator(]) + operator(+) ident(HexChar)operator([) ident(b) reserved(and) hex($0F) operator(];) +reserved(end)operator(;) + +comment({function HexOfCard2(c: Cardinal\): string; +var + Data: array[0..(1 shl 4\) - 1] of Char; + i: Integer; +begin + for i := 0 to (1 shl 4\) - 1 do + if i < 10 then + Data[i] := Char(Ord('0'\) + i\) + else + Data[i] := Char(Ord('A'\) + i - 10\); + + Result := Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (7 shl 2\)\)\) shr (7 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (6 shl 2\)\)\) shr (6 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (5 shl 2\)\)\) shr (5 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (4 shl 2\)\)\) shr (4 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (3 shl 2\)\)\) shr (3 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (2 shl 2\)\)\) shr (2 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (1 shl 2\)\)\) shr (1 shl 2\)] + + Data[(c and (((1 shl (1 shl 2\)\) - 1\) shl (0 shl 2\)\)\) shr (0 shl 2\)]; +end; }) + +reserved(function) ident(HexOfCard)operator(()ident(i)operator(:) ident(Cardinal)operator(\):) reserved(string)operator(;) +reserved(var) + ident(a)operator(:) ident(Cardinal)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(i) operator(>) integer(0) reserved(do) reserved(begin) + ident(a) operator(:=) ident(i) reserved(and) hex($F)operator(;) + ident(Result) operator(:=) ident(HexChar)operator([)ident(a)operator(]) operator(+) ident(Result)operator(;) + ident(i) operator(:=) ident(i) reserved(shr) integer(4)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(HexOfCard)operator(()ident(i)operator(:) ident(Cardinal)operator(;) ident(Digits)operator(:) ident(Integer)operator(\):) reserved(string)operator(;) +reserved(var) + ident(a)operator(:) ident(Cardinal)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(i) operator(>) integer(0) reserved(do) reserved(begin) + ident(a) operator(:=) ident(i) reserved(and) hex($F)operator(;) + ident(Result) operator(:=) ident(HexChar)operator([)ident(a)operator(]) operator(+) ident(Result)operator(;) + ident(i) operator(:=) ident(i) reserved(shr) integer(4)operator(;) + reserved(end)operator(;) + ident(Result) operator(:=) ident(MulStr)operator(()char<delimiter(')content(0)delimiter(')>operator(,) ident(Digits) operator(-) ident(Length)operator(()ident(Result)operator(\)\)) operator(+) ident(Result)operator(;) +reserved(end)operator(;) + +reserved(function) ident(PascalHexArray)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Name)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(,) ident(len)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')content(const)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content( )delimiter(')> operator(+) ident(Name) operator(+) string<delimiter(')content(: array[0..)delimiter(')> operator(+) ident(IntToStr)operator(()ident(High)operator(()ident(a)operator(\)\)) operator(+) string<delimiter(')content(] of Byte = ()delimiter(')>operator(;) + + ident(len) operator(:=) ident(Length)operator(()ident(a)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(len)operator(-)integer(1) reserved(do) reserved(begin) + reserved(if) operator(()ident(i) reserved(mod) integer(19)operator(\)) operator(=) integer(0) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(EOL) operator(+) string<delimiter(')content( )delimiter(')> operator(+) string<delimiter(')content( )delimiter(')>operator(;) + ident(Result) operator(:=) ident(Result) operator(+) char<delimiter(')content($)delimiter(')> operator(+) ident(HexOfByte)operator(()ident(a)operator([)ident(i)operator(]\);) + reserved(if) ident(i) operator(<) ident(len)operator(-)integer(1) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) char<delimiter(')content(,)delimiter(')>operator(;) + reserved(end)operator(;) + ident(Result) operator(:=) ident(Result) operator(+) ident(EOL) operator(+) string<delimiter(')content( \);)delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(function) ident(HexOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Blocks)operator(:) ident(Integer) operator(=) integer(1)operator(;) + reserved(const) ident(Splitter)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(if) ident(Blocks) operator(>) integer(0) reserved(then) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(a)operator(\)) reserved(do) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(HexOfByte)operator(()ident(a)operator([)ident(i)operator(]\);) + reserved(if) ident(i) operator(<) ident(High)operator(()ident(a)operator(\)) reserved(then) + reserved(if) operator((()ident(i)operator(+)integer(1)operator(\)) reserved(mod) ident(Blocks)operator(\)) operator(=) integer(0) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Splitter)operator(;) + reserved(end) + reserved(else) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(a)operator(\)) reserved(do) + ident(Result) operator(:=) ident(Result) operator(+) ident(HexOfByte)operator(()ident(a)operator([)ident(i)operator(]\);) +reserved(end)operator(;) + +reserved(function) ident(BinOfByteA)operator(()ident(a)operator(:) ident(TByteA)operator(;) ident(Blocks)operator(:) ident(Integer) operator(=) integer(4)operator(;) + reserved(const) ident(Splitter)operator(:) reserved(string) operator(=) char<delimiter(')content( )delimiter(')>operator(\):) reserved(string)operator(;) +reserved(var) + ident(i)operator(,) ident(max)operator(:) ident(Integer)operator(;) + ident(Bit)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + + reserved(if) ident(Blocks) operator(>) integer(0) reserved(then) reserved(begin) + ident(max) operator(:=) integer(8) operator(*) operator(()ident(High)operator(()ident(a)operator(\)\)) operator(+) integer(7)operator(;) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(max) reserved(do) reserved(begin) + ident(Bit) operator(:=) integer(7)operator(-()ident(i) reserved(mod) integer(8)operator(\)) reserved(in) ident(TBitSet)operator(()ident(a)operator([)ident(i) reserved(div) integer(8)operator(]\);) + ident(Result) operator(:=) ident(Result) operator(+) ident(Char)operator(()ident(Byte)operator(()char<delimiter(')content(0)delimiter(')>operator(\)) operator(+) ident(Byte)operator(()ident(Bit)operator(\)\);) + reserved(if) ident(i) operator(<) ident(max) reserved(then) + reserved(if) operator((()ident(i)operator(+)integer(1)operator(\)) reserved(mod) ident(Blocks)operator(\)) operator(=) integer(0) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Splitter)operator(;) + reserved(end)operator(;) + reserved(end) reserved(else) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(a)operator(\)) reserved(do) + ident(Result) operator(:=) ident(Result) operator(+) ident(Char)operator(()ident(Byte)operator(()char<delimiter(')content(0)delimiter(')>operator(\)) operator(+) ident(a)operator([)ident(i)operator(]) reserved(shr) operator(()ident(i) reserved(and) integer(8)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(CardOfHex)operator(()ident(Hex)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Hex) operator(:=) ident(Copy)operator(()ident(ExtractChars)operator(()ident(Hex)operator(,) ident(HexadecimalChars)operator(\),) integer(1)operator(,) integer(8)operator(\);) + + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(Length)operator(()ident(Hex)operator(\)) reserved(do) + reserved(if) ident(Hex)operator([)ident(i)operator(]) operator(<>) char<delimiter(')content(0)delimiter(')> reserved(then) + ident(Inc)operator(()ident(Result)operator(,) ident(HexOrd)operator(()ident(Hex)operator([)ident(i)operator(]\)) reserved(shl) operator((()ident(Length)operator(()ident(Hex)operator(\)) operator(-) ident(i)operator(\)) reserved(shl) integer(2)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(IntOfBin)operator(()ident(Bin)operator(:) reserved(string)operator(\):) ident(Cardinal)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(Bin) operator(:=) ident(Copy)operator(()ident(ExtractChars)operator(()ident(Bin)operator(,) ident(BinaryChars)operator(\),) integer(1)operator(,) integer(32)operator(\);) + + reserved(for) ident(i) operator(:=) ident(Length)operator(()ident(Bin)operator(\)) reserved(downto) integer(1) reserved(do) + reserved(if) ident(Bin)operator([)ident(i)operator(]) operator(=) char<delimiter(')content(1)delimiter(')> reserved(then) + ident(Inc)operator(()ident(Result)operator(,) integer(1) reserved(shl) operator(()ident(Length)operator(()ident(Bin)operator(\)) operator(-) ident(i)operator(\)\);) +reserved(end)operator(;) + +reserved(function) ident(BinOfInt)operator(()ident(n)operator(:) ident(Cardinal)operator(\):) reserved(string)operator(;) +reserved(var) + ident(a)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(n) operator(=) integer(0) reserved(then) reserved(begin) + ident(Result) operator(:=) char<delimiter(')content(0)delimiter(')>operator(;) + ident(exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(n) operator(>) integer(0) reserved(do) reserved(begin) + ident(a) operator(:=) ident(n) reserved(and) integer(1)operator(;) + ident(Result) operator(:=) ident(Char)operator(()ident(a) operator(+) ident(Byte)operator(()char<delimiter(')content(0)delimiter(')>operator(\)\)) operator(+) ident(Result)operator(;) + ident(n) operator(:=) ident(n) reserved(shr) integer(1)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(BinOfIntFill)operator(()ident(n)operator(:) ident(Cardinal)operator(;) ident(MinCount)operator(:) ident(Integer) operator(=) integer(8)operator(\):) reserved(string)operator(;) +reserved(var) + ident(a)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(n) operator(=) integer(0) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(MulStr)operator(()char<delimiter(')content(0)delimiter(')>operator(,) ident(MinCount)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(n) operator(>) integer(0) reserved(do) reserved(begin) + ident(a) operator(:=) ident(n) reserved(and) integer(1)operator(;) + ident(Result) operator(:=) ident(Char)operator(()ident(a) operator(+) ident(Byte)operator(()char<delimiter(')content(0)delimiter(')>operator(\)\)) operator(+) ident(Result)operator(;) + ident(n) operator(:=) ident(n) reserved(shr) integer(1)operator(;) + reserved(end)operator(;) + ident(Result) operator(:=) ident(MulStr)operator(()char<delimiter(')content(0)delimiter(')>operator(,) ident(MinCount) operator(-) ident(Length)operator(()ident(Result)operator(\)\)) operator(+) ident(Result)operator(;) +reserved(end)operator(;) + +reserved(function) ident(BaseNOfInt)operator(()ident(I)operator(:) ident(Cardinal)operator(;) ident(B)operator(:) ident(TBaseN)operator(\):) reserved(string)operator(;) +reserved(var) + ident(a)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) operator(()ident(B) operator(<) integer(2)operator(\)) reserved(or) operator(()ident(i) operator(=) integer(0)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) char<delimiter(')content(0)delimiter(')>operator(;) + ident(Exit)operator(;) reserved(end)operator(;) + + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + reserved(while) ident(i) operator(>) integer(0) reserved(do) reserved(begin) + ident(a) operator(:=) ident(i) reserved(mod) ident(B)operator(;) + ident(Result) operator(:=) ident(BaseNChar)operator([)ident(a)operator(]) operator(+) ident(Result)operator(;) + ident(i) operator(:=) ident(i) reserved(div) ident(B)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(IntOfBaseN)operator(()ident(V)operator(:) reserved(string)operator(;) ident(B)operator(:) ident(TBaseN)operator(\):) ident(Cardinal)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) + ident(F)operator(:) ident(Cardinal)operator(;) + ident(c)operator(:) ident(Byte)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + ident(V) operator(:=) ident(TrimAll)operator(()ident(V)operator(\);) + ident(F) operator(:=) integer(1)operator(;) + reserved(for) ident(i) operator(:=) ident(Length)operator(()ident(V)operator(\)) reserved(downto) integer(1) reserved(do) reserved(begin) + ident(c) operator(:=) ident(Byte)operator(()ident(UpCase)operator(()ident(V)operator([)ident(i)operator(]\)\);) + reserved(case) ident(Char)operator(()ident(c)operator(\)) reserved(of) + char<delimiter(')content(0)delimiter(')>operator(..)char<delimiter(')content(9)delimiter(')>operator(:) ident(c) operator(:=) ident(c) operator(-) integer(48)operator(;) + char<delimiter(')content(A)delimiter(')>operator(..)char<delimiter(')content(Z)delimiter(')>operator(:) ident(c) operator(:=) ident(c) operator(-) integer(55)operator(;) + reserved(end)operator(;) + reserved(if) ident(c) operator(<) ident(B) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(Byte)operator(()ident(c)operator(\)) operator(*) ident(F)operator(;) + ident(F) operator(:=) ident(F) operator(*) ident(B)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(KeepIn)operator(()ident(i)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Variant)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(i)operator(;) + reserved(if) ident(Result) operator(>) ident(Top) reserved(then) + ident(Result) operator(:=) ident(Top) + reserved(else) reserved(if) ident(Result) operator(<) ident(Bottom) reserved(then) + ident(Result) operator(:=) ident(Bottom)operator(;) +reserved(end)operator(;) + +reserved(function) ident(InRange)operator(()ident(Value)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Value) operator(>=) ident(Bottom)operator(\)) reserved(and) operator(()ident(Value) operator(<=) ident(Top)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(InStrictRange)operator(()ident(Value)operator(,) ident(Bottom)operator(,) ident(Top)operator(:) ident(Variant)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Value) operator(>) ident(Bottom)operator(\)) reserved(and) operator(()ident(Value) operator(<) ident(Top)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(Min)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(A) operator(<) ident(B) reserved(then) + ident(Result) operator(:=) ident(A) + reserved(else) + ident(Result) operator(:=) ident(B)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Min)operator(()reserved(const) ident(A)operator(:) ident(TIntA)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + reserved(if) ident(Length)operator(()ident(A)operator(\)) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) ident(A)operator([)integer(0)operator(];) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) + reserved(if) ident(A)operator([)ident(i)operator(]) operator(<) ident(Result) reserved(then) + ident(Result) operator(:=) ident(A)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(Max)operator(()reserved(const) ident(A)operator(,) ident(B)operator(:) ident(Integer)operator(\):) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(A) operator(>) ident(B) reserved(then) + ident(Result) operator(:=) ident(A) + reserved(else) + ident(Result) operator(:=) ident(B)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Max)operator(()reserved(const) ident(A)operator(:) ident(TIntA)operator(\):) ident(Integer)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + reserved(if) ident(Length)operator(()ident(A)operator(\)) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(Result) operator(:=) ident(A)operator([)integer(0)operator(];) + reserved(for) ident(i) operator(:=) integer(1) reserved(to) ident(High)operator(()ident(A)operator(\)) reserved(do) + reserved(if) ident(A)operator([)ident(i)operator(]) operator(>) ident(Result) reserved(then) + ident(Result) operator(:=) ident(A)operator([)ident(i)operator(];) +reserved(end)operator(;) + +reserved(function) ident(RangesOfStr)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) ident(TRanges)operator(;) +reserved(var) + ident(SL)operator(:) ident(TStringList)operator(;) + ident(r)operator(,) ident(b)operator(,) ident(t)operator(:) reserved(string)operator(;) + ident(i)operator(,) ident(p)operator(:) ident(Integer)operator(;) + + reserved(function) ident(TryStrToCard)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(;) reserved(out) ident(Value)operator(:) ident(Cardinal)operator(\):) ident(Boolean)operator(;) + reserved(var) + ident(E)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(Val)operator(()ident(S)operator(,) ident(Value)operator(,) ident(E)operator(\);) + ident(Result) operator(:=) ident(E) operator(=) integer(0)operator(;) + reserved(end)operator(;) + +reserved(begin) + ident(Result) operator(:=) reserved(nil)operator(;) + ident(SL) operator(:=) ident(TStringList)operator(.)ident(Create)operator(;) + reserved(try) + ident(Split)operator(()ident(S)operator(,) ident(RangesSeparator)operator(,) ident(SL)operator(\);) + ident(SetLength)operator(()ident(Result)operator(,) ident(SL)operator(.)ident(Count)operator(\);) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(SL)operator(.)ident(Count)operator(-)integer(1) reserved(do) reserved(begin) + ident(r) operator(:=) ident(SL)operator([)ident(i)operator(];) + reserved(with) ident(Result)operator([)ident(i)operator(]) reserved(do) reserved(begin) + ident(p) operator(:=) ident(CharPos)operator(()ident(RangeInnerSeparator)operator(,) ident(r)operator(\);) + ident(Simple) operator(:=) ident(p) operator(=) integer(0)operator(;) comment(// no '-' found) + reserved(if) ident(Simple) reserved(then) reserved(begin) + reserved(if) ident(r) operator(=) ident(RangeInfinite) reserved(then) reserved(begin) comment(// * --> *-*) + ident(Simple) operator(:=) ident(False)operator(;) + ident(Bottom) operator(:=) ident(Low)operator(()ident(Bottom)operator(\);) + ident(Top) operator(:=) ident(High)operator(()ident(Top)operator(\);) + reserved(end) reserved(else) reserved(if) reserved(not) ident(TryStrToCard)operator(()ident(r)operator(,) ident(Value)operator(\)) reserved(then) + ident(Break)operator(;) + + reserved(end) reserved(else) reserved(begin) + ident(TileStr)operator(()ident(r)operator(,) ident(p)operator(,) ident(p)operator(,) ident(b)operator(,) ident(t)operator(\);) + + reserved(if) ident(b) operator(=) ident(RangeInfinite) reserved(then) + ident(Bottom) operator(:=) ident(Low)operator(()ident(Bottom)operator(\)) + reserved(else) reserved(if) reserved(not) ident(TryStrToCard)operator(()ident(b)operator(,) ident(Bottom)operator(\)) reserved(then) + ident(Break)operator(;) + + reserved(if) ident(t) operator(=) ident(RangeInfinite) reserved(then) + ident(Top) operator(:=) ident(High)operator(()ident(Top)operator(\)) + reserved(else) reserved(if) reserved(not) ident(TryStrToCard)operator(()ident(t)operator(,) ident(Top)operator(\)) reserved(then) + ident(Break)operator(;) + reserved(if) ident(Bottom) operator(>) ident(Top) reserved(then) reserved(begin) + ident(p) operator(:=) ident(Bottom)operator(;) ident(Bottom) operator(:=) ident(Top)operator(;) ident(Top) operator(:=) ident(p)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) ident(i) operator(<>) ident(SL)operator(.)ident(Count) reserved(then) + ident(Result) operator(:=) reserved(nil)operator(;) + + reserved(finally) + ident(SL)operator(.)ident(Free)operator(;) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(function) ident(InRanges)operator(()ident(Ranges)operator(:) ident(TRanges)operator(;) ident(TestValue)operator(:) ident(Cardinal)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(True)operator(;) + + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(High)operator(()ident(Ranges)operator(\)) reserved(do) + reserved(with) ident(Ranges)operator([)ident(i)operator(]) reserved(do) + reserved(if) ident(Simple) reserved(then) reserved(begin) + reserved(if) ident(TestValue) operator(=) ident(Value) reserved(then) + ident(Exit)operator(;) + reserved(end) reserved(else) reserved(begin) + reserved(if) ident(InRange)operator(()ident(TestValue)operator(,) ident(Bottom)operator(,) ident(Top)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(end)operator(;) + + ident(Result) operator(:=) ident(False)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(WriteSL)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) reserved(const) ident(Prefix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(;) + reserved(const) ident(Suffix)operator(:) reserved(string) operator(=) string<delimiter(')delimiter(')>operator(\);) +reserved(var) + ident(i)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(for) ident(i) operator(:=) integer(0) reserved(to) ident(Strings)operator(.)ident(Count)operator(-)integer(1) reserved(do) + ident(WriteLn)operator(()ident(Prefix) operator(+) ident(Strings)operator([)ident(i)operator(]) operator(+) ident(Suffix)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(Success)operator(()ident(Res)operator(:) ident(Integer)operator(;) ident(ResultOnSuccess)operator(:) ident(Integer) operator(=) ident(ERROR_SUCCESS)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Res) operator(=) ident(ResultOnSuccess)operator(\);) + ident(LastSuccessRes) operator(:=) ident(Res)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Failure)operator(()ident(Res)operator(:) ident(Integer)operator(;) ident(ResultOnSuccess)operator(:) ident(Integer) operator(=) ident(ERROR_SUCCESS)operator(\):) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) reserved(not) ident(Success)operator(()ident(Res)operator(,) ident(ResultOnSuccess)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(ExpandString)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Len)operator(:) ident(Integer)operator(;) + ident(P)operator(,) ident(Res)operator(:) ident(PChar)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(P) operator(:=) ident(PChar)operator(()ident(S)operator(\);) + ident(Len) operator(:=) ident(ExpandEnvironmentStrings)operator(()ident(P)operator(,) reserved(nil)operator(,) integer(0)operator(\);) + reserved(if) ident(Len) operator(=) integer(0) reserved(then) + ident(Exit)operator(;) + + ident(GetMem)operator(()ident(Res)operator(,) ident(Len)operator(\);) + ident(ExpandEnvironmentStrings)operator(()ident(P)operator(,) ident(Res)operator(,) ident(Len)operator(\);) + + ident(Result) operator(:=) ident(Res)operator(;) + ident(FreeMem)operator(()ident(Res)operator(,) ident(Len)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(FindAll)operator(()ident(Strings)operator(:) ident(TStrings)operator(;) reserved(const) ident(Mask)operator(:) reserved(string)operator(;) + ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(;) + ident(FileReturn)operator(:) ident(TFileNameFunc) operator(=) reserved(nil)operator(\):) ident(Boolean)operator(;) +reserved(var) + ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(;) + + reserved(procedure) ident(ScanDir)operator(()reserved(const) ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(\);) + reserved(var) + ident(PSR)operator(:) ident(TSearchRec)operator(;) + ident(Res)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(Add)operator(()reserved(const) ident(S)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(if) ident(S) operator(<>) string<delimiter(')delimiter(')> reserved(then) + ident(Strings)operator(.)ident(Add)operator(()ident(S)operator(\);) + reserved(end)operator(;) + + reserved(begin) + ident(Res) operator(:=) ident(FindFirst)operator(()ident(Path) operator(+) ident(FileName)operator(,) ident(Attributes)operator(,) ident(PSR)operator(\);) + reserved(while) ident(Success)operator(()ident(Res)operator(,) integer(0)operator(\)) reserved(do) reserved(begin) + reserved(if) ident(Assigned)operator(()ident(FileReturn)operator(\)) reserved(then) + ident(Add)operator(()ident(FileReturn)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(\)\)) + reserved(else) + ident(Add)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(\);) + ident(Res) operator(:=) ident(FindNext)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(if) reserved(not) ident(ScanSubDirs) reserved(then) + ident(Exit)operator(;) + + ident(Res) operator(:=) ident(FindFirst)operator(()ident(Path) operator(+) char<delimiter(')content(*)delimiter(')>operator(,) ident(faDirectory)operator(,) ident(PSR)operator(\);) + reserved(while) ident(Success)operator(()ident(Res)operator(,) integer(0)operator(\)) reserved(do) reserved(begin) + reserved(if) operator(()ident(PSR)operator(.)ident(Attr) reserved(and) ident(faDirectory) operator(>) integer(0)operator(\)) + reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) char<delimiter(')content(.)delimiter(')>operator(\)) reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) string<delimiter(')content(..)delimiter(')>operator(\)) reserved(then) + ident(ScanDir)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name) operator(+) char<delimiter(')content(\\)delimiter(')>operator(,) ident(FileName)operator(\);) + ident(Res) operator(:=) ident(FindNext)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + +reserved(begin) + ident(Strings)operator(.)ident(Clear)operator(;) + ident(Path) operator(:=) ident(ExtractPath)operator(()ident(Mask)operator(\);) + ident(FileName) operator(:=) ident(ExtractFileName)operator(()ident(Mask)operator(\);) + ident(ScanDir)operator(()ident(Path)operator(,) ident(FileName)operator(\);) + ident(Result) operator(:=) ident(Strings)operator(.)ident(Count) operator(>) integer(0)operator(;) +reserved(end)operator(;) + +reserved(function) ident(FindAllFirst)operator(()reserved(const) ident(Mask)operator(:) reserved(string)operator(;) ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(;) + + reserved(function) ident(ScanDir)operator(()reserved(const) ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(\):) ident(Boolean)operator(;) + reserved(var) + ident(PSR)operator(:) ident(TSearchRec)operator(;) + ident(Res)operator(:) ident(Integer)operator(;) + reserved(begin) + ident(Result) operator(:=) ident(False)operator(;) + reserved(if) ident(Success)operator(()ident(FindFirst)operator(()ident(Path) operator(+) ident(FileName)operator(,) ident(Attributes)operator(,) ident(PSR)operator(\),) integer(0)operator(\)) reserved(then) reserved(begin) + ident(FindAllFirst) operator(:=) ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(;) + ident(Result) operator(:=) ident(True)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + ident(Exit)operator(;) reserved(end)operator(;) + reserved(if) reserved(not) ident(ScanSubDirs) reserved(then) + ident(Exit)operator(;) + + ident(Res) operator(:=) ident(FindFirst)operator(()ident(Path) operator(+) char<delimiter(')content(*)delimiter(')>operator(,) ident(faDirectory)operator(,) ident(PSR)operator(\);) + reserved(while) reserved(not) ident(Result) reserved(and) ident(Success)operator(()ident(Res)operator(,) integer(0)operator(\)) reserved(do) reserved(begin) + reserved(if) operator(()ident(PSR)operator(.)ident(Attr) reserved(and) ident(faDirectory) operator(>) integer(0)operator(\)) + reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) char<delimiter(')content(.)delimiter(')>operator(\)) reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) string<delimiter(')content(..)delimiter(')>operator(\)) reserved(then) + ident(Result) operator(:=) ident(ScanDir)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name) operator(+) char<delimiter(')content(\\)delimiter(')>operator(,) ident(FileName)operator(\);) + ident(Res) operator(:=) ident(FindNext)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(Path) operator(:=) ident(ExtractPath)operator(()ident(Mask)operator(\);) + ident(FileName) operator(:=) ident(ExtractFileName)operator(()ident(Mask)operator(\);) + ident(ScanDir)operator(()ident(Path)operator(,) ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(DeleteFiles)operator(()reserved(const) ident(Mask)operator(:) reserved(string)operator(;) ident(ScanSubDirs)operator(:) ident(Boolean) operator(=) ident(True)operator(;) + ident(Attributes)operator(:) ident(Integer) operator(=) ident(faFindEveryFile)operator(\);) +reserved(var) + ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(;) + + reserved(procedure) ident(ScanDir)operator(()reserved(const) ident(Path)operator(,) ident(FileName)operator(:) reserved(string)operator(\);) + reserved(var) + ident(PSR)operator(:) ident(TSearchRec)operator(;) + ident(Res)operator(:) ident(Integer)operator(;) + + reserved(procedure) ident(TryDeleteFile)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\);) + reserved(begin) + reserved(try) + ident(DeleteFile)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(\);) + reserved(except) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(begin) + ident(Res) operator(:=) ident(FindFirst)operator(()ident(Path) operator(+) ident(FileName)operator(,) ident(Attributes)operator(,) ident(PSR)operator(\);) + reserved(while) ident(Success)operator(()ident(Res)operator(,) integer(0)operator(\)) reserved(do) reserved(begin) + ident(TryDeleteFile)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(\);) + ident(Res) operator(:=) ident(FindNext)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(if) reserved(not) ident(ScanSubDirs) reserved(then) + ident(Exit)operator(;) + + ident(Res) operator(:=) ident(FindFirst)operator(()ident(Path) operator(+) char<delimiter(')content(*)delimiter(')>operator(,) ident(faDirectory)operator(,) ident(PSR)operator(\);) + reserved(while) ident(Success)operator(()ident(Res)operator(,) integer(0)operator(\)) reserved(do) reserved(begin) + reserved(if) operator(()ident(PSR)operator(.)ident(Attr) reserved(and) ident(faDirectory) operator(>) integer(0)operator(\)) + reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) char<delimiter(')content(.)delimiter(')>operator(\)) reserved(and) operator(()ident(PSR)operator(.)ident(Name) operator(<>) string<delimiter(')content(..)delimiter(')>operator(\)) reserved(then) reserved(begin) + ident(ScanDir)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name) operator(+) char<delimiter(')content(\\)delimiter(')>operator(,) ident(FileName)operator(\);) + ident(TryDeleteFile)operator(()ident(Path) operator(+) ident(PSR)operator(.)ident(Name)operator(\);) + reserved(end)operator(;) + ident(Res) operator(:=) ident(FindNext)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(end)operator(;) +reserved(begin) + ident(Path) operator(:=) ident(ExtractPath)operator(()ident(Mask)operator(\);) + ident(FileName) operator(:=) ident(ExtractFileName)operator(()ident(Mask)operator(\);) + ident(ScanDir)operator(()ident(Path)operator(,) ident(FileName)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(GetFileNew)operator(()ident(FileName)operator(:) reserved(string)operator(;) ident(NoFloppyDrives)operator(:) ident(Boolean) operator(=) ident(True)operator(\):) reserved(string)operator(;) +reserved(var) + ident(Drive)operator(:) reserved(string)operator(;) + ident(pf)operator(,) ident(pd)operator(,) ident(Len)operator(:) ident(Integer)operator(;) + ident(PSR)operator(:) ident(TSearchRec)operator(;) +reserved(begin) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(FileName) operator(:=) ident(Trim)operator(()ident(FileName)operator(\);) + reserved(if) ident(Length)operator(()ident(FileName)operator(\)) operator(<) integer(2) reserved(then) + ident(Exit)operator(;) + + ident(Drive) operator(:=) ident(ExtractDrive)operator(()ident(FileName)operator(\);) + reserved(if) reserved(not) ident(DirectoryExists)operator(()ident(Drive)operator(\)) reserved(then) + ident(Exit)operator(;) + + reserved(if) ident(NoFloppyDrives) reserved(and) operator(()ident(Drive)operator([)integer(1)operator(]) reserved(in) operator([)char<delimiter(')content(A)delimiter(')>operator(,) char<delimiter(')content(B)delimiter(')>operator(]\)) reserved(then) + ident(Exit)operator(;) + + ident(Len) operator(:=) ident(Length)operator(()ident(FileName)operator(\);) + ident(Result) operator(:=) ident(Drive)operator(;) + ident(pf) operator(:=) ident(Length)operator(()ident(Drive)operator(\)) operator(+) integer(1)operator(;) + reserved(while) ident(pf) operator(<=) ident(Len) reserved(do) reserved(begin) + reserved(if) ident(FileName)operator([)ident(pf)operator(]) operator(=) char<delimiter(')content(\\)delimiter(')> reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) char<delimiter(')content(\\)delimiter(')>operator(;) + ident(Inc)operator(()ident(pf)operator(\);) + ident(Continue)operator(;) reserved(end)operator(;) + + ident(pd) operator(:=) ident(CharPos)operator(()char<delimiter(')content(\\)delimiter(')>operator(,) ident(FileName)operator(,) ident(pf)operator(\);) + reserved(if) ident(pd) operator(=) integer(0) reserved(then) reserved(begin) + reserved(if) integer(0)operator(=)ident(FindFirst)operator(()ident(Result) operator(+) ident(Copy)operator(()ident(FileName)operator(,) ident(pf)operator(,) ident(MaxInt)operator(\),) ident(faFindEveryFile)operator(,) ident(PSR)operator(\)) reserved(then) reserved(begin) + ident(Result) operator(:=) ident(Result) operator(+) ident(PSR)operator(.)ident(Name)operator(;) + ident(Break)operator(;) reserved(end) reserved(else) reserved(begin) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(if) integer(0)operator(=)ident(FindFirst)operator(()ident(Result) operator(+) ident(Copy)operator(()ident(FileName)operator(,) ident(pf)operator(,) ident(MaxInt)operator(\),) ident(faDirectory)operator(,) ident(PSR)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(PSR)operator(.)ident(Name) operator(+) char<delimiter(')content(\\)delimiter(')> + reserved(else) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(if) ident(Result) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Break)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + + reserved(if) integer(0)operator(=)ident(FindFirst)operator(()ident(Result) operator(+) ident(Copy)operator(()ident(FileName)operator(,) ident(pf)operator(,) ident(pd) operator(-) ident(pf)operator(\),) ident(faDirectory)operator(,) ident(PSR)operator(\)) reserved(then) + ident(Result) operator(:=) ident(Result) operator(+) ident(PSR)operator(.)ident(Name) operator(+) char<delimiter(')content(\\)delimiter(')> + reserved(else) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) + ident(FindClose)operator(()ident(PSR)operator(\);) + reserved(if) ident(Result) operator(=) string<delimiter(')delimiter(')> reserved(then) + ident(Break)operator(;) + + ident(pf) operator(:=) ident(pd) operator(+) integer(1)operator(;) + reserved(end)operator(;) + + reserved(if) operator(()ident(Result) operator(<>) string<delimiter(')delimiter(')>operator(\)) reserved(and) reserved(not) ident(FileEx)operator(()ident(Result)operator(,) ident(True)operator(\)) reserved(then) + ident(Result) operator(:=) string<delimiter(')delimiter(')>operator(;) +reserved(end)operator(;) + +reserved(function) ident(DateTimeOfFileTime)operator(()reserved(const) ident(FileTime)operator(:) ident(TFileTime)operator(\):) ident(TDateTime)operator(;) +reserved(var) + ident(LocalFileTime)operator(:) ident(TFileTime)operator(;) + ident(Res)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + + ident(FileTimeToLocalFileTime)operator(()ident(FileTime)operator(,) ident(LocalFileTime)operator(\);) + reserved(if) reserved(not) ident(FileTimeToDosDateTime)operator(()ident(LocalFileTime)operator(,) ident(LongRec)operator(()ident(Res)operator(\).)ident(Hi)operator(,) + ident(LongRec)operator(()ident(Res)operator(\).)ident(Lo)operator(\)) reserved(then) + ident(Res) operator(:=) operator(-)integer(1)operator(;) + + reserved(if) operator(()ident(Res) operator(=) operator(-)integer(1)operator(\)) reserved(or) operator(()ident(Res) operator(=) integer(0)operator(\)) reserved(then) + ident(Exit)operator(;) + reserved(try) + ident(Result) operator(:=) ident(FileDateToDateTime)operator(()ident(Res)operator(\);) + reserved(except) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(FileNew)operator(()reserved(const) ident(FileName)operator(:) reserved(string)operator(\);) +reserved(var) + ident(Handle)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(Handle) operator(:=) ident(FileCreate)operator(()ident(FileName)operator(\);) + ident(FileClose)operator(()ident(Handle)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(Win32PlatformStr)operator(:) reserved(string)operator(;) +reserved(const) + ident(PlatformStrings)operator(:) reserved(array)operator([)ident(VER_PLATFORM_WIN32s)operator(..)ident(VER_PLATFORM_WIN32_NT)operator(]) reserved(of) reserved(string) operator(=) + operator(()string<delimiter(')content(VER_PLATFORM_WIN32s)delimiter(')>operator(,) string<delimiter(')content(VER_PLATFORM_WIN32_WINDOWS)delimiter(')>operator(,) string<delimiter(')content(VER_PLATFORM_WIN32_NT)delimiter(')>operator(\);) +reserved(begin) + ident(Result) operator(:=) ident(PlatformStrings)operator([)ident(Win32Platform)operator(];) +reserved(end)operator(;) + +reserved(function) ident(FullOSInfo)operator(:) reserved(string)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Format)operator(() + string<delimiter(')content(Platform: %s)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(Version: %d.%d Build %d)delimiter(')> operator(+) ident(EOL) operator(+) + string<delimiter(')content(CSD: %s)delimiter(')>operator(,) + operator([) + ident(Win32PlatformStr)operator(,) + ident(Win32MajorVersion)operator(,) ident(Win32MinorVersion)operator(,) ident(Win32BuildNumber)operator(,) + ident(Win32CSDVersion) + operator(]) + operator(\);) +reserved(end)operator(;) + +reserved(function) ident(Win9x)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Win32Platform) operator(=) ident(VER_PLATFORM_WIN32_WINDOWS)operator(;) +reserved(end)operator(;) + +reserved(function) ident(WinNT)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Win32Platform) operator(=) ident(VER_PLATFORM_WIN32_NT)operator(;) +reserved(end)operator(;) + +reserved(function) ident(Win2000)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) operator(()ident(Win32Platform) operator(=) ident(VER_PLATFORM_WIN32_NT)operator(\)) + reserved(and) operator(()ident(Win32MajorVersion) operator(=) integer(4)operator(\);) +reserved(end)operator(;) + +reserved(function) ident(WinXP)operator(:) ident(Boolean)operator(;) +reserved(begin) + ident(Result) operator(:=) ident(Win32MajorVersion) operator(>=) integer(5)operator(;) +reserved(end)operator(;) + +reserved(initialization) + ident(MyDir) operator(:=) ident(GetMyDir)operator(;) + +reserved(end)operator(.) + +reserved(unit) ident(FifoStream)operator(;) + +reserved(interface) + +reserved(uses) ident(Classes)operator(,) ident(windows)operator(,) ident(Dialogs)operator(;) + +reserved(const) + ident(DefaultChunksize) operator(=) integer(32768)operator(;) comment(// 32kb per chunk as default.) + +reserved(type) + ident(PMemChunk) operator(=) operator(^)ident(TMemChunk)operator(;) + ident(TMemChunk) operator(=) reserved(record) + ident(Filled)operator(:) ident(Longword)operator(;) + ident(Read)operator(:) ident(Longword)operator(;) + ident(Data)operator(:) ident(pointer)operator(;) + reserved(end)operator(;) + + ident(TFifo) operator(=) reserved(class) + directive(private) + ident(FBuffers)operator(:) ident(TList)operator(;) + ident(FChunksize)operator(:) ident(Longword)operator(;) + ident(FCritSect)operator(:) ident(TRTLCriticalSection)operator(;) + ident(FIsWinNT)operator(:) ident(boolean)operator(;) + ident(FBytesInFifo)operator(:) ident(LongWord)operator(;) + directive(protected) + reserved(function) ident(GetBytesInFifo)operator(:) ident(LongWord)operator(;) + directive(public) + reserved(constructor) ident(Create)operator(;) + reserved(destructor) ident(Destroy)operator(;) directive(override)operator(;) + reserved(procedure) ident(Write)operator(()ident(Data)operator(:) ident(pointer)operator(;) ident(Size)operator(:) ident(LongWord)operator(\);) + reserved(procedure) ident(Read)operator(()ident(Buff)operator(:) ident(pointer)operator(;) reserved(var) ident(ReqSize)operator(:) ident(LongWord)operator(\);) + reserved(procedure) ident(PeekData)operator(()ident(Buff)operator(:) ident(pointer)operator(;) reserved(var) ident(ReqSize)operator(:) ident(LongWord)operator(\);) + directive(published) + reserved(property) ident(BytesInFifo)operator(:) ident(LongWord) directive(read) ident(FBytesInFifo)operator(;) + reserved(end)operator(;) + +reserved(implementation) + +reserved(constructor) ident(TFifo)operator(.)ident(Create)operator(;) +reserved(begin) + reserved(inherited)operator(;) + ident(FBuffers) operator(:=) ident(TList)operator(.)ident(Create)operator(;) + comment(// set default chunksize...) + ident(FChunksize) operator(:=) ident(DefaultChunksize)operator(;) + ident(InitializeCriticalSection)operator(()ident(FCritSect)operator(\);) +reserved(end)operator(;) + +reserved(destructor) ident(TFifo)operator(.)ident(Destroy)operator(;) +reserved(var) + ident(I)operator(:) ident(Integer)operator(;) +reserved(begin) + ident(EnterCriticalSection)operator(()ident(FCritSect)operator(\);) + reserved(for) ident(I) operator(:=) integer(0) reserved(to) ident(FBuffers)operator(.)ident(count) operator(-) integer(1) reserved(do) + reserved(begin) + ident(FreeMem)operator(()ident(PMemChunk)operator(()ident(Fbuffers)operator([)ident(I)operator(]\).)ident(Data)operator(\);) + ident(Dispose)operator(()ident(PMemChunk)operator(()ident(Fbuffers)operator([)ident(I)operator(]\)\);) + reserved(end)operator(;) + ident(FBuffers)operator(.)ident(Clear)operator(;) + ident(FBuffers)operator(.)ident(Free)operator(;) + ident(LeaveCriticalSection)operator(()ident(FCritSect)operator(\);) + + ident(DeleteCriticalSection)operator(()ident(FCritSect)operator(\);) + reserved(inherited)operator(;) +reserved(end)operator(;) + +reserved(function) ident(TFifo)operator(.)ident(GetBytesInFifo)operator(:) ident(LongWord)operator(;) +reserved(begin) + ident(Result) operator(:=) integer(0)operator(;) + reserved(if) ident(FBuffers)operator(.)ident(Count) operator(=) integer(0) reserved(then) + reserved(begin) + ident(exit)operator(;) + reserved(end) + reserved(else) + reserved(begin) + reserved(if) ident(FBuffers)operator(.)ident(Count) operator(>) integer(1) reserved(then) + ident(Inc)operator(()ident(Result)operator(,) operator(()ident(FBuffers)operator(.)ident(Count) operator(-) integer(1)operator(\)) operator(*) ident(FChunkSize)operator(\);) + ident(Inc)operator(()ident(Result)operator(,) ident(PMemChunk)operator(()ident(FBuffers)operator([)ident(Fbuffers)operator(.)ident(Count) operator(-) integer(1)operator(]\).)ident(Filled)operator(\);) + ident(Dec)operator(()ident(Result)operator(,) ident(PMemChunk)operator(()ident(FBuffers)operator([)integer(0)operator(]\).)ident(Read)operator(\);) + reserved(end)operator(;) +reserved(end)operator(;) + +reserved(procedure) ident(TFifo)operator(.)ident(Write)operator(()ident(Data)operator(:) ident(pointer)operator(;) ident(Size)operator(:) ident(LongWord)operator(\);) +reserved(var) + ident(Privpointer)operator(:) ident(pointer)operator(;) + ident(PrivSize)operator(:) ident(LongWord)operator(;) + ident(Chunk)operator(:) ident(PMemChunk)operator(;) + ident(PosInChunk)operator(:) ident(pointer)operator(;) +reserved(begin) + reserved(if) ident(LongWord)operator(()ident(Data)operator(\)) operator(=) integer(0) reserved(then) + reserved(begin) + comment(// null pointer? somebody is trying to fool us, get out...) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(EnterCriticalSection)operator(()ident(FCritSect)operator(\);) + ident(PrivPointer) operator(:=) ident(Data)operator(;) + ident(PrivSize) operator(:=) integer(0)operator(;) + comment(// are already buffers there?) + reserved(if) ident(FBuffers)operator(.)ident(count) operator(>) integer(0) reserved(then) + reserved(begin) + comment(// is the last one of them not completely filled?) + reserved(if) ident(PMemChunk)operator(()ident(FBuffers)operator([)ident(FBuffers)operator(.)ident(count) operator(-) integer(1)operator(]\).)ident(filled) operator(<) ident(FChunksize) reserved(then) + comment(// not completely filled, so fill up the buffer.) + reserved(begin) + ident(Chunk) operator(:=) ident(PMemChunk)operator(()ident(FBuffers)operator([)ident(FBuffers)operator(.)ident(count) operator(-) integer(1)operator(]\);) + comment(// fetch chunkdata.) + ident(PosInChunk) operator(:=) ident(Chunk)operator(.)ident(Data)operator(;) + comment(// move to current fill pos...) + ident(Inc)operator(()ident(LongWord)operator(()ident(PosInChunk)operator(\),) ident(Chunk)operator(.)ident(Filled)operator(\);) + comment(// can we fill the chunk completely?) + reserved(if) ident(Size) operator(>) ident(FChunksize) operator(-) ident(Chunk)operator(.)ident(Filled) reserved(then) + reserved(begin) + comment(// yes we can.) + ident(Move)operator(()ident(PrivPointer)operator(^,) ident(PosInChunk)operator(^,) ident(FChunksize) operator(-) ident(Chunk)operator(.)ident(Filled)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(FChunksize) operator(-) ident(Chunk)operator(.)ident(Filled)operator(\);) + ident(Inc)operator(()ident(LongWord)operator(()ident(PrivPointer)operator(\),) ident(FChunksize) operator(-) ident(Chunk)operator(.)ident(Filled)operator(\);) + ident(Chunk)operator(.)ident(Filled) operator(:=) ident(FChunkSize)operator(;) + reserved(end) + reserved(else) + comment(// we have to less data for filling the chunk completely,) + comment(// just put everything in.) + reserved(begin) + ident(Move)operator(()ident(PrivPointer)operator(^,) ident(PosInChunk)operator(^,) ident(Size)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(Size)operator(\);) + ident(Inc)operator(()ident(Chunk)operator(.)ident(Filled)operator(,) ident(Size)operator(\);) + reserved(end)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + comment(// as long as we have remaining stuff put it into new chunks.) + reserved(while) operator(()ident(PrivSize) operator(<) ident(Size)operator(\)) reserved(do) + reserved(begin) + ident(new)operator(()ident(Chunk)operator(\);) + ident(GetMem)operator(()ident(Chunk)operator(.)ident(Data)operator(,) ident(FChunksize)operator(\);) + ident(Chunk)operator(.)ident(Read) operator(:=) integer(0)operator(;) + comment(// can we fill an entire chunk with the remaining data?) + reserved(if) ident(Privsize) operator(+) ident(FChunksize) operator(<) ident(Size) reserved(then) + reserved(begin) + comment(// yes we can, so put the stuff in.) + ident(Move)operator(()ident(Privpointer)operator(^,) ident(Chunk)operator(.)ident(Data)operator(^,) ident(FChunksize)operator(\);) + ident(Inc)operator(()ident(LongWord)operator(()ident(PrivPointer)operator(\),) ident(FChunksize)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(FChunksize)operator(\);) + ident(Chunk)operator(.)ident(Filled) operator(:=) ident(FChunksize)operator(;) + reserved(end) + reserved(else) comment(// we have to less data to fill the entire chunk, just put the remaining stuff in.) + reserved(begin) + ident(Move)operator(()ident(Privpointer)operator(^,) ident(Chunk)operator(.)ident(Data)operator(^,) ident(Size) operator(-) ident(Privsize)operator(\);) + ident(Chunk)operator(.)ident(Filled) operator(:=) ident(Size) operator(-) ident(Privsize)operator(;) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(Size) operator(-) ident(Privsize)operator(\);) + reserved(end)operator(;) + ident(Fbuffers)operator(.)ident(Add)operator(()ident(Chunk)operator(\);) + reserved(end)operator(;) + reserved(if) ident(Size) operator(<>) ident(Privsize) reserved(then) + ident(Showmessage)operator(()string<delimiter(')content(miscalculation in TFifo.write)delimiter(')>operator(\);) + ident(FBytesInFifo) operator(:=) ident(GetBytesInFifo)operator(;) + ident(LeaveCriticalSection)operator(()ident(FCritSect)operator(\);) +reserved(end)operator(;) + +reserved(procedure) ident(TFifo)operator(.)ident(Read)operator(()ident(Buff)operator(:) ident(pointer)operator(;) reserved(var) ident(ReqSize)operator(:) ident(LongWord)operator(\);) +reserved(var) + ident(PrivSize)operator(:) ident(Integer)operator(;) + ident(Privpos)operator(:) ident(pointer)operator(;) + ident(Chunk)operator(:) ident(PMemChunk)operator(;) + ident(ChunkPos)operator(:) ident(pointer)operator(;) +reserved(begin) + reserved(if) ident(LongWord)operator(()ident(Buff)operator(\)) operator(=) integer(0) reserved(then) + reserved(begin) + comment(// null pointer? somebody is trying to fool us, get out...) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(EnterCriticalSection)operator(()ident(FCritSect)operator(\);) + ident(PrivSize) operator(:=) integer(0)operator(;) + ident(Privpos) operator(:=) ident(Buff)operator(;) + reserved(while) ident(FBuffers)operator(.)ident(Count) operator(>) integer(0) reserved(do) + reserved(begin) + ident(Chunk) operator(:=) ident(PMemChunk)operator(()ident(FBuffers)operator([)integer(0)operator(]\);) + ident(ChunkPos) operator(:=) ident(Chunk)operator(.)ident(data)operator(;) + ident(Inc)operator(()ident(LongWord)operator(()ident(ChunkPos)operator(\),) ident(Chunk)operator(.)ident(Read)operator(\);) + comment(// does the remaining part of the chunk fit into the buffer?) + reserved(if) ident(PrivSize) operator(+) operator(()ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\)) operator(<) ident(ReqSize) reserved(then) + reserved(begin) comment(// yep, it fits) + ident(Move)operator(()ident(ChunkPos)operator(^,) ident(Privpos)operator(^,) ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\);) + ident(FreeMem)operator(()ident(Chunk)operator(.)ident(Data)operator(\);) + ident(Dispose)operator(()ident(Chunk)operator(\);) + ident(FBuffers)operator(.)ident(Delete)operator(()integer(0)operator(\);) + reserved(end) + reserved(else) comment(// remaining part didn't fit, get as much as we can and increment the) + comment(// read attribute.) + reserved(begin) + ident(Move)operator(()ident(ChunkPos)operator(^,) ident(Privpos)operator(^,) ident(ReqSize) operator(-) ident(PrivSize)operator(\);) + ident(Inc)operator(()ident(Chunk)operator(.)directive(read)operator(,) ident(ReqSize) operator(-) ident(PrivSize)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(ReqSize) operator(-) ident(PrivSize)operator(\);) + comment(// as we filled the buffer, we'll have to break here.) + ident(break)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + ident(FBytesInFifo) operator(:=) ident(GetBytesInFifo)operator(;) + ident(LeaveCriticalSection)operator(()ident(FCritSect)operator(\);) + ident(ReqSize) operator(:=) ident(PrivSize)operator(;) +reserved(end)operator(;) + +comment(// read Data from Stream without removing it from the Stream...) + +reserved(procedure) ident(TFifo)operator(.)ident(PeekData)operator(()ident(Buff)operator(:) ident(pointer)operator(;) reserved(var) ident(ReqSize)operator(:) ident(LongWord)operator(\);) +reserved(var) + ident(PrivSize)operator(:) ident(Integer)operator(;) + ident(Privpos)operator(:) ident(pointer)operator(;) + ident(Chunk)operator(:) ident(PMemChunk)operator(;) + ident(ChunkPos)operator(:) ident(pointer)operator(;) + ident(ChunkNr)operator(:) ident(Integer)operator(;) +reserved(begin) + reserved(if) ident(LongWord)operator(()ident(Buff)operator(\)) operator(=) integer(0) reserved(then) + reserved(begin) + comment(// null pointer? somebody is trying to fool us, get out...) + ident(Exit)operator(;) + reserved(end)operator(;) + ident(EnterCriticalSection)operator(()ident(FCritSect)operator(\);) + ident(PrivSize) operator(:=) integer(0)operator(;) + ident(Privpos) operator(:=) ident(Buff)operator(;) + ident(ChunkNr) operator(:=) integer(0)operator(;) + reserved(while) ident(FBuffers)operator(.)ident(Count) operator(>) ident(ChunkNr) reserved(do) + reserved(begin) + ident(Chunk) operator(:=) ident(PMemChunk)operator(()ident(FBuffers)operator([)ident(ChunkNr)operator(]\);) + ident(ChunkPos) operator(:=) ident(Chunk)operator(.)ident(data)operator(;) + ident(Inc)operator(()ident(LongWord)operator(()ident(ChunkPos)operator(\),) ident(Chunk)operator(.)ident(Read)operator(\);) + comment(// does the remaining part of the chunk fit into the buffer?) + reserved(if) ident(PrivSize) operator(+) operator(()ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\)) operator(<) ident(ReqSize) reserved(then) + reserved(begin) comment(// yep, it fits) + ident(Move)operator(()ident(ChunkPos)operator(^,) ident(Privpos)operator(^,) ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(Chunk)operator(.)ident(Filled) operator(-) ident(Chunk)operator(.)directive(read)operator(\);) + ident(Inc)operator(()ident(ChunkNr)operator(\);) + reserved(end) + reserved(else) comment(// remaining part didn't fit, get as much as we can and increment the) + comment(// read attribute.) + reserved(begin) + ident(Move)operator(()ident(ChunkPos)operator(^,) ident(Privpos)operator(^,) ident(ReqSize) operator(-) ident(PrivSize)operator(\);) + ident(Inc)operator(()ident(PrivSize)operator(,) ident(ReqSize) operator(-) ident(PrivSize)operator(\);) + comment(// as we filled the buffer, we'll have to break here.) + ident(break)operator(;) + reserved(end)operator(;) + reserved(end)operator(;) + ident(LeaveCriticalSection)operator(()ident(FCritSect)operator(\);) + ident(ReqSize) operator(:=) ident(PrivSize)operator(;) +reserved(end)operator(;) + +reserved(end)operator(.) |