xref: /packages/apps/Calendar/src/com/android/calendar/ColorChipView.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.calendar;

import android.content.Context;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.Shader.TileMode;
import android.graphics.PorterDuff;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;




/**
 * A custom view for a color chip for an event that can be drawn differently
 * accroding to the event's status.
 *
 */
public class ColorChipView extends View {

    private static final String TAG = "ColorChipView";
    // Style of drawing
    // Full rectangle for accepted events
    // Border for tentative events
    // Cross-hatched with 50% transparency for declined events

    public static final int DRAW_FULL = 0;
    public static final int DRAW_BORDER = 1;
    public static final int DRAW_CROSS_HATCHED = 2;

    private static final float DECLINED_ALPHA = (float) 0.4;
    private static final float DEFAULT_ALPHA = 1;

    int mDrawStyle = DRAW_FULL;

    private static final int DEF_BORDER_WIDTH = 4;

    int mBorderWidth = DEF_BORDER_WIDTH;

    int mColor;
    BitmapDrawable mCrosshatchedPattern;

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

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

    public void setDrawStyle(int style) {
        if (style != DRAW_FULL && style != DRAW_BORDER && style != DRAW_CROSS_HATCHED) {
            return;
        }
        mDrawStyle = style;
        if (style == DRAW_CROSS_HATCHED) {
            mCrosshatchedPattern.setColorFilter(mColor, PorterDuff.Mode.OVERLAY);
            setBackgroundDrawable(mCrosshatchedPattern);
            setAlpha(DECLINED_ALPHA);
        } else {
            setBackgroundDrawable(null);
            setAlpha(DEFAULT_ALPHA);
        }
        invalidate();
    }

    public void setBorderWidth(int width) {
        if (width >= 0) {
            mBorderWidth = width;
            invalidate();
        }
    }

    public void setColor(int color) {
        mColor = color;
        mCrosshatchedPattern.setColorFilter(mColor, PorterDuff.Mode.OVERLAY);
        invalidate();
    }

    private void init(Context c) {
        mCrosshatchedPattern = new BitmapDrawable(BitmapFactory.decodeResource(getResources(),
                R.drawable.event_bg_declined));
        mCrosshatchedPattern.setTileModeXY(TileMode.REPEAT, TileMode.REPEAT);
    }

    @Override
    public void onDraw(Canvas c) {

        int right = getWidth() - 1;
        int bottom = getHeight() - 1;
        Paint p = new Paint();
        p.setColor(mColor);
        p.setStyle(Style.FILL_AND_STROKE);

        switch (mDrawStyle) {
            case DRAW_FULL:
                c.drawRect(0, 0, right, bottom, p);
                break;
            case DRAW_BORDER:
                if (mBorderWidth <= 0) {
                    return;
                }
                int halfBorderWidth = mBorderWidth / 2;
                int top = halfBorderWidth;
                int left = halfBorderWidth;
                p.setStrokeWidth(mBorderWidth);

                float[] lines = new float[16];
                int ptr = 0;
                lines [ptr++] = 0;
                lines [ptr++] = top;
                lines [ptr++] = right;
                lines [ptr++] = top;
                lines [ptr++] = 0;
                lines [ptr++] = bottom - halfBorderWidth;
                lines [ptr++] = right;
                lines [ptr++] = bottom - halfBorderWidth;
                lines [ptr++] = left;
                lines [ptr++] = 0;
                lines [ptr++] = left;
                lines [ptr++] = bottom;
                lines [ptr++] = right - halfBorderWidth;
                lines [ptr++] = 0;
                lines [ptr++] = right - halfBorderWidth;
                lines [ptr++] = bottom;
                c.drawLines(lines, p);
                break;
            default:
                // Don't need to do anything for DRAW_CROSS_HATCHED since the
                // pattern is already set in the background drawable in "setStyle"
                break;
        }
    }
}