Java AWT Native Interface - Revision history

KMaster888: ce

2024-12-31T13:29:05Z

← Previous revision		Revision as of 13:29, 31 December 2024
Line 14:		Line 14:

	== Native painting ==		== Native painting ==
	One can paint as if it is a native application. In [[Microsoft Windows\|Windows]], the JVM will pass a HWND and other window information to the native application so that the application will "know" where to draw. It could use GDI to draw a Rectangle. The window information the native side needs will be in a <code>JAWT_Win32DrawingSurfaceInfo</code> structure (depending on [[~~Operating~~ ~~System~~]]) which can be retrieved with this line: {{code\|lang=c\|1=dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;}}		One can paint as if it is a native application. In [[Microsoft Windows\|Windows]], the JVM will pass a HWND and other window information to the native application so that the application will "know" where to draw. It could use GDI to draw a Rectangle. The window information the native side needs will be in a <code>JAWT_Win32DrawingSurfaceInfo</code> structure (depending on the [[operating system]]) which can be retrieved with this line: {{code\|lang=c\|1=dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;}}

	==References==		==References==

RJFJR: /* AWT Native Interface steps */ rem sect

2024-12-21T06:50:47Z

AWT Native Interface steps: rem sect

← Previous revision		Revision as of 06:50, 21 December 2024
Line 12:		Line 12:

	The AWT Native Interface is very similar to the JNI, and the steps are the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.		The AWT Native Interface is very similar to the JNI, and the steps are the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.

	== AWT Native Interface steps ==
	{{howto\|date=June 2012}}
	A complete walkthrough and demonstrating example of this technology is available on Wikibooks (see link below).

	To begin, a Java application is created. The utilisation of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.

	Following the creation of the Java application, a C++ header file is generated conventionally. Detailed explanations can be found in the Java Native Interface documentation.

	Next, the C++ native code is implemented, typically in a file named "NativeSideCanvas.cpp," and compiled into a library. Further information on this process is provided in the Java Native Interface (JNI) documentation.

	Once the program is constructed, it can be executed as per usual. Upon running the file, a window should appear, displaying, for example, a drawn rectangle. Detailed instructions can be found in the Java Native Interface documentation.

	It's important to note that the AWT Native Interface necessitates the presence of the "jawt.dll" (or "jawt.so") file to run alongside the application. The simplest method to ensure this is by copying the "jawt.dll" file, typically found in the .../jre/bin directory within the JDK's installation path.

	== Native painting ==		== Native painting ==

SabujHossain123: update

2024-12-12T14:12:58Z

update

← Previous revision		Revision as of 14:12, 12 December 2024
Line 7:		Line 7:
	'''Java AWT Native Interface''' ('''JAWT''') is an interface for the [[Java (programming language)\|Java programming language]] that enables [[Rendering (computer graphics)\|rendering]] [[library (computer science)\|libraries]] compiled to [[native code]] to draw directly to a Java [[Abstract Window Toolkit]] (AWT) {{Javadoc:SE\|java/awt\|Canvas\|module=java.desktop}} [[object (computer science)\|object]] drawing surface.		'''Java AWT Native Interface''' ('''JAWT''') is an interface for the [[Java (programming language)\|Java programming language]] that enables [[Rendering (computer graphics)\|rendering]] [[library (computer science)\|libraries]] compiled to [[native code]] to draw directly to a Java [[Abstract Window Toolkit]] (AWT) {{Javadoc:SE\|java/awt\|Canvas\|module=java.desktop}} [[object (computer science)\|object]] drawing surface.

	The [[Java Native Interface]] (JNI) allows developers to add platform-dependent functionality to Java [[application software\|applications]]. The JNI enables developers to add time-critical operations like mathematical calculations and [[3D rendering]].		The [[Java Native Interface]] (JNI) allows developers to add platform-dependent functionality to [[Java (programming language)\|Java]] [[application software\|applications]]. The JNI enables developers to add time-critical operations like [[Mathematics\|mathematical]] calculations and [[3D rendering]].

	Previously, native 3D rendering was challenging because the native code did not have access to the graphic context. The AWT Native Interface is designed to give developers access to an AWT <code>Canvas</code> for direct drawing with native code. In fact, the [[Java 3D]] API extension to the standard [[Java SE]] [[JDK]] relies heavily on the AWT Native Interface to render 3D objects in Java.		Previously, native 3D rendering was challenging because the native code did not have access to the graphic context. The AWT Native Interface is designed to give developers access to an AWT <code>Canvas</code> for direct drawing with native code. In fact, the [[Java 3D]] API extension to the standard [[Java SE]] [[JDK]] relies heavily on the AWT Native Interface to render 3D objects in Java.

	The AWT Native Interface is very similar to the JNI and the steps are the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.		The AWT Native Interface is very similar to the JNI, and the steps are the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.

	== AWT Native Interface steps ==		== AWT Native Interface steps ==
