Introduction de cette section :

Dans les deux sous-sections précédentes, nous avons découvert Drawable et Bitmap, qui impliquent tous deux le chargement d'images prêtes à l'emploi. Dans cette section, nous allons apprendre quelques API liées au dessin : Canvas, Paint et Path ! Cette section est très importante, et elle constitue également la base des vues personnalisées. Bon, sans plus tarder, commençons cette section.

Documentation officielle de l'API :Canvas;Paint;Path;


1. Explication détaillée des méthodes associées


1) Paint (pinceau) :

C'est le pinceau, utilisé pour définir le style de dessin, comme la largeur de ligne (épaisseur du trait), la couleur, la transparence et le style de remplissage. Vous pouvez créer une instance de Paint directement à l'aide du constructeur sans paramètre :Paint paint = new Paint( );

Nous pouvons définir les propriétés pertinentes de Paint via les méthodes suivantes. De plus, ces propriétés se répartissent en deux catégories : liées au dessin et liées au texte :

  • setARGB(int a,int r,int g,int b) : Définit la couleur de dessin ; a représente la transparence alpha, et r, g, b représentent les valeurs de couleur.
  • setAlpha(int a) : Définit la transparence de la forme dessinée.
  • setColor(int color) : Définit la couleur de dessin, exprimée sous forme de valeur de couleur, qui inclut la composante alpha et la couleur RGB.
  • setAntiAlias(boolean aa) : Définit s'il faut utiliser l'anticrénelage. Cela consomme plus de ressources et ralentit la vitesse de dessin.
  • setDither(boolean dither) : Définir s'il faut utiliser le tramage d'image. Cela rend les couleurs de l'image dessinée plus lisses et plus riches, et l'image plus nette.
  • setFilterBitmap(boolean filter) : Si défini sur true, l'image ignorera les opérations d'optimisation sur les images Bitmap pendant l'animation, ce qui accélère l'affichage. Ce paramètre dépend des réglages dither et xfermode.
  • setMaskFilter(MaskFilter maskfilter) : Définir MaskFilter. Différents MaskFilter peuvent être utilisés pour obtenir des effets de filtre, tels que le flou, la 3D, etc.
  • setColorFilter(ColorFilter colorfilter) : Définir le filtre de couleur, qui peut produire différents effets de transformation des couleurs lors du dessin des couleurs.
  • setPathEffect(PathEffect effect) : Définir l'effet pour le dessin des tracés, comme les lignes pointillées, etc.
  • setShader(Shader shader) : Définir l'effet d'image. L'utilisation de Shader permet de dessiner divers effets de dégradé.
  • setShadowLayer(float radius ,float dx,float dy,int color) : Définir une couche d'ombre sous la forme pour produire un effet d'ombre ; radius est l'angle de l'ombre, dx et dy sont les distances de l'ombre sur l'axe des x et l'axe des y, et color est la couleur de l'ombre.
  • setStyle(Paint.Style style) : Définir le style de pinceau sur FILL, FILL_OR_STROKE ou STROKE.
  • setStrokeCap(Paint.Cap cap) : Lorsque le style de pinceau est STROKE ou FILL_OR_STROKE, définir le style graphique du pinceau, tel que l'extrémité ronde Cap.ROUND ou carrée Cap.SQUARE.
  • setSrokeJoin(Paint.Join join) : Définir comment les formes sont jointes lors du dessin, comme les effets lisses, etc.
  • setStrokeWidth(float width) : Lorsque le style de pinceau est STROKE ou FILL_OR_STROKE, définir l'épaisseur du pinceau.
  • setXfermode(Xfermode xfermode) : Définir le mode de gestion lorsque les formes se chevauchent, comme la fusion, l'intersection ou l'union. Il est souvent utilisé pour créer des effets de gomme.
  • setFakeBoldText(boolean fakeBoldText) : Simule un texte en gras. L'effet sera très médiocre lorsqu'il est appliqué à de petites polices.
  • setSubpixelText(boolean subpixelText) : Définir ceci sur true améliorera l'effet d'affichage du texte sur les écrans LCD.
  • setTextAlign(Paint.Align align) : Définit la direction d'alignement pour le dessin du texte.
  • setTextScaleX(float scaleX) : Définit le rapport d'échelle de l'axe des x pour le dessin du texte, ce qui permet d'obtenir un effet d'étirement du texte.
  • setTextSize(float textSize) : Définit la taille de police pour le dessin du texte.
  • setTextSkewX(float skewX) : Définit un texte en italique ; skewX est l'angle d'inclinaison en radians.
  • setTypeface(Typeface typeface) : Définit l'objet Typeface, c'est-à-dire le style de police, incluant gras, italique, serif, sans-serif, etc.
  • setUnderlineText(boolean underlineText) : Définit un effet de texte avec un soulignement.
  • setStrikeThruText(boolean strikeThruText) : Définit un effet barré.
  • setStrokeJoin(Paint.Join join) : Définit l'apparence des jointures. Miter : jointure vive ; Round : jointure en arc ; BEVEL : jointure droite.
  • setStrokeMiter(float miter) : Définit l'inclinaison du pinceau.
  • setStrokeCap(Paint.Cap cap) : Définit le style aux coins/virages. Autres méthodes courantes :
  • float ascent( ) : Mesure la distance au-dessus de la ligne de base jusqu'au haut du caractère.
  • float descent( ) : La distance en dessous de la ligne de base jusqu'au bas du caractère.
  • int breakText(char[] text, int index, int count, float maxWidth, float[] measuredWidth) : Détecte la quantité de texte pouvant être affichée sur une ligne.
  • clearShadowLayer( ) : Efface la couche d'ombre. Pour les autres, consultez la documentation vous-même.

