src/com/android/calendar/month/MonthByWeekAdapter.java - platform/packages/apps/Calendar - Git at Google

 /*
  * 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 android.content.Context;
 import android.content.res.Configuration;
 import android.os.Handler;
 import android.os.Message;
 import android.text.format.Time;
 import android.util.Log;
 import android.view.GestureDetector;
 import android.view.HapticFeedbackConstants;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.widget.AbsListView.LayoutParams;

 import com.android.calendar.CalendarController;
 import com.android.calendar.CalendarController.EventType;
 import com.android.calendar.CalendarController.ViewType;
 import com.android.calendar.Event;
 import com.android.calendar.R;
 import com.android.calendar.Utils;

 import java.util.ArrayList;
 import java.util.HashMap;

 public class MonthByWeekAdapter extends SimpleWeeksAdapter {
     private static final String TAG = "MonthByWeekAdapter";

     public static final String WEEK_PARAMS_IS_MINI = "mini_month";
     protected static int DEFAULT_QUERY_DAYS = 7 * 8; // 8 weeks
     private static final long ANIMATE_TODAY_TIMEOUT = 1000;

     protected CalendarController mController;
     protected String mHomeTimeZone;
     protected Time mTempTime;
     protected Time mToday;
     protected int mFirstJulianDay;
     protected int mQueryDays;
     protected boolean mIsMiniMonth = true;
     protected int mOrientation = Configuration.ORIENTATION_LANDSCAPE;
     private final boolean mShowAgendaWithMonth;

     protected ArrayList<ArrayList<Event>> mEventDayList = new ArrayList<ArrayList<Event>>();
     protected ArrayList<Event> mEvents = null;

     private boolean mAnimateToday = false;
     private long mAnimateTime = 0;

     private Handler mEventDialogHandler;

     MonthWeekEventsView mClickedView;
     MonthWeekEventsView mSingleTapUpView;
     MonthWeekEventsView mLongClickedView;

     float mClickedXLocation;                // Used to find which day was clicked
     long mClickTime;                        // Used to calculate minimum click animation time
     // Used to insure minimal time for seeing the click animation before switching views
     private static final int mOnTapDelay = 100;
     // Minimal time for a down touch action before stating the click animation, this insures that
     // there is no click animation on flings
     private static int mOnDownDelay;
     private static int mTotalClickDelay;
     // Minimal distance to move the finger in order to cancel the click animation
     private static float mMovedPixelToCancel;

     public MonthByWeekAdapter(Context context, HashMap<String, Integer> params, Handler handler) {
         super(context, params);
         mEventDialogHandler = handler;
         if (params.containsKey(WEEK_PARAMS_IS_MINI)) {
             mIsMiniMonth = params.get(WEEK_PARAMS_IS_MINI) != 0;
         }
         mShowAgendaWithMonth = Utils.getConfigBool(context, R.bool.show_agenda_with_month);
         ViewConfiguration vc = ViewConfiguration.get(context);
         mOnDownDelay = ViewConfiguration.getTapTimeout();
         mMovedPixelToCancel = vc.getScaledTouchSlop();
         mTotalClickDelay = mOnDownDelay + mOnTapDelay;
     }

     public void animateToday() {
         mAnimateToday = true;
         mAnimateTime = System.currentTimeMillis();
     }

     @Override
     protected void init() {
         super.init();
         mGestureDetector = new GestureDetector(mContext, new CalendarGestureListener());
         mController = CalendarController.getInstance(mContext);
         mHomeTimeZone = Utils.getTimeZone(mContext, null);
         mSelectedDay.switchTimezone(mHomeTimeZone);
         mToday = new Time(mHomeTimeZone);
         mToday.setToNow();
         mTempTime = new Time(mHomeTimeZone);
     }

     private void updateTimeZones() {
         mSelectedDay.timezone = mHomeTimeZone;
         mSelectedDay.normalize(true);
         mToday.timezone = mHomeTimeZone;
         mToday.setToNow();
         mTempTime.switchTimezone(mHomeTimeZone);
     }

     @Override
     public void setSelectedDay(Time selectedTime) {
         mSelectedDay.set(selectedTime);
         long millis = mSelectedDay.normalize(true);
         mSelectedWeek = Utils.getWeeksSinceEpochFromJulianDay(
                 Time.getJulianDay(millis, mSelectedDay.gmtoff), mFirstDayOfWeek);
         notifyDataSetChanged();
     }

     public void setEvents(int firstJulianDay, int numDays, ArrayList<Event> events) {
         if (mIsMiniMonth) {
             if (Log.isLoggable(TAG, Log.ERROR)) {
                 Log.e(TAG, "Attempted to set events for mini view. Events only supported in full"
                         + " view.");
             }
             return;
         }
         mEvents = events;
         mFirstJulianDay = firstJulianDay;
         mQueryDays = numDays;
         // Create a new list, this is necessary since the weeks are referencing
         // pieces of the old list
         ArrayList<ArrayList<Event>> eventDayList = new ArrayList<ArrayList<Event>>();
         for (int i = 0; i < numDays; i++) {
             eventDayList.add(new ArrayList<Event>());
         }

         if (events == null || events.size() == 0) {
             if(Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "No events. Returning early--go schedule something fun.");
             }
             mEventDayList = eventDayList;
             refresh();
             return;
         }

         // Compute the new set of days with events
         for (Event event : events) {
             int startDay = event.startDay - mFirstJulianDay;
             int endDay = event.endDay - mFirstJulianDay + 1;
             if (startDay < numDays || endDay >= 0) {
                 if (startDay < 0) {
                     startDay = 0;
                 }
                 if (startDay > numDays) {
                     continue;
                 }
                 if (endDay < 0) {
                     continue;
                 }
                 if (endDay > numDays) {
                     endDay = numDays;
                 }
                 for (int j = startDay; j < endDay; j++) {
                     eventDayList.get(j).add(event);
                 }
             }
         }
         if(Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "Processed " + events.size() + " events.");
         }
         mEventDayList = eventDayList;
         refresh();
     }

     @SuppressWarnings("unchecked")
     @Override
     public View getView(int position, View convertView, ViewGroup parent) {
         if (mIsMiniMonth) {
             return super.getView(position, convertView, parent);
         }
         MonthWeekEventsView v;
         LayoutParams params = new LayoutParams(
                 LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
         HashMap<String, Integer> drawingParams = null;
         boolean isAnimatingToday = false;
         if (convertView != null) {
             v = (MonthWeekEventsView) convertView;
             // Checking updateToday uses the current params instead of the new
             // params, so this is assuming the view is relatively stable
             if (mAnimateToday && v.updateToday(mSelectedDay.timezone)) {
                 long currentTime = System.currentTimeMillis();
                 // If it's been too long since we tried to start the animation
                 // don't show it. This can happen if the user stops a scroll
                 // before reaching today.
                 if (currentTime - mAnimateTime > ANIMATE_TODAY_TIMEOUT) {
                     mAnimateToday = false;
                     mAnimateTime = 0;
                 } else {
                     isAnimatingToday = true;
                     // There is a bug that causes invalidates to not work some
                     // of the time unless we recreate the view.
                     v = new MonthWeekEventsView(mContext);
                }
             } else {
                 drawingParams = (HashMap<String, Integer>) v.getTag();
             }
         } else {
             v = new MonthWeekEventsView(mContext);
         }
         if (drawingParams == null) {
             drawingParams = new HashMap<String, Integer>();
         }
         drawingParams.clear();

         v.setLayoutParams(params);
         v.setClickable(true);
         v.setOnTouchListener(this);

         int selectedDay = -1;
         if (mSelectedWeek == position) {
             selectedDay = mSelectedDay.weekDay;
         }

         drawingParams.put(SimpleWeekView.VIEW_PARAMS_HEIGHT,
                 (parent.getHeight() + parent.getTop()) / mNumWeeks);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_SELECTED_DAY, selectedDay);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_SHOW_WK_NUM, mShowWeekNumber ? 1 : 0);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK_START, mFirstDayOfWeek);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_NUM_DAYS, mDaysPerWeek);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK, position);
         drawingParams.put(SimpleWeekView.VIEW_PARAMS_FOCUS_MONTH, mFocusMonth);
         drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ORIENTATION, mOrientation);

         if (isAnimatingToday) {
             drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ANIMATE_TODAY, 1);
             mAnimateToday = false;
         }

         v.setWeekParams(drawingParams, mSelectedDay.timezone);
         sendEventsToView(v);
         return v;
     }

     private void sendEventsToView(MonthWeekEventsView v) {
         if (mEventDayList.size() == 0) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "No events loaded, did not pass any events to view.");
             }
             v.setEvents(null, null);
             return;
         }
         int viewJulianDay = v.getFirstJulianDay();
         int start = viewJulianDay - mFirstJulianDay;
         int end = start + v.mNumDays;
         if (start < 0 || end > mEventDayList.size()) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "Week is outside range of loaded events. viewStart: " + viewJulianDay
                         + " eventsStart: " + mFirstJulianDay);
             }
             v.setEvents(null, null);
             return;
         }
         v.setEvents(mEventDayList.subList(start, end), mEvents);
     }

     @Override
     protected void refresh() {
         mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext);
         mShowWeekNumber = Utils.getShowWeekNumber(mContext);
         mHomeTimeZone = Utils.getTimeZone(mContext, null);
         mOrientation = mContext.getResources().getConfiguration().orientation;
         updateTimeZones();
         notifyDataSetChanged();
     }

     @Override
     protected void onDayTapped(Time day) {
         setDayParameters(day);
          if (mShowAgendaWithMonth || mIsMiniMonth) {
             // If agenda view is visible with month view , refresh the views
             // with the selected day's info
             mController.sendEvent(mContext, EventType.GO_TO, day, day, -1,
                     ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null);
         } else {
             // Else , switch to the detailed view
             mController.sendEvent(mContext, EventType.GO_TO, day, day, -1,
                     ViewType.DETAIL,
                             CalendarController.EXTRA_GOTO_DATE
                             | CalendarController.EXTRA_GOTO_BACK_TO_PREVIOUS, null, null);
         }
     }

     private void setDayParameters(Time day) {
         day.timezone = mHomeTimeZone;
         Time currTime = new Time(mHomeTimeZone);
         currTime.set(mController.getTime());
         day.hour = currTime.hour;
         day.minute = currTime.minute;
         day.allDay = false;
         day.normalize(true);
     }

     @Override
     public boolean onTouch(View v, MotionEvent event) {
         if (!(v instanceof MonthWeekEventsView)) {
             return super.onTouch(v, event);
         }

         int action = event.getAction();

         // Event was tapped - switch to the detailed view making sure the click animation
         // is done first.
         if (mGestureDetector.onTouchEvent(event)) {
             mSingleTapUpView = (MonthWeekEventsView) v;
             long delay = System.currentTimeMillis() - mClickTime;
             // Make sure the animation is visible for at least mOnTapDelay - mOnDownDelay ms
             mListView.postDelayed(mDoSingleTapUp,
                     delay > mTotalClickDelay ? 0 : mTotalClickDelay - delay);
             return true;
         } else {
             // Animate a click - on down: show the selected day in the "clicked" color.
             // On Up/scroll/move/cancel: hide the "clicked" color.
             switch (action) {
                 case MotionEvent.ACTION_DOWN:
                     mClickedView = (MonthWeekEventsView)v;
                     mClickedXLocation = event.getX();
                     mClickTime = System.currentTimeMillis();
                     mListView.postDelayed(mDoClick, mOnDownDelay);
                     break;
                 case MotionEvent.ACTION_UP:
                 case MotionEvent.ACTION_SCROLL:
                 case MotionEvent.ACTION_CANCEL:
                     clearClickedView((MonthWeekEventsView)v);
                     break;
                 case MotionEvent.ACTION_MOVE:
                     // No need to cancel on vertical movement, ACTION_SCROLL will do that.
                     if (Math.abs(event.getX() - mClickedXLocation) > mMovedPixelToCancel) {
                         clearClickedView((MonthWeekEventsView)v);
                     }
                     break;
                 default:
                     break;
             }
         }
         // Do not tell the frameworks we consumed the touch action so that fling actions can be
         // processed by the fragment.
         return false;
     }

     /**
      * This is here so we can identify events and process them
      */
     protected class CalendarGestureListener extends GestureDetector.SimpleOnGestureListener {
         @Override
         public boolean onSingleTapUp(MotionEvent e) {
             return true;
         }

         @Override
         public void onLongPress(MotionEvent e) {
             if (mLongClickedView != null) {
                 Time day = mLongClickedView.getDayFromLocation(mClickedXLocation);
                 if (day != null) {
                     mLongClickedView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
                     Message message = new Message();
                     message.obj = day;
                     mEventDialogHandler.sendMessage(message);
                 }
                 mLongClickedView.clearClickedDay();
                 mLongClickedView = null;
              }
         }
     }

     // Clear the visual cues of the click animation and related running code.
     private void clearClickedView(MonthWeekEventsView v) {
         mListView.removeCallbacks(mDoClick);
         synchronized(v) {
             v.clearClickedDay();
         }
         mClickedView = null;
     }

     // Perform the tap animation in a runnable to allow a delay before showing the tap color.
     // This is done to prevent a click animation when a fling is done.
     private final Runnable mDoClick = new Runnable() {
         @Override
         public void run() {
             if (mClickedView != null) {
                 synchronized(mClickedView) {
                     mClickedView.setClickedDay(mClickedXLocation);
                 }
                 mLongClickedView = mClickedView;
                 mClickedView = null;
                 // This is a workaround , sometimes the top item on the listview doesn't refresh on
                 // invalidate, so this forces a re-draw.
                 mListView.invalidate();
             }
         }
     };

     // Performs the single tap operation: go to the tapped day.
     // This is done in a runnable to allow the click animation to finish before switching views
     private final Runnable mDoSingleTapUp = new Runnable() {
         @Override
         public void run() {
             if (mSingleTapUpView != null) {
                 Time day = mSingleTapUpView.getDayFromLocation(mClickedXLocation);
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "Touched day at Row=" + mSingleTapUpView.mWeek + " day=" + day.toString());
                 }
                 if (day != null) {
                     onDayTapped(day);
                 }
                 clearClickedView(mSingleTapUpView);
                 mSingleTapUpView = null;
             }
         }
     };
 }
	/*
	* 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 android.content.Context;
	import android.content.res.Configuration;
	import android.os.Handler;
	import android.os.Message;
	import android.text.format.Time;
	import android.util.Log;
	import android.view.GestureDetector;
	import android.view.HapticFeedbackConstants;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewConfiguration;
	import android.view.ViewGroup;
	import android.widget.AbsListView.LayoutParams;

	import com.android.calendar.CalendarController;
	import com.android.calendar.CalendarController.EventType;
	import com.android.calendar.CalendarController.ViewType;
	import com.android.calendar.Event;
	import com.android.calendar.R;
	import com.android.calendar.Utils;

	import java.util.ArrayList;
	import java.util.HashMap;

	public class MonthByWeekAdapter extends SimpleWeeksAdapter {
	private static final String TAG = "MonthByWeekAdapter";

	public static final String WEEK_PARAMS_IS_MINI = "mini_month";
	protected static int DEFAULT_QUERY_DAYS = 7 * 8; // 8 weeks
	private static final long ANIMATE_TODAY_TIMEOUT = 1000;

	protected CalendarController mController;
	protected String mHomeTimeZone;
	protected Time mTempTime;
	protected Time mToday;
	protected int mFirstJulianDay;
	protected int mQueryDays;
	protected boolean mIsMiniMonth = true;
	protected int mOrientation = Configuration.ORIENTATION_LANDSCAPE;
	private final boolean mShowAgendaWithMonth;

	protected ArrayList<ArrayList<Event>> mEventDayList = new ArrayList<ArrayList<Event>>();
	protected ArrayList<Event> mEvents = null;

	private boolean mAnimateToday = false;
	private long mAnimateTime = 0;

	private Handler mEventDialogHandler;

	MonthWeekEventsView mClickedView;
	MonthWeekEventsView mSingleTapUpView;
	MonthWeekEventsView mLongClickedView;

	float mClickedXLocation; // Used to find which day was clicked
	long mClickTime; // Used to calculate minimum click animation time
	// Used to insure minimal time for seeing the click animation before switching views
	private static final int mOnTapDelay = 100;
	// Minimal time for a down touch action before stating the click animation, this insures that
	// there is no click animation on flings
	private static int mOnDownDelay;
	private static int mTotalClickDelay;
	// Minimal distance to move the finger in order to cancel the click animation
	private static float mMovedPixelToCancel;

	public MonthByWeekAdapter(Context context, HashMap<String, Integer> params, Handler handler) {
	super(context, params);
	mEventDialogHandler = handler;
	if (params.containsKey(WEEK_PARAMS_IS_MINI)) {
	mIsMiniMonth = params.get(WEEK_PARAMS_IS_MINI) != 0;
	}
	mShowAgendaWithMonth = Utils.getConfigBool(context, R.bool.show_agenda_with_month);
	ViewConfiguration vc = ViewConfiguration.get(context);
	mOnDownDelay = ViewConfiguration.getTapTimeout();
	mMovedPixelToCancel = vc.getScaledTouchSlop();
	mTotalClickDelay = mOnDownDelay + mOnTapDelay;
	}

	public void animateToday() {
	mAnimateToday = true;
	mAnimateTime = System.currentTimeMillis();
	}

	@Override
	protected void init() {
	super.init();
	mGestureDetector = new GestureDetector(mContext, new CalendarGestureListener());
	mController = CalendarController.getInstance(mContext);
	mHomeTimeZone = Utils.getTimeZone(mContext, null);
	mSelectedDay.switchTimezone(mHomeTimeZone);
	mToday = new Time(mHomeTimeZone);
	mToday.setToNow();
	mTempTime = new Time(mHomeTimeZone);
	}

	private void updateTimeZones() {
	mSelectedDay.timezone = mHomeTimeZone;
	mSelectedDay.normalize(true);
	mToday.timezone = mHomeTimeZone;
	mToday.setToNow();
	mTempTime.switchTimezone(mHomeTimeZone);
	}

	@Override
	public void setSelectedDay(Time selectedTime) {
	mSelectedDay.set(selectedTime);
	long millis = mSelectedDay.normalize(true);
	mSelectedWeek = Utils.getWeeksSinceEpochFromJulianDay(
	Time.getJulianDay(millis, mSelectedDay.gmtoff), mFirstDayOfWeek);
	notifyDataSetChanged();
	}

	public void setEvents(int firstJulianDay, int numDays, ArrayList<Event> events) {
	if (mIsMiniMonth) {
	if (Log.isLoggable(TAG, Log.ERROR)) {
	Log.e(TAG, "Attempted to set events for mini view. Events only supported in full"
	+ " view.");
	}
	return;
	}
	mEvents = events;
	mFirstJulianDay = firstJulianDay;
	mQueryDays = numDays;
	// Create a new list, this is necessary since the weeks are referencing
	// pieces of the old list
	ArrayList<ArrayList<Event>> eventDayList = new ArrayList<ArrayList<Event>>();
	for (int i = 0; i < numDays; i++) {
	eventDayList.add(new ArrayList<Event>());
	}

	if (events == null \|\| events.size() == 0) {
	if(Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "No events. Returning early--go schedule something fun.");
	}
	mEventDayList = eventDayList;
	refresh();
	return;
	}

	// Compute the new set of days with events
	for (Event event : events) {
	int startDay = event.startDay - mFirstJulianDay;
	int endDay = event.endDay - mFirstJulianDay + 1;
	if (startDay < numDays \|\| endDay >= 0) {
	if (startDay < 0) {
	startDay = 0;
	}
	if (startDay > numDays) {
	continue;
	}
	if (endDay < 0) {
	continue;
	}
	if (endDay > numDays) {
	endDay = numDays;
	}
	for (int j = startDay; j < endDay; j++) {
	eventDayList.get(j).add(event);
	}
	}
	}
	if(Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Processed " + events.size() + " events.");
	}
	mEventDayList = eventDayList;
	refresh();
	}

	@SuppressWarnings("unchecked")
	@Override
	public View getView(int position, View convertView, ViewGroup parent) {
	if (mIsMiniMonth) {
	return super.getView(position, convertView, parent);
	}
	MonthWeekEventsView v;
	LayoutParams params = new LayoutParams(
	LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
	HashMap<String, Integer> drawingParams = null;
	boolean isAnimatingToday = false;
	if (convertView != null) {
	v = (MonthWeekEventsView) convertView;
	// Checking updateToday uses the current params instead of the new
	// params, so this is assuming the view is relatively stable
	if (mAnimateToday && v.updateToday(mSelectedDay.timezone)) {
	long currentTime = System.currentTimeMillis();
	// If it's been too long since we tried to start the animation
	// don't show it. This can happen if the user stops a scroll
	// before reaching today.
	if (currentTime - mAnimateTime > ANIMATE_TODAY_TIMEOUT) {
	mAnimateToday = false;
	mAnimateTime = 0;
	} else {
	isAnimatingToday = true;
	// There is a bug that causes invalidates to not work some
	// of the time unless we recreate the view.
	v = new MonthWeekEventsView(mContext);
	}
	} else {
	drawingParams = (HashMap<String, Integer>) v.getTag();
	}
	} else {
	v = new MonthWeekEventsView(mContext);
	}
	if (drawingParams == null) {
	drawingParams = new HashMap<String, Integer>();
	}
	drawingParams.clear();

	v.setLayoutParams(params);
	v.setClickable(true);
	v.setOnTouchListener(this);

	int selectedDay = -1;
	if (mSelectedWeek == position) {
	selectedDay = mSelectedDay.weekDay;
	}

	drawingParams.put(SimpleWeekView.VIEW_PARAMS_HEIGHT,
	(parent.getHeight() + parent.getTop()) / mNumWeeks);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_SELECTED_DAY, selectedDay);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_SHOW_WK_NUM, mShowWeekNumber ? 1 : 0);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK_START, mFirstDayOfWeek);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_NUM_DAYS, mDaysPerWeek);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_WEEK, position);
	drawingParams.put(SimpleWeekView.VIEW_PARAMS_FOCUS_MONTH, mFocusMonth);
	drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ORIENTATION, mOrientation);

	if (isAnimatingToday) {
	drawingParams.put(MonthWeekEventsView.VIEW_PARAMS_ANIMATE_TODAY, 1);
	mAnimateToday = false;
	}

	v.setWeekParams(drawingParams, mSelectedDay.timezone);
	sendEventsToView(v);
	return v;
	}

	private void sendEventsToView(MonthWeekEventsView v) {
	if (mEventDayList.size() == 0) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "No events loaded, did not pass any events to view.");
	}
	v.setEvents(null, null);
	return;
	}
	int viewJulianDay = v.getFirstJulianDay();
	int start = viewJulianDay - mFirstJulianDay;
	int end = start + v.mNumDays;
	if (start < 0 \|\| end > mEventDayList.size()) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Week is outside range of loaded events. viewStart: " + viewJulianDay
	+ " eventsStart: " + mFirstJulianDay);
	}
	v.setEvents(null, null);
	return;
	}
	v.setEvents(mEventDayList.subList(start, end), mEvents);
	}

	@Override
	protected void refresh() {
	mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext);
	mShowWeekNumber = Utils.getShowWeekNumber(mContext);
	mHomeTimeZone = Utils.getTimeZone(mContext, null);
	mOrientation = mContext.getResources().getConfiguration().orientation;
	updateTimeZones();
	notifyDataSetChanged();
	}

	@Override
	protected void onDayTapped(Time day) {
	setDayParameters(day);
	if (mShowAgendaWithMonth \|\| mIsMiniMonth) {
	// If agenda view is visible with month view , refresh the views
	// with the selected day's info
	mController.sendEvent(mContext, EventType.GO_TO, day, day, -1,
	ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null);
	} else {
	// Else , switch to the detailed view
	mController.sendEvent(mContext, EventType.GO_TO, day, day, -1,
	ViewType.DETAIL,
	CalendarController.EXTRA_GOTO_DATE
	\| CalendarController.EXTRA_GOTO_BACK_TO_PREVIOUS, null, null);
	}
	}

	private void setDayParameters(Time day) {
	day.timezone = mHomeTimeZone;
	Time currTime = new Time(mHomeTimeZone);
	currTime.set(mController.getTime());
	day.hour = currTime.hour;
	day.minute = currTime.minute;
	day.allDay = false;
	day.normalize(true);
	}

	@Override
	public boolean onTouch(View v, MotionEvent event) {
	if (!(v instanceof MonthWeekEventsView)) {
	return super.onTouch(v, event);
	}

	int action = event.getAction();

	// Event was tapped - switch to the detailed view making sure the click animation
	// is done first.
	if (mGestureDetector.onTouchEvent(event)) {
	mSingleTapUpView = (MonthWeekEventsView) v;
	long delay = System.currentTimeMillis() - mClickTime;
	// Make sure the animation is visible for at least mOnTapDelay - mOnDownDelay ms
	mListView.postDelayed(mDoSingleTapUp,
	delay > mTotalClickDelay ? 0 : mTotalClickDelay - delay);
	return true;
	} else {
	// Animate a click - on down: show the selected day in the "clicked" color.
	// On Up/scroll/move/cancel: hide the "clicked" color.
	switch (action) {
	case MotionEvent.ACTION_DOWN:
	mClickedView = (MonthWeekEventsView)v;
	mClickedXLocation = event.getX();
	mClickTime = System.currentTimeMillis();
	mListView.postDelayed(mDoClick, mOnDownDelay);
	break;
	case MotionEvent.ACTION_UP:
	case MotionEvent.ACTION_SCROLL:
	case MotionEvent.ACTION_CANCEL:
	clearClickedView((MonthWeekEventsView)v);
	break;
	case MotionEvent.ACTION_MOVE:
	// No need to cancel on vertical movement, ACTION_SCROLL will do that.
	if (Math.abs(event.getX() - mClickedXLocation) > mMovedPixelToCancel) {
	clearClickedView((MonthWeekEventsView)v);
	}
	break;
	default:
	break;
	}
	}
	// Do not tell the frameworks we consumed the touch action so that fling actions can be
	// processed by the fragment.
	return false;
	}

	/**
	* This is here so we can identify events and process them
	*/
	protected class CalendarGestureListener extends GestureDetector.SimpleOnGestureListener {
	@Override
	public boolean onSingleTapUp(MotionEvent e) {
	return true;
	}

	@Override
	public void onLongPress(MotionEvent e) {
	if (mLongClickedView != null) {
	Time day = mLongClickedView.getDayFromLocation(mClickedXLocation);
	if (day != null) {
	mLongClickedView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
	Message message = new Message();
	message.obj = day;
	mEventDialogHandler.sendMessage(message);
	}
	mLongClickedView.clearClickedDay();
	mLongClickedView = null;
	}
	}
	}

	// Clear the visual cues of the click animation and related running code.
	private void clearClickedView(MonthWeekEventsView v) {
	mListView.removeCallbacks(mDoClick);
	synchronized(v) {
	v.clearClickedDay();
	}
	mClickedView = null;
	}

	// Perform the tap animation in a runnable to allow a delay before showing the tap color.
	// This is done to prevent a click animation when a fling is done.
	private final Runnable mDoClick = new Runnable() {
	@Override
	public void run() {
	if (mClickedView != null) {
	synchronized(mClickedView) {
	mClickedView.setClickedDay(mClickedXLocation);
	}
	mLongClickedView = mClickedView;
	mClickedView = null;
	// This is a workaround , sometimes the top item on the listview doesn't refresh on
	// invalidate, so this forces a re-draw.
	mListView.invalidate();
	}
	}
	};

	// Performs the single tap operation: go to the tapped day.
	// This is done in a runnable to allow the click animation to finish before switching views
	private final Runnable mDoSingleTapUp = new Runnable() {
	@Override
	public void run() {
	if (mSingleTapUpView != null) {
	Time day = mSingleTapUpView.getDayFromLocation(mClickedXLocation);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Touched day at Row=" + mSingleTapUpView.mWeek + " day=" + day.toString());
	}
	if (day != null) {
	onDayTapped(day);
	}
	clearClickedView(mSingleTapUpView);
	mSingleTapUpView = null;
	}
	}
	};
	}