public static Size GetTextSize(Graphics graphics, string text, Font font)
{
IntPtr hdc = IntPtr.Zero;
if ( graphics != null )
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = WindowsAPI.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
Win32.RECT rect = new Win32.RECT();
rect.left = 0;
rect.right = 0;
rect.top = 0;
rect.bottom = 0;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect,
(int)(DrawTextFormatFlags.DT_SINGLELINE | DrawTextFormatFlags.DT_LEFT | DrawTextFormatFlags.DT_CALCRECT));
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
if ( graphics != null )
graphics.ReleaseHdc(hdc);
else
WindowsAPI.ReleaseDC(IntPtr.Zero, hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
protected override void OnPaint(PaintEventArgs e)
{
IntPtr data=Win32.OpenThemeData2(this.Handle,"Scrollbar");
if (data!=IntPtr.Zero)//mit xp themes
{
IntPtr hdc=e.Graphics.GetHdc();
Win32.RECT rct=new Win32.RECT(0,0,this.Width,this.Height);
Win32.DrawThemeBackground2(data,hdc,4,4,ref rct);
rct=base._elems[0].Bounds; rct.Top--;
Win32.DrawThemeBackground2(data,hdc,1,(int)base._elems[0].State+8,ref rct);
rct=base._elems[1].Bounds; rct.Top--;
Win32.DrawThemeBackground2(data,hdc,1,(int)base._elems[1].State+12,ref rct);
rct=base._elems[2].Bounds; rct.Top--;
Win32.DrawThemeBackground2(data,hdc,2,(int)base._elems[2].State,ref rct);
e.Graphics.ReleaseHdc(hdc);
Win32.CloseThemeData2(data);
}
else//ohne xpthemes, einfache rechtecke
{
e.Graphics.FillRectangle(SystemBrushes.ControlLightLight,this.ClientRectangle);
ControlPaint.DrawScrollButton(e.Graphics,base._elems[0].Bounds,ScrollButton.Left,base._elems[0].ToButtonState());
ControlPaint.DrawScrollButton(e.Graphics,base._elems[1].Bounds,ScrollButton.Right,base._elems[1].ToButtonState());
ControlPaint.DrawButton(e.Graphics,base._elems[2].Bounds,ButtonState.Normal);
}
using(StringFormat fmt=new StringFormat(StringFormatFlags.NoWrap))
{
fmt.LineAlignment=fmt.Alignment=StringAlignment.Center;
e.Graphics.DrawString(base.Value.ToString(),base.Font,
this.Enabled?Brushes.Black:Brushes.Gray,base._elems[2].Bounds,fmt);
}
}
public static Size GetTextSize(Graphics graphics, string text, Font font, ref Rectangle rc, DrawTextFormatFlags drawFlags)
{
IntPtr hdc = IntPtr.Zero;
if ( graphics != null )
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = WindowsAPI.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
Win32.RECT rect = new Win32.RECT();
rect.left = rc.Left;
rect.right = rc.Right;
rect.top = rc.Top;
rect.bottom = rc.Bottom;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect, (int)drawFlags);
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
if ( graphics != null )
graphics.ReleaseHdc(hdc);
else
WindowsAPI.ReleaseDC(IntPtr.Zero, hdc);
return new Size(rect.right - rect.left, rect.bottom - rect.top);
}
/// <summary>
/// Retrieves DPI information when running on Windows 8.1 and higher.
/// </summary>
private Boolean InitWindows8_1(UltravioletContext uv, IUltravioletDisplay display)
{
if (uv.Platform != UltravioletPlatform.Windows || Environment.OSVersion.Version < new Version(6, 3))
return false;
var rect = new Win32.RECT
{
left = display.Bounds.Left,
top = display.Bounds.Top,
right = display.Bounds.Right,
bottom = display.Bounds.Bottom
};
var hmonitor = IntPtr.Zero;
Win32.EnumDisplayMonitors(IntPtr.Zero, &rect, (hdc, lprcClip, lprcMonitor, dwData) =>
{
hmonitor = hdc;
return false;
}, IntPtr.Zero);
if (hmonitor == IntPtr.Zero)
return false;
UInt32 x, y;
Win32.GetDpiForMonitor(hmonitor, 0, out x, out y);
this.densityX = x;
this.densityY = y;
this.densityScale = x / 96f;
this.densityBucket = GuessBucketFromDensityScale(densityScale);
return true;
}
/// <summary>
/// フックプロシージャ
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
private IntPtr HookProc( int nCode, IntPtr wParam, IntPtr lParam )
{
if( nCode == (int)Win32.HCBT.ACTIVATE )
{
Win32.RECT rcForm = new Win32.RECT( 0, 0, 0, 0 );
Win32.RECT rcMsgBox = new Win32.RECT( 0, 0, 0, 0 );
Win32.Api.GetWindowRect( m_ownerWindow.Handle, out rcForm );
Win32.Api.GetWindowRect( wParam, out rcMsgBox );
// センター位置を計算する。
int x = ( rcForm.Left + ( rcForm.Right - rcForm.Left ) / 2 ) - ( ( rcMsgBox.Right - rcMsgBox.Left ) / 2 );
int y = ( rcForm.Top + ( rcForm.Bottom - rcForm.Top ) / 2 ) - ( ( rcMsgBox.Bottom - rcMsgBox.Top ) / 2 );
Win32.Api.SetWindowPos( wParam, 0, x, y, 0, 0, Win32.SWP.NOSIZE | Win32.SWP.NOZORDER | Win32.SWP.NOACTIVATE );
IntPtr result = Win32.Api.CallNextHookEx( m_hHook, nCode, wParam, lParam );
// フックを解除する。
Win32.Api.UnhookWindowsHookEx( m_hHook );
m_hHook = IntPtr.Zero;
return result;
}
else
{
return Win32.Api.CallNextHookEx( m_hHook, nCode, wParam, lParam );
}
}
private static void CenterWindowOnParent(IntPtr hChildWnd_)
{
Win32.RECT rcChild = new Win32.RECT();
Win32.GetWindowRect(hChildWnd_, ref rcChild);
int cxChild = rcChild.right - rcChild.left;
int cyChild = rcChild.bottom - rcChild.top;
IntPtr hParent = Win32.GetParent(hChildWnd_);
Win32.RECT rcParent = new Win32.RECT();
Win32.GetWindowRect(hParent, ref rcParent);
int cxParent = rcParent.right - rcParent.left;
int cyParent = rcParent.bottom - rcParent.top;
int x = rcParent.left + (cxParent - cxChild) / 2;
int y = rcParent.top + (cyParent - cyChild) / 2;
uint uFlags = 0x15;
Win32.SetWindowPos(hChildWnd_, IntPtr.Zero, x, y, 0, 0, uFlags);
}
public static Size GetTextSize( Graphics g, string text, Font font, ref Rectangle rc, DrawTextFormatFlags drawFlags )
{
IntPtr hdc = GetGraphicsHDC( g );
IntPtr hFont = font.ToHfont();
IntPtr hOldFont = WindowsAPI.SelectObject( hdc, hFont );
Win32.RECT rect = new Win32.RECT();
rect.left = rc.Left;
rect.right = rc.Right;
rect.top = rc.Top;
rect.bottom = rc.Bottom;
WindowsAPI.DrawText( hdc, text, text.Length, ref rect, (int)drawFlags );
WindowsAPI.SelectObject( hdc, hOldFont );
WindowsAPI.DeleteObject( hFont );
ReleaseGraphicHDC( g, hdc );
return ( Size )rect;
}
public static Size GetTextSize(Graphics g, string text, Font font, ref Rectangle rc, DrawTextFormatFlags drawFlags)
{
IntPtr hdc = GetGraphicsHDC(g);
IntPtr hFont = font.ToHfont();
IntPtr hOldFont = WindowsAPI.SelectObject(hdc, hFont);
Win32.RECT rect = new Win32.RECT();
rect.left = rc.Left;
rect.right = rc.Right;
rect.top = rc.Top;
rect.bottom = rc.Bottom;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect, (int)drawFlags);
WindowsAPI.SelectObject(hdc, hOldFont);
WindowsAPI.DeleteObject(hFont);
ReleaseGraphicHDC(g, hdc);
return(( Size )rect);
}
void CopyFrontBufferToBack( /*IntPtr hWnd*/)
{
Gl.glDisable(Gl.GL_ALPHA_TEST);
if (!Types.iBugWhiteout)
{
// Found this by accident; Adam likes it. Freakshow option #1.
Gl.glDisable(Gl.GL_BLEND);
}
Win32.RECT rct=new Win32.RECT();
Win32.User.GetWindowRect(Video.WindowHandle, ref rct);
Gl.glReadBuffer(Gl.GL_FRONT);
Gl.glDrawBuffer(Gl.GL_BACK);
Gl.glRasterPos2i(0, 0);
Gl.glCopyPixels(0, 0, rct.Right, rct.Bottom, Gl.GL_COLOR);
if (!Types.iBugWhiteout)
{
Gl.glEnable(Gl.GL_BLEND);
}
Gl.glEnable(Gl.GL_ALPHA_TEST);
}
/// <summary>
/// Draw a themed background element.
/// </summary>
/// <param name="g">Graphics object reference.</param>
/// <param name="draw">Rectangle for drawing.</param>
/// <param name="part">Theme part.</param>
/// <param name="state">Theme state of part.</param>
public void DrawThemeBackground(Graphics g, Rectangle draw, int part, int state)
{
if (IsControlThemed)
{
// Create a Win32 version of the drawing Rectangle
Win32.RECT drawWin32 = new Win32.RECT();
drawWin32.left = draw.X;
drawWin32.top = draw.Y;
drawWin32.right = draw.Right;
drawWin32.bottom = draw.Bottom;
// Get access to the underlying HDC
IntPtr hDC = g.GetHdc();
// Perform actual drawing work
Uxtheme.DrawThemeBackground(_hTheme, hDC, part, state, ref drawWin32, IntPtr.Zero);
// Must release the resource to prevent leaks!
g.ReleaseHdc(hDC);
}
}
void CopyFrontBufferToBack(/*IntPtr hWnd*/)
{
Gl.glDisable(Gl.GL_ALPHA_TEST);
if (!Types.iBugWhiteout)
{
// Found this by accident; Adam likes it. Freakshow option #1.
Gl.glDisable(Gl.GL_BLEND);
}
Win32.RECT rct = new Win32.RECT();
Win32.User.GetWindowRect(Video.WindowHandle, ref rct);
Gl.glReadBuffer(Gl.GL_FRONT);
Gl.glDrawBuffer(Gl.GL_BACK);
Gl.glRasterPos2i(0, 0);
Gl.glCopyPixels(0, 0, rct.Right, rct.Bottom, Gl.GL_COLOR);
if (!Types.iBugWhiteout)
{
Gl.glEnable(Gl.GL_BLEND);
}
Gl.glEnable(Gl.GL_ALPHA_TEST);
}
public static Size GetTextSize(Graphics graphics, string text, Font font)
{
IntPtr hdc = IntPtr.Zero;
if (graphics != null)
{
// Get device context from the graphics passed in
hdc = graphics.GetHdc();
}
else
{
// Get screen device context
hdc = WindowsAPI.GetDC(IntPtr.Zero);
}
IntPtr fontHandle = font.ToHfont();
IntPtr currentFontHandle = WindowsAPI.SelectObject(hdc, fontHandle);
Win32.RECT rect = new Win32.RECT();
rect.left = 0;
rect.right = 0;
rect.top = 0;
rect.bottom = 0;
WindowsAPI.DrawText(hdc, text, text.Length, ref rect,
(int)(DrawTextFormatFlags.DT_SINGLELINE | DrawTextFormatFlags.DT_LEFT | DrawTextFormatFlags.DT_CALCRECT));
WindowsAPI.SelectObject(hdc, currentFontHandle);
WindowsAPI.DeleteObject(fontHandle);
if (graphics != null)
{
graphics.ReleaseHdc(hdc);
}
else
{
WindowsAPI.ReleaseDC(IntPtr.Zero, hdc);
}
return(new Size(rect.right - rect.left, rect.bottom - rect.top));
}
/// <summary>
/// 子ウィンドウを親ウィンドウの中央に移動する
/// </summary>
/// <param name="hChildWnd"></param>
private static void MoveToCenterOnParent(IntPtr hChildWnd)
{
// 子ウィンドウの領域取得
var childRect = new Win32.RECT();
Win32.GetWindowRect(hChildWnd, ref childRect);
int cxChild = childRect.Right - childRect.Left;
int cyChild = childRect.Bottom - childRect.Top;
// 親ウィンドウの領域取得
var parentRect = new Win32.RECT();
Win32.GetWindowRect(Win32.GetParent(hChildWnd), ref parentRect);
int cxParent = parentRect.Right - parentRect.Left;
int cyParent = parentRect.Bottom - parentRect.Top;
// 子ウィンドウを親ウィンドウの中央に移動
int x = parentRect.Left + (cxParent - cxChild) / 2;
int y = parentRect.Top + (cyParent - cyChild) / 2;
Win32.SetWindowPos(hChildWnd, IntPtr.Zero, x, y, 0, 0, 0x15); // 0x15 = SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE
}
protected override void OnPaint(PaintEventArgs e)
{
IntPtr data = Win32.OpenThemeData2(this.Handle, "Scrollbar");
if (data != IntPtr.Zero) //mit xp themes
{
IntPtr hdc = e.Graphics.GetHdc();
Win32.RECT rct = new Win32.RECT(0, 0, this.Width, this.Height);
Win32.DrawThemeBackground2(data, hdc, 6, 2, ref rct);
rct = base._elems[0].Bounds;
rct.Left--;
Win32.DrawThemeBackground2(data, hdc, 1, (int)base._elems[0].State, ref rct);
rct = base._elems[1].Bounds;
rct.Left--;
Win32.DrawThemeBackground2(data, hdc, 1, (int)base._elems[1].State + 4, ref rct);
rct = base._elems[2].Bounds;
rct.Left--;
Win32.DrawThemeBackground2(data, hdc, 3, (int)base._elems[2].State, ref rct);
e.Graphics.ReleaseHdc(hdc);
Win32.CloseThemeData2(data);
}
else //ohne xpthemes, einfache rechtecke
{
e.Graphics.FillRectangle(SystemBrushes.ControlLightLight, this.ClientRectangle);
ControlPaint.DrawScrollButton(e.Graphics, base._elems[0].Bounds, ScrollButton.Up, base._elems[0].ToButtonState());
ControlPaint.DrawScrollButton(e.Graphics, base._elems[1].Bounds, ScrollButton.Down, base._elems[1].ToButtonState());
ControlPaint.DrawButton(e.Graphics, base._elems[2].Bounds, ButtonState.Normal);
}
base._elems[2].Bounds.X -= 3;
using (StringFormat fmt = new StringFormat(StringFormatFlags.NoWrap |
StringFormatFlags.DirectionVertical)) {
fmt.LineAlignment = fmt.Alignment = StringAlignment.Center;
e.Graphics.DrawString(base.Value.ToString(), base.Font,
this.Enabled ? Brushes.Black : Brushes.Gray, base._elems[2].Bounds, fmt);
}
base._elems[2].Bounds.X += 3;
}
// Boilerplate window-centering code.
// Split out of HookCallback() for clarity.
private static void CenterWindowOnParent(IntPtr hChildWnd)
{
// Get child (MessageBox) size
Win32.RECT rcChild = new Win32.RECT();
Win32.GetWindowRect(hChildWnd, ref rcChild);
int cxChild = rcChild.right - rcChild.left;
int cyChild = rcChild.bottom - rcChild.top;
// Get parent (Form) size & location
IntPtr hParent = Win32.GetParent(hChildWnd);
Win32.RECT rcParent = new Win32.RECT();
Win32.GetWindowRect(hParent, ref rcParent);
int cxParent = rcParent.right - rcParent.left;
int cyParent = rcParent.bottom - rcParent.top;
// Center the MessageBox on the Form
int x = rcParent.left + (cxParent - cxChild)/2;
int y = rcParent.top + (cyParent - cyChild)/2;
const uint uFlags = 0x15; // SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE;
x = x < 0 ? 100 : x;
y = y < 0 ? 100 : y;
Win32.SetWindowPos(hChildWnd, IntPtr.Zero, x, y, 0, 0, uFlags);
}
private Rectangle CalculateToolTipLocation(string contentSpacing, IWin32Window window, int x, int y, StemPosition stemPosition)
{
Rectangle toolTipBounds = new Rectangle();
Size toolTipSize = GetToolTipWindowSize(contentSpacing);
Win32.RECT windowBounds = new Win32.RECT();
Win32.GetWindowRect(window.Handle, ref windowBounds);
x += windowBounds.left;
if (StemPosition.TopLeft == stemPosition || StemPosition.BottomLeft == stemPosition)
{
toolTipBounds.X = x - StemInset;
}
else if (StemPosition.TopCentre == stemPosition || StemPosition.BottomCentre == stemPosition)
{
toolTipBounds.X = x - (toolTipSize.Width / 2);
}
else
{
toolTipBounds.X = x - toolTipSize.Width + StemInset;
}
if (StemPosition.TopLeft == stemPosition || StemPosition.TopCentre == stemPosition || StemPosition.TopRight == stemPosition)
{
toolTipBounds.Y = windowBounds.bottom - y;
}
else
{
toolTipBounds.Y = y + windowBounds.top - toolTipSize.Height;
}
toolTipBounds.Width = toolTipSize.Width;
toolTipBounds.Height = toolTipSize.Height;
return(toolTipBounds);
}
/// <summary>
/// Brings the visualiser to the front of all windows, and aligns the windows.
/// </summary>
public static void BringVisualiserToFrontAndAlignWindows()
{
//Look for the visuliser window
IntPtr visualiserWindowHandle = Win32.FindWindow(null, "StromoLight Visualiser");
//If visualiser window hasn't opened yet, keep looking until it does
while (visualiserWindowHandle == new IntPtr(0))
{
System.Threading.Thread.Sleep(20);
visualiserWindowHandle = Win32.FindWindow(null, "StromoLight Visualiser");
}
//Get a Win32 RECT containing the visualiser window properties
Win32.RECT visualiserRect = new Win32.RECT();
Win32.GetWindowRect(visualiserWindowHandle, out visualiserRect);
//If the visualiser window hasn't finished initalising, keep getting it's properties until it has initialised
while (visualiserRect.Left == 0)
{
System.Threading.Thread.Sleep(20);
Win32.GetWindowRect(visualiserWindowHandle, out visualiserRect);
}
Win32.SetWindowPos(visualiserWindowHandle,
Win32.HWND_TOP,
(System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Width / 2) + 4,
5,
(System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Width / 2),
System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Height,
Win32.SWP_SHOWWINDOW);
//Bring the visualiser window to the front
Win32.SetForegroundWindow(visualiserWindowHandle);
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
IntPtr data = Win32.OpenThemeData2(this.Handle, "Trackbar");
if (data != IntPtr.Zero) {
IntPtr hdc = e.Graphics.GetHdc();
Win32.RECT rct = new Win32.RECT(
_tracker.Bounds.Width/2, this.Height/2 - 2,
this.Width - _tracker.Bounds.Width, 4);
Win32.DrawThemeBackground2(data, hdc, 1, 1, ref rct);
rct = _tracker.Bounds;
Win32.DrawThemeBackground2(data, hdc, 4, 1 + (int) _tracker.State, ref rct);
Win32.CloseThemeData2(hdc);
e.Graphics.ReleaseHdc(hdc);
}
else {
ControlPaint.DrawBorder3D(e.Graphics,
_tracker.Bounds.Width/2, this.Height/2 - 2,
this.Width - _tracker.Bounds.Width, 4,
Border3DStyle.SunkenOuter, Border3DSide.All);
ControlPaint.DrawButton(e.Graphics, _tracker.Bounds, ButtonState.Normal);
}
}
private IntPtr ReplacementWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
if (msg == Win32.WM_LBUTTONDOWN || msg == Win32.WM_LBUTTONDBLCLK)
{
Win32.POINT loc = new Win32.POINT();
loc.X = MousePosition.X;
loc.Y = MousePosition.Y;
Win32.ScreenToClient(DropDownHandle, ref loc);
Win32.RECT dropdown_rect = new Win32.RECT();
Win32.GetClientRect(DropDownHandle, out dropdown_rect);
if (dropdown_rect.Left <= loc.X && loc.X < dropdown_rect.Right && dropdown_rect.Top <= loc.Y && loc.Y < dropdown_rect.Bottom)
{
int index = (int)Win32.SendMessage(DropDownHandle, Win32.LB_ITEMFROMPOINT, IntPtr.Zero, (IntPtr)(loc.X + (loc.Y << 16)));
if (index >> 16 == 0)
{
if (IsItemNonSelectable(Items[index]))
{
return(IntPtr.Zero);
}
}
}
}
return(Win32.CallWindowProc(oldWndProc, hWnd, msg, wParam, lParam));
}
private Size GetToolTipWindowSize(string contentSpacing)
{
Win32.TOOLINFO ti = new Win32.TOOLINFO();
ti.cbSize = Marshal.SizeOf(ti);
ti.uFlags = Win32.TTF_TRACK;
ti.lpszText = contentSpacing;
if (0 == Win32.SendMessage(Handle, Win32.TTM_ADDTOOL, 0, ref ti))
{
throw new Exception();
}
// enable multi-line text-layout
Win32.SendMessage(Handle, Win32.TTM_SETMAXTIPWIDTH, 0, SystemInformation.MaxWindowTrackSize.Width);
Win32.SendMessage(Handle, Win32.TTM_TRACKACTIVATE, 1, ref ti);
Win32.RECT rect = new Win32.RECT();
Win32.GetWindowRect(Handle, ref rect);
Win32.SendMessage(Handle, Win32.TTM_TRACKACTIVATE, 0, ref ti);
Win32.SendMessage(Handle, Win32.TTM_DELTOOL, 0, ref ti);
return(new Size(rect.right - rect.left, rect.bottom - rect.top));
}
void adjust_maximized_client_rect(IntPtr window, Win32.RECT rect)
{
if (!maximized(window))
{
return;
}
IntPtr monitor = Win32.MonitorFromWindow(window, Win32.MONITOR_DEFAULTTONULL);
if (monitor == IntPtr.Zero)
{
return;
}
Win32.MONITORINFOEX monitor_info = new Win32.MONITORINFOEX();
if (!Win32.GetMonitorInfo(monitor, ref monitor_info))
{
return;
}
// when maximized, make the client area fill just the monitor (without task bar) rect,
// not the whole window rect which extends beyond the monitor.
rect = monitor_info.WorkArea;
}
public static extern IntPtr CreateRectRgnIndirect(ref Win32.RECT rect);
// draws all elements
protected override void OnPaint(PaintEventArgs e)
{
e.Graphics.Clear(SystemColors.Control);
if (this.Height < 24 || this.Width < 24)
{
return;
}
IntPtr data = Win32.OpenThemeData2(this.Handle, "Combobox");
if (data != IntPtr.Zero) //draw with winxp themes
{
IntPtr hdc = e.Graphics.GetHdc();
#region background, dropdown button
Win32.RECT rct = new Win32.RECT(0, 0, this.Width, 22);
Win32.DrawThemeBackground2(data, hdc, 0, _mouseentered ? 2 : 1, ref rct);
rct.Left = rct.Right - 15;
rct.Top += 2;
rct.Bottom -= 2;
rct.Right -= 2;
Win32.DrawThemeBackground2(data, hdc, 1, (int)_elements[0].State, ref rct);
Win32.CloseThemeData2(data);
#endregion
#region spin buttons
data = Win32.OpenThemeData2(this.Handle, "Spin");
if (data == IntPtr.Zero)
{
goto final;
}
rct.Left -= 13;
rct.Width = 13;
rct.Top--;
rct.Height = 10;
Win32.DrawThemeBackground2(data, hdc, 1, (int)_elements[1].State, ref rct);
rct.Top += 10;
rct.Bottom += 10;
Win32.DrawThemeBackground2(data, hdc, 2, (int)_elements[2].State, ref rct);
Win32.CloseThemeData2(data);
#endregion
#region progress bar
data = Win32.OpenThemeData2(this.Handle, "Progress");
if (data == IntPtr.Zero)
{
goto final;
}
rct.Bottom = this.Height;
rct.Top = rct.Bottom - 3;
rct.Left = 0;
rct.Right = GetPercentage(this.Width);
Win32.DrawThemeBackground2(data, hdc, 3, 1, ref rct);
Win32.CloseThemeData2(data);
#endregion
final:
e.Graphics.ReleaseHdc(hdc);
}
else //draw without winxp themes
{
#region background, dropdown button
Rectangle rct = new Rectangle(0, 0, this.Width, 22);
e.Graphics.FillRectangle(Brushes.White, rct);
e.Graphics.DrawRectangle(_mouseentered ? SystemPens.Highlight : SystemPens.ControlDark,
rct.X, rct.Y, rct.Width - 1, rct.Height - 1);
rct.X = this.Width - 15;
rct.Y = 1;
rct.Height -= 2;
rct.Width = 15;
ControlPaint.DrawComboButton(e.Graphics, rct, _elements[0].ToButtonState());
#endregion
#region spin button
rct.X -= 13;
rct.Width = 13;
rct.Height = 10;
ControlPaint.DrawScrollButton(e.Graphics, rct, ScrollButton.Up, _elements[1].ToButtonState());
rct.Y += 10;
ControlPaint.DrawScrollButton(e.Graphics, rct, ScrollButton.Down, _elements[2].ToButtonState());
#endregion
#region progress bar
rct.Y = this.Height - 3;
rct.Height = 3;
rct.X = 0;
rct.Width = GetPercentage(this.Width);
e.Graphics.FillRectangle(SystemBrushes.Highlight, rct);
#endregion
}
}
void SetParent(IntPtr hWnd)
{
Win32.RECT rc = new Win32.RECT();
Win32.User.GetWindowRect(hWnd, ref rc);
this.Width = rc.Right-rc.Left;
this.Height = rc.Bottom-rc.Top;
//int style=Win32.User.GetWindowLong(this.Handle, Win32.User.GWL_STYLE);
Win32.User.SetParent(this.Handle, hWnd);
Win32.User.SetWindowLong(this.Handle, Win32.User.GWL_STYLE, Win32.User.WS_VISIBLE | Win32.User.WS_CHILDWINDOW);
Win32.User.SetWindowPos(this.Handle, IntPtr.Zero, 0, 0, this.Width, this.Height, 0/*Win32.User.SWP_NOMOVE | Win32.User.SWP_NOSIZE*/);
}
protected static IntPtr CreateRectangleRegion(Rectangle rect, int indent)
{
Win32.RECT newWinRect = new Win32.RECT();
newWinRect.left = rect.Left;
newWinRect.top = rect.Top;
newWinRect.right = rect.Right;
newWinRect.bottom = rect.Bottom;
// Create region for whole of the new rectangle
IntPtr newOuter = Gdi32.CreateRectRgnIndirect(ref newWinRect);
// If the rectangle is to small to make an inner object from, then just use the outer
if ((indent <= 0) || (rect.Width <= indent) || (rect.Height <= indent))
return newOuter;
newWinRect.left += indent;
newWinRect.top += indent;
newWinRect.right -= indent;
newWinRect.bottom -= indent;
// Create region for the unwanted inside of the new rectangle
IntPtr newInner = Gdi32.CreateRectRgnIndirect(ref newWinRect);
Win32.RECT emptyWinRect = new Win32.RECT();
emptyWinRect.left = 0;
emptyWinRect.top = 0;
emptyWinRect.right = 0;
emptyWinRect.bottom = 0;
// Create a destination region
IntPtr newRegion = Gdi32.CreateRectRgnIndirect(ref emptyWinRect);
// Remove the intersection of the outer and inner
Gdi32.CombineRgn(newRegion, newOuter, newInner, (int)Win32.CombineFlags.RGN_XOR);
// Remove unwanted intermediate objects
Gdi32.DeleteObject(newOuter);
Gdi32.DeleteObject(newInner);
// Return the resultant region object
return newRegion;
}
/// <summary>
/// invalidates the titlebar
/// </summary>
public void InvalidateTitleBar()
{
Win32.RECT rct = new Win32.RECT(0, -HeaderHeight, this.Width, HeaderHeight);
Win32.RedrawWindow(this.Handle, ref rct, IntPtr.Zero, Win32.RDW_FRAME | 0x85);
}
/// <summary>
/// Highlights the designated window by drawing a rectangle around
/// it, just like Microsoft Spy++.
/// </summary>
///
/// <param name="hWnd">
/// Handle to the object to be highlighted.
/// </param>
///
/// <param name="useNativeHighlighter">
/// If true, the rectangle will be drawn using the native PatBlt
/// function.
/// </param>
public static void Highlight(IntPtr hWnd, bool useNativeHighlighter)
{
var rect = new Win32.RECT();
var hDC = Win32.GetWindowDC(hWnd);
if (hWnd == IntPtr.Zero || !Win32.IsWindow(hWnd))
{
return;
}
Win32.GetWindowRect(hWnd, out rect);
Win32.OffsetRect(ref rect, -rect.left, -rect.top);
// The thickness of the frame
const int width = 3;
if (hDC == IntPtr.Zero)
{
return;
}
if (!Win32.IsRectEmpty(ref rect))
{
if (useNativeHighlighter)
{
// Top side
Win32.PatBlt(hDC,
rect.left,
rect.top,
rect.right - rect.left,
width,
Win32.RasterOperations.PATINVERT);
// Left side
Win32.PatBlt(hDC,
rect.left,
rect.bottom - width,
width,
-(rect.bottom - rect.top - 2 * width),
Win32.RasterOperations.PATINVERT);
// Right side
Win32.PatBlt(hDC,
rect.right - width,
rect.top + width,
width,
rect.bottom - rect.top - 2 * width,
Win32.RasterOperations.PATINVERT);
// Bottom side
Win32.PatBlt(hDC,
rect.right,
rect.bottom - width,
-(rect.right - rect.left),
width,
Win32.RasterOperations.PATINVERT);
}
else
{
// Simple GDI+ rectangle drawing
using (var pen = new Pen(ColorTranslator.FromHtml("#FF0000"), 4F))
{
using (var g = Graphics.FromHdc(hDC))
g.DrawRectangle(pen, 0, 0, rect.right - rect.left,
rect.bottom - rect.top);
}
}
}
Win32.ReleaseDC(hWnd, hDC);
}
// draws all elements
protected override void OnPaint(PaintEventArgs e)
{
e.Graphics.Clear(SystemColors.Control);
if (this.Height < 24 || this.Width < 24) return;
IntPtr data = Win32.OpenThemeData2(this.Handle, "Combobox");
if (data != IntPtr.Zero) //draw with winxp themes
{
IntPtr hdc = e.Graphics.GetHdc();
#region background, dropdown button
Win32.RECT rct = new Win32.RECT(0, 0, this.Width, 22);
Win32.DrawThemeBackground2(data, hdc, 0, _mouseentered ? 2 : 1, ref rct);
rct.Left = rct.Right - 15;
rct.Top += 2;
rct.Bottom -= 2;
rct.Right -= 2;
Win32.DrawThemeBackground2(data, hdc, 1, (int) _elements[0].State, ref rct);
Win32.CloseThemeData2(data);
#endregion
#region spin buttons
data = Win32.OpenThemeData2(this.Handle, "Spin");
if (data == IntPtr.Zero)
goto final;
rct.Left -= 13;
rct.Width = 13;
rct.Top--;
rct.Height = 10;
Win32.DrawThemeBackground2(data, hdc, 1, (int) _elements[1].State, ref rct);
rct.Top += 10;
rct.Bottom += 10;
Win32.DrawThemeBackground2(data, hdc, 2, (int) _elements[2].State, ref rct);
Win32.CloseThemeData2(data);
#endregion
#region progress bar
data = Win32.OpenThemeData2(this.Handle, "Progress");
if (data == IntPtr.Zero)
goto final;
rct.Bottom = this.Height;
rct.Top = rct.Bottom - 3;
rct.Left = 0;
rct.Right = GetPercentage(this.Width);
Win32.DrawThemeBackground2(data, hdc, 3, 1, ref rct);
Win32.CloseThemeData2(data);
#endregion
final:
e.Graphics.ReleaseHdc(hdc);
}
else //draw without winxp themes
{
#region background, dropdown button
Rectangle rct = new Rectangle(0, 0, this.Width, 22);
e.Graphics.FillRectangle(Brushes.White, rct);
e.Graphics.DrawRectangle(_mouseentered ? SystemPens.Highlight : SystemPens.ControlDark,
rct.X, rct.Y, rct.Width - 1, rct.Height - 1);
rct.X = this.Width - 15;
rct.Y = 1;
rct.Height -= 2;
rct.Width = 15;
ControlPaint.DrawComboButton(e.Graphics, rct, _elements[0].ToButtonState());
#endregion
#region spin button
rct.X -= 13;
rct.Width = 13;
rct.Height = 10;
ControlPaint.DrawScrollButton(e.Graphics, rct, ScrollButton.Up, _elements[1].ToButtonState());
rct.Y += 10;
ControlPaint.DrawScrollButton(e.Graphics, rct, ScrollButton.Down, _elements[2].ToButtonState());
#endregion
#region progress bar
rct.Y = this.Height - 3;
rct.Height = 3;
rct.X = 0;
rct.Width = GetPercentage(this.Width);
e.Graphics.FillRectangle(SystemBrushes.Highlight, rct);
#endregion
}
}
protected void RegenerateExpansion()
{
// Remove all existing draw commands
_drawCommands.Clear();
// Move into the expanded mode
_showInfrequent = true;
// Show we remember the expansion to the collection?
if (_rememberExpansion)
_menuCommands.ShowInfrequent = true;
// Generate new ones
Size newSize = GenerateDrawPositions();
// Find the new screen location for the window
Point newPos = CorrectPositionForScreen(newSize);
// Remember the correct screen drawing details
_currentPoint = newPos;
_currentSize = newSize;
// Update the window clipping region
if (!_layered)
{
SetWindowRegion(newSize);
// Alter size and location of window
User32.MoveWindow(this.Handle, newPos.X, newPos.Y, newSize.Width, newSize.Height, true);
Win32.RECT clientRect = new Win32.RECT();
clientRect.left = 0;
clientRect.top = 0;
clientRect.right = newSize.Width;
clientRect.bottom = newSize.Height;
// Get the client area redrawn after MoveWindow has been processed
User32.InvalidateRect(this.Handle, ref clientRect, true);
}
else
{
// Update the image for display
UpdateLayeredWindow();
// Lets repaint everything
RefreshAllCommands();
}
}
public static extern int ScrollWindowEx(IntPtr hWnd, int dx, int dy, ref Win32.RECT prcScroll, ref Win32.RECT prcClip, IntPtr hrgnUpdate, ref Win32.RECT prcUpdate, uint flags);
public static extern bool ValidateRect(IntPtr hWnd, ref Win32.RECT lpRect);
/// <summary>
/// invalidates the titlebar
/// </summary>
public void InvalidateTitleBar()
{
Win32.RECT rct = new Win32.RECT(0, -HeaderHeight, this.Width, HeaderHeight);
Win32.RedrawWindow(this.Handle,ref rct,IntPtr.Zero,Win32.RDW_FRAME|0x85);
}
/// <summary>
/// Erase the trail of the gesture and stop drawing
/// </summary>
public void RefreshAndStopDrawing()
{
// the drawing of gestures was finished
m_gestureDrawing = false;
// drawing in thread timer tick should not continue
m_drawingEnded = true;
// stop the thread timer
m_threadTimerDraw.Change(-1, -1);
if (!m_threadDrawing)
{
int lastIndex = m_curvePoints.Count;
PointF[] points = m_curvePoints.GetRange(m_lastIndex, lastIndex - m_lastIndex).ToArray();
m_lastIndex = lastIndex - 1;
if (points.Length > 1)
m_gp.DrawLines(m_pen, points);
}
List<PointF> allPoints = new List<PointF>(m_curvePoints.ToArray());
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
path.AddLines(allPoints.ToArray());
RectangleF rect = path.GetBounds();
int rectShift = m_penWidth * 6;
rect.X -= rectShift;
rect.Y -= rectShift;
rect.Width += rectShift * 2;
rect.Height += rectShift * 2;
//Win32.RECT r = new Win32.RECT(rect);
m_drawnRegion = new Win32.RECT(rect);
//Rectangle r = new Rectangle((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height);
if (!m_threadDrawing)
{
Debug.WriteLine(String.Format("##### InvalidateRect in MOUSE UP left: {0}, top: {1}, right: {2}, bottom: {3} ######",
m_drawnRegion.left, m_drawnRegion.top, m_drawnRegion.right, m_drawnRegion.bottom));
//Win32.InvalidateRect(m_hwndForm, ref m_drawnRegion, true);
Win32.RedrawWindow(m_hwndForm, ref m_drawnRegion, IntPtr.Zero, Win32.RDW_ERASE | Win32.RDW_INVALIDATE | Win32.RDW_UPDATENOW);
MakeNonTopMost();
}
else
m_redrawInTick = true;
//this.Invalidate(r);
//Win32.RedrawWindow(m_hwndForm, ref r, IntPtr.Zero, 0x2);
}
protected PopupMenu WantMouseMessage(Win32.POINT screenPos)
{
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the window
User32.GetWindowRect(this.Handle, ref rectRaw);
if ((screenPos.x >= rectRaw.left) && (screenPos.x <= rectRaw.right) &&
(screenPos.y >= rectRaw.top) && (screenPos.y <= rectRaw.bottom))
return this;
if (_parentMenu != null)
return _parentMenu.WantMouseMessage(screenPos);
return null;
}
/// <summary>
/// Get state according to fullscreen option
/// </summary>
/// <param name="wndHandle"></param>
/// <returns></returns>
public bool GetFullScreenState(bool currentState, IntPtr wndHandle)
{
bool enabled = currentState;
System.Drawing.Rectangle screen = System.Windows.Forms.Screen.FromHandle(wndHandle).Bounds;
Win32.RECT screenSize = new Win32.RECT(screen);
Win32.WINDOWINFO info = new Win32.WINDOWINFO();
Win32.GetWindowInfo(wndHandle, ref info);
//Debug.WriteLine(string.Format("Wnd left: {0}, top: {1}, right: {2}, bottom: {3}",
// info.rcWindow.left, info.rcWindow.top, info.rcWindow.right, info.rcWindow.bottom));
if (info.rcWindow.Equals(screenSize))
{
switch (Config.User.StateFullScreen)
{
case 1: enabled = true; break;
case 2: enabled = false; break;
}
}
else
{
switch (Config.User.StateFullScreen)
{
case 1: enabled = false; break;
case 2: enabled = true; break;
}
}
return enabled;
}
public static bool GetRect(this IntPtr window, out Win32.RECT rect) => Win32.GetWindowRect(window, out rect);
internal void Render(IntPtr hdc, RenderProfile prof, Color baseBackColor, int x, int y) {
if (_text.Length == 0 || _text[0] == '\0')
return; //何も描かなくてよい。これはよくあるケース
float fx0 = (float)x;
float fx1 = fx0;
int y1 = y;
int y2 = y1 + (int)prof.Pitch.Height;
float pitch = prof.Pitch.Width;
int defaultBackColorArgb = baseBackColor.ToArgb();
Win32.SetBkMode(hdc, Win32.TRANSPARENT);
GWord word = _firstWord;
while (word != null) {
TextDecoration dec = word.Decoration;
IntPtr hFont = prof.CalcHFONT_NoUnderline(dec, word.CharGroup);
Win32.SelectObject(hdc, hFont);
uint foreColorRef = DrawUtil.ToCOLORREF(prof.CalcTextColor(dec));
Win32.SetTextColor(hdc, foreColorRef);
Color bkColor = prof.CalcBackColor(dec);
bool isOpaque = (bkColor.ToArgb() != defaultBackColorArgb);
if (isOpaque) {
uint bkColorRef = DrawUtil.ToCOLORREF(bkColor);
Win32.SetBkColor(hdc, bkColorRef);
}
int nextOffset = GetNextOffset(word);
float fx2 = fx0 + pitch * nextOffset;
if (prof.CalcBold(dec) || CharGroupUtil.IsCJK(word.CharGroup)) {
// It is not always true that width of a character in the CJK font is twice of a character in the ASCII font.
// Characters are drawn one by one to adjust pitch.
int step = CharGroupUtil.GetColumnsPerCharacter(word.CharGroup);
float charPitch = pitch * step;
int offset = word.Offset;
float fx = fx1;
if (isOpaque) {
// If background fill is required, we call ExtTextOut() with ETO_OPAQUE to draw the first character.
if (offset < nextOffset) {
Win32.RECT rect = new Win32.RECT((int)fx1, y1, (int)fx2, y2);
char ch = _text[offset];
Debug.Assert(ch != GLine.WIDECHAR_PAD);
unsafe {
Win32.ExtTextOut(hdc, rect.left, rect.top, Win32.ETO_OPAQUE, &rect, &ch, 1, null);
}
}
offset += step;
fx += charPitch;
}
for (; offset < nextOffset; offset += step) {
char ch = _text[offset];
Debug.Assert(ch != GLine.WIDECHAR_PAD);
unsafe {
Win32.ExtTextOut(hdc, (int)fx, y1, 0, null, &ch, 1, null);
}
fx += charPitch;
}
}
else {
int offset = word.Offset;
int displayLength = nextOffset - offset;
if (isOpaque) {
Win32.RECT rect = new Win32.RECT((int)fx1, y1, (int)fx2, y2);
unsafe {
fixed (char* p = &_text[offset]) {
Win32.ExtTextOut(hdc, rect.left, rect.top, Win32.ETO_OPAQUE, &rect, p, displayLength, null);
}
}
}
else {
unsafe {
fixed (char* p = &_text[offset]) {
Win32.ExtTextOut(hdc, (int)fx1, y1, 0, null, p, displayLength, null);
}
}
}
}
if (dec.Underline)
DrawUnderline(hdc, foreColorRef, (int)fx1, y2 - 1, (int)fx2 - (int)fx1);
fx1 = fx2;
word = word.Next;
}
}
protected bool ParentControlWantsMouseMessage(Win32.POINT screenPos, ref Win32.MSG msg)
{
// Special case the MOUSEMOVE so if we are part of a MenuControl
// then we should let the MenuControl process that message
if ((msg.message == (int)Win32.Msgs.WM_MOUSEMOVE) && (_parentControl != null))
{
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the parent control
User32.GetWindowRect(_parentControl.Handle, ref rectRaw);
if ((screenPos.x >= rectRaw.left) && (screenPos.x <= rectRaw.right) &&
(screenPos.y >= rectRaw.top) && (screenPos.y <= rectRaw.bottom))
return true;
}
return false;
}
protected void OnWM_PAINT(ref Message m)
{
Win32.PAINTSTRUCT ps = new Win32.PAINTSTRUCT();
// Have to call BeginPaint whenever processing a WM_PAINT message
IntPtr hDC = User32.BeginPaint(m.HWnd, ref ps);
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the window
User32.GetWindowRect(this.Handle, ref rectRaw);
// Convert to a client size rectangle
Rectangle rectWin = new Rectangle(0, 0,
rectRaw.right - rectRaw.left,
rectRaw.bottom - rectRaw.top);
// Create a graphics object for drawing
using(Graphics g = Graphics.FromHdc(hDC))
{
// Create bitmap for drawing onto
Bitmap memoryBitmap = new Bitmap(rectWin.Width, rectWin.Height);
using(Graphics h = Graphics.FromImage(memoryBitmap))
{
// Draw the background area
DrawBackground(h, rectWin);
// Draw the actual menu items
DrawAllCommands(h);
}
// Blit bitmap onto the screen
g.DrawImageUnscaled(memoryBitmap, 0, 0);
}
// Don't forget to end the paint operation!
User32.EndPaint(m.HWnd, ref ps);
}
public override void Render(AnnContainerMapper mapper, AnnObject annObject)
{
if (mapper == null)
{
ExceptionHelper.ArgumentNullException("mapper");
}
if (annObject == null)
{
ExceptionHelper.ArgumentNullException("annObject");
}
base.Render(mapper, annObject);
AnnRichTextObject annRichTextObject = annObject as AnnRichTextObject;
if (annRichTextObject != null && !String.IsNullOrEmpty(annRichTextObject.Rtf))
{
AnnWinFormsRenderingEngine engine = RenderingEngine as AnnWinFormsRenderingEngine;
if (engine != null && engine.Context != null)
{
AnnRectangleObject tempRect = new AnnRectangleObject();
tempRect.Points.Clear();
foreach (LeadPointD pt in GetRenderPoints(mapper, annRichTextObject))
{
tempRect.Points.Add(pt);
}
double rotation = tempRect.Angle;
if (rotation == 180)
{
rotation = 0;
}
LeadRectD boundsPixels = tempRect.Rect.Clone();
AnnContainerMapper identityMapper = mapper.Clone();
identityMapper.UpdateTransform(LeadMatrix.Identity);
identityMapper.MapResolutions(mapper.SourceDpiX, mapper.SourceDpiY, mapper.SourceDpiX, mapper.SourceDpiY);
boundsPixels = identityMapper.RectFromContainerCoordinates(boundsPixels, annRichTextObject.FixedStateOperations);
if (tempRect.Stroke != null)
{
boundsPixels.Inflate(-tempRect.Stroke.StrokeThickness.Value, -tempRect.Stroke.StrokeThickness.Value);
}
string rtf = annRichTextObject.Rtf;
IntPtr hemfDC;
if (_richTextBox == null)
{
_richTextBox = new InternalRichTextEdit();
}
try
{
_richTextBox.Rtf = rtf;
}
catch
{
using (RichTextBox richTextBox = new RichTextBox())
{
richTextBox.Text = rtf;
annRichTextObject.Rtf = richTextBox.Rtf;
_richTextBox.Rtf = richTextBox.Rtf;
}
}
Graphics graphics = engine.Context;
double dpiX = 96;
double dpiY = 96;
_richTextBox.Location = new Point((int)boundsPixels.Location.X, (int)boundsPixels.Location.Y);
_richTextBox.Size = new Size((int)boundsPixels.Size.Width, (int)boundsPixels.Size.Height);
IntPtr hdc = graphics.GetHdc();
Win32.RECT rc = new Win32.RECT();
rc.left = _richTextBox.ClientRectangle.Left;
rc.top = _richTextBox.ClientRectangle.Top;
rc.right = (int)boundsPixels.Width;
rc.bottom = (int)boundsPixels.Height;
int iWidthMM = SafeNativeMethods.GetDeviceCaps(hdc, Win32.HORZSIZE);
int iHeightMM = SafeNativeMethods.GetDeviceCaps(hdc, Win32.VERTSIZE);
int iWidthPels = SafeNativeMethods.GetDeviceCaps(hdc, Win32.HORZRES);
int iHeightPels = SafeNativeMethods.GetDeviceCaps(hdc, Win32.VERTRES);
rc.left = (rc.left * iWidthMM * 100) / iWidthPels;
rc.top = (rc.top * iHeightMM * 100) / iHeightPels;
rc.right = (rc.right * iWidthMM * 100) / iWidthPels;
rc.bottom = (rc.bottom * iHeightMM * 100) / iHeightPels;
hemfDC = SafeNativeMethods.CreateEnhMetaFile(hdc, null, ref rc, null);
Win32.RECT emfRect = new Win32.RECT();
emfRect.right = (int)boundsPixels.Width;
emfRect.bottom = (int)boundsPixels.Height;
IntPtr brush = SafeNativeMethods.GetStockObject(5);
SafeNativeMethods.SetBkMode(hemfDC, 1);
SafeNativeMethods.FillRect(hemfDC, ref emfRect, brush);
SafeNativeMethods.DeleteObject(brush);
Print(_richTextBox, _richTextBox.ClientRectangle, hemfDC, (int)dpiX, (int)dpiY, false);
IntPtr hemf = SafeNativeMethods.CloseEnhMetaFile(hemfDC);
using (Metafile metaFile = new Metafile(hemf, true))
{
graphics.ReleaseHdc();
GraphicsState state = graphics.Save();
//the mapper transform dosent contain dpi effect so we will add dpi effect .
LeadMatrix matrix = mapper.Transform;
//add dpi effect to the transform
matrix.Scale((float)(mapper.TargetDpiX / mapper.SourceDpiX), (float)(mapper.TargetDpiY / mapper.SourceDpiY));
if ((annRichTextObject.FixedStateOperations & AnnFixedStateOperations.Scrolling) == AnnFixedStateOperations.Scrolling)
{
matrix.Translate(-matrix.OffsetX, -matrix.OffsetY);
}
if ((annRichTextObject.FixedStateOperations & AnnFixedStateOperations.Zooming) == AnnFixedStateOperations.Zooming)
{
double offsetX = matrix.OffsetX;
double offsetY = matrix.OffsetY;
double scaleX = 1.0;
double scaleY = 1.0;
if (matrix.M11 != 0 && matrix.M22 != 0)
{
scaleX = 1.0 / Math.Abs(matrix.M11);
scaleY = 1.0 / Math.Abs(matrix.M22);
}
matrix.Scale(scaleX, scaleY);
}
using (Matrix transform = new Matrix((float)matrix.M11, (float)matrix.M12, (float)matrix.M21, (float)matrix.M22, (float)matrix.OffsetX, (float)matrix.OffsetY))
{
graphics.MultiplyTransform(transform);
graphics.DrawImage(metaFile, new Point((int)boundsPixels.Left, (int)boundsPixels.Top));
}
graphics.Restore(state);
}
}
//EndDraw(graphics, gState);
}
}
public static int Height(this Win32.RECT rect) => rect.Bottom - rect.Top;
private bool CreateWindowPane(int x, int y, int w, int h, bool fs)
{
windowSize = new Vec2d(w, h);
windowPos = new Vec2d(x, y);
mWndProcDelegate = MyWndProc;
Win32.WNDCLASSEX wcex = new Win32.WNDCLASSEX
{
style = (int)Win32.ClassStyles.CS_DBLCLKS,
lpfnWndProc = Marshal.GetFunctionPointerForDelegate(mWndProcDelegate),
lpszClassName = CLASS_NAME,
cbSize = Marshal.SizeOf(typeof(Win32.WNDCLASSEX)),
cbClsExtra = 0,
cbWndExtra = 0,
hIcon = Win32.LoadIcon(IntPtr.Zero, (IntPtr)Win32.SystemIcons.IDI_APPLICATION),
hCursor = Win32.LoadCursor(IntPtr.Zero, (int)Win32.IDC_ARROW),
hIconSm = IntPtr.Zero,
hbrBackground = (IntPtr)(Win32.COLOR_WINDOW + 1),
lpszMenuName = null
};
ushort regReturn = Win32.RegisterClassEx(ref wcex);
if (regReturn == 0)
{
return(false);
}
uint dwExStyle = (uint)(Win32.WindowStylesEx.WS_EX_APPWINDOW | Win32.WindowStylesEx.WS_EX_WINDOWEDGE);
uint dwStyle = (uint)(Win32.WindowStyles.WS_CAPTION | Win32.WindowStyles.WS_SYSMENU | Win32.WindowStyles.WS_VISIBLE);
if (fs)
{
dwExStyle = 0;
dwStyle = (uint)(Win32.WindowStyles.WS_VISIBLE | Win32.WindowStyles.WS_POPUP);
IntPtr hmon = Win32.MonitorFromWindow(m_hWnd, Win32.MONITOR_DEFAULTTONEAREST);
Win32.MonitorInfoEx mon_info = new Win32.MonitorInfoEx();
mon_info.Size = (int)Marshal.SizeOf(mon_info);
if (!Win32.GetMonitorInfo(hmon, ref mon_info))
{
return(false);
}
windowSize = new Vec2d(mon_info.Monitor.Right, mon_info.Monitor.Bottom);
windowPos.X = 0;
windowPos.Y = 0;
}
Win32.RECT rWndRect = new Win32.RECT(0, 0, (int)windowSize.X, (int)windowSize.Y);
Win32.AdjustWindowRectEx(ref rWndRect, dwStyle, false, dwExStyle);
int width = rWndRect.Right - rWndRect.Left;
int height = rWndRect.Bottom - rWndRect.Top;
m_hWnd = Win32.CreateWindowEx(
dwExStyle,
regReturn,
Title,
dwStyle,
(int)windowPos.X,
(int)windowPos.Y,
width,
height,
IntPtr.Zero,
IntPtr.Zero,
wcex.hInstance,
IntPtr.Zero);
mapKeys[0x00] = KeyUtil.Key.NONE;
mapKeys[0x41] = KeyUtil.Key.A; mapKeys[0x42] = KeyUtil.Key.B; mapKeys[0x43] = KeyUtil.Key.C; mapKeys[0x44] = KeyUtil.Key.D; mapKeys[0x45] = KeyUtil.Key.E;
mapKeys[0x46] = KeyUtil.Key.F; mapKeys[0x47] = KeyUtil.Key.G; mapKeys[0x48] = KeyUtil.Key.H; mapKeys[0x49] = KeyUtil.Key.I; mapKeys[0x4A] = KeyUtil.Key.J;
mapKeys[0x4B] = KeyUtil.Key.K; mapKeys[0x4C] = KeyUtil.Key.L; mapKeys[0x4D] = KeyUtil.Key.M; mapKeys[0x4E] = KeyUtil.Key.N; mapKeys[0x4F] = KeyUtil.Key.O;
mapKeys[0x50] = KeyUtil.Key.P; mapKeys[0x51] = KeyUtil.Key.Q; mapKeys[0x52] = KeyUtil.Key.R; mapKeys[0x53] = KeyUtil.Key.S; mapKeys[0x54] = KeyUtil.Key.T;
mapKeys[0x55] = KeyUtil.Key.U; mapKeys[0x56] = KeyUtil.Key.V; mapKeys[0x57] = KeyUtil.Key.W; mapKeys[0x58] = KeyUtil.Key.X; mapKeys[0x59] = KeyUtil.Key.Y;
mapKeys[0x5A] = KeyUtil.Key.Z;
mapKeys[(int)Win32.VK.F1] = KeyUtil.Key.F1; mapKeys[(int)Win32.VK.F2] = KeyUtil.Key.F2; mapKeys[(int)Win32.VK.F3] = KeyUtil.Key.F3; mapKeys[(int)Win32.VK.F4] = KeyUtil.Key.F4;
mapKeys[(int)Win32.VK.F5] = KeyUtil.Key.F5; mapKeys[(int)Win32.VK.F6] = KeyUtil.Key.F6; mapKeys[(int)Win32.VK.F7] = KeyUtil.Key.F7; mapKeys[(int)Win32.VK.F8] = KeyUtil.Key.F8;
mapKeys[(int)Win32.VK.F9] = KeyUtil.Key.F9; mapKeys[(int)Win32.VK.F10] = KeyUtil.Key.F10; mapKeys[(int)Win32.VK.F11] = KeyUtil.Key.F11; mapKeys[(int)Win32.VK.F12] = KeyUtil.Key.F12;
mapKeys[(int)Win32.VK.DOWN] = KeyUtil.Key.DOWN; mapKeys[(int)Win32.VK.LEFT] = KeyUtil.Key.LEFT; mapKeys[(int)Win32.VK.RIGHT] = KeyUtil.Key.RIGHT; mapKeys[(int)Win32.VK.UP] = KeyUtil.Key.UP;
mapKeys[(int)Win32.VK.RETURN] = KeyUtil.Key.ENTER; //mapKeys[VK_RETURN] = KeyUtil.Key.RETURN;
mapKeys[(int)Win32.VK.BACK] = KeyUtil.Key.BACK; mapKeys[(int)Win32.VK.ESCAPE] = KeyUtil.Key.ESCAPE; mapKeys[(int)Win32.VK.RETURN] = KeyUtil.Key.ENTER; mapKeys[(int)Win32.VK.PAUSE] = KeyUtil.Key.PAUSE;
mapKeys[(int)Win32.VK.SCROLL] = KeyUtil.Key.SCROLL; mapKeys[(int)Win32.VK.TAB] = KeyUtil.Key.TAB; mapKeys[(int)Win32.VK.DELETE] = KeyUtil.Key.DEL; mapKeys[(int)Win32.VK.HOME] = KeyUtil.Key.HOME;
mapKeys[(int)Win32.VK.END] = KeyUtil.Key.END; mapKeys[(int)Win32.VK.PRIOR] = KeyUtil.Key.PGUP; mapKeys[(int)Win32.VK.NEXT] = KeyUtil.Key.PGDN; mapKeys[(int)Win32.VK.INSERT] = KeyUtil.Key.INS;
mapKeys[(int)Win32.VK.SHIFT] = KeyUtil.Key.SHIFT; mapKeys[(int)Win32.VK.CONTROL] = KeyUtil.Key.CTRL;
mapKeys[(int)Win32.VK.SPACE] = KeyUtil.Key.SPACE;
mapKeys[0x30] = KeyUtil.Key.K0; mapKeys[0x31] = KeyUtil.Key.K1; mapKeys[0x32] = KeyUtil.Key.K2; mapKeys[0x33] = KeyUtil.Key.K3; mapKeys[0x34] = KeyUtil.Key.K4;
mapKeys[0x35] = KeyUtil.Key.K5; mapKeys[0x36] = KeyUtil.Key.K6; mapKeys[0x37] = KeyUtil.Key.K7; mapKeys[0x38] = KeyUtil.Key.K8; mapKeys[0x39] = KeyUtil.Key.K9;
mapKeys[(int)Win32.VK.NUMPAD0] = KeyUtil.Key.NP0; mapKeys[(int)Win32.VK.NUMPAD1] = KeyUtil.Key.NP1; mapKeys[(int)Win32.VK.NUMPAD2] = KeyUtil.Key.NP2; mapKeys[(int)Win32.VK.NUMPAD3] = KeyUtil.Key.NP3; mapKeys[(int)Win32.VK.NUMPAD4] = KeyUtil.Key.NP4;
mapKeys[(int)Win32.VK.NUMPAD5] = KeyUtil.Key.NP5; mapKeys[(int)Win32.VK.NUMPAD6] = KeyUtil.Key.NP6; mapKeys[(int)Win32.VK.NUMPAD7] = KeyUtil.Key.NP7; mapKeys[(int)Win32.VK.NUMPAD8] = KeyUtil.Key.NP8; mapKeys[(int)Win32.VK.NUMPAD9] = KeyUtil.Key.NP9;
mapKeys[(int)Win32.VK.MULTIPLY] = KeyUtil.Key.NP_MUL; mapKeys[(int)Win32.VK.ADD] = KeyUtil.Key.NP_ADD; mapKeys[(int)Win32.VK.DIVIDE] = KeyUtil.Key.NP_DIV; mapKeys[(int)Win32.VK.SUBTRACT] = KeyUtil.Key.NP_SUB; mapKeys[(int)Win32.VK.DECIMAL] = KeyUtil.Key.NP_DECIMAL;
return(true);
}
/// <summary>
/// calculates the new clientsize
/// </summary>
protected virtual void OnCalcSize(ref Win32.RECT clientbounds)
{
clientbounds.Inflate(-1, -1);
clientbounds.Top += HeaderHeight - 1;
}
public void WndActivate(object sender, CbtEventArgs e)
{
IntPtr hMsgBox = e.wParam;
// try to find a howner for this message box
if (hOwner == IntPtr.Zero)
{
hOwner = Win32.Function.GetActiveWindow();
}
// get the MessageBox window rect
Win32.RECT rectDlg = new Win32.RECT();
Win32.Function.GetWindowRect(hMsgBox, ref rectDlg);
// get the owner window rect
Win32.RECT rectForm = new Win32.RECT();
Win32.Function.GetWindowRect(hOwner, ref rectForm);
// get the biggest screen area
Rectangle rectScreen = TrueScreenRect;
// if no parent window, center on the primary screen
if (rectForm.right == rectForm.left)
{
rectForm.right = rectForm.left = Screen.PrimaryScreen.WorkingArea.Width / 2;
}
if (rectForm.bottom == rectForm.top)
{
rectForm.bottom = rectForm.top = Screen.PrimaryScreen.WorkingArea.Height / 2;
}
// center on parent
int dx = ((rectDlg.left + rectDlg.right) - (rectForm.left + rectForm.right)) / 2;
int dy = ((rectDlg.top + rectDlg.bottom) - (rectForm.top + rectForm.bottom)) / 2;
rect = new Rectangle(
rectDlg.left - dx,
rectDlg.top - dy,
rectDlg.right - rectDlg.left,
rectDlg.bottom - rectDlg.top);
// place in the screen
if (rect.Right > rectScreen.Right)
{
rect.Offset(rectScreen.Right - rect.Right, 0);
}
if (rect.Bottom > rectScreen.Bottom)
{
rect.Offset(0, rectScreen.Bottom - rect.Bottom);
}
if (rect.Left < rectScreen.Left)
{
rect.Offset(rectScreen.Left - rect.Left, 0);
}
if (rect.Top < rectScreen.Top)
{
rect.Offset(0, rectScreen.Top - rect.Top);
}
if (e.IsDialog)
{
// do the job when the WM_INITDIALOG message returns
wndProcRetHook = new WndProcRetHook(hMsgBox);
wndProcRetHook.WndProcRet += new WndProcRetHook.WndProcEventHandler(WndProcRet);
wndProcRetHook.Install();
}
else
{
Win32.Function.MoveWindow(hMsgBox, rect.Left, rect.Top, rect.Width, rect.Height, 1);
}
// uninstall this hook
WindowsHook wndHook = (WindowsHook)sender;
Debug.Assert(cbtHook == wndHook);
cbtHook.Uninstall();
cbtHook = null;
}
internal void Render(IntPtr hdc, RenderProfile prof, Color baseBackColor, int x, int y)
{
if (_text.Length == 0 || _text[0] == '\0')
{
return; //何も描かなくてよい。これはよくあるケース
}
float fx0 = (float)x;
float fx1 = fx0;
int y1 = y;
int y2 = y1 + (int)prof.Pitch.Height;
float pitch = prof.Pitch.Width;
int defaultBackColorArgb = baseBackColor.ToArgb();
Win32.SetBkMode(hdc, Win32.TRANSPARENT);
GWord word = _firstWord;
while (word != null)
{
TextDecoration dec = word.Decoration;
IntPtr hFont = prof.CalcHFONT_NoUnderline(dec, word.CharGroup);
Win32.SelectObject(hdc, hFont);
uint foreColorRef = DrawUtil.ToCOLORREF(prof.CalcTextColor(dec));
Win32.SetTextColor(hdc, foreColorRef);
Color bkColor = prof.CalcBackColor(dec);
bool isOpaque = (bkColor.ToArgb() != defaultBackColorArgb);
if (isOpaque)
{
uint bkColorRef = DrawUtil.ToCOLORREF(bkColor);
Win32.SetBkColor(hdc, bkColorRef);
}
int nextOffset = GetNextOffset(word);
float fx2 = fx0 + pitch * nextOffset;
if (prof.CalcBold(dec) || CharGroupUtil.IsCJK(word.CharGroup))
{
// It is not always true that width of a character in the CJK font is twice of a character in the ASCII font.
// Characters are drawn one by one to adjust pitch.
int step = CharGroupUtil.GetColumnsPerCharacter(word.CharGroup);
float charPitch = pitch * step;
int offset = word.Offset;
float fx = fx1;
if (isOpaque)
{
// If background fill is required, we call ExtTextOut() with ETO_OPAQUE to draw the first character.
if (offset < nextOffset)
{
Win32.RECT rect = new Win32.RECT((int)fx1, y1, (int)fx2, y2);
char ch = _text[offset];
Debug.Assert(ch != GLine.WIDECHAR_PAD);
unsafe {
Win32.ExtTextOut(hdc, rect.left, rect.top, Win32.ETO_OPAQUE, &rect, &ch, 1, null);
}
}
offset += step;
fx += charPitch;
}
for (; offset < nextOffset; offset += step)
{
char ch = _text[offset];
Debug.Assert(ch != GLine.WIDECHAR_PAD);
unsafe {
Win32.ExtTextOut(hdc, (int)fx, y1, 0, null, &ch, 1, null);
}
fx += charPitch;
}
}
else
{
int offset = word.Offset;
int displayLength = nextOffset - offset;
if (isOpaque)
{
Win32.RECT rect = new Win32.RECT((int)fx1, y1, (int)fx2, y2);
unsafe
{
fixed(char *p = &_text[offset])
{
Win32.ExtTextOut(hdc, rect.left, rect.top, Win32.ETO_OPAQUE, &rect, p, displayLength, null);
}
}
}
else
{
unsafe
{
fixed(char *p = &_text[offset])
{
Win32.ExtTextOut(hdc, (int)fx1, y1, 0, null, p, displayLength, null);
}
}
}
}
if (dec.Underline)
{
DrawUnderline(hdc, foreColorRef, (int)fx1, y2 - 1, (int)fx2 - (int)fx1);
}
fx1 = fx2;
word = word.Next;
}
}
protected override void DoPaint(HCStyle aStyle, Win32.RECT aDrawRect, int aDataDrawTop, int aDataDrawBottom, int aDataScreenTop, int aDataScreenBottom, HCCanvas aCanvas, PaintInfo aPaintInfo)
{
base.DoPaint(aStyle, aDrawRect, aDataDrawTop, aDataDrawBottom, aDataScreenTop, aDataScreenBottom, aCanvas, aPaintInfo);
}
public static void DrawDragRectangles(Rectangle[] newRects, int indent)
{
if (newRects.Length > 0)
{
// Create the first region
IntPtr newRegion = CreateRectangleRegion(newRects[0], indent);
for(int index=1; index<newRects.Length; index++)
{
// Create the extra region
IntPtr extraRegion = CreateRectangleRegion(newRects[index], indent);
// Remove the intersection of the existing and extra regions
Gdi32.CombineRgn(newRegion, newRegion, extraRegion, (int)Win32.CombineFlags.RGN_XOR);
// Remove unwanted intermediate objects
Gdi32.DeleteObject(extraRegion);
}
// Get hold of the DC for the desktop
IntPtr hDC = User32.GetDC(IntPtr.Zero);
// Define the area we are allowed to draw into
Gdi32.SelectClipRgn(hDC, newRegion);
Win32.RECT rectBox = new Win32.RECT();
// Get the smallest rectangle that encloses region
Gdi32.GetClipBox(hDC, ref rectBox);
IntPtr brushHandler = GetHalfToneBrush();
// Select brush into the device context
IntPtr oldHandle = Gdi32.SelectObject(hDC, brushHandler);
// Blit to screen using provided pattern brush and invert with existing screen contents
Gdi32.PatBlt(hDC,
rectBox.left,
rectBox.top,
rectBox.right - rectBox.left,
rectBox.bottom - rectBox.top,
(uint)RasterOperations.PATINVERT);
// Put old handle back again
Gdi32.SelectObject(hDC, oldHandle);
// Reset the clipping region
Gdi32.SelectClipRgn(hDC, IntPtr.Zero);
// Remove unwanted region object
Gdi32.DeleteObject(newRegion);
// Must remember to release the HDC resource!
User32.ReleaseDC(IntPtr.Zero, hDC);
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
// Get window area
Win32.RECT rc = new Win32.RECT();
WindowsAPI.GetWindowRect(Handle, ref rc);
// Convert to a client size rectangle
Rectangle rect = new Rectangle(0, 0, rc.right - rc.left, rc.bottom - rc.top);
Graphics g = e.Graphics;
DrawBackground(g, rect);
DrawBorder(g, rect);
DrawForeground(g, rect);
}
private void DrawStringByOneChar2(IntPtr hdc, GWord word, int display_length, IntPtr bkbrush, float fx, int y, RenderProfile prof)
{
float pitch = prof.Pitch.Width;
int nextoffset = WordNextOffset(word);
if(bkbrush!=IntPtr.Zero) { //���ꂪ�Ȃ��Ɠ��{�ꕶ���s�b�`���������Ƃ��I����̂����܂��ł���ꍇ������
Win32.RECT rect = new Win32.RECT();
rect.left = (int)fx;
rect.top = y;
rect.right = (int)(fx + pitch*display_length);
rect.bottom = y + (int)prof.Pitch.Height;
Win32.FillRect(hdc, ref rect, bkbrush);
}
for(int i=word.Offset; i<nextoffset; i++) {
char ch = _text[i];
if(ch=='\0') break;
if(ch==GLine.WIDECHAR_PAD) continue;
unsafe {
Win32.TextOut(hdc, (int)fx, y, &ch, 1);
}
fx += pitch * CalcDisplayLength(ch);
}
}
public static extern int DrawThemeBackground(IntPtr hTheme,
IntPtr hDC,
int partId,
int stateId,
ref Win32.RECT rect,
IntPtr clip);
public static extern int GetClipBox(IntPtr hDC, ref Win32.RECT rectBox);
private IntPtr HookProc(IntPtr hdlg, int msg, IntPtr wParam, IntPtr lParam)
{
switch (msg)
{
case Win32.WM_INITDIALOG:
// Center the dialog on its owner
Win32.RECT sr = new Win32.RECT();
Win32.RECT cr = new Win32.RECT();
IntPtr parent = Win32.GetParent(hdlg);
Win32.GetWindowRect(parent, ref cr);
Win32.GetWindowRect(Owner.Handle, ref sr);
int x = (sr.Right + sr.Left - (cr.Right - cr.Left)) / 2;
int y = (sr.Bottom + sr.Top - (cr.Bottom - cr.Top)) / 2;
Win32.SetWindowPos(parent, IntPtr.Zero, x, y, cr.Right - cr.Left, cr.Bottom - cr.Top + 32, Win32.SWP_NOZORDER);
IntPtr fileTypeWindow = Win32.GetDlgItem(parent, 0x441);
IntPtr fontHandle = Win32.SendMessage(fileTypeWindow, Win32.WM_GETFONT, IntPtr.Zero, IntPtr.Zero);
//we now need to find the combo-box to position the new tick box under
IntPtr fileComboWindow = Win32.GetDlgItem(parent, 0x470);
Win32.RECT aboveRect = new Win32.RECT();
Win32.GetWindowRect(fileComboWindow, ref aboveRect);
Win32.POINT point = new Win32.POINT();
point.X = aboveRect.Left;
point.Y = aboveRect.Bottom;
Win32.ScreenToClient(parent, ref point);
Win32.POINT rightPoint = new Win32.POINT();
rightPoint.X = aboveRect.Right;
rightPoint.Y = aboveRect.Top;
Win32.ScreenToClient(parent, ref rightPoint);
//we create the new combobox
IntPtr comboHandle = Win32.CreateWindowEx(0, "BUTTON", "", Win32.WS_VISIBLE | Win32.WS_CHILD | Win32.WS_TABSTOP | Win32.BS_AUTOCHECKBOX, point.X, point.Y + 8, rightPoint.X - point.X, 16, parent, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
fontHandle = Win32.SendMessage(fileTypeWindow, Win32.WM_GETFONT, IntPtr.Zero, IntPtr.Zero);
Win32.SendMessage(comboHandle, Win32.WM_SETFONT, fontHandle, IntPtr.Zero);
Win32.SendMessage(comboHandle, Win32.WM_SETTEXT, IntPtr.Zero, Messages.EXPORT_VM_VERIFY_POST_INSTALL);
Win32.SendMessage(comboHandle, Win32.BM_SETCHECK, (IntPtr)(Verify ? Win32.BST_CHECKED : Win32.BST_UNCHECKED), IntPtr.Zero);
//remember the handles of the controls we have created so we can destroy them after
ComboHandle = comboHandle;
break;
case Win32.WM_DESTROY:
//destroy the handles we have created
if (ComboHandle != IntPtr.Zero)
{
Win32.DestroyWindow(ComboHandle);
}
break;
case Win32.WM_NOTIFY:
//we need to intercept the CDN_FILEOK message
//which is sent when the user selects a filename
Win32.NMHDR nmhdr = (Win32.NMHDR)Marshal.PtrToStructure(lParam, typeof(Win32.NMHDR));
if (nmhdr.code == Win32.CDN_FILEOK)
{
Verify = Win32.SendMessage(ComboHandle, Win32.BM_GETCHECK, IntPtr.Zero, IntPtr.Zero) == (IntPtr)Win32.BST_CHECKED;
}
else if (nmhdr.code == Win32.CDN_HELP)
{
Help.HelpManager.Launch("ExportVMDialog");
}
break;
}
return(IntPtr.Zero);
}
protected void RefreshAllCommands()
{
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the window
WindowsAPI.GetWindowRect(this.Handle, ref rectRaw);
// Convert from screen to client sizing
Rectangle rectWin = new Rectangle(0, 0,
rectRaw.right - rectRaw.left,
rectRaw.bottom - rectRaw.top);
using(Graphics g = Graphics.FromHwnd(this.Handle))
{
// Draw the background area
DrawBackground(g, rectWin);
// Draw the actual menu items
DrawAllCommands(g);
}
}
protected bool ParentWantsMouseMessage(ref Win32.MSG msg)
{
Win32.POINT screenPos;
screenPos.x = (int)((uint)msg.lParam & 0x0000FFFFU);
screenPos.y = (int)(((uint)msg.lParam & 0xFFFF0000U) >> 16);
// Convert the mouse position to screen coordinates
WindowsAPI.ClientToScreen(msg.hwnd, ref screenPos);
// Special case the MOUSEMOVE so if we are part of a MenuControl
// then we should always allow mousemoves to be processed
if ((msg.message == (int)Msg.WM_MOUSEMOVE) && (_parentControl != null))
{
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the parent control
WindowsAPI.GetWindowRect(_parentControl.Handle, ref rectRaw);
if ((screenPos.x >= rectRaw.left) &&
(screenPos.x <= rectRaw.right) &&
(screenPos.y >= rectRaw.top) &&
(screenPos.y <= rectRaw.bottom))
return true;
}
if (_parentMenu != null)
return _parentMenu.WantMouseMessage(screenPos);
else
return false;
}
/*
static void
ScreenSaverCreateChildren(IntPtr hWndParent)
{
RECT rc;
g_iMonitor = 0;
switch (iMultiMonPosition) {
case MULTIMON_PERMONITOR:
EnumDisplayMonitors(NULL, NULL, ScreenSaverCreateChildrenCb,
(LPARAM)hWndParent);
return;
case MULTIMON_PRIMARY:
SetRect(&rc, 0, 0,
GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN));
break;
case MULTIMON_ALLMONITORS:
default:
GetClientRect(hWndParent, &rc);
break;
}
ScreenSaverCreateChild(hWndParent, &rc, 0, NULL);
}
int ScreenSaverCreateChildrenCb(IntPtr hMonitor, IntPtr hdcMonitor,
Win32.RECT lprcMonitor, IntPtr dwData)
{
IntPtr hWndParent = dwData;
Win32.RECT rcMonitorChild=new Win32.RECT();
Win32.User.MONITORINFOEX mi;
memset(&mi, 0, sizeof mi);
mi.cbSize = sizeof mi;
Win32.User.GetMonitorInfo(hMonitor, (MONITORINFO *)&mi);
_RPT1(_CRT_WARN, "Found monitor: %s\n", mi.szDevice);
rcMonitorChild = *lprcMonitor;
ScreenToClient(hWndParent, ((POINT*)&rcMonitorChild) + 0);
ScreenToClient(hWndParent, ((POINT*)&rcMonitorChild) + 1);
ScreenSaverCreateChild(hWndParent, &rcMonitorChild, g_iMonitor++, mi.szDevice);
return TRUE;
}*/
/*static void
ScreenSaverCreateChild(HWND hWndParent, RECT *rc, int iMonitor, char *device)
{
char szName[20];
FlurryAnimateChildInfo *child;
wsprintf(szName, "flurryMon%d", iMonitor);
_RPT2(_CRT_WARN, "Creating child %s on device %s:\n", szName, device);
child = new FlurryAnimateChildInfo;
memset(child, 0, sizeof *child);
child->id = iMonitor;
child->rc = *rc;
child->device = device ? strdup(device) : NULL;
child->fps.startTime = timeGetTime();
#define RECTWIDTH(rc) ((rc).right - (rc).left)
#define RECTHEIGHT(rc) ((rc).bottom - (rc).top)
// 200: n% / 100, and it counts on each size, so / 2 more
InflateRect(&child->rc,
-(int)(iFlurryShrinkPercentage * RECTWIDTH(child->rc) / 200),
-(int)(iFlurryShrinkPercentage * RECTHEIGHT(child->rc) / 200));
_RPT4(_CRT_WARN, " position %d, %d, %d, %d\n",
child->rc.left, child->rc.top, RECTWIDTH(child->rc), RECTHEIGHT(child->rc));
CreateWindow("FlurryAnimateChild", szName, WS_VISIBLE | WS_CHILD,
child->rc.left, child->rc.top, RECTWIDTH(child->rc), RECTHEIGHT(child->rc),
hWndParent, NULL, NULL, child);
}*/
/*
* FlurryAnimateChildWindowProc
*
* WndProc for the child windows that actually do the drawing.
* We handle WM_CREATE (setup), various painting and timer messages for
* animation, and forward mouse and keyboard messages to our parent.
*/
/*int FlurryAnimateChildWindowProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
FlurryAnimateChildInfo *child = (FlurryAnimateChildInfo *)
GetWindowLong(hWnd, GWL_USERDATA);
#ifdef _DEBUG
static int iFrameCounter = 0;
#endif
switch (message) {
case WM_CREATE: {
CREATESTRUCT *create = (CREATESTRUCT *)lParam;
// initialize per-child struct as window data
child = (FlurryAnimateChildInfo *)create->lpCreateParams;
child->hWnd = hWnd;
SetWindowLong(hWnd, GWL_USERDATA, (LONG)child);
// initialize flurry struct
int preset = child->id < g_multiMonPreset.size() ?
g_multiMonPreset[child->id] : iFlurryPreset;
child->flurry = new FlurryGroup(preset);
// prepare OpenGL context
AttachGLToWindow(child);
// prepare Flurry code -- must come after OpenGL initialization
child->flurry->PrepareToAnimate();
// set repaint timer
SetTimer(hWnd, 1, child->updateInterval, NULL);
// set up text parameters, in case we want to say anything
SetTextColor(child->hdc, 0xFFFFFF);
SetBkColor(child->hdc, 0x000000);
//SetBkMode(child->hdc, TRANSPARENT);
return 0;
}
case WM_ERASEBKGND:
// Never erase, so we get that nice fade effect initially and
// between frames.
return 0;
case WM_PAINT:
_RPT1(_CRT_WARN, "Start render frame %d\n", iFrameCounter);
if (wglMakeCurrent(child->hdc, child->hglrc)) {
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
CopyFrontBufferToBack(hWnd); // always call; may do nothing
child->flurry->AnimateOneFrame();
if (iSettingBufferMode > BUFFER_MODE_SINGLE) {
// ATI Radeon 9700s seem to get really upset if we call
// SwapBuffers in a single-buffered context when invoked
// with /p. So be careful not to!
SwapBuffers(ps.hdc);
}
EndPaint(hWnd, &ps);
} else {
_RPT1(_CRT_WARN, "OnPaint: wglMakeCurrent failed, error %d\n",
GetLastError());
}
ScreenSaverUpdateFpsIndicator(child);
_RPT1(_CRT_WARN, "End render frame %d\n", iFrameCounter++);
return 0;
case WM_TIMER:
InvalidateRect(hWnd, NULL, FALSE);
UpdateWindow(hWnd);
return 0;
case WM_DESTROY:
DetachGLFromWindow(child);
delete child->flurry;
free(child->device);
free(child);
SetWindowLong(hWnd, GWL_USERDATA, 0);
return 0;
case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
// forward input messages to parent, which will probably dismiss us
// note that the children don't actually get keyboard messages; the
// main window has the focus.
return SendMessage(GetParent(hWnd), message, wParam, lParam);
}
return DefWindowProc(hWnd, message, wParam, lParam);
}*/
/*
* RegisterDialogClasses
*
* Scrnsave.lib entry point: called before ScreenSaverConfigureDialog when
* invoked with /c.
*/
/*int RegisterDialogClasses(HANDLE hInst)
{
_Module.Init(NULL, (HINSTANCE)hInst);
return TRUE;
}*/
/*
* ScreenSaverConfigureDialog
*
* Scrnsave.lib entry point: called when invoked with /c.
*/
/*int ScreenSaverConfigureDialog(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_INITDIALOG:
ScreensaverCommonInit();
Settings_Read();
SettingsDialogInit(hWnd);
SettingsDialogEnableControls(hWnd);
SettingsToDialog(hWnd);
return TRUE;
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
// command buttons:
case IDOK:
SettingsFromDialog(hWnd);
Settings_Write();
EndDialog(hWnd, 1);
return TRUE;
case IDCANCEL:
EndDialog(hWnd, 0);
return TRUE;
case IDC_CREDITS:
DialogBoxParam(NULL, MAKEINTRESOURCE(DLG_CREDITS), hWnd, CreditsDialog, 0);
return TRUE;
case IDC_ABOUT:
CAboutBox::AutomaticDoModal();
return TRUE;
case IDC_TEST:
SettingsFromDialog(hWnd);
DoTestScreenSaver();
return TRUE;
// radio buttons:
case IDC_POSITION_DESKTOP:
case IDC_POSITION_PRIMARY:
case IDC_POSITION_PER:
SettingsDialogEnableControls(hWnd);
break;
}
break; // from WM_COMMAND
case WM_DESTROY:
_Module.Term();
break;
}
return FALSE;
}
static void
SettingsDialogEnableControls(HWND hWnd)
{
// Configure button enabled only when relevant
EnableWindow(GetDlgItem(hWnd, IDC_POSITION_PER_CONFIGURE),
IsDlgButtonChecked(hWnd, IDC_POSITION_PER));
// but all multimon stuff enabled only on multimon system
if (g_nMonitors <= 1) {
EnableWindow(GetDlgItem(hWnd, IDC_POSITION_PRIMARY), FALSE);
EnableWindow(GetDlgItem(hWnd, IDC_POSITION_PER), FALSE);
EnableWindow(GetDlgItem(hWnd, IDC_POSITION_PER_CONFIGURE), FALSE);
}
// XXX and per-monitor flurry assignment isn't implemented yet anyway
EnableWindow(GetDlgItem(hWnd, IDC_POSITION_PER_CONFIGURE), FALSE);
}
static void
SettingsDialogInit(HWND hWnd)
{
HWND hPresetList = GetDlgItem(hWnd, IDC_VISUAL);
for (int i = 0; i < g_visuals.size(); i++) {
ComboBox_AddString(hPresetList, g_visuals[i]->name);
}
}
static void
SettingsToDialog(HWND hWnd)
{
// visual preset
ComboBox_SetCurSel(GetDlgItem(hWnd, IDC_VISUAL), iFlurryPreset);
// multimon options
if (g_nMonitors <= 1) {
iMultiMonPosition = MULTIMON_ALLMONITORS;
}
CheckRadioButton(hWnd, IDC_POSITION_DESKTOP, IDC_POSITION_PER,
IDC_POSITION_DESKTOP + iMultiMonPosition);
// buffering mode
CheckRadioButton(hWnd, IDC_DOUBLE_BUFFER_NONE, IDC_DOUBLE_BUFFER_PARANOID,
IDC_DOUBLE_BUFFER_NONE + iSettingBufferMode);
}
static void
SettingsFromDialog(HWND hWnd)
{
// visual preset
iFlurryPreset = ComboBox_GetCurSel(GetDlgItem(hWnd, IDC_VISUAL));
// multimon options
if (IsDlgButtonChecked(hWnd, IDC_POSITION_DESKTOP)) {
iMultiMonPosition = MULTIMON_ALLMONITORS;
} else if (IsDlgButtonChecked(hWnd, IDC_POSITION_PRIMARY)) {
iMultiMonPosition = MULTIMON_PRIMARY;
} else if (IsDlgButtonChecked(hWnd, IDC_POSITION_PER)) {
iMultiMonPosition = MULTIMON_PERMONITOR;
}
// buffering mode
if (IsDlgButtonChecked(hWnd, IDC_DOUBLE_BUFFER_NONE)) {
iSettingBufferMode = BUFFER_MODE_SINGLE;
} else if (IsDlgButtonChecked(hWnd, IDC_DOUBLE_BUFFER_OPTIMISTIC)) {
iSettingBufferMode = BUFFER_MODE_FAST_DOUBLE;
} else if (IsDlgButtonChecked(hWnd, IDC_DOUBLE_BUFFER_PARANOID)) {
iSettingBufferMode = BUFFER_MODE_SAFE_DOUBLE;
}
}*/
// WGL attach/detach code
/*
static void
AttachGLToWindow(FlurryAnimateChildInfo *child)
{
// find current display settings on this monitor
DEVMODE mode;
EnumDisplaySettings(child->device, ENUM_CURRENT_SETTINGS, &mode);
_RPT4(_CRT_WARN, " current display settings %dx%dx%dbpp@%dHz\n",
mode.dmPelsWidth, mode.dmPelsHeight, mode.dmBitsPerPel, mode.dmDisplayFrequency);
if (mode.dmDisplayFrequency == 0) { // query failed
mode.dmDisplayFrequency = 60; // default to sane value
}
_RPT1(_CRT_WARN, " refresh time = %d ms\n", 1000 / mode.dmDisplayFrequency);
child->updateInterval = 1000 / mode.dmDisplayFrequency;
// build a pixel format
int iPixelFormat;
RECT rc;
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), // structure size
1, // version number
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL, // flags: support OpenGL rendering to visible window
PFD_TYPE_RGBA, // pixel format: RGBA
mode.dmBitsPerPel, // color depth, excluding alpha -- use whatever it's doing now
0, 0, 0, 0, 0, 0, 8, 0, // color bits ignored?
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
16, // 16-bit z-buffer
0, // no stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
if (iSettingBufferMode > BUFFER_MODE_SINGLE) {
pfd.dwFlags |= PFD_DOUBLEBUFFER;
}
// need a DC for the pixel format
child->hdc = GetDC(child->hWnd);
// apply pixel format to DC
iPixelFormat = ChoosePixelFormat(child->hdc, &pfd);
SetPixelFormat(child->hdc, iPixelFormat, &pfd);
// then use this to create a rendering context
child->hglrc = wglCreateContext(child->hdc);
wglMakeCurrent(child->hdc, child->hglrc);
// tell Flurry to use the whole window as viewport
GetClientRect(child->hWnd, &rc);
child->flurry->SetSize(rc.right - rc.left, rc.bottom - rc.top);
// some nice debug output
_RPT4(_CRT_WARN, " child 0x%08x: hWnd 0x%08x, hdc 0x%08x, hglrc 0x%08x\n",
child, child->hWnd, child->hdc, child->hglrc);
_RPT1(_CRT_WARN, " GL vendor: %s\n", glGetString(GL_VENDOR));
_RPT1(_CRT_WARN, " GL renderer: %s\n", glGetString(GL_RENDERER));
_RPT1(_CRT_WARN, " GL version: %s\n", glGetString(GL_VERSION));
_RPT1(_CRT_WARN, " GL extensions: %s\n", glGetString(GL_EXTENSIONS));
_RPT0(_CRT_WARN, "\n");
}
static void
DetachGLFromWindow(FlurryAnimateChildInfo *child)
{
if (child->hglrc == wglGetCurrentContext()) {
_RPT1(_CRT_WARN, "Evicting context %d\n", child->id);
wglMakeCurrent(NULL, NULL);
}
if (!wglDeleteContext(child->hglrc)) {
_RPT2(_CRT_WARN, "Failed to delete context for %d: %d\n",
child->id, GetLastError());
}
ReleaseDC(child->hWnd, child->hdc);
}
*/
void CopyFrontBufferToBack(IntPtr hWnd)
{
bool bFirstTime = true;
// copy front buffer to back buffer, to compensate for Windows'
// possibly weird implementation of SwapBuffers(). As documented, it
// reserves the right to leave the back buffer completely undefined
// after each swap, but on both my ATI Radeon 8500 and NVidia GF4Ti4200
// it works almost fine to just copy front to back once like this.
if ((iSettingBufferMode == BUFFER.BUFFER_MODE_SAFE_DOUBLE) ||
(iSettingBufferMode == BUFFER.BUFFER_MODE_FAST_DOUBLE && bFirstTime)) {
Win32.RECT rc=new Win32.RECT();
Win32.User.GetClientRect(hWnd, ref rc);
Gl.glDisable(Gl.GL_ALPHA_TEST);
if (!iBugWhiteout) {
// Found this by accident; Adam likes it. Freakshow option #1.
Gl.glDisable(Gl.GL_BLEND);
}
Gl.glReadBuffer(Gl.GL_FRONT);
Gl.glDrawBuffer(Gl.GL_BACK);
Gl.glRasterPos2i(0, 0);
Gl.glCopyPixels(0, 0, rc.Right, rc.Bottom, Gl.GL_COLOR);
if (!iBugWhiteout) {
Gl.glEnable(Gl.GL_BLEND);
}
Gl.glEnable(Gl.GL_ALPHA_TEST);
bFirstTime = false;
}
}
protected bool WantMouseMessage(Win32.POINT screenPos)
{
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the window
WindowsAPI.GetWindowRect(this.Handle, ref rectRaw);
bool want = ((screenPos.x >= rectRaw.left) &&
(screenPos.x <= rectRaw.right) &&
(screenPos.y >= rectRaw.top) &&
(screenPos.y <= rectRaw.bottom));
if (!want && (_parentMenu != null))
want = _parentMenu.WantMouseMessage(screenPos);
return want;
}
void DrawTextBoxState(DrawState drawState)
{
// Get window area
Win32.RECT rc = new Win32.RECT();
WindowsAPI.GetWindowRect(Handle, ref rc);
// Convert to Rectangle
Rectangle rect = new Rectangle(0, 0, rc.right - rc.left, rc.bottom - rc.top);
// Create DC for the whole edit window instead of just for the client area
IntPtr hDC = WindowsAPI.GetWindowDC(Handle);
using (Graphics g = Graphics.FromHdc(hDC))
{
// This rectangle is always drawn for any state
using ( Pen windowPen = new Pen(SystemBrushes.Window) )
{
g.DrawRectangle(windowPen, rect.Left+1, rect.Top+1, rect.Width-3, rect.Height-3);
}
if ( drawState == DrawState.Normal )
{
// draw SystemColos.Window rectangle
using ( Pen windowPen = new Pen(SystemBrushes.Window) )
{
g.DrawRectangle(windowPen, rect.Left, rect.Top, rect.Width-1, rect.Height-1);
}
}
else if ( drawState == DrawState.Hot )
{
// draw highlighted rectangle
g.DrawRectangle(SystemPens.Highlight, rect.Left, rect.Top, rect.Width-1, rect.Height-1);
}
else if ( drawState == DrawState.Disable )
{
// draw highlighted rectangle
g.FillRectangle(SystemBrushes.Control, rect);
Size textSize = TextUtil.GetTextSize(g, Text, Font);
Point point = new Point(rect.Left+1, rect.Top + (rect.Height - textSize.Height)/2);
if ( PasswordChar != 0)
{
int length = Text.Length;
string currentText = new String(PasswordChar, length);
g.DrawString(currentText, Font, SystemBrushes.ControlDark, point);
}
else
g.DrawString(Text, Font, SystemBrushes.ControlDark, point);
}
}
// Release DC
WindowsAPI.ReleaseDC(Handle, hDC);
}
protected void OnWM_PAINT(ref Message m)
{
// Paint message occurs after the window is created and we have
// entered the message loop. So this is a good place to handle focus
if (_grabFocus)
GrabTheFocus();
Win32.PAINTSTRUCT ps = new Win32.PAINTSTRUCT();
// Have to call BeginPaint whenever processing a WM_PAINT message
IntPtr hDC = WindowsAPI.BeginPaint(m.HWnd, ref ps);
Win32.RECT rectRaw = new Win32.RECT();
// Grab the screen rectangle of the window
WindowsAPI.GetWindowRect(this.Handle, ref rectRaw);
// Convert to a client size rectangle
Rectangle rectWin = new Rectangle(0, 0,
rectRaw.right - rectRaw.left,
rectRaw.bottom - rectRaw.top);
// Create a graphics object for drawing
using(Graphics g = Graphics.FromHdc(hDC))
{
// Create bitmap for drawing onto
using (Bitmap memoryBitmap = new Bitmap(rectWin.Width, rectWin.Height))
{
using(Graphics h = Graphics.FromImage(memoryBitmap))
{
// Draw the background area
DrawBackground(h, rectWin);
// Draw the actual menu items
DrawAllCommands(h);
}
// Blit bitmap onto the screen
g.DrawImageUnscaled(memoryBitmap, 0, 0);
}
}
// Don't forget to end the paint operation!
WindowsAPI.EndPaint(m.HWnd, ref ps);
}
private void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
{
// MINMAXINFO structure
Win32.MINMAXINFO mmi = (Win32.MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(Win32.MINMAXINFO));
// Get handle for nearest monitor to this window
WindowInteropHelper wih = new WindowInteropHelper(this);
IntPtr hMonitor = Win32.MonitorFromWindow(wih.Handle, Win32.MONITOR_DEFAULTTONEAREST);
// Get monitor info
Win32.MONITORINFOEX monitorInfo = new Win32.MONITORINFOEX();
monitorInfo.cbSize = Marshal.SizeOf(monitorInfo);
Win32.GetMonitorInfo(new HandleRef(this, hMonitor), monitorInfo);
// Get HwndSource
HwndSource source = HwndSource.FromHwnd(wih.Handle);
if (source == null)
{
// Should never be null
throw new Exception("Cannot get HwndSource instance.");
}
if (source.CompositionTarget == null)
{
// Should never be null
throw new Exception("Cannot get HwndTarget instance.");
}
// Get transformation matrix
//取消了DPI相关转换
//Matrix matrix = source.CompositionTarget.TransformFromDevice;
// Convert working area
Win32.RECT workingArea = monitorInfo.rcWork;
Point dpiIndependentSize =
new Point(//注释DPI转换相关
workingArea.Right - workingArea.Left,
workingArea.Bottom - workingArea.Top
);
//Point dpiIndependentSize =
// matrix.Transform(new Point(
// workingArea.Right - workingArea.Left,
// workingArea.Bottom - workingArea.Top
// ));
// Convert minimum size
Point dpiIndenpendentTrackingSize = new Point(//取消DPI相关转换
this.MinWidth,
this.MinHeight
);
//Point dpiIndenpendentTrackingSize = matrix.Transform(new Point(
// this.MinWidth,
// this.MinHeight
// ));
// Set the maximized size of the window
mmi.ptMaxSize.x = (int)dpiIndependentSize.X;
mmi.ptMaxSize.y = (int)dpiIndependentSize.Y;
// Set the position of the maximized window
mmi.ptMaxPosition.x = 0;
mmi.ptMaxPosition.y = 0;
// Set the minimum tracking size
mmi.ptMinTrackSize.x = (int)dpiIndenpendentTrackingSize.X;
mmi.ptMinTrackSize.y = (int)dpiIndenpendentTrackingSize.Y;
Marshal.StructureToPtr(mmi, lParam, true);
}
public static extern bool GetWindowRect(IntPtr hWnd, ref Win32.RECT lpRect);