Line 17:		Line 17:
	A complete walkthrough and demonstrating example of this technology is available on Wikibooks (see link below).		A complete walkthrough and demonstrating example of this technology is available on Wikibooks (see link below).

	To begin, a Java application is created. The ~~utilization~~ of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.		To begin, a Java application is created. The utilisation of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.

	Following the creation of the Java application, a C++ header file is generated conventionally. Detailed explanations can be found in the Java Native Interface documentation.		Following the creation of the Java application, a C++ header file is generated conventionally. Detailed explanations can be found in the Java Native Interface documentation.

Tall Tall Mountain at 13:41, 30 August 2024

2024-08-30T13:41:06Z

← Previous revision		Revision as of 13:41, 30 August 2024
Line 15:		Line 15:
	== AWT Native Interface steps ==		== AWT Native Interface steps ==
	{{howto\|date=June 2012}}		{{howto\|date=June 2012}}
	A complete walkthrough example of this technology is available on Wikibooks (see link below).		A complete walkthrough and demonstrating example of this technology is available on Wikibooks (see link below).

	A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).

	To begin, a Java application is created. The utilization of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.		To begin, a Java application is created. The utilization of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.

Codefans: /* External links */ update link version

2024-08-29T04:06:09Z

External links: update link version

← Previous revision		Revision as of 04:06, 29 August 2024
Line 38:		Line 38:
	{{Portal\|Computer programming}}		{{Portal\|Computer programming}}
	{{Wikibooks\|Java Swings/AWT}}		{{Wikibooks\|Java Swings/AWT}}
	*[https://docs.oracle.com/javase/7/docs/technotes/guides/awt/AWT_Native_Interface.html The AWT Native Interface]		*[https://docs.oracle.com/javase/8/docs/technotes/guides/awt/AWT_Native_Interface.html The AWT Native Interface]
	*[https://www.infoworld.com/article/2077589/java-tip-86--support-native-rendering-in-jdk-1-3.html Support native rendering in JDK 1.3]		*[https://www.infoworld.com/article/2077589/java-tip-86--support-native-rendering-in-jdk-1-3.html Support native rendering in JDK 1.3]

Boleyn: needs refs

2024-06-22T17:10:29Z

needs refs

← Previous revision		Revision as of 17:10, 22 June 2024
Line 31:		Line 31:
	== Native painting ==		== Native painting ==
	One can paint as if it is a native application. In [[Microsoft Windows\|Windows]], the JVM will pass a HWND and other window information to the native application so that the application will "know" where to draw. It could use GDI to draw a Rectangle. The window information the native side needs will be in a <code>JAWT_Win32DrawingSurfaceInfo</code> structure (depending on [[Operating System]]) which can be retrieved with this line: {{code\|lang=c\|1=dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;}}		One can paint as if it is a native application. In [[Microsoft Windows\|Windows]], the JVM will pass a HWND and other window information to the native application so that the application will "know" where to draw. It could use GDI to draw a Rectangle. The window information the native side needs will be in a <code>JAWT_Win32DrawingSurfaceInfo</code> structure (depending on [[Operating System]]) which can be retrieved with this line: {{code\|lang=c\|1=dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;}}

			==References==
			{{reflist}}

	== External links==		== External links==

MaybeitsMir: Reverted good faith edits by Editor314159 (talk): "walkthrough" is the proper spelling in this context

2024-05-03T04:04:40Z

Reverted good faith edits by Editor314159 (talk): "walkthrough" is the proper spelling in this context

← Previous revision		Revision as of 04:04, 3 May 2024
Line 15:		Line 15:
	== AWT Native Interface steps ==		== AWT Native Interface steps ==
	{{howto\|date=June 2012}}		{{howto\|date=June 2012}}
	A complete ~~walk through~~ example of this technology is available on Wikibooks (see link below).		A complete walkthrough example of this technology is available on Wikibooks (see link below).

	A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).		A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).

Editor314159 at 04:02, 3 May 2024

2024-05-03T04:02:01Z

← Previous revision		Revision as of 04:02, 3 May 2024
Line 15:		Line 15:
	== AWT Native Interface steps ==		== AWT Native Interface steps ==
	{{howto\|date=June 2012}}		{{howto\|date=June 2012}}
	A complete ~~walkthrough~~ example of this technology is available on Wikibooks (see link below).		A complete walk through example of this technology is available on Wikibooks (see link below).

	A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).		A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).

S. Diala: /* Create a Java application */ I changed the tone or style to reflect the encyclopedic tone used in Wikipedia.

2024-04-06T07:15:43Z

Create a Java application: I changed the tone or style to reflect the encyclopedic tone used in Wikipedia.

← Previous revision		Revision as of 07:15, 6 April 2024
Line 17:		Line 17:
	A complete walkthrough example of this technology is available on Wikibooks (see link below).		A complete walkthrough example of this technology is available on Wikibooks (see link below).

			A comprehensive example demonstrating this technology is available on Wikibooks (refer to the link below).
	=== Create a Java application ===
