current/DataAccess/Access_OniArchive.pas

unit Access_OniArchive;
interface

uses DataAccess, Classes, TypeDefs;

type
  TAccess_OniArchive = class(TDataAccess)
  private
    Fdat_file:           TFileStream;
    Fraw_file:           TFileStream;
    Fsep_file:           TFileStream;
    Fdat_files:          TFiles;
    Fdat_extensionsmap:  TExtensionsMap;
    FUnloadWhenUnused:   Boolean;
    FDatOpened:          Boolean;
    FRawOpened:          Boolean;
    FSepOpened:          Boolean;
  protected
  public
    property UnloadWhenUnused: Boolean Read FUnloadWhenUnused Write FUnloadWhenUnused;

    constructor Create(DatFilename: String; ConnectionID: Integer; var Msg: TStatusMessages); override;
    procedure Close; override;

    function GetFileInfo(FileID: Integer): TFileInfo; override;
    function GetFilesList(Ext: String; Pattern: String;
      NoEmptyFiles: Boolean; SortType: TSortType): TStrings; override;
    function GetFileCount: Integer; override;
    function GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings; override;

    procedure LoadDatFile(FileID: Integer; var Target: TStream); overload; override;
    procedure UpdateDatFile(FileID: Integer; Src: TStream); overload; override;
    procedure LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream); overload; override;
    procedure UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream); overload; override;

    function GetDatLinks(FileID: Integer): TDatLinkList; override;
    function GetDatLink(FileID, DatOffset: Integer): TDatLink; override;
    function GetRawList(FileID: Integer): TRawDataList; override;
    function GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo; override;

    procedure LoadRawOffset(LocSep: Boolean; RawAddr, Size: Integer; target: Pointer);
    procedure LoadRawFile(FileID, DatOffset: Integer; var Target: TStream); overload; override;
    procedure UpdateRawFile(FileID, DatOffset: Integer; Src: TStream); overload; override;
    procedure LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream); overload; override;
    procedure UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream); overload; override;

    function AppendRawFile(LocSep: Boolean; Src: TStream): Integer; overload; override;
  published
  end;

implementation

uses
  SysUtils, StrUtils, Data, Functions, RawList, DatLinks;


(*
================================================================================
                      Implementation of  TOniDataDat
*)


constructor TAccess_OniArchive.Create(DatFilename: String; ConnectionID: Integer; var Msg: TStatusMessages);
var
  i: Integer;
  header_pc, header_mac, header_macbeta: Boolean;
  Fdat_header:   THeader;
  Fdat_filesmap: TFilesMap;
  Fdat_namedfilesmap: TNamedFilesMap;