2) Canvas :

Maintenant que nous avons le pinceau, passons au Canvas. On ne peut pas dessiner à partir de rien, n'est-ce pas ? Les méthodes courantes sont les suivantes :

D'abord, il y a lesconstructeurs.Canvas a deux constructeurs :

Canvas(): Crée un canvas vide ; vous pouvez utiliser la méthode setBitmap() pour définir le canvas spécifique sur lequel dessiner.

Canvas(Bitmap bitmap): Crée un canvas avec un objet Bitmap ; tout le contenu est dessiné sur le bitmap, donc le bitmap ne doit pas être null.

Ensuite, il y a les1.drawXXX()méthodes de dessin : Elles dessinent sur la zone de dessin actuelle à des valeurs de coordonnées spécifiées. De plus, les couches s'empilent, ce qui signifie que les couches dessinées plus tard recouvrent les précédentes. Par exemple :

  • drawRect(RectF rect, Paint paint) : Dessine une région ; le premier paramètre est une région RectF.
  • drawPath(Path path, Paint paint) : Dessine un chemin ; le premier paramètre est un objet Path.
  • drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) : Dessine un bitmap. Le premier paramètre est notre objet Bitmap habituel, le deuxième est la région source (ici le bitmap), le troisième est la région cible (la position et la taille sur le canevas), et le quatrième est l'objet pinceau Paint. Comme une mise à l'échelle et un étirement peuvent être impliqués, les performances seront considérablement dégradées lorsque le Rect d'origine n'est pas égal au Rect cible.
  • drawLine(float startX, float startY, float stopX, float stopY, Paint paint) : Dessine une ligne. Le premier paramètre est la position sur l'axe x du point de départ, le deuxième est la position sur l'axe y du point de départ, le troisième est la position horizontale sur l'axe x du point d'arrivée, le quatrième est la position verticale sur l'axe y, et le dernier paramètre est l'objet pinceau Paint.
  • drawPoint(float x, float y, Paint paint) : Dessine un point. Le premier paramètre est l'axe horizontal x, le deuxième est l'axe vertical y, et le troisième paramètre est l'objet Paint.
  • drawText(String text, float x, float y, Paint paint) : Affiche du texte. En plus de ce qui précède, la classe Canvas peut également dessiner du texte. Le premier paramètre est un texte String, le deuxième est l'axe x, le troisième est l'axe y, et le quatrième est un objet Paint.
  • drawOval(RectF oval, Paint paint) : Dessine une ellipse. Le premier paramètre est la zone de balayage, et le deuxième est l'objet Paint.
  • drawCircle(float cx, float cy, float radius, Paint paint) : Dessine un cercle. Le premier paramètre est l'axe x du point central, le deuxième est l'axe y du point central, le troisième est le rayon, et le quatrième est l'objet Paint.
  • drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter, Paint paint) : Dessine un arc. Le premier paramètre est un objet RectF, la limite d’un ovale rectangulaire utilisée pour définir la forme et la taille de l’arc. Le deuxième paramètre est l’angle de départ (en degrés) au début de l’arc. Le troisième paramètre est l’angle de balayage (en degrés), mesuré dans le sens horaire à partir du début. Le quatrième paramètre, s’il est true, inclut le centre de l’ovale dans l’arc et le ferme ; s’il est false, ce sera une ligne d’arc. Le cinquième paramètre est l’objet Paint.

