path: root/bundles/org.eclipse.swt/Eclipse SWT PI/wpf/library/os_custom.cpp

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    IBM Corporation - initial API and implementation
 *******************************************************************************/

#include "swt.h"
#include "os_structs.h"
#include "os_stats.h"
#include "string.h"

#define OS_NATIVE(func) Java_org_eclipse_swt_internal_wpf_OS_##func

static JavaVM *jvm = NULL;

/*												*/
/* SWT Handle Table     						*/
/*												*/
#ifndef GCHANDLE_TABLE
#define GCHANDLE_STACKS
public ref class SWTObjectTable {
private:
	static int nextHandle = 0;
	static array<Object^>^table = nullptr;
	static Object^ mutex = gcnew Object();

#ifdef GCHANDLE_STACKS
	static array<int>^exceptions = nullptr;
#endif
	
public:
static int ToHandle(Object^ obj) {
	if (obj == nullptr) return 0;
	System::Threading::Monitor::Enter(mutex);
	if (table == nullptr || nextHandle == -1) {
		int length = 0;
		if (table != nullptr) length = table->GetLength(0);		
		int newLength = length * 2;
		if (newLength < 1024) newLength = 1024;
//		System::Console::Error->WriteLine("\t\t***grow={1}", length, newLength);
		Array::Resize(table, newLength);
#ifdef GCHANDLE_STACKS
		Array::Resize(exceptions, newLength);
#endif
		for (int i=length; i<newLength-1; i++) table[i] = i + 1;
		table[newLength-1] = -1;
		nextHandle = length;
	}
	int handle = nextHandle;
	nextHandle = (int)(Int32)table[handle];
	table[handle] = obj;
#ifdef GCHANDLE_STACKS
	if (jvm) {
		JNIEnv* env;
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
		jclass exceptionClass = env->FindClass("java/lang/Exception");
		exceptions[handle] = (int)env->NewGlobalRef(env->NewObject(exceptionClass, env->GetMethodID(exceptionClass, "<init>", "()V")));
	}
#endif
	System::Threading::Monitor::Exit(mutex);
	return handle + 1;	
}

static Object^ ToObject(int handle) {
	System::Threading::Monitor::Enter(mutex);
	Object^ result = nullptr;
	if (handle > 0) result = table[handle - 1];
	System::Threading::Monitor::Exit(mutex);
	return result;
}

static void Free(int handle) {
	System::Threading::Monitor::Enter(mutex);
	if (handle > 0) {
		table[handle - 1] = nextHandle;
		nextHandle = handle - 1;
#ifdef GCHANDLE_STACKS
		if (exceptions[handle - 1] != 0) {
			JNIEnv* env;
			if (IS_JNI_1_2) {
				jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
			}
			env->DeleteGlobalRef((jobject)exceptions[handle - 1]);
			exceptions[handle - 1] = 0;
		}
#endif
	}
	System::Threading::Monitor::Exit(mutex);
}

static void Dump() {
	System::Threading::Monitor::Enter(mutex);
	for (int i=0; i<table->GetLength(0); i++) {
		if (table[i]->GetType() != Int32::typeid) {
			System::Console::Error->WriteLine("LEAK -> {0}={1} type={2}", i + 1, table[i], table[i]->GetType());
#ifdef GCHANDLE_STACKS
			if (exceptions[i] != 0) {
				JNIEnv* env;
				jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
				jclass exceptionClass = env->FindClass("java/lang/Throwable");
				jmethodID mid = env->GetMethodID(exceptionClass, "printStackTrace", "()V");
				if (mid != NULL) env->CallVoidMethod((jobject)exceptions[i], mid, 0);
			}
#endif
		}
	}
	System::Threading::Monitor::Exit(mutex);
}

};
#endif // GCHANDLE_TABLE

extern "C" {

#ifdef GCHANDLE_TABLE

jint GCHandle_GetHandle(Object^ obj) {
	return obj == nullptr ? 0 : (int)GCHandle::ToIntPtr(GCHandle::Alloc(obj));
}

#else

int SWTObjectTable_ToHandle(Object^ obj) {
	return SWTObjectTable::ToHandle(obj);
}

Object^ SWTObjectTable_ToObject(int handle) {
	return SWTObjectTable::ToObject(handle);
}

void SWTObjectTable_Free(int handle) {
	return SWTObjectTable::Free(handle);
}

#endif // GCHANDLE_TABLE

} // extern "C" ends

/*												*/
/* JNI Ref Cookie       						*/
/*												*/
public ref class JniRefCookie {
public:
	jobject object;
	
	JniRefCookie (JNIEnv* env, jint jniRef) {
		if (jvm == NULL) env->GetJavaVM(&jvm);
		this->object = env->NewGlobalRef((jobject)jniRef);
	}

	~JniRefCookie() {
		this->!JniRefCookie();
	}

	!JniRefCookie() {
		if (object == NULL) return; 	
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			env->DeleteGlobalRef(object);
			if (detach) jvm->DetachCurrentThread();
		}
	}
};


/*												*/
/* Animation									*/
/*												*/

public ref class SWTAnimator : FrameworkElement {
public:
	static DependencyProperty^ DoubleValueProperty = DependencyProperty::Register("DoubleValue", double::typeid, SWTAnimator::typeid, gcnew PropertyMetadata(gcnew PropertyChangedCallback(OnPropertyChanged)));
	static DependencyProperty^ IntValueProperty = DependencyProperty::Register("IntValue", Int32::typeid, SWTAnimator::typeid, gcnew PropertyMetadata(gcnew PropertyChangedCallback(OnPropertyChanged)));
private:
	jmethodID OnPropertyChangedMID;
	JniRefCookie^ cookie;
public:		
	SWTAnimator(JNIEnv* env, jint jniRef) {
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (object) {
			jclass javaClass = env->GetObjectClass(object);
			OnPropertyChangedMID = env->GetMethodID(javaClass, "OnPropertyChanged", "(II)V");
		}
	}
	
	static void OnPropertyChanged(DependencyObject^ obj, DependencyPropertyChangedEventArgs args) {
		SWTAnimator^ animator = (SWTAnimator^) obj;
		animator->callin(obj, args);
	}
	
private:
	void callin (DependencyObject^ obj, DependencyPropertyChangedEventArgs args) {
		jobject object = cookie->object;
		if (object == NULL || OnPropertyChangedMID == NULL) return;
		JNIEnv* env;
		int result = 0;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				int arg0 = TO_HANDLE(obj);
				int arg1 = TO_HANDLE(args);
				env->CallVoidMethod(object, OnPropertyChangedMID, arg0, arg1);
				FREE_HANDLE(arg0);
				FREE_HANDLE(arg1);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}
};

