ViewVC Help

View File | Revision Log | View Changeset | Root Listing

root/Oni2/oup/current/Helper/LevelDB.pas

Comparing oup/current/Helper/LevelDB.pas (file contents):
Revision 134 by alloc, Wed Mar 28 17:53:54 2007 UTC vs.
Revision 166 by alloc, Tue Apr 3 02:58:53 2007 UTC

#	Line 12 | Line 12 | type
12		btn_abortok:  TButton;
13		lbl_estimation: TLabel;
14		procedure btn_abortokClick(Sender: TObject);
15	–	private
16	–	procedure HandleFile(Ext: String; FileID: Integer);
17	–	procedure StopConvert;
15		public
16		procedure CreateDatabase(Source, Target: String);
17		procedure CreateLevel(Source, Target: String);
#	Line 27 | Line 24 | var
24		implementation
25		{$R *.dfm}
26		uses ABSMain, ABSDecUtil, Main,
27	<	ConnectionManager, TypeDefs, DataAccess, OniImgClass, Data;
28	<
32	<	type
33	<	THandler = procedure(FileID: Integer);
34	<	TConvertHandler = record
35	<	Ext:     String[4];
36	<	Handler: THandler;
37	<	end;
27	>	ConnectionManager, TypeDefs, DataAccess, OniImgClass, Data, RawList,
28	>	Access_OniArchive;
29
30		var
40	–	ConvertHandlers: array of TConvertHandler;
41	–	//  loaded_filename: String;
31		Converting:  Boolean = False;
32		Abort:       Boolean = False;
33
#	Line 56 | Line 45 | end;
45
46
47		procedure TForm_LevelDB.CreateLevel(Source, Target: String);
48	+	const
49	+	EmptyBytes: Array[0..31] of Byte = (
50	+	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 );
51		var
52		DatHeader:        THeader;
53		FilesHeader:      TFilesMap;
#	Line 67 | Line 59 | var
59
60		BeginTime, FileTime: Double;
61		Step:     Integer;
70	–	OniImage:   TOniImage;
62		LevelID:    Integer;
63		TimeFormat: TFormatSettings;
64
#	Line 87 | Line 78 | var
78		RawLinks:   TRawDataList;
79
80		DatFileStream, RawFileStream: TMemoryStream;
90	–
91	–	// ###########################
92	–	datsum, linksum, rawsum: Int64;
93	–	freq: Int64;
94	–	tempticks1, tempticks2: Int64;
95	–	// ###########################
81		const
82		Steps: Byte = 3;
83
#	Line 107 | Line 92 | const
92		group_progress.Caption := 'Creating Dat (FINISHED)';
93		end;
94
95	+	procedure StopConvert;
96	+	begin
97	+	btn_abortok.Caption := '&Close';
98	+	btn_abortok.Default := True;
99	+	converting := False;
100	+	lbl_estimation.Caption := 'ABORTED';
101	+	group_progress.Caption := 'Creating Level (ABORTED)';
102	+
103	+	Stream_Body.Free;
104	+	Stream_Names.Free;
105	+	DatFileStream.Free;
106	+	RawFileStream.Free;
107	+
108	+	Stream_Dat.Free;
109	+	Stream_Raw.Free;
110	+	if Connection.DataOS in [DOS_WINDEMO, DOS_MAC, DOS_MACBETA] then
111	+	Stream_Sep.Free;
112	+
113	+	if MessageBox(Self.Handle, PChar('Delete the unfinished level-files?'),
114	+	PChar('Delete files?'), MB_YESNO) = idYes then
115	+	begin
116	+	DeleteFile(target);
117	+	DeleteFile(AnsiReplaceStr(Target, '.dat', '.raw'));
118	+	if Connection.DataOS in [DOS_WINDEMO, DOS_MAC, DOS_MACBETA] then
119	+	DeleteFile(AnsiReplaceStr(Target, '.dat', '.sep'));
120	+	end;
121	+	end;
122	+
123		begin
124
125		//
#	Line 176 | Line 189 | begin
189
190		LevelID  := Connection.LevelNumber;
191		LevelID  := (LevelID * 2) * 256 * 256 * 256 + $01;
179	–	OniImage := TOniImage.Create;
192
193		Self.Visible := True;
194		Form_Main.Visible := False;
#	Line 191 | Line 203 | begin
203		Stream_Names := TMemoryStream.Create;
204		Stream_Dat   := TFileStream.Create(Target, fmCreate);
205		Stream_Raw   := TFileStream.Create(AnsiReplaceStr(Target, '.dat', '.raw'), fmCreate);
206	+	Stream_Raw.Write(EmptyBytes[0], 32);
207		if Connection.DataOS in [DOS_WINDEMO, DOS_MAC, DOS_MACBETA] then
208	+	begin
209		Stream_Sep := TFileStream.Create(AnsiReplaceStr(Target, '.dat', '.sep'), fmCreate);
210	+	Stream_Sep.Write(EmptyBytes[0], 32);
211	+	end;
212	+
213
214		DoStep('Creating header');
215		progress.Position      := 0;
#	Line 283 | Line 300 | begin
300		lbl_estimation.Caption := 'Estimated finishing time: unknown';
301		Application.ProcessMessages;
302
286	–	QueryPerformanceFrequency(freq);
287	–	datsum := 0;
288	–	linksum := 0;
289	–	rawsum := 0;
290	–
303		FileTime := Time;
304		for FileID := 0 to DatHeader.Files - 1 do
305		begin
#	Line 296 | Line 308 | begin
308		FilesHeader[FileID].Extension[j] := FileInfo.Extension[4 - j];
309		if FileInfo.Size > 0 then
310		begin
299	–	QueryPerformanceCounter(tempticks1);
300	–
311		FilesHeader[FileID].DataAddr := Stream_Body.Size + 8;
312		DatFileStream := TMemoryStream.Create;
313		Connection.LoadDatFile(FileID, TStream(DatFileStream));
314		DatFileStream.Seek(0, soFromBeginning);
315	<	DatFileStream.Write(FileID, 4);
315	>	tempi := FileID * 256 + 1;
316	>	DatFileStream.Write(tempi, 4);
317		DatFileStream.Write(LevelID, 4);
318
308	–	QueryPerformanceCounter(tempticks2);
309	–	datsum := datsum + (tempticks2 - tempticks1);
310	–
319		DatLinks := Connection.GetDatLinks(FileID);
320		if Length(DatLinks) > 0 then
321		begin
#	Line 322 | Line 330 | begin
330		end;
331		end;
332
325	–	QueryPerformanceCounter(tempticks1);
326	–	linksum := linksum + (tempticks1 - tempticks2);
327	–
333		RawLinks := Connection.GetRawList(FileID);
334		if Length(RawLinks) > 0 then
335		begin
#	Line 339 | Line 344 | begin
344		begin
345		RawLinks[i].RawAddr := Stream_Sep.Size;
346		Stream_sep.CopyFrom(RawFileStream, RawFileStream.Size);
347	+	if (Stream_Sep.Size mod 32) > 0 then
348	+	Stream_Sep.Write(EmptyBytes[0], 32 - (Stream_Sep.Size mod 32));
349		end else begin
350		RawLinks[i].RawAddr := Stream_Raw.Size;
351		Stream_Raw.CopyFrom(RawFileStream, RawFileStream.Size);
352	+	if (Stream_Raw.Size mod 32) > 0 then
353	+	Stream_Raw.Write(EmptyBytes[0], 32 - (Stream_Raw.Size mod 32));
354		end;
355		end else
356		RawLinks[i].RawAddr := 0;
#	Line 351 | Line 360 | begin
360		end;
361		DatFileStream.Seek(0, soFromBeginning);
362		Stream_Body.CopyFrom(DatFileStream, DatFileStream.Size);
363	<
364	<	QueryPerformanceCounter(tempticks2);
365	<	rawsum := rawsum + (tempticks2 - tempticks1);
363	>	if (Stream_Body.Size mod 32) > 0 then
364	>	begin
365	>	ShowMessage(
366	>	IntToStr(FileID) + '-' + FileInfo.Name + '.' + FileInfo.Extension + #13#10 +
367	>	IntToStr(FileInfo.Size) + ' - 0x' + IntToHex(FileInfo.Size, 6) + ' - real: ' + IntToStr(DatFileStream.Size) + ' - 0x' + IntToHex(DatFileStream.Size, 6) + #13#10 +
368	>	IntToStr(Stream_Body.Size) + ' - 0x' + IntToHex(Stream_Body.Size, 6) );
369	>	Stream_Body.Write(EmptyBytes[0], 32 - (Stream_Body.Size mod 32));
370	>	end;
371		end
372		else
373		FilesHeader[FileID].DataAddr := 0;
#	Line 376 | Line 390 | begin
390		Application.ProcessMessages;
391		end;
392
379	–	ShowMessage('AvgDats: ' + FloatToStr((datsum / progress.Max) / freq) + #13#10 +
380	–	'AvgLinks: ' + FloatToStr((linksum / progress.Max) / freq) + #13#10 +
381	–	'AvgRaws: ' + FloatToStr((rawsum / progress.Max) / freq)
382	–	);
383	–
393		Stream_Dat.Write(DatHeader, SizeOf(DatHeader));
394		for i := 0 to High(FilesHeader) do
395		Stream_Dat.Write(FilesHeader[i], SizeOf(FilesHeader[i]));
#	Line 389 | Line 398 | begin
398		for i := 0 to High(ExtensionsHeader) do
399		Stream_Dat.Write(ExtensionsHeader[i], SizeOf(ExtensionsHeader[i]));
400
401	+	if (Stream_Dat.Size mod 32) > 0 then
402	+	Stream_Dat.Write(EmptyBytes[0], 32 - (Stream_Dat.Size mod 32));
403	+
404		DatHeader.DataSize  := Stream_Body.Size;
405		DatHeader.NamesSize := Stream_Names.Size;
406		DatHeader.DataAddr  := Stream_Dat.Size;
407
408		Stream_Body.Seek(0, soFromBeginning);
409		Stream_Dat.CopyFrom(Stream_Body, Stream_Body.Size);
410	+
411	+	if (Stream_Dat.Size mod 32) > 0 then
412	+	Stream_Dat.Write(EmptyBytes[0], 32 - (Stream_Dat.Size mod 32));
413	+
414		DatHeader.NamesAddr := Stream_Dat.Size;
415		Stream_Names.Seek(0, soFromBeginning);
416		Stream_Dat.CopyFrom(Stream_Names, Stream_Names.Size);
#	Line 419 | Line 435 | begin
435		btn_abortok.Caption := '&OK';
436		btn_abortok.Default := True;
437
422	–	OniImage.Free;
423	–
438		converting := False;
439
440		//  CloseDataConnection(DataConnections[conIndex]);
#	Line 429 | Line 443 | end;
443
444
445
432	–	procedure TForm_LevelDB.HandleFile;
433	–	var
434	–	i: Byte;
435	–	begin
436	–	{  for i := 1 to Length(ConvertHandlers) do
437	–	if UpperCase(ConvertHandlers[i].Ext) = UpperCase(ext) then
438	–	if ConvertHandlers[i].needed then
439	–	begin
440	–	ConvertHandlers[i].Handler(fileid, dir_dat2db);
441	–	Break;
442	–	end
443	–	else
444	–	Break;
445	–	}end;
446	–
447	–
448	–
449	–
446		procedure TForm_LevelDB.CreateDatabase(Source, target: String);
447		var
448		DataBase:  TABSDatabase;
449	<	{
450	<	var
455	<	DataBase:    TABSDatabase;
456	<	Query:       TABSQuery;
457	<	MimeCoder:   TStringFormat_MIME64;
458	<
459	<	i, j:     LongWord;
460	<	temps, temps2: String;
461	<	Data:     Tdata;
462	<	absolutebegintime, begintime: Double;
463	<	step:     Byte;
464	<	rawlist:  TRawList;
465	<	extlist:  TExtensionsMap;
466	<	fileinfo: TFileInfo;
467	<	timeformat: TFormatSettings;
449	>	Query:     TABSQuery;
450	>	MimeCoder: TStringFormat_MIME64;
451
452	<	conIndex: Integer;
453	<	const
454	<	steps: Byte = 4;
452	>	BeginTime, FileTime: Double;
453	>	Step:       Integer;
454	>	TimeFormat: TFormatSettings;
455
456	+	ConID:      Integer;
457	+	Connection: TDataAccess;
458	+	ConRepMsg:  TStatusMessages;
459
460	+	FileID:     Integer;
461
462	+	i:          Integer;
463	+	temps:      String;
464	+	tempdata:   TByteData;
465	+	FileInfo:   TFileInfo;
466	+	DatLinks:   TDatLinkList;
467	+	RawLinks:   TRawDataList;
468	+	const
469	+	steps: Byte = 2;
470
471		procedure DoStep(stepname: String);
472		begin
#	Line 482 | Line 477 | const
477		else
478		group_progress.Caption := 'Creating DB (FINISHED)';
479		end;
480	<	}
480	>
481	>	procedure StopConvert;
482	>	begin
483	>	btn_abortok.Caption := '&Close';
484	>	btn_abortok.Default := True;
485	>	converting := False;
486	>	lbl_estimation.Caption := 'ABORTED';
487	>	group_progress.Caption := 'Creating DB (ABORTED)';
488	>	DataBase.Close;
489	>	if MessageBox(Self.Handle, PChar('Delete the unfinished DB-file?'),
490	>	PChar('Delete file?'), MB_YESNO) = idYes then
491	>	begin
492	>	DeleteFile(target);
493	>	end;
494	>	end;
495	>
496	>
497
498		begin
499	<	{  if CreateDataConnection(Source, ODB_Dat) = nil then
499	>
500	>	//
501	>	// FILE EXISTS CHECK FÜR DAT/RAW/SEP!!!
502	>	//
503	>
504	>	TimeFormat.ShortTimeFormat := 'hh:nn:ss';
505	>	TimeFormat.LongTimeFormat  := 'hh:nn:ss';
506	>	TimeFormat.TimeSeparator   := ':';
507	>
508	>	ConID := ConManager.OpenConnection(Source, ConRepMsg);
509	>	if not (ConRepMsg in [SM_OK, SM_AlreadyOpened]) then
510		begin
511	<	ShowMessage('Could not connect to .dat-file');
511	>	ShowMessage('Source-file couldn''t be opened! Aborting' + CrLf + GetOpenMsg(ConRepMsg));
512		Exit;
513	<	end
514	<	else
513	>	end else
514	>	Connection := ConManager.Connection[ConID];
515	>
516	>	ConID := ConManager.FileOpened(Target);
517	>	if ConID >= 0 then
518		begin
519	<	TOniDataDat(OniDataConnection).UnloadWhenUnused := False;
519	>	if MessageBox(Self.Handle, PChar('Destination-file is opened, close it in ' +
520	>	'order to proceed conversion?'), PChar('Destination-file opened'),
521	>	MB_YESNO + MB_ICONQUESTION) = ID_YES then
522	>	begin
523	>	if Form_Main.CheckConnectionCloseable(ConID) then
524	>	if not ConManager.CloseConnection(ConID, ConRepMsg) then
525	>	begin
526	>	ShowMessage('Couldn''t close destination-file. Aborting');
527	>	Exit;
528	>	end;
529	>	end else begin
530	>	ShowMessage('Aborting');
531	>	Exit;
532	>	end;
533		end;
534
535	<	timeformat.LongTimeFormat := 'hh:nn:ss';
536	<	timeformat.ShortTimeFormat := 'hh:nn:ss';
537	<	timeformat.TimeSeparator := ':';
535	>	if FileExists(Target) then
536	>	begin
537	>	if MessageBox(Self.Handle, PChar('Destination-file exists. ' +
538	>	'Overwrite it?'), PChar('Destination-file exists'),
539	>	MB_YESNO + MB_ICONWARNING) = ID_YES then
540	>	begin
541	>	if not DeleteFile(Target) then
542	>	begin
543	>	ShowMessage('Couldn''t delete file. Aborting');
544	>	Exit;
545	>	end;
546	>	end else begin
547	>	ShowMessage('Aborting');
548	>	Exit;
549	>	end;
550	>	end;
551
552		Self.Visible := True;
553		Form_Main.Visible := False;
#	Line 506 | Line 556 | begin
556		abort := False;
557		btn_abortok.Caption := '&Abort...';
558		btn_abortok.Default := False;
509	–	loaded_filename := target;
559
560	<	absolutebegintime := Time;
560	>	BeginTime := Time;
561
562		DataBase := TABSDatabase.Create(Self);
514	–	}
563		DataBase.MaxConnections := 1;
564	<	{
564	>	DataBase.PageSize := 8112;
565	>	DataBase.PageCountInExtent := 8;
566	>
567		DataBase.DatabaseName := 'OLDB';
568		DataBase.DatabaseFileName := target;
569		DataBase.CreateDatabase;
#	Line 527 | Line 577 | begin
577		Query := TABSQuery.Create(Self);
578		Query.DatabaseName := 'OLDB';
579		Query.SQL.Text :=
580	<	'CREATE TABLE globals  ( id AUTOINC PRIMARY KEY, name STRING(128), value STRING(128) );';
580	>	'CREATE TABLE globals  ( id AUTOINC PRIMARY KEY, name STRING(128), ' +
581	>	'value STRING(128) );';
582		Query.ExecSQL;
583		Query.SQL.Text :=
584	<	'CREATE TABLE linkmap  ( id AUTOINC PRIMARY KEY, src_id INTEGER, src_link_offset INTEGER, target_id INTEGER );';
584	>	'CREATE TABLE linkmap  ( id AUTOINC PRIMARY KEY, src_id INTEGER, ' +
585	>	'src_link_offset INTEGER, target_id INTEGER);';
586	>	Query.ExecSQL;
587	>	Query.SQL.Text := 'CREATE INDEX idsrcid ON linkmap (src_id);';
588	>	Query.ExecSQL;
589	>	Query.SQL.Text := 'CREATE INDEX idtargetid ON linkmap (target_id);';
590		Query.ExecSQL;
591		Query.SQL.Text :=
592	<	'CREATE TABLE rawmap  ( id AUTOINC PRIMARY KEY, src_id INTEGER, src_link_offset INTEGER, sep BOOLEAN, size INTEGER, data BLOB BlobCompressionMode 9 BlobBlockSize 1024 BlobCompressionAlgorithm ZLib );';
592	>	'CREATE TABLE rawmap  ( id AUTOINC PRIMARY KEY, src_id INTEGER, ' +
593	>	'src_link_offset INTEGER, sep BOOLEAN, size INTEGER, ' +
594	>	'data BLOB BlobCompressionMode 9 BlobBlockSize 1024 BlobCompressionAlgorithm ZLib);';
595		//    Query.SQL.Text:='CREATE TABLE rawmap  ( id AUTOINC PRIMARY KEY, src_id INTEGER, src_link_offset INTEGER, size INTEGER, data BLOB BlobCompressionAlgorithm None );';
596		Query.ExecSQL;
597	<	Query.SQL.Text :=
540	<	'CREATE TABLE datfiles  ( id INTEGER PRIMARY KEY, extension CHAR(4), name STRING(128), contenttype INTEGER, size INTEGER, data BLOB BlobCompressionMode 9 BlobBlockSize 1024 BlobCompressionAlgorithm ZLib );';
541	<	//    Query.SQL.Text:='CREATE TABLE datfiles  ( id INTEGER PRIMARY KEY, extension CHAR(4), name STRING(128), contenttype INTEGER, size INTEGER, data BLOB BlobCompressionAlgorithm None );';
597	>	Query.SQL.Text := 'CREATE INDEX idsrcid ON rawmap (src_id);';
598		Query.ExecSQL;
599		Query.SQL.Text :=
600	<	'CREATE TABLE extlist  ( id AUTOINC PRIMARY KEY, ext CHAR(4), ident CHAR(16) );';
600	>	'CREATE TABLE datfiles  ( id INTEGER PRIMARY KEY, extension CHAR(4), ' +
601	>	'name STRING(128), contenttype INTEGER, size INTEGER, ' +
602	>	'data BLOB BlobCompressionMode 9 BlobBlockSize 1024 BlobCompressionAlgorithm ZLib );';
603	>	//    Query.SQL.Text:='CREATE TABLE datfiles  ( id INTEGER PRIMARY KEY, extension CHAR(4), name STRING(128), contenttype INTEGER, size INTEGER, data BLOB BlobCompressionAlgorithm None );';
604		Query.ExecSQL;
605	+	//  Query.SQL.Text :=
606	+	//    'CREATE TABLE extlist  ( id AUTOINC PRIMARY KEY, ext CHAR(4), ident CHAR(16) );';
607	+	//  Query.ExecSQL;
608
609		Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("dbversion","' +
610		dbversion + '");';
611		Query.ExecSQL;
612	<	SetLength(Data, Length(OniDataConnection.LevelInfo.Ident));
551	<	for i := 0 to High(OniDataConnection.LevelInfo.Ident) do
552	<	Data[i] := OniDataConnection.LevelInfo.Ident[i];
553	<	temps := CreateHexString(Data, True);
554	<	Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("ident","' + temps + '");';
555	<	Query.ExecSQL;
612	>
613		Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("lvl","' +
614	<	IntToStr(OniDataConnection.LevelInfo.LevelNumber) + '");';
614	>	IntToStr(Connection.LevelNumber) + '");';
615		Query.ExecSQL;
616	<	if OniDataConnection.OSisMAC then
617	<	Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("os","MAC");'
618	<	else
619	<	Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("os","PC");';
620	<	Query.ExecSQL;
564	<
565	<	DoStep('Writing extensionslist');
566	<	progress.Max := Length(OniDataConnection.GetExtensionsList);
567	<	Application.ProcessMessages;
568	<
569	<	extlist := OniDataConnection.GetExtendedExtensionsList;
570	<	for i := 0 to High(extlist) do
571	<	begin
572	<	SetLength(Data, Length(extlist[i].Ident));
573	<	for j := 0 to High(extlist[i].Ident) do
574	<	Data[j] := extlist[i].Ident[j];
575	<	temps := CreateHexString(Data, True);
576	<	temps2 := extlist[i].Extension[3] + extlist[i].Extension[2] +
577	<	extlist[i].Extension[1] + extlist[i].Extension[0];
578	<	Query.SQL.Text := 'INSERT INTO extlist (ext,ident) VALUES ("' +
579	<	temps2 + '","' + temps + '");';
580	<	Query.ExecSQL;
581	<	progress.Position    := i;
582	<	lbl_progress.Caption := 'Extensions done: ' + IntToStr(i) + '/' +
583	<	IntToStr(Length(extlist));
584	<	Application.ProcessMessages;
585	<	if abort then
586	<	begin
587	<	stop_convert;
588	<	Exit;
589	<	end;
616	>	case Connection.DataOS of
617	>	DOS_WIN: temps := 'WIN';
618	>	DOS_WINDEMO: temps := 'WINDEMO';
619	>	DOS_MAC: temps := 'MAC';
620	>	DOS_MACBETA: temps := 'MACBETA';
621		end;
622	<	lbl_progress.Caption := '';
622	>	Query.SQL.Text := 'INSERT INTO globals (name,value) VALUES ("os","' + temps + '");';
623	>	Query.ExecSQL;
624
625		progress.Position      := 0;
626		lbl_progress.Caption   := 'Files done: ' + IntToStr(0) + '/' + IntToStr(
627	<	OniDataConnection.GetFilesCount);
627	>	Connection.GetFileCount);
628		lbl_estimation.Caption := 'Estimated finishing time: unknown';
629
630	<	DoStep('Loading .dat into memory');
599	<	Application.ProcessMessages;
600	<
601	<	progress.Max := OniDataConnection.GetFilesCount;
630	>	progress.Max := Connection.GetFileCount;
631		begintime    := Time;
632		DoStep('Writing .dat-fileslist');
633		Application.ProcessMessages;
634
635	+	TAccess_OniArchive(Connection).UnloadWhenUnused := False;
636	+
637	+	FileTime := Time;
638		Database.StartTransaction;
639	<	for i := 0 to OniDataConnection.GetFilesCount - 1 do
639	>	for FileID := 0 to Connection.GetFileCount - 1 do
640		begin
641	<	fileinfo := OniDataConnection.GetFileInfo(i);
641	>	fileinfo := Connection.GetFileInfo(FileID);
642		if (fileinfo.FileType and $02) = 0 then
643		begin
644		mimecoder := TStringFormat_MIME64.Create;
645	<	Data      := OniDataConnection.LoadDatFile(i);
645	>	Connection.LoadDatFile(FileID, tempdata);
646		Query.SQL.Text :=
647		'INSERT INTO datfiles (id,extension,name,contenttype,size,data) VALUES (' +
648	<	IntToStr(i) + ',"' + fileinfo.Extension + '","' + fileinfo.Name + '","' + IntToHex(
648	>	IntToStr(FileID) + ',"' + fileinfo.Extension + '","' + fileinfo.Name + '","' + IntToHex(
649		fileinfo.FileType, 8) + '",' + IntToStr(fileinfo.Size) + ',MimeToBin("' +
650	<	MimeCoder.StrTo(@Data[0], Length(Data)) + '") );';
650	>	MimeCoder.StrTo(@tempdata[0], Length(tempdata)) + '") );';
651		Query.ExecSQL;
652		mimecoder.Free;
653
654	<	rawlist := OniDataConnection.GetRawList(i);
655	<	if Length(rawlist) > 0 then
654	>	RawLinks := Connection.GetRawList(FileID);
655	>	if Length(RawLinks) > 0 then
656		begin
657	<	for j := 0 to High(rawlist) do
657	>	for i := 0 to High(RawLinks) do
658		begin
659	<	if rawlist[j].raw_size > 0 then
659	>	if RawLinks[i].RawSize > 0 then
660		begin
661	<	SetLength(Data, rawlist[j].raw_size);
662	<	OniDataConnection.LoadRawFile(i, rawlist[j].src_offset, Data);
661	>	SetLength(tempdata, RawLinks[i].RawSize);
662	>	Connection.LoadRawFile(FileID, RawLinks[i].SrcOffset, tempdata);
663		mimecoder      := TStringFormat_MIME64.Create;
664		Query.SQL.Text :=
665		'INSERT INTO rawmap (src_id,src_link_offset,sep,size,data) VALUES (' +
666	<	IntToStr(i) + ',' + IntToStr(rawlist[j].src_offset) + ',' + BoolToStr(
667	<	rawlist[j].loc_sep) + ',' + IntToStr(rawlist[j].raw_size) + ',MimeToBin("' +
668	<	MimeCoder.StrTo(@Data[0], rawlist[j].raw_size) + '") );';
666	>	IntToStr(FileID) + ', ' + IntToStr(RawLinks[i].SrcOffset) + ',' +
667	>	BoolToStr(RawLinks[i].LocSep) + ', ' +
668	>	IntToStr(RawLinks[i].RawSize) + ', ' +
669	>	'MimeToBin("' + MimeCoder.StrTo(@tempdata[0], RawLinks[i].RawSize) + '") );';
670		Query.ExecSQL;
671		mimecoder.Free;
672		end
#	Line 641 | Line 674 | begin
674		begin
675		Query.SQL.Text :=
676		'INSERT INTO rawmap (src_id,src_link_offset,sep,size) VALUES (' +
677	<	IntToStr(i) + ',' + IntToStr(rawlist[j].src_offset) + ',' + BoolToStr(rawlist[j].loc_sep) + ',0);';
677	>	IntToStr(FileID) + ', ' + IntToStr(RawLinks[i].SrcOffset) + ', ' +
678	>	BoolToStr(RawLinks[i].LocSep) + ', 0);';
679		Query.ExecSQL;
680		end;
681		end;
682		end;
683
684	<	HandleFile(fileinfo.Extension, i, True);
684	>	DatLinks := Connection.GetDatLinks(FileID);
685	>	if Length(DatLinks) > 0 then
686	>	begin
687	>	for i := 0 to High(DatLinks) do
688	>	begin
689	>	Query.SQL.Text :=
690	>	'INSERT INTO linkmap (src_id, src_link_offset, target_id) VALUES (' +
691	>	IntToStr(FileID) + ', ' + IntToStr(DatLinks[i].SrcOffset) + ', ' +
692	>	IntToStr(DatLinks[i].DestID) + ');';
693	>	Query.ExecSQL;
694	>	end;
695	>	end;
696		end
697		else
698		begin
699		Query.SQL.Text :=
700		'INSERT INTO datfiles (id,extension,name,contenttype,size) VALUES (' +
701	<	IntToStr(i) + ',"' + fileinfo.Extension + '","' + fileinfo.Name + '","' + IntToHex(
702	<	fileinfo.FileType, 8) + '",0);';
701	>	IntToStr(FileID) + ', "' + fileinfo.Extension + '", ' +
702	>	'"' + fileinfo.Name + '", "' + IntToHex(fileinfo.FileType, 8) + '", 0);';
703		Query.ExecSQL;
704		end;
705	<	if ((i mod 100) = 0) and (i > 0) then
705	>	if ((FileID mod 100) = 0) and (FileID > 0) then
706		begin
707		Database.Commit(False);
708		Database.StartTransaction;
709		end;
710	<	if ((i mod 10) = 0) and (i >= 100) then
710	>	if ((FileID mod 10) = 0) and (FileID >= 100) then
711		lbl_estimation.Caption := 'Estimated time left: ' + TimeToStr(
712	<	(Time - begintime) / i * (progress.Max - i + 1) * 1.1, timeformat );
713	<	progress.Position := i;
714	<	lbl_progress.Caption := 'Files done: ' + IntToStr(i) + '/' + IntToStr(progress.Max);
712	>	(Time - FileTime) / FileID * (progress.Max - FileID + 1) * 1.1, timeformat );
713	>	progress.Position := FileID;
714	>	lbl_progress.Caption := 'Files done: ' + IntToStr(FileID) + '/' + IntToStr(progress.Max);
715		Application.ProcessMessages;
716		if abort then
717		begin
718	<	stop_convert;
718	>	StopConvert;
719		Exit;
720		end;
721		end;
#	Line 679 | Line 724 | begin
724		lbl_progress.Caption   := 'Files done: ' + IntToStr(progress.Max) + '/' +
725		IntToStr(progress.Max);
726
727	<	lbl_estimation.Caption := 'FINISHED (duration: ' + TimeToStr(Time - absolutebegintime, timeformat) + ')';
727	>	lbl_estimation.Caption := 'FINISHED (duration: ' + TimeToStr(Time - BeginTime, timeformat) + ')';
728
729		DoStep('FIN');
730		btn_abortok.Caption := '&OK';
#	Line 687 | Line 732 | begin
732
733		converting := False;
734
735	<	database.Close;
736	<	database.Free;
692	<
693	<	CloseDataConnection(DataConnections[conIndex]);
694	<	}
695	<	end;
696	<
697	<
698	<
699	<
700	<	procedure TForm_LevelDB.StopConvert;
701	<	begin
702	<	{  btn_abortok.Caption := '&Close';
703	<	btn_abortok.Default := True;
704	<	converting := False;
705	<	lbl_estimation.Caption := 'ABORTED';
706	<	group_progress.Caption := 'Creating DB (ABORTED)';
735	>	Query.Close;
736	>	Query.Free;
737		DataBase.Close;
738	<	if MessageBox(Self.Handle, PChar('Delete the unfinished DB-file?'),
739	<	PChar('Delete file?'), MB_YESNO) = idYes then
710	<	begin
711	<	DeleteFile(loaded_filename);
712	<	end;
713	<	}end;
738	>	DataBase.Free;
739	>	end;
740
741
742
#	Line 732 | Line 758 | begin
758		end;
759
760
761	<
736	<	{
737	<	procedure InsertDatLinkToDB(fileid: LongWord; offset: LongWord);
738	<	var
739	<	link: LongWord;
740	<	begin
741	<	OniDataConnection.LoadDatFilePart(fileid, offset, 4, @link);
742	<	if link = 0 then
743	<	link := $FFFFFFFF
744	<	else
745	<	link := link div 256;
746	<	Query.SQL.Text := 'INSERT INTO linkmap (src_id,src_link_offset,target_id) VALUES (' +
747	<	IntToStr(fileid) + ',' + IntToStr(offset) + ',' + IntToStr(link) + ');';
748	<	Query.ExecSQL;
749	<	end;
750	<
751	<
752	<
753	<
754	<	procedure AISA(fileid: LongWord; dir_dat2db: Boolean);
755	<	var
756	<	packages: Word;
757	<	i: LongWord;
758	<	begin
759	<	if dir_dat2db then
760	<	begin
761	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
762	<	if packages > 0 then
763	<	begin
764	<	for i := 0 to packages - 1 do
765	<	InsertDatLinkToDB(fileid, $20 + i * $160 + $28);
766	<	for i := 0 to packages - 1 do
767	<	InsertDatLinkToDB(fileid, $20 + i * $160 + $150);
768	<	end;
769	<	end
770	<	else
771	<	begin
772	<	end;
773	<	end;
774	<
775	<
776	<
777	<
778	<	procedure AKEV(fileid: LongWord; dir_dat2db: Boolean);
779	<	var
780	<	i: LongWord;
781	<	begin
782	<	if dir_dat2db then
783	<	begin
784	<	for i := 0 to 16 do
785	<	InsertDatLinkToDB(fileid, $8 + i * 4);
786	<	end
787	<	else
788	<	begin
789	<	end;
790	<	end;
791	<
792	<
793	<
794	<
795	<	procedure AKOT(fileid: LongWord; dir_dat2db: Boolean);
796	<	var
797	<	i: LongWord;
798	<	begin
799	<	if dir_dat2db then
800	<	begin
801	<	for i := 0 to 4 do
802	<	InsertDatLinkToDB(fileid, $8 + i * 4);
803	<	end
804	<	else
805	<	begin
806	<	end;
807	<	end;
808	<
809	<
810	<
811	<
812	<	procedure CBPI(fileid: LongWord; dir_dat2db: Boolean);
813	<	var
814	<	i: LongWord;
815	<	begin
816	<	if dir_dat2db then
817	<	begin
818	<	for i := 0 to 56 do
819	<	InsertDatLinkToDB(fileid, $8 + i * 4);
820	<	end
821	<	else
822	<	begin
823	<	end;
824	<	end;
825	<
826	<
827	<
828	<
829	<	procedure CBPM(fileid: LongWord; dir_dat2db: Boolean);
830	<	var
831	<	i: LongWord;
832	<	begin
833	<	if dir_dat2db then
834	<	begin
835	<	for i := 0 to 18 do
836	<	InsertDatLinkToDB(fileid, $8 + i * 4);
837	<	end
838	<	else
839	<	begin
840	<	end;
841	<	end;
842	<
843	<
844	<
845	<
846	<	procedure CONS(fileid: LongWord; dir_dat2db: Boolean);
847	<	var
848	<	i: LongWord;
849	<	begin
850	<	if dir_dat2db then
851	<	begin
852	<	for i := 0 to 1 do
853	<	InsertDatLinkToDB(fileid, $24 + i * 4);
854	<	end
855	<	else
856	<	begin
857	<	end;
858	<	end;
859	<
860	<
861	<
862	<
863	<	procedure CRSA(fileid: LongWord; dir_dat2db: Boolean);
864	<	var
865	<	packages: LongWord;
866	<	i: LongWord;
867	<	begin
868	<	if dir_dat2db then
869	<	begin
870	<	OniDataConnection.LoadDatFilePart(fileid, $14, 4, @packages);
871	<	if packages > 0 then
872	<	for i := 0 to packages - 1 do
873	<	InsertDatLinkToDB(fileid, $20 + i * 1100 + $A0);
874	<	end
875	<	else
876	<	begin
877	<	end;
878	<	end;
879	<
880	<
881	<
882	<
883	<	procedure DOOR(fileid: LongWord; dir_dat2db: Boolean);
884	<	begin
885	<	if dir_dat2db then
886	<	begin
887	<	InsertDatLinkToDB(fileid, $08);
888	<	InsertDatLinkToDB(fileid, $10);
889	<	end
890	<	else
891	<	begin
892	<	end;
893	<	end;
894	<
895	<
896	<
897	<
898	<	procedure DPGE(fileid: LongWord; dir_dat2db: Boolean);
899	<	begin
900	<	if dir_dat2db then
901	<	begin
902	<	InsertDatLinkToDB(fileid, $40);
903	<	end
904	<	else
905	<	begin
906	<	end;
907	<	end;
908	<
909	<
910	<
911	<
912	<	procedure HPGE(fileid: LongWord; dir_dat2db: Boolean);
913	<	begin
914	<	if dir_dat2db then
915	<	begin
916	<	InsertDatLinkToDB(fileid, $0C);
917	<	end
918	<	else
919	<	begin
920	<	end;
921	<	end;
922	<
923	<
924	<
925	<
926	<	procedure IGHH(fileid: LongWord; dir_dat2db: Boolean);
927	<	begin
928	<	if dir_dat2db then
929	<	begin
930	<	InsertDatLinkToDB(fileid, $24);
931	<	InsertDatLinkToDB(fileid, $28);
932	<	end
933	<	else
934	<	begin
935	<	end;
936	<	end;
937	<
938	<
939	<
940	<
941	<	procedure IGPA(fileid: LongWord; dir_dat2db: Boolean);
942	<	var
943	<	links: LongWord;
944	<	i:     LongWord;
945	<	begin
946	<	if dir_dat2db then
947	<	begin
948	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
949	<	if links > 0 then
950	<	for i := 0 to links - 1 do
951	<	InsertDatLinkToDB(fileid, $20 + i * 4);
952	<	end
953	<	else
954	<	begin
955	<	end;
956	<	end;
957	<
958	<
959	<
960	<
961	<	procedure IGPG(fileid: LongWord; dir_dat2db: Boolean);
962	<	var
963	<	i: LongWord;
964	<	begin
965	<	if dir_dat2db then
966	<	begin
967	<	for i := 0 to 1 do
968	<	InsertDatLinkToDB(fileid, $1C + i * 4);
969	<	end
970	<	else
971	<	begin
972	<	end;
973	<	end;
974	<
975	<
976	<
977	<
978	<	procedure IGSA(fileid: LongWord; dir_dat2db: Boolean);
979	<	var
980	<	links: LongWord;
981	<	i:     LongWord;
982	<	begin
983	<	if dir_dat2db then
984	<	begin
985	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
986	<	if links > 0 then
987	<	for i := 0 to links - 1 do
988	<	InsertDatLinkToDB(fileid, $20 + i * 4);
989	<	end
990	<	else
991	<	begin
992	<	end;
993	<	end;
994	<
995	<
996	<
997	<
998	<	procedure IMPT(fileid: LongWord; dir_dat2db: Boolean);
999	<	begin
1000	<	if dir_dat2db then
1001	<	begin
1002	<	InsertDatLinkToDB(fileid, $10);
1003	<	end
1004	<	else
1005	<	begin
1006	<	end;
1007	<	end;
1008	<
1009	<
1010	<
1011	<
1012	<	procedure IPGE(fileid: LongWord; dir_dat2db: Boolean);
1013	<	begin
1014	<	if dir_dat2db then
1015	<	begin
1016	<	InsertDatLinkToDB(fileid, $0C);
1017	<	end
1018	<	else
1019	<	begin
1020	<	end;
1021	<	end;
1022	<
1023	<
1024	<
1025	<
1026	<	procedure KEYI(fileid: LongWord; dir_dat2db: Boolean);
1027	<	var
1028	<	i: LongWord;
1029	<	begin
1030	<	if dir_dat2db then
1031	<	begin
1032	<	for i := 0 to 9 do
1033	<	InsertDatLinkToDB(fileid, $08 + i * 4);
1034	<	end
1035	<	else
1036	<	begin
1037	<	end;
1038	<	end;
1039	<
1040	<
1041	<
1042	<
1043	<	procedure M3GA(fileid: LongWord; dir_dat2db: Boolean);
1044	<	var
1045	<	links: LongWord;
1046	<	i:     LongWord;
1047	<	begin
1048	<	if dir_dat2db then
1049	<	begin
1050	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @links);
1051	<	if links > 0 then
1052	<	for i := 0 to links - 1 do
1053	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1054	<	end
1055	<	else
1056	<	begin
1057	<	end;
1058	<	end;
1059	<
1060	<
1061	<
1062	<
1063	<	procedure M3GM(fileid: LongWord; dir_dat2db: Boolean);
1064	<	var
1065	<	i: LongWord;
1066	<	begin
1067	<	if dir_dat2db then
1068	<	begin
1069	<	for i := 0 to 6 do
1070	<	InsertDatLinkToDB(fileid, $0C + i * 4);
1071	<	end
1072	<	else
1073	<	begin
1074	<	end;
1075	<	end;
1076	<
1077	<
1078	<
1079	<
1080	<	procedure MTRL(fileid: LongWord; dir_dat2db: Boolean);
1081	<	begin
1082	<	if dir_dat2db then
1083	<	begin
1084	<	InsertDatLinkToDB(fileid, $10);
1085	<	end
1086	<	else
1087	<	begin
1088	<	end;
1089	<	end;
1090	<
1091	<
1092	<
1093	<
1094	<	procedure OBDC(fileid: LongWord; dir_dat2db: Boolean);
1095	<	var
1096	<	packages: Word;
1097	<	i: LongWord;
1098	<	begin
1099	<	if dir_dat2db then
1100	<	begin
1101	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1102	<	if packages > 0 then
1103	<	for i := 0 to packages - 1 do
1104	<	InsertDatLinkToDB(fileid, $20 + i * $18 + $4);
1105	<	end
1106	<	else
1107	<	begin
1108	<	end;
1109	<	end;
1110	<
1111	<
1112	<
1113	<
1114	<	procedure OBOA(fileid: LongWord; dir_dat2db: Boolean);
1115	<	var
1116	<	packages: Word;
1117	<	i: LongWord;
1118	<	begin
1119	<	if dir_dat2db then
1120	<	begin
1121	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1122	<	if packages > 0 then
1123	<	for i := 0 to packages - 1 do
1124	<	begin
1125	<	InsertDatLinkToDB(fileid, $20 + i * 240 + $0);
1126	<	InsertDatLinkToDB(fileid, $20 + i * 240 + $4);
1127	<	InsertDatLinkToDB(fileid, $20 + i * 240 + $8);
1128	<	end;
1129	<	end
1130	<	else
1131	<	begin
1132	<	end;
1133	<	end;
1134	<
1135	<
1136	<
1137	<
1138	<	procedure OFGA(fileid: LongWord; dir_dat2db: Boolean);
1139	<	var
1140	<	packages: LongWord;
1141	<	i: LongWord;
1142	<	begin
1143	<	if dir_dat2db then
1144	<	begin
1145	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1146	<	if packages > 0 then
1147	<	for i := 0 to packages - 1 do
1148	<	InsertDatLinkToDB(fileid, $20 + i * 12 + $04);
1149	<	end
1150	<	else
1151	<	begin
1152	<	end;
1153	<	end;
1154	<
1155	<
1156	<
1157	<
1158	<	procedure ONCC(fileid: LongWord; dir_dat2db: Boolean);
1159	<	var
1160	<	i: LongWord;
1161	<	begin
1162	<	if dir_dat2db then
1163	<	begin
1164	<	InsertDatLinkToDB(fileid, $28);
1165	<	InsertDatLinkToDB(fileid, $434);
1166	<	InsertDatLinkToDB(fileid, $438);
1167	<	InsertDatLinkToDB(fileid, $43C);
1168	<	InsertDatLinkToDB(fileid, $C3C);
1169	<	InsertDatLinkToDB(fileid, $C40);
1170	<	InsertDatLinkToDB(fileid, $C44);
1171	<	InsertDatLinkToDB(fileid, $C48);
1172	<	InsertDatLinkToDB(fileid, $C88);
1173	<	InsertDatLinkToDB(fileid, $C8C);
1174	<	end
1175	<	else
1176	<	begin
1177	<	end;
1178	<	end;
1179	<
1180	<
1181	<
1182	<
1183	<	procedure ONCV(fileid: LongWord; dir_dat2db: Boolean);
1184	<	begin
1185	<	if dir_dat2db then
1186	<	begin
1187	<	InsertDatLinkToDB(fileid, $08);
1188	<	end
1189	<	else
1190	<	begin
1191	<	end;
1192	<	end;
1193	<
1194	<
1195	<
1196	<
1197	<	procedure ONLV(fileid: LongWord; dir_dat2db: Boolean);
1198	<	var
1199	<	i: LongWord;
1200	<	begin
1201	<	if dir_dat2db then
1202	<	begin
1203	<	for i := 0 to 5 do
1204	<	InsertDatLinkToDB(fileid, $48 + i * 4);
1205	<	for i := 0 to 5 do
1206	<	InsertDatLinkToDB(fileid, $64 + i * 4);
1207	<	InsertDatLinkToDB(fileid, $300);
1208	<	end
1209	<	else
1210	<	begin
1211	<	end;
1212	<	end;
1213	<
1214	<
1215	<
1216	<
1217	<	procedure ONOA(fileid: LongWord; dir_dat2db: Boolean);
1218	<	var
1219	<	packages: LongWord;
1220	<	i: LongWord;
1221	<	begin
1222	<	if dir_dat2db then
1223	<	begin
1224	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1225	<	if packages > 0 then
1226	<	for i := 0 to packages - 1 do
1227	<	InsertDatLinkToDB(fileid, $20 + i * 8 + $04);
1228	<	end
1229	<	else
1230	<	begin
1231	<	end;
1232	<	end;
1233	<
1234	<
1235	<
1236	<
1237	<	procedure ONSK(fileid: LongWord; dir_dat2db: Boolean);
1238	<	begin
1239	<	if dir_dat2db then
1240	<	begin
1241	<	InsertDatLinkToDB(fileid, $08);
1242	<	InsertDatLinkToDB(fileid, $0C);
1243	<	InsertDatLinkToDB(fileid, $10);
1244	<	InsertDatLinkToDB(fileid, $14);
1245	<	InsertDatLinkToDB(fileid, $18);
1246	<	InsertDatLinkToDB(fileid, $20);
1247	<	InsertDatLinkToDB(fileid, $44);
1248	<	end
1249	<	else
1250	<	begin
1251	<	end;
1252	<	end;
1253	<
1254	<
1255	<
1256	<
1257	<	procedure ONVL(fileid: LongWord; dir_dat2db: Boolean);
1258	<	var
1259	<	packages: LongWord;
1260	<	i: LongWord;
1261	<	begin
1262	<	if dir_dat2db then
1263	<	begin
1264	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1265	<	if packages > 0 then
1266	<	for i := 0 to packages - 1 do
1267	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1268	<	end
1269	<	else
1270	<	begin
1271	<	end;
1272	<	end;
1273	<
1274	<
1275	<
1276	<
1277	<	procedure ONWC(fileid: LongWord; dir_dat2db: Boolean);
1278	<	begin
1279	<	if dir_dat2db then
1280	<	begin
1281	<	InsertDatLinkToDB(fileid, $28);
1282	<	InsertDatLinkToDB(fileid, $34);
1283	<	InsertDatLinkToDB(fileid, $40);
1284	<	InsertDatLinkToDB(fileid, $54);
1285	<	InsertDatLinkToDB(fileid, $58);
1286	<	InsertDatLinkToDB(fileid, $5C);
1287	<	InsertDatLinkToDB(fileid, $60);
1288	<	InsertDatLinkToDB(fileid, $6FC);
1289	<	InsertDatLinkToDB(fileid, $700);
1290	<	end
1291	<	else
1292	<	begin
1293	<	end;
1294	<	end;
1295	<
1296	<
1297	<
1298	<
1299	<	procedure OPGE(fileid: LongWord; dir_dat2db: Boolean);
1300	<	begin
1301	<	if dir_dat2db then
1302	<	begin
1303	<	InsertDatLinkToDB(fileid, $0C);
1304	<	end
1305	<	else
1306	<	begin
1307	<	end;
1308	<	end;
1309	<
1310	<
1311	<
1312	<
1313	<	procedure PSPC(fileid: LongWord; dir_dat2db: Boolean);
1314	<	begin
1315	<	if dir_dat2db then
1316	<	begin
1317	<	InsertDatLinkToDB(fileid, $50);
1318	<	end
1319	<	else
1320	<	begin
1321	<	end;
1322	<	end;
1323	<
1324	<
1325	<
1326	<
1327	<	procedure PSPL(fileid: LongWord; dir_dat2db: Boolean);
1328	<	var
1329	<	packages: LongWord;
1330	<	i: LongWord;
1331	<	begin
1332	<	if dir_dat2db then
1333	<	begin
1334	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1335	<	if packages > 0 then
1336	<	for i := 0 to packages - 1 do
1337	<	InsertDatLinkToDB(fileid, $20 + i * 8 + $4);
1338	<	end
1339	<	else
1340	<	begin
1341	<	end;
1342	<	end;
1343	<
1344	<
1345	<
1346	<
1347	<	procedure PSUI(fileid: LongWord; dir_dat2db: Boolean);
1348	<	var
1349	<	i: LongWord;
1350	<	begin
1351	<	if dir_dat2db then
1352	<	begin
1353	<	for i := 0 to 43 do
1354	<	InsertDatLinkToDB(fileid, $08 + i * 4);
1355	<	end
1356	<	else
1357	<	begin
1358	<	end;
1359	<	end;
1360	<
1361	<
1362	<
1363	<
1364	<	procedure STNA(fileid: LongWord; dir_dat2db: Boolean);
1365	<	var
1366	<	packages: Word;
1367	<	i: LongWord;
1368	<	begin
1369	<	if dir_dat2db then
1370	<	begin
1371	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1372	<	if packages > 0 then
1373	<	for i := 0 to packages - 1 do
1374	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1375	<	end
1376	<	else
1377	<	begin
1378	<	end;
1379	<	end;
1380	<
1381	<
1382	<
1383	<
1384	<	procedure TRAC(fileid: LongWord; dir_dat2db: Boolean);
1385	<	var
1386	<	packages: Word;
1387	<	i: LongWord;
1388	<	begin
1389	<	if dir_dat2db then
1390	<	begin
1391	<	InsertDatLinkToDB(fileid, $18);
1392	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1393	<	if packages > 0 then
1394	<	for i := 0 to packages - 1 do
1395	<	InsertDatLinkToDB(fileid, $20 + i * 12 + 8);
1396	<	end
1397	<	else
1398	<	begin
1399	<	end;
1400	<	end;
1401	<
1402	<
1403	<
1404	<
1405	<	procedure TRAM(fileid: LongWord; dir_dat2db: Boolean);
1406	<	begin
1407	<	if dir_dat2db then
1408	<	begin
1409	<	InsertDatLinkToDB(fileid, $40);
1410	<	InsertDatLinkToDB(fileid, $44);
1411	<	end
1412	<	else
1413	<	begin
1414	<	end;
1415	<	end;
1416	<
1417	<
1418	<
1419	<
1420	<	procedure TRAS(fileid: LongWord; dir_dat2db: Boolean);
1421	<	begin
1422	<	if dir_dat2db then
1423	<	begin
1424	<	InsertDatLinkToDB(fileid, $08);
1425	<	end
1426	<	else
1427	<	begin
1428	<	end;
1429	<	end;
1430	<
1431	<
1432	<
1433	<
1434	<	procedure TRBS(fileid: LongWord; dir_dat2db: Boolean);
1435	<	var
1436	<	i: LongWord;
1437	<	begin
1438	<	if dir_dat2db then
1439	<	begin
1440	<	for i := 0 to 4 do
1441	<	InsertDatLinkToDB(fileid, $08 + i * 4);
1442	<	end
1443	<	else
1444	<	begin
1445	<	end;
1446	<	end;
1447	<
1448	<
1449	<
1450	<
1451	<	procedure TRCM(fileid: LongWord; dir_dat2db: Boolean);
1452	<	var
1453	<	i: LongWord;
1454	<	begin
1455	<	if dir_dat2db then
1456	<	begin
1457	<	for i := 0 to 2 do
1458	<	InsertDatLinkToDB(fileid, $5C + i * 4);
1459	<	end
1460	<	else
1461	<	begin
1462	<	end;
1463	<	end;
1464	<
1465	<
1466	<
1467	<
1468	<	procedure TRGA(fileid: LongWord; dir_dat2db: Boolean);
1469	<	var
1470	<	i: LongWord;
1471	<	packages: Word;
1472	<	begin
1473	<	if dir_dat2db then
1474	<	begin
1475	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1476	<	if packages > 0 then
1477	<	for i := 0 to packages - 1 do
1478	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1479	<	end
1480	<	else
1481	<	begin
1482	<	end;
1483	<	end;
1484	<
1485	<
1486	<
1487	<
1488	<	procedure TRGE(fileid: LongWord; dir_dat2db: Boolean);
1489	<	begin
1490	<	if dir_dat2db then
1491	<	begin
1492	<	InsertDatLinkToDB(fileid, $20);
1493	<	end
1494	<	else
1495	<	begin
1496	<	end;
1497	<	end;
1498	<
1499	<
1500	<
1501	<
1502	<	procedure TRIG(fileid: LongWord; dir_dat2db: Boolean);
1503	<	begin
1504	<	if dir_dat2db then
1505	<	begin
1506	<	InsertDatLinkToDB(fileid, $18);
1507	<	InsertDatLinkToDB(fileid, $24);
1508	<	InsertDatLinkToDB(fileid, $28);
1509	<	end
1510	<	else
1511	<	begin
1512	<	end;
1513	<	end;
1514	<
1515	<
1516	<
1517	<
1518	<	procedure TRMA(fileid: LongWord; dir_dat2db: Boolean);
1519	<	var
1520	<	i: LongWord;
1521	<	packages: Word;
1522	<	begin
1523	<	if dir_dat2db then
1524	<	begin
1525	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1526	<	if packages > 0 then
1527	<	for i := 0 to packages - 1 do
1528	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1529	<	end
1530	<	else
1531	<	begin
1532	<	end;
1533	<	end;
1534	<
1535	<
1536	<
1537	<
1538	<	procedure TRSC(fileid: LongWord; dir_dat2db: Boolean);
1539	<	var
1540	<	i: LongWord;
1541	<	packages: Word;
1542	<	begin
1543	<	if dir_dat2db then
1544	<	begin
1545	<	OniDataConnection.LoadDatFilePart(fileid, $1E, 2, @packages);
1546	<	if packages > 0 then
1547	<	for i := 0 to packages - 1 do
1548	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1549	<	end
1550	<	else
1551	<	begin
1552	<	end;
1553	<	end;
1554	<
1555	<
1556	<
1557	<
1558	<	procedure TSFF(fileid: LongWord; dir_dat2db: Boolean);
1559	<	var
1560	<	i: LongWord;
1561	<	packages: LongWord;
1562	<	begin
1563	<	if dir_dat2db then
1564	<	begin
1565	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1566	<	if packages > 0 then
1567	<	for i := 0 to packages - 1 do
1568	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1569	<	end
1570	<	else
1571	<	begin
1572	<	end;
1573	<	end;
1574	<
1575	<
1576	<
1577	<
1578	<	procedure TSFT(fileid: LongWord; dir_dat2db: Boolean);
1579	<	begin
1580	<	if dir_dat2db then
1581	<	begin
1582	<	InsertDatLinkToDB(fileid, $1C);
1583	<	end
1584	<	else
1585	<	begin
1586	<	end;
1587	<	end;
1588	<
1589	<
1590	<
1591	<
1592	<	procedure TURR(fileid: LongWord; dir_dat2db: Boolean);
1593	<	begin
1594	<	if dir_dat2db then
1595	<	begin
1596	<	InsertDatLinkToDB(fileid, $60);
1597	<	InsertDatLinkToDB(fileid, $6C);
1598	<	InsertDatLinkToDB(fileid, $74);
1599	<	end
1600	<	else
1601	<	begin
1602	<	end;
1603	<	end;
1604	<
1605	<
1606	<
1607	<
1608	<	procedure TXAN(fileid: LongWord; dir_dat2db: Boolean);
1609	<	var
1610	<	i: LongWord;
1611	<	packages: LongWord;
1612	<	begin
1613	<	if dir_dat2db then
1614	<	begin
1615	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1616	<	if packages > 0 then
1617	<	for i := 0 to packages - 1 do
1618	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1619	<	end
1620	<	else
1621	<	begin
1622	<	end;
1623	<	end;
1624	<
1625	<
1626	<
1627	<
1628	<	procedure TXMA(fileid: LongWord; dir_dat2db: Boolean);
1629	<	var
1630	<	i: LongWord;
1631	<	packages: LongWord;
1632	<	begin
1633	<	if dir_dat2db then
1634	<	begin
1635	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1636	<	if packages > 0 then
1637	<	for i := 0 to packages - 1 do
1638	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1639	<	end
1640	<	else
1641	<	begin
1642	<	end;
1643	<	end;
1644	<
1645	<
1646	<
1647	<
1648	<	procedure TXMB(fileid: LongWord; dir_dat2db: Boolean);
1649	<	var
1650	<	i: LongWord;
1651	<	packages: LongWord;
1652	<	begin
1653	<	if dir_dat2db then
1654	<	begin
1655	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1656	<	if packages > 0 then
1657	<	for i := 0 to packages - 1 do
1658	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1659	<	end
1660	<	else
1661	<	begin
1662	<	end;
1663	<	end;
1664	<
1665	<
1666	<
1667	<
1668	<	procedure TXMP(fileid: LongWord; dir_dat2db: Boolean);
1669	<	begin
1670	<	if dir_dat2db then
1671	<	begin
1672	<	InsertDatLinkToDB(fileid, $94);
1673	<	InsertDatLinkToDB(fileid, $98);
1674	<	end
1675	<	else
1676	<	begin
1677	<	end;
1678	<	end;
1679	<
1680	<
1681	<
1682	<
1683	<	procedure TXTC(fileid: LongWord; dir_dat2db: Boolean);
1684	<	begin
1685	<	if dir_dat2db then
1686	<	begin
1687	<	InsertDatLinkToDB(fileid, $08);
1688	<	end
1689	<	else
1690	<	begin
1691	<	end;
1692	<	end;
1693	<
1694	<
1695	<
1696	<
1697	<	procedure WMCL(fileid: LongWord; dir_dat2db: Boolean);
1698	<	var
1699	<	i: LongWord;
1700	<	packages: LongWord;
1701	<	begin
1702	<	if dir_dat2db then
1703	<	begin
1704	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1705	<	if packages > 0 then
1706	<	for i := 0 to packages - 1 do
1707	<	InsertDatLinkToDB(fileid, $20 + i * 8 + $4);
1708	<	end
1709	<	else
1710	<	begin
1711	<	end;
1712	<	end;
1713	<
1714	<
1715	<
1716	<
1717	<	procedure WMDD(fileid: LongWord; dir_dat2db: Boolean);
1718	<	var
1719	<	i: LongWord;
1720	<	packages: LongWord;
1721	<	begin
1722	<	if dir_dat2db then
1723	<	begin
1724	<	OniDataConnection.LoadDatFilePart(fileid, $11C, 4, @packages);
1725	<	if packages > 0 then
1726	<	for i := 0 to packages - 1 do
1727	<	InsertDatLinkToDB(fileid, $120 + i * $124 + $114);
1728	<	end
1729	<	else
1730	<	begin
1731	<	end;
1732	<	end;
1733	<
1734	<
1735	<
1736	<
1737	<	procedure WMMB(fileid: LongWord; dir_dat2db: Boolean);
1738	<	var
1739	<	i: LongWord;
1740	<	packages: LongWord;
1741	<	begin
1742	<	if dir_dat2db then
1743	<	begin
1744	<	OniDataConnection.LoadDatFilePart(fileid, $1C, 4, @packages);
1745	<	if packages > 0 then
1746	<	for i := 0 to packages - 1 do
1747	<	InsertDatLinkToDB(fileid, $20 + i * 4);
1748	<	end
1749	<	else
1750	<	begin
1751	<	end;
1752	<	end;
1753	<
1754	<
1755	<
1756	<
1757	<	procedure WPGE(fileid: LongWord; dir_dat2db: Boolean);
1758	<	begin
1759	<	if dir_dat2db then
1760	<	begin
1761	<	InsertDatLinkToDB(fileid, $08);
1762	<	InsertDatLinkToDB(fileid, $0C);
1763	<	end
1764	<	else
1765	<	begin
1766	<	end;
1767	<	end;
1768	<	}
1769	<
1770	<
1771	<	{
1772	<	procedure InsertHandler(ext: String; needed: Boolean; handler: THandler);
1773	<	begin
1774	<	SetLength(ConvertHandlers, Length(ConvertHandlers) + 1);
1775	<	ConvertHandlers[High(ConvertHandlers)].Ext     := ext;
1776	<	ConvertHandlers[High(ConvertHandlers)].needed  := needed;
1777	<	ConvertHandlers[High(ConvertHandlers)].handler := handler;
1778	<	end;
1779	<	}
1780	<	begin
1781	<	{  InsertHandler('ABNA', False, nil);
1782	<	//  InsertHandler('AGDB',True,AGDB);
1783	<	InsertHandler('AGDB', False, nil);
1784	<	InsertHandler('AGQC', False, nil);
1785	<	InsertHandler('AGQG', False, nil);
1786	<	InsertHandler('AGQR', False, nil);
1787	<	InsertHandler('AISA', True, AISA);
1788	<	InsertHandler('AITR', False, nil);
1789	<	InsertHandler('AKAA', False, nil);
1790	<	InsertHandler('AKBA', False, nil);
1791	<	InsertHandler('AKBP', False, nil);
1792	<	InsertHandler('AKDA', False, nil);
1793	<	InsertHandler('AKEV', True, AKEV);
1794	<	InsertHandler('AKOT', True, AKOT);
1795	<	InsertHandler('AKVA', False, nil);
1796	<	InsertHandler('BINA', False, nil);
1797	<	InsertHandler('CBPI', True, CBPI);
1798	<	InsertHandler('CBPM', True, CBPM);
1799	<	InsertHandler('CONS', True, CONS);
1800	<	InsertHandler('CRSA', True, CRSA);
1801	<	InsertHandler('DOOR', True, DOOR);
1802	<	InsertHandler('DPGE', True, DPGE);
1803	<	InsertHandler('ENVP', False, nil);
1804	<	InsertHandler('FILM', False, nil);
1805	<	InsertHandler('HPGE', True, HPGE);
1806	<	InsertHandler('IDXA', False, nil);
1807	<	InsertHandler('IGHH', True, IGHH);
1808	<	InsertHandler('IGPA', True, IGPA);
1809	<	InsertHandler('IGPG', True, IGPG);
1810	<	InsertHandler('IGSA', True, IGSA);
1811	<	InsertHandler('IMPT', True, IMPT);
1812	<	InsertHandler('IPGE', True, IPGE);
1813	<	InsertHandler('KEYI', True, KEYI);
1814	<	InsertHandler('M3GA', True, M3GA);
1815	<	InsertHandler('M3GM', True, M3GM);
1816	<	InsertHandler('MTRL', True, MTRL);
1817	<	InsertHandler('OBAN', False, nil);
1818	<	InsertHandler('OBDC', True, OBDC);
1819	<	InsertHandler('OBOA', True, OBOA);
1820	<	InsertHandler('OFGA', True, OFGA);
1821	<	InsertHandler('ONCC', True, ONCC);
1822	<	InsertHandler('ONCP', False, nil);
1823	<	InsertHandler('ONCV', True, ONCV);
1824	<	InsertHandler('ONFA', False, nil);
1825	<	InsertHandler('ONGS', False, nil);
1826	<	InsertHandler('ONIA', False, nil);
1827	<	InsertHandler('ONLD', False, nil);
1828	<	InsertHandler('ONLV', True, ONLV);
1829	<	InsertHandler('ONMA', False, nil);
1830	<	InsertHandler('ONOA', True, ONOA);
1831	<	InsertHandler('ONSA', False, nil);
1832	<	InsertHandler('ONSK', True, ONSK);
1833	<	InsertHandler('ONTA', False, nil);
1834	<	InsertHandler('ONVL', True, ONVL);
1835	<	InsertHandler('ONWC', True, ONWC);
1836	<	InsertHandler('OPGE', True, OPGE);
1837	<	InsertHandler('OSBD', False, nil);
1838	<	InsertHandler('OTIT', False, nil);
1839	<	InsertHandler('OTLF', False, nil);
1840	<	InsertHandler('PLEA', False, nil);
1841	<	InsertHandler('PNTA', False, nil);
1842	<	InsertHandler('PSPC', True, PSPC);
1843	<	InsertHandler('PSPL', True, PSPL);
1844	<	InsertHandler('PSUI', True, PSUI);
1845	<	InsertHandler('QTNA', False, nil);
1846	<	InsertHandler('SNDD', False, nil);
1847	<	InsertHandler('STNA', True, STNA);
1848	<	InsertHandler('SUBT', False, nil);
1849	<	InsertHandler('TRAC', True, TRAC);
1850	<	InsertHandler('TRAM', True, TRAM);
1851	<	InsertHandler('TRAS', True, TRAS);
1852	<	InsertHandler('TRBS', True, TRBS);
1853	<	InsertHandler('TRCM', True, TRCM);
1854	<	InsertHandler('TRGA', True, TRGA);
1855	<	InsertHandler('TRGE', True, TRGE);
1856	<	InsertHandler('TRIA', False, nil);
1857	<	InsertHandler('TRIG', True, TRIG);
1858	<	InsertHandler('TRMA', True, TRMA);
1859	<	InsertHandler('TRSC', True, TRSC);
1860	<	InsertHandler('TRTA', False, nil);
1861	<	InsertHandler('TSFF', True, TSFF);
1862	<	InsertHandler('TSFL', False, nil);
1863	<	InsertHandler('TSFT', True, TSFT);
1864	<	InsertHandler('TSGA', False, nil);
1865	<	InsertHandler('TSTR', False, nil);
1866	<	InsertHandler('TURR', True, TURR);
1867	<	InsertHandler('TXAN', True, TXAN);
1868	<	InsertHandler('TXCA', False, nil);
1869	<	InsertHandler('TXMA', True, TXMA);
1870	<	InsertHandler('TXMB', True, TXMB);
1871	<	InsertHandler('TXMP', True, TXMP);
1872	<	InsertHandler('TXTC', True, TXTC);
1873	<	InsertHandler('VCRA', False, nil);
1874	<	InsertHandler('WMCL', True, WMCL);
1875	<	InsertHandler('WMDD', True, WMDD);
1876	<	InsertHandler('WMM_', False, nil);
1877	<	InsertHandler('WMMB', True, WMMB);
1878	<	InsertHandler('WPGE', True, WPGE);
1879	<	}end.
761	>	end.

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)