2.clipXXX()Famille de méthodes : découper une nouvelle zone de dessin à partir de la zone de dessin actuelle ; cette zone de dessin devient la zone de dessin actuelle de l’objet canvas. Par exemple : clipRect(new Rect()), alors cette zone rectangulaire devient la zone de dessin actuelle du canvas.

3.save()etrestore()Méthode :save( ) : utilisée pour enregistrer l’état du Canvas. Après save, vous pouvez effectuer des opérations telles que la translation, la mise à l’échelle, la rotation, l’inclinaison et le découpage sur le Canvas.restore( ) : utilisée pour restaurer l’état précédemment enregistré du Canvas. Empêche les opérations effectuées sur le Canvas après save d’affecter le dessin suivant. save() et restore() doivent être utilisés par paires (restore peut être moins fréquent que save, mais pas plus). Si restore est appelé plus de fois que save, une erreur sera signalée !

4.translate(float dx, float dy) : translater, en déplaçant l’origine des coordonnées du canvas horizontalement de x et verticalement de y. La position par défaut du canvas est (0,0).

5.scale(float sx, float sy) : mettre à l’échelle, x est le facteur d’agrandissement horizontal, y est le facteur d’agrandissement vertical.

6.rotate(float degrees) : rotation, angle désigne l’angle de rotation, tourne dans le sens horaire.


3) Path

En termes simples, il s’agit de tracer des points et de relier des lignes~ Après avoir créé notre Path, nous pouvons appelerdrawPath(path, paint) de Canvas pour dessiner la forme~ Les méthodes courantes sont les suivantes :

  • addArc(RectF oval, float startAngle, float sweepAngle : Ajoute un polygone au chemin
  • addCircle(float x, float y, float radius, Path.Direction dir) : Ajoute un cercle au chemin
  • addOval(RectF oval, Path.Direction dir) : Ajoute un ovale
  • addRect(RectF rect, Path.Direction dir) : Ajoute une région
  • addRoundRect(RectF rect, float[] radii, Path.Direction dir) : Ajoute une région aux coins arrondis
  • isEmpty( ) : Détermine si le chemin est vide
  • transform(Matrix matrix) : Applique une transformation matricielle
  • transform(Matrix matrix, Path dst) : Applique une transformation matricielle et place le résultat dans un nouveau chemin, c'est-à-dire le deuxième paramètre.

Pour des effets plus avancés, vous pouvez utiliser la classe PathEffect !

Plusieurs méthodes To :

  • moveTo(float x, float y) : Ne dessine pas ; sert uniquement à déplacer le pinceau.
  • lineTo(float x, float y) : Sert à dessiner des lignes droites. Par défaut, le dessin commence à (0,0) ; utilisez moveTo pour déplacer ! Par exemple : mPath.lineTo(300, 300); canvas.drawPath(mPath, mPaint);
  • quadTo(float x1, float y1, float x2, float y2): Utilisé pour dessiner des courbes lisses, c’est-à-dire des courbes de Bézier. Il peut aussi être utilisé avec moveTo !
  • rCubicTo(float x1, float y1, float x2, float y2, float x3, float y3) Également utilisé pour implémenter des courbes de Bézier. (x1,y1) est un point de contrôle, (x2,y2) est un point de contrôle, (x3,y3) est le point d’arrivée. Identique à cubicTo, mais les coordonnées sont considérées comme relatives au point courant sur ce contour. C’est juste un point de contrôle de plus~ Pour dessiner la courbe ci-dessus : mPath.moveTo(100, 500); mPath.cubicTo(100, 500, 300, 100, 600, 500); Si vous n’ajoutez pas le moveTo ci-dessus, alors en partant de (0,0), avec (100,500) et (300,100) comme points de contrôle, dessinez la courbe de Bézier.
  • arcTo(RectF oval, float startAngle, float sweepAngle): Dessine un arc (en réalité, il intercepte une partie d’un cercle ou d’une ellipse). ovalRectF est le rectangle de l’ellipse, startAngle est l’angle de départ, sweepAngle est l’angle de fin.

2. Essayez par vous-même :

Il y a tellement de propriétés ; il faut vraiment mettre la main à la pâte pour renforcer notre impression, non ? Héhé, le dessin se fait soit sur une View, soit sur une SurfaceView. Ici, dessinons sur une View. Nous définissons une classe View, puis nous faisons le travail de dessin dans onDraw() !

/**
 * Created by Jay on 2015/10/15 0015.
 */
public class MyView extends View{

    private Paint mPaint;


    public MyView(Context context) {
        super(context);
        init();
    }

    public MyView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public MyView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init(){
        mPaint = new Paint();
        mPaint.setAntiAlias(true);          //抗锯齿
        mPaint.setColor(getResources().getColor(R.color.puple));//画笔颜色
        mPaint.setStyle(Paint.Style.FILL);  //画笔风格
        mPaint.setTextSize(36);             //绘制文字大小,单位px
        mPaint.setStrokeWidth(5);           //画笔粗细
    }
    
    //重写该方法,在这里绘图
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
    }
    
} 