public ref class SWTAnimation : DoubleAnimation {
private:
	JniRefCookie^ cookie;
	jmethodID GetCurrentValueCoreMID;
public: 
	SWTAnimation (JNIEnv* env, jint jniRef) {
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (object) {
			jclass javaClass = env->GetObjectClass(object);
			GetCurrentValueCoreMID = env->GetMethodID(javaClass, "GetCurrentValueCore", "(D)V");
		}
	}
private:
	SWTAnimation (JniRefCookie^ cookie, jmethodID methodID) {
		this->cookie = cookie;
		this->GetCurrentValueCoreMID = methodID;
	}
protected:
	virtual Freezable^ CreateInstanceCore () override {
		return gcnew SWTAnimation(cookie, GetCurrentValueCoreMID);
	}
	virtual double GetCurrentValueCore(double fromVal, double toVal, AnimationClock^ clock) override {
		Nullable<TimeSpan> currentTime = clock->CurrentTime;
		if (currentTime.HasValue) {
			double ms = currentTime.Value.TotalMilliseconds;
			callin(ms);
		}
		return DoubleAnimation::GetCurrentValueCore(fromVal, toVal, clock);
	}
private:
	void callin (double args) {
		jobject object = cookie->object;
		if (object == NULL || GetCurrentValueCoreMID == NULL) return;
		JNIEnv* env;
		int result = 0;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				env->CallVoidMethod(object, GetCurrentValueCoreMID, args);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}	
};

/*												*/
/* Table and Tree Classes						*/
/*												*/

