mirror of
https://github.com/beefytech/Beef.git
synced 2025-06-20 08:58:00 +02:00
820 lines
29 KiB
Beef
820 lines
29 KiB
Beef
using System;
|
|
using System.Collections;
|
|
using System.Text;
|
|
using System.Diagnostics;
|
|
using Beefy.gfx;
|
|
using Beefy.sys;
|
|
using System.IO;
|
|
|
|
#if MONOTOUCH
|
|
using MonoTouch;
|
|
#endif
|
|
|
|
#if STUDIO_CLIENT
|
|
using Beefy.ipc;
|
|
#endif
|
|
|
|
namespace Beefy
|
|
{
|
|
public class BFWindowBase
|
|
{
|
|
public enum Flags
|
|
{
|
|
Border = 0x000001,
|
|
ThickFrame = 0x000002,
|
|
Resizable = 0x000004,
|
|
SysMenu = 0x000008,
|
|
Caption = 0x000010,
|
|
Minimize = 0x000020,
|
|
Maximize = 0x000040,
|
|
ClientSized = 0x000080,
|
|
QuitOnClose = 0x000100,
|
|
VSync = 0x000200,
|
|
PopupPosition = 0x000400,
|
|
DestAlpha = 0x000800,
|
|
AlphaMask = 0x001000,
|
|
Child = 0x002000,
|
|
TopMost = 0x004000,
|
|
ToolWindow = 0x008000,
|
|
NoActivate = 0x01'0000,
|
|
NoMouseActivate = 0x02'0000,
|
|
Menu = 0x04'0000,
|
|
Modal = 0x08'0000,
|
|
ScaleContent = 0x10'0000,
|
|
UseParentMenu = 0x20'0000,
|
|
CaptureMediaKeys = 0x40'0000,
|
|
Fullscreen = 0x80'0000,
|
|
FakeFocus = 0x0100'0000,
|
|
ShowMinimized = 0x0200'0000,
|
|
ShowMaximized = 0x0400'0000,
|
|
AllowFullscreen = 0x0800'0000,
|
|
};
|
|
|
|
[AllowDuplicates]
|
|
public enum HitTestResult
|
|
{
|
|
NotHandled = -3,
|
|
|
|
Border = 18,
|
|
Bottom = 15,
|
|
BottomLeft = 16,
|
|
BottomRight = 17,
|
|
Caption = 2,
|
|
Client = 1,
|
|
Close = 20,
|
|
Error = -2,
|
|
GrowBox = 4,
|
|
Help = 21,
|
|
HScroll = 6,
|
|
Left = 10,
|
|
Menu = 5,
|
|
MaxButton = 9,
|
|
MinButton = 8,
|
|
NoWhere = 0,
|
|
Reduce = 8,
|
|
Right = 11,
|
|
Size = 4,
|
|
SysMenu = 3,
|
|
Top = 12,
|
|
TopLeft = 13,
|
|
TopRight = 14,
|
|
Transparent = -1,
|
|
VScroll = 7,
|
|
Zoom = 9
|
|
}
|
|
|
|
public SysMenu mSysMenu ~ delete _;
|
|
public Dictionary<int, SysMenu> mSysMenuMap = new Dictionary<int, SysMenu>() ~ delete _;
|
|
public DrawLayer mDefaultDrawLayer ~ delete _;
|
|
|
|
public virtual void Draw(Graphics g)
|
|
{
|
|
|
|
}
|
|
|
|
public virtual void PreDraw(Graphics g)
|
|
{
|
|
g.PushDrawLayer(mDefaultDrawLayer);
|
|
}
|
|
|
|
public virtual void PostDraw(Graphics g)
|
|
{
|
|
g.PopDrawLayer();
|
|
}
|
|
}
|
|
#if !STUDIO_CLIENT
|
|
public class BFWindow : BFWindowBase, INativeWindow
|
|
{
|
|
public enum ShowKind
|
|
{
|
|
Normal,
|
|
Minimized,
|
|
Maximized
|
|
}
|
|
|
|
delegate void NativeMovedDelegate(void* window);
|
|
delegate int32 NativeCloseQueryDelegate(void* window);
|
|
delegate void NativeClosedDelegate(void* window);
|
|
delegate void NativeGotFocusDelegate(void* window);
|
|
delegate void NativeLostFocusDelegate(void* window);
|
|
delegate void NativeKeyCharDelegate(void* window, char32 theChar);
|
|
delegate bool NativeKeyDownDelegate(void* window, int32 keyCode, int32 isRepeat);
|
|
delegate void NativeKeyUpDelegate(void* window, int32 keyCode);
|
|
delegate int32 NativeHitTestDelegate(void* window, int32 x, int32 y);
|
|
delegate void NativeMouseMoveDelegate(void* window, int32 x, int32 y);
|
|
delegate void NativeMouseProxyMoveDelegate(void* window, int32 x, int32 y);
|
|
delegate void NativeMouseDownDelegate(void* window, int32 x, int32 y, int32 btn, int32 btnCount);
|
|
delegate void NativeMouseUpDelegate(void* window, int32 x, int32 y, int32 btn);
|
|
delegate void NativeMouseWheelDelegate(void* window, int32 x, int32 y, float delta);
|
|
delegate void NativeMouseLeaveDelegate(void* window);
|
|
delegate void NativeMenuItemSelectedDelegate(void* window, void* menu);
|
|
|
|
public void* mNativeWindow;
|
|
public bool mNativeWindowClosed;
|
|
|
|
static int32 sId;
|
|
protected int32 mId = ++sId;
|
|
|
|
public String mName ~ delete _;
|
|
public String mTitle ~ delete _;
|
|
public int32 mX;
|
|
public int32 mY;
|
|
public int32 mWindowWidth;
|
|
public int32 mWindowHeight;
|
|
public int32 mNormX;
|
|
public int32 mNormY;
|
|
public int32 mNormWidth;
|
|
public int32 mNormHeight;
|
|
public ShowKind mShowKind;
|
|
public int32 mClientX;
|
|
public int32 mClientY;
|
|
public int32 mClientWidth;
|
|
public int32 mClientHeight;
|
|
public float mAlpha = 1.0f;
|
|
public Flags mWindowFlags;
|
|
public bool mVisible = true;
|
|
private bool mMouseVisible;
|
|
public bool mHasFocus = false;
|
|
public bool mHasClosed;
|
|
public bool mIsDirty = true;
|
|
public BFWindow mParent;
|
|
public List<BFWindow> mChildWindows = new List<BFWindow>() ~ delete _;
|
|
|
|
static protected Dictionary<int, BFWindow> sWindowDictionary = new Dictionary<int, BFWindow>() ~ delete _;
|
|
|
|
static NativeMovedDelegate sNativeMovedDelegate ~ delete _;
|
|
static NativeCloseQueryDelegate sNativeCloseQueryDelegate ~ delete _;
|
|
static NativeClosedDelegate sNativeClosedDelegate ~ delete _;
|
|
static NativeGotFocusDelegate sNativeGotFocusDelegate ~ delete _;
|
|
static NativeLostFocusDelegate sNativeLostFocusDelegate ~ delete _;
|
|
static NativeKeyCharDelegate sNativeKeyCharDelegate ~ delete _;
|
|
static NativeKeyDownDelegate sNativeKeyDownDelegate ~ delete _;
|
|
static NativeKeyUpDelegate sNativeKeyUpDelegate ~ delete _;
|
|
static NativeHitTestDelegate sNativeHitTestDelegate ~ delete _;
|
|
static NativeMouseMoveDelegate sNativeMouseMoveDelegate ~ delete _;
|
|
static NativeMouseProxyMoveDelegate sNativeMouseProxyMoveDelegate ~ delete _;
|
|
static NativeMouseDownDelegate sNativeMouseDownDelegate ~ delete _;
|
|
static NativeMouseUpDelegate sNativeMouseUpDelegate ~ delete _;
|
|
static NativeMouseWheelDelegate sNativeMouseWheelDelegate ~ delete _;
|
|
static NativeMouseLeaveDelegate sNativeMouseLeaveDelegate ~ delete _;
|
|
static NativeMenuItemSelectedDelegate sNativeMenuItemSelectedDelegate ~ delete _;
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void* BFApp_CreateWindow(void* parent, char8* title, int32 x, int32 y, int32 width, int32 height, int32 windowFlags);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void* BFWindow_GetNativeUnderlying(void* window);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetCallbacks(void* window, void* movedDelegate, void* closeQueryDelegate, void* closedDelegate,
|
|
void* gotFocusDelegate, void* lostFocusDelegate,
|
|
void* keyCharDelegate, void* keyDownDelegate, void* keyUpDelegate, void* hitTestDelegate,
|
|
void* mouseMoveDelegate, void* mouseProxyMoveDelegate, void* mouseDownDelegate, void* mouseUpDelegate, void* mouseWheelDelegate, void* mouseLeaveDelegate,
|
|
void* menuItemSelectedDelegate);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetTitle(void* window, char8* title);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetMinimumSize(void* window, int32 minWidth, int32 minHeight, bool clientSized);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_GetPosition(void* window, out int32 x, out int32 y, out int32 width, out int32 height, out int32 clientX, out int32 clientY, out int32 clientWidth, out int32 clientHeight);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_GetPlacement(void* window, out int32 normX, out int32 normY, out int32 normWidth, out int32 normHeight, out int32 showKind);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_Resize(void* window, int32 x, int32 y, int32 width, int32 height, int showKind);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_Close(void* window, int32 force);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetForeground(void* window);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_LostFocus(void* window, void* newFocus);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetNonExclusiveMouseCapture(void* window);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetClientPosition(void* window, int32 x, int32 y);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetAlpha(void* window, float alpha, uint32 destAlphaSrcMask, int32 mouseVisible);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_SetMouseVisible(void* window, bool mouseVisible);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void BFWindow_CaptureMouse(void* window);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern bool BFWindow_IsMouseCaptured(void* window);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void* BFWindow_AddMenuItem(void* window, void* parent, int32 insertIdx, char8* text, char8* hotKey, void* bitmap, int32 enabled, int32 checkState, int32 radioCheck);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void* BFWindow_ModifyMenuItem(void* window, void* item, char8* text, char8* hotKey, void* bitmap, int32 enabled, int32 checkState, int32 radioCheck);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern void* BFWindow_DeleteMenuItem(void* window, void* item);
|
|
|
|
[CallingConvention(.Stdcall), CLink]
|
|
static extern int BFWindow_GetDPI(void* window);
|
|
|
|
public static BFWindow GetBFWindow(void* window)
|
|
{
|
|
return sWindowDictionary[(int)window];
|
|
}
|
|
|
|
#if MONOTOUCH
|
|
[MonoPInvokeCallback(typeof(NativeMovedDelegate))]
|
|
static void Static_NativeMovedDelegate(void* window) { GetBFWindow(window).Moved(); }
|
|
[MonoPInvokeCallback(typeof(NativeClosedDelegate))]
|
|
static void Static_NativeClosedDelegate(void* window) { GetBFWindow(window).Closed(); }
|
|
[MonoPInvokeCallback(typeof(NativeCloseQueryDelegate))]
|
|
static int Static_NativeCloseQueryDelegate(void* window) { return GetBFWindow(window).CloseQuery(); }
|
|
[MonoPInvokeCallback(typeof(NativeGotFocusDelegate))]
|
|
static void Static_NativeGotFocusDelegate(void* window) { GetBFWindow(window).GotFocus(); }
|
|
[MonoPInvokeCallback(typeof(NativeLostFocusDelegate))]
|
|
static void Static_NativeLostFocusDelegate(void* window) { GetBFWindow(window).LostFocus(); }
|
|
[MonoPInvokeCallback(typeof(NativeKeyCharDelegate))]
|
|
static void Static_NativeKeyCharDelegate(void* window, char8 c) { GetBFWindow(window).KeyChar(c); }
|
|
[MonoPInvokeCallback(typeof(NativeKeyDownDelegate))]
|
|
static bool Static_NativeKeyDownDelegate(void* window, int key, int isRepeat) { return GetBFWindow(window).KeyDown(key, isRepeat); }
|
|
[MonoPInvokeCallback(typeof(NativeKeyUpDelegate))]
|
|
static void Static_NativeKeyUpDelegate(void* window, int key) { GetBFWindow(window).KeyUp(key); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseMoveDelegate))]
|
|
static void Static_NativeMouseMoveDelegate(void* window, int mouseX, int mouseY) { GetBFWindow(window).MouseMove(mouseX, mouseY); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseProxyMoveDelegate))]
|
|
static void Static_NativeMouseProxyMoveDelegate(void* window, int mouseX, int mouseY) { GetBFWindow(window).MouseProxyMove(mouseX, mouseY); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseDownDelegate))]
|
|
static void Static_NativeMouseDownDelegate(void* window, int mouseX, int mouseY, int btnNum, int btnCount) { GetBFWindow(window).MouseDown(mouseX, mouseY, btnNum, btnCount); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseUpDelegate))]
|
|
static void Static_NativeMouseUpDelegate(void* window, int mouseX, int mouseY, int btnNum) { GetBFWindow(window).MouseUp(mouseX, mouseY, btnNum); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseWheelDelegate))]
|
|
static void Static_NativeMouseWheelDelegate(void* window, int mouseX, int mouseY, int delta) { GetBFWindow(window).MouseWheel(mouseX, mouseY, delta); }
|
|
[MonoPInvokeCallback(typeof(NativeMouseLeaveDelegate))]
|
|
static void Static_NativeMouseLeaveDelegate(void* window) { GetBFWindow(window).MouseLeave(); }
|
|
[MonoPInvokeCallback(typeof(NativeMenuItemSelectedDelegate))]
|
|
static void Static_NativeMenuItemSelectedDelegate(void* window, void* item) { GetBFWindow(window).NativeMenuItemSelected(item); }
|
|
#else
|
|
static void Static_NativeMovedDelegate(void* window) { GetBFWindow(window).Moved(); }
|
|
static void Static_NativeClosedDelegate(void* window) { GetBFWindow(window).Closed(); }
|
|
static int32 Static_NativeCloseQueryDelegate(void* window) { return GetBFWindow(window).CloseQuery(); }
|
|
static void Static_NativeGotFocusDelegate(void* window) { GetBFWindow(window).GotFocus(); }
|
|
static void Static_NativeLostFocusDelegate(void* window) { GetBFWindow(window).LostFocus(null); }
|
|
static void Static_NativeKeyCharDelegate(void* window, char32 c) { GetBFWindow(window).KeyChar(c); }
|
|
static bool Static_NativeKeyDownDelegate(void* window, int32 key, int32 isRepeat) { return GetBFWindow(window).KeyDown(key, isRepeat); }
|
|
static void Static_NativeKeyUpDelegate(void* window, int32 key) { GetBFWindow(window).KeyUp(key); }
|
|
static int32 Static_NativeHitTestDelegate(void* window, int32 x, int32 y) { return (int32)GetBFWindow(window).HitTest(x, y); }
|
|
static void Static_NativeMouseMoveDelegate(void* window, int32 mouseX, int32 mouseY) { GetBFWindow(window).MouseMove(mouseX, mouseY); }
|
|
static void Static_NativeMouseProxyMoveDelegate(void* window, int32 mouseX, int32 mouseY) { GetBFWindow(window).MouseProxyMove(mouseX, mouseY); }
|
|
static void Static_NativeMouseDownDelegate(void* window, int32 mouseX, int32 mouseY, int32 btnNum, int32 btnCount) { GetBFWindow(window).MouseDown(mouseX, mouseY, btnNum, btnCount); }
|
|
static void Static_NativeMouseUpDelegate(void* window, int32 mouseX, int32 mouseY, int32 btnNum) { GetBFWindow(window).MouseUp(mouseX, mouseY, btnNum); }
|
|
static void Static_NativeMouseWheelDelegate(void* window, int32 mouseX, int32 mouseY, float delta) { GetBFWindow(window).MouseWheel(mouseX, mouseY, delta); }
|
|
static void Static_NativeMouseLeaveDelegate(void* window) { GetBFWindow(window).MouseLeave(); }
|
|
static void Static_NativeMenuItemSelectedDelegate(void* window, void* item) { GetBFWindow(window).NativeMenuItemSelected(item); }
|
|
#endif
|
|
|
|
public this()
|
|
{
|
|
}
|
|
|
|
public this(BFWindow parent, String title, int x, int y, int width, int height, BFWindow.Flags windowFlags)
|
|
{
|
|
Init(parent, title, x, y, width, height, windowFlags);
|
|
}
|
|
|
|
public ~this()
|
|
{
|
|
bool worked = sWindowDictionary.Remove((int)mNativeWindow);
|
|
Debug.Assert(worked);
|
|
}
|
|
|
|
void Init(BFWindow parent, String title, int x, int y, int width, int height, BFWindow.Flags windowFlags)
|
|
{
|
|
mTitle = new String(title);
|
|
mParent = parent;
|
|
if (mParent != null)
|
|
mParent.mChildWindows.Add(this);
|
|
|
|
var useFlags = windowFlags;
|
|
/*if (useFlags.HasFlag(.FakeFocus))
|
|
{
|
|
useFlags |= .NoActivate;
|
|
useFlags |= .NoMouseActivate;
|
|
}*/
|
|
|
|
mNativeWindow = BFApp_CreateWindow((parent != null) ? (parent.mNativeWindow) : null, title, (int32)x, (int32)y, (int32)width, (int32)height, (int32)useFlags);
|
|
sWindowDictionary[(int)mNativeWindow] = this;
|
|
|
|
if (sNativeMovedDelegate == null)
|
|
{
|
|
sNativeMovedDelegate = new => Static_NativeMovedDelegate;
|
|
sNativeClosedDelegate = new => Static_NativeClosedDelegate;
|
|
sNativeCloseQueryDelegate = new => Static_NativeCloseQueryDelegate;
|
|
sNativeGotFocusDelegate = new => Static_NativeGotFocusDelegate;
|
|
sNativeLostFocusDelegate = new => Static_NativeLostFocusDelegate;
|
|
sNativeKeyCharDelegate = new => Static_NativeKeyCharDelegate;
|
|
sNativeKeyDownDelegate = new => Static_NativeKeyDownDelegate;
|
|
sNativeKeyUpDelegate = new => Static_NativeKeyUpDelegate;
|
|
sNativeHitTestDelegate = new => Static_NativeHitTestDelegate;
|
|
sNativeMouseMoveDelegate = new => Static_NativeMouseMoveDelegate;
|
|
sNativeMouseProxyMoveDelegate = new => Static_NativeMouseProxyMoveDelegate;
|
|
sNativeMouseDownDelegate = new => Static_NativeMouseDownDelegate;
|
|
sNativeMouseUpDelegate = new => Static_NativeMouseUpDelegate;
|
|
sNativeMouseWheelDelegate = new => Static_NativeMouseWheelDelegate;
|
|
sNativeMouseLeaveDelegate = new => Static_NativeMouseLeaveDelegate;
|
|
sNativeMenuItemSelectedDelegate = new => Static_NativeMenuItemSelectedDelegate;
|
|
}
|
|
|
|
BFWindow_SetCallbacks(mNativeWindow, sNativeMovedDelegate.GetFuncPtr(), sNativeCloseQueryDelegate.GetFuncPtr(), sNativeClosedDelegate.GetFuncPtr(), sNativeGotFocusDelegate.GetFuncPtr(), sNativeLostFocusDelegate.GetFuncPtr(),
|
|
sNativeKeyCharDelegate.GetFuncPtr(), sNativeKeyDownDelegate.GetFuncPtr(), sNativeKeyUpDelegate.GetFuncPtr(), sNativeHitTestDelegate.GetFuncPtr(),
|
|
sNativeMouseMoveDelegate.GetFuncPtr(), sNativeMouseProxyMoveDelegate.GetFuncPtr(), sNativeMouseDownDelegate.GetFuncPtr(), sNativeMouseUpDelegate.GetFuncPtr(), sNativeMouseWheelDelegate.GetFuncPtr(), sNativeMouseLeaveDelegate.GetFuncPtr(),
|
|
sNativeMenuItemSelectedDelegate.GetFuncPtr());
|
|
BFApp.sApp.mWindows.Add(this);
|
|
|
|
mDefaultDrawLayer = new DrawLayer(this);
|
|
|
|
if (windowFlags.HasFlag(Flags.Menu))
|
|
{
|
|
mSysMenu = new SysMenu();
|
|
mSysMenu.mWindow = this;
|
|
}
|
|
mWindowFlags = windowFlags;
|
|
|
|
if ((parent != null) && (!mWindowFlags.HasFlag(Flags.NoActivate)))
|
|
parent.LostFocus(this);
|
|
|
|
if ((parent != null) && (mWindowFlags.HasFlag(Flags.Modal)))
|
|
parent.PreModalChild();
|
|
|
|
if ((mWindowFlags.HasFlag(.FakeFocus)) && (!mWindowFlags.HasFlag(.NoActivate)))
|
|
GotFocus();
|
|
|
|
BFApp.sApp.RehupMouse();
|
|
}
|
|
|
|
public void SetTitle(String title)
|
|
{
|
|
mTitle.Set(title);
|
|
BFWindow_SetTitle(mNativeWindow, mTitle);
|
|
}
|
|
|
|
public int Handle
|
|
{
|
|
get
|
|
{
|
|
return (int)BFWindow_GetNativeUnderlying(mNativeWindow);
|
|
}
|
|
}
|
|
|
|
#if BF_PLATFORM_WINDOWS
|
|
public Windows.HWnd HWND
|
|
{
|
|
get
|
|
{
|
|
return (.)(int)BFWindow_GetNativeUnderlying(mNativeWindow);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
public void PreModalChild()
|
|
{
|
|
//MouseLeave();
|
|
}
|
|
|
|
public virtual void Dispose()
|
|
{
|
|
Close(true);
|
|
}
|
|
|
|
public virtual int32 CloseQuery()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
public virtual void Close(bool force = false)
|
|
{
|
|
// This doesn't play properly with CloseQuery. We may do a force close in CloseQuery, but that fails
|
|
// if we do this following logic:
|
|
/*if (mNativeWindowClosed)
|
|
return;
|
|
mNativeWindowClosed = true;*/
|
|
|
|
while (mChildWindows.Count > 0)
|
|
mChildWindows[mChildWindows.Count - 1].Close(force);
|
|
|
|
//for (var childWindow in mChildWindows)
|
|
//childWindow.Close(force);
|
|
//mChildWindows[mChildWindows.Count - 1].Close(force);
|
|
|
|
if (mNativeWindow != null)
|
|
{
|
|
BFWindow_Close(mNativeWindow, force ? 1 : 0);
|
|
}
|
|
else
|
|
{
|
|
Closed();
|
|
}
|
|
}
|
|
|
|
public virtual void Resize(int x, int y, int width, int height, ShowKind showKind = .Normal)
|
|
{
|
|
Debug.Assert(mNativeWindow != null);
|
|
BFWindow_Resize(mNativeWindow, (int32)x, (int32)y, (int32)width, (int32)height, (int32)showKind);
|
|
}
|
|
|
|
public void SetForeground()
|
|
{
|
|
BFWindow_SetForeground(mNativeWindow);
|
|
GotFocus();
|
|
}
|
|
|
|
public void SetNonExclusiveMouseCapture()
|
|
{
|
|
// Does checking of mouse coords against all window even when this window has mouse capture,
|
|
// helps some dragging scenarios. Gets turned off automatically on mouse up.
|
|
BFWindow_SetNonExclusiveMouseCapture(mNativeWindow);
|
|
}
|
|
|
|
public bool HasParent(BFWindow widgetWindow)
|
|
{
|
|
var checkParent = mParent;
|
|
while (checkParent != null)
|
|
{
|
|
if (checkParent == widgetWindow)
|
|
return true;
|
|
checkParent = checkParent.mParent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public virtual void Closed()
|
|
{
|
|
if (mHasClosed)
|
|
return;
|
|
mHasClosed = true;
|
|
|
|
bool hadFocus = mHasFocus;
|
|
|
|
BFApp.sApp.mWindows.Remove(this);
|
|
|
|
if (mWindowFlags.HasFlag(Flags.QuitOnClose))
|
|
BFApp.sApp.Stop();
|
|
|
|
if (mParent != null)
|
|
{
|
|
mParent.mChildWindows.Remove(this);
|
|
if ((hadFocus) && (mWindowFlags.HasFlag(Flags.Modal)))
|
|
mParent.GotFocus();
|
|
}
|
|
|
|
DeleteAndNullify!(mDefaultDrawLayer);
|
|
BFApp.sApp.DeferDelete(this);
|
|
}
|
|
|
|
public void SetMinimumSize(int32 minWidth, int32 minHeight, bool clientSized = false)
|
|
{
|
|
BFWindow_SetMinimumSize(mNativeWindow, minWidth, minHeight, clientSized);
|
|
}
|
|
|
|
public virtual void RehupSize()
|
|
{
|
|
BFWindow_GetPosition(mNativeWindow, out mX, out mY, out mWindowWidth, out mWindowHeight, out mClientX, out mClientY, out mClientWidth, out mClientHeight);
|
|
|
|
int32 showKind = 0;
|
|
BFWindow_GetPlacement(mNativeWindow, out mNormX, out mNormY, out mNormWidth, out mNormHeight, out showKind);
|
|
mShowKind = (.)showKind;
|
|
|
|
mIsDirty = true;
|
|
}
|
|
|
|
public virtual void Moved()
|
|
{
|
|
RehupSize();
|
|
}
|
|
|
|
public virtual void SetClientPosition(float x, float y)
|
|
{
|
|
mClientX = (int32)x;
|
|
mClientY = (int32)y;
|
|
BFWindow_SetClientPosition(mNativeWindow, (int32)x, (int32)y);
|
|
}
|
|
|
|
public virtual void SetAlpha(float alpha, uint32 destAlphaSrcMask, bool mouseVisible)
|
|
{
|
|
mAlpha = alpha;
|
|
BFWindow_SetAlpha(mNativeWindow, alpha, destAlphaSrcMask, mouseVisible ? 1 : 0);
|
|
}
|
|
|
|
public virtual void SetMouseVisible(bool mouseVisible)
|
|
{
|
|
mMouseVisible = mouseVisible;
|
|
BFWindow_SetMouseVisible(mNativeWindow, mouseVisible);
|
|
}
|
|
|
|
public virtual void CaptureMouse()
|
|
{
|
|
BFWindow_CaptureMouse(mNativeWindow);
|
|
}
|
|
|
|
public bool IsMouseCaptured()
|
|
{
|
|
return BFWindow_IsMouseCaptured(mNativeWindow);
|
|
}
|
|
|
|
public virtual void* AddMenuItem(void* parent, int insertIdx, String text, String hotKey, void* bitmap, bool enabled, int checkState, bool radioCheck)
|
|
{
|
|
return BFWindow_AddMenuItem(mNativeWindow, parent, (int32)insertIdx, text, hotKey, bitmap, enabled ? 1 : 0, (int32)checkState, radioCheck ? 1 : 0);
|
|
}
|
|
|
|
public virtual void ModifyMenuItem(void* item, String text, String hotKey, void* bitmap, bool enabled, int checkState, bool radioCheck)
|
|
{
|
|
BFWindow_ModifyMenuItem(mNativeWindow, item, text, hotKey, bitmap, enabled ? 1 : 0, (int32)checkState, radioCheck ? 1 : 0);
|
|
}
|
|
|
|
public virtual void DeleteMenuItem(void* menuItem)
|
|
{
|
|
BFWindow_DeleteMenuItem(mNativeWindow, menuItem);
|
|
}
|
|
|
|
public virtual void MenuItemSelected(SysMenu sysMenu)
|
|
{
|
|
sysMenu.Selected();
|
|
}
|
|
|
|
public virtual void NativeMenuItemSelected(void* menu)
|
|
{
|
|
SysMenu aSysMenu = mSysMenuMap[(int)menu];
|
|
MenuItemSelected(aSysMenu);
|
|
}
|
|
|
|
public virtual SysBitmap LoadSysBitmap(String path)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public virtual void GotFocus()
|
|
{
|
|
if (mHasFocus)
|
|
return;
|
|
mHasFocus = true;
|
|
//Console.WriteLine("GotFocus {0}", mTitle);
|
|
}
|
|
|
|
public virtual void LostFocus(BFWindow newFocus)
|
|
{
|
|
if (!mHasFocus)
|
|
return;
|
|
mHasFocus = false;
|
|
if (mNativeWindow != null)
|
|
BFWindow_LostFocus(mNativeWindow, (newFocus != null) ? newFocus.mNativeWindow : null);
|
|
|
|
//TODO: REMOVE
|
|
//Debug.WriteLine("LostFocus {0}", mTitle);
|
|
}
|
|
|
|
public virtual int GetDPI()
|
|
{
|
|
return BFWindow_GetDPI(mNativeWindow);
|
|
}
|
|
|
|
public virtual void KeyChar(char32 theChar)
|
|
{
|
|
}
|
|
|
|
public virtual bool KeyDown(int32 keyCode, int32 isRepeat)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public virtual void KeyUp(int32 keyCode)
|
|
{
|
|
|
|
}
|
|
|
|
public virtual HitTestResult HitTest(int32 x, int32 y)
|
|
{
|
|
return HitTestResult.NotHandled;
|
|
}
|
|
|
|
public virtual void MouseMove(int32 x, int32 y)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseProxyMove(int32 x, int32 y)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseDown(int32 x, int32 y, int32 btn, int32 btnCount)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseUp(int32 x, int32 y, int32 btn)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseWheel(int32 x, int32 y, float delta)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseLeave()
|
|
{
|
|
}
|
|
|
|
public override void Draw(Graphics g)
|
|
{
|
|
}
|
|
|
|
public virtual void Update()
|
|
{
|
|
}
|
|
}
|
|
#else
|
|
public class BFWindow : BFWindowBase, IStudioClientWindow
|
|
{
|
|
//IStudioWidgetWindow mProxy;
|
|
public int mClientWidth;
|
|
public int mClientHeight;
|
|
public int mClientX;
|
|
public int mClientY;
|
|
public float mAlpha = 1.0f;
|
|
public bool mVisible = true;
|
|
public Flags mWindowFlags;
|
|
|
|
public IPCProxy<IStudioHostWindow> mRemoteWindow;
|
|
public IPCEndpoint<IStudioClientWindow> mStudioClientWindow;
|
|
|
|
public BFWindow(BFWindow parent, string title, int x, int y, int width, int height, BFWindow.Flags windowFlags)
|
|
{
|
|
mStudioClientWindow = IPCEndpoint<IStudioClientWindow>.Create(this);
|
|
|
|
IStudioHost studioInstance = BFApp.sApp.mStudioHost.Proxy;
|
|
IPCObjectId remoteWindowId = studioInstance.CreateWindow(mStudioClientWindow.ObjId, 0, title, x, y, width, height, (int)windowFlags);
|
|
mRemoteWindow = IPCProxy<IStudioHostWindow>.Create(remoteWindowId);
|
|
|
|
mDefaultDrawLayer = new DrawLayer(this);
|
|
|
|
BFApp.sApp.mWindows.Add(this);
|
|
|
|
mClientX = 0;
|
|
mClientY = 0;
|
|
mClientWidth = width;
|
|
mClientHeight = height;
|
|
|
|
mWindowFlags = windowFlags;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
public virtual int CloseQuery()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
public virtual void Close(bool force = false)
|
|
{
|
|
//if (mNativeWindow != null)
|
|
//BFWindow_Close(mNativeWindow, force ? 1 : 0);
|
|
}
|
|
|
|
public virtual void Closed()
|
|
{
|
|
//mNativeWindow = null;
|
|
BFApp.sApp.mWindows.Remove(this);
|
|
}
|
|
|
|
public virtual void Moved()
|
|
{
|
|
//BFWindow_GetPosition(mNativeWindow, out mX, out mY, out mWindowWidth, out mWindowHeight, out mClientX, out mClientY, out mClientWidth, out mClientHeight);
|
|
}
|
|
|
|
public virtual void SetClientPosition(float x, float y)
|
|
{
|
|
//BFWindow_SetClientPosition(mNativeWindow, (int)x, (int)y);
|
|
}
|
|
|
|
public virtual void SetAlpha(float alpha, uint destAlphaSrcMask, bool mouseVisible)
|
|
{
|
|
//mAlpha = alpha;
|
|
//BFWindow_SetAlpha(mNativeWindow, alpha, destAlphaSrcMask, mouseVisible ? 1 : 0);
|
|
}
|
|
|
|
public virtual void* AddMenuItem(void* parent, string text, string hotKey, void* bitmap, bool enabled, int checkState, bool radioCheck)
|
|
{
|
|
//return BFWindow_AddMenuItem(mNativeWindow, parent, text, hotKey, bitmap, enabled ? 1 : 0, checkState, radioCheck ? 1 : 0);
|
|
return null;
|
|
}
|
|
|
|
public virtual void MenuItemSelected(SysMenu sysMenu)
|
|
{
|
|
sysMenu.Selected();
|
|
}
|
|
|
|
public virtual void NativeMenuItemSelected(void* menu)
|
|
{
|
|
//SysMenu aSysMenu = mSysMenuMap[menu];
|
|
//MenuItemSelected(aSysMenu);
|
|
}
|
|
|
|
public virtual SysBitmap LoadSysBitmap(string path)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public virtual void GotFocus()
|
|
{
|
|
}
|
|
|
|
public virtual void LostFocus()
|
|
{
|
|
}
|
|
|
|
public virtual void KeyChar(char32 theChar)
|
|
{
|
|
}
|
|
|
|
public virtual void KeyDown(int keyCode, int isRepeat)
|
|
{
|
|
}
|
|
|
|
public virtual void KeyUp(int keyCode)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseMove(int x, int y)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseProxyMove(int x, int y)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseDown(int x, int y, int btn, int btnCount)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseUp(int x, int y, int btn)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseWheel(int x, int y, int delta)
|
|
{
|
|
}
|
|
|
|
public virtual void MouseLeave()
|
|
{
|
|
}
|
|
|
|
public virtual void Update()
|
|
{
|
|
}
|
|
|
|
public override void PreDraw(Graphics g)
|
|
{
|
|
base.PreDraw(g);
|
|
mRemoteWindow.Proxy.RemoteDrawingStarted();
|
|
}
|
|
|
|
public override void PostDraw(Graphics g)
|
|
{
|
|
base.PostDraw(g);
|
|
mRemoteWindow.Proxy.RemoteDrawingDone();
|
|
}
|
|
|
|
public void SetIsVisible(bool visible)
|
|
{
|
|
mVisible = visible;
|
|
}
|
|
}
|
|
#endif
|
|
}
|