/// <summary>
/// Show the popup using the provided rectangle as the screen rect.
/// </summary>
/// <param name="screenRect">Screen rectangle for showing the popup.</param>
public virtual void Show(Rectangle screenRect)
{
// Offset by the width/height of the shadow
screenRect.X += SHADOW_SIZE;
screenRect.Y += SHADOW_SIZE;
// Update the screen position
Location = screenRect.Location;
ClientSize = screenRect.Size;
// Show the window without activating it (i.e. do not take focus)
PI.ShowWindow(this.Handle, (short)PI.SW_SHOWNOACTIVATE);
PI.SetWindowPos(this.Handle, (IntPtr)(-2), screenRect.X, screenRect.Y, screenRect.Width, screenRect.Height, 0x0010);
PI.SetWindowPos(this.Handle, (IntPtr)(-1), screenRect.X, screenRect.Y, screenRect.Width, screenRect.Height, 0x0010);
// this.Visible = true;
// PI.SetWindowPos(this.Handle, (IntPtr)(-2), screenRect.X, screenRect.Y, screenRect.Width, screenRect.Height, 0x0010);
//this.TopMost = true;
//this.TopMost = false;
}
/// <summary>
/// Process Windows-based messages.
/// </summary>
/// <param name="m">A Windows-based message.</param>
protected override void WndProc(ref Message m)
{
// We need to snoop the need to show a context menu
if (m.Msg == PI.WM_CONTEXTMENU)
{
// Only interested in overriding the behavior when we have a krypton context menu...
if (KryptonContextMenu != null)
{
// Extract the screen mouse position (if might not actually be provided)
Point mousePt = new Point(PI.LOWORD(m.LParam), PI.HIWORD(m.LParam));
// If keyboard activated, the menu position is centered
if (((int)((long)m.LParam)) == -1)
{
mousePt = new Point(Width / 2, Height / 2);
}
else
{
mousePt = PointToClient(mousePt);
// Mouse point up and left 1 pixel so that the mouse overlaps the top left corner
// of the showing context menu just like it happens for a ContextMenuStrip.
mousePt.X -= 1;
mousePt.Y -= 1;
}
// If the mouse posiiton is within our client area
if (ClientRectangle.Contains(mousePt))
{
// Show the context menu
KryptonContextMenu.Show(this, PointToScreen(mousePt));
// We eat the message!
return;
}
}
}
base.WndProc(ref m);
}
private bool ProcessMouseMoveWithCMS(ref Message m)
{
if (_current == null)
{
return(false);
}
// Convert the client position to screen point
Point screenPt = CommonHelper.ClientMouseMessageToScreenPt(m);
// Convert from a class to a structure
PI.POINT screenPIPt = new PI.POINT();
screenPIPt.x = screenPt.X;
screenPIPt.y = screenPt.Y;
// Get the window handle of the window under this screen point
IntPtr hWnd = PI.WindowFromPoint(screenPIPt);
// Is the window handle that of the currently tracking popup
if (_current.Handle == hWnd)
{
return(true);
}
// Search all the stacked popups for any that match the window handle
VisualPopup[] popups = _stack.ToArray();
for (int i = 0; i < popups.Length; i++)
{
if (!popups[i].IsDisposed)
{
if (popups[i].Handle == hWnd)
{
return(true);
}
}
}
// Mouse move is not over a popup, so allow it
return(false);
}
private static string InternalShow(IWin32Window owner,
string prompt,
string caption,
string defaultResponse)
{
IWin32Window showOwner = null;
// If do not have an owner passed in then get the active window and use that instead
if (owner == null)
{
showOwner = Control.FromHandle(PI.GetActiveWindow());
}
else
{
showOwner = owner;
}
// Show input box window as a modal dialog and then dispose of it afterwards
using (KryptonInputBox ib = new KryptonInputBox(prompt, caption, defaultResponse))
{
if (showOwner == null)
{
ib.StartPosition = FormStartPosition.CenterScreen;
}
else
{
ib.StartPosition = FormStartPosition.CenterParent;
}
if (ib.ShowDialog(showOwner) == DialogResult.OK)
{
return(ib.InputResponse);
}
else
{
return(string.Empty);
}
}
}
private bool ProcessNonClientMouseDown(ref Message m)
{
// Extract the x and y mouse position from message
Point screenPt = new Point(PI.LOWORD((int)m.LParam), PI.HIWORD((int)m.LParam));
// Ask the popup if this message causes the entire stack to be killed
if (_current.DoesCurrentMouseDownEndAllTracking(m, ScreenPtToClientPt(screenPt)))
{
EndAllTracking();
}
// Do any of the current popups want the mouse down to be eaten?
bool processed = false;
if (_current != null)
{
processed = _current.DoesMouseDownGetEaten(m, screenPt);
if (!processed)
{
// Search from end towards the front, the last entry is the most recent 'Push'
VisualPopup[] popups = _stack.ToArray();
for (int i = 0; i < popups.Length; i++)
{
// Ignore disposed popups
VisualPopup popup = popups[i];
if (!popup.IsDisposed)
{
processed = popup.DoesMouseDownGetEaten(m, screenPt);
if (processed)
{
break;
}
}
}
}
}
return(processed);
}
/// <summary>
/// Perform a paint of the view.
/// </summary>
/// <param name="context">Renderer context.</param>
public virtual void Paint(RenderContext context)
{
Debug.Assert(context != null);
Debug.Assert(Root != null);
// Validate incoming reference
if (context == null)
{
throw new ArgumentNullException("context");
}
// Do nothing if the control is disposed or inside a layout call
if (!_control.IsDisposed)
{
if (_outputDebug)
{
PI.QueryPerformanceCounter(ref _outputStart);
}
// Ask the view to paint itself
Root.Render(context);
if (_outputDebug)
{
long outputEnd = 0;
PI.QueryPerformanceCounter(ref outputEnd);
long outputDiff = outputEnd - _outputStart;
Console.WriteLine("Id:{0} Paint Type:{1} Elapsed: {2}",
Id,
_control.GetType().ToString(),
outputDiff.ToString());
}
}
// Maintain internal counters for measuring perf
_paintCounter++;
}
/// <summary>
/// Show the popup using the provided rectangle as the screen rect.
/// </summary>
/// <param name="screenRect">Screen rectangle for showing the popup.</param>
public virtual void Show(Rectangle screenRect)
{
// Update the screen position
SetBounds(screenRect.X, screenRect.Y,
screenRect.Width, screenRect.Height);
// If we have a shadow then update it now
if (_shadow != null)
{
_shadow.Show(screenRect);
}
// Show the window without activating it (i.e. do not take focus)
PI.ShowWindow(this.Handle, (short)PI.SW_SHOWNOACTIVATE);
PI.SetWindowPos(this.Handle, (IntPtr)(-1), screenRect.X, screenRect.Y, screenRect.Width, screenRect.Height, 0x0010);
this.Visible = true;
// PI.SetWindowPos(this.Handle, (IntPtr)(-2), screenRect.X, screenRect.Y, screenRect.Width, screenRect.Height, 0x0010);
//this.BringToFront();
//this.SetTopLevel(true);
// Use manager to track mouse/keyboard input and to dismiss the window
VisualPopupManager.Singleton.StartTracking(this);
}
/// <summary>
/// Draw text with a glowing background, for use on a composition element.
/// </summary>
/// <param name="g">Graphics reference.</param>
/// <param name="text">Text to be drawn.</param>
/// <param name="font">Font to use for text.</param>
/// <param name="bounds">Bounding area for the text.</param>
/// <param name="state">State of the source element.</param>
/// <param name="color">Color of the text.</param>
/// <param name="copyBackground">Should existing background be copied into the bitmap.</param>
public static void DrawCompositionGlowingText(Graphics g,
string text,
Font font,
Rectangle bounds,
PaletteState state,
Color color,
bool copyBackground)
{
try
{
// Get the hDC for the graphics instance and create a memory DC
IntPtr gDC = g.GetHdc();
IntPtr mDC = PI.CreateCompatibleDC(gDC);
PI.BITMAPINFO bmi = new PI.BITMAPINFO();
bmi.biSize = Marshal.SizeOf(bmi);
bmi.biWidth = bounds.Width;
bmi.biHeight = -(bounds.Height + GLOW_EXTRA_HEIGHT * 2);
bmi.biCompression = 0;
bmi.biBitCount = 32;
bmi.biPlanes = 1;
// Create a device independant bitmp and select into the memory DC
IntPtr hDIB = PI.CreateDIBSection(gDC, bmi, 0, 0, IntPtr.Zero, 0);
PI.SelectObject(mDC, hDIB);
if (copyBackground)
{
// Copy existing background into the bitmap
PI.BitBlt(mDC, 0, 0, bounds.Width, bounds.Height + GLOW_EXTRA_HEIGHT * 2,
gDC, bounds.X, bounds.Y - GLOW_EXTRA_HEIGHT, 0x00CC0020);
}
// Select the font for use when drawing
IntPtr hFont = font.ToHfont();
PI.SelectObject(mDC, hFont);
// Get renderer for the correct state
VisualStyleRenderer renderer = new VisualStyleRenderer(state == PaletteState.Normal ? VisualStyleElement.Window.Caption.Active :
VisualStyleElement.Window.Caption.Inactive);
// Create structures needed for theme drawing call
PI.RECT textBounds = new PI.RECT();
textBounds.left = 0;
textBounds.top = 0;
textBounds.right = (bounds.Right - bounds.Left);
textBounds.bottom = (bounds.Bottom - bounds.Top) + (GLOW_EXTRA_HEIGHT * 2);
PI.DTTOPTS dttOpts = new PI.DTTOPTS();
dttOpts.dwSize = Marshal.SizeOf(typeof(PI.DTTOPTS));
dttOpts.dwFlags = PI.DTT_COMPOSITED | PI.DTT_GLOWSIZE | PI.DTT_TEXTCOLOR;
dttOpts.crText = ColorTranslator.ToWin32(color);
dttOpts.iGlowSize = 11;
// Always draw text centered
TextFormatFlags textFormat = TextFormatFlags.SingleLine |
TextFormatFlags.HorizontalCenter |
TextFormatFlags.VerticalCenter |
TextFormatFlags.EndEllipsis;
// Perform actual drawing
PI.DrawThemeTextEx(renderer.Handle,
mDC, 0, 0,
text, -1, (int)textFormat,
ref textBounds, ref dttOpts);
// Copy to foreground
PI.BitBlt(gDC,
bounds.Left, bounds.Top - GLOW_EXTRA_HEIGHT,
bounds.Width, bounds.Height + (GLOW_EXTRA_HEIGHT * 2),
mDC, 0, 0, 0x00CC0020);
// Dispose of allocated objects
PI.DeleteObject(hFont);
PI.DeleteObject(hDIB);
PI.DeleteDC(mDC);
// Must remember to release the hDC
g.ReleaseHdc(gDC);
}
catch
{
}
}
/// <summary>
/// Shows the task dialog as a modal dialog box with the currently active window set as its owner.
/// </summary>
/// <returns>One of the DialogResult values.</returns>
public DialogResult ShowDialog()
{
return(ShowDialog(Control.FromHandle(PI.GetActiveWindow())));
}
public bool PreFilterMessage(ref Message m)
{
// If we have suspended operation....
if (_suspended > 0)
{
// Intercept the non-client mouse move to prevent the custom
// chrome of the form from providing hot tracking feedback
if (m.Msg == PI.WM_NCMOUSEMOVE)
{
return(true);
}
// A mouse move can occur because a context menu is showing with a popup also
// already showing. We suppress the mouse move to prevent tracking of the popup
if (m.Msg == PI.WM_MOUSEMOVE)
{
return(ProcessMouseMoveWithCMS(ref m));
}
return(false);
}
if (_current != null)
{
// If the popup has been become disposed
if (_current.IsDisposed)
{
EndCurrentTracking();
return(false);
}
else
{
// Get the active window
IntPtr activeWindow = PI.GetActiveWindow();
// Is there a change in active window?
if (activeWindow != _activeWindow)
{
// If the current window has become active, ask popup if that is allowed
if ((activeWindow == _current.Handle) && _current.AllowBecomeActiveWhenCurrent)
{
_activeWindow = _current.Handle;
}
else
{
bool focus = _current.ContainsFocus;
if (!focus)
{
VisualPopup[] popups = _stack.ToArray();
// For from last to first for any popup that has the focus
for (int i = popups.Length - 1; i >= 0; i--)
{
if (!popups[i].IsDisposed)
{
if (popups[i].ContainsFocus)
{
focus = true;
break;
}
}
}
}
// If the change in active window (focus) is not to the current
// or a stacked popup then we need to pull down the entire stack
// as focus has been shifted away from the use of any popup.
if (!focus)
{
EndAllTracking();
return(false);
}
}
}
}
// We only intercept and handle keyboard and mouse messages
if (!IsKeyOrMouseMessage(ref m))
{
return(false);
}
switch (m.Msg)
{
case PI.WM_KEYDOWN:
case PI.WM_SYSKEYDOWN:
// If the popup is telling us to redirect keyboard to itself
if (!_current.KeyboardInert)
{
// If the focus is not inside the actual current tracking popup
// then we need to manually translate the message to ensure that
// KeyPress events occur for the current popup.
if (!_current.ContainsFocus)
{
PI.MSG msg = new PI.MSG();
msg.hwnd = m.HWnd;
msg.message = m.Msg;
msg.lParam = m.LParam;
msg.wParam = m.WParam;
PI.TranslateMessage(ref msg);
}
return(ProcessKeyboard(ref m));
}
break;
case PI.WM_CHAR:
case PI.WM_KEYUP:
case PI.WM_DEADCHAR:
case PI.WM_SYSCHAR:
case PI.WM_SYSKEYUP:
case PI.WM_SYSDEADCHAR:
// If the popup is telling us to redirect keyboard to itself
if (!_current.KeyboardInert)
{
return(ProcessKeyboard(ref m));
}
break;
case PI.WM_MOUSEMOVE:
case PI.WM_NCMOUSEMOVE:
return(ProcessMouseMove(ref m));
case PI.WM_LBUTTONDOWN:
case PI.WM_RBUTTONDOWN:
case PI.WM_MBUTTONDOWN:
return(ProcessClientMouseDown(ref m));
case PI.WM_NCLBUTTONDOWN:
case PI.WM_NCRBUTTONDOWN:
case PI.WM_NCMBUTTONDOWN:
return(ProcessNonClientMouseDown(ref m));
}
}
return(false);
}