sysutils/winscp
1
0
Fork 0
mirror of https://github.com/winscp/winscp.git synced 2026-10-24 02:28:55 +03:00
Code Activity
Files
0707234bbe4dcaee4e84958f1b331ded48ce8bb7
winscp/source/windows/TerminalManager.cpp

2493 lines
82 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------
#include <WinPCH.h>
#pragma hdrstop
#include "TerminalManager.h"
#include <Authenticate.h>
#include "CustomScpExplorer.h"
#include "NonVisual.h"
#include <Progress.h>
#include <WinApi.h>
#include <PuttyTools.h>
//---------------------------------------------------------------------------
TTerminalManager * TTerminalManager::FInstance = NULL;
//---------------------------------------------------------------------------
__fastcall TManagedTerminal::TManagedTerminal(TSessionData * SessionData,
TConfiguration * Configuration) :
TTerminal(SessionData, Configuration),
LocalBrowser(false), LocalExplorerState(NULL), RemoteExplorerState(NULL), OtherLocalExplorerState(NULL),
ReopenStart(), DirectoryLoaded(Now()), TerminalThread(NULL),
Disconnected(false), DisconnectedTemporarily(false), InitiateReconnectTimeout(false),
ThumbnailsSection(new TCriticalSection()), ThumbnailsEnabled(false), ThumbnailDownloadQueueItem(NULL),
ThumbnailVisibleResult(-1)
{
StateData = new TSessionData(L"");
StateData->Assign(SessionData);
StateData->LocalDirectory = StateData->LocalDirectoryExpanded;
}
//---------------------------------------------------------------------------
__fastcall TManagedTerminal::~TManagedTerminal()
{
delete StateData;
delete LocalExplorerState;
delete OtherLocalExplorerState;
delete RemoteExplorerState;
ReleaseThumbnails();
DebugAssert(ThumbnailDownloadQueueItem == NULL);
}
//---------------------------------------------------------------------------
void TManagedTerminal::StartLoadingDirectory()
{
// just in case it wasn't already (like when only reloading the list view on view style change)
DisableThumbnails();
AppLog(L"Starting loading directory");
TGuard Guard(ThumbnailsSection.get());
DebugAssert(TTerminalManager::Instance()->ActiveTerminal == this);
ReleaseThumbnails();
DebugAssert(ThumbnailsQueue.empty());
}
//---------------------------------------------------------------------------
void TManagedTerminal::DisableThumbnails()
{
TGuard Guard(ThumbnailsSection.get());
ThumbnailsEnabled = false;
ThumbnailVisibleResult = 0;
TRemoteThumbnailsQueue Queue;
Queue.swap(ThumbnailsQueue);
TRemoteThumbnailsQueue::iterator I = Queue.begin();
while (I != Queue.end())
{
delete I->File;
I++;
}
}
//---------------------------------------------------------------------------
void TManagedTerminal::PopThumbnailQueue()
{
delete ThumbnailsQueue.front().File;
ThumbnailsQueue.pop_front();
}
//---------------------------------------------------------------------------
void TManagedTerminal::ThumbnailVisible(int Index, const UnicodeString & FileName, bool Visible)
{
if (!ThumbnailsQueue.empty() &&
(ThumbnailsQueue.front().Index == Index) &&
(ThumbnailsQueue.front().File->FullFileName == FileName) && // should check ThumbnailSize too
// weren't thumbnails disabled meanwhile?
(ThumbnailVisibleResult < 0))
{
ThumbnailVisibleResult = Visible ? 1 : 0;
// Delete right now, so that if new visible thumbail request for the same file comes,
// before this negative visibility response is processed, the new request can get queued
if (!Visible)
{
PopThumbnailQueue();
TRemoteThumbnailsMap::iterator I = Thumbnails.find(Index);
if (DebugAlwaysTrue(I != Thumbnails.end()) &&
DebugAlwaysTrue(I->second.Thumbnail == NULL))
{
Thumbnails.erase(I);
}
}
}
else
{
ThumbnailVisibleResult = 0;
}
}
//---------------------------------------------------------------------------
void TManagedTerminal::ReleaseThumbnails()
{
TRemoteThumbnailsMap Map;
Thumbnails.swap(Map);
TRemoteThumbnailsMap::iterator I = Map.begin();
while (I != Map.end())
{
delete I->second.Thumbnail;
I++;
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
TTerminalManager * __fastcall TTerminalManager::Instance(bool ForceCreation)
{
if (!FInstance && ForceCreation)
{
FInstance = new TTerminalManager();
}
return FInstance;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DestroyInstance()
{
DebugAssert(FInstance);
SAFE_DESTROY(FInstance);
}
//---------------------------------------------------------------------------
__fastcall TTerminalManager::TTerminalManager() :
TTerminalList(Configuration)
{
FQueueSection = new TCriticalSection();
FActiveSession = NULL;
FTerminalWithFatalExceptionTimer = NULL;
FScpExplorer = NULL;
FDestroying = false;
FTerminalPendingAction = tpNull;
FDirectoryReadingStart = 0;
FAuthenticateForm = NULL;
FAuthenticating = 0;
FMainThread = GetCurrentThreadId();
FChangeSection.reset(new TCriticalSection());
FPendingConfigurationChange = 0;
FKeepAuthenticateForm = false;
FUpdating = 0;
FOpeningTerminal = NULL;
FReconnectingInactiveTerminal = NULL;
FApplicationsEvents.reset(new TApplicationEvents(Application));
FApplicationsEvents->OnException = ApplicationException;
FApplicationsEvents->OnShowHint = ApplicationShowHint;
FApplicationsEvents->OnMessage = ApplicationMessage;
FApplicationsEvents->OnModalBegin = ApplicationModalBegin;
FApplicationsEvents->OnModalEnd = ApplicationModalEnd;
DebugAssert(WinConfiguration->OnMasterPasswordPrompt == NULL);
WinConfiguration->OnMasterPasswordPrompt = MasterPasswordPrompt;
InitTaskbarButtonCreatedMessage();
DebugAssert(Configuration && !Configuration->OnChange);
Configuration->OnChange = ConfigurationChange;
FMaxSessions = WinConfiguration->MaxSessions;
FSessionList = new TStringList();
FQueues = new TList();
std::unique_ptr<TSessionData> DummyData(new TSessionData(L""));
FLocalTerminal = CreateTerminal(DummyData.get());
SetupTerminal(FLocalTerminal);
}
//---------------------------------------------------------------------------
__fastcall TTerminalManager::~TTerminalManager()
{
FreeAll();
DebugAssert(!ScpExplorer);
DebugAssert(Configuration->OnChange == ConfigurationChange);
Configuration->OnChange = NULL;
FApplicationsEvents.reset(NULL);
DebugAssert(WinConfiguration->OnMasterPasswordPrompt == MasterPasswordPrompt);
WinConfiguration->OnMasterPasswordPrompt = NULL;
delete FLocalTerminal;
delete FQueues;
delete FSessionList;
CloseAutheticateForm();
delete FQueueSection;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetQueueConfiguration(TTerminalQueue * Queue)
{
Queue->TransfersLimit = Configuration->QueueTransfersLimit;
Queue->KeepDoneItemsFor =
(GUIConfiguration->QueueKeepDoneItems ? GUIConfiguration->QueueKeepDoneItemsFor : 0);
}
//---------------------------------------------------------------------------
TTerminalQueue * __fastcall TTerminalManager::NewQueue(TTerminal * Terminal)
{
TTerminalQueue * Queue = new TTerminalQueue(Terminal, Configuration);
SetQueueConfiguration(Queue);
Queue->Enabled = WinConfiguration->EnableQueueByDefault;
Queue->OnQueryUser = TerminalQueryUser;
Queue->OnPromptUser = TerminalPromptUser;
Queue->OnShowExtendedException = TerminalShowExtendedException;
Queue->OnEvent = QueueEvent;
return Queue;
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::CreateManagedTerminal(TSessionData * Data)
{
TManagedTerminal * Result = new TManagedTerminal(Data, Configuration);
Result->LocalBrowser = Data->IsLocalBrowser;
return Result;
}
//---------------------------------------------------------------------------
TTerminal * __fastcall TTerminalManager::CreateTerminal(TSessionData * Data)
{
return CreateManagedTerminal(Data);
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::GetSession(int Index)
{
return DebugNotNull(dynamic_cast<TManagedTerminal *>(TTerminalList::Terminals[Index]));
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetupTerminal(TTerminal * Terminal)
{
Terminal->OnQueryUser = TerminalQueryUser;
Terminal->OnPromptUser = TerminalPromptUser;
Terminal->OnDisplayBanner = TerminalDisplayBanner;
Terminal->OnShowExtendedException = TerminalShowExtendedException;
Terminal->OnProgress = OperationProgress;
Terminal->OnFinished = OperationFinished;
Terminal->OnDeleteLocalFile = DeleteLocalFile;
Terminal->OnReadDirectoryProgress = TerminalReadDirectoryProgress;
Terminal->OnInformation = TerminalInformation;
Terminal->OnCustomCommand = TerminalCustomCommand;
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::DoNewSession(TSessionData * Data)
{
if (Count >= FMaxSessions)
{
UnicodeString Msg = FMTLOAD(TOO_MANY_SESSIONS, (Count));
if (MessageDialog(Msg, qtConfirmation, qaOK | qaCancel, HELP_TOO_MANY_SESSIONS) == qaCancel)
{
Abort();
}
FMaxSessions = FMaxSessions * 3 / 2; // increase limit before the next warning by 50%
}
TManagedTerminal * Session = DebugNotNull(dynamic_cast<TManagedTerminal *>(TTerminalList::NewTerminal(Data)));
try
{
FQueues->Add(NewQueue(Session));
SetupTerminal(Session);
}
catch(...)
{
if (Session != NULL)
{
FreeTerminal(Session);
}
throw;
}
return Session;
}
//---------------------------------------------------------------------------
TTerminal * __fastcall TTerminalManager::NewTerminal(TSessionData * Data)
{
TTerminal * Terminal = DoNewSession(Data);
DoSessionListChanged();
return Terminal;
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::NewLocalBrowser(const UnicodeString & LocalDirectory, const UnicodeString & OtherLocalDirectory)
{
std::unique_ptr<TSessionData> SessionData(new TSessionData(UnicodeString()));
SessionData->LocalDirectory = LocalDirectory;
SessionData->OtherLocalDirectory = OtherLocalDirectory;
TManagedTerminal * Result = NewManagedTerminal(SessionData.get());
// Is true already, when LocalDirectory and OtherLocalDirectory are set
Result->LocalBrowser = true;
return Result;
}
//---------------------------------------------------------------------------
void TTerminalManager::NewLocalSession(const UnicodeString & LocalDirectory, const UnicodeString & OtherLocalDirectory)
{
ActiveSession = NewLocalBrowser(LocalDirectory, OtherLocalDirectory);
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::NewManagedTerminal(TSessionData * Data)
{
return DebugNotNull(dynamic_cast<TManagedTerminal *>(NewTerminal(Data)));
}
//---------------------------------------------------------------------------
bool TTerminalManager::SupportedSession(TSessionData * Data)
{
bool Result;
// When main window exists already, ask it if it supports the session
// (we cannot decide based on configuration,
// as the user might have changed the interface in the preferences after the main window was created)
// If not, assume based on configuration.
if (ScpExplorer != NULL)
{
Result = ScpExplorer->SupportedSession(Data);
}
else
{
Result =
(WinConfiguration->Interface != ifExplorer) ||
!Data->IsLocalBrowser;
}
return Result;
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::NewSessions(TList * DataList)
{
TManagedTerminal * Result = NULL;
for (int Index = 0; Index < DataList->Count; Index++)
{
TSessionData * Data = reinterpret_cast<TSessionData *>(DataList->Items[Index]);
if (SupportedSession(Data))
{
TManagedTerminal * Session = DoNewSession(Data);
// When opening workspace/folder, keep the sessions open, even if they fail to connect.
// We cannot detect a folder here, so we "guess" it by a session set size.
// After all, no one will have a folder with a one session only (while a workspace with one session is likely).
// And when when opening a folder with a one session only, it's not that big problem, if we treat it the same way
// as when opening the session only.
// Also closing a workspace session will remove the session from the workspace.
// While closing a folder session won't remove the session from the folder.
Session->Permanent = Data->IsWorkspace || (DataList->Count > 1);
if (Result == NULL)
{
Result = Session;
}
else if (WinConfiguration->WorkspaceConnectAll)
{
Session->NextInactiveReconnect = IncSecond(Now(), 3);
AppLogFmt(L"Scheduling connect of session %s", (Data->SessionName));
}
}
}
DoSessionListChanged();
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::FreeActiveTerminal()
{
if (FTerminalPendingAction == tpNull)
{
DebugAssert(ActiveSession != NULL);
FreeTerminal(ActiveSession);
}
else
{
DebugAssert(FTerminalPendingAction == ::tpNone);
FTerminalPendingAction = tpFree;
}
}
//---------------------------------------------------------------------------
TTerminalThread * TTerminalManager::CreateTerminalThread(TTerminal * Terminal)
{
TTerminalThread * TerminalThread = new TTerminalThread(Terminal);
TerminalThread->OnIdle = MakeMethod<TNotifyEvent>(NULL, TerminalThreadIdle);
return TerminalThread;
}
//---------------------------------------------------------------------------
void TTerminalManager::ReconnectingTerminal(TManagedTerminal * ManagedTerminal)
{
// particularly when we are reconnecting RemoteDirectory of managed terminal
// hold the last used remote directory as opposite to session data, which holds
// the default remote directory.
// make sure the last used directory is used, but the default is preserved too
ManagedTerminal->OrigRemoteDirectory = ManagedTerminal->SessionData->RemoteDirectory;
ManagedTerminal->SessionData->RemoteDirectory = ManagedTerminal->StateData->RemoteDirectory;
if (ManagedTerminal->ReopenStart == TDateTime())
{
ManagedTerminal->ReopenStart = Now();
}
}
//---------------------------------------------------------------------------
void TTerminalManager::ReconnectedTerminal(TManagedTerminal * ManagedTerminal)
{
ManagedTerminal->SessionData->RemoteDirectory = ManagedTerminal->OrigRemoteDirectory;
if (ManagedTerminal->Active)
{
ManagedTerminal->ReopenStart = TDateTime();
ManagedTerminal->Permanent = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DoConnectTerminal(TTerminal * Terminal, bool Reopen, bool AdHoc)
{
TManagedTerminal * ManagedTerminal = dynamic_cast<TManagedTerminal *>(Terminal);
// it must be managed terminal, unless it is secondary terminal (of managed terminal)
DebugAssert((ManagedTerminal != NULL) || (dynamic_cast<TSecondaryTerminal *>(Terminal) != NULL));
try
{
TValueRestorer<TTerminal *> OpeningTerminalRestorer(FOpeningTerminal, Terminal);
TTerminalThread * TerminalThread;
bool ReconnectingInactiveTerminal = (Terminal == FReconnectingInactiveTerminal);
if (ReconnectingInactiveTerminal)
{
DebugAssert(Terminal == ActiveTerminal);
TerminalThread = ManagedTerminal->TerminalThread;
FReconnectingInactiveTerminal = NULL;
}
else
{
TerminalThread = CreateTerminalThread(Terminal);
}
try
{
TerminalThread->AllowAbandon = (Terminal == ActiveTerminal);
if (ReconnectingInactiveTerminal && DebugAlwaysTrue(Reopen))
{
TerminalThread->ContinueTerminalReopenInteractive();
}
else
{
if (ManagedTerminal != NULL)
{
ReconnectingTerminal(ManagedTerminal);
ManagedTerminal->Disconnected = false;
ManagedTerminal->DisconnectedTemporarily = false;
ManagedTerminal->DisconnectMessage = EmptyStr;
ManagedTerminal->InitiateReconnectTimeout = false;
DebugAssert(ManagedTerminal->TerminalThread == NULL);
ManagedTerminal->TerminalThread = TerminalThread;
}
if (Reopen)
{
TerminalThread->TerminalReopen();
}
else
{
TerminalThread->TerminalOpen();
}
}
}
__finally
{
TerminalThread->OnIdle = NULL;
if (!TerminalThread->Release())
{
if (!AdHoc && (DebugAlwaysTrue(Terminal == ActiveTerminal)))
{
// terminal was abandoned, must create a new one to replace it
Terminal = ManagedTerminal = CreateManagedTerminal(new TSessionData(L""));
SetupTerminal(Terminal);
OwnsObjects = false;
Items[ActiveSessionIndex] = Terminal;
OwnsObjects = true;
FActiveSession = ManagedTerminal;
// Can be NULL, when opening the first session from command-line
if (FScpExplorer != NULL)
{
FScpExplorer->ReplaceTerminal(ManagedTerminal);
}
}
// Now we do not have any reference to an abandoned terminal, so we can safely allow the thread
// to complete its task and destroy the terminal afterwards.
TerminalThread->Terminate();
// When abandoning cancelled terminal, DoInformation(Phase = 0) usually does not make it to TerminalInformation handler.
if (FAuthenticating > 0)
{
FKeepAuthenticateForm = false;
AuthenticatingDone();
}
}
else
{
if (ManagedTerminal != NULL)
{
ManagedTerminal->TerminalThread = NULL;
}
}
}
}
__finally
{
if (ManagedTerminal != NULL)
{
ReconnectedTerminal(ManagedTerminal);
}
if (ScpExplorer != NULL)
{
// Particularly to enable remote panel, now that FOpeningTerminal is cleared
ScpExplorer->UpdateControls();
}
}
if (DebugAlwaysTrue(Terminal->Active) && !Reopen && GUIConfiguration->QueueBootstrap)
{
FindQueueForTerminal(Terminal)->AddItem(new TBootstrapQueueItem());
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::CloseAutheticateForm()
{
SAFE_DESTROY(FAuthenticateForm);
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::ConnectTerminal(TTerminal * Terminal)
{
bool Result = true;
// were it an active terminal, it would allow abandoning, what this API cannot deal with
DebugAssert(Terminal != ActiveTerminal);
try
{
DoConnectTerminal(Terminal, false, false);
}
catch (Exception & E)
{
ShowExtendedExceptionEx(Terminal, &E, false);
Result = false;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalThreadIdle(void * /*Data*/, TObject * /*Sender*/)
{
Application->ProcessMessages();
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::ConnectActiveTerminalImpl(bool Reopen)
{
if (ActiveTerminal != FReconnectingInactiveTerminal)
{
ActiveTerminal->CollectUsage();
}
TTerminalPendingAction Action;
bool Result;
do
{
Action = tpNull;
Result = false;
try
{
DebugAssert(ActiveTerminal != NULL);
DoConnectTerminal(ActiveTerminal, Reopen, false);
if (ScpExplorer)
{
DebugAssert(ActiveTerminal->Status == ssOpened);
SessionReady();
}
WinConfiguration->ClearTemporaryLoginData();
Result = true;
}
catch (Exception & E)
{
DebugAssert(FTerminalPendingAction == tpNull);
FTerminalPendingAction = ::tpNone;
try
{
DebugAssert(ActiveTerminal != NULL);
ActiveTerminal->ShowExtendedException(&E);
Action = FTerminalPendingAction;
}
__finally
{
FTerminalPendingAction = tpNull;
}
}
}
while (Action == tpReconnect);
if (Action == tpFree)
{
DisconnectActiveTerminalIfPermanentFreeOtherwise(EmptyStr);
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DisconnectActiveTerminalIfPermanentFreeOtherwise(const UnicodeString & Message)
{
if (ActiveTerminal->Permanent)
{
DisconnectActiveTerminal(Message);
}
else
{
FreeActiveTerminal();
}
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::ConnectActiveTerminal()
{
// add only stored sessions to the jump list,
// ad-hoc session cannot be reproduced from just a session name
if (StoredSessions->FindSame(ActiveTerminal->SessionData) != NULL)
{
try
{
WinConfiguration->AddSessionToJumpList(ActiveTerminal->SessionData->SessionName);
}
catch (Exception & E)
{
ShowExtendedException(&E);
}
}
FAuthenticationCancelled = false;
bool Result = ConnectActiveTerminalImpl(false);
UnicodeString DateStamp = StandardDatestamp();
if (Result)
{
if (Configuration->Usage->Get(L"OpenedSessionsFailedLastDate") == DateStamp)
{
Configuration->Usage->Inc(L"OpenedSessionsFailedRecovered");
}
}
else
{
Configuration->Usage->Inc(L"OpenedSessionsFailed");
Configuration->Usage->Set(L"OpenedSessionsFailedLastDate", DateStamp);
if (FAuthenticationCancelled)
{
Configuration->Usage->Inc(L"OpenedSessionsFailedAfterCancel");
}
}
if (Result && WinConfiguration->AutoOpenInPutty && CanOpenInPutty())
{
try
{
OpenInPutty();
}
catch(Exception & E)
{
ShowExtendedExceptionEx(NULL, &E, false);
}
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DisconnectActiveTerminal(const UnicodeString & Message)
{
DebugAssert(ActiveTerminal);
if (ActiveTerminal->Active)
{
ActiveTerminal->Close();
}
int Index = IndexOf(ActiveTerminal);
TTerminalQueue * OldQueue;
TTerminalQueue * NewQueue;
OldQueue = reinterpret_cast<TTerminalQueue *>(FQueues->Items[Index]);
NewQueue = this->NewQueue(ActiveTerminal);
FQueues->Items[Index] = NewQueue;
if (ScpExplorer != NULL)
{
ScpExplorer->Queue = NewQueue;
}
delete OldQueue;
ActiveTerminal->Disconnected = true;
ActiveTerminal->DisconnectMessage = Message;
ActiveTerminal->InitiateReconnectTimeout = !Message.IsEmpty() && GUIConfiguration->SessionReopenAutoIdleOn;
ActiveTerminal->DisableThumbnails();
if (ScpExplorer != NULL)
{
SessionReady(); // in case it was never connected
ScpExplorer->TerminalDisconnected();
}
// disconnecting duplidate session removes need to distinguish the only connected session with short path
DoSessionListChanged();
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ReconnectActiveTerminal()
{
DebugAssert(ActiveTerminal);
if ((ScpExplorer != NULL) &&
(ActiveTerminal != FReconnectingInactiveTerminal) &&
(ScpExplorer->Terminal == ActiveTerminal))
{
ScpExplorer->UpdateSession(ActiveTerminal);
}
try
{
if (FTerminalPendingAction == tpNull)
{
ConnectActiveTerminalImpl(true);
}
else
{
FTerminalPendingAction = tpReconnect;
}
}
catch(...)
{
DisconnectActiveTerminal();
throw;
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::FreeAll()
{
FDestroying = true;
try
{
while (Count)
{
FreeTerminal(Sessions[0]);
}
}
__finally
{
FDestroying = false;
}
}
//---------------------------------------------------------------------------
void TTerminalManager::FreeTerminalCleanup(TTerminal * ATerminal, bool IsActiveSession)
{
int Index = IndexOf(ATerminal);
Extract(ATerminal);
TTerminalQueue * Queue;
Queue = reinterpret_cast<TTerminalQueue *>(FQueues->Items[Index]);
FQueues->Delete(Index);
if (IsActiveSession)
{
TManagedTerminal * NewActiveTerminal;
bool LastTerminalClosed = false;
if (FDestroying)
{
NewActiveTerminal = NULL;
}
else
{
if (Count > 0)
{
NewActiveTerminal = Sessions[Index < Count ? Index : Index - 1];
if (!NewActiveTerminal->Active && !NewActiveTerminal->Disconnected)
{
NewActiveTerminal->Disconnected = true;
NewActiveTerminal->DisconnectedTemporarily = true;
NewActiveTerminal->DisconnectMessage = EmptyStr;
NewActiveTerminal->InitiateReconnectTimeout = false;
}
}
else
{
NewActiveTerminal = NULL;
LastTerminalClosed = true;
if (ScpExplorer != NULL)
{
TAutoNestingCounter UpdatingCounter(FUpdating); // prevent tab flicker
NewActiveTerminal = ScpExplorer->GetReplacementForLastSession();
}
}
}
DoSetActiveSession(NewActiveTerminal, false, LastTerminalClosed);
}
// only now all references to/from queue (particularly events to explorer) are cleared
delete Queue;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::FreeTerminal(TTerminal * Terminal)
{
TTerminal * ATerminal = Terminal;
bool IsActiveSession = ((ActiveSession != NULL) && (Terminal == ActiveSession));
try
{
if (!IsActiveSession)
{
// For active session, done by DoSetActiveSession below.
// For inactive session, needs to be done here before potentially abandoning the session.
SaveTerminal(Terminal);
}
TManagedTerminal * ManagedSession = DebugNotNull(dynamic_cast<TManagedTerminal *>(Terminal));
// we want the Login dialog to open on auto-workspace name,
// as set in TCustomScpExplorerForm::FormClose
if ((!FDestroying || !WinConfiguration->AutoSaveWorkspace) && !ManagedSession->LocalBrowser)
{
if (StoredSessions->FindSame(Terminal->SessionData) != NULL)
{
WinConfiguration->LastStoredSession = Terminal->SessionData->Name;
}
}
if (ScpExplorer != NULL)
{
ScpExplorer->TerminalRemoved(Terminal);
}
if (ManagedSession == FReconnectingInactiveTerminal)
{
DebugAssert(!IsActiveSession);
AppLog(L"Cancelling background reconnect before closing session");
TTerminalThread * TerminalThread = DebugNotNull(ManagedSession->TerminalThread);
DebugAssert(TerminalThread->AllowAbandon);
TerminalThread->Cancel();
while (!TerminalThread->Abandoned())
{
Sleep(50);
}
if (!TerminalThread->Release())
{
AppLog(L"Abandoned background reconnect");
TerminalThread->Terminate();
Terminal = NULL;
}
else
{
AppLog(L"Background reconnect stopped");
ManagedSession->TerminalThread = NULL;
}
FReconnectingInactiveTerminal = NULL;
}
else if (Terminal->Active)
{
Terminal->Close();
}
}
__finally
{
FreeTerminalCleanup(ATerminal, IsActiveSession);
delete Terminal; // noop if abandoned
DoSessionListChanged();
}
}
//---------------------------------------------------------------------------
void TTerminalManager::UpdateScpExplorer(TManagedTerminal * Session, TTerminalQueue * Queue)
{
FScpExplorer->ManagedSession = Session;
FScpExplorer->Queue = Queue;
}
//---------------------------------------------------------------------------
void TTerminalManager::UpdateScpExplorer()
{
UpdateScpExplorer(ActiveSession, ActiveQueue);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetScpExplorer(TCustomScpExplorerForm * value)
{
if (ScpExplorer != value)
{
// changing explorer is not supported yet
DebugAssert(!ScpExplorer || !value);
FScpExplorer = value;
if (FScpExplorer)
{
UpdateScpExplorer();
UpdateTaskbarList();
}
}
}
//---------------------------------------------------------------------------
TManagedTerminal * TTerminalManager::GetActiveTerminal()
{
TManagedTerminal * Result;
if ((ActiveSession != NULL) && !ActiveSession->LocalBrowser)
{
Result = ActiveSession;
}
else
{
Result = NULL;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetActiveSession(TManagedTerminal * value)
{
DoSetActiveSession(value, false, false);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetActiveTerminalWithAutoReconnect(TManagedTerminal * value)
{
DoSetActiveSession(value, true, false);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DoSetActiveSession(TManagedTerminal * value, bool AutoReconnect, bool LastTerminalClosed)
{
if (ActiveSession != value)
{
if (NonVisualDataModule != NULL)
{
NonVisualDataModule->StartBusy();
}
void * Focus = NULL;
try
{
// here used to be call to TCustomScpExporer::UpdateSessionData (now UpdateSession)
// but it seems to be duplicate to call from TCustomScpExporer::SessionChanging
bool ReconnectingInactiveTerminal =
(value != nullptr) &&
(FReconnectingInactiveTerminal == value) &&
(ScpExplorer != NULL) &&
DebugAlwaysTrue(FReconnectingInactiveTerminal->TerminalThread != NULL);
TManagedTerminal * PActiveSession = ActiveSession;
FActiveSession = value;
if (ScpExplorer)
{
Focus = ScpExplorer->SaveFocus();
if ((ActiveSession != NULL) &&
!ReconnectingInactiveTerminal &&
((ActiveSession->Status == ssOpened) || ActiveSession->Disconnected || ActiveSession->LocalBrowser))
{
SessionReady();
}
else
{
UpdateScpExplorer(NULL, NULL);
}
}
UpdateAppTitle();
if (PActiveSession != NULL)
{
PActiveSession->DisableThumbnails();
if (PActiveSession->DisconnectedTemporarily && DebugAlwaysTrue(PActiveSession->Disconnected))
{
PActiveSession->Disconnected = false;
PActiveSession->DisconnectedTemporarily = false;
}
if (!PActiveSession->Active)
{
SaveTerminal(PActiveSession);
}
}
if (ActiveSession != NULL)
{
if (ReconnectingInactiveTerminal)
{
DebugAssert(FTerminalPendingAction == tpNull); // the only assumed and tested scenario
ReconnectActiveTerminal();
}
else if (!ActiveSession->Active &&
!ActiveSession->InactiveTerminationMessage.IsEmpty() &&
DebugAlwaysTrue(!ActiveSession->LocalBrowser))
{
UnicodeString Message = ActiveSession->InactiveTerminationMessage;
ActiveSession->InactiveTerminationMessage = EmptyStr;
if (AutoReconnect || GUIConfiguration->SessionReopenAutoInactive)
{
ReconnectActiveTerminal();
}
else
{
// finally show pending terminal message,
// this gives user also possibility to reconnect
std::unique_ptr<ESshFatal> E(new ESshFatal(NULL, Message));
E->InactiveTerminationMessage = true;
ActiveTerminal->ShowExtendedException(E.get());
}
}
// LastTerminalClosed is true only for a replacement local session,
// and it should never happen that it fails to be activated
if (LastTerminalClosed && DebugAlwaysFalse(value != ActiveSession))
{
LastTerminalClosed = false; // just in case
}
}
else
{
LastTerminalClosed = true;
}
if (LastTerminalClosed && !Updating && (ScpExplorer != NULL))
{
ScpExplorer->LastTerminalClosed();
}
if ((ActiveSession != NULL) &&
!ActiveSession->Active && !ActiveSession->Disconnected && !ActiveSession->LocalBrowser)
{
DebugAssert(ActiveSession->InactiveTerminationMessage.IsEmpty());
ConnectActiveTerminal();
}
}
__finally
{
if (NonVisualDataModule != NULL)
{
NonVisualDataModule->EndBusy();
}
if ((Focus != NULL) && DebugAlwaysTrue(ScpExplorer != NULL))
{
ScpExplorer->RestoreFocus(Focus);
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::QueueStatusUpdated()
{
UpdateAppTitle();
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::ShouldDisplayQueueStatusOnAppTitle()
{
bool Result = IsMainFormMinimized();
if (!Result && (ScpExplorer != NULL))
{
HWND Window = GetActiveWindow();
Window = GetAncestor(Window, GA_ROOTOWNER);
Result = (ScpExplorer->Handle != Window);
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TTerminalManager::FormatFormCaptionWithSession(TCustomForm * Form, const UnicodeString & Caption)
{
return FormatFormCaption(Form, Caption, GetActiveSessionAppTitle());
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TTerminalManager::GetAppProgressTitle()
{
UnicodeString Result;
UnicodeString QueueProgressTitle;
UnicodeString ProgressTitle = !FProgressTitle.IsEmpty() ? FProgressTitle : ScpExplorer->GetProgressTitle();
if (!FForegroundProgressTitle.IsEmpty())
{
Result = FForegroundProgressTitle;
}
else if (!ProgressTitle.IsEmpty() && !ForegroundTask())
{
Result = ProgressTitle;
}
else if (ShouldDisplayQueueStatusOnAppTitle() &&
!(QueueProgressTitle = ScpExplorer->GetQueueProgressTitle()).IsEmpty())
{
Result = QueueProgressTitle;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::UpdateAppTitle()
{
if (ScpExplorer)
{
TForm * MainForm = GetMainForm();
if (MainForm != ScpExplorer)
{
// triggers caption update for some forms
MainForm->Perform(WM_MANAGES_CAPTION, 0, NativeInt(0));
}
UnicodeString NewTitle = FormatMainFormCaption(GetActiveSessionAppTitle());
UnicodeString ProgressTitle = GetAppProgressTitle();
if (!ProgressTitle.IsEmpty())
{
NewTitle = ProgressTitle + TitleSeparator + NewTitle;
}
else if (ScpExplorer != NULL)
{
UnicodeString Path = ScpExplorer->PathForCaption();
if (!Path.IsEmpty())
{
NewTitle = Path + TitleSeparator + NewTitle;
}
}
// Not updating MainForm here, as for all other possible main forms, this code is actually not what we want.
// And they all update their title on their own (some using GetAppProgressTitle()).
ScpExplorer->Caption = NewTitle;
ScpExplorer->ApplicationTitleChanged();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SaveTerminal(TTerminal * Terminal)
{
TSessionData * Data = StoredSessions->FindSame(Terminal->SessionData);
if (Data != NULL)
{
TManagedTerminal * ManagedTerminal = dynamic_cast<TManagedTerminal *>(Terminal);
DebugAssert(ManagedTerminal != NULL);
bool Changed = false;
if (Terminal->SessionData->UpdateDirectories)
{
Data->CopyDirectoriesStateData(ManagedTerminal->StateData);
Changed = true;
}
if (Changed)
{
// modified only, implicit
StoredSessions->Save(false, false);
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::HandleException(Exception * E)
{
// can be null for example when exception is thrown on login dialog
if (ActiveTerminal != NULL)
{
ActiveTerminal->ShowExtendedException(E);
}
else
{
ShowExtendedException(E);
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ApplicationException(TObject * /*Sender*/,
Exception * E)
{
HandleException(E);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ApplicationShowHint(UnicodeString & HintStr,
bool & /*CanShow*/, THintInfo & HintInfo)
{
HintInfo.HintData = HintInfo.HintControl;
if (HasLabelHintPopup(HintInfo.HintControl, HintStr))
{
// Hack for transfer setting labels.
// Should be converted to something like HintLabel()
HintInfo.HideTimeout = 100000; // "almost" never
}
else if (dynamic_cast<TProgressBar *>(HintInfo.HintControl) != NULL)
{
// Hint is forcibly hidden in TProgressForm::FormHide
HintInfo.HideTimeout = 100000; // "almost" never
HintInfo.ReshowTimeout = 500; // updated each 0.5s
}
else
{
int HintMaxWidth = 300;
TControl * ScaleControl = HintInfo.HintControl;
if (DebugAlwaysFalse(HintInfo.HintControl == NULL) ||
(GetParentForm(HintInfo.HintControl) == NULL))
{
ScaleControl = ScpExplorer;
}
HintMaxWidth = ScaleByTextHeight(ScaleControl, HintMaxWidth);
HintInfo.HintMaxWidth = HintMaxWidth;
}
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::HandleMouseWheel(WPARAM WParam, LPARAM LParam)
{
// WORKAROUND This is no longer necessary on Windows 10 (except for WM_WANTS_MOUSEWHEEL_INACTIVE part)
bool Result = false;
if (Application->Active)
{
TPoint Point(LOWORD(LParam), HIWORD(LParam));
TWinControl * Control = FindVCLWindow(Point);
if (Control != NULL)
{
TCustomForm * Form = GetParentForm(Control);
// Only case we expect the parent form to be NULL is on the Find/Replace dialog,
// which is owned by VCL's internal TRedirectorWindow.
DebugAssert((Form != NULL) || (Control->ClassName() == L"TRedirectorWindow"));
if (Form != NULL)
{
// Send it only to windows we tested it with.
// Though we should sooner or later remove this test and pass it to all our windows.
if (Form->Active && (Form->Perform(WM_WANTS_MOUSEWHEEL, 0, NativeInt(0)) == 1))
{
SendMessage(Control->Handle, WM_MOUSEWHEEL, WParam, LParam);
Result = true;
}
else if (!Form->Active && (Form->Perform(WM_WANTS_MOUSEWHEEL_INACTIVE, 0, NativeInt(0)) == 1))
{
TWinControl * Control2;
// FindVCLWindow stops on window level, when the window is not active? or when there's a modal window over it?
// (but in any case, when we have operation running on top of Synchronization checklist).
// WORKAROUND: The while loop does what AllLevels parameter of ControlAtPos should do, but it's broken.
// Based on (now removed) Embarcadero QC 82143.
while ((Control2 = dynamic_cast<TWinControl *>(Control->ControlAtPos(Control->ScreenToClient(Point), false, true))) != NULL)
{
Control = Control2;
}
SendMessage(Control->Handle, WM_MOUSEWHEEL, WParam, LParam);
Result = true;
}
}
}
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ApplicationMessage(TMsg & Msg, bool & Handled)
{
if (Msg.message == FTaskbarButtonCreatedMessage)
{
CreateTaskbarList();
}
if (Msg.message == WM_MOUSEWHEEL)
{
Handled = HandleMouseWheel(Msg.wParam, Msg.lParam);
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ApplicationModalBegin(TObject * /*Sender*/)
{
InterfaceStartDontMeasure();
NonVisualDataModule->StartBusy();
if (ScpExplorer != NULL)
{
ScpExplorer->SuspendWindowLock();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ApplicationModalEnd(TObject * /*Sender*/)
{
NonVisualDataModule->EndBusy();
if (ScpExplorer != NULL)
{
ScpExplorer->ResumeWindowLock();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::InitTaskbarButtonCreatedMessage()
{
// XE6 VCL already handles TaskbarButtonCreated, but does not call ChangeWindowMessageFilterEx.
// So we keep our implementation.
// See also https://stackoverflow.com/q/14614823/850848#14618587
// See also VCL's TTaskbar class
FTaskbarButtonCreatedMessage = RegisterWindowMessage(L"TaskbarButtonCreated");
HINSTANCE User32Library = LoadLibrary(L"user32.dll");
ChangeWindowMessageFilterExProc ChangeWindowMessageFilterEx =
reinterpret_cast<ChangeWindowMessageFilterExProc>(GetProcAddress(User32Library, "ChangeWindowMessageFilterEx"));
if (ChangeWindowMessageFilterEx != NULL)
{
// without this we won't get TaskbarButtonCreated, when app is running elevated
ChangeWindowMessageFilterEx(
Application->Handle, FTaskbarButtonCreatedMessage, MSGFLT_ALLOW, NULL);
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::CreateTaskbarList()
{
if (FTaskbarList.TryCreate(CLSID_TaskbarList, CLSCTX_ALL))
{
if (ScpExplorer != NULL)
{
UpdateTaskbarList();
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::UpdateTaskbarList()
{
ScpExplorer->UpdateTaskbarList(FTaskbarList.Get());
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DeleteLocalFile(const UnicodeString FileName, bool Alternative, int & Deleted)
{
Deleted = RecursiveDeleteFileChecked(FileName, (WinConfiguration->DeleteToRecycleBin != Alternative));
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalQueryUser(TObject * Sender,
const UnicodeString Query, TStrings * MoreMessages, unsigned int Answers,
const TQueryParams * Params, unsigned int & Answer, TQueryType Type, void * /*Arg*/)
{
TTerminal * Terminal = DebugNotNull(dynamic_cast<TTerminal *>(Sender));
UnicodeString HelpKeyword;
TMessageParams MessageParams(Params);
UnicodeString AQuery = Query;
if (Params != NULL)
{
HelpKeyword = Params->HelpKeyword;
if (FLAGSET(Params->Params, qpFatalAbort))
{
AQuery = FMTLOAD(WARN_FATAL_ERROR, (AQuery));
if (!MessageParams.TimerMessage.IsEmpty())
{
MessageParams.TimerMessage = FMTLOAD(WARN_FATAL_ERROR, (MessageParams.TimerMessage));
}
}
}
if (ScpExplorer)
{
Answer = ScpExplorer->MoreMessageDialog(AQuery, MoreMessages, Type, Answers,
HelpKeyword, &MessageParams, Terminal);
}
else
{
Answer = MoreMessageDialog(AQuery, MoreMessages, Type, Answers, HelpKeyword,
&MessageParams);
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::AuthenticateFormCancel(TObject * Sender)
{
TAuthenticateForm * Form = dynamic_cast<TAuthenticateForm *>(Sender);
DebugAssert(Form != NULL);
TManagedTerminal * ManagedTerminal = dynamic_cast<TManagedTerminal *>(Form->Terminal);
// will be null e.g. for background transfers
if (ManagedTerminal != NULL)
{
TTerminalThread * TerminalThread = ManagedTerminal->TerminalThread;
// can be NULL for reconnects from transfers
if ((TerminalThread != NULL) && !TerminalThread->Cancelling)
{
Form->Log(LoadStr(AUTH_CANCELLING));
TerminalThread->Cancel();
}
}
FAuthenticationCancelled = true;
}
//---------------------------------------------------------------------------
TAuthenticateForm * __fastcall TTerminalManager::MakeAuthenticateForm(
TTerminal * Terminal)
{
TAuthenticateForm * Dialog = SafeFormCreate<TAuthenticateForm>();
Dialog->Init(Terminal);
DebugAssert(Dialog->OnCancel == NULL);
Dialog->OnCancel = AuthenticateFormCancel;
return Dialog;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::FileNameInputDialogInitializeRenameBaseName(
TObject * /*Sender*/, TInputDialogData * Data)
{
EditSelectBaseName(Data->Edit->Handle);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalPromptUser(
TTerminal * Terminal, TPromptKind Kind, UnicodeString Name, UnicodeString Instructions,
TStrings * Prompts, TStrings * Results, bool & Result, void * /*Arg*/)
{
if (((Kind == pkPrompt) || (Kind == pkFileName)) && (FAuthenticateForm == NULL) &&
(Terminal->Status != ssOpening))
{
DebugAssert(Instructions.IsEmpty());
DebugAssert(Prompts->Count == 1);
DebugAssert(FLAGSET(int(Prompts->Objects[0]), pupEcho));
UnicodeString AResult = Results->Strings[0];
TInputDialogInitialize InputDialogInitialize = NULL;
if ((Kind == pkFileName) && !WinConfiguration->RenameWholeName)
{
InputDialogInitialize = FileNameInputDialogInitializeRenameBaseName;
}
Result = InputDialog(Name, Prompts->Strings[0], AResult, L"", NULL, false, InputDialogInitialize);
if (Result)
{
Results->Strings[0] = AResult;
}
}
else
{
TAuthenticateForm * AuthenticateForm = FAuthenticateForm;
if (AuthenticateForm == NULL)
{
AuthenticateForm = MakeAuthenticateForm(Terminal);
}
try
{
Result = AuthenticateForm->PromptUser(Kind, Name, Instructions, Prompts, Results,
(FAuthenticateForm != NULL), Terminal->StoredCredentialsTried);
}
__finally
{
if (FAuthenticateForm == NULL)
{
delete AuthenticateForm;
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalDisplayBanner(
TTerminal * Terminal, UnicodeString DebugUsedArg(SessionName),
const UnicodeString & Banner, bool & NeverShowAgain, int Options, unsigned int & Params)
{
DebugAssert(FAuthenticateForm != NULL);
TAuthenticateForm * AuthenticateForm = FAuthenticateForm;
if (AuthenticateForm == NULL)
{
AuthenticateForm = MakeAuthenticateForm(Terminal);
}
try
{
AuthenticateForm->Banner(Banner, NeverShowAgain, Options, Params);
}
__finally
{
if (FAuthenticateForm == NULL)
{
delete AuthenticateForm;
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalShowExtendedException(
TTerminal * Terminal, Exception * E, void * /*Arg*/)
{
if (ScpExplorer)
{
ScpExplorer->ShowExtendedException(Terminal, E);
}
else
{
ShowExtendedExceptionEx(Terminal, E, false);
}
}
//---------------------------------------------------------------------------
static TDateTime DirectoryReadingProgressDelay(0, 0, 1, 500);
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalReadDirectoryProgress(
TObject * Sender, int Progress, int ResolvedLinks, bool & Cancel)
{
DebugAssert((Sender == FOpeningTerminal) == (FAuthenticateForm != NULL));
if (Progress == 0)
{
if ((ScpExplorer != NULL) && (Sender != FOpeningTerminal))
{
// See also TCustomScpExplorerForm::RemoteDirViewBusy
ScpExplorer->LockWindow();
}
FDirectoryReadingStart = Now();
if (!FProgressTitle.IsEmpty() || !FForegroundProgressTitle.IsEmpty())
{
FProgressTitle = L"";
FForegroundProgressTitle = L"";
UpdateAppTitle();
}
// Reset "was ESC ever pressed?" state
GetAsyncKeyState(VK_ESCAPE);
}
else if (Progress < 0)
{
if (Progress == -2)
{
// cancelled
if (ScpExplorer != NULL)
{
ScpExplorer->ReadDirectoryCancelled();
}
}
else
{
if ((ScpExplorer != NULL) && (Sender != FOpeningTerminal))
{
ScpExplorer->UnlockWindow();
}
FProgressTitle = L"";
FForegroundProgressTitle = L"";
UpdateAppTitle();
}
}
else
{
// If the least significant bit is set,
// the key was pressed after the previous call to GetAsyncKeyState.
int KeyState = GetAsyncKeyState(VK_ESCAPE);
if (FLAGSET(KeyState, 0x01))
{
Cancel = true;
}
if ((Now() - FDirectoryReadingStart) >= DirectoryReadingProgressDelay)
{
// 4 is arbitrary number
FForegroundProgressTitle =
FMTLOAD(ResolvedLinks >= 4 ? DIRECTORY_READING_AND_RESOLVING_PROGRESS : DIRECTORY_READING_PROGRESS,
(Progress));
UpdateAppTitle();
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalCustomCommand(
TTerminal * /*Terminal*/, const UnicodeString & Command, bool & Handled)
{
// Implementation has to be thread-safe
Handled = CopyCommandToClipboard(Command);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::AuthenticatingDone()
{
FAuthenticating--;
if (FAuthenticating == 0)
{
BusyEnd(FBusyToken);
FBusyToken = NULL;
}
if (!FKeepAuthenticateForm)
{
CloseAutheticateForm();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalInformation(
TTerminal * Terminal, const UnicodeString & Str, int Phase, const UnicodeString & Additional)
{
if (ScpExplorer != NULL)
{
ScpExplorer->TerminalConnecting();
}
if (Phase == 1)
{
if (FAuthenticating == 0)
{
FBusyToken = BusyStart();
}
FAuthenticating++;
}
else if (Phase == 0)
{
DebugAssert(FAuthenticating > 0);
AuthenticatingDone();
}
else
{
if (FAuthenticating > 0)
{
bool ShowPending = false;
if (FAuthenticateForm == NULL)
{
FAuthenticateForm = MakeAuthenticateForm(Terminal);
ShowPending = true;
}
FAuthenticateForm->Log(Str, Additional);
if (ShowPending)
{
FAuthenticateForm->ShowAsModal();
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::OperationFinished(::TFileOperation Operation,
TOperationSide Side, bool Temp, const UnicodeString & FileName, bool Success, bool NotCancelled,
TOnceDoneOperation & OnceDoneOperation)
{
DebugAssert(ScpExplorer);
ScpExplorer->OperationFinished(Operation, Side, Temp, FileName, Success, NotCancelled, OnceDoneOperation);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::OperationProgress(
TFileOperationProgressType & ProgressData)
{
UpdateAppTitle();
DebugAssert(ScpExplorer);
ScpExplorer->OperationProgress(ProgressData);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::QueueEvent(TTerminalQueue * Queue, TQueueEvent Event)
{
TGuard Guard(FQueueSection);
FQueueEvents.push_back(std::make_pair(Queue, Event));
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DoConfigurationChange()
{
DebugAssert(Configuration);
DebugAssert(Configuration == WinConfiguration);
TTerminalQueue * Queue;
for (int Index = 0; Index < Count; Index++)
{
DebugAssert(Sessions[Index]->Log);
Sessions[Index]->Log->ReflectSettings();
Sessions[Index]->ActionLog->ReflectSettings();
Queue = reinterpret_cast<TTerminalQueue *>(FQueues->Items[Index]);
SetQueueConfiguration(Queue);
}
if (ScpExplorer)
{
ScpExplorer->ConfigurationChanged();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::ConfigurationChange(TObject * /*Sender*/)
{
if (FMainThread == GetCurrentThreadId())
{
DoConfigurationChange();
}
else
{
TGuard Guard(FChangeSection.get());
FPendingConfigurationChange++;
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SessionReady()
{
UpdateScpExplorer();
ScpExplorer->SessionReady();
}
//---------------------------------------------------------------------------
TStrings * __fastcall TTerminalManager::GetSessionList()
{
FSessionList->Clear();
for (int i = 0; i < Count; i++)
{
TManagedTerminal * Terminal = Sessions[i];
UnicodeString Name = GetSessionTitle(Terminal, true);
FSessionList->AddObject(Name, Terminal);
}
return FSessionList;
}
//---------------------------------------------------------------------------
int __fastcall TTerminalManager::GetActiveSessionIndex()
{
return (ActiveSession != NULL) ? IndexOf(ActiveSession) : -1;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SetActiveSessionIndex(int value)
{
ActiveSession = Sessions[value];
}
//---------------------------------------------------------------------------
UnicodeString TTerminalManager::GetPathForSessionTabName(const UnicodeString & Path)
{
UnicodeString Result = Path;
const int MaxPathLen = 16;
if ((WinConfiguration->SessionTabNameFormat == stnfShortPathTrunc) &&
(Result.Length() > MaxPathLen))
{
Result = Result.SubString(1, MaxPathLen - 2) + Ellipsis;
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TTerminalManager::GetSessionTitle(TManagedTerminal * Session, bool Unique)
{
UnicodeString Result;
if (!Session->LocalBrowser)
{
Result = Session->SessionData->SessionName;
if (Unique &&
(WinConfiguration->SessionTabNameFormat != stnfNone))
{
int Index = IndexOf(Session);
// not for background transfer sessions and disconnected sessions
if ((Index >= 0) && Session->Active)
{
for (int Index2 = 0; Index2 < Count; Index2++)
{
UnicodeString Name = Sessions[Index2]->SessionData->SessionName;
if ((Sessions[Index2] != Session) &&
Sessions[Index2]->Active &&
SameText(Name, Result))
{
UnicodeString Path = ExtractShortName(Session->CurrentDirectory, true);
if (!Path.IsEmpty())
{
Path = GetPathForSessionTabName(Path);
Result = FORMAT(L"%s (%s)", (Result, Path));
}
break;
}
}
}
}
}
else
{
// should happen only when closing
if (ScpExplorer != NULL)
{
Result = ScpExplorer->GetLocalBrowserSessionTitle(Session);
}
}
return Result;
}
//---------------------------------------------------------------------------
UnicodeString TTerminalManager::FormatTerminalNoteMessage(TManagedTerminal * Terminal, const UnicodeString & Message)
{
return FORMAT(L"%s: %s", (GetSessionTitle(Terminal, true), Message));
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TTerminalManager::GetActiveSessionAppTitle()
{
UnicodeString Result;
if ((ActiveSession != NULL) && !ActiveSession->LocalBrowser)
{
Result = GetSessionTitle(ActiveSession, false);
}
return Result;
}
//---------------------------------------------------------------------------
TTerminalQueue * __fastcall TTerminalManager::GetActiveQueue()
{
TTerminalQueue * Result = NULL;
if (ActiveSession != NULL)
{
Result = reinterpret_cast<TTerminalQueue *>(FQueues->Items[ActiveSessionIndex]);
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::CycleTerminals(bool Forward)
{
if (Count > 0)
{
int Index = ActiveSessionIndex;
Index += Forward ? 1 : -1;
if (Index < 0)
{
Index = Count-1;
}
else if (Index >= Count)
{
Index = 0;
}
ActiveSessionIndex = Index;
}
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::CanOpenInPutty()
{
return (ActiveTerminal != NULL) && !GUIConfiguration->PuttyPath.Trim().IsEmpty();
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::OpenInPutty()
{
Configuration->Usage->Inc(L"OpenInPutty");
TSessionData * Data = NULL;
try
{
// Is NULL on the first session when called from ConnectActiveTerminal()
// due to WinConfiguration->AutoOpenInPutty
if (ScpExplorer != NULL)
{
Data = ScpExplorer->CloneCurrentSessionData();
}
else
{
Data = new TSessionData(L"");
DebugAssert(ActiveTerminal != NULL);
Data->Assign(ActiveTerminal->SessionData);
ActiveTerminal->UpdateSessionCredentials(Data);
}
if (ActiveTerminal->TunnelLocalPortNumber != 0)
{
Data->ConfigureTunnel(ActiveTerminal->TunnelLocalPortNumber);
}
OpenSessionInPutty(Data);
}
__finally
{
delete Data;
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::NewSession(
const UnicodeString & SessionUrl, bool ReloadSessions, TForm * LinkedForm, bool ReplaceExisting)
{
if (ReloadSessions)
{
StoredSessions->Reload();
}
std::unique_ptr<TObjectList> DataList;
bool Retry;
do
{
Retry = false;
if (!DataList) // first round
{
DataList.reset(new TObjectList());
UnicodeString DownloadFile; // unused
GetLoginData(SessionUrl, NULL, DataList.get(), DownloadFile, lnSession, LinkedForm);
}
else
{
if (!DoLoginDialog(DataList.get(), LinkedForm, false))
{
Abort(); // As GetLoginData would do
}
}
if (DataList->Count > 0)
{
if (ReplaceExisting)
{
// Tested for only the implicit Commanders' local browser
DebugAssert((Count == 0) || ((Count == 1) && Sessions[0]->LocalBrowser));
TAutoNestingCounter UpdatingCounter(FUpdating); // prevent tab flicker
FreeAll();
}
TManagedTerminal * ANewSession = NewSessions(DataList.get());
bool AdHoc = (DataList->Count == 1) && (StoredSessions->FindSame(reinterpret_cast<TSessionData *>(DataList->Items[0])) == NULL);
bool CanRetry = SessionUrl.IsEmpty() && AdHoc;
bool ShowLoginWhenNoSession = WinConfiguration->ShowLoginWhenNoSession;
if (CanRetry)
{
// we will show our own login dialog, so prevent opening an empty one
WinConfiguration->ShowLoginWhenNoSession = false;
}
try
{
ActiveSession = ANewSession;
}
__finally
{
if (CanRetry) // do not reset the value, unless really needed, as it can theoretically be changed meanwhile by the user
{
WinConfiguration->ShowLoginWhenNoSession = ShowLoginWhenNoSession;
}
}
Retry = CanRetry && (ActiveSession != ANewSession);
}
}
while (Retry);
}
//---------------------------------------------------------------------------
void TTerminalManager::StartInactiveTerminalReconnect(TManagedTerminal * Terminal)
{
ReconnectingTerminal(Terminal);
Terminal->NextInactiveReconnect = TDateTime(); // just in case
FReconnectingInactiveTerminal = Terminal;
DebugAssert(Terminal->TerminalThread == NULL);
TTerminalThread * TerminalThread = CreateTerminalThread(Terminal);
Terminal->TerminalThread = TerminalThread;
TerminalThread->AllowAbandon = true;
TerminalThread->StartTerminalReopenNonInteractive();
FReconnectingNote = FormatTerminalNoteMessage(Terminal, LoadStr(SESSION_RECONNECTING));
ScpExplorer->PostNote(FReconnectingNote);
}
//---------------------------------------------------------------------------
void TTerminalManager::CheckInactiveTerminalReconnect()
{
TManagedTerminal * Terminal = DebugNotNull(FReconnectingInactiveTerminal);
TTerminalThread * TerminalThread = DebugNotNull(Terminal->TerminalThread);
TTerminalReopenResult ReopenResult = TerminalThread->IsTerminalReopenComplete();
UnicodeString SessionName = Terminal->SessionData->SessionName;
if (ReopenResult == trrPending)
{
AppLog(FORMAT(L"Inactive session %s is still being reconnected", (SessionName)));
}
else
{
try
{
DebugCheck(TerminalThread->Release());
}
__finally
{
ReconnectedTerminal(Terminal);
Terminal->TerminalThread = NULL;
FReconnectingInactiveTerminal = NULL;
}
if (ReopenResult == trrSucceeded)
{
AppLog(FORMAT(L"Inactive session %s was reconnected", (SessionName)));
ScpExplorer->CancelNote(FReconnectingNote);
UnicodeString ReconnectMessage = LoadStr(SESSION_RECONNECTED);
// This is an indication that we got tray popup on disconnect, so counter that with the same on reconnect
if (!Terminal->InactiveTerminationMessage.IsEmpty())
{
ScpExplorer->InactiveTerminalNotify(Terminal, ReconnectMessage, qtInformation);
}
// otherwise (= when connecting a workspace on the background), notify more subtly with just status bar note
else
{
ScpExplorer->PostNote(FormatTerminalNoteMessage(Terminal, ReconnectMessage));
// update session tab (implied by InactiveTerminalNotify in the previous branch)
ScpExplorer->TerminalStatusChanged(Terminal);
}
}
else
{
if (ReopenResult == trrFailed)
{
// in case it was disabled meanwhile
if (GUIConfiguration->SessionReopenAutoInactive)
{
int Interval = 2 * GUIConfiguration->SessionReopenAutoIdle;
AppLog(FORMAT(L"Inactive session %s failed to reconnect, will try again in %d ms", (SessionName, Interval)));
// Might want to consider SessionReopenTimeout
Terminal->NextInactiveReconnect = IncMilliSecond(Now(), Interval);
}
else
{
Terminal->NextInactiveReconnect = TDateTime();
}
}
else if (ReopenResult == trrNeedsInteraction)
{
AppLog(FORMAT(L"Inactive session %s needs interaction", (SessionName)));
ScpExplorer->CancelNote(FReconnectingNote);
ScpExplorer->InactiveTerminalNotify(Terminal, LoadStr(SESSION_NEED_INTERACTION), qtInformation);
Terminal->NextInactiveReconnect = TDateTime();
}
try
{
if (Terminal->Active)
{
Terminal->Close();
}
}
catch (...)
{
}
}
FReconnectingNote = EmptyStr;
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::Idle(bool SkipCurrentTerminal)
{
if (FPendingConfigurationChange > 0) // optimization
{
bool Changed = false;
{
TGuard Guard(FChangeSection.get());
if (DebugAlwaysTrue(FPendingConfigurationChange > 0))
{
FPendingConfigurationChange--;
Changed = true;
}
}
if (Changed)
{
DoConfigurationChange();
}
}
for (int Index = 0; Index < Count; Index++)
{
TManagedTerminal * Terminal = Sessions[Index];
try
{
if (Terminal == FReconnectingInactiveTerminal)
{
CheckInactiveTerminalReconnect();
}
else if (!SkipCurrentTerminal || (Terminal != ActiveTerminal))
{
// make sure Idle is called on the thread that runs the terminal
if (Terminal->TerminalThread != NULL)
{
Terminal->TerminalThread->Idle();
}
else
{
if (Terminal->Active)
{
Terminal->Idle();
}
else if ((Terminal != ActiveTerminal) &&
((!Terminal->InactiveTerminationMessage.IsEmpty() && GUIConfiguration->SessionReopenAutoInactive) ||
(Terminal->InactiveTerminationMessage.IsEmpty() && WinConfiguration->WorkspaceConnectAll)) &&
(FReconnectingInactiveTerminal == NULL) &&
(Terminal->NextInactiveReconnect != TDateTime()) &&
(Terminal->NextInactiveReconnect < Now()))
{
StartInactiveTerminalReconnect(Terminal);
}
}
if (Terminal->Active)
{
DebugAssert(Index < FQueues->Count);
if (Index < FQueues->Count)
{
reinterpret_cast<TTerminalQueue *>(FQueues->Items[Index])->Idle();
}
}
}
}
catch(Exception & E)
{
if (Terminal == ActiveTerminal)
{
// throw further, so that the exception is handled in proper place
// (particularly in broken-transfer reconnect handler, bug 72)
throw;
}
else
{
// we may not have inactive terminal, unless there is a explorer,
// also Idle is called from explorer anyway
if (DebugAlwaysTrue(ScpExplorer != NULL))
{
ScpExplorer->InactiveTerminalNotify(Terminal, EmptyStr, qtError, &E);
}
if (!Terminal->Active)
{
// if session is lost, save the error message and rethrow it
// once the terminal gets activated
Terminal->InactiveTerminationMessage = E.Message;
Terminal->NextInactiveReconnect = IncMilliSecond(Now(), GUIConfiguration->SessionReopenAutoIdle);
}
}
}
}
TTerminalQueue * QueueWithEvent;
do
{
QueueWithEvent = NULL;
TQueueEvent QueueEvent = TQueueEvent(); // shut up
{
TGuard Guard(FQueueSection);
if (!FQueueEvents.empty())
{
QueueWithEvent = FQueueEvents[0].first;
QueueEvent = FQueueEvents[0].second;
FQueueEvents.erase(FQueueEvents.begin());
}
}
if (QueueWithEvent != NULL)
{
int Index = FQueues->IndexOf(QueueWithEvent);
// the session may not exist anymore
if (Index >= 0)
{
TManagedTerminal * Terminal = Sessions[Index];
// we can hardly have a queue event without explorer
DebugAssert(ScpExplorer != NULL);
if (ScpExplorer != NULL)
{
ScpExplorer->QueueEvent(Terminal, QueueWithEvent, QueueEvent);
}
}
}
}
while (QueueWithEvent != NULL);
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::MasterPasswordPrompt()
{
if (GetCurrentThreadId() == MainThreadID)
{
if (!DoMasterPasswordDialog())
{
Abort();
}
}
else
{
// this can happen only when we keep cancelling all master password prompts
// as long as the sessing finally connects (session password has to be
// explictly typed in), and background transfer is started
Abort();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::Move(TTerminal * Source, TTerminal * Target)
{
int SourceIndex = IndexOf(Source);
int TargetIndex = IndexOf(Target);
TTerminalList::Move(SourceIndex, TargetIndex);
FQueues->Move(SourceIndex, TargetIndex);
DoSessionListChanged();
// when there are indexed sessions with the same name,
// the index may change when reordering the sessions
UpdateAppTitle();
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::DoSessionListChanged()
{
if ((FScpExplorer != NULL) && !Updating)
{
FScpExplorer->SessionListChanged();
}
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::SaveWorkspace(TList * DataList)
{
for (int Index = 0; Index < Count; Index++)
{
TManagedTerminal * ManagedTerminal = Sessions[Index];
TSessionData * Data = StoredSessions->SaveWorkspaceData(ManagedTerminal->StateData, Index);
if (ManagedTerminal->Active)
{
ManagedTerminal->UpdateSessionCredentials(Data);
}
DataList->Add(Data);
}
}
//---------------------------------------------------------------------------
bool TTerminalManager::IsOpenedTerminal(TTerminal * Terminal)
{
return
(Terminal != NULL) &&
Terminal->Active;
}
//---------------------------------------------------------------------------
bool TTerminalManager::IsAvailableTerminal(TTerminal * Terminal)
{
return
IsOpenedTerminal(Terminal) &&
!IsReconnectingTerminal(Terminal);
}
//---------------------------------------------------------------------------
bool TTerminalManager::IsReconnectingTerminal(TTerminal * Terminal)
{
return
(Terminal != NULL) &&
((Terminal == FOpeningTerminal) || (Terminal == FReconnectingInactiveTerminal));
}
//---------------------------------------------------------------------------
bool TTerminalManager::IsAvailableTerminalForSite(TTerminal * Terminal, TSessionData * Data)
{
bool Result = IsAvailableTerminal(Terminal);
if (Result)
{
std::unique_ptr<TSessionData> TerminalData(Terminal->SessionData->Clone());
Terminal->UpdateSessionCredentials(TerminalData.get());
Result = TerminalData->IsSameSite(Data);
}
return Result;
}
//---------------------------------------------------------------------------
TManagedTerminal * __fastcall TTerminalManager::FindActiveTerminalForSite(TSessionData * Data)
{
TManagedTerminal * Result = NULL;
for (int Index = 0; (Result == NULL) && (Index < Count); Index++)
{
TManagedTerminal * Terminal = Sessions[Index];
if (IsAvailableTerminalForSite(Terminal, Data))
{
Result = Terminal;
}
}
return Result;
}
//---------------------------------------------------------------------------
TTerminalQueue * __fastcall TTerminalManager::FindQueueForTerminal(TTerminal * Terminal)
{
int Index = IndexOf(Terminal);
return reinterpret_cast<TTerminalQueue *>(FQueues->Items[Index]);
}
//---------------------------------------------------------------------------
bool __fastcall TTerminalManager::UploadPublicKey(
TTerminal * Terminal, TSessionData * Data, UnicodeString & FileName)
{
std::unique_ptr<TOpenDialog> OpenDialog(new TOpenDialog(Application));
OpenDialog->Title = LoadStr(LOGIN_PUBLIC_KEY_TITLE);
OpenDialog->Filter = LoadStr(LOGIN_PUBLIC_KEY_FILTER);
OpenDialog->DefaultExt = PuttyKeyExt;
OpenDialog->FileName = FileName;
bool Result = OpenDialog->Execute();
if (Result)
{
Configuration->Usage->Inc(L"PublicKeyInstallation");
FileName = OpenDialog->FileName;
VerifyAndConvertKey(FileName, false);
bool AdHocTerminal = (Terminal == NULL);
std::unique_ptr<TTerminal> TerminalOwner;
if (AdHocTerminal)
{
DebugAssert(Data != NULL);
TAutoFlag KeepAuthenticateFormFlag(FKeepAuthenticateForm);
try
{
TerminalOwner.reset(CreateTerminal(Data));
Terminal = TerminalOwner.get();
SetupTerminal(Terminal);
Terminal->OnProgress = NULL;
Terminal->OnFinished = NULL;
DoConnectTerminal(Terminal, false, true);
}
catch (Exception &)
{
CloseAutheticateForm();
throw;
}
}
UnicodeString Installed;
try
{
UnicodeString SshImplementation = Terminal->GetSessionInfo().SshImplementation;
UnicodeString NotOpenSSHMessage = FMTLOAD(LOGIN_NOT_OPENSSH, (SshImplementation));
if (IsOpenSSH(SshImplementation) ||
(MessageDialog(NotOpenSSHMessage, qtConfirmation, qaOK | qaCancel, HELP_LOGIN_AUTHORIZED_KEYS) == qaOK))
{
// Ad-hoc terminal
if (FAuthenticateForm != NULL)
{
UnicodeString Comment;
bool UnusedHasCertificate;
GetPublicKeyLine(FileName, Comment, UnusedHasCertificate);
FAuthenticateForm->Log(FMTLOAD(LOGIN_PUBLIC_KEY_UPLOAD, (Comment)));
}
Installed = Terminal->UploadPublicKey(FileName);
}
}
__finally
{
CloseAutheticateForm(); // When uploading from Login dialog
}
if (!Installed.IsEmpty())
{
Terminal->LogEvent(L"Public key installation done.");
if (AdHocTerminal)
{
TerminalOwner.reset(NULL);
}
else
{
Terminal->Log->AddSeparator();
}
MessageDialog(Installed, qtInformation, qaOK, HELP_LOGIN_AUTHORIZED_KEYS);
}
}
return Result;
}
//---------------------------------------------------------------------------
bool TTerminalManager::IsUpdating()
{
return (FUpdating > 0);
}
//---------------------------------------------------------------------------
bool TTerminalManager::HookFatalExceptionMessageDialog(TMessageParams & Params)
{
bool Result =
DebugAlwaysTrue(ActiveTerminal != NULL) &&
DebugAlwaysTrue(Params.Timer == 0) &&
DebugAlwaysTrue(Params.TimerEvent == NULL) &&
DebugAlwaysTrue(FTerminalWithFatalExceptionTimer == NULL);
if (Result)
{
Params.Timer = MSecsPerSec / 4;
Params.TimerEvent = TerminalFatalExceptionTimer;
FTerminalWithFatalExceptionTimer = ActiveTerminal;
FTerminalReconnnecteScheduled = false;
}
return Result;
}
//---------------------------------------------------------------------------
void TTerminalManager::UnhookFatalExceptionMessageDialog()
{
DebugAssert(FTerminalWithFatalExceptionTimer != NULL);
FTerminalWithFatalExceptionTimer = NULL;
}
//---------------------------------------------------------------------------
bool TTerminalManager::ScheduleTerminalReconnnect(TTerminal * Terminal)
{
bool Result = (FTerminalWithFatalExceptionTimer == Terminal);
if (Result)
{
FTerminalReconnnecteScheduled = true;
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TTerminalManager::TerminalFatalExceptionTimer(unsigned int & Result)
{
if (FTerminalReconnnecteScheduled)
{
Result = qaRetry;
FTerminalReconnnecteScheduled = false;
}
}
//---------------------------------------------------------------------------
TBitmap * TTerminalManager::ThumbnailNeeded(TManagedTerminal * Terminal, int Index, TRemoteFile * File, const TSize & Size)
{
TGuard Guard(Terminal->ThumbnailsSection.get());
TRemoteThumbnailsMap::iterator I = Terminal->Thumbnails.find(Index);
TBitmap * Result;
if ((I != Terminal->Thumbnails.end()) &&
UnixSamePath(File->FileName, I->second.FileName) &&
(I->second.ThumbnailSize == Size))
{
Result = I->second.Thumbnail;
}
else
{
TRemoteThumbnailNeeded ThumbnailNeeded;
ThumbnailNeeded.Index = Index;
ThumbnailNeeded.File = File->Duplicate();
ThumbnailNeeded.ThumbnailSize = Size;
Terminal->ThumbnailsQueue.push_back(ThumbnailNeeded);
if (I != Terminal->Thumbnails.end())
{
delete I->second.Thumbnail;
}
// Prevent duplicates in queue
TRemoteThumbnailData ThumbnailData;
ThumbnailData.FileName = File->FileName;
ThumbnailData.Thumbnail = NULL;
ThumbnailData.ThumbnailSize = Size;
Terminal->Thumbnails.insert(std::make_pair(Index, ThumbnailData));
if (Terminal->ThumbnailsEnabled)
{
NeedThumbnailDownloadQueueItem(Terminal);
}
Result = NULL;
}
return Result;
}
//---------------------------------------------------------------------------
void TTerminalManager::NeedThumbnailDownloadQueueItem(TManagedTerminal * ATerminal)
{
// Expects that ThumbnailsSection is already locked
if (ATerminal->ThumbnailDownloadQueueItem == NULL)
{
ATerminal->ThumbnailDownloadQueueItem = ScpExplorer->AddThumbnailDownloadQueueItem(ATerminal);
}
}
//---------------------------------------------------------------------------
void TTerminalManager::TerminalLoadedDirectory(TManagedTerminal * ATerminal)
{
DebugAssert(ActiveTerminal == ATerminal);
TGuard Guard(ATerminal->ThumbnailsSection.get());
AppLog(L"Loaded directory");
ATerminal->ThumbnailsEnabled = true;
if (!ATerminal->ThumbnailsQueue.empty())
{
NeedThumbnailDownloadQueueItem(ATerminal);
}
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
TThumbnailDownloadQueueItem::TThumbnailDownloadQueueItem(
TCustomScpExplorerForm * ScpExplorer, TManagedTerminal * Terminal, const UnicodeString & SourceDir,
const UnicodeString & TargetDir, const TCopyParamType * CopyParam) :
TTransferQueueItem(Terminal, NULL, TargetDir, CopyParam, cpNoConfirmation | cpTemporary, osRemote, true, false),
FManagedTerminal(Terminal), FScpExplorer(ScpExplorer)
{
FInfo->Source = SourceDir;
}
//---------------------------------------------------------------------------
__fastcall TThumbnailDownloadQueueItem::~TThumbnailDownloadQueueItem()
{
RecursiveDeleteFile(ExcludeTrailingBackslash(FTargetDir));
}
//---------------------------------------------------------------------------
bool TThumbnailDownloadQueueItem::Continue()
{
return !IsExecutionCancelled() && FManagedTerminal->ThumbnailsEnabled;
}
//---------------------------------------------------------------------------
bool TThumbnailDownloadQueueItem::CheckQueueFront(int Index, const UnicodeString & FileName, TSize ThumbnailSize)
{
TRemoteThumbnailsQueue & ThumbnailsQueue = FManagedTerminal->ThumbnailsQueue;
bool Result = !ThumbnailsQueue.empty();
if (Result)
{
const TRemoteThumbnailNeeded & ThumbnailNeeded = ThumbnailsQueue.front();
Result =
(ThumbnailNeeded.Index == Index) &&
(ThumbnailNeeded.File->FullFileName == FileName) &&
(ThumbnailNeeded.ThumbnailSize == ThumbnailSize);
}
return Result;
}
//---------------------------------------------------------------------------
void __fastcall TThumbnailDownloadQueueItem::DoTransferExecute(TTerminal * Terminal, TParallelOperation *)
{
TCriticalSection * Section = FManagedTerminal->ThumbnailsSection.get();
TGuard Guard(Section);
UnicodeString LastSourceDir;
TRemoteThumbnailsQueue & ThumbnailsQueue = FManagedTerminal->ThumbnailsQueue;
while (Continue() && !ThumbnailsQueue.empty())
{
const TRemoteThumbnailNeeded & ThumbnailNeeded = ThumbnailsQueue.front();
FManagedTerminal->ThumbnailVisibleResult = -1;
int Index = ThumbnailNeeded.Index;
std::unique_ptr<TRemoteFile> File(ThumbnailNeeded.File->Duplicate());
TSize ThumbnailSize = ThumbnailNeeded.ThumbnailSize;
UnicodeString FileName = File->FullFileName.Unique();
AppLogFmt(L"Retrieving thumbnail for %s", (FileName));
FManagedTerminal->ThumbnailVisibleResult = -1;
FScpExplorer->PostThumbnailVisibleQueueQuery(Index, FileName);
LastSourceDir = UnixExtractFileDir(FileName);
{
TGuard ItemGuard(FSection);
FInfo->Source = FileName;
}
while (Continue() &&
(FManagedTerminal->ThumbnailVisibleResult < 0))
{
TUnguard Unguard(Section);
Sleep(10);
}
if (Continue())
{
if (FManagedTerminal->ThumbnailVisibleResult == 0)
{
DebugAssert(ThumbnailsQueue.empty() || (&ThumbnailsQueue.front() != &ThumbnailNeeded));
}
else if (DebugAlwaysTrue(CheckQueueFront(Index, FileName, ThumbnailSize)))
{
std::unique_ptr<TStringList> Files(new TStringList());
Files->AddObject(FileName, File.get());
std::unique_ptr<TBitmap> Thumbnail;
{
TUnguard Unguard(Section);
Terminal->CopyToLocal(Files.get(), FTargetDir, FCopyParam, FParams, NULL);
UnicodeString LocalPath =
TPath::Combine(FTargetDir, Terminal->ChangeFileName(FCopyParam, UnixExtractFileName(FileName), osRemote, false));
Thumbnail.reset(GetThumbnail(LocalPath, ThumbnailSize));
}
if (CheckQueueFront(Index, FileName, ThumbnailSize))
{
TRemoteThumbnailsMap::iterator I = FManagedTerminal->Thumbnails.find(Index);
if (DebugAlwaysTrue(I != FManagedTerminal->Thumbnails.end()))
{
TRemoteThumbnailData & RemoteThumbnailData = I->second;
if (DebugAlwaysTrue(RemoteThumbnailData.FileName == UnixExtractFileName(FileName)) &&
DebugAlwaysTrue(RemoteThumbnailData.ThumbnailSize == ThumbnailSize) &&
DebugAlwaysTrue(RemoteThumbnailData.Thumbnail == NULL))
{
RemoteThumbnailData.Thumbnail = Thumbnail.release();
FManagedTerminal->PopThumbnailQueue();
FScpExplorer->PostThumbnailDrawRequest(Index);
}
}
}
}
}
}
{
TGuard ItemGuard(FSection);
FInfo->Source = LastSourceDir;
}
FManagedTerminal->ThumbnailDownloadQueueItem = NULL;
}
View Git Blame Copy Permalink