| /* qtgraphics.cpp -- |
| Copyright (C) 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| #include <assert.h> |
| #include <jni.h> |
| #include <QPainter> |
| #include <QBrush> |
| #include <QLinearGradient> |
| #include <QPen> |
| #include <QPaintDevice> |
| #include <QPainterPath> |
| #include <QImage> |
| #include <QColor> |
| #include <gnu_java_awt_peer_qt_QtGraphics.h> |
| #include "nativewrapper.h" |
| #include "qtimage.h" |
| #include "qtstrings.h" |
| #include "qtcomponent.h" |
| #include "qtgraphics.h" |
| #include "qtfont.h" |
| |
| // Constants from java.awt.AlphaComposite |
| #define CLEAR 1 |
| #define SRC 2 |
| #define DST 9 |
| #define SRC_OVER 3 |
| #define DST_OVER 4 |
| #define SRC_IN 5 |
| #define DST_IN 6 |
| #define SRC_OUT 7 |
| #define DST_OUT 8 |
| #define SRC_ATOP 10 |
| #define DST_ATOP 11 |
| #define XOR 12 |
| |
| GraphicsPainter *getPainter( JNIEnv *env, jobject obj ) |
| { |
| jclass cls = env->GetObjectClass( obj ); |
| jfieldID field = env->GetFieldID( cls, "nativeObject", "J" ); |
| return (GraphicsPainter *)env->GetLongField( obj, field ); |
| } |
| |
| static void setNativePtr( JNIEnv *env, jobject obj, void *value ) |
| { |
| jlong longValue = (jlong) value; |
| jclass cls = env->GetObjectClass( obj ); |
| jfieldID field = env->GetFieldID( cls, "nativeObject", "J" ); |
| env->SetLongField( obj, field, longValue ); |
| } |
| |
| static jobject getToolkit( JNIEnv *env, jobject obj ) |
| { |
| jclass cls = env->FindClass( "gnu/java/awt/peer/qt/QtGraphics" ); |
| |
| jfieldID field = env->GetFieldID( cls, "toolkit", |
| "Lgnu/java/awt/peer/qt/QtToolkit;" ); |
| return env->GetObjectField( obj, field ); |
| } |
| |
| ///////////////////////// JNI methods //////////////////////////////// |
| |
| /** |
| * Clones the parent QPainter object. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_cloneNativeContext |
| (JNIEnv *env, jobject obj, jobject parent) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, parent ); |
| assert( painter ); |
| QPainter *newPainter = new GraphicsPainter( painter->device() ); |
| assert( newPainter ); |
| setNativePtr(env, obj, newPainter); |
| } |
| |
| /* |
| * Start of JNI methods |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_initImage |
| (JNIEnv *env, jobject obj, jobject image) |
| { |
| QImage *im = getQtImage( env, image ); |
| assert( im ); |
| QPainter *painter = new GraphicsPainter( im ); |
| assert( painter ); |
| setNativePtr(env, obj, painter); |
| painter->setRenderHint(QPainter::TextAntialiasing); |
| painter->setRenderHint(QPainter::Antialiasing); |
| painter->setRenderHint(QPainter::SmoothPixmapTransform); |
| } |
| |
| /* |
| * Start of JNI methods |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_initVolatileImage |
| (JNIEnv *env, jobject obj, jobject image) |
| { |
| QPixmap *im = getQtVolatileImage( env, image ); |
| assert( im ); |
| QPainter *painter = new GraphicsPainter( im ); |
| assert( painter ); |
| setNativePtr(env, obj, painter); |
| painter->setRenderHint(QPainter::TextAntialiasing); |
| painter->setRenderHint(QPainter::Antialiasing); |
| painter->setRenderHint(QPainter::SmoothPixmapTransform); |
| } |
| |
| /** |
| * Deletes the QPainter |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_delete |
| (JNIEnv *env, jobject obj) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| setNativePtr( env, obj, NULL ); |
| if( painter ) |
| { |
| if( painter->isActive() ) |
| painter->end(); |
| delete painter; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| /* |
| * Sets the clip to a path. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setClipNative |
| (JNIEnv *env, jobject obj, jobject path) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QPainterPath *pp = (QPainterPath *)getNativeObject( env, path ); |
| assert( pp ); |
| painter->setClipPath( *pp ); |
| } |
| |
| /* |
| * Sets the clip to a rectangle. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setClipRectNative |
| (JNIEnv *env, jobject obj, jint x, jint y, jint w, jint h) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| painter->setClipRect( x, y, w, h ); |
| } |
| |
| /* |
| * Intersects a shape with the current clip. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_intersectClipNative |
| (JNIEnv *env, jobject obj, jobject path) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QPainterPath *pp = (QPainterPath *)getNativeObject( env, path ); |
| assert( pp ); |
| painter->setClipPath( *pp, Qt::IntersectClip ); |
| } |
| |
| /* |
| * Intersect a rectangle with the current clip. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_intersectClipRectNative |
| (JNIEnv *env, jobject obj, jint x, jint y, jint w, jint h) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| painter->setClipRect( x, y, w, h, Qt::IntersectClip ); |
| } |
| |
| /* |
| * Returns a QPainterPath object with the clip path of this painter. |
| */ |
| JNIEXPORT jobject JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_getClipNative |
| (JNIEnv *env, jobject obj) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| jclass cls = env->FindClass("gnu/java/awt/peer/qt/QPainterPath"); |
| jmethodID method = env->GetMethodID(cls, "<init>", "()V"); |
| |
| jobject ppo = env->NewObject(cls, method); |
| QPainterPath qpp = painter->clipPath(); |
| setNativeObject(env, ppo, &qpp); |
| |
| env->DeleteLocalRef( cls ); |
| return ppo; |
| } |
| |
| /* |
| * Returns a Rectangle with the bounds of this painters clip path. |
| */ |
| JNIEXPORT jobject JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_getClipBounds |
| (JNIEnv *env, jobject obj) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| qreal x, y, w, h; |
| painter->clipPath().boundingRect().getRect(&x, &y, &w, &h); |
| |
| jclass cls = env->FindClass("java/awt/Rectangle"); |
| assert( cls != NULL); |
| jmethodID mid = env->GetMethodID(cls, "<init>", "(IIII)V"); |
| assert( mid != NULL); |
| jvalue values[4]; |
| |
| values[0].i = (jint) x; |
| values[1].i = (jint) y; |
| values[2].i = (jint) w; |
| values[3].i = (jint) h; |
| |
| return env->NewObjectA(cls, mid, values); |
| } |
| |
| ///////////////////////// Color stuff //////////////////////// |
| /** |
| * |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setColor |
| (JNIEnv *env, jobject obj, jint r, jint g, jint b, jint alpha) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| assert( painter ); |
| painter->currentPen->setColor( QColor(r, g, b, alpha) ); |
| painter->setPen( *painter->currentPen ); |
| painter->currentBrush = new QBrush( QColor(r, g, b, alpha) ); |
| painter->setBrush( *painter->currentBrush ); |
| painter->currentColor = new QColor(r, g, b, alpha); |
| } |
| |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setAlphaNative |
| (JNIEnv *env, jobject obj, jdouble alpha) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| assert( painter ); |
| |
| QColor c = painter->currentPen->color(); |
| c.setAlphaF( (qreal)alpha ); |
| painter->currentPen->setColor(c); |
| |
| c = painter->currentBrush->color(); |
| c.setAlphaF( (qreal)alpha ); |
| painter->currentBrush->setColor( c ); |
| } |
| |
| /* |
| * Class: gnu_java_awt_peer_qt_QtGraphics |
| * Method: drawNative |
| * Signature: (Lgnu/java/awt/peer/qt/QPainterPath;)V |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_drawNative |
| (JNIEnv *env, jobject obj, jobject path) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| assert( painter ); |
| QPainterPath *pp = (QPainterPath *)getNativeObject( env, path ); |
| assert( pp ); |
| painter->setPen( *painter->currentPen ); |
| painter->setBrush( Qt::NoBrush ); |
| painter->drawPath( *pp ); |
| } |
| |
| /* |
| * Class: gnu_java_awt_peer_qt_QtGraphics |
| * Method: fillNative |
| * Signature: (Lgnu/java/awt/peer/qt/QPainterPath;)V |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_fillNative |
| (JNIEnv *env, jobject obj, jobject path) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| assert( painter ); |
| QPainterPath *pp = (QPainterPath *)getNativeObject( env, path ); |
| assert( pp ); |
| |
| painter->setPen(Qt::NoPen); |
| painter->setBrush( *painter->currentBrush ); |
| painter->drawPath( *pp ); |
| } |
| |
| /** |
| * Draws a string. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_drawStringNative |
| (JNIEnv *env, jobject obj, jstring str, jdouble x, jdouble y) |
| { |
| GraphicsPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QString *qStr = getQString(env, str); |
| painter->setBrush( Qt::NoBrush ); |
| painter->setPen( *painter->currentPen ); |
| painter->drawText(QPointF( (qreal)x, (qreal)y ), *qStr); |
| delete qStr; |
| } |
| |
| /* |
| * Sets the native stroke |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setNativeStroke |
| (JNIEnv *env, jobject obj, jobject stroke) |
| { |
| GraphicsPainter *painter = (GraphicsPainter *)getPainter( env, obj ); |
| assert( painter ); |
| QPen *pen = (QPen *)getNativeObject(env, stroke); |
| assert( pen ); |
| painter->currentPen = new QPen( *pen ); |
| painter->setPen( *painter->currentPen ); |
| } |
| |
| /* |
| * Sets the transform |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setQtTransform |
| (JNIEnv *env, jobject obj, jobject matrix) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QMatrix *m = (QMatrix *)getNativeObject( env, matrix ); |
| assert( m ); |
| painter->setMatrix( *m ); |
| } |
| |
| /** |
| * Set the font |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setFontNative |
| (JNIEnv *env, jobject obj, jobject fontpeer) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QFont *font = (QFont *) getFont( env, fontpeer ); |
| assert( font ); |
| painter->setFont( *font ); |
| } |
| |
| /* |
| * Sets Porter-Duff compositing. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setNativeComposite |
| (JNIEnv *env, jobject obj, jint compositeMode) |
| { |
| QPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QPainter::CompositionMode mode; |
| |
| switch( compositeMode ) |
| { |
| case CLEAR: |
| mode = QPainter::CompositionMode_Clear; |
| break; |
| case SRC: |
| mode = QPainter::CompositionMode_Source; |
| break; |
| case DST: |
| mode = QPainter::CompositionMode_Destination; |
| break; |
| case SRC_OVER: |
| mode = QPainter::CompositionMode_SourceOver; |
| break; |
| case DST_OVER: |
| mode = QPainter::CompositionMode_DestinationOver; |
| break; |
| case SRC_IN: |
| mode = QPainter::CompositionMode_SourceIn; |
| break; |
| case DST_IN: |
| mode = QPainter::CompositionMode_DestinationIn; |
| break; |
| case SRC_OUT: |
| mode = QPainter::CompositionMode_SourceOut; |
| break; |
| case DST_OUT: |
| mode = QPainter::CompositionMode_DestinationOut; |
| break; |
| case SRC_ATOP: |
| mode = QPainter::CompositionMode_SourceAtop; |
| break; |
| case DST_ATOP: |
| mode = QPainter::CompositionMode_DestinationAtop; |
| break; |
| case XOR: |
| mode = QPainter::CompositionMode_Xor; |
| break; |
| } |
| painter->setCompositionMode( mode ); |
| } |
| |
| /** |
| * Sets the current brush to a linear gradient. |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_setLinearGradient |
| (JNIEnv *env, jobject obj, jint r1, jint g1, jint b1, jint r2, jint g2, |
| jint b2, jdouble x1, jdouble y1, jdouble x2, jdouble y2, jboolean cyclic) |
| { |
| GraphicsPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| QLinearGradient *lg = new QLinearGradient(QPointF( (qreal)x1, (qreal)y1 ), |
| QPointF( (qreal)x2, (qreal)y2 ) ); |
| lg->setColorAt( (qreal)0.0, QColor(r1, g1, b1) ); |
| lg->setColorAt( (qreal)1.0, QColor(r2, g2, b2) ); |
| if( cyclic == JNI_TRUE ) |
| lg->setSpread( QGradient::ReflectSpread ); |
| else |
| lg->setSpread( QGradient::PadSpread ); |
| painter->currentBrush = new QBrush( *lg ); |
| delete lg; |
| } |
| |
| /* |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_fill3DRect |
| (JNIEnv *env, jobject obj, jint x, jint y, jint w, jint h, jboolean raised) |
| { |
| GraphicsPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| // FIXME: Adjust colors |
| painter->fillRect ( x, y, w, h, QBrush( *painter->currentColor) ); |
| QPen *p = new QPen( *painter->currentColor ); |
| p->setWidth( 1 ); |
| painter->setPen( *p ); |
| painter->drawLine( x + w, y, x + w, y + h); |
| painter->drawLine( x, y + h, x + w, y + h); |
| } |
| |
| /* |
| */ |
| JNIEXPORT void JNICALL Java_gnu_java_awt_peer_qt_QtGraphics_draw3DRect |
| (JNIEnv *env, jobject obj, jint x, jint y, jint w, jint h, jboolean raised) |
| { |
| GraphicsPainter *painter = getPainter( env, obj ); |
| assert( painter ); |
| // FIXME: Adjust colors |
| QPen *p = new QPen( *painter->currentColor ); |
| p->setWidth( 1 ); |
| painter->setPen( *p ); |
| painter->drawLine( x, y, x + w, y ); |
| painter->drawLine( x, y, x, y + h); |
| painter->drawLine( x + w, y, x + w, y + h); |
| painter->drawLine( x, y + h, x + w, y + h); |
| } |