public ref class SWTDockPanel : DockPanel {
public: 
	static DependencyProperty^ JNIRefProperty = DependencyProperty::Register("JNIRef", Int32::typeid, SWTDockPanel::typeid);
private:
	jmethodID OnRenderMID;
	JniRefCookie^ cookie;

	void callin (jmethodID mid, DrawingContext^ context) {
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (cookie == nullptr) {
				cookie = gcnew JniRefCookie(env, (jint)(Int32)GetValue(SWTDockPanel::JNIRefProperty));
			}
			jobject object = cookie->object;
			if (object == NULL) { 
			 	return;
			}
			if (mid == NULL){
				jclass javaClass = env->GetObjectClass(object);
				OnRenderMID = env->GetMethodID(javaClass, "OnRender", "(II)V");
				mid = OnRenderMID;
			}
			if (!env->ExceptionOccurred()) {
				int arg0 = TO_HANDLE(this); 
				int arg1 = TO_HANDLE(context);
				env->CallVoidMethod(object, mid, arg0, arg1);
				FREE_HANDLE(arg0);
				FREE_HANDLE(arg1);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}
protected:
	virtual void OnRender(DrawingContext^ drawingContext) override {
		this->DockPanel::OnRender(drawingContext);
		callin(OnRenderMID, drawingContext);
	}
};

public ref class SWTTreeView : TreeView {
private:
	JniRefCookie^ cookie;
	jmethodID HandlerMID;
	
	void callin (jmethodID mid, RoutedPropertyChangedEventArgs<Object^>^ args) {
		jobject object = cookie->object;
		if (object == NULL || mid == NULL) return;
		JNIEnv* env;
		int result = 0;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				int arg0 = TO_HANDLE(args);
				env->CallVoidMethod(object, mid, arg0);
				FREE_HANDLE(arg0);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}	
protected:
	virtual void OnSelectedItemChanged (RoutedPropertyChangedEventArgs<Object^>^ args) override {
		callin(HandlerMID, args);
		TreeView::OnSelectedItemChanged(args);
	}
public:
	SWTTreeView (JNIEnv* env, jint jniRef) {
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (object) {
			jclass javaClass = env->GetObjectClass(object);
			HandlerMID = env->GetMethodID(javaClass, "OnSelectedItemChanged", "(I)V");
		}
	}	
};

public ref class SWTTreeViewRowPresenter : GridViewRowPresenter {
private: 
	TreeView^ tree;
	static void Handle_Loaded (Object^ sender, RoutedEventArgs^ args) {
		SWTTreeViewRowPresenter^ presenter = (SWTTreeViewRowPresenter^) sender;
		presenter->InvalidateMeasure ();
	}
public:
	SWTTreeViewRowPresenter (Object^ treeview) {
		this->tree = (TreeView^)treeview;
		Loaded += gcnew RoutedEventHandler (&SWTTreeViewRowPresenter::Handle_Loaded);
	}	
protected:
	virtual Size MeasureOverride (Size constraint) override {
		Point point = TranslatePoint(*gcnew Point (0,0), tree);
		Size size = GridViewRowPresenter::MeasureOverride (constraint);
		size.Width -= Math::Min (point.X, size.Width);
		return size;
	}
	virtual Size ArrangeOverride (Size arrangeSize) override {
		double availableWidth = arrangeSize.Width;
		int i = VisualChildrenCount - 1;
		for (; i>=0; i--) {
			UIElement^ child = (UIElement^) GetVisualChild (i);
			GridViewColumn^ column = Columns [i];
			double x = 0;
			double width = 0;
			if (i == 0) {
				width = availableWidth;
			} else {				
				width = column->ActualWidth;
				//if (Double::IsNaN(width)) width = 0;
				x = availableWidth - width;
			}
			width = Math::Max (0.0, width);
			Point^ loc = gcnew Point (x, 0);
			Size^ size = gcnew Size (width, arrangeSize.Height);
			Rect^ rect = gcnew Rect (*loc, *size);
			child->Arrange (*rect);
			availableWidth -= width;
		}
		return arrangeSize;
	}
};


/*												*/
/* Canvas										*/
/*												*/

public ref class SWTCanvas : Canvas {
private:
	DrawingVisual^ _visual;
	jmethodID OnRenderMID;
	JniRefCookie^ cookie;

	void callin (jmethodID mid, DrawingContext^ context) {
		jobject object = cookie->object;
		if (object == NULL || mid == NULL) return;
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				int arg0 = TO_HANDLE(context);
				env->CallVoidMethod(object, mid, arg0);
				FREE_HANDLE(arg0);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}
	void updateVisual(DrawingVisual^ visual) {
		if (_visual != nullptr) {
			RemoveVisualChild(_visual);
		}
		_visual = visual;
		if (_visual != nullptr) {
			AddVisualChild(_visual);
		}
	}
	
protected:
	virtual void OnRender(DrawingContext^ drawingContext) override {
		this->Canvas::OnRender(drawingContext);
		callin(OnRenderMID, drawingContext);
	}
	
	property int VisualChildrenCount {
		virtual int get () override {
			int count = this->Canvas::VisualChildrenCount;
			if (_visual != nullptr) count++;
			return count;
		}
	}
	
	virtual Visual^ GetVisualChild(int index) override {
		if (_visual != nullptr) {
			//int count = this->Canvas::VisualChildrenCount;
			//if (index == count) return _visual;
			if (index == 0) return _visual;
			return this->Canvas::GetVisualChild(index - 1);
		}
		return this->Canvas::GetVisualChild(index);
	}

public:
	SWTCanvas (JNIEnv* env, jint jniRef) {
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (object) {
			jclass javaClass = env->GetObjectClass(object);
			OnRenderMID = env->GetMethodID(javaClass, "OnRender", "(I)V");
		}
		_visual = nullptr;
	}
	property DrawingVisual^ Visual {
		DrawingVisual^ get() {
			return _visual;
		}
		void set(DrawingVisual^ visual) {
			updateVisual(visual);
		}
	}
};

/*												*/
/* Cursor Support Class							*/
/*												*/

public ref class SWTSafeHandle : SafeHandle {
private:
	bool _isIcon;
public:
	SWTSafeHandle (IntPtr handle, bool isIcon) : SafeHandle ((IntPtr)-1, true) {
		this->handle = handle;
		_isIcon = isIcon;
	}
	[DllImport("user32.dll", SetLastError = true)]
	static bool DestroyIcon(int hIcon);

	[DllImport("user32.dll", SetLastError = true)]
	static bool DestroyCursor(int hCursor);
	
	virtual bool ReleaseHandle () override {
		bool result;
		if (_isIcon) {
			result = DestroyIcon((int)handle);
		} else {
			result = DestroyCursor((int)handle);
		}
		handle = (IntPtr)(-1);
		return result;
	}
	property bool IsInvalid {
		virtual bool get() override { return (int)handle == -1; }
	}
};

/*												*/
/* Text Layout Classes							*/
/*												*/

public ref class SWTTextEmbeddedObject : TextEmbeddedObject {
private:
	int _length;
	double _width, _height, _baseline;
	TextRunProperties^ _properties;

public:
	SWTTextEmbeddedObject (TextRunProperties^ properties, int length, double width, double height, double baseline) {
		_properties = properties;
		_length = length;
		_width = width;
		_height = height;
		_baseline = baseline;
	}

	virtual void Draw(DrawingContext^ drawingContext, Point origin, bool rightToLeft, bool sideways) override {
	}
	virtual System::Windows::Rect ComputeBoundingBox(bool rightToLeft, bool sideways) override {
		return System::Windows::Rect(0, 0, _width, _height);
	}
	virtual TextEmbeddedObjectMetrics^ Format(double remainingParagraphWidth) override {
		return gcnew TextEmbeddedObjectMetrics(_width, _height, _baseline);
	}
	property LineBreakCondition BreakAfter {
		virtual LineBreakCondition get() override { return LineBreakCondition::BreakAlways; }
	}
	property LineBreakCondition BreakBefore {
		virtual LineBreakCondition get() override { return LineBreakCondition::BreakAlways; }
	}
	property bool HasFixedSize {
		virtual bool get() override { return true; }
	}
	property System::Windows::Media::TextFormatting::CharacterBufferReference CharacterBufferReference {
		virtual System::Windows::Media::TextFormatting::CharacterBufferReference get() override { throw gcnew Exception("The method or operation is not implemented."); }
	}
	property int Length {
		virtual int get() override { return _length; }
	}
	property TextRunProperties^ Properties {
		virtual TextRunProperties^ get() override { return _properties; }
	}
};

public ref class SWTTextParagraphProperties : TextParagraphProperties {
private:
	System::Windows::FlowDirection _flowDirection;
	System::Windows::TextAlignment _textAlignment;
	bool _firstLineInParagraph;
	TextRunProperties^ _defaultTextRunProperties;
	System::Windows::TextWrapping _textWrap;
	double _indent;
	double _paragraphIndent;
	double _lineHeight;
	System::Collections::Generic::IList<TextTabProperties^>^ _tabs;

public:
	SWTTextParagraphProperties (
		System::Windows::FlowDirection flowDirection,
		System::Windows::TextAlignment textAlignment,
		bool firstLineInParagraph,
		TextRunProperties^ defaultTextRunProperties,
		System::Windows::TextWrapping textWrap,
		double lineHeight,
		double indent,
		System::Collections::Generic::IList<TextTabProperties^>^ tabs)
	{
		_flowDirection = flowDirection;
		_textAlignment = textAlignment;
		_firstLineInParagraph = firstLineInParagraph;
		_defaultTextRunProperties = defaultTextRunProperties;
		_textWrap = textWrap;
		_lineHeight = lineHeight;
		_indent = indent;
		_tabs = tabs;
	}
	property System::Windows::FlowDirection FlowDirection {
		virtual System::Windows::FlowDirection get() override { return _flowDirection; }
	}
	property System::Windows::TextAlignment TextAlignment {
		virtual System::Windows::TextAlignment get() override { return _textAlignment; }
	}
	property bool FirstLineInParagraph {
		virtual bool get() override { return _firstLineInParagraph; }
	}
	property TextRunProperties^ DefaultTextRunProperties {
		virtual TextRunProperties^ get() override { return _defaultTextRunProperties; }
	}
	property System::Windows::TextWrapping TextWrapping {
		virtual System::Windows::TextWrapping get() override { return _textWrap; }
	}
	property double LineHeight {
		virtual double get() override { return _lineHeight; }
	}
	property double Indent {
		virtual double get() override { return _indent; }
	}
	property System::Windows::Media::TextFormatting::TextMarkerProperties^ TextMarkerProperties {
		virtual System::Windows::Media::TextFormatting::TextMarkerProperties^ get() override { return nullptr; }
	}
	property double ParagraphIndent {
		virtual double get() override { return _paragraphIndent; }
	}
	property System::Collections::Generic::IList<TextTabProperties^>^ Tabs {
		virtual System::Collections::Generic::IList<TextTabProperties^>^ get() override { return _tabs; }
	}
};

public ref class SWTTextRunProperties : TextRunProperties {
private:
	System::Windows::Media::Typeface^ _typeface;
	double _emSize;
	double _emHintingSize;
	System::Windows::TextDecorationCollection^ _textDecorations;
	System::Windows::Media::Brush^ _foregroundBrush;
	System::Windows::Media::Brush^ _backgroundBrush;
	System::Windows::BaselineAlignment _baselineAlignment;
	System::Globalization::CultureInfo^ _culture;

public:
	SWTTextRunProperties (
		System::Windows::Media::Typeface^ typeface,
		double size,
		double hintingSize,
		System::Windows::TextDecorationCollection^ textDecorations,
		System::Windows::Media::Brush^  forgroundBrush,
		System::Windows::Media::Brush^ backgroundBrush,
		System::Windows::BaselineAlignment baselineAlignment,
		System::Globalization::CultureInfo^ culture)
	{
		_typeface = typeface;
		_emSize = size;
		_emHintingSize = hintingSize;
		_textDecorations = textDecorations;
		_foregroundBrush = forgroundBrush;
		_backgroundBrush = backgroundBrush;
		_baselineAlignment = baselineAlignment;
		_culture = culture;
	}
	property System::Windows::Media::Typeface^ Typeface {
		virtual System::Windows::Media::Typeface^ get() override { return _typeface; }
	}
	property double FontRenderingEmSize {
		virtual double get() override { return _emSize; }
	}
	property double FontHintingEmSize {
		virtual double get() override { return _emHintingSize; }
	}
	property System::Windows::TextDecorationCollection^ TextDecorations {
		virtual System::Windows::TextDecorationCollection^ get() override { return _textDecorations; }
	}
	property System::Windows::Media::Brush^ ForegroundBrush {
		virtual System::Windows::Media::Brush^ get() override { return _foregroundBrush; }
		void set(System::Windows::Media::Brush^ brush) { _foregroundBrush = brush; }
	}
	property System::Windows::Media::Brush^ BackgroundBrush {
		virtual System::Windows::Media::Brush^ get() override { return _backgroundBrush; }
	}
	property System::Windows::BaselineAlignment BaselineAlignment {
		virtual System::Windows::BaselineAlignment get() override { return _baselineAlignment; }
	}
	property System::Globalization::CultureInfo^ CultureInfo {
		virtual System::Globalization::CultureInfo^ get() override { return _culture; }
	}
	property System::Windows::Media::TextFormatting::TextRunTypographyProperties^ TypographyProperties {
		virtual System::Windows::Media::TextFormatting::TextRunTypographyProperties^ get() override { return nullptr; }
	}
	property System::Windows::Media::TextEffectCollection^ TextEffects {
		virtual System::Windows::Media::TextEffectCollection^ get() override { return nullptr; }
	}
	property System::Windows::Media::NumberSubstitution^ NumberSubstitution {
		virtual System::Windows::Media::NumberSubstitution^ get() override { return nullptr; }
	}
};

public ref class SWTTextSource : TextSource {
private:
	jmethodID GetTextRunMID, GetPrecedingTextMID;
	JniRefCookie^ cookie;
		
public:
	SWTTextSource (JNIEnv* env, jint jniRef) {	
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (object) {
			jclass javaClass = env->GetObjectClass(object);
			GetTextRunMID = env->GetMethodID(javaClass, "GetTextRun", "(I)I");
			GetPrecedingTextMID = env->GetMethodID(javaClass, "GetPrecedingText", "(I)I");
		}
	}
	Object^ callin (jmethodID mid, int arg0) {
		jobject object = cookie->object;
		if (object == NULL || mid == NULL) return nullptr;
		JNIEnv* env;
		bool detach = false;
		int result = 0;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				result = env->CallIntMethod(object, mid, arg0);
			}
			if (detach) jvm->DetachCurrentThread();
		}
		return TO_OBJECT (result);
	}
	
	virtual TextRun^ GetTextRun(int textSourceCharacterIndex) override {
		return (TextRun^) callin(GetTextRunMID, textSourceCharacterIndex);
	}
	virtual TextSpan<CultureSpecificCharacterBufferRange^>^ GetPrecedingText(int textSourceCharacterIndexLimit) override {
		return (TextSpan<CultureSpecificCharacterBufferRange^>^) callin(GetPrecedingTextMID, textSourceCharacterIndexLimit);
	}
	virtual int GetTextEffectCharacterIndexFromTextSourceCharacterIndex(int textSourceCharacterIndex) override {
		return 0;
	}
};

