void CQueueViewFailed::OnRemoveSelected(wxCommandEvent& event)
{
#ifndef __WXMSW__
// GetNextItem is O(n) if nothing is selected, GetSelectedItemCount() is O(1)
if (!GetSelectedItemCount())
return;
#endif
std::list<CQueueItem*> selectedItems;
long item = -1;
while (true)
{
item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (item == -1)
break;
selectedItems.push_front(GetQueueItem(item));
SetItemState(item, 0, wxLIST_STATE_SELECTED);
}
CEditHandler* pEditHandler = CEditHandler::Get();
while (!selectedItems.empty())
{
CQueueItem* pItem = selectedItems.front();
selectedItems.pop_front();
CQueueItem* pTopLevelItem = pItem->GetTopLevelItem();
if (pItem->GetType() == QueueItemType_Server)
{
CServerItem* pServerItem = (CServerItem*)pItem;
if (pEditHandler && pEditHandler->GetFileCount(CEditHandler::remote, CEditHandler::upload_and_remove_failed, &pServerItem->GetServer()))
pEditHandler->RemoveAll(CEditHandler::upload_and_remove_failed, &pServerItem->GetServer());
}
else if (pItem->GetType() == QueueItemType_File)
{
CFileItem* pFileItem = (CFileItem*)pItem;
if (pFileItem->m_edit == CEditHandler::remote && pEditHandler)
{
wxFileName fn(pFileItem->GetLocalFile());
if (pFileItem->m_edit == CEditHandler::local)
{
enum CEditHandler::fileState state = pEditHandler->GetFileState(pFileItem->GetLocalFile());
if (state == CEditHandler::upload_and_remove_failed)
pEditHandler->Remove(pFileItem->GetLocalFile());
}
else
{
CServerItem* pServerItem = (CServerItem*)pFileItem->GetTopLevelItem();
enum CEditHandler::fileState state = pEditHandler->GetFileState(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer());
if (state == CEditHandler::upload_and_remove_failed)
pEditHandler->Remove(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer());
}
}
}
if (!pTopLevelItem->GetChild(1))
{
// Parent will get deleted
// If next selected item is parent, remove it from list
if (!selectedItems.empty() && selectedItems.front() == pTopLevelItem)
selectedItems.pop_front();
}
RemoveItem(pItem, true, false, false);
}
DisplayNumberQueuedFiles();
SaveSetItemCount(m_itemCount);
RefreshListOnly();
if (!m_itemCount && m_pQueue->GetQueueView()->GetItemCount())
m_pQueue->SetSelection(0);
}
void CQueueViewFailed::OnRequeueSelected(wxCommandEvent&)
{
#ifndef __WXMSW__
// GetNextItem is O(n) if nothing is selected, GetSelectedItemCount() is O(1)
if (!GetSelectedItemCount())
return;
#endif
bool failedToRequeueAll = false;
std::list<CQueueItem*> selectedItems;
long item = -1;
long skipTo = -1;
for (;;) {
item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (item == -1)
break;
SetItemState(item, 0, wxLIST_STATE_SELECTED);
if (item < skipTo)
continue;
CQueueItem* pItem = GetQueueItem(item);
if (pItem->GetType() == QueueItemType::Server)
skipTo = item + pItem->GetChildrenCount(true) + 1;
selectedItems.push_back(GetQueueItem(item));
}
if (selectedItems.empty())
return;
CQueueView* pQueueView = m_pQueue->GetQueueView();
while (!selectedItems.empty()) {
CQueueItem* pItem = selectedItems.front();
selectedItems.pop_front();
if (pItem->GetType() == QueueItemType::Server) {
CServerItem* pServerItem = (CServerItem*)pItem;
failedToRequeueAll |= !RequeueServerItem(pServerItem);
}
else {
CFileItem* pFileItem = (CFileItem*)pItem;
CServerItem* pOldServerItem = (CServerItem*)pItem->GetTopLevelItem();
CServerItem* pServerItem = pQueueView->CreateServerItem(pOldServerItem->GetServer());
RemoveItem(pItem, false, false, false);
failedToRequeueAll |= !RequeueFileItem(pFileItem, pServerItem);
if (!pServerItem->GetChildrenCount(false)) {
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
}
}
m_fileCountChanged = true;
pQueueView->CommitChanges();
if (pQueueView->IsActive())
pQueueView->AdvanceQueue(false);
DisplayNumberQueuedFiles();
SaveSetItemCount(m_itemCount);
RefreshListOnly();
if (!m_itemCount && m_pQueue->GetQueueView()->GetItemCount())
m_pQueue->SetSelection(0);
if (failedToRequeueAll)
wxMessageBoxEx(_("Not all items could be requeued for transfer."));
}
void CQueueViewFailed::OnRequeueSelected(wxCommandEvent& event)
{
#ifndef __WXMSW__
// GetNextItem is O(n) if nothing is selected, GetSelectedItemCount() is O(1)
if (!GetSelectedItemCount())
return;
#endif
bool failedToRequeueAll = false;
std::list<CQueueItem*> selectedItems;
long item = -1;
long skipTo = -1;
while (true)
{
item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (item == -1)
break;
SetItemState(item, 0, wxLIST_STATE_SELECTED);
if (item < skipTo)
continue;
CQueueItem* pItem = GetQueueItem(item);
if (pItem->GetType() == QueueItemType_Server)
skipTo = item + pItem->GetChildrenCount(true) + 1;
selectedItems.push_back(GetQueueItem(item));
}
if (selectedItems.empty())
return;
CQueueView* pQueueView = m_pQueue->GetQueueView();
while (!selectedItems.empty())
{
CQueueItem* pItem = selectedItems.front();
selectedItems.pop_front();
if (pItem->GetType() == QueueItemType_Server)
{
CServerItem* pOldServerItem = (CServerItem*)pItem;
CServerItem* pServerItem = pQueueView->CreateServerItem(pOldServerItem->GetServer());
unsigned int childrenCount = pOldServerItem->GetChildrenCount(false);
for (unsigned int i = 0; i < childrenCount; i++)
{
CFileItem* pFileItem = (CFileItem*)pItem->GetChild(i, false);
pFileItem->m_errorCount = 0;
pFileItem->m_statusMessage.Clear();
if (!pFileItem->Download() && !wxFileName::FileExists(pFileItem->GetLocalFile()))
{
failedToRequeueAll = true;
RemoveItem(pItem, true, false, false);
continue;
}
if (pFileItem->m_edit == CEditHandler::remote)
{
CEditHandler* pEditHandler = CEditHandler::Get();
if (!pEditHandler)
{
failedToRequeueAll = true;
delete pFileItem;
continue;
}
enum CEditHandler::fileState state = pEditHandler->GetFileState(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer());
if (state == CEditHandler::unknown)
{
wxASSERT(pFileItem->Download());
wxString file = pFileItem->GetRemoteFile();
if (!pEditHandler->AddFile(CEditHandler::remote, file, pFileItem->GetRemotePath(), pServerItem->GetServer()))
{
failedToRequeueAll = true;
delete pFileItem;
continue;
}
pFileItem->SetLocalFile(file);
}
else if (state == CEditHandler::upload_and_remove_failed)
{
wxASSERT(!pFileItem->Download());
if (!pEditHandler->UploadFile(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer(), true))
failedToRequeueAll = true;
delete pFileItem;
continue;
}
else
{
failedToRequeueAll = true;
delete pFileItem;
continue;
}
}
pFileItem->SetParent(pServerItem);
pQueueView->InsertItem(pServerItem, pFileItem);
}
m_fileCount -= childrenCount;
m_itemCount -= childrenCount + 1;
pOldServerItem->DetachChildren();
delete pOldServerItem;
std::vector<CServerItem*>::iterator iter;
for (iter = m_serverList.begin(); iter != m_serverList.end(); iter++)
{
if (*iter == pOldServerItem)
break;
}
if (iter != m_serverList.end())
m_serverList.erase(iter);
if (!pServerItem->GetChildrenCount(false))
{
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
}
else
{
CFileItem* pFileItem = (CFileItem*)pItem;
pFileItem->m_errorCount = 0;
pFileItem->m_statusMessage.Clear();
if (!pFileItem->Download() && !wxFileName::FileExists(pFileItem->GetLocalFile()))
{
failedToRequeueAll = true;
RemoveItem(pItem, true, false, false);
continue;
}
CServerItem* pOldServerItem = (CServerItem*)pItem->GetTopLevelItem();
CServerItem* pServerItem = pQueueView->CreateServerItem(pOldServerItem->GetServer());
RemoveItem(pItem, false, false, false);
if (pFileItem->m_edit == CEditHandler::remote)
{
CEditHandler* pEditHandler = CEditHandler::Get();
if (!pEditHandler)
{
if (!pServerItem->GetChildrenCount(false))
{
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
failedToRequeueAll = true;
delete pItem;
continue;
}
enum CEditHandler::fileState state = pEditHandler->GetFileState(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer());
if (state == CEditHandler::unknown)
{
wxASSERT(pFileItem->Download());
wxString file = pFileItem->GetRemoteFile();
if (!pEditHandler->AddFile(CEditHandler::remote, file, pFileItem->GetRemotePath(), pServerItem->GetServer()))
{
if (!pServerItem->GetChildrenCount(false))
{
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
failedToRequeueAll = true;
delete pItem;
continue;
}
pFileItem->SetLocalFile(file);
}
else if (state == CEditHandler::upload_and_remove_failed)
{
wxASSERT(!pFileItem->Download());
if (!pEditHandler->UploadFile(pFileItem->GetRemoteFile(), pFileItem->GetRemotePath(), pServerItem->GetServer(), true))
failedToRequeueAll = true;
if (!pServerItem->GetChildrenCount(false))
{
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
delete pItem;
continue;
}
else
{
if (!pServerItem->GetChildrenCount(false))
{
pQueueView->CommitChanges();
pQueueView->RemoveItem(pServerItem, true, true, true);
}
failedToRequeueAll = true;
delete pItem;
continue;
}
}
pItem->SetParent(pServerItem);
pQueueView->InsertItem(pServerItem, pItem);
}
}
m_fileCountChanged = true;
pQueueView->CommitChanges();
if (pQueueView->IsActive())
pQueueView->AdvanceQueue(false);
DisplayNumberQueuedFiles();
SaveSetItemCount(m_itemCount);
RefreshListOnly();
if (!m_itemCount && m_pQueue->GetQueueView()->GetItemCount())
m_pQueue->SetSelection(0);
if (failedToRequeueAll)
wxMessageBox(_("Not all items could be requeued for viewing/editing."));
}
bool CQueueStorage::Impl::SaveServer(const CServerItem& item)
{
bool kiosk_mode = COptions::Get()->GetOptionVal(OPTION_DEFAULT_KIOSKMODE) != 0;
const CServer& server = item.GetServer();
Bind(insertServerQuery_, server_table_column_names::host, server.GetHost());
Bind(insertServerQuery_, server_table_column_names::port, static_cast<int>(server.GetPort()));
Bind(insertServerQuery_, server_table_column_names::protocol, static_cast<int>(server.GetProtocol()));
Bind(insertServerQuery_, server_table_column_names::type, static_cast<int>(server.GetType()));
enum LogonType logonType = server.GetLogonType();
if (server.GetLogonType() != ANONYMOUS) {
Bind(insertServerQuery_, server_table_column_names::user, server.GetUser());
if (server.GetLogonType() == NORMAL || server.GetLogonType() == ACCOUNT) {
if (kiosk_mode) {
logonType = ASK;
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
else {
Bind(insertServerQuery_, server_table_column_names::password, server.GetPass());
if (server.GetLogonType() == ACCOUNT)
Bind(insertServerQuery_, server_table_column_names::account, server.GetAccount());
else
BindNull(insertServerQuery_, server_table_column_names::account);
}
}
else {
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
}
else {
BindNull(insertServerQuery_, server_table_column_names::user);
BindNull(insertServerQuery_, server_table_column_names::password);
BindNull(insertServerQuery_, server_table_column_names::account);
}
Bind(insertServerQuery_, server_table_column_names::logontype, static_cast<int>(logonType));
Bind(insertServerQuery_, server_table_column_names::timezone_offset, server.GetTimezoneOffset());
switch (server.GetPasvMode())
{
case MODE_PASSIVE:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("passive"));
break;
case MODE_ACTIVE:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("active"));
break;
default:
Bind(insertServerQuery_, server_table_column_names::transfer_mode, _T("default"));
break;
}
Bind(insertServerQuery_, server_table_column_names::max_connections, server.MaximumMultipleConnections());
switch (server.GetEncodingType())
{
default:
case ENCODING_AUTO:
Bind(insertServerQuery_, server_table_column_names::encoding, _T("Auto"));
break;
case ENCODING_UTF8:
Bind(insertServerQuery_, server_table_column_names::encoding, _T("UTF-8"));
break;
case ENCODING_CUSTOM:
Bind(insertServerQuery_, server_table_column_names::encoding, server.GetCustomEncoding());
break;
}
if (CServer::SupportsPostLoginCommands(server.GetProtocol())) {
const std::vector<wxString>& postLoginCommands = server.GetPostLoginCommands();
if (!postLoginCommands.empty()) {
wxString commands;
for (std::vector<wxString>::const_iterator iter = postLoginCommands.begin(); iter != postLoginCommands.end(); ++iter) {
if (!commands.empty())
commands += _T("\n");
commands += *iter;
}
Bind(insertServerQuery_, server_table_column_names::post_login_commands, commands);
}
else
BindNull(insertServerQuery_, server_table_column_names::post_login_commands);
}
else
BindNull(insertServerQuery_, server_table_column_names::post_login_commands);
Bind(insertServerQuery_, server_table_column_names::bypass_proxy, server.GetBypassProxy() ? 1 : 0);
if (!server.GetName().empty())
Bind(insertServerQuery_, server_table_column_names::name, server.GetName());
else
BindNull(insertServerQuery_, server_table_column_names::name);
int res;
do {
res = sqlite3_step(insertServerQuery_);
} while (res == SQLITE_BUSY);
sqlite3_reset(insertServerQuery_);
bool ret = res == SQLITE_DONE;
if (ret) {
sqlite3_int64 serverId = sqlite3_last_insert_rowid(db_);
Bind(insertFileQuery_, file_table_column_names::server, static_cast<int64_t>(serverId));
const std::vector<CQueueItem*>& children = item.GetChildren();
for (std::vector<CQueueItem*>::const_iterator it = children.begin() + item.GetRemovedAtFront(); it != children.end(); ++it) {
CQueueItem & childItem = **it;
if (childItem.GetType() == QueueItemType::File)
ret &= SaveFile(serverId, static_cast<CFileItem&>(childItem));
else if (childItem.GetType() == QueueItemType::Folder)
ret &= SaveDirectory(serverId, static_cast<CFolderItem&>(childItem));
}
}
return ret;
}
