Merge remote-tracking branch 'origin/master' into no-reflect

Move installer to destination directory

This reduces the garbage left behind by the installer generation script.

Streamlined nsis installer

OpenAL is now included in the Dependencies/ folder and NShader is no
longer linked to by the installer.

Ignore generated installers

Corrected zip build script

Excluded items are now really excluded.

Reduce temporary string allocations

Instead of modifying the name of an OpenGL symbol on the managed side,
before copying it to the unmanaged side, we perform the modification
directly on the unmanaged side. This reduces the total amount of
allocations in OpenTK by ~30% (673496 bytes in 10750 objects compared
to 930272 bytes in 15243 objects before this modification.)

Added debug arguments in release builds

Generate debug symbols in release builds

Updated project files

Generate debug symbols on release builds. Remove unused resx file that
referenced WinForms.

Implemented manual marshaling of string parameters

Correct convenience wrapper implementation

Convert string[] callsites to IntPtr

This fixes the signature mismatch between the new marshaling code and
the callsites.

Implemented marshaling for string arrays

This allows functions such as GL.ShaderSource to run on Mono without
crashing.

Regenerated bindings

Clean up wrapper generation

We can now apply multiple WrapperTypes values to a single parameter.

Update WrapperTypes values for [Flags]

Removed duplicate ldarg

Workaround for #5

WS_CLIPCHILDREN and WS_CLIPSIBLINGS appear to cause flickering on
specific video cards. OpenGL appears to work correctly without these, so
we'll disable them to return to OpenTK 1.0 behavior.

Fixed centering for non DPI-aware applications

DPI-scaling should affect resolution

The correct resolution will now be reported depending on whether the
application is DPI-aware.

High-resolution mode is enabled by default