/*												*/
/* Event Handler Class							*/
/*												*/

delegate void NoArgsDelegate ();

ref class SWTHandler {
private:
	jmethodID mid;
	JniRefCookie^ cookie;
	
public:
	SWTHandler() {
	}
	
	SWTHandler(JNIEnv* env, jint jniRef, jstring method, char* signature) {
		const char * methodString;	
		cookie = gcnew JniRefCookie(env, jniRef);
		jobject object = cookie->object;
		if (method) methodString = (const char *) env->GetStringUTFChars(method, NULL);
		if (object && methodString) {
			jclass javaClass = env->GetObjectClass(object);    
			mid = env->GetMethodID(javaClass, methodString, signature);
		}
		if (method && methodString) env->ReleaseStringUTFChars(method, methodString);
	}
	
	void EventHandler (Object^ sender, EventArgs^ e) {
		jobject object = cookie->object;	
		if (object == NULL || mid == NULL) return; 	
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				//TODO alloc sender causes handle table corruption
				int arg0 = TO_HANDLE(sender);
				int arg1 = TO_HANDLE(e);
				env->CallVoidMethod(object, mid, arg0, arg1);
				//env->CallVoidMethod(object, mid, 0, arg1);
				FREE_HANDLE(arg0);
				FREE_HANDLE(arg1);
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}
	
	void TimerHandler (Object^ sender, EventArgs^ e) {
		jobject object = cookie->object;
		if (object == NULL || mid == NULL) return; 	
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				if (sender->GetType() == DispatcherTimer::typeid) {
					DispatcherTimer^ timer = (DispatcherTimer^)sender;
					int index = (int)timer->Tag;
					int arg1 = TO_HANDLE(e);
					env->CallVoidMethod(object, mid, index, arg1);
					FREE_HANDLE(arg1);
				}
			}
			if (detach) jvm->DetachCurrentThread();
		}
	}
	
	void CancelEventHandler (Object^ sender, CancelEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void RoutedEventHandler (Object^ sender, RoutedEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void RoutedPropertyChangedEventHandler  (Object^ sender, RoutedPropertyChangedEventArgs<double>^ e) {
		EventHandler (sender, e);
	}

	void RoutedPropertyChangedEventHandlerObject  (Object^ sender, RoutedPropertyChangedEventArgs<Object^>^ e) {
		EventHandler (sender, e);
	}

	void ExecutedRoutedEventHandler (Object^ sender, ExecutedRoutedEventArgs^ e) {
		EventHandler (sender, e);	
	}
		
	void DispatcherHookEventHandler (Object^ sender, DispatcherHookEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void SizeChangedEventHandler (Object^ sender, SizeChangedEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void ScrollEventHandler (Object^ sender, ScrollEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void SelectionChangedEventHandler (Object^ sender, SelectionChangedEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void KeyEventHandler (Object^ sender, KeyEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void MouseEventHandler (Object^ sender, MouseEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void FormsMouseEventHandler (Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {
		EventHandler (sender, e);	
	}
		
	void MouseButtonEventHandler (Object^ sender, MouseButtonEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void MouseWheelEventHandler (Object^ sender, MouseWheelEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void TextCompositionEventHandler (Object^ sender, TextCompositionEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void TextChangedEventHandler (Object^ sender, TextChangedEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void KeyboardFocusChangedEventHandler (Object^ sender, KeyboardFocusChangedEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void ContextMenuEventHandler (Object^ sender, ContextMenuEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void DragEventHandler (Object^ sender, DragEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void DragDeltaEventHandler (Object^ sender, DragDeltaEventArgs^ e) {
		EventHandler (sender, e);	
	}
		
	void GiveFeedbackEventHandler (Object^ sender, GiveFeedbackEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void QueryContinueDragEventHandler (Object^ sender, QueryContinueDragEventArgs^ e) {
		EventHandler (sender, e);	
	}
		
	void WebBrowserNavigatingEventHandler (Object^ sender, System::Windows::Forms::WebBrowserNavigatingEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void WebBrowserNavigatedEventHandler (Object^ sender, System::Windows::Forms::WebBrowserNavigatedEventArgs^ e) {
		EventHandler (sender, e);	
	}
	
	void WebBrowserProgressChangedEventHandler (Object^ sender, System::Windows::Forms::WebBrowserProgressChangedEventArgs^ e) {
		EventHandler (sender, e);	
	}	
	
	void WebBrowserDocumentCompletedEventHandler (Object^ sender, System::Windows::Forms::WebBrowserDocumentCompletedEventArgs^ e) {
		EventHandler (sender, e);	
	}

	void NoArgsDelegate() {	
		jobject object = cookie->object;
		if (object == NULL || mid == NULL) return; 	
		JNIEnv* env;
		bool detach = false;

#ifdef JNI_VERSION_1_2
		if (IS_JNI_1_2) {
			jvm->GetEnv((void **)&env, JNI_VERSION_1_2);
		}
#endif
		if (env == NULL) {
			jvm->AttachCurrentThread((void **)&env, NULL);
			if (IS_JNI_1_2) detach = true;
		}
		if (env != NULL) {
			if (!env->ExceptionOccurred()) {
				env->CallVoidMethod(object, mid);
			}
			if (detach) jvm->DetachCurrentThread();
		}	
	}
};

#define HANDLER_CONSTRUCTOR(name, type, signature) extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1##name##) (JNIEnv *env, jclass that, jint arg0, jstring arg1); \
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1##name##) (JNIEnv *env, jclass that, jint arg0, jstring arg1) { \
	jint rc = 0; \
	OS_NATIVE_ENTER(env, that, gcnew_1##name##_FUNC); \
	rc = (jint)TO_HANDLE(gcnew type (gcnew SWTHandler(env, arg0, arg1, signature), &SWTHandler::##name##)); \
	OS_NATIVE_EXIT(env, that, gcnew_1##name##_FUNC); \
	return rc; \
} \

#ifndef NO_gcnew_1EventHandler
HANDLER_CONSTRUCTOR (EventHandler, EventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1CancelEventHandler
HANDLER_CONSTRUCTOR (CancelEventHandler, CancelEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1ExecutedRoutedEventHandler
HANDLER_CONSTRUCTOR (ExecutedRoutedEventHandler, ExecutedRoutedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1DispatcherHookEventHandler
HANDLER_CONSTRUCTOR (DispatcherHookEventHandler, DispatcherHookEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1SizeChangedEventHandler
HANDLER_CONSTRUCTOR (SizeChangedEventHandler, SizeChangedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1ScrollEventHandler
HANDLER_CONSTRUCTOR (ScrollEventHandler, ScrollEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1SelectionChangedEventHandler
HANDLER_CONSTRUCTOR (SelectionChangedEventHandler, SelectionChangedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1KeyEventHandler
HANDLER_CONSTRUCTOR (KeyEventHandler, KeyEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1MouseEventHandler
HANDLER_CONSTRUCTOR (MouseEventHandler, MouseEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1FormsMouseEventHandler
HANDLER_CONSTRUCTOR (FormsMouseEventHandler, System::Windows::Forms::MouseEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1MouseButtonEventHandler
HANDLER_CONSTRUCTOR (MouseButtonEventHandler, MouseButtonEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1MouseWheelEventHandler
HANDLER_CONSTRUCTOR (MouseWheelEventHandler, MouseWheelEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1TextCompositionEventHandler
HANDLER_CONSTRUCTOR (TextCompositionEventHandler, TextCompositionEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1TextChangedEventHandler
HANDLER_CONSTRUCTOR (TextChangedEventHandler, TextChangedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1KeyboardFocusChangedEventHandler
HANDLER_CONSTRUCTOR (KeyboardFocusChangedEventHandler, KeyboardFocusChangedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1ContextMenuEventHandler
HANDLER_CONSTRUCTOR (ContextMenuEventHandler, ContextMenuEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1RoutedEventHandler
HANDLER_CONSTRUCTOR (RoutedEventHandler, RoutedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1DragEventHandler
HANDLER_CONSTRUCTOR (DragEventHandler, DragEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1DragDeltaEventHandler
HANDLER_CONSTRUCTOR (DragDeltaEventHandler, DragDeltaEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1GiveFeedbackEventHandler
HANDLER_CONSTRUCTOR (GiveFeedbackEventHandler, GiveFeedbackEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1QueryContinueDragEventHandler
HANDLER_CONSTRUCTOR (QueryContinueDragEventHandler, QueryContinueDragEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1RoutedPropertyChangedEventHandlerObject
HANDLER_CONSTRUCTOR (RoutedPropertyChangedEventHandlerObject, RoutedPropertyChangedEventHandler<Object^>, "(II)V")
#endif

#ifndef NO_gcnew_1RoutedPropertyChangedEventHandler
HANDLER_CONSTRUCTOR (RoutedPropertyChangedEventHandler, RoutedPropertyChangedEventHandler<double>, "(II)V")
#endif

#ifndef NO_gcnew_1WebBrowserNavigatingEventHandler
HANDLER_CONSTRUCTOR (WebBrowserNavigatingEventHandler, System::Windows::Forms::WebBrowserNavigatingEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1WebBrowserNavigatedEventHandler
HANDLER_CONSTRUCTOR (WebBrowserNavigatedEventHandler, System::Windows::Forms::WebBrowserNavigatedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1WebBrowserProgressChangedEventHandler
HANDLER_CONSTRUCTOR (WebBrowserProgressChangedEventHandler, System::Windows::Forms::WebBrowserProgressChangedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1WebBrowserDocumentCompletedEventHandler
HANDLER_CONSTRUCTOR (WebBrowserDocumentCompletedEventHandler, System::Windows::Forms::WebBrowserDocumentCompletedEventHandler, "(II)V")
#endif

#ifndef NO_gcnew_1NoArgsDelegate
HANDLER_CONSTRUCTOR (NoArgsDelegate, NoArgsDelegate, "()V")
#endif

// special cases
#ifndef NO_gcnew_1TimerHandler
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1TimerHandler) (JNIEnv *env, jclass that, jint arg0, jstring arg1);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1TimerHandler) (JNIEnv *env, jclass that, jint arg0, jstring arg1) {
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1TimerHandler_FUNC);
	rc = (jint)TO_HANDLE(gcnew EventHandler (gcnew SWTHandler(env, arg0, arg1, "(II)V"), &SWTHandler::TimerHandler));
	OS_NATIVE_EXIT(env, that, gcnew_1TimerHandler_FUNC);
	return rc;
}
#endif

/*												*/
/* Custom Classes Constructors and Functions	*/
/*												*/

#ifndef NO_gcnew_1SWTCanvas
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTCanvas)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTCanvas)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTCanvas_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTCanvas(env, arg0));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTCanvas_FUNC);
	return rc;
}
#endif

#ifndef NO_SWTDockPanel_1JNIRefProperty
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(SWTDockPanel_1JNIRefProperty)(JNIEnv *env, jclass that);
JNIEXPORT jint JNICALL OS_NATIVE(SWTDockPanel_1JNIRefProperty)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, SWTDockPanel_1JNIRefProperty_FUNC);
	rc = (jint)TO_HANDLE(SWTDockPanel::JNIRefProperty);
	OS_NATIVE_EXIT(env, that, SWTDockPanel_1JNIRefProperty_FUNC);
	return rc;
}
#endif

#ifndef NO_SWTDockPanel_1typeid
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(SWTDockPanel_1typeid)(JNIEnv *env, jclass that);
JNIEXPORT jint JNICALL OS_NATIVE(SWTDockPanel_1typeid)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, SWTDockPanel_1typeid_FUNC);
	rc = (jint)TO_HANDLE(SWTDockPanel::typeid);
	OS_NATIVE_EXIT(env, that, SWTDockPanel_1typeid_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTSafeHandle
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTSafeHandle)(JNIEnv *env, jclass that, jint arg0, jboolean arg1);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTSafeHandle)
	(JNIEnv *env, jclass that, jint arg0, jboolean arg1)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTSafeHandle_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTSafeHandle((IntPtr)arg0, (bool)arg1));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTSafeHandle_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTextSource
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextSource)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextSource)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTextSource_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTextSource(env, arg0));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTextSource_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTextParagraphProperties
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextParagraphProperties)(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6, int arg7);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextParagraphProperties)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jboolean arg2, jint arg3, jint arg4, jdouble arg5, jdouble arg6, int arg7)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTextParagraphProperties_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTextParagraphProperties((FlowDirection)arg0, (TextAlignment)arg1, arg2, (TextRunProperties^)TO_OBJECT(arg3), (TextWrapping)arg4, arg5, arg6, (System::Collections::Generic::IList<TextTabProperties^>^)TO_OBJECT(arg7)));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTextParagraphProperties_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTextEmbeddedObject
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextEmbeddedObject)(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2, jdouble arg3, jdouble arg4);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextEmbeddedObject)
	(JNIEnv *env, jclass that, jint arg0, jint arg1, jdouble arg2, jdouble arg3, jdouble arg4)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTextEmbeddedObject_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTextEmbeddedObject((TextRunProperties^)TO_OBJECT(arg0), arg1, arg2, arg3, arg4));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTextEmbeddedObject_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTextRunProperties
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextRunProperties)(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTextRunProperties)
	(JNIEnv *env, jclass that, jint arg0, jdouble arg1, jdouble arg2, jint arg3, jint arg4, jint arg5, jint arg6, jint arg7)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTextRunProperties_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTextRunProperties((Typeface^)TO_OBJECT(arg0), arg1, arg2, (TextDecorationCollection^)TO_OBJECT(arg3), (Brush^)TO_OBJECT(arg4), (Brush^)TO_OBJECT(arg5), (BaselineAlignment)arg6, (CultureInfo^)TO_OBJECT(arg7)));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTextRunProperties_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTreeView
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTreeView)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTreeView) 
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTreeView_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTreeView(env, arg0));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTreeView_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTTreeViewRowPresenter
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTreeViewRowPresenter)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTTreeViewRowPresenter) 
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTTreeViewRowPresenter_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTTreeViewRowPresenter(TO_OBJECT(arg0)));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTTreeViewRowPresenter_FUNC);
	return rc;
}
#endif

#ifndef NO_gcnew_1SWTAnimator
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTAnimator)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTAnimator)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTAnimator_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTAnimator(env, arg0));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTAnimator_FUNC);
	return rc;
}
#endif

#ifndef NO_SWTTextRunProperties_1ForegroundBrush
extern "C" JNIEXPORT void JNICALL OS_NATIVE(SWTTextRunProperties_1ForegroundBrush)(JNIEnv *env, jclass that, jint arg0, jint arg1);
JNIEXPORT void JNICALL OS_NATIVE(SWTTextRunProperties_1ForegroundBrush)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, SWTTextRunProperties_1ForegroundBrush_FUNC);
	((SWTTextRunProperties^)TO_OBJECT(arg0))->ForegroundBrush = ((Brush^)TO_OBJECT(arg1));
	OS_NATIVE_EXIT(env, that, SWTTextRunProperties_1ForegroundBrush_FUNC);
}
#endif

#ifndef NO_SWTCanvas_1Visual__I
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(SWTCanvas_1Visual__I)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(SWTCanvas_1Visual__I)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, SWTCanvas_1Visual__I_FUNC);
	rc = (jint)TO_HANDLE(((SWTCanvas^)TO_OBJECT(arg0))->Visual);
	OS_NATIVE_EXIT(env, that, SWTCanvas_1Visual__I_FUNC);
	return rc;
}
#endif

#ifndef NO_SWTCanvas_1Visual__II
extern "C" JNIEXPORT void JNICALL OS_NATIVE(SWTCanvas_1Visual__II)(JNIEnv *env, jclass that, jint arg0, jint arg1);
JNIEXPORT void JNICALL OS_NATIVE(SWTCanvas_1Visual__II)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, SWTCanvas_1Visual__II_FUNC);
	((SWTCanvas^)TO_OBJECT(arg0))->Visual = ((DrawingVisual^)TO_OBJECT(arg1));
	OS_NATIVE_EXIT(env, that, SWTCanvas_1Visual__II_FUNC);
}
#endif

