C++ C++ C# C# ASP.NET Security ASP.NET Security ASM ASM Скачать Скачать Поиск Поиск Хостинг Хостинг  
  Программа для работы с LPT портом...
Язык: .NET — ©Alexey...
  "ASP.NET Atlas" – AJAX в исполнении Micro...
Язык: .NET — ©legigor@mail.ru...
  "Невытесняющая" Многопоточность...
Язык: C/C++ — ©...
  01.05.2010 — Update World C++: Сборник GPL QT исходников
  15.12.2007 — Весь сайт целиком можно загрузить по ссылкам из раздела Скачать
Хостинг:
Windows 2003, ASP.NET 2.0
бесплатный и от 80 руб./мес


   Отправить письмо
Кулабухов Артем, Беларусь




 Помещаем файл в "Корзину" (Recycle Bin) / Файлы, папки, диски / Файловая система

Помещаем файл в "Корзину" (Recycle Bin)

Этим занимается API функция оболочки под названием SHFileOperation, объявленная в shellapi.h. Для того, чтобы воспользоваться этой функцией, необходимо заполнить специальную структуру SHFILEOPSTRUCT, которая указывает, какую операцию необходимо проделать, какой файл необходимо удалить, а так же другую важную информацию:

int SHFileOperation(LPSHFILEOPSTRUCT lpFileOp);

struct SHFILEOPSTRUCT{ 
    HWND hwnd;                          // NULL (диалога прогреса, не
                                        // используем)
    UINT wFunc;                         // FO_DELETE (операция удаления)
    LPCTSTR pFrom;                      // имя файла(ов) для удаления
    LPCTSTR pTo;                        // NULL (для удаления не используется)
    FILEOP_FLAGS fFlags;                // см. ниже
    BOOL fAnyOperationsAborted;         // (возвращает TRUE если пользователь
                                        // прервал) не используем
    LPVOID hNameMappings;               // для удаления не используется
    LPCSTR lpszProgressTitle;           // для удаления не используется
};

// Используемые флаги
#define FOF_SILENT      0x0004          // не показывать процесс удаления
#define FOF_NOERRORUI   0x0400          // не выводить ошибки
#define FOF_ALLOWUNDO   0x0040          // ОБЯЗАТЕЛЬНО для корзины!!!
#define FOF_NOCONFIRMATION 0x0010       // Не спрашивать пользователя OK
                                        // для подтверждения удаления

SHFileOperation позволяет копировать, удалять, перемещать или переименовывать один или несколько файлов.

   Итак, теперь о главном. Для того, чтобы удалить файл с помещением его в корзину, необходимо использовать флаг FOF_ALLOWUNDO, присвоив значение pFrom равное FO_DELETE. Если же задать только имя файла без пути, то файл будет удалён без помещения в корзину.

   Прилагаемый пример содержит небольшой класс CRecycleFile, который призван упростить данную процедуру. Пример представляет из себя консольное приложение:


RECYCLE в действии

   Вот элементарный приём использования данного класса:

LPCTSTR pszPathName = GetFileNameSomehow(); // полный путь с именем!
CRecycleFile rf;
rf.Recycle(pszPathName);

Что может быть проще этого? Исходный код

 

RecycFile.h

////////////////////////////////////////////////////////////////
// MSDN — April 2001
// If this code works, it was written by Paul DiLascia.
// If not, I don't know who wrote it.
// Compiles with Visual C++ 6.0. Runs on Windows 98 and probably Windows 
// 2000 too.
//
#include <shellapi.h>

//////////////////
// CRecycleFile — sends a file to the Recycle Bin.
// Note derived from SHFILEOPSTRUCT.
//
class CRecycleFile : public SHFILEOPSTRUCT {
protected:
public:
   CRecycleFile();
   ~CRecycleFile() { }
   int Recycle(LPCTSTR pszPath, BOOL bDelete=FALSE);
};

 

RecycFile.cpp

////////////////////////////////////////////////////////////////
// MSDN — April 2001
// If this code works, it was written by Paul DiLascia.
// If not, I don't know who wrote it.
// Compiles with Visual C++ 6.0. Runs on Windows 98 and probably Windows 
// 2000 too.
//
#include <windows.h>
#include <tchar.h>
#include "RecycFile.h"