begin
  FUnloadWhenUnused := True;
  FDatOpened := False;
  FRawOpened := False;
  Msg := SM_UnknownError;
  if not FileExists(DatFilename) then
  begin
    Msg := SM_FileNotFound;
    Exit;
  end;
  FFileName := DatFilename;
  Fdat_file := TFileStream.Create(FFileName, fmOpenRead);
  Fdat_file.Read(Fdat_header, SizeOf(Fdat_header));
  header_pc  := True;
  header_mac := True;
  header_macbeta := True;
  for i := 0 to High(Fdat_header.GlobalIdent) do
    if Fdat_header.GlobalIdent[i] <> HeaderGlobalIdent[i] then
    begin
      Msg := SM_IncompatibleFile;
      Exit;
    end;

  for i := 0 to High(Fdat_header.OSIdent) do
  begin
    if Fdat_header.OSIdent[i] <> HeaderOSIdentWin[i] then
      header_pc := False;
    if Fdat_header.OSIdent[i] <> HeaderOSIdentMac[i] then
      header_mac := False;
    if Fdat_header.OSIdent[i] <> HeaderOSIdentMacBeta[i] then
      header_macbeta := False;
  end;
  if not (header_pc xor header_mac xor header_macbeta) then
  begin
    Msg := SM_IncompatibleFile;
    Exit;
  end
  else
  begin
    if (header_pc and not header_mac and not header_macbeta) then
      FDataOS := DOS_WIN
    else if (not header_pc and header_mac and not header_macbeta) then
      FDataOS := DOS_MAC
    else if (not header_pc and not header_mac and header_macbeta) then
      FDataOS := DOS_MACBETA;
  end;
  SetLength(Fdat_filesmap, Fdat_header.Files);
  SetLength(Fdat_files, Fdat_header.Files);
  for i := 0 to Fdat_header.Files - 1 do
    Fdat_file.Read(Fdat_filesmap[i], SizeOf(Fdat_filesmap[i]));
  for i := 0 to Fdat_header.Files - 1 do
  begin
    Fdat_files[i].ID := i;
    Fdat_files[i].Extension := Fdat_filesmap[i].Extension;
    Fdat_files[i].Extension := ReverseString(Fdat_files[i].Extension);
    Fdat_files[i].Size      := Fdat_filesmap[i].FileSize;
    Fdat_files[i].FileType  := Fdat_filesmap[i].FileType;
    Fdat_files[i].DatAddr   := Fdat_filesmap[i].DataAddr - 8 + Fdat_header.DataAddr;
    if (Fdat_filesmap[i].FileType and $01) = 0 then
    begin
      Fdat_file.Seek(Fdat_filesmap[i].NameAddr + Fdat_header.NamesAddr, soFromBeginning);
      SetLength(Fdat_files[i].Name, 100);
      Fdat_file.Read(Fdat_files[i].Name[1], 100);
      Fdat_files[i].Name := MidStr(Fdat_files[i].Name, 1 + 4, Pos(
        #0, Fdat_files[i].Name) - 1 - 4);
    end
    else
    begin
      Fdat_files[i].Name := '';
    end;
  end;
  Fdat_file.Seek($40 + Fdat_header.Files * $14, soFromBeginning);
  SetLength(Fdat_namedfilesmap, Fdat_header.NamedFiles);
  for i := 0 to Fdat_header.NamedFiles - 1 do
    Fdat_file.Read(Fdat_namedfilesmap[i], SizeOf(Fdat_namedfilesmap[i]));

  Fdat_file.Seek($40 + Fdat_header.Files * $14 + Fdat_header.NamedFiles * $8, soFromBeginning);
  SetLength(Fdat_extensionsmap, Fdat_header.Extensions);
  for i := 0 to Fdat_header.Extensions - 1 do
    Fdat_file.Read(Fdat_extensionsmap[i], SizeOf(Fdat_extensionsmap[i]));

  Fdat_file.Seek(Fdat_files[0].DatAddr + 7, soFromBeginning);
  Fdat_file.Read(FLevelNumber, 1);
  FLevelNumber := FLevelNumber div 2;

  Fdat_file.Free;

  Msg := SM_OK;
  FBackend := DB_ONI;
  FConnectionID := ConnectionID;
  FChangeRights := [CR_EditDat, CR_EditRaw, CR_AppendRaw];
end;


procedure TAccess_OniArchive.Close;
begin
  if FDatOpened then
    Fdat_file.Free;
  if FRawOpened then
    Fraw_file.Free;
  if FSepOpened then
    Fsep_file.Free;
  Self.Free;
end;


function TAccess_OniArchive.GetFileInfo(fileid: Integer): TFileInfo;
begin
  if fileid = -1 then
  begin
    Result := inherited GetFileInfo(fileid);
    Exit;
  end;
  if fileid < Self.GetFileCount then
    Result    := Fdat_files[fileid]
  else
    Result.ID := -1;
end;


function TAccess_OniArchive.GetFilesList(ext: String; pattern: String;
  NoEmptyFiles: Boolean; SortType: TSortType): TStrings;
var
  i:      Integer;
  list:   TStringList;
  id, name, extension: String;
  fields: TStrings;

  procedure getfields;
  begin
    fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
    if SortType in [ST_IDAsc, ST_IDDesc] then
    begin
      id := fields.Strings[0];
      name := fields.Strings[1];
      extension := fields.Strings[2];
    end;
    if SortType in [ST_NameAsc, ST_NameDesc] then
    begin
      id := fields.Strings[1];
      name := fields.Strings[0];
      extension := fields.Strings[2];
    end;
    if SortType in [ST_ExtAsc, ST_ExtDesc] then
    begin
      id := fields.Strings[1];
      name := fields.Strings[2];
      extension := fields.Strings[0];
    end;
    if SortType in [ST_ExtNameAsc, ST_ExtNameDesc] then
    begin
      id := fields.Strings[2];
      name := fields.Strings[1];
      extension := fields.Strings[0];
    end;
  end;

begin
  list := TStringList.Create;
  list.Sorted := True;
  for i := 0 to GetFileCount - 1 do
  begin
    if ((Length(ext) = 0) or (Pos(Fdat_files[i].Extension, ext) > 0)) and
      ((Length(pattern) = 0) or
      (Pos(UpperCase(pattern), UpperCase(Fdat_files[i].Name)) > 0)) then
    begin
      if (NoEmptyFiles = False) or ((Fdat_files[i].FileType and $02) = 0) then
      begin
        id := FormatNumber(Fdat_files[i].ID, 5, '0');
        name := Fdat_files[i].Name;
        extension := Fdat_files[i].Extension;

        case SortType of
          ST_IDAsc, ST_IDDesc:     list.Add(id + ';' + name + ';' + extension);
          ST_NameAsc, ST_NameDesc: list.Add(name + ';' + id + ';' + extension);
          ST_ExtAsc, ST_ExtDesc:   list.Add(extension + ';' + id + ';' + name);
          ST_ExtNameAsc, ST_ExtNameDesc: list.Add(name + ';' + extension + ';' + id);
        end;
      end;
    end;
  end;
  if not Assigned(Result) then
    Result := TStringList.Create;
  if list.Count > 0 then
  begin
    fields := TStringList.Create;
    if SortType in [ST_IDAsc, ST_NameAsc, ST_ExtAsc, ST_ExtNameAsc] then
      for i := 0 to list.Count - 1 do
      begin
        getfields;
        Result.Add(id + '-' + name + '.' + extension);
      end
    else
      for i := list.Count - 1 downto 0 do
      begin
        getfields;
        Result.Add(id + '-' + name + '.' + extension);
      end;
    fields.Free;
  end;
  list.Free;
end;


function TAccess_OniArchive.GetFileCount: Integer;
begin
  Result := Length(Fdat_files);
end;


function TAccess_OniArchive.GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings;
var
  i: Integer;
begin
  if not Assigned(Result) then
    Result := TStringList.Create;
  if Result is TStringList then
    TStringList(Result).Sorted := True;
  for i := 0 to Length(Fdat_extensionsmap) - 1 do
  begin
    with Fdat_extensionsmap[i] do
    begin
      case ExtListFormat of
        EF_ExtOnly:
          Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0]);
        EF_ExtCount:
          Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0] +
                ' (' + IntToStr(ExtCount) + ')');
      end;
    end;
  end;