#ifndef NO_JNIGetObject
extern "C" JNIEXPORT jobject JNICALL OS_NATIVE(JNIGetObject)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jobject JNICALL OS_NATIVE(JNIGetObject)
	(JNIEnv *env, jclass that, jint arg0)
{
	jobject rc = 0;
	OS_NATIVE_ENTER(env, that, JNIGetObject_FUNC);
	rc = (jobject)arg0;
	OS_NATIVE_EXIT(env, that, JNIGetObject_FUNC);
	return rc;
}
#endif

#ifndef NO_GCHandle_1Free
extern "C" JNIEXPORT void JNICALL OS_NATIVE(GCHandle_1Free) (JNIEnv *env, jclass that, jint arg0);
JNIEXPORT void JNICALL OS_NATIVE(GCHandle_1Free) (JNIEnv *env, jclass that, jint arg0) {
	OS_NATIVE_ENTER(env, that, GCHandle_1Free_FUNC);
	FREE_HANDLE(arg0);
	OS_NATIVE_EXIT(env, that, GCHandle_1Free_FUNC);
}
#endif

#ifndef NO_GCHandle_1Dump
extern "C" JNIEXPORT void JNICALL OS_NATIVE(GCHandle_1Dump) (JNIEnv *env, jclass that);
JNIEXPORT void JNICALL OS_NATIVE(GCHandle_1Dump) (JNIEnv *env, jclass that) {
	OS_NATIVE_ENTER(env, that, GCHandle_1Dump_FUNC);
#ifndef GCHANDLE_TABLE	
	SWTObjectTable::Dump();
#endif	
	OS_NATIVE_EXIT(env, that, GCHandle_1Dump_FUNC);
}
#endif

