//--------------------------------------------------------------------------- #include #pragma hdrstop #include #include #include #include #include #include "JclDebug.hpp" #include "JclHookExcept.hpp" #include #include //--------------------------------------------------------------------------- #define WM_TRAY_ICON (WM_WINSCP_USER + 5) //--------------------------------------------------------------------- static TNotifyEvent GlobalOnMinimize = NULL; //--------------------------------------------------------------------- const IID IID_IListView_Win7 = {0xE5B16AF2, 0x3990, 0x4681, {0xA6, 0x09, 0x1F, 0x06, 0x0C, 0xD1, 0x42, 0x69}}; //--------------------------------------------------------------------- void __fastcall FormHelp(TCustomForm * Form) { InvokeHelp(Form->ActiveControl != NULL ? Form->ActiveControl : Form); } //--------------------------------------------------------------------------- TMessageParams::TMessageParams(unsigned int AParams) { Reset(); Params = AParams; } //--------------------------------------------------------------------------- TMessageParams::TMessageParams(const TQueryParams * AParams) { Reset(); if (AParams != NULL) { Aliases = AParams->Aliases; AliasesCount = AParams->AliasesCount; Timer = AParams->Timer; TimerEvent = AParams->TimerEvent; TimerMessage = AParams->TimerMessage; TimerAnswers = AParams->TimerAnswers; TimerQueryType = AParams->TimerQueryType; Timeout = AParams->Timeout; TimeoutAnswer = AParams->TimeoutAnswer; TimeoutResponse = AParams->TimeoutResponse; if (FLAGSET(AParams->Params, qpNeverAskAgainCheck)) { Params |= mpNeverAskAgainCheck; } if (FLAGSET(AParams->Params, qpAllowContinueOnError)) { Params |= mpAllowContinueOnError; } } } //--------------------------------------------------------------------------- inline void TMessageParams::Reset() { Params = 0; Aliases = NULL; AliasesCount = 0; Timer = 0; TimerEvent = NULL; TimerMessage = L""; TimerAnswers = 0; TimerQueryType = static_cast(-1); Timeout = 0; TimeoutAnswer = 0; TimeoutResponse = 0; NeverAskAgainTitle = L""; NeverAskAgainAnswer = 0; NeverAskAgainCheckedInitially = false; AllowHelp = true; ImageName = L""; MoreMessagesUrl = L""; MoreMessagesSize = TSize(); CustomCaption = L""; } //--------------------------------------------------------------------------- static bool __fastcall IsPositiveAnswer(unsigned int Answer) { return (Answer == qaYes) || (Answer == qaOK) || (Answer == qaYesToAll); } //--------------------------------------------------------------------------- static void __fastcall NeverAskAgainCheckClick(void * /*Data*/, TObject * Sender) { TCheckBox * CheckBox = dynamic_cast(Sender); DebugAssert(CheckBox != NULL); TForm * Dialog = dynamic_cast(CheckBox->Owner); DebugAssert(Dialog != NULL); unsigned int PositiveAnswer = 0; if (CheckBox->Checked) { if (CheckBox->Tag > 0) { PositiveAnswer = CheckBox->Tag; } else { for (int ii = 0; ii < Dialog->ControlCount; ii++) { TButton * Button = dynamic_cast(Dialog->Controls[ii]); if (Button != NULL) { if (IsPositiveAnswer(Button->ModalResult)) { PositiveAnswer = Button->ModalResult; break; } } } } DebugAssert(PositiveAnswer != 0); } for (int ii = 0; ii < Dialog->ControlCount; ii++) { TButton * Button = dynamic_cast(Dialog->Controls[ii]); if (Button != NULL) { if ((Button->ModalResult != 0) && (Button->ModalResult != static_cast(qaCancel))) { Button->Enabled = !CheckBox->Checked || (Button->ModalResult == static_cast(PositiveAnswer)); } if (Button->DropDownMenu != NULL) { for (int iii = 0; iii < Button->DropDownMenu->Items->Count; iii++) { TMenuItem * Item = Button->DropDownMenu->Items->Items[iii]; Item->Enabled = Item->Default || !CheckBox->Checked; } } } } } //--------------------------------------------------------------------------- static TCheckBox * __fastcall FindNeverAskAgainCheck(TForm * Dialog) { return DebugNotNull(dynamic_cast(Dialog->FindComponent(L"NeverAskAgainCheck"))); } //--------------------------------------------------------------------------- TForm * __fastcall CreateMessageDialogEx(const UnicodeString Msg, TStrings * MoreMessages, TQueryType Type, unsigned int Answers, UnicodeString HelpKeyword, const TMessageParams * Params, TButton *& TimeoutButton) { TMsgDlgType DlgType; switch (Type) { case qtConfirmation: DlgType = mtConfirmation; break; case qtInformation: DlgType = mtInformation; break; case qtError: DlgType = mtError; break; case qtWarning: DlgType = mtWarning; break; default: DebugFail(); } unsigned int TimeoutAnswer = (Params != NULL) ? Params->TimeoutAnswer : 0; unsigned int ActualAnswers = Answers; if ((Params == NULL) || Params->AllowHelp) { Answers = Answers | qaHelp; } if (IsInternalErrorHelpKeyword(HelpKeyword)) { Answers = Answers | qaReport; } if ((MoreMessages != NULL) && (MoreMessages->Count == 0)) { MoreMessages = NULL; } UnicodeString ImageName; UnicodeString MoreMessagesUrl; TSize MoreMessagesSize; UnicodeString CustomCaption; if (Params != NULL) { ImageName = Params->ImageName; MoreMessagesUrl = Params->MoreMessagesUrl; MoreMessagesSize = Params->MoreMessagesSize; CustomCaption = Params->CustomCaption; } const TQueryButtonAlias * Aliases = (Params != NULL) ? Params->Aliases : NULL; unsigned int AliasesCount = (Params != NULL) ? Params->AliasesCount : 0; UnicodeString NeverAskAgainCaption; bool HasNeverAskAgain = (Params != NULL) && FLAGSET(Params->Params, mpNeverAskAgainCheck); if (HasNeverAskAgain) { NeverAskAgainCaption = !Params->NeverAskAgainTitle.IsEmpty() ? (UnicodeString)Params->NeverAskAgainTitle : // qaOK | qaIgnore is used, when custom "non-answer" button is required LoadStr(((ActualAnswers == qaOK) || (ActualAnswers == (qaOK | qaIgnore))) ? NEVER_SHOW_AGAIN : NEVER_ASK_AGAIN); } TForm * Dialog = CreateMoreMessageDialog(Msg, MoreMessages, DlgType, Answers, Aliases, AliasesCount, TimeoutAnswer, &TimeoutButton, ImageName, NeverAskAgainCaption, MoreMessagesUrl, MoreMessagesSize, CustomCaption); try { if (HasNeverAskAgain && DebugAlwaysTrue(Params != NULL)) { TCheckBox * NeverAskAgainCheck = FindNeverAskAgainCheck(Dialog); NeverAskAgainCheck->Checked = Params->NeverAskAgainCheckedInitially; if (Params->NeverAskAgainAnswer > 0) { NeverAskAgainCheck->Tag = Params->NeverAskAgainAnswer; } NeverAskAgainCheck->OnClick = MakeMethod(NULL, NeverAskAgainCheckClick); } Dialog->HelpKeyword = HelpKeyword; if (FLAGSET(Answers, qaHelp)) { Dialog->BorderIcons = Dialog->BorderIcons << biHelp; } ResetSystemSettings(Dialog); } catch(...) { delete Dialog; throw; } return Dialog; } //--------------------------------------------------------------------------- unsigned int __fastcall ExecuteMessageDialog(TForm * Dialog, unsigned int Answers, const TMessageParams * Params) { FlashOnBackground(); unsigned int Answer = Dialog->ShowModal(); // mrCancel is returned always when X button is pressed, despite // no Cancel button was on the dialog. Find valid "cancel" answer. // mrNone is returned when Windows session is closing (log off) if ((Answer == mrCancel) || (Answer == mrNone)) { Answer = CancelAnswer(Answers); } if ((Params != NULL) && (Params->Params & mpNeverAskAgainCheck)) { TCheckBox * NeverAskAgainCheck = FindNeverAskAgainCheck(Dialog); if (NeverAskAgainCheck->Checked) { bool PositiveAnswer = (Params->NeverAskAgainAnswer > 0) ? (Answer == Params->NeverAskAgainAnswer) : IsPositiveAnswer(Answer); if (PositiveAnswer) { Answer = qaNeverAskAgain; } } } return Answer; } //--------------------------------------------------------------------------- class TMessageTimer : public TTimer { public: TQueryParamsTimerEvent Event; TForm * Dialog; __fastcall TMessageTimer(TComponent * AOwner); protected: void __fastcall DoTimer(TObject * Sender); }; //--------------------------------------------------------------------------- __fastcall TMessageTimer::TMessageTimer(TComponent * AOwner) : TTimer(AOwner) { Event = NULL; OnTimer = DoTimer; Dialog = NULL; } //--------------------------------------------------------------------------- void __fastcall TMessageTimer::DoTimer(TObject * /*Sender*/) { if (Event != NULL) { unsigned int Result = 0; Event(Result); if (Result != 0) { Dialog->ModalResult = Result; } } } //--------------------------------------------------------------------------- class TMessageTimeout : public TTimer { public: __fastcall TMessageTimeout(TComponent * AOwner, unsigned int Timeout, TButton * Button, unsigned int Answer); protected: unsigned int FOrigTimeout; unsigned int FTimeout; TButton * FButton; UnicodeString FOrigCaption; TPoint FOrigCursorPos; std::unique_ptr FApplicationEvents; unsigned int FAnswer; void __fastcall DoTimer(TObject * Sender); void __fastcall UpdateButton(); void __fastcall ApplicationMessage(TMsg & Msg, bool & Handled); void __fastcall MouseMove(); void __fastcall Cancel(); }; //--------------------------------------------------------------------------- __fastcall TMessageTimeout::TMessageTimeout(TComponent * AOwner, unsigned int Timeout, TButton * Button, unsigned int Answer) : TTimer(AOwner), FOrigTimeout(Timeout), FTimeout(Timeout), FButton(Button), FAnswer(Answer) { OnTimer = DoTimer; Interval = MSecsPerSec; FOrigCaption = FButton->Caption; FOrigCursorPos = Mouse->CursorPos; FApplicationEvents.reset(new TApplicationEvents(Application)); FApplicationEvents->OnMessage = ApplicationMessage; UpdateButton(); } //--------------------------------------------------------------------------- void __fastcall TMessageTimeout::ApplicationMessage(TMsg & Msg, bool & DebugUsedArg(Handled)) { if (Msg.message == WM_MOUSEMOVE) { MouseMove(); } else if ((Msg.message == WM_LBUTTONDOWN) || (Msg.message == WM_RBUTTONDOWN) || (Msg.message == WM_KEYDOWN) || (Msg.message == WM_SYSKEYDOWN)) { Cancel(); } } //--------------------------------------------------------------------------- void __fastcall TMessageTimeout::MouseMove() { TPoint CursorPos = Mouse->CursorPos; int Delta = std::max(std::abs(FOrigCursorPos.X - CursorPos.X), std::abs(FOrigCursorPos.Y - CursorPos.Y)); int Threshold = 8; if (DebugAlwaysTrue(FButton != NULL)) { Threshold = ScaleByTextHeight(FButton, Threshold); } if (Delta > Threshold) { FOrigCursorPos = CursorPos; const unsigned int SuspendTime = 30 * MSecsPerSec; FTimeout = std::max(FOrigTimeout, SuspendTime); UpdateButton(); } } //--------------------------------------------------------------------------- void __fastcall TMessageTimeout::Cancel() { Enabled = false; UpdateButton(); } //--------------------------------------------------------------------------- void __fastcall TMessageTimeout::UpdateButton() { DebugAssert(FButton != NULL); FButton->Caption = !Enabled ? FOrigCaption : FMTLOAD(TIMEOUT_BUTTON, (FOrigCaption, int(FTimeout / MSecsPerSec))); } //--------------------------------------------------------------------------- void __fastcall TMessageTimeout::DoTimer(TObject * /*Sender*/) { if (FTimeout <= Interval) { DebugAssert(FButton != NULL); // Needed particularly for "keep up to date" dialog, which does not close on the button click Enabled = false; TModalResult PrevModalResult = FButton->ModalResult; if (FAnswer != 0) { FButton->ModalResult = FAnswer; } try { FButton->Click(); } __finally { FButton->ModalResult = PrevModalResult; } } else { FTimeout -= Interval; UpdateButton(); } } //--------------------------------------------------------------------------- void InitiateDialogTimeout(TForm * Dialog, unsigned int Timeout, TButton * Button, unsigned int Answer) { TMessageTimeout * MessageTimeout = new TMessageTimeout(Application, Timeout, Button, Answer); MessageTimeout->Name = L"MessageTimeout"; Dialog->InsertComponent(MessageTimeout); } //--------------------------------------------------------------------- class TPublicControl : public TControl { friend void __fastcall MenuPopup(TObject * Sender, const TPoint & MousePos, bool & Handled); }; //--------------------------------------------------------------------------- // Merge with CreateMessageDialogEx TForm * __fastcall CreateMoreMessageDialogEx(const UnicodeString Message, TStrings * MoreMessages, TQueryType Type, unsigned int Answers, UnicodeString HelpKeyword, const TMessageParams * Params) { std::unique_ptr Dialog; UnicodeString AMessage = Message; TMessageTimer * Timer = NULL; if ((Params != NULL) && (Params->Timer > 0)) { Timer = new TMessageTimer(Application); Timer->Interval = Params->Timer; Timer->Event = Params->TimerEvent; if (Params->TimerAnswers > 0) { Answers = Params->TimerAnswers; } if (Params->TimerQueryType >= 0) { Type = Params->TimerQueryType; } if (!Params->TimerMessage.IsEmpty()) { AMessage = Params->TimerMessage; } Timer->Name = L"MessageTimer"; } TButton * TimeoutButton = NULL; Dialog.reset( CreateMessageDialogEx( AMessage, MoreMessages, Type, Answers, HelpKeyword, Params, TimeoutButton)); if (Timer != NULL) { Timer->Dialog = Dialog.get(); Dialog->InsertComponent(Timer); } if (Params != NULL) { if (Params->Timeout > 0) { InitiateDialogTimeout(Dialog.get(), Params->Timeout, TimeoutButton, Params->TimeoutResponse); } } return Dialog.release(); } //--------------------------------------------------------------------------- unsigned int __fastcall MoreMessageDialog(const UnicodeString Message, TStrings * MoreMessages, TQueryType Type, unsigned int Answers, UnicodeString HelpKeyword, const TMessageParams * Params) { AppLogFmt(L"Message dialog: %s", (Message)); std::unique_ptr Dialog(CreateMoreMessageDialogEx(Message, MoreMessages, Type, Answers, HelpKeyword, Params)); unsigned int Result = ExecuteMessageDialog(Dialog.get(), Answers, Params); AppLogFmt(L"Message dialog answer: %d", (Integer(Result))); return Result; } //--------------------------------------------------------------------------- unsigned int __fastcall MessageDialog(const UnicodeString Msg, TQueryType Type, unsigned int Answers, UnicodeString HelpKeyword, const TMessageParams * Params) { return MoreMessageDialog(Msg, NULL, Type, Answers, HelpKeyword, Params); } //--------------------------------------------------------------------------- unsigned int __fastcall SimpleErrorDialog(const UnicodeString Msg, const UnicodeString MoreMessages) { unsigned int Result; TStrings * More = NULL; try { if (!MoreMessages.IsEmpty()) { More = TextToStringList(MoreMessages); } Result = MoreMessageDialog(Msg, More, qtError, qaOK, HELP_NONE); } __finally { delete More; } return Result; } //--------------------------------------------------------------------------- static void FormatStackTrace(TStrings * StackTrace) { for (int Index = 0; Index < StackTrace->Count; Index++) { UnicodeString Frame = StackTrace->Strings[Index]; // get rid of declarations "flags" that are included in .map Frame = ReplaceStr(Frame, L"__fastcall ", L""); Frame = ReplaceStr(Frame, L"__linkproc__ ", L""); if (DebugAlwaysTrue(!Frame.IsEmpty() && (Frame[1] == L'('))) { int Start = Frame.Pos(L"["); int End = Frame.Pos(L"]"); if (DebugAlwaysTrue((Start > 1) && (End > Start) && (Frame[Start - 1] == L' '))) { // remove absolute address Frame.Delete(Start - 1, End - Start + 2); } } StackTrace->Strings[Index] = Frame; } } //--------------------------------------------------------------------------- static TStrings * __fastcall StackInfoListToStrings( TJclStackInfoList * StackInfoList) { std::unique_ptr StackTrace(new TStringList()); // Corresponds to our JclExceptionStacktraceOptions StackInfoList->AddToStrings(StackTrace.get(), true, false, true, true); FormatStackTrace(StackTrace.get()); return StackTrace.release(); } //--------------------------------------------------------------------------- static TStrings * GetExceptionStackTraceStrings(Exception * E) { std::unique_ptr StackTrace(TextToStringList(E->StackTrace)); FormatStackTrace(StackTrace.get()); return StackTrace.release(); } //--------------------------------------------------------------------------- UnicodeString GetExceptionDebugInfo(Exception * E) { UnicodeString Result; if (DebugAlwaysTrue(IsInternalException(E)) && DebugAlwaysTrue(E->StackInfo != NULL)) { std::unique_ptr StackTrace(GetExceptionStackTraceStrings(E)); for (int Index = 0; Index < StackTrace->Count; Index++) { UnicodeString Frame = StackTrace->Strings[Index]; // The last line might be empty if (!Frame.IsEmpty()) { int P = Frame.Pos(L")"); if (DebugAlwaysTrue(P > 0)) { UnicodeString Symbol = Frame.SubString(P + 1, Frame.Length() - P).Trim(); if ((Symbol != L"KERNELBASE.dll.RaiseException") && (Symbol != L"Jclhookexcept::JclAddExceptNotifier") && (Symbol != L"_ReThrowException") && (Symbol != L"____ExceptionHandler") && (Symbol != L"__ExceptionHandler") && (Symbol != L"___doGlobalUnwind") && (Symbol != L"_ThrowExceptionLDTC")) { AddToList(Result, Symbol, L";"); } } } } } return Result; } //--------------------------------------------------------------------------- bool AppendExceptionStackTrace(Exception * E, TStrings *& MoreMessages) { bool Result = false; if (IsInternalException(E) && DebugAlwaysTrue(E->StackInfo != NULL)) { std::unique_ptr StackTrace(GetExceptionStackTraceStrings(E)); std::unique_ptr OwnedMoreMessages; if (MoreMessages == NULL) { OwnedMoreMessages.reset(new TStringList()); MoreMessages = OwnedMoreMessages.get(); Result = true; } if (!MoreMessages->Text.IsEmpty()) { MoreMessages->Text = MoreMessages->Text + "\n"; } MoreMessages->Text = MoreMessages->Text + LoadStr(STACK_TRACE) + "\n"; MoreMessages->AddStrings(StackTrace.get()); OwnedMoreMessages.release(); } return Result; } //--------------------------------------------------------------------------- unsigned int __fastcall ExceptionMessageDialog(Exception * E, TQueryType Type, const UnicodeString MessageFormat, unsigned int Answers, UnicodeString HelpKeyword, const TMessageParams * Params) { TStrings * MoreMessages = NULL; ExtException * EE = dynamic_cast(E); if (EE != NULL) { MoreMessages = EE->MoreMessages; } UnicodeString Message; // this is always called from within ExceptionMessage check, // so it should never fail here DebugCheck(ExceptionMessageFormatted(E, Message)); if (!MessageFormat.IsEmpty()) { Message = FORMAT(MessageFormat, (UnformatMessage(Message))); } HelpKeyword = MergeHelpKeyword(HelpKeyword, GetExceptionHelpKeyword(E)); std::unique_ptr OwnedMoreMessages; if (AppendExceptionStackTrace(E, MoreMessages)) { OwnedMoreMessages.reset(MoreMessages); } return MoreMessageDialog( Message, MoreMessages, Type, Answers, HelpKeyword, Params); } //--------------------------------------------------------------------------- unsigned int __fastcall FatalExceptionMessageDialog( Exception * E, TQueryType Type, const UnicodeString & MessageFormat, unsigned int Answers, const UnicodeString & HelpKeyword, const TMessageParams * Params) { DebugAssert(FLAGCLEAR(Answers, qaRetry)); Answers |= qaRetry; TQueryButtonAlias Aliases[1]; Aliases[0].Button = qaRetry; Aliases[0].Alias = LoadStr(RECONNECT_BUTTON); TMessageParams AParams; if (Params != NULL) { AParams = *Params; } DebugAssert(AParams.Aliases == NULL); AParams.Aliases = Aliases; AParams.AliasesCount = LENOF(Aliases); return ExceptionMessageDialog(E, Type, MessageFormat, Answers, HelpKeyword, &AParams); } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- void * __fastcall BusyStart() { void * Token = reinterpret_cast(Screen->Cursor); Screen->Cursor = crHourGlass; return Token; } //--------------------------------------------------------------------------- void __fastcall BusyEnd(void * Token) { Screen->Cursor = static_cast(reinterpret_cast(Token)); } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- static DWORD MainThread = 0; static TDateTime LastGUIUpdate = 0; static double GUIUpdateIntervalFrac = static_cast(OneSecond/1000*GUIUpdateInterval); // 1/5 sec static bool NoGUI = false; //--------------------------------------------------------------------------- void __fastcall SetNoGUI() { NoGUI = true; } //--------------------------------------------------------------------------- bool __fastcall ProcessGUI(bool Force) { DebugAssert(MainThread != 0); bool Result = false; // Calling ProcessMessages in Azure WebJob causes access violation in VCL. // As we do not really need to call it in scripting/.NET, just skip it. if ((MainThread == GetCurrentThreadId()) && !NoGUI) { TDateTime N = Now(); if (Force || (double(N) - double(LastGUIUpdate) > GUIUpdateIntervalFrac)) { LastGUIUpdate = N; Application->ProcessMessages(); Result = true; } } return Result; } //--------------------------------------------------------------------------- const int cpiDefault = -1; const int cpiConfigure = -2; const int cpiCustom = -3; const int cpiSaveSettings = -4; const int cpiGenerateCode = -5; const int cpiSavePreset = -6; //--------------------------------------------------------------------------- void __fastcall CopyParamListPopup(TRect Rect, TPopupMenu * Menu, const TCopyParamType & Param, UnicodeString Preset, TNotifyEvent OnClick, int Options, int CopyParamAttrs, bool SaveSettings) { Menu->Items->Clear(); TMenuItem * Item; Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_CUSTOM); Item->Tag = cpiCustom; Item->Default = FLAGSET(Options, cplCustomizeDefault); Item->OnClick = OnClick; Menu->Items->Add(Item); TMenuItem * CustomizeItem = Item; if (FLAGSET(Options, cplSaveSettings)) { Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_SAVE_SETTINGS); Item->Tag = cpiSaveSettings; Item->Checked = SaveSettings; Item->OnClick = OnClick; Menu->Items->Add(Item); } Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_SAVE_PRESET); Item->Tag = cpiSavePreset; Item->OnClick = OnClick; Menu->Items->Add(Item); Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_PRESET_HEADER); Item->Visible = false; Item->Enabled = false; Menu->Items->Add(Item); bool AnyChecked = false; Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_DEFAULT); Item->Tag = cpiDefault; Item->Checked = Preset.IsEmpty() && (GUIConfiguration->CopyParamPreset[L""] == Param); AnyChecked = AnyChecked || Item->Checked; Item->OnClick = OnClick; Menu->Items->Add(Item); TCopyParamType DefaultParam; const TCopyParamList * CopyParamList = GUIConfiguration->CopyParamList; for (int i = 0; i < CopyParamList->Count; i++) { UnicodeString Name = CopyParamList->Names[i]; TCopyParamType AParam = GUIConfiguration->CopyParamPreset[Name]; if (AParam.AnyUsableCopyParam(CopyParamAttrs) || // This makes "Binary" preset visible, // as long as we care about transfer mode ((AParam == DefaultParam) && FLAGCLEAR(CopyParamAttrs, cpaIncludeMaskOnly) && FLAGCLEAR(CopyParamAttrs, cpaNoTransferMode))) { Item = new TMenuItem(Menu); Item->Caption = Name; Item->Tag = i; Item->Checked = (Preset == Name) && (AParam == Param); AnyChecked = AnyChecked || Item->Checked; Item->OnClick = OnClick; Menu->Items->Add(Item); } } CustomizeItem->Checked = !AnyChecked; Item = new TMenuItem(Menu); Item->Caption = L"-"; Menu->Items->Add(Item); Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_CONFIGURE); Item->Tag = cpiConfigure; Item->OnClick = OnClick; Menu->Items->Add(Item); if (FLAGSET(Options, cplGenerateCode)) { Item = new TMenuItem(Menu); Item->Caption = L"-"; Menu->Items->Add(Item); Item = new TMenuItem(Menu); Item->Caption = LoadStr(COPY_PARAM_GENERATE_CODE); Item->Tag = cpiGenerateCode; Item->OnClick = OnClick; Menu->Items->Add(Item); } MenuPopup(Menu, Rect, NULL); } //--------------------------------------------------------------------------- int __fastcall CopyParamListPopupClick(TObject * Sender, TCopyParamType & Param, UnicodeString & Preset, int CopyParamAttrs, bool * SaveSettings) { TComponent * Item = dynamic_cast(Sender); DebugAssert(Item != NULL); DebugAssert((Item->Tag >= cpiSavePreset) && (Item->Tag < GUIConfiguration->CopyParamList->Count)); int Result; if (Item->Tag == cpiConfigure) { bool MatchedPreset = (GUIConfiguration->CopyParamPreset[Preset] == Param); DoPreferencesDialog(pmPresets); Result = (MatchedPreset && GUIConfiguration->HasCopyParamPreset[Preset]) ? 1 : 0; if (Result > 0) { // For cast, see a comment below Param = TCopyParamType(GUIConfiguration->CopyParamPreset[Preset]); } } else if (Item->Tag == cpiCustom) { Result = DoCopyParamCustomDialog(Param, CopyParamAttrs) ? 1 : 0; } else if (Item->Tag == cpiSaveSettings) { if (DebugAlwaysTrue(SaveSettings != NULL)) { *SaveSettings = !*SaveSettings; } Result = 0; } else if (Item->Tag == cpiSavePreset) { std::unique_ptr CopyParamList(new TCopyParamList()); *CopyParamList = *GUIConfiguration->CopyParamList; int Index = -1; if (DoCopyParamPresetDialog(CopyParamList.get(), Index, cpmAdd, NULL, Param)) { GUIConfiguration->CopyParamList = CopyParamList.get(); // If saved unmodified, then make this the selected preset if (*CopyParamList->CopyParams[Index] == Param) { Preset = CopyParamList->Names[Index]; } } Result = 0; } else if (Item->Tag == cpiGenerateCode) { Result = -cplGenerateCode; } else { Preset = (Item->Tag >= 0) ? GUIConfiguration->CopyParamList->Names[Item->Tag] : UnicodeString(); // The cast strips away the "queue" properties of the TGUICopyParamType // that are not configurable in presets Param = TCopyParamType(GUIConfiguration->CopyParamPreset[Preset]); Result = 1; } return Result; } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- class TCustomCommandPromptsDialog : public TCustomDialog { public: __fastcall TCustomCommandPromptsDialog( const UnicodeString & CustomCommandName, const UnicodeString & HelpKeyword, const TUnicodeStringVector & Prompts, const TUnicodeStringVector & Defaults); bool __fastcall Execute(TUnicodeStringVector & Values); private: UnicodeString __fastcall HistoryKey(int Index); std::vector FEdits; TUnicodeStringVector FPrompts; UnicodeString FCustomCommandName; }; //--------------------------------------------------------------------------- __fastcall TCustomCommandPromptsDialog::TCustomCommandPromptsDialog( const UnicodeString & CustomCommandName, const UnicodeString & HelpKeyword, const TUnicodeStringVector & Prompts, const TUnicodeStringVector & Defaults) : TCustomDialog(HelpKeyword) { FCustomCommandName = CustomCommandName; Caption = FMTLOAD(CUSTOM_COMMANDS_PARAMS_TITLE, (FCustomCommandName)); FPrompts = Prompts; DebugAssert(FPrompts.size() == Defaults.size()); for (size_t Index = 0; Index < FPrompts.size(); Index++) { UnicodeString Prompt = FPrompts[Index]; if (Prompt.IsEmpty()) { Prompt = LoadStr(CUSTOM_COMMANDS_PARAM_PROMPT2); } THistoryComboBox * ComboBox = new THistoryComboBox(this); ComboBox->AutoComplete = false; AddComboBox(ComboBox, CreateLabel(Prompt)); ComboBox->Items = CustomWinConfiguration->History[HistoryKey(Index)]; ComboBox->Text = Defaults[Index]; FEdits.push_back(ComboBox); } } //--------------------------------------------------------------------------- UnicodeString __fastcall TCustomCommandPromptsDialog::HistoryKey(int Index) { UnicodeString Result = FPrompts[Index]; if (Result.IsEmpty()) { Result = IntToStr(Index); } Result = FORMAT(L"%s_%s", (FCustomCommandName, Result)); Result = CustomWinConfiguration->GetValidHistoryKey(Result); return L"CustomCommandParam_" + Result; } //--------------------------------------------------------------------------- bool __fastcall TCustomCommandPromptsDialog::Execute(TUnicodeStringVector & Values) { bool Result = TCustomDialog::Execute(); if (Result) { for (size_t Index = 0; Index < FEdits.size(); Index++) { Values.push_back(FEdits[Index]->Text); FEdits[Index]->SaveToHistory(); CustomWinConfiguration->History[HistoryKey(Index)] = FEdits[Index]->Items; } } return Result; } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- TWinInteractiveCustomCommand::TWinInteractiveCustomCommand( TCustomCommand * ChildCustomCommand, const UnicodeString CustomCommandName, const UnicodeString HelpKeyword) : TInteractiveCustomCommand(ChildCustomCommand) { FCustomCommandName = StripEllipsis(StripHotkey(CustomCommandName)); FHelpKeyword = HelpKeyword; } //--------------------------------------------------------------------------- void __fastcall TWinInteractiveCustomCommand::PatternHint(int Index, const UnicodeString & Pattern) { if (IsPromptPattern(Pattern)) { UnicodeString Prompt; UnicodeString Default; bool Delimit = false; ParsePromptPattern(Pattern, Prompt, Default, Delimit); FIndexes.insert(std::make_pair(Index, FPrompts.size())); FPrompts.push_back(Prompt); FDefaults.push_back(Default); } } //--------------------------------------------------------------------------- void __fastcall TWinInteractiveCustomCommand::Prompt( int Index, const UnicodeString & /*Prompt*/, UnicodeString & Value) { if (DebugAlwaysTrue(FIndexes.find(Index) != FIndexes.end())) { size_t PromptIndex = FIndexes[Index]; if (FValues.empty()) { UnicodeString HelpKeyword = FHelpKeyword; if (HelpKeyword.IsEmpty()) { HelpKeyword = HELP_CUSTOM_COMMAND_PARAM; } std::unique_ptr Dialog( new TCustomCommandPromptsDialog(FCustomCommandName, HelpKeyword, FPrompts, FDefaults)); if (!Dialog->Execute(FValues)) { Abort(); } } if (DebugAlwaysTrue(FValues.size() == FPrompts.size()) && DebugAlwaysTrue(PromptIndex < FValues.size())) { Value = FValues[PromptIndex]; } } } //--------------------------------------------------------------------------- void __fastcall TWinInteractiveCustomCommand::Execute( const UnicodeString & Command, UnicodeString & Value) { DWORD DummyExitCode; ExecuteProcessAndReadOutput(Command, Value, DummyExitCode, false); // trim trailing cr/lf Value = TrimRight(Value); } //--------------------------------------------------------------------------- void __fastcall MenuPopup(TPopupMenu * Menu, TButton * Button) { MenuPopup(Menu, CalculatePopupRect(Button), Button); } //--------------------------------------------------------------------------- void __fastcall MenuPopup(TObject * Sender, const TPoint & MousePos, bool & Handled) { TControl * Control = dynamic_cast(Sender); DebugAssert(Control != NULL); TPoint Point; if ((MousePos.x == -1) && (MousePos.y == -1)) { Point = Control->ClientToScreen(TPoint(0, 0)); } else { Point = Control->ClientToScreen(MousePos); } TPopupMenu * PopupMenu = (reinterpret_cast(Control))->PopupMenu; DebugAssert(PopupMenu != NULL); TRect Rect(Point, Point); MenuPopup(PopupMenu, Rect, Control); Handled = true; } //--------------------------------------------------------------------------- TComponent * __fastcall GetPopupComponent(TObject * Sender) { TComponent * Item = dynamic_cast(Sender); DebugAssert(Item != NULL); TPopupMenu * PopupMenu = dynamic_cast(Item->Owner); DebugAssert(PopupMenu != NULL); DebugAssert(PopupMenu->PopupComponent != NULL); return PopupMenu->PopupComponent; } //--------------------------------------------------------------------------- static void __fastcall SetMenuButtonImages(TButton * Button) { Button->Images = GetButtonImages(Button); } //--------------------------------------------------------------------------- static void __fastcall MenuButtonRescale(TComponent * Sender, TObject * /*Token*/) { TButton * Button = DebugNotNull(dynamic_cast(Sender)); SetMenuButtonImages(Button); } //--------------------------------------------------------------------------- void __fastcall MenuButton(TButton * Button) { SetMenuButtonImages(Button); // buttons are dark only when system theme is dark Button->ImageIndex = (GetSysDarkTheme() && UseDarkModeForControl(Button)) ? 2 : 0; Button->DisabledImageIndex = 1; Button->ImageAlignment = iaRight; SetRescaleFunction(Button, MenuButtonRescale); } //--------------------------------------------------------------------------- TRect __fastcall CalculatePopupRect(TButton * Button) { TPoint UpPoint = Button->ClientToScreen(TPoint(0, 0)); TPoint DownPoint = Button->ClientToScreen(TPoint(Button->Width, Button->Height)); TRect Rect(UpPoint, DownPoint); // With themes enabled, button are rendered 1 pixel smaller than their actual size int Offset = UseThemes() ? -1 : 0; Rect.Inflate(Offset, Offset); return Rect; } //--------------------------------------------------------------------------- TRect __fastcall CalculatePopupRect(TControl * Control, TPoint MousePos) { MousePos = Control->ClientToScreen(MousePos); TRect Rect(MousePos, MousePos); return Rect; } //--------------------------------------------------------------------------- void __fastcall FixButtonImage(TButton * Button) { // with themes enabled, button image is by default drawn too high if (UseThemes()) { Button->ImageMargins->Top = 1; } } //--------------------------------------------------------------------------- void __fastcall CenterButtonImage(TButton * Button) { // with themes disabled, the text seems to be drawn over the icon, // so that the padding spaces hide away most of the icon if (UseThemes()) { Button->ImageAlignment = iaCenter; int ImageWidth = Button->Images->Width; std::unique_ptr Canvas(CreateControlCanvas(Button)); UnicodeString Caption; // Centering unlinks the caption from the action TAction * Action = dynamic_cast(Button->Action); if (Action != NULL) { Caption = Action->Caption; } else { Caption = Button->Caption.Trim(); } UnicodeString Padding; while (Canvas->TextWidth(Padding) < ImageWidth) { Padding += L" "; } if (Button->IsRightToLeft()) { Caption = Caption + Padding; } else { Caption = Padding + Caption; } Button->Caption = Caption; int CaptionWidth = Canvas->TextWidth(Caption); // The margins seem to extend the area over which the image is centered, // so we have to set it to a double of desired padding. // The original formula is - 2 * ((CaptionWidth / 2) - (ImageWidth / 2) + ScaleByTextHeight(Button, 2)) // the one below is equivalent, but with reduced rounding. // Without the change, the rounding caused the space between icon and caption too // small on 200% zoom. // Note that (CaptionWidth / 2) - (ImageWidth / 2) // is approximately same as half of caption width before padding. Button->ImageMargins->Left = -(CaptionWidth - ImageWidth + ScaleByTextHeight(Button, 4)); } else { // at least do not draw it so near to the edge Button->ImageMargins->Left = 1; } } //--------------------------------------------------------------------------- int __fastcall AdjustLocaleFlag(const UnicodeString & S, TLocaleFlagOverride LocaleFlagOverride, bool Recommended, int On, int Off) { int Result = !S.IsEmpty() && StrToInt(S); switch (LocaleFlagOverride) { default: case lfoLanguageIfRecommended: if (!Recommended) { Result = Off; } break; case lfoLanguage: // noop = as configured in locale break; case lfoAlways: Result = On; break; case lfoNever: Result = Off; break; } return Result; } //--------------------------------------------------------------------------- void __fastcall SetGlobalMinimizeHandler(TCustomForm * /*Form*/, TNotifyEvent OnMinimize) { if (GlobalOnMinimize == NULL) { GlobalOnMinimize = OnMinimize; } } //--------------------------------------------------------------------------- void __fastcall ClearGlobalMinimizeHandler(TNotifyEvent OnMinimize) { if (GlobalOnMinimize == OnMinimize) { GlobalOnMinimize = NULL; } } //--------------------------------------------------------------------------- void __fastcall CallGlobalMinimizeHandler(TObject * Sender) { Configuration->Usage->Inc(L"OperationMinimizations"); if (DebugAlwaysTrue(GlobalOnMinimize != NULL)) { GlobalOnMinimize(Sender); } } //--------------------------------------------------------------------------- static bool MinimizedToTray = false; //--------------------------------------------------------------------------- static void __fastcall DoApplicationMinimizeRestore(bool Minimize) { TForm * MainForm = Application->MainForm; TForm * MainLikeForm = GetMainForm(); bool MinimizeToTray; if (Minimize) { MinimizeToTray = WinConfiguration->MinimizeToTray; } else { // Use tray restore code, even if minimization to tray is not on anymore when restoring. // This is particularly used for ad-hoc minimize to tray from "keep up to date" dialog. MinimizeToTray = MinimizedToTray; } MinimizedToTray = false; // reset in any case, even if we somehow got restored from tray without invoking this code if ((MainLikeForm != MainForm) && !MinimizeToTray) { static TWindowState PreviousWindowState = wsNormal; if (Minimize) { PreviousWindowState = MainLikeForm->WindowState; // This works correctly with child windows thanks to Application->OnGetMainFormHandle MainLikeForm->WindowState = wsMinimized; } else { MainLikeForm->WindowState = PreviousWindowState; } } else { // What is described below should not ever happen, except when minimizing to tray, // as we capture command-line operation above. // Had we called TApplication::Minimize, it would hide all non-MainForm windows, including MainLineForm, // so it actually also hides taskbar button, what we do not want. // WORKAROUND // When main window is hidden (command-line operation), // we do not want it to be shown by TApplication.Restore, // so we temporarily detach it from an application. // Probably not really necessary for minimizing phase, // but we do it for consistency anyway. bool RestoreMainForm = false; if (DebugAlwaysTrue(MainForm != NULL) && !MainForm->Visible) { SetAppMainForm(NULL); RestoreMainForm = true; } try { if (Minimize) { // WORKAROUND: // VCL enables minimized windows (why?) and restores the previous disabled state on restore. // But if we meanwhile re-enable the window (like when transfer finishes while minimized), // the VCL will re-disable the window on restore. // (This does not help in scenario, then the main window is minimized with its own title's minimize window, // but then it should not be disabled in the first place) bool WasDisabled = !MainForm->Enabled; if (WasDisabled) { MainForm->Enabled = true; } try { Application->Minimize(); } __finally { if (WasDisabled) { MainForm->Enabled = false; } } MinimizedToTray = WinConfiguration->MinimizeToTray; } else { Application->Restore(); } } __finally { if (RestoreMainForm) { SetAppMainForm(MainForm); } } } } //--------------------------------------------------------------------------- void __fastcall ApplicationMinimize() { DoApplicationMinimizeRestore(true); } //--------------------------------------------------------------------------- void __fastcall ApplicationRestore() { DoApplicationMinimizeRestore(false); } //--------------------------------------------------------------------------- bool __fastcall IsApplicationMinimized() { // VCL help recommends handling Application->OnMinimize/OnRestore // for tracking state, but OnRestore is actually not called // (OnMinimize is), when app is minimized from e.g. Progress window bool AppMinimized = IsIconic(Application->Handle); bool MainFormMinimized = IsIconic(Application->MainFormHandle); return AppMinimized || MainFormMinimized; } //--------------------------------------------------------------------------- bool __fastcall HandleMinimizeSysCommand(TMessage & Message) { TWMSysCommand & SysCommand = reinterpret_cast(Message); unsigned int Cmd = (SysCommand.CmdType & 0xFFF0); bool Result = (Cmd == SC_MINIMIZE); if (Result) { ApplicationMinimize(); SysCommand.Result = 1; } return Result; } //--------------------------------------------------------------------------- void __fastcall ClickToolbarItem(TTBCustomItem * Item, bool PositionCursor) { TTBCustomItem * TopItem = Item; while (TopItem->Parent != NULL) { TopItem = TopItem->Parent; } TTBCustomToolbar * Toolbar = dynamic_cast(TopItem->ParentComponent); DebugAssert(Toolbar != NULL); TTBItemViewer * Viewer = Toolbar->View->Find(Item); DebugAssert(Viewer != NULL); int X = Viewer->BoundsRect.Left + (Viewer->BoundsRect.Width() / 2); int Y = Viewer->BoundsRect.Top + (Viewer->BoundsRect.Height() / 2); if (PositionCursor) { Mouse->CursorPos = Toolbar->ClientToScreen(TPoint(X, Y)); } PostMessage(Toolbar->Handle, WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(X, Y)); } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- UnicodeString DumpCallstackEventName(int ProcessId) { return FORMAT(DUMPCALLSTACK_EVENT, (ProcessId)); } //--------------------------------------------------------------------------- UnicodeString DumpCallstackFileName(int ProcessId) { UnicodeString FileName = FORMAT(L"%s.txt", (DumpCallstackEventName(ProcessId))); UnicodeString Result = CombinePaths(SystemTemporaryDirectory(), FileName); return Result; } //--------------------------------------------------------------------------- void CheckConfigurationForceSave() { if (UseAlternativeFunction() && Configuration->Persistent && (Configuration->Storage == stIniFile) && Sysutils::FileExists(ApiPath(Configuration->IniFileStorageName)) && !Configuration->ForceSave) { int Attr = GetFileAttributes(ApiPath(Configuration->IniFileStorageName).c_str()); if (FLAGSET(Attr, FILE_ATTRIBUTE_READONLY)) { UnicodeString Message = FMTLOAD(READONLY_INI_FILE_OVERWRITE, (Configuration->IniFileStorageName)); if (MessageDialog(Message, qtConfirmation, qaOK | qaCancel, HELP_READONLY_INI_FILE) == qaOK) { Configuration->ForceSave = true; } } } } //--------------------------------------------------------------------------- class TCallstackThread : public TSignalThread { public: __fastcall TCallstackThread(); protected: virtual void __fastcall ProcessEvent(); private: static HANDLE DoCreateEvent(); }; //--------------------------------------------------------------------------- __fastcall TCallstackThread::TCallstackThread() : TSignalThread(true, DoCreateEvent()) { } //--------------------------------------------------------------------------- void __fastcall TCallstackThread::ProcessEvent() { try { UnicodeString Path = DumpCallstackFileName(GetCurrentProcessId()); std::unique_ptr StackStrings; HANDLE MainThreadHandle = OpenThread(THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION, false, MainThreadID); if (MainThreadHandle == NULL) { RaiseLastOSError(); } DWORD SuspendError = static_cast(-1); if (SuspendThread(MainThreadHandle) == SuspendError) { RaiseLastOSError(); } try { TJclStackInfoList * StackInfoList = JclCreateThreadStackTraceFromID(true, MainThreadID); if (StackInfoList == NULL) { RaiseLastOSError(); } StackStrings.reset(StackInfoListToStrings(StackInfoList)); } __finally { if (ResumeThread(MainThreadHandle) == SuspendError) { RaiseLastOSError(); } CloseHandle(MainThreadHandle); } TFile::WriteAllText(Path, StackStrings->Text); } catch (...) { } } //--------------------------------------------------------------------------- HANDLE TCallstackThread::DoCreateEvent() { UnicodeString Name = DumpCallstackEventName(GetCurrentProcessId()); return CreateEvent(NULL, false, false, Name.c_str()); } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- static std::unique_ptr CallstackThread; //--------------------------------------------------------------------------- static void __fastcall AppGetMainFormHandle(void * /*Data*/, HWND & Handle) { TForm * MainForm = GetMainForm(); // This, among other, causes minimizing of the top-level non-MainForm minimize other child windows. // Like clicking "Minimize" on Progress window over Synchronization progress window over Synchronization checklist window. // Would also have a lot of other effects (hopefully positive) and may render lot of existing MainFormLike code obsolete. if ((MainForm != NULL) && IsMainFormLike(MainForm) && MainForm->HandleAllocated()) { Handle = MainForm->Handle; } } //--------------------------------------------------------------------------- void __fastcall WinInitialize() { // Not sure if we need to call JclHookExceptions at all, stack trace tracking seems to work without it. // Note though that with Clang, this does not work for exceptions explicitly raised from C++ code. // Not a big deal for us, as we are primarily looking for system exceptions and internal exceptions raised from Pascal VCL code. if (JclHookExceptions()) { JclStackTrackingOptions << stAllModules; // Neeeded with Clang JclStackTrackingOptions << stRawMode; // See also StackInfoListToStrings JclExceptionStacktraceOptions >> estoIncludeAdressOffset; CallstackThread.reset(new TCallstackThread()); CallstackThread->Start(); } SetErrorMode(SEM_FAILCRITICALERRORS); OnApiPath = ApiPath; MainThread = GetCurrentThreadId(); Application->OnGetMainFormHandle = MakeMethod(NULL, AppGetMainFormHandle); } //--------------------------------------------------------------------------- void __fastcall WinFinalize() { CallstackThread.reset(NULL); } //--------------------------------------------------------------------------- __fastcall ::TTrayIcon::TTrayIcon(unsigned int Id) { FVisible = false; FOnClick = NULL; FOnBalloonClick = NULL; FBalloonUserData = NULL; FTrayIcon = new NOTIFYICONDATA; memset(FTrayIcon, 0, sizeof(*FTrayIcon)); FTrayIcon->cbSize = sizeof(*FTrayIcon); FTrayIcon->uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP; // LoadIconMetric is available from Windows Vista only HMODULE ComCtl32Dll = GetModuleHandle(comctl32); if (DebugAlwaysTrue(ComCtl32Dll)) { typedef HRESULT WINAPI (* TLoadIconMetric)(HINSTANCE hinst, PCWSTR pszName, int lims, __out HICON *phico); TLoadIconMetric LoadIconMetric = (TLoadIconMetric)GetProcAddress(ComCtl32Dll, "LoadIconMetric"); if (LoadIconMetric != NULL) { // Prefer not to use Application->Icon->Handle as that shows 32x32 scaled down to 16x16 for some reason LoadIconMetric(MainInstance, L"MAINICON", LIM_SMALL, &FTrayIcon->hIcon); } } if (FTrayIcon->hIcon == 0) { FTrayIcon->hIcon = Application->Icon->Handle; } FTrayIcon->uID = Id; FTrayIcon->hWnd = AllocateHWnd(WndProc); FTrayIcon->uCallbackMessage = WM_TRAY_ICON; FTaskbarCreatedMsg = RegisterWindowMessage(L"TaskbarCreated"); } //--------------------------------------------------------------------------- __fastcall ::TTrayIcon::~TTrayIcon() { // make sure we hide icon even in case it was shown just to pop up the balloon // (in which case Visible == false) CancelBalloon(); Visible = false; DeallocateHWnd(FTrayIcon->hWnd); delete FTrayIcon; } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::PopupBalloon(UnicodeString Title, const UnicodeString & Str, TQueryType QueryType, unsigned int Timeout, TNotifyEvent OnBalloonClick, TObject * BalloonUserData) { if (Timeout > 30000) { // this is probably system limit, do not try more, especially for // the timeout-driven hiding of the tray icon (for Win2k) Timeout = 30000; } FTrayIcon->uFlags |= NIF_INFO; AppLogFmt("Tray popup balloon: %s - %s", (Title, Str)); Title = Title + TitleSeparator + AppNameString(); StrPLCopy(FTrayIcon->szInfoTitle, Title, LENOF(FTrayIcon->szInfoTitle) - 1); UnicodeString Info = Str; // When szInfo is empty, balloon is not shown // (or actually it means the balloon should be deleted, if any) if (Info.IsEmpty()) { Info = L" "; } StrPLCopy(FTrayIcon->szInfo, Info, LENOF(FTrayIcon->szInfo) - 1); FTrayIcon->uTimeout = Timeout; switch (QueryType) { case qtError: FTrayIcon->dwInfoFlags = NIIF_ERROR; break; case qtInformation: case qtConfirmation: FTrayIcon->dwInfoFlags = NIIF_INFO; break; case qtWarning: default: FTrayIcon->dwInfoFlags = NIIF_WARNING; break; } KillTimer(FTrayIcon->hWnd, 1); if (Visible) { Update(); } else { Notify(NIM_ADD); } FOnBalloonClick = OnBalloonClick; delete FBalloonUserData; FBalloonUserData = BalloonUserData; // Clearing the flag ensures that subsequent updates does not hide the baloon // unless CancelBalloon is called explicitly FTrayIcon->uFlags = FTrayIcon->uFlags & ~NIF_INFO; } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::BalloonCancelled() { FOnBalloonClick = NULL; delete FBalloonUserData; FBalloonUserData = NULL; } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::CancelBalloon() { KillTimer(FTrayIcon->hWnd, 1); if (Visible) { FTrayIcon->uFlags |= NIF_INFO; FTrayIcon->szInfo[0] = L'\0'; Update(); FTrayIcon->uFlags = FTrayIcon->uFlags & ~NIF_INFO; } else { Notify(NIM_DELETE); } BalloonCancelled(); } //--------------------------------------------------------------------------- bool __fastcall ::TTrayIcon::Notify(unsigned int Message) { bool Result = SUCCEEDED(Shell_NotifyIcon(Message, (NOTIFYICONDATA*)FTrayIcon)); if (Result && (Message == NIM_ADD)) { UINT Timeout = FTrayIcon->uTimeout; try { FTrayIcon->uVersion = NOTIFYICON_VERSION; Result = SUCCEEDED(Shell_NotifyIcon(NIM_SETVERSION, (NOTIFYICONDATA*)FTrayIcon)); } __finally { FTrayIcon->uTimeout = Timeout; } } return Result; } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::Update() { if (Visible) { Notify(NIM_MODIFY); } } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::SetVisible(bool value) { if (Visible != value) { if (value) { FVisible = Notify(NIM_ADD); } else { FVisible = false; KillTimer(FTrayIcon->hWnd, 1); Notify(NIM_DELETE); BalloonCancelled(); } } } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::WndProc(TMessage & Message) { try { if (Message.Msg == WM_TRAY_ICON) { DebugAssert(Message.WParam == 0); switch (Message.LParam) { // old shell32 case WM_LBUTTONUP: case WM_RBUTTONUP: // new shell32: case WM_CONTEXTMENU: if (OnClick != NULL) { OnClick(NULL); } Message.Result = true; break; } if (Message.LParam == NIN_BALLOONUSERCLICK) { if (FOnBalloonClick != NULL) { // prevent the user data from being freed by possible call // to CancelBalloon or PopupBalloon during call to OnBalloonClick std::unique_ptr UserData(FBalloonUserData); FBalloonUserData = NULL; FOnBalloonClick(UserData.get()); } else if (OnClick != NULL) { OnClick(NULL); } } switch (Message.LParam) { case NIN_BALLOONHIDE: case NIN_BALLOONTIMEOUT: case NIN_BALLOONUSERCLICK: KillTimer(FTrayIcon->hWnd, 1); // if icon was shown just to display balloon, hide it with the balloon if (!Visible) { Notify(NIM_DELETE); } BalloonCancelled(); break; } } else if (Message.Msg == WM_TIMER) { // sanity check Notify(NIM_DELETE); BalloonCancelled(); } else if (Message.Msg == FTaskbarCreatedMsg) { if (Visible) { // force recreation Visible = false; Visible = true; } } else { Message.Result = DefWindowProc(FTrayIcon->hWnd, Message.Msg, Message.WParam, Message.LParam); } } catch(Exception & E) { Application->HandleException(&E); } } //--------------------------------------------------------------------------- UnicodeString __fastcall ::TTrayIcon::GetHint() { return FTrayIcon->szTip; } //--------------------------------------------------------------------------- void __fastcall ::TTrayIcon::SetHint(UnicodeString value) { if (Hint != value) { unsigned int Max = LENOF(FTrayIcon->szTip); StrPLCopy(FTrayIcon->szTip, value, Max - 1); Update(); } } //---------------------------------------------------------------------------