From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../classpath/native/jni/qt-peer/qtgraphics.cpp | 475 +++++++++++++++++++++ 1 file changed, 475 insertions(+) create mode 100644 libjava/classpath/native/jni/qt-peer/qtgraphics.cpp (limited to 'libjava/classpath/native/jni/qt-peer/qtgraphics.cpp') diff --git a/libjava/classpath/native/jni/qt-peer/qtgraphics.cpp b/libjava/classpath/native/jni/qt-peer/qtgraphics.cpp new file mode 100644 index 000000000..efd334292 --- /dev/null +++ b/libjava/classpath/native/jni/qt-peer/qtgraphics.cpp @@ -0,0 +1,475 @@ +/* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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, "", "()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, "", "(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); +} -- cgit v1.2.3