#ifndef NO_GCHandle_1Alloc
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(GCHandle_1Alloc) (JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(GCHandle_1Alloc) (JNIEnv *env, jclass that, jint arg0) {
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GCHandle_1Alloc_FUNC);
	rc = TO_HANDLE (TO_OBJECT (arg0));	
	OS_NATIVE_EXIT(env, that, GCHandle_1Alloc_FUNC);
	return rc;
}
#endif

#ifndef NO_GCHandle_1ToHandle
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(GCHandle_1ToHandle) (JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(GCHandle_1ToHandle) (JNIEnv *env, jclass that, jint arg0) {
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, GCHandle_1ToHandle_FUNC);
#ifdef GCHANDLE_TABLE	
	rc = arg0; 
#else
	GCHandle gc = GCHandle::FromIntPtr((IntPtr)arg0);
	rc = TO_HANDLE (gc.Target);
	gc.Free();
#endif
	OS_NATIVE_EXIT(env, that, GCHandle_1ToHandle_FUNC);
	return rc;
}
#endif

#ifndef NO_Bitmap_1GetHicon
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(Bitmap_1GetHicon)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(Bitmap_1GetHicon)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, Bitmap_1GetHicon_FUNC);
	rc = (jint)(int)((System::Drawing::Bitmap^)TO_OBJECT(arg0))->GetHicon();
	OS_NATIVE_EXIT(env, that, Bitmap_1GetHicon_FUNC);
	return rc;
}
#endif

