void CResourceFolderView::OnSelectionChanged(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*) pNMHDR;
CString strPath = GetPathFromItem (pNMTreeView->itemNew.hItem);
//GetDocument ()->UpdateAllViews (this, 0x5A, (CObject*) (LPCTSTR) strPath);
CResourceDoc* pDoc = DYNAMIC_DOWNCAST(CResourceDoc, GetDocument());
///////////////////////////////////////////// old solution
/*
// append the selected path to the resource path
CGDSApp * gApp = dynamic_cast< CGDSApp * >( AfxGetApp() );
if( gApp )
{
stdstrPath = StdString(gApp->GetResourcePath()) + _T("\\") + stdstrPath;
}
*/
/////////////////////////////////////////////// new solution
StdString stdstrPath( strPath );
stdstrPath = m_strResouceDirectory + "\\" + stdstrPath;
pDoc->SetActiveDirectory( stdstrPath );
*pResult = 0;
}
void CPage6::OnItemexpanding(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
HTREEITEM hItem = pNMTreeView->itemNew.hItem;
CString strPathName = GetPathFromItem (hItem);
if (!IsMediaValid (strPathName))
{
HTREEITEM hRoot = GetDriveNode (hItem);
m_FileTree.Expand (hRoot, TVE_COLLAPSE);
DeleteChildren (hRoot);
AddDummyNode (hRoot);
*pResult = TRUE;
return;
}
if (!IsPathValid (strPathName))
{
if(strPathName != MYCOMPUTER && strPathName != "")
{
m_FileTree.DeleteItem (hItem);
*pResult = TRUE;
return;
}
}
CWaitCursor wait;
if (pNMTreeView->action == TVE_EXPAND)
{
if(strPathName != MYCOMPUTER)
{
DeleteChildren (hItem);
if (!AddDirectoryNodes (hItem, strPathName))
*pResult = TRUE;
}
}
else {
if(strPathName != MYCOMPUTER)
{
DeleteChildren (hItem);
if (IsDriveNode (hItem))
AddDummyNode (hItem);
else
SetButtonState (hItem, strPathName);
}
}
m_LocalPath = strPathName;
*pResult = 0;
}
void CRemoteTreeView::OnMenuDelete(wxCommandEvent&)
{
if (!m_pState->IsRemoteIdle())
return;
if (!m_contextMenuItem)
return;
const CServerPath& path = GetPathFromItem(m_contextMenuItem);
if (path.empty())
return;
if (wxMessageBoxEx(_("Really delete all selected files and/or directories from the server?"), _("Confirmation needed"), wxICON_QUESTION | wxYES_NO, this) != wxYES)
return;
const bool hasParent = path.HasParent();
CRecursiveOperation* pRecursiveOperation = m_pState->GetRecursiveOperationHandler();
CServerPath startDir;
if (hasParent)
{
const wxString& name = GetItemText(m_contextMenuItem);
startDir = path.GetParent();
pRecursiveOperation->AddDirectoryToVisit(startDir, name);
}
else
{
startDir = path;
pRecursiveOperation->AddDirectoryToVisit(startDir, _T(""));
}
CServerPath currentPath;
const wxTreeItemId selected = GetSelection();
if (selected)
currentPath = GetPathFromItem(selected);
if (!currentPath.empty() && (path == currentPath || path.IsParentOf(currentPath, false)))
currentPath = startDir;
CFilterManager filter;
pRecursiveOperation->StartRecursiveOperation(CRecursiveOperation::recursive_delete, startDir, filter.GetActiveFilters(false), !hasParent, currentPath);
}
void CLeftView::CreateRoots()
{
CTreeCtrl &ctlTree=GetTreeCtrl();
ctlTree.DeleteAllItems();
CTreeCtrl &ctlDrives = this->GetTreeCtrl();
HTREEITEM hRoot;
char * strBuffer= NULL;
CString strMessage;
int nPos = 0;
UINT nCount = 0;
CString strDrive = _T("?:\\");
DWORD dwDriveList = ::GetLogicalDrives ();
CString cTmp;
while (dwDriveList) {
if (dwDriveList & 1) {
cTmp = strDrive;
strDrive.SetAt (0, 0x41 + nPos);
strDrive = strDrive.Left(2);
hRoot = ctlDrives.InsertItem(strDrive,0, 1);
}
dwDriveList >>= 1;
nPos++;
}
TCHAR szPath[MAX_PATH];
::GetCurrentDirectory (sizeof (szPath) / sizeof (TCHAR), szPath);
CString strPath = szPath;
strPath = strPath.Left (3);
HTREEITEM hItem = GetTreeCtrl ().GetNextItem (NULL, TVGN_ROOT);
while (hItem != NULL) {
if (GetTreeCtrl ().GetItemText (hItem) == strPath)
break;
hItem = GetTreeCtrl ().GetNextSiblingItem (hItem);
}
if (hItem != NULL) {
GetTreeCtrl ().Expand (hItem, TVE_EXPAND);
GetTreeCtrl ().Select (hItem, TVGN_CARET);
}
strPath = GetPathFromItem (GetTreeCtrl().GetSelectedItem());
GetDocument()->UpdateAllViews (this, 0x5A,
(CObject*) (LPCTSTR) strPath);
}
// Help-Function to create a new Directory
// Returns the name of the new directory
CServerPath CRemoteTreeView::MenuMkdir()
{
if (!m_pState->IsRemoteIdle())
return CServerPath();
if (!m_contextMenuItem)
return CServerPath();
const CServerPath& path = GetPathFromItem(m_contextMenuItem);
if (path.empty())
return CServerPath();
CInputDialog dlg;
if (!dlg.Create(this, _("Create directory"), _("Please enter the name of the directory which should be created:")))
return CServerPath();
CServerPath newPath = path;
// Append a long segment which does (most likely) not exist in the path and
// replace it with "New directory" later. This way we get the exact position of
// "New directory" and can preselect it in the dialog.
wxString tmpName = _T("25CF809E56B343b5A12D1F0466E3B37A49A9087FDCF8412AA9AF8D1E849D01CF");
if (newPath.AddSegment(tmpName))
{
wxString pathName = newPath.GetPath();
int pos = pathName.Find(tmpName);
wxASSERT(pos != -1);
wxString newName = _("New directory");
pathName.Replace(tmpName, newName);
dlg.SetValue(pathName);
dlg.SelectText(pos, pos + newName.Length());
}
if (dlg.ShowModal() != wxID_OK)
return CServerPath();
newPath = path;
if (!newPath.ChangePath(dlg.GetValue()))
{
wxBell();
return CServerPath();
}
m_pState->m_pCommandQueue->ProcessCommand(new CMkdirCommand(newPath));
return newPath;
}
void CRemoteTreeView::OnMenuRename(wxCommandEvent&)
{
if (!m_pState->IsRemoteIdle())
return;
if (!m_contextMenuItem)
return;
const CServerPath& path = GetPathFromItem(m_contextMenuItem);
if (path.empty())
return;
if (!path.HasParent())
return;
EditLabel(m_contextMenuItem);
}
// Create a new Directory
void CRemoteTreeView::OnMkdir(wxCommandEvent&)
{
CServerPath newpath = MenuMkdir();
CServerPath listed;
if (newpath.HasParent())
{
listed = newpath.GetParent();
m_pState->ChangeRemoteDir(listed);
}
CServerPath currentPath;
const wxTreeItemId selected = GetSelection();
if (selected)
currentPath = GetPathFromItem(selected);
if (!currentPath.empty() && currentPath != listed)
m_pState->ChangeRemoteDir(currentPath);
}
void CDriveView::OnInitialUpdate()
{
CTreeView::OnInitialUpdate();
//
// Initialize the image list.
//
m_ilDrives.Create (IDB_DRIVEIMAGES, 16, 1, RGB (255, 0, 255));
GetTreeCtrl ().SetImageList (&m_ilDrives, TVSIL_NORMAL);
//
// Populate the tree view with drive items.
//
AddDrives ();
//
// Show the folders on the current drive.
//
TCHAR szPath[MAX_PATH];
::GetCurrentDirectory (sizeof (szPath) / sizeof (TCHAR), szPath);
CString strPath = szPath;
strPath = strPath.Left (3);
HTREEITEM hItem = GetTreeCtrl ().GetNextItem (NULL, TVGN_ROOT);
while (hItem != NULL) {
if (GetTreeCtrl ().GetItemText (hItem) == strPath)
break;
hItem = GetTreeCtrl ().GetNextSiblingItem (hItem);
}
if (hItem != NULL) {
GetTreeCtrl ().Expand (hItem, TVE_EXPAND);
GetTreeCtrl ().Select (hItem, TVGN_CARET);
}
//
// Initialize the list view.
//
strPath = GetPathFromItem (GetTreeCtrl ().GetSelectedItem ());
GetDocument ()->UpdateAllViews (this, 0x5A, (CObject*) (LPCTSTR) strPath);
}
bool CRemoteTreeView::ListExpand(wxTreeItemId item)
{
const CServerPath path = GetPathFromItem(item);
wxASSERT(!path.empty());
if (path.empty())
return false;
CDirectoryListing listing;
if (m_pState->m_pEngine->CacheLookup(path, listing) == FZ_REPLY_OK)
RefreshItem(item, listing, false);
else
{
SetItemImages(item, true);
wxTreeItemId child = GetLastChild(item);
if (!child || GetItemText(child).empty())
return false;
}
return true;
}
void CRemoteTreeView::OnBeginLabelEdit(wxTreeEvent& event)
{
if (!m_pState->IsRemoteIdle())
{
event.Veto();
return;
}
const CServerPath& path = GetPathFromItem(event.GetItem());
if (path.empty())
{
event.Veto();
return;
}
if (!path.HasParent())
{
event.Veto();
return;
}
}
void CDriveView::OnItemExpanding(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
HTREEITEM hItem = pNMTreeView->itemNew.hItem;
CString string = GetPathFromItem (hItem);
*pResult = FALSE;
if (pNMTreeView->action == TVE_EXPAND) {
DeleteFirstChild (hItem);
if (AddDirectories (hItem, string) == 0)
*pResult = TRUE;
}
else { // pNMTreeView->action == TVE_COLLAPSE
DeleteAllChildren (hItem);
if (GetTreeCtrl ().GetParentItem (hItem) == NULL)
GetTreeCtrl ().InsertItem (_T (""), ILI_CLOSED_FOLDER,
ILI_CLOSED_FOLDER, hItem);
else
SetButtonState (hItem, string);
}
}
void CRemoteTreeView::OnSelectionChanged(wxTreeEvent& event)
{
if (event.GetItem() != m_ExpandAfterList)
m_ExpandAfterList = wxTreeItemId();
if (m_busy)
return;
if (!m_pState->IsRemoteIdle())
{
wxBell();
return;
}
wxTreeItemId item = event.GetItem();
if (!item)
return;
const CServerPath path = GetPathFromItem(item);
wxASSERT(!path.empty());
if (path.empty())
return;
m_pState->ChangeRemoteDir(path);
}
void CRemoteTreeView::OnMenuGeturl(wxCommandEvent&)
{
if (!m_contextMenuItem)
return;
const CServerPath& path = GetPathFromItem(m_contextMenuItem);
if (path.empty())
{
wxBell();
return;
}
const CServer *pServer = m_pState->GetServer();
if (!pServer)
{
wxBell();
return;
}
if (!wxTheClipboard->Open())
{
wxMessageBoxEx(_("Could not open clipboard"), _("Could not copy URLs"), wxICON_EXCLAMATION);
return;
}
wxString url = pServer->FormatServer(true);
url += path.GetPath();
// Poor mans URLencode
url.Replace(_T(" "), _T("%20"));
wxTheClipboard->SetData(new wxURLDataObject(url));
wxTheClipboard->Flush();
wxTheClipboard->Close();
}
void CRemoteTreeView::OnMenuChmod(wxCommandEvent&)
{
if (!m_pState->IsRemoteIdle())
return;
if (!m_contextMenuItem)
return;
const CServerPath& path = GetPathFromItem(m_contextMenuItem);
if (path.empty())
return;
const bool hasParent = path.HasParent();
CChmodDialog* pChmodDlg = new CChmodDialog;
// Get current permissions of directory
const wxString& name = GetItemText(m_contextMenuItem);
char permissions[9] = {0};
bool cached = false;
// Obviously item needs to have a parent directory...
if (hasParent)
{
const CServerPath& parentPath = path.GetParent();
CDirectoryListing listing;
// ... and it needs to be cached
cached = m_pState->m_pEngine->CacheLookup(parentPath, listing) == FZ_REPLY_OK;
if (cached)
{
for (unsigned int i = 0; i < listing.GetCount(); i++)
{
if (listing[i].name != name)
continue;
pChmodDlg->ConvertPermissions(*listing[i].permissions, permissions);
}
}
}
if (!pChmodDlg->Create(this, 0, 1, name, permissions))
{
pChmodDlg->Destroy();
pChmodDlg = 0;
return;
}
if (pChmodDlg->ShowModal() != wxID_OK)
{
pChmodDlg->Destroy();
pChmodDlg = 0;
return;
}
// State may have changed while chmod dialog was shown
if (!m_contextMenuItem || !m_pState->IsRemoteConnected() || !m_pState->IsRemoteIdle())
{
pChmodDlg->Destroy();
pChmodDlg = 0;
return;
}
const int applyType = pChmodDlg->GetApplyType();
CRecursiveOperation* pRecursiveOperation = m_pState->GetRecursiveOperationHandler();
if (cached) // Implies hasParent
{
// Change directory permissions
if (!applyType || applyType == 2)
{
wxString newPerms = pChmodDlg->GetPermissions(permissions, true);
m_pState->m_pCommandQueue->ProcessCommand(new CChmodCommand(path.GetParent(), name, newPerms));
}
if (pChmodDlg->Recursive())
// Start recursion
pRecursiveOperation->AddDirectoryToVisit(path, _T(""), CLocalPath());
}
else
{
if (hasParent)
pRecursiveOperation->AddDirectoryToVisitRestricted(path.GetParent(), name, pChmodDlg->Recursive());
else
pRecursiveOperation->AddDirectoryToVisitRestricted(path, _T(""), pChmodDlg->Recursive());
}
if (!cached || pChmodDlg->Recursive())
{
pRecursiveOperation->SetChmodDialog(pChmodDlg);
CServerPath currentPath;
const wxTreeItemId selected = GetSelection();
if (selected)
currentPath = GetPathFromItem(selected);
CFilterManager filter;
pRecursiveOperation->StartRecursiveOperation(CRecursiveOperation::recursive_chmod, hasParent ? path.GetParent() : path, filter.GetActiveFilters(false), !cached, currentPath);
}
else
{
pChmodDlg->Destroy();
const wxTreeItemId selected = GetSelection();
if (selected)
{
CServerPath currentPath = GetPathFromItem(selected);
m_pState->ChangeRemoteDir(currentPath);
}
}
}
void CRemoteTreeView::OnBeginDrag(wxTreeEvent& event)
{
// Drag could result in recursive operation, don't allow at this point
if (!m_pState->IsRemoteIdle()) {
wxBell();
return;
}
const wxTreeItemId& item = event.GetItem();
if (!item)
return;
CServerPath path = GetPathFromItem(item);
if (path.empty() || !path.HasParent())
return;
const CServerPath& parent = path.GetParent();
const wxString& lastSegment = path.GetLastSegment();
if (lastSegment.empty())
return;
wxDataObjectComposite object;
CServer const* pServer = m_pState->GetServer();
if (!pServer)
return;
CServer const server = *pServer;
CRemoteDataObject *pRemoteDataObject = new CRemoteDataObject(*pServer, parent);
pRemoteDataObject->AddFile(lastSegment, true, -1, false);
pRemoteDataObject->Finalize();
object.Add(pRemoteDataObject, true);
#if FZ3_USESHELLEXT
std::unique_ptr<CShellExtensionInterface> ext = CShellExtensionInterface::CreateInitialized();
if (ext) {
const wxString& file = ext->GetDragDirectory();
wxASSERT(!file.empty());
wxFileDataObject *pFileDataObject = new wxFileDataObject;
pFileDataObject->AddFile(file);
object.Add(pFileDataObject);
}
#endif
CDragDropManager* pDragDropManager = CDragDropManager::Init();
pDragDropManager->pDragSource = this;
pDragDropManager->server = *pServer;
pDragDropManager->remoteParent = parent;
wxDropSource source(this);
source.SetData(object);
int res = source.DoDragDrop();
pDragDropManager->Release();
if (res != wxDragCopy) {
return;
}
#if FZ3_USESHELLEXT
if (ext) {
if (!pRemoteDataObject->DidSendData()) {
pServer = m_pState->GetServer();
if (!pServer || !m_pState->IsRemoteIdle() || *pServer != server) {
wxBell();
return;
}
CLocalPath target(ext->GetTarget());
if (target.empty()) {
ext.reset(); // Release extension before the modal message box
wxMessageBoxEx(_("Could not determine the target of the Drag&Drop operation.\nEither the shell extension is not installed properly or you didn't drop the files into an Explorer window."));
return;
}
m_pState->DownloadDroppedFiles(pRemoteDataObject, target);
}
}
#endif
}
void CRemoteTreeView::ApplyFilters(bool resort)
{
std::list<struct _parents> parents;
const wxTreeItemId root = GetRootItem();
wxTreeItemIdValue cookie;
for (wxTreeItemId child = GetFirstChild(root, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
CFilterManager filter;
while (!parents.empty()) {
struct _parents parent = parents.back();
parents.pop_back();
if (resort) {
SortChildren(parent.item);
}
CDirectoryListing listing;
if (m_pState->m_pEngine->CacheLookup(parent.path, listing) == FZ_REPLY_OK)
RefreshItem(parent.item, listing, false);
else if (filter.HasActiveFilters()) {
for (wxTreeItemId child = GetFirstChild(parent.item, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
if (filter.FilenameFiltered(GetItemText(child), path.GetPath(), true, -1, false, 0, CDateTime())) {
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
if (!sel) {
Delete(child);
continue;
}
}
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
// The stuff below has already been done above in this one case
continue;
}
for (wxTreeItemId child = GetFirstChild(parent.item, cookie); child; child = GetNextSibling(child)) {
CServerPath path = GetPathFromItem(child);
if (path.empty())
continue;
struct _parents dir;
dir.item = child;
dir.path = path;
parents.push_back(dir);
}
}
}
void CRemoteTreeView::OnEndLabelEdit(wxTreeEvent& event)
{
if (event.IsEditCancelled())
{
event.Veto();
return;
}
if (!m_pState->IsRemoteIdle())
{
event.Veto();
return;
}
CItemData* const pData = (CItemData*)GetItemData(event.GetItem());
if (pData)
{
event.Veto();
return;
}
CServerPath old_path = GetPathFromItem(event.GetItem());
CServerPath parent = old_path.GetParent();
const wxString& oldName = GetItemText(event.GetItem());
const wxString& newName = event.GetLabel();
if (oldName == newName)
{
event.Veto();
return;
}
m_pState->m_pCommandQueue->ProcessCommand(new CRenameCommand(parent, oldName, parent, newName));
m_pState->ChangeRemoteDir(parent);
CServerPath currentPath;
const wxTreeItemId selected = GetSelection();
if (selected)
currentPath = GetPathFromItem(selected);
if (currentPath.empty())
return;
if (currentPath == old_path || currentPath.IsSubdirOf(old_path, false))
{
// Previously selected path was below renamed one, list the new one
std::list<wxString> subdirs;
while (currentPath != old_path)
{
if (!currentPath.HasParent())
{
// Abort just in case
return;
}
subdirs.push_front(currentPath.GetLastSegment());
currentPath = currentPath.GetParent();
}
currentPath = parent;
currentPath.AddSegment(newName);
for (std::list<wxString>::const_iterator iter = subdirs.begin(); iter != subdirs.end(); ++iter)
currentPath.AddSegment(*iter);
m_pState->ChangeRemoteDir(currentPath);
}
else if (currentPath != parent)
m_pState->ChangeRemoteDir(currentPath);
}