end;


procedure TAccess_OniArchive.LoadDatFile(FileID: Integer; var Target: TStream);
var
  streampos: Integer;
begin
  if fileid < GetFileCount then
  begin
    if not Assigned(Target) then
      Target := TMemoryStream.Create;
    if not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
    streampos := Target.Position;
    Target.CopyFrom(Fdat_file, Fdat_files[fileid].Size);
    Target.Seek(streampos, soFromBeginning);
    if UnloadWhenUnused then
    begin
      Fdat_file.Free;
      FDatOpened := False;
    end
    else
      FDatOpened := True;
  end;
end;

procedure TAccess_OniArchive.UpdateDatFile(FileID: Integer; Src: TStream);
begin
  if fileid < GetFileCount then
  begin
    if not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
    Fdat_file.CopyFrom(Src, Fdat_files[fileid].Size);
    if UnloadWhenUnused then
    begin
      Fdat_file.Free;
      FDatOpened := False;
    end
    else
      FDatOpened := True;
  end;
end;

procedure TAccess_OniArchive.LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream);
var
  streampos: Integer;
begin
  if fileid < GetFileCount then
  begin
    if not Assigned(Target) then
      Target := TMemoryStream.Create;
    if not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
    streampos := Target.Position;
    Target.CopyFrom(Fdat_file, size);
    Target.Seek(streampos, soFromBeginning);
    if UnloadWhenUnused then
    begin
      FDatOpened := False;
      Fdat_file.Free;
    end
    else
      FDatOpened := True;
  end;
end;

procedure TAccess_OniArchive.UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream);
begin
  if fileid < GetFileCount then
  begin
    if not FDatOpened then
      Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
    Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
    Fdat_file.CopyFrom(Src, Size);
    if UnloadWhenUnused then
    begin
      Fdat_file.Free;
      FDatOpened := False;
    end
    else
      FDatOpened := True;
  end;
end;


function TAccess_OniArchive.GetDatLink(FileID, DatOffset: Integer): TDatLink;
var
  link: Integer;
begin
  Result := DatLinksManager.GetDatLink(FConnectionID, FileID, DatOffset);
  LoadDatFilePart(fileid, Result.SrcOffset, 4, @link);
  if link > 0 then
    Result.DestID := link div 256
  else
    Result.DestID := -1;
end;


function TAccess_OniArchive.GetDatLinks(FileID: Integer): TDatLinkList;
var
  i: Integer;
  link: Integer;
begin
  Result := DatLinksManager.GetDatLinks(FConnectionID, FileID);
  if Length(Result) > 0 then
  begin
    for i := 0 to High(Result) do
    begin
      LoadDatFilePart(fileid, Result[i].SrcOffset, 4, @link);
      if link > 0 then
        Result[i].DestID := link div 256
      else
        Result[i].DestID := -1;
    end;
  end;
end;


function TAccess_OniArchive.GetRawList(FileID: Integer): TRawDataList;
begin
  Result := RawLists.GetRawList(FConnectionID, FileID);
end;


function TAccess_OniArchive.GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo;
begin
  Result := RawLists.GetRawInfo(FConnectionID, FileID, DatOffset);
end;


procedure TAccess_OniArchive.LoadRawOffset(LocSep: Boolean; RawAddr, Size: Integer; target: Pointer);
begin
  if not LocSep then
  begin
    if not FRawOpened then
      Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
        fmOpenReadWrite);
    if RawAddr <= Fraw_file.Size then
    begin
      Fraw_file.Seek(RawAddr, soFromBeginning);
      Fraw_file.Read(target^, size);
    end;
    if UnloadWhenUnused then
    begin
      FRawOpened := False;
      Fraw_file.Free;
    end
    else
      FRawOpened := True;
  end
  else
  begin
    if not FSepOpened then
      Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
        fmOpenReadWrite);
    if RawAddr <= Fsep_file.Size then
    begin
      Fsep_file.Seek(RawAddr, soFromBeginning);
      Fsep_file.Read(target^, size);
    end;
    if UnloadWhenUnused then
    begin
      FSepOpened := False;
      Fsep_file.Free;
    end
    else
      FSepOpened := True;
  end;
end;

procedure TAccess_OniArchive.LoadRawFile(FileID, DatOffset: Integer; var Target: TStream);
var
  raw_info: TRawDataInfo;
  streampos: Integer;
begin
  if not Assigned(Target) then
    Target := TMemoryStream.Create;
  if fileid < GetFileCount then
  begin
    raw_info := Self.GetRawInfo(FileID, DatOffset);
    if not raw_info.LocSep then
    begin
      if not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.RawAddr, soFromBeginning);
      streampos := Target.Position;
      Target.CopyFrom(Fraw_file, raw_info.RawSize);
      Target.Seek(streampos, soFromBeginning);
      if UnloadWhenUnused then
      begin
        FRawOpened := False;
        Fraw_file.Free;
      end
      else
        FRawOpened := True;
    end
    else
    begin
      if FUnloadWhenUnused or not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.RawAddr, soFromBeginning);
      streampos := Target.Position;
      Target.CopyFrom(Fsep_file, raw_info.RawSize);
      Target.Seek(streampos, soFromBeginning);
      if UnloadWhenUnused then
      begin
        FSepOpened := False;
        Fsep_file.Free;
      end
      else
        FSepOpened := True;
    end;
  end;
