mirror of
https://github.com/winscp/winscp.git
synced 2026-10-24 02:28:55 +03:00
3122 lines
102 KiB
C++
3122 lines
102 KiB
C++
//---------------------------------------------------------------------------
|
|
#include <WinPCH.h>
|
|
#pragma hdrstop
|
|
|
|
#include "GUITools.h"
|
|
|
|
#include <shlobj.h>
|
|
#include <mshtmhst.h>
|
|
|
|
#include <SessionData.h>
|
|
#include <TBXUtils.hpp>
|
|
#include "PngImageList.hpp"
|
|
#include <Glyphs.h>
|
|
#include <WinApi.h>
|
|
#include <HistoryComboBox.h>
|
|
#include <vssym32.h>
|
|
#include <Queue.h>
|
|
#include <Vcl.Themes.hpp>
|
|
|
|
#include "Animations96.h"
|
|
#include "Animations120.h"
|
|
#include "Animations144.h"
|
|
#include "Animations192.h"
|
|
//---------------------------------------------------------------------------
|
|
extern const UnicodeString PageantTool = L"pageant.exe";
|
|
extern const UnicodeString PuttygenTool = L"puttygen.exe";
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall FindFile(UnicodeString & Path)
|
|
{
|
|
bool Result = FileExistsFix(Path);
|
|
|
|
if (!Result)
|
|
{
|
|
UnicodeString ProgramFiles32 = IncludeTrailingBackslash(GetEnvironmentVariable(L"ProgramFiles"));
|
|
UnicodeString ProgramFiles64 = IncludeTrailingBackslash(GetEnvironmentVariable(L"ProgramW6432"));
|
|
if (!ProgramFiles32.IsEmpty() &&
|
|
SameText(Path.SubString(1, ProgramFiles32.Length()), ProgramFiles32) &&
|
|
!ProgramFiles64.IsEmpty())
|
|
{
|
|
UnicodeString Path64 =
|
|
ProgramFiles64 + Path.SubString(ProgramFiles32.Length() + 1, Path.Length() - ProgramFiles32.Length());
|
|
if (FileExists(ApiPath(Path64)))
|
|
{
|
|
Path = Path64;
|
|
Result = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Result && SameText(ExtractFileName(Path), Path))
|
|
{
|
|
UnicodeString Paths = GetEnvironmentVariable(L"PATH");
|
|
if (!Paths.IsEmpty())
|
|
{
|
|
UnicodeString NewPath = FileSearch(Path, Paths);
|
|
Result = !NewPath.IsEmpty();
|
|
if (Result)
|
|
{
|
|
Path = NewPath;
|
|
}
|
|
else
|
|
{
|
|
// Basically the same what FileSearch does, except for FileExistsFix.
|
|
// Once this proves working, we can ged rid of the FileSearch call.
|
|
while (!Result && !Paths.IsEmpty())
|
|
{
|
|
UnicodeString P = CutToChar(Paths, L';', false);
|
|
// Not using CombinePaths as it throws on an invalid path and PATH is not under our control
|
|
NewPath = IncludeTrailingBackslash(P) + Path;
|
|
Result = FileExistsFix(NewPath);
|
|
if (Result)
|
|
{
|
|
Path = NewPath;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool DoesSessionExistInPutty(const UnicodeString & StorageKey)
|
|
{
|
|
std::unique_ptr<TRegistryStorage> Storage(new TRegistryStorage(Configuration->PuttySessionsKey));
|
|
Storage->ConfigureForPutty();
|
|
return Storage->OpenRootKey(true) && Storage->KeyExists(StorageKey);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall ExportSessionToPutty(TSessionData * SessionData, bool ReuseExisting, const UnicodeString & SessionName)
|
|
{
|
|
bool Result = true;
|
|
std::unique_ptr<TRegistryStorage> Storage(new TRegistryStorage(Configuration->PuttySessionsKey));
|
|
Storage->AccessMode = smReadWrite;
|
|
Storage->ConfigureForPutty();
|
|
if (Storage->OpenRootKey(true))
|
|
{
|
|
Result = ReuseExisting && Storage->KeyExists(SessionData->StorageKey);
|
|
if (Result)
|
|
{
|
|
AppLogFmt(L"Reusing existing PuTTY session: %s", (SessionData->StorageKey));
|
|
}
|
|
else
|
|
{
|
|
std::unique_ptr<TRegistryStorage> SourceStorage(new TRegistryStorage(Configuration->PuttySessionsKey));
|
|
SourceStorage->ConfigureForPutty();
|
|
if (SourceStorage->OpenSubKey(StoredSessions->DefaultSettings->Name, false) &&
|
|
Storage->OpenSubKey(SessionName, true))
|
|
{
|
|
Storage->Copy(SourceStorage.get());
|
|
Storage->CloseSubKey();
|
|
}
|
|
|
|
std::unique_ptr<TSessionData> ExportData(new TSessionData(L""));
|
|
ExportData->Assign(SessionData);
|
|
ExportData->Modified = true;
|
|
ExportData->Name = SessionName;
|
|
ExportData->WinTitle = SessionData->SessionName;
|
|
ExportData->Password = L"";
|
|
|
|
if (SessionData->FSProtocol == fsFTP)
|
|
{
|
|
if (GUIConfiguration->TelnetForFtpInPutty)
|
|
{
|
|
ExportData->PuttyProtocol = PuttyTelnetProtocol;
|
|
ExportData->PortNumber = TelnetPortNumber;
|
|
}
|
|
else
|
|
{
|
|
ExportData->PuttyProtocol = PuttySshProtocol;
|
|
ExportData->PortNumber = SshPortNumber;
|
|
}
|
|
}
|
|
|
|
ExportData->Save(Storage.get(), true);
|
|
AppLogFmt(L"Exported site settings to PuTTY session: %s", (SessionName));
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TStandaloneThread : public TSimpleThread
|
|
{
|
|
public:
|
|
virtual void __fastcall Terminate();
|
|
protected:
|
|
virtual bool __fastcall Finished();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TStandaloneThread::Terminate()
|
|
{
|
|
// noop - the thread always self-terminates
|
|
DebugFail();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TStandaloneThread::Finished()
|
|
{
|
|
// self-destroy
|
|
return TSimpleThread::Finished() || true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
class TSingletonThread : public TStandaloneThread
|
|
{
|
|
public:
|
|
static void Schedule();
|
|
static void Finalize();
|
|
|
|
protected:
|
|
virtual void __fastcall Execute();
|
|
void DoSchedule();
|
|
virtual void DoExecute(bool HasExpired) = 0;
|
|
|
|
TDateTime FTimer;
|
|
static T * FInstance;
|
|
static std::unique_ptr<TCriticalSection> FSection;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
std::unique_ptr<TCriticalSection> TSingletonThread<T, TT, I>::FSection(TraceInitPtr(new TCriticalSection()));
|
|
template<typename T, int TT, int I>
|
|
T * TSingletonThread<T, TT, I>::FInstance;
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
void TSingletonThread<T, TT, I>::Schedule()
|
|
{
|
|
TGuard Guard(FSection.get());
|
|
if (FInstance == NULL)
|
|
{
|
|
FInstance = new T();
|
|
FInstance->DoSchedule();
|
|
FInstance->Start();
|
|
}
|
|
else
|
|
{
|
|
FInstance->DoSchedule();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
void TSingletonThread<T, TT, I>::Finalize()
|
|
{
|
|
while (true)
|
|
{
|
|
{
|
|
TGuard Guard(FSection.get());
|
|
if (FInstance == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
Sleep(100);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
void __fastcall TSingletonThread<T, TT, I>::Execute()
|
|
{
|
|
try
|
|
{
|
|
bool HasExpired;
|
|
do
|
|
{
|
|
{
|
|
TGuard Guard(FSection.get());
|
|
HasExpired = (FTimer < Now());
|
|
}
|
|
DoExecute(HasExpired);
|
|
if (!HasExpired)
|
|
{
|
|
Sleep(I);
|
|
}
|
|
}
|
|
while (!HasExpired);
|
|
}
|
|
__finally
|
|
{
|
|
TGuard Guard(FSection.get());
|
|
FInstance = NULL;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
template<typename T, int TT, int I>
|
|
void TSingletonThread<T, TT, I>::DoSchedule()
|
|
{
|
|
FTimer = IncSecond(Now(), TT);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TPuttyCleanupThread : public TSingletonThread<TPuttyCleanupThread, 10, 1000>
|
|
{
|
|
protected:
|
|
virtual void DoExecute(bool HasExpired);
|
|
|
|
private:
|
|
std::unique_ptr<TStrings> FSessions;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void TPuttyCleanupThread::DoExecute(bool HasExpired)
|
|
{
|
|
if (!FSessions)
|
|
{
|
|
FSessions.reset(new TStringList());
|
|
}
|
|
|
|
TGuard Guard(FSection.get());
|
|
std::unique_ptr<TRegistryStorage> Storage(new TRegistryStorage(Configuration->PuttySessionsKey));
|
|
Storage->AccessMode = smReadWrite;
|
|
Storage->ConfigureForPutty();
|
|
|
|
std::unique_ptr<TStringList> Sessions2(new TStringList());
|
|
if (Storage->OpenRootKey(true))
|
|
{
|
|
std::unique_ptr<TStrings> SubKeys(new TStringList());
|
|
Storage->GetSubKeyNames(SubKeys.get());
|
|
for (int Index = 0; Index < SubKeys->Count; Index++)
|
|
{
|
|
UnicodeString SessionName = SubKeys->Strings[Index];
|
|
if (StartsStr(GUIConfiguration->PuttySession, SessionName))
|
|
{
|
|
Sessions2->Add(SessionName);
|
|
}
|
|
}
|
|
|
|
Sessions2->Sort();
|
|
if (!FSessions->Equals(Sessions2.get()))
|
|
{
|
|
// Just in case new sessions from another WinSCP instance are added, delay the cleanup
|
|
// (to avoid having to implement some inter-process communication).
|
|
// Both instances will attempt to do the cleanup, but that not a problem
|
|
FSessions->Assign(Sessions2.get());
|
|
DoSchedule();
|
|
HasExpired = false;
|
|
}
|
|
}
|
|
|
|
if (HasExpired)
|
|
{
|
|
for (int Index = 0; Index < Sessions2->Count; Index++)
|
|
{
|
|
UnicodeString SessionName = Sessions2->Strings[Index];
|
|
Storage->RecursiveDeleteSubKey(SessionName);
|
|
}
|
|
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TPuttyPasswordThread : public TStandaloneThread
|
|
{
|
|
public:
|
|
TPuttyPasswordThread(const UnicodeString & Password, const UnicodeString & PipeName);
|
|
virtual __fastcall ~TPuttyPasswordThread();
|
|
|
|
protected:
|
|
virtual void __fastcall Execute();
|
|
|
|
private:
|
|
HANDLE FPipe;
|
|
AnsiString FPassword;
|
|
|
|
void DoSleep(int & Timeout);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
TPuttyPasswordThread::TPuttyPasswordThread(const UnicodeString & Password, const UnicodeString & PipeName)
|
|
{
|
|
DWORD OpenMode = PIPE_ACCESS_OUTBOUND | FILE_FLAG_FIRST_PIPE_INSTANCE;
|
|
DWORD PipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_NOWAIT | PIPE_REJECT_REMOTE_CLIENTS;
|
|
DWORD BufferSize = 16 * 1024;
|
|
FPipe = CreateNamedPipe(PipeName.c_str(), OpenMode, PipeMode, 1, BufferSize, BufferSize, NMPWAIT_USE_DEFAULT_WAIT, NULL);
|
|
if (FPipe == INVALID_HANDLE_VALUE)
|
|
{
|
|
throw EOSExtException(L"Cannot create password pipe");
|
|
}
|
|
FPassword = AnsiString(Password);
|
|
Start();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TPuttyPasswordThread::~TPuttyPasswordThread()
|
|
{
|
|
DebugAssert(FFinished);
|
|
AppLog(L"Disconnecting and closing password pipe");
|
|
DisconnectNamedPipe(FPipe);
|
|
CloseHandle(FPipe);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TPuttyPasswordThread::DoSleep(int & Timeout)
|
|
{
|
|
unsigned int Step = 50;
|
|
Sleep(Step);
|
|
Timeout -= Step;
|
|
if (Timeout <= 0)
|
|
{
|
|
AppLog(L"Timeout waiting for PuTTY");
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TPuttyPasswordThread::Execute()
|
|
{
|
|
AppLog(L"Waiting for PuTTY to connect to password pipe");
|
|
int Timeout = MSecsPerSec * SecsPerMin;
|
|
while (Timeout > 0)
|
|
{
|
|
if (ConnectNamedPipe(FPipe, NULL))
|
|
{
|
|
AppLog(L"Password pipe is ready");
|
|
}
|
|
else
|
|
{
|
|
int Error = GetLastError();
|
|
if (Error == ERROR_PIPE_CONNECTED)
|
|
{
|
|
AppLog(L"PuTTY has connected to password pipe");
|
|
int Pos = 0;
|
|
while ((Timeout > 0) && (Pos < FPassword.Length()))
|
|
{
|
|
DWORD Written = 0;
|
|
if (!WriteFile(FPipe, FPassword.c_str() + Pos, FPassword.Length() - Pos, &Written, NULL))
|
|
{
|
|
AppLog(L"Error writting password pipe");
|
|
Timeout = 0;
|
|
}
|
|
else
|
|
{
|
|
Pos += Written;
|
|
if (Pos >= FPassword.Length())
|
|
{
|
|
FlushFileBuffers(FPipe);
|
|
AppLog(L"Complete password was written to pipe");
|
|
Timeout = 0;
|
|
}
|
|
else
|
|
{
|
|
AppLog(L"Part of password was written to pipe");
|
|
DoSleep(Timeout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (Error == ERROR_PIPE_LISTENING)
|
|
{
|
|
DoSleep(Timeout);
|
|
}
|
|
else
|
|
{
|
|
AppLogFmt(L"Password pipe error %d", (Error));
|
|
Timeout = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void SplitPuttyCommand(UnicodeString & Program, UnicodeString & Params)
|
|
{
|
|
// See also TSiteAdvancedDialog::PuttySettingsButtonClick
|
|
UnicodeString Dir;
|
|
SplitCommand(GUIConfiguration->PuttyPath, Program, Params, Dir);
|
|
Program = ExpandEnvironmentVariables(Program);
|
|
Params = ExpandEnvironmentVariables(Params);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString FindPuttyPath()
|
|
{
|
|
UnicodeString Program, Params;
|
|
SplitPuttyCommand(Program, Params);
|
|
if (!FindFile(Program))
|
|
{
|
|
throw Exception(FMTLOAD(EXECUTE_APP_ERROR, (Program)));
|
|
}
|
|
return Program;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static unsigned int PipeCounter = 0;
|
|
//---------------------------------------------------------------------------
|
|
void OpenSessionInPutty(TSessionData * SessionData)
|
|
{
|
|
// putty does not support resolving environment variables in session settings
|
|
SessionData->ExpandEnvironmentVariables();
|
|
UnicodeString Program, AParams;
|
|
SplitPuttyCommand(Program, AParams);
|
|
AppLogFmt(L"PuTTY program: %s", (Program));
|
|
AppLogFmt(L"Params: %s", (AParams));
|
|
if (FindFile(Program))
|
|
{
|
|
|
|
UnicodeString Password;
|
|
if (GUIConfiguration->PuttyPassword)
|
|
{
|
|
// Passphrase has precendence, as it's more likely entered by user during authentication, hence more likely really needed.
|
|
if (!SessionData->Passphrase.IsEmpty())
|
|
{
|
|
Password = SessionData->Passphrase;
|
|
}
|
|
else if (!SessionData->Password.IsEmpty())
|
|
{
|
|
Password = SessionData->Password;
|
|
}
|
|
}
|
|
TCustomCommandData Data(SessionData, SessionData->UserName, Password);
|
|
TLocalCustomCommand LocalCustomCommand(Data, SessionData->RemoteDirectory, SessionData->LocalDirectory);
|
|
TWinInteractiveCustomCommand InteractiveCustomCommand(
|
|
&LocalCustomCommand, L"PuTTY", UnicodeString());
|
|
|
|
UnicodeString Params =
|
|
LocalCustomCommand.Complete(InteractiveCustomCommand.Complete(AParams, false), true);
|
|
UnicodeString PuttyParams;
|
|
AppLogFmt(L"Expanded params: %s", (Params));
|
|
|
|
if (!LocalCustomCommand.IsSiteCommand(AParams))
|
|
{
|
|
{
|
|
bool SessionList = false;
|
|
std::unique_ptr<THierarchicalStorage> SourceHostKeyStorage(Configuration->CreateScpStorage(SessionList));
|
|
std::unique_ptr<THierarchicalStorage> TargetHostKeyStorage(new TRegistryStorage(Configuration->PuttyRegistryStorageKey));
|
|
TargetHostKeyStorage->Explicit = true;
|
|
TargetHostKeyStorage->AccessMode = smReadWrite;
|
|
std::unique_ptr<TStoredSessionList> HostKeySessionList(new TStoredSessionList());
|
|
HostKeySessionList->OwnsObjects = false;
|
|
HostKeySessionList->Add(SessionData);
|
|
int Imported =
|
|
TStoredSessionList::ImportHostKeys(SourceHostKeyStorage.get(), TargetHostKeyStorage.get(), HostKeySessionList.get(), false, true);
|
|
AppLogFmt(L"Imported host keys: %d", (Imported));
|
|
}
|
|
|
|
if (IsUWP())
|
|
{
|
|
bool Telnet = (SessionData->FSProtocol == fsFTP) && GUIConfiguration->TelnetForFtpInPutty;
|
|
if (Telnet)
|
|
{
|
|
AddToList(PuttyParams, L"-telnet", L" ");
|
|
// PuTTY does not allow -pw for telnet
|
|
Password = L"";
|
|
}
|
|
AddToList(PuttyParams, EscapePuttyCommandParam(SessionData->HostName), L" ");
|
|
if (!SessionData->UserName.IsEmpty())
|
|
{
|
|
AddToList(PuttyParams, FORMAT(L"-l %s", (EscapePuttyCommandParam(SessionData->UserName))), L" ");
|
|
}
|
|
if ((SessionData->FSProtocol != fsFTP) && (SessionData->PortNumber != SshPortNumber))
|
|
{
|
|
AddToList(PuttyParams, FORMAT(L"-P %d", (SessionData->PortNumber)), L" ");
|
|
}
|
|
|
|
if (!Telnet)
|
|
{
|
|
UnicodeString PublicKeyFile = SessionData->ResolvePublicKeyFile();
|
|
if (!PublicKeyFile.IsEmpty())
|
|
{
|
|
AddToList(PuttyParams, FORMAT(L"-i \"%s\"", (PublicKeyFile)), L" ");
|
|
}
|
|
AddToList(PuttyParams, (SessionData->TryAgent ? L"-agent" : L"-noagent"), L" ");
|
|
if (SessionData->TryAgent)
|
|
{
|
|
AddToList(PuttyParams, (SessionData->AgentFwd ? L"-A" : L"-a"), L" ");
|
|
}
|
|
if (SessionData->Compression)
|
|
{
|
|
AddToList(PuttyParams, L"-C", L" ");
|
|
}
|
|
AddToList(PuttyParams, L"-2", L" ");
|
|
if (!SessionData->LogicalHostName.IsEmpty())
|
|
{
|
|
AddToList(PuttyParams, FORMAT(L"-loghost \"%s\"", (SessionData->LogicalHostName)), L" ");
|
|
}
|
|
}
|
|
|
|
if (SessionData->AddressFamily == afIPv4)
|
|
{
|
|
AddToList(PuttyParams, L"-4", L" ");
|
|
}
|
|
else if (SessionData->AddressFamily == afIPv6)
|
|
{
|
|
AddToList(PuttyParams, L"-6", L" ");
|
|
}
|
|
|
|
AppLogFmt(L"Using command-line instead of stored session in UWP: %s", (PuttyParams));
|
|
}
|
|
else
|
|
{
|
|
UnicodeString SessionName;
|
|
|
|
UnicodeString PuttySession = GUIConfiguration->PuttySession;
|
|
int Uniq = 1;
|
|
while (DoesSessionExistInPutty(PuttySession))
|
|
{
|
|
Uniq++;
|
|
PuttySession = FORMAT(L"%s (%d)", (GUIConfiguration->PuttySession, Uniq));
|
|
}
|
|
|
|
if (ExportSessionToPutty(SessionData, true, PuttySession))
|
|
{
|
|
SessionName = SessionData->SessionName;
|
|
}
|
|
else
|
|
{
|
|
SessionName = PuttySession;
|
|
TPuttyCleanupThread::Schedule();
|
|
if ((SessionData->FSProtocol == fsFTP) &&
|
|
GUIConfiguration->TelnetForFtpInPutty)
|
|
{
|
|
// PuTTY does not allow -pw for telnet
|
|
Password = L"";
|
|
}
|
|
}
|
|
|
|
UnicodeString LoadSwitch = L"-load";
|
|
int P = Params.LowerCase().Pos(LoadSwitch + L" ");
|
|
if ((P == 0) || ((P > 1) && (Params[P - 1] != L' ')))
|
|
{
|
|
AddToList(PuttyParams, FORMAT(L"%s %s", (LoadSwitch, EscapePuttyCommandParam(SessionName))), L" ");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Password.IsEmpty() && !LocalCustomCommand.IsPasswordCommand(AParams))
|
|
{
|
|
Password = NormalizeString(Password); // if password is empty, we should quote it always
|
|
bool UsePuttyPwFile;
|
|
if (GUIConfiguration->UsePuttyPwFile == asAuto)
|
|
{
|
|
UsePuttyPwFile = false;
|
|
if (SameText(ExtractFileName(Program), OriginalPuttyExecutable))
|
|
{
|
|
unsigned int Version = GetFileVersion(Program);
|
|
if (Version != static_cast<unsigned int>(-1))
|
|
{
|
|
int MajorVersion = HIWORD(Version);
|
|
int MinorVersion = LOWORD(Version);
|
|
if (CalculateCompoundVersion(MajorVersion, MinorVersion) >= CalculateCompoundVersion(0, 77))
|
|
{
|
|
UsePuttyPwFile = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UsePuttyPwFile = (GUIConfiguration->UsePuttyPwFile == asOn);
|
|
}
|
|
|
|
UnicodeString PasswordParam;
|
|
if (UsePuttyPwFile)
|
|
{
|
|
PipeCounter++;
|
|
UnicodeString PipeName = FORMAT(L"\\\\.\\PIPE\\WinSCPPuTTYPassword.%.8x.%.8x.%.4x", (GetCurrentProcessId(), PipeCounter, rand()));
|
|
new TPuttyPasswordThread(Password, PipeName);
|
|
PasswordParam = FORMAT(L"-pwfile \"%s\"", (PipeName));
|
|
}
|
|
else
|
|
{
|
|
PasswordParam = FORMAT(L"-pw %s", (EscapePuttyCommandParam(Password)));
|
|
}
|
|
AddToList(PuttyParams, PasswordParam, L" ");
|
|
}
|
|
|
|
AddToList(PuttyParams, Params, L" ");
|
|
|
|
// PuTTY is started in its binary directory to allow relative paths in private key,
|
|
// when opening PuTTY's own stored session.
|
|
ExecuteShellChecked(Program, PuttyParams, true);
|
|
}
|
|
else
|
|
{
|
|
throw Exception(FMTLOAD(FILE_NOT_FOUND, (Program)));
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
static HWND OperationStatusWindow = 0;
|
|
static TRect OperationStatusCenterRect;
|
|
//---------------------------------------------------------------------------
|
|
void PlaceOperationStatusWindow()
|
|
{
|
|
TRect CurRect;
|
|
if (GetWindowRect(OperationStatusWindow, &CurRect))
|
|
{
|
|
TRect Rect = CurRect;
|
|
CenterFormOn(Rect, OperationStatusCenterRect);
|
|
if (Rect != CurRect)
|
|
{
|
|
// What TWinControl.SetBounds does
|
|
SetWindowPos(OperationStatusWindow, 0, Rect.Left, Rect.Top, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TOperationStatusWindowMonitorThread : public TSingletonThread<TOperationStatusWindowMonitorThread, 3, 25>
|
|
{
|
|
protected:
|
|
virtual void DoExecute(bool HasExpired);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void TOperationStatusWindowMonitorThread::DoExecute(bool)
|
|
{
|
|
PlaceOperationStatusWindow();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void CheckOperationStatusWindow()
|
|
{
|
|
if (Screen->ActiveForm != nullptr)
|
|
{
|
|
OperationStatusCenterRect = GetCenterRect(Screen->ActiveForm, nullptr);
|
|
HWND WindowHandle = GetForegroundWindow();
|
|
if ((WindowHandle != nullptr) && (WindowHandle != OperationStatusWindow))
|
|
{
|
|
DWORD ProcessId;
|
|
if ((GetWindowThreadProcessId(WindowHandle, &ProcessId) != 0) &&
|
|
(ProcessId == GetCurrentProcessId()))
|
|
{
|
|
UnicodeString ClassName;
|
|
ClassName.SetLength(256);
|
|
GetClassName(WindowHandle, ClassName.c_str(), ClassName.Length());
|
|
PackStr(ClassName);
|
|
if ((ClassName == L"OperationStatusWindow") &&
|
|
!IsIconic(WindowHandle))
|
|
{
|
|
OperationStatusWindow = WindowHandle;
|
|
PlaceOperationStatusWindow();
|
|
TOperationStatusWindowMonitorThread::Schedule();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall FindTool(const UnicodeString & Name, UnicodeString & Path)
|
|
{
|
|
UnicodeString AppPath = IncludeTrailingBackslash(ExtractFilePath(Application->ExeName));
|
|
Path = AppPath + Name;
|
|
bool Result = true;
|
|
if (!FileExists(ApiPath(Path)))
|
|
{
|
|
Path = AppPath + L"PuTTY\\" + Name;
|
|
if (!FileExists(ApiPath(Path)))
|
|
{
|
|
Path = Name;
|
|
if (!FindFile(Path))
|
|
{
|
|
Result = false;
|
|
}
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ExecuteTool(const UnicodeString & Name)
|
|
{
|
|
UnicodeString Path;
|
|
if (!FindTool(Name, Path))
|
|
{
|
|
throw Exception(FMTLOAD(EXECUTE_APP_ERROR, (Name)));
|
|
}
|
|
|
|
ExecuteShellChecked(Path, L"");
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TObjectList * StartCreationDirectoryMonitorsOnEachDrive(unsigned int Filter, TFileChangedEvent OnChanged)
|
|
{
|
|
std::unique_ptr<TStrings> Drives(new TStringList());
|
|
|
|
std::unique_ptr<TStrings> DDDrives(CommaTextToStringList(WinConfiguration->DDDrives));
|
|
UnicodeString ExcludedDrives;
|
|
for (int Index = 0; Index < DDDrives->Count; Index++)
|
|
{
|
|
UnicodeString S = Trim(DDDrives->Strings[Index]);
|
|
if (!S.IsEmpty() && (S[1] == L'-'))
|
|
{
|
|
S = Trim(S.SubString(2, S.Length() - 1));
|
|
if (!S.IsEmpty())
|
|
{
|
|
ExcludedDrives += S[1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Drives->Add(S);
|
|
}
|
|
}
|
|
|
|
for (char Drive = FirstDrive; Drive <= LastDrive; Drive++)
|
|
{
|
|
if (ExcludedDrives.Pos(Drive) == 0)
|
|
{
|
|
// Not calling ReadDriveStatus(... dsSize), relying on drive ready status cached by the background thread
|
|
TDriveInfoRec * DriveInfoRec = DriveInfo->Get(Drive);
|
|
if (DriveInfoRec->Valid && DriveInfoRec->DriveReady &&
|
|
(DriveInfoRec->DriveType != DRIVE_CDROM) &&
|
|
((DriveInfoRec->DriveType != DRIVE_REMOVABLE) || (Drive >= DriveInfo->FirstFixedDrive)))
|
|
{
|
|
Drives->Add(Drive);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<TObjectList> Result(new TObjectList());
|
|
for (int Index = 0; Index < Drives->Count; Index++)
|
|
{
|
|
UnicodeString Drive = Drives->Strings[Index];
|
|
std::unique_ptr<TDirectoryMonitor> Monitor(new TDirectoryMonitor(Application));
|
|
try
|
|
{
|
|
Monitor->Path = DriveInfo->GetDriveRoot(Drive);
|
|
Monitor->WatchSubtree = true;
|
|
Monitor->WatchFilters = Filter;
|
|
Monitor->OnCreated = OnChanged;
|
|
Monitor->OnModified = OnChanged;
|
|
Monitor->Active = true;
|
|
Result->Add(Monitor.release());
|
|
}
|
|
catch (Exception & E)
|
|
{
|
|
// Ignore errors watching not-ready drives
|
|
DebugUsedParam(E);
|
|
}
|
|
}
|
|
return Result.release();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool DontCopyCommandToClipboard = false;
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall CopyCommandToClipboard(const UnicodeString & Command)
|
|
{
|
|
bool Result = !DontCopyCommandToClipboard && UseAlternativeFunction() && IsKeyPressed(VK_CONTROL);
|
|
if (Result)
|
|
{
|
|
TInstantOperationVisualizer Visualizer;
|
|
AppLogFmt(L"Copied command to the clipboard: %s", (Command));
|
|
CopyToClipboard(Command);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static bool __fastcall DoExecuteShell(const UnicodeString Path, const UnicodeString Params,
|
|
bool ChangeWorkingDirectory, HANDLE * Handle)
|
|
{
|
|
bool Result = CopyCommandToClipboard(FormatCommand(Path, Params));
|
|
|
|
if (Result)
|
|
{
|
|
if (Handle != NULL)
|
|
{
|
|
*Handle = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UnicodeString Directory = ExtractFilePath(Path);
|
|
|
|
TShellExecuteInfoW ExecuteInfo;
|
|
memset(&ExecuteInfo, 0, sizeof(ExecuteInfo));
|
|
ExecuteInfo.cbSize = sizeof(ExecuteInfo);
|
|
ExecuteInfo.fMask =
|
|
SEE_MASK_FLAG_NO_UI |
|
|
FLAGMASK((Handle != NULL), SEE_MASK_NOCLOSEPROCESS);
|
|
ExecuteInfo.hwnd = Application->Handle;
|
|
ExecuteInfo.lpFile = static_cast<const wchar_t *>(Path.data());
|
|
ExecuteInfo.lpParameters = static_cast<const wchar_t *>(Params.data());
|
|
ExecuteInfo.lpDirectory = (ChangeWorkingDirectory ? Directory.c_str() : NULL);
|
|
ExecuteInfo.nShow = SW_SHOW;
|
|
|
|
AppLogFmt(L"Executing program \"%s\" with params: %s", (Path, Params));
|
|
Result = (ShellExecuteEx(&ExecuteInfo) != 0);
|
|
if (Result)
|
|
{
|
|
if (Handle != NULL)
|
|
{
|
|
*Handle = ExecuteInfo.hProcess;
|
|
}
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ExecuteShellChecked(const UnicodeString Path, const UnicodeString Params, bool ChangeWorkingDirectory)
|
|
{
|
|
if (!DoExecuteShell(Path, Params, ChangeWorkingDirectory, NULL))
|
|
{
|
|
throw EOSExtException(FMTLOAD(EXECUTE_APP_ERROR, (Path)));
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ExecuteShellChecked(const UnicodeString Command)
|
|
{
|
|
UnicodeString Program, Params, Dir;
|
|
SplitCommand(Command, Program, Params, Dir);
|
|
ExecuteShellChecked(Program, Params);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall ExecuteShell(const UnicodeString Path, const UnicodeString Params,
|
|
HANDLE & Handle)
|
|
{
|
|
return DoExecuteShell(Path, Params, false, &Handle);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ExecuteShellCheckedAndWait(const UnicodeString Command,
|
|
TProcessMessagesEvent ProcessMessages)
|
|
{
|
|
UnicodeString Program, Params, Dir;
|
|
SplitCommand(Command, Program, Params, Dir);
|
|
HANDLE ProcessHandle;
|
|
bool Result = DoExecuteShell(Program, Params, false, &ProcessHandle);
|
|
if (!Result)
|
|
{
|
|
throw EOSExtException(FMTLOAD(EXECUTE_APP_ERROR, (Program)));
|
|
}
|
|
else
|
|
{
|
|
if (ProcessHandle != NULL) // only if command was copied to clipboard only
|
|
{
|
|
if (ProcessMessages != NULL)
|
|
{
|
|
unsigned long WaitResult;
|
|
do
|
|
{
|
|
// Same as in ExecuteProcessAndReadOutput
|
|
WaitResult = WaitForSingleObject(ProcessHandle, 50);
|
|
if (WaitResult == WAIT_FAILED)
|
|
{
|
|
throw Exception(LoadStr(DOCUMENT_WAIT_ERROR));
|
|
}
|
|
ProcessMessages();
|
|
}
|
|
while (WaitResult == WAIT_TIMEOUT);
|
|
}
|
|
else
|
|
{
|
|
WaitForSingleObject(ProcessHandle, INFINITE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool KnownFolderPath(REFKNOWNFOLDERID FolderID, UnicodeString & Path)
|
|
{
|
|
PWSTR Buf = nullptr;
|
|
bool Result = SUCCEEDED(SHGetKnownFolderPath(FolderID, 0, nullptr, &Buf));
|
|
if (Result)
|
|
{
|
|
Path = Buf;
|
|
CoTaskMemFree(Buf);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString __fastcall UniqTempDir(const UnicodeString BaseDir, const UnicodeString Identity,
|
|
bool Mask)
|
|
{
|
|
DebugAssert(!BaseDir.IsEmpty());
|
|
UnicodeString TempDir;
|
|
do
|
|
{
|
|
TempDir = IncludeTrailingBackslash(BaseDir) + Identity;
|
|
if (Mask)
|
|
{
|
|
TempDir += L"?????";
|
|
}
|
|
else
|
|
{
|
|
TempDir += IncludeTrailingBackslash(FormatDateTime(L"nnzzz", Now()));
|
|
}
|
|
}
|
|
while (!Mask && DirectoryExists(ApiPath(TempDir)));
|
|
|
|
return TempDir;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TSessionColors : public TComponent
|
|
{
|
|
public:
|
|
__fastcall TSessionColors() : TComponent(nullptr)
|
|
{
|
|
}
|
|
|
|
static TSessionColors * __fastcall Retrieve(TComponent * Component)
|
|
{
|
|
return GetComponentInstance<TSessionColors>(Component);
|
|
}
|
|
|
|
typedef std::map<TColor, int> TColorMap;
|
|
TColorMap ColorMap;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall GetSessionColorImage(
|
|
TCustomImageList * ImageList, TColor Color, int MaskIndex)
|
|
{
|
|
|
|
TSessionColors * SessionColors = TSessionColors::Retrieve(ImageList);
|
|
|
|
int Result;
|
|
TSessionColors::TColorMap::const_iterator I = SessionColors->ColorMap.find(Color);
|
|
if (I != SessionColors->ColorMap.end())
|
|
{
|
|
Result = I->second;
|
|
}
|
|
else
|
|
{
|
|
// This overly complex drawing is here to support color button on SiteAdvanced
|
|
// dialog. There we use plain TImageList, instead of TPngImageList,
|
|
// TButton does not work with transparent images
|
|
// (not even TBitmap with Transparent = true)
|
|
std::unique_ptr<TBitmap> MaskBitmap(new TBitmap());
|
|
ImageList->GetBitmap(MaskIndex, MaskBitmap.get());
|
|
|
|
std::unique_ptr<TPngImage> MaskImage(new TPngImage());
|
|
MaskImage->Assign(MaskBitmap.get());
|
|
|
|
std::unique_ptr<TPngImage> ColorImage(new TPngImage(COLOR_RGB, 16, ImageList->Width, ImageList->Height));
|
|
|
|
TColor MaskTransparentColor = MaskImage->Pixels[0][0];
|
|
TColor TransparentColor = MaskTransparentColor;
|
|
// Expecting that the color to be replaced is in the centre of the image (HACK)
|
|
TColor MaskColor = MaskImage->Pixels[ImageList->Width / 2][ImageList->Height / 2];
|
|
|
|
for (int Y = 0; Y < ImageList->Height; Y++)
|
|
{
|
|
for (int X = 0; X < ImageList->Width; X++)
|
|
{
|
|
TColor SourceColor = MaskImage->Pixels[X][Y];
|
|
TColor DestColor;
|
|
// this branch is pointless as long as MaskTransparentColor and
|
|
// TransparentColor are the same
|
|
if (SourceColor == MaskTransparentColor)
|
|
{
|
|
DestColor = TransparentColor;
|
|
}
|
|
else if (SourceColor == MaskColor)
|
|
{
|
|
DestColor = Color;
|
|
}
|
|
else
|
|
{
|
|
DestColor = SourceColor;
|
|
}
|
|
ColorImage->Pixels[X][Y] = DestColor;
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<TBitmap> Bitmap(new TBitmap());
|
|
Bitmap->SetSize(ImageList->Width, ImageList->Height);
|
|
ColorImage->AssignTo(Bitmap.get());
|
|
|
|
Result = ImageList->AddMasked(Bitmap.get(), TransparentColor);
|
|
|
|
SessionColors->ColorMap.insert(std::make_pair(Color, Result));
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall RegenerateSessionColorsImageList(TCustomImageList * ImageList, int MaskIndex)
|
|
{
|
|
TSessionColors * SessionColors = TSessionColors::Retrieve(ImageList);
|
|
|
|
std::vector<TColor> Colors;
|
|
size_t FixedImages = static_cast<size_t>(ImageList->Count);
|
|
Colors.resize(FixedImages + SessionColors->ColorMap.size());
|
|
TSessionColors::TColorMap::const_iterator I = SessionColors->ColorMap.begin();
|
|
while (I != SessionColors->ColorMap.end())
|
|
{
|
|
DebugAssert(Colors[I->second] == TColor());
|
|
Colors[I->second] = I->first;
|
|
I++;
|
|
}
|
|
|
|
TSessionColors::TColorMap ColorMap = SessionColors->ColorMap;
|
|
SessionColors->ColorMap.clear();
|
|
|
|
for (size_t Index = 0; Index < Colors.size(); Index++)
|
|
{
|
|
bool IsFixedImageIndex = (Index < FixedImages);
|
|
DebugAssert((Colors[Index] == TColor()) == IsFixedImageIndex);
|
|
if (!IsFixedImageIndex)
|
|
{
|
|
GetSessionColorImage(ImageList, Colors[Index], MaskIndex);
|
|
}
|
|
}
|
|
|
|
DebugAssert(SessionColors->ColorMap == ColorMap);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetSubmenu(TTBXCustomItem * Item, bool Enable)
|
|
{
|
|
class TTBXPublicItem : public TTBXCustomItem
|
|
{
|
|
public:
|
|
__property ItemStyle;
|
|
};
|
|
TTBXPublicItem * PublicItem = reinterpret_cast<TTBXPublicItem *>(Item);
|
|
DebugAssert(PublicItem != NULL);
|
|
// See TTBItemViewer.IsPtInButtonPart (called from TTBItemViewer.MouseDown)
|
|
if (Enable)
|
|
{
|
|
PublicItem->ItemStyle = PublicItem->ItemStyle << tbisSubmenu;
|
|
}
|
|
else
|
|
{
|
|
PublicItem->ItemStyle = PublicItem->ItemStyle >> tbisSubmenu;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall IsEligibleForApplyingTabs(
|
|
UnicodeString Line, int & TabPos, UnicodeString & Start, UnicodeString & Remaining)
|
|
{
|
|
bool Result = false;
|
|
TabPos = Line.Pos(L"\t");
|
|
if (TabPos > 0)
|
|
{
|
|
Remaining = Line.SubString(TabPos + 1, Line.Length() - TabPos);
|
|
// WORKAROUND
|
|
// Some translations still use obsolete hack of consecutive tabs to aling the contents.
|
|
// Delete these, so that the following check does not fail on this
|
|
while (Remaining.SubString(1, 1) == L"\t")
|
|
{
|
|
Remaining.Delete(1, 1);
|
|
}
|
|
|
|
// We do not have, not support, mutiple tabs on a single line
|
|
if (DebugAlwaysTrue(Remaining.Pos(L"\t") == 0))
|
|
{
|
|
Start = Line.SubString(1, TabPos - 1);
|
|
// WORKAROUND
|
|
// Previously we padded the string before tab with spaces,
|
|
// to aling the contents across multiple lines
|
|
Start = Start.TrimRight();
|
|
// at least two normal spaces for separation
|
|
Start += L" ";
|
|
Result = true;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static int __fastcall CalculateWidthByLength(UnicodeString Text, void * /*Arg*/)
|
|
{
|
|
return Text.Length();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ApplyTabs(
|
|
UnicodeString & Text, wchar_t Padding,
|
|
TCalculateWidth CalculateWidth, void * CalculateWidthArg)
|
|
{
|
|
if (CalculateWidth == NULL)
|
|
{
|
|
DebugAssert(CalculateWidthArg == NULL);
|
|
CalculateWidth = CalculateWidthByLength;
|
|
}
|
|
|
|
std::unique_ptr<TStringList> Lines(TextToStringList(Text));
|
|
|
|
int MaxWidth = -1;
|
|
for (int Index = 0; Index < Lines->Count; Index++)
|
|
{
|
|
UnicodeString Line = Lines->Strings[Index];
|
|
int TabPos;
|
|
UnicodeString Start;
|
|
UnicodeString Remaining;
|
|
if (IsEligibleForApplyingTabs(Line, TabPos, Start, Remaining))
|
|
{
|
|
int Width = CalculateWidth(Start, CalculateWidthArg);
|
|
MaxWidth = Max(MaxWidth, Width);
|
|
}
|
|
}
|
|
|
|
// Optimization and also to prevent potential regression for texts without tabs
|
|
if (MaxWidth >= 0)
|
|
{
|
|
for (int Index = 0; Index < Lines->Count; Index++)
|
|
{
|
|
UnicodeString Line = Lines->Strings[Index];
|
|
int TabPos;
|
|
UnicodeString Start;
|
|
UnicodeString Remaining;
|
|
if (IsEligibleForApplyingTabs(Line, TabPos, Start, Remaining))
|
|
{
|
|
int Width;
|
|
int Iterations = 0;
|
|
while ((Width = CalculateWidth(Start, CalculateWidthArg)) < MaxWidth)
|
|
{
|
|
int Wider = CalculateWidth(Start + Padding, CalculateWidthArg);
|
|
// If padded string is wider than max width by more pixels
|
|
// than non-padded string is shorter than max width
|
|
if ((Wider > MaxWidth) && ((Wider - MaxWidth) > (MaxWidth - Width)))
|
|
{
|
|
break;
|
|
}
|
|
Start += Padding;
|
|
Iterations++;
|
|
// In rare case a tab is zero-width with some strange font (like HYLE)
|
|
if (Iterations > 100)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
Lines->Strings[Index] = Start + Remaining;
|
|
}
|
|
}
|
|
|
|
Text = Lines->Text;
|
|
// remove trailing newline
|
|
Text = Text.TrimRight();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall DoSelectScaledImageList(TImageList * ImageList)
|
|
{
|
|
TImageList * MatchingList = NULL;
|
|
int MachingPixelsPerInch = 0;
|
|
int PixelsPerInch = LargerPixelsPerInch(GetComponentPixelsPerInch(ImageList), WinConfiguration->LargerToolbar);
|
|
|
|
for (int Index = 0; Index < ImageList->Owner->ComponentCount; Index++)
|
|
{
|
|
TImageList * OtherList = dynamic_cast<TImageList *>(ImageList->Owner->Components[Index]);
|
|
|
|
if ((OtherList != NULL) &&
|
|
(OtherList != ImageList) &&
|
|
StartsStr(ImageList->Name, OtherList->Name))
|
|
{
|
|
UnicodeString OtherListPixelsPerInchStr =
|
|
OtherList->Name.SubString(
|
|
ImageList->Name.Length() + 1, OtherList->Name.Length() - ImageList->Name.Length());
|
|
int OtherListPixelsPerInch = StrToInt(OtherListPixelsPerInchStr);
|
|
if ((OtherListPixelsPerInch <= PixelsPerInch) &&
|
|
((MatchingList == NULL) ||
|
|
(MachingPixelsPerInch < OtherListPixelsPerInch)))
|
|
{
|
|
MatchingList = OtherList;
|
|
MachingPixelsPerInch = OtherListPixelsPerInch;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (MatchingList != NULL)
|
|
{
|
|
UnicodeString ImageListBackupName = ImageList->Name + IntToStr(USER_DEFAULT_SCREEN_DPI);
|
|
|
|
if (ImageList->Owner->FindComponent(ImageListBackupName) == NULL)
|
|
{
|
|
TImageList * ImageListBackup;
|
|
TPngImageList * PngImageList = dynamic_cast<TPngImageList *>(ImageList);
|
|
if (PngImageList != NULL)
|
|
{
|
|
ImageListBackup = new TPngImageList(ImageList->Owner);
|
|
}
|
|
else
|
|
{
|
|
ImageListBackup = new TImageList(ImageList->Owner);
|
|
}
|
|
|
|
ImageListBackup->Name = ImageListBackupName;
|
|
ImageList->Owner->InsertComponent(ImageListBackup);
|
|
CopyImageList(ImageListBackup, ImageList);
|
|
}
|
|
|
|
CopyImageList(ImageList, MatchingList);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall ImageListRescale(TComponent * Sender, TObject * /*Token*/)
|
|
{
|
|
TImageList * ImageList = DebugNotNull(dynamic_cast<TImageList *>(Sender));
|
|
DoSelectScaledImageList(ImageList);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SelectScaledImageList(TImageList * ImageList)
|
|
{
|
|
DoSelectScaledImageList(ImageList);
|
|
|
|
SetRescaleFunction(ImageList, ImageListRescale);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall CopyImageList(TImageList * TargetList, TImageList * SourceList)
|
|
{
|
|
// Maybe this is not necessary, once the TPngImageList::Assign was fixed.
|
|
// But if we ever use Assign, make sure the target keeps its Scaled property.
|
|
TPngImageList * PngTargetList = dynamic_cast<TPngImageList *>(TargetList);
|
|
TPngImageList * PngSourceList = dynamic_cast<TPngImageList *>(SourceList);
|
|
|
|
TargetList->Clear();
|
|
TargetList->Height = SourceList->Height;
|
|
TargetList->Width = SourceList->Width;
|
|
|
|
if ((PngTargetList != NULL) && (PngSourceList != NULL))
|
|
{
|
|
// AddImages won't copy the names and we need them for
|
|
// LoadDialogImage and TFrameAnimation
|
|
PngTargetList->PngImages->Assign(PngSourceList->PngImages);
|
|
}
|
|
else
|
|
{
|
|
TargetList->AddImages(SourceList);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static bool __fastcall DoLoadDialogImage(TImage * Image, const UnicodeString & ImageName)
|
|
{
|
|
bool Result = false;
|
|
if (GlyphsModule != NULL)
|
|
{
|
|
TPngImageList * DialogImages = GetDialogImages(Image);
|
|
|
|
int Index;
|
|
for (Index = 0; Index < DialogImages->PngImages->Count; Index++)
|
|
{
|
|
TPngImageCollectionItem * PngItem = DialogImages->PngImages->Items[Index];
|
|
if (SameText(PngItem->Name, ImageName))
|
|
{
|
|
Image->Picture->Assign(PngItem->PngImage);
|
|
break;
|
|
}
|
|
}
|
|
|
|
DebugAssert(Index < DialogImages->PngImages->Count);
|
|
Result = true;
|
|
}
|
|
// When showing an exception from wWinMain, the images are released already.
|
|
// Non-existence of the glyphs module is just a good indication of that.
|
|
// We expect errors only.
|
|
else if (ImageName == L"Error")
|
|
{
|
|
Image->Picture->Icon->Handle = LoadIcon(0, IDI_HAND);
|
|
}
|
|
// For showing an information about trace files
|
|
else if (DebugAlwaysTrue(ImageName == L"Information"))
|
|
{
|
|
Image->Picture->Icon->Handle = LoadIcon(0, IDI_APPLICATION);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TDialogImageName : public TObject
|
|
{
|
|
public:
|
|
UnicodeString ImageName;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall DialogImageRescale(TComponent * Sender, TObject * Token)
|
|
{
|
|
TImage * Image = DebugNotNull(dynamic_cast<TImage *>(Sender));
|
|
TDialogImageName * DialogImageName = DebugNotNull(dynamic_cast<TDialogImageName *>(Token));
|
|
DoLoadDialogImage(Image, DialogImageName->ImageName);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall LoadDialogImage(TImage * Image, const UnicodeString & ImageName)
|
|
{
|
|
if (DoLoadDialogImage(Image, ImageName))
|
|
{
|
|
TDialogImageName * DialogImageName = new TDialogImageName();
|
|
DialogImageName->ImageName = ImageName;
|
|
SetRescaleFunction(Image, DialogImageRescale, DialogImageName, true);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall DialogImageSize(TForm * Form)
|
|
{
|
|
return ScaleByPixelsPerInch(32, Form);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall HideComponentsPanel(TForm * Form)
|
|
{
|
|
TComponent * Component = DebugNotNull(Form->FindComponent(L"ComponentsPanel"));
|
|
TPanel * Panel = DebugNotNull(dynamic_cast<TPanel *>(Component));
|
|
DebugAssert(Panel->Align == alBottom);
|
|
int Offset = Panel->Height;
|
|
Panel->Visible = false;
|
|
Panel->Height = 0;
|
|
Form->Height -= Offset;
|
|
|
|
for (int Index = 0; Index < Form->ControlCount; Index++)
|
|
{
|
|
TControl * Control = Form->Controls[Index];
|
|
|
|
// Shift back bottom-anchored controls
|
|
// (needed for toolbar panel on Progress window and buttons on Preferences dialog),
|
|
if ((Control->Align == alNone) &&
|
|
Control->Anchors.Contains(akBottom) &&
|
|
!Control->Anchors.Contains(akTop))
|
|
{
|
|
Control->Top += Offset;
|
|
}
|
|
|
|
// Resize back all-anchored controls
|
|
// (needed for main panel on Preferences dialog),
|
|
if (Control->Anchors.Contains(akBottom) &&
|
|
Control->Anchors.Contains(akTop))
|
|
{
|
|
Control->Height += Offset;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TIncrementalSearchState::TIncrementalSearchState()
|
|
{
|
|
Reset();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TIncrementalSearchState::Reset()
|
|
{
|
|
Searching = false;
|
|
Text = EmptyStr;
|
|
HaveNext = false;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString FormatIncrementalSearchStatus(const TIncrementalSearchState & SearchState)
|
|
{
|
|
UnicodeString Result =
|
|
FMTLOAD(INC_SEARCH, (DefaultStr(SearchState.Text, LoadStr(INC_SEARCH_TYPE)))) +
|
|
((SearchState.HaveNext && DebugAlwaysTrue(!SearchState.Text.IsEmpty())) ? L" " + LoadStr(INC_NEXT_SEARCH) : EmptyStr);
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TCustomDocHandler : public TComponent, public ::IDocHostUIHandler
|
|
{
|
|
public:
|
|
__fastcall TCustomDocHandler(TComponent * Owner, ICustomDoc * CustomDoc) :
|
|
TComponent(Owner), FCustomDoc(CustomDoc)
|
|
{
|
|
}
|
|
|
|
virtual __fastcall ~TCustomDocHandler()
|
|
{
|
|
// Something keeps the reference behind otherwise and calls it on WM_SETTINGCHANGE.
|
|
// Would make sense with TWebBrowserEx, which leaks. But it happens even with TWebBrowser.
|
|
FCustomDoc->SetUIHandler(NULL);
|
|
FCustomDoc->Release();
|
|
}
|
|
|
|
protected:
|
|
ICustomDoc * FCustomDoc;
|
|
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Woverloaded-virtual"
|
|
virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID ClassId, void ** Intf)
|
|
{
|
|
HRESULT Result = S_OK;
|
|
if (ClassId == IID_IUnknown)
|
|
{
|
|
*Intf = static_cast<IUnknown *>(this);
|
|
}
|
|
else if (ClassId == ::IID_IDocHostUIHandler)
|
|
{
|
|
*Intf = static_cast<::IDocHostUIHandler *>(this);
|
|
}
|
|
else
|
|
{
|
|
Result = E_NOINTERFACE;
|
|
}
|
|
return Result;
|
|
}
|
|
#pragma clang diagnostic pop
|
|
|
|
virtual ULONG STDMETHODCALLTYPE AddRef()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
virtual ULONG STDMETHODCALLTYPE Release()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE ShowContextMenu(
|
|
DWORD DebugUsedArg(dwID), POINT *, IUnknown *, IDispatch *)
|
|
{
|
|
// No context menu
|
|
// (implementing IDocHostUIHandler reenabled context menu disabled by TBrowserViewer::DoContextPopup)
|
|
return S_OK;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetHostInfo(::_DOCHOSTUIINFO * Info)
|
|
{
|
|
// Setting ControlBorder is ignored with IDocHostUIHandler.
|
|
// DOCHOSTUIFLAG_DPI_AWARE does not seem to have any effect
|
|
Info->dwFlags |= DOCHOSTUIFLAG_SCROLL_NO | DOCHOSTUIFLAG_NO3DBORDER | DOCHOSTUIFLAG_DPI_AWARE;
|
|
return S_OK;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE ShowUI(
|
|
DWORD DebugUsedArg(dwID), IOleInPlaceActiveObject *, IOleCommandTarget *, IOleInPlaceFrame *, IOleInPlaceUIWindow *)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE HideUI()
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE UpdateUI()
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE EnableModeless(BOOL DebugUsedArg(fEnable))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE OnDocWindowActivate(BOOL DebugUsedArg(fActivate))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE OnFrameWindowActivate(BOOL DebugUsedArg(fActivate))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE ResizeBorder(LPCRECT, IOleInPlaceUIWindow *, BOOL DebugUsedArg(fRameWindow))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE TranslateAccelerator(LPMSG, const GUID * DebugUsedArg(pguidCmdGroup), DWORD DebugUsedArg(nCmdID))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetOptionKeyPath(LPOLESTR * DebugUsedArg(pchKey), DWORD DebugUsedArg(dw))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetDropTarget(IDropTarget *, IDropTarget **)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetExternal(IDispatch **)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE TranslateUrl(DWORD DebugUsedArg(dwTranslate), OLECHAR * DebugUsedArg(pchURLIn), OLECHAR ** DebugUsedArg(ppchURLOut))
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE FilterDataObject(IDataObject *, IDataObject **)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
// Included only here as it defines ambiguous LONG_PTR, causing INVALID_HANDLE_VALUE to be unusable
|
|
#include <WebBrowserEx.hpp>
|
|
//---------------------------------------------------------------------------
|
|
class TBrowserViewer : public TWebBrowserEx
|
|
{
|
|
public:
|
|
__fastcall virtual TBrowserViewer(TComponent* AOwner);
|
|
|
|
void __fastcall AddLinkHandler(
|
|
const UnicodeString & Url, TNotifyEvent Handler);
|
|
void __fastcall NavigateToUrl(const UnicodeString & Url);
|
|
|
|
TControl * LoadingPanel;
|
|
|
|
protected:
|
|
DYNAMIC void __fastcall DoContextPopup(const TPoint & MousePos, bool & Handled);
|
|
void __fastcall DocumentComplete(
|
|
TObject * Sender, const _di_IDispatch Disp, const OleVariant & URL);
|
|
void __fastcall BeforeNavigate2(
|
|
TObject * Sender, const _di_IDispatch Disp, const OleVariant & URL,
|
|
const OleVariant & Flags, const OleVariant & TargetFrameName,
|
|
const OleVariant & PostData, const OleVariant & Headers, WordBool & Cancel);
|
|
|
|
bool FComplete;
|
|
std::map<UnicodeString, TNotifyEvent> FHandlers;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TBrowserViewer::TBrowserViewer(TComponent* AOwner) :
|
|
TWebBrowserEx(AOwner)
|
|
{
|
|
FComplete = false;
|
|
|
|
OnDocumentComplete = DocumentComplete;
|
|
OnBeforeNavigate2 = BeforeNavigate2;
|
|
LoadingPanel = NULL;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TBrowserViewer::AddLinkHandler(
|
|
const UnicodeString & Url, TNotifyEvent Handler)
|
|
{
|
|
FHandlers.insert(std::make_pair(Url, Handler));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TBrowserViewer::DoContextPopup(const TPoint & MousePos, bool & Handled)
|
|
{
|
|
// Suppress built-in context menu.
|
|
// Is ignored with IDocHostUIHandler. Needs to be overriden by ShowContextMenu.
|
|
Handled = true;
|
|
TWebBrowserEx::DoContextPopup(MousePos, Handled);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TBrowserViewer::DocumentComplete(
|
|
TObject * /*Sender*/, const _di_IDispatch /*Disp*/, const OleVariant & /*URL*/)
|
|
{
|
|
SetBrowserDesignModeOff(this);
|
|
|
|
FComplete = true;
|
|
|
|
if (LoadingPanel != NULL)
|
|
{
|
|
LoadingPanel->Visible = false;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TBrowserViewer::BeforeNavigate2(
|
|
TObject * /*Sender*/, const _di_IDispatch /*Disp*/, const OleVariant & AURL,
|
|
const OleVariant & /*Flags*/, const OleVariant & /*TargetFrameName*/,
|
|
const OleVariant & /*PostData*/, const OleVariant & /*Headers*/, WordBool & Cancel)
|
|
{
|
|
// If OnDocumentComplete was not called yet, is has to be our initial message URL,
|
|
// opened using TWebBrowserEx::Navigate(), allow it.
|
|
// Otherwise it's user navigating, block that and open link
|
|
// in an external browser, possibly adding campaign parameters on the way.
|
|
if (FComplete)
|
|
{
|
|
Cancel = 1;
|
|
|
|
UnicodeString URL = AURL;
|
|
if (FHandlers.count(URL) > 0)
|
|
{
|
|
FHandlers[URL](this);
|
|
}
|
|
else
|
|
{
|
|
OpenBrowser(URL);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TBrowserViewer::NavigateToUrl(const UnicodeString & Url)
|
|
{
|
|
FComplete = false;
|
|
Navigate(Url.c_str());
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TWebBrowserEx * __fastcall CreateBrowserViewer(TPanel * Parent, const UnicodeString & LoadingLabel)
|
|
{
|
|
TBrowserViewer * Result = new TBrowserViewer(Parent);
|
|
// TWebBrowserEx has its own unrelated Name and Parent properties.
|
|
// The name is used in DownloadUpdate().
|
|
static_cast<TWinControl *>(Result)->Name = L"BrowserViewer";
|
|
static_cast<TWinControl *>(Result)->Parent = Parent;
|
|
Result->Align = alClient;
|
|
// Is ignored with IDocHostUIHandler. Needs to be overriden by DOCHOSTUIFLAG_NO3DBORDER in GetHostInfo.
|
|
Result->ControlBorder = cbNone;
|
|
|
|
Result->LoadingPanel = CreateLabelPanel(Parent, LoadingLabel);
|
|
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetBrowserDesignModeOff(TWebBrowserEx * WebBrowser)
|
|
{
|
|
if (DebugAlwaysTrue(WebBrowser->Document2 != NULL))
|
|
{
|
|
WebBrowser->Document2->designMode = L"Off";
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall AddBrowserLinkHandler(TWebBrowserEx * WebBrowser,
|
|
const UnicodeString & Url, TNotifyEvent Handler)
|
|
{
|
|
TBrowserViewer * BrowserViewer = dynamic_cast<TBrowserViewer *>(WebBrowser);
|
|
if (DebugAlwaysTrue(BrowserViewer != NULL))
|
|
{
|
|
BrowserViewer->AddLinkHandler(Url, Handler);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall NavigateBrowserToUrl(TWebBrowserEx * WebBrowser, const UnicodeString & Url)
|
|
{
|
|
TBrowserViewer * BrowserViewer = dynamic_cast<TBrowserViewer *>(WebBrowser);
|
|
if (DebugAlwaysTrue(BrowserViewer != NULL))
|
|
{
|
|
BrowserViewer->NavigateToUrl(Url);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void ReadyBrowserForStreaming(TWebBrowserEx * WebBrowser)
|
|
{
|
|
// This creates TWebBrowserEx::Document, which we need to stream in an in-memory document
|
|
NavigateBrowserToUrl(WebBrowser, L"about:blank");
|
|
// Needs to be followed by WaitBrowserToIdle
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void WaitBrowserToIdle(TWebBrowserEx * WebBrowser)
|
|
{
|
|
while (WebBrowser->ReadyState < ::READYSTATE_INTERACTIVE)
|
|
{
|
|
Application->ProcessMessages();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void HideBrowserScrollbars(TWebBrowserEx * WebBrowser)
|
|
{
|
|
ICustomDoc * CustomDoc = NULL;
|
|
if (DebugAlwaysTrue(WebBrowser->Document != NULL) &&
|
|
SUCCEEDED(WebBrowser->Document->QueryInterface(&CustomDoc)) &&
|
|
DebugAlwaysTrue(CustomDoc != NULL))
|
|
{
|
|
TCustomDocHandler * Handler = new TCustomDocHandler(WebBrowser, CustomDoc);
|
|
CustomDoc->SetUIHandler(Handler);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool CopyTextFromBrowser(TWebBrowserEx * WebBrowser, UnicodeString & Text)
|
|
{
|
|
WebBrowser->SelectAll();
|
|
WebBrowser->CopyToClipBoard();
|
|
bool Result = NonEmptyTextFromClipboard(Text);
|
|
WebBrowser->DoCommand(L"UNSELECT");
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPanel * CreateBlankPanel(TComponent * Owner)
|
|
{
|
|
TPanel * Panel = new TPanel(Owner);
|
|
Panel->BevelOuter = bvNone;
|
|
Panel->BevelInner = bvNone; // default
|
|
Panel->BevelKind = bkNone;
|
|
Panel->Color = clWindow;
|
|
return Panel;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPanel * CreateLabelPanel(TPanel * Parent, const UnicodeString & Label)
|
|
{
|
|
TPanel * Result = CreateBlankPanel(Parent);
|
|
Result->Parent = Parent;
|
|
Result->Align = alClient;
|
|
Result->Caption = Label;
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString GenerateAppHtmlPage(TFont * Font, TPanel * Parent, const UnicodeString & Body, bool Seamless)
|
|
{
|
|
UnicodeString Result =
|
|
L"<!DOCTYPE html>\n"
|
|
L"<meta charset=\"utf-8\">\n"
|
|
L"<html>\n"
|
|
L"<head>\n"
|
|
L"<style>\n"
|
|
L"\n"
|
|
L"body\n"
|
|
L"{\n"
|
|
L" font-family: '" + Font->Name + L"';\n"
|
|
L" margin: " + UnicodeString(Seamless ? L"0" : L"0.5em") + L";\n"
|
|
L" color: " + ColorToWebColorStr(Parent->Font->Color) + L";\n"
|
|
L" background-color: " + ColorToWebColorStr(Parent->Color) + L";\n" +
|
|
UnicodeString(Seamless ? L" overflow: hidden;\n" : L"") +
|
|
L" font-size: " + IntToStr(Font->Size) + L"pt;\n"
|
|
L"}\n"
|
|
L"\n"
|
|
L"p\n"
|
|
L"{\n"
|
|
L" margin-top: 0;\n"
|
|
L" margin-bottom: 1em;\n"
|
|
L"}\n"
|
|
L"\n"
|
|
L"a, a:visited, a:hover, a:visited, a:current\n"
|
|
L"{\n"
|
|
L" color: " + ColorToWebColorStr(GetLinkColor(Parent)) + L";\n"
|
|
L"}\n"
|
|
L"</style>\n"
|
|
L"</head>\n"
|
|
L"<body>\n" +
|
|
Body +
|
|
L"</body>\n"
|
|
L"</html>\n";
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void LoadBrowserDocument(TWebBrowserEx * WebBrowser, const UnicodeString & Document)
|
|
{
|
|
std::unique_ptr<TMemoryStream> DocumentStream(new TMemoryStream());
|
|
UTF8String DocumentUTF8 = UTF8String(Document);
|
|
DocumentStream->Write(DocumentUTF8.c_str(), DocumentUTF8.Length());
|
|
DocumentStream->Seek(0, 0);
|
|
|
|
// For stream-loaded document, when set only after loading from OnDocumentComplete,
|
|
// browser stops working
|
|
SetBrowserDesignModeOff(WebBrowser);
|
|
|
|
TStreamAdapter * DocumentStreamAdapter = new TStreamAdapter(DocumentStream.get(), soReference);
|
|
IPersistStreamInit * PersistStreamInit = NULL;
|
|
if (DebugAlwaysTrue(WebBrowser->Document != NULL) &&
|
|
SUCCEEDED(WebBrowser->Document->QueryInterface(IID_IPersistStreamInit, reinterpret_cast<void **>(&PersistStreamInit))) &&
|
|
DebugAlwaysTrue(PersistStreamInit != NULL))
|
|
{
|
|
PersistStreamInit->Load(static_cast<_di_IStream>(*DocumentStreamAdapter));
|
|
PersistStreamInit->Release();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TComponent * __fastcall FindComponentRecursively(TComponent * Root, const UnicodeString & Name)
|
|
{
|
|
for (int Index = 0; Index < Root->ComponentCount; Index++)
|
|
{
|
|
TComponent * Component = Root->Components[Index];
|
|
if (CompareText(Component->Name, Name) == 0)
|
|
{
|
|
return Component;
|
|
}
|
|
|
|
Component = FindComponentRecursively(Component, Name);
|
|
if (Component != NULL)
|
|
{
|
|
return Component;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall GetInstrutionsTheme(
|
|
TColor & MainInstructionColor, HFONT & MainInstructionFont, HFONT & InstructionFont)
|
|
{
|
|
MainInstructionColor = Graphics::clNone;
|
|
MainInstructionFont = 0;
|
|
InstructionFont = 0;
|
|
HTHEME Theme = OpenThemeData(0, L"TEXTSTYLE");
|
|
if (Theme != NULL)
|
|
{
|
|
LOGFONT AFont;
|
|
COLORREF AColor;
|
|
|
|
memset(&AFont, 0, sizeof(AFont));
|
|
// Using Canvas->Handle in the 2nd argument we can get scaled font,
|
|
// but at this point the form is sometime not scaled yet (difference is particularly for standalone messages like
|
|
// /UninstallCleanup), so the results are inconsistent.
|
|
if (GetThemeFont(Theme, NULL, TEXT_MAININSTRUCTION, 0, TMT_FONT, &AFont) == S_OK)
|
|
{
|
|
MainInstructionFont = CreateFontIndirect(&AFont);
|
|
}
|
|
if (GetThemeColor(Theme, TEXT_MAININSTRUCTION, 0, TMT_TEXTCOLOR, &AColor) == S_OK)
|
|
{
|
|
MainInstructionColor = static_cast<TColor>(AColor);
|
|
}
|
|
|
|
memset(&AFont, 0, sizeof(AFont));
|
|
if (GetThemeFont(Theme, NULL, TEXT_INSTRUCTION, 0, TMT_FONT, &AFont) == S_OK)
|
|
{
|
|
InstructionFont = CreateFontIndirect(&AFont);
|
|
}
|
|
|
|
CloseThemeData(Theme);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TLocalCustomCommand::TLocalCustomCommand()
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TLocalCustomCommand::TLocalCustomCommand(
|
|
const TCustomCommandData & Data, const UnicodeString & RemotePath, const UnicodeString & LocalPath) :
|
|
TFileCustomCommand(Data, RemotePath)
|
|
{
|
|
FLocalPath = LocalPath;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TLocalCustomCommand::TLocalCustomCommand(const TCustomCommandData & Data,
|
|
const UnicodeString & RemotePath, const UnicodeString & LocalPath, const UnicodeString & FileName,
|
|
const UnicodeString & LocalFileName, const UnicodeString & FileList) :
|
|
TFileCustomCommand(Data, RemotePath, FileName, FileList)
|
|
{
|
|
FLocalPath = LocalPath;
|
|
FLocalFileName = LocalFileName;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TLocalCustomCommand::PatternLen(const UnicodeString & Command, int Index)
|
|
{
|
|
int Len;
|
|
if ((Index < Command.Length()) && (Command[Index + 1] == L'\\'))
|
|
{
|
|
Len = 2;
|
|
}
|
|
else if ((Index < Command.Length()) && (Command[Index + 1] == L'^'))
|
|
{
|
|
Len = 3;
|
|
}
|
|
else
|
|
{
|
|
Len = TFileCustomCommand::PatternLen(Command, Index);
|
|
}
|
|
return Len;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TLocalCustomCommand::PatternReplacement(
|
|
int Index, const UnicodeString & Pattern, UnicodeString & Replacement, bool & Delimit)
|
|
{
|
|
bool Result;
|
|
if (Pattern == L"!\\")
|
|
{
|
|
// When used as "!\" in an argument to PowerShell, the trailing \ would escape the ",
|
|
// so we exclude it
|
|
Replacement = ExcludeTrailingBackslash(FLocalPath);
|
|
Result = true;
|
|
}
|
|
else if (Pattern == L"!^!")
|
|
{
|
|
Replacement = FLocalFileName;
|
|
Result = true;
|
|
}
|
|
else
|
|
{
|
|
Result = TFileCustomCommand::PatternReplacement(Index, Pattern, Replacement, Delimit);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TLocalCustomCommand::DelimitReplacement(
|
|
UnicodeString & /*Replacement*/, wchar_t /*Quote*/)
|
|
{
|
|
// never delimit local commands
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TLocalCustomCommand::HasLocalFileName(const UnicodeString & Command)
|
|
{
|
|
return FindPattern(Command, L'^');
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TLocalCustomCommand::IsFileCommand(const UnicodeString & Command)
|
|
{
|
|
return TFileCustomCommand::IsFileCommand(Command) || HasLocalFileName(Command);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
typedef std::set<TDataModule *> TImagesModules;
|
|
static TImagesModules ImagesModules;
|
|
static std::map<int, TPngImageList *> AnimationsImages;
|
|
static std::map<int, TImageList *> ButtonImages;
|
|
static std::map<int, TPngImageList *> DialogImages;
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall DoNormalizePixelsPerInch(int PixelsPerInch, bool Larger)
|
|
{
|
|
if (PixelsPerInch >= 192)
|
|
{
|
|
PixelsPerInch = 192;
|
|
}
|
|
else if (PixelsPerInch >= 144)
|
|
{
|
|
PixelsPerInch = Larger ? 192 : 144;
|
|
}
|
|
else if (PixelsPerInch >= 120)
|
|
{
|
|
PixelsPerInch = Larger ? 144 : 120;
|
|
}
|
|
else
|
|
{
|
|
PixelsPerInch = Larger ? 120 : 96;
|
|
}
|
|
return PixelsPerInch;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int NormalizePixelsPerInch(int PixelsPerInch)
|
|
{
|
|
return DoNormalizePixelsPerInch(PixelsPerInch, false);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int LargerPixelsPerInch(int PixelsPerInch, int Larger)
|
|
{
|
|
int Result = PixelsPerInch;
|
|
while (Larger > 0)
|
|
{
|
|
Result = DoNormalizePixelsPerInch(Result, true);
|
|
Larger--;
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static int __fastcall NeedImagesModule(TControl * Control)
|
|
{
|
|
int PixelsPerInch = NormalizePixelsPerInch(GetControlPixelsPerInch(Control));
|
|
|
|
if (AnimationsImages.find(PixelsPerInch) == AnimationsImages.end())
|
|
{
|
|
TDataModule * ImagesModule;
|
|
HMODULE ResourceModule = GUIConfiguration->ChangeToDefaultResourceModule();
|
|
try
|
|
{
|
|
if (PixelsPerInch == 192)
|
|
{
|
|
ImagesModule = new TAnimations192Module(Application);
|
|
}
|
|
else if (PixelsPerInch == 144)
|
|
{
|
|
ImagesModule = new TAnimations144Module(Application);
|
|
}
|
|
else if (PixelsPerInch == 120)
|
|
{
|
|
ImagesModule = new TAnimations120Module(Application);
|
|
}
|
|
else
|
|
{
|
|
DebugAssert(PixelsPerInch == 96);
|
|
ImagesModule = new TAnimations96Module(Application);
|
|
}
|
|
|
|
ImagesModules.insert(ImagesModule);
|
|
|
|
TPngImageList * AAnimationImages =
|
|
DebugNotNull(dynamic_cast<TPngImageList *>(ImagesModule->FindComponent(L"AnimationImages")));
|
|
AnimationsImages.insert(std::make_pair(PixelsPerInch, AAnimationImages));
|
|
|
|
TImageList * AButtonImages =
|
|
DebugNotNull(dynamic_cast<TImageList *>(ImagesModule->FindComponent(L"ButtonImages")));
|
|
ButtonImages.insert(std::make_pair(PixelsPerInch, AButtonImages));
|
|
|
|
TPngImageList * ADialogImages =
|
|
DebugNotNull(dynamic_cast<TPngImageList *>(ImagesModule->FindComponent(L"DialogImages")));
|
|
DialogImages.insert(std::make_pair(PixelsPerInch, ADialogImages));
|
|
}
|
|
__finally
|
|
{
|
|
GUIConfiguration->ChangeResourceModule(ResourceModule);
|
|
}
|
|
}
|
|
|
|
return PixelsPerInch;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPngImageList * __fastcall GetAnimationsImages(TControl * Control)
|
|
{
|
|
int PixelsPerInch = NeedImagesModule(Control);
|
|
return DebugNotNull(AnimationsImages[PixelsPerInch]);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TImageList * __fastcall GetButtonImages(TControl * Control)
|
|
{
|
|
int PixelsPerInch = NeedImagesModule(Control);
|
|
return DebugNotNull(ButtonImages[PixelsPerInch]);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPngImageList * __fastcall GetDialogImages(TControl * Control)
|
|
{
|
|
int PixelsPerInch = NeedImagesModule(Control);
|
|
return DebugNotNull(DialogImages[PixelsPerInch]);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ReleaseImagesModules()
|
|
{
|
|
|
|
TImagesModules::iterator i = ImagesModules.begin();
|
|
while (i != ImagesModules.end())
|
|
{
|
|
delete (*i);
|
|
i++;
|
|
}
|
|
ImagesModules.clear();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TFrameAnimation::TFrameAnimation()
|
|
{
|
|
FFirstFrame = -1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Init(TPaintBox * PaintBox, const UnicodeString & Name)
|
|
{
|
|
FName = Name;
|
|
FPaintBox = PaintBox;
|
|
|
|
FPaintBox->ControlStyle = FPaintBox->ControlStyle << csOpaque;
|
|
DebugAssert((FPaintBox->OnPaint == NULL) || (FPaintBox->OnPaint == PaintBoxPaint));
|
|
FPaintBox->OnPaint = PaintBoxPaint;
|
|
SetRescaleFunction(FPaintBox, PaintBoxRescale, reinterpret_cast<TObject *>(this));
|
|
|
|
DoInit();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::DoInit()
|
|
{
|
|
FImageList = GetAnimationsImages(FPaintBox);
|
|
FFirstFrame = -1;
|
|
FFirstLoopFrame = -1;
|
|
FPaintBox->Width = FImageList->Width;
|
|
FPaintBox->Height = FImageList->Height;
|
|
|
|
if (!FName.IsEmpty())
|
|
{
|
|
int Frame = 0;
|
|
while (Frame < FImageList->PngImages->Count)
|
|
{
|
|
UnicodeString FrameData = FImageList->PngImages->Items[Frame]->Name;
|
|
UnicodeString FrameName;
|
|
FrameName = CutToChar(FrameData, L'_', false);
|
|
|
|
if (SameText(FName, FrameName))
|
|
{
|
|
int FrameIndex = StrToInt(CutToChar(FrameData, L'_', false));
|
|
if (FFirstFrame < 0)
|
|
{
|
|
FFirstFrame = Frame;
|
|
}
|
|
if ((FFirstLoopFrame < 0) && (FrameIndex > 0))
|
|
{
|
|
FFirstLoopFrame = Frame;
|
|
}
|
|
FLastFrame = Frame;
|
|
}
|
|
else
|
|
{
|
|
if (FFirstFrame >= 0)
|
|
{
|
|
// optimization
|
|
break;
|
|
}
|
|
}
|
|
Frame++;
|
|
}
|
|
|
|
DebugAssert(FFirstFrame >= 0);
|
|
DebugAssert(FFirstLoopFrame >= 0);
|
|
}
|
|
|
|
Stop();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::PaintBoxRescale(TComponent * /*Sender*/, TObject * Token)
|
|
{
|
|
TFrameAnimation * FrameAnimation = reinterpret_cast<TFrameAnimation *>(Token);
|
|
FrameAnimation->Rescale();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Rescale()
|
|
{
|
|
bool Started = (FTimer != NULL) && FTimer->Enabled;
|
|
DoInit();
|
|
if (Started)
|
|
{
|
|
Start();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Start()
|
|
{
|
|
if (FFirstFrame >= 0)
|
|
{
|
|
FNextFrameTick = GetTickCount();
|
|
CalculateNextFrameTick();
|
|
|
|
if (FTimer == NULL)
|
|
{
|
|
FTimer = new TTimer(GetParentForm(FPaintBox));
|
|
FTimer->Interval = static_cast<int>(GUIUpdateInterval);
|
|
FTimer->OnTimer = Timer;
|
|
}
|
|
else
|
|
{
|
|
// reset timer
|
|
FTimer->Enabled = false;
|
|
FTimer->Enabled = true;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Timer(TObject * /*Sender*/)
|
|
{
|
|
Animate();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::PaintBoxPaint(TObject * Sender)
|
|
{
|
|
if (FFirstFrame >= 0)
|
|
{
|
|
// Double-buffered drawing to prevent flicker (as the images are transparent)
|
|
DebugUsedParam(Sender);
|
|
DebugAssert(FPaintBox == Sender);
|
|
DebugAssert(FPaintBox->ControlStyle.Contains(csOpaque));
|
|
std::unique_ptr<TBitmap> Bitmap(new TBitmap());
|
|
Bitmap->SetSize(FPaintBox->Width, FPaintBox->Height);
|
|
Bitmap->Canvas->Brush->Color = FPaintBox->Color;
|
|
TRect Rect(0, 0, Bitmap->Width, Bitmap->Height);
|
|
Bitmap->Canvas->FillRect(Rect);
|
|
TGraphic * Graphic = GetCurrentImage()->PngImage;
|
|
DebugAssert(Graphic->Width == FPaintBox->Width);
|
|
DebugAssert(Graphic->Height == FPaintBox->Height);
|
|
Bitmap->Canvas->Draw(0, 0, Graphic);
|
|
FPaintBox->Canvas->Draw(0, 0, Bitmap.get());
|
|
}
|
|
FPainted = true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Repaint()
|
|
{
|
|
FPainted = false;
|
|
// If the form is not showing yet, the Paint() is not even called
|
|
FPaintBox->Repaint();
|
|
if (!FPainted)
|
|
{
|
|
// Paint later, alternatively we may keep trying Repaint() in Animate().
|
|
// See also a hack in TAuthenticateForm::Log.
|
|
FPaintBox->Invalidate();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Stop()
|
|
{
|
|
FNextFrameTick = std::numeric_limits<DWORD>::max();
|
|
FCurrentFrame = FFirstFrame;
|
|
Repaint();
|
|
|
|
if (FTimer != NULL)
|
|
{
|
|
FTimer->Enabled = false;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::Animate()
|
|
{
|
|
if (FFirstFrame >= 0)
|
|
{
|
|
// UPGRADE: Use GetTickCount64() when we stop supporting Windows XP.
|
|
DWORD TickCount = GetTickCount();
|
|
|
|
// Keep in sync with an opposite condition at the end of the loop.
|
|
// We may skip some frames if we got stalled for a while
|
|
while (TickCount >= FNextFrameTick)
|
|
{
|
|
if (FCurrentFrame >= FLastFrame)
|
|
{
|
|
FCurrentFrame = FFirstLoopFrame;
|
|
}
|
|
else
|
|
{
|
|
FCurrentFrame++;
|
|
}
|
|
|
|
CalculateNextFrameTick();
|
|
|
|
Repaint();
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPngImageCollectionItem * __fastcall TFrameAnimation::GetCurrentImage()
|
|
{
|
|
return FImageList->PngImages->Items[FCurrentFrame];
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TFrameAnimation::CalculateNextFrameTick()
|
|
{
|
|
TPngImageCollectionItem * ImageItem = GetCurrentImage();
|
|
UnicodeString Duration = ImageItem->Name;
|
|
CutToChar(Duration, L'_', false);
|
|
// skip index (is not really used)
|
|
CutToChar(Duration, L'_', false);
|
|
// This should overflow, when tick count wraps.
|
|
FNextFrameTick += StrToInt(Duration) * 10;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// Hints use:
|
|
// - Cleanup list tooltip (multi line)
|
|
// - Combo edit button
|
|
// - Transfer settings label (multi line, follows label size and font)
|
|
// - HintLabel (hint and persistent hint, multi line)
|
|
// - status bar hints
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TScreenTipHintWindow::TScreenTipHintWindow(TComponent * Owner) :
|
|
THintWindow(Owner)
|
|
{
|
|
FParentPainting = false;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TScreenTipHintWindow::GetTextFlags(TControl * Control)
|
|
{
|
|
return DT_LEFT | DT_WORDBREAK | DT_NOPREFIX | Control->DrawTextBiDiModeFlagsReadingOnly();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TScreenTipHintWindow::UseBoldShortHint(TControl * HintControl)
|
|
{
|
|
return
|
|
(dynamic_cast<TTBCustomDockableWindow *>(HintControl) != NULL) ||
|
|
(dynamic_cast<TTBPopupWindow *>(HintControl) != NULL) ||
|
|
(HintControl->Perform(WM_WANTS_SCREEN_TIPS, 0, NativeInt(0)) == 1);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TScreenTipHintWindow::IsPathLabel(TControl * HintControl)
|
|
{
|
|
return (dynamic_cast<TPathLabel *>(HintControl) != NULL);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall TScreenTipHintWindow::GetMargin(TControl * HintControl, const UnicodeString & Hint)
|
|
{
|
|
int Result;
|
|
|
|
if (HasLabelHintPopup(HintControl, Hint) || IsPathLabel(HintControl))
|
|
{
|
|
Result = 3;
|
|
}
|
|
else
|
|
{
|
|
Result = 6;
|
|
}
|
|
|
|
Result = ScaleByTextHeight(HintControl, Result);
|
|
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TFont * __fastcall TScreenTipHintWindow::GetFont(TControl * HintControl, const UnicodeString & Hint)
|
|
{
|
|
TFont * Result;
|
|
if (HasLabelHintPopup(HintControl, Hint) || IsPathLabel(HintControl))
|
|
{
|
|
Result = reinterpret_cast<TLabel *>(dynamic_cast<TCustomLabel *>(HintControl))->Font;
|
|
}
|
|
else
|
|
{
|
|
FScaledHintFont.reset(new TFont());
|
|
FScaledHintFont->Assign(Screen->HintFont);
|
|
FScaledHintFont->Size = ScaleByPixelsPerInchFromSystem(FScaledHintFont->Size, HintControl);
|
|
Result = FScaledHintFont.get();
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TScreenTipHintWindow::CalcHintTextRect(TControl * Control, TCanvas * Canvas, TRect & Rect, const UnicodeString & Hint)
|
|
{
|
|
const int Flags = DT_CALCRECT | GetTextFlags(Control);
|
|
DrawText(Canvas->Handle, Hint.c_str(), -1, &Rect, Flags);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TRect __fastcall TScreenTipHintWindow::CalcHintRect(int MaxWidth, const UnicodeString AHint, void * AData)
|
|
{
|
|
TControl * HintControl = GetHintControl(AData);
|
|
int Margin = GetMargin(HintControl, AHint);
|
|
UnicodeString ShortHint;
|
|
UnicodeString LongHint;
|
|
SplitHint(HintControl, AHint, ShortHint, LongHint);
|
|
|
|
Canvas->Font->Assign(GetFont(HintControl, AHint));
|
|
|
|
// from XE6 Vcl.ScreenTips.pas, but absent in 11
|
|
const int cScreenTipTextOnlyWidth = 210;
|
|
const int ScreenTipTextOnlyWidth = ScaleByTextHeight(HintControl, cScreenTipTextOnlyWidth);
|
|
|
|
int LongHintMargin = 0; // shut up
|
|
bool HasLongHint = !LongHint.IsEmpty();
|
|
if (HasLongHint)
|
|
{
|
|
// double-margin on the right
|
|
LongHintMargin = (3 * Margin);
|
|
MaxWidth = ScreenTipTextOnlyWidth - LongHintMargin;
|
|
}
|
|
|
|
// Multi line short hints can be twice as wide, to not break the individual lines unless really necessary.
|
|
// (login site tree, clean up dialog list, preferences custom command list, persistent hint, etc).
|
|
// And they also can be twice as wide, to not break the individual lines unless really necessary.
|
|
if (ShortHint.Pos(L"\n") > 0)
|
|
{
|
|
MaxWidth *= 2;
|
|
}
|
|
|
|
bool HintPopup = HasLabelHintPopup(HintControl, AHint);
|
|
if (HintPopup)
|
|
{
|
|
MaxWidth = HintControl->Width;
|
|
}
|
|
|
|
if (UseBoldShortHint(HintControl))
|
|
{
|
|
Canvas->Font->Style = TFontStyles() << fsBold;
|
|
}
|
|
TRect ShortRect(0, 0, MaxWidth, 0);
|
|
CalcHintTextRect(this, Canvas, ShortRect, ShortHint);
|
|
Canvas->Font->Style = TFontStyles();
|
|
|
|
TRect Result;
|
|
|
|
if (!HasLongHint)
|
|
{
|
|
Result = ShortRect;
|
|
|
|
if (HintPopup)
|
|
{
|
|
Result.Right = MaxWidth + 2 * Margin;
|
|
}
|
|
else
|
|
{
|
|
Result.Right += 3 * Margin;
|
|
}
|
|
|
|
Result.Bottom += 2 * Margin;
|
|
}
|
|
else
|
|
{
|
|
const int LongIndentation = Margin * 3 / 2;
|
|
TRect LongRect(0, 0, MaxWidth - LongIndentation, 0);
|
|
CalcHintTextRect(this, Canvas, LongRect, LongHint);
|
|
|
|
Result.Right = Max(ScreenTipTextOnlyWidth, LongRect.Right + LongIndentation + LongHintMargin);
|
|
Result.Bottom = Margin + ShortRect.Height() + (Margin / 3 * 5) + LongRect.Height() + Margin;
|
|
}
|
|
|
|
// VCLCOPY: To counter the increase in THintWindow::ActivateHintData
|
|
Result.Bottom -= 4;
|
|
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TScreenTipHintWindow::SplitHint(
|
|
TControl * HintControl, const UnicodeString & Hint, UnicodeString & ShortHint, UnicodeString & LongHint)
|
|
{
|
|
if (HasLabelHintPopup(HintControl, Hint))
|
|
{
|
|
ShortHint = HintControl->Hint;
|
|
}
|
|
else
|
|
{
|
|
ShortHint = GetShortHint(Hint);
|
|
LongHint = GetLongHintIfAny(Hint);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TScreenTipHintWindow::ActivateHintData(const TRect & ARect, const UnicodeString AHint, void * AData)
|
|
{
|
|
FHintControl = GetHintControl(AData);
|
|
SplitHint(FHintControl, AHint, FShortHint, FLongHint);
|
|
FMargin = GetMargin(FHintControl, AHint);
|
|
FHintPopup = HasLabelHintPopup(FHintControl, AHint);
|
|
|
|
Canvas->Font->Assign(GetFont(FHintControl, AHint));
|
|
|
|
TRect Rect = ARect;
|
|
|
|
if (FHintPopup)
|
|
{
|
|
Rect.SetLocation(FHintControl->ClientToScreen(TPoint(-FMargin, -FMargin)));
|
|
}
|
|
if (IsPathLabel(FHintControl))
|
|
{
|
|
Rect.Offset(-FMargin, -FMargin);
|
|
}
|
|
|
|
THintWindow::ActivateHintData(Rect, FShortHint, AData);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TControl * __fastcall TScreenTipHintWindow::GetHintControl(void * Data)
|
|
{
|
|
return reinterpret_cast<TControl *>(DebugNotNull(Data));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString __fastcall TScreenTipHintWindow::GetLongHintIfAny(const UnicodeString & AHint)
|
|
{
|
|
UnicodeString Result;
|
|
int P = Pos(L"|", AHint);
|
|
if (P > 0)
|
|
{
|
|
Result = GetLongHint(AHint);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TScreenTipHintWindow::Dispatch(void * AMessage)
|
|
{
|
|
TMessage * Message = static_cast<TMessage*>(AMessage);
|
|
switch (Message->Msg)
|
|
{
|
|
case WM_GETTEXTLENGTH:
|
|
if (FParentPainting)
|
|
{
|
|
// make THintWindow::Paint() not paint the Caption
|
|
Message->Result = 0;
|
|
}
|
|
else
|
|
{
|
|
THintWindow::Dispatch(AMessage);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
THintWindow::Dispatch(AMessage);
|
|
break;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TScreenTipHintWindow::Paint()
|
|
{
|
|
// paint frame/background
|
|
{
|
|
TAutoFlag ParentPaintingFlag(FParentPainting);
|
|
THintWindow::Paint();
|
|
}
|
|
|
|
const int Flags = GetTextFlags(this);
|
|
const int Margin = FMargin - 1; // 1 = border
|
|
|
|
TRect Rect = ClientRect;
|
|
Rect.Inflate(-Margin, -Margin);
|
|
if (!FHintPopup)
|
|
{
|
|
Rect.Right -= FMargin;
|
|
}
|
|
if (UseBoldShortHint(FHintControl))
|
|
{
|
|
Canvas->Font->Style = TFontStyles() << fsBold;
|
|
}
|
|
DrawText(Canvas->Handle, FShortHint.c_str(), -1, &Rect, Flags);
|
|
TRect ShortRect = Rect;
|
|
DrawText(Canvas->Handle, FShortHint.c_str(), -1, &ShortRect, DT_CALCRECT | Flags);
|
|
Canvas->Font->Style = TFontStyles();
|
|
|
|
if (!FLongHint.IsEmpty())
|
|
{
|
|
Rect.Left += FMargin * 3 / 2;
|
|
Rect.Top += ShortRect.Height() + (FMargin / 3 * 5);
|
|
DrawText(Canvas->Handle, FLongHint.c_str(), -1, &Rect, Flags);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static int HideAccelFlag(TControl * Control)
|
|
{
|
|
//ask the top level window about its UI state
|
|
while (Control->Parent != NULL)
|
|
{
|
|
Control = Control->Parent;
|
|
}
|
|
int Result;
|
|
if (FLAGSET(Control->Perform(WM_QUERYUISTATE, 0, NativeInt(0)), UISF_HIDEACCEL))
|
|
{
|
|
Result = DT_HIDEPREFIX;
|
|
}
|
|
else
|
|
{
|
|
Result = 0;
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TDarkUxThemeStyle : public TUxThemeStyle
|
|
{
|
|
public:
|
|
static TDarkUxThemeStyle * Instance();
|
|
|
|
protected:
|
|
virtual bool __fastcall DoDrawText(
|
|
HDC DC, const TThemedElementDetails & Details, const UnicodeString S, TRect & R, TTextFormat Flags,
|
|
const TStyleTextOptions & Options, int DPI);
|
|
|
|
private:
|
|
static std::unique_ptr<TDarkUxThemeStyle> FInstance;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
std::unique_ptr<TDarkUxThemeStyle> TDarkUxThemeStyle::FInstance;
|
|
//---------------------------------------------------------------------------
|
|
TDarkUxThemeStyle * TDarkUxThemeStyle::Instance()
|
|
{
|
|
if (FInstance.get() == NULL)
|
|
{
|
|
FInstance.reset(new TDarkUxThemeStyle());
|
|
}
|
|
return FInstance.get();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TDarkUxThemeStyle::DoDrawText(
|
|
HDC DC, const TThemedElementDetails & Details, const UnicodeString S, TRect & R, TTextFormat Flags,
|
|
const TStyleTextOptions & AOptions, int DPI)
|
|
{
|
|
TStyleTextOptions Options = AOptions;
|
|
Options.TextColor = GetWindowTextColor(GetBtnFaceColor());
|
|
Options.Flags << stfTextColor;
|
|
return TUxThemeStyle::DoDrawText(DC, Details, S, R, Flags, Options, DPI);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// For controls that need both custom VCL theme style and custom Windows theme.
|
|
// Currently the checkbox (custom VCL theme for light caption and custom Windows theme for dark more checkbox bitmaps).
|
|
// Current this handles only "button" theme.
|
|
// It's a singleton and can be used only for controls that share the same Windows theme (curently used with "explorer").
|
|
class TDarkExplorerUxThemeStyle : public TDarkUxThemeStyle
|
|
{
|
|
public:
|
|
static const UnicodeString ThemeName;
|
|
|
|
virtual __fastcall TDarkExplorerUxThemeStyle();
|
|
virtual __fastcall ~TDarkExplorerUxThemeStyle();
|
|
void SetControl(TWinControl * Control);
|
|
|
|
protected:
|
|
virtual NativeUInt __fastcall GetTheme(TThemedElement Element);
|
|
virtual NativeUInt __fastcall GetThemeForDPI(TThemedElement Element, int DPI);
|
|
virtual void __fastcall UpdateThemes();
|
|
virtual bool __fastcall DoDrawText(
|
|
HDC DC, const TThemedElementDetails & Details, const UnicodeString S, TRect & R, TTextFormat Flags,
|
|
const TStyleTextOptions & Options, int DPI);
|
|
|
|
protected:
|
|
typedef std::map<int, NativeUInt> TThemes;
|
|
TThemes FThemes;
|
|
bool FInitialized;
|
|
HWND FControlHandle;
|
|
int FTextFlags;
|
|
|
|
bool DoGetTheme(TThemedElement Element, int DPI, NativeUInt & Result);
|
|
void Clear();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
const UnicodeString TDarkExplorerUxThemeStyle::ThemeName = L"explorer";
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TDarkExplorerUxThemeStyle::TDarkExplorerUxThemeStyle()
|
|
{
|
|
FControlHandle = NULL;
|
|
FTextFlags = 0;
|
|
FInitialized = true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TDarkExplorerUxThemeStyle::~TDarkExplorerUxThemeStyle()
|
|
{
|
|
Clear();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TDarkExplorerUxThemeStyle::SetControl(TWinControl * Control)
|
|
{
|
|
// Handle is safer than a pointer
|
|
if (Control->HandleAllocated())
|
|
{
|
|
FControlHandle = Control->Handle;
|
|
// WORKAROUND - VCL does not hide accelerator of custom-styled (at least) checkboxes
|
|
FTextFlags = HideAccelFlag(Control);
|
|
}
|
|
else
|
|
{
|
|
FControlHandle = 0;
|
|
FTextFlags = 0;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
NativeUInt __fastcall TDarkExplorerUxThemeStyle::GetTheme(TThemedElement Element)
|
|
{
|
|
NativeUInt Result;
|
|
if (!DoGetTheme(Element, 0, Result))
|
|
{
|
|
Result = TDarkUxThemeStyle::GetTheme(Element);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
NativeUInt __fastcall TDarkExplorerUxThemeStyle::GetThemeForDPI(TThemedElement Element, int DPI)
|
|
{
|
|
NativeUInt Result;
|
|
if (!DoGetTheme(Element, DPI, Result))
|
|
{
|
|
Result = TDarkUxThemeStyle::GetThemeForDPI(Element, DPI);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool TDarkExplorerUxThemeStyle::DoGetTheme(TThemedElement Element, int DPI, NativeUInt & Result)
|
|
{
|
|
bool Handle = DebugAlwaysTrue(FControlHandle != 0) && DebugAlwaysTrue(Element == teButton);
|
|
if (Handle)
|
|
{
|
|
if (DPI == 0)
|
|
{
|
|
DPI = Screen->PixelsPerInch;
|
|
}
|
|
|
|
TThemes::const_iterator ITheme = FThemes.find(DPI);
|
|
if (ITheme != FThemes.end())
|
|
{
|
|
Result = ITheme->second;
|
|
}
|
|
else
|
|
{
|
|
if (!UseThemes())
|
|
{
|
|
Result = 0;
|
|
}
|
|
else
|
|
{
|
|
HTHEME Theme;
|
|
const wchar_t * ClassName = L"button";
|
|
if (!IsWin10() || !IsWin10Build(15063) || (DPI == Screen->PixelsPerInch))
|
|
{
|
|
Theme = OpenThemeData(FControlHandle, ClassName);
|
|
}
|
|
else
|
|
{
|
|
Theme = OpenThemeDataForDpi(FControlHandle, ClassName, DPI);
|
|
}
|
|
Result = reinterpret_cast<NativeUInt>(Theme);
|
|
}
|
|
|
|
FThemes.insert(std::make_pair(DPI, Result));
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TDarkExplorerUxThemeStyle::Clear()
|
|
{
|
|
TThemes Themes;
|
|
// TUxThemeStyle.UnloadThemeData implementation (FThemeDataUnLoading) imply
|
|
// that GetTheme might be called while unloading, so protecting against that
|
|
FThemes.swap(Themes);
|
|
|
|
TThemes::iterator I = Themes.begin();
|
|
while (I != Themes.end())
|
|
{
|
|
CloseThemeData(reinterpret_cast<HTHEME>(I->second));
|
|
++I;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TDarkExplorerUxThemeStyle::UpdateThemes()
|
|
{
|
|
TDarkUxThemeStyle::UpdateThemes();
|
|
// This is only ever called from the constructor, where FThemes is not initialized yet.
|
|
// It's not called for theme updates, as it is called only for the detault global app theme instance.
|
|
if (DebugAlwaysFalse(FInitialized))
|
|
{
|
|
Clear();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TDarkExplorerUxThemeStyle::DoDrawText(
|
|
HDC DC, const TThemedElementDetails & Details, const UnicodeString S, TRect & R, TTextFormat Flags,
|
|
const TStyleTextOptions & Options, int DPI)
|
|
{
|
|
int TextFlags = FTextFlags;
|
|
if (FLAGSET(TextFlags, DT_HIDEPREFIX))
|
|
{
|
|
TextFlags -= DT_HIDEPREFIX;
|
|
Flags << tfHidePrefix;
|
|
}
|
|
DebugAssert(TextFlags == 0);
|
|
DebugUsedParam(TextFlags);
|
|
return TDarkUxThemeStyle::DoDrawText(DC, Details, S, R, Flags, Options, DPI);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static std::unique_ptr<TDarkExplorerUxThemeStyle> DarkExplorerUxThemeStyle;
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// Based on:
|
|
// https://stackoverflow.com/q/6912424/850848
|
|
// https://stackoverflow.com/q/4685863/850848
|
|
class TUIStateAwareLabel : public TLabel
|
|
{
|
|
public:
|
|
__fastcall virtual TUIStateAwareLabel(TComponent * AOwner);
|
|
|
|
protected:
|
|
DYNAMIC void __fastcall DoDrawText(TRect & Rect, int Flags);
|
|
virtual void __fastcall Dispatch(void * AMessage);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
TLabel * CreateLabel(TComponent * AOwner)
|
|
{
|
|
return new TUIStateAwareLabel(AOwner);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TUIStateAwareLabel::TUIStateAwareLabel(TComponent * AOwner) :
|
|
TLabel(AOwner)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TUIStateAwareLabel::DoDrawText(TRect & Rect, int Flags)
|
|
{
|
|
if (ShowAccelChar)
|
|
{
|
|
Flags = Flags | HideAccelFlag(this);
|
|
}
|
|
TLabel::DoDrawText(Rect, Flags);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TUIStateAwareLabel::Dispatch(void * AMessage)
|
|
{
|
|
TMessage * Message = static_cast<TMessage*>(AMessage);
|
|
// WORKAROUND: Particularly when focusing csDropDownList-style combobox via label, there's no visual feedback
|
|
// that the combobox was selected (strangely, there is, when the previous focus was on TTreeView).
|
|
// For consistency, we enable focus display for all controls types (like checkboxes).
|
|
if (Message->Msg == CM_DIALOGCHAR)
|
|
{
|
|
bool WasFocused = (FocusControl != NULL) ? FocusControl->Focused() : false;
|
|
TLabel::Dispatch(AMessage);
|
|
if (!WasFocused && (FocusControl != NULL) && FocusControl->Focused())
|
|
{
|
|
TCustomForm * ParentForm = GetParentForm(this);
|
|
if (ParentForm != NULL)
|
|
{
|
|
ParentForm->Perform(WM_CHANGEUISTATE, MAKELONG(UIS_CLEAR, UISF_HIDEFOCUS), NativeInt(0));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TLabel::Dispatch(AMessage);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
template<typename T>
|
|
bool HandleMessageByDarkStyleHook(TMessage & Msg, TWinControl * Control, std::unique_ptr<T> & StyleHook)
|
|
{
|
|
bool Result = false;
|
|
if (Control->HandleAllocated() &&
|
|
!Control->ComponentState.Contains(csDestroying) &&
|
|
!Control->ControlState.Contains(csDestroyingHandle) &&
|
|
!Control->ControlStyle.Contains(csOverrideStylePaint) &&
|
|
UseDarkModeForControl(Control))
|
|
{
|
|
if (StyleHook.get() == NULL)
|
|
{
|
|
StyleHook.reset(new T(Control));
|
|
}
|
|
Result = StyleHook->HandleMessage(Msg);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void SetColorModeTheme(TWinControl * Control, const UnicodeString & DarkSubAppName)
|
|
{
|
|
if (UseDarkModeForControl(Control))
|
|
{
|
|
SetDarkModeTheme(Control, DarkSubAppName);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void SetExplorerTheme(TWinControl * Button)
|
|
{
|
|
SetColorModeTheme(Button, TDarkExplorerUxThemeStyle::ThemeName);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TDarkGroupBoxStyleHook : public TGroupBoxStyleHook
|
|
{
|
|
public:
|
|
__fastcall virtual TDarkGroupBoxStyleHook(TWinControl * AControl) :
|
|
TGroupBoxStyleHook(AControl)
|
|
{
|
|
}
|
|
|
|
protected:
|
|
virtual TCustomStyleServices * __fastcall StyleServices()
|
|
{
|
|
return TDarkUxThemeStyle::Instance();
|
|
}
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
class TGroupBoxEx : public TGroupBox
|
|
{
|
|
protected:
|
|
virtual void __fastcall PaintWindow(HDC DC);
|
|
virtual void __fastcall WndProc(TMessage & Msg);
|
|
private:
|
|
std::unique_ptr<TDarkGroupBoxStyleHook> FStyleHook;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGroupBoxEx::WndProc(TMessage & Msg)
|
|
{
|
|
if (!HandleMessageByDarkStyleHook(Msg, this, FStyleHook))
|
|
{
|
|
TGroupBox::WndProc(Msg);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TGroupBoxEx::PaintWindow(HDC DC)
|
|
{
|
|
if (UseDarkModeForControl(this))
|
|
{
|
|
std::unique_ptr<TCanvas> Canvas(new TCanvas());
|
|
Canvas->Handle = DC;
|
|
Canvas->Font = Font;
|
|
|
|
TRect Rect = ClientRect;
|
|
Canvas->Brush->Style = bsSolid;
|
|
Canvas->Brush->Color = GetBtnFaceColor();
|
|
Canvas->FillRect(Rect);
|
|
}
|
|
|
|
TGroupBox::PaintWindow(DC);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TDarkCheckBoxStyleHook : public TCheckBoxStyleHook
|
|
{
|
|
public:
|
|
__fastcall virtual TDarkCheckBoxStyleHook(TWinControl * AControl);
|
|
protected:
|
|
virtual void __fastcall PaintBackground(TCanvas * Canvas);
|
|
virtual TCustomStyleServices * __fastcall StyleServices();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
class TCheckBoxEx : public TCheckBox
|
|
{
|
|
public:
|
|
__fastcall virtual TCheckBoxEx(TComponent * AOwner);
|
|
protected:
|
|
virtual void __fastcall WndProc(TMessage & Msg);
|
|
virtual void __fastcall CreateWnd();
|
|
private:
|
|
std::unique_ptr<TDarkCheckBoxStyleHook> FStyleHook;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
TCheckBox * CreateCheckBox(TComponent * AOwner)
|
|
{
|
|
return new TCheckBoxEx(AOwner);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TDarkCheckBoxStyleHook::TDarkCheckBoxStyleHook(TWinControl * AControl) :
|
|
TCheckBoxStyleHook(AControl)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TDarkCheckBoxStyleHook::PaintBackground(TCanvas * Canvas)
|
|
{
|
|
Canvas->Brush->Style = bsSolid;
|
|
Canvas->Brush->Color = GetBtnFaceColor();
|
|
Canvas->FillRect(Rect(0, 0, Control->Width, Control->Height));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TCustomStyleServices * __fastcall TDarkCheckBoxStyleHook::StyleServices()
|
|
{
|
|
if (DarkExplorerUxThemeStyle.get() == NULL)
|
|
{
|
|
DarkExplorerUxThemeStyle.reset(new TDarkExplorerUxThemeStyle());
|
|
}
|
|
DarkExplorerUxThemeStyle->SetControl(Control);
|
|
return DarkExplorerUxThemeStyle.get();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TCheckBoxEx::TCheckBoxEx(TComponent * AOwner) :
|
|
TCheckBox(AOwner)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TCheckBoxEx::CreateWnd()
|
|
{
|
|
TCheckBox::CreateWnd();
|
|
SetColorModeTheme(this, TDarkExplorerUxThemeStyle::ThemeName);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TCheckBoxEx::WndProc(TMessage & Msg)
|
|
{
|
|
if (!HandleMessageByDarkStyleHook(Msg, this, FStyleHook))
|
|
{
|
|
TCheckBox::WndProc(Msg);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TButtonEx : public TButton
|
|
{
|
|
public:
|
|
__fastcall virtual TButtonEx(TComponent * AOwner);
|
|
protected:
|
|
virtual void __fastcall CreateWnd();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TButtonEx::TButtonEx(TComponent * AOwner) :
|
|
TButton(AOwner)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TButtonEx::CreateWnd()
|
|
{
|
|
TButton::CreateWnd();
|
|
SetExplorerTheme(this);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TButton * CreateButton(TComponent * AOwner)
|
|
{
|
|
return new TButtonEx(AOwner);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TEditEx : public TEdit
|
|
{
|
|
public:
|
|
__fastcall virtual TEditEx(TComponent * AOwner);
|
|
protected:
|
|
virtual void __fastcall CreateWnd();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TEditEx::TEditEx(TComponent * AOwner) :
|
|
TEdit(AOwner)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TEditEx::CreateWnd()
|
|
{
|
|
TEdit::CreateWnd();
|
|
SetColorModeTheme(this, L"CFD");
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TEdit * CreateEdit(TComponent * AOwner)
|
|
{
|
|
return new TEditEx(AOwner);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
class TMemoEx : public TMemo
|
|
{
|
|
public:
|
|
__fastcall virtual TMemoEx(TComponent * AOwner);
|
|
protected:
|
|
virtual void __fastcall CreateWnd();
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TMemoEx::TMemoEx(TComponent * AOwner) :
|
|
TMemo(AOwner)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TMemoEx::CreateWnd()
|
|
{
|
|
TMemo::CreateWnd();
|
|
SetColorModeTheme(this, L"CFD");
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TMemo * CreateMemo(TComponent * AOwner)
|
|
{
|
|
return new TMemoEx(AOwner);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall FindComponentClass(
|
|
void *, TReader *, const UnicodeString DebugUsedArg(ClassName), TComponentClass & ComponentClass)
|
|
{
|
|
if (ComponentClass == __classid(TLabel))
|
|
{
|
|
ComponentClass = __classid(TUIStateAwareLabel);
|
|
}
|
|
else if (ComponentClass == __classid(TComboBox))
|
|
{
|
|
ComponentClass = __classid(TUIStateAwareComboBox);
|
|
}
|
|
else if (ComponentClass == __classid(TGroupBox))
|
|
{
|
|
ComponentClass = __classid(TGroupBoxEx);
|
|
}
|
|
else if (ComponentClass == __classid(TCheckBox))
|
|
{
|
|
ComponentClass = __classid(TCheckBoxEx);
|
|
}
|
|
else if (ComponentClass == __classid(TButton))
|
|
{
|
|
ComponentClass = __classid(TButtonEx);
|
|
}
|
|
else if (ComponentClass == __classid(TEdit))
|
|
{
|
|
ComponentClass = __classid(TEditEx);
|
|
}
|
|
else if (ComponentClass == __classid(TMemo))
|
|
{
|
|
ComponentClass = __classid(TMemoEx);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool CanShowTimeEstimate(TDateTime StartTime)
|
|
{
|
|
return (SecondsBetween(StartTime, Now()) >= 3);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TSystemRequiredThread : public TSignalThread
|
|
{
|
|
public:
|
|
TSystemRequiredThread();
|
|
void Required();
|
|
protected:
|
|
virtual bool __fastcall WaitForEvent();
|
|
virtual void __fastcall ProcessEvent();
|
|
private:
|
|
bool FRequired;
|
|
TDateTime FLastRequired;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
static std::unique_ptr<TCriticalSection> SystemRequiredThreadSection(TraceInitPtr(new TCriticalSection()));
|
|
static TSystemRequiredThread * SystemRequiredThread = NULL;
|
|
//---------------------------------------------------------------------------
|
|
TSystemRequiredThread::TSystemRequiredThread() :
|
|
TSignalThread(true), FRequired(false)
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TSystemRequiredThread::Required()
|
|
{
|
|
// guarded in SystemRequired()
|
|
FLastRequired = Now();
|
|
TriggerEvent();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall TSystemRequiredThread::WaitForEvent()
|
|
{
|
|
const int ExpireInterval = 5000;
|
|
bool Result = (TSignalThread::WaitForEvent(ExpireInterval) > 0);
|
|
if (!Result && !FTerminated)
|
|
{
|
|
TGuard Guard(SystemRequiredThreadSection.get());
|
|
if (!FTerminated && FRequired &&
|
|
(MilliSecondsBetween(Now(), FLastRequired) > ExpireInterval))
|
|
{
|
|
AppLog(L"System is not required");
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
|
FLastRequired = TDateTime();
|
|
FRequired = false;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TSystemRequiredThread::ProcessEvent()
|
|
{
|
|
TGuard Guard(SystemRequiredThreadSection.get());
|
|
if (!FRequired &&
|
|
(FLastRequired != TDateTime()))
|
|
{
|
|
AppLog(L"System is required");
|
|
SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_CONTINUOUS);
|
|
FRequired = true;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void SystemRequired()
|
|
{
|
|
if (IsWin11())
|
|
{
|
|
TGuard Guard(SystemRequiredThreadSection.get());
|
|
if (SystemRequiredThread == NULL)
|
|
{
|
|
AppLog(L"Starting system required thread");
|
|
SystemRequiredThread = new TSystemRequiredThread();
|
|
SystemRequiredThread->Start();
|
|
}
|
|
SystemRequiredThread->Required();
|
|
}
|
|
else
|
|
{
|
|
SetThreadExecutionState(ES_SYSTEM_REQUIRED);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void GUIFinalize()
|
|
{
|
|
TPuttyCleanupThread::Finalize();
|
|
|
|
TSystemRequiredThread * Thread;
|
|
{
|
|
TGuard Guard(SystemRequiredThreadSection.get());
|
|
Thread = SystemRequiredThread;
|
|
SystemRequiredThread = NULL;
|
|
}
|
|
|
|
if (Thread != NULL)
|
|
{
|
|
AppLog(L"Stopping system required thread");
|
|
Thread->Terminate();
|
|
Thread->WaitFor();
|
|
delete Thread;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TCustomImageList * TreeViewImageList(TPngImageList * ImageList)
|
|
{
|
|
// WORKAROUND Prevent DPI scaling, see TCustomTreeView.SetImages
|
|
ImageList->Scaled = true;
|
|
return ImageList;
|
|
}
|