Sujet Précédent Sujet Suivant

UNRAR.DLL sous Borland C++ Builder

bdkiller Messages postés 55 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 7 décembre 2004 - 8 oct. 2003 à 10:53
bdkiller Messages postés 55 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 7 décembre 2004 - 9 oct. 2003 à 10:56
Bonjour tout le monde!

S'il vous plaît, dites moi comment s'en servir de UNRAR.DLL sous Borland C++ Builder.

J'ai trouvé UNRAR.DLL avec ces codes sources ici:
http://www.rarlab.com/rar_add.htm

L'exemple pour C est une console 32-bit. Mais vu que je suis newbie, je ne comprends pas trop et donc j'ai du mal a me servir du code source.

Est-ce qu'il y aurait une gentille âme pour me faire un petit src en utilisant les fichiers qui sont sur le site cité plus haut? :blush)
du genre (par la logique):

Si Archive "blabla.rar" existe
extraire dans Edit1(GetText);

Je vous remercie énormement à l'avance.

1 réponse

Réponse 1 / 1
bdkiller Messages postés 55 Date d'inscription mercredi 23 avril 2003 Statut Membre Dernière intervention 7 décembre 2004
9 oct. 2003 à 10:56
Rebonjour tlm. C'est bon j'ai trouvé ce qu'il me fallait :) carrement un composant et une source :) c'est la source qu'il me fallait :big) , ben pour ceux qui veulent la voir, la voilà: 

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "UnRar.h"
#include "urar.h"

#ifdef UNRAR_smartinit
#pragma package(smart_init)
#endif

UNRAR_dcr // use resource ivory.dcr

int ProcessChangeVol(char* ArcName, int Name);

AnsiString TUnRar::ChangeDiskTitle = String("Insert new disk");
Forms::TModalResult TUnRar::ChangeDiskModalResult = mrNone;

