Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / WinForms / Managed / System / WinForms / ToolTip.cs / 4 / ToolTip.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
namespace System.Windows.Forms {
using System.Runtime.Serialization.Formatters;
using System.Threading;
using System.Runtime.Remoting;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using Hashtable = System.Collections.Hashtable;
using System.Drawing;
using Microsoft.Win32;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Drawing.Design;
using System.Globalization;
///
///
/// Provides a small pop-up window containing a line of text
/// that describes the purpose of a tool or control (usually represented as a
/// graphical
/// object) in a program.
///
///
[
ProvideProperty("ToolTip", typeof(Control)),
DefaultEvent("Popup"),
ToolboxItemFilter("System.Windows.Forms"),
SRDescription(SR.DescriptionToolTip)
]
public class ToolTip : Component, IExtenderProvider {
const int DEFAULT_DELAY = 500;
const int RESHOW_RATIO = 5;
const int AUTOPOP_RATIO = 10;
const int XBALLOONOFFSET = 10;
const int YBALLOONOFFSET = 8;
Hashtable tools = new Hashtable();
int[] delayTimes = new int[4];
bool auto = true;
bool showAlways = false;
ToolTipNativeWindow window = null;
Control topLevelControl = null;
bool active = true;
bool ownerDraw = false;
object userData;
Color backColor = SystemColors.Info;
Color foreColor = SystemColors.InfoText;
bool isBalloon;
bool isDisposing;
string toolTipTitle = string.Empty;
ToolTipIcon toolTipIcon = (ToolTipIcon)0;
ToolTipTimer timer;
Hashtable owners = new Hashtable();
bool stripAmpersands = false;
bool useAnimation = true;
bool useFading = true;
int originalPopupDelay = 0;
// setting TTM_TRACKPOSITION will cause redundant POP and Draw Messages..
// Hence we gaurd against this by having this private Flag..
bool trackPosition = false;
PopupEventHandler onPopup;
DrawToolTipEventHandler onDraw;
// Adding a tool twice breaks the ToolTip, so we need to track which
// tools are created to prevent this...
//
Hashtable created = new Hashtable();
private bool cancelled = false;
///
///
/// Initializes a new instance of the
///
public ToolTip(IContainer cont) : this() {
cont.Add(this);
}
///
///
/// Initializes a new instance of the
///
public ToolTip() {
window = new ToolTipNativeWindow(this);
auto = true;
delayTimes[NativeMethods.TTDT_AUTOMATIC] = DEFAULT_DELAY;
AdjustBaseFromAuto();
}
///
///
/// Gets or sets a value indicating whether the
///
[
SRDescription(SR.ToolTipActiveDescr),
DefaultValue(true)
]
public bool Active {
get {
return active;
}
set {
if (active != value) {
active = value;
//lets not actually activate the tooltip if we're in the designer (just set the value)
if (!DesignMode && GetHandleCreated()) {
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_ACTIVATE, (value==true)? 1: 0, 0);
}
}
}
}
///
///
/// Gets or sets
/// the time (in milliseconds) that passes before the
///
[
RefreshProperties(RefreshProperties.All),
SRDescription(SR.ToolTipAutomaticDelayDescr),
DefaultValue(DEFAULT_DELAY)
]
public int AutomaticDelay {
get {
return delayTimes[NativeMethods.TTDT_AUTOMATIC];
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("AutomaticDelay", SR.GetString(SR.InvalidLowBoundArgumentEx, "AutomaticDelay", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
SetDelayTime(NativeMethods.TTDT_AUTOMATIC, value);
}
}
///
///
/// Gets or sets the initial delay for the
///
[
RefreshProperties(RefreshProperties.All),
SRDescription(SR.ToolTipAutoPopDelayDescr)
]
public int AutoPopDelay {
get {
return delayTimes[NativeMethods.TTDT_AUTOPOP];
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("AutoPopDelay", SR.GetString(SR.InvalidLowBoundArgumentEx, "AutoPopDelay", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
SetDelayTime(NativeMethods.TTDT_AUTOPOP, value);
}
}
///
///
/// Gets or sets the BackColor for the
///
[
SRDescription(SR.ToolTipBackColorDescr),
DefaultValue(typeof(Color),"Info")
]
public Color BackColor {
get {
return backColor;
}
set {
backColor = value;
if (GetHandleCreated()) {
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_SETTIPBKCOLOR, ColorTranslator.ToWin32(backColor), 0);
}
}
}
///
/// The createParams to create the window.
///
///
///
/// Gets or sets the ForeColor for the
///
[
SRDescription(SR.ToolTipForeColorDescr),
DefaultValue(typeof(Color),"InfoText")
]
public Color ForeColor {
get {
return foreColor;
}
set {
if (value.IsEmpty) {
throw new ArgumentException(SR.GetString(SR.ToolTipEmptyColor, "ForeColor"));
}
foreColor = value;
if (GetHandleCreated()) {
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_SETTIPTEXTCOLOR, ColorTranslator.ToWin32(foreColor), 0);
}
}
}
internal IntPtr Handle {
get {
if (!GetHandleCreated()) {
CreateHandle();
}
return window.Handle;
}
}
///
/// SECREVIEW: Pattern to check if the caller has a permission without bubbling up a security exception
///
private bool HasAllWindowsPermission {
get {
try {
IntSecurity.AllWindows.Demand();
return true;
}
catch (SecurityException) {
}
return false;
}
}
///
///
/// Gets or sets the IsBalloon for the
///
[
SRDescription(SR.ToolTipIsBalloonDescr),
DefaultValue(false)
]
public bool IsBalloon {
get {
return isBalloon;
}
set {
if (isBalloon != value) {
isBalloon = value;
if (GetHandleCreated()) {
RecreateHandle();
}
}
}
}
// refer VsWhidbey 498263: ToolTips should be shown only on active Windows.
private bool IsWindowActive(IWin32Window window)
{
Control windowControl = window as Control;
// We want to enter in the IF block only if ShowParams does not return SW_SHOWNOACTIVATE.
// for ToolStripDropDown ShowParams returns SW_SHOWNOACTIVATE, in which case we DONT want to check IsWindowActive and hence return true.
if ((windowControl.ShowParams & 0xF) != NativeMethods.SW_SHOWNOACTIVATE)
{
IntPtr hWnd = UnsafeNativeMethods.GetActiveWindow();
IntPtr rootHwnd =UnsafeNativeMethods.GetAncestor(new HandleRef(window, window.Handle), NativeMethods.GA_ROOT);
if (hWnd != rootHwnd)
{
TipInfo tt = (TipInfo)tools[windowControl];
if (tt != null && (tt.TipType & TipInfo.Type.SemiAbsolute) != 0)
{
tools.Remove(windowControl);
DestroyRegion(windowControl);
}
return false;
}
}
return true;
}
///
///
/// Gets or sets the initial delay for
/// the
///
[
RefreshProperties(RefreshProperties.All),
SRDescription(SR.ToolTipInitialDelayDescr)
]
public int InitialDelay {
get {
return delayTimes[NativeMethods.TTDT_INITIAL];
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("InitialDelay", SR.GetString(SR.InvalidLowBoundArgumentEx, "InitialDelay", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
SetDelayTime(NativeMethods.TTDT_INITIAL, value);
}
}
///
/// Indicates whether the ToolTip will be drawn by the system or the user.
///
[
SRCategory(SR.CatBehavior),
DefaultValue(false),
SRDescription(SR.ToolTipOwnerDrawDescr)
]
public bool OwnerDraw
{
get
{
return ownerDraw;
}
[UIPermission(SecurityAction.Demand, Window=UIPermissionWindow.AllWindows)]
set
{
ownerDraw = value;
}
}
///
///
/// Gets or sets the length of time (in milliseconds) that
/// it takes subsequent ToolTip instances to appear as the mouse pointer moves from
/// one ToolTip region to
/// another.
///
///
[
RefreshProperties(RefreshProperties.All),
SRDescription(SR.ToolTipReshowDelayDescr)
]
public int ReshowDelay {
get {
return delayTimes[NativeMethods.TTDT_RESHOW];
}
set {
if (value < 0) {
throw new ArgumentOutOfRangeException("ReshowDelay", SR.GetString(SR.InvalidLowBoundArgumentEx, "ReshowDelay", (value).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
SetDelayTime(NativeMethods.TTDT_RESHOW, value);
}
}
///
///
/// Gets or sets a value indicating whether the
///
[
DefaultValue(false),
SRDescription(SR.ToolTipShowAlwaysDescr)
]
public bool ShowAlways {
get {
return showAlways;
}
set {
if (showAlways != value) {
showAlways = value;
if (GetHandleCreated()) {
RecreateHandle();
}
}
}
}
///
///
/// When set to true, any ampersands in the Text property are not displayed.
///
///
[
SRDescription(SR.ToolTipStripAmpersandsDescr),
Browsable(true),
DefaultValue(false)
]
public bool StripAmpersands {
get {
return stripAmpersands;
}
set {
if (stripAmpersands != value) {
stripAmpersands = value;
if (GetHandleCreated()) {
RecreateHandle();
}
}
}
}
///
///
/// Gets or sets an Icon on the ToolTip.
///
///
[
DefaultValue(ToolTipIcon.None),
SRDescription(SR.ToolTipToolTipIconDescr)
]
public ToolTipIcon ToolTipIcon {
get {
return toolTipIcon;
}
set {
if (toolTipIcon != value) {
//valid values are 0x0 to 0x3
if (!ClientUtils.IsEnumValid(value, (int)value, (int)ToolTipIcon.None, (int)ToolTipIcon.Error))
{
throw new InvalidEnumArgumentException("value", (int)value, typeof(ToolTipIcon));
}
toolTipIcon = value;
if (toolTipIcon > 0 && GetHandleCreated()) {
// If the title is null/empty, the icon won't display.
string title = !String.IsNullOrEmpty(toolTipTitle) ? toolTipTitle : " ";
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_SETTITLE, (int)toolTipIcon, title);
// Tooltip need to be updated to reflect the changes in the icon because
// this operation directly affects the size of the tooltip
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_UPDATE, 0, 0);
}
}
}
}
///
///
/// Gets or sets the title of the ToolTip.
///
///
[
DefaultValue(""),
SRDescription(SR.ToolTipTitleDescr)
]
public string ToolTipTitle
{
get
{
return toolTipTitle;
}
set
{
if (value == null)
{
value = string.Empty;
}
if (toolTipTitle != value)
{
toolTipTitle = value;
if (GetHandleCreated())
{
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_SETTITLE, (int)toolTipIcon, toolTipTitle);
// Tooltip need to be updated to reflect the changes in the titletext because
// this operation directly affects the size of the tooltip
UnsafeNativeMethods.SendMessage(new HandleRef(this, Handle), NativeMethods.TTM_UPDATE, 0, 0);
}
}
}
}
private Control TopLevelControl {
get {
Control baseVar = null;
if (topLevelControl == null) {
Control[] regions = new Control[tools.Keys.Count];
tools.Keys.CopyTo(regions, 0);
if (regions != null && regions.Length > 0) {
for (int i=0; i
///
/// When set to true, animations are used when tooltip is shown or hidden.
///
///
[
SRDescription(SR.ToolTipUseAnimationDescr),
Browsable(true),
DefaultValue(true)
]
public bool UseAnimation {
get {
return useAnimation;
}
set {
if (useAnimation != value) {
useAnimation = value;
if (GetHandleCreated()) {
RecreateHandle();
}
}
}
}
///
///
/// When set to true, a fade effect is used when tooltips are shown or hidden.
///
///
[
SRDescription(SR.ToolTipUseFadingDescr),
Browsable(true),
DefaultValue(true)
]
public bool UseFading {
get {
return useFading;
}
set {
if (useFading != value) {
useFading = value;
if (GetHandleCreated()) {
RecreateHandle();
}
}
}
}
///
/// Fires in OwnerDraw mode when the tooltip needs to be drawn.
///
[SRCategory(SR.CatBehavior),SRDescription(SR.ToolTipDrawEventDescr)]
public event DrawToolTipEventHandler Draw
{
add
{
onDraw += value;
}
remove
{
onDraw -= value;
}
}
///
/// Fires when the tooltip is just about to be shown.
///
[SRCategory(SR.CatBehavior),SRDescription(SR.ToolTipPopupEventDescr)]
public event PopupEventHandler Popup
{
add
{
onPopup += value;
}
remove
{
onPopup -= value;
}
}
///
/// Adjusts the other delay values based on the Automatic value.
///
///
/// Fires the Draw event.
///
private void OnDraw(DrawToolTipEventArgs e)
{
if(onDraw != null)
{
onDraw(this,e);
}
}
///
/// Fires the Popup event.
///
private void OnPopup(PopupEventArgs e)
{
if(onPopup != null)
{
onPopup(this,e);
}
}
private void TopLevelCreated(object sender, EventArgs eventargs) {
CreateHandle();
CreateAllRegions();
}
private void TopLevelDestroyed(object sender, EventArgs eventargs) {
DestoyAllRegions();
DestroyHandle();
}
///
/// Returns true if the tooltip can offer an extender property to the
/// specified target component.
///
///
/// Creates the handle for the control.
///
/// 0;
bool handlesCreated = ctl.IsHandleCreated
&& TopLevelControl != null
&& TopLevelControl.IsHandleCreated;
if (!created.ContainsKey(ctl) && captionValid
&& handlesCreated && !DesignMode) {
//Call the Sendmessage thru a function..
SetToolInfo(ctl, caption);
created[ctl] = ctl;
}
if (ctl.IsHandleCreated && topLevelControl == null) {
// Remove first to purge any duplicates...
//
ctl.MouseMove -= new MouseEventHandler(this.MouseMove);
ctl.MouseMove += new MouseEventHandler(this.MouseMove);
}
}
private void MouseMove(object sender, MouseEventArgs me) {
Control ctl = (Control)sender;
if (!created.ContainsKey(ctl)
&& ctl.IsHandleCreated
&& TopLevelControl != null) {
CreateRegion(ctl);
}
if (created.ContainsKey(ctl)) {
ctl.MouseMove -= new MouseEventHandler(this.MouseMove);
}
}
///
/// Destroys the handle for this control.
///
///
///
/// Disposes of the
///
protected override void Dispose(bool disposing) {
if (disposing) {
this.isDisposing = true;
try {
ClearTopLevelControlEvents();
StopTimer();
// always destroy the handle...
//
DestroyHandle();
RemoveAll();
window = null;
//Unhook the DeactiveEvent...
// Lets find the Form for associated Control ...
// and hook up to the Deactivated event to Hide the Shown tooltip
Form baseFrom = TopLevelControl as Form;
if (baseFrom != null) {
baseFrom.Deactivate -= new EventHandler(this.BaseFormDeactivate);
}
}
finally {
this.isDisposing = false;
}
}
base.Dispose(disposing);
}
///
/// Returns the delayTime based on the NativeMethods.TTDT_* values.
///
///
/// Returns a new instance of the TOOLINFO_T structure with the minimum
/// required data to uniquely identify a region. This is used primarily
/// for delete operations. NOTE: This cannot force the creation of a handle.
///
///
/// Returns a detailed TOOLINFO_TOOLTIP structure that represents the specified
/// region. NOTE: This may force the creation of a handle.
/// If the out parameter allocatedString has been set to true, It is the responsibility of the caller
/// to free the string buffer referenced by lpszText (using Marshal.FreeHGlobal).
///
///
///
/// Retrieves the
///
[
DefaultValue(""),
Localizable(true),
SRDescription(SR.ToolTipToolTipDescr),
Editor("System.ComponentModel.Design.MultilineStringEditor, " + AssemblyRef.SystemDesign, typeof(System.Drawing.Design.UITypeEditor))
]
public string GetToolTip(Control control) {
if (control == null) {
return String.Empty;
}
TipInfo tt = (TipInfo)tools[control];
if (tt == null || tt.Caption == null) {
return "";
}
else {
return tt.Caption;
}
}
///
/// Returns the HWND of the window that is at the specified point. This
/// handles special cases where one Control owns multiple HWNDs (i.e. ComboBox).
///
///
///
///
///
/// Removes all of the tooltips currently associated
/// with the
///
public void RemoveAll() {
Control[] regions = new Control[tools.Keys.Count];
tools.Keys.CopyTo(regions, 0);
for (int i=0; i
/// Sets the delayTime based on the NativeMethods.TTDT_* values.
///
///
///
/// Associates
///
public void SetToolTip(Control control, string caption) {
TipInfo info = new TipInfo(caption, TipInfo.Type.Auto);
SetToolTipInternal(control, info);
}
///
///
/// Associates
/// Returns true if the AutomaticDelay property should be persisted.
///
///
/// Returns true if the AutoPopDelay property should be persisted.
///
///
/// Returns true if the InitialDelay property should be persisted.
///
///
/// Returns true if the ReshowDelay property should be persisted.
///
///
/// Shows a tooltip for specified text, window, and hotspot
///
///
///
/// Associates
///
public void Show(string text, IWin32Window window) {
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
// Check if the foreground window is the TopLevelWindow
if (HasAllWindowsPermission && IsWindowActive(window)) {
ShowTooltip(text, window, 0);
}
}
///
///
/// Associates
///
public void Show(string text, IWin32Window window, int duration) {
if (duration < 0) {
throw new ArgumentOutOfRangeException("duration", SR.GetString(SR.InvalidLowBoundArgumentEx, "duration", (duration).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission && IsWindowActive(window)) {
ShowTooltip(text, window, duration);
}
}
///
///
/// Associates
///
public void Show(string text, IWin32Window window, Point point) {
if (window == null) {
throw new ArgumentNullException("window");
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission && IsWindowActive(window)) {
//Set The ToolTips...
NativeMethods.RECT r = new NativeMethods.RECT();
UnsafeNativeMethods.GetWindowRect(new HandleRef(window, Control.GetSafeHandle(window)), ref r);
int pointX = r.left + point.X;
int pointY = r.top + point.Y;
SetTrackPosition(pointX, pointY);
SetTool(window, text, TipInfo.Type.Absolute, new Point(pointX, pointY));
}
}
///
///
/// Associates
///
public void Show(string text, IWin32Window window, Point point, int duration) {
if (window == null) {
throw new ArgumentNullException("window");
}
if (duration < 0) {
throw new ArgumentOutOfRangeException("duration", SR.GetString(SR.InvalidLowBoundArgumentEx, "duration", (duration).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission && IsWindowActive(window)) {
//Set The ToolTips...
NativeMethods.RECT r = new NativeMethods.RECT();
UnsafeNativeMethods.GetWindowRect(new HandleRef(window, Control.GetSafeHandle(window)), ref r);
int pointX = r.left + point.X;
int pointY = r.top + point.Y;
SetTrackPosition(pointX, pointY);
SetTool(window, text, TipInfo.Type.Absolute, new Point(pointX, pointY));
StartTimer(window, duration);
}
}
///
///
/// Associates
///
public void Show(string text, IWin32Window window, int x, int y) {
if (window == null) {
throw new ArgumentNullException("window");
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission && IsWindowActive(window)) {
NativeMethods.RECT r = new NativeMethods.RECT();
UnsafeNativeMethods.GetWindowRect(new HandleRef(window, Control.GetSafeHandle(window)), ref r);
int pointX = r.left + x;
int pointY = r.top + y;
SetTrackPosition(pointX, pointY);
SetTool(window, text, TipInfo.Type.Absolute, new Point(pointX, pointY));
}
}
///
///
/// Associates
///
public void Show(string text, IWin32Window window, int x, int y, int duration) {
if (window == null) {
throw new ArgumentNullException("window");
}
if (duration < 0) {
throw new ArgumentOutOfRangeException("duration", SR.GetString(SR.InvalidLowBoundArgumentEx, "duration", (duration).ToString(CultureInfo.CurrentCulture), (0).ToString(CultureInfo.CurrentCulture)));
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission && IsWindowActive(window)) {
NativeMethods.RECT r = new NativeMethods.RECT();
UnsafeNativeMethods.GetWindowRect(new HandleRef(window, Control.GetSafeHandle(window)), ref r);
int pointX = r.left + x;
int pointY = r.top + y;
SetTrackPosition(pointX, pointY);
SetTool(window, text, TipInfo.Type.Absolute, new Point(pointX, pointY));
StartTimer(window, duration);
}
}
///
/// Private Function to encapsulate TTM_TRACKPOSITION so that this doesnt fire an extra POP event
///
private void SetTrackPosition(int pointX, int pointY)
{
try
{
trackPosition = true;
UnsafeNativeMethods.SendMessage(new HandleRef(this, this.Handle), NativeMethods.TTM_TRACKPOSITION, 0, NativeMethods.Util.MAKELONG(pointX, pointY));
}
finally
{
trackPosition= false;
}
}
///
///
/// Hides
///
public void Hide(IWin32Window win) {
if (win == null) {
throw new ArgumentNullException("win");
}
//SecReview: We should not allow Semi-trust apps to call Show on a tooltip. Refer VsWhidbey : 439847
if (HasAllWindowsPermission) {
if (window == null)
{
return;
}
// VSWhidbey 562045: Only send message if we actually have a ToolTip at this point.
if (GetHandleCreated()) {
IntPtr hWnd = Control.GetSafeHandle(win);
UnsafeNativeMethods.SendMessage(new HandleRef(this, this.Handle), NativeMethods.TTM_TRACKACTIVATE, 0, GetWinTOOLINFO(hWnd));
UnsafeNativeMethods.SendMessage(new HandleRef(this, this.Handle), NativeMethods.TTM_DELTOOL, 0, GetWinTOOLINFO(hWnd));
}
StopTimer();
//Check if the passed in IWin32Window is a Control...
Control tool = win as Control;
if (tool == null) {
owners.Remove(win.Handle);
}
else
{
if (tools.ContainsKey(tool)) {
SetToolInfo(tool, GetToolTip(tool));
}
else {
owners.Remove(win.Handle);
}
// Lets find the Form for associated Control ...
// and hook up to the Deactivated event to Hide the Shown tooltip
Form baseFrom = tool.FindFormInternal();
if (baseFrom != null) {
baseFrom.Deactivate -= new EventHandler(this.BaseFormDeactivate);
}
}
// VSWhidbey 562045 - clear off the toplevel control.
ClearTopLevelControlEvents();
topLevelControl = null;
}
}
private void BaseFormDeactivate(System.Object sender, System.EventArgs e){
HideAllToolTips();
}
private void HideAllToolTips() {
Control[] ctls = new Control[owners.Values.Count];
owners.Values.CopyTo(ctls, 0);
for (int i=0; i
/// Starts the timer hiding Positioned ToolTips
///
private void StartTimer(IWin32Window owner, int interval) {
if (timer == null) {
timer = new ToolTipTimer(owner);
// Add the timer handler
timer.Tick += new EventHandler(TimerHandler);
}
timer.Interval = interval;
timer.Start();
}
///
/// Stops the timer for hiding Positioned ToolTips
///
protected void StopTimer() {
//VSWhidbey 363538: hold a local ref to timer
//so that a posted message doesn't null this
//out during disposal.
ToolTipTimer timerRef = timer;
if (timerRef != null) {
timerRef.Stop();
timerRef.Dispose();
timer = null;
}
}
///
/// Generates updown events when the timer calls this function.
///
private void TimerHandler(object source, EventArgs args) {
Hide(((ToolTipTimer)source).Host);
}
///
///
/// Finalizes garbage collection.
///
///
~ToolTip() {
DestroyHandle();
}
///
///
/// Returns a string representation for this control.
///
///
public override string ToString() {
string s = base.ToString();
return s + " InitialDelay: " + InitialDelay.ToString(CultureInfo.CurrentCulture) + ", ShowAlways: " + ShowAlways.ToString(CultureInfo.CurrentCulture);
}
private void Reposition(Point tipPosition, Size tipSize) {
Point moveToLocation = tipPosition;
Screen screen = Screen.FromPoint(moveToLocation);
// Re-adjust the X position of the tool tip if it bleeds off the screen working area
if (moveToLocation.X + tipSize.Width > screen.WorkingArea.Right) {
moveToLocation.X = screen.WorkingArea.Right - tipSize.Width;
}
// re-adjust the Y position of the tool tip if it bleeds off the screen working area.
if (moveToLocation.Y + tipSize.Height> screen.WorkingArea.Bottom) {
moveToLocation.Y = screen.WorkingArea.Bottom - tipSize.Height;
}
SafeNativeMethods.SetWindowPos(new HandleRef(this, this.Handle),
NativeMethods.HWND_TOPMOST,
moveToLocation.X, moveToLocation.Y, tipSize.Width, tipSize.Height,
NativeMethods.SWP_NOACTIVATE | NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOOWNERZORDER);
}
///
/// Handles the WM_MOVE message.
///
///
/// Handles the WM_MOUSEACTIVATE message.
///
///
/// Handles the WM_WINDOWFROMPOINT message.
///
///
/// Handles the TTN_SHOW message.
///
///
/// Handles the WM_WINDOWPOSCHANGED message.
/// We need to Hide the window since the native tooltip actually calls SetWindowPos in its TTN_SHOW even if we cancel showing the
/// tooltip : Hence we need to listen to the WindowPosChanged message can hide the window ourselves.
/// Refer to VsWhidbey : 490044 for more details.
///
///
/// Handles the WM_WINDOWPOSCHANGING message.
///
///
/// Called just before the tooltip is hidden
///
///
/// WNDPROC
///
///
///
///
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XmlNodeReader.cs
- UpdatePanelControlTrigger.cs
- ContentFileHelper.cs
- coordinatorscratchpad.cs
- FileDialog_Vista_Interop.cs
- Profiler.cs
- RadioButton.cs
- Vector3DConverter.cs
- ArrayConverter.cs
- MethodBuilder.cs
- Int32Collection.cs
- xsdvalidator.cs
- ItemsControl.cs
- DeploymentSection.cs
- _NTAuthentication.cs
- BamlBinaryWriter.cs
- EntitySetBase.cs
- BezierSegment.cs
- MarkupExtensionReturnTypeAttribute.cs
- Material.cs
- SettingsSection.cs
- PropertyContainer.cs
- XsdBuildProvider.cs
- XmlSchemaValidationException.cs
- _OSSOCK.cs
- GlyphInfoList.cs
- XPathExpr.cs
- WizardStepCollectionEditor.cs
- DataRowComparer.cs
- ImmComposition.cs
- ToolStripItemBehavior.cs
- InternalResources.cs
- CommandLibraryHelper.cs
- SchemaAttDef.cs
- DataTrigger.cs
- ProcessModelSection.cs
- PixelShader.cs
- NullRuntimeConfig.cs
- DataGridHeaderBorder.cs
- WindowsListBox.cs
- RangeValidator.cs
- DocumentGridContextMenu.cs
- WindowsGrip.cs
- ValidationHelper.cs
- VBCodeProvider.cs
- DataGridViewLinkCell.cs
- SerialPort.cs
- SystemWebSectionGroup.cs
- HelpInfo.cs
- OledbConnectionStringbuilder.cs
- MetaData.cs
- CultureSpecificStringDictionary.cs
- TreeViewHitTestInfo.cs
- FormatVersion.cs
- ErrorReporting.cs
- FirstMatchCodeGroup.cs
- NativeMethods.cs
- MinimizableAttributeTypeConverter.cs
- PageAsyncTask.cs
- FontEditor.cs
- RangeValueProviderWrapper.cs
- DrawingAttributesDefaultValueFactory.cs
- FragmentQuery.cs
- DataException.cs
- DataGridViewCellCancelEventArgs.cs
- TextDecorationLocationValidation.cs
- DataServiceContext.cs
- XmlQualifiedName.cs
- AesCryptoServiceProvider.cs
- DataGridViewTextBoxEditingControl.cs
- MessageDescription.cs
- PriorityItem.cs
- RelatedPropertyManager.cs
- TableRowCollection.cs
- TranslateTransform.cs
- TargetInvocationException.cs
- InertiaTranslationBehavior.cs
- Group.cs
- MenuAutomationPeer.cs
- ErrorWebPart.cs
- WindowsRebar.cs
- LicenseContext.cs
- PKCS1MaskGenerationMethod.cs
- CLSCompliantAttribute.cs
- SystemUnicastIPAddressInformation.cs
- CodeStatement.cs
- MasterPageCodeDomTreeGenerator.cs
- GradientStop.cs
- TransactionManager.cs
- CacheAxisQuery.cs
- BitmapScalingModeValidation.cs
- XhtmlTextWriter.cs
- safemediahandle.cs
- ToolStripPanelRow.cs
- SimpleBitVector32.cs
- CreateUserWizard.cs
- shaper.cs
- ScrollBarRenderer.cs
- SortedList.cs
- ExtensionsSection.cs