* core/java/com/sun/lwuit/Image.java (mirror, rotate, fastRotate, extractTranslucentM...
authorguillaum1 <guillaum1@users.evolvis.org>
Sat, 6 Sep 2008 16:38:32 +0000 (16:38 +0000)
committerguillaum1 <guillaum1@users.evolvis.org>
Sat, 6 Sep 2008 16:38:32 +0000 (16:38 +0000)
* core/java/com/sun/lwuit/Graphics.java: Cleaned code

core/java/com/sun/lwuit/Graphics.java
core/java/com/sun/lwuit/Image.java

index c0f1b40..18b1f08 100644 (file)
@@ -441,13 +441,6 @@ public final class Graphics {
         g.drawChar(character, xTranslate + x, yTranslate + y, g.TOP | g.LEFT);\r
     }\r
 \r
-    // void drawNativeChars(javax.microedition.lcdui.Font font, char[] data, int\r
-    // offset, int length, int x, int y) {\r
-    // g.setFont(font);\r
-    // g.drawChars(data, offset, length, xTranslate + x, yTranslate + y, g.TOP |\r
-    // g.LEFT);\r
-    // }\r
-\r
     /**\r
      * Draw the given char using the current font and color in the x,y\r
      * coordinates. The font is drawn from the top position and not the\r
index d2bde3c..40791b5 100644 (file)
@@ -138,57 +138,52 @@ public class Image {
     public Image rotate(int degrees) {\r
 \r
         if (Log.TRACE_ENABLED)\r
-            System.out.println("[DEBUG] Image.rotate(): not implemented yet");\r
-\r
-        return null;\r
+            System.out.println("[DEBUG] Image.rotate()");\r
+\r
+        // a square angle so we can use the "fast" algorithm...\r
+        int transform = 0;\r
+        Image i;\r
+        if (degrees % 90 == 0) {\r
+            transform = fastRotate(degrees);\r
+            i = new Image(image);\r
+        } else {\r
+            // rotate up to the point to a smaller than 90 degree angle then let\r
+            //the radian code do its magic...\r
+            if (degrees > 90) {\r
+                int deg = degrees - degrees % 90;\r
+                transform = fastRotate(deg);\r
+                degrees -= deg;\r
+            }\r
+            // can't use sprite rotation since it will lose transparency\r
+            //information...\r
+            int width = image.getWidth();\r
+            int height = image.getHeight();\r
+            int[] arr = new int[width * height];\r
+            int[] dest = new int[arr.length];\r
+            image.getRGB(arr, 0, width, 0, 0, width, height);\r
+            int centerX = width / 2;\r
+            int centerY = height / 2;\r
+\r
+            double radians = Math.toRadians(-degrees);\r
+            double cosDeg = Math.cos(radians);\r
+            double sinDeg = Math.sin(radians);\r
+            for (int x = 0; x < width; x++) {\r
+                for (int y = 0; y < height; y++) {\r
+                    int x2 = round(cosDeg * (x - centerX) - sinDeg * (y - centerY) + centerX);\r
+                    int y2 = round(sinDeg * (x - centerX) + cosDeg * (y - centerY) + centerY);\r
+                    if (!(x2 < 0 || y2 < 0 || x2 >= width || y2 >= height)) {\r
+                        int destOffset = x2 + y2 * width;\r
+                        if (destOffset >= 0 && destOffset < dest.length) {\r
+                            dest[x + y * width] = arr[destOffset];\r
+                        }\r
+                    }\r
+                }\r
+            }\r
+            i = new Image(new VirtualImage(dest, width, height, true));\r
+        }\r
 \r
-        // // a square angle so we can use the "fast" algorithm...\r
-        // int transform = 0;\r
-        // Image i;\r
-        // if(degrees % 90 == 0) {\r
-        // transform = fastRotate(degrees);\r
-        // i = new Image(image);\r
-        // } else {\r
-        // // rotate up to the point to a smaller than 90 degree angle then let\r
-        // the radian code do its magic...\r
-        // if(degrees > 90) {\r
-        // int deg = degrees - degrees % 90;\r
-        // transform = fastRotate(deg);\r
-        // degrees -= deg;\r
-        // }\r
-        // // can't use sprite rotation since it will lose transparency\r
-        // information...\r
-        // int width = image.getWidth();\r
-        // int height = image.getHeight();\r
-        // int[] arr = new int[width * height];\r
-        // int[] dest = new int[arr.length];\r
-        // image.getRGB(arr, 0, width, 0, 0, width, height);\r
-        // int centerX = width / 2;\r
-        // int centerY = height / 2;\r
-        //\r
-        // double radians = Math.toRadians(-degrees);\r
-        // double cosDeg = Math.cos(radians);\r
-        // double sinDeg = Math.sin(radians);\r
-        // for(int x = 0 ; x < width ; x++) {\r
-        // for(int y = 0 ; y < height ; y++) {\r
-        // int x2 = round(cosDeg * (x - centerX) - sinDeg * (y - centerY) +\r
-        // centerX);\r
-        // int y2 = round(sinDeg * (x - centerX) + cosDeg * (y - centerY) +\r
-        // centerY);\r
-        // if(!(x2 < 0 || y2 < 0 || x2 >= width || y2 >= height)) {\r
-        // int destOffset = x2 + y2 * width;\r
-        // if(destOffset >= 0 && destOffset < dest.length) {\r
-        // dest[x + y * width] = arr[destOffset];\r
-        // }\r
-        // }\r
-        // }\r
-        // }\r
-        // i = new Image(VirtualImage.createRGBImage(dest, width, height,\r
-        // true));\r
-        // }\r
-        //        \r
-        // i.transform = transform;\r
-        // return i;\r
+        i.transform = transform;\r
+        return i;\r
     }\r
 \r
     private int round(double d) {\r
@@ -276,86 +271,82 @@ public class Image {
     public Image mirror() {\r
 \r
         if (Log.TRACE_ENABLED)\r
-            System.out.println("[DEBUG] Image.mirror(): not implemented yet");\r
-        return null;\r
+            System.out.println("[DEBUG] Image.mirror()");\r
+\r
+        Image i = new Image(image);\r
+        if (transform != 0) {\r
+            switch (transform) {\r
+            case VirtualImage.TRANS_MIRROR:\r
+                i.transform = 0;\r
+                break;\r
+            case VirtualImage.TRANS_MIRROR_ROT180:\r
+                i.transform = VirtualImage.TRANS_ROT180;\r
+                break;\r
+            case VirtualImage.TRANS_MIRROR_ROT270:\r
+                i.transform = VirtualImage.TRANS_ROT270;\r
+                break;\r
+            case VirtualImage.TRANS_MIRROR_ROT90:\r
+                i.transform = VirtualImage.TRANS_ROT90;\r
+                break;\r
+            case VirtualImage.TRANS_NONE:\r
+                i.transform = VirtualImage.TRANS_MIRROR;\r
+                break;\r
+            case VirtualImage.TRANS_ROT180:\r
+                i.transform = VirtualImage.TRANS_MIRROR_ROT180;\r
+                break;\r
+            case VirtualImage.TRANS_ROT270:\r
+                i.transform = VirtualImage.TRANS_MIRROR_ROT270;\r
+                break;\r
+            case VirtualImage.TRANS_ROT90:\r
+                i.transform = VirtualImage.TRANS_MIRROR_ROT90;\r
+                break;\r
+            default:\r
+                throw new IllegalStateException("Image could not be mirrored, error code: " + transform);\r
+            }\r
+        } else {\r
+            i.transform = transform;\r
+        }\r
+        return i;\r
+    }\r
+\r
+    /**\r
+     * Rotates the given image array fast assuming this is a "right" angle\r
+     * divides by 90 degrees\r
+     */\r
+    private int fastRotate(int degrees) {\r
+        // if we have a preexisting rotation...\r
+        switch (transform) {\r
+        case VirtualImage.TRANS_ROT90:\r
+            degrees += 90;\r
+            break;\r
+        case VirtualImage.TRANS_ROT180:\r
+            degrees += 180;\r
+            break;\r
+        case VirtualImage.TRANS_ROT270:\r
+            degrees += 270;\r
+            break;\r
+        }\r
+\r
+        switch ((degrees % 360) / 90) {\r
+        case 0:\r
+            return 0;\r
+\r
+            // 90 degree angle\r
+        case 1:\r
+            return VirtualImage.TRANS_ROT90;\r
+\r
+            // 180 degree angle\r
+        case 2:\r
+            return VirtualImage.TRANS_ROT180;\r
 \r
-        // Image i = new Image(image);\r
-        // if(transform != 0) {\r
-        // switch(transform) {\r
-        // case Sprite.TRANS_MIRROR:\r
-        // i.transform = 0;\r
-        // break;\r
-        // case Sprite.TRANS_MIRROR_ROT180:\r
-        // i.transform = Sprite.TRANS_ROT180;\r
-        // break;\r
-        // case Sprite.TRANS_MIRROR_ROT270:\r
-        // i.transform = Sprite.TRANS_ROT270;\r
-        // break;\r
-        // case Sprite.TRANS_MIRROR_ROT90:\r
-        // i.transform = Sprite.TRANS_ROT90;\r
-        // break;\r
-        // case Sprite.TRANS_NONE:\r
-        // i.transform = Sprite.TRANS_MIRROR;\r
-        // break;\r
-        // case Sprite.TRANS_ROT180:\r
-        // i.transform = Sprite.TRANS_MIRROR_ROT180;\r
-        // break;\r
-        // case Sprite.TRANS_ROT270:\r
-        // i.transform = Sprite.TRANS_MIRROR_ROT270;\r
-        // break;\r
-        // case Sprite.TRANS_ROT90:\r
-        // i.transform = Sprite.TRANS_MIRROR_ROT90;\r
-        // break;\r
-        // default:\r
-        // throw new\r
-        // IllegalStateException("Image could not be mirrored, error code: " +\r
-        // transform);\r
-        // }\r
-        // } else {\r
-        // i.transform = transform;\r
-        // }\r
-        // return i;\r
-    }\r
-\r
-    // /**\r
-    // * Rotates the given image array fast assuming this is a "right" angle\r
-    // * divides by 90 degrees\r
-    // */\r
-    // private int fastRotate(int degrees) {\r
-    // // if we have a preexisting rotation...\r
-    // switch(transform) {\r
-    // case javax.microedition.lcdui.game.Sprite.TRANS_ROT90:\r
-    // degrees += 90;\r
-    // break;\r
-    // case javax.microedition.lcdui.game.Sprite.TRANS_ROT180:\r
-    // degrees += 180;\r
-    // break;\r
-    // case javax.microedition.lcdui.game.Sprite.TRANS_ROT270:\r
-    // degrees += 270;\r
-    // break;\r
-    // }\r
-    //        \r
-    // switch((degrees % 360) / 90) {\r
-    // case 0:\r
-    // return 0;\r
-    //            \r
-    // // 90 degree angle\r
-    // case 1:\r
-    // return javax.microedition.lcdui.game.Sprite.TRANS_ROT90;\r
-    //\r
-    // // 180 degree angle\r
-    // case 2:\r
-    // return javax.microedition.lcdui.game.Sprite.TRANS_ROT180;\r
-    //            \r
-    // // 270 degree angle\r
-    // case 3:\r
-    // return javax.microedition.lcdui.game.Sprite.TRANS_ROT270;\r
-    //\r
-    // default:\r
-    // throw new IllegalArgumentException("Fast rotate can't handle degrees = "\r
-    // + degrees);\r
-    // }\r
-    // }\r
+            // 270 degree angle\r
+        case 3:\r
+            return VirtualImage.TRANS_ROT270;\r
+\r
+        default:\r
+            throw new IllegalArgumentException("Fast rotate can't handle degrees = " + degrees);\r
+        }\r
+    }\r
 \r
     /**\r
      * Converts a newly loaded masked image into a translucent image. A masked\r
@@ -373,24 +364,22 @@ public class Image {
     public Image extractTranslucentMask() {\r
 \r
         if (Log.TRACE_ENABLED)\r
-            System.out.println("[DEBUG] Image.extractTranslucentMask(): not implemented yet");\r
+            System.out.println("[DEBUG] Image.extractTranslucentMask()");\r
 \r
-        return null;\r
-\r
-        // int w = image.getWidth();\r
-        // int h = image.getHeight();\r
-        // int[] arr = new int[w * h];\r
-        // image.getRGB(arr, 0, w, 0, 0, w, h);\r
-        // int offset = h * w / 2;\r
-        // for(int iter = 0 ; iter < offset ; iter++) {\r
-        // // extract the red component from the bottom portion of the image\r
-        // int alpha = arr[iter + offset] & 0xff0000;\r
-        //            \r
-        // // shift the alpha 8 bits to the left\r
-        // // apply the alpha to the top portion of the image\r
-        // arr[iter] = (arr[iter] & 0xffffff) | (alpha << 8);\r
-        // }\r
-        // return new Image(VirtualImage.createRGBImage(arr, w, h / 2, true));\r
+        int w = image.getWidth();\r
+        int h = image.getHeight();\r
+        int[] arr = new int[w * h];\r
+        image.getRGB(arr, 0, w, 0, 0, w, h);\r
+        int offset = h * w / 2;\r
+        for (int iter = 0; iter < offset; iter++) {\r
+            // extract the red component from the bottom portion of the image\r
+            int alpha = arr[iter + offset] & 0xff0000;\r
+\r
+            // shift the alpha 8 bits to the left\r
+            // apply the alpha to the top portion of the image\r
+            arr[iter] = (arr[iter] & 0xffffff) | (alpha << 8);\r
+        }\r
+        return new Image(new VirtualImage(arr, w, h / 2, true));\r
     }\r
 \r
     /**\r
@@ -721,14 +710,14 @@ public class Image {
         // if an image is opaque use a mutable image since on the device it\r
         // takes\r
         // far less memory\r
-        // if(opaque) {\r
-        image = new VirtualImage(width, height);\r
-        VirtualGraphics g = image.getGraphics();\r
-        g.drawRGB(destinationArray, 0, width, 0, 0, width, height, false);\r
-        /*\r
-         * } else { image = VirtualImage.createRGBImage(destinationArray, width,\r
-         * height, true); }\r
-         */\r
+        if (opaque) {\r
+            image = new VirtualImage(width, height);\r
+            VirtualGraphics g = image.getGraphics();\r
+            g.drawRGB(destinationArray, 0, width, 0, 0, width, height, false);\r
+        } else {\r
+            image = new VirtualImage(destinationArray, width, height, true);\r
+        }\r
+\r
     }// resize image\r
 \r
     VirtualImage getImage() {\r