//---------------------------------------------------------------------------
static inline TUnRar* ValidCtrCheck()
{
   return new TUnRar(NULL);
}
//---------------------------------------------------------------------------
String __fastcall EUnRarError::GetErrString(TResult res)
{
   if(res == resNoMemory) return "Not enough memory";
   else if(res == resBadData) return "Bad data";
   else if(res == resBadArchive) return "Bad archive";
   else if(res == resOpenError) return "Open error";
   else if(res == resEndOfFile) return "End of file";
   else if(res == resCloseError) return "Close error";
   else if(res == resCreateError) return "Create error";
   else if(res == resReadError) return "Read error";
   else if(res == resWriteError) return "Write error";
   else if(res == resUnknownFormat) return "Unknown file format";
   else if(res == resDllError) return "Couldn't open UNRAR.DLL";
   else return "Unknown error";
}
//---------------------------------------------------------------------------
__fastcall TUnRar::TUnRar(Classes::TComponent* AOwner)
 : TComponent(AOwner),
   fEof(true), fResult(resNone), fArchiveCommentState(csNone),
   fArchiveName(""), fArchiveComment(""), fHandle(NULL), fDestPath(""), fPassword(""),
   fFileName(""), fExtract(false), fComment(""), fCommentState(csNone), fDictionarySize(0),
   fActive(false), hDll(NULL), fExceptionOnError(true)
{
}
//---------------------------------------------------------------------------
__fastcall TUnRar::~TUnRar()
{
   if(fIsOpen) Close();
   if(hDll != NULL) FreeLibrary(hDll);
}
//---------------------------------------------------------------------------
bool __fastcall TUnRar::Open()//AnsiString filename, bool extract)
{
   if(fActive)
   {
      fResult = resOpenError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   hDll = LoadLibrary("UNRAR");
   if(hDll == NULL)
   {
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   PROCUnRarOpen _RAROpenArchive = (PROCUnRarOpen)GetProcAddress(hDll, "RAROpenArchive");
   if(_RAROpenArchive == NULL)
   {
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   PROCUnRarSetPassword _RARSetPassword = (PROCUnRarSetPassword)GetProcAddress(hDll, "RARSetPassword");
   if(_RARSetPassword == NULL)
   {
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   PROCUnRarSetChangeVolProc _RARSetChangeVolProc = (PROCUnRarSetChangeVolProc)GetProcAddress(hDll, "RARSetChangeVolProc");
   if(_RARSetChangeVolProc == NULL)
   {
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   RAROpenArchiveData _OpenData;
   char* _comment = new char[65536];

//   fArchiveName = filename;
   _OpenData.ArcName = fArchiveName.c_str();
   _OpenData.OpenMode = fExtract ? RAR_OM_EXTRACT : RAR_OM_LIST;
   _OpenData.CmtBuf = _comment;
   _OpenData.CmtBufSize = 65536;
   fResult = resOpenError;
   fHandle = _RAROpenArchive(&_OpenData);
   fArchiveComment = _comment;
   delete _comment;
   switch(_OpenData.OpenResult)
   {
      case 0: fResult = resOk; break;
      case ERAR_NO_MEMORY: fResult = resNoMemory; break;
      case ERAR_BAD_DATA:  fResult = resBadData; break;
      case ERAR_BAD_ARCHIVE: fResult = resBadArchive; break;
      case ERAR_EOPEN: fResult = resOpenError; break;
   }
   switch(_OpenData.CmtState)
   {
      case 0: fArchiveCommentState = csNone; break;
      case 1: fArchiveCommentState = csOk; break;
      case ERAR_NO_MEMORY: fArchiveCommentState = csNoMemory; break;
      case ERAR_BAD_DATA: fArchiveCommentState = csBadData; break;
      case ERAR_UNKNOWN_FORMAT: fArchiveCommentState = csUnknownFormat; break;
   }
   if(fHandle!=NULL)
   {
      fEof = false;
      fActive = true;
      if(fPassword!="") _RARSetPassword(fHandle, fPassword.c_str());
      _RARSetChangeVolProc(fHandle, ProcessChangeVol);
      return ReadHeader();
   }
   else
   {
      fEof = true;
      fActive = false;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }
}
//---------------------------------------------------------------------------
bool __fastcall TUnRar::Close()
{
   if(!fActive)
   {
      fResult = resCloseError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   fActive = false;
   fEof = true;

   PROCUnRarClose _RARCloseArchive = (PROCUnRarClose)GetProcAddress(hDll, "RARCloseArchive");
   if(_RARCloseArchive == NULL)
   {
      FreeLibrary(hDll); hDll = NULL;
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   if(_RARCloseArchive(fHandle)==0)
   {
      FreeLibrary(hDll); hDll = NULL;
      fResult = resOk;
      return true;
   }
   else
   {
      FreeLibrary(hDll); hDll = NULL;
      fResult = resCloseError;
      if(fExceptionOnError) throw EUnRarError(fResult);
   }

   return false;
}
//---------------------------------------------------------------------------
bool __fastcall TUnRar::ReadHeader()
{
   if(!fActive)
   {
      fResult = resOpenError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }
/*   if(fEof)
   {
      fResult = resEndOfFile;
//    throw EUnRarError(fResult);
      return false;
   }*/

   PROCUnRarHeader _RARReadHeader = (PROCUnRarHeader)GetProcAddress(hDll, "RARReadHeader");
   if(_RARReadHeader == NULL)
   {
      FreeLibrary(hDll); hDll = NULL;
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   RARHeaderData _HeaderData;
   char* _comment = new char[65536];
   int retval;

   _HeaderData.CmtBuf = _comment;
   _HeaderData.CmtBufSize = 65536;
   retval = _RARReadHeader(fHandle, &_HeaderData);

   if(retval==0)
   {
      fResult = resOk;
      fArchiveName = _HeaderData.ArcName;
      fFileName = _HeaderData.FileName;
      fFlags.Clear();      unsigned f _HeaderData.Flags, ds f & 0xE0;
      if(f & 0x01) fFlags = fFlags << ffPrevVolume;
      if(f & 0x02) fFlags = fFlags << ffNextVolume;
      if(f & 0x04) fFlags = fFlags << ffPassword;
      if(f & 0x08) fFlags = fFlags << ffComment;
      if(f & 0x10) fFlags = fFlags << ffSolid;
      if(ds==0xE0) { fFlags = fFlags << ffDirectory; fDictionarySize = 0; }
      else if(ds==0) fDictionarySize = 64;
      else if(ds==0x20) fDictionarySize = 128;
      else if(ds==0x40) fDictionarySize = 256;
      else if(ds==0x60) fDictionarySize = 512;
      else if(ds==0x80) fDictionarySize = 1024;
      else fDictionarySize = 0;
      fPackedSize = _HeaderData.PackSize;
      fUnpackedSize = _HeaderData.UnpSize;
      switch(_HeaderData.HostOS)
      {
         case 0: fHostOS = hosMsDos; break;
         case 1: fHostOS = hosOS2; break;
         case 2: fHostOS = hosWin32; break;
         case 3: fHostOS = hosUnix; break;
      }
      fCRC = _HeaderData.FileCRC;
      fFileTime = _HeaderData.FileTime;
      fRarVersion = _HeaderData.UnpVer;
      fMethod = _HeaderData.Method;
      fAttr = _HeaderData.FileAttr;
      switch(_HeaderData.CmtState)
      {
         case 0: fCommentState = csNone; break;
         case 1: fCommentState = csOk; break;
         case ERAR_NO_MEMORY: fCommentState = csNoMemory; break;
         case ERAR_BAD_DATA: fCommentState = csBadData; break;
         case ERAR_UNKNOWN_FORMAT: fCommentState = csUnknownFormat; break;
      }
      fComment = _comment;
      delete _comment;
      return true;
   }
   else if(retval==ERAR_END_ARCHIVE)
   {
      delete _comment;
      fResult = resEndOfFile;
      fEof = true;
   }
   else
   {
      delete _comment;
      fResult = resBadData;
      throw EUnRarError(fResult);
   }
   return false;
}
//---------------------------------------------------------------------------
bool __fastcall TUnRar::Process(TRarOperation op, AnsiString DestName)
{
   if(!fActive)
   {
      fResult = resOpenError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }
   if(fEof)
   {
      fResult = resEndOfFile;
      return false;
   }

   PROCUnRarProcess _RARProcessFile = (PROCUnRarProcess)GetProcAddress(hDll, "RARProcessFile");
   if(_RARProcessFile == NULL)
   {
      FreeLibrary(hDll); hDll = NULL;
      fResult = resDllError;
      if(fExceptionOnError) throw EUnRarError(fResult);
      return false;
   }

   int operation;
   switch(op)
   {
      case opSkip: operation = RAR_SKIP; break;
      case opTest: operation = RAR_TEST; break;
      case opExtract: operation = RAR_EXTRACT; break;
   }
   char* destpath = (fDestPath=="") ? NULL : fDestPath.c_str();
   char* destname = (DestName=="") ? NULL : DestName.c_str();
   int retval = _RARProcessFile(fHandle, operation, destpath, destname);

   switch(retval)
   {
      case 0: return ReadHeader();
      case ERAR_BAD_DATA: fResult = resBadData; break;
      case ERAR_BAD_ARCHIVE: fResult = resBadArchive; break;
      case ERAR_UNKNOWN_FORMAT: fResult = resUnknownFormat; break;
      case ERAR_EOPEN: fResult = resOpenError; break; // volume open error
      case ERAR_ECREATE: fResult = resCreateError; break;
      case ERAR_ECLOSE: fResult = resCloseError; break;
      case ERAR_EREAD: fResult = resReadError; break;
      case ERAR_EWRITE: fResult = resWriteError; break;
   }
   if(fExceptionOnError) throw EUnRarError(fResult);
   return false;
}
//---------------------------------------------------------------------------
void __fastcall TUnRar::SetPassword(AnsiString s)
{
   fPassword=s;
   if(fActive)
   {
      PROCUnRarSetPassword _RARSetPassword = (PROCUnRarSetPassword)GetProcAddress(hDll, "RARSetPassword");
      if(_RARSetPassword != NULL)
         _RARSetPassword(fHandle, s.c_str());
   }
}
//---------------------------------------------------------------------------
void __fastcall TUnRar::SetActive(bool active)
{
   if(active) Open(); else Close();
}
//---------------------------------------------------------------------------
int ProcessChangeVol(char* ArcName, int Mode)
{
   int retval = true;
   if(Mode==RAR_VOL_ASK)
   {
      TOpenDialog* OpenDialog = new TOpenDialog(NULL);
      OpenDialog->Title = TUnRar::ChangeDiskTitle;
      OpenDialog->FileName = ArcName;
      if(OpenDialog->Execute())
      {
         delete [] ArcName;
         ArcName = new char[OpenDialog->FileName.Length()+1];
         strcpy(ArcName, OpenDialog->FileName.c_str());
         retval = true;
         TUnRar::ChangeDiskModalResult = mrOk;
      }
      else
      {
         retval = false;
         TUnRar::ChangeDiskModalResult = mrCancel;
      }
      delete OpenDialog;
   }
   return retval;
}
//---------------------------------------------------------------------------
namespace Unrar
{
   void __fastcall UNRAR_package Register()
   {
      TComponentClass classes[1] = { __classid(TUnRar) };
      RegisterComponents("Samples", classes, 0);
   }
}
//---------------------------------------------------------------------------
0

Discussions similaires

Problème avec builder et un Radio Groupe
DarkTiteuf -
DarkTiteuf -

3 réponses
borland c/c++ compiler
Saros -
Saros -

6 réponses
Executer un programme sous c++ builder
xtrememan -
xtrememan -

9 réponses
texte dans c++ builder
cs_cbil -
fredcl -

6 réponses
Changer la couleur de la font d'un radiobutton ou d'un radiogroup
charleslaplante -
yanb -

1 réponse
Rejoignez-nous