//////////////////
// Constructor initializes SHFILEOPSTRUCT with reasonable
// defaults. You can override if you like. Go ahead, make my day.
//
CRecycleFile::CRecycleFile()
{
   memset((SHFILEOPSTRUCT*)this,0,sizeof(SHFILEOPSTRUCT));
   fFlags |= FOF_SILENT;                // don't report progress
   fFlags |= FOF_NOERRORUI;             // don't report errors
   fFlags |= FOF_NOCONFIRMATION;        // don't confirm delete
}

//////////////////
// Send a file to the recycle bin. Args:
//  - full pathname of file.
//  - bDelete: if TRUE, really delete file (no recycle bin)
//
int CRecycleFile::Recycle(LPCTSTR pszPath, BOOL bDelete)
{
   // Copy pathname to double-NULL-terminated string.
   //
   TCHAR buf[_MAX_PATH + 1]; // allow one more character
   _tcscpy(buf, pszPath);    // copy caller's path name
   buf[_tcslen(buf)+1]=0;    // need two NULLs at end

   // Set SHFILEOPSTRUCT params for delete operation
   //
   wFunc = FO_DELETE;                   // REQUIRED: delete operation
   pFrom = buf;                         // REQUIRED: which file(s)
   pTo = NULL;                          // MUST be NULL
   if (bDelete) {                       // if delete requested..
      fFlags &= ~FOF_ALLOWUNDO;         // ..don't use Recycle Bin
   } else {                             // otherwise..
      fFlags |= FOF_ALLOWUNDO;          // ..send to Recycle Bin
   }
   return SHFileOperation(this);        // do it!
}

recycle.cpp

////////////////////////////////////////////////////////////////
// MSDN — April 2001
// If this code works, it was written by Paul DiLascia.
// If not, I don't know who wrote it.
// Compiles with Visual C++ 6.0. Runs on Windows 98 and probably Windows 
// 2000 too.
//
#pragma once
#pragma warning(disable:4786)           // disable annoying C4786
#define VC_EXTRALEAN                    // Exclude rarely used stuff from
                                        // headers
#include <windows.h>
#include <stdio.h>
#include <direct.h>                     // getcwd
#include <conio.h>                      // getche
#include <tchar.h>
#include <assert.h>
#include <string>                       // STL string class
#include <list>                         // STL list class
#include <sys/stat.h>                   // stat function
#include "RecycFile.h"

using namespace std;                    // use STL
typedef list<string> CStringList;       // like MFC

// I'm really roughing it here—need my own TRACE and ASSERT!
#define ASSERT assert
#ifdef _DEBUG
#define TRACE _tprintf
#else
#define TRACE 1 ? (void)0 : ::_tprintf
#endif

// pre-declare functions
void    usage();
void    help();
string  GetCurrentDir();
string  MakeAbsolute(const string& relname);
BOOL    confirm(LPCTSTR pFileName);
LPCTSTR GetErrorMsg(int err);

// global command-line switches
BOOL bPrompt=FALSE;        // prompt each file
BOOL bQuiet=FALSE;         // don't display messages
BOOL bDisplayOnly=FALSE;   // display results only; don't actually recycle
BOOL bZap=FALSE;           // really delete (don't recycle)

// test if file exists
inline fileexists(LPCTSTR pFilename)
{
   struct stat st;
   return stat(pFilename, &st)==0;
}

// check for switch: / or -
inline BOOL isswitch(TCHAR c)
{
   return c==L'/' || c==L'-';
}

