Canvas.java revision 2d4f01ba7f544f1bd772239a0f19946b01ed98d9
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 /** 8329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 8339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rectangle to intersect with the current clip. 8369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 838ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull RectF rect) { 839caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 84095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 84195d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 84295d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita 8439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8448c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 8458c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 8468c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8478c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param rect The rectangle to perform a difference op with the current clip. 8488c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 8498c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 8508c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(@NonNull RectF rect) { 8518c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 8528c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 8538c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 8548c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 8558c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 8569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 8579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect The rectangle to intersect with the current clip. 8609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 862ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(@NonNull Rect rect) { 863caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 86495d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 86595d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 866051910b9f998030dacb8a0722588cc715813fde1Raph Levien 8679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 8688c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 8698c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 8708c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8718c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param rect The rectangle to perform a difference op with the current clip. 8728c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 8738c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 8748c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(@NonNull Rect rect) { 8758c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, 8768c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 8778c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 8788c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 8798c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 8809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified rectangle, which is 8819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 8829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 8839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 8849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 8859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current 8869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 8879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 8889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 8899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 8909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 8919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 8929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 8938c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 8948c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 8958c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 8968c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 8978c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 8988c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipRect(float,float,float,float)} and 8998c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link #clipOutRect(float,float,float,float)}; 9007b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 9017b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 9027b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 9039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 9048c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 905ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRect(float left, float top, float right, float bottom, 906ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Region.Op op) { 9077b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 908caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, op.nativeInt); 9099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 9109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 9119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 9139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 9149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 9169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current clip 9189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 9199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 9219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 9229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 9239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 92495d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public boolean clipRect(float left, float top, float right, float bottom) { 925caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 92695d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 92795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 928f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy 9299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9308c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 9318c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 9328c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9338c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param left The left side of the rectangle used in the difference operation 9348c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param top The top of the rectangle used in the difference operation 9358c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param right The right side of the rectangle used in the difference operation 9368c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param bottom The bottom of the rectangle used in the difference operation 9378c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 9388c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 9398c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(float left, float top, float right, float bottom) { 9408c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 9418c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 9428c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 9438c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 9448c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 9459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified rectangle, which is 9469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * expressed in local coordinates. 9479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to intersect with the 9499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to intersect with the current clip 9519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to intersect with the 9529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 9539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to intersect with the current 9549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 9559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting clip is non-empty 9569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 95795d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita public boolean clipRect(int left, int top, int right, int bottom) { 958caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 95995d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita Region.Op.INTERSECT.nativeInt); 96095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 961f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy 9629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 9638c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified rectangle, which is 9648c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * expressed in local coordinates. 9658c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9668c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param left The left side of the rectangle used in the difference operation 9678c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param top The top of the rectangle used in the difference operation 9688c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param right The right side of the rectangle used in the difference operation 9698c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param bottom The bottom of the rectangle used in the difference operation 9708c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 9718c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 9728c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutRect(int left, int top, int right, int bottom) { 9738c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return nClipRect(mNativeCanvasWrapper, left, top, right, bottom, 9748c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger Region.Op.DIFFERENCE.nativeInt); 9758c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 9768c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 9778c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 9789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified path. 9799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 9809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to operate on the current clip 9819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 9829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 9838c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 9848c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @deprecated Region.Op values other than {@link Region.Op#INTERSECT} and 9858c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link Region.Op#DIFFERENCE} have the ability to expand the clip. The canvas clipping APIs 9868c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * are intended to only expand the clip as a result of a restore operation. This enables a view 9878c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * parent to clip a canvas to clearly define the maximal drawing area of its children. The 9888c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * recommended alternative calls are {@link #clipPath(Path)} and 9898c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * {@link #clipOutPath(Path)}; 9907b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * 9917b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * As of API Level API level {@value Build.VERSION_CODES#P} only {@link Region.Op#INTERSECT} and 9927b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger * {@link Region.Op#DIFFERENCE} are valid Region.Op parameters. 9939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 9948c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger @Deprecated 995ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipPath(@NonNull Path path, @NonNull Region.Op op) { 9967b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger checkValidClipOp(op); 997caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nClipPath(mNativeCanvasWrapper, path.readOnlyNI(), op.nativeInt); 9989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 999051910b9f998030dacb8a0722588cc715813fde1Raph Levien 10009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified path. 10029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to intersect with the current clip 10048c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 10059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1006ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipPath(@NonNull Path path) { 10079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return clipPath(path, Region.Op.INTERSECT); 10089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1009051910b9f998030dacb8a0722588cc715813fde1Raph Levien 10109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10118c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * Set the clip to the difference of the current clip and the specified path. 10128c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * 10138c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @param path The path used in the difference operation 10148c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger * @return true if the resulting clip is non-empty 10158c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger */ 10168c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger public boolean clipOutPath(@NonNull Path path) { 10178c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger return clipPath(path, Region.Op.DIFFERENCE); 10188c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger } 10198c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger 10208c5759624c71ef701cba6751a030328481b4a83cDerek Sollenberger /** 10219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Modify the current clip with the specified region. Note that unlike 10229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clipRect() and clipPath() which transform their arguments by the 10239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, clipRegion() assumes its argument is already in the 10249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * coordinate system of the current layer's bitmap, and so not 10259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * transformation is performed. 10269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param region The region to operate on the current clip, based on op 10289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param op How the clip is modified 10299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 10300d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * 1031b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger * @removed 10320d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * @deprecated Unlike all other clip calls this API does not respect the 10330d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * current matrix. Use {@link #clipRect(Rect)} as an alternative. 10349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1035eda57925cafdf1dab451e70052dea27846f368b4Chris Craik @Deprecated 1036ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRegion(@NonNull Region region, @NonNull Region.Op op) { 1037b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger return false; 10389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 10419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Intersect the current clip with the specified region. Note that unlike 10429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clipRect() and clipPath() which transform their arguments by the 10439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, clipRegion() assumes its argument is already in the 10449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * coordinate system of the current layer's bitmap, and so not 10459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * transformation is performed. 10469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 10479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param region The region to operate on the current clip, based on op 10489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the resulting is non-empty 10490d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * 1050b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger * @removed 10510d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * @deprecated Unlike all other clip calls this API does not respect the 10520d181540e0c96da454f45e65987f690b27b929d9Derek Sollenberger * current matrix. Use {@link #clipRect(Rect)} as an alternative. 10539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1054eda57925cafdf1dab451e70052dea27846f368b4Chris Craik @Deprecated 1055ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean clipRegion(@NonNull Region region) { 1056b29b16e5423fe7deab8ebf3da512c6d2192f19b5Derek Sollenberger return false; 10579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1058051910b9f998030dacb8a0722588cc715813fde1Raph Levien 1059ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public @Nullable DrawFilter getDrawFilter() { 10609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return mDrawFilter; 10619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1062051910b9f998030dacb8a0722588cc715813fde1Raph Levien 1063ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void setDrawFilter(@Nullable DrawFilter filter) { 106436bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat long nativeFilter = 0; 10659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (filter != null) { 10669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project nativeFilter = filter.mNativeInt; 10679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mDrawFilter = filter; 1069caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nSetDrawFilter(mNativeCanvasWrapper, nativeFilter); 10709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 10719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 10728b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase /** 10738b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * Constant values used as parameters to {@code quickReject()} calls. These values 10748b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * specify how much space around the shape should be accounted for, depending on whether 10758b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * the shaped area is antialiased or not. 10768b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * 10778b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(float, float, float, float, EdgeType) 10788b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(Path, EdgeType) 10798b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase * @see #quickReject(RectF, EdgeType) 10808b9ed44f8d559be2590b25cb4b72d2aefd3b3784Chet Haase */ 10819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project public enum EdgeType { 1082d320001807168f5565bab9807ef13c111096bbb3Chet Haase 1083d320001807168f5565bab9807ef13c111096bbb3Chet Haase /** 1084d320001807168f5565bab9807ef13c111096bbb3Chet Haase * Black-and-White: Treat edges by just rounding to nearest pixel boundary 1085d320001807168f5565bab9807ef13c111096bbb3Chet Haase */ 10869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project BW(0), //!< treat edges by just rounding to nearest pixel boundary 1087d320001807168f5565bab9807ef13c111096bbb3Chet Haase 1088d320001807168f5565bab9807ef13c111096bbb3Chet Haase /** 1089d320001807168f5565bab9807ef13c111096bbb3Chet Haase * Antialiased: Treat edges by rounding-out, since they may be antialiased 1090d320001807168f5565bab9807ef13c111096bbb3Chet Haase */ 1091d320001807168f5565bab9807ef13c111096bbb3Chet Haase AA(1); 1092051910b9f998030dacb8a0722588cc715813fde1Raph Levien 10939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project EdgeType(int nativeInt) { 10949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project this.nativeInt = nativeInt; 10959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1096c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy 1097c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy /** 1098c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy * @hide 1099c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy */ 1100c7d53494f1fbd9f9d74af89053ff9fdb1ccbac6cRomain Guy public final int nativeInt; 11019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified rectangle, after being transformed by the 11059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). 11089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param rect the rect to compare with the current clip 1110d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1111d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1112d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the rect (transformed by the canvas' matrix) 11149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1116ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean quickReject(@NonNull RectF rect, @NonNull EdgeType type) { 1117caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, 111895d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita rect.left, rect.top, rect.right, rect.bottom); 11199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified path, after being transformed by the 11239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). Note: for speed it may 11269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * return false even if the path itself might not intersect the clip 11279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * (i.e. the bounds of the path intersects, but the path does not). 11289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param path The path to compare with the current clip 1130d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1131d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1132d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the path (transformed by the canvas' matrix) 11349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1136ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean quickReject(@NonNull Path path, @NonNull EdgeType type) { 1137caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, path.readOnlyNI()); 11389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 11419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Return true if the specified rectangle, after being transformed by the 11429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current matrix, would lie completely outside of the current clip. Call 11439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * this to check if an area you intend to draw into is clipped out (and 11449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * therefore you can skip making the draw calls). 11459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param left The left side of the rectangle to compare with the 11479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 11489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param top The top of the rectangle to compare with the current 11499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * clip 11509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param right The right side of the rectangle to compare with the 11519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 11529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bottom The bottom of the rectangle to compare with the 11539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * current clip 1154d320001807168f5565bab9807ef13c111096bbb3Chet Haase * @param type {@link Canvas.EdgeType#AA} if the path should be considered antialiased, 1155d320001807168f5565bab9807ef13c111096bbb3Chet Haase * since that means it may affect a larger area (more pixels) than 1156d320001807168f5565bab9807ef13c111096bbb3Chet Haase * non-antialiased ({@link Canvas.EdgeType#BW}). 11579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the rect (transformed by the canvas' matrix) 11589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * does not intersect with the canvas' clip 11599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1160ca79cf69d09efa0c327e9b1237d86a119aea5da7Derek Sollenberger public boolean quickReject(float left, float top, float right, float bottom, 1161ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull EdgeType type) { 1162caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nQuickReject(mNativeCanvasWrapper, left, top, right, bottom); 11639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 11649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 11659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1166708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * Return the bounds of the current clip (in local coordinates) in the 1167708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * bounds parameter, and return true if it is non-empty. This can be useful 1168708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * in a way similar to quickReject, in that it tells you that drawing 1169708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * outside of these bounds will be clipped out. 11709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bounds Return the clip bounds here. If it is null, ignore it but 11729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * still return true if the current clip is non-empty. 11739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return true if the current clip is non-empty. 11749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1175ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public boolean getClipBounds(@Nullable Rect bounds) { 1176caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck return nGetClipBounds(mNativeCanvasWrapper, bounds); 11779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1178051910b9f998030dacb8a0722588cc715813fde1Raph Levien 11799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1180708144e828b1a549567ce50cd8ed3cda62930501Derek Sollenberger * Retrieve the bounds of the current clip (in local coordinates). 11819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 11829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @return the clip bounds, or [0, 0, 0, 0] if the clip is empty. 11839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1184ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public final @NonNull Rect getClipBounds() { 11859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Rect r = new Rect(); 11869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project getClipBounds(r); 11879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return r; 11889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1189051910b9f998030dacb8a0722588cc715813fde1Raph Levien 11909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1191caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Save the canvas state, draw the picture, and restore the canvas state. 1192caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * This differs from picture.draw(canvas), which does not perform any 1193caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * save/restore. 11949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1195caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <p> 1196caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <strong>Note:</strong> This forces the picture to internally call 1197caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * {@link Picture#endRecording} in order to prepare for playback. 1198caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1199caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param picture The picture to be drawn 12009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1201caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPicture(@NonNull Picture picture) { 1202caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck picture.endRecording(); 1203caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int restoreCount = save(); 1204caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck picture.draw(this); 1205caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restoreToCount(restoreCount); 12069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1209caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw the picture, stretched to fit into the dst rectangle. 12109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 12111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPicture(@NonNull Picture picture, @NonNull RectF dst) { 1212caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck save(); 1213caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck translate(dst.left, dst.top); 1214caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (picture.getWidth() > 0 && picture.getHeight() > 0) { 12151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck scale(dst.width() / picture.getWidth(), dst.height() / picture.getHeight()); 1216caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1217caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck drawPicture(picture); 1218caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restore(); 12199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1222caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw the picture, stretched to fit into the dst rectangle. 12239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 12241ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPicture(@NonNull Picture picture, @NonNull Rect dst) { 1225caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck save(); 1226caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck translate(dst.left, dst.top); 1227caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (picture.getWidth() > 0 && picture.getHeight() > 0) { 12281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck scale((float) dst.width() / picture.getWidth(), 12291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck (float) dst.height() / picture.getHeight()); 1230caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1231caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck drawPicture(picture); 1232caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck restore(); 12339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1235caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public enum VertexMode { 1236caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLES(0), 1237caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLE_STRIP(1), 1238caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck TRIANGLE_FAN(2); 1239caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1240caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck VertexMode(int nativeInt) { 1241caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck this.nativeInt = nativeInt; 1242caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1243caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1244caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1245caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1246caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1247caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public final int nativeInt; 12489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1251caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Releases the resources associated with this canvas. 12529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1253caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1255caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void release() { 1256caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mNativeCanvasWrapper = 0; 1257caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck if (mFinalizer != null) { 1258caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mFinalizer.run(); 1259caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck mFinalizer = null; 1260caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 12619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1262051910b9f998030dacb8a0722588cc715813fde1Raph Levien 12639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1264caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Free up as much memory as possible from private caches (e.g. fonts, images) 12659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1266caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1268caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public static void freeCaches() { 1269caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nFreeCaches(); 127095d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 12719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1273caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Free up text layout caches 1274caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1275caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 12769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1277caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public static void freeTextLayoutCaches() { 1278caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck nFreeTextLayoutCaches(); 12799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 12809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 12817717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev /** @hide */ 12827b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger public static void setCompatibilityVersion(int apiLevel) { 12837b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger sCompatiblityVersion = apiLevel; 12847b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger nSetCompatibilityVersion(apiLevel); 12857b837616ae88cbdaf12600cee23b5188e5531937Derek Sollenberger } 12867717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev 1287caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nFreeCaches(); 1288caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nFreeTextLayoutCaches(); 1289caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native long nInitRaster(Bitmap bitmap); 1290caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native long nGetNativeFinalizer(); 12917717e22c85fd2eaba39f1dc38c65fb7f723882f4Stan Iliev private static native void nSetCompatibilityVersion(int apiLevel); 1292caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1293caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck // ---------------- @FastNative ------------------- 1294caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1295caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @FastNative 1296bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetBitmap(long canvasHandle, Bitmap bitmap); 1297bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1298caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @FastNative 1299bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nGetClipBounds(long nativeCanvas, Rect bounds); 1300bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1301bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // ---------------- @CriticalNative ------------------- 1302bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1303bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1304caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native boolean nIsOpaque(long canvasHandle); 1305bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1306caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetWidth(long canvasHandle); 1307bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1308caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetHeight(long canvasHandle); 1309caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1310bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1311caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nSave(long canvasHandle, int saveFlags); 1312bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1313bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native int nSaveLayer(long nativeCanvas, float l, float t, float r, float b, 1314bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik long nativePaint, int layerFlags); 1315bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1316bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native int nSaveLayerAlpha(long nativeCanvas, float l, float t, float r, float b, 1317bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik int alpha, int layerFlags); 1318bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1319bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nRestore(long canvasHandle); 1320bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1321bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nRestoreToCount(long canvasHandle, int saveCount); 1322bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1323caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native int nGetSaveCount(long canvasHandle); 1324caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1325bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1326bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nTranslate(long canvasHandle, float dx, float dy); 1327bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1328bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nScale(long canvasHandle, float sx, float sy); 1329bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1330caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native void nRotate(long canvasHandle, float degrees); 1331bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1332bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSkew(long canvasHandle, float sx, float sy); 1333bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1334bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nConcat(long nativeCanvas, long nativeMatrix); 1335bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1336bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetMatrix(long nativeCanvas, long nativeMatrix); 1337bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1338caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck private static native boolean nClipRect(long nativeCanvas, 1339bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik float left, float top, float right, float bottom, int regionOp); 1340bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1341bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nClipPath(long nativeCanvas, long nativePath, int regionOp); 1342bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1343bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nSetDrawFilter(long nativeCanvas, long nativeFilter); 1344bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1345bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native void nGetMatrix(long nativeCanvas, long nativeMatrix); 1346bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1347bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nQuickReject(long nativeCanvas, long nativePath); 1348bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik @CriticalNative 1349bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik private static native boolean nQuickReject(long nativeCanvas, float left, float top, 1350bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik float right, float bottom); 1351bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1352bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik 1353bfa0b29883d56edfc2ec217962290d3c94f9fc2aChris Craik // ---------------- Draw Methods ------------------- 1354caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 13559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 13561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13571ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified arc, which will be scaled to fit inside the specified oval. 13581ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13591ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the start angle is negative or >= 360, the start angle is treated as start angle modulo 13611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 360. 13621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs 13651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is 13661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * negative, the sweep angle is treated as sweep angle modulo 360 13671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 13701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * degrees (3 o'clock on a watch.) 13711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1372caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 13731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param oval The bounds of oval used to define the shape and size of the arc 1374caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startAngle Starting angle (in degrees) where the arc begins 1375caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param sweepAngle Sweep angle (in degrees) measured clockwise 13761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param useCenter If true, include the center of the oval in the arc, and close it if it is 13771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * being stroked. This will draw a wedge 13781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the arc 13799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 13801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter, 13811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 13821ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawArc(oval, startAngle, sweepAngle, useCenter, paint); 138395d49149cc7fff87a18449fa661454c1b5ddbd30Florin Malita } 13849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 13859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 13861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified arc, which will be scaled to fit inside the specified oval. 13881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the start angle is negative or >= 360, the start angle is treated as start angle modulo 13911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 360. 13921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the sweep angle is >= 360, then the oval is drawn completely. Note that this differs 13951ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * slightly from SkPath::arcTo, which treats the sweep angle modulo 360. If the sweep angle is 13961ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * negative, the sweep angle is treated as sweep angle modulo 360 13971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 13981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 13991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The arc is drawn clockwise. An angle of 0 degrees correspond to the geometric angle of 0 14001ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * degrees (3 o'clock on a watch.) 14011ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1402caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1403caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startAngle Starting angle (in degrees) where the arc begins 1404caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param sweepAngle Sweep angle (in degrees) measured clockwise 14051ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param useCenter If true, include the center of the oval in the arc, and close it if it is 14061ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * being stroked. This will draw a wedge 14071ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the arc 14089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 14091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawArc(float left, float top, float right, float bottom, float startAngle, 14101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck float sweepAngle, boolean useCenter, @NonNull Paint paint) { 14111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawArc(left, top, right, bottom, startAngle, sweepAngle, useCenter, paint); 14129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB 14161ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * color, using srcover porterduff mode. 14179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1418caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param a alpha component (0..255) of the color to draw onto the canvas 1419caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param r red component (0..255) of the color to draw onto the canvas 1420caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param g green component (0..255) of the color to draw onto the canvas 1421caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param b blue component (0..255) of the color to draw onto the canvas 14229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1423caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawARGB(int a, int r, int g, int b) { 1424caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawARGB(a, r, g, b); 14259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, with its top/left corner at (x,y), using the specified paint, 14291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * transformed by the current matrix. 14301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14311ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14321ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * If the bitmap and canvas have different densities, this function will take care of 14371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * automatically scaling the bitmap to draw at the same density as the canvas. 1438051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to be drawn 14401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param left The position of the left side of the bitmap being drawn 14411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param top The position of the top side of the bitmap being drawn 14421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the bitmap (may be null) 14439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1444ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) { 1445caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(bitmap, left, top, paint); 14469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 14479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, scaling/translating automatically to fill the destination 14501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to 14511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * draw. 14521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14571ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14581ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This function <em>ignores the density associated with the bitmap</em>. This is because the 14591ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * source and destination rectangle coordinate spaces are in their respective densities, so must 14601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * already have the appropriate scaling factor applied. 1461051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bitmap The bitmap to be drawn 14631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param src May be null. The subset of the bitmap to be drawn 14641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param dst The rectangle that the bitmap will be scaled/translated to fit into 14651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 14669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 14671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawBitmap(@NonNull Bitmap bitmap, @Nullable Rect src, @NonNull RectF dst, 14681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @Nullable Paint paint) { 14691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawBitmap(bitmap, src, dst, paint); 1470caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 14719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 14729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 14731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified bitmap, scaling/translating automatically to fill the destination 14741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * rectangle. If the source rectangle is not null, it specifies the subset of the bitmap to 14751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * draw. 14761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note: if the paint contains a maskfilter that generates a mask which extends beyond the 14781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap's original width/height (e.g. BlurMaskFilter), then the bitmap will be drawn as if it 14791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * were in a Shader with CLAMP mode. Thus the color outside of the original width/height will be 14801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the edge color replicated. 14811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 14821ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This function <em>ignores the density associated with the bitmap</em>. This is because the 14831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * source and destination rectangle coordinate spaces are in their respective densities, so must 14841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * already have the appropriate scaling factor applied. 1485051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 14869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to be drawn 14871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param src May be null. The subset of the bitmap to be drawn 14881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param dst The rectangle that the bitmap will be scaled/translated to fit into 14891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 14909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1491ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull Bitmap bitmap, @Nullable Rect src, @NonNull Rect dst, 1492ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Nullable Paint paint) { 1493caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(bitmap, src, dst, paint); 1494caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1495caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1496caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 14971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Treat the specified array of colors as a bitmap, and draw it. This gives the same result as 14981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * first creating a bitmap from the array, and then drawing it, but this method avoids 14991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly creating a bitmap object which can be more efficient if the colors are changing 15001ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * often. 15019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 15029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param colors Array of colors representing the pixels of the bitmap 15039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param offset Offset into the array of colors for the first pixel 15041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param stride The number of colors in the array between rows (must be >= width or <= -width). 15059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param x The X coordinate for where to draw the bitmap 15069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param y The Y coordinate for where to draw the bitmap 15079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param width The width of the bitmap 15089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param height The height of the bitmap 15091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hasAlpha True if the alpha channel of the colors contains valid values. If false, the 15101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * alpha byte is ignored (assumed to be 0xFF for every pixel). 15111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 1512cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * @deprecated Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas 15131ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * requires an internal copy of color buffer contents every time this method is 15141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * called. Using a Bitmap avoids this copy, and allows the application to more 15151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly control the lifetime and copies of pixel data. 15169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1517cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik @Deprecated 1518ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull int[] colors, int offset, int stride, float x, float y, 1519ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese int width, int height, boolean hasAlpha, @Nullable Paint paint) { 1520caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint); 15219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1522cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik 1523cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik /** 1524cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * Legacy version of drawBitmap(int[] colors, ...) that took ints for x,y 1525cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * 1526cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik * @deprecated Usage with a {@link #isHardwareAccelerated() hardware accelerated} canvas 15271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * requires an internal copy of color buffer contents every time this method is 15281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * called. Using a Bitmap avoids this copy, and allows the application to more 15291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * explicitly control the lifetime and copies of pixel data. 15309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1531cd23df6a08cf7a9bdee11e703f40bca5904d779dChris Craik @Deprecated 1532ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmap(@NonNull int[] colors, int offset, int stride, int x, int y, 1533ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese int width, int height, boolean hasAlpha, @Nullable Paint paint) { 1534caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmap(colors, offset, stride, x, y, width, height, hasAlpha, paint); 15359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1536051910b9f998030dacb8a0722588cc715813fde1Raph Levien 15379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 15381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the bitmap using the specified matrix. 15391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * 15401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bitmap The bitmap to draw 15411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param matrix The matrix used to transform the bitmap when it is drawn 15421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 15431ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck */ 15441ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) { 15451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawBitmap(bitmap, matrix, paint); 15461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck } 15471ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck 15481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck /** 15491ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the bitmap through the mesh, where mesh vertices are evenly distributed across the 15501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * bitmap. There are meshWidth+1 vertices across, and meshHeight+1 vertices down. The verts 15511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array is accessed in row-major order, so that the first meshWidth+1 vertices are distributed 15521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * across the top of the bitmap from left to right. A more general version of this method is 15531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawVertices(). 15549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1555322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * Prior to API level {@value Build.VERSION_CODES#P} vertOffset and colorOffset were ignored, 1556322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * effectively treating them as zeros. In API level {@value Build.VERSION_CODES#P} and above 1557322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * these parameters will be respected. 1558322bc57a338ec650347084ef379860c19b29d1b4Mike Reed * 15599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param bitmap The bitmap to draw using the mesh 15601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param meshWidth The number of columns in the mesh. Nothing is drawn if this is 0 15611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param meshHeight The number of rows in the mesh. Nothing is drawn if this is 0 15621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param verts Array of x,y pairs, specifying where the mesh should be drawn. There must be at 15631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * least (meshWidth+1) * (meshHeight+1) * 2 + vertOffset values in the array 15649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param vertOffset Number of verts elements to skip before drawing 15651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param colors May be null. Specifies a color at each vertex, which is interpolated across the 15661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * cell, and whose values are multiplied by the corresponding bitmap colors. If not 15671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * null, there must be at least (meshWidth+1) * (meshHeight+1) + colorOffset values 15681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * in the array. 15699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param colorOffset Number of color elements to skip before drawing 15701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint May be null. The paint used to draw the bitmap 15719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1572ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawBitmapMesh(@NonNull Bitmap bitmap, int meshWidth, int meshHeight, 1573ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull float[] verts, int vertOffset, @Nullable int[] colors, int colorOffset, 1574ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @Nullable Paint paint) { 1575caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawBitmapMesh(bitmap, meshWidth, meshHeight, verts, vertOffset, colors, colorOffset, 1576caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck paint); 15779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1578051910b9f998030dacb8a0722588cc715813fde1Raph Levien 15799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 15801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified circle using the specified paint. If radius is <= 0, then nothing will be 15811ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawn. The circle will be filled or framed based on the Style in the paint. 15829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 15831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param cx The x-coordinate of the center of the cirle to be drawn 15841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param cy The y-coordinate of the center of the cirle to be drawn 1585caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param radius The radius of the cirle to be drawn 15861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the circle 15879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1588caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint) { 1589caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawCircle(cx, cy, radius, paint); 15909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 159136bef0bf30d6bae48cf3837df351075ca4fce654Ashok Bhat 15929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 15931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified color, 15941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * using srcover porterduff mode. 15959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1596caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param color the color to draw onto the canvas 15979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1598caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawColor(@ColorInt int color) { 1599caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawColor(color); 16009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 16019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified color and 16041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * porter-duff xfermode. 16059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 1606caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param color the color to draw with 16071ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param mode the porter-duff mode to apply to the color 16089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1609caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawColor(@ColorInt int color, @NonNull PorterDuff.Mode mode) { 1610caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawColor(color, mode); 1611f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 16129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a line segment with the specified start and stop x,y coordinates, using the specified 16151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint. 16161ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 16171ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Note that since a line is always "framed", the Style is ignored in the paint. 16181ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 16191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 16201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Degenerate lines (length is 0) will not be drawn. 16211ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * </p> 1622caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1623caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startX The x-coordinate of the start point of the line 1624caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param startY The y-coordinate of the start point of the line 16251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the line 16269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1627caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawLine(float startX, float startY, float stopX, float stopY, 1628ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1629caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLine(startX, startY, stopX, stopY, paint); 16309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 16319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 16329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 16331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a series of lines. Each line is taken from 4 consecutive values in the pts array. Thus 16341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * to draw 1 line, the array must contain at least 4 values. This is logically the same as 16351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * drawing the array as follows: drawLine(pts[0], pts[1], pts[2], pts[3]) followed by 1636caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * drawLine(pts[4], pts[5], pts[6], pts[7]) and so on. 16379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 16381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...] 16391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param offset Number of values in the array to skip before drawing. 16401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of values in the array to process, after skipping "offset" of them. 16411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Since each line uses 4 values, the number of "lines" that are drawn is really 16421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * (count >> 2). 16431ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the points 16449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 16451ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawLines(@Size(multiple = 4) @NonNull float[] pts, int offset, int count, 1646ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1647caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLines(pts, offset, count, paint); 1648caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1649caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 16501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawLines(@Size(multiple = 4) @NonNull float[] pts, @NonNull Paint paint) { 1651caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawLines(pts, paint); 1652f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 1653f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1654f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt /** 16551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified oval using the specified paint. The oval will be filled or framed based on 16561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 1657caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1658caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param oval The rectangle bounds of the oval to be drawn 1659caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1660caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawOval(@NonNull RectF oval, @NonNull Paint paint) { 1661caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawOval(oval, paint); 1662f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt } 1663f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1664f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt /** 16651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified oval using the specified paint. The oval will be filled or framed based on 16661ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 16671ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck */ 16681ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawOval(float left, float top, float right, float bottom, @NonNull Paint paint) { 16691ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawOval(left, top, right, bottom, paint); 16701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck } 16711ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck 16721ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck /** 16731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified paint. 16741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * This is equivalent (but faster) to drawing an infinitely large rectangle with the specified 16751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint. 1676c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1677caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw onto the canvas 1678caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1679caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPaint(@NonNull Paint paint) { 1680caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPaint(paint); 1681caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1682caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1683caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1684caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draws the specified bitmap as an N-patch (most often, a 9-patches.) 1685c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1686caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param patch The ninepatch object to render 1687caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param dst The destination rectangle. 1688caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint to draw the bitmap with. may be null 1689caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1690caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1691caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPatch(@NonNull NinePatch patch, @NonNull Rect dst, @Nullable Paint paint) { 1692caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPatch(patch, dst, paint); 1693caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1694caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1695caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1696caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draws the specified bitmap as an N-patch (most often, a 9-patches.) 1697c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 1698caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param patch The ninepatch object to render 1699caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param dst The destination rectangle. 1700caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint to draw the bitmap with. may be null 1701caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @hide 1702caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1703caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPatch(@NonNull NinePatch patch, @NonNull RectF dst, @Nullable Paint paint) { 1704caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPatch(patch, dst, paint); 1705caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1706caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1707caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified path using the specified paint. The path will be filled or framed based on 17091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the Style in the paint. 1710c6abf5bff6bbfafa1f133644f02a5d50d5269b7fRaph Levien * 17111ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path to be drawn 1712caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the path 1713f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt */ 1714caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPath(@NonNull Path path, @NonNull Paint paint) { 1715caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPath(path, paint); 1716caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1717f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1718caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1719caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Helper for drawPoints() for drawing a single point. 1720caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1721caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawPoint(float x, float y, @NonNull Paint paint) { 1722caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoint(x, y, paint); 1723caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1724f47d7405bbcb25d7cdf89ebb059f41520fe9ab87Doug Felt 1725caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw a series of points. Each point is centered at the coordinate specified by pts[], and its 17271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * diameter is specified by the paint's stroke width (as transformed by the canvas' CTM), with 17281ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * special treatment for a stroke width of 0, which always draws exactly 1 pixel (or at most 4 17291ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * if antialiasing is enabled). The shape of the point is controlled by the paint's Cap type. 17301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The shape is a square, unless the cap type is Round, in which case the shape is a circle. 1731caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 17321ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pts Array of points to draw [x0 y0 x1 y1 x2 y2 ...] 17331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param offset Number of values to skip before starting to draw. 17341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of values to process, after skipping offset of them. Since one point 17351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * uses two values, the number of "points" that are drawn is really (count >> 1). 17361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the points 1737caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 17381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPoints(@Size(multiple = 2) float[] pts, int offset, int count, 1739caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1740caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoints(pts, offset, count, paint); 1741caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1742caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1743caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 1744caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Helper for drawPoints() that assumes you want to draw the entire array 1745caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 17461ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPoints(@Size(multiple = 2) @NonNull float[] pts, @NonNull Paint paint) { 1747caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPoints(pts, paint); 17489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 17499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 17509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 17511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text in the array, with each character's origin specified by the pos array. 1752eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 17531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 17541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param index The index of the first character to draw 17551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param count The number of characters to draw, starting from index. 17561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pos Array of [x,y] positions, used to position each character 17571ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 17581ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @deprecated This method does not support glyph composition and decomposition and should 17591ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * therefore not be used to render complex scripts. It also doesn't handle 17601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * supplementary characters (eg emoji). 17619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1762f9d9c065ed75f1196316a9a31f92309f602cef76Romain Guy @Deprecated 1763b3ec733bb830f2d4425825d93f9ed95f284e9145Tor Norbye public void drawPosText(@NonNull char[] text, int index, int count, 17641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull @Size(multiple = 2) float[] pos, 1765ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese @NonNull Paint paint) { 1766caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPosText(text, index, count, pos, paint); 1767caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1768caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1769caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17701ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text in the array, with each character's origin specified by the pos array. 1771caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 17721ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 17731ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param pos Array of [x,y] positions, used to position each character 1774caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 17751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @deprecated This method does not support glyph composition and decomposition and should 17761ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * therefore not be used to render complex scripts. It also doesn't handle 17771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * supplementary characters (eg emoji). 1778caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1779caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @Deprecated 17801ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawPosText(@NonNull String text, @NonNull @Size(multiple = 2) float[] pos, 1781caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1782caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawPosText(text, pos, paint); 1783caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1784caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1785caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 17861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified Rect using the specified paint. The rectangle will be filled or framed 17871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Style in the paint. 1788caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 17891ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rect The rect to be drawn 17901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the rect 1791caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 17921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRect(@NonNull RectF rect, @NonNull Paint paint) { 17931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRect(rect, 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 r The rectangle to be drawn. 18011ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used to draw the rectangle 1802caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1803caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawRect(@NonNull Rect r, @NonNull Paint paint) { 1804caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawRect(r, 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 left The left side of the rectangle to be drawn 18121ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param top The top side of the rectangle to be drawn 18131ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param right The right side of the rectangle to be drawn 18141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param bottom The bottom side of the rectangle to be drawn 1815caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the rect 1816caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18171ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) { 18181ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRect(left, top, right, bottom, paint); 1819caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1820caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1821caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color, 18231ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * using srcover porterduff mode. 1824caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1825caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param r red component (0..255) of the color to draw onto the canvas 1826caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param g green component (0..255) of the color to draw onto the canvas 1827caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param b blue component (0..255) of the color to draw onto the canvas 1828caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1829caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawRGB(int r, int g, int b) { 1830caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawRGB(r, g, b); 1831caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1832caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1833caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified round-rect using the specified paint. The roundrect will be filled or 18351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * framed based on the Style in the paint. 1836caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rect The rectangular bounds of the roundRect to be drawn 18381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rx The x-radius of the oval used to round the corners 18391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param ry The y-radius of the oval used to round the corners 1840caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the roundRect 1841caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18421ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRoundRect(@NonNull RectF rect, float rx, float ry, @NonNull Paint paint) { 18431ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRoundRect(rect, rx, ry, paint); 1844caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1845caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1846caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18471ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified round-rect using the specified paint. The roundrect will be filled or 18481ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * framed based on the Style in the paint. 1849caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18501ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param rx The x-radius of the oval used to round the corners 18511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param ry The y-radius of the oval used to round the corners 1852caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used to draw the roundRect 1853caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry, 18551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 18561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawRoundRect(left, top, right, bottom, rx, ry, paint); 1857caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1858caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1859caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18601ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18611ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1862caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 18641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 18651ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 1866caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 1867caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 1868caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawText(@NonNull char[] text, int index, int count, float x, float y, 1869caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 1870caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawText(text, index, count, x, y, paint); 1871caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1872caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1873caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 18741ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18751ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1876caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 18771ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 18781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 18791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 1880caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 1881caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18821ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull String text, float x, float y, @NonNull Paint paint) { 18831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawText(text, x, y, paint); 18849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 18859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 18869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 18871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint. The origin is interpreted 18881ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * based on the Align setting in the paint. 1889051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 18901ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 18911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param start The index of the first character in text to draw 18921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end (end - 1) is the index of the last character in text to draw 18931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of the origin of the text being drawn 18941ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of the baseline of the text being drawn 18959066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * @param paint The paint used for the text (e.g. color, size, style) 1896caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck */ 18971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull String text, int start, int end, float x, float y, 18981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck @NonNull Paint paint) { 18991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck super.drawText(text, start, end, x, y, paint); 1900caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 1901caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck 1902caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck /** 19031ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the specified range of text, specified by start/end, with its origin at (x,y), in the 19041ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * specified Paint. The origin is interpreted based on the Align setting in the Paint. 1905eda57925cafdf1dab451e70052dea27846f368b4Chris Craik * 19061ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 1907caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param start The index of the first character in text to draw 19081ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end (end - 1) is the index of the last character in text to draw 19091ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param x The x-coordinate of origin for where to draw the text 19101ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param y The y-coordinate of origin for where to draw the text 1911caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint The paint used for the text (e.g. color, size, style) 19129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 19131ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck public void drawText(@NonNull CharSequence text, int start, int end, float x, float y, 1914b3ec733bb830f2d4425825d93f9ed95f284e9145Tor Norbye @NonNull Paint paint) { 1915caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawText(text, start, end, x, y, paint); 19169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 19191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint, along the specified path. The 19201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint's Align setting determins where along the path to start the text. 19219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 19221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 19231ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path the text should follow for its baseline 19241ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hOffset The distance along the path to add to the text's starting position 19251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vOffset The distance above(-) or below(+) the path to position the text 19261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 19279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1928ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawTextOnPath(@NonNull char[] text, int index, int count, @NonNull Path path, 1929ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese float hOffset, float vOffset, @NonNull Paint paint) { 1930caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextOnPath(text, index, count, path, hOffset, vOffset, paint); 19319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 19341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the text, with origin at (x,y), using the specified paint, along the specified path. The 19351ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * paint's Align setting determins where along the path to start the text. 19369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 19371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param text The text to be drawn 19381ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param path The path the text should follow for its baseline 19391ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param hOffset The distance along the path to add to the text's starting position 19401ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vOffset The distance above(-) or below(+) the path to position the text 19411ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param paint The paint used for the text (e.g. color, size, style) 19429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1943ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese public void drawTextOnPath(@NonNull String text, @NonNull Path path, float hOffset, 1944ff7215aa0cb28a4815126b056f34b2bd29e5c651Antonio Calabrese float vOffset, @NonNull Paint paint) { 1945caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextOnPath(text, path, hOffset, vOffset, paint); 19469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 19479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 19489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /** 1949caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw a run of text, all in a single direction, with optional context for complex text 1950caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * shaping. 19511ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19521ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * See {@link #drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)} for 19531ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * more details. This method uses a character array rather than CharSequence to represent the 19541ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * string. Also, to be consistent with the pattern established in {@link #drawText}, in this 19551ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * method {@code count} and {@code contextCount} are used rather than offsets of the end 19561ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * position; {@code count = end - start, contextCount = contextEnd - 1957caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * contextStart}. 1958051910b9f998030dacb8a0722588cc715813fde1Raph Levien * 1959caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param text the text to render 1960caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param index the start of the text to render 1961caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param count the count of chars to render 19621ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param contextIndex the start of the context for shaping. Must be no greater than index. 19631ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param contextCount the number of characters in the context for shaping. contexIndex + 19641ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * contextCount must be no less than index + count. 1965caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param x the x position at which to draw the text 1966caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param y the y position at which to draw the text 1967caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param isRtl whether the run is in RTL direction 1968caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint the paint 19699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1970caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawTextRun(@NonNull char[] text, int index, int count, int contextIndex, 1971caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int contextCount, float x, float y, boolean isRtl, @NonNull Paint paint) { 1972caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextRun(text, index, count, contextIndex, contextCount, x, y, isRtl, paint); 19739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1974da8532c6f48b4c10b5e2ccb9e08690341efa1616Romain Guy 1975da8532c6f48b4c10b5e2ccb9e08690341efa1616Romain Guy /** 1976caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Draw a run of text, all in a single direction, with optional context for complex text 1977caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * shaping. 19781ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19791ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The run of text includes the characters from {@code start} to {@code end} in the text. In 1980caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * addition, the range {@code contextStart} to {@code contextEnd} is used as context for the 1981caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * purpose of complex text shaping, such as Arabic text potentially shaped differently based on 1982caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * the text next to it. 19831ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19841ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * All text outside the range {@code contextStart..contextEnd} is ignored. The text between 1985caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * {@code start} and {@code end} will be laid out and drawn. 19861ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19871ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * The direction of the run is explicitly specified by {@code isRtl}. Thus, this method is 1988caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * suitable only for runs of a single direction. Alignment of the text is as determined by the 1989caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * Paint's TextAlign value. Further, {@code 0 <= contextStart <= start <= end <= contextEnd 1990caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * <= text.length} must hold on entry. 19911ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * <p> 19921ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Also see {@link android.graphics.Paint#getRunAdvance} for a corresponding method to measure 19931ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * the text; the advance width of the text drawn matches the value obtained from that method. 1994caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * 1995caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param text the text to render 19961ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param start the start of the text to render. Data before this position can be used for 19971ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shaping context. 19981ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param end the end of the text to render. Data at or after this position can be used for 19991ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shaping context. 2000caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param contextStart the index of the start of the shaping context 2001caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param contextEnd the index of the end of the shaping context 2002caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param x the x position at which to draw the text 2003caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param y the y position at which to draw the text 2004caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param isRtl whether the run is in RTL direction 2005caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint the paint 2006caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @see #drawTextRun(char[], int, int, int, int, float, float, boolean, Paint) 2007caf0df1b7f99736aed1a0b923ef278fc4fd0fccaMike Reed */ 2008caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawTextRun(@NonNull CharSequence text, int start, int end, int contextStart, 2009caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int contextEnd, float x, float y, boolean isRtl, @NonNull Paint paint) { 2010caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawTextRun(text, start, end, contextStart, contextEnd, x, y, isRtl, paint); 2011caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 2012caf0df1b7f99736aed1a0b923ef278fc4fd0fccaMike Reed 201330ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio /** 20141ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * Draw the array of vertices, interpreted as triangles (based on mode). The verts array is 20151ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * required, and specifies the x,y pairs for each vertex. If texs is non-null, then it is used 20161ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * to specify the coordinate in shader coordinates to use at each vertex (the paint must have a 20171ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shader in this case). If there is no texs array, but there is a color array, then each color 20181ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * is interpolated across its corresponding triangle in a gradient. If both texs and colors 20191ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * arrays are present, then they behave as before, but the resulting color at each pixels is the 20201ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * result of multiplying the colors from the shader and the color-gradient together. The indices 20211ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array is optional, but if it is present, then it is used to specify the index of each 20221ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * triangle, rather than just walking through the arrays in order. 202330ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio * 2024caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param mode How to interpret the array of vertices 20251ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param vertexCount The number of values in the vertices array (and corresponding texs and 20261ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * colors arrays if non-null). Each logical vertex is two values (x, y), vertexCount 20271ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * must be a multiple of 2. 2028caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param verts Array of vertices for the mesh 2029caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param vertOffset Number of values in the verts to skip before drawing. 20301ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param texs May be null. If not null, specifies the coordinates to sample into the current 20311ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * shader (e.g. bitmap tile or gradient) 2032caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param texOffset Number of values in texs to skip before drawing. 20331ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param colors May be null. If not null, specifies a color for each vertex, to be interpolated 20341ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * across the triangle. 2035caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param colorOffset Number of values in colors to skip before drawing. 20361ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * @param indices If not null, array of indices to reference into the vertex (texs, colors) 20371ece145e018a7e66d3f422e647d3f6cb1887dca5John Reck * array. 2038caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param indexCount number of entries in the indices array (if not null). 2039caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck * @param paint Specifies the shader to use if the texs array is non-null. 204030ca5cd11a23f06f2f8eeaa587685450826f800fFabrice Di Meglio */ 2041caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck public void drawVertices(@NonNull VertexMode mode, int vertexCount, @NonNull float[] verts, 2042caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int vertOffset, @Nullable float[] texs, int texOffset, @Nullable int[] colors, 2043caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck int colorOffset, @Nullable short[] indices, int indexOffset, int indexCount, 2044caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck @NonNull Paint paint) { 2045caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck super.drawVertices(mode, vertexCount, verts, vertOffset, texs, texOffset, 2046caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck colors, colorOffset, indices, indexOffset, indexCount, paint); 2047caa08ff5e9ee004634a95776fc72bb769f1286deJohn Reck } 20489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 2049