Changeset 576


Ignore:
Timestamp:
11/15/2008 5:05:52 PM (6 years ago)
Author:
cjax
Message:

Some functions

Location:
branches/erasershellext/cpp
Files:
3 added
6 edited

Legend:

Unmodified
Added
Removed
  • branches/erasershellext/cpp/CtxMenu.cpp

    r441 r576  
    99using namespace Eraser; 
    1010///////////////////////////////////////////////////////////////////////////// 
    11 // COpenWithCtxMenuExt 
    1211 
    1312HRESULT CCtxMenu::Initialize ( 
    14     LPCITEMIDLIST   pidlFolder, 
    15     LPDATAOBJECT    pDataObj, 
    16     HKEY            hProgID ) 
    17 { 
    18  
     13                        LPCITEMIDLIST   pidlFolder, 
     14                        LPDATAOBJECT    pDataObj, 
     15                        HKEY            hProgID ) 
     16{ 
    1917    FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; 
    2018    STGMEDIUM stg = { TYMED_HGLOBAL }; 
    2119    HDROP     hDrop; 
    2220 
    23     // Look for CF_HDROP data in the data object. 
    24     if ( FAILED( pDataObj->GetData ( &fmt, &stg ))) 
    25         // Nope! Return an "invalid argument" error back to Explorer. 
    26         return E_INVALIDARG; 
    27  
    28     // Get a pointer to the actual data. 
    29     hDrop = (HDROP) GlobalLock ( stg.hGlobal ); 
    30  
    31     // Make sure it worked. 
    32     if ( NULL == hDrop ) 
    33         return E_INVALIDARG; 
    34  
    35     // Sanity check - make sure there is at least one filename. 
     21    // Look for CF_HDROP data in the data object. 
     22    if ( FAILED( pDataObj->GetData ( &fmt, &stg ))) 
     23        // Nope! Return an "invalid argument" error back to Explorer. 
     24        return E_INVALIDARG; 
     25 
     26    // Get a pointer to the actual data. 
     27    hDrop = (HDROP) GlobalLock ( stg.hGlobal ); 
     28 
     29    // Make sure it worked. 
     30    if ( NULL == hDrop ) 
     31        return E_INVALIDARG; 
     32 
     33    // Sanity check - make sure there is at least one filename. 
    3634    UINT uNumFiles = DragQueryFile ( hDrop, 0xFFFFFFFF, NULL, 0 ); 
    3735 
    38     if (!uNumFiles) 
     36    if (!uNumFiles) 
    3937    { 
    4038        GlobalUnlock(stg.hGlobal); 
     
    4240        return E_INVALIDARG; 
    4341    } 
    44      
     42 
    4543    HRESULT hr = S_OK; 
    4644 
     
    5553    } 
    5654 
    57     // TODO: load Eraser Icon 
    58     // m_szEraserIcon 
    59  
    60     GlobalUnlock ( stg.hGlobal ); 
    61     ReleaseStgMedium ( &stg ); 
    62  
    63     return hr; 
     55    // TODO: load Eraser Icon and store HBITMAP in m_szEraserIcon 
     56 
     57    GlobalUnlock ( stg.hGlobal ); 
     58    ReleaseStgMedium ( &stg ); 
     59 
     60    return hr; 
    6461} 
    6562/* 
     
    7067|                   | 
    7168+-------------------+    +-------------------+ 
    72 |(ICON) Eraser v6 > |    | Schedule Selected | 
    73 +-------------------+    +-------------------+ 
    74 |                   |    |(*) Select Default | // Eraser.Manager.Wipe Algorithms popup 
    75 |                   |    |(*) Chose algorithm| // set algorithm for this query only 
     69|(ICON) Eraser v6 > |    | Erase selected    | //--> erase the files immediately using defaults 
     70+-------------------+    | Schedule Selected | //--> open the scheduler menu, with files/folders filled in 
     71|                   |    +-------------------+ 
     72|                   |    | Secure move       | //--> secure move the files 
     73|                   |    +-------------------+ // Eraser.Manager Algorithms popup 
     74|                   |    |(*) Customise      | // set algorithm for this query only 
    7675+-------------------+    +-------------------+ 
    7776*/ 
    7877 
     78/* 
     79we have eraser shell scripts (.eshlls) where we use them 
     80to generate shell extention menus dynamically. 
     81the syntax is simple. 
     82This project should be aimed at the 6.1 release. 
     83 
     84BEGIN @MENU : POSITION($INDEX) 
     85    [ICON="PATH"] 
     86    [TEXT="DISPLAY_TEXT"] 
     87 
     88    [FLAGS=MIIM_*]           
     89        //MIIM_BITMAP 
     90        //MIIM_CHECKMARKS 
     91        //MIIM_DATA 
     92        //MIIM_FTYPE 
     93        //MIIM_ID 
     94        //MIIM_STATE 
     95        //MIIM_STRING 
     96        //MIIM_SUBMENU 
     97        //MIIM_TYPE 
     98 
     99    [TYPE=MF_*] 
     100        //MF_APPEND, 
     101        //MF_BITMAP, 
     102        //MF_BYCOMMAND, 
     103        //MF_BYPOSITION 
     104        //MF_CHECKED 
     105        //MF_DEFAULT 
     106        //MF_DELETE 
     107        //MF_DISABLED 
     108        //MF_ENABLED 
     109        //MF_END 
     110        //MF_GRAYED 
     111        //MF_HELP 
     112        //MF_HILITE 
     113        //MF_INSERT 
     114        //MF_MENUBARBREAK 
     115        //MF_MENUBREAK 
     116        //MF_MOUSESELECT 
     117        //MF_OWNERDRAW 
     118        //MF_POPUP 
     119        //MF_POPUP 
     120        //MF_REMOVE, 
     121        //MF_RIGHTJUSTIFY, 
     122        //MF_SEPARATOR, 
     123        //MF_STRING, 
     124        //MF_SYSMENU, 
     125        //MF_UNCHECKED, 
     126        //MF_UNHILITE 
     127        //MF_USECHECKBITMAPS 
     128END 
     129 
     130// Desirable to have bitmaps cached 
     131@MENU  
     132{ 
     133    BITMAP = "FILE"; 
     134    TEXT="Eraser"; 
     135    BITMAP CHECKED="FILE"; 
     136    BITMAP UNCHECKED="FILE"; 
     137 
     138    // submenu creation 
     139    @MENU  
     140    { 
     141        @CHECKBOX  
     142        { 
     143        } 
     144        @SEPERATOR 
     145    } 
     146} 
     147 
     148UINT     cbSize; 
     149UINT     fMask; 
     150UINT     fType;         // used if MIIM_TYPE (4.0) or MIIM_FTYPE (>4.0) 
     151UINT     fState;        // used if MIIM_STATE 
     152UINT     wID;           // used if MIIM_ID 
     153HMENU    hSubMenu;      // used if MIIM_SUBMENU 
     154HBITMAP  hbmpChecked;   // used if MIIM_CHECKMARKS 
     155HBITMAP  hbmpUnchecked; // used if MIIM_CHECKMARKS 
     156ULONG_PTR dwItemData;   // used if MIIM_DATA 
     157__field_ecount_opt(cch) LPSTR    dwTypeData;    // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0) 
     158UINT     cch;           // used if MIIM_TYPE (4.0) or MIIM_STRING (>4.0) 
     159HBITMAP  hbmpItem;      // used if MIIM_BITMAP 
     160 
     161*/ 
     162 
     163/** 
     164 * return a seperate MENUITEMINFO structure */ 
     165static MENUITEMINFO* GetSeperator() 
     166{ 
     167    MENUITEMINFO *mii = new MENUITEMINFO();      
     168    mii->cbSize = sizeof(MENUITEMINFO); 
     169    mii->fMask = MIIM_TYPE; 
     170    mii->fType = MF_SEPARATOR; 
     171    return mii; 
     172} 
     173 
    79174HRESULT CCtxMenu::QueryContextMenu ( 
    80     HMENU hmenu, 
    81     UINT  uMenuIndex,  
    82     UINT  uidFirstCmd,  
    83     UINT  uidLastCmd, 
    84     UINT  uFlags ) 
    85 { 
    86     // If the flags include CMF_DEFAULTONLY then we shouldn't do anything. 
    87     if ( uFlags & CMF_DEFAULTONLY ) 
    88         return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 0 ); 
    89  
    90     // First, create and populate a submenu. 
    91     HMENU hSubmenu = CreatePopupMenu(); 
    92     UINT uID = uidFirstCmd; 
     175                HMENU hmenu, 
     176                UINT  uMenuIndex, 
     177                UINT  uidFirstCmd,  
     178                UINT  uidLastCmd, 
     179                UINT  uFlags ) 
     180{ 
     181    // If the flags include CMF_DEFAULTONLY then we shouldn't do anything. 
     182    if ( uFlags & CMF_DEFAULTONLY ) 
     183        return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 0 ); 
     184 
     185    // First, create and populate a submenu. 
    93186    UINT ctrPos = 0; 
    94  
    95     InsertMenu ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("&Erase"   ) ); 
    96     InsertMenu ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("&Set Algorithm" ) ); 
    97     InsertMenu ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("S&chedule" ) ); 
    98     InsertMenu ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("Se&lect Default") ); 
    99      
    100     // Insert the submenu into the ctx menu provided by Explorer. 
    101     {// sperator 
    102         MENUITEMINFO mii = { sizeof(MENUITEMINFO) };         
    103         mii.fMask = MIIM_TYPE; 
    104         mii.fType = MF_SEPARATOR; 
    105         InsertMenuItem(hmenu, uMenuIndex++, TRUE, &mii); 
    106     } 
    107  
     187    UINT uID = uidFirstCmd;  
     188    HMENU hSubmenu = CreatePopupMenu();  
     189 
     190 
     191    /* Remember this order is defined _Statically_ on the CEraserLPVERB enum */ 
     192    /* -------------------------------- Submenu -------------------------------- */ 
     193    /* [0] */ InsertMenu     ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("&Erase"    ) ); 
     194    /* [1] */ InsertMenu     ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("&Schedule" ) ); 
     195    /* [2] */ InsertMenu     ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("Erase on &Restart" ) ); 
     196    /* ------------------------------------------------------------------------- */ 
     197    /* [3] */ InsertMenuItem ( hSubmenu, ctrPos++, TRUE, GetSeperator() ); 
     198    /* [4] */ InsertMenu     ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("Secure &Move" ) );  
     199    /* ------------------------------------------------------------------------- */ 
     200    /* [5] */ InsertMenuItem ( hSubmenu, ctrPos++, TRUE, GetSeperator() ); 
     201    /* [6] */ InsertMenu     ( hSubmenu, ctrPos++, MF_BYPOSITION, uID++, _T("&Customise") );     
     202    /* ------------------------------ Submenu end ------------------------------ */ 
     203 
     204    // Insert the submenu into the ctx menu provided by Explorer. 
     205    /* ------------------------------------------------------------------------- */ 
     206    InsertMenuItem ( hSubmenu, uMenuIndex++, TRUE, GetSeperator() ); 
    108207    { 
    109208        MENUITEMINFO mii = { sizeof(MENUITEMINFO) }; 
     
    114213        InsertMenuItem(hmenu, uMenuIndex++, TRUE, &mii); 
    115214    } 
    116      
    117     {// sperator 
    118         MENUITEMINFO mii = { sizeof(MENUITEMINFO) };         
    119         mii.fMask = MIIM_TYPE; 
    120         mii.fType = MF_SEPARATOR; 
    121         InsertMenuItem(hmenu, uMenuIndex++, TRUE, &mii); 
    122     } 
     215    /* ------------------------------------------------------------------------- */ 
     216    InsertMenuItem ( hSubmenu, uMenuIndex++, TRUE, GetSeperator() ); 
    123217 
    124218    // Set the bitmap for the register item. 
    125     if ( m_szEraserIcon != nullpointer(HBITMAP*) ) 
    126     { 
    127         DebugMessageBox(DebugHWND, 
    128                     _T("Loading Eraser Icon Bitmap"), 
    129                     _T("Eraser Shell Extention - Debug"), 
    130                     MB_OK); 
    131  
    132         SetMenuItemBitmaps(hmenu, uMenuIndex, MF_BYPOSITION, *m_szEraserIcon, NULL ); 
    133     } 
    134  
    135     return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, uID - uidFirstCmd ); 
     219    if ( m_szEraserIcon != ((HBITMAP)0) ) 
     220        SetMenuItemBitmaps(hmenu, uMenuIndex++, MF_BYPOSITION, m_szEraserIcon, NULL ); 
     221 
     222    return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, uID - uidFirstCmd ); 
    136223} 
    137224 
    138225HRESULT CCtxMenu::GetCommandString ( 
    139     UINT  idCmd,    
    140     UINT uFlags, 
    141     UINT* pwReserved, 
    142     LPSTR pszName, 
    143     UINT  cchMax ) 
    144 { 
    145 USES_CONVERSION; 
    146  
    147     // Check idCmd, it must be 0 or 1 since we have two menu items. 
    148     if ( idCmd > 4 ) 
    149         return E_INVALIDARG; 
    150  
    151     // If Explorer is asking for a help string, copy our string into the 
    152     // supplied buffer. 
    153     if (!(uFlags & GCS_HELPTEXT))  
    154         return E_INVALIDARG; 
    155  
     226                                    UINT  idCmd,    
     227                                    UINT uFlags, 
     228                                    UINT* pwReserved, 
     229                                    LPSTR pszName, 
     230                                    UINT  cchMax ) 
     231{ 
     232    USES_CONVERSION; 
     233 
     234    // Check idCmd, it must be 0 or 1 since we have two menu items. 
     235    if ( idCmd > 4 ) 
     236        return E_INVALIDARG; 
     237 
     238    // If Explorer is asking for a help string, copy our string into the 
     239    // supplied buffer. 
     240    if (!(uFlags & GCS_HELPTEXT))  
     241        return E_INVALIDARG; 
     242  
    156243    static LPCTSTR szNotepadText = _T("Open the selected file in Notepad"); 
    157244    static LPCTSTR szIEText = _T("Open the selected file in Internet Explorer"); 
     
    162249        // Unicode string copy API. 
    163250        lstrcpynW ( (LPWSTR) pszName, T2CW(pszText), cchMax ); 
    164     else 
    165         // Use the ANSI string copy API to return the help string. 
    166         lstrcpynA ( pszName, T2CA(pszText), cchMax ); 
    167      
    168     return S_OK; 
     251    else 
     252        // Use the ANSI string copy API to return the help string. 
     253        lstrcpynA ( pszName, T2CA(pszText), cchMax ); 
     254 
     255    return S_OK; 
    169256} 
    170257 
     
    1752623) Set default algorithm 
    176263*/ 
     264 
     265#define foreach(iter, container) \ 
     266    for(string_list::iterator iter = container.begin(); \ 
     267    iter != container.end(); iter++) 
     268 
    177269HRESULT CCtxMenu::InvokeCommand ( LPCMINVOKECOMMANDINFO pCmdInfo ) 
    178270{ 
    179     // If lpVerb really points to a string, ignore this function call and bail out. 
    180     if ( 0 != HIWORD( pCmdInfo->lpVerb )) 
    181         return E_INVALIDARG; 
    182  
    183     // Get the command index. 
    184     switch  
    185         ( 
    186         LOWORD(pCmdInfo->lpVerb + 1 + CERASER_ENUM(CEraserLPVERB::LPVERB_FRIST)) 
    187         ) 
    188     { 
    189     case CERASER_ENUM(CEraserLPVERB::LPVERB_ERASE_FILE): 
    190     case CERASER_ENUM(CEraserLPVERB::LPVERB_ERASE_FREE_SPACE): 
    191     case CERASER_ENUM(CEraserLPVERB::LPVERB_SET_DEFAULT_FILE_ALGORITHM): 
    192     case CERASER_ENUM(CEraserLPVERB::LPVERB_SET_DEFAULT_FREE_SPACE_ALGORITHM): 
    193     case CERASER_ENUM(CEraserLPVERB::LPVERB_SET_FILE_ALGORITHM): 
    194     case CERASER_ENUM(CEraserLPVERB::LPVERB_SET_FREE_SPACE_ALGORITHM): 
    195         { 
    196             WCHAR szMsg [MAX_PATH + 32]; 
    197             wsprintf ( szMsg, _T("Not Implemented Querry!\n\nID = %d\n\n"), LOWORD(pCmdInfo->lpVerb) ); 
    198             MessageBox ( pCmdInfo->hwnd, szMsg, _T("Eraser v6 - Shell Extention Query"), MB_ICONINFORMATION ); 
    199             return E_INVALIDARG; 
    200         } 
    201         break; // unreachable code 
    202          
    203     case CERASER_ENUM(CEraserLPVERB::LPVERB_SHOW_FILE_NAME): 
    204         { 
    205             std::basic_string<WCHAR> map = _T("The selected files were:\n\n"); 
    206  
    207             for(string_list::iterator i = m_szSelectedFiles.begin(); 
    208                 i != m_szSelectedFiles.end(); i++, map += _T("\r\n")) 
    209                     map += i->c_str(); 
    210  
    211             MessageBox ( pCmdInfo->hwnd, (LPWSTR)map.c_str(), _T("Eraser v6 - Shell Extention Query"), MB_ICONINFORMATION ); 
    212  
    213             return S_OK;  
    214         } 
    215         break; // unreachable code 
     271    // If lpVerb really points to a string, ignore this function call and bail out. 
     272    if ( HIWORD( pCmdInfo->lpVerb )  != 0) 
     273        return E_INVALIDARG; 
     274 
     275    // Get the command index. 
     276    switch( LOWORD(pCmdInfo->lpVerb + 1) ) 
     277    { 
     278    case CERASER_ENUM(CEraserLPVERBS::CERASER_ERASE): 
     279        { 
     280            List<String ^> ^files = gcnew List<String ^>(m_szSelectedFiles.size()); 
     281 
     282            foreach(file, m_szSelectedFiles) 
     283            { 
     284                files->Add( UnmanagedToManagedString(*file) ); 
     285            } 
     286            EraseFiles(files); 
     287        } 
     288    case CERASER_ENUM(CEraserLPVERBS::CERASER_SECURE_MOVE): 
     289        { 
     290            List<String ^> ^files = gcnew List<String ^>(m_szSelectedFiles.size()); 
     291 
     292            foreach(file, m_szSelectedFiles) 
     293            { 
     294                files->Add( UnmanagedToManagedString(*file) ); 
     295            } 
     296            EraseFiles(files); 
     297        } 
     298        // NOT IMPLEMENTED METHODS 
     299    case CERASER_ENUM(CEraserLPVERBS::CERASER_ERASE_ON_RESTART): 
     300        { 
     301            List<String ^> ^files = gcnew List<String ^>(m_szSelectedFiles.size()); 
     302 
     303            foreach(file, m_szSelectedFiles) 
     304            { 
     305                files->Add( UnmanagedToManagedString(*file) ); 
     306            } 
     307            EraseFiles(files); 
     308        } 
     309    case CERASER_ENUM(CEraserLPVERBS::CERASER_SCHEDULE): 
     310        { 
     311            foreach(file, m_szSelectedFiles) 
     312            { 
     313            } 
     314        } 
     315    case CERASER_ENUM(CEraserLPVERBS::CERASER_CUSTOMISE): 
     316        { 
     317        } 
    216318    default: 
    217319        { 
     
    221323            return E_INVALIDARG; 
    222324        } 
    223         break; // unreachable code 
    224     } 
    225 } 
     325        break; // unreachable code 
     326    } 
     327} 
  • branches/erasershellext/cpp/CtxMenu.h

    r441 r576  
    22 
    33#pragma once 
     4#pragma unmanaged 
     5 
    46#include "resource.h"       // main symbols 
    57 
    68#include "EraserCtxMenu_i.h" 
    7  
    89 
    910#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA) 
     
    1314#include <string> 
    1415#include <list> 
     16#include <fstream> 
    1517 
    16  
    17 #define CERASER_ENUM_TYPE       unsigned short 
    18 #define CERASER_CAST(type,x)    ((type)(x)) 
    19 #define CERASER_ENUM(x)         (CERASER_CAST(CERASER_ENUM_TYPE,x)) 
    20  
    21 #define private()   private: 
    22 #define public()    public: 
    23 #define protected() protected: 
    24 #define nullpointer(type) ((type)0) 
    25  
    26 #ifdef __cplusplus0x 
    27 #define CERASER_ENUM_CPP0X          : CERASER_ENUM_TYPE 
    28 #elif defined(__cplusplus) 
    29 #define CERASER_ENUM_CPP0X   
    30 #else 
    31 #error This is a template C++ file! 
    32 #endif 
     18#define CERASER_ENUM_TYPE       unsigned int 
     19#define CERASER_ENUM(x)         ((CERASER_ENUM_TYPE)x) 
    3320 
    3421#ifdef _DEBUG 
     
    4229namespace Eraser  
    4330{ 
    44     typedef std::list<std::basic_string<WCHAR> > string_list; 
     31    typedef std::basic_string<WCHAR> string_type; 
     32    typedef std::list<string_type  > string_list; 
     33 
     34    enum CEraserSecureMove 
     35    { 
     36        INV_SRC_FILE, 
     37        INV_DST_FILE, 
     38    }; 
     39 
     40    static int SecureMove(const string_type& dst, const string_type& src) 
     41    { 
     42    } 
    4543 
    4644    // CCtxMenu 
    47  
    4845    class ATL_NO_VTABLE CCtxMenu : 
    4946        public CComObjectRootEx<CComSingleThreadModel>, 
     
    5754        { 
    5855        } 
     56                 
     57    public: enum CEraserLPVERBS 
     58    { 
     59        CERASER_ERASE                       = 0, 
     60        CERASER_SCHEDULE                = 1, 
     61        CERASER_ERASE_ON_RESTART= 2,             
     62        CERASER_SEPERATOR_1         = 3, 
     63        CERASER_SECURE_MOVE         = 4,             
     64        CERASER_SEPERATOR_2         = 5, 
     65        CERASER_CUSTOMISE               = 6, 
     66    }; 
    5967 
    60         public() enum CEraserLPVERB CERASER_ENUM_CPP0X 
    61         { 
    62             LPVERB_FRIST                    = 0x8000, // 16-bit enum hack  
    63             LPVERB_SHOW_FILE_NAME                   , 
    64             LPVERB_ERASE_FREE_SPACE                 , 
    65             LPVERB_ERASE_FILE                       , 
    66             LPVERB_SET_FREE_SPACE_ALGORITHM         , 
    67             LPVERB_SET_FILE_ALGORITHM               , 
    68             LPVERB_SET_DEFAULT_FREE_SPACE_ALGORITHM , 
    69             LPVERB_SET_DEFAULT_FILE_ALGORITHM       ,    
    70             LPVERB_LAST, 
    71         }; 
    7268    public: 
    7369        // IShellExtInit 
     
    8177    protected: 
    8278        string_list m_szSelectedFiles; 
    83         HBITMAP*    m_szEraserIcon; 
     79        HBITMAP     m_szEraserIcon; 
    8480    public: 
    8581 
     
    107103 
    108104} // namespace Eraser 
     105 
     106#pragma managed 
     107 
     108using namespace System; 
     109using namespace System::Collections::Generic; 
     110using namespace System::ComponentModel; 
     111using namespace System::Data; 
     112using namespace System::Drawing; 
     113using namespace System::Text; 
     114 
     115using namespace Eraser; 
     116using namespace Eraser::Manager; 
     117 
     118namespace Eraser 
     119{    
     120    static String ^UnmanagedToManagedString(const string_type& string) 
     121    { 
     122        return gcnew String(string.c_str()); 
     123    } 
     124 
     125    static void EraseFiles(List<String ^> ^paths) 
     126    { 
     127        Task ^task = gcnew Task(); 
     128     
     129        for(int i = 0; i < paths->Count; i++) 
     130        { 
     131            Task::File ^fileTask = gcnew Task::File(); 
     132            fileTask->Path = paths[i]; 
     133            fileTask->Method = reinterpret_cast<ErasureMethod ^> 
     134                ( ErasureMethodManager::Default ); 
     135 
     136            task->Targets->Add(fileTask); 
     137        } 
     138 
     139        // DirectExecutor::AddTask(task); 
     140    } 
     141 
     142    static void EraseFolder(List<String ^> ^paths) 
     143    { 
     144        Task ^task = gcnew Task(); 
     145 
     146        for(int i = 0; i < paths->Count; i++) 
     147        { 
     148            Task::Folder ^folderTask = gcnew Task::Folder(); 
     149            folderTask->Path = paths[i]; 
     150            folderTask->IncludeMask = L""; 
     151            folderTask->ExcludeMask = L""; 
     152            folderTask->DeleteIfEmpty =  
     153                Windows::Forms::MessageBox::Show(L"Would you like to delete empty folders?", L"Eraser Empty Folders Tips?", 
     154                Windows::Forms::MessageBoxButtons::YesNo,  
     155                Windows::Forms::MessageBoxIcon::Question) == 
     156                Windows::Forms::DialogResult::Yes; 
     157            task->Targets->Add(folderTask); 
     158        } 
     159 
     160        // DirectExecutor::AddTask(task); 
     161    } 
     162 
     163    static void EraseUnusedSpace(List<String ^> ^paths) 
     164    { 
     165        Task ^task = gcnew Task(); 
     166 
     167        for(int i = 0; i < paths->Count; i++) 
     168        { 
     169            Task::UnusedSpace ^unusedSpaceTask = gcnew Task::UnusedSpace(); 
     170            unusedSpaceTask->Drive = paths[i]; 
     171            unusedSpaceTask->EraseClusterTips =  
     172                Windows::Forms::MessageBox::Show(L"Would you like to erase the cluster tips as well?", L"Eraser Cluster Tips?", 
     173                Windows::Forms::MessageBoxButtons::YesNo,  
     174                Windows::Forms::MessageBoxIcon::Question) == 
     175                Windows::Forms::DialogResult::Yes;           
     176            task->Targets->Add(unusedSpaceTask); 
     177        } 
     178 
     179        // DirectExecutor::AddTask(task); 
     180    } 
     181 
     182} // namespace Eraser 
  • branches/erasershellext/cpp/EraserCtxMenu.vcproj

    r441 r576  
    55    Name="EraserCtxMenu" 
    66    ProjectGUID="{738F455B-2220-4F8F-B87F-DA93F0B0F1BA}" 
     7    RootNamespace="EraserCtxMenu" 
    78    Keyword="AtlProj" 
    89    TargetFrameworkVersion="196613" 
     
    2526            ATLMinimizesCRunTimeLibraryUsage="false" 
    2627            CharacterSet="1" 
     28            ManagedExtensions="1" 
    2729            > 
    2830            <Tool 
     
    5557                Optimization="0" 
    5658                PreprocessorDefinitions="WIN32;_WINDOWS;_DEBUG;_USRDLL;_MERGE_PROXYSTUB" 
    57                 MinimalRebuild="true" 
    58                 BasicRuntimeChecks="3" 
     59                MinimalRebuild="false" 
     60                BasicRuntimeChecks="0" 
    5961                RuntimeLibrary="3" 
    6062                UsePrecompiledHeader="2" 
    6163                WarningLevel="3" 
    62                 DebugInformationFormat="4" 
     64                DebugInformationFormat="3" 
    6365            /> 
    6466            <Tool 
     
    8284                ModuleDefinitionFile=".\EraserCtxMenu.def" 
    8385                GenerateDebugInformation="true" 
     86                AssemblyDebug="1" 
    8487                SubSystem="2" 
    8588                TargetMachine="1" 
     
    200203    </Configurations> 
    201204    <References> 
     205        <ProjectReference 
     206            ReferencedProjectIdentifier="{C1AC3255-0939-499D-A69D-725E3DD4F574}" 
     207            RelativePathToProject=".\Manager\Manager.csproj" 
     208        /> 
     209        <ProjectReference 
     210            ReferencedProjectIdentifier="{D083E1A8-3A4C-4683-9B3F-D5FEDE61B9C9}" 
     211            RelativePathToProject=".\Util\Util.csproj" 
     212        /> 
     213        <ProjectReference 
     214            ReferencedProjectIdentifier="{A9884ABF-46E8-42C1-A30B-9A3DD6C38004}" 
     215            RelativePathToProject=".\Eraser\Eraser.csproj" 
     216        /> 
     217        <AssemblyReference 
     218            RelativePath="System.dll" 
     219            AssemblyName="System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" 
     220            MinFrameworkVersion="131072" 
     221        /> 
     222        <AssemblyReference 
     223            RelativePath="System.Data.dll" 
     224            AssemblyName="System.Data, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=x86" 
     225            MinFrameworkVersion="131072" 
     226        /> 
     227        <AssemblyReference 
     228            RelativePath="System.Drawing.dll" 
     229            AssemblyName="System.Drawing, Version=2.0.0.0, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" 
     230            MinFrameworkVersion="131072" 
     231        /> 
     232        <AssemblyReference 
     233            RelativePath="System.Windows.Forms.dll" 
     234            AssemblyName="System.Windows.Forms, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" 
     235            MinFrameworkVersion="131072" 
     236        /> 
     237        <AssemblyReference 
     238            RelativePath="System.XML.dll" 
     239            AssemblyName="System.Xml, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" 
     240            MinFrameworkVersion="131072" 
     241        /> 
    202242    </References> 
    203243    <Files> 
     
    272312            </File> 
    273313            <File 
     314                RelativePath=".\SecureMove1.cpp" 
     315                > 
     316            </File> 
     317            <File 
    274318                RelativePath=".\stdafx.cpp" 
    275319                > 
     
    306350            </File> 
    307351            <File 
     352                RelativePath=".\ctxMenuParser.h" 
     353                > 
     354            </File> 
     355            <File 
    308356                RelativePath=".\dlldatax.h" 
    309357                > 
     
    314362            </File> 
    315363            <File 
     364                RelativePath=".\Eraser.h" 
     365                > 
     366            </File> 
     367            <File 
     368                RelativePath=".\Eraser.Manager.h" 
     369                > 
     370            </File> 
     371            <File 
     372                RelativePath=".\Eraser.Util.h" 
     373                > 
     374            </File> 
     375            <File 
    316376                RelativePath=".\Resource.h" 
    317377                > 
     378            </File> 
     379            <File 
     380                RelativePath=".\SecureMove1.h" 
     381                FileType="3" 
     382                > 
     383                <File 
     384                    RelativePath=".\SecureMove1.resx" 
     385                    > 
     386                </File> 
    318387            </File> 
    319388            <File 
  • branches/erasershellext/cpp/EraserCtxMenu_i.c

    r441 r576  
    77 
    88 /* File created by MIDL compiler version 7.00.0500 */ 
    9 /* at Sun Oct 12 03:28:36 2008 
     9/* at Sat Nov 15 13:44:02 2008 
    1010 */ 
    1111/* Compiler settings for .\EraserCtxMenu.idl: 
  • branches/erasershellext/cpp/EraserCtxMenu_i.h

    r441 r576  
    55 
    66 /* File created by MIDL compiler version 7.00.0500 */ 
    7 /* at Sun Oct 12 03:28:36 2008 
     7/* at Sat Nov 15 13:44:02 2008 
    88 */ 
    99/* Compiler settings for .\EraserCtxMenu.idl: 
  • branches/erasershellext/cpp/EraserCtxMenu_p.c

    r441 r576  
    55 
    66 /* File created by MIDL compiler version 7.00.0500 */ 
    7 /* at Sun Oct 12 03:28:36 2008 
     7/* at Sat Nov 15 13:44:02 2008 
    88 */ 
    99/* Compiler settings for .\EraserCtxMenu.idl: 
Note: See TracChangeset for help on using the changeset viewer.