Skip to content

GitLab

Commit d5193d93 authored by The Android Open Source Project's avatar The Android Open Source Project
Browse files

auto import from //depot/cupcake/@135843

parent 43aa2b1c
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 4986 deletions

Too many changes to show.

To preserve performance only 163 of 163+ files are displayed.
Plain diff Email patch
MODULE_LICENSE_APACHE2 deleted 100644 → 0
View file @ 43aa2b1c
NOTICE deleted 100644 → 0
View file @ 43aa2b1c
=========================================================================
== NOTICE file corresponding to the section 4 d of ==
== the Apache License, Version 2.0, ==
== in this case for the Android-specific code. ==
=========================================================================
Android Code
Copyright 2005-2008 The Android Open Source Project
This product includes software developed as part of
The Android Open Source Project (http://source.android.com).
=========================================================================
== NOTICE file corresponding to the section 4 d of ==
== the Apache License, Version 2.0, ==
== in this case for Apache Commons code. ==
=========================================================================
Apache Commons
Copyright 1999-2004 The Apache Software Foundation
This product includes software developed at
The Apache Software Foundation (http://www.apache.org/).
=========================================================================
== NOTICE file corresponding to the section 4 d of ==
== the Apache License, Version 2.0, ==
== in this case for Jakarta Commons Logging. ==
=========================================================================
Jakarta Commons Logging (JCL)
Copyright 2005,2006 The Apache Software Foundation.
This product includes software developed at
The Apache Software Foundation (http://www.apache.org/).
=========================================================================
== NOTICE file corresponding to the section 4 d of ==
== the Apache License, Version 2.0, ==
== in this case for the Nuance code. ==
=========================================================================
These files are Copyright 2007 Nuance Communications, but released under
the Apache2 License.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
awt/Android.mk deleted 100644 → 0
View file @ 43aa2b1c
#
# Copyright (C) 2008 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := $(call all-subdir-java-files)
LOCAL_JAVA_RESOURCE_DIRS := resources
LOCAL_JAVA_LIBRARIES := core framework
LOCAL_MODULE:= android.awt
LOCAL_DX_FLAGS := --core-library
include $(BUILD_JAVA_LIBRARY)
awt/com/android/internal/awt/AndroidGraphics2D.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import com.android.internal.awt.AndroidGraphicsConfiguration;
import com.android.internal.graphics.NativeUtils;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.GeneralPath;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.PathIterator;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.RenderableImage;
import java.text.AttributedCharacterIterator;
import java.util.Map;
import org.apache.harmony.awt.gl.ImageSurface;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.font.AndroidGlyphVector;
import org.apache.harmony.awt.gl.font.FontMetricsImpl;
import org.apache.harmony.awt.gl.image.OffscreenImage;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region;
import android.graphics.Typeface;
import android.graphics.PixelXorXfermode;
import android.view.Display;
import android.view.WindowManager;
import android.content.Context;
public class AndroidGraphics2D extends Graphics2D {
private int displayWidth, displayHeight;
protected Surface dstSurf = null;
protected MultiRectArea clip = null;
protected Composite composite = AlphaComposite.SrcOver;
protected AffineTransform transform = new AffineTransform();
private static AndroidGraphics2D mAg;
private static Canvas mC;
// Android Paint
public static Paint mP;
private static java.awt.Font mFnt;
// Cached Matrix
public static Matrix mM;
private static FontMetrics mFm;
private static RenderingHints mRh;
private static Color mBc;
private Area mCurrClip;
public final static double RAD_360 = Math.PI / 180 * 360;
// Image drawing
private AndroidJavaBlitter blitter;
private DirectColorModel cm;
private SinglePixelPackedSampleModel sm;
private WritableRaster wr;
public static AndroidGraphics2D getInstance() {
if (mAg == null) {
throw new RuntimeException("AndroidGraphics2D not instantiated!");
}
return mAg;
}
public static AndroidGraphics2D getInstance(Context ctx, Canvas c, Paint p) {
if (c == null || ctx == null) {
throw new RuntimeException(
"Illegal argument, Canvas cannot be null!");
}
mAg = new AndroidGraphics2D(ctx, c, p);
return mAg;
}
private AndroidGraphics2D(Context ctx, Canvas c, Paint p) {
super();
mC = c;
mP = p;
mM = new Matrix();
mM.reset();
mM = mC.getMatrix();
Rect r = mC.getClipBounds();
int cl[] = {-1, r.top, r.left, -2, r.top, r.right, -2, r.bottom, r.right, -2, r.bottom, r.left};
mCurrClip = new Area(createShape(cl));
if(ctx != null) {
WindowManager wm = (WindowManager)ctx.getSystemService(Context.WINDOW_SERVICE);
Display d = wm.getDefaultDisplay();
displayWidth = d.getWidth();
displayHeight = d.getHeight();
}
blitter = new AndroidJavaBlitter(c);
cm = new DirectColorModel(32, 0xff0000, 0xff00, 0xff, 0xff000000);
sm = new SinglePixelPackedSampleModel(
DataBuffer.TYPE_INT, displayWidth, displayHeight, cm.getMasks());
wr = Raster.createWritableRaster(sm, null);
dstSurf = new ImageSurface(cm, wr);
}
@Override
public void addRenderingHints(Map<?, ?> hints) {
if (mRh == null) {
mRh = (RenderingHints) hints;
}
mRh.add((RenderingHints) hints);
}
public float[] getMatrix() {
float[] f = new float[9];
mC.getMatrix().getValues(f);
return f;
}
/**
*
* @return a Matrix in Android format
*/
public float[] getInverseMatrix() {
AffineTransform af = new AffineTransform(createAWTMatrix(getMatrix()));
try {
af = af.createInverse();
} catch (NoninvertibleTransformException e) {
}
return createMatrix(af);
}
private Path getPath(Shape s) {
Path path = new Path();
PathIterator pi = s.getPathIterator(null);
while (pi.isDone() == false) {
getCurrentSegment(pi, path);
pi.next();
}
return path;
}
private void getCurrentSegment(PathIterator pi, Path path) {
float[] coordinates = new float[6];
int type = pi.currentSegment(coordinates);
switch (type) {
case PathIterator.SEG_MOVETO:
path.moveTo(coordinates[0], coordinates[1]);
break;
case PathIterator.SEG_LINETO:
path.lineTo(coordinates[0], coordinates[1]);
break;
case PathIterator.SEG_QUADTO:
path.quadTo(coordinates[0], coordinates[1], coordinates[2],
coordinates[3]);
break;
case PathIterator.SEG_CUBICTO:
path.cubicTo(coordinates[0], coordinates[1], coordinates[2],
coordinates[3], coordinates[4], coordinates[5]);
break;
case PathIterator.SEG_CLOSE:
path.close();
break;
default:
break;
}
}
private Shape createShape(int[] arr) {
Shape s = new GeneralPath();
for(int i = 0; i < arr.length; i++) {
int type = arr[i];
switch (type) {
case -1:
//MOVETO
((GeneralPath)s).moveTo(arr[++i], arr[++i]);
break;
case -2:
//LINETO
((GeneralPath)s).lineTo(arr[++i], arr[++i]);
break;
case -3:
//QUADTO
((GeneralPath)s).quadTo(arr[++i], arr[++i], arr[++i],
arr[++i]);
break;
case -4:
//CUBICTO
((GeneralPath)s).curveTo(arr[++i], arr[++i], arr[++i],
arr[++i], arr[++i], arr[++i]);
break;
case -5:
//CLOSE
return s;
default:
break;
}
}
return s;
}
/*
public int[] getPixels() {
return mC.getPixels();
}*/
public static float getRadian(float degree) {
return (float) ((Math.PI / 180) * degree);
}
private Shape getShape() {
return null;
}
public static float getDegree(float radian) {
return (float) ((180 / Math.PI) * radian);
}
/*
* Degree in radian
*/
public static float getEllipsisX(float degree, float princAxis) {
return (float) Math.cos(degree) * princAxis;
}
public static float getEllipsisY(float degree, float conAxis) {
return (float) Math.sin(degree) * conAxis;
}
@Override
public void clip(Shape s) {
mC.clipPath(getPath(s));
}
public void setCanvas(Canvas c) {
mC = c;
}
@Override
public void draw(Shape s) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.STROKE);
mC.drawPath(getPath(s), mP);
mP.setStyle(tmp);
}
/*
private ArrayList getSegments(Shape s) {
ArrayList arr = new ArrayList();
PathIterator pi = s.getPathIterator(null);
while (pi.isDone() == false) {
getCurrentSegment(pi, arr);
pi.next();
}
return arr;
}
private void getCurrentSegment(PathIterator pi, ArrayList arr) {
float[] coordinates = new float[6];
int type = pi.currentSegment(coordinates);
switch (type) {
case PathIterator.SEG_MOVETO:
arr.add(new Integer(-1));
break;
case PathIterator.SEG_LINETO:
arr.add(new Integer(-2));
break;
case PathIterator.SEG_QUADTO:
arr.add(new Integer(-3));
break;
case PathIterator.SEG_CUBICTO:
arr.add(new Integer(-4));
break;
case PathIterator.SEG_CLOSE:
arr.add(new Integer(-5));
break;
default:
break;
}
}
*/
/*
* Convenience method, not standard AWT
*/
public void draw(Path s) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.STROKE);
s.transform(mM);
mC.drawPath(s, mP);
mP.setStyle(tmp);
}
@Override
public void drawGlyphVector(GlyphVector g, float x, float y) {
// TODO draw at x, y
// draw(g.getOutline());
/*
Matrix matrix = new Matrix();
matrix.setTranslate(x, y);
Path pth = getPath(g.getOutline());
pth.transform(matrix);
draw(pth);
*/
Path path = new Path();
char[] c = ((AndroidGlyphVector)g).getGlyphs();
mP.getTextPath(c, 0, c.length, x, y, path);
mC.drawPath(path, mP);
}
@Override
public void drawRenderableImage(RenderableImage img, AffineTransform xform) {
throw new RuntimeException("Not implemented!");
}
@Override
public void drawRenderedImage(RenderedImage img, AffineTransform xform) {
throw new RuntimeException("Not implemented!");
}
@Override
public void drawString(AttributedCharacterIterator iterator, float x,
float y) {
throw new RuntimeException("AttributedCharacterIterator not supported!");
}
@Override
public void drawString(AttributedCharacterIterator iterator, int x, int y) {
throw new RuntimeException("AttributedCharacterIterator not supported!");
}
@Override
public void drawString(String s, float x, float y) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.FILL);
Path pth = new Path();
mP.getTextPath(s, 0, s.length(), x, y, pth);
mC.drawPath(pth, mP);
mP.setStyle(tmp);
}
@Override
public void drawString(String str, int x, int y) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStrokeWidth(0);
mC.drawText(str.toCharArray(), 0, str.toCharArray().length, x, y,
mP);
mP.setStyle(tmp);
}
@Override
public void fill(Shape s) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.FILL);
mC.drawPath(getPath(s), mP);
mP.setStyle(tmp);
}
@Override
public Color getBackground() {
return mBc;
}
@Override
public Composite getComposite() {
throw new RuntimeException("Composite not implemented!");
}
@Override
public GraphicsConfiguration getDeviceConfiguration() {
return new AndroidGraphicsConfiguration();
}
@Override
public FontRenderContext getFontRenderContext() {
return new FontRenderContext(getTransform(), mP.isAntiAlias(), true);
}
@Override
public java.awt.Paint getPaint() {
throw new RuntimeException("AWT Paint not implemented in Android!");
}
public static Canvas getAndroidCanvas() {
return mC;
}
public static Paint getAndroidPaint() {
return mP;
}
@Override
public RenderingHints getRenderingHints() {
return mRh;
}
@Override
public Stroke getStroke() {
if (mP != null) {
return new BasicStroke(mP.getStrokeWidth(), mP.getStrokeCap()
.ordinal(), mP.getStrokeJoin().ordinal());
}
return null;
}
@Override
public AffineTransform getTransform() {
return new AffineTransform(createAWTMatrix(getMatrix()));
}
@Override
public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
// ???AWT TODO check if on stroke
return s.intersects(rect.getX(), rect.getY(), rect.getWidth(), rect
.getHeight());
}
@Override
public void rotate(double theta) {
mM.preRotate((float) AndroidGraphics2D
.getDegree((float) (RAD_360 - theta)));
mC.concat(mM);
}
@Override
public void rotate(double theta, double x, double y) {
mM.preRotate((float) AndroidGraphics2D.getDegree((float) theta),
(float) x, (float) y);
mC.concat(mM);
}
@Override
public void scale(double sx, double sy) {
mM.setScale((float) sx, (float) sy);
mC.concat(mM);
}
@Override
public void setBackground(Color color) {
mBc = color;
mC.clipRect(new Rect(0, 0, mC.getWidth(), mC.getHeight()));
// TODO don't limit to current clip
mC.drawARGB(color.getAlpha(), color.getRed(), color.getGreen(), color
.getBlue());
}
@Override
public void setComposite(Composite comp) {
throw new RuntimeException("Composite not implemented!");
}
public void setSpaint(Paint paint) {
mP = paint;
}
@Override
public void setPaint(java.awt.Paint paint) {
setColor((Color)paint);
}
@Override
public Object getRenderingHint(RenderingHints.Key key) {
if (mRh == null) {
return null;
}
return mRh.get(key);
}
@Override
public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue) {
if (mRh == null) {
mRh = new RenderingHints(hintKey, hintValue);
} else {
mRh.put(hintKey, hintValue);
}
applyHints();
}
@Override
public void setRenderingHints(Map<?, ?> hints) {
mRh = (RenderingHints) hints;
applyHints();
}
private void applyHints() {
Object o;
// TODO do something like this:
/*
* Set s = mRh.keySet(); Iterator it = s.iterator(); while(it.hasNext()) {
* o = it.next(); }
*/
// /////////////////////////////////////////////////////////////////////
// not supported in skia
/*
* o = mRh.get(RenderingHints.KEY_ALPHA_INTERPOLATION); if
* (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)) { } else
* if (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)) { }
* else if (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)) { }
*
* o = mRh.get(RenderingHints.KEY_COLOR_RENDERING); if
* (o.equals(RenderingHints.VALUE_COLOR_RENDER_DEFAULT)) { } else if
* (o.equals(RenderingHints.VALUE_COLOR_RENDER_QUALITY)) { } else if
* (o.equals(RenderingHints.VALUE_COLOR_RENDER_SPEED)) { }
*
* o = mRh.get(RenderingHints.KEY_DITHERING); if
* (o.equals(RenderingHints.VALUE_DITHER_DEFAULT)) { } else if
* (o.equals(RenderingHints.VALUE_DITHER_DISABLE)) { } else if
* (o.equals(RenderingHints.VALUE_DITHER_ENABLE)) { }
*
* o = mRh.get(RenderingHints.KEY_FRACTIONALMETRICS); if
* (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT)) { } else
* if (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_OFF)) { } else if
* (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_ON)) { }
*
* o = mRh.get(RenderingHints.KEY_INTERPOLATION); if
* (o.equals(RenderingHints.VALUE_INTERPOLATION_BICUBIC)) { } else if
* (o.equals(RenderingHints.VALUE_INTERPOLATION_BILINEAR)) { } else if
* (o .equals(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)) { }
*
* o = mRh.get(RenderingHints.KEY_RENDERING); if
* (o.equals(RenderingHints.VALUE_RENDER_DEFAULT)) { } else if
* (o.equals(RenderingHints.VALUE_RENDER_QUALITY)) { } else if
* (o.equals(RenderingHints.VALUE_RENDER_SPEED)) { }
*
* o = mRh.get(RenderingHints.KEY_STROKE_CONTROL); if
* (o.equals(RenderingHints.VALUE_STROKE_DEFAULT)) { } else if
* (o.equals(RenderingHints.VALUE_STROKE_NORMALIZE)) { } else if
* (o.equals(RenderingHints.VALUE_STROKE_PURE)) { }
*/
o = mRh.get(RenderingHints.KEY_ANTIALIASING);
if (o != null) {
if (o.equals(RenderingHints.VALUE_ANTIALIAS_DEFAULT)) {
mP.setAntiAlias(false);
} else if (o.equals(RenderingHints.VALUE_ANTIALIAS_OFF)) {
mP.setAntiAlias(false);
} else if (o.equals(RenderingHints.VALUE_ANTIALIAS_ON)) {
mP.setAntiAlias(true);
}
}
o = mRh.get(RenderingHints.KEY_TEXT_ANTIALIASING);
if (o != null) {
if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT)) {
mP.setAntiAlias(false);
} else if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)) {
mP.setAntiAlias(false);
} else if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_ON)) {
mP.setAntiAlias(true);
}
}
}
@Override
public void setStroke(Stroke s) {
if (mP == null) {
mP = new Paint();
}
BasicStroke bs = (BasicStroke) s;
mP.setStyle(Paint.Style.STROKE);
mP.setStrokeWidth(bs.getLineWidth());
int cap = bs.getEndCap();
if (cap == 0) {
mP.setStrokeCap(Paint.Cap.BUTT);
} else if (cap == 1) {
mP.setStrokeCap(Paint.Cap.ROUND);
} else if (cap == 2) {
mP.setStrokeCap(Paint.Cap.SQUARE);
}
int join = bs.getLineJoin();
if (join == 0) {
mP.setStrokeJoin(Paint.Join.MITER);
} else if (join == 1) {
mP.setStrokeJoin(Paint.Join.ROUND);
} else if (join == 2) {
mP.setStrokeJoin(Paint.Join.BEVEL);
}
}
public static float[] createMatrix(AffineTransform Tx) {
double[] at = new double[9];
Tx.getMatrix(at);
float[] f = new float[at.length];
f[0] = (float) at[0];
f[1] = (float) at[2];
f[2] = (float) at[4];
f[3] = (float) at[1];
f[4] = (float) at[3];
f[5] = (float) at[5];
f[6] = 0;
f[7] = 0;
f[8] = 1;
return f;
}
private float[] createAWTMatrix(float[] matrix) {
float[] at = new float[9];
at[0] = matrix[0];
at[1] = matrix[3];
at[2] = matrix[1];
at[3] = matrix[4];
at[4] = matrix[2];
at[5] = matrix[5];
at[6] = 0;
at[7] = 0;
at[8] = 1;
return at;
}
public static Matrix createMatrixObj(AffineTransform Tx) {
Matrix m = new Matrix();
m.reset();
m.setValues(createMatrix(Tx));
return m;
}
@Override
public void setTransform(AffineTransform Tx) {
mM.reset();
/*
* if(Tx.isIdentity()) { mM = new Matrix(); }
*/
mM.setValues(createMatrix(Tx));
Matrix m = new Matrix();
m.setValues(getInverseMatrix());
mC.concat(m);
mC.concat(mM);
}
@Override
public void shear(double shx, double shy) {
mM.setSkew((float) shx, (float) shy);
mC.concat(mM);
}
@Override
public void transform(AffineTransform Tx) {
Matrix m = new Matrix();
m.setValues(createMatrix(Tx));
mC.concat(m);
}
@Override
public void translate(double tx, double ty) {
mM.setTranslate((float) tx, (float) ty);
mC.concat(mM);
}
@Override
public void translate(int x, int y) {
mM.setTranslate((float) x, (float) y);
mC.concat(mM);
}
@Override
public void clearRect(int x, int y, int width, int height) {
mC.clipRect(x, y, x + width, y + height);
if (mBc != null) {
mC.drawARGB(mBc.getAlpha(), mBc.getBlue(), mBc.getGreen(), mBc
.getRed());
} else {
mC.drawARGB(0xff, 0xff, 0xff, 0xff);
}
}
@Override
public void clipRect(int x, int y, int width, int height) {
int cl[] = {-1, x, y, -2, x, y + width, -2, x + height, y + width, -2, x + height, y};
Shape shp = createShape(cl);
mCurrClip.intersect(new Area(shp));
mC.clipRect(new Rect(x, y, x + width, y + height), Region.Op.INTERSECT);
}
@Override
public void copyArea(int sx, int sy, int width, int height, int dx, int dy) {
copyArea(mC, sx, sy, width + dx, height + dy, dx, dy);
}
@Override
public Graphics create() {
return this;
}
@Override
public void dispose() {
mC = null;
mP = null;
}
@Override
public void drawArc(int x, int y, int width, int height, int sa, int ea) {
if (mP == null) {
mP = new Paint();
}
mP.setStrokeWidth(0);
mC.drawArc(new RectF(x, y, x + width, y + height), 360 - (ea + sa),
ea, true, mP);
}
// ???AWT: only used for debuging, delete in final version
public void drawBitmap(Bitmap bm, float x, float y, Paint p) {
mC.drawBitmap(bm, x, y, null);
}
@Override
public boolean drawImage(Image image, int x, int y, Color bgcolor,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h, (AffineTransform) transform.clone(),
composite, bgcolor, clip);
}
return done;
}
@Override
public boolean drawImage(Image image, int x, int y, ImageObserver imageObserver) {
return drawImage(image, x, y, null, imageObserver);
}
@Override
public boolean drawImage(Image image, int x, int y, int width, int height,
Color bgcolor, ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(width == 0 || height == 0) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
if(w == width && h == height){
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
composite, bgcolor, clip);
}else{
AffineTransform xform = new AffineTransform();
xform.setToScale((float)width / w, (float)height / h);
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
xform, composite, bgcolor, clip);
}
}
return done;
}
@Override
public boolean drawImage(Image image, int x, int y, int width, int height,
ImageObserver imageObserver) {
return drawImage(image, x, y, width, height, null, imageObserver);
}
@Override
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2, Color bgcolor,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(dx1 == dx2 || dy1 == dy2 || sx1 == sx2 || sy1 == sy2) {
return true;
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int dstX = dx1;
int dstY = dy1;
int srcX = sx1;
int srcY = sy1;
int dstW = dx2 - dx1;
int dstH = dy2 - dy1;
int srcW = sx2 - sx1;
int srcH = sy2 - sy1;
if(srcW == dstW && srcH == dstH){
blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
(AffineTransform) transform.clone(),
composite, bgcolor, clip);
}else{
AffineTransform xform = new AffineTransform();
xform.setToScale((float)dstW / srcW, (float)dstH / srcH);
blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
(AffineTransform) transform.clone(),
xform, composite, bgcolor, clip);
}
}
return done;
}
@Override
public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2, ImageObserver imageObserver) {
return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
imageObserver);
}
@Override
public void drawImage(BufferedImage bufImage, BufferedImageOp op,
int x, int y) {
if(bufImage == null) {
return;
}
if(op == null) {
drawImage(bufImage, x, y, null);
} else if(op instanceof AffineTransformOp){
AffineTransformOp atop = (AffineTransformOp) op;
AffineTransform xform = atop.getTransform();
Surface srcSurf = Surface.getImageSurface(bufImage);
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(), xform,
composite, null, clip);
} else {
bufImage = op.filter(bufImage, null);
Surface srcSurf = Surface.getImageSurface(bufImage);
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
(AffineTransform) transform.clone(),
composite, null, clip);
}
}
@Override
public boolean drawImage(Image image, AffineTransform trans,
ImageObserver imageObserver) {
if(image == null) {
return true;
}
if(trans == null || trans.isIdentity()) {
return drawImage(image, 0, 0, imageObserver);
}
boolean done = false;
boolean somebits = false;
Surface srcSurf = null;
if(image instanceof OffscreenImage){
OffscreenImage oi = (OffscreenImage) image;
if((oi.getState() & ImageObserver.ERROR) != 0) {
return false;
}
done = oi.prepareImage(imageObserver);
somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
srcSurf = oi.getImageSurface();
}else{
done = true;
srcSurf = Surface.getImageSurface(image);
}
if(done || somebits) {
int w = srcSurf.getWidth();
int h = srcSurf.getHeight();
AffineTransform xform = (AffineTransform) transform.clone();
xform.concatenate(trans);
blitter.blit(0, 0, srcSurf, 0, 0, dstSurf, w, h, xform, composite,
null, clip);
}
return done;
}
@Override
public void drawLine(int x1, int y1, int x2, int y2) {
if (mP == null) {
mP = new Paint();
}
mC.drawLine(x1, y1, x2, y2, mP);
}
@Override
public void drawOval(int x, int y, int width, int height) {
if (mP == null) {
mP = new Paint();
}
mP.setStyle(Paint.Style.STROKE);
mC.drawOval(new RectF(x, y, x + width, y + height), mP);
}
@Override
public void drawPolygon(int[] xpoints, int[] ypoints, int npoints) {
if (mP == null) {
mP = new Paint();
}
mC.drawLine(xpoints[npoints - 1], ypoints[npoints - 1], xpoints[0],
ypoints[0], mP);
for (int i = 0; i < npoints - 1; i++) {
mC.drawLine(xpoints[i], ypoints[i], xpoints[i + 1],
ypoints[i + 1], mP);
}
}
@Override
public void drawPolyline(int[] xpoints, int[] ypoints, int npoints) {
for (int i = 0; i < npoints - 1; i++) {
drawLine(xpoints[i], ypoints[i], xpoints[i + 1], ypoints[i + 1]);
}
}
@Override
public void drawRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
if (mP == null) {
mP = new Paint();
}
mC.drawRoundRect(new RectF(x, y, width, height), arcWidth,
arcHeight, mP);
}
@Override
public void fillArc(int x, int y, int width, int height, int sa, int ea) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.FILL_AND_STROKE);
mC.drawArc(new RectF(x, y, x + width, y + height), 360 - (sa + ea),
ea, true, mP);
mP.setStyle(tmp);
}
@Override
public void fillOval(int x, int y, int width, int height) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.FILL);
mC.drawOval(new RectF(x, y, x + width, y + height), mP);
mP.setStyle(tmp);
}
@Override
public void fillPolygon(int[] xpoints, int[] ypoints, int npoints) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mC.save(Canvas.CLIP_SAVE_FLAG);
mP.setStyle(Paint.Style.FILL);
GeneralPath filledPolygon = new GeneralPath(
GeneralPath.WIND_EVEN_ODD, npoints);
filledPolygon.moveTo(xpoints[0], ypoints[0]);
for (int index = 1; index < xpoints.length; index++) {
filledPolygon.lineTo(xpoints[index], ypoints[index]);
}
filledPolygon.closePath();
Path path = getPath(filledPolygon);
mC.clipPath(path);
mC.drawPath(path, mP);
mP.setStyle(tmp);
mC.restore();
}
@Override
public void fillRect(int x, int y, int width, int height) {
if (mP == null) {
mP = new Paint();
}
Paint.Style tmp = mP.getStyle();
mP.setStyle(Paint.Style.FILL);
mC.drawRect(new Rect(x, y, x + width, y + height), mP);
mP.setStyle(tmp);
}
@Override
public void drawRect(int x, int y, int width, int height) {
int[] xpoints = { x, x, x + width, x + width };
int[] ypoints = { y, y + height, y + height, y };
drawPolygon(xpoints, ypoints, 4);
}
@Override
public void fillRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
if (mP == null) {
mP = new Paint();
}
mP.setStyle(Paint.Style.FILL);
mC.drawRoundRect(new RectF(x, y, x + width, y + height), arcWidth,
arcHeight, mP);
}
@Override
public Shape getClip() {
return mCurrClip;
}
@Override
public Rectangle getClipBounds() {
Rect r = mC.getClipBounds();
return new Rectangle(r.left, r.top, r.width(), r.height());
}
@Override
public Color getColor() {
if (mP != null) {
return new Color(mP.getColor());
}
return null;
}
@Override
public Font getFont() {
return mFnt;
}
@Override
public FontMetrics getFontMetrics(Font font) {
mFm = new FontMetricsImpl(font);
return mFm;
}
@Override
public void setClip(int x, int y, int width, int height) {
int cl[] = {-1, x, y, -2, x, y + width, -2, x + height, y + width, -2, x + height, y};
mCurrClip = new Area(createShape(cl));
mC.clipRect(x, y, x + width, y + height, Region.Op.REPLACE);
}
@Override
public void setClip(Shape clip) {
mCurrClip = new Area(clip);
mC.clipPath(getPath(clip), Region.Op.REPLACE);
}
@Override
public void setColor(Color c) {
if (mP == null) {
mP = new Paint();
}
mP.setColor(c.getRGB());
}
/**
* Font mapping:
*
* Family:
*
* Android AWT
* -------------------------------------
* serif Serif / TimesRoman
* sans-serif SansSerif / Helvetica
* monospace Monospaced / Courier
*
* Style:
*
* Android AWT
* -------------------------------------
* normal Plain
* bold bold
* italic italic
*
*/
@Override
public void setFont(Font font) {
if (font == null) {
return;
}
if (mP == null) {
mP = new Paint();
}
mFnt = font;
Typeface tf = null;
int sty = font.getStyle();
String nam = font.getName();
String aF = "";
if (nam != null) {
if (nam.equalsIgnoreCase("Serif")
|| nam.equalsIgnoreCase("TimesRoman")) {
aF = "serif";
} else if (nam.equalsIgnoreCase("SansSerif")
|| nam.equalsIgnoreCase("Helvetica")) {
aF = "sans-serif";
} else if (nam.equalsIgnoreCase("Monospaced")
|| nam.equalsIgnoreCase("Courier")) {
aF = "monospace";
}
}
switch (sty) {
case Font.PLAIN:
tf = Typeface.create(aF, Typeface.NORMAL);
break;
case Font.BOLD:
tf = Typeface.create(aF, Typeface.BOLD);
break;
case Font.ITALIC:
tf = Typeface.create(aF, Typeface.ITALIC);
break;
case Font.BOLD | Font.ITALIC:
tf = Typeface.create(aF, Typeface.BOLD_ITALIC);
break;
default:
tf = Typeface.DEFAULT;
}
mP.setTextSize(font.getSize());
mP.setTypeface(tf);
}
@Override
public void drawBytes(byte[] data, int offset, int length, int x, int y) {
drawString(new String(data, offset, length), x, y);
}
@Override
public void drawPolygon(Polygon p) {
drawPolygon(p.xpoints, p.ypoints, p.npoints);
}
@Override
public void fillPolygon(Polygon p) {
fillPolygon(p.xpoints, p.ypoints, p.npoints);
}
@Override
public Rectangle getClipBounds(Rectangle r) {
Shape clip = getClip();
if (clip != null) {
Rectangle b = clip.getBounds();
r.x = b.x;
r.y = b.y;
r.width = b.width;
r.height = b.height;
}
return r;
}
@Override
public boolean hitClip(int x, int y, int width, int height) {
return getClipBounds().intersects(new Rectangle(x, y, width, height));
}
@Override
public void drawChars(char[] data, int offset, int length, int x, int y) {
mC.drawText(data, offset, length, x, y, mP);
}
@Override
public void setPaintMode() {
if (mP == null) {
mP = new Paint();
}
mP.setXfermode(null);
}
@Override
public void setXORMode(Color color) {
if (mP == null) {
mP = new Paint();
}
mP.setXfermode(new PixelXorXfermode(color.getRGB()));
}
@Override
public void fill3DRect(int x, int y, int width, int height, boolean raised) {
Color color = getColor();
Color colorUp, colorDown;
if (raised) {
colorUp = color.brighter();
colorDown = color.darker();
setColor(color);
} else {
colorUp = color.darker();
colorDown = color.brighter();
setColor(colorUp);
}
width--;
height--;
fillRect(x+1, y+1, width-1, height-1);
setColor(colorUp);
fillRect(x, y, width, 1);
fillRect(x, y+1, 1, height);
setColor(colorDown);
fillRect(x+width, y, 1, height);
fillRect(x+1, y+height, width, 1);
}
@Override
public void draw3DRect(int x, int y, int width, int height, boolean raised) {
Color color = getColor();
Color colorUp, colorDown;
if (raised) {
colorUp = color.brighter();
colorDown = color.darker();
} else {
colorUp = color.darker();
colorDown = color.brighter();
}
setColor(colorUp);
fillRect(x, y, width, 1);
fillRect(x, y+1, 1, height);
setColor(colorDown);
fillRect(x+width, y, 1, height);
fillRect(x+1, y+height, width, 1);
}
public void copyArea(Canvas canvas, int sx, int sy, int width, int height, int dx, int dy) {
sx += getTransform().getTranslateX();
sy += getTransform().getTranslateY();
NativeUtils.nativeScrollRect(canvas,
new Rect(sx, sy, sx + width, sy + height),
dx, dy);
}
}
awt/com/android/internal/awt/AndroidGraphicsConfiguration.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import com.android.internal.awt.AndroidGraphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.VolatileImage;
import android.graphics.Canvas;
public class AndroidGraphicsConfiguration extends GraphicsConfiguration {
@Override
public BufferedImage createCompatibleImage(int width, int height) {
// TODO Auto-generated method stub
return null;
}
@Override
public BufferedImage createCompatibleImage(int width, int height,
int transparency) {
// TODO Auto-generated method stub
return null;
}
@Override
public VolatileImage createCompatibleVolatileImage(int width, int height) {
// TODO Auto-generated method stub
return null;
}
@Override
public VolatileImage createCompatibleVolatileImage(int width, int height,
int transparency) {
// TODO Auto-generated method stub
return null;
}
@Override
public Rectangle getBounds() {
Canvas c = AndroidGraphics2D.getAndroidCanvas();
if(c != null)
return new Rectangle(0, 0, c.getWidth(), c.getHeight());
return null;
}
@Override
public ColorModel getColorModel() {
// TODO Auto-generated method stub
return null;
}
@Override
public ColorModel getColorModel(int transparency) {
// TODO Auto-generated method stub
return null;
}
@Override
public AffineTransform getDefaultTransform() {
return new AffineTransform();
}
@Override
public GraphicsDevice getDevice() {
// TODO Auto-generated method stub
return null;
}
@Override
public AffineTransform getNormalizingTransform() {
// TODO Auto-generated method stub
return null;
}
}
awt/com/android/internal/awt/AndroidGraphicsFactory.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.GraphicsEnvironment;
import java.awt.peer.FontPeer;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.gl.font.AndroidFont;
import org.apache.harmony.awt.gl.font.FontManager;
import org.apache.harmony.awt.gl.font.FontMetricsImpl;
import org.apache.harmony.awt.gl.font.AndroidFontManager;
import org.apache.harmony.awt.wtk.NativeWindow;
import org.apache.harmony.awt.wtk.WindowFactory;
import org.apache.harmony.awt.gl.CommonGraphics2DFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.content.Context;
public class AndroidGraphicsFactory extends CommonGraphics2DFactory {
public GraphicsEnvironment createGraphicsEnvironment(WindowFactory wf) {
// TODO Auto-generated method stub
return null;
}
public Font embedFont(String fontFilePath) {
// TODO Auto-generated method stub
return null;
}
public FontManager getFontManager() {
return AndroidFontManager.inst;
}
public FontMetrics getFontMetrics(Font font) {
return new FontMetricsImpl(font);
}
public FontPeer getFontPeer(Font font) {
//return getFontManager().getFontPeer(font.getName(), font.getStyle(), font.getSize());
return new AndroidFont(font.getName(), font.getStyle(), font.getSize());
}
public Graphics2D getGraphics2D(NativeWindow win, int translateX,
int translateY, MultiRectArea clip) {
// TODO Auto-generated method stub
return null;
}
public Graphics2D getGraphics2D(NativeWindow win, int translateX,
int translateY, int width, int height) {
// TODO Auto-generated method stub
return null;
}
public Graphics2D getGraphics2D(Context ctx, Canvas c, Paint p) {
return AndroidGraphics2D.getInstance(ctx, c, p);
}
public Graphics2D getGraphics2D(Canvas c, Paint p) {
throw new RuntimeException("Not supported!");
}
public Graphics2D getGraphics2D() {
return AndroidGraphics2D.getInstance();
}
}
awt/com/android/internal/awt/AndroidImageDecoder.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
//import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageConsumer;
import java.awt.image.IndexColorModel;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import org.apache.harmony.awt.gl.image.DecodingImageSource;
import org.apache.harmony.awt.gl.image.ImageDecoder;
import org.apache.harmony.awt.internal.nls.Messages;
public class AndroidImageDecoder extends ImageDecoder {
private static final int hintflags =
ImageConsumer.SINGLEFRAME | // PNG is a static image
ImageConsumer.TOPDOWNLEFTRIGHT | // This order is only one possible
ImageConsumer.COMPLETESCANLINES; // Don't deliver incomplete scanlines
// Each pixel is a grayscale sample.
private static final int PNG_COLOR_TYPE_GRAY = 0;
// Each pixel is an R,G,B triple.
private static final int PNG_COLOR_TYPE_RGB = 2;
// Each pixel is a palette index, a PLTE chunk must appear.
private static final int PNG_COLOR_TYPE_PLTE = 3;
// Each pixel is a grayscale sample, followed by an alpha sample.
private static final int PNG_COLOR_TYPE_GRAY_ALPHA = 4;
// Each pixel is an R,G,B triple, followed by an alpha sample.
private static final int PNG_COLOR_TYPE_RGBA = 6;
private static final int NB_OF_LINES_PER_CHUNK = 1; // 0 = full image
Bitmap bm; // The image as decoded by Android
// Header information
int imageWidth; // Image size
int imageHeight;
int colorType; // One of the PNG_ constants from above
int bitDepth; // Number of bits per color
byte cmap[]; // The color palette for index color models
ColorModel model; // The corresponding AWT color model
boolean transferInts; // Is transfer of type int or byte?
int dataElementsPerPixel;
// Buffers for decoded image data
byte byteOut[];
int intOut[];
public AndroidImageDecoder(DecodingImageSource src, InputStream is) {
super(src, is);
dataElementsPerPixel = 1;
}
@Override
/**
* All the decoding is done in Android
*
* AWT???: Method returns only once the image is completly
* decoded; decoding is not done asynchronously
*/
public void decodeImage() throws IOException {
try {
bm = BitmapFactory.decodeStream(inputStream);
if (bm == null) {
throw new IOException("Input stream empty and no image cached");
}
// Check size
imageWidth = bm.getWidth();
imageHeight = bm.getHeight();
if (imageWidth < 0 || imageHeight < 0 ) {
throw new RuntimeException("Illegal image size: "
+ imageWidth + ", " + imageHeight);
}
// We got the image fully decoded; now send all image data to AWT
setDimensions(imageWidth, imageHeight);
model = createColorModel();
setColorModel(model);
setHints(hintflags);
setProperties(new Hashtable<Object, Object>()); // Empty
sendPixels(NB_OF_LINES_PER_CHUNK != 0 ? NB_OF_LINES_PER_CHUNK : imageHeight);
imageComplete(ImageConsumer.STATICIMAGEDONE);
} catch (IOException e) {
throw e;
} catch (RuntimeException e) {
imageComplete(ImageConsumer.IMAGEERROR);
throw e;
} finally {
closeStream();
}
}
/**
* Create the AWT color model
*
* ???AWT: Android Bitmaps are always of type: ARGB-8888-Direct color model
*
* However, we leave the code here for a more powerfull decoder
* that returns a native model, and the conversion is then handled
* in AWT. With such a decoder, we would need to get the colorType,
* the bitDepth, (and the color palette for an index color model)
* from the image and construct the correct color model here.
*/
private ColorModel createColorModel() {
ColorModel cm = null;
int bmModel = 5; // TODO This doesn't exist: bm.getColorModel();
cmap = null;
switch (bmModel) {
// A1_MODEL
case 1:
colorType = PNG_COLOR_TYPE_GRAY;
bitDepth = 1;
break;
// A8_MODEL
case 2:
colorType = PNG_COLOR_TYPE_GRAY_ALPHA;
bitDepth = 8;
break;
// INDEX8_MODEL
// RGB_565_MODEL
// ARGB_8888_MODEL
case 3:
case 4:
case 5:
colorType = bm.hasAlpha() ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB;
bitDepth = 8;
break;
default:
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
switch (colorType) {
case PNG_COLOR_TYPE_GRAY: {
if (bitDepth != 8 && bitDepth != 4 && bitDepth != 2 && bitDepth != 1) {
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
// Create gray color model
int numEntries = 1 << bitDepth;
int scaleFactor = 255 / (numEntries-1);
byte comps[] = new byte[numEntries];
for (int i = 0; i < numEntries; i++) {
comps[i] = (byte) (i * scaleFactor);
}
cm = new IndexColorModel(bitDepth, numEntries, comps, comps, comps);
transferInts = false;
break;
}
case PNG_COLOR_TYPE_RGB: {
if (bitDepth != 8) {
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
cm = new DirectColorModel(24, 0xff0000, 0xFF00, 0xFF);
transferInts = true;
break;
}
case PNG_COLOR_TYPE_PLTE: {
if (bitDepth != 8 && bitDepth != 4 && bitDepth != 2 && bitDepth != 1) {
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
if (cmap == null) {
throw new IllegalStateException("Palette color type is not supported");
}
cm = new IndexColorModel(bitDepth, cmap.length / 3, cmap, 0, false);
transferInts = false;
break;
}
case PNG_COLOR_TYPE_GRAY_ALPHA: {
if (bitDepth != 8) {
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_GRAY),
true, false,
Transparency.TRANSLUCENT,
DataBuffer.TYPE_BYTE);
transferInts = false;
dataElementsPerPixel = 2;
break;
}
case PNG_COLOR_TYPE_RGBA: {
if (bitDepth != 8) {
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
cm = ColorModel.getRGBdefault();
transferInts = true;
break;
}
default:
// awt.3C=Unknown PNG color type
throw new IllegalArgumentException(Messages.getString("awt.3C")); //$NON-NLS-1$
}
return cm;
}
private void sendPixels(int nbOfLinesPerChunk) {
int w = imageWidth;
int h = imageHeight;
int n = 1;
if (nbOfLinesPerChunk > 0 && nbOfLinesPerChunk <= h) {
n = nbOfLinesPerChunk;
}
if (transferInts) {
// Create output buffer
intOut = new int[w * n];
for (int yi = 0; yi < h; yi += n) {
// Last chunk might contain less liness
if (n > 1 && h - yi < n ) {
n = h - yi;
}
bm.getPixels(intOut, 0, w, 0, yi, w, n);
setPixels(0, yi, w, n, model, intOut, 0, w);
}
} else {
// Android bitmaps always store ints (ARGB-8888 direct model)
throw new RuntimeException("Byte transfer not supported");
}
}
}
awt/com/android/internal/awt/AndroidJavaBlitter.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.XORComposite;
import org.apache.harmony.awt.gl.render.Blitter;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DataBufferInt;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
public class AndroidJavaBlitter implements Blitter {
private Canvas canvas;
private Paint paint;
private int colorCache;
public AndroidJavaBlitter(Canvas c) {
this.canvas = c;
this.paint = new Paint();
this.paint.setStrokeWidth(1);
}
/**
* Instead of multiplication and division we are using values from
* Lookup tables.
*/
static byte mulLUT[][]; // Lookup table for multiplication
static byte divLUT[][]; // Lookup table for division
static{
mulLUT = new byte[256][256];
for(int i = 0; i < 256; i++){
for(int j = 0; j < 256; j++){
mulLUT[i][j] = (byte)((float)(i * j)/255 + 0.5f);
}
}
divLUT = new byte[256][256];
for(int i = 1; i < 256; i++){
for(int j = 0; j < i; j++){
divLUT[i][j] = (byte)(((float)j / 255) / ((float)i/ 255) * 255 + 0.5f);
}
for(int j = i; j < 256; j++){
divLUT[i][j] = (byte)255;
}
}
}
final static int AlphaCompositeMode = 1;
final static int XORMode = 2;
public void blit(int srcX, int srcY, Surface srcSurf, int dstX, int dstY,
Surface dstSurf, int width, int height, AffineTransform sysxform,
AffineTransform xform, Composite comp, Color bgcolor,
MultiRectArea clip) {
if(xform == null){
blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, width, height,
sysxform, comp, bgcolor, clip);
}else{
double scaleX = xform.getScaleX();
double scaleY = xform.getScaleY();
double scaledX = dstX / scaleX;
double scaledY = dstY / scaleY;
AffineTransform at = new AffineTransform();
at.setToTranslation(scaledX, scaledY);
xform.concatenate(at);
sysxform.concatenate(xform);
blit(srcX, srcY, srcSurf, 0, 0, dstSurf, width, height,
sysxform, comp, bgcolor, clip);
}
}
public void blit(int srcX, int srcY, Surface srcSurf, int dstX, int dstY,
Surface dstSurf, int width, int height, AffineTransform sysxform,
Composite comp, Color bgcolor, MultiRectArea clip) {
if(sysxform == null) {
sysxform = new AffineTransform();
}
int type = sysxform.getType();
switch(type){
case AffineTransform.TYPE_TRANSLATION:
dstX += sysxform.getTranslateX();
dstY += sysxform.getTranslateY();
case AffineTransform.TYPE_IDENTITY:
simpleBlit(srcX, srcY, srcSurf, dstX, dstY, dstSurf,
width, height, comp, bgcolor, clip);
break;
default:
int srcW = srcSurf.getWidth();
int srcH = srcSurf.getHeight();
int w = srcX + width < srcW ? width : srcW - srcX;
int h = srcY + height < srcH ? height : srcH - srcY;
ColorModel srcCM = srcSurf.getColorModel();
Raster srcR = srcSurf.getRaster().createChild(srcX, srcY,
w, h, 0, 0, null);
ColorModel dstCM = dstSurf.getColorModel();
WritableRaster dstR = dstSurf.getRaster();
transformedBlit(srcCM, srcR, 0, 0, dstCM, dstR, dstX, dstY, w, h,
sysxform, comp, bgcolor, clip);
}
}
public void simpleBlit(int srcX, int srcY, Surface srcSurf, int dstX, int dstY,
Surface dstSurf, int width, int height, Composite comp,
Color bgcolor, MultiRectArea clip) {
// TODO It's possible, though unlikely that we might encounter non-int[]
// data buffers. In this case the following code needs to have several
// branches that take this into account.
data = (DataBufferInt)srcSurf.getRaster().getDataBuffer();
int[] pixels = data.getData();
if (!srcSurf.getColorModel().hasAlpha()) {
// This wouldn't be necessary if Android supported RGB_888.
for (int i = 0; i < pixels.length; i++) {
pixels[i] = pixels[i] | 0xff000000;
}
}
bmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
canvas.drawBitmap(bmap, dstX, dstY, paint);
}
public void blit(int srcX, int srcY, Surface srcSurf, int dstX, int dstY,
Surface dstSurf, int width, int height, Composite comp,
Color bgcolor, MultiRectArea clip) {
javaBlt(srcX, srcY, srcSurf.getWidth(), srcSurf.getHeight(),
srcSurf.getColorModel(), srcSurf.getRaster(), dstX, dstY,
dstSurf.getWidth(), dstSurf.getHeight(),
dstSurf.getColorModel(), dstSurf.getRaster(),
width, height, comp, bgcolor, clip);
}
public void javaBlt(int srcX, int srcY, int srcW, int srcH,
ColorModel srcCM, Raster srcRast, int dstX, int dstY,
int dstW, int dstH, ColorModel dstCM, WritableRaster dstRast,
int width, int height, Composite comp, Color bgcolor,
MultiRectArea clip){
int srcX2 = srcW - 1;
int srcY2 = srcH - 1;
int dstX2 = dstW - 1;
int dstY2 = dstH - 1;
if(srcX < 0){
width += srcX;
srcX = 0;
}
if(srcY < 0){
height += srcY;
srcY = 0;
}
if(dstX < 0){
width += dstX;
srcX -= dstX;
dstX = 0;
}
if(dstY < 0){
height += dstY;
srcY -= dstY;
dstY = 0;
}
if(srcX > srcX2 || srcY > srcY2) {
return;
}
if(dstX > dstX2 || dstY > dstY2) {
return;
}
if(srcX + width > srcX2) {
width = srcX2 - srcX + 1;
}
if(srcY + height > srcY2) {
height = srcY2 - srcY + 1;
}
if(dstX + width > dstX2) {
width = dstX2 - dstX + 1;
}
if(dstY + height > dstY2) {
height = dstY2 - dstY + 1;
}
if(width <= 0 || height <= 0) {
return;
}
int clipRects[];
if(clip != null) {
clipRects = clip.rect;
} else {
clipRects = new int[]{5, 0, 0, dstW - 1, dstH - 1};
}
boolean isAlphaComp = false;
int rule = 0;
float alpha = 0;
boolean isXORComp = false;
Color xorcolor = null;
CompositeContext cont = null;
if(comp instanceof AlphaComposite){
isAlphaComp = true;
AlphaComposite ac = (AlphaComposite) comp;
rule = ac.getRule();
alpha = ac.getAlpha();
}else if(comp instanceof XORComposite){
isXORComp = true;
XORComposite xcomp = (XORComposite) comp;
xorcolor = xcomp.getXORColor();
}else{
cont = comp.createContext(srcCM, dstCM, null);
}
for(int i = 1; i < clipRects[0]; i += 4){
int _sx = srcX;
int _sy = srcY;
int _dx = dstX;
int _dy = dstY;
int _w = width;
int _h = height;
int cx = clipRects[i]; // Clipping left top X
int cy = clipRects[i + 1]; // Clipping left top Y
int cx2 = clipRects[i + 2]; // Clipping right bottom X
int cy2 = clipRects[i + 3]; // Clipping right bottom Y
if(_dx > cx2 || _dy > cy2 || dstX2 < cx || dstY2 < cy) {
continue;
}
if(cx > _dx){
int shx = cx - _dx;
_w -= shx;
_dx = cx;
_sx += shx;
}
if(cy > _dy){
int shy = cy - _dy;
_h -= shy;
_dy = cy;
_sy += shy;
}
if(_dx + _w > cx2 + 1){
_w = cx2 - _dx + 1;
}
if(_dy + _h > cy2 + 1){
_h = cy2 - _dy + 1;
}
if(_sx > srcX2 || _sy > srcY2) {
continue;
}
if(isAlphaComp){
alphaCompose(_sx, _sy, srcCM, srcRast, _dx, _dy,
dstCM, dstRast, _w, _h, rule, alpha, bgcolor);
}else if(isXORComp){
xorCompose(_sx, _sy, srcCM, srcRast, _dx, _dy,
dstCM, dstRast, _w, _h, xorcolor);
}else{
Raster sr = srcRast.createChild(_sx, _sy, _w, _h, 0, 0, null);
WritableRaster dr = dstRast.createWritableChild(_dx, _dy,
_w, _h, 0, 0, null);
cont.compose(sr, dr, dr);
}
}
}
DataBufferInt data;
Bitmap bmap, bmp;
void alphaCompose(int srcX, int srcY, ColorModel srcCM, Raster srcRast,
int dstX, int dstY, ColorModel dstCM, WritableRaster dstRast,
int width, int height, int rule, float alpha, Color bgcolor){
Object srcPixel = getTransferArray(srcRast, 1);
data = (DataBufferInt)srcRast.getDataBuffer();
int pix[] = data.getData();
bmap = Bitmap.createBitmap(pix, width, height, Bitmap.Config.RGB_565);
canvas.drawBitmap(bmap, dstX, dstY, paint);
}
void render(int[] img, int x, int y, int width, int height) {
canvas.drawBitmap(Bitmap.createBitmap(img, width, height, Bitmap.Config.ARGB_8888), x, y, paint);
}
void xorCompose(int srcX, int srcY, ColorModel srcCM, Raster srcRast,
int dstX, int dstY, ColorModel dstCM, WritableRaster dstRast,
int width, int height, Color xorcolor){
data = (DataBufferInt)srcRast.getDataBuffer();
int pix[] = data.getData();
bmap = Bitmap.createBitmap(pix, width, height, Bitmap.Config.RGB_565);
canvas.drawBitmap(bmap, dstX, dstY, paint);
}
private void transformedBlit(ColorModel srcCM, Raster srcR, int srcX, int srcY,
ColorModel dstCM, WritableRaster dstR, int dstX, int dstY,
int width, int height, AffineTransform at, Composite comp,
Color bgcolor, MultiRectArea clip) {
data = (DataBufferInt)srcR.getDataBuffer();
int[] pixels = data.getData();
if (!srcCM.hasAlpha()) {
// This wouldn't be necessary if Android supported RGB_888.
for (int i = 0; i < pixels.length; i++) {
pixels[i] = pixels[i] | 0xff000000;
}
}
bmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
Matrix tm = new Matrix();
tm.setConcat(canvas.getMatrix(), AndroidGraphics2D.createMatrixObj(at));
if(at.getType() > 1) {
bmp = Bitmap.createBitmap(bmap, 0, 0, width, height, tm, true);
} else {
bmp = Bitmap.createBitmap(bmap, 0, 0, width, height, tm, false);
}
canvas.drawBitmap(bmp, dstX + (float)at.getTranslateX(), dstY + (float)at.getTranslateY(), paint);
}
private Rectangle2D getBounds2D(AffineTransform at, Rectangle r) {
int x = r.x;
int y = r.y;
int width = r.width;
int height = r.height;
float[] corners = {
x, y,
x + width, y,
x + width, y + height,
x, y + height
};
at.transform(corners, 0, corners, 0, 4);
Rectangle2D.Float bounds = new Rectangle2D.Float(corners[0], corners[1], 0 , 0);
bounds.add(corners[2], corners[3]);
bounds.add(corners[4], corners[5]);
bounds.add(corners[6], corners[7]);
return bounds;
}
private int compose(int srcRGB, boolean isSrcAlphaPre,
int dstRGB, boolean dstHasAlpha, boolean isDstAlphaPre,
int rule, int srcConstAlpha){
int sa, sr, sg, sb, da, dr, dg, db;
sa = (srcRGB >> 24) & 0xff;
sr = (srcRGB >> 16) & 0xff;
sg = (srcRGB >> 8) & 0xff;
sb = srcRGB & 0xff;
if(isSrcAlphaPre){
sa = mulLUT[srcConstAlpha][sa] & 0xff;
sr = mulLUT[srcConstAlpha][sr] & 0xff;
sg = mulLUT[srcConstAlpha][sg] & 0xff;
sb = mulLUT[srcConstAlpha][sb] & 0xff;
}else{
sa = mulLUT[srcConstAlpha][sa] & 0xff;
sr = mulLUT[sa][sr] & 0xff;
sg = mulLUT[sa][sg] & 0xff;
sb = mulLUT[sa][sb] & 0xff;
}
da = (dstRGB >> 24) & 0xff;
dr = (dstRGB >> 16) & 0xff;
dg = (dstRGB >> 8) & 0xff;
db = dstRGB & 0xff;
if(!isDstAlphaPre){
dr = mulLUT[da][dr] & 0xff;
dg = mulLUT[da][dg] & 0xff;
db = mulLUT[da][db] & 0xff;
}
int Fs = 0;
int Fd = 0;
switch(rule){
case AlphaComposite.CLEAR:
break;
case AlphaComposite.DST:
Fd = 255;
break;
case AlphaComposite.DST_ATOP:
Fs = 255 - da;
Fd = sa;
break;
case AlphaComposite.DST_IN:
Fd = sa;
break;
case AlphaComposite.DST_OUT:
Fd = 255 - sa;
break;
case AlphaComposite.DST_OVER:
Fs = 255 - da;
Fd = 255;
break;
case AlphaComposite.SRC:
Fs = 255;
break;
case AlphaComposite.SRC_ATOP:
Fs = da;
Fd = 255 - sa;
break;
case AlphaComposite.SRC_IN:
Fs = da;
break;
case AlphaComposite.SRC_OUT:
Fs = 255 - da;
break;
case AlphaComposite.SRC_OVER:
Fs = 255;
Fd = 255 - sa;
break;
case AlphaComposite.XOR:
Fs = 255 - da;
Fd = 255 - sa;
break;
}
dr = (mulLUT[sr][Fs] & 0xff) + (mulLUT[dr][Fd] & 0xff);
dg = (mulLUT[sg][Fs] & 0xff) + (mulLUT[dg][Fd] & 0xff);
db = (mulLUT[sb][Fs] & 0xff) + (mulLUT[db][Fd] & 0xff);
da = (mulLUT[sa][Fs] & 0xff) + (mulLUT[da][Fd] & 0xff);
if(!isDstAlphaPre){
if(da != 255){
dr = divLUT[da][dr] & 0xff;
dg = divLUT[da][dg] & 0xff;
db = divLUT[da][db] & 0xff;
}
}
if(!dstHasAlpha) {
da = 0xff;
}
dstRGB = (da << 24) | (dr << 16) | (dg << 8) | db;
return dstRGB;
}
/**
* Allocate an array that can be use to store the result for a
* Raster.getDataElements call.
* @param raster Raster (type) where the getDataElements call will be made.
* @param nbPixels How many pixels to store in the array at most
* @return the result array or null
*/
private Object getTransferArray(Raster raster, int nbPixels) {
int transferType = raster.getTransferType();
int nbDataElements = raster.getSampleModel().getNumDataElements();
int n = nbDataElements * nbPixels;
switch (transferType) {
case DataBuffer.TYPE_BYTE:
return new byte[n];
case DataBuffer.TYPE_SHORT:
case DataBuffer.TYPE_USHORT:
return new short[n];
case DataBuffer.TYPE_INT:
return new int[n];
case DataBuffer.TYPE_FLOAT:
return new float[n];
case DataBuffer.TYPE_DOUBLE:
return new double[n];
case DataBuffer.TYPE_UNDEFINED:
default:
return null;
}
}
/**
* Draw a pixel
*/
private void dot(int x, int y, int clr) {
if (colorCache != clr) {
paint.setColor(clr);
colorCache = clr;
}
canvas.drawLine(x, y, x + 1, y + 1, paint);
}
}
awt/com/android/internal/awt/AndroidNativeEventQueue.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import org.apache.harmony.awt.wtk.NativeEventQueue;
public class AndroidNativeEventQueue extends NativeEventQueue {
private Object eventMonitor;
public AndroidNativeEventQueue() {
super();
eventMonitor = getEventMonitor();
}
@Override
public void awake() {
synchronized (eventMonitor) {
eventMonitor.notify();
}
}
@Override
public void dispatchEvent() {
//???AWT
System.out.println(getClass()+": empty method called");
}
@Override
public long getJavaWindow() {
//???AWT
System.out.println(getClass()+": empty method called");
return 0;
}
@Override
public void performLater(Task task) {
//???AWT
System.out.println(getClass()+": empty method called");
}
@Override
public void performTask(Task task) {
//???AWT
System.out.println(getClass()+": empty method called");
}
@Override
public boolean waitEvent() {
while (isEmpty() ) {
synchronized (eventMonitor) {
try {
eventMonitor.wait(1000);
} catch (InterruptedException ignore) {
}
}
}
return false;
}
}
awt/com/android/internal/awt/AndroidWTK.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import java.awt.GraphicsDevice;
import org.apache.harmony.awt.wtk.CursorFactory;
import org.apache.harmony.awt.wtk.GraphicsFactory;
import org.apache.harmony.awt.wtk.NativeEventQueue;
import org.apache.harmony.awt.wtk.NativeIM;
import org.apache.harmony.awt.wtk.NativeMouseInfo;
import org.apache.harmony.awt.wtk.NativeRobot;
import org.apache.harmony.awt.wtk.SystemProperties;
import org.apache.harmony.awt.wtk.WTK;
import org.apache.harmony.awt.wtk.WindowFactory;
public class AndroidWTK extends WTK {
private AndroidGraphicsFactory mAgf;
private AndroidNativeEventQueue mAneq;
@Override
public CursorFactory getCursorFactory() {
// TODO Auto-generated method stub
return null;
}
@Override
public GraphicsFactory getGraphicsFactory() {
if(mAgf == null) {
mAgf = new AndroidGraphicsFactory();
}
return mAgf;
}
@Override
public NativeEventQueue getNativeEventQueue() {
if(mAneq == null) {
mAneq = new AndroidNativeEventQueue();
}
return mAneq;
}
@Override
public NativeIM getNativeIM() {
// TODO Auto-generated method stub
return null;
}
@Override
public NativeMouseInfo getNativeMouseInfo() {
// TODO Auto-generated method stub
return null;
}
@Override
public NativeRobot getNativeRobot(GraphicsDevice screen) {
// TODO Auto-generated method stub
return null;
}
@Override
public SystemProperties getSystemProperties() {
// TODO Auto-generated method stub
return null;
}
@Override
public WindowFactory getWindowFactory() {
// TODO Auto-generated method stub
return null;
}
}
awt/com/android/internal/awt/AwtFactory.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import org.apache.harmony.awt.wtk.GraphicsFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
public class AwtFactory {
private static GraphicsFactory gf;
/**
* Use this method to get acces to AWT drawing primitives and to
* render into the surface area of a Android widget. Origin and
* clip of the returned graphics object are the same as in the
* corresponding Android widget.
*
* @param c Canvas of the android widget to draw into
* @param p The default drawing parameters such as font,
* stroke, foreground and background colors, etc.
* @return The AWT Graphics object that makes all AWT
* drawing primitives available in the androind world.
*/
public static Graphics2D getAwtGraphics(Canvas c, Paint p) {
// AWT?? TODO: test it!
if (null == gf) {
Toolkit tk = Toolkit.getDefaultToolkit();
gf = tk.getGraphicsFactory();
}
return gf.getGraphics2D(c, p);
}
}
awt/com/android/internal/awt/ImageOutputStreamWrapper.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Copyright 2007, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.internal.awt;
import java.io.IOException;
import java.io.OutputStream;
import javax.imageio.stream.ImageOutputStream;
public class ImageOutputStreamWrapper extends OutputStream {
protected ImageOutputStream mIos;
private byte[] mBuff;
public ImageOutputStreamWrapper(ImageOutputStream ios) {
if (null == ios) {
throw new IllegalArgumentException("ImageOutputStream must not be null");
}
this.mIos = ios;
this.mBuff = new byte[1];
}
public ImageOutputStream getImageOutputStream() {
return mIos;
}
@Override
public void write(int oneByte) throws IOException {
mBuff[0] = (byte)oneByte;
mIos.write(mBuff, 0, 1);
}
public void write(byte[] b) throws IOException {
mIos.write(b, 0, b.length);
}
public void write(byte[] b, int off, int len) throws IOException {
mIos.write(b, off, len);
}
public void flush() throws IOException {
mIos.flush();
}
public void close() throws IOException {
if (mIos == null) {
throw new IOException("Stream already closed");
}
mIos = null;
}
}
awt/java/awt/AWTEvent.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Dmitry A. Durnev, Michael Danilov
* @version $Revision$
*/
package java.awt;
import java.util.EventObject;
import java.util.Hashtable;
import java.util.EventListener;
import java.awt.event.*;
/**
* The abstract class AWTEvent is the base class for all AWT events. This class
* and its subclasses supersede the original java.awt.Event class.
*
* @since Android 1.0
*/
public abstract class AWTEvent extends EventObject {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -1825314779160409405L;
/**
* The Constant COMPONENT_EVENT_MASK indicates the event relates to a
* component.
*/
public static final long COMPONENT_EVENT_MASK = 1;
/**
* The Constant CONTAINER_EVENT_MASK indicates the event relates to a
* container.
*/
public static final long CONTAINER_EVENT_MASK = 2;
/**
* The Constant FOCUS_EVENT_MASK indicates the event relates to the focus.
*/
public static final long FOCUS_EVENT_MASK = 4;
/**
* The Constant KEY_EVENT_MASK indicates the event relates to a key.
*/
public static final long KEY_EVENT_MASK = 8;
/**
* The Constant MOUSE_EVENT_MASK indicates the event relates to the mouse.
*/
public static final long MOUSE_EVENT_MASK = 16;
/**
* The Constant MOUSE_MOTION_EVENT_MASK indicates the event relates to a
* mouse motion.
*/
public static final long MOUSE_MOTION_EVENT_MASK = 32;
/**
* The Constant WINDOW_EVENT_MASK indicates the event relates to a window.
*/
public static final long WINDOW_EVENT_MASK = 64;
/**
* The Constant ACTION_EVENT_MASK indicates the event relates to an action.
*/
public static final long ACTION_EVENT_MASK = 128;
/**
* The Constant ADJUSTMENT_EVENT_MASK indicates the event relates to an
* adjustment.
*/
public static final long ADJUSTMENT_EVENT_MASK = 256;
/**
* The Constant ITEM_EVENT_MASK indicates the event relates to an item.
*/
public static final long ITEM_EVENT_MASK = 512;
/**
* The Constant TEXT_EVENT_MASK indicates the event relates to text.
*/
public static final long TEXT_EVENT_MASK = 1024;
/**
* The Constant INPUT_METHOD_EVENT_MASK indicates the event relates to an
* input method.
*/
public static final long INPUT_METHOD_EVENT_MASK = 2048;
/**
* The Constant PAINT_EVENT_MASK indicates the event relates to a paint
* method.
*/
public static final long PAINT_EVENT_MASK = 8192;
/**
* The Constant INVOCATION_EVENT_MASK indicates the event relates to a
* method invocation.
*/
public static final long INVOCATION_EVENT_MASK = 16384;
/**
* The Constant HIERARCHY_EVENT_MASK indicates the event relates to a
* hierarchy.
*/
public static final long HIERARCHY_EVENT_MASK = 32768;
/**
* The Constant HIERARCHY_BOUNDS_EVENT_MASK indicates the event relates to
* hierarchy bounds.
*/
public static final long HIERARCHY_BOUNDS_EVENT_MASK = 65536;
/**
* The Constant MOUSE_WHEEL_EVENT_MASK indicates the event relates to the
* mouse wheel.
*/
public static final long MOUSE_WHEEL_EVENT_MASK = 131072;
/**
* The Constant WINDOW_STATE_EVENT_MASK indicates the event relates to a
* window state.
*/
public static final long WINDOW_STATE_EVENT_MASK = 262144;
/**
* The Constant WINDOW_FOCUS_EVENT_MASK indicates the event relates to a
* window focus.
*/
public static final long WINDOW_FOCUS_EVENT_MASK = 524288;
/**
* The Constant RESERVED_ID_MAX indicates the maximum value for reserved AWT
* event IDs.
*/
public static final int RESERVED_ID_MAX = 1999;
/**
* The Constant eventsMap.
*/
private static final Hashtable<Integer, EventDescriptor> eventsMap = new Hashtable<Integer, EventDescriptor>();
/**
* The converter.
*/
private static EventConverter converter;
/**
* The ID of the event.
*/
protected int id;
/**
* The consumed indicates whether or not the event is sent back down to the
* peer once the source has processed it (false means it's sent to the peer,
* true means it's not).
*/
protected boolean consumed;
/**
* The dispatched by kfm.
*/
boolean dispatchedByKFM;
/**
* The is posted.
*/
transient boolean isPosted;
static {
eventsMap.put(new Integer(KeyEvent.KEY_TYPED), new EventDescriptor(KEY_EVENT_MASK,
KeyListener.class));
eventsMap.put(new Integer(KeyEvent.KEY_PRESSED), new EventDescriptor(KEY_EVENT_MASK,
KeyListener.class));
eventsMap.put(new Integer(KeyEvent.KEY_RELEASED), new EventDescriptor(KEY_EVENT_MASK,
KeyListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_CLICKED), new EventDescriptor(MOUSE_EVENT_MASK,
MouseListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_PRESSED), new EventDescriptor(MOUSE_EVENT_MASK,
MouseListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_RELEASED), new EventDescriptor(MOUSE_EVENT_MASK,
MouseListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_MOVED), new EventDescriptor(
MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_ENTERED), new EventDescriptor(MOUSE_EVENT_MASK,
MouseListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_EXITED), new EventDescriptor(MOUSE_EVENT_MASK,
MouseListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_DRAGGED), new EventDescriptor(
MOUSE_MOTION_EVENT_MASK, MouseMotionListener.class));
eventsMap.put(new Integer(MouseEvent.MOUSE_WHEEL), new EventDescriptor(
MOUSE_WHEEL_EVENT_MASK, MouseWheelListener.class));
eventsMap.put(new Integer(ComponentEvent.COMPONENT_MOVED), new EventDescriptor(
COMPONENT_EVENT_MASK, ComponentListener.class));
eventsMap.put(new Integer(ComponentEvent.COMPONENT_RESIZED), new EventDescriptor(
COMPONENT_EVENT_MASK, ComponentListener.class));
eventsMap.put(new Integer(ComponentEvent.COMPONENT_SHOWN), new EventDescriptor(
COMPONENT_EVENT_MASK, ComponentListener.class));
eventsMap.put(new Integer(ComponentEvent.COMPONENT_HIDDEN), new EventDescriptor(
COMPONENT_EVENT_MASK, ComponentListener.class));
eventsMap.put(new Integer(FocusEvent.FOCUS_GAINED), new EventDescriptor(FOCUS_EVENT_MASK,
FocusListener.class));
eventsMap.put(new Integer(FocusEvent.FOCUS_LOST), new EventDescriptor(FOCUS_EVENT_MASK,
FocusListener.class));
eventsMap.put(new Integer(PaintEvent.PAINT), new EventDescriptor(PAINT_EVENT_MASK, null));
eventsMap.put(new Integer(PaintEvent.UPDATE), new EventDescriptor(PAINT_EVENT_MASK, null));
eventsMap.put(new Integer(WindowEvent.WINDOW_OPENED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSING), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_CLOSED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_DEICONIFIED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_ICONIFIED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_STATE_CHANGED), new EventDescriptor(
WINDOW_STATE_EVENT_MASK, WindowStateListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_LOST_FOCUS), new EventDescriptor(
WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_GAINED_FOCUS), new EventDescriptor(
WINDOW_FOCUS_EVENT_MASK, WindowFocusListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_DEACTIVATED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(WindowEvent.WINDOW_ACTIVATED), new EventDescriptor(
WINDOW_EVENT_MASK, WindowListener.class));
eventsMap.put(new Integer(HierarchyEvent.HIERARCHY_CHANGED), new EventDescriptor(
HIERARCHY_EVENT_MASK, HierarchyListener.class));
eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_MOVED), new EventDescriptor(
HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class));
eventsMap.put(new Integer(HierarchyEvent.ANCESTOR_RESIZED), new EventDescriptor(
HIERARCHY_BOUNDS_EVENT_MASK, HierarchyBoundsListener.class));
eventsMap.put(new Integer(ContainerEvent.COMPONENT_ADDED), new EventDescriptor(
CONTAINER_EVENT_MASK, ContainerListener.class));
eventsMap.put(new Integer(ContainerEvent.COMPONENT_REMOVED), new EventDescriptor(
CONTAINER_EVENT_MASK, ContainerListener.class));
eventsMap.put(new Integer(InputMethodEvent.INPUT_METHOD_TEXT_CHANGED), new EventDescriptor(
INPUT_METHOD_EVENT_MASK, InputMethodListener.class));
eventsMap.put(new Integer(InputMethodEvent.CARET_POSITION_CHANGED), new EventDescriptor(
INPUT_METHOD_EVENT_MASK, InputMethodListener.class));
eventsMap.put(new Integer(InvocationEvent.INVOCATION_DEFAULT), new EventDescriptor(
INVOCATION_EVENT_MASK, null));
eventsMap.put(new Integer(ItemEvent.ITEM_STATE_CHANGED), new EventDescriptor(
ITEM_EVENT_MASK, ItemListener.class));
eventsMap.put(new Integer(TextEvent.TEXT_VALUE_CHANGED), new EventDescriptor(
TEXT_EVENT_MASK, TextListener.class));
eventsMap.put(new Integer(ActionEvent.ACTION_PERFORMED), new EventDescriptor(
ACTION_EVENT_MASK, ActionListener.class));
eventsMap.put(new Integer(AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED), new EventDescriptor(
ADJUSTMENT_EVENT_MASK, AdjustmentListener.class));
converter = new EventConverter();
}
/**
* Instantiates a new AWT event from the specified Event object.
*
* @param event
* the Event object.
*/
public AWTEvent(Event event) {
this(event.target, event.id);
}
/**
* Instantiates a new AWT event with the specified object and type.
*
* @param source
* the source Object.
* @param id
* the event's type.
*/
public AWTEvent(Object source, int id) {
super(source);
this.id = id;
consumed = false;
}
/**
* Gets the event's type.
*
* @return the event type ID.
*/
public int getID() {
return id;
}
/**
* Sets a new source for the AWTEvent.
*
* @param newSource
* the new source Object for the AWTEvent.
*/
public void setSource(Object newSource) {
source = newSource;
}
/**
* Returns a String representation of the AWTEvent.
*
* @return the String representation of the AWTEvent.
*/
@Override
public String toString() {
/*
* The format is based on 1.5 release behavior which can be revealed by
* the following code: AWTEvent event = new AWTEvent(new Component(){},
* 1){}; System.out.println(event);
*/
String name = ""; //$NON-NLS-1$
if (source instanceof Component && (source != null)) {
Component comp = (Component)getSource();
name = comp.getName();
if (name == null) {
name = ""; //$NON-NLS-1$
}
}
return (getClass().getName() + "[" + paramString() + "]" //$NON-NLS-1$ //$NON-NLS-2$
+ " on " + (name.length() > 0 ? name : source)); //$NON-NLS-1$
}
/**
* Returns a string representation of the AWTEvent state.
*
* @return a string representation of the AWTEvent state.
*/
public String paramString() {
// nothing to implement: all event types must override this method
return ""; //$NON-NLS-1$
}
/**
* Checks whether or not this AWTEvent has been consumed.
*
* @return true, if this AWTEvent has been consumed, false otherwise.
*/
protected boolean isConsumed() {
return consumed;
}
/**
* Consumes the AWTEvent.
*/
protected void consume() {
consumed = true;
}
/**
* Convert AWTEvent object to a corresponding (deprecated) Event object.
*
* @return new Event object which is a converted AWTEvent object or null if
* the conversion is not possible
*/
Event getEvent() {
if (id == ActionEvent.ACTION_PERFORMED) {
ActionEvent ae = (ActionEvent)this;
return converter.convertActionEvent(ae);
} else if (id == AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED) {
AdjustmentEvent ae = (AdjustmentEvent)this;
return converter.convertAdjustmentEvent(ae);
// ???AWT
// } else if (id == ComponentEvent.COMPONENT_MOVED
// && source instanceof Window) {
// //the only type of Component events is COMPONENT_MOVED on window
// ComponentEvent ce = (ComponentEvent) this;
// return converter.convertComponentEvent(ce);
} else if (id >= FocusEvent.FOCUS_FIRST && id <= FocusEvent.FOCUS_LAST) {
// nothing to convert
// ???AWT
// } else if (id == ItemEvent.ITEM_STATE_CHANGED) {
// ItemEvent ie = (ItemEvent) this;
// return converter.convertItemEvent(ie);
} else if (id == KeyEvent.KEY_PRESSED || id == KeyEvent.KEY_RELEASED) {
KeyEvent ke = (KeyEvent)this;
return converter.convertKeyEvent(ke);
} else if (id >= MouseEvent.MOUSE_FIRST && id <= MouseEvent.MOUSE_LAST) {
MouseEvent me = (MouseEvent)this;
return converter.convertMouseEvent(me);
} else if (id == WindowEvent.WINDOW_CLOSING || id == WindowEvent.WINDOW_ICONIFIED
|| id == WindowEvent.WINDOW_DEICONIFIED) {
// nothing to convert
} else {
return null;
}
return new Event(source, id, null);
}
/**
* The class EventDescriptor.
*/
static final class EventDescriptor {
/**
* The event mask.
*/
final long eventMask;
/**
* The listener type.
*/
final Class<? extends EventListener> listenerType;
/**
* Instantiates a new event descriptor.
*
* @param eventMask
* the event mask.
* @param listenerType
* the listener type.
*/
EventDescriptor(long eventMask, Class<? extends EventListener> listenerType) {
this.eventMask = eventMask;
this.listenerType = listenerType;
}
}
/**
* The class EventTypeLookup.
*/
static final class EventTypeLookup {
/**
* The last event.
*/
private AWTEvent lastEvent = null;
/**
* The last event descriptor.
*/
private EventDescriptor lastEventDescriptor = null;
/**
* Gets the event descriptor.
*
* @param event
* the event.
* @return the event descriptor.
*/
EventDescriptor getEventDescriptor(AWTEvent event) {
synchronized (this) {
if (event != lastEvent) {
lastEvent = event;
lastEventDescriptor = eventsMap.get(new Integer(event.id));
}
return lastEventDescriptor;
}
}
/**
* Gets the event mask.
*
* @param event
* the event.
* @return the event mask.
*/
long getEventMask(AWTEvent event) {
final EventDescriptor ed = getEventDescriptor(event);
return ed == null ? -1 : ed.eventMask;
}
}
/**
* The class EventConverter.
*/
static final class EventConverter {
/**
* The constant OLD_MOD_MASK.
*/
static final int OLD_MOD_MASK = Event.ALT_MASK | Event.CTRL_MASK | Event.META_MASK
| Event.SHIFT_MASK;
/**
* Convert action event.
*
* @param ae
* the ae.
* @return the event.
*/
Event convertActionEvent(ActionEvent ae) {
Event evt = new Event(ae.getSource(), ae.getID(), ae.getActionCommand());
evt.when = ae.getWhen();
evt.modifiers = ae.getModifiers() & OLD_MOD_MASK;
/*
* if (source instanceof Button) { arg = ((Button)
* source).getLabel(); } else if (source instanceof Checkbox) { arg
* = new Boolean(((Checkbox) source).getState()); } else if (source
* instanceof CheckboxMenuItem) { arg = ((CheckboxMenuItem)
* source).getLabel(); } else if (source instanceof Choice) { arg =
* ((Choice) source).getSelectedItem(); } else if (source instanceof
* List) { arg = ((List) source).getSelectedItem(); } else if
* (source instanceof MenuItem) { arg = ((MenuItem)
* source).getLabel(); } else if (source instanceof TextField) { arg
* = ((TextField) source).getText(); }
*/
return evt;
}
/**
* Convert adjustment event.
*
* @param ae
* the ae.
* @return the event.
*/
Event convertAdjustmentEvent(AdjustmentEvent ae) {
// TODO: Event.SCROLL_BEGIN/SCROLL_END
return new Event(ae.source, ae.id + ae.getAdjustmentType() - 1, new Integer(ae
.getValue()));
}
/**
* Convert component event.
*
* @param ce
* the ce.
* @return the event.
*/
Event convertComponentEvent(ComponentEvent ce) {
Component comp = ce.getComponent();
Event evt = new Event(comp, Event.WINDOW_MOVED, null);
evt.x = comp.getX();
evt.y = comp.getY();
return evt;
}
// ???AWT
/*
* Event convertItemEvent(ItemEvent ie) { int oldId = ie.id +
* ie.getStateChange() - 1; Object source = ie.source; int idx = -1; if
* (source instanceof List) { List list = (List) source; idx =
* list.getSelectedIndex(); } else if (source instanceof Choice) {
* Choice choice = (Choice) source; idx = choice.getSelectedIndex(); }
* Object arg = idx >= 0 ? new Integer(idx) : null; return new
* Event(source, oldId, arg); }
*/
/**
* Convert key event.
*
* @param ke
* the ke.
* @return the event.
*/
Event convertKeyEvent(KeyEvent ke) {
int oldId = ke.id;
// leave only old Event's modifiers
int mod = ke.getModifiers() & OLD_MOD_MASK;
Component comp = ke.getComponent();
char keyChar = ke.getKeyChar();
int keyCode = ke.getKeyCode();
int key = convertKey(keyChar, keyCode);
if (key >= Event.HOME && key <= Event.INSERT) {
oldId += 2; // non-ASCII key -> action key
}
return new Event(comp, ke.getWhen(), oldId, 0, 0, key, mod);
}
/**
* Convert mouse event.
*
* @param me
* the me.
* @return the event.
*/
Event convertMouseEvent(MouseEvent me) {
int id = me.id;
if (id != MouseEvent.MOUSE_CLICKED) {
Event evt = new Event(me.source, id, null);
evt.x = me.getX();
evt.y = me.getY();
int mod = me.getModifiers();
// in Event modifiers mean button number for mouse events:
evt.modifiers = mod & (Event.ALT_MASK | Event.META_MASK);
if (id == MouseEvent.MOUSE_PRESSED) {
evt.clickCount = me.getClickCount();
}
return evt;
}
return null;
}
/**
* Convert key.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @return the int.
*/
int convertKey(char keyChar, int keyCode) {
int key;
// F1 - F12
if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12) {
key = Event.F1 + keyCode - KeyEvent.VK_F1;
} else {
switch (keyCode) {
default: // non-action key
key = keyChar;
break;
// action keys:
case KeyEvent.VK_HOME:
key = Event.HOME;
break;
case KeyEvent.VK_END:
key = Event.END;
break;
case KeyEvent.VK_PAGE_UP:
key = Event.PGUP;
break;
case KeyEvent.VK_PAGE_DOWN:
key = Event.PGDN;
break;
case KeyEvent.VK_UP:
key = Event.UP;
break;
case KeyEvent.VK_DOWN:
key = Event.DOWN;
break;
case KeyEvent.VK_LEFT:
key = Event.LEFT;
break;
case KeyEvent.VK_RIGHT:
key = Event.RIGHT;
break;
case KeyEvent.VK_PRINTSCREEN:
key = Event.PRINT_SCREEN;
break;
case KeyEvent.VK_SCROLL_LOCK:
key = Event.SCROLL_LOCK;
break;
case KeyEvent.VK_CAPS_LOCK:
key = Event.CAPS_LOCK;
break;
case KeyEvent.VK_NUM_LOCK:
key = Event.NUM_LOCK;
break;
case KeyEvent.VK_PAUSE:
key = Event.PAUSE;
break;
case KeyEvent.VK_INSERT:
key = Event.INSERT;
break;
}
}
return key;
}
}
}
awt/java/awt/AWTException.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Michael Danilov
* @version $Revision$
*/
package java.awt;
/**
* The AWTException class is used to provide notification and information about
* AWT errors.
*
* @since Android 1.0
*/
public class AWTException extends Exception {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -1900414231151323879L;
/**
* Instantiates a new AWT exception with the specified message.
*
* @param msg
* the specific message for current exception.
*/
public AWTException(String msg) {
super(msg);
}
}
awt/java/awt/AWTKeyStroke.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Dmitry A. Durnev
* @version $Revision$
*/
package java.awt;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The AWTKeyStroke holds all of the information for the complete act of
* typing a character. This includes the events that are generated when
* the key is pressed, released, or typed (pressed and released generating
* a Unicode character result) which are associated with the event
* objects KeyEvent.KEY_PRESSED, KeyEvent.KEY_RELEASED, or KeyEvent.KEY_TYPED.
* It also holds information about which modifiers (such as control or
* shift) were used in conjunction with the keystroke. The following masks
* are available to identify the modifiers:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
* <li>java.awt.event.InputEvent.ALT_MASK</li>
* <li>java.awt.event.InputEvent.CTRL_MASK</li>
* <li>java.awt.event.InputEvent.META_MASK</li>
* <li>java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
* <br>
* The AWTKeyStroke is unique, and applications should not create their own
* instances of AWTKeyStroke. All applications should use getAWTKeyStroke
* methods for obtaining instances of AWTKeyStroke.
*
* @since Android 1.0
*/
public class AWTKeyStroke implements Serializable {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -6430539691155161871L;
/**
* The Constant cache.
*/
private static final Map<AWTKeyStroke, AWTKeyStroke> cache = new HashMap<AWTKeyStroke, AWTKeyStroke>(); // Map
// <
// AWTKeyStroke
// ,
// ?
// extends
// AWTKeyStroke
// >
/**
* The Constant keyEventTypesMap.
*/
private static final Map<Integer, String> keyEventTypesMap = new HashMap<Integer, String>(); // Map
// <
// int
// ,
// String
// >
private static Constructor<?> subConstructor;
static {
keyEventTypesMap.put(new Integer(KeyEvent.KEY_PRESSED), "pressed"); //$NON-NLS-1$
keyEventTypesMap.put(new Integer(KeyEvent.KEY_RELEASED), "released"); //$NON-NLS-1$
keyEventTypesMap.put(new Integer(KeyEvent.KEY_TYPED), "typed"); //$NON-NLS-1$
}
/**
* The key char.
*/
private char keyChar;
/**
* The key code.
*/
private int keyCode;
/**
* The modifiers.
*/
private int modifiers;
/**
* The on key release.
*/
private boolean onKeyRelease;
/**
* Instantiates a new AWTKeyStroke. getAWTKeyStroke method should be used by
* applications code.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* true if AWTKeyStroke is for a key release, false otherwise.
*/
protected AWTKeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
setAWTKeyStroke(keyChar, keyCode, modifiers, onKeyRelease);
}
/**
* Sets the AWT key stroke.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
*/
private void setAWTKeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
this.keyChar = keyChar;
this.keyCode = keyCode;
this.modifiers = modifiers;
this.onKeyRelease = onKeyRelease;
}
/**
* Instantiates a new AWTKeyStroke with default parameters:
* KeyEvent.CHAR_UNDEFINED key char, KeyEvent.VK_UNDEFINED key code, without
* modifiers and false key realized value.
*/
protected AWTKeyStroke() {
this(KeyEvent.CHAR_UNDEFINED, KeyEvent.VK_UNDEFINED, 0, false);
}
/**
* Returns the unique number value for AWTKeyStroke object.
*
* @return the integer unique value of the AWTKeyStroke object.
*/
@Override
public int hashCode() {
return modifiers + (keyCode != KeyEvent.VK_UNDEFINED ? keyCode : keyChar)
+ (onKeyRelease ? -1 : 0);
}
/**
* Gets the set of modifiers for the AWTKeyStroke object.
*
* @return the integer value which contains modifiers.
*/
public final int getModifiers() {
return modifiers;
}
/**
* Compares this AWTKeyStroke object to the specified object.
*
* @param anObject
* the specified AWTKeyStroke object to compare with this
* instance.
* @return true if objects are identical, false otherwise.
*/
@Override
public final boolean equals(Object anObject) {
if (anObject instanceof AWTKeyStroke) {
AWTKeyStroke key = (AWTKeyStroke)anObject;
return ((key.keyCode == keyCode) && (key.keyChar == keyChar)
&& (key.modifiers == modifiers) && (key.onKeyRelease == onKeyRelease));
}
return false;
}
/**
* Returns the string representation of the AWTKeyStroke. This string should
* contain key stroke properties.
*
* @return the string representation of the AWTKeyStroke.
*/
@Override
public String toString() {
int type = getKeyEventType();
return InputEvent.getModifiersExText(getModifiers()) + " " + //$NON-NLS-1$
keyEventTypesMap.get(new Integer(type)) + " " + //$NON-NLS-1$
(type == KeyEvent.KEY_TYPED ? new String(new char[] {
keyChar
}) : KeyEvent.getKeyText(keyCode));
}
/**
* Gets the key code for the AWTKeyStroke object.
*
* @return the key code for the AWTKeyStroke object.
*/
public final int getKeyCode() {
return keyCode;
}
/**
* Gets the key character for the AWTKeyStroke object.
*
* @return the key character for the AWTKeyStroke object.
*/
public final char getKeyChar() {
return keyChar;
}
/**
* Gets the AWT key stroke.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
* @return the AWT key stroke.
*/
private static AWTKeyStroke getAWTKeyStroke(char keyChar, int keyCode, int modifiers,
boolean onKeyRelease) {
AWTKeyStroke key = newInstance(keyChar, keyCode, modifiers, onKeyRelease);
AWTKeyStroke value = cache.get(key);
if (value == null) {
value = key;
cache.put(key, value);
}
return value;
}
/**
* New instance.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
* @return the AWT key stroke.
*/
private static AWTKeyStroke newInstance(char keyChar, int keyCode, int modifiers,
boolean onKeyRelease) {
AWTKeyStroke key;
// ???AWT
// if (subConstructor == null) {
key = new AWTKeyStroke();
// ???AWT
// } else {
// try {
// key = (AWTKeyStroke) subConstructor.newInstance();
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
int allModifiers = getAllModifiers(modifiers);
key.setAWTKeyStroke(keyChar, keyCode, allModifiers, onKeyRelease);
return key;
}
/**
* Adds the mask.
*
* @param mod
* the mod.
* @param mask
* the mask.
* @return the int.
*/
private static int addMask(int mod, int mask) {
return ((mod & mask) != 0) ? (mod | mask) : mod;
}
/**
* Return all (old & new) modifiers corresponding to.
*
* @param mod
* old or new modifiers.
* @return old and new modifiers together.
*/
static int getAllModifiers(int mod) {
int allMod = mod;
int shift = (InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK);
int ctrl = (InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK);
int meta = (InputEvent.META_MASK | InputEvent.META_DOWN_MASK);
int alt = (InputEvent.ALT_MASK | InputEvent.ALT_DOWN_MASK);
int altGr = (InputEvent.ALT_GRAPH_MASK | InputEvent.ALT_GRAPH_DOWN_MASK);
// button modifiers are not converted between old & new
allMod = addMask(allMod, shift);
allMod = addMask(allMod, ctrl);
allMod = addMask(allMod, meta);
allMod = addMask(allMod, alt);
allMod = addMask(allMod, altGr);
return allMod;
}
/**
* Returns an instance of AWTKeyStroke for parsed string. The string must
* have the following syntax:
*<p>
* &lt;modifiers&gt;* (&lt;typedID&gt; | &lt;pressedReleasedID&gt;)
*<p>
* modifiers := shift | control | ctrl | meta | alt | altGraph <br>
* typedID := typed <typedKey> <br>
* typedKey := string of length 1 giving the Unicode character. <br>
* pressedReleasedID := (pressed | released) <key> <br>
* key := KeyEvent key code name, i.e. the name following "VK_".
* <p>
*
* @param s
* the String which contains key stroke parameters.
* @return the AWTKeyStroke for string.
* @throws IllegalArgumentException
* if string has incorrect format or null.
*/
public static AWTKeyStroke getAWTKeyStroke(String s) {
if (s == null) {
// awt.65=null argument
throw new IllegalArgumentException(Messages.getString("awt.65")); //$NON-NLS-1$
}
StringTokenizer tokenizer = new StringTokenizer(s);
Boolean release = null;
int modifiers = 0;
int keyCode = KeyEvent.VK_UNDEFINED;
char keyChar = KeyEvent.CHAR_UNDEFINED;
boolean typed = false;
long modifier = 0;
String token = null;
do {
token = getNextToken(tokenizer);
modifier = parseModifier(token);
modifiers |= modifier;
} while (modifier > 0);
typed = parseTypedID(token);
if (typed) {
token = getNextToken(tokenizer);
keyChar = parseTypedKey(token);
}
if (keyChar == KeyEvent.CHAR_UNDEFINED) {
release = parsePressedReleasedID(token);
if (release != null) {
token = getNextToken(tokenizer);
}
keyCode = parseKey(token);
}
if (tokenizer.hasMoreTokens()) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return getAWTKeyStroke(keyChar, keyCode, modifiers, release == Boolean.TRUE);
}
/**
* Gets the next token.
*
* @param tokenizer
* the tokenizer.
* @return the next token.
*/
private static String getNextToken(StringTokenizer tokenizer) {
try {
return tokenizer.nextToken();
} catch (NoSuchElementException exception) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
}
/**
* Gets the key code.
*
* @param s
* the s.
* @return the key code.
*/
static int getKeyCode(String s) {
try {
Field vk = KeyEvent.class.getField("VK_" + s); //$NON-NLS-1$
return vk.getInt(null);
} catch (Exception e) {
if (s.length() != 1) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return KeyEvent.VK_UNDEFINED;
}
}
/**
* Gets an instance of the AWTKeyStroke for specified character.
*
* @param keyChar
* the keyboard character value.
* @return a AWTKeyStroke for specified character.
*/
public static AWTKeyStroke getAWTKeyStroke(char keyChar) {
return getAWTKeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
}
/**
* Returns an instance of AWTKeyStroke for a given key code, set of
* modifiers, and specified key released flag value. The key codes are
* defined in java.awt.event.KeyEvent class. The set of modifiers is given
* as a bitwise combination of masks taken from the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
* <br>
*
* @param keyCode
* the specified key code of keyboard.
* @param modifiers
* the bit set of modifiers.
* @param onKeyRelease
* the value which represents whether this AWTKeyStroke shall
* represents a key release.
* @return the AWTKeyStroke.
*/
public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers, boolean onKeyRelease) {
return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, onKeyRelease);
}
/**
* Returns AWTKeyStroke for a specified character and set of modifiers. The
* set of modifiers is given as a bitwise combination of masks taken from
* the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
*
* @param keyChar
* the Character object which represents keyboard character
* value.
* @param modifiers
* the bit set of modifiers.
* @return the AWTKeyStroke object.
* @throws IllegalArgumentException
* if keyChar value is null.
*/
public static AWTKeyStroke getAWTKeyStroke(Character keyChar, int modifiers) {
if (keyChar == null) {
// awt.01='{0}' parameter is null
throw new IllegalArgumentException(Messages.getString("awt.01", "keyChar")); //$NON-NLS-1$ //$NON-NLS-2$
}
return getAWTKeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED, modifiers, false);
}
/**
* Returns an instance of AWTKeyStroke for a specified key code and set of
* modifiers. The key codes are defined in java.awt.event.KeyEvent class.
* The set of modifiers is given as a bitwise combination of masks taken
* from the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
*
* @param keyCode
* the specified key code of keyboard.
* @param modifiers
* the bit set of modifiers.
* @return the AWTKeyStroke.
*/
public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers) {
return getAWTKeyStroke(keyCode, modifiers, false);
}
/**
* Gets the AWTKeyStroke for a key event. This method obtains the key char
* and key code from the specified key event.
*
* @param anEvent
* the key event which identifies the desired AWTKeyStroke.
* @return the AWTKeyStroke for the key event.
*/
public static AWTKeyStroke getAWTKeyStrokeForEvent(KeyEvent anEvent) {
int id = anEvent.getID();
char undef = KeyEvent.CHAR_UNDEFINED;
char keyChar = (id == KeyEvent.KEY_TYPED ? anEvent.getKeyChar() : undef);
int keyCode = (keyChar == undef ? anEvent.getKeyCode() : KeyEvent.VK_UNDEFINED);
return getAWTKeyStroke(keyChar, keyCode, anEvent.getModifiersEx(),
id == KeyEvent.KEY_RELEASED);
}
/**
* Gets the key event type for the AWTKeyStroke object.
*
* @return the key event type: KeyEvent.KEY_PRESSED, KeyEvent.KEY_TYPED, or
* KeyEvent.KEY_RELEASED.
*/
public final int getKeyEventType() {
if (keyCode == KeyEvent.VK_UNDEFINED) {
return KeyEvent.KEY_TYPED;
}
return (onKeyRelease ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED);
}
/**
* Returns true if the key event is associated with the AWTKeyStroke is
* KEY_RELEASED, false otherwise.
*
* @return true, if if the key event associated with the AWTKeyStroke is
* KEY_RELEASED, false otherwise.
*/
public final boolean isOnKeyRelease() {
return onKeyRelease;
}
/**
* Read resolve.
*
* @return the object.
* @throws ObjectStreamException
* the object stream exception.
*/
protected Object readResolve() throws ObjectStreamException {
return getAWTKeyStroke(this.keyChar, this.keyCode, this.modifiers, this.onKeyRelease);
}
/**
* Register subclass.
*
* @param subclass
* the subclass.
*/
protected static void registerSubclass(Class<?> subclass) {
// ???AWT
/*
* if (subclass == null) { // awt.01='{0}' parameter is null throw new
* IllegalArgumentException(Messages.getString("awt.01", "subclass"));
* //$NON-NLS-1$ //$NON-NLS-2$ } if (!
* AWTKeyStroke.class.isAssignableFrom(subclass)) { // awt.67=subclass
* is not derived from AWTKeyStroke throw new
* ClassCastException(Messages.getString("awt.67")); //$NON-NLS-1$ } try
* { subConstructor = subclass.getDeclaredConstructor();
* subConstructor.setAccessible(true); } catch (SecurityException e) {
* throw new RuntimeException(e); } catch (NoSuchMethodException e) { //
* awt.68=subclass could not be instantiated throw new
* IllegalArgumentException(Messages.getString("awt.68")); //$NON-NLS-1$
* } cache.clear(); //flush the cache
*/
}
/**
* Parses the modifier.
*
* @param strMod
* the str mod.
* @return the long.
*/
private static long parseModifier(String strMod) {
long modifiers = 0l;
if (strMod.equals("shift")) { //$NON-NLS-1$
modifiers |= InputEvent.SHIFT_DOWN_MASK;
} else if (strMod.equals("control") || strMod.equals("ctrl")) { //$NON-NLS-1$ //$NON-NLS-2$
modifiers |= InputEvent.CTRL_DOWN_MASK;
} else if (strMod.equals("meta")) { //$NON-NLS-1$
modifiers |= InputEvent.META_DOWN_MASK;
} else if (strMod.equals("alt")) { //$NON-NLS-1$
modifiers |= InputEvent.ALT_DOWN_MASK;
} else if (strMod.equals("altGraph")) { //$NON-NLS-1$
modifiers |= InputEvent.ALT_GRAPH_DOWN_MASK;
} else if (strMod.equals("button1")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON1_DOWN_MASK;
} else if (strMod.equals("button2")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON2_DOWN_MASK;
} else if (strMod.equals("button3")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON3_DOWN_MASK;
}
return modifiers;
}
/**
* Parses the typed id.
*
* @param strTyped
* the str typed.
* @return true, if successful.
*/
private static boolean parseTypedID(String strTyped) {
if (strTyped.equals("typed")) { //$NON-NLS-1$
return true;
}
return false;
}
/**
* Parses the typed key.
*
* @param strChar
* the str char.
* @return the char.
*/
private static char parseTypedKey(String strChar) {
char keyChar = KeyEvent.CHAR_UNDEFINED;
if (strChar.length() != 1) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
keyChar = strChar.charAt(0);
return keyChar;
}
/**
* Parses the pressed released id.
*
* @param str
* the str.
* @return the boolean.
*/
private static Boolean parsePressedReleasedID(String str) {
if (str.equals("pressed")) { //$NON-NLS-1$
return Boolean.FALSE;
} else if (str.equals("released")) { //$NON-NLS-1$
return Boolean.TRUE;
}
return null;
}
/**
* Parses the key.
*
* @param strCode
* the str code.
* @return the int.
*/
private static int parseKey(String strCode) {
int keyCode = KeyEvent.VK_UNDEFINED;
keyCode = getKeyCode(strCode);
if (keyCode == KeyEvent.VK_UNDEFINED) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return keyCode;
}
}
awt/java/awt/AWTListenerList.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.awt;
import java.util.EventListener;
import org.apache.harmony.awt.ListenerList;
final class AWTListenerList<T extends EventListener> extends ListenerList<T> {
private static final long serialVersionUID = -2622077171532840953L;
private final Component owner;
AWTListenerList() {
super();
this.owner = null;
}
AWTListenerList(Component owner) {
super();
this.owner = owner;
}
@Override
public void addUserListener(T listener) {
super.addUserListener(listener);
if (owner != null) {
owner.deprecatedEventHandler = false;
}
}
}
awt/java/awt/AWTPermission.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Pavel Dolgov
* @version $Revision$
*/
package java.awt;
import java.security.BasicPermission;
/**
* The AWTPermission specifies the name of the permission and the corresponding
* action list.
*
* @since Android 1.0
*/
public final class AWTPermission extends BasicPermission {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = 8890392402588814465L;
/**
* Instantiates a new AWTPermission with defined name and actions.
*
* @param name
* the name of a new AWTPermission.
* @param actions
* the actions of a new AWTPermission.
*/
public AWTPermission(String name, String actions) {
super(name, actions);
}
/**
* Instantiates a new AWT permission with the defined name.
*
* @param name
* the name of a new AWTPermission.
*/
public AWTPermission(String name) {
super(name);
}
}
awt/java/awt/ActiveEvent.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Michael Danilov
* @version $Revision$
*/
package java.awt;
/**
* This interface defines events that know how to dispatch themselves. Such
* event can be placed upon the event queue and its dispatch method will be
* called when the event is dispatched.
*
* @since Android 1.0
*/
public interface ActiveEvent {
/**
* Dispatches the event to the listeners of the event's source, or does
* whatever it is this event is supposed to do.
*/
public void dispatch();
}
awt/java/awt/Adjustable.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Pavel Dolgov
* @version $Revision$
*/
package java.awt;
import java.awt.event.AdjustmentListener;
/**
* The Adjustable interface represents an adjustable numeric value contained
* within a bounded range of values, such as the current location in scrollable
* region or the value of a gauge.
*
* @since Android 1.0
*/
public interface Adjustable {
/**
* The Constant HORIZONTAL indicates that the Adjustable's orientation is
* horizontal.
*/
public static final int HORIZONTAL = 0;
/**
* The Constant VERTICAL indicates that the Adjustable's orientation is
* vertical.
*/
public static final int VERTICAL = 1;
/**
* The Constant NO_ORIENTATION indicates that the Adjustable has no
* orientation.
*/
public static final int NO_ORIENTATION = 2;
/**
* Gets the value of the Adjustable.
*
* @return the current value of the Adjustable.
*/
public int getValue();
/**
* Sets the value to the Adjustable object.
*
* @param a0
* the new value of the Adjustable object.
*/
public void setValue(int a0);
/**
* Adds the AdjustmentListener to current Adjustment.
*
* @param a0
* the AdjustmentListener object.
*/
public void addAdjustmentListener(AdjustmentListener a0);
/**
* Gets the block increment of the Adjustable.
*
* @return the block increment of the Adjustable.
*/
public int getBlockIncrement();
/**
* Gets the maximum value of the Adjustable.
*
* @return the maximum value of the Adjustable.
*/
public int getMaximum();
/**
* Gets the minimum value of the Adjustable.
*
* @return the minimum value of the Adjustable.
*/
public int getMinimum();
/**
* Gets the orientation of the Adjustable.
*
* @return the orientation of the Adjustable.
*/
public int getOrientation();
/**
* Gets the unit increment of the Adjustable.
*
* @return the unit increment of the Adjustable.
*/
public int getUnitIncrement();
/**
* Gets the visible amount of the Adjustable.
*
* @return the visible amount of the Adjustable.
*/
public int getVisibleAmount();
/**
* Removes the adjustment listener of the Adjustable.
*
* @param a0
* the specified AdjustmentListener to be removed.
*/
public void removeAdjustmentListener(AdjustmentListener a0);
/**
* Sets the block increment for the Adjustable.
*
* @param a0
* the new block increment.
*/
public void setBlockIncrement(int a0);
/**
* Sets the maximum value of the Adjustable.
*
* @param a0
* the new maximum of the Adjustable.
*/
public void setMaximum(int a0);
/**
* Sets the minimum value of the Adjustable.
*
* @param a0
* the new minimum of the Adjustable.
*/
public void setMinimum(int a0);
/**
* Sets the unit increment of the Adjustable.
*
* @param a0
* the new unit increment of the Adjustable.
*/
public void setUnitIncrement(int a0);
/**
* Sets the visible amount of the Adjustable.
*
* @param a0
* the new visible amount of the Adjustable.
*/
public void setVisibleAmount(int a0);
}
awt/java/awt/AlphaComposite.java deleted 100644 → 0
View file @ 43aa2b1c
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Igor V. Stolyarov
* @version $Revision$
*/
package java.awt;
import java.awt.Composite;
import java.awt.CompositeContext;
import java.awt.RenderingHints;
import java.awt.image.ColorModel;
import org.apache.harmony.awt.gl.ICompositeContext;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The AlphaComposite class defines a basic alpha compositing rules for
* combining source and destination colors to achieve blending and transparency
* effects with graphics and images.
*
* @since Android 1.0
*/
public final class AlphaComposite implements Composite {
/**
* The Constant CLEAR indicates that both the color and the alpha of the
* destination are cleared (Porter-Duff Clear rule).
*/
public static final int CLEAR = 1;
/**
* The Constant SRC indicates that the source is copied to the destination
* (Porter-Duff Source rule).
*/
public static final int SRC = 2;
/**
* The Constant DST indicates that the destination is left untouched
* (Porter-Duff Destination rule).
*/
public static final int DST = 9;
/**
* The Constant SRC_OVER indicates that the source is composited over the
* destination (Porter-Duff Source Over Destination rule).
*/
public static final int SRC_OVER = 3;
/**
* The Constant DST_OVER indicates that The destination is composited over
* the source and the result replaces the destination (Porter-Duff
* Destination Over Source rule).
*/
public static final int DST_OVER = 4;
/**
* The Constant SRC_IN indicates that the part of the source lying inside of
* the destination replaces the destination (Porter-Duff Source In
* Destination rule).
*/
public static final int SRC_IN = 5;
/**
* The Constant DST_IN indicates that the part of the destination lying
* inside of the source replaces the destination (Porter-Duff Destination In
* Source rule).
*/
public static final int DST_IN = 6;
/**
* The Constant SRC_OUT indicates that the part of the source lying outside
* of the destination replaces the destination (Porter-Duff Source Held Out
* By Destination rule).
*/
public static final int SRC_OUT = 7;
/**
* The Constant DST_OUT indicates that the part of the destination lying
* outside of the source replaces the destination (Porter-Duff Destination
* Held Out By Source rule).
*/
public static final int DST_OUT = 8;
/**
* The Constant SRC_ATOP indicates that the part of the source lying inside
* of the destination is composited onto the destination (Porter-Duff Source
* Atop Destination rule).
*/
public static final int SRC_ATOP = 10;
/**
* The Constant DST_ATOP indicates that the part of the destination lying
* inside of the source is composited over the source and replaces the
* destination (Porter-Duff Destination Atop Source rule).
*/
public static final int DST_ATOP = 11;
/**
* The Constant XOR indicates that the part of the source that lies outside
* of the destination is combined with the part of the destination that lies
* outside of the source (Porter-Duff Source Xor Destination rule).
*/
public static final int XOR = 12;
/**
* AlphaComposite object with the opaque CLEAR rule and an alpha of 1.0f.
*/
public static final AlphaComposite Clear = new AlphaComposite(CLEAR);
/**
* AlphaComposite object with the opaque SRC rule and an alpha of 1.0f.
*/
public static final AlphaComposite Src = new AlphaComposite(SRC);
/**
* AlphaComposite object with the opaque DST rule and an alpha of 1.0f.
*/
public static final AlphaComposite Dst = new AlphaComposite(DST);
/**
* AlphaComposite object with the opaque SRC_OVER rule and an alpha of 1.0f.
*/
public static final AlphaComposite SrcOver = new AlphaComposite(SRC_OVER);
/**
* AlphaComposite object with the opaque DST_OVER rule and an alpha of 1.0f.
*/
public static final AlphaComposite DstOver = new AlphaComposite(DST_OVER);
/**
* AlphaComposite object with the opaque SRC_IN rule and an alpha of 1.0f.
*/
public static final AlphaComposite SrcIn = new AlphaComposite(SRC_IN);
/**
* AlphaComposite object with the opaque DST_IN rule and an alpha of 1.0f.
*/
public static final AlphaComposite DstIn = new AlphaComposite(DST_IN);
/**
* AlphaComposite object with the opaque SRC_OUT rule and an alpha of 1.0f.
*/
public static final AlphaComposite SrcOut = new AlphaComposite(SRC_OUT);
/**
* AlphaComposite object with the opaque DST_OUT rule and an alpha of 1.0f.
*/
public static final AlphaComposite DstOut = new AlphaComposite(DST_OUT);
/**
* AlphaComposite object with the opaque SRC_ATOP rule and an alpha of 1.0f.
*/
public static final AlphaComposite SrcAtop = new AlphaComposite(SRC_ATOP);
/**
* AlphaComposite object with the opaque DST_ATOP rule and an alpha of 1.0f.
*/
public static final AlphaComposite DstAtop = new AlphaComposite(DST_ATOP);
/**
* AlphaComposite object with the opaque XOR rule and an alpha of 1.0f.
*/
public static final AlphaComposite Xor = new AlphaComposite(XOR);
/**
* The rule.
*/
private int rule;
/**
* The alpha.
*/
private float alpha;
/**
* Instantiates a new alpha composite. Creates a context for the compositing
* operation. The context contains state that is used in performing the
* compositing operation.
*
* @param rule
* the rule.
* @param alpha
* the alpha.
*/
private AlphaComposite(int rule, float alpha) {
if (rule < CLEAR || rule > XOR) {
// awt.11D=Unknown rule
throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$
}
if (alpha < 0.0f || alpha > 1.0f) {
// awt.11E=Wrong alpha value
throw new IllegalArgumentException(Messages.getString("awt.11E")); //$NON-NLS-1$
}
this.rule = rule;
this.alpha = alpha;
}
/**
* Instantiates a new alpha composite.
*
* @param rule
* the rule.
*/
private AlphaComposite(int rule) {
this(rule, 1.0f);
}
/**
* Creates a CompositeContext object with the specified source ColorModel,
* destination ColorModel and RenderingHints parameters for a composing
* operation.
*
* @param srcColorModel
* the source's ColorModel.
* @param dstColorModel
* the destination's ColorModel.
* @param hints
* the RenderingHints object.
* @return the CompositeContext object.
* @see java.awt.Composite#createContext(java.awt.image.ColorModel,
* java.awt.image.ColorModel, java.awt.RenderingHints)
*/
public CompositeContext createContext(ColorModel srcColorModel, ColorModel dstColorModel,
RenderingHints hints) {
return new ICompositeContext(this, srcColorModel, dstColorModel);
}
/**
* Compares the AlphaComposite object with the specified object.
*
* @param obj
* the Object to be compared.
* @return true, if the AlphaComposite object is equal to the specified
* object.
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof AlphaComposite)) {
return false;
}
AlphaComposite other = (AlphaComposite)obj;
return (this.rule == other.getRule() && this.alpha == other.getAlpha());
}
/**
* Returns the hash code of the AlphaComposite object.
*
* @return the hash code of the AlphaComposite object.
*/
@Override
public int hashCode() {
int hash = Float.floatToIntBits(alpha);
int tmp = hash >>> 24;
hash <<= 8;
hash |= tmp;
hash ^= rule;
return hash;
}
/**
* Gets the compositing rule of this AlphaComposite object.
*
* @return the compositing rule of this AlphaComposite object.
*/
public int getRule() {
return rule;
}
/**
* Gets the alpha value of this AlphaComposite object; returns 1.0 if this
* AlphaComposite object doesn't have alpha value.
*
* @return the alpha value of this AlphaComposite object or 1.0 if this
* AlphaComposite object doesn't have alpha value.
*/
public float getAlpha() {
return alpha;
}
/**
* Gets the AlphaComposite instance with the specified rule and alpha value.
*
* @param rule
* the compositing rule.
* @param alpha
* the alpha value.
* @return the AlphaComposite instance.
*/
public static AlphaComposite getInstance(int rule, float alpha) {
if (alpha == 1.0f) {
return getInstance(rule);
}
return new AlphaComposite(rule, alpha);
}
/**
* Gets the AlphaComposite instance with the specified rule.
*
* @param rule
* the compositing rule.
* @return the AlphaComposite instance.
*/
public static AlphaComposite getInstance(int rule) {
switch (rule) {
case CLEAR:
return Clear;
case SRC:
return Src;
case DST:
return Dst;
case SRC_OVER:
return SrcOver;
case DST_OVER:
return DstOver;
case SRC_IN:
return SrcIn;
case DST_IN:
return DstIn;
case SRC_OUT:
return SrcOut;
case DST_OUT:
return DstOut;
case SRC_ATOP:
return SrcAtop;
case DST_ATOP:
return DstAtop;
case XOR:
return Xor;
default:
// awt.11D=Unknown rule
throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$
}
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment