obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

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.

1 files changed, 475 insertions, 0 deletions

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 <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);
+}