end;

procedure TAccess_OniArchive.UpdateRawFile(FileID, DatOffset: Integer; Src: TStream);
var
  raw_info: TRawDataInfo;
begin
  if fileid < GetFileCount then
  begin
    raw_info := GetRawInfo(FileID, DatOffset);
    if not raw_info.LocSep then
    begin
      if not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.RawAddr, soFromBeginning);
      Fraw_file.CopyFrom(Src, raw_info.RawSize);
      if UnloadWhenUnused then
      begin
        FRawOpened := False;
        Fraw_file.Free;
      end
      else
        FRawOpened := True;
    end
    else
    begin
      if not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.RawAddr, soFromBeginning);
      Fsep_file.CopyFrom(Src, raw_info.RawSize);
      if UnloadWhenUnused then
      begin
        FSepOpened := False;
        Fsep_file.Free;
      end
      else
        FSepOpened := True;
    end;
  end;
end;

procedure TAccess_OniArchive.LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream);
var
  Data: TStream;
  streampos: Integer;
begin
  if not Assigned(Target) then
    Target := TMemoryStream.Create;
  if fileid < Self.GetFileCount then
  begin
    data := nil;
    LoadRawFile(FileID, DatOffset, Data);
    Data.Seek(Offset, soFromBeginning);
    streampos := Target.Position;
    Target.CopyFrom(Data, Size);
    Target.Seek(streampos, soFromBeginning);
  end;
end;

procedure TAccess_OniArchive.UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream);
var
  raw_info: TRawDataInfo;
begin
  if fileid < GetFileCount then
  begin
    raw_info := GetRawInfo(FileID, DatOffset);
    if not raw_info.LocSep then
    begin
      if not FRawOpened then
        Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
          fmOpenReadWrite);
      Fraw_file.Seek(raw_info.RawAddr + Offset, soFromBeginning);
      Fraw_file.CopyFrom(Src, Size);
      if UnloadWhenUnused then
      begin
        FRawOpened := False;
        Fraw_file.Free;
      end
      else
        FRawOpened := True;
    end
    else
    begin
      if not FSepOpened then
        Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
          fmOpenReadWrite);
      Fsep_file.Seek(raw_info.RawAddr + Offset, soFromBeginning);
      Fsep_file.CopyFrom(Src, Size);
      if UnloadWhenUnused then
      begin
        FSepOpened := False;
        Fsep_file.Free;
      end
      else
        FSepOpened := True;
    end;
  end;
end;

function TAccess_OniArchive.AppendRawFile(LocSep: Boolean; Src: TStream): Integer;
begin
  if not LocSep then
  begin
    if not FRawOpened then
      Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
        fmOpenReadWrite);
    Result := Fraw_file.Size;
    Fraw_file.Seek(0, soFromEnd);
    Fraw_file.CopyFrom(Src, Src.Size);
    if UnloadWhenUnused then
    begin
      FRawOpened := False;
      Fraw_file.Free;
    end
    else
      FRawOpened := True;
  end
  else
  begin
    if not FSepOpened then
      Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
        fmOpenReadWrite);
    Result := Fsep_file.Size;
    Fsep_file.Seek(0, soFromEnd);
    Fsep_file.CopyFrom(Src, Src.Size);
    if UnloadWhenUnused then
    begin
      FSepOpened := False;
      Fsep_file.Free;
    end
    else
      FSepOpened := True;
  end;
end;

