//
/// When the gadget window receives a WM_COMMAND message, it is likely from a gadget
/// or control within a TControlGadget. This reroutes it to the command target.
//
TResult
TGadgetWindow::EvCommand(uint id, HWND hWndCtl, uint notifyCode)
{
TRACEX(OwlCmd, 1, "TGadgetWindow::EvCommand - id(" << id << "), ctl(" <<\
hex << uint(hWndCtl) << "), code(" << notifyCode << ")");
// First allow any derived class that wants to handle the command
// NOTE: This search only caters for menu-style WM_COMMANDs (not those
// sent by controls)
//
TEventInfo eventInfo(0, id);
if (Find(eventInfo)) {
Dispatch(eventInfo, id);
return 0;
}
#if 0
// Prior versions of TGadgetWindow relied on TWindow's EvCommand for
// dispatching WM_COMMAND events. This required that one derives from
// a decoration class (eg. TControlbar, TToolbox) to handle control
// notifications. The current version uses a more generalized logic
// involving the CommandTarget and a frame ancestor class. This allows
// a client window to handle notifications of a control in a toolbar
// without using a TControlbar-derived class.
// However, if you need to previous behaviour, simply invoke TWindow's
// EvCommand from this handler.
return TWindow::EvCommand(id, hWndCtl, notifyCode);
#endif
TWindow* target;
TFrameWindow* frame;
// Find the frame who is our latest ancestor and make it our command target
//
for (target = GetParentO(); target; target = target->GetParentO()) {
frame = TYPESAFE_DOWNCAST(target, TFrameWindow);
if (frame || !target->GetParentO())
break;
}
// Make sure the frame doesn't think we are its command target, or a BAD
// loop will happen
//
if (target && (!frame || frame->GetCommandTarget() != GetHandle())) {
CHECK(target->IsWindow());
return target->EvCommand(id, hWndCtl, notifyCode);
}
// If all command routing fails, go back to basic dispatching of TWindow
//
return TWindow::EvCommand(id, hWndCtl, notifyCode);
}
//
/// Sets the text of the gadget. If the given text is blank, then we attempt to
/// load the text from the menu or tooltip.
//
void
TButtonTextGadget::SetText(const tstring& text, bool repaint)
{
if (text == Text) return;
Text = text;
if (Text.length() == 0 && (Style & sText) && GetGadgetWindow())
{
TWindow* parent = GetGadgetWindow()->GetParentO();
TDecoratedFrame* frame= parent ? dynamic_cast<TDecoratedFrame*>(parent) : 0;
while (parent && !frame){
parent = parent->GetParentO();
if (parent)
frame = dynamic_cast<TDecoratedFrame*>(parent);
}
CHECK(frame);
Text = frame->GetHintText(GetResId().GetInt(), htTooltip);
}
if (GetGadgetWindow() && repaint)
{
GetGadgetWindow()->GadgetChangedSize(*this);
Invalidate();
}
}
void
TGadgetWindow::EnableTooltip(bool enable)
{
if (!Tooltip) {
// Find a parent for the tooltip: It's attractive to make the
// gadgetwindow the owner of the tooltip, a popup window. However, this
// will typically fail since the gadget window is invariably a child
// window. Windows seems to accomodate this situation by simply making
// the tooltip's owner the gadgetwindow's owner. This works fine until
// the owner of the gadgetwindow is destroyed before the gadgetwindow
// is destroyed, such as in the case of a gadgetwindow initally created
// as a floating docking toolbar; When it's docked, the floating slip,
// it's original owner, is destroyed and the gadget window is reparented
// to an edge slip. In this scenario, the tooltip is silently destroyed
// along with the floating slip [it's real owner!] and the docked
// gadgetwindow no longer provide tool tips!
//
// To circumvent this scenario, we'll look for a window which is fairly
// stable/rooted as owner of the tooltip. Ideally, we'll get the
// application's main window.
//
TWindow* tipParent = this;
while (tipParent->GetParentO()) {
tipParent = tipParent->GetParentO();
if (tipParent->IsFlagSet(wfMainWindow))
break;
}
// Create and initialize tooltip
//
SetTooltip(new TTooltip(tipParent));
}
else {
if (Tooltip->GetHandle())
Tooltip->Activate(enable);
}
}