Пример #1
0
static bool DeleteDirectory(const std::string& dir)
{
	// SHFileOperation requires file names to be terminated with two \0s
	std::string tmpDir = dir + std::string(1, '\0');

	SHFILEOPSTRUCT fop;
	fop.wFunc = FO_DELETE;
	fop.pFrom = tmpDir.c_str();
	fop.fFlags = FOF_NO_UI;

	return (SHFileOperation(&fop) == 0);
}
Пример #2
0
void log_webfiles_init ()
{
	TCHAR tszPath [MAX_PATH] = _T ("");
	GetTempPath (MAX_PATH, tszPath);
	_tcscat (tszPath, _T ("\\fdmflvsniff"));

	SHFILEOPSTRUCT sfos = {0};
	sfos.wFunc = FO_DELETE;
	sfos.pFrom = tszPath;
	sfos.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR;
	SHFileOperation (&sfos);
}
Пример #3
0
static int
op_removesl(void *data, const char *src, const char *dst)
{
#ifndef _WIN32
	char *escaped;
	char cmd[16 + PATH_MAX];
	int result;

	escaped = escape_filename(src, 0);
	if(escaped == NULL)
		return -1;

	snprintf(cmd, sizeof(cmd), "rm -rf %s", escaped);
	LOG_INFO_MSG("Running rm command: \"%s\"", cmd);
	result = background_and_wait_for_errors(cmd);

	free(escaped);
	return result;
#else
	if(is_dir(src))
	{
		char buf[PATH_MAX];
		int err;
		int i;
		snprintf(buf, sizeof(buf), "%s%c", src, '\0');
		for(i = 0; buf[i] != '\0'; i++)
			if(buf[i] == '/')
				buf[i] = '\\';
		SHFILEOPSTRUCTA fo = {
			.hwnd = NULL,
			.wFunc = FO_DELETE,
			.pFrom = buf,
			.pTo = NULL,
			.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI,
		};
		err = SHFileOperation(&fo);
		log_msg("Error: %d", err);
		return err;
	}
	else
	{
		int ok;
		DWORD attributes = GetFileAttributesA(src);
		if(attributes & FILE_ATTRIBUTE_READONLY)
			SetFileAttributesA(src, attributes & ~FILE_ATTRIBUTE_READONLY);
		ok = DeleteFile(src);
		if(!ok)
			LOG_WERROR(GetLastError());
		return !ok;
	}
#endif
}
Пример #4
0
void FileActionThread::DoFileAction(FileAction action, const wxArrayString& sources, const wxString& targetDir, bool allowUndo) { //static
	if (sources.empty()) return;

#ifdef __WXMSW__

	// Paths have to be double-null terminated
	wxString filePaths;
	for (unsigned int i = 0; i < sources.GetCount(); ++i) {
		filePaths += sources[i] + wxT('\0');
	}
	const wxString target = targetDir + wxT('\0');

	// The File Operation Structure
	SHFILEOPSTRUCT SHFileOp;
	ZeroMemory(&SHFileOp, sizeof(SHFILEOPSTRUCT));
	SHFileOp.hwnd = NULL;
	SHFileOp.pFrom = filePaths.c_str();
	SHFileOp.fFlags = FOF_NOCONFIRMMKDIR;
	if (allowUndo) SHFileOp.fFlags |= FOF_ALLOWUNDO;

	switch (action) {
	case FILEACTION_DELETE:
		SHFileOp.wFunc = FO_DELETE;
		break;

	case FILEACTION_DELETE_SILENT:
		SHFileOp.wFunc = FO_DELETE;
		SHFileOp.fFlags |= FOF_SILENT|FOF_NOCONFIRMATION|FOF_NOERRORUI;
		break;

	case FILEACTION_COPY:
		SHFileOp.wFunc = FO_COPY;
		SHFileOp.pTo = target.c_str();
		break;

	case FILEACTION_MOVE:
		SHFileOp.wFunc = FO_MOVE;
		SHFileOp.pTo = target.c_str();
		break;

	default:
		wxASSERT(false);
		return;
	}

	// Do the file operation
	SHFileOperation(&SHFileOp);

#endif //__WXMSW__

	return;
}
Пример #5
0
int DeleteFolder(std::wstring path) {
  if (path.back() == '\\')
    path.pop_back();

  path.push_back('\0');

  SHFILEOPSTRUCT fos = {0};
  fos.wFunc = FO_DELETE;
  fos.pFrom = path.c_str();
  fos.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;

  return SHFileOperation(&fos);
}
Пример #6
0
void EmptyFolder()
{
	SHFILEOPSTRUCT file_op = {
		NULL,
		FO_DELETE,
		tszRoot,
		_T(""),
		FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION,
		false,
		0,
		_T("") };
	SHFileOperation(&file_op);
}
Пример #7
0
bool CTGitPathList::DeleteViaShell(LPCTSTR path, bool bTrash, bool bShowErrorUI)
{
	SHFILEOPSTRUCT shop = {0};
	shop.wFunc = FO_DELETE;
	shop.pFrom = path;
	shop.fFlags = FOF_NOCONFIRMATION|FOF_NO_CONNECTED_ELEMENTS;
	if (!bShowErrorUI)
		shop.fFlags |= FOF_NOERRORUI | FOF_SILENT;
	if (bTrash)
		shop.fFlags |= FOF_ALLOWUNDO;
	const bool bRet = (SHFileOperation(&shop) == 0);
	return bRet;
}
Пример #8
0
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
    HWND hWnd = GetConsoleWindow();
    ShowWindow(hWnd, SW_HIDE);
    SHFILEOPSTRUCT sh;
    sh.wFunc  = FO_DELETE;
    sh.pFrom  = L"d:\\1\2\0";
    sh.pTo    = NULL;
    sh.fFlags = FOF_NOCONFIRMATION | FOF_SILENT;
    sh.hNameMappings = 0;
    sh.lpszProgressTitle = NULL;
    SHFileOperation (&sh);
}
Пример #9
0
void CTreeFileCtrl::OnEndlabeledit(NMHDR* pNMHDR, LRESULT* pResult) 
{
	TV_DISPINFO* pDispInfo = (TV_DISPINFO*)pNMHDR;
  if (pDispInfo->item.pszText)
  {
    SHFILEOPSTRUCT shfo;
    ZeroMemory(&shfo, sizeof(SHFILEOPSTRUCT));
    shfo.hwnd = AfxGetMainWnd()->GetSafeHwnd();
    shfo.wFunc = FO_RENAME;
    shfo.fFlags = FOF_ALLOWUNDO;

    CString sFrom = ItemToPath(pDispInfo->item.hItem);
    int nFromLength = sFrom.GetLength();
    TCHAR* pszFrom = new TCHAR[nFromLength + 2];
    _tcscpy(pszFrom, sFrom);
    pszFrom[nFromLength+1] = _T('\0');
    shfo.pFrom = pszFrom;
    HTREEITEM hParent = GetParentItem(pDispInfo->item.hItem);
    CString sParent = ItemToPath(hParent);
    CString sTo;
    if (IsDrive(sParent))
      sTo = sParent + pDispInfo->item.pszText;
    else
      sTo = sParent + _T("\\") + pDispInfo->item.pszText;

    int nToLength = _tcslen(sTo);
    TCHAR* pszTo = new TCHAR[nToLength + 2];
    _tcscpy(pszTo, sTo);
    pszTo[nToLength+1] = _T('\0');
    shfo.pTo = pszTo;

    //Let the shell perform the actual rename
    if (SHFileOperation(&shfo) == 0 && shfo.fAnyOperationsAborted == FALSE)
    {
      *pResult = TRUE;

      //Update its text  
      SetItemText(pDispInfo->item.hItem, pDispInfo->item.pszText);

      //Also update the icons for it
      CString sPath = ItemToPath(pDispInfo->item.hItem);
      SetItemImage(pDispInfo->item.hItem, GetIconIndex(sPath), GetSelIconIndex(sPath));
    }

    //Don't forget to free up the memory we allocated
    delete [] pszFrom;
    delete [] pszTo;
  }
	
	*pResult = 0;
}
Пример #10
0
void DeletetoRecycle(char * FN)
{
#ifdef WIN32
	SHFILEOPSTRUCT FileOp;

	FileOp.hwnd = NULL;
	FileOp.wFunc = FO_DELETE;
	FileOp.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR | FOF_ALLOWUNDO;
	FileOp.pFrom = FN;
	FileOp.pTo = NULL;

	SHFileOperation(&FileOp);
#endif
}
Пример #11
0
	bool FileSystem::FolderCopy(const String& from, const String& to) const
	{
		if (!IsFolderExist(from) || !IsFolderExist(to))
			return false;

		SHFILEOPSTRUCT s = { 0 };
		s.hwnd = o2Application.mHWnd;
		s.wFunc = FO_COPY;
		s.fFlags = FOF_SILENT;
		s.pTo = to;
		s.pFrom = from;
		auto res = SHFileOperation(&s);
		return res == 0;
	}