#ifndef NO_Icon_1FromHandle
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(Icon_1FromHandle)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(Icon_1FromHandle)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, Icon_1FromHandle_FUNC);
	rc = (jint)TO_HANDLE(System::Drawing::Icon::FromHandle((IntPtr)(int)arg0));
	OS_NATIVE_EXIT(env, that, Icon_1FromHandle_FUNC);
	return rc;
}
#endif

#ifndef NO_memcpy___3CII
extern "C" JNIEXPORT void JNICALL OS_NATIVE(memcpy___3CII)(JNIEnv *env, jclass that, jcharArray arg0, jint arg1, jint arg2);
JNIEXPORT void JNICALL OS_NATIVE(memcpy___3CII)
	(JNIEnv *env, jclass that, jcharArray arg0, jint arg1, jint arg2)
{
	jchar *lparg0=NULL;
	pin_ptr<wchar_t> lparg1; 
	OS_NATIVE_ENTER(env, that, memcpy___3CII_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) if ((lparg0 = (jchar *)env->GetPrimitiveArrayCritical(arg0, NULL)) == NULL) goto fail;
	} else
#endif
	{
		if (arg0) if ((lparg0 = env->GetCharArrayElements(arg0, NULL)) == NULL) goto fail;
	}
	if (arg2 > 0) {
		lparg1 = &((array<wchar_t>^)TO_OBJECT(arg1))[0];
		memcpy(lparg0, lparg1, arg2);
	}
