Awt Toolkit Sınıfı

Giriş
Şu satırı dahil ederiz.

import java.awt.Toolkit; 

beep metodu
Örnek ver

getDefaultToolkit metodu
Şöyle yaparız.

Toolkit tk = Toolkit.getDefaultToolkit();

getImage metodu
Şöyle yaparız. Bu metod yerine ImageIO.read() de kullanılabilir.

tk.getImage(getClass().getClassLoader().getResource("something/image.png"));

getScreenInsets metodu
Şöyle yaparız.

JFrame frame = ...;alo
// height of the task bar
java.awt.Insets toolHeight = tk.getScreenInsets(frame.getGraphicsConfiguration());

getScreenSize metodu
Dimension nesnesi döner.
Örnek
Şöyle yaparız.

Dimension scrSize = tk.getScreenSize();// size of the screen

Örnek
Şöyle yaparız.

JFrame aFrame = ...;

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

aFrame.setSize(screenSize.width, screenSize.height);

getSystemClipboard metodu
Şöyle yaparız.

Clipboard clipboard = tk.getSystemClipboard();

Swing FileSystemView Sınıfı

getSystemIcon metodu
Şöyle yaparız.

File file = new File("Whatever.txt");
FileSystemView view = FileSystemView.getFileSystemView();
Icon icon = view.getSystemIcon(file);

swig (Simplified Wrapper and Generator) komutu

Giriş
swig dosyaları genellikle "*.i" uzantısına sahip. swig ile üretilen şeyi ayrı bir jar veya assembly yapmak iyi bir fikir. Açıklaması şöyle.

Whether you are just wrapping a few classes or en entire SDK and whether you write your own C++/CLI interoperability code, it is always good practice to have the C++/CLI code in a separate assembly since you will deal with unmanaged code and unmanaged code debugging which you WANT to centralize in a single component.

Swig Dosyası Formatı
%{...%}
Açıklaması şöyle.

The code between %{ and %} is copied directly into the generated wrapper. 

Örnek
Şeklen şöyledir.

%module foo

%{
#include<foo.h>
%}

%include foo.h

Örnek
Şöyle yaparız

/* file : gfg.i */

/* name of module to use*/
%module gfg 
%{ 
    /* Every thing in this file is being copied in  
     wrapper file. We include the C header file necessary 
     to compile the interface */
    #include "gfg.h" 

    /* variable declaration*/
    double myvar; 
%} 

/* explicitly list functions and variables to be interfaced */
double myvar; 
long long int fact(long long int n1); 
int my_mod(int m, int n); 

/* or if we want to interface all functions then we can simply 
   include header file like this -  
   %include "gfg.h" 
*/

Komut Satırı Seçenekleri

-csharp seçeneği
C# kodu üretmek için kullanırız.
Örnek
C++'tan C# üretmek için şöyle yaparız.

swig -c++ -csharp -v foo.i

Örnek
Bir projede şu seçenekleri kullanarak kod üretmiştik. -c++ ile C++ parsing etkinleştirildi.

swig -c++ -csharp -o cswrapp.cpp -oh cswrap.h -dllimport mylib 
  -outdir d:\test mycs.i

-cgo seçeneği
go dosyası üretmek için -cgo kullanırız. Burada module ismi swig inpute dosyası yerine -module seçeneği ile komut satırından veriliyor. Şöyle yaparız.

swig -go -cgo -intgosize 64 -module mylib \
-o $WORK/mylib/_obj/mylib_wrap.cxx \
-outdir $WORK/mylib/_obj/ \
-I/mylib/lib \
-c++ mylib.swigcxx

-I seçeneği
Include dizinini belirtir.

-python seçeneği
Şöyle yaparız.

$(SWIG_PATH)\swig.exe -python gfg.i

JNI - Java'dan CPP'yi çağırmak

Giriş
Cpp kodu şöyledir.

JNIEXPORT MethodReturnType JNICALL Java_fullclassname_methodname

Diğer
Java'dan çağırmak için
1. Java kodu içinde

public static native MethodReturnType MethodName(MethodParameters);

şeklinde metod tanımlamaları yapılır.
2. Java kodu içinde System.loadLibrary() çağrısı ile .dll veya .so yüklenir.
3. fullclassname ile sınıf yaratılır ve metodu çağrılır

Örnek - Java'dan CPP Üretmek

