//-------------------------------------------------------------------------------------//
//+++++++++++++++++[ Drives_Class_Header ]+++++++++++++++++++++++++++++++++++++++++++++//
//-------------------------------------------------------------------------------------//
//
//
// Last modi: 22.03.07 L.ey (µ~)
//
//
#ifndef _C_DRIVES_H_
 #define _C_DRIVES_H_

 #include <windows.h>
 #include <stdio.h>

 #include "C_Array.hpp"

 struct C_S_Drive
 {
   char   _sName[50];
   char   _sPath[6];
   UINT   _Type;
   DWORD  _SizeMb;
   DWORD  _FreeMb;
   DWORD  _cMbRecycle;
   DWORD  _nItemRecycle;
 };

 const int DRIVES_EMPTY_HIDE    = SHERB_NOSOUND|SHERB_NOCONFIRMATION|
                                  SHERB_NOPROGRESSUI;

 const int DRIVES_EMPTY_NOSOUND = SHERB_NOSOUND;
  
 const int DRIVES_EMPTY_ALL     = 0x0100;

 const int DRIVES_DOSDEV_ALL    = DDD_RAW_TARGET_PATH|DDD_REMOVE_DEFINITION|
                                  DDD_EXACT_MATCH_ON_REMOVE;

 //+++++++++++++++++[ class C_Drives ]+++++++++++++++++++++++++++++++++++++++++++++//
 class C_Drives
 {
  public://+++++++öffentlicher Zugriff+++++++//

    C_Drives();
   ~C_Drives();  

   DWORD    _Refresh();

   C_Array* _Get_aDrives();

   DWORD    _Create_DosDevice(char* psName, char* psPath);
   DWORD    _Delete_DosDevice(char* psName);

   DWORD    _EmptyRecycleBin(int Index, int modus);

  private://++++++privater Zugriff+++++++++++//
  
  protected://++++geschützter Zugriff++++++++//

   C_Array  _aDrives;                        // Array von C_S_Drive
   DWORD    _cDrives;                        // Anzahl Drives
  
   DWORD    _bReady;
 };

#endif // _C_DRIVES_H_

//-------------------------------------------------------------------------------------//
//+++++++++++++++++[ Drives_Class_Source ]+++++++++++++++++++++++++++++++++++++++++++++//
//-------------------------------------------------------------------------------------//
   
#include "C_Drives.hpp"