Made DPI-awareness configurable (issue #6)

It is now possible to indicate that an application is not DPI-aware. In
that case, OpenTK will let the operating system handle DPI scaling. This
results in worse visuals (pixel doubling) but allows non DPI-aware
applications to continue working.

Removed unused code

Added MonoDevelop project policy

Initial implementation of manual StringBuilder marshaling (WIP)

The implementation is based on Marshal.AllocHGlobal and
Marshal.FreeHGlobal. This is not working correctly yet.

Added manual marshaling for StringBuilder

Mono fails to marshal StringBuilder arguments in unmanaged callsites
invoked through calli. We need to implement the marshaling code
ourselves.

Use StdCall calling convention by default

It appears that calli callsites cannot be decorated with the
“platformapi” calling convention like DllImport signatures can. This is
problematic since Windows uses stdcall by default and most other
platforms use cdecl.

There are three approaches to this issue, without going back to
delegate calls: (a) generate an unmanaged thunk that cleans up the
stack after a GL call; (b) use libFFI; (c) use cdecl *or* stdcall
everywhere and hope that the runtime can cope.

.Net 2.0 can detect and fix stdcall functions invoked through a cdecl
callsite. .Net 4.0 adds a configuration option to enable or disable
this fixup (faster p/invoke if disabled) and raise a MDA exception when
this condition is detected. (This affects x86 only.)

Mono appears to be able to cope with cdecl functions invoked through a
stdcall callsite.

More testing is required.

Mark slots with [DllImport]; remove "core" and "delegates" generation

We should be able to use static pinvokes on platforms that do not
provide or require extensions and calli instructions on platforms with
extension APIs. This dinstiction will be implemented as a parameter in
the rewriter.

Regenerated bindings

Enabled symbol generation; minor code cleanup

Use untyped int for enums in unmanaged callsites

By using untyped integers instead of typed integers in the unmanaged
callsites, we allow monolinker to keep the exact set of enums that are
used by the user. Without this, we’d have to keep every single enum in
place to avoid missing type exceptions.

This does not affect the public signatures or the generated code in any
way.

Load system types from referenced mscorlib

Use C calling convention even on Windows

Corrected the handling of arrays

This includes arrays of primitives and arrays of generics. Our code is
similar to the code generated by the Mono C# compiler for the "fixed"
construct. The .Net compiler produces slightly different code (two local
variables instead of one) - more research is required.

Refactored il emitters into methods

Use unmanaged StdCall calling convention

Default results in a managed calling convention which does not generate
unmanaged thunking code for parameter marshaling.
System.Runtime.InteropServices.CallingConvention.Winapi appears to
correspond to StdCall for calli callsites (this might be different for
pinvoke, which supports an unmanaged "platformapi" calling convention.)
Needs more testing to prove this is doing the right thing on non-Windows
platforms.

Removed deleted file from project

Removed unused WGL methods

WGL was autogenerated a few years ago but never touched after that.
Since we use a tiny fraction of all available methods, it makes sense to
remove the unused ones. This reduces dll size and improves startup
times.

Added GetProcAddress(IntPtr) overloads

This might allow us to improve startup performance, by avoiding string
marshaling during extension loading.

Fixed wglGetProcAddress entry point

A typo would cause extension loading to fail. This is now fixed.

Removed unused WGL bindings

Our WGL bindings contained dozens of methods that OpenTK did not use.
Removing these reduces the dll size and improves startup times.

Fixed entry point validity check

Enable InitLocals to make peverify happy

Fixed convenience return type implementation

Corrected RewrittenAttribute definition

Build 3.5 profile with Visual Studio

Rewrite nested types

Fixes zero-RVA exception for OpenGL extensions (e.g. GL.Ext etc)

Use [AutoGenerated] only for generated methods

The rewriter will patch the body of methods marked with [AutoGenerated].
Methods that are implemented manually (e.g. various math helper
overloads) should avoid this attribute.

Implemented string return types

Added MonoDevelop artifacts

Regenerated bindings

Implemented convenience wrapper types

Emit native signatures

The patcher uses those signatures to implement wrapper functionality
for the various wrapper types that exist in OpenTK.

Update to latest version from git

Protect against multiple runs; optimize il

Do not emit method bodies.

Rewrite support for [Slot] attribute

Initial work on Pin<> statements (WIP)

Fixed build on Visual Studio

Applied MonoDevelop project style

Corrected keyfile path

Corrected patch for CallReturn<TRet, ...> signatures

.Net will happily execute a calli with a generic return type, whereas
Mono will refuse to. Mono is probably doing the right thing here. Fixed
by resolving the generic return into a concrete type.

Added rewrite postbuild event

Fixed calling convention for non-Windows platforms

Fixed core loading on Windows

On Windows, entry points for OpenGL 1.0 and 1.1 are not exposed by
wglGetProcAddress. We fall back to LoadLibrary+GetProcAddress when
wglProcAddress fails.

Added OpenTK.Rewrite project

Added InteropHelper file

Implemented dll rewriter using Mono.Cecil

Regenerated bindings

Moved address parameter to last place

This way, it is the last item on the evaluation stack before calling the
unmanaged function pointer. This simplifies the calli rewrite procedure.

Removed GLObsolete.cs helper

This file must be recreated using the new loading mechanism.

Regenerated bindings with new loading mechanism

Hooked up new loading mechanism

Hooked up new loading mechanism

Implemented new loading mechanism

Clarified GetAddress documentation

Allow overriding of loading methods

Removed delegates and DllImports

Add slots into entry point table

Generate entry point tables

Moved delegate loaders to the Delegates class

Regenerated bindings with lazy loading

Added support for lazy binding loading

Moved GetExtensionDelegate to the correct position

Added static GetExtensionDelegate implementation

Add test for new text input events

Implemented KeyPress event for Sdl2NativeWindow.

Implemented KeyDown and KeyUp events for Sdl2NativeWindow.

Enabled KeyDown and KeyUp events in NativeWindow.

Implemented direct binding loading

OpenTK normally uses reflection to load bindings, instead of generating
huge constructors. Although reflection is faster on first load (thanks
to reduced JIT overhead), it fails to work correctly with monolinker.
This branch explores the performance of a direct binding.

Fix "CursorVisible bugs"

When we enter the modal resize loop on Windows with ClipCursor set, we
cause a feedback loop where every resize causes the cursor to move and
every move causes a new resize. To fix this, we need to ungrab the
cursor when we are enter the modal loop.

Updated release notes

Updated todo list

Updated build instructions.

Fix exceptions on reused OpenGL context handles

Implementations may reuse OpenGL context handles that have been
destroyed. If a context is finalized but not Disposed, then OpenTK may
keep a reference to the old context handle, causing a crash when the
same handle is returned for a new context. To fix that, new context
handles will now replace old handles in case of a clash.

Destroy SDL window when finalized

SDL_DestroyWindow must be called on the main thread. If the window is
finalized, the finalizer will push a CLOSE event to the event loop
(thread-safe) and the window will be destroyed on the main thread.

Fixed #5

We need to release the cursor before closing a GameWindow, otherwise
subsequent GameWindows may fail to receive mouse events.

Toolkit.Init() now returns a concrete class

This gives us room for expansion in the future, if necessary.

Removed incorrect comment

Fixed #4

Sdl2InputDriver.Dispose() would call SDL_DelEventWatch with a different
"user_data" parameter than SDL_AdEventWatch. This caused the EventFilter
to remain registered and subsequently crash when closing and reopening a
window.