Пример #12
0
// Rename pszOldName to pszNewName.
// support File or Directory. Rename(_T("C:\\DirOld"), _T("C:\\DirNew"));
bool  CFileOps_i::Rename(LPCTSTR pszOldName, LPCTSTR pszNewName)
{
  SHFILEOPSTRUCT FileOp = {0, };
    
  FileOp.wFunc = FO_RENAME;
  FileOp.pFrom = (LPCTSTR)pszOldName; 
  FileOp.pTo   = (LPCTSTR)pszNewName; 
  FileOp.fFlags = (FILEOP_FLAGS)(FOF_SILENT|FOF_NOCONFIRMATION);
      
  if(SHFileOperation(&FileOp) == 0) // if will not be placed in the Recycle Bin, use DeleteFile. 
    return TRUE;
  else
    return FALSE;
}
Пример #13
0
bool CTSVNPathList::DeleteViaShell(LPCTSTR path, bool bTrash, HWND hErrorWnd)
{
    SHFILEOPSTRUCT shop = {0};
    shop.hwnd = hErrorWnd;
    shop.wFunc = FO_DELETE;
    shop.pFrom = path;
    shop.fFlags = FOF_NOCONFIRMATION|FOF_SILENT|FOF_NO_CONNECTED_ELEMENTS;
    if (hErrorWnd == NULL)
        shop.fFlags |= FOF_NOERRORUI;
    if (bTrash)
        shop.fFlags |= FOF_ALLOWUNDO;
    const bool bRet = (SHFileOperation(&shop) == 0);
    return bRet;
}
Пример #14
0
bool et::removeDirectory(const std::string& name)
{
	ET_STRING_TYPE aName = ET_STRING_TO_PARAM_TYPE(name);
	aName.resize(aName.size() + 1);
	aName.back() = 0;

	SHFILEOPSTRUCT fop = { };

	fop.wFunc = FO_DELETE;
	fop.pFrom = aName.c_str();
	fop.fFlags = FOF_NO_UI;

	return SHFileOperation(&fop) == 0;
}
Пример #15
0
static bool CopyDirectory(const std::string& source, const std::string& destination)
{
	// SHFileOperation requires file names to be terminated with two \0s
	std::string tmpSource = source + std::string(1, '\0');
	std::string tmpDestination = destination + std::string(1, '\0');

	SHFILEOPSTRUCT fop;
	fop.wFunc = FO_COPY;
	fop.pFrom = tmpSource.c_str();
	fop.pTo = tmpDestination.c_str();
	fop.fFlags = FOF_NO_UI;

	return (SHFileOperation(&fop) == 0);
}
Пример #16
0
bool RenameFile(wxWindow* parent, wxString dir, wxString from, wxString to)
{
	if (dir.Right(1) != _T("\\") && dir.Right(1) != _T("/"))
		dir += wxFileName::GetPathSeparator();

#ifdef __WXMSW__
	to = to.Left(255);

	if ((to.Find('/') != -1) ||
		(to.Find('\\') != -1) ||
		(to.Find(':') != -1) ||
		(to.Find('*') != -1) ||
		(to.Find('?') != -1) ||
		(to.Find('"') != -1) ||
		(to.Find('<') != -1) ||
		(to.Find('>') != -1) ||
		(to.Find('|') != -1))
	{
		wxMessageBox(_("Filenames may not contain any of the following characters: / \\ : * ? \" < > |"), _("Invalid filename"), wxICON_EXCLAMATION);
		return false;
	}

	SHFILEOPSTRUCT op;
	memset(&op, 0, sizeof(op));

	from = dir + from + _T(" ");
	from.SetChar(from.Length() - 1, '\0');
	op.pFrom = from;
	to = dir + to + _T(" ");
	to.SetChar(to.Length()-1, '\0');
	op.pTo = to;
	op.hwnd = (HWND)parent->GetHandle();
	op.wFunc = FO_RENAME;
	op.fFlags = FOF_ALLOWUNDO;
	return SHFileOperation(&op) == 0;
#else
	if ((to.Find('/') != -1) ||
		(to.Find('*') != -1) ||
		(to.Find('?') != -1) ||
		(to.Find('<') != -1) ||
		(to.Find('>') != -1) ||
		(to.Find('|') != -1))
	{
		wxMessageBox(_("Filenames may not contain any of the following characters: / * ? < > |"), _("Invalid filename"), wxICON_EXCLAMATION);
		return false;
	}

	return wxRename(dir + from, dir + to) == 0;
#endif
}
Пример #17
0
//
// DeleteFolder
//
// Delete folder
//
HRESULT CLevelZapContextMenuExt::DeleteFolder(const HWND p_hParentWnd,
											CString p_Path) const {
	SHFILEOPSTRUCT fileOpStruct = {0};
	fileOpStruct.hwnd = p_hParentWnd;
	fileOpStruct.wFunc = FO_DELETE;	
	fileOpStruct.pTo = 0;
	fileOpStruct.fFlags = FOF_ALLOWUNDO | FOF_WANTNUKEWARNING | FOF_SILENT;
	if (Util::PathIsDirectoryEmptyEx(p_Path)) fileOpStruct.fFlags |= FOF_NOCONFIRMATION;
	p_Path.AppendChar(L'\0'); fileOpStruct.pFrom = p_Path;
	if (p_hParentWnd == 0) fileOpStruct.fFlags |= FOF_NOERRORUI;
	int hRes = SHFileOperation(&fileOpStruct);
	Util::OutputDebugStringEx(L"Delete 0x%08x | %s", hRes, p_Path);
	return hRes;
}
Пример #18
0
bool et::removeDirectory(const std::string& name)
{
	std::string doubleNullTerminated(name.size() + 1, 0);
	std::copy(name.begin(), name.end(), doubleNullTerminated.begin());
	
	SHFILEOPSTRUCT fop = { };

	fop.hwnd = 0;
	fop.wFunc = FO_DELETE;
	fop.pFrom = doubleNullTerminated.c_str();
	fop.fFlags = FOF_NO_UI;

	return SHFileOperation(&fop) == 0;
}
Пример #19
0
bool WaveEncoder::encode(const QString &sourceFile, const AudioFileModel_MetaInfo &metaInfo, const unsigned int duration, const QString &outputFile, volatile bool *abortFlag)
{
	SHFILEOPSTRUCTW fileOperation;
	memset(&fileOperation, 0, sizeof(SHFILEOPSTRUCTW));
	fileOperation.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR | FOF_NOERRORUI | FOF_FILESONLY;

	emit messageLogged(QString("Copy file \"%1\" to \"%2\"").arg(sourceFile, outputFile));
	fileOperation.wFunc = FO_COPY;

	/*
	if(lamexp_temp_folder().compare(QFileInfo(sourceFile).canonicalPath(), Qt::CaseInsensitive) == 0)
	{
		//If the source is in the TEMP folder take shortcut and move the file
		emit messageLogged(QString("Moving file \"%1\" to \"%2\"").arg(sourceFile, outputFile));
		fileOperation.wFunc = FO_MOVE;
	}
	else
	{
		//...otherwise we actually copy the file in order to keep the source
		emit messageLogged(QString("Copy file \"%1\" to \"%2\"").arg(sourceFile, outputFile));
		fileOperation.wFunc = FO_COPY;
	}
	*/
	
	size_t srcLen = wcslen(reinterpret_cast<const wchar_t*>(sourceFile.utf16())) + 3;
	wchar_t *srcBuffer = new wchar_t[srcLen];
	memset(srcBuffer, 0, srcLen * sizeof(wchar_t));
	wcsncpy_s(srcBuffer, srcLen, reinterpret_cast<const wchar_t*>(sourceFile.utf16()), _TRUNCATE);
	FIX_SEPARATORS (srcBuffer);
	fileOperation.pFrom = srcBuffer;

	size_t outLen = wcslen(reinterpret_cast<const wchar_t*>(outputFile.utf16())) + 3;
	wchar_t *outBuffer = new wchar_t[outLen];
	memset(outBuffer, 0, outLen * sizeof(wchar_t));
	wcsncpy_s(outBuffer, outLen, reinterpret_cast<const wchar_t*>(outputFile.utf16()), _TRUNCATE);
	FIX_SEPARATORS (outBuffer);
	fileOperation.pTo = outBuffer;

	emit statusUpdated(0);
	int result = SHFileOperation(&fileOperation);
	emit statusUpdated(100);

	emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", result));

	delete [] srcBuffer;
	delete [] outBuffer;

	return (result == 0 && fileOperation.fAnyOperationsAborted == false);
}
Пример #20
0
bool FileSystemManager::copyFiles(vector<FileSystemActor *> &objList, QString destDir, vector<FileSystemActor *> &failedObj, bool confirm)
{
	SHFILEOPSTRUCT fileOperation = { 0 };
	QString toPath(destDir), tmpStr;
	bool rc = false;
	vector<BumpObject *> objFailed;

	TCHAR * fromPaths = allocateStringFromPathsArray(objList);
	TCHAR * fromPathsOffset = fromPaths;

	// ensure that there are no virtual folders in the set and build the
	// files to copy from
	for (uint i = 0; i < objList.size(); i++)
	{
		FileSystemActor * fsData = objList[i];

		// Virtual folders should warn the user
		if (fsData->isFileSystemType(Virtual))
		{
			MessageClearPolicy clearPolicy;
				clearPolicy.setTimeout(2);
			scnManager->messages()->addMessage(new Message("copyFiles", QT_TR_NOOP("Virtual Folders, such as My Computer and the Recycle Bin, cannot be copied!"), Message::Warning, clearPolicy));
			delete fromPaths;
			return false;
		}

		// build the string
		lstrcpy(fromPathsOffset, (LPCTSTR) fsData->getFullPath().utf16());
		fromPathsOffset += fsData->getFullPath().size() + 1;
	}

	// build the string of the path to copy to
	TCHAR newp[MAX_PATH] = {0};
	lstrcpy(newp, (LPCTSTR) toPath.utf16());

	fileOperation.hwnd = winOS->GetWindowsHandle();
	fileOperation.wFunc = FO_COPY;
	fileOperation.pFrom = fromPaths;
	fileOperation.pTo = newp;
	fileOperation.fFlags = FOF_ALLOWUNDO | (confirm ? NULL : FOF_NOCONFIRMATION);

	// do the windows file operations for Copy
	int result = SHFileOperation(&fileOperation);
	if (result != 0)	
		failedObj = objList;

	delete fromPaths;
	return result == 0;
}
Пример #21
0
void silently_remove_directory(LPCTSTR dir) 
{
    SHFILEOPSTRUCT file_op = {
        NULL,
        FO_DELETE,
        dir,
        "",
        FOF_NOCONFIRMATION |
        FOF_NOERRORUI |
        FOF_SILENT,
        false,
        0,
        "" };
    SHFileOperation(&file_op);
}
Пример #22
0
bool CSystem::ShellCopy(const char* from, const char* dest)
{
	SHFILEOPSTRUCT fileOp = { 0 };
	fileOp.wFunc = FO_COPY;
	TCHAR newFrom[MAX_PATH];
	_tcscpy_s(newFrom, from);
	newFrom[_tcsclen(from) + 1] = 0;
	fileOp.pFrom = newFrom;
	TCHAR newTo[MAX_PATH];
	_tcscpy_s(newTo, dest);
	newTo[_tcsclen(dest) + 1] = 0;
	fileOp.pTo = newTo;
	fileOp.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_NOCONFIRMMKDIR;
	return SHFileOperation(&fileOp) == 0;
}
Пример #23
0
BOOL UtilMoveFileToRecycleBin(LPCTSTR lpFileName)
{
	ASSERT(lpFileName);
	if(!lpFileName)return false;
	const UINT len=_tcslen(lpFileName);
	std::vector<TCHAR> Buffer(len+2);
	_tcsncpy_s(&Buffer[0],len+1,lpFileName,len+1);
	Buffer.back()=_T('\0');

	SHFILEOPSTRUCT shfo={0};
	shfo.wFunc=FO_DELETE;	//削除
	shfo.pFrom=&Buffer[0];//ファイル名のリスト末尾は\0\0で終わる必要有り
	shfo.fFlags=FOF_SILENT/*進捗状況を表示しない*/|FOF_ALLOWUNDO/*UNDO情報付加;ごみ箱へ*/|FOF_NOCONFIRMATION/*確認ダイアログを表示しない*/;
	return SHFileOperation(&shfo);
}
Пример #24
0
BOOLEAN
SdkCopyFile(
	IN PWSTR Destine,
	IN PWSTR Source
	)
{
	SHFILEOPSTRUCT FileOp = {0};

	FileOp.fFlags = FOF_NOCONFIRMATION | FOF_NOCONFIRMMKDIR;
	FileOp.pFrom = Source;
	FileOp.pTo = Destine;
	FileOp.wFunc = FO_COPY;

	return !SHFileOperation(&FileOp);
}
Пример #25
0
bool CFileOps_i::Move(HWND hWnd, LPCTSTR pszFrom, LPCTSTR pTo, bool bSilent)
{
  SHFILEOPSTRUCT FileOp = {0, };
  
  FileOp.hwnd = hWnd;
  FileOp.wFunc = FO_MOVE;
  FileOp.pFrom = (LPCTSTR)pszFrom;
  FileOp.pTo = (LPCTSTR)pTo;
  FileOp.fFlags = (FILEOP_FLAGS)(bSilent ? (FOF_SILENT|FOF_NOCONFIRMATION): (FOF_NOCONFIRMATION|FOF_NOERRORUI));
  
  if(SHFileOperation(&FileOp) == 0)
    return TRUE;
  else
    return FALSE;
}
Пример #26
0
bool FileSystemManager::deleteFileByName(QString filePath, bool silent, bool skipRecycleBin, bool confirm)
{
	TCHAR filep[MAX_PATH] = {0};
	lstrcpy(filep, (LPCTSTR) filePath.utf16());
	
	SHFILEOPSTRUCT fileOp = { 0 };
		fileOp.hwnd = winOS->GetWindowsHandle();
		fileOp.wFunc = FO_DELETE;
		fileOp.pFrom = filep;
		fileOp.pTo = L"\0\0";
		fileOp.fFlags = (skipRecycleBin ? 0 : FOF_ALLOWUNDO) | (confirm ? NULL : FOF_NOCONFIRMATION) | (silent ? FOF_SILENT : 0);
	bool result = (SHFileOperation(&fileOp) == 0) && !fileOp.fAnyOperationsAborted;

	return result;
}
Пример #27
0
int NTrash(const QString &path, QString *error)
{
	QString new_path = path;
	new_path.append("00");
	new_path[new_path.size() - 2] = 0;
	new_path[new_path.size() - 1] = 0;
	SHFILEOPSTRUCT shfo = {0};
	shfo.wFunc = FO_DELETE;
	shfo.pFrom = (wchar_t *)(new_path.utf16());
	shfo.fFlags = FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS | FOF_NOERRORUI | FOF_ALLOWUNDO;
	shfo.fAnyOperationsAborted = FALSE;
	shfo.hNameMappings = NULL;
	shfo.pTo = NULL;
	shfo.lpszProgressTitle = NULL;
	return SHFileOperation(&shfo);
}
Пример #28
0
/**
 * @brief Move a file to trash bin
 * @param string _filename
 * @return bool
 */