end.
Revision:	116
Committed:	Mon Feb 26 22:57:02 2007 UTC (18 years, 8 months ago) by alloc
Content type:	text/x-pascal
File size:	19642 byte(s)
Log Message:
#	Content
1	unit Access_OniArchive;
2	interface
3
4	uses DataAccess, Classes, TypeDefs;
5
6	type
7	TAccess_OniArchive = class(TDataAccess)
8	private
9	Fdat_file: TFileStream;
10	Fraw_file: TFileStream;
11	Fsep_file: TFileStream;
12	Fdat_files: TFiles;
13	Fdat_extensionsmap: TExtensionsMap;
14	FUnloadWhenUnused: Boolean;
15	FDatOpened: Boolean;
16	FRawOpened: Boolean;
17	FSepOpened: Boolean;
18	protected
19	public
20	property UnloadWhenUnused: Boolean Read FUnloadWhenUnused Write FUnloadWhenUnused;
21
22	constructor Create(DatFilename: String; ConnectionID: Integer; var Msg: TStatusMessages); override;
23	procedure Close; override;
24
25	function GetFileInfo(FileID: Integer): TFileInfo; override;
26	function GetFilesList(Ext: String; Pattern: String;
27	NoEmptyFiles: Boolean; SortType: TSortType): TStrings; override;
28	function GetFileCount: Integer; override;
29	function GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings; override;
30
31	procedure LoadDatFile(FileID: Integer; var Target: TStream); overload; override;
32	procedure UpdateDatFile(FileID: Integer; Src: TStream); overload; override;
33	procedure LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream); overload; override;
34	procedure UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream); overload; override;
35
36	function GetDatLinks(FileID: Integer): TDatLinkList; override;
37	function GetDatLink(FileID, DatOffset: Integer): TDatLink; override;
38	function GetRawList(FileID: Integer): TRawDataList; override;
39	function GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo; override;
40
41	procedure LoadRawOffset(LocSep: Boolean; RawAddr, Size: Integer; target: Pointer);
42	procedure LoadRawFile(FileID, DatOffset: Integer; var Target: TStream); overload; override;
43	procedure UpdateRawFile(FileID, DatOffset: Integer; Src: TStream); overload; override;
44	procedure LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream); overload; override;
45	procedure UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream); overload; override;
46
47	function AppendRawFile(LocSep: Boolean; Src: TStream): Integer; overload; override;
48	published
49	end;
50
51	implementation
52
53	uses
54	SysUtils, StrUtils, Data, Functions, RawList, DatLinks;
55
56
57	(*
58	================================================================================
59	Implementation of TOniDataDat
60	*)
61
62
63	constructor TAccess_OniArchive.Create(DatFilename: String; ConnectionID: Integer; var Msg: TStatusMessages);
64	var
65	i: Integer;
66	header_pc, header_mac, header_macbeta: Boolean;
67	Fdat_header: THeader;
68	Fdat_filesmap: TFilesMap;
69	Fdat_namedfilesmap: TNamedFilesMap;
70	begin
71	FUnloadWhenUnused := True;
72	FDatOpened := False;
73	FRawOpened := False;
74	Msg := SM_UnknownError;
75	if not FileExists(DatFilename) then
76	begin
77	Msg := SM_FileNotFound;
78	Exit;
79	end;
80	FFileName := DatFilename;
81	Fdat_file := TFileStream.Create(FFileName, fmOpenRead);
82	Fdat_file.Read(Fdat_header, SizeOf(Fdat_header));
83	header_pc := True;
84	header_mac := True;
85	header_macbeta := True;
86	for i := 0 to High(Fdat_header.GlobalIdent) do
87	if Fdat_header.GlobalIdent[i] <> HeaderGlobalIdent[i] then
88	begin
89	Msg := SM_IncompatibleFile;
90	Exit;
91	end;
92
93	for i := 0 to High(Fdat_header.OSIdent) do
94	begin
95	if Fdat_header.OSIdent[i] <> HeaderOSIdentWin[i] then
96	header_pc := False;
97	if Fdat_header.OSIdent[i] <> HeaderOSIdentMac[i] then
98	header_mac := False;
99	if Fdat_header.OSIdent[i] <> HeaderOSIdentMacBeta[i] then
100	header_macbeta := False;
101	end;
102	if not (header_pc xor header_mac xor header_macbeta) then
103	begin
104	Msg := SM_IncompatibleFile;
105	Exit;
106	end
107	else
108	begin
109	if (header_pc and not header_mac and not header_macbeta) then
110	FDataOS := DOS_WIN
111	else if (not header_pc and header_mac and not header_macbeta) then
112	FDataOS := DOS_MAC
113	else if (not header_pc and not header_mac and header_macbeta) then
114	FDataOS := DOS_MACBETA;
115	end;
116	SetLength(Fdat_filesmap, Fdat_header.Files);
117	SetLength(Fdat_files, Fdat_header.Files);
118	for i := 0 to Fdat_header.Files - 1 do
119	Fdat_file.Read(Fdat_filesmap[i], SizeOf(Fdat_filesmap[i]));
120	for i := 0 to Fdat_header.Files - 1 do
121	begin
122	Fdat_files[i].ID := i;
123	Fdat_files[i].Extension := Fdat_filesmap[i].Extension;
124	Fdat_files[i].Extension := ReverseString(Fdat_files[i].Extension);
125	Fdat_files[i].Size := Fdat_filesmap[i].FileSize;
126	Fdat_files[i].FileType := Fdat_filesmap[i].FileType;
127	Fdat_files[i].DatAddr := Fdat_filesmap[i].DataAddr - 8 + Fdat_header.DataAddr;
128	if (Fdat_filesmap[i].FileType and $01) = 0 then
129	begin
130	Fdat_file.Seek(Fdat_filesmap[i].NameAddr + Fdat_header.NamesAddr, soFromBeginning);
131	SetLength(Fdat_files[i].Name, 100);
132	Fdat_file.Read(Fdat_files[i].Name[1], 100);
133	Fdat_files[i].Name := MidStr(Fdat_files[i].Name, 1 + 4, Pos(
134	#0, Fdat_files[i].Name) - 1 - 4);
135	end
136	else
137	begin
138	Fdat_files[i].Name := '';
139	end;
140	end;
141	Fdat_file.Seek($40 + Fdat_header.Files * $14, soFromBeginning);
142	SetLength(Fdat_namedfilesmap, Fdat_header.NamedFiles);
143	for i := 0 to Fdat_header.NamedFiles - 1 do
144	Fdat_file.Read(Fdat_namedfilesmap[i], SizeOf(Fdat_namedfilesmap[i]));
145
146	Fdat_file.Seek($40 + Fdat_header.Files * $14 + Fdat_header.NamedFiles * $8, soFromBeginning);
147	SetLength(Fdat_extensionsmap, Fdat_header.Extensions);
148	for i := 0 to Fdat_header.Extensions - 1 do
149	Fdat_file.Read(Fdat_extensionsmap[i], SizeOf(Fdat_extensionsmap[i]));
150
151	Fdat_file.Seek(Fdat_files[0].DatAddr + 7, soFromBeginning);
152	Fdat_file.Read(FLevelNumber, 1);
153	FLevelNumber := FLevelNumber div 2;
154
155	Fdat_file.Free;
156
157	Msg := SM_OK;
158	FBackend := DB_ONI;
159	FConnectionID := ConnectionID;
160	FChangeRights := [CR_EditDat, CR_EditRaw, CR_AppendRaw];
161	end;
162
163
164
165
166	procedure TAccess_OniArchive.Close;
167	begin
168	if FDatOpened then
169	Fdat_file.Free;
170	if FRawOpened then
171	Fraw_file.Free;
172	if FSepOpened then
173	Fsep_file.Free;
174	Self.Free;
175	end;
176
177
178
179
180	function TAccess_OniArchive.GetFileInfo(fileid: Integer): TFileInfo;
181	begin
182	if fileid = -1 then
183	begin
184	Result := inherited GetFileInfo(fileid);
185	Exit;
186	end;
187	if fileid < Self.GetFileCount then
188	Result := Fdat_files[fileid]
189	else
190	Result.ID := -1;
191	end;
192
193
194
195
196	function TAccess_OniArchive.GetFilesList(ext: String; pattern: String;
197	NoEmptyFiles: Boolean; SortType: TSortType): TStrings;
198	var
199	i: Integer;
200	list: TStringList;
201	id, name, extension: String;
202	fields: TStrings;
203
204	procedure getfields;
205	begin
206	fields.CommaText := StringReplace(AnsiQuotedStr(list.Strings[i], '"'), ';', '","', [rfReplaceAll]);
207	if SortType in [ST_IDAsc, ST_IDDesc] then
208	begin
209	id := fields.Strings[0];
210	name := fields.Strings[1];
211	extension := fields.Strings[2];
212	end;
213	if SortType in [ST_NameAsc, ST_NameDesc] then
214	begin
215	id := fields.Strings[1];
216	name := fields.Strings[0];
217	extension := fields.Strings[2];
218	end;
219	if SortType in [ST_ExtAsc, ST_ExtDesc] then
220	begin
221	id := fields.Strings[1];
222	name := fields.Strings[2];
223	extension := fields.Strings[0];
224	end;
225	if SortType in [ST_ExtNameAsc, ST_ExtNameDesc] then
226	begin
227	id := fields.Strings[2];
228	name := fields.Strings[1];
229	extension := fields.Strings[0];
230	end;
231	end;
232
233	begin
234	list := TStringList.Create;
235	list.Sorted := True;
236	for i := 0 to GetFileCount - 1 do
237	begin
238	if ((Length(ext) = 0) or (Pos(Fdat_files[i].Extension, ext) > 0)) and
239	((Length(pattern) = 0) or
240	(Pos(UpperCase(pattern), UpperCase(Fdat_files[i].Name)) > 0)) then
241	begin
242	if (NoEmptyFiles = False) or ((Fdat_files[i].FileType and $02) = 0) then
243	begin
244	id := FormatNumber(Fdat_files[i].ID, 5, '0');
245	name := Fdat_files[i].Name;
246	extension := Fdat_files[i].Extension;
247
248	case SortType of
249	ST_IDAsc, ST_IDDesc: list.Add(id + ';' + name + ';' + extension);
250	ST_NameAsc, ST_NameDesc: list.Add(name + ';' + id + ';' + extension);
251	ST_ExtAsc, ST_ExtDesc: list.Add(extension + ';' + id + ';' + name);
252	ST_ExtNameAsc, ST_ExtNameDesc: list.Add(name + ';' + extension + ';' + id);
253	end;
254	end;
255	end;
256	end;
257	if not Assigned(Result) then
258	Result := TStringList.Create;
259	if list.Count > 0 then
260	begin
261	fields := TStringList.Create;
262	if SortType in [ST_IDAsc, ST_NameAsc, ST_ExtAsc, ST_ExtNameAsc] then
263	for i := 0 to list.Count - 1 do
264	begin
265	getfields;
266	Result.Add(id + '-' + name + '.' + extension);
267	end
268	else
269	for i := list.Count - 1 downto 0 do
270	begin
271	getfields;
272	Result.Add(id + '-' + name + '.' + extension);
273	end;
274	fields.Free;
275	end;
276	list.Free;
277	end;
278
279
280
281
282	function TAccess_OniArchive.GetFileCount: Integer;
283	begin
284	Result := Length(Fdat_files);
285	end;
286
287
288
289
290	function TAccess_OniArchive.GetExtensionsList(ExtListFormat: TExtensionFormat): TStrings;
291	var
292	i: Integer;
293	begin
294	if not Assigned(Result) then
295	Result := TStringList.Create;
296	if Result is TStringList then
297	TStringList(Result).Sorted := True;
298	for i := 0 to Length(Fdat_extensionsmap) - 1 do
299	begin
300	with Fdat_extensionsmap[i] do
301	begin
302	case ExtListFormat of
303	EF_ExtOnly:
304	Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0]);
305	EF_ExtCount:
306	Result.Add(Extension[3] + Extension[2] + Extension[1] + Extension[0] +
307	' (' + IntToStr(ExtCount) + ')');
308	end;
309	end;
310	end;
311	end;
312
313
314
315	procedure TAccess_OniArchive.LoadDatFile(FileID: Integer; var Target: TStream);
316	var
317	streampos: Integer;
318	begin
319	if fileid < GetFileCount then
320	begin
321	if not Assigned(Target) then
322	Target := TMemoryStream.Create;
323	if not FDatOpened then
324	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
325	Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
326	streampos := Target.Position;
327	Target.CopyFrom(Fdat_file, Fdat_files[fileid].Size);
328	Target.Seek(streampos, soFromBeginning);
329	if UnloadWhenUnused then
330	begin
331	Fdat_file.Free;
332	FDatOpened := False;
333	end
334	else
335	FDatOpened := True;
336	end;
337	end;
338
339	procedure TAccess_OniArchive.UpdateDatFile(FileID: Integer; Src: TStream);
340	begin
341	if fileid < GetFileCount then
342	begin
343	if not FDatOpened then
344	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
345	Fdat_file.Seek(Fdat_files[fileid].DatAddr, soFromBeginning);
346	Fdat_file.CopyFrom(Src, Fdat_files[fileid].Size);
347	if UnloadWhenUnused then
348	begin
349	Fdat_file.Free;
350	FDatOpened := False;
351	end
352	else
353	FDatOpened := True;
354	end;
355	end;
356
357	procedure TAccess_OniArchive.LoadDatFilePart(FileID, Offset, Size: Integer; var Target: TStream);
358	var
359	streampos: Integer;
360	begin
361	if fileid < GetFileCount then
362	begin
363	if not Assigned(Target) then
364	Target := TMemoryStream.Create;
365	if not FDatOpened then
366	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
367	Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
368	streampos := Target.Position;
369	Target.CopyFrom(Fdat_file, size);
370	Target.Seek(streampos, soFromBeginning);
371	if UnloadWhenUnused then
372	begin
373	FDatOpened := False;
374	Fdat_file.Free;
375	end
376	else
377	FDatOpened := True;
378	end;
379	end;
380
381	procedure TAccess_OniArchive.UpdateDatFilePart(FileID, Offset, Size: Integer; Src: TStream);
382	begin
383	if fileid < GetFileCount then
384	begin
385	if not FDatOpened then
386	Fdat_file := TFileStream.Create(FFileName, fmOpenReadWrite);
387	Fdat_file.Seek(Fdat_files[fileid].DatAddr + offset, soFromBeginning);
388	Fdat_file.CopyFrom(Src, Size);
389	if UnloadWhenUnused then
390	begin
391	Fdat_file.Free;
392	FDatOpened := False;
393	end
394	else
395	FDatOpened := True;
396	end;
397	end;
398
399
400
401	function TAccess_OniArchive.GetDatLink(FileID, DatOffset: Integer): TDatLink;
402	var
403	link: Integer;
404	begin
405	Result := DatLinksManager.GetDatLink(FConnectionID, FileID, DatOffset);
406	LoadDatFilePart(fileid, Result.SrcOffset, 4, @link);
407	if link > 0 then
408	Result.DestID := link div 256
409	else
410	Result.DestID := -1;
411	end;
412
413
414	function TAccess_OniArchive.GetDatLinks(FileID: Integer): TDatLinkList;
415	var
416	i: Integer;
417	link: Integer;
418	begin
419	Result := DatLinksManager.GetDatLinks(FConnectionID, FileID);
420	if Length(Result) > 0 then
421	begin
422	for i := 0 to High(Result) do
423	begin
424	LoadDatFilePart(fileid, Result[i].SrcOffset, 4, @link);
425	if link > 0 then
426	Result[i].DestID := link div 256
427	else
428	Result[i].DestID := -1;
429	end;
430	end;
431	end;
432
433
434	function TAccess_OniArchive.GetRawList(FileID: Integer): TRawDataList;
435	begin
436	Result := RawLists.GetRawList(FConnectionID, FileID);
437	end;
438
439
440	function TAccess_OniArchive.GetRawInfo(FileID, DatOffset: Integer): TRawDataInfo;
441	begin
442	Result := RawLists.GetRawInfo(FConnectionID, FileID, DatOffset);
443	end;
444
445
446
447
448	procedure TAccess_OniArchive.LoadRawOffset(LocSep: Boolean; RawAddr, Size: Integer; target: Pointer);
449	begin
450	if not LocSep then
451	begin
452	if not FRawOpened then
453	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
454	fmOpenReadWrite);
455	if RawAddr <= Fraw_file.Size then
456	begin
457	Fraw_file.Seek(RawAddr, soFromBeginning);
458	Fraw_file.Read(target^, size);
459	end;
460	if UnloadWhenUnused then
461	begin
462	FRawOpened := False;
463	Fraw_file.Free;
464	end
465	else
466	FRawOpened := True;
467	end
468	else
469	begin
470	if not FSepOpened then
471	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
472	fmOpenReadWrite);
473	if RawAddr <= Fsep_file.Size then
474	begin
475	Fsep_file.Seek(RawAddr, soFromBeginning);
476	Fsep_file.Read(target^, size);
477	end;
478	if UnloadWhenUnused then
479	begin
480	FSepOpened := False;
481	Fsep_file.Free;
482	end
483	else
484	FSepOpened := True;
485	end;
486	end;
487
488	procedure TAccess_OniArchive.LoadRawFile(FileID, DatOffset: Integer; var Target: TStream);
489	var
490	raw_info: TRawDataInfo;
491	streampos: Integer;
492	begin
493	if not Assigned(Target) then
494	Target := TMemoryStream.Create;
495	if fileid < GetFileCount then
496	begin
497	raw_info := Self.GetRawInfo(FileID, DatOffset);
498	if not raw_info.LocSep then
499	begin
500	if not FRawOpened then
501	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
502	fmOpenReadWrite);
503	Fraw_file.Seek(raw_info.RawAddr, soFromBeginning);
504	streampos := Target.Position;
505	Target.CopyFrom(Fraw_file, raw_info.RawSize);
506	Target.Seek(streampos, soFromBeginning);
507	if UnloadWhenUnused then
508	begin
509	FRawOpened := False;
510	Fraw_file.Free;
511	end
512	else
513	FRawOpened := True;
514	end
515	else
516	begin
517	if FUnloadWhenUnused or not FSepOpened then
518	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
519	fmOpenReadWrite);
520	Fsep_file.Seek(raw_info.RawAddr, soFromBeginning);
521	streampos := Target.Position;
522	Target.CopyFrom(Fsep_file, raw_info.RawSize);
523	Target.Seek(streampos, soFromBeginning);
524	if UnloadWhenUnused then
525	begin
526	FSepOpened := False;
527	Fsep_file.Free;
528	end
529	else
530	FSepOpened := True;
531	end;
532	end;
533	end;
534
535	procedure TAccess_OniArchive.UpdateRawFile(FileID, DatOffset: Integer; Src: TStream);
536	var
537	raw_info: TRawDataInfo;
538	begin
539	if fileid < GetFileCount then
540	begin
541	raw_info := GetRawInfo(FileID, DatOffset);
542	if not raw_info.LocSep then
543	begin
544	if not FRawOpened then
545	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
546	fmOpenReadWrite);
547	Fraw_file.Seek(raw_info.RawAddr, soFromBeginning);
548	Fraw_file.CopyFrom(Src, raw_info.RawSize);
549	if UnloadWhenUnused then
550	begin
551	FRawOpened := False;
552	Fraw_file.Free;
553	end
554	else
555	FRawOpened := True;
556	end
557	else
558	begin
559	if not FSepOpened then
560	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
561	fmOpenReadWrite);
562	Fsep_file.Seek(raw_info.RawAddr, soFromBeginning);
563	Fsep_file.CopyFrom(Src, raw_info.RawSize);
564	if UnloadWhenUnused then
565	begin
566	FSepOpened := False;
567	Fsep_file.Free;
568	end
569	else
570	FSepOpened := True;
571	end;
572	end;
573	end;
574
575	procedure TAccess_OniArchive.LoadRawFilePart(FileID, DatOffset, Offset, Size: Integer; var Target: TStream);
576	var
577	Data: TStream;
578	streampos: Integer;
579	begin
580	if not Assigned(Target) then
581	Target := TMemoryStream.Create;
582	if fileid < Self.GetFileCount then
583	begin
584	data := nil;
585	LoadRawFile(FileID, DatOffset, Data);
586	Data.Seek(Offset, soFromBeginning);
587	streampos := Target.Position;
588	Target.CopyFrom(Data, Size);
589	Target.Seek(streampos, soFromBeginning);
590	end;
591	end;
592
593	procedure TAccess_OniArchive.UpdateRawFilePart(FileID, DatOffset, Offset, Size: Integer; Src: TStream);
594	var
595	raw_info: TRawDataInfo;
596	begin
597	if fileid < GetFileCount then
598	begin
599	raw_info := GetRawInfo(FileID, DatOffset);
600	if not raw_info.LocSep then
601	begin
602	if not FRawOpened then
603	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
604	fmOpenReadWrite);
605	Fraw_file.Seek(raw_info.RawAddr + Offset, soFromBeginning);
606	Fraw_file.CopyFrom(Src, Size);
607	if UnloadWhenUnused then
608	begin
609	FRawOpened := False;
610	Fraw_file.Free;
611	end
612	else
613	FRawOpened := True;
614	end
615	else
616	begin
617	if not FSepOpened then
618	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
619	fmOpenReadWrite);
620	Fsep_file.Seek(raw_info.RawAddr + Offset, soFromBeginning);
621	Fsep_file.CopyFrom(Src, Size);
622	if UnloadWhenUnused then
623	begin
624	FSepOpened := False;
625	Fsep_file.Free;
626	end
627	else
628	FSepOpened := True;
629	end;
630	end;
631	end;
632
633	function TAccess_OniArchive.AppendRawFile(LocSep: Boolean; Src: TStream): Integer;
634	begin
635	if not LocSep then
636	begin
637	if not FRawOpened then
638	Fraw_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.raw'),
639	fmOpenReadWrite);
640	Result := Fraw_file.Size;
641	Fraw_file.Seek(0, soFromEnd);
642	Fraw_file.CopyFrom(Src, Src.Size);
643	if UnloadWhenUnused then
644	begin
645	FRawOpened := False;
646	Fraw_file.Free;
647	end
648	else
649	FRawOpened := True;
650	end
651	else
652	begin
653	if not FSepOpened then
654	Fsep_file := TFileStream.Create(AnsiReplaceStr(FFileName, '.dat', '.sep'),
655	fmOpenReadWrite);
656	Result := Fsep_file.Size;
657	Fsep_file.Seek(0, soFromEnd);
658	Fsep_file.CopyFrom(Src, Src.Size);
659	if UnloadWhenUnused then
660	begin
661	FSepOpened := False;
662	Fsep_file.Free;
663	end
664	else
665	FSepOpened := True;
666	end;
667	end;
668
669	end.