1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 package javax.microedition.lcdui;

    18 

    19 import javax.microedition.lcdui.game.Sprite;

    20 

    21 import com.nokia.mid.ui.DirectGraphics;

    22 

    23 /**

    24  * DirectGraphics interface implementation class.

    25  *

    26  * @see DirectGraphics

    27  */

    28 class DirectGraphicsImpl implements DirectGraphics {

    29 

    30     private static final int MANIPULATION_MASK = 0x0FFF;

    31 

    32     private Graphics graphics;

    33 

    34     private int alpha;

    35 

    36     DirectGraphicsImpl(Graphics g) {

    37         graphics = g;

    38     }

    39 

    40     public void drawImage(Image img, int x, int y, int anchor,

    41             int manipulation) {

    42 

    43         int transform = getTransformation(manipulation);

    44         if (transform < 0) {

    45             throw new IllegalArgumentException(

    46                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_MANIPULATION);

    47         }

    48         graphics.drawRegion(img, 0, 0, img.getWidth(), img.getHeight(),

    49                 transform, x, y, anchor);

    50     }

    51 

    52     public void drawPixels(final int[] pixels, final boolean transparency,

    53             final int offset, final int scanlength, final int x, final int y,

    54             final int width, final int height, final int manipulation,

    55             final int format) {

    56 

    57         int transform = getTransformation(manipulation);

    58         if (transform < 0) {

    59             throw new IllegalArgumentException(

    60                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_MANIPULATION);

    61         }

    62         if (format != TYPE_INT_888_RGB && format != TYPE_INT_8888_ARGB) {

    63             throw new IllegalArgumentException(

    64                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

    65         }

    66 

    67         final boolean processAlpha = (format == TYPE_INT_8888_ARGB);

    68         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

    69             public void run() {

    70                 graphics.getGc().drawRGB(pixels, offset, scanlength,

    71                         x, y, width, height, processAlpha,

    72                         getNativeTransformValue(manipulation));

    73             }

    74         });

    75     }

    76 

    77     public void drawPixels(final byte[] pixels, final byte[] transparencyMask,

    78             final int offset, final int scanlength, final int x, final int y,

    79             final int width, final int height, final int manipulation,

    80             final int format) {

    81 

    82         int transform = getTransformation(manipulation);

    83         if (transform < 0) {

    84             throw new IllegalArgumentException(

    85                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_MANIPULATION);

    86         }

    87         if (format != TYPE_BYTE_1_GRAY && format != TYPE_BYTE_2_GRAY) {

    88             throw new IllegalArgumentException(

    89                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

    90         }

    91 

    92         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

    93             public void run() {

    94                 graphics.getGc().drawRGB(pixels, transparencyMask, offset, scanlength,

    95                         x, y, width, height, getNativeTransformValue(manipulation),

    96                         getNativeFormatValue(format));

    97             }

    98         });

    99     }

   100 

   101     public void drawPixels(final short[] pixels, final boolean transparency,

   102             final int offset, final int scanlength, final int x, final int y,

   103             final int width, final int height, final int manipulation,

   104             final int format) {

   105 

   106         int transform = getTransformation(manipulation);

   107         if (transform < 0) {

   108             throw new IllegalArgumentException(

   109                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_MANIPULATION);

   110         }

   111         if (format != TYPE_USHORT_4444_ARGB

   112                 && format != TYPE_USHORT_444_RGB

   113                 && format != TYPE_USHORT_565_RGB

   114                 && format != TYPE_USHORT_555_RGB) {

   115             throw new IllegalArgumentException(

   116                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

   117         }

   118 

   119         final boolean processAlpha = (format == TYPE_USHORT_4444_ARGB);

   120         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   121             public void run() {

   122                 graphics.getGc().drawRGB(pixels, offset, scanlength,

   123                         x, y, width, height, processAlpha,

   124                         getNativeTransformValue(manipulation),

   125                         getNativeFormatValue(format));

   126             }

   127         });

   128     }

   129 

   130     public void drawPolygon(int[] xPoints, int xOffset, int[] yPoints,

   131             int yOffset, int nPoints, int argbColor) {

   132         setARGBColor(argbColor);

   133         final int[] points = new int[nPoints * 2];

   134         for (int i = 0; i < nPoints; i++) {

   135             points[i * 2] = xPoints[xOffset + i];

   136             points[(i * 2) + 1] = yPoints[yOffset + i];

   137         }

   138         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   139             public void run() {

   140                 graphics.getGc().drawPolygon(points);

   141             }

   142         });

   143     }

   144 

   145     public void drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3,

   146             int argbColor) {

   147         setARGBColor(argbColor);

   148         final int[] points = {x1, y1, x2, y2, x3, y3};

   149         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   150             public void run() {

   151                 graphics.getGc().drawPolygon(points);

   152             }

   153         });

   154     }

   155 

   156     public void fillPolygon(int[] xPoints, int xOffset, int[] yPoints,

   157             int yOffset, int nPoints, int argbColor) {

   158         setARGBColor(argbColor);

   159         final int[] points = new int[nPoints * 2];

   160         for (int i = 0; i < nPoints; i++) {

   161             points[i * 2] = xPoints[xOffset + i];

   162             points[(i * 2) + 1] = yPoints[yOffset + i];

   163         }

   164         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   165             public void run() {

   166                 graphics.getGc().fillPolygon(points);

   167             }

   168         });

   169     }

   170 

   171     public void fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3,

   172             int argbColor) {

   173         setARGBColor(argbColor);

   174         final int[] points = {x1, y1, x2, y2, x3, y3};

   175         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   176             public void run() {

   177                 graphics.getGc().fillPolygon(points);

   178             }

   179         });

   180     }

   181 

   182 

   183     public void getPixels(final int[] pixels, final int offset,

   184             final int scanlength, final int x, final int y, final int width,

   185             final int height, final int format) {

   186         if (format != TYPE_INT_888_RGB) {

   187             throw new IllegalArgumentException(

   188                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

   189         }

   190         if (width < 0 || height < 0) {

   191             throw new IllegalArgumentException(

   192                    MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_WIDTH_HEIGHT);

   193         }

   194         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   195             public void run() {

   196                 org.eclipse.swt.internal.qt.graphics.Image cgImg;

   197                 Object target = graphics.getGc().getBoundTarget();

   198                 if (target != null && target instanceof org.eclipse.swt.internal.qt.graphics.Image) {

   199                     cgImg = (org.eclipse.swt.internal.qt.graphics.Image) target;

   200                 }

   201                 else {

   202                     cgImg = new org.eclipse.swt.internal.qt.graphics.Image(width, height);

   203                     // TODO: in future the copyArea() signature will change

   204                     graphics.getGc().copyArea(cgImg, x, y);

   205                 }

   206                 cgImg.getRGB(pixels, offset, scanlength, x, y, width, height);

   207                 if (target == null || !(target instanceof org.eclipse.swt.internal.qt.graphics.Image)) {

   208                     cgImg.dispose();

   209                 }

   210             }

   211         });

   212     }

   213 

   214     public void getPixels(final byte[] pixels, final byte[] transparencyMask,

   215             final int offset, final int scanlength, final int x, final int y,

   216             final int width, final int height, final int format) {

   217         if (format != TYPE_BYTE_1_GRAY) {

   218             throw new IllegalArgumentException(

   219                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

   220         }

   221         if (width < 0 || height < 0) {

   222             throw new IllegalArgumentException(

   223                    MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_WIDTH_HEIGHT);

   224         }

   225         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   226             public void run() {

   227                 org.eclipse.swt.internal.qt.graphics.Image cgImg;

   228                 Object target = graphics.getGc().getBoundTarget();

   229                 if (target != null && target instanceof org.eclipse.swt.internal.qt.graphics.Image) {

   230                     cgImg = (org.eclipse.swt.internal.qt.graphics.Image) target;

   231                 }

   232                 else {

   233                     cgImg = new org.eclipse.swt.internal.qt.graphics.Image(width, height);

   234                     graphics.getGc().copyArea(cgImg, x, y);

   235                 }

   236                 cgImg.getRGB(pixels, transparencyMask, offset, scanlength, x, y, width,

   237                         height, getNativeFormatValue(format));

   238                 if (target == null || !(target instanceof org.eclipse.swt.internal.qt.graphics.Image)) {

   239                     cgImg.dispose();

   240                 }

   241             }

   242         });

   243     }

   244 

   245     public void getPixels(final short[] pixels, final int offset,

   246             final int scanlength, final int x, final int y, final int width,

   247             final int height, final int format) {

   248         if (format != TYPE_USHORT_4444_ARGB

   249             && format != TYPE_USHORT_444_RGB

   250             && format != TYPE_USHORT_565_RGB

   251             && format != TYPE_USHORT_555_RGB) {

   252             throw new IllegalArgumentException(

   253                     MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_FORMAT);

   254         }

   255         if (width < 0 || height < 0) {

   256             throw new IllegalArgumentException(

   257                    MsgRepository.DIRECTGRAPHICS_EXCEPTION_INVALID_WIDTH_HEIGHT);

   258         }

   259         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   260             public void run() {

   261                 org.eclipse.swt.internal.qt.graphics.Image cgImg;

   262                 Object target = graphics.getGc().getBoundTarget();

   263                 if (target != null && target instanceof org.eclipse.swt.internal.qt.graphics.Image) {

   264                     cgImg = (org.eclipse.swt.internal.qt.graphics.Image) target;

   265                 }

   266                 else {

   267                     cgImg = new org.eclipse.swt.internal.qt.graphics.Image(width, height);

   268                     graphics.getGc().copyArea(cgImg, x, y);

   269                 }

   270                 cgImg.getRGB(pixels, offset, scanlength, 0, 0, width, height, getNativeFormatValue(format));

   271                 if (target == null || !(target instanceof org.eclipse.swt.internal.qt.graphics.Image)) {

   272                     cgImg.dispose();

   273                 }

   274             }

   275         });

   276     }

   277 

   278     public void setARGBColor(int argbColor) {

   279         alpha = (argbColor >> 24) & Graphics.COMPONENT_MASK;

   280         graphics.setColor(argbColor);

   281         ESWTUIThreadRunner.safeSyncExec(new Runnable() {

   282             public void run() {

   283                 graphics.getGc().setForegroundAlpha(alpha);

   284                 graphics.getGc().setBackgroundAlpha(alpha);

   285             }

   286         });

   287     }

   288 

   289     public int getAlphaComponent() {

   290         return alpha;

   291     }

   292 

   293     public int getNativePixelFormat() {

   294         // TODO: is this the native pixel format ?

   295         return TYPE_INT_8888_ARGB;

   296     }

   297 

   298     private static int getTransformation(int manipulation) {

   299         // manipulations are C-CW and sprite rotations are CW

   300         int ret = -1;

   301         int rotation = manipulation & MANIPULATION_MASK;

   302         if ((manipulation & FLIP_HORIZONTAL) != 0) {

   303             if ((manipulation & FLIP_VERTICAL) != 0) {

   304                 // horiz and vertical flipping

   305                 switch (rotation) {

   306                     case 0:

   307                         ret = Sprite.TRANS_ROT180;

   308                         break;

   309                     case ROTATE_90:

   310                         ret = Sprite.TRANS_ROT90;

   311                         break;

   312                     case ROTATE_180:

   313                         ret = Sprite.TRANS_NONE;

   314                         break;

   315                     case ROTATE_270:

   316                         ret = Sprite.TRANS_ROT270;

   317                         break;

   318                     default:

   319                 }

   320             }

   321             else {

   322                 // horizontal flipping

   323                 switch (rotation) {

   324                     case 0:

   325                         ret = Sprite.TRANS_MIRROR_ROT180;

   326                         break;

   327                     case ROTATE_90:

   328                         ret = Sprite.TRANS_MIRROR_ROT90;

   329                         break;

   330                     case ROTATE_180:

   331                         ret = Sprite.TRANS_MIRROR;

   332                         break;

   333                     case ROTATE_270:

   334                         ret = Sprite.TRANS_MIRROR_ROT270;

   335                         break;

   336                     default:

   337                 }

   338             }

   339         }

   340         else {

   341             if ((manipulation & FLIP_VERTICAL) != 0) {

   342                 // vertical flipping

   343                 switch (rotation) {

   344                     case 0:

   345                         ret = Sprite.TRANS_MIRROR;

   346                         break;

   347                     case ROTATE_90:

   348                         ret = Sprite.TRANS_MIRROR_ROT270;

   349                         break;

   350                     case ROTATE_180:

   351                         ret = Sprite.TRANS_MIRROR_ROT180;

   352                         break;

   353                     case ROTATE_270:

   354                         ret = Sprite.TRANS_MIRROR_ROT90;

   355                         break;

   356                     default:

   357                 }

   358             }

   359             else {

   360                 // no flipping

   361                 switch (rotation) {

   362                     case 0:

   363                         ret = Sprite.TRANS_NONE;

   364                         break;

   365                     case ROTATE_90:

   366                         ret = Sprite.TRANS_ROT270;

   367                         break;

   368                     case ROTATE_180:

   369                         ret = Sprite.TRANS_ROT180;

   370                         break;

   371                     case ROTATE_270:

   372                         ret = Sprite.TRANS_ROT90;

   373                         break;

   374                     default:

   375                 }

   376             }

   377         }

   378         return ret;

   379     }

   380 

   381     /**

   382      * Get Native transformation value out of given LCDUI manipulation

   383      *

   384      * @param manipulation LCDUI manipulation

   385      *

   386      * @return corresponding native transformation value

   387      */

   388     private static int getNativeTransformValue(int manipulation) {

   389         int returnVal = 0;

   390         switch (manipulation) {

   391             case 0:

   392                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_NONE;

   393                 break;

   394             case DirectGraphics.FLIP_HORIZONTAL:

   395                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_FLIP_HORIZONTAL;

   396                 break;

   397             case DirectGraphics.FLIP_VERTICAL:

   398                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_FLIP_VERTICAL;

   399                 break;

   400             case DirectGraphics.ROTATE_90:

   401                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_ROT90;

   402                 break;

   403             case DirectGraphics.ROTATE_180:

   404                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_ROT180;

   405                 break;

   406             case DirectGraphics.ROTATE_270:

   407                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_ROT270;

   408                 break;

   409             default:

   410                 returnVal =  org.eclipse.swt.internal.qt.graphics.Image.TRANS_NONE;

   411         }

   412         return returnVal;

   413     }

   414 

   415     /**

   416      * Get Native format value out of given LCDUI format

   417      *

   418      * @param format LCDUI format

   419      *

   420      * @return corresponding native format value

   421      */

   422     private static int getNativeFormatValue(int format) {

   423         int returnVal = 0;

   424         switch (format) {

   425             case 0:

   426                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_NONE;

   427                 break;

   428             case DirectGraphics.TYPE_BYTE_1_GRAY:

   429                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_MONO;

   430                 break;

   431             case DirectGraphics.TYPE_INT_8888_ARGB:

   432                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_ARGB32;

   433                 break;

   434             case DirectGraphics.TYPE_INT_888_RGB:

   435                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_RGB32;

   436                 break;

   437             case DirectGraphics.TYPE_USHORT_4444_ARGB:

   438                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_RGB4444PREMULTIPLIED;

   439                 break;

   440             case DirectGraphics.TYPE_USHORT_444_RGB:

   441                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_RGB444;

   442                 break;

   443             case DirectGraphics.TYPE_USHORT_555_RGB:

   444                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_RGB555;

   445                 break;

   446             case DirectGraphics.TYPE_USHORT_565_RGB:

   447                 returnVal = org.eclipse.swt.internal.qt.graphics.Image.FORMAT_IMG_RGB16;

   448                 break;

   449             default:

   450                 break;

   451         }

   452         return returnVal;

   453     }

   454 

   455 }