//////////////////
// Main function expects argv already expanded for wildcards. You must 
// link with setargv.obj!!
//
int main(int argc, TCHAR* argv[], TCHAR* envp[])
{
   // Parse command line, building list of file names.
   // Switches can come in any order.
   //
   CStringList files;
   for (int i=1; i<argc; i++) {
      if (isswitch(argv[i][0])) {
         switch(tolower(argv[i][1])) {
         case 'q':
            bQuiet=TRUE;
            break;
         case 'n':
            bDisplayOnly=TRUE;
            break;
         case 'p':
            bPrompt=TRUE;
            break;
         case 'z':
            bZap=TRUE;
            break;
         case '?':
            help();
            return 0;
         default:
            usage();
            return 0;
         }
      } else {
         // Got a file name. Make it absolute and add to list.
         files.push_back(MakeAbsolute(argv[i]));
      }
   }

   if (files.empty()) {
      // No files specified: tell bozo user how to use this command.
      usage();
      return 0;
   }

   // Delete (recycle) all the files in the list
   int nDel=0;
   CStringList::iterator it;

   // loop over list of files and recycle each one 
   for (it=files.begin(); it!=files.end(); it++) {
      const string& filename = *it;
      LPCTSTR pFileName = filename.c_str();

      // Only recycle if file exists. If the user types a wildcard—eg:
      // recycle foo.* and there are no files that match "foo.*", then 
      // setargv passes the wildcard expression unexpanded—but obviously 
      // there is no such file.
      //
      if (fileexists(pFileName)) {

         if (!bQuiet && !bPrompt) {
            // tell user I'm recycling this file
            _ftprintf(stderr,_T("%s %s\n"),
               bZap ? _T("Deleting") : _T("Recycling"), pFileName);
         }

         if (!bDisplayOnly) {
            if (!bPrompt || confirm(pFileName)) {
               // Finally! Recycle the file. Use CRecycleFile.
               CRecycleFile rf;
               int err = rf.Recycle(pFileName,bZap);
               if (err==0) {
                  nDel++;
               } else {
                  // Can't recycle: display error message
                  _ftprintf(stderr,_T("Error %d: %s"), err, 
	                            GetErrorMsg(err));
               }
            }
         }
      } else {
         _ftprintf(stderr,_T("File not found \"%s\"\n"), pFileName);
      }
   }
   if (!bQuiet) {
      _ftprintf(stderr,_T("%d files recycled\n"),nDel);
   }
   return 0;
}

////////////////
// Duh.
//
void usage()
{
   _tprintf(_T("Usage: RECYCLE [/QNPZ?] file...\n"));
}

////////////////
// Ditto duh.
//
void help()
{
   _tprintf(_T("Purpose:  Send one or more files to the recycle bin.\n"));
   _tprintf(_T("Format:   RECYCLE [/Q /N /P /Z] file....\n"));
   _tprintf(_T("          /Q(uiet)     no messages\n"));
   _tprintf(_T("          /N(othing)   don't delete, just show files\n"));
   _tprintf(_T("          /P(rompt)    confirm each file\n"));
   _tprintf(_T("          /Z(ap)       really delete—same as del\n"));
}

//////////////////
// Make a file name absolute with respect to current directory.
//
string MakeAbsolute(const string& relname)
{
   // Get current directory. Since cwd is static this happens only once.
   static const string cwd = GetCurrentDir();

   string absname;
   if (relname[0] && relname[1] && relname[1]==':') {
      // relname is already absolute
      absname = relname;

   } else if (relname[0]=='\\') {
      // relname begins with \ — add drive letter and colon
      absname = string(cwd,0,2);
      absname += relname;

   } else {                             // file name begins with letter:
      // relname begins with a letter — prepend cwd
      absname = cwd;
      absname += relname;
   }
   return absname;
}

//////////////////
// Get current directory. For some reason unknown to mankind, getcwd 
// returns "C:\FOO" (no \ at end) if dir is NOT root; yet it returns "C:\" 
// (with \) if cwd is root. Go figure. To make the result consistent for 
// appending a file name, GetCurrentDir adds the missing \ if needed. 
// Result always has final \.
//
string GetCurrentDir()
{
   TCHAR dir[MAX_PATH];
   _tgetcwd(dir, sizeof(dir)/sizeof(TCHAR));

   // Append '\' if needed
   int lastchar = _tcslen(dir)-1;
   if (lastchar>0 && dir[lastchar] != '\\') // if last char isn't \ ..
      _tcscat(dir,_T("\\"));                // ..add one

   return dir;                         // compiler will convert to string!
}

//////////////////
// Get user confirmation to recycle/delete a file
//
BOOL confirm(LPCTSTR pFileName)
{
   while (TRUE) {
      _tprintf(_T("Recycle %s (Y/N/All)? "), pFileName);
      char c = _getche();
      if (c=='') {
         _tprintf(_T("^C\n"));
         exit(0);
      }
      _tprintf(_T("\n"));
      switch (tolower(c)) {
      case 'a':
         bPrompt=FALSE;
         // fall through
      case 'y':
         return TRUE;
      case 'n':
         return FALSE;
      }
   }
}

//////////////////
// Get Windows system error message
//
LPCTSTR GetErrorMsg(int err)
{
   const BUFSIZE = 512;
   static TCHAR buf[BUFSIZE];
   buf[0]=0;

   // Only Windows could have a function this confusing to get a simple 
   // error message.
   FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
      NULL,    // source
      err,     // error code
      0,       // language ID
      buf,     // buffer to receive message
      BUFSIZE, // size of buf
      NULL);   // arguments
   return buf;
}