mirror of
https://github.com/winscp/winscp.git
synced 2026-10-24 02:28:55 +03:00
2957 lines
96 KiB
C++
2957 lines
96 KiB
C++
//---------------------------------------------------------------------------
|
|
#include <vcl.h>
|
|
#pragma hdrstop
|
|
|
|
#include "WinInterface.h"
|
|
#include "VCLCommon.h"
|
|
|
|
#include <Common.h>
|
|
#include <TextsWin.h>
|
|
#include <RemoteFiles.h>
|
|
#include <GUITools.h>
|
|
#include <Tools.h>
|
|
#include <CustomWinConfiguration.h>
|
|
#include <CoreMain.h>
|
|
|
|
#include <Vcl.StdActns.hpp>
|
|
#include <PasswordEdit.hpp>
|
|
#include <FileCtrl.hpp>
|
|
#include <PathLabel.hpp>
|
|
#include <PasTools.hpp>
|
|
#include <StrUtils.hpp>
|
|
#include <Vcl.Imaging.pngimage.hpp>
|
|
#include <Math.hpp>
|
|
#include <TB2ExtItems.hpp>
|
|
#include <TBXExtItems.hpp>
|
|
#include <IEListView.hpp>
|
|
#include <WinApi.h>
|
|
#include <vssym32.h>
|
|
//---------------------------------------------------------------------------
|
|
const UnicodeString LinkAppLabelMark(TraceInitStr(L" \x00BB"));
|
|
//---------------------------------------------------------------------------
|
|
#pragma package(smart_init)
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall FixListColumnWidth(TListView * TListView, int Index)
|
|
{
|
|
if (Index < 0)
|
|
{
|
|
Index = TListView->Columns->Count + Index;
|
|
}
|
|
TListView->Column[Index]->Tag = 1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static int __fastcall GetColumnTextWidth(TListView * ListView, int ColumnPadding, const UnicodeString & Text)
|
|
{
|
|
return
|
|
ColumnPadding +
|
|
ListView->Canvas->TextExtent(Text).Width;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall AutoSizeListColumnsWidth(TListView * ListView, int ColumnToShrinkIndex)
|
|
{
|
|
// Preallocate handle to precreate columns, otherwise our changes may get
|
|
// overwritten once the handle is created.
|
|
// This should actually get called only once the handle are allocated.
|
|
// Otherwise we end up recreating the handles,
|
|
// what may cause a flicker of the currently focused window title.
|
|
ListView->HandleNeeded();
|
|
|
|
SendMessage(ListView->Handle, WM_SETREDRAW, false, 0);
|
|
|
|
try
|
|
{
|
|
int ColumnPadding = 2 * ScaleByTextHeightRunTime(ListView, 6);
|
|
int ColumnShrinkMinWidth = ScaleByTextHeightRunTime(ListView, 60);
|
|
|
|
int ResizableWidth = 0;
|
|
int NonResizableWidth = 0;
|
|
int LastResizable = -1;
|
|
for (int Index = 0; Index < ListView->Columns->Count; Index++)
|
|
{
|
|
TListColumn * Column = ListView->Columns->Items[Index];
|
|
|
|
int CaptionWidth = GetColumnTextWidth(ListView, ColumnPadding, Column->Caption);
|
|
|
|
int OrigWidth = -1;
|
|
bool NonResizable = (Column->Tag != 0);
|
|
if (NonResizable) // optimization
|
|
{
|
|
OrigWidth = ListView_GetColumnWidth(ListView->Handle, Index);
|
|
}
|
|
|
|
int Width;
|
|
// LVSCW_AUTOSIZE does not work for OwnerData list views
|
|
if (!ListView->OwnerData)
|
|
{
|
|
ListView_SetColumnWidth(ListView->Handle, Index, LVSCW_AUTOSIZE);
|
|
Width = ListView_GetColumnWidth(ListView->Handle, Index);
|
|
}
|
|
else
|
|
{
|
|
Width = 0;
|
|
for (int ItemIndex = 0; ItemIndex < ListView->Items->Count; ItemIndex++)
|
|
{
|
|
TListItem * Item = ListView->Items->Item[ItemIndex];
|
|
|
|
UnicodeString Text;
|
|
if (Index == 0)
|
|
{
|
|
Text = Item->Caption;
|
|
}
|
|
// Particularly EditorListView3 on Preferences dialog does not have all subitems filled for internal editor
|
|
else if (Index <= Item->SubItems->Count)
|
|
{
|
|
Text = Item->SubItems->Strings[Index - 1];
|
|
}
|
|
|
|
int TextWidth = GetColumnTextWidth(ListView, ColumnPadding, Text);
|
|
if (TextWidth > Width)
|
|
{
|
|
Width = TextWidth;
|
|
}
|
|
}
|
|
}
|
|
Width = Max(Width, CaptionWidth);
|
|
// Never shrink the non-resizable columns
|
|
if (NonResizable && (Width < OrigWidth))
|
|
{
|
|
Width = OrigWidth;
|
|
}
|
|
Column->Width = Width;
|
|
|
|
if (NonResizable)
|
|
{
|
|
NonResizableWidth += Width;
|
|
}
|
|
else
|
|
{
|
|
LastResizable = Index;
|
|
ResizableWidth += Width;
|
|
}
|
|
}
|
|
|
|
DebugAssert(LastResizable >= 0);
|
|
|
|
int ClientWidth = ListView->ClientWidth;
|
|
int RowCount = ListView->Items->Count;
|
|
if ((ListView->VisibleRowCount < RowCount) &&
|
|
(ListView->Width - ListView->ClientWidth < GetSystemMetricsForControl(ListView, SM_CXVSCROLL)))
|
|
{
|
|
ClientWidth -= GetSystemMetricsForControl(ListView, SM_CXVSCROLL);
|
|
}
|
|
|
|
if (DebugAlwaysTrue(NonResizableWidth < ClientWidth))
|
|
{
|
|
int Remaining = ClientWidth - NonResizableWidth;
|
|
|
|
bool ProportionalResize = true;
|
|
|
|
bool Shrinking = (Remaining < ResizableWidth);
|
|
// If columns are too wide to fit and we have dedicated shrink column, shrink it
|
|
if (Shrinking &&
|
|
(ColumnToShrinkIndex >= 0))
|
|
{
|
|
TListColumn * ColumnToShrink = ListView->Columns->Items[ColumnToShrinkIndex];
|
|
int ColumnToShrinkCaptionWidth = GetColumnTextWidth(ListView, ColumnPadding, ColumnToShrink->Caption);
|
|
int ColumnToShrinkMinWidth = Max(ColumnShrinkMinWidth, ColumnToShrinkCaptionWidth);
|
|
// This falls back to proprotional shrinking when the shrink column would fall below min width.
|
|
// Question is whether we should not shrink to min width instead.
|
|
if ((ResizableWidth - ColumnToShrink->Width) < (Remaining - ColumnToShrinkMinWidth))
|
|
{
|
|
int ColumnToShrinkWidth = Remaining - (ResizableWidth - ColumnToShrink->Width);
|
|
ColumnToShrink->Width = ColumnToShrinkWidth;
|
|
ProportionalResize = false;
|
|
}
|
|
}
|
|
|
|
if (ProportionalResize)
|
|
{
|
|
for (int Index = 0; Index <= LastResizable; Index++)
|
|
{
|
|
TListColumn * Column = ListView->Columns->Items[Index];
|
|
|
|
if (Column->Tag == 0)
|
|
{
|
|
int Width = ListView_GetColumnWidth(ListView->Handle, Index);
|
|
int AutoWidth = Width;
|
|
if (Index < LastResizable)
|
|
{
|
|
Width = (Remaining * Width) / ResizableWidth;
|
|
}
|
|
else
|
|
{
|
|
Width = Remaining;
|
|
}
|
|
|
|
int CaptionWidth = GetColumnTextWidth(ListView, ColumnPadding, Column->Caption);
|
|
Width = Max(Width, CaptionWidth);
|
|
Width = Max(Width, Min(ColumnShrinkMinWidth, AutoWidth));
|
|
Column->Width = Width;
|
|
Remaining -= Min(Width, Remaining);
|
|
}
|
|
}
|
|
|
|
DebugAssert(Remaining == 0);
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
SendMessage(ListView->Handle, WM_SETREDRAW, true, 0);
|
|
// As recommended by documentation for WM_SETREDRAW.
|
|
// Without this, session list on Import dialog stops working after the list is reloaded while visible
|
|
// (i.e. when chaing import source)
|
|
RedrawWindow(ListView->Handle, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall SetParentColor(TControl * Control)
|
|
{
|
|
TColor Color = clBtnFace;
|
|
if (UseThemes)
|
|
{
|
|
bool OnTabSheet = false;
|
|
TWinControl * Parent = Control->Parent;
|
|
while ((Parent != NULL) && !OnTabSheet)
|
|
{
|
|
TTabSheet * TabSheet = dynamic_cast<TTabSheet *>(Parent);
|
|
OnTabSheet = (TabSheet != NULL) && TabSheet->TabVisible;
|
|
Parent = Parent->Parent;
|
|
}
|
|
|
|
if (OnTabSheet)
|
|
{
|
|
HTHEME Theme = OpenThemeData(NULL, L"tab");
|
|
if (Theme != NULL)
|
|
{
|
|
COLORREF RGB;
|
|
// XP with classic theme: Does not get past OpenThemeData, clBtnFace is exact color
|
|
// XP with XP theme: not the exact color (probably same as clBtnFace), but close
|
|
// Vista - ok
|
|
// 2016 without desktop - ok
|
|
// 7 with classic and high contrast themes: Do not get past OpenThemeData, clBtnFace is exact color
|
|
// 7 with 7 and basic themes - ok
|
|
// 10 with high contrast themes - ok (note the difference to 7 with high contract themes)
|
|
// 10 - ok
|
|
if (GetThemeColor(Theme, TABP_AEROWIZARDBODY, TIS_NORMAL, TMT_FILLCOLOR, &RGB) == S_OK)
|
|
{
|
|
Color = static_cast<TColor>(RGB);
|
|
}
|
|
CloseThemeData(Theme);
|
|
}
|
|
}
|
|
}
|
|
|
|
((TEdit*)Control)->Color = Color;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall EnableControl(TControl * Control, bool Enable)
|
|
{
|
|
if (Control->Enabled != Enable)
|
|
{
|
|
TWinControl * WinControl = dynamic_cast<TWinControl *>(Control);
|
|
if ((WinControl != NULL) &&
|
|
(WinControl->ControlCount > 0))
|
|
{
|
|
for (int Index = 0; Index < WinControl->ControlCount; Index++)
|
|
{
|
|
EnableControl(WinControl->Controls[Index], Enable);
|
|
}
|
|
}
|
|
Control->Enabled = Enable;
|
|
}
|
|
|
|
if ((dynamic_cast<TCustomEdit *>(Control) != NULL) ||
|
|
(dynamic_cast<TCustomComboBox *>(Control) != NULL) ||
|
|
(dynamic_cast<TCustomListView *>(Control) != NULL) ||
|
|
(dynamic_cast<TCustomTreeView *>(Control) != NULL))
|
|
{
|
|
if (Enable)
|
|
{
|
|
((TEdit*)Control)->Color = clWindow;
|
|
}
|
|
else
|
|
{
|
|
// This does not work for list view with
|
|
// LVS_EX_DOUBLEBUFFER (TCustomDirView).
|
|
// It automatically gets gray background.
|
|
// Though on Windows 7, the control has to be disabled
|
|
// only after it is showing already (see TCustomScpExplorerForm::UpdateControls())
|
|
((TEdit*)Control)->Color = clBtnFace;
|
|
}
|
|
}
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall DoReadOnlyControl(TControl * Control, bool ReadOnly, bool Color);
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ReadOnlyAndEnabledControl(TControl * Control, bool ReadOnly, bool Enabled)
|
|
{
|
|
// Change color only in only one of EnableControl and DoReadOnlyControl to prevent flicker
|
|
if (ReadOnly)
|
|
{
|
|
DebugAssert(dynamic_cast<TWinControl *>(Control)->ControlCount == 0);
|
|
// As EnableControl, but with no color change
|
|
Control->Enabled = Enabled;
|
|
DoReadOnlyControl(Control, ReadOnly, true);
|
|
}
|
|
else
|
|
{
|
|
DoReadOnlyControl(Control, ReadOnly, false);
|
|
EnableControl(Control, Enabled);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall ReadOnlyEditContextPopup(void * /*Data*/, TObject * Sender, const TPoint & MousePos, bool & Handled)
|
|
{
|
|
TEdit * Edit = static_cast<TEdit *>(Sender);
|
|
if (Edit->ReadOnly)
|
|
{
|
|
MenuPopup(Sender, MousePos, Handled);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall DoReadOnlyControl(TControl * Control, bool ReadOnly, bool Color)
|
|
{
|
|
if (dynamic_cast<TCustomEdit *>(Control) != NULL)
|
|
{
|
|
TEdit * Edit = static_cast<TEdit *>(Control);
|
|
Edit->ReadOnly = ReadOnly;
|
|
TMemo * Memo = dynamic_cast<TMemo *>(Control);
|
|
if (ReadOnly)
|
|
{
|
|
if (Color)
|
|
{
|
|
SetParentColor(Control);
|
|
}
|
|
if (Memo != NULL)
|
|
{
|
|
// Is true by default and makes the control swallow not only
|
|
// returns but also escapes.
|
|
// See also MemoKeyDown
|
|
Memo->WantReturns = false;
|
|
}
|
|
|
|
if ((Edit->PopupMenu == NULL) && (dynamic_cast<TPasswordEdit *>(Control) == NULL))
|
|
{
|
|
std::unique_ptr<TPopupMenu> PopupMenu(new TPopupMenu(Edit));
|
|
|
|
TMenuItem * Item;
|
|
Item = new TMenuItem(PopupMenu.get());
|
|
PopupMenu->Items->Add(Item);
|
|
Item->Action = new TEditCopy(Item);
|
|
Item->Caption = LoadStr(EDIT_COPY);
|
|
Item->ShortCut = ShortCut(L'C', TShiftState() << ssCtrl);
|
|
Item = new TMenuItem(PopupMenu.get());
|
|
PopupMenu->Items->Add(Item);
|
|
Item->Action = new TEditSelectAll(Item);
|
|
Item->Caption = LoadStr(EDIT_SELECT_ALL);
|
|
Item->ShortCut = ShortCut(L'A', TShiftState() << ssCtrl);
|
|
|
|
Edit->PopupMenu = PopupMenu.release();
|
|
Edit->OnContextPopup = MakeMethod<TContextPopupEvent>(NULL, ReadOnlyEditContextPopup);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Color)
|
|
{
|
|
Edit->Color = clWindow;
|
|
}
|
|
// not supported atm, we need to persist previous value of WantReturns
|
|
DebugAssert(Memo == NULL);
|
|
|
|
if ((Edit->PopupMenu != NULL) && (Edit->PopupMenu->Owner == Edit))
|
|
{
|
|
delete Edit->PopupMenu;
|
|
}
|
|
}
|
|
}
|
|
else if ((dynamic_cast<TCustomComboBox *>(Control) != NULL) ||
|
|
(dynamic_cast<TCustomTreeView *>(Control) != NULL))
|
|
{
|
|
EnableControl(Control, !ReadOnly);
|
|
}
|
|
else
|
|
{
|
|
DebugFail();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ReadOnlyControl(TControl * Control, bool ReadOnly)
|
|
{
|
|
DoReadOnlyControl(Control, ReadOnly, true);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int CalculateCheckBoxWidth(TControl * Control, const UnicodeString & Caption)
|
|
{
|
|
return
|
|
ScaleByTextHeight(Control, 13 + 3 + 8) + // checkbox, padding and buffer
|
|
GetParentForm(Control)->Canvas->TextWidth(StripHotkey(Caption));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void AutoSizeCheckBox(TCheckBox * CheckBox)
|
|
{
|
|
CheckBox->Width = CalculateCheckBoxWidth(CheckBox, CheckBox->Caption);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// Some of MainFormLike code can now be obsolete, thanks to Application->OnGetMainFormHandle.
|
|
static TForm * MainLikeForm = NULL;
|
|
//---------------------------------------------------------------------------
|
|
TForm * __fastcall GetMainForm()
|
|
{
|
|
TForm * Result;
|
|
if (MainLikeForm != NULL)
|
|
{
|
|
Result = MainLikeForm;
|
|
}
|
|
else
|
|
{
|
|
Result = Application->MainForm;
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall IsMainFormHidden()
|
|
{
|
|
bool Result = false;
|
|
TForm * MainForm = GetMainForm();
|
|
if (MainForm != NULL)
|
|
{
|
|
Result =
|
|
!MainForm->Visible ||
|
|
(MainForm->Perform(WM_IS_HIDDEN, 0, 0) == 1);
|
|
}
|
|
// we do not expect this to return true when MainLikeForm is set
|
|
DebugAssert(!Result || (MainLikeForm == NULL));
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall IsMainFormLike(TCustomForm * Form)
|
|
{
|
|
return
|
|
(GetMainForm() == Form) ||
|
|
// this particularly happens if error occurs while main
|
|
// window is being shown (e.g. non existent local directory when opening
|
|
// explorer)
|
|
IsMainFormHidden();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString __fastcall FormatMainFormCaption(const UnicodeString & Caption, const UnicodeString & SessionName)
|
|
{
|
|
UnicodeString Suffix = AppName;
|
|
if (!SessionName.IsEmpty())
|
|
{
|
|
Suffix = SessionName + TitleSeparator + Suffix;
|
|
}
|
|
UnicodeString Result = Caption;
|
|
if (Result.IsEmpty())
|
|
{
|
|
Result = Suffix;
|
|
}
|
|
else
|
|
{
|
|
Suffix = TitleSeparator + Suffix;
|
|
if (!EndsStr(Suffix, Result))
|
|
{
|
|
Result += Suffix;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
UnicodeString __fastcall FormatFormCaption(
|
|
TCustomForm * Form, const UnicodeString & Caption, const UnicodeString & SessionName)
|
|
{
|
|
UnicodeString Result = Caption;
|
|
if (IsMainFormLike(Form))
|
|
{
|
|
Result = FormatMainFormCaption(Result, SessionName);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TPublicWinControl : public TWinControl
|
|
{
|
|
friend TWndMethod __fastcall ControlWndProc(TWinControl * Control);
|
|
friend void __fastcall InstallPathWordBreakProc(TWinControl * Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
TWndMethod __fastcall ControlWndProc(TWinControl * Control)
|
|
{
|
|
TPublicWinControl * PublicWinControl = static_cast<TPublicWinControl *>(Control);
|
|
return &PublicWinControl->WndProc;
|
|
}
|
|
//---------------------------------------------------------------------
|
|
class TPublicControl : public TControl
|
|
{
|
|
friend void __fastcall RealignControl(TControl * Control);
|
|
friend void __fastcall DoFormWindowProc(TCustomForm * Form, TWndMethod WndProc, TMessage & Message);
|
|
friend TCanvas * CreateControlCanvas(TControl * Control);
|
|
};
|
|
//---------------------------------------------------------------------
|
|
class TPublicForm : public TForm
|
|
{
|
|
friend void __fastcall ChangeFormPixelsPerInch(TForm * Form, int PixelsPerInch);
|
|
friend void __fastcall ShowAsModal(TForm * Form, void *& Storage, bool BringToFront, bool TriggerModalStarted);
|
|
friend void __fastcall HideAsModal(TForm * Form, void *& Storage);
|
|
friend void __fastcall ShowFormNoActivate(TForm * Form);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall RealignControl(TControl * Control)
|
|
{
|
|
TPublicControl * PublicControl = static_cast<TPublicControl *>(Control);
|
|
PublicControl->RequestAlign();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static Forms::TMonitor * LastMonitor = NULL;
|
|
//---------------------------------------------------------------------------
|
|
static int __fastcall GetTextHeightAtPixelsPerInch(TForm * Form, int PixelsPerInch)
|
|
{
|
|
std::unique_ptr<TCanvas> Canvas(new TCanvas());
|
|
Canvas->Handle = GetDC(0);
|
|
Canvas->Font->Assign(Form->Font);
|
|
Canvas->Font->PixelsPerInch = PixelsPerInch; // Must be set BEFORE size
|
|
Canvas->Font->Size = Form->Font->Size;
|
|
// VCLCOPY: this is what TCustomForm.GetTextHeight does
|
|
return Canvas->TextHeight(L"0");
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TRescaleComponent : public TComponent
|
|
{
|
|
public:
|
|
__fastcall TRescaleComponent(TRescaleEvent AOnRescale, TObject * AToken, bool AOwnsToken) :
|
|
TComponent(NULL)
|
|
{
|
|
OnRescale = AOnRescale;
|
|
Token = AToken;
|
|
OwnsToken = AOwnsToken;
|
|
}
|
|
|
|
virtual __fastcall ~TRescaleComponent()
|
|
{
|
|
if (OwnsToken)
|
|
{
|
|
delete Token;
|
|
}
|
|
}
|
|
|
|
TRescaleEvent OnRescale;
|
|
TObject * Token;
|
|
bool OwnsToken;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetRescaleFunction(
|
|
TComponent * Component, TRescaleEvent OnRescale, TObject * Token, bool OwnsToken)
|
|
{
|
|
TRescaleComponent * RescaleComponent = new TRescaleComponent(OnRescale, Token, OwnsToken);
|
|
RescaleComponent->Name = TRescaleComponent::QualifiedClassName();
|
|
Component->InsertComponent(RescaleComponent);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall ChangeControlScale(TControl * Control, int M, int D)
|
|
{
|
|
// VCLCOPY This is what TCustomListView.ChangeScale does,
|
|
// but it does that for initial loading only, when ScalingFlags includes sfWidth.
|
|
// But ScalingFlags is reset in TControl.ChangeScale (seems like a bug).
|
|
TCustomListView * CustomListView = dynamic_cast<TCustomListView *>(Control);
|
|
if (CustomListView != NULL)
|
|
{
|
|
TListView * ListView = reinterpret_cast<TListView *>(CustomListView);
|
|
for (int Index = 0; Index < ListView->Columns->Count; Index++)
|
|
{
|
|
TListColumn * Column = ListView->Columns->Items[Index];
|
|
if ((Column->Width != LVSCW_AUTOSIZE) &&
|
|
(Column->Width != LVSCW_AUTOSIZE_USEHEADER))
|
|
{
|
|
Column->Width = MulDiv(Column->Width, M, D);
|
|
}
|
|
}
|
|
}
|
|
|
|
TCustomCombo * CustomCombo = dynamic_cast<TCustomCombo *>(Control);
|
|
if (CustomCombo != NULL)
|
|
{
|
|
// WORKAROUND
|
|
// Some combo boxes (e.g. path box on Copy dialog) visualize selection after rescaling, even when not focused
|
|
if (!CustomCombo->Focused())
|
|
{
|
|
CustomCombo->SelLength = 0;
|
|
}
|
|
}
|
|
|
|
for (int Index = 0; Index < Control->ComponentCount; Index++)
|
|
{
|
|
TComponent * Component = Control->Components[Index];
|
|
|
|
TControl * ChildControl = dynamic_cast<TControl *>(Component);
|
|
if (ChildControl != NULL)
|
|
{
|
|
ChangeControlScale(ChildControl, M, D);
|
|
}
|
|
|
|
TRescaleComponent * RescaleComponent =
|
|
dynamic_cast<TRescaleComponent *>(Component->FindComponent(TRescaleComponent::QualifiedClassName()));
|
|
if (RescaleComponent != NULL)
|
|
{
|
|
RescaleComponent->OnRescale(Component, RescaleComponent->Token);
|
|
}
|
|
}
|
|
|
|
Control->Perform(CM_DPICHANGED, M, D);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
typedef std::pair<int, int> TRatio;
|
|
typedef std::map<TRatio, TRatio > TRatioMap;
|
|
//---------------------------------------------------------------------------
|
|
class TFormRescaleComponent : public TComponent
|
|
{
|
|
public:
|
|
__fastcall TFormRescaleComponent() :
|
|
TComponent(NULL)
|
|
{
|
|
ImplicitRescaleAdded = false;
|
|
Rescaling = false;
|
|
}
|
|
|
|
bool Rescaling;
|
|
bool ImplicitRescaleAdded;
|
|
TRatioMap RatioMap;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
static TFormRescaleComponent * GetFormRescaleComponent(TForm * Form)
|
|
{
|
|
TFormRescaleComponent * FormRescaleComponent =
|
|
dynamic_cast<TFormRescaleComponent *>(Form->FindComponent(TFormRescaleComponent::QualifiedClassName()));
|
|
if (FormRescaleComponent == NULL)
|
|
{
|
|
FormRescaleComponent = new TFormRescaleComponent();
|
|
FormRescaleComponent->Name = TFormRescaleComponent::QualifiedClassName();
|
|
Form->InsertComponent(FormRescaleComponent);
|
|
}
|
|
return FormRescaleComponent;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall RecordFormImplicitRescale(TForm * Form)
|
|
{
|
|
if (Form->Scaled)
|
|
{
|
|
TFormRescaleComponent * FormRescaleComponent = GetFormRescaleComponent(Form);
|
|
if (!FormRescaleComponent->ImplicitRescaleAdded)
|
|
{
|
|
TRatio Ratio;
|
|
GetFormScaleRatio(Form, Ratio.first, Ratio.second);
|
|
TRatio RescaleKeyRatio(Form->PixelsPerInch, USER_DEFAULT_SCREEN_DPI);
|
|
FormRescaleComponent->RatioMap[RescaleKeyRatio] = Ratio;
|
|
FormRescaleComponent->ImplicitRescaleAdded = true;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void GetFormRescaleRatio(TForm * Form, int PixelsPerInch, int & M, int & D)
|
|
{
|
|
TFormRescaleComponent * FormRescaleComponent = GetFormRescaleComponent(Form);
|
|
TRatio ReverseRescaleKeyRatio(Form->PixelsPerInch, PixelsPerInch);
|
|
if (FormRescaleComponent->RatioMap.count(ReverseRescaleKeyRatio) > 0)
|
|
{
|
|
M = FormRescaleComponent->RatioMap[ReverseRescaleKeyRatio].second;
|
|
D = FormRescaleComponent->RatioMap[ReverseRescaleKeyRatio].first;
|
|
}
|
|
else
|
|
{
|
|
M = GetTextHeightAtPixelsPerInch(Form, PixelsPerInch);
|
|
D = GetTextHeightAtPixelsPerInch(Form, Form->PixelsPerInch);
|
|
}
|
|
|
|
|
|
TRatio RescaleKeyRatio(PixelsPerInch, Form->PixelsPerInch);
|
|
FormRescaleComponent->RatioMap[RescaleKeyRatio] = TRatio(M, D);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall ChangeFormPixelsPerInch(TForm * Form, int PixelsPerInch)
|
|
{
|
|
RecordFormImplicitRescale(Form);
|
|
|
|
TFormRescaleComponent * FormRescaleComponent = GetFormRescaleComponent(Form);
|
|
|
|
if ((Form->PixelsPerInch != PixelsPerInch) && // optimization
|
|
!FormRescaleComponent->Rescaling)
|
|
{
|
|
AppLogFmt(L"Scaling window %s", (Form->Caption));
|
|
TAutoFlag RescalingFlag(FormRescaleComponent->Rescaling);
|
|
|
|
int M, D;
|
|
GetFormRescaleRatio(Form, PixelsPerInch, M, D);
|
|
|
|
Form->PixelsPerInch = PixelsPerInch;
|
|
TPublicForm * PublicCustomForm = static_cast<TPublicForm *>(Form);
|
|
|
|
// WORKAROUND
|
|
// TCustomForm.ChangeScale scales contraints only after rescaling the size,
|
|
// so the unscaled constraints apply to the new size
|
|
// (e.g. with TLoginDialog)
|
|
std::unique_ptr<TSizeConstraints> Constraints(new TSizeConstraints(NULL));
|
|
Constraints->Assign(PublicCustomForm->Constraints);
|
|
std::unique_ptr<TSizeConstraints> NoConstraints(new TSizeConstraints(NULL));
|
|
PublicCustomForm->Constraints = NoConstraints.get();
|
|
|
|
// Does not seem to have any effect
|
|
PublicCustomForm->DisableAlign();
|
|
try
|
|
{
|
|
int PrevFontHeight = Form->Font->Height;
|
|
PublicCustomForm->ChangeScale(M, D);
|
|
// Re-rescale by Height as it has higher granularity, hence lower risk of loosing precision due to rounding
|
|
Form->Font->Height = MulDiv(PrevFontHeight, M, D);
|
|
|
|
ChangeControlScale(Form, M, D);
|
|
|
|
Constraints->MinWidth = MulDiv(Constraints->MinWidth, M, D);
|
|
Constraints->MaxWidth = MulDiv(Constraints->MaxWidth, M, D);
|
|
Constraints->MinHeight = MulDiv(Constraints->MinHeight, M, D);
|
|
Constraints->MaxHeight = MulDiv(Constraints->MaxHeight, M, D);
|
|
PublicCustomForm->Constraints = Constraints.get();
|
|
}
|
|
__finally
|
|
{
|
|
PublicCustomForm->EnableAlign();
|
|
}
|
|
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall FormShowingChanged(TForm * Form, TWndMethod WndProc, TMessage & Message)
|
|
{
|
|
if (IsMainFormLike(Form))
|
|
{
|
|
if (Form->Showing)
|
|
{
|
|
if (Application->MainForm != Form)
|
|
{
|
|
MainLikeForm = Form;
|
|
|
|
// When main form is hidden, no taskbar button for it is shown and
|
|
// this window does not become main window, so there won't be no taskbar
|
|
// icon created automatically (by VCL). So we force it manually here.
|
|
// This particularly happen for all windows/dialogs of command-line
|
|
// operations (e.g. /synchronize) after CreateScpExplorer() happens.
|
|
|
|
// Also CM_SHOWINGCHANGED happens twice, and the WS_EX_APPWINDOW flag
|
|
// from the first call is not preserved, re-applying on the second call too.
|
|
|
|
// TODO: What about minimize to tray?
|
|
|
|
int Style = GetWindowLong(Form->Handle, GWL_EXSTYLE);
|
|
if (FLAGCLEAR(Style, WS_EX_APPWINDOW))
|
|
{
|
|
Style |= WS_EX_APPWINDOW;
|
|
SetWindowLong(Form->Handle, GWL_EXSTYLE, Style);
|
|
}
|
|
}
|
|
|
|
if (Form->Perform(WM_MANAGES_CAPTION, 0, 0) == 0)
|
|
{
|
|
Form->Caption = FormatFormCaption(Form, Form->Caption);
|
|
}
|
|
SendMessage(Form->Handle, WM_SETICON, ICON_BIG, reinterpret_cast<long>(Application->Icon->Handle));
|
|
}
|
|
else
|
|
{
|
|
if (MainLikeForm == Form)
|
|
{
|
|
// Do not bother with hiding the WS_EX_APPWINDOW flag
|
|
// as the window is closing anyway.
|
|
MainLikeForm = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Part of following code (but actually not all, TODO), has to happen
|
|
// for all windows when VCL main window is hidden (particularly the last branch).
|
|
// This is different from above brach, that should happen only for top-level visible window.
|
|
if ((Application->MainForm == Form) ||
|
|
// this particularly happens if error occurs while main
|
|
// window is being shown (e.g. non existent local directory when opening
|
|
// explorer)
|
|
((Application->MainForm != NULL) && !Application->MainForm->Visible))
|
|
{
|
|
if (!Form->Showing)
|
|
{
|
|
// when closing main form, remember its monitor,
|
|
// so that the next form is shown on the same one
|
|
LastMonitor = Form->Monitor;
|
|
}
|
|
else if ((LastMonitor != NULL) && (LastMonitor != Form->Monitor) &&
|
|
Form->Showing)
|
|
{
|
|
// would actually always be poScreenCenter, see _SafeFormCreate
|
|
if ((Form->Position == poMainFormCenter) ||
|
|
(Form->Position == poOwnerFormCenter) ||
|
|
(Form->Position == poScreenCenter))
|
|
{
|
|
// this would typically be a standalone message box (e.g. /UninstallCleanup or /Update)
|
|
|
|
// If DPI changes (as the form moves to a monitor with a non-system DPI),
|
|
// we have to re-center as the form size changed too.
|
|
int PixelsPerInch;
|
|
do
|
|
{
|
|
PixelsPerInch = Form->PixelsPerInch;
|
|
// taken from TCustomForm::SetWindowToMonitor
|
|
Form->SetBounds(LastMonitor->Left + ((LastMonitor->Width - Form->Width) / 2),
|
|
LastMonitor->Top + ((LastMonitor->Height - Form->Height) / 2),
|
|
Form->Width, Form->Height);
|
|
Form->Position = poDesigned;
|
|
}
|
|
while (PixelsPerInch != Form->PixelsPerInch);
|
|
}
|
|
else if ((Form->Position != poDesigned) &&
|
|
(Form->Position != poDefaultPosOnly))
|
|
{
|
|
// we do not expect any other positioning
|
|
DebugFail();
|
|
}
|
|
}
|
|
// otherwise it would not get centered
|
|
else if ((Form->Position == poMainFormCenter) ||
|
|
(Form->Position == poOwnerFormCenter))
|
|
{
|
|
Form->Position = poScreenCenter;
|
|
}
|
|
}
|
|
|
|
if (Form->Showing)
|
|
{
|
|
// At least on single monitor setup, monitor DPI is 100% but system DPI is higher,
|
|
// WM_DPICHANGED is not sent. But VCL scales the form using system DPI.
|
|
// Also we have to do this always for implicitly placed forms (poDefaultPosOnly), like TEditorForm,
|
|
// as they never get the WM_DPICHANGED.
|
|
// Call this before WndProc below, i.e. before OnShow event (particularly important for the TEditorForm::FormShow).
|
|
|
|
// GetControlPixelsPerInch would return Form.PixelsPerInch, but we want to get a new DPI of the form monitor.
|
|
ChangeFormPixelsPerInch(Form, GetMonitorPixelsPerInch(GetMonitorFromControl(Form)));
|
|
}
|
|
|
|
bool WasFormCenter =
|
|
(Form->Position == poMainFormCenter) ||
|
|
(Form->Position == poOwnerFormCenter);
|
|
WndProc(Message);
|
|
// Make sure dialogs are shown on-screen even if center of the main window
|
|
// is off-screen. Occurs e.g. if you move the main window so that
|
|
// only window title is visible above taksbar.
|
|
if (Form->Showing && WasFormCenter && (Form->Position == poDesigned))
|
|
{
|
|
TRect Rect;
|
|
// Reading Form.Left/Form.Top instead here does not work, likely due to some
|
|
// bug, when querying TProgressForm opened from TEditorForm (reloading remote file)
|
|
GetWindowRect(Form->Handle, &Rect);
|
|
|
|
int Left = Rect.Left;
|
|
int Top = Rect.Top;
|
|
TRect WorkArea = Form->Monitor->WorkareaRect;
|
|
|
|
if (Left + Rect.Width() > WorkArea.Right)
|
|
{
|
|
Left = WorkArea.Right - Rect.Width();
|
|
}
|
|
if (Left < WorkArea.Left)
|
|
{
|
|
Left = WorkArea.Left;
|
|
}
|
|
if (Top + Rect.Height() > WorkArea.Bottom)
|
|
{
|
|
Top = WorkArea.Bottom - Rect.Height();
|
|
}
|
|
if (Top < WorkArea.Top)
|
|
{
|
|
Top = WorkArea.Top;
|
|
}
|
|
if ((Left != Rect.Left) ||
|
|
(Top != Rect.Top))
|
|
{
|
|
SetWindowPos(Form->Handle, 0, Left, Top, Rect.Width(), Rect.Height(),
|
|
SWP_NOZORDER + SWP_NOACTIVATE);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static TCustomForm * WindowPrintForm = NULL;
|
|
static DWORD WindowPrintPrevClick = 0;
|
|
static unsigned int WindowPrintClickCount = 0;
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall CountClicksForWindowPrint(TForm * Form)
|
|
{
|
|
if ((WinConfiguration != NULL) && WinConfiguration->AllowWindowPrint)
|
|
{
|
|
DWORD Tick = GetTickCount();
|
|
if (WindowPrintForm != Form)
|
|
{
|
|
WindowPrintForm = Form;
|
|
WindowPrintClickCount = 0;
|
|
}
|
|
if (WindowPrintPrevClick < Tick - 500)
|
|
{
|
|
WindowPrintClickCount = 0;
|
|
}
|
|
WindowPrintClickCount++;
|
|
WindowPrintPrevClick = Tick;
|
|
if (WindowPrintClickCount == 3)
|
|
{
|
|
WindowPrintClickCount = 0;
|
|
|
|
TInstantOperationVisualizer Visualizer;
|
|
|
|
// get the device context of the screen
|
|
HDC ScreenDC = CreateDC(L"DISPLAY", NULL, NULL, NULL);
|
|
// and a device context to put it in
|
|
HDC MemoryDC = CreateCompatibleDC(ScreenDC);
|
|
|
|
try
|
|
{
|
|
bool Sizable = (Form->BorderStyle == bsSizeable);
|
|
int Frame = GetSystemMetrics(Sizable ? SM_CXSIZEFRAME : SM_CXFIXEDFRAME) - 1;
|
|
int Width = Form->Width - 2*Frame;
|
|
int Height = Form->Height - Frame;
|
|
|
|
// maybe worth checking these are positive values
|
|
HBITMAP Bitmap = CreateCompatibleBitmap(ScreenDC, Width, Height);
|
|
try
|
|
{
|
|
// get a new bitmap
|
|
HBITMAP OldBitmap = static_cast<HBITMAP>(SelectObject(MemoryDC, Bitmap));
|
|
|
|
BitBlt(MemoryDC, 0, 0, Width, Height, ScreenDC, Form->Left + Frame, Form->Top, SRCCOPY);
|
|
Bitmap = static_cast<HBITMAP>(SelectObject(MemoryDC, OldBitmap));
|
|
|
|
OpenClipboard(NULL);
|
|
try
|
|
{
|
|
EmptyClipboard();
|
|
SetClipboardData(CF_BITMAP, Bitmap);
|
|
}
|
|
__finally
|
|
{
|
|
CloseClipboard();
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
DeleteObject(Bitmap);
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
DeleteDC(MemoryDC);
|
|
DeleteDC(ScreenDC);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
inline void __fastcall DoFormWindowProc(TCustomForm * Form, TWndMethod WndProc,
|
|
TMessage & Message)
|
|
{
|
|
TForm * AForm = dynamic_cast<TForm *>(Form);
|
|
DebugAssert(AForm != NULL);
|
|
if ((Message.Msg == WM_SYSCOMMAND) &&
|
|
(Message.WParam == SC_CONTEXTHELP))
|
|
{
|
|
FormHelp(Form);
|
|
Message.Result = 1;
|
|
}
|
|
else if (Message.Msg == CM_SHOWINGCHANGED)
|
|
{
|
|
FormShowingChanged(AForm, WndProc, Message);
|
|
}
|
|
else if (Message.Msg == WM_SETICON)
|
|
{
|
|
// WORKAROUND: Swallow VCL attempt to clear the icon from TCustomForm.WMDestroy.
|
|
// The clearing still happens to be visualised before the form is hidden.
|
|
// On resizable forms, the icon gets replaced by the default application icon,
|
|
// on the other forms, the icon disappears and window caption is shifted left.
|
|
if (Message.LParam != 0)
|
|
{
|
|
WndProc(Message);
|
|
}
|
|
}
|
|
else if (Message.Msg == WM_GETDPISCALEDSIZE)
|
|
{
|
|
WndProc(Message);
|
|
int M, D;
|
|
GetFormRescaleRatio(AForm, LOWORD(Message.WParam), M, D);
|
|
SIZE & Size = *(reinterpret_cast<SIZE *>(Message.LParam));
|
|
Size.cx = MulDiv(Size.cx, M, D);
|
|
Size.cy = MulDiv(Size.cy, M, D);
|
|
Message.Result = TRUE;
|
|
}
|
|
else if (Message.Msg == WM_DPICHANGED)
|
|
{
|
|
ChangeFormPixelsPerInch(AForm, LOWORD(Message.WParam));
|
|
WndProc(Message);
|
|
}
|
|
else if ((Message.Msg == WM_LBUTTONDOWN) || (Message.Msg == WM_LBUTTONDBLCLK))
|
|
{
|
|
CountClicksForWindowPrint(AForm);
|
|
WndProc(Message);
|
|
}
|
|
else
|
|
{
|
|
WndProc(Message);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall FormWindowProc(void * Data, TMessage & Message)
|
|
{
|
|
TCustomForm * Form = static_cast<TCustomForm *>(Data);
|
|
DoFormWindowProc(Form, ControlWndProc(Form), Message);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall InitializeSystemSettings()
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall FinalizeSystemSettings()
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
#ifdef _DEBUG
|
|
void __fastcall VerifyControl(TControl * Control)
|
|
{
|
|
// If at this time the control has allocated persistence data that are used
|
|
// for delayed handle recreation, we are at potential risk, as the future
|
|
// de-persistence may overwrite meanwhile changed data.
|
|
// For instance it may happen with list view that DPI scaling gets lost.
|
|
// This for example happens when the list view has both design time
|
|
// ReadOnly = true and some items set. We cannot usually explicitly
|
|
// check for the presence of items as while the listview does not have
|
|
// a handle allocated, item count querying does not work
|
|
// (see also a check below)
|
|
if (ControlHasRecreationPersistenceData(Control))
|
|
{
|
|
// Though if RTL bidi mode is set, the controls are recreated always,
|
|
// as we cannot really prevent it. So we force creation here.
|
|
DebugAssert(Application->BiDiMode != bdLeftToRight);
|
|
TWinControl * WinControl = dynamic_cast<TWinControl *>(Control);
|
|
// It must be TWinControl if ControlHasRecreationPersistenceData returned true
|
|
if (DebugAlwaysTrue(WinControl != NULL))
|
|
{
|
|
WinControl->HandleNeeded();
|
|
}
|
|
}
|
|
|
|
TCustomListView * ListView = dynamic_cast<TCustomListView *>(Control);
|
|
if (ListView != NULL)
|
|
{
|
|
// As of now the HandleAllocated check is pointless as
|
|
// ListView->Items->Count returns 0 when the handle is not allocated yet.
|
|
// But we want to know if the implementation ever changes to allocate the handle
|
|
// on the call. Because we do not want to allocate a handle here as
|
|
// that would change the debug mode behavior from release behavior,
|
|
// possibly hiding away some problems.
|
|
DebugAssert(!ListView->HandleAllocated() || (ListView->Items->Count == 0));
|
|
}
|
|
}
|
|
#endif
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ApplySystemSettingsOnControl(TControl * Control)
|
|
{
|
|
#ifdef _DEBUG
|
|
VerifyControl(Control);
|
|
#endif
|
|
|
|
// WORKAROUND
|
|
// VCL does not scale status par panels (while for instance it does
|
|
// scale list view headers). Remove this if they ever "fix" this.
|
|
// Neither they scale the status bar size if UseSystemFont is true.
|
|
// they claim it should scale with font size, but it does not,
|
|
// probably because they eat WM_SIZE in TCustomStatusBar.WMSize.
|
|
// (used to be issue 83599 on Embarcadero QC, when it was still online)
|
|
// Check TCustomStatusBar.ChangeScale() for changes.
|
|
// For TBX status bars, this is implemented in TTBXCustomStatusBar.ChangeScale
|
|
TStatusBar * StatusBar = dynamic_cast<TStatusBar *>(Control);
|
|
if (StatusBar != NULL)
|
|
{
|
|
// We should have UseSystemFont and bottom alignment set for all status bars.
|
|
if (DebugAlwaysTrue(StatusBar->UseSystemFont) &&
|
|
DebugAlwaysTrue(StatusBar->Align == alBottom))
|
|
{
|
|
StatusBar->Height = ScaleByTextHeight(StatusBar, StatusBar->Height);
|
|
}
|
|
|
|
for (int Index = 0; Index < StatusBar->Panels->Count; Index++)
|
|
{
|
|
TStatusPanel * Panel = StatusBar->Panels->Items[Index];
|
|
Panel->Width = ScaleByTextHeight(StatusBar, Panel->Width);
|
|
}
|
|
}
|
|
|
|
TCustomListView * ListView = dynamic_cast<TCustomListView *>(Control);
|
|
TCustomIEListView * IEListView = dynamic_cast<TCustomIEListView *>(Control);
|
|
// For IEListView, this is (somewhat) handled in the TCustomListViewColProperties
|
|
if ((ListView != NULL) && (IEListView == NULL))
|
|
{
|
|
TListView * PublicListView = reinterpret_cast<TListView *>(ListView);
|
|
|
|
for (int Index = 0; Index < PublicListView->Columns->Count; Index++)
|
|
{
|
|
TListColumn * Column = ListView->Column[Index];
|
|
Column->MaxWidth = ScaleByTextHeight(ListView, Column->MaxWidth);
|
|
Column->MinWidth = ScaleByTextHeight(ListView, Column->MinWidth);
|
|
}
|
|
}
|
|
|
|
// WORKAROUND for lack of public API for mimicking Explorer-style mouse selection
|
|
// See https://stackoverflow.com/q/15750842/850848
|
|
if (IEListView != NULL)
|
|
{
|
|
// It should not be a problem to call the LVM_QUERYINTERFACE
|
|
// on earlier versions of Windows. It should be noop.
|
|
if (IsWin7())
|
|
{
|
|
IListView_Win7 * ListViewIntf = NULL;
|
|
SendMessage(IEListView->Handle, LVM_QUERYINTERFACE, reinterpret_cast<WPARAM>(&IID_IListView_Win7), reinterpret_cast<LPARAM>(&ListViewIntf));
|
|
if (ListViewIntf != NULL)
|
|
{
|
|
ListViewIntf->SetSelectionFlags(1, 1);
|
|
ListViewIntf->Release();
|
|
}
|
|
else
|
|
{
|
|
DebugAssert(IsWine());
|
|
}
|
|
}
|
|
}
|
|
|
|
TWinControl * WinControl = dynamic_cast<TWinControl *>(Control);
|
|
if (WinControl != NULL)
|
|
{
|
|
for (int Index = 0; Index < WinControl->ControlCount; Index++)
|
|
{
|
|
ApplySystemSettingsOnControl(WinControl->Controls[Index]);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// Settings that must be set as soon as possible.
|
|
void __fastcall UseSystemSettingsPre(TCustomForm * Control)
|
|
{
|
|
LocalSystemSettings(Control);
|
|
|
|
TWndMethod WindowProc;
|
|
((TMethod*)&WindowProc)->Data = Control;
|
|
((TMethod*)&WindowProc)->Code = FormWindowProc;
|
|
Control->WindowProc = WindowProc;
|
|
|
|
if (Control->HelpKeyword.IsEmpty())
|
|
{
|
|
// temporary help keyword to enable F1 key in all forms
|
|
Control->HelpKeyword = L"start";
|
|
}
|
|
|
|
ApplySystemSettingsOnControl(Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
static void FlipAnchors(TControl * Control)
|
|
{
|
|
// WORKAROUND VCL flips the Align, but not the Anchors
|
|
TAnchors Anchors = Control->Anchors;
|
|
if (Anchors.Contains(akLeft) != Anchors.Contains(akRight))
|
|
{
|
|
if (Anchors.Contains(akLeft))
|
|
{
|
|
Anchors << akRight;
|
|
Anchors >> akLeft;
|
|
}
|
|
else
|
|
{
|
|
Anchors << akLeft;
|
|
Anchors >> akRight;
|
|
}
|
|
}
|
|
Control->Anchors = Anchors;
|
|
|
|
TWinControl * WinControl = dynamic_cast<TWinControl *>(Control);
|
|
if (WinControl != NULL)
|
|
{
|
|
for (int Index = 0; Index < WinControl->ControlCount; Index++)
|
|
{
|
|
FlipAnchors(WinControl->Controls[Index]);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// Settings that must be set only after whole form is constructed
|
|
void __fastcall UseSystemSettingsPost(TCustomForm * Control)
|
|
{
|
|
// When showing an early error message
|
|
if (WinConfiguration != NULL)
|
|
{
|
|
UnicodeString FlipStr = LoadStr(FLIP_CHILDREN);
|
|
int FlipChildrenFlag =
|
|
AdjustLocaleFlag(FlipStr, WinConfiguration->FlipChildrenOverride, false, true, false);
|
|
if (static_cast<bool>(FlipChildrenFlag))
|
|
{
|
|
Control->FlipChildren(true);
|
|
|
|
FlipAnchors(Control);
|
|
}
|
|
}
|
|
ResetSystemSettings(Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall UseSystemSettings(TCustomForm * Control)
|
|
{
|
|
UseSystemSettingsPre(Control);
|
|
UseSystemSettingsPost(Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ResetSystemSettings(TCustomForm * /*Control*/)
|
|
{
|
|
// noop
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
struct TShowAsModalStorage
|
|
{
|
|
bool TriggerModalFinished;
|
|
void * FocusWindowList;
|
|
HWND FocusActiveWindow;
|
|
TFocusState FocusState;
|
|
TCursor SaveCursor;
|
|
int SaveCount;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ShowAsModal(TForm * Form, void *& Storage, bool BringToFront, bool TriggerModalStarted)
|
|
{
|
|
SetCorrectFormParent(Form);
|
|
CancelDrag();
|
|
if (GetCapture() != 0) SendMessage(GetCapture(), WM_CANCELMODE, 0, 0);
|
|
ReleaseCapture();
|
|
if (TriggerModalStarted)
|
|
{
|
|
Application->ModalStarted();
|
|
}
|
|
(static_cast<TPublicForm*>(Form))->FFormState << fsModal;
|
|
|
|
TShowAsModalStorage * AStorage = new TShowAsModalStorage;
|
|
|
|
AStorage->TriggerModalFinished = TriggerModalStarted;
|
|
AStorage->FocusActiveWindow = GetActiveWindow();
|
|
AStorage->FocusState = SaveFocusState();
|
|
Screen->SaveFocusedList->Insert(0, Screen->FocusedForm);
|
|
Screen->FocusedForm = Form;
|
|
AStorage->SaveCursor = Screen->Cursor;
|
|
// This is particularly used when displaing progress window
|
|
// while downloading via temporary folder
|
|
// (the mouse cursor is yet hidden at this point).
|
|
// While the code was added to workaround the above problem,
|
|
// it is taken from TCustomForm.ShowModal and
|
|
// should have been here ever since.
|
|
Screen->Cursor = crDefault;
|
|
AStorage->SaveCount = Screen->CursorCount;
|
|
AStorage->FocusWindowList = DisableTaskWindows(0);
|
|
|
|
// VCLCOPY (TCustomForm::Show)
|
|
Form->Visible = true;
|
|
if (BringToFront)
|
|
{
|
|
Form->BringToFront();
|
|
}
|
|
|
|
SendMessage(Form->Handle, CM_ACTIVATE, 0, 0);
|
|
|
|
Storage = AStorage;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall HideAsModal(TForm * Form, void *& Storage)
|
|
{
|
|
DebugAssert((static_cast<TPublicForm*>(Form))->FFormState.Contains(fsModal));
|
|
TShowAsModalStorage * AStorage = static_cast<TShowAsModalStorage *>(Storage);
|
|
Storage = NULL;
|
|
|
|
SendMessage(Form->Handle, CM_DEACTIVATE, 0, 0);
|
|
if (GetActiveWindow() != Form->Handle)
|
|
{
|
|
AStorage->FocusActiveWindow = 0;
|
|
}
|
|
Form->Hide();
|
|
|
|
if (Screen->CursorCount == AStorage->SaveCount)
|
|
{
|
|
Screen->Cursor = AStorage->SaveCursor;
|
|
}
|
|
else
|
|
{
|
|
Screen->Cursor = crDefault;
|
|
}
|
|
|
|
EnableTaskWindows(AStorage->FocusWindowList);
|
|
|
|
if (Screen->SaveFocusedList->Count > 0)
|
|
{
|
|
Screen->FocusedForm = static_cast<TCustomForm *>(Screen->SaveFocusedList->First());
|
|
Screen->SaveFocusedList->Remove(Screen->FocusedForm);
|
|
}
|
|
else
|
|
{
|
|
Screen->FocusedForm = NULL;
|
|
}
|
|
|
|
if (AStorage->FocusActiveWindow != 0)
|
|
{
|
|
SetActiveWindow(AStorage->FocusActiveWindow);
|
|
}
|
|
|
|
RestoreFocusState(AStorage->FocusState);
|
|
|
|
(static_cast<TPublicForm*>(Form))->FFormState >> fsModal;
|
|
|
|
if (AStorage->TriggerModalFinished)
|
|
{
|
|
Application->ModalFinished();
|
|
}
|
|
|
|
delete AStorage;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall ReleaseAsModal(TForm * Form, void *& Storage)
|
|
{
|
|
bool Result = (Storage != NULL);
|
|
if (Result)
|
|
{
|
|
HideAsModal(Form, Storage);
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall SelectDirectory(UnicodeString & Path, const UnicodeString Prompt,
|
|
bool PreserveFileName)
|
|
{
|
|
bool Result;
|
|
unsigned int ErrorMode;
|
|
ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
|
|
|
|
try
|
|
{
|
|
UnicodeString Directory;
|
|
UnicodeString FileName;
|
|
// We do not have any real use for the PreserveFileName
|
|
if (!PreserveFileName || DirectoryExists(ApiPath(Path)))
|
|
{
|
|
Directory = Path;
|
|
}
|
|
else
|
|
{
|
|
Directory = ExtractFilePath(Path);
|
|
FileName = ExtractFileName(Path);
|
|
}
|
|
Result = SelectDirectory(Prompt, L"", Directory);
|
|
if (Result)
|
|
{
|
|
Path = Directory;
|
|
if (!FileName.IsEmpty())
|
|
{
|
|
Path = IncludeTrailingBackslash(Path) + FileName;
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
SetErrorMode(ErrorMode);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void SelectDirectoryForEdit(THistoryComboBox * Edit)
|
|
{
|
|
UnicodeString OriginalDirectory = ExpandEnvironmentVariables(Edit->Text);
|
|
UnicodeString Directory = OriginalDirectory;
|
|
if (SelectDirectory(Directory, LoadStr(SELECT_LOCAL_DIRECTORY), true) &&
|
|
!SamePaths(OriginalDirectory, Directory))
|
|
{
|
|
Edit->Text = Directory;
|
|
if (Edit->OnChange != NULL)
|
|
{
|
|
Edit->OnChange(Edit);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall ListViewAnyChecked(TListView * ListView, bool Checked)
|
|
{
|
|
bool AnyChecked = false;
|
|
for (int Index = 0; Index < ListView->Items->Count; Index++)
|
|
{
|
|
if (ListView->Items->Item[Index]->Checked == Checked)
|
|
{
|
|
AnyChecked = true;
|
|
break;
|
|
}
|
|
}
|
|
return AnyChecked;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ListViewCheckAll(TListView * ListView,
|
|
TListViewCheckAll CheckAll)
|
|
{
|
|
bool Check;
|
|
|
|
if (CheckAll == caToggle)
|
|
{
|
|
Check = ListViewAnyChecked(ListView, false);
|
|
}
|
|
else
|
|
{
|
|
Check = (CheckAll == caCheck);
|
|
}
|
|
|
|
for (int Index = 0; Index < ListView->Items->Count; Index++)
|
|
{
|
|
ListView->Items->Item[Index]->Checked = Check;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ComboAutoSwitchInitialize(TComboBox * ComboBox)
|
|
{
|
|
int PrevIndex = ComboBox->ItemIndex;
|
|
ComboBox->Items->BeginUpdate();
|
|
try
|
|
{
|
|
ComboBox->Clear();
|
|
ComboBox->Items->Add(LoadStr(AUTO_SWITCH_AUTO));
|
|
ComboBox->Items->Add(LoadStr(AUTO_SWITCH_OFF));
|
|
ComboBox->Items->Add(LoadStr(AUTO_SWITCH_ON));
|
|
}
|
|
__finally
|
|
{
|
|
ComboBox->Items->EndUpdate();
|
|
}
|
|
DebugAssert(PrevIndex < ComboBox->Items->Count);
|
|
ComboBox->ItemIndex = PrevIndex;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ComboAutoSwitchLoad(TComboBox * ComboBox, TAutoSwitch Value)
|
|
{
|
|
ComboBox->ItemIndex = 2 - Value;
|
|
if (ComboBox->ItemIndex < 0)
|
|
{
|
|
ComboBox->ItemIndex = 0;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TAutoSwitch __fastcall ComboAutoSwitchSave(TComboBox * ComboBox)
|
|
{
|
|
return (TAutoSwitch)(2 - ComboBox->ItemIndex);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall CheckBoxAutoSwitchLoad(TCheckBox * CheckBox, TAutoSwitch Value)
|
|
{
|
|
switch (Value)
|
|
{
|
|
case asOn:
|
|
CheckBox->State = cbChecked;
|
|
break;
|
|
case asOff:
|
|
CheckBox->State = cbUnchecked;
|
|
break;
|
|
default:
|
|
CheckBox->State = cbGrayed;
|
|
break;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TAutoSwitch __fastcall CheckBoxAutoSwitchSave(TCheckBox * CheckBox)
|
|
{
|
|
switch (CheckBox->State)
|
|
{
|
|
case cbChecked:
|
|
return asOn;
|
|
case cbUnchecked:
|
|
return asOff;
|
|
default:
|
|
return asAuto;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static const wchar_t PathWordDelimiters[] = L"\\/ ;,.\r\n=";
|
|
//---------------------------------------------------------------------------
|
|
static bool IsPathWordDelimiter(wchar_t Ch)
|
|
{
|
|
return (wcschr(PathWordDelimiters, Ch) != NULL);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// Windows algorithm is as follows (tested on W2k):
|
|
// right:
|
|
// is_delimiter(current)
|
|
// false:
|
|
// right(left(current) + 1)
|
|
// true:
|
|
// right(right(current) + 1)
|
|
// left:
|
|
// right(left(current) + 1)
|
|
int CALLBACK PathWordBreakProc(wchar_t * Ch, int Current, int Len, int Code)
|
|
{
|
|
int Result;
|
|
UnicodeString ACh(Ch, Len);
|
|
if (Code == WB_ISDELIMITER)
|
|
{
|
|
// we return negacy of what WinAPI docs says
|
|
Result = !IsPathWordDelimiter(ACh[Current + 1]);
|
|
}
|
|
else if (Code == WB_LEFT)
|
|
{
|
|
// skip consecutive delimiters
|
|
while ((Current > 0) &&
|
|
IsPathWordDelimiter(ACh[Current]))
|
|
{
|
|
Current--;
|
|
}
|
|
Result = ACh.SubString(1, Current - 1).LastDelimiter(PathWordDelimiters);
|
|
}
|
|
else if (Code == WB_RIGHT)
|
|
{
|
|
if (Current == 0)
|
|
{
|
|
// will be called again with Current == 1
|
|
Result = 0;
|
|
}
|
|
else
|
|
{
|
|
const wchar_t * P = wcspbrk(ACh.c_str() + Current - 1, PathWordDelimiters);
|
|
if (P == NULL)
|
|
{
|
|
Result = Len;
|
|
}
|
|
else
|
|
{
|
|
Result = P - ACh.c_str() + 1;
|
|
// skip consecutive delimiters
|
|
while ((Result < Len) &&
|
|
IsPathWordDelimiter(ACh[Result + 1]))
|
|
{
|
|
Result++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugFail();
|
|
Result = 0;
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TPathWordBreakProcComponent : public TComponent
|
|
{
|
|
public:
|
|
__fastcall TPathWordBreakProcComponent() :
|
|
TComponent(NULL)
|
|
{
|
|
}
|
|
|
|
void __fastcall PathWordBreakEditWindowProc(TMessage & Message);
|
|
|
|
TWinControl * WinControl;
|
|
TWndMethod PrevWindowProc;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TPathWordBreakProcComponent::PathWordBreakEditWindowProc(TMessage & Message)
|
|
{
|
|
bool Handled = false;
|
|
if (Message.Msg == WM_CHAR)
|
|
{
|
|
// Ctrl+Backspace
|
|
// Ctrl+Backspace is handled in WM_CHAR as any other char,
|
|
// so we have to swallow it here to prevent it getting inserted to the text
|
|
TWMChar & CharMessage = *reinterpret_cast<TWMChar *>(&Message);
|
|
if (CharMessage.CharCode == '\x7F')
|
|
{
|
|
TCustomEdit * Edit = dynamic_cast<TCustomEdit *>(WinControl);
|
|
TCustomComboBox * ComboBox = dynamic_cast<TCustomComboBox *>(WinControl);
|
|
|
|
if (((Edit != NULL) && (Edit->SelLength == 0)) ||
|
|
((ComboBox != NULL) && (ComboBox->SelLength == 0)))
|
|
{
|
|
// See TCustomMaskEdit.SetCursor
|
|
TKeyboardState KeyState;
|
|
GetKeyboardState(KeyState);
|
|
TKeyboardState NewKeyState;
|
|
memset(NewKeyState, 0, sizeof(NewKeyState));
|
|
NewKeyState[VK_CONTROL] = 0x81;
|
|
NewKeyState[VK_SHIFT] = 0x81;
|
|
SetKeyboardState(NewKeyState);
|
|
|
|
SendMessage(WinControl->Handle, WM_KEYDOWN, VK_LEFT, 1);
|
|
NewKeyState[VK_SHIFT] = 0;
|
|
NewKeyState[VK_CONTROL] = 0;
|
|
SetKeyboardState(NewKeyState);
|
|
|
|
SendMessage(WinControl->Handle, WM_KEYDOWN, VK_DELETE, 1);
|
|
SetKeyboardState(KeyState);
|
|
}
|
|
Message.Result = 1;
|
|
Handled = true;
|
|
}
|
|
}
|
|
|
|
if (!Handled)
|
|
{
|
|
if (PrevWindowProc != NULL)
|
|
{
|
|
PrevWindowProc(Message);
|
|
}
|
|
else
|
|
{
|
|
ControlWndProc(WinControl)(Message);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TPublicCustomCombo : public TCustomCombo
|
|
{
|
|
friend void __fastcall InstallPathWordBreakProc(TWinControl * Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall InstallPathWordBreakProc(TWinControl * Control)
|
|
{
|
|
// Since we are setting Application->ModalPopupMode = pmAuto,
|
|
// this has to be called from OnShow, not from constructor anymore,
|
|
// to have any effect
|
|
|
|
HWND Wnd;
|
|
if (dynamic_cast<TCustomCombo*>(Control) != NULL)
|
|
{
|
|
TPublicCustomCombo * Combo =
|
|
static_cast<TPublicCustomCombo *>(dynamic_cast<TCustomCombo *>(Control));
|
|
Combo->HandleNeeded();
|
|
Wnd = Combo->EditHandle;
|
|
}
|
|
else
|
|
{
|
|
Wnd = Control->Handle;
|
|
}
|
|
SendMessage(Wnd, EM_SETWORDBREAKPROC, 0, (LPARAM)(EDITWORDBREAKPROC)PathWordBreakProc);
|
|
|
|
TPathWordBreakProcComponent * PathWordBreakProcComponent = new TPathWordBreakProcComponent();
|
|
PathWordBreakProcComponent->Name = TPathWordBreakProcComponent::QualifiedClassName();
|
|
Control->InsertComponent(PathWordBreakProcComponent);
|
|
PathWordBreakProcComponent->WinControl = Control;
|
|
// Have to remember the proc because of TTBEditItemViewer.EditWndProc
|
|
PathWordBreakProcComponent->PrevWindowProc =
|
|
// Test is probably redundant, it's there to limit impact of the change.
|
|
((Control->WindowProc != ControlWndProc(Control)) ? Control->WindowProc : TWndMethod());
|
|
|
|
Control->WindowProc = PathWordBreakProcComponent->PathWordBreakEditWindowProc;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall RemoveHiddenControlsFromOrder(TControl ** ControlsOrder, int & Count)
|
|
{
|
|
int Shift = 0;
|
|
for (int Index = 0; Index < Count; Index++)
|
|
{
|
|
if (ControlsOrder[Index]->Visible)
|
|
{
|
|
ControlsOrder[Index - Shift] = ControlsOrder[Index];
|
|
}
|
|
else
|
|
{
|
|
Shift++;
|
|
}
|
|
}
|
|
Count -= Shift;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetVerticalControlsOrder(TControl ** ControlsOrder, int Count)
|
|
{
|
|
RemoveHiddenControlsFromOrder(ControlsOrder, Count);
|
|
|
|
if (Count > 0)
|
|
{
|
|
TWinControl * CommonParent = ControlsOrder[0]->Parent;
|
|
CommonParent->DisableAlign();
|
|
try
|
|
{
|
|
int Top = 0;
|
|
for (int Index = 0; Index < Count; Index++)
|
|
{
|
|
DebugAssert(ControlsOrder[Index]->Parent == CommonParent);
|
|
if ((Index == 0) || (Top > ControlsOrder[Index]->Top))
|
|
{
|
|
Top = ControlsOrder[Index]->Top;
|
|
}
|
|
}
|
|
|
|
for (int Index = 0; Index < Count; Index++)
|
|
{
|
|
TControl * Control = ControlsOrder[Index];
|
|
Control->Top = Top;
|
|
if (((Control->Align == alTop) || (Control->Align == alBottom)) ||
|
|
((Index == Count - 1) || (ControlsOrder[Index + 1]->Align == alBottom)))
|
|
{
|
|
Top += Control->Height;
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
CommonParent->EnableAlign();
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetHorizontalControlsOrder(TControl ** ControlsOrder, int Count)
|
|
{
|
|
RemoveHiddenControlsFromOrder(ControlsOrder, Count);
|
|
|
|
if (Count > 0)
|
|
{
|
|
TWinControl * CommonParent = ControlsOrder[0]->Parent;
|
|
CommonParent->DisableAlign();
|
|
try
|
|
{
|
|
int Left = 0;
|
|
for (int Index = 0; Index < Count; Index++)
|
|
{
|
|
DebugAssert(ControlsOrder[Index]->Parent == CommonParent);
|
|
if ((Index == 0) || (Left > ControlsOrder[Index]->Left))
|
|
{
|
|
Left = ControlsOrder[Index]->Left;
|
|
}
|
|
}
|
|
|
|
for (int Index = 0; Index < Count; Index++)
|
|
{
|
|
TControl * Control = ControlsOrder[Index];
|
|
Control->Left = Left;
|
|
if (((Control->Align == alLeft) || (Control->Align == alRight)) ||
|
|
((Index == Count - 1) || (ControlsOrder[Index + 1]->Align == alRight)))
|
|
{
|
|
Left += Control->Width;
|
|
}
|
|
// vertical alignment has priority, so alBottom-aligned controls start
|
|
// at the very left, even if there are any alLeft/alRight controls.
|
|
// for the reason this code is not necessary in SetVerticalControlsOrder.
|
|
// we could exit the loop as well here.
|
|
if ((Index == Count - 1) || (ControlsOrder[Index + 1]->Align == alBottom))
|
|
{
|
|
Left = 0;
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
CommonParent->EnableAlign();
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall MakeNextInTabOrder(TWinControl * Control, TWinControl * After)
|
|
{
|
|
if (After->TabOrder > Control->TabOrder)
|
|
{
|
|
After->TabOrder = Control->TabOrder;
|
|
}
|
|
else if (After->TabOrder < Control->TabOrder - 1)
|
|
{
|
|
After->TabOrder = static_cast<TTabOrder>(Control->TabOrder - 1);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall CutFormToDesktop(TForm * Form)
|
|
{
|
|
DebugAssert(Form->Monitor != NULL);
|
|
TRect Workarea = Form->Monitor->WorkareaRect;
|
|
if (Form->Top + Form->Height > Workarea.Bottom)
|
|
{
|
|
Form->Height = Workarea.Bottom - Form->Top;
|
|
}
|
|
if (Form->Left + Form->Width >= Workarea.Right)
|
|
{
|
|
Form->Width = Workarea.Right - Form->Left;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall UpdateFormPosition(TCustomForm * Form, TPosition Position)
|
|
{
|
|
if ((Position == poScreenCenter) ||
|
|
(Position == poOwnerFormCenter) ||
|
|
(Position == poMainFormCenter))
|
|
{
|
|
TCustomForm * CenterForm = NULL;
|
|
if ((Position == poOwnerFormCenter) ||
|
|
(Position == poMainFormCenter))
|
|
{
|
|
CenterForm = Application->MainForm;
|
|
if ((Position == poOwnerFormCenter) &&
|
|
(dynamic_cast<TCustomForm*>(Form->Owner) != NULL))
|
|
{
|
|
CenterForm = dynamic_cast<TCustomForm*>(Form->Owner);
|
|
}
|
|
}
|
|
|
|
TRect Bounds = Form->BoundsRect;
|
|
int X, Y;
|
|
if (CenterForm != NULL)
|
|
{
|
|
X = ((((TForm *)CenterForm)->Width - Bounds.Width()) / 2) +
|
|
((TForm *)CenterForm)->Left;
|
|
Y = ((((TForm *)CenterForm)->Height - Bounds.Height()) / 2) +
|
|
((TForm *)CenterForm)->Top;
|
|
}
|
|
else
|
|
{
|
|
X = (Form->Monitor->Width - Bounds.Width()) / 2;
|
|
Y = (Form->Monitor->Height - Bounds.Height()) / 2;
|
|
}
|
|
|
|
if (X < 0)
|
|
{
|
|
X = 0;
|
|
}
|
|
if (Y < 0)
|
|
{
|
|
Y = 0;
|
|
}
|
|
|
|
Form->SetBounds(X, Y, Bounds.Width(), Bounds.Height());
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ResizeForm(TCustomForm * Form, int Width, int Height)
|
|
{
|
|
// This has to be called only after DoFormWindowProc(CM_SHOWINGCHANGED),
|
|
// so that a correct monitor is considered.
|
|
// Note that we cannot use LastMonitor(), as ResizeForm is also called from
|
|
// TConsoleDialog::DoAdjustWindow, where we need to use the actual monitor
|
|
// (in case user moves the console window to a different monitor,
|
|
// than where a main window is [no matter how unlikely that is])
|
|
TRect WorkareaRect = Form->Monitor->WorkareaRect;
|
|
if (Height > WorkareaRect.Height())
|
|
{
|
|
Height = WorkareaRect.Height();
|
|
}
|
|
if (Width > WorkareaRect.Width())
|
|
{
|
|
Width = WorkareaRect.Width();
|
|
}
|
|
if (Height < Form->Constraints->MinHeight)
|
|
{
|
|
Height = Form->Constraints->MinHeight;
|
|
}
|
|
if (Width < Form->Constraints->MinWidth)
|
|
{
|
|
Width = Form->Constraints->MinWidth;
|
|
}
|
|
TRect Bounds = Form->BoundsRect;
|
|
int Top = Bounds.Top + ((Bounds.Height() - Height) / 2);
|
|
int Left = Bounds.Left + ((Bounds.Width() - Width) / 2);
|
|
if (Top + Height > WorkareaRect.Bottom)
|
|
{
|
|
Top = WorkareaRect.Bottom - Height;
|
|
}
|
|
if (Left + Width >= WorkareaRect.Right)
|
|
{
|
|
Left = WorkareaRect.Right - Width;
|
|
}
|
|
// WorkareaRect.Left is not 0, when secondary monitor is placed left of primary one.
|
|
// Similarly for WorkareaRect.Top.
|
|
if (Top < WorkareaRect.Top)
|
|
{
|
|
Top = WorkareaRect.Top;
|
|
}
|
|
if (Left < WorkareaRect.Left)
|
|
{
|
|
Left = WorkareaRect.Left;
|
|
}
|
|
Form->SetBounds(Left, Top, Width, Height);
|
|
Bounds = Form->BoundsRect;
|
|
// due to constraints, form can remain larger, make sure it is centered although
|
|
Left = Bounds.Left + ((Width - Bounds.Width()) / 2);
|
|
Top = Bounds.Top + ((Height - Bounds.Height()) / 2);
|
|
Form->SetBounds(Left, Top, Width, Height);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TComponent * __fastcall GetFormOwner()
|
|
{
|
|
if (Screen->ActiveForm != NULL)
|
|
{
|
|
return Screen->ActiveForm;
|
|
}
|
|
else
|
|
{
|
|
return Application;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetCorrectFormParent(TForm * /*Form*/)
|
|
{
|
|
// noop
|
|
// remove
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall InvokeHelp(TWinControl * Control)
|
|
{
|
|
DebugAssert(Control != NULL);
|
|
|
|
HELPINFO HelpInfo;
|
|
HelpInfo.cbSize = sizeof(HelpInfo);
|
|
HelpInfo.iContextType = HELPINFO_WINDOW;
|
|
HelpInfo.iCtrlId = 0;
|
|
HelpInfo.hItemHandle = Control->Handle;
|
|
HelpInfo.dwContextId = 0;
|
|
HelpInfo.MousePos.x = 0;
|
|
HelpInfo.MousePos.y = 0;
|
|
SendMessage(Control->Handle, WM_HELP, NULL, reinterpret_cast<long>(&HelpInfo));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall FocusableLabelCanvas(TStaticText * StaticText,
|
|
TCanvas ** ACanvas, TRect & R)
|
|
{
|
|
TCanvas * Canvas = CreateControlCanvas(StaticText);
|
|
try
|
|
{
|
|
R = StaticText->ClientRect;
|
|
|
|
TSize TextSize;
|
|
if (StaticText->AutoSize)
|
|
{
|
|
// We possibly could use the same code as in !AutoSize branch,
|
|
// keeping this to avoid problems in existing code
|
|
UnicodeString Caption = StaticText->Caption;
|
|
bool AccelChar = false;
|
|
if (StaticText->ShowAccelChar)
|
|
{
|
|
Caption = StripHotkey(Caption);
|
|
AccelChar = (Caption != StaticText->Caption);
|
|
}
|
|
TextSize = Canvas->TextExtent(Caption);
|
|
|
|
DebugAssert(StaticText->BorderStyle == sbsNone); // not taken into account
|
|
if (AccelChar)
|
|
{
|
|
TextSize.cy += 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRect TextRect;
|
|
SetRect(&TextRect, 0, 0, StaticText->Width, 0);
|
|
DrawText(Canvas->Handle, StaticText->Caption.c_str(), -1, &TextRect,
|
|
DT_CALCRECT | DT_WORDBREAK |
|
|
StaticText->DrawTextBiDiModeFlagsReadingOnly());
|
|
TextSize = TextRect.GetSize();
|
|
}
|
|
|
|
R.Bottom = R.Top + TextSize.cy;
|
|
// Should call ChangeBiDiModeAlignment when UseRightToLeftAlignment(),
|
|
// but the label seems to draw the text wrongly aligned, even though
|
|
// the alignment is correctly flipped in TCustomStaticText.CreateParams
|
|
switch (StaticText->Alignment)
|
|
{
|
|
case taLeftJustify:
|
|
R.Right = R.Left + TextSize.cx;
|
|
break;
|
|
|
|
case taRightJustify:
|
|
R.Left = Max(0, R.Right - TextSize.cx);
|
|
break;
|
|
|
|
case taCenter:
|
|
{
|
|
DebugFail(); // not used branch, possibly untested
|
|
int Diff = R.Width() - TextSize.cx;
|
|
R.Left += Diff / 2;
|
|
R.Right -= Diff - (Diff / 2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if (ACanvas == NULL)
|
|
{
|
|
delete Canvas;
|
|
}
|
|
}
|
|
|
|
if (ACanvas != NULL)
|
|
{
|
|
*ACanvas = Canvas;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall FocusableLabelWindowProc(void * Data, TMessage & Message,
|
|
bool & Clicked)
|
|
{
|
|
Clicked = false;
|
|
TStaticText * StaticText = static_cast<TStaticText *>(Data);
|
|
if (Message.Msg == WM_LBUTTONDOWN)
|
|
{
|
|
StaticText->SetFocus();
|
|
// in case the action takes long, make sure focus is shown immediately
|
|
UpdateWindow(StaticText->Handle);
|
|
Clicked = true;
|
|
Message.Result = 1;
|
|
}
|
|
else if (Message.Msg == WM_RBUTTONDOWN)
|
|
{
|
|
StaticText->SetFocus();
|
|
Message.Result = 1;
|
|
}
|
|
else if (Message.Msg == WM_CHAR)
|
|
{
|
|
if (reinterpret_cast<TWMChar &>(Message).CharCode == L' ')
|
|
{
|
|
Clicked = true;
|
|
Message.Result = 1;
|
|
}
|
|
else
|
|
{
|
|
ControlWndProc(StaticText)(Message);
|
|
}
|
|
}
|
|
else if (Message.Msg == CM_DIALOGCHAR)
|
|
{
|
|
if (StaticText->CanFocus() && StaticText->ShowAccelChar &&
|
|
IsAccel(reinterpret_cast<TCMDialogChar &>(Message).CharCode, StaticText->Caption))
|
|
{
|
|
StaticText->SetFocus();
|
|
// in case the action takes long, make sure focus is shown immediately
|
|
UpdateWindow(StaticText->Handle);
|
|
Clicked = true;
|
|
Message.Result = 1;
|
|
}
|
|
else
|
|
{
|
|
ControlWndProc(StaticText)(Message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ControlWndProc(StaticText)(Message);
|
|
}
|
|
|
|
if (Message.Msg == WM_PAINT)
|
|
{
|
|
TRect R;
|
|
TCanvas * Canvas;
|
|
FocusableLabelCanvas(StaticText, &Canvas, R);
|
|
try
|
|
{
|
|
if (StaticText->Focused())
|
|
{
|
|
Canvas->DrawFocusRect(R);
|
|
}
|
|
else if ((StaticText->Font->Color != LinkColor) && // LinkActionLabel and LinkLabel
|
|
!EndsStr(LinkAppLabelMark, StaticText->Caption)) // LinkAppLabel
|
|
{
|
|
Canvas->Pen->Style = psDot;
|
|
Canvas->Brush->Style = bsClear;
|
|
if (!StaticText->Enabled)
|
|
{
|
|
Canvas->Pen->Color = clBtnHighlight;
|
|
Canvas->MoveTo(R.Left + 1 + 1, R.Bottom);
|
|
Canvas->LineTo(R.Right + 1, R.Bottom);
|
|
Canvas->Pen->Color = clGrayText;
|
|
}
|
|
Canvas->MoveTo(R.Left, R.Bottom - 1);
|
|
Canvas->LineTo(R.Right, R.Bottom - 1);
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
delete Canvas;
|
|
}
|
|
}
|
|
else if ((Message.Msg == WM_SETFOCUS) || (Message.Msg == WM_KILLFOCUS) ||
|
|
(Message.Msg == CM_ENABLEDCHANGED))
|
|
{
|
|
StaticText->Invalidate();
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static THintWindow * PersistentHintWindow = NULL;
|
|
static TControl * PersistentHintControl = NULL;
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall CancelPersistentHint()
|
|
{
|
|
if (PersistentHintWindow != NULL)
|
|
{
|
|
PersistentHintControl = NULL;
|
|
SAFE_DESTROY(PersistentHintWindow);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ShowPersistentHint(TControl * Control, TPoint HintPos)
|
|
{
|
|
CancelPersistentHint();
|
|
|
|
THintInfo HintInfo;
|
|
HintInfo.HintControl = Control;
|
|
HintInfo.HintPos = HintPos;
|
|
HintInfo.HintMaxWidth = GetParentForm(Control)->Monitor->Width;
|
|
HintInfo.HintColor = Application->HintColor;
|
|
HintInfo.HintStr = GetShortHint(Control->Hint);
|
|
HintInfo.HintData = NULL;
|
|
|
|
bool CanShow = true;
|
|
if (Application->OnShowHint != NULL)
|
|
{
|
|
Application->OnShowHint(HintInfo.HintStr, CanShow, HintInfo);
|
|
}
|
|
|
|
if (CanShow)
|
|
{
|
|
PersistentHintControl = Control;
|
|
|
|
PersistentHintWindow = new TScreenTipHintWindow(Application);
|
|
PersistentHintWindow->BiDiMode = Control->BiDiMode;
|
|
PersistentHintWindow->Color = HintInfo.HintColor;
|
|
|
|
TRect HintWinRect;
|
|
if (HintInfo.HintMaxWidth < Control->Width)
|
|
{
|
|
HintInfo.HintMaxWidth = Control->Width;
|
|
}
|
|
HintWinRect = PersistentHintWindow->CalcHintRect(
|
|
HintInfo.HintMaxWidth, HintInfo.HintStr, HintInfo.HintData);
|
|
OffsetRect(HintWinRect, HintInfo.HintPos.x, HintInfo.HintPos.y);
|
|
// TODO: right align window placement for UseRightToLeftAlignment, see Forms.pas
|
|
|
|
PersistentHintWindow->ActivateHintData(HintWinRect, HintInfo.HintStr, HintInfo.HintData);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall HintLabelWindowProc(void * Data, TMessage & Message)
|
|
{
|
|
bool Clicked = false;
|
|
bool Cancel = false;
|
|
|
|
TStaticText * StaticText = static_cast<TStaticText *>(Data);
|
|
if (Message.Msg == CM_HINTSHOW)
|
|
{
|
|
TCMHintShow & HintShow = reinterpret_cast<TCMHintShow &>(Message);
|
|
if (PersistentHintControl == StaticText)
|
|
{
|
|
// do not allow standard hint when persistent is already shown
|
|
HintShow.Result = 1;
|
|
}
|
|
else
|
|
{
|
|
HintShow.HintInfo->HideTimeout = 100000; // never
|
|
}
|
|
}
|
|
else if (Message.Msg == CN_KEYDOWN)
|
|
{
|
|
if ((reinterpret_cast<TWMKey &>(Message).CharCode == VK_ESCAPE) &&
|
|
(PersistentHintControl == StaticText))
|
|
{
|
|
CancelPersistentHint();
|
|
StaticText->Invalidate();
|
|
Message.Result = 1;
|
|
}
|
|
else
|
|
{
|
|
FocusableLabelWindowProc(Data, Message, Clicked);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FocusableLabelWindowProc(Data, Message, Clicked);
|
|
}
|
|
|
|
if (Message.Msg == CM_CANCELMODE)
|
|
{
|
|
TCMCancelMode & CancelMessage = (TCMCancelMode&)Message;
|
|
if ((CancelMessage.Sender != StaticText) &&
|
|
(CancelMessage.Sender != PersistentHintWindow))
|
|
{
|
|
Cancel = true;
|
|
}
|
|
}
|
|
|
|
if ((Message.Msg == WM_DESTROY) || (Message.Msg == WM_KILLFOCUS))
|
|
{
|
|
Cancel = true;
|
|
}
|
|
|
|
if (Cancel && (PersistentHintControl == StaticText))
|
|
{
|
|
CancelPersistentHint();
|
|
}
|
|
|
|
if (Clicked && (PersistentHintControl != StaticText))
|
|
{
|
|
TRect R;
|
|
TPoint HintPos;
|
|
|
|
FocusableLabelCanvas(StaticText, NULL, R);
|
|
HintPos.y = R.Bottom - R.Top;
|
|
HintPos.x = R.Left;
|
|
|
|
ShowPersistentHint(StaticText, StaticText->ClientToScreen(HintPos));
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall HintLabel(TStaticText * StaticText, UnicodeString Hint)
|
|
{
|
|
// Currently all are right-justified, when other alignment is used,
|
|
// test respective branches in FocusableLabelCanvas.
|
|
DebugAssert(StaticText->Alignment == taRightJustify);
|
|
// With right-justify, it has to be off. We may not notice on original
|
|
// English version, results will differ with translations only
|
|
DebugAssert(!StaticText->AutoSize);
|
|
StaticText->ParentFont = true;
|
|
if (!Hint.IsEmpty())
|
|
{
|
|
StaticText->Hint = Hint;
|
|
}
|
|
StaticText->ShowHint = true;
|
|
StaticText->Cursor = crHandPoint;
|
|
|
|
TWndMethod WindowProc;
|
|
((TMethod*)&WindowProc)->Data = StaticText;
|
|
((TMethod*)&WindowProc)->Code = HintLabelWindowProc;
|
|
StaticText->WindowProc = WindowProc;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall ComboBoxFixWindowProc(void * Data, TMessage & Message)
|
|
{
|
|
// it is TCustomComboxBox, but the properties are published only by TComboBox
|
|
TComboBox * ComboBox = static_cast<TComboBox *>(Data);
|
|
if (Message.Msg == WM_SIZE)
|
|
{
|
|
UnicodeString Text = ComboBox->Text;
|
|
try
|
|
{
|
|
ControlWndProc(ComboBox)(Message);
|
|
}
|
|
__finally
|
|
{
|
|
// workaround for bug in combo box, that causes it to change text to any
|
|
// item from drop down list which starts with current text,
|
|
// after control is resized (unless the text is in drop down list as well)
|
|
ComboBox->Text = Text;
|
|
// hide selection, which is wrongly shown when form is resized, even when the box has not focus
|
|
if (!ComboBox->Focused())
|
|
{
|
|
ComboBox->SelLength = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ControlWndProc(ComboBox)(Message);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall FixComboBoxResizeBug(TCustomComboBox * ComboBox)
|
|
{
|
|
TWndMethod WindowProc;
|
|
((TMethod*)&WindowProc)->Data = ComboBox;
|
|
((TMethod*)&WindowProc)->Code = ComboBoxFixWindowProc;
|
|
ComboBox->WindowProc = WindowProc;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall LinkLabelClick(TStaticText * StaticText)
|
|
{
|
|
if (StaticText->OnClick != NULL)
|
|
{
|
|
StaticText->OnClick(StaticText);
|
|
}
|
|
else
|
|
{
|
|
OpenBrowser(StaticText->Caption);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall LinkLabelWindowProc(void * Data, TMessage & Message)
|
|
{
|
|
bool Clicked = false;
|
|
|
|
TStaticText * StaticText = static_cast<TStaticText *>(Data);
|
|
if (Message.Msg == WM_CONTEXTMENU)
|
|
{
|
|
TWMContextMenu & ContextMenu = reinterpret_cast<TWMContextMenu &>(Message);
|
|
|
|
if ((ContextMenu.Pos.x < 0) && (ContextMenu.Pos.y < 0))
|
|
{
|
|
TRect R;
|
|
FocusableLabelCanvas(StaticText, NULL, R);
|
|
TPoint P = StaticText->ClientToScreen(TPoint(R.Left, R.Bottom));
|
|
ContextMenu.Pos.x = static_cast<short>(P.x);
|
|
ContextMenu.Pos.y = static_cast<short>(P.y);
|
|
}
|
|
}
|
|
else if (Message.Msg == WM_KEYDOWN)
|
|
{
|
|
TWMKey & Key = reinterpret_cast<TWMKey &>(Message);
|
|
if ((GetKeyState(VK_CONTROL) < 0) && (Key.CharCode == L'C'))
|
|
{
|
|
TInstantOperationVisualizer Visualizer;
|
|
CopyToClipboard(StaticText->Caption);
|
|
Message.Result = 1;
|
|
}
|
|
else
|
|
{
|
|
FocusableLabelWindowProc(Data, Message, Clicked);
|
|
}
|
|
}
|
|
|
|
FocusableLabelWindowProc(Data, Message, Clicked);
|
|
|
|
if (Message.Msg == WM_DESTROY)
|
|
{
|
|
delete StaticText->PopupMenu;
|
|
DebugAssert(StaticText->PopupMenu == NULL);
|
|
}
|
|
|
|
if (Clicked)
|
|
{
|
|
LinkLabelClick(StaticText);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall LinkLabelContextMenuClick(void * Data, TObject * Sender)
|
|
{
|
|
TStaticText * StaticText = static_cast<TStaticText *>(Data);
|
|
TMenuItem * MenuItem = dynamic_cast<TMenuItem *>(Sender);
|
|
DebugAssert(MenuItem != NULL);
|
|
|
|
if (MenuItem->Tag == 0)
|
|
{
|
|
LinkLabelClick(StaticText);
|
|
}
|
|
else
|
|
{
|
|
TInstantOperationVisualizer Visualizer;
|
|
CopyToClipboard(StaticText->Caption);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall DoLinkLabel(TStaticText * StaticText)
|
|
{
|
|
StaticText->Transparent = false;
|
|
StaticText->ParentFont = true;
|
|
StaticText->Cursor = crHandPoint;
|
|
|
|
TWndMethod WindowProc;
|
|
((TMethod*)&WindowProc)->Data = StaticText;
|
|
((TMethod*)&WindowProc)->Code = LinkLabelWindowProc;
|
|
StaticText->WindowProc = WindowProc;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall LinkLabel(TStaticText * StaticText, UnicodeString Url,
|
|
TNotifyEvent OnEnter)
|
|
{
|
|
DoLinkLabel(StaticText);
|
|
|
|
StaticText->Font->Style = StaticText->Font->Style << fsUnderline;
|
|
|
|
reinterpret_cast<TButton*>(StaticText)->OnEnter = OnEnter;
|
|
|
|
if (!Url.IsEmpty())
|
|
{
|
|
StaticText->Caption = Url;
|
|
}
|
|
|
|
bool IsUrl = IsHttpOrHttpsUrl(StaticText->Caption);
|
|
if (IsUrl)
|
|
{
|
|
DebugAssert(StaticText->PopupMenu == NULL);
|
|
StaticText->PopupMenu = new TPopupMenu(StaticText);
|
|
try
|
|
{
|
|
TNotifyEvent ContextMenuOnClick;
|
|
((TMethod*)&ContextMenuOnClick)->Data = StaticText;
|
|
((TMethod*)&ContextMenuOnClick)->Code = LinkLabelContextMenuClick;
|
|
|
|
TMenuItem * Item;
|
|
|
|
Item = new TMenuItem(StaticText->PopupMenu);
|
|
Item->Caption = LoadStr(URL_LINK_OPEN);
|
|
Item->Tag = 0;
|
|
Item->ShortCut = ShortCut(L' ', TShiftState());
|
|
Item->OnClick = ContextMenuOnClick;
|
|
StaticText->PopupMenu->Items->Add(Item);
|
|
|
|
Item = new TMenuItem(StaticText->PopupMenu);
|
|
Item->Caption = LoadStr(EDIT_COPY);
|
|
Item->Tag = 1;
|
|
Item->ShortCut = ShortCut(L'C', TShiftState() << ssCtrl);
|
|
Item->OnClick = ContextMenuOnClick;
|
|
StaticText->PopupMenu->Items->Add(Item);
|
|
}
|
|
catch(...)
|
|
{
|
|
delete StaticText->PopupMenu;
|
|
DebugAssert(StaticText->PopupMenu == NULL);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
StaticText->Font->Color = LinkColor;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall LinkActionLabel(TStaticText * StaticText)
|
|
{
|
|
DoLinkLabel(StaticText);
|
|
|
|
StaticText->Font->Color = LinkColor;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall LinkAppLabel(TStaticText * StaticText)
|
|
{
|
|
DoLinkLabel(StaticText);
|
|
|
|
StaticText->Caption = StaticText->Caption + LinkAppLabelMark;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall HotTrackLabelMouseEnter(void * /*Data*/, TObject * Sender)
|
|
{
|
|
reinterpret_cast<TLabel *>(Sender)->Font->Color = clBlue;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall HotTrackLabelMouseLeave(void * /*Data*/, TObject * Sender)
|
|
{
|
|
reinterpret_cast<TLabel *>(Sender)->ParentFont = true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall HotTrackLabel(TLabel * Label)
|
|
{
|
|
DebugAssert(Label->OnMouseEnter == NULL);
|
|
DebugAssert(Label->OnMouseLeave == NULL);
|
|
|
|
Label->OnMouseEnter = MakeMethod<TNotifyEvent>(NULL, HotTrackLabelMouseEnter);
|
|
Label->OnMouseLeave = MakeMethod<TNotifyEvent>(NULL, HotTrackLabelMouseLeave);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetLabelHintPopup(TLabel * Label, const UnicodeString & Hint)
|
|
{
|
|
Label->Caption = Hint;
|
|
Label->Hint = Hint;
|
|
TRect Rect(0, 0, Label->Width, 0);
|
|
TScreenTipHintWindow::CalcHintTextRect(Label, Label->Canvas, Rect, Label->Caption);
|
|
Label->ShowHint = (Rect.Bottom > Label->Height);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall HasLabelHintPopup(TControl * Control, const UnicodeString & HintStr)
|
|
{
|
|
TLabel * HintLabel = dynamic_cast<TLabel *>(Control);
|
|
return (HintLabel != NULL) && (GetShortHint(HintLabel->Caption) == HintStr);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
Forms::TMonitor * __fastcall FormMonitor(TCustomForm * Form)
|
|
{
|
|
Forms::TMonitor * Result;
|
|
if ((Application->MainForm != NULL) && (Application->MainForm != Form))
|
|
{
|
|
Result = Application->MainForm->Monitor;
|
|
}
|
|
else if (LastMonitor != NULL)
|
|
{
|
|
Result = LastMonitor;
|
|
}
|
|
else
|
|
{
|
|
int i = 0;
|
|
while ((i < Screen->MonitorCount) && !Screen->Monitors[i]->Primary)
|
|
{
|
|
i++;
|
|
}
|
|
DebugAssert(Screen->Monitors[i]->Primary);
|
|
Result = Screen->Monitors[i];
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
int __fastcall GetLastMonitor()
|
|
{
|
|
if (LastMonitor != NULL)
|
|
{
|
|
return LastMonitor->MonitorNum;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall SetLastMonitor(int MonitorNum)
|
|
{
|
|
if ((MonitorNum >= 0) && (MonitorNum < Screen->MonitorCount))
|
|
{
|
|
LastMonitor = Screen->Monitors[MonitorNum];
|
|
}
|
|
else
|
|
{
|
|
LastMonitor = NULL;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TForm * __fastcall _SafeFormCreate(TMetaClass * FormClass, TComponent * Owner)
|
|
{
|
|
TForm * Form;
|
|
|
|
if (Owner == NULL)
|
|
{
|
|
Owner = GetFormOwner();
|
|
}
|
|
|
|
// If there is no main form yet, make this one main.
|
|
// This:
|
|
// - Makes other forms (dialogs invoked from this one),
|
|
// be placed on the same monitor (otherwise all new forms get placed
|
|
// on primary monitor)
|
|
// - Triggers MainForm-specific code in DoFormWindowProc.
|
|
// - Shows button on taskbar
|
|
if (Application->MainForm == NULL)
|
|
{
|
|
Application->CreateForm(FormClass, &Form);
|
|
DebugAssert(Application->MainForm == Form);
|
|
}
|
|
else
|
|
{
|
|
Form = dynamic_cast<TForm *>(Construct(FormClass, Owner));
|
|
DebugAssert(Form != NULL);
|
|
}
|
|
|
|
return Form;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool __fastcall SupportsSplitButton()
|
|
{
|
|
return (Win32MajorVersion >= 6);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static TButton * __fastcall FindStandardButton(TWinControl * Control, bool Default)
|
|
{
|
|
TButton * Result = NULL;
|
|
int Index = 0;
|
|
while ((Result == NULL) && (Index < Control->ControlCount))
|
|
{
|
|
TControl * ChildControl = Control->Controls[Index];
|
|
TButton * Button = dynamic_cast<TButton *>(ChildControl);
|
|
if ((Button != NULL) && (Default ? Button->Default : Button->Cancel))
|
|
{
|
|
Result = Button;
|
|
}
|
|
else
|
|
{
|
|
TWinControl * WinControl = dynamic_cast<TWinControl *>(ChildControl);
|
|
if (WinControl != NULL)
|
|
{
|
|
Result = FindStandardButton(WinControl, Default);
|
|
}
|
|
}
|
|
Index++;
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TModalResult __fastcall DefaultResult(TCustomForm * Form, TButton * DefaultButton)
|
|
{
|
|
// The point of this is to avoid hardcoding mrOk when checking dialog results.
|
|
// Previously we used != mrCancel instead, as mrCancel is more reliable,
|
|
// being automatically used for Esc/X buttons (and hence kind of forced to be used
|
|
// for Cancel buttons). But that failed to be reliable in the end, for
|
|
// ModalResult being mrNone, when Windows session is being logged off.
|
|
// We interpreted mrNone as OK, causing lots of troubles.
|
|
TModalResult Result = mrNone;
|
|
TButton * Button = FindStandardButton(Form, true);
|
|
if (DebugAlwaysTrue(Button != NULL))
|
|
{
|
|
Result = Button->ModalResult;
|
|
}
|
|
if (Result == mrNone)
|
|
{
|
|
DebugAssert((DefaultButton != NULL) && (DefaultButton->ModalResult != mrNone));
|
|
Result = DefaultButton->ModalResult;
|
|
}
|
|
else
|
|
{
|
|
// If default button fallback was provided,
|
|
// make sure it is the default button we actually detected
|
|
DebugAssert((DefaultButton == NULL) || (Button == DefaultButton));
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall DefaultButton(TButton * Button, bool Default)
|
|
{
|
|
// default property setter does not have guard for "the same value"
|
|
if (Button->Default != Default)
|
|
{
|
|
Button->Default = Default;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall MemoKeyDown(TObject * Sender, WORD & Key, TShiftState Shift)
|
|
{
|
|
// Sender can be Form or Memo itself
|
|
TControl * Control = dynamic_cast<TControl *>(Sender);
|
|
if (DebugAlwaysTrue(Control != NULL))
|
|
{
|
|
TCustomForm * Form = GetParentForm(Control);
|
|
// Particularly when WantReturns is true,
|
|
// memo swallows also Esc, so we have to handle it ourselves.
|
|
// See also ReadOnlyControl.
|
|
if ((Key == VK_ESCAPE) && Shift.Empty())
|
|
{
|
|
Form->ModalResult = mrCancel;
|
|
Key = 0;
|
|
}
|
|
else if ((Key == VK_RETURN) && Shift.Contains(ssCtrl))
|
|
{
|
|
Form->ModalResult = DefaultResult(Form);
|
|
Key = 0;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TIconOwnerComponent : public TComponent
|
|
{
|
|
public:
|
|
__fastcall TIconOwnerComponent(TIcon * Icon) :
|
|
TComponent(NULL),
|
|
FIcon(Icon)
|
|
{
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<TIcon> FIcon;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
static void __fastcall FixFormIcon(TForm * Form, int Size, int WidthMetric, int HeightMetric)
|
|
{
|
|
// Whole this code is to call ReadIcon from Vcl.Graphics.pas with correct size
|
|
|
|
// Clone the icon data (whole .ico file content, that is originally loaded from .dfm)
|
|
// to a new TIcon that does not have a size fixed yet (size cannot be changed after handle is allocated)
|
|
std::unique_ptr<TMemoryStream> Stream(new TMemoryStream());
|
|
Form->Icon->SaveToStream(Stream.get());
|
|
std::unique_ptr<TIcon> Icon(new TIcon());
|
|
Stream->Position = 0;
|
|
Icon->LoadFromStream(Stream.get());
|
|
|
|
// Set desired size
|
|
int Width = GetSystemMetricsForControl(Form, WidthMetric);
|
|
int Height = GetSystemMetricsForControl(Form, HeightMetric);
|
|
Icon->SetSize(Width, Height);
|
|
|
|
// This calls TIcon::RequireHandle that retrieves the best icon for given size
|
|
LPARAM LParam = reinterpret_cast<LPARAM>(Icon->Handle);
|
|
SendMessage(Form->Handle, WM_SETICON, Size, LParam);
|
|
|
|
// Make sure the icon is released
|
|
TIconOwnerComponent * IconOwnerComponent = new TIconOwnerComponent(Icon.release());
|
|
IconOwnerComponent->Name = TIconOwnerComponent::QualifiedClassName() + IntToStr(Size);
|
|
Form->InsertComponent(IconOwnerComponent);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall FixFormIcons(TForm * Form)
|
|
{
|
|
// VCL sets only ICON_BIG (so small icon is scaled down by OS from big icon),
|
|
// and it uses a random (first?) size from the resource,
|
|
// not the best size.
|
|
FixFormIcon(Form, ICON_SMALL, SM_CXSMICON, SM_CYSMICON);
|
|
FixFormIcon(Form, ICON_BIG, SM_CXICON, SM_CYICON);
|
|
// We rely on VCL not calling WM_SETICON ever after
|
|
// (what it would do, if CreateWnd is called again).
|
|
// That would overwrite the ICON_BIG.
|
|
// We might be able to make sure it uses a correct size by calling
|
|
// TIcon.ReleaseHandle and setting a correct size.
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
class TDesktopFontManager : public TComponent
|
|
{
|
|
public:
|
|
TDesktopFontManager();
|
|
virtual __fastcall ~TDesktopFontManager();
|
|
|
|
void AddControl(TControl * Control);
|
|
void Update();
|
|
|
|
protected:
|
|
virtual void __fastcall Notification(TComponent * AComponent, TOperation Operation);
|
|
|
|
private:
|
|
HWND FWindowHandle;
|
|
typedef std::set<TControl *> TControlSet;
|
|
TControlSet FControls;
|
|
|
|
void __fastcall WndProc(TMessage & Message);
|
|
void UpdateControl(TControl * Control);
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
TDesktopFontManager::TDesktopFontManager() : TComponent(NULL)
|
|
{
|
|
// Alternative is using Application->HookMainWindow
|
|
FWindowHandle = AllocateHWnd(WndProc);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
__fastcall TDesktopFontManager::~TDesktopFontManager()
|
|
{
|
|
DeallocateHWnd(FWindowHandle);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TDesktopFontManager::Notification(TComponent * AComponent, TOperation Operation)
|
|
{
|
|
if (DebugAlwaysTrue(Operation == opRemove))
|
|
{
|
|
TControl * Control = DebugNotNull(dynamic_cast<TControl *>(AComponent));
|
|
FControls.erase(Control);
|
|
}
|
|
|
|
TComponent::Notification(AComponent, Operation);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TDesktopFontManager::UpdateControl(TControl * Control)
|
|
{
|
|
class TPublicControl : public TControl
|
|
{
|
|
public:
|
|
__property Font;
|
|
};
|
|
|
|
TPublicControl * PublicControl = reinterpret_cast<TPublicControl *>(Control);
|
|
std::unique_ptr<TFont> DesktopFont(new TFont());
|
|
if (WinConfiguration->PanelFont.FontName.IsEmpty())
|
|
{
|
|
int PixelsPerInch = GetControlPixelsPerInch(Control);
|
|
TLogFont LogFont;
|
|
if (DebugAlwaysTrue(SystemParametersInfoForPixelsPerInch(SPI_GETICONTITLELOGFONT, sizeof(LogFont), &LogFont, 0, PixelsPerInch)))
|
|
{
|
|
DesktopFont->Handle = CreateFontIndirect(&LogFont);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TWinConfiguration::RestoreFont(WinConfiguration->PanelFont, DesktopFont.get());
|
|
DesktopFont->Height = ScaleByPixelsPerInchFromSystem(DesktopFont->Height, Control);
|
|
DesktopFont->PixelsPerInch = PublicControl->Font->PixelsPerInch;
|
|
}
|
|
|
|
// Neither CreateFontIndirect nor RestoreFont set color, so we should have the default set by TFont constructor here.
|
|
DebugAssert(DesktopFont->Color == clWindowText);
|
|
if (!SameFont(DesktopFont.get(), PublicControl->Font) ||
|
|
(DesktopFont->PixelsPerInch != PublicControl->Font->PixelsPerInch))
|
|
{
|
|
// Preserve color (particularly white color of file panel font in dark mode)
|
|
DesktopFont->Color = PublicControl->Font->Color;
|
|
|
|
PublicControl->Font->Assign(DesktopFont.get());
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TDesktopFontManager::AddControl(TControl * Control)
|
|
{
|
|
FControls.insert(Control);
|
|
Control->FreeNotification(this);
|
|
UpdateControl(Control);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void TDesktopFontManager::Update()
|
|
{
|
|
TControlSet::iterator I = FControls.begin();
|
|
while (I != FControls.end())
|
|
{
|
|
UpdateControl(*I);
|
|
I++;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall TDesktopFontManager::WndProc(TMessage & Message)
|
|
{
|
|
if (Message.Msg == WM_WININICHANGE)
|
|
{
|
|
Update();
|
|
}
|
|
Message.Result = DefWindowProc(FWindowHandle, Message.Msg, Message.WParam, Message.LParam);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
std::unique_ptr<TDesktopFontManager> DesktopFontManager(new TDesktopFontManager());
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall UseDesktopFont(TControl * Control)
|
|
{
|
|
TCustomStatusBar * StatusBar = dynamic_cast<TCustomStatusBar *>(Control);
|
|
if (StatusBar != NULL)
|
|
{
|
|
// prevent syncing to system font
|
|
StatusBar->UseSystemFont = false;
|
|
}
|
|
|
|
DesktopFontManager->AddControl(Control);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall UpdateDesktopFont()
|
|
{
|
|
DesktopFontManager->Update();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TShiftState __fastcall AllKeyShiftStates()
|
|
{
|
|
return TShiftState() << ssShift << ssAlt << ssCtrl;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
static bool __fastcall FormActivationHook(void * Data, TMessage & Message)
|
|
{
|
|
bool Result = false;
|
|
// Some dialogs, when application is restored from minimization,
|
|
// do not get activated. So we do it explicitly here.
|
|
// We cannot do this from TApplication::OnActivate because
|
|
// TApplication.WndProc resets focus to the last active window afterwards.
|
|
// So we override CM_ACTIVATE implementation here completely.
|
|
if (Message.Msg == CM_ACTIVATE)
|
|
{
|
|
TCustomForm * Form = static_cast<TCustomForm *>(Data);
|
|
if (Screen->FocusedForm == Form)
|
|
{
|
|
::SetFocus(Form->Handle);
|
|
// VCLCOPY
|
|
if (Application->OnActivate != NULL)
|
|
{
|
|
Application->OnActivate(Application);
|
|
}
|
|
Result = true;
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall HookFormActivation(TCustomForm * Form)
|
|
{
|
|
Application->HookMainWindow(MakeMethod<TWindowHook>(Form, FormActivationHook));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall UnhookFormActivation(TCustomForm * Form)
|
|
{
|
|
Application->UnhookMainWindow(MakeMethod<TWindowHook>(Form, FormActivationHook));
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void __fastcall ShowFormNoActivate(TForm * Form)
|
|
{
|
|
TPublicForm * PublicForm = static_cast<TPublicForm *>(Form);
|
|
|
|
// This is same as SendToBack, except for added SWP_NOACTIVATE (VCLCOPY)
|
|
SetWindowPos(PublicForm->WindowHandle, HWND_BOTTOM, 0, 0, 0, 0,
|
|
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
|
|
// This replaces TCustomForm::CMShowingChanged()
|
|
// which calls ShowWindow(Handle, SW_SHOWNORMAL).
|
|
|
|
ShowWindow(Form->Handle, SW_SHOWNOACTIVATE);
|
|
|
|
// - so we have to call DoShow explicitly.
|
|
PublicForm->DoShow();
|
|
|
|
// - also we skip applying TForm::Position (VCLCOPY)
|
|
if (DebugAlwaysTrue(Form->Position == poOwnerFormCenter))
|
|
{
|
|
TCustomForm * CenterForm = Application->MainForm;
|
|
TCustomForm * OwnerForm = dynamic_cast<TCustomForm *>(Form->Owner);
|
|
if (OwnerForm != NULL)
|
|
{
|
|
CenterForm = OwnerForm;
|
|
}
|
|
int X, Y;
|
|
if ((CenterForm != NULL) && (CenterForm != Form))
|
|
{
|
|
TRect Bounds = CenterForm->BoundsRect;
|
|
X = ((Bounds.Width() - Form->Width) / 2) + CenterForm->Left;
|
|
Y = ((Bounds.Height() - Form->Height) / 2) + CenterForm->Top;
|
|
}
|
|
else
|
|
{
|
|
X = (Screen->Width - Form->Width) / 2;
|
|
Y = (Screen->Height - Form->Height) / 2;
|
|
}
|
|
if (X < Screen->DesktopLeft)
|
|
{
|
|
X = Screen->DesktopLeft;
|
|
}
|
|
if (Y < Screen->DesktopTop)
|
|
{
|
|
Y = Screen->DesktopTop;
|
|
}
|
|
Form->SetBounds(X, Y, Form->Width, Form->Height);
|
|
// We cannot call SetWindowToMonitor().
|
|
// We cannot set FPosition = poDesigned, so workarea-checking code
|
|
// in DoFormWindowProc is not triggered
|
|
|
|
// If application is restored, dialog is not activated, do it manually.
|
|
// Wait for application to be activated to activate ourself.
|
|
HookFormActivation(Form);
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TPanel * __fastcall CreateBlankPanel(TComponent * Owner)
|
|
{
|
|
TPanel * Panel = new TPanel(Owner);
|
|
Panel->BevelOuter = bvNone;
|
|
Panel->BevelInner = bvNone; // default
|
|
Panel->BevelKind = bkNone;
|
|
return Panel;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool IsButtonBeingClicked(TButtonControl * Button)
|
|
{
|
|
class TPublicButtonControl : public TButtonControl
|
|
{
|
|
public:
|
|
__property ClicksDisabled;
|
|
};
|
|
TPublicButtonControl * PublicButton = reinterpret_cast<TPublicButtonControl *>(Button);
|
|
// HACK ClicksDisabled is set in TButtonControl.WndProc while changing focus as response to WM_LBUTTONDOWN.
|
|
return PublicButton->ClicksDisabled;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// When using this in OnExit handers, it's still possible that the user does not actually click the
|
|
// CancelButton (for example, when the button is released out of the button).
|
|
// Then the validation is bypassed. Consequently, all dialogs that uses this must still
|
|
// gracefully handle submission with non-validated data.
|
|
bool IsCancelButtonBeingClicked(TControl * Control)
|
|
{
|
|
TCustomForm * Form = GetParentForm(Control);
|
|
TButtonControl * CancelButton = FindStandardButton(Form, false);
|
|
// Find dialog has no Cancel button
|
|
return (CancelButton != NULL) && IsButtonBeingClicked(CancelButton);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
TCanvas * CreateControlCanvas(TControl * Control)
|
|
{
|
|
std::unique_ptr<TControlCanvas> Canvas(new TControlCanvas());
|
|
Canvas->Control = Control;
|
|
TPublicControl * PublicControl = static_cast<TPublicControl *>(Control);
|
|
Canvas->Font = PublicControl->Font;
|
|
return Canvas.release();
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void AutoSizeButton(TButton * Button)
|
|
{
|
|
std::unique_ptr<TCanvas> Canvas(CreateControlCanvas(Button));
|
|
int MinWidth = Canvas->TextWidth(Button->Caption) + ScaleByTextHeight(Button, (2 * 8));
|
|
if (Button->Width < MinWidth)
|
|
{
|
|
if (Button->Anchors.Contains(akRight))
|
|
{
|
|
Button->Left = Button->Left - (MinWidth - Button->Width);
|
|
}
|
|
Button->Width = MinWidth;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
void GiveTBItemPriority(TTBCustomItem * Item)
|
|
{
|
|
DebugAssert(Item->GetTopComponent() != NULL);
|
|
TTBCustomToolbar * ToolbarComponent = dynamic_cast<TTBCustomToolbar *>(Item->GetTopComponent());
|
|
if ((ToolbarComponent != NULL) &&
|
|
// Only for top-level buttons on custom command toolbar, not for submenus of the custom commands menu in the main menu
|
|
(Item->Parent == ToolbarComponent->Items))
|
|
{
|
|
TTBItemViewer * Viewer = ToolbarComponent->View->Find(Item);
|
|
ToolbarComponent->View->GivePriority(Viewer);
|
|
}
|
|
}
|