⚫	~~See~~ the [[Java Native Interface]] ~~article~~ ~~for~~ an ~~explanation~~ of ~~the~~ ~~<code>~~native~~</code>~~ [[keyword ~~(computer programming)\|keyword]]~~ and the ~~<code>~~loadLibrary()~~</code>~~ method. A ~~<code>~~paint()~~</code>~~ method ~~will be simply~~ invoked when the AWT [[event dispatching thread]] "repaints" the screen.

		⚫	To begin, a Java application is created. The utilization of the Java Native Interface is explained in the article. The native keyword and the loadLibrary() method are integral components, while the paint() method is invoked when the AWT event dispatching thread repaints the screen.
	=== Create a C++ header file ===
	Create the [[C++]] [[header file]] as usual. (See [[Java Native Interface]] for more complete explanations.)

			Following the creation of the Java application, a C++ header file is generated conventionally. Detailed explanations can be found in the Java Native Interface documentation.
	=== Implement the C++ native code ===
	Type this in a file named "NativeSideCanvas.cpp" and compile into a library. See [[Java Native Interface]] (JNI) for a more complete explanation. (For [[Solaris (operating system)\|Solaris]] code and other operating systems see links below.)

			Next, the C++ native code is implemented, typically in a file named "NativeSideCanvas.cpp," and compiled into a library. Further information on this process is provided in the Java Native Interface (JNI) documentation.
	=== Run the program ===
	One should run the file as usual. One should then see a window with, for example, a rectangle drawn in it. (See [[Java Native Interface]] for complete instructions.)

			Once the program is constructed, it can be executed as per usual. Upon running the file, a window should appear, displaying, for example, a drawn rectangle. Detailed instructions can be found in the Java Native Interface documentation.
⚫	~~Note:~~ ~~One~~ ~~can~~ ~~notice~~ that the AWT Native Interface ~~requires~~ the "jawt.dll" (or "jawt.so") to run ~~with~~ the application, ~~so the~~ ~~easiest~~ ~~way~~ to do ~~that~~ is copying the "jawt.dll". ~~(should~~ be in the .../jre/bin ~~[[file~~ ~~path]] of~~ the JDK's installation path.~~){{citation needed\|date=June 2012}}~~

		⚫	It's important to note that the AWT Native Interface necessitates the presence of the "jawt.dll" (or "jawt.so") file to run alongside the application. The simplest method to ensure this is by copying the "jawt.dll" file, typically found in the .../jre/bin directory within the JDK's installation path.

	== Native painting ==		== Native painting ==

Manhuntfan200: Fixed grammar and language.

2023-11-07T22:23:25Z

Fixed grammar and language.

← Previous revision		Revision as of 22:23, 7 November 2023
Line 5:		Line 5:
	}}		}}

	'''Java AWT Native Interface''' ('''~~jawt~~''') is an interface for the [[Java (programming language)\|Java programming language]] that enables [[Rendering (computer graphics)\|rendering]] [[library (computer science)\|libraries]] compiled to [[native code]] to draw directly to a Java [[Abstract Window Toolkit]] (AWT) {{Javadoc:SE\|java/awt\|Canvas\|module=java.desktop}} [[object (computer science)\|object]] drawing surface.		'''Java AWT Native Interface''' ('''JAWT''') is an interface for the [[Java (programming language)\|Java programming language]] that enables [[Rendering (computer graphics)\|rendering]] [[library (computer science)\|libraries]] compiled to [[native code]] to draw directly to a Java [[Abstract Window Toolkit]] (AWT) {{Javadoc:SE\|java/awt\|Canvas\|module=java.desktop}} [[object (computer science)\|object]] drawing surface.

	The [[Java Native Interface]] (JNI) allows developers to add platform-dependent functionality to Java [[application software\|applications]]. The JNI enables developers to add time-critical operations like mathematical calculations and [[3D rendering]].		The [[Java Native Interface]] (JNI) allows developers to add platform-dependent functionality to Java [[application software\|applications]]. The JNI enables developers to add time-critical operations like mathematical calculations and [[3D rendering]].

	Previously, native 3D rendering was challenging because the native code ~~didn't~~ have access to the graphic context. The AWT Native Interface is designed to give developers access to an AWT <code>Canvas</code> for direct drawing with native code. In fact, the [[Java 3D]] API extension to the standard [[Java SE]] [[JDK]] relies heavily on the AWT Native Interface to render 3D objects in Java.		Previously, native 3D rendering was challenging because the native code did not have access to the graphic context. The AWT Native Interface is designed to give developers access to an AWT <code>Canvas</code> for direct drawing with native code. In fact, the [[Java 3D]] API extension to the standard [[Java SE]] [[JDK]] relies heavily on the AWT Native Interface to render 3D objects in Java.

	The AWT Native Interface is very similar to the JNI, and the steps are~~, in fact,~~ the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.		The AWT Native Interface is very similar to the JNI and the steps are the same as those of the JNI. See the [[Java Native Interface]] article for an explanation of the JNI techniques employed by the AWT Native Interface. The AWT Native Interface was added to the [[Java platform]] with the [[Java Platform, Standard Edition\|J2SE]] 1.3 ("Kestrel") version.

	== AWT Native Interface steps ==		== AWT Native Interface steps ==