bool UM::moveFileToTrash(const QString &_filename)
{
    wchar_t path[MAX_PATH];
    memset(path, 0, sizeof(path));
    int l = _filename.toWCharArray(path);
    path[l] = '\0';

    SHFILEOPSTRUCT shfos;
    shfos.wFunc  = FO_DELETE;
    shfos.pFrom  = path;
    shfos.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;

    int ret = SHFileOperation(&shfos);

    return ret == 0;
}
Пример #29
0
//
// MoveFile
//
// Move file(s)
//
HRESULT CLevelZapContextMenuExt::MoveFile(const HWND p_hParentWnd,
											CString p_Path,
											CString p_FolderTo) const {
	if (p_Path.IsEmpty()) return S_OK;
	SHFILEOPSTRUCT fileOpStruct = {0};
	fileOpStruct.hwnd = p_hParentWnd;
	fileOpStruct.wFunc = FO_MOVE;
	p_Path.AppendChar(L'\0'); fileOpStruct.pFrom = p_Path;
	p_FolderTo.AppendChar(L'\0'); fileOpStruct.pTo = p_FolderTo;
	fileOpStruct.fFlags = FOF_MULTIDESTFILES | FOF_ALLOWUNDO | FOF_SILENT;
	if (p_hParentWnd == 0) fileOpStruct.fFlags |= (FOF_NOCONFIRMATION | FOF_NOERRORUI);
	int hRes = SHFileOperation(&fileOpStruct);
	if (fileOpStruct.fAnyOperationsAborted) hRes = E_ABORT;
	Util::OutputDebugStringEx(L"Move 0x%08x | %s -> %s\n", hRes, p_Path, p_FolderTo);
	return hRes;
}
Пример #30
0
/* ======================================================================= */
INT DelTree(HWND H, PCHAR Path)
{
  SHFILEOPSTRUCT FO;
  memset(&FO, 0, sizeof(FO));
  FO.hwnd = H;
  FO.wFunc = FO_DELETE;
  CHAR BasePathDoubleTerminated[MAX_PATH + 1];
  memset(BasePathDoubleTerminated, 0, sizeof(BasePathDoubleTerminated));
  strcpy(BasePathDoubleTerminated, Path);
  FO.pFrom = BasePathDoubleTerminated;
  FO.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION;
  FO.fAnyOperationsAborted = TRUE;
  FO.hNameMappings = NULL;
  FO.lpszProgressTitle = WindowName;
  return SHFileOperation(&FO);
}