Ensuite, il suffit de définir cette View dans le layout. Le code suivant est entièrement écrit dans onDraw()~


1) Définir la couleur du canevas :

canvas.drawColor(getResources().getColor(R.color.yellow));   //设置画布背景颜色

2) Dessiner un cercle :

canvas.drawCircle(200, 200, 100, mPaint);           //画实心圆


3) Dessiner un rectangle :

canvas.drawRect(0, 0, 200, 100, mPaint);            //画矩形


4) Dessiner un Bitmap :

canvas.drawBitmap(BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher), 0, 0, mPaint);


5) Dessiner une zone d’arc :

canvas.drawArc(new RectF(0, 0, 100, 100),0,90,true,mPaint);  //绘制弧形区域

Si true est changé en false :


6) Dessiner un rectangle arrondi :

canvas.drawRoundRect(new RectF(10,10,210,110),15,15,mPaint); //画圆角矩形


7) Dessiner une ellipse :

canvas.drawOval(new RectF(0,0,200,300),mPaint); //画椭圆


8) Dessiner un polygone :

Path path = new Path();
path.moveTo(10, 10); //移动到 坐标10,10
path.lineTo(100, 50);
path.lineTo(200,40);
path.lineTo(300, 20);
path.lineTo(200, 10);
path.lineTo(100, 70);
path.lineTo(50, 40);
path.close();
canvas.drawPath(path,mPaint);


9) Dessiner du texte :

canvas.drawText("最喜欢看曹神日狗了~",50,50,mPaint);    //绘制文字

Vous pouvez également dessiner ce texte le long d'un Path :

Path path = new Path();
path.moveTo(50,50);
path.lineTo(100, 100);
path.lineTo(200, 200);
path.lineTo(300, 300);
path.close();
canvas.drawTextOnPath("最喜欢看曹神日狗了~", path, 50, 50, mPaint);    //绘制文字


10) Dessiner une forme personnalisée :

Le code provient d'Internet :

protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    canvas.translate(canvas.getWidth()/2, 200); //将位置移动画纸的坐标点:150,150
    canvas.drawCircle(0, 0, 100, mPaint); //画圆圈

    //使用path绘制路径文字
    canvas.save();
    canvas.translate(-75, -75);
    Path path = new Path();
    path.addArc(new RectF(0,0,150,150), -180, 180);
    Paint citePaint = new Paint(mPaint);
    citePaint.setTextSize(14);
    citePaint.setStrokeWidth(1);
    canvas.drawTextOnPath("绘制表盘~", path, 28, 0, citePaint);
    canvas.restore();

    Paint tmpPaint = new Paint(mPaint); //小刻度画笔对象
    tmpPaint.setStrokeWidth(1);

    float  y=100;
    int count = 60; //总刻度数

    for(int i=0 ; i <count ; i++){
        if(i%5 == 0){
            canvas.drawLine(0f, y, 0, y+12f, mPaint);
            canvas.drawText(String.valueOf(i/5+1), -4f, y+25f, tmpPaint);

        }else{
            canvas.drawLine(0f, y, 0f, y +5f, tmpPaint);
        }
        canvas.rotate(360/count,0f,0f); //旋转画纸
    }

    //绘制指针
    tmpPaint.setColor(Color.GRAY);
    tmpPaint.setStrokeWidth(4);
    canvas.drawCircle(0, 0, 7, tmpPaint);
    tmpPaint.setStyle(Paint.Style.FILL);
    tmpPaint.setColor(Color.YELLOW);
    canvas.drawCircle(0, 0, 5, tmpPaint);
    canvas.drawLine(0, 10, 0, -65, mPaint);
}


Résumé de cette section :

Dans cette section, nous avons étudié trois API de dessin parmi les classes d'interface android.graphics : Canvas (canvas), Paint (brush) et Path (path). Il existe de nombreuses méthodes ; ne les mémorisez pas mécaniquement. Consultez-les simplement lorsque c'est nécessaire. Ici, nous avons seulement besoin d'une impression générale. Nous aborderons les contrôles personnalisés lentement plus tard. Bon, c'est tout. Merci !