Elimizde şöyle bir Java kodu olsun

package sample;

public class CalculateMath {
  static {
    System.loadLibrary("mathlib");
  }
  public native int calcSquare(int n);
}

Header dosyası üretmek için şöyle yaparız

javac -h . sample/CalculateMath.java

Üretilen sample_CalculateMath.h dosyası şöyledir

include <jni.h>
/* Header for class sample_CalculateMath */
                        
#ifndef _Included_sample_CalculateMath
#define _Included_sample_CalculateMath
#ifdef __cplusplus
extern "C" {
#endif

  /*
   * Class:     sample_CalculateMath
   * Method:    calcSquare
   * Signature: (I)I
   */
  JNIEXPORT jint JNICALL Java_sample_CalculateMath_calcSquare (JNIEnv *, jobject, jint);
        
#ifdef __cplusplus
}
#endif
#endif

CalculateMath.c dosyasının içini dolduralım

#include "sample_CalculateMath.h"
#include <string.h>

JNIEXPORT jint JNICALL Java_sample_CalculateMath_calcSquare
  (JNIEnv *env, jobject obj, jint num) {
   return num * num;
}

void main(){}

libmathlib.so ismide bir shared object derleyim

gcc -fPIC -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/linux" -shared -o libmathlib.so
 CalculateMath.c

Örnek

Java kodu şöyle olsun.

public class JNItest2 {

public native void helloworld(String[] args);

  static{
    System.loadLibrary("Dense");        
  }
  public static void main(String[] args)
  {        
    new JNItest2().helloworld(args);
  }
}

C metod ismi Java ile başlar, Java sınıf ismi eklenir, metod ismi eklenir. 

İlk parametre JNIEnv, 

İkinci parametre metodu ihtiva eden nesnedir. Eğer metod static ise bu parametreye gerek yok. 

Diğer parametreler metoda geçilen değerler. 

Şöyle yaparız.

JNIEXPORT void JNICALL
Java_JNItest2_helloworld(JNIEnv *env,jobject object, jobjectArray args)
{
...
}   

Örnek
Şöyle yaparız.

#include <jni.h>
#include <string>

extern "C"
JNIEXPORT jstring JNICALL
Java_com_android_app_aesKeyFromJNI(JNIEnv *env, jobject /* this */) {
    std::string secret = "somesecretkey";
    return env->NewStringUTF(secret.c_str());
}

Örnek

Şöyle yaparız.

JNIEXPORT jlong JNICALL Java_com_mypackage_ClipboardHelper_initialize
    (JNIEnv *env, jclass obj, jstring arg) {

Örnek

Şöyle yaparız.
header dosyasında şu include yapılır

#include <jni.h>

cpp şuna benzer.

JNIEXPORT jstring JNICALL Java_six_pack_Neatifier_neatify(JNIEnv* env, 
                                                          jclass clazz, 
                                                          jlong val, 
                                                          jchar pad, 
                                                          jint span)
{
   ... 
   jstring ret = env->NewStringUTF(out);
   return ret;
}

Java'dan DLL'i yükleriz.

System.load(System.getProperty("user.dir") + File.separator +
                        "src" + File.separator + "mylib.jnilib");

Java içinde Cpp ile aynı imzayı taşıyan bir metod tanımlarız.

public static native String neatify(final long val,
                                    final char pad,
                                    final int span);

Metodu çağırırız.

neatify(l, '_', 3);

Örnek

Elimizde şöyle bir java kodu olsun. HashMap parametre olarak metoda geçiliyor.

import java.util.*;  
class javasam{  
  private native void print(HashMap<String,String> hm);
  public static void main(String args[]){  
    HashMap<String,String> hm=new HashMap<String,String>();   
    hm.put("100","Amit");  
    hm.put("101","Vijay");  
    hm.put("102","Rahul");  
    new javasam().print(hm);
  }  
  static {
    System.loadLibrary("javasam");
  }  
}

cpp kodu şöyle olsun. Parametre olarak geçilen nesneye erişiliyor.

#include "stdafx.h"
#include <stdio.h>
#include <jni.h>
#include "javasam.h"
#include <string.h>
#include <map>
#include <iostream>
JNIEXPORT void JNICALL Java_javasam_print (JNIEnv *s, jobject k, jobject l)
{
  jclass mapclass = s->GetObjectClass(l);
  ...
}