fail:
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0 && lparg0) env->ReleasePrimitiveArrayCritical(arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0 && lparg0) env->ReleaseCharArrayElements(arg0, lparg0, 0);
	}
	OS_NATIVE_EXIT(env, that, memcpy___3CII_FUNC);
}
#endif

#ifndef NO_memcpy__I_3BI
extern "C" JNIEXPORT void JNICALL OS_NATIVE(memcpy__I_3BI)(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jint arg2);
JNIEXPORT void JNICALL OS_NATIVE(memcpy__I_3BI)
	(JNIEnv *env, jclass that, jint arg0, jbyteArray arg1, jint arg2)
{
	jbyte *lparg1=NULL;
	pin_ptr<Byte> lparg0; 
	OS_NATIVE_ENTER(env, that, memcpy__I_3BI_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1) if ((lparg1 = (jbyte*)env->GetPrimitiveArrayCritical(arg1, NULL)) == NULL) goto fail;
	} else
#endif
	{
		if (arg1) if ((lparg1 = env->GetByteArrayElements(arg1, NULL)) == NULL) goto fail;
	}
	if (arg2 > 0) {
		lparg0 = &((array<Byte>^)TO_OBJECT(arg0))[0];
		memcpy(lparg0, lparg1, arg2);	
	}
fail:
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg1 && lparg1) env->ReleasePrimitiveArrayCritical(arg1, lparg1, JNI_ABORT);
	} else
#endif
	{
		if (arg1 && lparg1) env->ReleaseByteArrayElements(arg1, lparg1, JNI_ABORT);
	}
	OS_NATIVE_EXIT(env, that, memcpy__I_3BI_FUNC);
}
#endif

#ifndef NO_memcpy___3BII
extern "C" JNIEXPORT void JNICALL OS_NATIVE(memcpy___3BII)(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2);
JNIEXPORT void JNICALL OS_NATIVE(memcpy___3BII)
	(JNIEnv *env, jclass that, jbyteArray arg0, jint arg1, jint arg2)
{
	jbyte *lparg0=NULL;
	pin_ptr<Byte> lparg1; 
	OS_NATIVE_ENTER(env, that, memcpy___3BII_FUNC);
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0) if ((lparg0 = (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL)) == NULL) goto fail;
	} else
#endif
	{
		if (arg0) if ((lparg0 = env->GetByteArrayElements(arg0, NULL)) == NULL) goto fail;
	}
	if (arg2 > 0) {
		lparg1 = &((array<Byte>^)TO_OBJECT(arg1))[0];
		memcpy(lparg0, lparg1, arg2);
	}
fail:
#ifdef JNI_VERSION_1_2
	if (IS_JNI_1_2) {
		if (arg0 && lparg0) env->ReleasePrimitiveArrayCritical(arg0, lparg0, 0);
	} else
#endif
	{
		if (arg0 && lparg0) env->ReleaseByteArrayElements(arg0, lparg0, 0);
	}
	OS_NATIVE_EXIT(env, that, memcpy___3BII_FUNC);
}
#endif

#ifndef NO_ToggleButton_1IsCheckedNullSetter
extern "C" JNIEXPORT void JNICALL OS_NATIVE(ToggleButton_1IsCheckedNullSetter)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT void JNICALL OS_NATIVE(ToggleButton_1IsCheckedNullSetter)
	(JNIEnv *env, jclass that, jint arg0)
{
	OS_NATIVE_ENTER(env, that, ToggleButton_1IsCheckedNullSetter_FUNC);
	((ToggleButton^)TO_OBJECT(arg0))->IsChecked = Nullable<bool>(); 
	OS_NATIVE_EXIT(env, that, ToggleButton_1IsCheckedNullSetter_FUNC);
}
#endif

#ifndef NO_SWTAnimator_1DoubleValueProperty
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(SWTAnimator_1DoubleValueProperty)(JNIEnv *env, jclass that);
JNIEXPORT jint JNICALL OS_NATIVE(SWTAnimator_1DoubleValueProperty)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, SWTAnimator_1DoubleValueProperty_FUNC);
	rc = (jint)TO_HANDLE(SWTAnimator::DoubleValueProperty);
	OS_NATIVE_EXIT(env, that, SWTAnimator_1DoubleValueProperty_FUNC);
	return rc;
}
#endif

#ifndef NO_SWTAnimator_1IntValueProperty
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(SWTAnimator_1IntValueProperty)(JNIEnv *env, jclass that);
JNIEXPORT jint JNICALL OS_NATIVE(SWTAnimator_1IntValueProperty)
	(JNIEnv *env, jclass that)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, SWTAnimator_1IntValueProperty_FUNC);
	rc = (jint)TO_HANDLE(SWTAnimator::IntValueProperty);
	OS_NATIVE_EXIT(env, that, SWTAnimator_1IntValueProperty_FUNC);
	return rc;
}
#endif

#ifndef NO_Timeline_1BeginTime__II
extern "C" JNIEXPORT void JNICALL OS_NATIVE(Timeline_1BeginTime__II)(JNIEnv *env, jclass that, jint arg0, jint arg1);
JNIEXPORT void JNICALL OS_NATIVE(Timeline_1BeginTime__II)
	(JNIEnv *env, jclass that, jint arg0, jint arg1)
{
	OS_NATIVE_ENTER(env, that, Timeline_1BeginTime__II_FUNC);
	TimeSpan^ span = (TimeSpan^)TO_OBJECT(arg1);
	Timeline^ timeline = (Timeline^)TO_OBJECT(arg0);
	timeline->BeginTime =  (Nullable<TimeSpan>(span));
	OS_NATIVE_EXIT(env, that, Timeline_1BeginTime__II_FUNC);
}
#endif

#ifndef NO_gcnew_1SWTAnimation
extern "C" JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTAnimation)(JNIEnv *env, jclass that, jint arg0);
JNIEXPORT jint JNICALL OS_NATIVE(gcnew_1SWTAnimation)
	(JNIEnv *env, jclass that, jint arg0)
{
	jint rc = 0;
	OS_NATIVE_ENTER(env, that, gcnew_1SWTAnimation_FUNC);
	rc = (jint)TO_HANDLE(gcnew SWTAnimation(env, arg0));
	OS_NATIVE_EXIT(env, that, gcnew_1SWTAnimation_FUNC);
	return rc;
}
#endif