/* * Copyright (C) 2010 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.month; import com.android.calendar.Event; import com.android.calendar.R; import com.android.calendar.Utils; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.ObjectAnimator; import android.app.Service; import android.content.Context; import android.content.res.Configuration; import android.content.res.Resources; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Paint.Align; import android.graphics.Paint.Style; import android.graphics.Typeface; import android.graphics.drawable.Drawable; import android.provider.CalendarContract.Attendees; import android.text.TextPaint; import android.text.TextUtils; import android.text.format.DateFormat; import android.text.format.DateUtils; import android.text.format.Time; import android.util.Log; import android.view.MotionEvent; import android.view.accessibility.AccessibilityEvent; import android.view.accessibility.AccessibilityManager; import java.util.ArrayList; import java.util.Arrays; import java.util.Formatter; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Locale; public class MonthWeekEventsView extends SimpleWeekView { private static final String TAG = "MonthView"; private static final boolean DEBUG_LAYOUT = false; public static final String VIEW_PARAMS_ORIENTATION = "orientation"; public static final String VIEW_PARAMS_ANIMATE_TODAY = "animate_today"; /* NOTE: these are not constants, and may be multiplied by a scale factor */ private static int TEXT_SIZE_MONTH_NUMBER = 32; private static int TEXT_SIZE_EVENT = 12; private static int TEXT_SIZE_EVENT_TITLE = 14; private static int TEXT_SIZE_MORE_EVENTS = 12; private static int TEXT_SIZE_MONTH_NAME = 14; private static int TEXT_SIZE_WEEK_NUM = 12; private static int DNA_MARGIN = 4; private static int DNA_ALL_DAY_HEIGHT = 4; private static int DNA_MIN_SEGMENT_HEIGHT = 4; private static int DNA_WIDTH = 8; private static int DNA_ALL_DAY_WIDTH = 32; private static int DNA_SIDE_PADDING = 6; private static int CONFLICT_COLOR = Color.BLACK; private static int EVENT_TEXT_COLOR = Color.WHITE; private static int DEFAULT_EDGE_SPACING = 0; private static int SIDE_PADDING_MONTH_NUMBER = 4; private static int TOP_PADDING_MONTH_NUMBER = 4; private static int TOP_PADDING_WEEK_NUMBER = 4; private static int SIDE_PADDING_WEEK_NUMBER = 20; private static int DAY_SEPARATOR_OUTER_WIDTH = 0; private static int DAY_SEPARATOR_INNER_WIDTH = 1; private static int DAY_SEPARATOR_VERTICAL_LENGTH = 53; private static int DAY_SEPARATOR_VERTICAL_LENGHT_PORTRAIT = 64; private static int MIN_WEEK_WIDTH = 50; private static int EVENT_X_OFFSET_LANDSCAPE = 38; private static int EVENT_Y_OFFSET_LANDSCAPE = 8; private static int EVENT_Y_OFFSET_PORTRAIT = 7; private static int EVENT_SQUARE_WIDTH = 10; private static int EVENT_SQUARE_BORDER = 2; private static int EVENT_LINE_PADDING = 2; private static int EVENT_RIGHT_PADDING = 4; private static int EVENT_BOTTOM_PADDING = 3; private static int TODAY_HIGHLIGHT_WIDTH = 2; private static int SPACING_WEEK_NUMBER = 24; private static boolean mInitialized = false; private static boolean mShowDetailsInMonth; protected Time mToday = new Time(); protected boolean mHasToday = false; protected int mTodayIndex = -1; protected int mOrientation = Configuration.ORIENTATION_LANDSCAPE; protected List> mEvents = null; protected ArrayList mUnsortedEvents = null; HashMap mDna = null; // This is for drawing the outlines around event chips and supports up to 10 // events being drawn on each day. The code will expand this if necessary. protected FloatRef mEventOutlines = new FloatRef(10 * 4 * 4 * 7); protected static StringBuilder mStringBuilder = new StringBuilder(50); // TODO recreate formatter when locale changes protected static Formatter mFormatter = new Formatter(mStringBuilder, Locale.getDefault()); protected Paint mMonthNamePaint; protected TextPaint mEventPaint; protected TextPaint mSolidBackgroundEventPaint; protected TextPaint mFramedEventPaint; protected TextPaint mDeclinedEventPaint; protected TextPaint mEventExtrasPaint; protected TextPaint mEventDeclinedExtrasPaint; protected Paint mWeekNumPaint; protected Paint mDNAAllDayPaint; protected Paint mDNATimePaint; protected Paint mEventSquarePaint; protected Drawable mTodayDrawable; protected int mMonthNumHeight; protected int mMonthNumAscentHeight; protected int mEventHeight; protected int mEventAscentHeight; protected int mExtrasHeight; protected int mExtrasAscentHeight; protected int mExtrasDescent; protected int mWeekNumAscentHeight; protected int mMonthBGColor; protected int mMonthBGOtherColor; protected int mMonthBGTodayColor; protected int mMonthNumColor; protected int mMonthNumOtherColor; protected int mMonthNumTodayColor; protected int mMonthNameColor; protected int mMonthNameOtherColor; protected int mMonthEventColor; protected int mMonthDeclinedEventColor; protected int mMonthDeclinedExtrasColor; protected int mMonthEventExtraColor; protected int mMonthEventOtherColor; protected int mMonthEventExtraOtherColor; protected int mMonthWeekNumColor; protected int mMonthBusyBitsBgColor; protected int mMonthBusyBitsBusyTimeColor; protected int mMonthBusyBitsConflictTimeColor; private int mClickedDayIndex = -1; private int mClickedDayColor; private static final int mClickedAlpha = 128; protected int mEventChipOutlineColor = 0xFFFFFFFF; protected int mDaySeparatorInnerColor; protected int mTodayAnimateColor; private boolean mAnimateToday; private int mAnimateTodayAlpha = 0; private ObjectAnimator mTodayAnimator = null; private final TodayAnimatorListener mAnimatorListener = new TodayAnimatorListener(); class TodayAnimatorListener extends AnimatorListenerAdapter { private volatile Animator mAnimator = null; private volatile boolean mFadingIn = false; @Override public void onAnimationEnd(Animator animation) { synchronized (this) { if (mAnimator != animation) { animation.removeAllListeners(); animation.cancel(); return; } if (mFadingIn) { if (mTodayAnimator != null) { mTodayAnimator.removeAllListeners(); mTodayAnimator.cancel(); } mTodayAnimator = ObjectAnimator.ofInt(MonthWeekEventsView.this, "animateTodayAlpha", 255, 0); mAnimator = mTodayAnimator; mFadingIn = false; mTodayAnimator.addListener(this); mTodayAnimator.setDuration(600); mTodayAnimator.start(); } else { mAnimateToday = false; mAnimateTodayAlpha = 0; mAnimator.removeAllListeners(); mAnimator = null; mTodayAnimator = null; invalidate(); } } } public void setAnimator(Animator animation) { mAnimator = animation; } public void setFadingIn(boolean fadingIn) { mFadingIn = fadingIn; } } private int[] mDayXs; /** * This provides a reference to a float array which allows for easy size * checking and reallocation. Used for drawing lines. */ private class FloatRef { float[] array; public FloatRef(int size) { array = new float[size]; } public void ensureSize(int newSize) { if (newSize >= array.length) { // Add enough space for 7 more boxes to be drawn array = Arrays.copyOf(array, newSize + 16 * 7); } } } /** * Shows up as an error if we don't include this. */ public MonthWeekEventsView(Context context) { super(context); } // Sets the list of events for this week. Takes a sorted list of arrays // divided up by day for generating the large month version and the full // arraylist sorted by start time to generate the dna version. public void setEvents(List> sortedEvents, ArrayList unsortedEvents) { setEvents(sortedEvents); // The MIN_WEEK_WIDTH is a hack to prevent the view from trying to // generate dna bits before its width has been fixed. createDna(unsortedEvents); } /** * Sets up the dna bits for the view. This will return early if the view * isn't in a state that will create a valid set of dna yet (such as the * views width not being set correctly yet). */ public void createDna(ArrayList unsortedEvents) { if (unsortedEvents == null || mWidth <= MIN_WEEK_WIDTH || getContext() == null) { // Stash the list of events for use when this view is ready, or // just clear it if a null set has been passed to this view mUnsortedEvents = unsortedEvents; mDna = null; return; } else { // clear the cached set of events since we're ready to build it now mUnsortedEvents = null; } // Create the drawing coordinates for dna if (!mShowDetailsInMonth) { int numDays = mEvents.size(); int effectiveWidth = mWidth - mPadding * 2; if (mShowWeekNum) { effectiveWidth -= SPACING_WEEK_NUMBER; } DNA_ALL_DAY_WIDTH = effectiveWidth / numDays - 2 * DNA_SIDE_PADDING; mDNAAllDayPaint.setStrokeWidth(DNA_ALL_DAY_WIDTH); mDayXs = new int[numDays]; for (int day = 0; day < numDays; day++) { mDayXs[day] = computeDayLeftPosition(day) + DNA_WIDTH / 2 + DNA_SIDE_PADDING; } int top = DAY_SEPARATOR_INNER_WIDTH + DNA_MARGIN + DNA_ALL_DAY_HEIGHT + 1; int bottom = mHeight - DNA_MARGIN; mDna = Utils.createDNAStrands(mFirstJulianDay, unsortedEvents, top, bottom, DNA_MIN_SEGMENT_HEIGHT, mDayXs, getContext()); } } public void setEvents(List> sortedEvents) { mEvents = sortedEvents; if (sortedEvents == null) { return; } if (sortedEvents.size() != mNumDays) { if (Log.isLoggable(TAG, Log.ERROR)) { Log.wtf(TAG, "Events size must be same as days displayed: size=" + sortedEvents.size() + " days=" + mNumDays); } mEvents = null; return; } } protected void loadColors(Context context) { Resources res = context.getResources(); mMonthWeekNumColor = res.getColor(R.color.month_week_num_color); mMonthNumColor = res.getColor(R.color.month_day_number); mMonthNumOtherColor = res.getColor(R.color.month_day_number_other); mMonthNumTodayColor = res.getColor(R.color.month_today_number); mMonthNameColor = mMonthNumColor; mMonthNameOtherColor = mMonthNumOtherColor; mMonthEventColor = res.getColor(R.color.month_event_color); mMonthDeclinedEventColor = res.getColor(R.color.agenda_item_declined_color); mMonthDeclinedExtrasColor = res.getColor(R.color.agenda_item_where_declined_text_color); mMonthEventExtraColor = res.getColor(R.color.month_event_extra_color); mMonthEventOtherColor = res.getColor(R.color.month_event_other_color); mMonthEventExtraOtherColor = res.getColor(R.color.month_event_extra_other_color); mMonthBGTodayColor = res.getColor(R.color.month_today_bgcolor); mMonthBGOtherColor = res.getColor(R.color.month_other_bgcolor); mMonthBGColor = res.getColor(R.color.month_bgcolor); mDaySeparatorInnerColor = res.getColor(R.color.month_grid_lines); mTodayAnimateColor = res.getColor(R.color.today_highlight_color); mClickedDayColor = res.getColor(R.color.day_clicked_background_color); mTodayDrawable = res.getDrawable(R.drawable.today_blue_week_holo_light); } /** * Sets up the text and style properties for painting. Override this if you * want to use a different paint. */ @Override protected void initView() { super.initView(); if (!mInitialized) { Resources resources = getContext().getResources(); mShowDetailsInMonth = Utils.getConfigBool(getContext(), R.bool.show_details_in_month); TEXT_SIZE_EVENT_TITLE = resources.getInteger(R.integer.text_size_event_title); TEXT_SIZE_MONTH_NUMBER = resources.getInteger(R.integer.text_size_month_number); SIDE_PADDING_MONTH_NUMBER = resources.getInteger(R.integer.month_day_number_margin); CONFLICT_COLOR = resources.getColor(R.color.month_dna_conflict_time_color); EVENT_TEXT_COLOR = resources.getColor(R.color.calendar_event_text_color); if (mScale != 1) { TOP_PADDING_MONTH_NUMBER *= mScale; TOP_PADDING_WEEK_NUMBER *= mScale; SIDE_PADDING_MONTH_NUMBER *= mScale; SIDE_PADDING_WEEK_NUMBER *= mScale; SPACING_WEEK_NUMBER *= mScale; TEXT_SIZE_MONTH_NUMBER *= mScale; TEXT_SIZE_EVENT *= mScale; TEXT_SIZE_EVENT_TITLE *= mScale; TEXT_SIZE_MORE_EVENTS *= mScale; TEXT_SIZE_MONTH_NAME *= mScale; TEXT_SIZE_WEEK_NUM *= mScale; DAY_SEPARATOR_OUTER_WIDTH *= mScale; DAY_SEPARATOR_INNER_WIDTH *= mScale; DAY_SEPARATOR_VERTICAL_LENGTH *= mScale; DAY_SEPARATOR_VERTICAL_LENGHT_PORTRAIT *= mScale; EVENT_X_OFFSET_LANDSCAPE *= mScale; EVENT_Y_OFFSET_LANDSCAPE *= mScale; EVENT_Y_OFFSET_PORTRAIT *= mScale; EVENT_SQUARE_WIDTH *= mScale; EVENT_SQUARE_BORDER *= mScale; EVENT_LINE_PADDING *= mScale; EVENT_BOTTOM_PADDING *= mScale; EVENT_RIGHT_PADDING *= mScale; DNA_MARGIN *= mScale; DNA_WIDTH *= mScale; DNA_ALL_DAY_HEIGHT *= mScale; DNA_MIN_SEGMENT_HEIGHT *= mScale; DNA_SIDE_PADDING *= mScale; DEFAULT_EDGE_SPACING *= mScale; DNA_ALL_DAY_WIDTH *= mScale; TODAY_HIGHLIGHT_WIDTH *= mScale; } if (!mShowDetailsInMonth) { TOP_PADDING_MONTH_NUMBER += DNA_ALL_DAY_HEIGHT + DNA_MARGIN; } mInitialized = true; } mPadding = DEFAULT_EDGE_SPACING; loadColors(getContext()); // TODO modify paint properties depending on isMini mMonthNumPaint = new Paint(); mMonthNumPaint.setFakeBoldText(false); mMonthNumPaint.setAntiAlias(true); mMonthNumPaint.setTextSize(TEXT_SIZE_MONTH_NUMBER); mMonthNumPaint.setColor(mMonthNumColor); mMonthNumPaint.setStyle(Style.FILL); mMonthNumPaint.setTextAlign(Align.RIGHT); mMonthNumPaint.setTypeface(Typeface.DEFAULT); mMonthNumAscentHeight = (int) (-mMonthNumPaint.ascent() + 0.5f); mMonthNumHeight = (int) (mMonthNumPaint.descent() - mMonthNumPaint.ascent() + 0.5f); mEventPaint = new TextPaint(); mEventPaint.setFakeBoldText(true); mEventPaint.setAntiAlias(true); mEventPaint.setTextSize(TEXT_SIZE_EVENT_TITLE); mEventPaint.setColor(mMonthEventColor); mSolidBackgroundEventPaint = new TextPaint(mEventPaint); mSolidBackgroundEventPaint.setColor(EVENT_TEXT_COLOR); mFramedEventPaint = new TextPaint(mSolidBackgroundEventPaint); mDeclinedEventPaint = new TextPaint(); mDeclinedEventPaint.setFakeBoldText(true); mDeclinedEventPaint.setAntiAlias(true); mDeclinedEventPaint.setTextSize(TEXT_SIZE_EVENT_TITLE); mDeclinedEventPaint.setColor(mMonthDeclinedEventColor); mEventAscentHeight = (int) (-mEventPaint.ascent() + 0.5f); mEventHeight = (int) (mEventPaint.descent() - mEventPaint.ascent() + 0.5f); mEventExtrasPaint = new TextPaint(); mEventExtrasPaint.setFakeBoldText(false); mEventExtrasPaint.setAntiAlias(true); mEventExtrasPaint.setStrokeWidth(EVENT_SQUARE_BORDER); mEventExtrasPaint.setTextSize(TEXT_SIZE_EVENT); mEventExtrasPaint.setColor(mMonthEventExtraColor); mEventExtrasPaint.setStyle(Style.FILL); mEventExtrasPaint.setTextAlign(Align.LEFT); mExtrasHeight = (int)(mEventExtrasPaint.descent() - mEventExtrasPaint.ascent() + 0.5f); mExtrasAscentHeight = (int)(-mEventExtrasPaint.ascent() + 0.5f); mExtrasDescent = (int)(mEventExtrasPaint.descent() + 0.5f); mEventDeclinedExtrasPaint = new TextPaint(); mEventDeclinedExtrasPaint.setFakeBoldText(false); mEventDeclinedExtrasPaint.setAntiAlias(true); mEventDeclinedExtrasPaint.setStrokeWidth(EVENT_SQUARE_BORDER); mEventDeclinedExtrasPaint.setTextSize(TEXT_SIZE_EVENT); mEventDeclinedExtrasPaint.setColor(mMonthDeclinedExtrasColor); mEventDeclinedExtrasPaint.setStyle(Style.FILL); mEventDeclinedExtrasPaint.setTextAlign(Align.LEFT); mWeekNumPaint = new Paint(); mWeekNumPaint.setFakeBoldText(false); mWeekNumPaint.setAntiAlias(true); mWeekNumPaint.setTextSize(TEXT_SIZE_WEEK_NUM); mWeekNumPaint.setColor(mWeekNumColor); mWeekNumPaint.setStyle(Style.FILL); mWeekNumPaint.setTextAlign(Align.RIGHT); mWeekNumAscentHeight = (int) (-mWeekNumPaint.ascent() + 0.5f); mDNAAllDayPaint = new Paint(); mDNATimePaint = new Paint(); mDNATimePaint.setColor(mMonthBusyBitsBusyTimeColor); mDNATimePaint.setStyle(Style.FILL_AND_STROKE); mDNATimePaint.setStrokeWidth(DNA_WIDTH); mDNATimePaint.setAntiAlias(false); mDNAAllDayPaint.setColor(mMonthBusyBitsConflictTimeColor); mDNAAllDayPaint.setStyle(Style.FILL_AND_STROKE); mDNAAllDayPaint.setStrokeWidth(DNA_ALL_DAY_WIDTH); mDNAAllDayPaint.setAntiAlias(false); mEventSquarePaint = new Paint(); mEventSquarePaint.setStrokeWidth(EVENT_SQUARE_BORDER); mEventSquarePaint.setAntiAlias(false); if (DEBUG_LAYOUT) { Log.d("EXTRA", "mScale=" + mScale); Log.d("EXTRA", "mMonthNumPaint ascent=" + mMonthNumPaint.ascent() + " descent=" + mMonthNumPaint.descent() + " int height=" + mMonthNumHeight); Log.d("EXTRA", "mEventPaint ascent=" + mEventPaint.ascent() + " descent=" + mEventPaint.descent() + " int height=" + mEventHeight + " int ascent=" + mEventAscentHeight); Log.d("EXTRA", "mEventExtrasPaint ascent=" + mEventExtrasPaint.ascent() + " descent=" + mEventExtrasPaint.descent() + " int height=" + mExtrasHeight); Log.d("EXTRA", "mWeekNumPaint ascent=" + mWeekNumPaint.ascent() + " descent=" + mWeekNumPaint.descent()); } } @Override public void setWeekParams(HashMap params, String tz) { super.setWeekParams(params, tz); if (params.containsKey(VIEW_PARAMS_ORIENTATION)) { mOrientation = params.get(VIEW_PARAMS_ORIENTATION); } updateToday(tz); mNumCells = mNumDays + 1; if (params.containsKey(VIEW_PARAMS_ANIMATE_TODAY) && mHasToday) { synchronized (mAnimatorListener) { if (mTodayAnimator != null) { mTodayAnimator.removeAllListeners(); mTodayAnimator.cancel(); } mTodayAnimator = ObjectAnimator.ofInt(this, "animateTodayAlpha", Math.max(mAnimateTodayAlpha, 80), 255); mTodayAnimator.setDuration(150); mAnimatorListener.setAnimator(mTodayAnimator); mAnimatorListener.setFadingIn(true); mTodayAnimator.addListener(mAnimatorListener); mAnimateToday = true; mTodayAnimator.start(); } } } /** * @param tz */ public boolean updateToday(String tz) { mToday.timezone = tz; mToday.setToNow(); mToday.normalize(true); int julianToday = Time.getJulianDay(mToday.toMillis(false), mToday.gmtoff); if (julianToday >= mFirstJulianDay && julianToday < mFirstJulianDay + mNumDays) { mHasToday = true; mTodayIndex = julianToday - mFirstJulianDay; } else { mHasToday = false; mTodayIndex = -1; } return mHasToday; } public void setAnimateTodayAlpha(int alpha) { mAnimateTodayAlpha = alpha; invalidate(); } @Override protected void onDraw(Canvas canvas) { drawBackground(canvas); drawWeekNums(canvas); drawDaySeparators(canvas); if (mHasToday && mAnimateToday) { drawToday(canvas); } if (mShowDetailsInMonth) { drawEvents(canvas); } else { if (mDna == null && mUnsortedEvents != null) { createDna(mUnsortedEvents); } drawDNA(canvas); } drawClick(canvas); } protected void drawToday(Canvas canvas) { r.top = DAY_SEPARATOR_INNER_WIDTH + (TODAY_HIGHLIGHT_WIDTH / 2); r.bottom = mHeight - (int) Math.ceil(TODAY_HIGHLIGHT_WIDTH / 2.0f); p.setStyle(Style.STROKE); p.setStrokeWidth(TODAY_HIGHLIGHT_WIDTH); r.left = computeDayLeftPosition(mTodayIndex) + (TODAY_HIGHLIGHT_WIDTH / 2); r.right = computeDayLeftPosition(mTodayIndex + 1) - (int) Math.ceil(TODAY_HIGHLIGHT_WIDTH / 2.0f); p.setColor(mTodayAnimateColor | (mAnimateTodayAlpha << 24)); canvas.drawRect(r, p); p.setStyle(Style.FILL); } // TODO move into SimpleWeekView // Computes the x position for the left side of the given day private int computeDayLeftPosition(int day) { int effectiveWidth = mWidth; int x = 0; int xOffset = 0; if (mShowWeekNum) { xOffset = SPACING_WEEK_NUMBER + mPadding; effectiveWidth -= xOffset; } x = day * effectiveWidth / mNumDays + xOffset; return x; } @Override protected void drawDaySeparators(Canvas canvas) { float lines[] = new float[8 * 4]; int count = 6 * 4; int wkNumOffset = 0; int i = 0; if (mShowWeekNum) { // This adds the first line separating the week number int xOffset = SPACING_WEEK_NUMBER + mPadding; count += 4; lines[i++] = xOffset; lines[i++] = 0; lines[i++] = xOffset; lines[i++] = mHeight; wkNumOffset++; } count += 4; lines[i++] = 0; lines[i++] = 0; lines[i++] = mWidth; lines[i++] = 0; int y0 = 0; int y1 = mHeight; while (i < count) { int x = computeDayLeftPosition(i / 4 - wkNumOffset); lines[i++] = x; lines[i++] = y0; lines[i++] = x; lines[i++] = y1; } p.setColor(mDaySeparatorInnerColor); p.setStrokeWidth(DAY_SEPARATOR_INNER_WIDTH); canvas.drawLines(lines, 0, count, p); } @Override protected void drawBackground(Canvas canvas) { int i = 0; int offset = 0; r.top = DAY_SEPARATOR_INNER_WIDTH; r.bottom = mHeight; if (mShowWeekNum) { i++; offset++; } if (!mOddMonth[i]) { while (++i < mOddMonth.length && !mOddMonth[i]) ; r.right = computeDayLeftPosition(i - offset); r.left = 0; p.setColor(mMonthBGOtherColor); canvas.drawRect(r, p); // compute left edge for i, set up r, draw } else if (!mOddMonth[(i = mOddMonth.length - 1)]) { while (--i >= offset && !mOddMonth[i]) ; i++; // compute left edge for i, set up r, draw r.right = mWidth; r.left = computeDayLeftPosition(i - offset); p.setColor(mMonthBGOtherColor); canvas.drawRect(r, p); } if (mHasToday) { p.setColor(mMonthBGTodayColor); r.left = computeDayLeftPosition(mTodayIndex); r.right = computeDayLeftPosition(mTodayIndex + 1); canvas.drawRect(r, p); } } // Draw the "clicked" color on the tapped day private void drawClick(Canvas canvas) { if (mClickedDayIndex != -1) { int alpha = p.getAlpha(); p.setColor(mClickedDayColor); p.setAlpha(mClickedAlpha); r.left = computeDayLeftPosition(mClickedDayIndex); r.right = computeDayLeftPosition(mClickedDayIndex + 1); r.top = DAY_SEPARATOR_INNER_WIDTH; r.bottom = mHeight; canvas.drawRect(r, p); p.setAlpha(alpha); } } @Override protected void drawWeekNums(Canvas canvas) { int y; int i = 0; int offset = -1; int todayIndex = mTodayIndex; int x = 0; int numCount = mNumDays; if (mShowWeekNum) { x = SIDE_PADDING_WEEK_NUMBER + mPadding; y = mWeekNumAscentHeight + TOP_PADDING_WEEK_NUMBER; canvas.drawText(mDayNumbers[0], x, y, mWeekNumPaint); numCount++; i++; todayIndex++; offset++; } y = mMonthNumAscentHeight + TOP_PADDING_MONTH_NUMBER; boolean isFocusMonth = mFocusDay[i]; boolean isBold = false; mMonthNumPaint.setColor(isFocusMonth ? mMonthNumColor : mMonthNumOtherColor); for (; i < numCount; i++) { if (mHasToday && todayIndex == i) { mMonthNumPaint.setColor(mMonthNumTodayColor); mMonthNumPaint.setFakeBoldText(isBold = true); if (i + 1 < numCount) { // Make sure the color will be set back on the next // iteration isFocusMonth = !mFocusDay[i + 1]; } } else if (mFocusDay[i] != isFocusMonth) { isFocusMonth = mFocusDay[i]; mMonthNumPaint.setColor(isFocusMonth ? mMonthNumColor : mMonthNumOtherColor); } x = computeDayLeftPosition(i - offset) - (SIDE_PADDING_MONTH_NUMBER); canvas.drawText(mDayNumbers[i], x, y, mMonthNumPaint); if (isBold) { mMonthNumPaint.setFakeBoldText(isBold = false); } } } protected void drawEvents(Canvas canvas) { if (mEvents == null) { return; } int day = -1; for (ArrayList eventDay : mEvents) { day++; if (eventDay == null || eventDay.size() == 0) { continue; } int ySquare; int xSquare = computeDayLeftPosition(day) + SIDE_PADDING_MONTH_NUMBER + 1; int rightEdge = computeDayLeftPosition(day + 1); if (mOrientation == Configuration.ORIENTATION_PORTRAIT) { ySquare = EVENT_Y_OFFSET_PORTRAIT + mMonthNumHeight + TOP_PADDING_MONTH_NUMBER; rightEdge -= SIDE_PADDING_MONTH_NUMBER + 1; } else { ySquare = EVENT_Y_OFFSET_LANDSCAPE; rightEdge -= EVENT_X_OFFSET_LANDSCAPE; } // Determine if everything will fit when time ranges are shown. boolean showTimes = true; Iterator iter = eventDay.iterator(); int yTest = ySquare; while (iter.hasNext()) { Event event = iter.next(); int newY = drawEvent(canvas, event, xSquare, yTest, rightEdge, iter.hasNext(), showTimes, /*doDraw*/ false); if (newY == yTest) { showTimes = false; break; } yTest = newY; } int eventCount = 0; iter = eventDay.iterator(); while (iter.hasNext()) { Event event = iter.next(); int newY = drawEvent(canvas, event, xSquare, ySquare, rightEdge, iter.hasNext(), showTimes, /*doDraw*/ true); if (newY == ySquare) { break; } eventCount++; ySquare = newY; } int remaining = eventDay.size() - eventCount; if (remaining > 0) { drawMoreEvents(canvas, remaining, xSquare); } } } protected int addChipOutline(FloatRef lines, int count, int x, int y) { lines.ensureSize(count + 16); // top of box lines.array[count++] = x; lines.array[count++] = y; lines.array[count++] = x + EVENT_SQUARE_WIDTH; lines.array[count++] = y; // right side of box lines.array[count++] = x + EVENT_SQUARE_WIDTH; lines.array[count++] = y; lines.array[count++] = x + EVENT_SQUARE_WIDTH; lines.array[count++] = y + EVENT_SQUARE_WIDTH; // left side of box lines.array[count++] = x; lines.array[count++] = y; lines.array[count++] = x; lines.array[count++] = y + EVENT_SQUARE_WIDTH + 1; // bottom of box lines.array[count++] = x; lines.array[count++] = y + EVENT_SQUARE_WIDTH; lines.array[count++] = x + EVENT_SQUARE_WIDTH + 1; lines.array[count++] = y + EVENT_SQUARE_WIDTH; return count; } /** * Attempts to draw the given event. Returns the y for the next event or the * original y if the event will not fit. An event is considered to not fit * if the event and its extras won't fit or if there are more events and the * more events line would not fit after drawing this event. * * @param canvas the canvas to draw on * @param event the event to draw * @param x the top left corner for this event's color chip * @param y the top left corner for this event's color chip * @param rightEdge the rightmost point we're allowed to draw on (exclusive) * @param moreEvents indicates whether additional events will follow this one * @param showTimes if set, a second line with a time range will be displayed for non-all-day * events * @param doDraw if set, do the actual drawing; otherwise this just computes the height * and returns * @return the y for the next event or the original y if it won't fit */ protected int drawEvent(Canvas canvas, Event event, int x, int y, int rightEdge, boolean moreEvents, boolean showTimes, boolean doDraw) { /* * Vertical layout: * (top of box) * a. EVENT_Y_OFFSET_LANDSCAPE or portrait equivalent * b. Event title: mEventHeight for a normal event, + 2xBORDER_SPACE for all-day event * c. [optional] Time range (mExtrasHeight) * d. EVENT_LINE_PADDING * * Repeat (b,c,d) as needed and space allows. If we have more events than fit, we need * to leave room for something like "+2" at the bottom: * * e. "+ more" line (mExtrasHeight) * * f. EVENT_BOTTOM_PADDING (overlaps EVENT_LINE_PADDING) * (bottom of box) */ final int BORDER_SPACE = EVENT_SQUARE_BORDER + 1; // want a 1-pixel gap inside border final int STROKE_WIDTH_ADJ = EVENT_SQUARE_BORDER / 2; // adjust bounds for stroke width boolean allDay = event.allDay; int eventRequiredSpace = mEventHeight; if (allDay) { // Add a few pixels for the box we draw around all-day events. eventRequiredSpace += BORDER_SPACE * 2; } else if (showTimes) { // Need room for the "1pm - 2pm" line. eventRequiredSpace += mExtrasHeight; } int reservedSpace = EVENT_BOTTOM_PADDING; // leave a bit of room at the bottom if (moreEvents) { // More events follow. Leave a bit of space between events. eventRequiredSpace += EVENT_LINE_PADDING; // Make sure we have room for the "+ more" line. (The "+ more" line is expected // to be <= the height of an event line, so we won't show "+1" when we could be // showing the event.) reservedSpace += mExtrasHeight; } if (y + eventRequiredSpace + reservedSpace > mHeight) { // Not enough space, return original y return y; } else if (!doDraw) { return y + eventRequiredSpace; } boolean isDeclined = event.selfAttendeeStatus == Attendees.ATTENDEE_STATUS_DECLINED; int color = event.color; if (isDeclined) { color = Utils.getDeclinedColorFromColor(color); } int textX, textY, textRightEdge; if (allDay) { // We shift the render offset "inward", because drawRect with a stroke width greater // than 1 draws outside the specified bounds. (We don't adjust the left edge, since // we want to match the existing appearance of the "event square".) r.left = x; r.right = rightEdge - STROKE_WIDTH_ADJ; r.top = y + STROKE_WIDTH_ADJ; r.bottom = y + mEventHeight + BORDER_SPACE * 2 - STROKE_WIDTH_ADJ; textX = x + BORDER_SPACE; textY = y + mEventAscentHeight + BORDER_SPACE; textRightEdge = rightEdge - BORDER_SPACE; } else { r.left = x; r.right = x + EVENT_SQUARE_WIDTH; r.bottom = y + mEventAscentHeight; r.top = r.bottom - EVENT_SQUARE_WIDTH; textX = x + EVENT_SQUARE_WIDTH + EVENT_RIGHT_PADDING; textY = y + mEventAscentHeight; textRightEdge = rightEdge; } Style boxStyle = Style.STROKE; boolean solidBackground = false; if (event.selfAttendeeStatus != Attendees.ATTENDEE_STATUS_INVITED) { boxStyle = Style.FILL_AND_STROKE; if (allDay) { solidBackground = true; } } mEventSquarePaint.setStyle(boxStyle); mEventSquarePaint.setColor(color); canvas.drawRect(r, mEventSquarePaint); float avail = textRightEdge - textX; CharSequence text = TextUtils.ellipsize( event.title, mEventPaint, avail, TextUtils.TruncateAt.END); Paint textPaint; if (solidBackground) { // Text color needs to contrast with solid background. textPaint = mSolidBackgroundEventPaint; } else if (isDeclined) { // Use "declined event" color. textPaint = mDeclinedEventPaint; } else if (allDay) { // Text inside frame is same color as frame. mFramedEventPaint.setColor(color); textPaint = mFramedEventPaint; } else { // Use generic event text color. textPaint = mEventPaint; } canvas.drawText(text.toString(), textX, textY, textPaint); y += mEventHeight; if (allDay) { y += BORDER_SPACE * 2; } if (showTimes && !allDay) { // show start/end time, e.g. "1pm - 2pm" textY = y + mExtrasAscentHeight; mStringBuilder.setLength(0); text = DateUtils.formatDateRange(getContext(), mFormatter, event.startMillis, event.endMillis, DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_ABBREV_ALL, Utils.getTimeZone(getContext(), null)).toString(); text = TextUtils.ellipsize(text, mEventExtrasPaint, avail, TextUtils.TruncateAt.END); canvas.drawText(text.toString(), textX, textY, isDeclined ? mEventDeclinedExtrasPaint : mEventExtrasPaint); y += mExtrasHeight; } y += EVENT_LINE_PADDING; return y; } protected void drawMoreEvents(Canvas canvas, int remainingEvents, int x) { int y = mHeight - (mExtrasDescent + EVENT_BOTTOM_PADDING); String text = getContext().getResources().getQuantityString( R.plurals.month_more_events, remainingEvents); mEventExtrasPaint.setAntiAlias(true); mEventExtrasPaint.setFakeBoldText(true); canvas.drawText(String.format(text, remainingEvents), x, y, mEventExtrasPaint); mEventExtrasPaint.setFakeBoldText(false); } /** * Draws a line showing busy times in each day of week The method draws * non-conflicting times in the event color and times with conflicting * events in the dna conflict color defined in colors. * * @param canvas */ protected void drawDNA(Canvas canvas) { // Draw event and conflict times if (mDna != null) { for (Utils.DNAStrand strand : mDna.values()) { if (strand.color == CONFLICT_COLOR || strand.points == null || strand.points.length == 0) { continue; } mDNATimePaint.setColor(strand.color); canvas.drawLines(strand.points, mDNATimePaint); } // Draw black last to make sure it's on top Utils.DNAStrand strand = mDna.get(CONFLICT_COLOR); if (strand != null && strand.points != null && strand.points.length != 0) { mDNATimePaint.setColor(strand.color); canvas.drawLines(strand.points, mDNATimePaint); } if (mDayXs == null) { return; } int numDays = mDayXs.length; int xOffset = (DNA_ALL_DAY_WIDTH - DNA_WIDTH) / 2; if (strand != null && strand.allDays != null && strand.allDays.length == numDays) { for (int i = 0; i < numDays; i++) { // this adds at most 7 draws. We could sort it by color and // build an array instead but this is easier. if (strand.allDays[i] != 0) { mDNAAllDayPaint.setColor(strand.allDays[i]); canvas.drawLine(mDayXs[i] + xOffset, DNA_MARGIN, mDayXs[i] + xOffset, DNA_MARGIN + DNA_ALL_DAY_HEIGHT, mDNAAllDayPaint); } } } } } @Override protected void updateSelectionPositions() { if (mHasSelectedDay) { int selectedPosition = mSelectedDay - mWeekStart; if (selectedPosition < 0) { selectedPosition += 7; } int effectiveWidth = mWidth - mPadding * 2; effectiveWidth -= SPACING_WEEK_NUMBER; mSelectedLeft = selectedPosition * effectiveWidth / mNumDays + mPadding; mSelectedRight = (selectedPosition + 1) * effectiveWidth / mNumDays + mPadding; mSelectedLeft += SPACING_WEEK_NUMBER; mSelectedRight += SPACING_WEEK_NUMBER; } } public int getDayIndexFromLocation(float x) { int dayStart = mShowWeekNum ? SPACING_WEEK_NUMBER + mPadding : mPadding; if (x < dayStart || x > mWidth - mPadding) { return -1; } // Selection is (x - start) / (pixels/day) == (x -s) * day / pixels return ((int) ((x - dayStart) * mNumDays / (mWidth - dayStart - mPadding))); } @Override public Time getDayFromLocation(float x) { int dayPosition = getDayIndexFromLocation(x); if (dayPosition == -1) { return null; } int day = mFirstJulianDay + dayPosition; Time time = new Time(mTimeZone); if (mWeek == 0) { // This week is weird... if (day < Time.EPOCH_JULIAN_DAY) { day++; } else if (day == Time.EPOCH_JULIAN_DAY) { time.set(1, 0, 1970); time.normalize(true); return time; } } time.setJulianDay(day); return time; } @Override public boolean onHoverEvent(MotionEvent event) { Context context = getContext(); // only send accessibility events if accessibility and exploration are // on. AccessibilityManager am = (AccessibilityManager) context .getSystemService(Service.ACCESSIBILITY_SERVICE); if (!am.isEnabled() || !am.isTouchExplorationEnabled()) { return super.onHoverEvent(event); } if (event.getAction() != MotionEvent.ACTION_HOVER_EXIT) { Time hover = getDayFromLocation(event.getX()); if (hover != null && (mLastHoverTime == null || Time.compare(hover, mLastHoverTime) != 0)) { Long millis = hover.toMillis(true); String date = Utils.formatDateRange(context, millis, millis, DateUtils.FORMAT_SHOW_DATE); AccessibilityEvent accessEvent = AccessibilityEvent .obtain(AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED); accessEvent.getText().add(date); if (mShowDetailsInMonth && mEvents != null) { int dayStart = SPACING_WEEK_NUMBER + mPadding; int dayPosition = (int) ((event.getX() - dayStart) * mNumDays / (mWidth - dayStart - mPadding)); ArrayList events = mEvents.get(dayPosition); List text = accessEvent.getText(); for (Event e : events) { text.add(e.getTitleAndLocation() + ". "); int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR; if (!e.allDay) { flags |= DateUtils.FORMAT_SHOW_TIME; if (DateFormat.is24HourFormat(context)) { flags |= DateUtils.FORMAT_24HOUR; } } else { flags |= DateUtils.FORMAT_UTC; } text.add(Utils.formatDateRange(context, e.startMillis, e.endMillis, flags) + ". "); } } sendAccessibilityEventUnchecked(accessEvent); mLastHoverTime = hover; } } return true; } public void setClickedDay(float xLocation) { mClickedDayIndex = getDayIndexFromLocation(xLocation); invalidate(); } public void clearClickedDay() { mClickedDayIndex = -1; invalidate(); } }