/////////////////////////////////////////////////////////////////////////////////////////
////////  [Konstructor]  ////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
C_Drives::C_Drives()
{
   _bReady  = 0;
   _cDrives = 0;

   _Refresh();
}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [Destructor]  /////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
C_Drives::~C_Drives()
{

}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [_Refresh]  ///////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
DWORD C_Drives::_Refresh()
{
   char sData[250];

   DWORD Drives       = 0;
   DWORD DriveCounter = 0;
   DWORD mask         = 1;
 
   ULONGLONG ulLong = 0;

   ULARGE_INTEGER  FreeBytes;
   ULARGE_INTEGER  TotalNumberOfBytes;
   ULARGE_INTEGER  TotalNumberOfFreeBytes;

   C_S_Drive* tC_S_Drive = 0;

   // Get BitMask
   //
   Drives = GetLogicalDrives();

   if(!Drives) return(0);

   for(UINT bit = 0; bit < 32; bit++)
   {
      if(Drives & mask) DriveCounter++;

      mask = (mask << 1);
   }

   _cDrives = DriveCounter;

   if(_bReady == 1)
   {
      _aDrives._Destroy();

      _bReady = 0;
   }
  
   _aDrives._Create(DriveCounter, sizeof(C_S_Drive));

   if(!GetLogicalDriveStrings(sizeof(sData), sData)) return(2);

   UINT nOffset = 0;
   UINT nDrive  = 0;

   for(UINT nData = 0; nData < sizeof(sData); nData++)
   {
      if(sData[nData] == 0)
      {
         tC_S_Drive = (C_S_Drive*)_aDrives._Get_pItem(nDrive);

         tC_S_Drive->_Type = GetDriveType(&sData[nOffset]);

         strcpy(tC_S_Drive->_sPath, &sData[nOffset]);

         GetVolumeInformation(&sData[nOffset], tC_S_Drive->_sName, 50, 0, 0, 0, 0, 0);

         if(GetDiskFreeSpaceEx(&sData[nOffset], &FreeBytes, 
                               &TotalNumberOfBytes, &TotalNumberOfFreeBytes) != 0)
         {
            ulLong = (TotalNumberOfFreeBytes.QuadPart) / (1024) / (1024);
            tC_S_Drive->_FreeMb = (DWORD)ulLong;

            ulLong = (TotalNumberOfBytes.QuadPart) / (1024) / (1024);
            tC_S_Drive->_SizeMb = (DWORD)ulLong;
         }
       
         // PapierKorb
         if(tC_S_Drive->_Type == DRIVE_FIXED)
         {
            SHQUERYRBINFO tSHQUERYRBINFO;

            tSHQUERYRBINFO.cbSize = sizeof(SHQUERYRBINFO);

            SHQueryRecycleBin(&sData[nOffset], &tSHQUERYRBINFO);

            char i64Size[sizeof(tSHQUERYRBINFO.i64Size)];
            char i64Items[sizeof(tSHQUERYRBINFO.i64NumItems)];

            DWORD ISize  = 0;
            DWORD ICount = 0;

            // Copy 64Bit Number
            memcpy(i64Size,  &tSHQUERYRBINFO.i64Size,     sizeof(tSHQUERYRBINFO.i64Size));
            memcpy(i64Items, &tSHQUERYRBINFO.i64NumItems, sizeof(tSHQUERYRBINFO.i64NumItems));

            // Copy 32Bit HighWord
            memcpy(&ISize,  &i64Size[0],  4);
            memcpy(&ICount, &i64Items[0], 4);

            tC_S_Drive->_cMbRecycle = ISize / 1024 / 1024;
            tC_S_Drive->_nItemRecycle  = ICount;
         }
         // PapierKorb
         
         nOffset = nData + 1; 

         nDrive++;

         if(nDrive == DriveCounter) break;
      }
   }

   _bReady = 1;

   return(1);
}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [_Get_aDrives]  ///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
C_Array* C_Drives::_Get_aDrives()
{
   if(_bReady != 1) return(0);
   return(&_aDrives);
}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [_EmptyRecycleBin]  ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
DWORD C_Drives::_EmptyRecycleBin(int index, int modus)
{
   if(_bReady != 1) return(0);

   // Empty All Drives
   //
   if((index == DRIVES_EMPTY_ALL) && (modus == DRIVES_EMPTY_HIDE))
   {
      if(SHEmptyRecycleBin(0, 0, DRIVES_EMPTY_HIDE) != S_OK) return(2);
      return(1);
   }
   else
   if((index == DRIVES_EMPTY_ALL) && (modus == DRIVES_EMPTY_NOSOUND))
   {
      if(SHEmptyRecycleBin(0, 0, DRIVES_EMPTY_NOSOUND) != S_OK) return(2);
      return(1);
   }

   // Empty single Drives
   //
   C_S_Drive* pSDrive = (C_S_Drive*)_aDrives._Get_pItem(index);

   if(!pSDrive) return(3);

   if(modus == DRIVES_EMPTY_HIDE)
   {
      if(SHEmptyRecycleBin(0, pSDrive->_sPath, DRIVES_EMPTY_HIDE) != S_OK) return(2);
   }
   else if(modus == DRIVES_EMPTY_NOSOUND)
   {
      if(SHEmptyRecycleBin(0, pSDrive->_sPath, DRIVES_EMPTY_NOSOUND) != S_OK) return(2);
   }

   return(1);
}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [_Create_DosDevice]  //////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
DWORD C_Drives::_Create_DosDevice(char* psName, char* psPath)
{
   if(!DefineDosDevice(0, psName, psPath)) return(0);
   _Refresh();
   return(1);
}
/////////////////////////////////////////////////////////////////////////////////////////
////////  [_Delete_DosDevice]  //////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
DWORD C_Drives::_Delete_DosDevice(char* psName)
{
   char szNtDeviceName[MAX_PATH];

   QueryDosDevice (psName, szNtDeviceName, MAX_PATH);
  
   if(!DefineDosDevice(DRIVES_DOSDEV_ALL, psName, szNtDeviceName)) return(0);
   _Refresh();
   return(1);
}