Canvas.java revision 2ad19e51463f2f4b5633fa9c155fd9fc75f387a6
19066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 29066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Copyright (C) 2006 The Android Open Source Project 39066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 49066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 59066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * you may not use this file except in compliance with the License. 69066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * You may obtain a copy of the License at 79066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 89066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 99066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * See the License for the specific language governing permissions and 149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * limitations under the License. 159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectpackage android.graphics; 189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1980756e38882720860db52f1fcc21fa1505a02abfTor Norbyeimport android.annotation.ColorInt; 20ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabreseimport android.annotation.IntDef; 21ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabreseimport android.annotation.NonNull; 22ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabreseimport android.annotation.Nullable; 23b3ec733bb830f2d4425825d93f9ed95f284e9145Tor Norbyeimport android.annotation.Size; 24b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenbergerimport android.os.Build; 259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 26bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craikimport dalvik.annotation.optimization.CriticalNative; 275cb74bca88268a8b9025be2cce81e1b4f967d19dJohn Reckimport dalvik.annotation.optimization.FastNative; 285cb74bca88268a8b9025be2cce81e1b4f967d19dJohn Reck 295cb74bca88268a8b9025be2cce81e1b4f967d19dJohn Reckimport libcore.util.NativeAllocationRegistry; 305cb74bca88268a8b9025be2cce81e1b4f967d19dJohn Reck 31ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabreseimport java.lang.annotation.Retention; 32ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabreseimport java.lang.annotation.RetentionPolicy; 33ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese 34091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craikimport javax.microedition.khronos.opengles.GL; 35091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik 369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/** 379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * The Canvas class holds the "draw" calls. To draw something, you need 389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 4 basic components: A Bitmap to hold the pixels, a Canvas to host 399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the draw calls (writing into the bitmap), a drawing primitive (e.g. Rect, 409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Path, text, Bitmap), and a paint (to describe the colors and styles for the 419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * drawing). 4261fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * 4361fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * <div class="special reference"> 4461fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * <h3>Developer Guides</h3> 4561fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * <p>For more information about how to use Canvas, read the 4661fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * <a href="{@docRoot}guide/topics/graphics/2d-graphics.html"> 4761fd1e8d8c3ccf2d6b7d4af1c19e8f0988d5a1ecJoe Fernandez * Canvas and Drawables</a> developer guide.</p></div> 489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 49caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reckpublic class Canvas extends BaseCanvas { 507b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger private static int sCompatiblityVersion = 0; 513891f3ad598561d5a82c07795e1fee7f1d3612d1Chris Craik /** @hide */ 523891f3ad598561d5a82c07795e1fee7f1d3612d1Chris Craik public static boolean sCompatibilityRestore = false; 53d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger /** @hide */ 54d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger public static boolean sCompatibilitySetBitmap = false; 55ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov 56ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov /** @hide */ 575c3d927e17e98e8fd4a9f3c86f7f4def0bcfa816Florin Malita public long getNativeCanvasWrapper() { 585c3d927e17e98e8fd4a9f3c86f7f4def0bcfa816Florin Malita return mNativeCanvasWrapper; 59c677675e9c465dc1de21ecf2e0421835c7eb55b4Florin Malita } 60ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov 61a753f4c6cb8558795e673df1896532cd148781e2Chris Craik /** @hide */ 62a753f4c6cb8558795e673df1896532cd148781e2Chris Craik public boolean isRecordingFor(Object o) { return false; } 63a753f4c6cb8558795e673df1896532cd148781e2Chris Craik 64e0aa84b7dc087e999e20055dcc04cb6a48d5bd62Romain Guy // may be null 65e0aa84b7dc087e999e20055dcc04cb6a48d5bd62Romain Guy private Bitmap mBitmap; 66ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov 679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // optional field set by the caller 68ce0537b80087a6225273040a987414b1dd081aa0Romain Guy private DrawFilter mDrawFilter; 699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 70f61970fc79e9c5cf340fa942597628242361864aRomain Guy // Maximum bitmap size as defined in Skia's native code 71f61970fc79e9c5cf340fa942597628242361864aRomain Guy // (see SkCanvas.cpp, SkDraw.cpp) 72f61970fc79e9c5cf340fa942597628242361864aRomain Guy private static final int MAXMIMUM_BITMAP_SIZE = 32766; 73f61970fc79e9c5cf340fa942597628242361864aRomain Guy 74775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler // The approximate size of the native allocation associated with 75775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler // a Canvas object. 76775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler private static final long NATIVE_ALLOCATION_SIZE = 525; 77e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy 78f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe // Use a Holder to allow static initialization of Canvas in the boot image. 79f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe private static class NoImagePreloadHolder { 80f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry( 81caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck Canvas.class.getClassLoader(), nGetNativeFinalizer(), NATIVE_ALLOCATION_SIZE); 82f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe } 83ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov 84775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler // This field is used to finalize the native Canvas properly 85775873a66a946fae2b0535abb51df9817bd1b20cRichard Uhler private Runnable mFinalizer; 86e4ac2d6b5723c95e648c489b187ddde449452c13Patrick Dubroy 87f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt /** 889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Construct an empty raster canvas. Use setBitmap() to specify a bitmap to 8996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * draw into. The initial target density is {@link Bitmap#DENSITY_NONE}; 9096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * this will typically be replaced when a target bitmap is set for the 9196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * canvas. 929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public Canvas() { 94003123004f7b23b3dc472d5c40b8c1a16df37a54Romain Guy if (!isHardwareAccelerated()) { 95003123004f7b23b3dc472d5c40b8c1a16df37a54Romain Guy // 0 means no native bitmap 96caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mNativeCanvasWrapper = nInitRaster(null); 97f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation( 98f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe this, mNativeCanvasWrapper); 99003123004f7b23b3dc472d5c40b8c1a16df37a54Romain Guy } else { 100003123004f7b23b3dc472d5c40b8c1a16df37a54Romain Guy mFinalizer = null; 101003123004f7b23b3dc472d5c40b8c1a16df37a54Romain Guy } 1029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Construct a canvas with the specified bitmap to draw into. The bitmap 1069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * must be mutable. 107051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 10896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * <p>The initial target density of the canvas is the same as the given 10996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * bitmap's density. 1109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap Specifies a mutable bitmap for the canvas to draw into. 1129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 113ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public Canvas(@NonNull Bitmap bitmap) { 1149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (!bitmap.isMutable()) { 115f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy throw new IllegalStateException("Immutable bitmap passed to Canvas constructor"); 1169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1171abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik throwIfCannotDraw(bitmap); 118caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mNativeCanvasWrapper = nInitRaster(bitmap); 119f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation( 120f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe this, mNativeCanvasWrapper); 1219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mBitmap = bitmap; 12296e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn mDensity = bitmap.mDensity; 1239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 124ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov 125ff4adde5737be08d3e2d03fbe588c591d27d4a74Svetoslav Ganov /** @hide */ 12636bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat public Canvas(long nativeCanvas) { 1279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (nativeCanvas == 0) { 1289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project throw new IllegalStateException(); 1299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1308872b38ef403cc2c44aca07d392f5e9426fd7f54Derek Sollenberger mNativeCanvasWrapper = nativeCanvas; 131f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation( 132f6765f3965ce669458e0bb5d2e226d4233a1acb3Andreas Gampe this, mNativeCanvasWrapper); 13396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn mDensity = Bitmap.getDefaultDensity(); 1349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 135163935113919a184122b8b3bd672ef08c8df65dcRomain Guy 1369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 137091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik * Returns null. 138c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik * 139091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik * @deprecated This method is not supported and should not be invoked. 140c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik * 141091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik * @hide 142091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik */ 143091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik @Deprecated 144091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik protected GL getGL() { 145091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik return null; 146091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik } 147091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik 148091ddb1374e3bcdac129c1df5ef2555cf5c2183eChris Craik /** 1492d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy * Indicates whether this Canvas uses hardware acceleration. 150051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 1512d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy * Note that this method does not define what type of hardware acceleration 1522d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy * may or may not be used. 153051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 1542d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy * @return True if drawing operations are hardware accelerated, 1552d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy * false otherwise. 1562d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy */ 1572d6145993e19d2bb664766dbaf3c1e9ad3d12cdcRomain Guy public boolean isHardwareAccelerated() { 158163935113919a184122b8b3bd672ef08c8df65dcRomain Guy return false; 159caf0df1b7f99736aed1a0b923ef278fc4fd0fccaMike Reed } 160163935113919a184122b8b3bd672ef08c8df65dcRomain Guy 1619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 162051910b9f998030dacb8a0722588cc715813fde1Raph Levien * Specify a bitmap for the canvas to draw into. All canvas state such as 163eb69cbbe22d993a9ba88a1206853c660f8f43628Derek Sollenberger * layers, filters, and the save/restore stack are reset. Additionally, 1643bd9a6dc6b30ed0ce40ca9087ca0f4b1ca789100Derek Sollenberger * the canvas' target density is updated to match that of the bitmap. 1659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 166eb69cbbe22d993a9ba88a1206853c660f8f43628Derek Sollenberger * Prior to API level {@value Build.VERSION_CODES#O} the current matrix and 167eb69cbbe22d993a9ba88a1206853c660f8f43628Derek Sollenberger * clip stack were preserved. 168eb69cbbe22d993a9ba88a1206853c660f8f43628Derek Sollenberger * 1699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap Specifies a mutable bitmap for the canvas to draw into. 17096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * @see #setDensity(int) 17196e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * @see #getDensity() 1729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 173ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void setBitmap(@Nullable Bitmap bitmap) { 174163935113919a184122b8b3bd672ef08c8df65dcRomain Guy if (isHardwareAccelerated()) { 17596890564bdbd2f2a41dfc323fc8b3938fb335639Chris Craik throw new RuntimeException("Can't set a bitmap device on a HW accelerated canvas"); 1769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 178d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger Matrix preservedMatrix = null; 179d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger if (bitmap != null && sCompatibilitySetBitmap) { 180d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger preservedMatrix = getMatrix(); 181d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger } 182d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger 183fc615a0f643408956fc0dc1b997871e2b27cee7eDerek Sollenberger if (bitmap == null) { 184caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSetBitmap(mNativeCanvasWrapper, null); 185fc615a0f643408956fc0dc1b997871e2b27cee7eDerek Sollenberger mDensity = Bitmap.DENSITY_NONE; 186fc615a0f643408956fc0dc1b997871e2b27cee7eDerek Sollenberger } else { 1870965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy if (!bitmap.isMutable()) { 1880965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy throw new IllegalStateException(); 1890965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy } 1901abf5d62429e5a9329520b2f7c2b5a5e7a8e72ecChris Craik throwIfCannotDraw(bitmap); 191fc615a0f643408956fc0dc1b997871e2b27cee7eDerek Sollenberger 192caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSetBitmap(mNativeCanvasWrapper, bitmap); 1930965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy mDensity = bitmap.mDensity; 1940965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy } 1950965a3244b4c3009d08db2e084cdcb681ef66d26Romain Guy 196d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger if (preservedMatrix != null) { 197d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger setMatrix(preservedMatrix); 198d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger } 199d70695ee34611bee420d901ac9e6470d8c211519Derek Sollenberger 2009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mBitmap = bitmap; 2019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 202c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 203cce47eb580d666ead1f6095d1e3b65233592bbaaChris Craik /** @hide */ 2048afd0f245cc0c4a0366f39f41b5f78e47ee83be3Chris Craik public void insertReorderBarrier() {} 2058afd0f245cc0c4a0366f39f41b5f78e47ee83be3Chris Craik 2068afd0f245cc0c4a0366f39f41b5f78e47ee83be3Chris Craik /** @hide */ 2078afd0f245cc0c4a0366f39f41b5f78e47ee83be3Chris Craik public void insertInorderBarrier() {} 2088afd0f245cc0c4a0366f39f41b5f78e47ee83be3Chris Craik 209797b95b26bbb7557678af78b9a2a61830158920fChris Craik /** 2109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the device that the current layer draws into is opaque 2119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * (i.e. does not support per-pixel alpha). 2129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 2139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the device that the current layer draws into is opaque 2149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 21595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public boolean isOpaque() { 216caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nIsOpaque(mNativeCanvasWrapper); 21795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 2189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 2209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the width of the current drawing layer 2219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 2229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return the width of the current drawing layer 2239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 22495d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public int getWidth() { 225caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nGetWidth(mNativeCanvasWrapper); 22695d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 2279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 2299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the height of the current drawing layer 2309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 2319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return the height of the current drawing layer 2329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 23395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public int getHeight() { 234caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nGetHeight(mNativeCanvasWrapper); 23595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 2369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 23896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * <p>Returns the target density of the canvas. The default density is 23996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * derived from the density of its backing bitmap, or 24096e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * {@link Bitmap#DENSITY_NONE} if there is not one.</p> 2419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 24296e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * @return Returns the current target density of the canvas, which is used 24396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * to determine the scaling factor when drawing a bitmap into it. 2449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 24511ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn * @see #setDensity(int) 246051910b9f998030dacb8a0722588cc715813fde1Raph Levien * @see Bitmap#getDensity() 2479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 24811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn public int getDensity() { 24911ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn return mDensity; 2509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 2519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 25396e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * <p>Specifies the density for this Canvas' backing bitmap. This modifies 25496e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * the target density of the canvas itself, as well as the density of its 25596e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * backing bitmap via {@link Bitmap#setDensity(int) Bitmap.setDensity(int)}. 2569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 25796e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * @param density The new target density of the canvas, which is used 25896e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * to determine the scaling factor when drawing a bitmap into it. Use 25996e240f25a97c10bba863df328ed73a82c34ff61Dianne Hackborn * {@link Bitmap#DENSITY_NONE} to disable bitmap scaling. 2609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 26111ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn * @see #getDensity() 262051910b9f998030dacb8a0722588cc715813fde1Raph Levien * @see Bitmap#setDensity(int) 2639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 26411ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn public void setDensity(int density) { 2659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (mBitmap != null) { 26611ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn mBitmap.setDensity(density); 2679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 26811ea33471e1a14a8594f0b2cd012d86340dd3bd8Dianne Hackborn mDensity = density; 2699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 2709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 2710d221012ff5fd314711c00ed30e9b807b9c454c1Dianne Hackborn /** @hide */ 2720d221012ff5fd314711c00ed30e9b807b9c454c1Dianne Hackborn public void setScreenDensity(int density) { 2730d221012ff5fd314711c00ed30e9b807b9c454c1Dianne Hackborn mScreenDensity = density; 2740d221012ff5fd314711c00ed30e9b807b9c454c1Dianne Hackborn } 275f61970fc79e9c5cf340fa942597628242361864aRomain Guy 276f61970fc79e9c5cf340fa942597628242361864aRomain Guy /** 277f61970fc79e9c5cf340fa942597628242361864aRomain Guy * Returns the maximum allowed width for bitmaps drawn with this canvas. 278f61970fc79e9c5cf340fa942597628242361864aRomain Guy * Attempting to draw with a bitmap wider than this value will result 279f61970fc79e9c5cf340fa942597628242361864aRomain Guy * in an error. 280051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 281051910b9f998030dacb8a0722588cc715813fde1Raph Levien * @see #getMaximumBitmapHeight() 282f61970fc79e9c5cf340fa942597628242361864aRomain Guy */ 283f61970fc79e9c5cf340fa942597628242361864aRomain Guy public int getMaximumBitmapWidth() { 284f61970fc79e9c5cf340fa942597628242361864aRomain Guy return MAXMIMUM_BITMAP_SIZE; 285f61970fc79e9c5cf340fa942597628242361864aRomain Guy } 286051910b9f998030dacb8a0722588cc715813fde1Raph Levien 287f61970fc79e9c5cf340fa942597628242361864aRomain Guy /** 288f61970fc79e9c5cf340fa942597628242361864aRomain Guy * Returns the maximum allowed height for bitmaps drawn with this canvas. 289f61970fc79e9c5cf340fa942597628242361864aRomain Guy * Attempting to draw with a bitmap taller than this value will result 290f61970fc79e9c5cf340fa942597628242361864aRomain Guy * in an error. 291051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 292051910b9f998030dacb8a0722588cc715813fde1Raph Levien * @see #getMaximumBitmapWidth() 293f61970fc79e9c5cf340fa942597628242361864aRomain Guy */ 294f61970fc79e9c5cf340fa942597628242361864aRomain Guy public int getMaximumBitmapHeight() { 295f61970fc79e9c5cf340fa942597628242361864aRomain Guy return MAXMIMUM_BITMAP_SIZE; 296f61970fc79e9c5cf340fa942597628242361864aRomain Guy } 297f61970fc79e9c5cf340fa942597628242361864aRomain Guy 2989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project // the SAVE_FLAG constants must match their native equivalents 2999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 300ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese /** @hide */ 301ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @IntDef(flag = true, 302ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese value = { 303ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese ALL_SAVE_FLAG 304ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese }) 305ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Retention(RetentionPolicy.SOURCE) 306ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public @interface Saveflags {} 307ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese 308f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 309f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Restore the current matrix when restore() is called. 3107b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 311b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use the flagless version of {@link #save()}, {@link #saveLayer(RectF, Paint)} or 312b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link #saveLayerAlpha(RectF, int)}. For saveLayer() calls the matrix 313b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * was always restored for {@link #isHardwareAccelerated() Hardware accelerated} 314b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * canvases and as of API level {@value Build.VERSION_CODES#O} that is the default 315b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * behavior for all canvas types. 316f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 3179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static final int MATRIX_SAVE_FLAG = 0x01; 318f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik 319f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 320f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Restore the current clip when restore() is called. 321b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 3227b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 323b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use the flagless version of {@link #save()}, {@link #saveLayer(RectF, Paint)} or 324b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link #saveLayerAlpha(RectF, int)}. For saveLayer() calls the clip 325b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * was always restored for {@link #isHardwareAccelerated() Hardware accelerated} 326b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * canvases and as of API level {@value Build.VERSION_CODES#O} that is the default 327b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * behavior for all canvas types. 328f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 3299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static final int CLIP_SAVE_FLAG = 0x02; 330f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik 331f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 332f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * The layer requires a per-pixel alpha channel. 333b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 3347b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 335b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated This flag is ignored. Use the flagless version of {@link #saveLayer(RectF, Paint)} 336b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link #saveLayerAlpha(RectF, int)}. 337f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 3389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static final int HAS_ALPHA_LAYER_SAVE_FLAG = 0x04; 339f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik 340f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 341f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * The layer requires full 8-bit precision for each color channel. 342b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 3437b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 344b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated This flag is ignored. Use the flagless version of {@link #saveLayer(RectF, Paint)} 345b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link #saveLayerAlpha(RectF, int)}. 346f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 3479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static final int FULL_COLOR_LAYER_SAVE_FLAG = 0x08; 348f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik 349f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 350f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Clip drawing to the bounds of the offscreen layer, omit at your own peril. 351f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p class="note"><strong>Note:</strong> it is strongly recommended to not 352f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * omit this flag for any call to <code>saveLayer()</code> and 353f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <code>saveLayerAlpha()</code> variants. Not passing this flag generally 354f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * triggers extremely poor performance with hardware accelerated rendering. 355b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 3567b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 357b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated This flag results in poor performance and the same effect can be achieved with 358b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * a single layer or multiple draw commands with different clips. 359b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 360f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 3619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public static final int CLIP_TO_LAYER_SAVE_FLAG = 0x10; 362f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik 363f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik /** 364f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Restore everything when restore() is called (standard save flags). 365f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p class="note"><strong>Note:</strong> for performance reasons, it is 366f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * strongly recommended to pass this - the complete set of flags - to any 367f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * call to <code>saveLayer()</code> and <code>saveLayerAlpha()</code> 368f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * variants. 369b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 370b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * <p class="note"><strong>Note:</strong> all methods that accept this flag 371b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * have flagless versions that are equivalent to passing this flag. 372f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik */ 373051910b9f998030dacb8a0722588cc715813fde1Raph Levien public static final int ALL_SAVE_FLAG = 0x1F; 374051910b9f998030dacb8a0722588cc715813fde1Raph Levien 3752d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger private static void checkValidSaveFlags(int saveFlags) { 3762d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger if (sCompatiblityVersion >= Build.VERSION_CODES.P 3772d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger && saveFlags != ALL_SAVE_FLAG) { 3782d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger throw new IllegalArgumentException( 3792d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger "Invalid Layer Save Flag - only ALL_SAVE_FLAGS is allowed"); 3802d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger } 3812d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger } 3822d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger 3839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 384f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Saves the current matrix and clip onto a private stack. 385f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 386f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Subsequent calls to translate,scale,rotate,skew,concat or clipRect, 387f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * clipPath will all operate as usual, but when the balancing call to 388f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * restore() is made, those calls will be forgotten, and the settings that 389f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * existed before the save() will be reinstated. 3909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 3919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return The value to pass to restoreToCount() to balance this save() 3929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 39395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public int save() { 394caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nSave(mNativeCanvasWrapper, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG); 39595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 396051910b9f998030dacb8a0722588cc715813fde1Raph Levien 3979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 3989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Based on saveFlags, can save the current matrix and clip onto a private 399f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * stack. 400f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p class="note"><strong>Note:</strong> if possible, use the 401f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * parameter-less save(). It is simpler and faster than individually 402f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * disabling the saving of matrix or clip with this method. 403f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 404f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Subsequent calls to translate,scale,rotate,skew,concat or clipRect, 405f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * clipPath will all operate as usual, but when the balancing call to 406f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * restore() is made, those calls will be forgotten, and the settings that 407f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * existed before the save() will be reinstated. 4089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 4097b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * @removed 410b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use {@link #save()} instead. 4119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param saveFlags flag bits that specify which parts of the Canvas state 4129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * to save/restore 4139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return The value to pass to restoreToCount() to balance this save() 4149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 415ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public int save(@Saveflags int saveFlags) { 416caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nSave(mNativeCanvasWrapper, saveFlags); 41795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 4189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 4199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 420f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * This behaves the same as save(), but in addition it allocates and 421f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * redirects drawing to an offscreen bitmap. 422f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p class="note"><strong>Note:</strong> this method is very expensive, 423f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * incurring more than double rendering cost for contained content. Avoid 4242d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * using this method, especially if the bounds provided are large. It is 4252d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * recommended to use a {@link android.view.View#LAYER_TYPE_HARDWARE hardware layer} on a View 426f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * to apply an xfermode, color filter, or alpha, as it will perform much 427f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * better than this method. 428f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 429f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * All drawing calls are directed to a newly allocated offscreen bitmap. 430f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Only when the balancing call to restore() is made, is that offscreen 431f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * buffer drawn back to the current target of the Canvas (either the 432f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * screen, it's target Bitmap, or the previous layer). 433f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 434f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Attributes of the Paint - {@link Paint#getAlpha() alpha}, 435f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * {@link Paint#getXfermode() Xfermode}, and 436f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * {@link Paint#getColorFilter() ColorFilter} are applied when the 437f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * offscreen bitmap is drawn back when restore() is called. 4389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 4392d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} the only valid 4402d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * {@code saveFlags} is {@link #ALL_SAVE_FLAG}. All other flags are ignored. 4412d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * 442b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use {@link #saveLayer(RectF, Paint)} instead. 4439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bounds May be null. The maximum size the offscreen bitmap 4449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * needs to be (in local coordinates) 4459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param paint This is copied, and is applied to the offscreen when 4469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * restore() is called. 447f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * @param saveFlags see _SAVE_FLAG constants, generally {@link #ALL_SAVE_FLAG} is recommended 448f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * for performance reasons. 4499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return value to pass to restoreToCount() to balance this save() 4509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 451ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public int saveLayer(@Nullable RectF bounds, @Nullable Paint paint, @Saveflags int saveFlags) { 4529bc13a353fa8fac323839268789ef661b219530cChris Craik if (bounds == null) { 4539bc13a353fa8fac323839268789ef661b219530cChris Craik bounds = new RectF(getClipBounds()); 4549bc13a353fa8fac323839268789ef661b219530cChris Craik } 4552d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger checkValidSaveFlags(saveFlags); 4562d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger return saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, 4572d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger ALL_SAVE_FLAG); 4589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 459c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 460c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik /** 461b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * This behaves the same as save(), but in addition it allocates and 462b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * redirects drawing to an offscreen rendering target. 463b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * <p class="note"><strong>Note:</strong> this method is very expensive, 464b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * incurring more than double rendering cost for contained content. Avoid 465b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * using this method when possible and instead use a 466b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link android.view.View#LAYER_TYPE_HARDWARE hardware layer} on a View 467b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * to apply an xfermode, color filter, or alpha, as it will perform much 468b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * better than this method. 469b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * <p> 470b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * All drawing calls are directed to a newly allocated offscreen rendering target. 471b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * Only when the balancing call to restore() is made, is that offscreen 472b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * buffer drawn back to the current target of the Canvas (which can potentially be a previous 473b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * layer if these calls are nested). 474b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * <p> 475b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * Attributes of the Paint - {@link Paint#getAlpha() alpha}, 476b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link Paint#getXfermode() Xfermode}, and 477b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * {@link Paint#getColorFilter() ColorFilter} are applied when the 478b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * offscreen rendering target is drawn back when restore() is called. 479b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 480b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @param bounds May be null. The maximum size the offscreen render target 481b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * needs to be (in local coordinates) 482b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @param paint This is copied, and is applied to the offscreen when 483b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * restore() is called. 484b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @return value to pass to restoreToCount() to balance this save() 485c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik */ 486ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public int saveLayer(@Nullable RectF bounds, @Nullable Paint paint) { 487c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik return saveLayer(bounds, paint, ALL_SAVE_FLAG); 488c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik } 489c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 4909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 4912d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * @hide 4922d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger */ 4932d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger public int saveUnclippedLayer(int left, int top, int right, int bottom) { 4942d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger return nSaveLayer(mNativeCanvasWrapper, left, top, right, bottom, 0, 0); 4952d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger } 4962d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger 4972d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger /** 4989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Helper version of saveLayer() that takes 4 values rather than a RectF. 499b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 5002d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} the only valid 5012d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * {@code saveFlags} is {@link #ALL_SAVE_FLAG}. All other flags are ignored. 5022d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * 503b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use {@link #saveLayer(float, float, float, float, Paint)} instead. 5049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 505ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public int saveLayer(float left, float top, float right, float bottom, @Nullable Paint paint, 506ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Saveflags int saveFlags) { 5072d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger checkValidSaveFlags(saveFlags); 508caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nSaveLayer(mNativeCanvasWrapper, left, top, right, bottom, 509dfba4d3d11bbf47dff45f94d61d4d97510b3034aDerek Sollenberger paint != null ? paint.getNativeInstance() : 0, 5102d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger ALL_SAVE_FLAG); 5119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 514b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * Convenience for {@link #saveLayer(RectF, Paint)} that takes the four float coordinates of the 515b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * bounds rectangle. 516c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik */ 517ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public int saveLayer(float left, float top, float right, float bottom, @Nullable Paint paint) { 518c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik return saveLayer(left, top, right, bottom, paint, ALL_SAVE_FLAG); 519c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik } 520c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 521c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik /** 522f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * This behaves the same as save(), but in addition it allocates and 523f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * redirects drawing to an offscreen bitmap. 524f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p class="note"><strong>Note:</strong> this method is very expensive, 525f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * incurring more than double rendering cost for contained content. Avoid 5262d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * using this method, especially if the bounds provided are large. It is 5272d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * recommended to use a {@link android.view.View#LAYER_TYPE_HARDWARE hardware layer} on a View 528f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * to apply an xfermode, color filter, or alpha, as it will perform much 529f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * better than this method. 530f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 531f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * All drawing calls are directed to a newly allocated offscreen bitmap. 532f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * Only when the balancing call to restore() is made, is that offscreen 533f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * buffer drawn back to the current target of the Canvas (either the 534f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * screen, it's target Bitmap, or the previous layer). 535f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * <p> 536f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * The {@code alpha} parameter is applied when the offscreen bitmap is 537f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * drawn back when restore() is called. 5389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 5392d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} the only valid 5402d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * {@code saveFlags} is {@link #ALL_SAVE_FLAG}. All other flags are ignored. 5412d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * 542b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use {@link #saveLayerAlpha(RectF, int)} instead. 5439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bounds The maximum size the offscreen bitmap needs to be 5449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * (in local coordinates) 5450d3d1f825f399c62f2ba236b53bef17581e03a16Sungsoo Lim * @param alpha The alpha to apply to the offscreen when it is 5469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project drawn during restore() 547f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * @param saveFlags see _SAVE_FLAG constants, generally {@link #ALL_SAVE_FLAG} is recommended 548f37a364a530c5c055cf4634f0b0463454a252b0fChris Craik * for performance reasons. 5499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return value to pass to restoreToCount() to balance this call 5509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 5519bc13a353fa8fac323839268789ef661b219530cChris Craik public int saveLayerAlpha(@Nullable RectF bounds, int alpha, @Saveflags int saveFlags) { 5529bc13a353fa8fac323839268789ef661b219530cChris Craik if (bounds == null) { 5539bc13a353fa8fac323839268789ef661b219530cChris Craik bounds = new RectF(getClipBounds()); 5549bc13a353fa8fac323839268789ef661b219530cChris Craik } 5552d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger checkValidSaveFlags(saveFlags); 5562d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger return saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom, alpha, 5572d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger ALL_SAVE_FLAG); 5589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 559c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 560c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik /** 561b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * Convenience for {@link #saveLayer(RectF, Paint)} but instead of taking a entire Paint object 562b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * it takes only the {@code alpha} parameter. 563b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 564b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @param bounds The maximum size the offscreen bitmap needs to be 565b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * (in local coordinates) 566b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @param alpha The alpha to apply to the offscreen when it is 567b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger drawn during restore() 568c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik */ 5699bc13a353fa8fac323839268789ef661b219530cChris Craik public int saveLayerAlpha(@Nullable RectF bounds, int alpha) { 570c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik return saveLayerAlpha(bounds, alpha, ALL_SAVE_FLAG); 571c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik } 572c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 5739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 5749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Helper for saveLayerAlpha() that takes 4 values instead of a RectF. 575b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * 5762d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} the only valid 5772d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * {@code saveFlags} is {@link #ALL_SAVE_FLAG}. All other flags are ignored. 5782d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger * 579b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * @deprecated Use {@link #saveLayerAlpha(float, float, float, float, int)} instead. 5809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 581f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy public int saveLayerAlpha(float left, float top, float right, float bottom, int alpha, 582ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Saveflags int saveFlags) { 5832d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger checkValidSaveFlags(saveFlags); 5849bc13a353fa8fac323839268789ef661b219530cChris Craik alpha = Math.min(255, Math.max(0, alpha)); 585caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nSaveLayerAlpha(mNativeCanvasWrapper, left, top, right, bottom, 5862d4f01ba7f544f1bd772239a0f19946b01ed98d9Derek Sollenberger alpha, ALL_SAVE_FLAG); 5879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 5889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 5899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 590b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * Convenience for {@link #saveLayerAlpha(RectF, int)} that takes the four float coordinates of 591b8201195dfb2bae05faaf91b9b3d065e2f199929Derek Sollenberger * the bounds rectangle. 592c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik */ 593c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik public int saveLayerAlpha(float left, float top, float right, float bottom, int alpha) { 594c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik return saveLayerAlpha(left, top, right, bottom, alpha, ALL_SAVE_FLAG); 595c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik } 596c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik 597c306ad61a791bae34ed83b339f27cb67a1d91b53Chris Craik /** 5989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * This call balances a previous call to save(), and is used to remove all 5999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * modifications to the matrix/clip state since the last save call. It is 6009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * an error to call restore() more times than save() was called. 6019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 60295d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void restore() { 603bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik if (!nRestore(mNativeCanvasWrapper) 604bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik && (!sCompatibilityRestore || !isHardwareAccelerated())) { 605bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik throw new IllegalStateException("Underflow in restore - more restores than saves"); 606bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik } 60795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Returns the number of matrix/clip states on the Canvas' private stack. 6119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * This will equal # save() calls - # restore() calls. 6129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 61395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public int getSaveCount() { 614caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nGetSaveCount(mNativeCanvasWrapper); 61595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Efficient way to pop any calls to save() that happened after the save 6199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * count reached saveCount. It is an error for saveCount to be less than 1. 6209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Example: 6229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * int count = canvas.save(); 6239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * ... // more calls potentially to save() 6249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * canvas.restoreToCount(count); 6259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * // now the canvas is back in the same state it was before the initial 6269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * // call to save(). 6279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param saveCount The save level to restore to. 6299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 63095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void restoreToCount(int saveCount) { 631bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik if (saveCount < 1) { 632bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik if (!sCompatibilityRestore || !isHardwareAccelerated()) { 633bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // do nothing and throw without restoring 634bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik throw new IllegalArgumentException( 635bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik "Underflow in restoreToCount - more restores than saves"); 636bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik } 637bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // compat behavior - restore as far as possible 638bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik saveCount = 1; 639bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik } 640bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik nRestoreToCount(mNativeCanvasWrapper, saveCount); 64195d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified translation 6459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param dx The distance to translate in X 6479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param dy The distance to translate in Y 6489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 64995d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void translate(float dx, float dy) { 65041f864ec45c4fc5c490936fd145c4b087c076646John Reck if (dx == 0.0f && dy == 0.0f) return; 651caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nTranslate(mNativeCanvasWrapper, dx, dy); 65295d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified scale. 6569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sx The amount to scale in X 6589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sy The amount to scale in Y 6599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 66095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void scale(float sx, float sy) { 66141f864ec45c4fc5c490936fd145c4b087c076646John Reck if (sx == 1.0f && sy == 1.0f) return; 662caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nScale(mNativeCanvasWrapper, sx, sy); 66395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified scale. 6679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sx The amount to scale in X 6699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sy The amount to scale in Y 670cc3ec6cdb2b892eb29513e72d8b205acbe997b25Gilles Debunne * @param px The x-coord for the pivot point (unchanged by the scale) 671cc3ec6cdb2b892eb29513e72d8b205acbe997b25Gilles Debunne * @param py The y-coord for the pivot point (unchanged by the scale) 6729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void scale(float sx, float sy, float px, float py) { 67441f864ec45c4fc5c490936fd145c4b087c076646John Reck if (sx == 1.0f && sy == 1.0f) return; 6759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project translate(px, py); 6769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project scale(sx, sy); 6779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project translate(-px, -py); 6789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 6799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified rotation. 6829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param degrees The amount to rotate, in degrees 6849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 68595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void rotate(float degrees) { 68641f864ec45c4fc5c490936fd145c4b087c076646John Reck if (degrees == 0.0f) return; 687caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nRotate(mNativeCanvasWrapper, degrees); 68895d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 6899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 6909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 6919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified rotation. 6929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 6939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param degrees The amount to rotate, in degrees 6949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param px The x-coord for the pivot point (unchanged by the rotation) 6959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param py The y-coord for the pivot point (unchanged by the rotation) 6969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 6979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public final void rotate(float degrees, float px, float py) { 69841f864ec45c4fc5c490936fd145c4b087c076646John Reck if (degrees == 0.0f) return; 6999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project translate(px, py); 7009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project rotate(degrees); 7019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project translate(-px, -py); 7029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 7039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Preconcat the current matrix with the specified skew. 7069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 7079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sx The amount to skew in X 7089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param sy The amount to skew in Y 7099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 71095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public void skew(float sx, float sy) { 71141f864ec45c4fc5c490936fd145c4b087c076646John Reck if (sx == 0.0f && sy == 0.0f) return; 712caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSkew(mNativeCanvasWrapper, sx, sy); 71395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 7149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 7159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7164e7b772b733593fbe25c733e95b8dcea293234b6Romain Guy * Preconcat the current matrix with the specified matrix. If the specified 7174e7b772b733593fbe25c733e95b8dcea293234b6Romain Guy * matrix is null, this method does nothing. 7189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 7199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param matrix The matrix to preconcatenate with the current matrix 7209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 721ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void concat(@Nullable Matrix matrix) { 722caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (matrix != null) nConcat(mNativeCanvasWrapper, matrix.native_instance); 7239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 724051910b9f998030dacb8a0722588cc715813fde1Raph Levien 7259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Completely replace the current matrix with the specified matrix. If the 7279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * matrix parameter is null, then the current matrix is reset to identity. 728051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 729f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy * <strong>Note:</strong> it is recommended to use {@link #concat(Matrix)}, 730f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy * {@link #scale(float, float)}, {@link #translate(float, float)} and 731f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy * {@link #rotate(float)} instead of this method. 7329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 7339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param matrix The matrix to replace the current matrix with. If it is 7349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * null, set the current matrix to identity. 735051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 736051910b9f998030dacb8a0722588cc715813fde1Raph Levien * @see #concat(Matrix) 7379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 738ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void setMatrix(@Nullable Matrix matrix) { 739caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSetMatrix(mNativeCanvasWrapper, 7409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project matrix == null ? 0 : matrix.native_instance); 7419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 742051910b9f998030dacb8a0722588cc715813fde1Raph Levien 7439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return, in ctm, the current transformation matrix. This does not alter 7459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the matrix in the canvas, but just returns a copy of it. 746eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 747eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * @deprecated {@link #isHardwareAccelerated() Hardware accelerated} canvases may have any 748eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * matrix when passed to a View or Drawable, as it is implementation defined where in the 749eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * hierarchy such canvases are created. It is recommended in such cases to either draw contents 750eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * irrespective of the current matrix, or to track relevant transform state outside of the 751eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * canvas. 7529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 753f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy @Deprecated 754ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void getMatrix(@NonNull Matrix ctm) { 755bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik nGetMatrix(mNativeCanvasWrapper, ctm.native_instance); 7569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 75741030da16856c8869e1e51d4a0405432fa96614eRomain Guy 75841030da16856c8869e1e51d4a0405432fa96614eRomain Guy /** 7599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return a new matrix with a copy of the canvas' current transformation 7609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * matrix. 761eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 762eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * @deprecated {@link #isHardwareAccelerated() Hardware accelerated} canvases may have any 763eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * matrix when passed to a View or Drawable, as it is implementation defined where in the 764eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * hierarchy such canvases are created. It is recommended in such cases to either draw contents 765eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * irrespective of the current matrix, or to track relevant transform state outside of the 766eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * canvas. 7679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 76865447287cb4112cf74483c87be70bcd00b622e2dRomain Guy @Deprecated 769ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public final @NonNull Matrix getMatrix() { 7709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Matrix m = new Matrix(); 771f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy //noinspection deprecation 7729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project getMatrix(m); 7739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return m; 7749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 775051910b9f998030dacb8a0722588cc715813fde1Raph Levien 7767b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger private static void checkValidClipOp(@NonNull Region.Op op) { 7777b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger if (sCompatiblityVersion >= Build.VERSION_CODES.P 7787b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger && op != Region.Op.INTERSECT && op != Region.Op.DIFFERENCE) { 7797b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger throw new IllegalArgumentException( 7807b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger "Invalid Region.Op - only INTERSECT and DIFFERENCE are allowed"); 7817b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger } 7827b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger } 7837b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger 7849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 7859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified rectangle. 7869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 7879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rect to intersect with the current clip 7889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 7899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 7908c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 7918c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 7928c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 7938c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 7948c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 7958c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipRect(RectF)} and {@link #clipOutRect(RectF)}; 7967b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 7977b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 7987b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 7999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 8008c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 801ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull RectF rect, @NonNull Region.Op op) { 8027b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 803caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 804f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy op.nativeInt); 8059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified rectangle, which is 8099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rectangle to intersect with the current clip. 8129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 8139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8148c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8158c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 8168c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 8178c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 8188c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 8198c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipRect(Rect)} and {@link #clipOutRect(Rect)}; 8207b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 8217b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 8227b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 8239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 8248c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 825ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull Rect rect, @NonNull Region.Op op) { 8267b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 827caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 828f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy op.nativeInt); 8299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 8309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 8319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8322ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger * DON'T USE THIS METHOD. It exists only to support a particular legacy behavior in 8332ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger * the view system and will be removed as soon as that code is refactored to no longer 8342ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger * depend on this behavior. 8352ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger * @hide 8362ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger */ 8372ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger public boolean clipRectUnion(@NonNull Rect rect) { 8382ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 8392ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger Region.Op.UNION.nativeInt); 8402ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger } 8412ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger 8422ad19e51463f2f4b5633fa9c155fd9fc75f387a6Derek Sollenberger /** 8439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 8449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rectangle to intersect with the current clip. 8479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 849ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull RectF rect) { 850caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 85195d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 85295d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 85395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita 8549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8558c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 8568c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 8578c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8588c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param rect The rectangle to perform a difference op with the current clip. 8598c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 8608c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 8618c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(@NonNull RectF rect) { 8628c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 8638c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 8648c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 8658c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 8668c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 8679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 8689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rectangle to intersect with the current clip. 8719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 873ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull Rect rect) { 874caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 87595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 87695d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 877051910b9f998030dacb8a0722588cc715813fde1Raph Levien 8789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8798c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 8808c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 8818c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8828c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param rect The rectangle to perform a difference op with the current clip. 8838c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 8848c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 8858c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(@NonNull Rect rect) { 8868c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 8878c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 8888c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 8898c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 8908c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 8919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified rectangle, which is 8929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 8959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 8969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current 8979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 8989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 8999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 9019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 9029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 9039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 9048c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9058c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 9068c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 9078c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 9088c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 9098c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipRect(float,float,float,float)} and 9108c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link #clipOutRect(float,float,float,float)}; 9117b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 9127b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 9137b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 9149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 9158c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 916ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(float left, float top, float right, float bottom, 917ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Region.Op op) { 9187b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 919caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, op.nativeInt); 9209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 9249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 9259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 9279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current clip 9299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 9309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 9329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 9339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 9349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 93595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public boolean clipRect(float left, float top, float right, float bottom) { 936caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 93795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 93895d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 939f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy 9409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9418c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 9428c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 9438c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9448c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param left The left side of the rectangle used in the difference operation 9458c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param top The top of the rectangle used in the difference operation 9468c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param right The right side of the rectangle used in the difference operation 9478c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param bottom The bottom of the rectangle used in the difference operation 9488c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 9498c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 9508c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(float left, float top, float right, float bottom) { 9518c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 9528c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 9538c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 9548c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 9558c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 9569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 9579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 9589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 9609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current clip 9629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 9639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 9659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 9669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 9679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 96895d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public boolean clipRect(int left, int top, int right, int bottom) { 969caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 97095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 97195d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 972f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy 9739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9748c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 9758c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 9768c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9778c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param left The left side of the rectangle used in the difference operation 9788c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param top The top of the rectangle used in the difference operation 9798c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param right The right side of the rectangle used in the difference operation 9808c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param bottom The bottom of the rectangle used in the difference operation 9818c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 9828c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 9838c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(int left, int top, int right, int bottom) { 9848c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 9858c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 9868c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 9878c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 9888c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 9899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified path. 9909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to operate on the current clip 9929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 9939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 9948c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9958c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 9968c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 9978c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 9988c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 9998c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipPath(Path)} and 10008c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link #clipOutPath(Path)}; 10017b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 10027b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 10037b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 10049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 10058c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 1006ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipPath(@NonNull Path path, @NonNull Region.Op op) { 10077b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 1008caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipPath(mNativeCanvasWrapper, path.readOnlyNI(), op.nativeInt); 10099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1010051910b9f998030dacb8a0722588cc715813fde1Raph Levien 10119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified path. 10139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to intersect with the current clip 10158c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 10169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1017ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipPath(@NonNull Path path) { 10189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return clipPath(path, Region.Op.INTERSECT); 10199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1020051910b9f998030dacb8a0722588cc715813fde1Raph Levien 10219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10228c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified path. 10238c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 10248c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param path The path used in the difference operation 10258c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 10268c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 10278c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutPath(@NonNull Path path) { 10288c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return clipPath(path, Region.Op.DIFFERENCE); 10298c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 10308c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 10318c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 10329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified region. Note that unlike 10339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clipRect() and clipPath() which transform their arguments by the 10349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, clipRegion() assumes its argument is already in the 10359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * coordinate system of the current layer's bitmap, and so not 10369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * transformation is performed. 10379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param region The region to operate on the current clip, based on op 10399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 10409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 10410d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * 1042b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger * @removed 10430d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * @deprecated Unlike all other clip calls this API does not respect the 10440d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * current matrix. Use {@link #clipRect(Rect)} as an alternative. 10459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1046eda57925cafdf1dab451e70052dea27846f368b4Chris Craik @Deprecated 1047ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRegion(@NonNull Region region, @NonNull Region.Op op) { 1048b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger return false; 10499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified region. Note that unlike 10539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clipRect() and clipPath() which transform their arguments by the 10549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, clipRegion() assumes its argument is already in the 10559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * coordinate system of the current layer's bitmap, and so not 10569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * transformation is performed. 10579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param region The region to operate on the current clip, based on op 10599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 10600d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * 1061b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger * @removed 10620d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * @deprecated Unlike all other clip calls this API does not respect the 10630d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * current matrix. Use {@link #clipRect(Rect)} as an alternative. 10649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1065eda57925cafdf1dab451e70052dea27846f368b4Chris Craik @Deprecated 1066ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRegion(@NonNull Region region) { 1067b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger return false; 10689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1069051910b9f998030dacb8a0722588cc715813fde1Raph Levien 1070ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public @Nullable DrawFilter getDrawFilter() { 10719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mDrawFilter; 10729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1073051910b9f998030dacb8a0722588cc715813fde1Raph Levien 1074ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void setDrawFilter(@Nullable DrawFilter filter) { 107536bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat long nativeFilter = 0; 10769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (filter != null) { 10779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeFilter = filter.mNativeInt; 10789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mDrawFilter = filter; 1080caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSetDrawFilter(mNativeCanvasWrapper, nativeFilter); 10819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10838b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase /** 10848b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * Constant values used as parameters to {@code quickReject()} calls. These values 10858b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * specify how much space around the shape should be accounted for, depending on whether 10868b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * the shaped area is antialiased or not. 10878b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * 10888b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(float, float, float, float, EdgeType) 10898b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(Path, EdgeType) 10908b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(RectF, EdgeType) 10918b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase */ 10929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public enum EdgeType { 1093d320001807168f5565bab9807ef13c111096bbb3Chet Haase 1094d320001807168f5565bab9807ef13c111096bbb3Chet Haase /** 1095d320001807168f5565bab9807ef13c111096bbb3Chet Haase * Black-and-White: Treat edges by just rounding to nearest pixel boundary 1096d320001807168f5565bab9807ef13c111096bbb3Chet Haase */ 10979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project BW(0), //!< treat edges by just rounding to nearest pixel boundary 1098d320001807168f5565bab9807ef13c111096bbb3Chet Haase 1099d320001807168f5565bab9807ef13c111096bbb3Chet Haase /** 1100d320001807168f5565bab9807ef13c111096bbb3Chet Haase * Antialiased: Treat edges by rounding-out, since they may be antialiased 1101d320001807168f5565bab9807ef13c111096bbb3Chet Haase */ 1102d320001807168f5565bab9807ef13c111096bbb3Chet Haase AA(1); 1103051910b9f998030dacb8a0722588cc715813fde1Raph Levien 11049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project EdgeType(int nativeInt) { 11059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project this.nativeInt = nativeInt; 11069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1107c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy 1108c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy /** 1109c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy * @hide 1110c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy */ 1111c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy public final int nativeInt; 11129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified rectangle, after being transformed by the 11169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). 11199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect the rect to compare with the current clip 1121d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1122d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1123d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the rect (transformed by the canvas' matrix) 11259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1127ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean quickReject(@NonNull RectF rect, @NonNull EdgeType type) { 1128caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, 112995d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita rect.left, rect.top, rect.right, rect.bottom); 11309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified path, after being transformed by the 11349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). Note: for speed it may 11379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * return false even if the path itself might not intersect the clip 11389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * (i.e. the bounds of the path intersects, but the path does not). 11399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to compare with the current clip 1141d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1142d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1143d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the path (transformed by the canvas' matrix) 11459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1147ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean quickReject(@NonNull Path path, @NonNull EdgeType type) { 1148caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, path.readOnlyNI()); 11499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified rectangle, after being transformed by the 11539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). 11569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to compare with the 11589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 11599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to compare with the current 11609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 11619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to compare with the 11629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 11639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to compare with the 11649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 1165d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1166d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1167d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the rect (transformed by the canvas' matrix) 11699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1171ca79cf69d09efa0c327e9b1237d86a119aea5da7Derek Sollenberger public boolean quickReject(float left, float top, float right, float bottom, 1172ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull EdgeType type) { 1173caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, left, top, right, bottom); 11749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1177708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * Return the bounds of the current clip (in local coordinates) in the 1178708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * bounds parameter, and return true if it is non-empty. This can be useful 1179708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * in a way similar to quickReject, in that it tells you that drawing 1180708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * outside of these bounds will be clipped out. 11819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bounds Return the clip bounds here. If it is null, ignore it but 11839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * still return true if the current clip is non-empty. 11849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the current clip is non-empty. 11859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1186ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean getClipBounds(@Nullable Rect bounds) { 1187caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nGetClipBounds(mNativeCanvasWrapper, bounds); 11889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1189051910b9f998030dacb8a0722588cc715813fde1Raph Levien 11909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1191708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * Retrieve the bounds of the current clip (in local coordinates). 11929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return the clip bounds, or [0, 0, 0, 0] if the clip is empty. 11949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1195ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public final @NonNull Rect getClipBounds() { 11969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Rect r = new Rect(); 11979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project getClipBounds(r); 11989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return r; 11999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1200051910b9f998030dacb8a0722588cc715813fde1Raph Levien 12019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1202caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Save the canvas state, draw the picture, and restore the canvas state. 1203caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * This differs from picture.draw(canvas), which does not perform any 1204caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * save/restore. 12059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1206caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <p> 1207caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <strong>Note:</strong> This forces the picture to internally call 1208caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * {@link Picture#endRecording} in order to prepare for playback. 1209caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1210caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param picture The picture to be drawn 12119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1212caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPicture(@NonNull Picture picture) { 1213caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck picture.endRecording(); 1214caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int restoreCount = save(); 1215caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck picture.draw(this); 1216caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restoreToCount(restoreCount); 12179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1220caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw the picture, stretched to fit into the dst rectangle. 12219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 12221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPicture(@NonNull Picture picture, @NonNull RectF dst) { 1223caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck save(); 1224caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck translate(dst.left, dst.top); 1225caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (picture.getWidth() > 0 && picture.getHeight() > 0) { 12261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck scale(dst.width() / picture.getWidth(), dst.height() / picture.getHeight()); 1227caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1228caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck drawPicture(picture); 1229caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restore(); 12309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1233caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw the picture, stretched to fit into the dst rectangle. 12349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 12351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPicture(@NonNull Picture picture, @NonNull Rect dst) { 1236caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck save(); 1237caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck translate(dst.left, dst.top); 1238caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (picture.getWidth() > 0 && picture.getHeight() > 0) { 12391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck scale((float) dst.width() / picture.getWidth(), 12401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck (float) dst.height() / picture.getHeight()); 1241caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1242caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck drawPicture(picture); 1243caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restore(); 12449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1246caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public enum VertexMode { 1247caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLES(0), 1248caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLE_STRIP(1), 1249caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLE_FAN(2); 1250caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1251caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck VertexMode(int nativeInt) { 1252caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck this.nativeInt = nativeInt; 1253caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1254caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1255caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1256caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1257caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1258caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public final int nativeInt; 12599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1262caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Releases the resources associated with this canvas. 12639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1264caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1266caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void release() { 1267caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mNativeCanvasWrapper = 0; 1268caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (mFinalizer != null) { 1269caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mFinalizer.run(); 1270caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mFinalizer = null; 1271caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 12729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1273051910b9f998030dacb8a0722588cc715813fde1Raph Levien 12749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1275caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Free up as much memory as possible from private caches (e.g. fonts, images) 12769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1277caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1279caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public static void freeCaches() { 1280caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nFreeCaches(); 128195d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 12829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1284caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Free up text layout caches 1285caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1286caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1288caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public static void freeTextLayoutCaches() { 1289caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nFreeTextLayoutCaches(); 12909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12927717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev /** @hide */ 12937b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger public static void setCompatibilityVersion(int apiLevel) { 12947b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger sCompatiblityVersion = apiLevel; 12957b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger nSetCompatibilityVersion(apiLevel); 12967b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger } 12977717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev 1298caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nFreeCaches(); 1299caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nFreeTextLayoutCaches(); 1300caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native long nInitRaster(Bitmap bitmap); 1301caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native long nGetNativeFinalizer(); 13027717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev private static native void nSetCompatibilityVersion(int apiLevel); 1303caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1304caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck // ---------------- @FastNative ------------------- 1305caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1306caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @FastNative 1307bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetBitmap(long canvasHandle, Bitmap bitmap); 1308bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1309caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @FastNative 1310bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nGetClipBounds(long nativeCanvas, Rect bounds); 1311bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1312bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // ---------------- @CriticalNative ------------------- 1313bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1314bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1315caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native boolean nIsOpaque(long canvasHandle); 1316bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1317caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetWidth(long canvasHandle); 1318bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1319caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetHeight(long canvasHandle); 1320caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1321bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1322caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nSave(long canvasHandle, int saveFlags); 1323bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1324bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native int nSaveLayer(long nativeCanvas, float l, float t, float r, float b, 1325bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik long nativePaint, int layerFlags); 1326bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1327bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native int nSaveLayerAlpha(long nativeCanvas, float l, float t, float r, float b, 1328bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik int alpha, int layerFlags); 1329bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1330bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nRestore(long canvasHandle); 1331bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1332bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nRestoreToCount(long canvasHandle, int saveCount); 1333bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1334caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetSaveCount(long canvasHandle); 1335caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1336bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1337bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nTranslate(long canvasHandle, float dx, float dy); 1338bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1339bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nScale(long canvasHandle, float sx, float sy); 1340bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1341caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nRotate(long canvasHandle, float degrees); 1342bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1343bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSkew(long canvasHandle, float sx, float sy); 1344bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1345bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nConcat(long nativeCanvas, long nativeMatrix); 1346bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1347bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetMatrix(long nativeCanvas, long nativeMatrix); 1348bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1349caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native boolean nClipRect(long nativeCanvas, 1350bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik float left, float top, float right, float bottom, int regionOp); 1351bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1352bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nClipPath(long nativeCanvas, long nativePath, int regionOp); 1353bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1354bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetDrawFilter(long nativeCanvas, long nativeFilter); 1355bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1356bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nGetMatrix(long nativeCanvas, long nativeMatrix); 1357bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1358bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nQuickReject(long nativeCanvas, long nativePath); 1359bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1360bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nQuickReject(long nativeCanvas, float left, float top, 1361bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik float right, float bottom); 1362bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1363bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1364bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // ---------------- Draw Methods ------------------- 1365caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 13669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 13671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified arc, which will be scaled to fit inside the specified oval. 13691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the start angle is negative or >= 360, the start angle is treated as start angle modulo 13721ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 360. 13731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs 13761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is 13771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * negative, the sweep angle is treated as sweep angle modulo 360 13781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 13811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * degrees (3 o'clock on a watch.) 13821ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1383caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 13841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param oval The bounds of oval used to define the shape and size of the arc 1385caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startAngle Starting angle (in degrees) where the arc begins 1386caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param sweepAngle Sweep angle (in degrees) measured clockwise 13871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param useCenter If true, include the center of the oval in the arc, and close it if it is 13881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * being stroked. This will draw a wedge 13891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the arc 13909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 13911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter, 13921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 13931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawArc(oval, startAngle, sweepAngle, useCenter, paint); 139495d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 13959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 13969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 13971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified arc, which will be scaled to fit inside the specified oval. 13991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 14001ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14011ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the start angle is negative or >= 360, the start angle is treated as start angle modulo 14021ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 360. 14031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 14041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14051ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs 14061ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is 14071ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * negative, the sweep angle is treated as sweep angle modulo 360 14081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 14091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 14111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * degrees (3 o'clock on a watch.) 14121ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1413caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1414caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startAngle Starting angle (in degrees) where the arc begins 1415caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param sweepAngle Sweep angle (in degrees) measured clockwise 14161ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param useCenter If true, include the center of the oval in the arc, and close it if it is 14171ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * being stroked. This will draw a wedge 14181ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the arc 14199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 14201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawArc(float left, float top, float right, float bottom, float startAngle, 14211ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck float sweepAngle, boolean useCenter, @NonNull Paint paint) { 14221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawArc(left, top, right, bottom, startAngle, sweepAngle, useCenter, paint); 14239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB 14271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * color, using srcover porterduff mode. 14289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1429caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param a alpha component (0..255) of the color to draw onto the canvas 1430caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param r red component (0..255) of the color to draw onto the canvas 1431caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param g green component (0..255) of the color to draw onto the canvas 1432caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param b blue component (0..255) of the color to draw onto the canvas 14339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1434caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawARGB(int a, int r, int g, int b) { 1435caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawARGB(a, r, g, b); 14369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, with its top/left corner at (x,y), using the specified paint, 14401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * transformed by the current matrix. 14411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14431ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14441ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14471ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the bitmap and canvas have different densities, this function will take care of 14481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * automatically scaling the bitmap to draw at the same density as the canvas. 1449051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to be drawn 14511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param left The position of the left side of the bitmap being drawn 14521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param top The position of the top side of the bitmap being drawn 14531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the bitmap (may be null) 14549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1455ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) { 1456caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(bitmap, left, top, paint); 14579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, scaling/translating automatically to fill the destination 14611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to 14621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * draw. 14631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This function <em>ignores the density associated with the bitmap</em>. This is because the 14701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * source and destination rectangle coordinate spaces are in their respective densities, so must 14711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * already have the appropriate scaling factor applied. 1472051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bitmap The bitmap to be drawn 14741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param src May be null. The subset of the bitmap to be drawn 14751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param dst The rectangle that the bitmap will be scaled/translated to fit into 14761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 14779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 14781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawBitmap(@NonNull Bitmap bitmap, @Nullable Rect src, @NonNull RectF dst, 14791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @Nullable Paint paint) { 14801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawBitmap(bitmap, src, dst, paint); 1481caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 14829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, scaling/translating automatically to fill the destination 14851ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to 14861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * draw. 14871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This function <em>ignores the density associated with the bitmap</em>. This is because the 14941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * source and destination rectangle coordinate spaces are in their respective densities, so must 14951ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * already have the appropriate scaling factor applied. 1496051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to be drawn 14981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param src May be null. The subset of the bitmap to be drawn 14991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param dst The rectangle that the bitmap will be scaled/translated to fit into 15001ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 15019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1502ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull Bitmap bitmap, @Nullable Rect src, @NonNull Rect dst, 1503ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Nullable Paint paint) { 1504caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(bitmap, src, dst, paint); 1505caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1506caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1507caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 15081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Treat the specified array of colors as a bitmap, and draw it. This gives the same result as 15091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * first creating a bitmap from the array, and then drawing it, but this method avoids 15101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly creating a bitmap object which can be more efficient if the colors are changing 15111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * often. 15129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 15139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param colors Array of colors representing the pixels of the bitmap 15149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param offset Offset into the array of colors for the first pixel 15151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param stride The number of colors in the array between rows (must be >= width or <= -width). 15169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param x The X coordinate for where to draw the bitmap 15179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param y The Y coordinate for where to draw the bitmap 15189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param width The width of the bitmap 15199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param height The height of the bitmap 15201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hasAlpha True if the alpha channel of the colors contains valid values. If false, the 15211ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * alpha byte is ignored (assumed to be 0xFF for every pixel). 15221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 1523cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * @deprecated Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas 15241ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * requires an internal copy of color buffer contents every time this method is 15251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * called. Using a Bitmap avoids this copy, and allows the application to more 15261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly control the lifetime and copies of pixel data. 15279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1528cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik @Deprecated 1529ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull int[] colors, int offset, int stride, float x, float y, 1530ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese int width, int height, boolean hasAlpha, @Nullable Paint paint) { 1531caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint); 15329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1533cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik 1534cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik /** 1535cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * Legacy version of drawBitmap(int[] colors, ...) that took ints for x,y 1536cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * 1537cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * @deprecated Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas 15381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * requires an internal copy of color buffer contents every time this method is 15391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * called. Using a Bitmap avoids this copy, and allows the application to more 15401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly control the lifetime and copies of pixel data. 15419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1542cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik @Deprecated 1543ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull int[] colors, int offset, int stride, int x, int y, 1544ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese int width, int height, boolean hasAlpha, @Nullable Paint paint) { 1545caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint); 15469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1547051910b9f998030dacb8a0722588cc715813fde1Raph Levien 15489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 15491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the bitmap using the specified matrix. 15501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 15511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bitmap The bitmap to draw 15521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param matrix The matrix used to transform the bitmap when it is drawn 15531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 15541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck */ 15551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) { 15561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawBitmap(bitmap, matrix, paint); 15571ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck } 15581ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck 15591ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck /** 15601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the bitmap through the mesh, where mesh vertices are evenly distributed across the 15611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap. There are meshWidth+1 vertices across, and meshHeight+1 vertices down. The verts 15621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array is accessed in row-major order, so that the first meshWidth+1 vertices are distributed 15631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * across the top of the bitmap from left to right. A more general version of this method is 15641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawVertices(). 15659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1566322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * Prior to API level {@value Build.VERSION_CODES#P} vertOffset and colorOffset were ignored, 1567322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * effectively treating them as zeros. In API level {@value Build.VERSION_CODES#P} and above 1568322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * these parameters will be respected. 1569322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * 15709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to draw using the mesh 15711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param meshWidth The number of columns in the mesh. Nothing is drawn if this is 0 15721ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param meshHeight The number of rows in the mesh. Nothing is drawn if this is 0 15731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param verts Array of x,y pairs, specifying where the mesh should be drawn. There must be at 15741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * least (meshWidth+1) * (meshHeight+1) * 2 + vertOffset values in the array 15759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param vertOffset Number of verts elements to skip before drawing 15761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param colors May be null. Specifies a color at each vertex, which is interpolated across the 15771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * cell, and whose values are multiplied by the corresponding bitmap colors. If not 15781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * null, there must be at least (meshWidth+1) * (meshHeight+1) + colorOffset values 15791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * in the array. 15809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param colorOffset Number of color elements to skip before drawing 15811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 15829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1583ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmapMesh(@NonNull Bitmap bitmap, int meshWidth, int meshHeight, 1584ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull float[] verts, int vertOffset, @Nullable int[] colors, int colorOffset, 1585ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Nullable Paint paint) { 1586caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmapMesh(bitmap, meshWidth, meshHeight, verts, vertOffset, colors, colorOffset, 1587caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck paint); 15889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1589051910b9f998030dacb8a0722588cc715813fde1Raph Levien 15909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 15911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified circle using the specified paint. If radius is <= 0, then nothing will be 15921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawn. The circle will be filled or framed based on the Style in the paint. 15939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 15941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param cx The x-coordinate of the center of the cirle to be drawn 15951ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param cy The y-coordinate of the center of the cirle to be drawn 1596caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param radius The radius of the cirle to be drawn 15971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the circle 15989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1599caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint) { 1600caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawCircle(cx, cy, radius, paint); 16019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 160236bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat 16039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified color, 16051ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * using srcover porterduff mode. 16069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1607caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param color the color to draw onto the canvas 16089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1609caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawColor(@ColorInt int color) { 1610caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawColor(color); 16119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 16129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and 16151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * porter-duff xfermode. 16169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1617caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param color the color to draw with 16181ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param mode the porter-duff mode to apply to the color 16199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1620caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawColor(@ColorInt int color, @NonNull PorterDuff.Mode mode) { 1621caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawColor(color, mode); 1622f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 16239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a line segment with the specified start and stop x,y coordinates, using the specified 16261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint. 16271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 16281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note that since a line is always "framed", the Style is ignored in the paint. 16291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 16301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 16311ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Degenerate lines (length is 0) will not be drawn. 16321ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1633caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1634caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startX The x-coordinate of the start point of the line 1635caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startY The y-coordinate of the start point of the line 16361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the line 16379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1638caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawLine(float startX, float startY, float stopX, float stopY, 1639ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1640caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLine(startX, startY, stopX, stopY, paint); 16419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 16429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16441ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a series of lines. Each line is taken from 4 consecutive values in the pts array. Thus 16451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * to draw 1 line, the array must contain at least 4 values. This is logically the same as 16461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawing the array as follows: drawLine(pts[0], pts[1], pts[2], pts[3]) followed by 1647caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * drawLine(pts[4], pts[5], pts[6], pts[7]) and so on. 16489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 16491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...] 16501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param offset Number of values in the array to skip before drawing. 16511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of values in the array to process, after skipping "offset" of them. 16521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Since each line uses 4 values, the number of "lines" that are drawn is really 16531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * (count >> 2). 16541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the points 16559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 16561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawLines(@Size(multiple = 4) @NonNull float[] pts, int offset, int count, 1657ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1658caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLines(pts, offset, count, paint); 1659caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1660caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 16611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawLines(@Size(multiple = 4) @NonNull float[] pts, @NonNull Paint paint) { 1662caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLines(pts, paint); 1663f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 1664f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1665f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt /** 16661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified oval using the specified paint. The oval will be filled or framed based on 16671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 1668caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1669caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param oval The rectangle bounds of the oval to be drawn 1670caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1671caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawOval(@NonNull RectF oval, @NonNull Paint paint) { 1672caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawOval(oval, paint); 1673f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 1674f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1675f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt /** 16761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified oval using the specified paint. The oval will be filled or framed based on 16771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 16781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck */ 16791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawOval(float left, float top, float right, float bottom, @NonNull Paint paint) { 16801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawOval(left, top, right, bottom, paint); 16811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck } 16821ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck 16831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck /** 16841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified paint. 16851ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This is equivalent (but faster) to drawing an infinitely large rectangle with the specified 16861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint. 1687c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1688caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw onto the canvas 1689caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1690caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPaint(@NonNull Paint paint) { 1691caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPaint(paint); 1692caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1693caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1694caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1695caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draws the specified bitmap as an N-patch (most often, a 9-patches.) 1696c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1697caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param patch The ninepatch object to render 1698caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param dst The destination rectangle. 1699caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint to draw the bitmap with. may be null 1700caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1701caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1702caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPatch(@NonNull NinePatch patch, @NonNull Rect dst, @Nullable Paint paint) { 1703caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPatch(patch, dst, paint); 1704caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1705caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1706caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1707caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draws the specified bitmap as an N-patch (most often, a 9-patches.) 1708c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1709caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param patch The ninepatch object to render 1710caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param dst The destination rectangle. 1711caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint to draw the bitmap with. may be null 1712caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1713caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1714caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPatch(@NonNull NinePatch patch, @NonNull RectF dst, @Nullable Paint paint) { 1715caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPatch(patch, dst, paint); 1716caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1717caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1718caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified path using the specified paint. The path will be filled or framed based on 17201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 1721c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 17221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path to be drawn 1723caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the path 1724f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt */ 1725caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPath(@NonNull Path path, @NonNull Paint paint) { 1726caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPath(path, paint); 1727caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1728f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1729caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1730caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Helper for drawPoints() for drawing a single point. 1731caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1732caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPoint(float x, float y, @NonNull Paint paint) { 1733caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoint(x, y, paint); 1734caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1735f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1736caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a series of points. Each point is centered at the coordinate specified by pts[], and its 17381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * diameter is specified by the paint's stroke width (as transformed by the canvas' CTM), with 17391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * special treatment for a stroke width of 0, which always draws exactly 1 pixel (or at most 4 17401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * if antialiasing is enabled). The shape of the point is controlled by the paint's Cap type. 17411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The shape is a square, unless the cap type is Round, in which case the shape is a circle. 1742caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 17431ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...] 17441ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param offset Number of values to skip before starting to draw. 17451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of values to process, after skipping offset of them. Since one point 17461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * uses two values, the number of "points" that are drawn is really (count >> 1). 17471ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the points 1748caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 17491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPoints(@Size(multiple = 2) float[] pts, int offset, int count, 1750caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1751caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoints(pts, offset, count, paint); 1752caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1753caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1754caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1755caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Helper for drawPoints() that assumes you want to draw the entire array 1756caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 17571ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPoints(@Size(multiple = 2) @NonNull float[] pts, @NonNull Paint paint) { 1758caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoints(pts, paint); 17599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 17609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 17619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 17621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text in the array, with each character's origin specified by the pos array. 1763eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 17641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 17651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param index The index of the first character to draw 17661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of characters to draw, starting from index. 17671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pos Array of [x,y] positions, used to position each character 17681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 17691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @deprecated This method does not support glyph composition and decomposition and should 17701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * therefore not be used to render complex scripts. It also doesn't handle 17711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * supplementary characters (eg emoji). 17729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1773f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy @Deprecated 1774b3ec733bb830f2d4425825d93f9ed95f284e9145Tor Norbye public void drawPosText(@NonNull char[] text, int index, int count, 17751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull @Size(multiple = 2) float[] pos, 1776ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1777caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPosText(text, index, count, pos, paint); 1778caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1779caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1780caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text in the array, with each character's origin specified by the pos array. 1782caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 17831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 17841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pos Array of [x,y] positions, used to position each character 1785caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 17861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @deprecated This method does not support glyph composition and decomposition and should 17871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * therefore not be used to render complex scripts. It also doesn't handle 17881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * supplementary characters (eg emoji). 1789caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1790caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @Deprecated 17911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPosText(@NonNull String text, @NonNull @Size(multiple = 2) float[] pos, 1792caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1793caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPosText(text, pos, paint); 1794caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1795caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1796caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified Rect using the specified paint. The rectangle will be filled or framed 17981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Style in the paint. 1799caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18001ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rect The rect to be drawn 18011ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the rect 1802caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRect(@NonNull RectF rect, @NonNull Paint paint) { 18041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRect(rect, paint); 1805caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1806caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1807caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified Rect using the specified Paint. The rectangle will be filled or framed 18091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Style in the paint. 1810caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param r The rectangle to be drawn. 18121ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the rectangle 1813caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1814caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawRect(@NonNull Rect r, @NonNull Paint paint) { 1815caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawRect(r, paint); 1816caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1817caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1818caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified Rect using the specified paint. The rectangle will be filled or framed 18201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Style in the paint. 1821caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param left The left side of the rectangle to be drawn 18231ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param top The top side of the rectangle to be drawn 18241ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param right The right side of the rectangle to be drawn 18251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bottom The bottom side of the rectangle to be drawn 1826caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the rect 1827caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) { 18291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRect(left, top, right, bottom, paint); 1830caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1831caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1832caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color, 18341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * using srcover porterduff mode. 1835caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1836caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param r red component (0..255) of the color to draw onto the canvas 1837caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param g green component (0..255) of the color to draw onto the canvas 1838caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param b blue component (0..255) of the color to draw onto the canvas 1839caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1840caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawRGB(int r, int g, int b) { 1841caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawRGB(r, g, b); 1842caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1843caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1844caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified round-rect using the specified paint. The roundrect will be filled or 18461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * framed based on the Style in the paint. 1847caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rect The rectangular bounds of the roundRect to be drawn 18491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rx The x-radius of the oval used to round the corners 18501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param ry The y-radius of the oval used to round the corners 1851caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the roundRect 1852caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRoundRect(@NonNull RectF rect, float rx, float ry, @NonNull Paint paint) { 18541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRoundRect(rect, rx, ry, paint); 1855caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1856caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1857caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18581ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified round-rect using the specified paint. The roundrect will be filled or 18591ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * framed based on the Style in the paint. 1860caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rx The x-radius of the oval used to round the corners 18621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param ry The y-radius of the oval used to round the corners 1863caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the roundRect 1864caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry, 18661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 18671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRoundRect(left, top, right, bottom, rx, ry, paint); 1868caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1869caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1870caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18721ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1873caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 18751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 18761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 1877caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 1878caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1879caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawText(@NonNull char[] text, int index, int count, float x, float y, 1880caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1881caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawText(text, index, count, x, y, paint); 1882caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1883caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1884caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18851ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1887caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 18891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 18901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 1891caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 1892caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull String text, float x, float y, @NonNull Paint paint) { 18941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawText(text, x, y, paint); 18959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 18969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 18979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 18981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1900051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 19011ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 19021ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param start The index of the first character in text to draw 19031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end (end - 1) is the index of the last character in text to draw 19041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 19051ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 19069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param paint The paint used for the text (e.g. color, size, style) 1907caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 19081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull String text, int start, int end, float x, float y, 19091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 19101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawText(text, start, end, x, y, paint); 1911caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1912caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1913caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 19141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified range of text, specified by start/end, with its origin at (x,y), in the 19151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * specified Paint. The origin is interpreted based on the Align setting in the Paint. 1916eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 19171ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 1918caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param start The index of the first character in text to draw 19191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end (end - 1) is the index of the last character in text to draw 19201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of origin for where to draw the text 19211ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of origin for where to draw the text 1922caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 19239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 19241ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull CharSequence text, int start, int end, float x, float y, 1925b3ec733bb830f2d4425825d93f9ed95f284e9145Tor Norbye @NonNull Paint paint) { 1926caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawText(text, start, end, x, y, paint); 19279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 19301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint, along the specified path. The 19311ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint's Align setting determins where along the path to start the text. 19329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 19331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 19341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path the text should follow for its baseline 19351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hOffset The distance along the path to add to the text's starting position 19361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vOffset The distance above(-) or below(+) the path to position the text 19371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 19389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1939ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawTextOnPath(@NonNull char[] text, int index, int count, @NonNull Path path, 1940ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese float hOffset, float vOffset, @NonNull Paint paint) { 1941caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextOnPath(text, index, count, path, hOffset, vOffset, paint); 19429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 19451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint, along the specified path. The 19461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint's Align setting determins where along the path to start the text. 19479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 19481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 19491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path the text should follow for its baseline 19501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hOffset The distance along the path to add to the text's starting position 19511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vOffset The distance above(-) or below(+) the path to position the text 19521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 19539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1954ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawTextOnPath(@NonNull String text, @NonNull Path path, float hOffset, 1955ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese float vOffset, @NonNull Paint paint) { 1956caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextOnPath(text, path, hOffset, vOffset, paint); 19579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1960caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw a run of text, all in a single direction, with optional context for complex text 1961caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * shaping. 19621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * See {@link #drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)} for 19641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * more details. This method uses a character array rather than CharSequence to represent the 19651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * string. Also, to be consistent with the pattern established in {@link #drawText}, in this 19661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * method {@code count} and {@code contextCount} are used rather than offsets of the end 19671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * position; {@code count = end - start, contextCount = contextEnd - 1968caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * contextStart}. 1969051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 1970caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param text the text to render 1971caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param index the start of the text to render 1972caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param count the count of chars to render 19731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param contextIndex the start of the context for shaping. Must be no greater than index. 19741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param contextCount the number of characters in the context for shaping. contexIndex + 19751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * contextCount must be no less than index + count. 1976caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param x the x position at which to draw the text 1977caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param y the y position at which to draw the text 1978caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param isRtl whether the run is in RTL direction 1979caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint the paint 19809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1981caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawTextRun(@NonNull char[] text, int index, int count, int contextIndex, 1982caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int contextCount, float x, float y, boolean isRtl, @NonNull Paint paint) { 1983caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextRun(text, index, count, contextIndex, contextCount, x, y, isRtl, paint); 19849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1985da8532c6f48b4c10b5e2ccb9e08690341efa1616Romain Guy 1986da8532c6f48b4c10b5e2ccb9e08690341efa1616Romain Guy /** 1987caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw a run of text, all in a single direction, with optional context for complex text 1988caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * shaping. 19891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The run of text includes the characters from {@code start} to {@code end} in the text. In 1991caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * addition, the range {@code contextStart} to {@code contextEnd} is used as context for the 1992caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * purpose of complex text shaping, such as Arabic text potentially shaped differently based on 1993caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * the text next to it. 19941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19951ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * All text outside the range {@code contextStart..contextEnd} is ignored. The text between 1996caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * {@code start} and {@code end} will be laid out and drawn. 19971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The direction of the run is explicitly specified by {@code isRtl}. Thus, this method is 1999caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * suitable only for runs of a single direction. Alignment of the text is as determined by the 2000caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Paint's TextAlign value. Further, {@code 0 <= contextStart <= start <= end <= contextEnd 2001caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <= text.length} must hold on entry. 20021ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 20031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Also see {@link android.graphics.Paint#getRunAdvance} for a corresponding method to measure 20041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the text; the advance width of the text drawn matches the value obtained from that method. 2005caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 2006caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param text the text to render 20071ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param start the start of the text to render. Data before this position can be used for 20081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shaping context. 20091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end the end of the text to render. Data at or after this position can be used for 20101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shaping context. 2011caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param contextStart the index of the start of the shaping context 2012caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param contextEnd the index of the end of the shaping context 2013caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param x the x position at which to draw the text 2014caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param y the y position at which to draw the text 2015caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param isRtl whether the run is in RTL direction 2016caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint the paint 2017caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @see #drawTextRun(char[], int, int, int, int, float, float, boolean, Paint) 2018caf0df1b7f99736aed1a0b923ef278fc4fd0fccaMike Reed */ 2019caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawTextRun(@NonNull CharSequence text, int start, int end, int contextStart, 2020caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int contextEnd, float x, float y, boolean isRtl, @NonNull Paint paint) { 2021caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextRun(text, start, end, contextStart, contextEnd, x, y, isRtl, paint); 2022caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 2023caf0df1b7f99736aed1a0b923ef278fc4fd0fccaMike Reed 202430ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio /** 20251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the array of vertices, interpreted as triangles (based on mode). The verts array is 20261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * required, and specifies the x,y pairs for each vertex. If texs is non-null, then it is used 20271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * to specify the coordinate in shader coordinates to use at each vertex (the paint must have a 20281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shader in this case). If there is no texs array, but there is a color array, then each color 20291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * is interpolated across its corresponding triangle in a gradient. If both texs and colors 20301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * arrays are present, then they behave as before, but the resulting color at each pixels is the 20311ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * result of multiplying the colors from the shader and the color-gradient together. The indices 20321ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array is optional, but if it is present, then it is used to specify the index of each 20331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * triangle, rather than just walking through the arrays in order. 203430ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio * 2035caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param mode How to interpret the array of vertices 20361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vertexCount The number of values in the vertices array (and corresponding texs and 20371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * colors arrays if non-null). Each logical vertex is two values (x, y), vertexCount 20381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * must be a multiple of 2. 2039caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param verts Array of vertices for the mesh 2040caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param vertOffset Number of values in the verts to skip before drawing. 20411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param texs May be null. If not null, specifies the coordinates to sample into the current 20421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shader (e.g. bitmap tile or gradient) 2043caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param texOffset Number of values in texs to skip before drawing. 20441ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param colors May be null. If not null, specifies a color for each vertex, to be interpolated 20451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * across the triangle. 2046caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param colorOffset Number of values in colors to skip before drawing. 20471ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param indices If not null, array of indices to reference into the vertex (texs, colors) 20481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array. 2049caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param indexCount number of entries in the indices array (if not null). 2050caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint Specifies the shader to use if the texs array is non-null. 205130ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio */ 2052caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawVertices(@NonNull VertexMode mode, int vertexCount, @NonNull float[] verts, 2053caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int vertOffset, @Nullable float[] texs, int texOffset, @Nullable int[] colors, 2054caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int colorOffset, @Nullable short[] indices, int indexOffset, int indexCount, 2055caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 2056caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawVertices(mode, vertexCount, verts, vertOffset, texs, texOffset, 2057caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck colors, colorOffset, indices, indexOffset, indexCount, paint); 2058caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 20599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 2060