| public static ThrowError ( string source, string message ) : void | ||
| source | string | |
| message | string | |
| 리턴 | void | |
public static void EndOptimizedMode()
{
if (TimeEndPeriod(caps.wPeriodMin) != 0)
{
Debug.ThrowError("StopWatch", "TimeEndPeriod failed");
}
}
private static void asyncUpdateLoad()
{
if (ItemsRemainingToLoad == 0)
{
aysncLoadDone = true;
return;
}
foreach (var loadable in loadables.ToArray())
{
try
{
if (loadable.UpdateLoad() || loadable.FailedToLoad)
{
loadables.Remove(loadable);
if (loadable.FailedToLoad)
{
Debug.ThrowError("Loader", "Failed to load object");
}
}
}
catch (Exception e)
{
loadables.Remove(loadable);
asyncLoadingExeception = e;
break;
}
}
aysncLoadDone = true;
}
protected Dictionary <string, object> createDictionaryFromMethod(Type type, string methodName, params ConstructorParam[] methodParameters)
{
var types = new Type[methodParameters.Length];
for (int i = 0; i != methodParameters.Length; ++i)
{
types[i] = methodParameters[i].Type;
}
#if WINRT
var methodInfo = type.GetRuntimeMethod(methodName, types);
#else
var methodInfo = type.GetMethod(methodName, types);
#endif
if (methodInfo == null)
{
Debug.ThrowError("DisposableResource", "Invalid method name.");
}
var perameters = methodInfo.GetParameters();
if (methodParameters.Length != perameters.Length)
{
Debug.ThrowError("DisposableResource", "MethodParameters count do not match MethedInfo.");
}
var dictionary = new Dictionary <string, object>();
for (int i = 0; i != methodParameters.Length; ++i)
{
dictionary.Add(perameters[i].Name, methodParameters[i]);
}
return(dictionary);
}
public void Init(ApplicationDesc desc)
{
theEvent = new ApplicationEvent();
var frame = desc.FrameSize;
if (frame.Width == 0 || frame.Height == 0)
{
frame = (OS.ScreenSize.ToVector2() / 1.5f).ToSize();
}
SetContentSize(new SizeF(frame.Width, frame.Height));
lastFrameSize = frame;
AcceptsMouseMovedEvents = true;
View = new NSView();
switch (desc.StartPosition)
{
case (ApplicationStartPositions.CenterCurrentScreen): Center(); break;
}
switch (desc.Type)
{
case (ApplicationTypes.Box): StyleMask = NSWindowStyle.Borderless; break;
case (ApplicationTypes.Frame): StyleMask = NSWindowStyle.Titled | NSWindowStyle.Miniaturizable | NSWindowStyle.Closable; break;
case (ApplicationTypes.FrameSizable): StyleMask = NSWindowStyle.Titled | NSWindowStyle.Resizable | NSWindowStyle.Miniaturizable | NSWindowStyle.Closable; break;
default: Debug.ThrowError("NSWindow", "Unsuported window type"); break;
}
Title = desc.Name;
ContentView = View;
WillClose += closingEvent;
}
public static BoundingBox2 FromPoints(IList <Vector2> points)
{
BoundingBox2 boundingBox;
#if DEBUG
if (points.Count == 0)
{
Debug.ThrowError("BoundingBox2", "Cannot construct a bounding box from an empty list");
}
#endif
boundingBox.Min = points[0];
boundingBox.Max = boundingBox.Min;
foreach (var point in points)
{
if (point.X < boundingBox.Min.X)
{
boundingBox.Min.X = point.X;
}
else if (point.X > boundingBox.Max.X)
{
boundingBox.Max.X = point.X;
}
if (point.Y < boundingBox.Min.Y)
{
boundingBox.Min.Y = point.Y;
}
else if (point.Y > boundingBox.Max.Y)
{
boundingBox.Max.Y = point.Y;
}
}
return(boundingBox);
}
private Dictionary <string, object> createDictionaryFromConstructor(Type type, params ConstructorParam[] constructorParameters)
{
var types = new Type[constructorParameters.Length];
for (int i = 0; i != constructorParameters.Length; ++i)
{
types[i] = constructorParameters[i].Type;
}
#if WINRT
ConstructorInfo constructor = null;
foreach (var c in type.GetTypeInfo().DeclaredConstructors)
{
bool pass = true;
var args = c.GetGenericArguments();
if (types.Length == args.Length)
{
for (int i = 0; i != args.Length; ++i)
{
if (types[i] != args[i])
{
pass = false;
break;
}
}
}
else
{
pass = false;
}
if (pass)
{
constructor = c;
break;
}
}
#else
var constructor = type.GetConstructor(types);
#endif
if (constructor == null)
{
Debug.ThrowError("DisposableResource", "Invalid constructor parameters");
}
var perameters = constructor.GetParameters();
if (constructorParameters.Length != perameters.Length)
{
Debug.ThrowError("DisposableResource", "ConstructorParameters count do not match ConstructorInfo");
}
var dictionary = new Dictionary <string, object>();
for (int i = 0; i != constructorParameters.Length; ++i)
{
dictionary.Add(perameters[i].Name, constructorParameters[i].Value);
}
return(dictionary);
}
public void Init(ApplicationDesc desc)
{
theEvent = new ApplicationEvent();
var frame = desc.FrameSize;
if (frame.Width == 0 || frame.Height == 0)
{
frame = (OS.ScreenSize.ToVector2() / 1.5f).ToSize2();
}
//X11.XInitThreads();// Only needed for multi threaded applications.
dc = X11.XOpenDisplay(IntPtr.Zero);
if (dc == IntPtr.Zero)
{
Debug.ThrowError("Window", "Cannot open Display");
}
sc = X11.XDefaultScreen(dc);
Handle = X11.XCreateSimpleWindow(dc, X11.XRootWindow(dc, sc), 0, 0, (uint)frame.Width, (uint)frame.Height, 0, X11.XBlackPixel(dc, sc), X11.XWhitePixel(dc, sc));
X11.XSelectInput(dc, Handle, X11.ExposureMask | X11.KeyPressMask | X11.KeyReleaseMask | X11.ButtonPressMask | X11.ButtonReleaseMask);
// Enable Capture of close box
var normalHint = X11.XInternAtom(dc, "WM_NORMAL_HINTS", false);
var deleteHint = X11.XInternAtom(dc, "WM_DELETE_WINDOW", false);
X11.XSetWMProtocols(dc, Handle, new IntPtr[] { normalHint, deleteHint }, 2);
X11.XStoreName(dc, Handle, desc.Name);
// Size
if (desc.Type == ApplicationTypes.Frame || desc.Type == ApplicationTypes.FrameSizable || desc.Type == ApplicationTypes.Box)
{
unsafe
{
var sizeHints = new X11.XSizeHints();
var flags = X11.XSizeHintsFlags.PPosition;
if (desc.Type != ApplicationTypes.FrameSizable)
{
flags |= X11.XSizeHintsFlags.PMinSize | X11.XSizeHintsFlags.PMaxSize;
sizeHints.min_width = sizeHints.max_width = frame.Width;
sizeHints.min_height = sizeHints.max_height = frame.Height;
}
sizeHints.flags = (IntPtr)flags;
X11.XSetNormalHints(dc, Handle, &sizeHints);
}
}
// Position
if (desc.StartPosition == ApplicationStartPositions.CenterCurrentScreen)
{
var screenSize = OS.ScreenSize;
X11.XMoveWindow(dc, Handle, (screenSize.Width - frame.Width) / 2, (screenSize.Height - frame.Height) / 2);
}
}
public void Init(ApplicationDesc desc)
{
#if XNA
graphics = new GraphicsDeviceManager(this);
graphics.PreparingDeviceSettings += graphics_PreparingDeviceSettings;
graphics.SynchronizeWithVerticalRetrace = true;
if (desc.DepthBit == -1)
{
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24;
}
else if (desc.DepthBit == 24 && desc.StencilBit == 8)
{
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
}
else if (desc.DepthBit == 24 && desc.StencilBit == 0)
{
graphics.PreferredDepthStencilFormat = DepthFormat.Depth24;
}
else if (desc.DepthBit == 16)
{
graphics.PreferredDepthStencilFormat = DepthFormat.Depth16;
}
else if (desc.DepthBit == 0)
{
graphics.PreferredDepthStencilFormat = DepthFormat.None;
}
else
{
Debug.ThrowError("XNAApplication", string.Format("Unsuported DepthBit: {0} or StencilBit: {1}", desc.DepthBit, desc.StencilBit));
}
var frame = desc.FrameSize;
#if XBOX360
if (frame.Width == 0 || frame.Height == 0)
{
var display = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode;
frame = new Size2(display.Width, display.Height);
}
graphics.PreferredBackBufferWidth = frame.Width;
graphics.PreferredBackBufferHeight = frame.Height;
#else
if (frame.Width == 0 || frame.Height == 0)
{
frame = (OS.ScreenSize.ToVector2() / 1.5f).ToSize2();
}
graphics.PreferredBackBufferWidth = frame.Width;
graphics.PreferredBackBufferHeight = frame.Height;
#endif
var gsc = new GamerServicesComponent(this);
Components.Add(gsc);
Content.RootDirectory = "";
#endif
}
public static Stream SaveFile(string filename, FolderLocations folderLocation)
#endif
{
#if OSX || iOS
throw new NotImplementedException();
#elif ANDROID
throw new NotImplementedException();
#elif NaCl
throw new NotImplementedException();
#elif WINRT || WP8
filename = filename.Replace('/', '\\');
switch (folderLocation)
{
case FolderLocations.Application:
var appFolder = Package.Current.InstalledLocation;
return(await appFolder.OpenStreamForWriteAsync(filename, CreationCollisionOption.ReplaceExisting));
case FolderLocations.Storage:
var storageFolder = ApplicationData.Current.LocalFolder;
return(await storageFolder.OpenStreamForWriteAsync(filename, CreationCollisionOption.ReplaceExisting));
case FolderLocations.Documents:
var docFile = await KnownFolders.DocumentsLibrary.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
return(await docFile.OpenStreamForWriteAsync());
case FolderLocations.Pictures:
var picFile = await KnownFolders.PicturesLibrary.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
return(await picFile.OpenStreamForWriteAsync());
case FolderLocations.Music:
var musicFile = await KnownFolders.MusicLibrary.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
return(await musicFile.OpenStreamForWriteAsync());
case FolderLocations.Video:
var videoFile = await KnownFolders.VideosLibrary.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
return(await videoFile.OpenStreamForWriteAsync());
default:
Debug.ThrowError("Streams", "Unsuported folder location: " + folderLocation.ToString());
break;
}
return(null);
#else
#if LINUX
filename = filename.Replace('\\', '/');
#else
filename = filename.Replace('/', '\\');
#endif
return(new FileStream(filename, FileMode.Create, FileAccess.Write));
#endif
}
public async void BuyInAppItem(string appID)
{
if (BuyAppCallback != null)
{
BuyAppCallback(await coreMetroWindow.BuyInAppItem(appID));
}
else
{
Debug.ThrowError("MetroApplication", "BuyAppCallback method cannot be null");
}
}
public static bool FileExists(string filename, FolderLocations folderLocation)
#endif
{
#if OSX || iOS
throw new NotImplementedException();
#elif ANDROID
throw new NotImplementedException();
#elif NaCl
throw new NotImplementedException();
#elif WINRT || WP8
filename = filename.Replace('/', '\\');
try
{
switch (folderLocation)
{
case FolderLocations.Application:
var appFolder = Package.Current.InstalledLocation;
return((await appFolder.GetFileAsync(filename)) != null);
case FolderLocations.Storage:
var storageFolder = ApplicationData.Current.LocalFolder;
return((await storageFolder.GetFileAsync(filename)) != null);
case FolderLocations.Documents:
return((await KnownFolders.DocumentsLibrary.GetFileAsync(filename)) != null);
case FolderLocations.Pictures:
return((await KnownFolders.PicturesLibrary.CreateFileAsync(filename)) != null);
case FolderLocations.Music:
return((await KnownFolders.MusicLibrary.CreateFileAsync(filename)) != null);
case FolderLocations.Video:
return((await KnownFolders.VideosLibrary.CreateFileAsync(filename)) != null);
default:
Debug.ThrowError("Streams", "Unsuported folder location: " + folderLocation.ToString());
break;
}
}
catch
{
return(false);
}
return(false);
#else
#if LINUX
filename = filename.Replace('\\', '/');
#else
filename = filename.Replace('/', '\\');
#endif
throw new NotImplementedException();
#endif
}
public static void OptimizedMode()
{
caps = new TimeCaps();
if (TimeGetDevCaps(ref caps, (uint)System.Runtime.InteropServices.Marshal.SizeOf(caps)) != 0)
{
Debug.ThrowError("StopWatch", "TimeGetDevCaps failed");
}
if (TimeBeginPeriod(caps.wPeriodMin) != 0)
{
Debug.ThrowError("StopWatch", "TimeBeginPeriod failed");
}
}
public T FindParentOrSelfWithException <T>() where T : DisposableResource
{
if (this.GetType() == typeof(T))
{
return((T)this);
}
var parent = FindParent <T>();
if (parent == null)
{
Debug.ThrowError("DisposableResource", "Failed to find disposable parent of type: " + typeof(T).ToString());
return(null);
}
else
{
return(parent);
}
}
private static PickerLocationId getFolderType(FolderLocations folderLocation)
{
PickerLocationId folder = PickerLocationId.Desktop;
switch (folderLocation)
{
case FolderLocations.Documents: folder = PickerLocationId.DocumentsLibrary; break;
case FolderLocations.Pictures: folder = PickerLocationId.PicturesLibrary; break;
case FolderLocations.Music: folder = PickerLocationId.MusicLibrary; break;
case FolderLocations.Video: folder = PickerLocationId.VideosLibrary; break;
default: Debug.ThrowError("Streams", "Unsuported folder location"); break;
}
return(folder);
}
private void init(IDisposableResource parent, Dictionary <string, object> constructorParameters)
{
DisposableResource disposable = null;
if (parent != null)
{
disposable = parent as DisposableResource;
if (disposable == null)
{
Debug.ThrowError("DisposableResource", "Parent object must be a DisposableResource class object, NOT just an interface");
}
}
this.parent = disposable;
if (this.parent != null)
{
this.parent.children.Add(this);
}
children = new List <DisposableResource>();
referenceCount = 1;
this.constructorParameters = constructorParameters;
}
public ApplicationPage(string applicationID, string unitID, ApplicationAdSize adSize, ApplicationAdGravity adGravity, bool supportAds)
{
swapChainPanel = new SwapChainBackgroundPanel();
if (supportAds)
{
adControl = new AdControl();
adControl.ApplicationId = applicationID;
adControl.AdUnitId = unitID;
adControl.IsEnabled = false;
adControl.Visibility = Visibility.Collapsed;
switch (adSize)
{
case ApplicationAdSize.Sqaure_250x250:
adControl.Width = 250;
adControl.Height = 250;
break;
default:
Debug.ThrowError("ApplicationPage", "Unsuported Ad size");
break;
}
switch (adGravity)
{
case ApplicationAdGravity.BottomLeft:
adControl.HorizontalAlignment = HorizontalAlignment.Left;
adControl.VerticalAlignment = VerticalAlignment.Bottom;
break;
case ApplicationAdGravity.BottomRight:
adControl.HorizontalAlignment = HorizontalAlignment.Right;
adControl.VerticalAlignment = VerticalAlignment.Bottom;
break;
case ApplicationAdGravity.BottomCenter:
adControl.HorizontalAlignment = HorizontalAlignment.Center;
adControl.VerticalAlignment = VerticalAlignment.Top;
break;
case ApplicationAdGravity.TopLeft:
adControl.HorizontalAlignment = HorizontalAlignment.Left;
adControl.VerticalAlignment = VerticalAlignment.Top;
break;
case ApplicationAdGravity.TopRight:
adControl.HorizontalAlignment = HorizontalAlignment.Right;
adControl.VerticalAlignment = VerticalAlignment.Top;
break;
case ApplicationAdGravity.TopCenter:
adControl.HorizontalAlignment = HorizontalAlignment.Center;
adControl.VerticalAlignment = VerticalAlignment.Top;
break;
default:
Debug.ThrowError("ApplicationPage", "Unsuported Ad gravity");
break;
}
swapChainPanel.Children.Add(adControl);
}
base.Content = swapChainPanel;
((XAMLApplication)OS.CurrentApplication).SwapChainPanel = swapChainPanel;
}
public static Stream OpenFile(string filename, FolderLocations folderLocation)
#endif
{
if (folderLocation == FolderLocations.Unknown)
{
Debug.ThrowError("Streams", "Unsuported folder type: " + folderLocation.ToString());
}
#if OSX || iOS
filename = filename.Replace('\\', '/');
string directory = GetFileDirectory(filename);
string ext = GetFileExt(filename);
ext = (ext.Length > 0) ? ext.Remove(0, 1) : "";
string file = GetFileNameWithoutExt(filename);
string path = NSBundle.MainBundle.PathForResource(file, ext, directory, "");
if (string.IsNullOrEmpty(path))
{
Debug.ThrowError("Streams", "Could not find file: " + filename);
}
return(new FileStream(path, FileMode.Open, FileAccess.Read));
#elif ANDROID
try
{
filename = filename.Replace('\\', '/');
using (var stream = ((AndroidApplication)OS.CurrentApplication).Assets.Open(filename))
{
return(CopyToMemoryStream(stream));
}
}
catch (Exception e)
{
Debug.ThrowError("Streams", "Could not find file: " + filename + " - SubErrorMessage: " + e.Message);
return(null);
}
#elif NaCl
Debug.ThrowError("Streams", "Method not supported in NaCl. Use StreamLoader instead");
return(null);
#elif WINRT || WP8
filename = filename.Replace('/', '\\');
switch (folderLocation)
{
case FolderLocations.Application:
var appFolder = Package.Current.InstalledLocation;
return(await appFolder.OpenStreamForReadAsync(filename));
case FolderLocations.Storage:
var storageFolder = ApplicationData.Current.LocalFolder;
return(await storageFolder.OpenStreamForReadAsync(filename));
case FolderLocations.Documents:
var docFile = await KnownFolders.DocumentsLibrary.GetFileAsync(filename);
return(await docFile.OpenStreamForReadAsync());
case FolderLocations.Pictures:
var picFile = await KnownFolders.PicturesLibrary.GetFileAsync(filename);
return(await picFile.OpenStreamForReadAsync());
case FolderLocations.Music:
var musicFile = await KnownFolders.MusicLibrary.GetFileAsync(filename);
return(await musicFile.OpenStreamForReadAsync());
case FolderLocations.Video:
var videoFile = await KnownFolders.VideosLibrary.GetFileAsync(filename);
return(await videoFile.OpenStreamForReadAsync());
}
return(null);
#elif SILVERLIGHT
filename = filename.Replace('\\', '/');
var file = Application.GetResourceStream(new Uri(filename, UriKind.Relative));
if (file == null)
{
Debug.ThrowError("Streams", "Failed to find file: " + filename);
}
return(file.Stream);
#else
#if LINUX
filename = filename.Replace('\\', '/');
#else
filename = filename.Replace('/', '\\');
#if VITA
filename = "/Application/" + filename;
#endif
#endif
return(new FileStream(filename, FileMode.Open, FileAccess.Read));
#endif
}
