Click here to Skip to main content
15,895,829 members
Search within:


Articles / Desktop Programming / Windows Forms
 

Listing and Working with Files in Archives

Rate me:
Please Sign up or sign in to vote.
2.86/5 (6 votes)
22 Jun 2007CPOL 32.3K   529   23  
This article describes how to use CAKE3, which is a wrapper component for many archiver DLLs,
 
/*
 * Created by SharpDevelop.
 * User: LYCJ
 * Date: 27/11/2006
 * Time: 22:28
 * 
 * To change this template use Tools | Options | Coding | Edit Standard Headers.
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using AceDllWrapped;
using Cake3;

namespace Cake3.Ace
{
	/// <summary>
	/// Cake3 Ace Wrapper, based on the official AceDllWrapped namespace.
	/// </summary>
	public class AceArchiver :CakArchiver
	{
		private static AceArchiver arc;
		private static string processingFile;		
		private static string processingAction;
		private static string extractPassword;
		private static ExtractOptions extractOptions;
		private static string DllName = "acev2.dll";
		
		public AceArchiver() : base()
		{						
		}
		
		internal override void setArchiveName(string anArchive)
		{			
			base.setArchiveName(anArchive);
			
			string extension = Cake3.Utils.ExtractFileExt(anArchive).ToLower();
			switch (extension)
			{
				case ".ace" :					
					break;
				default : throw new NotSupportedException();
			}
			
			canList = true;
			canExtract = true;
			canAdd = false;
		}
		
		public override List<string> SupportedExtensions()
		{ 
			List<string> retVal = new List<string>();
			if (Utils.verifyDllPath(DllName))
				retVal.Add(".ace");		
			return retVal;		
		}						
		
		public override bool Open()
		{ 
			if (archiveOpened) 
				return false;
			
			
			sACEArchiveDataStruc ArchiveData = new sACEArchiveDataStruc();
			if (AceWrap.CallAceInitDll())
			{
				if (AceWrap.CallAceReadArchiveData(archiveName,ref ArchiveData))
				{
					archiveOpened = true;
					return true;					
				}
			}			
			
			
			return false;
		}
		
		public override bool Close()
		{
			if (!archiveOpened) 
				return false;
						
			AceWrap.AceDone();
			
			archiveOpened = false;
			return true;
		}
				
		
		public override bool List(string mask) 
		{ 
			if(OnItemList == null) return false;
			
			arc = this;					
			AceWrap.CallAceList(archiveName, "*.*");							
			
			return true;
		}
		
		
		public override bool Test()
		{			
			return AceWrap.CallAceTest(archiveName, "*.*");			
		}
		
		
		public override bool Extract(ExtractOptions options)
		{
			Int32 allowFolder = 1;
			if (options.allowFolder) 
				allowFolder = 0;
			
			extractPassword = options.password;
			extractOptions = options;
			
			foreach (string item in options.extractItem)				
				if (!AceWrap.CallAceExtract(archiveName, ModifySlashFromCak(item), options.extractFolder, allowFolder))
					return false;
									
			return true;
		}								
		
		private static string ModifySlashToCak(string input)
		{
			return Utils.AppendFrontSlash( input );
		}
		
		private static string ModifySlashFromCak(string input)
		{
			return Utils.RemoveFrontSlash( input );
		}
		
		
		#region StateProc		
		public static int HandleStateStartFile(sACECallbackArchivedFileStruc ArchivedFile)
		{

			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(ArchivedFile.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(ArchivedFile.ArchiveData, typeof(sACEArchiveDataStruc));
			sACEFileDataStruc FileData		 = (sACEFileDataStruc)Marshal.PtrToStructure(ArchivedFile.FileData, typeof(sACEFileDataStruc));

			processingAction = "";
			processingFile = FileData.SourceFileName;
			
			switch (ArchivedFile.Operation)
			{
				case Callback.ACE_CALLBACK_OPERATION_LIST:
				{	if (FileData.CRC32 != 4294967295) // <== Directory!
						arc.OnItemList(arc, new ItemListEventArgs(arc, 
							                new ContentType((UInt32)FileData.Size, (UInt32)FileData.CompressedSize,
							                Utils.DosDateToDateTime(FileData.Time), FileData.CRC32,
											 ModifySlashToCak(FileData.SourceFileName), false)) );
					break;
				}

				case Callback.ACE_CALLBACK_OPERATION_TEST: 					
					{ processingAction = "PROCESSTEST";
						break; }
				case Callback.ACE_CALLBACK_OPERATION_EXTRACT: 
					{ processingAction = "PROCESSEXTR";
						break; }
//				case Callback.ACE_CALLBACK_OPERATION_ADD: 
//					{ arc.DispMessage(Defines.ErrorMessage("PROCESSADD"), processingFile);
//						break; }
//				case Callback.ACE_CALLBACK_OPERATION_REPACK:
//					{ arc.DispMessage(Defines.ErrorMessage("PROCESSREADD"), processingFile);
//						break; }
//				case Callback.ACE_CALLBACK_OPERATION_DELETE:
//					{ arc.DispMessage(Defines.ErrorMessage("PROCESSREDEL"), processingFile);
//						break; }
//				case Callback.ACE_CALLBACK_OPERATION_REPAIR:
//					{ arc.DispMessage(Defines.ErrorMessage("PROCESSREPAIR"), processingFile);
//						break; }
				default:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESS"), processingFile);
						break; }
			}
			
			
			return Callback.ACE_CALLBACK_RETURN_OK;
		}
				
		public static int HandleStateStartArchive(sACECallbackArchiveStruc Archive)
		{			
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(Archive.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(Archive.ArchiveData, typeof(sACEArchiveDataStruc));

			string arcName = ArchiveData.ArchiveName;
			
			switch (Archive.Operation)
			{				
				case Callback.ACE_CALLBACK_OPERATION_LIST:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSLIST"), arcName);
						break; }
				case Callback.ACE_CALLBACK_OPERATION_TEST:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSTEST"), arcName);
						break; }
				case Callback.ACE_CALLBACK_OPERATION_EXTRACT:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSEXTR"), arcName);
						break; }
				case Callback.ACE_CALLBACK_OPERATION_ADD:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSADD"), arcName);
						break; }
				case Callback.ACE_CALLBACK_OPERATION_DELETE:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSDEL"), arcName);
						break; }
				case Callback.ACE_CALLBACK_OPERATION_REPAIR:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSREPAIR"), arcName);
						break; }	
				case Callback.ACE_CALLBACK_OPERATION_RECOVER:
					{	arc.DispMessage(Defines.ErrorMessage("PROCESSREPAIR"), arcName);
						break; }		
//				case Callback.ACE_CALLBACK_OPERATION_SETCMT:
//				case Callback.ACE_CALLBACK_OPERATION_ADDSFX:
//				case Callback.ACE_CALLBACK_OPERATION_ENCRYPT:
//				case Callback.ACE_CALLBACK_OPERATION_HEADSEARCH:
//				case Callback.ACE_CALLBACK_OPERATION_RECRECSEARCH:
//				case Callback.ACE_CALLBACK_OPERATION_LOCK:
//				case Callback.ACE_CALLBACK_OPERATION_ADDRECOVREC:
			}

			return Callback.ACE_CALLBACK_RETURN_OK;
		}

	
		public static int StateProc(IntPtr State)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACECallbackArchiveStruc Archive    = (sACECallbackArchiveStruc)Marshal.PtrToStructure(State, typeof(sACECallbackArchiveStruc));

			switch (Archive.StructureType)
			{
				case Callback.ACE_CALLBACK_TYPE_ARCHIVE:
				{	if (Archive.Code == Callback.ACE_CALLBACK_STATE_STARTARCHIVE)
							return HandleStateStartArchive(Archive);					
					break;	
				}
					
				case Callback.ACE_CALLBACK_TYPE_ARCHIVEDFILE:
				{ 	// make data from native memory accessible by marshalling to managed structures
					sACECallbackArchivedFileStruc ArchivedFile  = (sACECallbackArchivedFileStruc)Marshal.PtrToStructure(State, typeof(sACECallbackArchivedFileStruc));

					if (ArchivedFile.Code == Callback.ACE_CALLBACK_STATE_STARTFILE)
						return HandleStateStartFile(ArchivedFile);
					break;	
				}

//				case Callback.ACE_CALLBACK_TYPE_REALFILE:

				case Callback.ACE_CALLBACK_TYPE_PROGRESS:
				{	// make data from native memory accessible by marshalling to managed structures
					sACECallbackProgressStruc Progress  = (sACECallbackProgressStruc)Marshal.PtrToStructure(State, typeof(sACECallbackProgressStruc));

					if (arc.OnProgress != null)
						if (Progress.Code == Callback.ACE_CALLBACK_STATE_PROGRESS)
					{
						// make data from native memory accessible by marshalling to managed structures
						sACEProgressDataStruc ProgressData  = (sACEProgressDataStruc)Marshal.PtrToStructure(Progress.ProgressData, typeof(sACEProgressDataStruc));
						float Ratio = (float)ProgressData.TotalProcessedSize / (float)ProgressData.TotalSize * 100;

						arc.OnProgress(arc, new ProgressEventArgs(arc, (UInt16)Ratio, processingFile));
					}

					break;	
				}

				case Callback.ACE_CALLBACK_TYPE_CRCCHECK:
				{	// make data from native memory accessible by marshalling to managed structures
					sACECallbackCRCCheckStruc CRCCheck  = (sACECallbackCRCCheckStruc)Marshal.PtrToStructure(State, typeof(sACECallbackCRCCheckStruc));

					if (processingAction != "")
					if (CRCCheck.Code == Callback.ACE_CALLBACK_STATE_ENDCRCCHECK)
					if (CRCCheck.CRCOk)	
						arc.DispMessage(Defines.ErrorMessage("PROCESSOK"), processingFile);
					else arc.DispMessage(Defines.ErrorMessage("PROCESSFAIL"), processingFile);					

					break;	
				}
			}

			return Callback.ACE_CALLBACK_RETURN_OK;
		}
		#endregion
				
		#region ErrorProc
		public static int HandleErrorGlobal(sACECallbackGlobalStruc Global)
		{
			switch (Global.Code)
			{
				case Callback.ACE_CALLBACK_ERROR_MEMORY:
				{	arc.DispError(Defines.ErrorMessage("NOMEMORY"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_OK;	}

				case Callback.ACE_CALLBACK_ERROR_UNCSPACE:
				{	arc.DispError(Defines.ErrorMessage("NODISKSPACE"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_OK;	}

				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_CANCEL;	}
			}			
		}

		
		public static int HandleErrorArchive(sACECallbackArchiveStruc Archive)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(Archive.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(Archive.ArchiveData, typeof(sACEArchiveDataStruc));

			string ArcName = ArchiveData.ArchiveName;

			switch (Archive.Code)
			{			
				case Callback.ACE_CALLBACK_ERROR_AV:
				{	arc.DispError(Defines.ErrorMessage("AVERROR"), ArcName);					
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_OPENARCHIVEREAD:
				{	arc.DispError(Defines.ErrorMessage("LISTERROR"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_READARCHIVE:
				{	arc.DispError(Defines.ErrorMessage("READERROR"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_ARCHIVEBROKEN:
				{	arc.DispError(Defines.ErrorMessage("HEADERBROKE"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_NOFILES:
				{	arc.DispError(Defines.ErrorMessage("NOTSPECIFY"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_ISNOTANARCHIVE:
				{	arc.DispError(Defines.ErrorMessage("NOTARC"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_HIGHERVERSION:
				{	arc.DispError(Defines.ErrorMessage("WRONGVER"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_MODIFYVOLUME:
				{ 	arc.DispError(Defines.ErrorMessage("READONLY"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_MODIFYLOCKEDARCHIVE:
				{ 	arc.DispError(Defines.ErrorMessage("READONLY"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_TOODAMAGED:
				{ 	arc.DispError(Defines.ErrorMessage("READERROR"), ArcName);	
					arc.DispMessage(Defines.ErrorMessage("PROCESSREPAIR"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_ARCHIVEEXISTS:
				{ 	arc.DispError(Defines.ErrorMessage("EXIST"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
				case Callback.ACE_CALLBACK_ERROR_OPENREPAIRARCHIVE:
				{ 	arc.DispError(Defines.ErrorMessage("CANTOPEN"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}
//				case Callback.ACE_CALLBACK_ERROR_OPENARCHIVEWRITE:
//				case Callback.ACE_CALLBACK_ERROR_WRITEARCHIVE:
//				case Callback.ACE_CALLBACK_ERROR_ALREADYSFX:
//				case Callback.ACE_CALLBACK_ERROR_ADDSFXTOVOLUME:
//				case Callback.ACE_CALLBACK_ERROR_ARCHIVESAVE:
				case Callback.ACE_CALLBACK_ERROR_TEMPDIRCREATE:
				{ 	arc.DispError(Defines.ErrorMessage("COPYTEMP"), ArcName);	
					return Callback.ACE_CALLBACK_RETURN_OK;	}

				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), ArcName);
						return Callback.ACE_CALLBACK_RETURN_CANCEL;	}				
			}
		}

		
		public static int HandleErrorArchivedFile(sACECallbackArchivedFileStruc ArchivedFile)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(ArchivedFile.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(ArchivedFile.ArchiveData, typeof(sACEArchiveDataStruc));
			sACEFileDataStruc FileData       = (sACEFileDataStruc)Marshal.PtrToStructure(ArchivedFile.FileData, typeof(sACEFileDataStruc));

			string FileName = FileData.SourceFileName;

			switch (ArchivedFile.Code)
			{
					/* .. add more codes to handle here ..*/

				case Callback.ACE_CALLBACK_ERROR_CREATIONNAMEINUSE:
				{	arc.DispError(Defines.ErrorMessage("SAMENAME"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
				case Callback.ACE_CALLBACK_ERROR_WRITE:
				{	arc.DispError(Defines.ErrorMessage("CANTWRITE"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
				case Callback.ACE_CALLBACK_ERROR_OPENWRITE:
				{	arc.DispError(Defines.ErrorMessage("CANTWRITE"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
				case Callback.ACE_CALLBACK_ERROR_METHOD:
				{	arc.DispError(Defines.ErrorMessage("NOSUPPORT"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}						
				case Callback.ACE_CALLBACK_ERROR_EXTRACTSPACE:
				{	arc.DispError(Defines.ErrorMessage("NODISKSPACE"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
				case Callback.ACE_CALLBACK_ERROR_CREATION:
				{	arc.DispError(Defines.ErrorMessage("CANTWRITE"), FileName);
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
//				case Callback.ACE_CALLBACK_ERROR_ENCRYPTIONCRC:
//				case Callback.ACE_CALLBACK_ERROR_READ:				
//				case Callback.ACE_CALLBACK_ERROR_OPENREAD:
//				case Callback.ACE_CALLBACK_ERROR_FILENAMETOOLONG:
//				case Callback.ACE_CALLBACK_ERROR_REPACKCRC:
//				case Callback.ACE_CALLBACK_ERROR_EXCLUDEPATH:
				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), FileName);
						return Callback.ACE_CALLBACK_RETURN_CANCEL;	}			
			}

		}


		public static int HandleErrorRealFile(sACECallbackRealFileStruc ErrorRealFile)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(ErrorRealFile.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(ErrorRealFile.ArchiveData, typeof(sACEArchiveDataStruc));

			switch (ErrorRealFile.Code)
			{

//				case Callback.ACE_CALLBACK_ERROR_MOVEDELETE:

				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), "");
						return Callback.ACE_CALLBACK_RETURN_CANCEL;	}		
			}
		}


		public static int HandleErrorSpace(ref sACECallbackSpaceStruc ErrorSpace)
		{
			switch (ErrorSpace.Code)
			{
				case Callback.ACE_CALLBACK_ERROR_TEMPDIRSPACE:
				{	arc.DispError(Defines.ErrorMessage("COPYTEMP"), "");
					arc.DispError(Defines.ErrorMessage("NODISKSPACE"), "");					
					ErrorSpace.Directory = Cake3.Utils.GetTempPath();
					return Callback.ACE_CALLBACK_RETURN_OK;	}						
//				case Callback.ACE_CALLBACK_ERROR_ARCHIVESPACE:

				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), "");
						return Callback.ACE_CALLBACK_RETURN_CANCEL;	}	
			}

		}


		public static int HandleErrorSFXFile(sACECallbackSFXFileStruc ErrorSFXFile)
		{
			switch (ErrorSFXFile.Code)
			{
				case Callback.ACE_CALLBACK_ERROR_READINGSFXFILE:
				{	arc.DispError(Defines.ErrorMessage("NOTARC"), "");
						return Callback.ACE_CALLBACK_RETURN_OK;	}	
				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), "");
						return Callback.ACE_CALLBACK_RETURN_CANCEL;	}			
			}
		}


		public static int ErrorProc(IntPtr Error)
		{
			int Result = new int();

			// make data from native memory accessible by marshalling to managed structures
			sACECallbackGlobalStruc Global = (sACECallbackGlobalStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackGlobalStruc));

			switch (Global.StructureType)
			{
				case Callback.ACE_CALLBACK_TYPE_GLOBAL:
				{
					Result = HandleErrorGlobal(Global);
					break;
				}

				case Callback.ACE_CALLBACK_TYPE_ARCHIVE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackArchiveStruc Archive  = (sACECallbackArchiveStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackArchiveStruc));
					Result = HandleErrorArchive(Archive); 
					break;
				}

				case Callback.ACE_CALLBACK_TYPE_ARCHIVEDFILE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackArchivedFileStruc ArchivedFile  = (sACECallbackArchivedFileStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackArchivedFileStruc));
					Result = HandleErrorArchivedFile(ArchivedFile); 					
					break;
				}

				case Callback.ACE_CALLBACK_TYPE_REALFILE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackRealFileStruc RealFile  = (sACECallbackRealFileStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackRealFileStruc));
					Result = HandleErrorRealFile(RealFile);					
					break;
				}

				case Callback.ACE_CALLBACK_TYPE_SPACE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackSpaceStruc Space = (sACECallbackSpaceStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackSpaceStruc));
					Result = HandleErrorSpace(ref Space); 					
					Marshal.StructureToPtr(Space, Error, false);	// write back structure to native memory
					break;
				}

				case Callback.ACE_CALLBACK_TYPE_SFXFILE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackSFXFileStruc SFXFile = (sACECallbackSFXFileStruc)Marshal.PtrToStructure(Error, typeof(sACECallbackSFXFileStruc));
					Result = HandleErrorSFXFile(SFXFile);					
					break;
				}

				default:
				{
					Result = Callback.ACE_CALLBACK_RETURN_CANCEL;					
					break;
				}
			}

			return Result;
		}

		
		#endregion
		
		#region RequestProc
		
		public static int HandleRequestGlobal(sACECallbackGlobalStruc Request)
		{			
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData = (sACEGlobalDataStruc)Marshal.PtrToStructure(Request.GlobalData, typeof(sACEGlobalDataStruc));

			switch (Request.Code)
			{
				default:
				{	arc.DispError(Defines.ErrorMessage("UNDEFERROR"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_CANCEL;	}
			}			
		}


		public static int HandleRequestArchive(sACECallbackArchiveStruc Request)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(Request.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(Request.ArchiveData, typeof(sACEArchiveDataStruc));

			switch (Request.Code)
			{
					/* .. add more codes to handle here ..*/

				case Callback.ACE_CALLBACK_REQUEST_CHANGEVOLUME:
				{	arc.DispError(Defines.ErrorMessage("VOLUMECHANGE"), ArchiveData.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_OK;	}
//				case Callback.ACE_CALLBACK_REQUEST_MARKASSOLID:
//				case Callback.ACE_CALLBACK_REQUEST_ARCHIVEEXISTS:
				default:
				{	arc.DispError(Defines.ErrorMessage("UNKREQ"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_CANCEL;	}
			}			
		}


		public static int HandleRequestArchivedFile(sACECallbackArchivedFileStruc ArchivedFile)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(ArchivedFile.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(ArchivedFile.ArchiveData, typeof(sACEArchiveDataStruc));
			sACEFileDataStruc FileData		 = (sACEFileDataStruc)Marshal.PtrToStructure(ArchivedFile.FileData, typeof(sACEFileDataStruc));

			switch (ArchivedFile.Code)
			{
					/* .. add more codes to handle here ..*/

				case Callback.ACE_CALLBACK_REQUEST_OVERWRITE:
				{	if (extractOptions.allowOverwrite) return Callback.ACE_CALLBACK_RETURN_OK;
						
					OverwriteEventArgs e = new OverwriteEventArgs(arc, FileData.SourceFileName);
					if (arc.OnOverwrite != null)
						arc.OnOverwrite(arc, ref e);
					if (e.Overwrite)
						return Callback.ACE_CALLBACK_RETURN_OK;
					else
						return Callback.ACE_CALLBACK_RETURN_CANCEL;					
				}

				case Callback.ACE_CALLBACK_REQUEST_PASSWORD:
				{	
					if (GlobalData.DecryptPassword == extractPassword)
					{
						PasswordEventArgs e = new PasswordEventArgs(arc, FileData.SourceFileName);
						if (arc.OnPassword == null)
							return Callback.ACE_CALLBACK_RETURN_CANCEL;
							
						arc.OnPassword(arc, ref e);
						GlobalData.DecryptPassword = e.Password;
					}
					else
					{
						GlobalData.DecryptPassword = extractPassword;
					}
					
					Marshal.StructureToPtr(GlobalData, ArchivedFile.GlobalData, true);
					if (GlobalData.DecryptPassword != "")
						return Callback.ACE_CALLBACK_RETURN_OK;		
					else return Callback.ACE_CALLBACK_RETURN_CANCEL;		
				}

//				case Callback.ACE_CALLBACK_REQUEST_DELARCHIVEDSYSFILE:
//				case Callback.ACE_CALLBACK_REQUEST_ADDBROKENFILE:

				default:
				{	arc.DispError(Defines.ErrorMessage("UNKREQ"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_CANCEL;	}
			}
		}


		public static int HandleRequestRealFile(sACECallbackRealFileStruc RealFile)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACEGlobalDataStruc GlobalData   = (sACEGlobalDataStruc)Marshal.PtrToStructure(RealFile.GlobalData, typeof(sACEGlobalDataStruc));
			sACEArchiveDataStruc ArchiveData = (sACEArchiveDataStruc)Marshal.PtrToStructure(RealFile.ArchiveData, typeof(sACEArchiveDataStruc));

			switch (RealFile.Code)
			{
				case Callback.ACE_CALLBACK_REQUEST_MOVEDELREALSYSFILE:
				{	return Callback.ACE_CALLBACK_RETURN_OK;	}
				default:
				{	arc.DispError(Defines.ErrorMessage("UNKREQ"), arc.ArchiveName);
					return Callback.ACE_CALLBACK_RETURN_CANCEL;	}
			}		
		}


		public static int RequestProc(IntPtr Request)
		{
			// make data from native memory accessible by marshalling to managed structures
			sACECallbackGlobalStruc Global				= (sACECallbackGlobalStruc)Marshal.PtrToStructure(Request, typeof(sACECallbackGlobalStruc));

			switch (Global.StructureType)
			{
				case Callback.ACE_CALLBACK_TYPE_GLOBAL:
				{
					return HandleRequestGlobal(Global);
				}

				case Callback.ACE_CALLBACK_TYPE_ARCHIVE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackArchiveStruc Archive = (sACECallbackArchiveStruc)Marshal.PtrToStructure(Request, typeof(sACECallbackArchiveStruc));
					return HandleRequestArchive(Archive);
				}

				case Callback.ACE_CALLBACK_TYPE_ARCHIVEDFILE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackArchivedFileStruc ArchivedFile = (sACECallbackArchivedFileStruc)Marshal.PtrToStructure(Request, typeof(sACECallbackArchivedFileStruc));
					return HandleRequestArchivedFile(ArchivedFile);
				}

				case Callback.ACE_CALLBACK_TYPE_REALFILE:
				{
					// make data from native memory accessible by marshalling to managed structures
					sACECallbackRealFileStruc RealFile = (sACECallbackRealFileStruc)Marshal.PtrToStructure(Request, typeof(sACECallbackRealFileStruc));
					return HandleRequestRealFile(RealFile);
				}

				default:
				{
					return Callback.ACE_CALLBACK_RETURN_CANCEL;
				}
			}
		}
		#endregion
		
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Leung Yat Chun
Founder
Hong Kong Hong Kong
Long we have all hope and faith we see The Lord Your God.
--
DirectoryInfoEx - [1.0.27]
WPF FileExplorer3 - [3.0.19]
WPF HtmlTextBlock - [Codeplex]
WPF ListView MultiSelect - [0.4]
WPF UIEventHub MultiSelect/DragDrop w Touch support - [3.0]
WPF BreadcrumbFolderTextBox - [2.5]
WPF BreadcrumbTree and Breadcrumb
WPF Aero Titlebar - [0.2]

Comments and Discussions

Permalink
Advertise
Privacy
Cookies
Terms of Use
Layout: fixed | fluid

Posted 14 Jun 2007

Article Copyright 2007 by Leung Yat Chun
Everything else Copyright © CodeProject, 1999-2024

Web01 2.8:2024-04-02:1