AOSP/Calendar - Initial Conversion of DayView
This is how Android Studio's built-in converter
converted DayView.java to Kotlin without any
additional edits.
Change-Id: Icc9a779706d9962b2edd4975d1df2b209cb9dea0
diff --git a/src/com/android/calendar/DayView.kt b/src/com/android/calendar/DayView.kt
index 2fc00b3..ce8ad12 100644
--- a/src/com/android/calendar/DayView.kt
+++ b/src/com/android/calendar/DayView.kt
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2007 The Android Open Source Project
+ * Copyright (C) 2021 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.
@@ -13,119 +13,23 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+package com.android.calendar
-package com.android.calendar;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
-import android.animation.ValueAnimator;
-import android.app.AlertDialog;
-import android.app.Service;
-import android.content.ContentResolver;
-import android.content.ContentUris;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.res.Resources;
-import android.content.res.TypedArray;
-import android.database.Cursor;
-import android.graphics.Canvas;
-import android.graphics.Paint;
-import android.graphics.Paint.Align;
-import android.graphics.Paint.Style;
-import android.graphics.Rect;
-import android.graphics.Typeface;
-import android.graphics.drawable.Drawable;
-import android.net.Uri;
-import android.os.Handler;
-import android.provider.CalendarContract.Attendees;
-import android.provider.CalendarContract.Calendars;
-import android.provider.CalendarContract.Events;
-import android.text.Layout.Alignment;
-import android.text.SpannableStringBuilder;
-import android.text.StaticLayout;
-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.text.style.StyleSpan;
-import android.util.Log;
-import android.view.ContextMenu;
-import android.view.ContextMenu.ContextMenuInfo;
-import android.view.GestureDetector;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.LayoutInflater;
-import android.view.MenuItem;
-import android.view.MotionEvent;
-import android.view.ScaleGestureDetector;
-import android.view.View;
-import android.view.ViewConfiguration;
-import android.view.ViewGroup;
-import android.view.WindowManager;
-import android.view.accessibility.AccessibilityEvent;
-import android.view.accessibility.AccessibilityManager;
-import android.view.animation.AccelerateDecelerateInterpolator;
-import android.view.animation.Animation;
-import android.view.animation.Interpolator;
-import android.view.animation.TranslateAnimation;
-import android.widget.EdgeEffect;
-import android.widget.ImageView;
-import android.widget.OverScroller;
-import android.widget.PopupWindow;
-import android.widget.TextView;
-import android.widget.ViewSwitcher;
-
-import com.android.calendar.CalendarController.EventType;
-import com.android.calendar.CalendarController.ViewType;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Formatter;
-import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import android.animation.Animator
/**
* View for multi-day view. So far only 1 and 7 day have been tested.
*/
-public class DayView extends View implements View.OnCreateContextMenuListener,
- ScaleGestureDetector.OnScaleGestureListener, View.OnClickListener, View.OnLongClickListener
- {
- private static String TAG = "DayView";
- private static boolean DEBUG = false;
- private static boolean DEBUG_SCALING = false;
- private static final String PERIOD_SPACE = ". ";
+class DayView(
+ context: Context, controller: CalendarController,
+ viewSwitcher: ViewSwitcher, eventLoader: EventLoader, numDays: Int
+) : View(context), View.OnCreateContextMenuListener, ScaleGestureDetector.OnScaleGestureListener,
+ View.OnClickListener, View.OnLongClickListener {
+ private var mOnFlingCalled = false
+ private var mStartingScroll = false
+ protected var mPaused = true
+ private var mHandler: Handler? = null
- private static float mScale = 0; // Used for supporting different screen densities
- private static final long INVALID_EVENT_ID = -1; //This is used for remembering a null event
- // Duration of the allday expansion
- private static final long ANIMATION_DURATION = 400;
- // duration of the more allday event text fade
- private static final long ANIMATION_SECONDARY_DURATION = 200;
- // duration of the scroll to go to a specified time
- private static final int GOTO_SCROLL_DURATION = 200;
- // duration for events' cross-fade animation
- private static final int EVENTS_CROSS_FADE_DURATION = 400;
- // duration to show the event clicked
- private static final int CLICK_DISPLAY_DURATION = 50;
-
- private static final int MENU_DAY = 3;
- private static final int MENU_EVENT_VIEW = 5;
- private static final int MENU_EVENT_CREATE = 6;
- private static final int MENU_EVENT_EDIT = 7;
- private static final int MENU_EVENT_DELETE = 8;
-
- private static int DEFAULT_CELL_HEIGHT = 64;
- private static int MAX_CELL_HEIGHT = 150;
- private static int MIN_Y_SPAN = 100;
-
- private boolean mOnFlingCalled;
- private boolean mStartingScroll = false;
- protected boolean mPaused = true;
- private Handler mHandler;
/**
* ID of the last event which was displayed with the toast popup.
*
@@ -134,166 +38,137 @@
* on starting calendar or by scrolling to an event. It becomes invalid when the user
* explicitly scrolls to an empty time slot, changes views, or deletes the event.
*/
- private long mLastPopupEventID;
-
- protected Context mContext;
-
- private static final String[] CALENDARS_PROJECTION = new String[] {
- Calendars._ID, // 0
- Calendars.CALENDAR_ACCESS_LEVEL, // 1
- Calendars.OWNER_ACCOUNT, // 2
- };
- private static final int CALENDARS_INDEX_ACCESS_LEVEL = 1;
- private static final int CALENDARS_INDEX_OWNER_ACCOUNT = 2;
- private static final String CALENDARS_WHERE = Calendars._ID + "=%d";
-
- private static final int FROM_NONE = 0;
- private static final int FROM_ABOVE = 1;
- private static final int FROM_BELOW = 2;
- private static final int FROM_LEFT = 4;
- private static final int FROM_RIGHT = 8;
-
- private static final int ACCESS_LEVEL_NONE = 0;
- private static final int ACCESS_LEVEL_DELETE = 1;
- private static final int ACCESS_LEVEL_EDIT = 2;
-
- private static int mHorizontalSnapBackThreshold = 128;
-
- private final ContinueScroll mContinueScroll = new ContinueScroll();
+ private var mLastPopupEventID: Long
+ protected var mContext: Context
+ private val mContinueScroll: ContinueScroll = ContinueScroll()
// Make this visible within the package for more informative debugging
- Time mBaseDate;
- private Time mCurrentTime;
- //Update the current time line every five minutes if the window is left open that long
- private static final int UPDATE_CURRENT_TIME_DELAY = 300000;
- private final UpdateCurrentTime mUpdateCurrentTime = new UpdateCurrentTime();
- private int mTodayJulianDay;
-
- private final Typeface mBold = Typeface.DEFAULT_BOLD;
- private int mFirstJulianDay;
- private int mLoadedFirstJulianDay = -1;
- private int mLastJulianDay;
-
- private int mMonthLength;
- private int mFirstVisibleDate;
- private int mFirstVisibleDayOfWeek;
- private int[] mEarliestStartHour; // indexed by the week day offset
- private boolean[] mHasAllDayEvent; // indexed by the week day offset
- private String mEventCountTemplate;
- private Event mClickedEvent; // The event the user clicked on
- private Event mSavedClickedEvent;
- private static int mOnDownDelay;
- private int mClickedYLocation;
- private long mDownTouchTime;
-
- private int mEventsAlpha = 255;
- private ObjectAnimator mEventsCrossFadeAnimation;
-
- protected static StringBuilder mStringBuilder = new StringBuilder(50);
- // TODO recreate formatter when locale changes
- protected static Formatter mFormatter = new Formatter(mStringBuilder, Locale.getDefault());
-
- private final Runnable mTZUpdater = new Runnable() {
+ var mBaseDate: Time? = null
+ private var mCurrentTime: Time? = null
+ private val mUpdateCurrentTime: UpdateCurrentTime = UpdateCurrentTime()
+ private var mTodayJulianDay = 0
+ private val mBold: Typeface = Typeface.DEFAULT_BOLD
+ private var mFirstJulianDay = 0
+ private var mLoadedFirstJulianDay = -1
+ private var mLastJulianDay = 0
+ private var mMonthLength = 0
+ private var mFirstVisibleDate = 0
+ private var mFirstVisibleDayOfWeek = 0
+ private var mEarliestStartHour // indexed by the week day offset
+ : IntArray
+ private var mHasAllDayEvent // indexed by the week day offset
+ : BooleanArray
+ private var mEventCountTemplate: String? = null
+ private var mClickedEvent // The event the user clicked on
+ : Event? = null
+ private var mSavedClickedEvent: Event? = null
+ private var mClickedYLocation = 0
+ private var mDownTouchTime: Long = 0
+ private var mEventsAlpha = 255
+ private var mEventsCrossFadeAnimation: ObjectAnimator? = null
+ private val mTZUpdater: Runnable = object : Runnable() {
@Override
- public void run() {
- String tz = Utils.getTimeZone(mContext, this);
- mBaseDate.timezone = tz;
- mBaseDate.normalize(true);
- mCurrentTime.switchTimezone(tz);
- invalidate();
+ fun run() {
+ val tz: String = Utils.getTimeZone(mContext, this)
+ mBaseDate.timezone = tz
+ mBaseDate.normalize(true)
+ mCurrentTime.switchTimezone(tz)
+ invalidate()
}
- };
+ }
// Sets the "clicked" color from the clicked event
- private final Runnable mSetClick = new Runnable() {
+ private val mSetClick: Runnable = object : Runnable() {
@Override
- public void run() {
- mClickedEvent = mSavedClickedEvent;
- mSavedClickedEvent = null;
- DayView.this.invalidate();
+ fun run() {
+ mClickedEvent = mSavedClickedEvent
+ mSavedClickedEvent = null
+ this@DayView.invalidate()
}
- };
+ }
// Clears the "clicked" color from the clicked event and launch the event
- private final Runnable mClearClick = new Runnable() {
+ private val mClearClick: Runnable = object : Runnable() {
@Override
- public void run() {
+ fun run() {
if (mClickedEvent != null) {
- mController.sendEventRelatedEvent(this, EventType.VIEW_EVENT, mClickedEvent.id,
- mClickedEvent.startMillis, mClickedEvent.endMillis,
- DayView.this.getWidth() / 2, mClickedYLocation,
- getSelectedTimeInMillis());
+ mController.sendEventRelatedEvent(
+ this, EventType.VIEW_EVENT, mClickedEvent.id,
+ mClickedEvent.startMillis, mClickedEvent.endMillis,
+ this@DayView.getWidth() / 2, mClickedYLocation,
+ selectedTimeInMillis
+ )
}
- mClickedEvent = null;
- DayView.this.invalidate();
+ mClickedEvent = null
+ this@DayView.invalidate()
}
- };
+ }
+ private val mTodayAnimatorListener: TodayAnimatorListener = TodayAnimatorListener()
- private final TodayAnimatorListener mTodayAnimatorListener = new TodayAnimatorListener();
+ internal inner class TodayAnimatorListener : AnimatorListenerAdapter() {
+ @Volatile
+ private var mAnimator: Animator? = null
- class TodayAnimatorListener extends AnimatorListenerAdapter {
- private volatile Animator mAnimator = null;
- private volatile boolean mFadingIn = false;
-
+ @Volatile
+ private var mFadingIn = false
@Override
- public void onAnimationEnd(Animator animation) {
- synchronized (this) {
- if (mAnimator != animation) {
- animation.removeAllListeners();
- animation.cancel();
- return;
+ fun onAnimationEnd(animation: Animator) {
+ synchronized(this) {
+ if (mAnimator !== animation) {
+ animation.removeAllListeners()
+ animation.cancel()
+ return
}
if (mFadingIn) {
if (mTodayAnimator != null) {
- mTodayAnimator.removeAllListeners();
- mTodayAnimator.cancel();
+ mTodayAnimator.removeAllListeners()
+ mTodayAnimator.cancel()
}
mTodayAnimator = ObjectAnimator
- .ofInt(DayView.this, "animateTodayAlpha", 255, 0);
- mAnimator = mTodayAnimator;
- mFadingIn = false;
- mTodayAnimator.addListener(this);
- mTodayAnimator.setDuration(600);
- mTodayAnimator.start();
+ .ofInt(this@DayView, "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();
+ mAnimateToday = false
+ mAnimateTodayAlpha = 0
+ mAnimator.removeAllListeners()
+ mAnimator = null
+ mTodayAnimator = null
+ invalidate()
}
}
}
- public void setAnimator(Animator animation) {
- mAnimator = animation;
+ fun setAnimator(animation: Animator?) {
+ mAnimator = animation
}
- public void setFadingIn(boolean fadingIn) {
- mFadingIn = fadingIn;
+ fun setFadingIn(fadingIn: Boolean) {
+ mFadingIn = fadingIn
}
-
}
- AnimatorListenerAdapter mAnimatorListener = new AnimatorListenerAdapter() {
+ var mAnimatorListener: AnimatorListenerAdapter = object : AnimatorListenerAdapter() {
@Override
- public void onAnimationStart(Animator animation) {
- mScrolling = true;
+ fun onAnimationStart(animation: Animator?) {
+ mScrolling = true
}
@Override
- public void onAnimationCancel(Animator animation) {
- mScrolling = false;
+ fun onAnimationCancel(animation: Animator?) {
+ mScrolling = false
}
@Override
- public void onAnimationEnd(Animator animation) {
- mScrolling = false;
- resetSelectedHour();
- invalidate();
+ fun onAnimationEnd(animation: Animator?) {
+ mScrolling = false
+ resetSelectedHour()
+ invalidate()
}
- };
+ }
/**
* This variable helps to avoid unnecessarily reloading events by keeping
@@ -302,824 +177,550 @@
* reloaded. To force a reload, set this to zero (this is set to zero
* in the method clearCachedEvents()).
*/
- private long mLastReloadMillis;
-
- private ArrayList<Event> mEvents = new ArrayList<Event>();
- private ArrayList<Event> mAllDayEvents = new ArrayList<Event>();
- private StaticLayout[] mLayouts = null;
- private StaticLayout[] mAllDayLayouts = null;
- private int mSelectionDay; // Julian day
- private int mSelectionHour;
-
- boolean mSelectionAllday;
+ private var mLastReloadMillis: Long = 0
+ private var mEvents: ArrayList<Event> = ArrayList<Event>()
+ private var mAllDayEvents: ArrayList<Event>? = ArrayList<Event>()
+ private var mLayouts: Array<StaticLayout?>? = null
+ private var mAllDayLayouts: Array<StaticLayout?>? = null
+ private var mSelectionDay // Julian day
+ = 0
+ private var mSelectionHour = 0
+ var mSelectionAllday = false
// Current selection info for accessibility
- private int mSelectionDayForAccessibility; // Julian day
- private int mSelectionHourForAccessibility;
- private Event mSelectedEventForAccessibility;
+ private var mSelectionDayForAccessibility // Julian day
+ = 0
+ private var mSelectionHourForAccessibility = 0
+ private var mSelectedEventForAccessibility: Event? = null
+
// Last selection info for accessibility
- private int mLastSelectionDayForAccessibility;
- private int mLastSelectionHourForAccessibility;
- private Event mLastSelectedEventForAccessibility;
+ private var mLastSelectionDayForAccessibility = 0
+ private var mLastSelectionHourForAccessibility = 0
+ private var mLastSelectedEventForAccessibility: Event? = null
-
- /** Width of a day or non-conflicting event */
- private int mCellWidth;
+ /** Width of a day or non-conflicting event */
+ private var mCellWidth = 0
// Pre-allocate these objects and re-use them
- private final Rect mRect = new Rect();
- private final Rect mDestRect = new Rect();
- private final Rect mSelectionRect = new Rect();
+ private val mRect: Rect = Rect()
+ private val mDestRect: Rect = Rect()
+ private val mSelectionRect: Rect = Rect()
+
// This encloses the more allDay events icon
- private final Rect mExpandAllDayRect = new Rect();
+ private val mExpandAllDayRect: Rect = Rect()
+
// TODO Clean up paint usage
- private final Paint mPaint = new Paint();
- private final Paint mEventTextPaint = new Paint();
- private final Paint mSelectionPaint = new Paint();
- private float[] mLines;
-
- private int mFirstDayOfWeek; // First day of the week
-
- private PopupWindow mPopup;
- private View mPopupView;
-
- // The number of milliseconds to show the popup window
- private static final int POPUP_DISMISS_DELAY = 3000;
- private final DismissPopup mDismissPopup = new DismissPopup();
-
- private boolean mRemeasure = true;
-
- private final EventLoader mEventLoader;
- protected final EventGeometry mEventGeometry;
-
- private static float GRID_LINE_LEFT_MARGIN = 0;
- private static final float GRID_LINE_INNER_WIDTH = 1;
-
- private static final int DAY_GAP = 1;
- private static final int HOUR_GAP = 1;
- // This is the standard height of an allday event with no restrictions
- private static int SINGLE_ALLDAY_HEIGHT = 34;
- /**
- * This is the minimum desired height of a allday event.
- * When unexpanded, allday events will use this height.
- * When expanded allDay events will attempt to grow to fit all
- * events at this height.
- */
- private static float MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = 28.0F; // in pixels
- /**
- * This is how big the unexpanded allday height is allowed to be.
- * It will get adjusted based on screen size
- */
- private static int MAX_UNEXPANDED_ALLDAY_HEIGHT =
- (int) (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4);
- /**
- * This is the minimum size reserved for displaying regular events.
- * The expanded allDay region can't expand into this.
- */
- private static int MIN_HOURS_HEIGHT = 180;
- private static int ALLDAY_TOP_MARGIN = 1;
- // The largest a single allDay event will become.
- private static int MAX_HEIGHT_OF_ONE_ALLDAY_EVENT = 34;
-
- private static int HOURS_TOP_MARGIN = 2;
- private static int HOURS_LEFT_MARGIN = 2;
- private static int HOURS_RIGHT_MARGIN = 4;
- private static int HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN;
- private static int NEW_EVENT_MARGIN = 4;
- private static int NEW_EVENT_WIDTH = 2;
- private static int NEW_EVENT_MAX_LENGTH = 16;
-
- private static int CURRENT_TIME_LINE_SIDE_BUFFER = 4;
- private static int CURRENT_TIME_LINE_TOP_OFFSET = 2;
-
- /* package */ static final int MINUTES_PER_HOUR = 60;
- /* package */ static final int MINUTES_PER_DAY = MINUTES_PER_HOUR * 24;
- /* package */ static final int MILLIS_PER_MINUTE = 60 * 1000;
- /* package */ static final int MILLIS_PER_HOUR = (3600 * 1000);
- /* package */ static final int MILLIS_PER_DAY = MILLIS_PER_HOUR * 24;
-
- // More events text will transition between invisible and this alpha
- private static final int MORE_EVENTS_MAX_ALPHA = 0x4C;
- private static int DAY_HEADER_ONE_DAY_LEFT_MARGIN = 0;
- private static int DAY_HEADER_ONE_DAY_RIGHT_MARGIN = 5;
- private static int DAY_HEADER_ONE_DAY_BOTTOM_MARGIN = 6;
- private static int DAY_HEADER_RIGHT_MARGIN = 4;
- private static int DAY_HEADER_BOTTOM_MARGIN = 3;
- private static float DAY_HEADER_FONT_SIZE = 14;
- private static float DATE_HEADER_FONT_SIZE = 32;
- private static float NORMAL_FONT_SIZE = 12;
- private static float EVENT_TEXT_FONT_SIZE = 12;
- private static float HOURS_TEXT_SIZE = 12;
- private static float AMPM_TEXT_SIZE = 9;
- private static int MIN_HOURS_WIDTH = 96;
- private static int MIN_CELL_WIDTH_FOR_TEXT = 20;
- private static final int MAX_EVENT_TEXT_LEN = 500;
- // smallest height to draw an event with
- private static float MIN_EVENT_HEIGHT = 24.0F; // in pixels
- private static int CALENDAR_COLOR_SQUARE_SIZE = 10;
- private static int EVENT_RECT_TOP_MARGIN = 1;
- private static int EVENT_RECT_BOTTOM_MARGIN = 0;
- private static int EVENT_RECT_LEFT_MARGIN = 1;
- private static int EVENT_RECT_RIGHT_MARGIN = 0;
- private static int EVENT_RECT_STROKE_WIDTH = 2;
- private static int EVENT_TEXT_TOP_MARGIN = 2;
- private static int EVENT_TEXT_BOTTOM_MARGIN = 2;
- private static int EVENT_TEXT_LEFT_MARGIN = 6;
- private static int EVENT_TEXT_RIGHT_MARGIN = 6;
- private static int ALL_DAY_EVENT_RECT_BOTTOM_MARGIN = 1;
- private static int EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN;
- private static int EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_BOTTOM_MARGIN;
- private static int EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN;
- private static int EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_RIGHT_MARGIN;
- // margins and sizing for the expand allday icon
- private static int EXPAND_ALL_DAY_BOTTOM_MARGIN = 10;
- // sizing for "box +n" in allDay events
- private static int EVENT_SQUARE_WIDTH = 10;
- private static int EVENT_LINE_PADDING = 4;
- private static int NEW_EVENT_HINT_FONT_SIZE = 12;
-
- private static int mEventTextColor;
- private static int mMoreEventsTextColor;
-
- private static int mWeek_saturdayColor;
- private static int mWeek_sundayColor;
- private static int mCalendarDateBannerTextColor;
- private static int mCalendarAmPmLabel;
- private static int mCalendarGridAreaSelected;
- private static int mCalendarGridLineInnerHorizontalColor;
- private static int mCalendarGridLineInnerVerticalColor;
- private static int mFutureBgColor;
- private static int mFutureBgColorRes;
- private static int mBgColor;
- private static int mNewEventHintColor;
- private static int mCalendarHourLabelColor;
- private static int mMoreAlldayEventsTextAlpha = MORE_EVENTS_MAX_ALPHA;
-
- private float mAnimationDistance = 0;
- private int mViewStartX;
- private int mViewStartY;
- private int mMaxViewStartY;
- private int mViewHeight;
- private int mViewWidth;
- private int mGridAreaHeight = -1;
- private static int mCellHeight = 0; // shared among all DayViews
- private static int mMinCellHeight = 32;
- private int mScrollStartY;
- private int mPreviousDirection;
- private static int mScaledPagingTouchSlop = 0;
+ private val mPaint: Paint = Paint()
+ private val mEventTextPaint: Paint = Paint()
+ private val mSelectionPaint: Paint = Paint()
+ private var mLines: FloatArray
+ private var mFirstDayOfWeek // First day of the week
+ = 0
+ private var mPopup: PopupWindow? = null
+ private var mPopupView: View? = null
+ private val mDismissPopup: DismissPopup = DismissPopup()
+ private var mRemeasure = true
+ private val mEventLoader: EventLoader
+ protected val mEventGeometry: EventGeometry
+ private var mAnimationDistance = 0f
+ private var mViewStartX = 0
+ private var mViewStartY = 0
+ private var mMaxViewStartY = 0
+ private var mViewHeight = 0
+ private var mViewWidth = 0
+ private var mGridAreaHeight = -1
+ private var mScrollStartY = 0
+ private var mPreviousDirection = 0
/**
* Vertical distance or span between the two touch points at the start of a
* scaling gesture
*/
- private float mStartingSpanY = 0;
- /** Height of 1 hour in pixels at the start of a scaling gesture */
- private int mCellHeightBeforeScaleGesture;
- /** The hour at the center two touch points */
- private float mGestureCenterHour = 0;
+ private var mStartingSpanY = 0f
- private boolean mRecalCenterHour = false;
+ /** Height of 1 hour in pixels at the start of a scaling gesture */
+ private var mCellHeightBeforeScaleGesture = 0
+
+ /** The hour at the center two touch points */
+ private var mGestureCenterHour = 0f
+ private var mRecalCenterHour = false
/**
* Flag to decide whether to handle the up event. Cases where up events
* should be ignored are 1) right after a scale gesture and 2) finger was
* down before app launch
*/
- private boolean mHandleActionUp = true;
+ private var mHandleActionUp = true
+ private var mHoursTextHeight = 0
- private int mHoursTextHeight;
/**
* The height of the area used for allday events
*/
- private int mAlldayHeight;
+ private var mAlldayHeight = 0
+
/**
* The height of the allday event area used during animation
*/
- private int mAnimateDayHeight = 0;
+ private var mAnimateDayHeight = 0
+
/**
* The height of an individual allday event during animation
*/
- private int mAnimateDayEventHeight = (int) MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT;
- /**
- * Whether to use the expand or collapse icon.
- */
- private static boolean mUseExpandIcon = true;
- /**
- * The height of the day names/numbers
- */
- private static int DAY_HEADER_HEIGHT = 45;
- /**
- * The height of the day names/numbers for multi-day views
- */
- private static int MULTI_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT;
- /**
- * The height of the day names/numbers when viewing a single day
- */
- private static int ONE_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT;
+ private var mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
+
/**
* Max of all day events in a given day in this view.
*/
- private int mMaxAlldayEvents;
+ private var mMaxAlldayEvents = 0
+
/**
* A count of the number of allday events that were not drawn for each day
*/
- private int[] mSkippedAlldayEvents;
+ private var mSkippedAlldayEvents: IntArray?
+
/**
* The number of allDay events at which point we start hiding allDay events.
*/
- private int mMaxUnexpandedAlldayEventCount = 4;
- /**
- * Whether or not to expand the allDay area to fill the screen
- */
- private static boolean mShowAllAllDayEvents = false;
+ private var mMaxUnexpandedAlldayEventCount = 4
+ protected var mNumDays = 7
+ private var mNumHours = 10
- protected int mNumDays = 7;
- private int mNumHours = 10;
+ /** Width of the time line (list of hours) to the left. */
+ private var mHoursWidth = 0
+ private var mDateStrWidth = 0
- /** Width of the time line (list of hours) to the left. */
- private int mHoursWidth;
- private int mDateStrWidth;
- /** Top of the scrollable region i.e. below date labels and all day events */
- private int mFirstCell;
- /** First fully visibile hour */
- private int mFirstHour = -1;
- /** Distance between the mFirstCell and the top of first fully visible hour. */
- private int mFirstHourOffset;
- private String[] mHourStrs;
- private String[] mDayStrs;
- private String[] mDayStrs2Letter;
- private boolean mIs24HourFormat;
+ /** Top of the scrollable region i.e. below date labels and all day events */
+ private var mFirstCell = 0
- private final ArrayList<Event> mSelectedEvents = new ArrayList<Event>();
- private boolean mComputeSelectedEvents;
- private boolean mUpdateToast;
- private Event mSelectedEvent;
- private Event mPrevSelectedEvent;
- private final Rect mPrevBox = new Rect();
- protected final Resources mResources;
- protected final Drawable mCurrentTimeLine;
- protected final Drawable mCurrentTimeAnimateLine;
- protected final Drawable mTodayHeaderDrawable;
- protected final Drawable mExpandAlldayDrawable;
- protected final Drawable mCollapseAlldayDrawable;
- protected Drawable mAcceptedOrTentativeEventBoxDrawable;
- private String mAmString;
- private String mPmString;
- private static int sCounter = 0;
+ /** First fully visible hour */
+ private var mFirstHour = -1
- ScaleGestureDetector mScaleGestureDetector;
-
- /**
- * The initial state of the touch mode when we enter this view.
- */
- private static final int TOUCH_MODE_INITIAL_STATE = 0;
-
- /**
- * Indicates we just received the touch event and we are waiting to see if
- * it is a tap or a scroll gesture.
- */
- private static final int TOUCH_MODE_DOWN = 1;
-
- /**
- * Indicates the touch gesture is a vertical scroll
- */
- private static final int TOUCH_MODE_VSCROLL = 0x20;
-
- /**
- * Indicates the touch gesture is a horizontal scroll
- */
- private static final int TOUCH_MODE_HSCROLL = 0x40;
-
- private int mTouchMode = TOUCH_MODE_INITIAL_STATE;
-
- /**
- * The selection modes are HIDDEN, PRESSED, SELECTED, and LONGPRESS.
- */
- private static final int SELECTION_HIDDEN = 0;
- private static final int SELECTION_PRESSED = 1; // D-pad down but not up yet
- private static final int SELECTION_SELECTED = 2;
- private static final int SELECTION_LONGPRESS = 3;
-
- private int mSelectionMode = SELECTION_HIDDEN;
-
- private boolean mScrolling = false;
+ /** Distance between the mFirstCell and the top of first fully visible hour. */
+ private var mFirstHourOffset = 0
+ private var mHourStrs: Array<String>
+ private var mDayStrs: Array<String?>
+ private var mDayStrs2Letter: Array<String?>
+ private var mIs24HourFormat = false
+ private val mSelectedEvents: ArrayList<Event> = ArrayList<Event>()
+ private var mComputeSelectedEvents = false
+ private var mUpdateToast = false
+ private var mSelectedEvent: Event? = null
+ private var mPrevSelectedEvent: Event? = null
+ private val mPrevBox: Rect = Rect()
+ protected val mResources: Resources
+ protected val mCurrentTimeLine: Drawable
+ protected val mCurrentTimeAnimateLine: Drawable
+ protected val mTodayHeaderDrawable: Drawable
+ protected val mExpandAlldayDrawable: Drawable
+ protected val mCollapseAlldayDrawable: Drawable
+ protected var mAcceptedOrTentativeEventBoxDrawable: Drawable
+ private var mAmString: String? = null
+ private var mPmString: String? = null
+ var mScaleGestureDetector: ScaleGestureDetector
+ private var mTouchMode = TOUCH_MODE_INITIAL_STATE
+ private var mSelectionMode = SELECTION_HIDDEN
+ private var mScrolling = false
// Pixels scrolled
- private float mInitialScrollX;
- private float mInitialScrollY;
-
- private boolean mAnimateToday = false;
- private int mAnimateTodayAlpha = 0;
+ private var mInitialScrollX = 0f
+ private var mInitialScrollY = 0f
+ private var mAnimateToday = false
+ private var mAnimateTodayAlpha = 0
// Animates the height of the allday region
- ObjectAnimator mAlldayAnimator;
+ var mAlldayAnimator: ObjectAnimator? = null
+
// Animates the height of events in the allday region
- ObjectAnimator mAlldayEventAnimator;
+ var mAlldayEventAnimator: ObjectAnimator? = null
+
// Animates the transparency of the more events text
- ObjectAnimator mMoreAlldayEventsAnimator;
+ var mMoreAlldayEventsAnimator: ObjectAnimator? = null
+
// Animates the current time marker when Today is pressed
- ObjectAnimator mTodayAnimator;
+ var mTodayAnimator: ObjectAnimator? = null
+
// whether or not an event is stopping because it was cancelled
- private boolean mCancellingAnimations = false;
+ private var mCancellingAnimations = false
+
// tracks whether a touch originated in the allday area
- private boolean mTouchStartedInAlldayArea = false;
-
- private final CalendarController mController;
- private final ViewSwitcher mViewSwitcher;
- private final GestureDetector mGestureDetector;
- private final OverScroller mScroller;
- private final EdgeEffect mEdgeEffectTop;
- private final EdgeEffect mEdgeEffectBottom;
- private boolean mCallEdgeEffectOnAbsorb;
- private final int OVERFLING_DISTANCE;
- private float mLastVelocity;
-
- private final ScrollInterpolator mHScrollInterpolator;
- private AccessibilityManager mAccessibilityMgr = null;
- private boolean mIsAccessibilityEnabled = false;
- private boolean mTouchExplorationEnabled = false;
- private final String mNewEventHintString;
-
- public DayView(Context context, CalendarController controller,
- ViewSwitcher viewSwitcher, EventLoader eventLoader, int numDays) {
- super(context);
- mContext = context;
- initAccessibilityVariables();
-
- mResources = context.getResources();
- mNewEventHintString = mResources.getString(R.string.day_view_new_event_hint);
- mNumDays = numDays;
-
- DATE_HEADER_FONT_SIZE = (int) mResources.getDimension(R.dimen.date_header_text_size);
- DAY_HEADER_FONT_SIZE = (int) mResources.getDimension(R.dimen.day_label_text_size);
- ONE_DAY_HEADER_HEIGHT = (int) mResources.getDimension(R.dimen.one_day_header_height);
- DAY_HEADER_BOTTOM_MARGIN = (int) mResources.getDimension(R.dimen.day_header_bottom_margin);
- EXPAND_ALL_DAY_BOTTOM_MARGIN = (int) mResources.getDimension(R.dimen.all_day_bottom_margin);
- HOURS_TEXT_SIZE = (int) mResources.getDimension(R.dimen.hours_text_size);
- AMPM_TEXT_SIZE = (int) mResources.getDimension(R.dimen.ampm_text_size);
- MIN_HOURS_WIDTH = (int) mResources.getDimension(R.dimen.min_hours_width);
- HOURS_LEFT_MARGIN = (int) mResources.getDimension(R.dimen.hours_left_margin);
- HOURS_RIGHT_MARGIN = (int) mResources.getDimension(R.dimen.hours_right_margin);
- MULTI_DAY_HEADER_HEIGHT = (int) mResources.getDimension(R.dimen.day_header_height);
- int eventTextSizeId;
- if (mNumDays == 1) {
- eventTextSizeId = R.dimen.day_view_event_text_size;
- } else {
- eventTextSizeId = R.dimen.week_view_event_text_size;
- }
- EVENT_TEXT_FONT_SIZE = (int) mResources.getDimension(eventTextSizeId);
- NEW_EVENT_HINT_FONT_SIZE = (int) mResources.getDimension(R.dimen.new_event_hint_text_size);
- MIN_EVENT_HEIGHT = mResources.getDimension(R.dimen.event_min_height);
- MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = MIN_EVENT_HEIGHT;
- EVENT_TEXT_TOP_MARGIN = (int) mResources.getDimension(R.dimen.event_text_vertical_margin);
- EVENT_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN;
- EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN;
- EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN;
-
- EVENT_TEXT_LEFT_MARGIN = (int) mResources
- .getDimension(R.dimen.event_text_horizontal_margin);
- EVENT_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN;
- EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN;
- EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN;
-
- if (mScale == 0) {
-
- mScale = mResources.getDisplayMetrics().density;
- if (mScale != 1) {
- SINGLE_ALLDAY_HEIGHT *= mScale;
- ALLDAY_TOP_MARGIN *= mScale;
- MAX_HEIGHT_OF_ONE_ALLDAY_EVENT *= mScale;
-
- NORMAL_FONT_SIZE *= mScale;
- GRID_LINE_LEFT_MARGIN *= mScale;
- HOURS_TOP_MARGIN *= mScale;
- MIN_CELL_WIDTH_FOR_TEXT *= mScale;
- MAX_UNEXPANDED_ALLDAY_HEIGHT *= mScale;
- mAnimateDayEventHeight = (int) MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT;
-
- CURRENT_TIME_LINE_SIDE_BUFFER *= mScale;
- CURRENT_TIME_LINE_TOP_OFFSET *= mScale;
-
- MIN_Y_SPAN *= mScale;
- MAX_CELL_HEIGHT *= mScale;
- DEFAULT_CELL_HEIGHT *= mScale;
- DAY_HEADER_HEIGHT *= mScale;
- DAY_HEADER_RIGHT_MARGIN *= mScale;
- DAY_HEADER_ONE_DAY_LEFT_MARGIN *= mScale;
- DAY_HEADER_ONE_DAY_RIGHT_MARGIN *= mScale;
- DAY_HEADER_ONE_DAY_BOTTOM_MARGIN *= mScale;
- CALENDAR_COLOR_SQUARE_SIZE *= mScale;
- EVENT_RECT_TOP_MARGIN *= mScale;
- EVENT_RECT_BOTTOM_MARGIN *= mScale;
- ALL_DAY_EVENT_RECT_BOTTOM_MARGIN *= mScale;
- EVENT_RECT_LEFT_MARGIN *= mScale;
- EVENT_RECT_RIGHT_MARGIN *= mScale;
- EVENT_RECT_STROKE_WIDTH *= mScale;
- EVENT_SQUARE_WIDTH *= mScale;
- EVENT_LINE_PADDING *= mScale;
- NEW_EVENT_MARGIN *= mScale;
- NEW_EVENT_WIDTH *= mScale;
- NEW_EVENT_MAX_LENGTH *= mScale;
- }
- }
- HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN;
- DAY_HEADER_HEIGHT = mNumDays == 1 ? ONE_DAY_HEADER_HEIGHT : MULTI_DAY_HEADER_HEIGHT;
-
- mCurrentTimeLine = mResources.getDrawable(R.drawable.timeline_indicator_holo_light);
- mCurrentTimeAnimateLine = mResources
- .getDrawable(R.drawable.timeline_indicator_activated_holo_light);
- mTodayHeaderDrawable = mResources.getDrawable(R.drawable.today_blue_week_holo_light);
- mExpandAlldayDrawable = mResources.getDrawable(R.drawable.ic_expand_holo_light);
- mCollapseAlldayDrawable = mResources.getDrawable(R.drawable.ic_collapse_holo_light);
- mNewEventHintColor = mResources.getColor(R.color.new_event_hint_text_color);
- mAcceptedOrTentativeEventBoxDrawable = mResources
- .getDrawable(R.drawable.panel_month_event_holo_light);
-
- mEventLoader = eventLoader;
- mEventGeometry = new EventGeometry();
- mEventGeometry.setMinEventHeight(MIN_EVENT_HEIGHT);
- mEventGeometry.setHourGap(HOUR_GAP);
- mEventGeometry.setCellMargin(DAY_GAP);
- mLastPopupEventID = INVALID_EVENT_ID;
- mController = controller;
- mViewSwitcher = viewSwitcher;
- mGestureDetector = new GestureDetector(context, new CalendarGestureListener());
- mScaleGestureDetector = new ScaleGestureDetector(getContext(), this);
- if (mCellHeight == 0) {
- mCellHeight = Utils.getSharedPreference(mContext,
- GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT, DEFAULT_CELL_HEIGHT);
- }
- mScroller = new OverScroller(context);
- mHScrollInterpolator = new ScrollInterpolator();
- mEdgeEffectTop = new EdgeEffect(context);
- mEdgeEffectBottom = new EdgeEffect(context);
- ViewConfiguration vc = ViewConfiguration.get(context);
- mScaledPagingTouchSlop = vc.getScaledPagingTouchSlop();
- mOnDownDelay = ViewConfiguration.getTapTimeout();
- OVERFLING_DISTANCE = vc.getScaledOverflingDistance();
-
- init(context);
- }
-
+ private var mTouchStartedInAlldayArea = false
+ private val mController: CalendarController
+ private val mViewSwitcher: ViewSwitcher
+ private val mGestureDetector: GestureDetector
+ private val mScroller: OverScroller
+ private val mEdgeEffectTop: EdgeEffect
+ private val mEdgeEffectBottom: EdgeEffect
+ private var mCallEdgeEffectOnAbsorb = false
+ private val OVERFLING_DISTANCE: Int
+ private var mLastVelocity = 0f
+ private val mHScrollInterpolator: ScrollInterpolator
+ private var mAccessibilityMgr: AccessibilityManager? = null
+ private var mIsAccessibilityEnabled = false
+ private var mTouchExplorationEnabled = false
+ private val mNewEventHintString: String
@Override
- protected void onAttachedToWindow() {
+ protected fun onAttachedToWindow() {
if (mHandler == null) {
- mHandler = getHandler();
- mHandler.post(mUpdateCurrentTime);
+ mHandler = getHandler()
+ mHandler.post(mUpdateCurrentTime)
}
}
- private void init(Context context) {
- setFocusable(true);
+ private fun init(context: Context) {
+ setFocusable(true)
// Allow focus in touch mode so that we can do keyboard shortcuts
// even after we've entered touch mode.
- setFocusableInTouchMode(true);
- setClickable(true);
- setOnCreateContextMenuListener(this);
-
- mFirstDayOfWeek = Utils.getFirstDayOfWeek(context);
-
- mCurrentTime = new Time(Utils.getTimeZone(context, mTZUpdater));
- long currentTime = System.currentTimeMillis();
- mCurrentTime.set(currentTime);
- mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime.gmtoff);
-
- mWeek_saturdayColor = mResources.getColor(R.color.week_saturday);
- mWeek_sundayColor = mResources.getColor(R.color.week_sunday);
- mCalendarDateBannerTextColor = mResources.getColor(R.color.calendar_date_banner_text_color);
- mFutureBgColorRes = mResources.getColor(R.color.calendar_future_bg_color);
- mBgColor = mResources.getColor(R.color.calendar_hour_background);
- mCalendarAmPmLabel = mResources.getColor(R.color.calendar_ampm_label);
- mCalendarGridAreaSelected = mResources.getColor(R.color.calendar_grid_area_selected);
+ setFocusableInTouchMode(true)
+ setClickable(true)
+ setOnCreateContextMenuListener(this)
+ mFirstDayOfWeek = Utils.getFirstDayOfWeek(context)
+ mCurrentTime = Time(Utils.getTimeZone(context, mTZUpdater))
+ val currentTime: Long = System.currentTimeMillis()
+ mCurrentTime.set(currentTime)
+ mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime.gmtoff)
+ mWeek_saturdayColor = mResources.getColor(R.color.week_saturday)
+ mWeek_sundayColor = mResources.getColor(R.color.week_sunday)
+ mCalendarDateBannerTextColor = mResources.getColor(R.color.calendar_date_banner_text_color)
+ mFutureBgColorRes = mResources.getColor(R.color.calendar_future_bg_color)
+ mBgColor = mResources.getColor(R.color.calendar_hour_background)
+ mCalendarAmPmLabel = mResources.getColor(R.color.calendar_ampm_label)
+ mCalendarGridAreaSelected = mResources.getColor(R.color.calendar_grid_area_selected)
mCalendarGridLineInnerHorizontalColor = mResources
- .getColor(R.color.calendar_grid_line_inner_horizontal_color);
+ .getColor(R.color.calendar_grid_line_inner_horizontal_color)
mCalendarGridLineInnerVerticalColor = mResources
- .getColor(R.color.calendar_grid_line_inner_vertical_color);
- mCalendarHourLabelColor = mResources.getColor(R.color.calendar_hour_label);
- mEventTextColor = mResources.getColor(R.color.calendar_event_text_color);
- mMoreEventsTextColor = mResources.getColor(R.color.month_event_other_color);
-
- mEventTextPaint.setTextSize(EVENT_TEXT_FONT_SIZE);
- mEventTextPaint.setTextAlign(Paint.Align.LEFT);
- mEventTextPaint.setAntiAlias(true);
-
- int gridLineColor = mResources.getColor(R.color.calendar_grid_line_highlight_color);
- Paint p = mSelectionPaint;
- p.setColor(gridLineColor);
- p.setStyle(Style.FILL);
- p.setAntiAlias(false);
-
- p = mPaint;
- p.setAntiAlias(true);
+ .getColor(R.color.calendar_grid_line_inner_vertical_color)
+ mCalendarHourLabelColor = mResources.getColor(R.color.calendar_hour_label)
+ mEventTextColor = mResources.getColor(R.color.calendar_event_text_color)
+ mMoreEventsTextColor = mResources.getColor(R.color.month_event_other_color)
+ mEventTextPaint.setTextSize(EVENT_TEXT_FONT_SIZE)
+ mEventTextPaint.setTextAlign(Paint.Align.LEFT)
+ mEventTextPaint.setAntiAlias(true)
+ val gridLineColor: Int = mResources.getColor(R.color.calendar_grid_line_highlight_color)
+ var p: Paint = mSelectionPaint
+ p.setColor(gridLineColor)
+ p.setStyle(Style.FILL)
+ p.setAntiAlias(false)
+ p = mPaint
+ p.setAntiAlias(true)
// Allocate space for 2 weeks worth of weekday names so that we can
// easily start the week display at any week day.
- mDayStrs = new String[14];
+ mDayStrs = arrayOfNulls(14)
// Also create an array of 2-letter abbreviations.
- mDayStrs2Letter = new String[14];
-
- for (int i = Calendar.SUNDAY; i <= Calendar.SATURDAY; i++) {
- int index = i - Calendar.SUNDAY;
+ mDayStrs2Letter = arrayOfNulls(14)
+ for (i in Calendar.SUNDAY..Calendar.SATURDAY) {
+ val index: Int = i - Calendar.SUNDAY
// e.g. Tue for Tuesday
mDayStrs[index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_MEDIUM)
- .toUpperCase();
- mDayStrs[index + 7] = mDayStrs[index];
+ .toUpperCase()
+ mDayStrs[index + 7] = mDayStrs[index]
// e.g. Tu for Tuesday
mDayStrs2Letter[index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_SHORT)
- .toUpperCase();
+ .toUpperCase()
// If we don't have 2-letter day strings, fall back to 1-letter.
- if (mDayStrs2Letter[index].equals(mDayStrs[index])) {
- mDayStrs2Letter[index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_SHORTEST);
+ if (mDayStrs2Letter[index]!!.equals(mDayStrs[index])) {
+ mDayStrs2Letter[index] = DateUtils.getDayOfWeekString(i, DateUtils.LENGTH_SHORTEST)
}
-
- mDayStrs2Letter[index + 7] = mDayStrs2Letter[index];
+ mDayStrs2Letter[index + 7] = mDayStrs2Letter[index]
}
// Figure out how much space we need for the 3-letter abbrev names
// in the worst case.
- p.setTextSize(DATE_HEADER_FONT_SIZE);
- p.setTypeface(mBold);
- String[] dateStrs = {" 28", " 30"};
- mDateStrWidth = computeMaxStringWidth(0, dateStrs, p);
- p.setTextSize(DAY_HEADER_FONT_SIZE);
- mDateStrWidth += computeMaxStringWidth(0, mDayStrs, p);
-
- p.setTextSize(HOURS_TEXT_SIZE);
- p.setTypeface(null);
- handleOnResume();
-
- mAmString = DateUtils.getAMPMString(Calendar.AM).toUpperCase();
- mPmString = DateUtils.getAMPMString(Calendar.PM).toUpperCase();
- String[] ampm = {mAmString, mPmString};
- p.setTextSize(AMPM_TEXT_SIZE);
- mHoursWidth = Math.max(HOURS_MARGIN, computeMaxStringWidth(mHoursWidth, ampm, p)
- + HOURS_RIGHT_MARGIN);
- mHoursWidth = Math.max(MIN_HOURS_WIDTH, mHoursWidth);
-
- LayoutInflater inflater;
- inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
- mPopupView = inflater.inflate(R.layout.bubble_event, null);
- mPopupView.setLayoutParams(new ViewGroup.LayoutParams(
+ p.setTextSize(DATE_HEADER_FONT_SIZE)
+ p.setTypeface(mBold)
+ val dateStrs = arrayOf<String?>(" 28", " 30")
+ mDateStrWidth = computeMaxStringWidth(0, dateStrs, p)
+ p.setTextSize(DAY_HEADER_FONT_SIZE)
+ mDateStrWidth += computeMaxStringWidth(0, mDayStrs, p)
+ p.setTextSize(HOURS_TEXT_SIZE)
+ p.setTypeface(null)
+ handleOnResume()
+ mAmString = DateUtils.getAMPMString(Calendar.AM).toUpperCase()
+ mPmString = DateUtils.getAMPMString(Calendar.PM).toUpperCase()
+ val ampm = arrayOf(mAmString, mPmString)
+ p.setTextSize(AMPM_TEXT_SIZE)
+ mHoursWidth = Math.max(
+ HOURS_MARGIN, computeMaxStringWidth(mHoursWidth, ampm, p)
+ + HOURS_RIGHT_MARGIN
+ )
+ mHoursWidth = Math.max(MIN_HOURS_WIDTH, mHoursWidth)
+ val inflater: LayoutInflater
+ inflater = context.getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
+ mPopupView = inflater.inflate(R.layout.bubble_event, null)
+ mPopupView.setLayoutParams(
+ LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
- ViewGroup.LayoutParams.WRAP_CONTENT));
- mPopup = new PopupWindow(context);
- mPopup.setContentView(mPopupView);
- Resources.Theme dialogTheme = getResources().newTheme();
- dialogTheme.applyStyle(android.R.style.Theme_Dialog, true);
- TypedArray ta = dialogTheme.obtainStyledAttributes(new int[] {
- android.R.attr.windowBackground });
- mPopup.setBackgroundDrawable(ta.getDrawable(0));
- ta.recycle();
+ ViewGroup.LayoutParams.WRAP_CONTENT
+ )
+ )
+ mPopup = PopupWindow(context)
+ mPopup.setContentView(mPopupView)
+ val dialogTheme: Resources.Theme = getResources().newTheme()
+ dialogTheme.applyStyle(android.R.style.Theme_Dialog, true)
+ val ta: TypedArray = dialogTheme.obtainStyledAttributes(
+ intArrayOf(
+ android.R.attr.windowBackground
+ )
+ )
+ mPopup.setBackgroundDrawable(ta.getDrawable(0))
+ ta.recycle()
// Enable touching the popup window
- mPopupView.setOnClickListener(this);
+ mPopupView.setOnClickListener(this)
// Catch long clicks for creating a new event
- setOnLongClickListener(this);
-
- mBaseDate = new Time(Utils.getTimeZone(context, mTZUpdater));
- long millis = System.currentTimeMillis();
- mBaseDate.set(millis);
-
- mEarliestStartHour = new int[mNumDays];
- mHasAllDayEvent = new boolean[mNumDays];
+ setOnLongClickListener(this)
+ mBaseDate = Time(Utils.getTimeZone(context, mTZUpdater))
+ val millis: Long = System.currentTimeMillis()
+ mBaseDate.set(millis)
+ mEarliestStartHour = IntArray(mNumDays)
+ mHasAllDayEvent = BooleanArray(mNumDays)
// mLines is the array of points used with Canvas.drawLines() in
// drawGridBackground() and drawAllDayEvents(). Its size depends
// on the max number of lines that can ever be drawn by any single
// drawLines() call in either of those methods.
- final int maxGridLines = (24 + 1) // max horizontal lines we might draw
- + (mNumDays + 1); // max vertical lines we might draw
- mLines = new float[maxGridLines * 4];
+ val maxGridLines = (24 + 1 // max horizontal lines we might draw
+ + (mNumDays + 1)) // max vertical lines we might draw
+ mLines = FloatArray(maxGridLines * 4)
}
/**
* This is called when the popup window is pressed.
*/
- public void onClick(View v) {
- if (v == mPopupView) {
+ fun onClick(v: View) {
+ if (v === mPopupView) {
// Pretend it was a trackball click because that will always
// jump to the "View event" screen.
- switchViews(true /* trackball */);
+ switchViews(true /* trackball */)
}
}
- public void handleOnResume() {
- initAccessibilityVariables();
- if(Utils.getSharedPreference(mContext, OtherPreferences.KEY_OTHER_1, false)) {
- mFutureBgColor = 0;
+ fun handleOnResume() {
+ initAccessibilityVariables()
+ if (Utils.getSharedPreference(mContext, OtherPreferences.KEY_OTHER_1, false)) {
+ mFutureBgColor = 0
} else {
- mFutureBgColor = mFutureBgColorRes;
+ mFutureBgColor = mFutureBgColorRes
}
- mIs24HourFormat = DateFormat.is24HourFormat(mContext);
- mHourStrs = mIs24HourFormat ? CalendarData.s24Hours : CalendarData.s12HoursNoAmPm;
- mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext);
- mLastSelectionDayForAccessibility = 0;
- mLastSelectionHourForAccessibility = 0;
- mLastSelectedEventForAccessibility = null;
- mSelectionMode = SELECTION_HIDDEN;
+ mIs24HourFormat = DateFormat.is24HourFormat(mContext)
+ mHourStrs = if (mIs24HourFormat) CalendarData.s24Hours else CalendarData.s12HoursNoAmPm
+ mFirstDayOfWeek = Utils.getFirstDayOfWeek(mContext)
+ mLastSelectionDayForAccessibility = 0
+ mLastSelectionHourForAccessibility = 0
+ mLastSelectedEventForAccessibility = null
+ mSelectionMode = SELECTION_HIDDEN
}
- private void initAccessibilityVariables() {
- mAccessibilityMgr = (AccessibilityManager) mContext
- .getSystemService(Service.ACCESSIBILITY_SERVICE);
- mIsAccessibilityEnabled = mAccessibilityMgr != null && mAccessibilityMgr.isEnabled();
- mTouchExplorationEnabled = isTouchExplorationEnabled();
- }
-
+ private fun initAccessibilityVariables() {
+ mAccessibilityMgr = mContext
+ .getSystemService(Service.ACCESSIBILITY_SERVICE) as AccessibilityManager
+ mIsAccessibilityEnabled = mAccessibilityMgr != null && mAccessibilityMgr.isEnabled()
+ mTouchExplorationEnabled = isTouchExplorationEnabled
+ }/* ignore isDst */// We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
/**
* Returns the start of the selected time in milliseconds since the epoch.
*
* @return selected time in UTC milliseconds since the epoch.
*/
- long getSelectedTimeInMillis() {
- Time time = new Time(mBaseDate);
- time.setJulianDay(mSelectionDay);
- time.hour = mSelectionHour;
+ val selectedTimeInMillis: Long
+ get() {
+ val time = Time(mBaseDate)
+ time.setJulianDay(mSelectionDay)
+ time.hour = mSelectionHour
- // We ignore the "isDst" field because we want normalize() to figure
- // out the correct DST value and not adjust the selected time based
- // on the current setting of DST.
- return time.normalize(true /* ignore isDst */);
- }
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ return time.normalize(true /* ignore isDst */)
+ }/* ignore isDst */
- Time getSelectedTime() {
- Time time = new Time(mBaseDate);
- time.setJulianDay(mSelectionDay);
- time.hour = mSelectionHour;
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ val selectedTime: Time
+ get() {
+ val time = Time(mBaseDate)
+ time.setJulianDay(mSelectionDay)
+ time.hour = mSelectionHour
- // We ignore the "isDst" field because we want normalize() to figure
- // out the correct DST value and not adjust the selected time based
- // on the current setting of DST.
- time.normalize(true /* ignore isDst */);
- return time;
- }
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ time.normalize(true /* ignore isDst */)
+ return time
+ }/* ignore isDst */
- Time getSelectedTimeForAccessibility() {
- Time time = new Time(mBaseDate);
- time.setJulianDay(mSelectionDayForAccessibility);
- time.hour = mSelectionHourForAccessibility;
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ val selectedTimeForAccessibility: Time
+ get() {
+ val time = Time(mBaseDate)
+ time.setJulianDay(mSelectionDayForAccessibility)
+ time.hour = mSelectionHourForAccessibility
- // We ignore the "isDst" field because we want normalize() to figure
- // out the correct DST value and not adjust the selected time based
- // on the current setting of DST.
- time.normalize(true /* ignore isDst */);
- return time;
- }
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ time.normalize(true /* ignore isDst */)
+ return time
+ }
/**
* Returns the start of the selected time in minutes since midnight,
* local time. The derived class must ensure that this is consistent
* with the return value from getSelectedTimeInMillis().
*/
- int getSelectedMinutesSinceMidnight() {
- return mSelectionHour * MINUTES_PER_HOUR;
- }
+ val selectedMinutesSinceMidnight: Int
+ get() = mSelectionHour * MINUTES_PER_HOUR
+ var firstVisibleHour: Int
+ get() = mFirstHour
+ set(firstHour) {
+ mFirstHour = firstHour
+ mFirstHourOffset = 0
+ }
- int getFirstVisibleHour() {
- return mFirstHour;
- }
-
- void setFirstVisibleHour(int firstHour) {
- mFirstHour = firstHour;
- mFirstHourOffset = 0;
- }
-
- public void setSelected(Time time, boolean ignoreTime, boolean animateToday) {
- mBaseDate.set(time);
- setSelectedHour(mBaseDate.hour);
- setSelectedEvent(null);
- mPrevSelectedEvent = null;
- long millis = mBaseDate.toMillis(false /* use isDst */);
- setSelectedDay(Time.getJulianDay(millis, mBaseDate.gmtoff));
- mSelectedEvents.clear();
- mComputeSelectedEvents = true;
-
- int gotoY = Integer.MIN_VALUE;
-
+ fun setSelected(time: Time?, ignoreTime: Boolean, animateToday: Boolean) {
+ mBaseDate.set(time)
+ setSelectedHour(mBaseDate.hour)
+ setSelectedEvent(null)
+ mPrevSelectedEvent = null
+ val millis: Long = mBaseDate.toMillis(false /* use isDst */)
+ selectedDay = Time.getJulianDay(millis, mBaseDate.gmtoff)
+ mSelectedEvents.clear()
+ mComputeSelectedEvents = true
+ var gotoY: Int = Integer.MIN_VALUE
if (!ignoreTime && mGridAreaHeight != -1) {
- int lastHour = 0;
-
+ var lastHour = 0
if (mBaseDate.hour < mFirstHour) {
// Above visible region
- gotoY = mBaseDate.hour * (mCellHeight + HOUR_GAP);
+ gotoY = mBaseDate.hour * (mCellHeight + HOUR_GAP)
} else {
- lastHour = (mGridAreaHeight - mFirstHourOffset) / (mCellHeight + HOUR_GAP)
- + mFirstHour;
-
+ lastHour = ((mGridAreaHeight - mFirstHourOffset) / (mCellHeight + HOUR_GAP)
+ + mFirstHour)
if (mBaseDate.hour >= lastHour) {
// Below visible region
// target hour + 1 (to give it room to see the event) -
// grid height (to get the y of the top of the visible
// region)
- gotoY = (int) ((mBaseDate.hour + 1 + mBaseDate.minute / 60.0f)
- * (mCellHeight + HOUR_GAP) - mGridAreaHeight);
+ gotoY = ((mBaseDate.hour + 1 + mBaseDate.minute / 60.0f)
+ * (mCellHeight + HOUR_GAP) - mGridAreaHeight)
}
}
-
if (DEBUG) {
- Log.e(TAG, "Go " + gotoY + " 1st " + mFirstHour + ":" + mFirstHourOffset + "CH "
- + (mCellHeight + HOUR_GAP) + " lh " + lastHour + " gh " + mGridAreaHeight
- + " ymax " + mMaxViewStartY);
+ Log.e(
+ TAG, "Go " + gotoY + " 1st " + mFirstHour + ":" + mFirstHourOffset + "CH "
+ + (mCellHeight + HOUR_GAP) + " lh " + lastHour + " gh " + mGridAreaHeight
+ + " ymax " + mMaxViewStartY
+ )
}
-
if (gotoY > mMaxViewStartY) {
- gotoY = mMaxViewStartY;
+ gotoY = mMaxViewStartY
} else if (gotoY < 0 && gotoY != Integer.MIN_VALUE) {
- gotoY = 0;
+ gotoY = 0
}
}
-
- recalc();
-
- mRemeasure = true;
- invalidate();
-
- boolean delayAnimateToday = false;
+ recalc()
+ mRemeasure = true
+ invalidate()
+ var delayAnimateToday = false
if (gotoY != Integer.MIN_VALUE) {
- ValueAnimator scrollAnim = ObjectAnimator.ofInt(this, "viewStartY", mViewStartY, gotoY);
- scrollAnim.setDuration(GOTO_SCROLL_DURATION);
- scrollAnim.setInterpolator(new AccelerateDecelerateInterpolator());
- scrollAnim.addListener(mAnimatorListener);
- scrollAnim.start();
- delayAnimateToday = true;
+ val scrollAnim: ValueAnimator =
+ ObjectAnimator.ofInt(this, "viewStartY", mViewStartY, gotoY)
+ scrollAnim.setDuration(GOTO_SCROLL_DURATION)
+ scrollAnim.setInterpolator(AccelerateDecelerateInterpolator())
+ scrollAnim.addListener(mAnimatorListener)
+ scrollAnim.start()
+ delayAnimateToday = true
}
if (animateToday) {
- synchronized (mTodayAnimatorListener) {
+ synchronized(mTodayAnimatorListener) {
if (mTodayAnimator != null) {
- mTodayAnimator.removeAllListeners();
- mTodayAnimator.cancel();
+ mTodayAnimator.removeAllListeners()
+ mTodayAnimator.cancel()
}
- mTodayAnimator = ObjectAnimator.ofInt(this, "animateTodayAlpha",
- mAnimateTodayAlpha, 255);
- mAnimateToday = true;
- mTodayAnimatorListener.setFadingIn(true);
- mTodayAnimatorListener.setAnimator(mTodayAnimator);
- mTodayAnimator.addListener(mTodayAnimatorListener);
- mTodayAnimator.setDuration(150);
+ mTodayAnimator = ObjectAnimator.ofInt(
+ this, "animateTodayAlpha",
+ mAnimateTodayAlpha, 255
+ )
+ mAnimateToday = true
+ mTodayAnimatorListener.setFadingIn(true)
+ mTodayAnimatorListener.setAnimator(mTodayAnimator)
+ mTodayAnimator.addListener(mTodayAnimatorListener)
+ mTodayAnimator.setDuration(150)
if (delayAnimateToday) {
- mTodayAnimator.setStartDelay(GOTO_SCROLL_DURATION);
+ mTodayAnimator.setStartDelay(GOTO_SCROLL_DURATION)
}
- mTodayAnimator.start();
+ mTodayAnimator.start()
}
}
- sendAccessibilityEventAsNeeded(false);
+ sendAccessibilityEventAsNeeded(false)
}
// Called from animation framework via reflection. Do not remove
- public void setViewStartY(int viewStartY) {
+ fun setViewStartY(viewStartY: Int) {
+ var viewStartY = viewStartY
if (viewStartY > mMaxViewStartY) {
- viewStartY = mMaxViewStartY;
+ viewStartY = mMaxViewStartY
+ }
+ mViewStartY = viewStartY
+ computeFirstHour()
+ invalidate()
+ }
+
+ fun setAnimateTodayAlpha(todayAlpha: Int) {
+ mAnimateTodayAlpha = todayAlpha
+ invalidate()
+ }/* ignore isDst */
+
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ var selectedDay: Time
+ get() {
+ val time = Time(mBaseDate)
+ time.setJulianDay(mSelectionDay)
+ time.hour = mSelectionHour
+
+ // We ignore the "isDst" field because we want normalize() to figure
+ // out the correct DST value and not adjust the selected time based
+ // on the current setting of DST.
+ time.normalize(true /* ignore isDst */)
+ return time
+ }
+ private set(d) {
+ mSelectionDay = d
+ mSelectionDayForAccessibility = d
}
- mViewStartY = viewStartY;
-
- computeFirstHour();
- invalidate();
- }
-
- public void setAnimateTodayAlpha(int todayAlpha) {
- mAnimateTodayAlpha = todayAlpha;
- invalidate();
- }
-
- public Time getSelectedDay() {
- Time time = new Time(mBaseDate);
- time.setJulianDay(mSelectionDay);
- time.hour = mSelectionHour;
-
- // We ignore the "isDst" field because we want normalize() to figure
- // out the correct DST value and not adjust the selected time based
- // on the current setting of DST.
- time.normalize(true /* ignore isDst */);
- return time;
- }
-
- public void updateTitle() {
- Time start = new Time(mBaseDate);
- start.normalize(true);
- Time end = new Time(start);
- end.monthDay += mNumDays - 1;
+ fun updateTitle() {
+ val start = Time(mBaseDate)
+ start.normalize(true)
+ val end = Time(start)
+ end.monthDay += mNumDays - 1
// Move it forward one minute so the formatter doesn't lose a day
- end.minute += 1;
- end.normalize(true);
-
- long formatFlags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR;
+ end.minute += 1
+ end.normalize(true)
+ var formatFlags: Long = DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_YEAR
if (mNumDays != 1) {
// Don't show day of the month if for multi-day view
- formatFlags |= DateUtils.FORMAT_NO_MONTH_DAY;
+ formatFlags = formatFlags or DateUtils.FORMAT_NO_MONTH_DAY
// Abbreviate the month if showing multiple months
- if (start.month != end.month) {
- formatFlags |= DateUtils.FORMAT_ABBREV_MONTH;
+ if (start.month !== end.month) {
+ formatFlags = formatFlags or DateUtils.FORMAT_ABBREV_MONTH
}
}
-
- mController.sendEvent(this, EventType.UPDATE_TITLE, start, end, null, -1, ViewType.CURRENT,
- formatFlags, null, null);
+ mController.sendEvent(
+ this, EventType.UPDATE_TITLE, start, end, null, -1, ViewType.CURRENT,
+ formatFlags, null, null
+ )
}
/**
@@ -1127,139 +728,130 @@
* range, a positive number if "time" is after the visible time range, and 0
* if it is in the visible time range.
*/
- public int compareToVisibleTimeRange(Time time) {
-
- int savedHour = mBaseDate.hour;
- int savedMinute = mBaseDate.minute;
- int savedSec = mBaseDate.second;
-
- mBaseDate.hour = 0;
- mBaseDate.minute = 0;
- mBaseDate.second = 0;
-
+ fun compareToVisibleTimeRange(time: Time): Int {
+ val savedHour: Int = mBaseDate.hour
+ val savedMinute: Int = mBaseDate.minute
+ val savedSec: Int = mBaseDate.second
+ mBaseDate.hour = 0
+ mBaseDate.minute = 0
+ mBaseDate.second = 0
if (DEBUG) {
- Log.d(TAG, "Begin " + mBaseDate.toString());
- Log.d(TAG, "Diff " + time.toString());
+ Log.d(TAG, "Begin " + mBaseDate.toString())
+ Log.d(TAG, "Diff " + time.toString())
}
// Compare beginning of range
- int diff = Time.compare(time, mBaseDate);
+ var diff: Int = Time.compare(time, mBaseDate)
if (diff > 0) {
// Compare end of range
- mBaseDate.monthDay += mNumDays;
- mBaseDate.normalize(true);
- diff = Time.compare(time, mBaseDate);
-
- if (DEBUG) Log.d(TAG, "End " + mBaseDate.toString());
-
- mBaseDate.monthDay -= mNumDays;
- mBaseDate.normalize(true);
+ mBaseDate.monthDay += mNumDays
+ mBaseDate.normalize(true)
+ diff = Time.compare(time, mBaseDate)
+ if (DEBUG) Log.d(TAG, "End " + mBaseDate.toString())
+ mBaseDate.monthDay -= mNumDays
+ mBaseDate.normalize(true)
if (diff < 0) {
// in visible time
- diff = 0;
+ diff = 0
} else if (diff == 0) {
// Midnight of following day
- diff = 1;
+ diff = 1
}
}
-
- if (DEBUG) Log.d(TAG, "Diff: " + diff);
-
- mBaseDate.hour = savedHour;
- mBaseDate.minute = savedMinute;
- mBaseDate.second = savedSec;
- return diff;
+ if (DEBUG) Log.d(TAG, "Diff: $diff")
+ mBaseDate.hour = savedHour
+ mBaseDate.minute = savedMinute
+ mBaseDate.second = savedSec
+ return diff
}
- private void recalc() {
+ private fun recalc() {
// Set the base date to the beginning of the week if we are displaying
// 7 days at a time.
if (mNumDays == 7) {
- adjustToBeginningOfWeek(mBaseDate);
+ adjustToBeginningOfWeek(mBaseDate)
}
-
- final long start = mBaseDate.toMillis(false /* use isDst */);
- mFirstJulianDay = Time.getJulianDay(start, mBaseDate.gmtoff);
- mLastJulianDay = mFirstJulianDay + mNumDays - 1;
-
- mMonthLength = mBaseDate.getActualMaximum(Time.MONTH_DAY);
- mFirstVisibleDate = mBaseDate.monthDay;
- mFirstVisibleDayOfWeek = mBaseDate.weekDay;
+ val start: Long = mBaseDate.toMillis(false /* use isDst */)
+ mFirstJulianDay = Time.getJulianDay(start, mBaseDate.gmtoff)
+ mLastJulianDay = mFirstJulianDay + mNumDays - 1
+ mMonthLength = mBaseDate.getActualMaximum(Time.MONTH_DAY)
+ mFirstVisibleDate = mBaseDate.monthDay
+ mFirstVisibleDayOfWeek = mBaseDate.weekDay
}
- private void adjustToBeginningOfWeek(Time time) {
- int dayOfWeek = time.weekDay;
- int diff = dayOfWeek - mFirstDayOfWeek;
+ private fun adjustToBeginningOfWeek(time: Time?) {
+ val dayOfWeek: Int = time.weekDay
+ var diff = dayOfWeek - mFirstDayOfWeek
if (diff != 0) {
if (diff < 0) {
- diff += 7;
+ diff += 7
}
- time.monthDay -= diff;
- time.normalize(true /* ignore isDst */);
+ time.monthDay -= diff
+ time.normalize(true /* ignore isDst */)
}
}
@Override
- protected void onSizeChanged(int width, int height, int oldw, int oldh) {
- mViewWidth = width;
- mViewHeight = height;
- mEdgeEffectTop.setSize(mViewWidth, mViewHeight);
- mEdgeEffectBottom.setSize(mViewWidth, mViewHeight);
- int gridAreaWidth = width - mHoursWidth;
- mCellWidth = (gridAreaWidth - (mNumDays * DAY_GAP)) / mNumDays;
+ protected fun onSizeChanged(width: Int, height: Int, oldw: Int, oldh: Int) {
+ mViewWidth = width
+ mViewHeight = height
+ mEdgeEffectTop.setSize(mViewWidth, mViewHeight)
+ mEdgeEffectBottom.setSize(mViewWidth, mViewHeight)
+ val gridAreaWidth = width - mHoursWidth
+ mCellWidth = (gridAreaWidth - mNumDays * DAY_GAP) / mNumDays
// This would be about 1 day worth in a 7 day view
- mHorizontalSnapBackThreshold = width / 7;
-
- Paint p = new Paint();
- p.setTextSize(HOURS_TEXT_SIZE);
- mHoursTextHeight = (int) Math.abs(p.ascent());
- remeasure(width, height);
+ mHorizontalSnapBackThreshold = width / 7
+ val p = Paint()
+ p.setTextSize(HOURS_TEXT_SIZE)
+ mHoursTextHeight = Math.abs(p.ascent())
+ remeasure(width, height)
}
/**
* Measures the space needed for various parts of the view after
* loading new events. This can change if there are all-day events.
*/
- private void remeasure(int width, int height) {
+ private fun remeasure(width: Int, height: Int) {
// Shrink to fit available space but make sure we can display at least two events
- MAX_UNEXPANDED_ALLDAY_HEIGHT = (int) (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4);
- MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.min(MAX_UNEXPANDED_ALLDAY_HEIGHT, height / 6);
- MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.max(MAX_UNEXPANDED_ALLDAY_HEIGHT,
- (int) MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 2);
+ MAX_UNEXPANDED_ALLDAY_HEIGHT = (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4).toInt()
+ MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.min(MAX_UNEXPANDED_ALLDAY_HEIGHT, height / 6)
+ MAX_UNEXPANDED_ALLDAY_HEIGHT = Math.max(
+ MAX_UNEXPANDED_ALLDAY_HEIGHT,
+ MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt() * 2
+ )
mMaxUnexpandedAlldayEventCount =
- (int) (MAX_UNEXPANDED_ALLDAY_HEIGHT / MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT);
+ (MAX_UNEXPANDED_ALLDAY_HEIGHT / MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
// First, clear the array of earliest start times, and the array
// indicating presence of an all-day event.
- for (int day = 0; day < mNumDays; day++) {
- mEarliestStartHour[day] = 25; // some big number
- mHasAllDayEvent[day] = false;
+ for (day in 0 until mNumDays) {
+ mEarliestStartHour[day] = 25 // some big number
+ mHasAllDayEvent[day] = false
}
-
- int maxAllDayEvents = mMaxAlldayEvents;
+ val maxAllDayEvents = mMaxAlldayEvents
// The min is where 24 hours cover the entire visible area
- mMinCellHeight = Math.max((height - DAY_HEADER_HEIGHT) / 24, (int) MIN_EVENT_HEIGHT);
+ mMinCellHeight = Math.max((height - DAY_HEADER_HEIGHT) / 24, MIN_EVENT_HEIGHT.toInt())
if (mCellHeight < mMinCellHeight) {
- mCellHeight = mMinCellHeight;
+ mCellHeight = mMinCellHeight
}
// Calculate mAllDayHeight
- mFirstCell = DAY_HEADER_HEIGHT;
- int allDayHeight = 0;
+ mFirstCell = DAY_HEADER_HEIGHT
+ var allDayHeight = 0
if (maxAllDayEvents > 0) {
- int maxAllAllDayHeight = height - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT;
+ val maxAllAllDayHeight = height - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
// If there is at most one all-day event per day, then use less
// space (but more than the space for a single event).
if (maxAllDayEvents == 1) {
- allDayHeight = SINGLE_ALLDAY_HEIGHT;
- } else if (maxAllDayEvents <= mMaxUnexpandedAlldayEventCount){
+ allDayHeight = SINGLE_ALLDAY_HEIGHT
+ } else if (maxAllDayEvents <= mMaxUnexpandedAlldayEventCount) {
// Allow the all-day area to grow in height depending on the
// number of all-day events we need to show, up to a limit.
- allDayHeight = maxAllDayEvents * MAX_HEIGHT_OF_ONE_ALLDAY_EVENT;
+ allDayHeight = maxAllDayEvents * MAX_HEIGHT_OF_ONE_ALLDAY_EVENT
if (allDayHeight > MAX_UNEXPANDED_ALLDAY_HEIGHT) {
- allDayHeight = MAX_UNEXPANDED_ALLDAY_HEIGHT;
+ allDayHeight = MAX_UNEXPANDED_ALLDAY_HEIGHT
}
} else {
// if we have more than the magic number, check if we're animating
@@ -1268,58 +860,58 @@
// Don't shrink the space past the final allDay space. The animation
// continues to hide the last event so the more events text can
// fade in.
- allDayHeight = Math.max(mAnimateDayHeight, MAX_UNEXPANDED_ALLDAY_HEIGHT);
+ allDayHeight = Math.max(mAnimateDayHeight, MAX_UNEXPANDED_ALLDAY_HEIGHT)
} else {
// Try to fit all the events in
- allDayHeight = (int) (maxAllDayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT);
+ allDayHeight = (maxAllDayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
// But clip the area depending on which mode we're in
if (!mShowAllAllDayEvents && allDayHeight > MAX_UNEXPANDED_ALLDAY_HEIGHT) {
- allDayHeight = (int) (mMaxUnexpandedAlldayEventCount *
- MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT);
+ allDayHeight = (mMaxUnexpandedAlldayEventCount *
+ MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
} else if (allDayHeight > maxAllAllDayHeight) {
- allDayHeight = maxAllAllDayHeight;
+ allDayHeight = maxAllAllDayHeight
}
}
}
- mFirstCell = DAY_HEADER_HEIGHT + allDayHeight + ALLDAY_TOP_MARGIN;
+ mFirstCell = DAY_HEADER_HEIGHT + allDayHeight + ALLDAY_TOP_MARGIN
} else {
- mSelectionAllday = false;
+ mSelectionAllday = false
}
- mAlldayHeight = allDayHeight;
-
- mGridAreaHeight = height - mFirstCell;
+ mAlldayHeight = allDayHeight
+ mGridAreaHeight = height - mFirstCell
// Set up the expand icon position
- int allDayIconWidth = mExpandAlldayDrawable.getIntrinsicWidth();
- mExpandAllDayRect.left = Math.max((mHoursWidth - allDayIconWidth) / 2,
- EVENT_ALL_DAY_TEXT_LEFT_MARGIN);
- mExpandAllDayRect.right = Math.min(mExpandAllDayRect.left + allDayIconWidth, mHoursWidth
- - EVENT_ALL_DAY_TEXT_RIGHT_MARGIN);
- mExpandAllDayRect.bottom = mFirstCell - EXPAND_ALL_DAY_BOTTOM_MARGIN;
- mExpandAllDayRect.top = mExpandAllDayRect.bottom
- - mExpandAlldayDrawable.getIntrinsicHeight();
-
- mNumHours = mGridAreaHeight / (mCellHeight + HOUR_GAP);
- mEventGeometry.setHourHeight(mCellHeight);
-
- final long minimumDurationMillis = (long)
- (MIN_EVENT_HEIGHT * DateUtils.MINUTE_IN_MILLIS / (mCellHeight / 60.0f));
- Event.computePositions(mEvents, minimumDurationMillis);
+ val allDayIconWidth: Int = mExpandAlldayDrawable.getIntrinsicWidth()
+ mExpandAllDayRect.left = Math.max(
+ (mHoursWidth - allDayIconWidth) / 2,
+ EVENT_ALL_DAY_TEXT_LEFT_MARGIN
+ )
+ mExpandAllDayRect.right = Math.min(
+ mExpandAllDayRect.left + allDayIconWidth, mHoursWidth
+ - EVENT_ALL_DAY_TEXT_RIGHT_MARGIN
+ )
+ mExpandAllDayRect.bottom = mFirstCell - EXPAND_ALL_DAY_BOTTOM_MARGIN
+ mExpandAllDayRect.top = (mExpandAllDayRect.bottom
+ - mExpandAlldayDrawable.getIntrinsicHeight())
+ mNumHours = mGridAreaHeight / (mCellHeight + HOUR_GAP)
+ mEventGeometry.setHourHeight(mCellHeight)
+ val minimumDurationMillis =
+ (MIN_EVENT_HEIGHT * DateUtils.MINUTE_IN_MILLIS / (mCellHeight / 60.0f)) as Long
+ Event.computePositions(mEvents, minimumDurationMillis)
// Compute the top of our reachable view
- mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight;
+ mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight
if (DEBUG) {
- Log.e(TAG, "mViewStartY: " + mViewStartY);
- Log.e(TAG, "mMaxViewStartY: " + mMaxViewStartY);
+ Log.e(TAG, "mViewStartY: $mViewStartY")
+ Log.e(TAG, "mMaxViewStartY: $mMaxViewStartY")
}
if (mViewStartY > mMaxViewStartY) {
- mViewStartY = mMaxViewStartY;
- computeFirstHour();
+ mViewStartY = mMaxViewStartY
+ computeFirstHour()
}
-
if (mFirstHour == -1) {
- initFirstHour();
- mFirstHourOffset = 0;
+ initFirstHour()
+ mFirstHourOffset = 0
}
// When we change the base date, the number of all-day events may
@@ -1327,17 +919,16 @@
// we use the mFirstHourOffset from the previous view, but that may
// be too large for the new view if the cell height is smaller.
if (mFirstHourOffset >= mCellHeight + HOUR_GAP) {
- mFirstHourOffset = mCellHeight + HOUR_GAP - 1;
+ mFirstHourOffset = mCellHeight + HOUR_GAP - 1
}
- mViewStartY = mFirstHour * (mCellHeight + HOUR_GAP) - mFirstHourOffset;
-
- final int eventAreaWidth = mNumDays * (mCellWidth + DAY_GAP);
+ mViewStartY = mFirstHour * (mCellHeight + HOUR_GAP) - mFirstHourOffset
+ val eventAreaWidth = mNumDays * (mCellWidth + DAY_GAP)
//When we get new events we don't want to dismiss the popup unless the event changes
if (mSelectedEvent != null && mLastPopupEventID != mSelectedEvent.id) {
- mPopup.dismiss();
+ mPopup.dismiss()
}
- mPopup.setWidth(eventAreaWidth - 20);
- mPopup.setHeight(WindowManager.LayoutParams.WRAP_CONTENT);
+ mPopup.setWidth(eventAreaWidth - 20)
+ mPopup.setHeight(WindowManager.LayoutParams.WRAP_CONTENT)
}
/**
@@ -1348,28 +939,27 @@
*
* @param view the view to initialize.
*/
- private void initView(DayView view) {
- view.setSelectedHour(mSelectionHour);
- view.mSelectedEvents.clear();
- view.mComputeSelectedEvents = true;
- view.mFirstHour = mFirstHour;
- view.mFirstHourOffset = mFirstHourOffset;
- view.remeasure(getWidth(), getHeight());
- view.initAllDayHeights();
-
- view.setSelectedEvent(null);
- view.mPrevSelectedEvent = null;
- view.mFirstDayOfWeek = mFirstDayOfWeek;
+ private fun initView(view: DayView) {
+ view.setSelectedHour(mSelectionHour)
+ view.mSelectedEvents.clear()
+ view.mComputeSelectedEvents = true
+ view.mFirstHour = mFirstHour
+ view.mFirstHourOffset = mFirstHourOffset
+ view.remeasure(getWidth(), getHeight())
+ view.initAllDayHeights()
+ view.setSelectedEvent(null)
+ view.mPrevSelectedEvent = null
+ view.mFirstDayOfWeek = mFirstDayOfWeek
if (view.mEvents.size() > 0) {
- view.mSelectionAllday = mSelectionAllday;
+ view.mSelectionAllday = mSelectionAllday
} else {
- view.mSelectionAllday = false;
+ view.mSelectionAllday = false
}
// Redraw the screen so that the selection box will be redrawn. We may
// have scrolled to a different part of the day in some other view
// so the selection box in this view may no longer be visible.
- view.recalc();
+ view.recalc()
}
/**
@@ -1379,11 +969,10 @@
* @param trackBallSelection true if the selection was made using the
* trackball.
*/
- private void switchViews(boolean trackBallSelection) {
- Event selectedEvent = mSelectedEvent;
-
- mPopup.dismiss();
- mLastPopupEventID = INVALID_EVENT_ID;
+ private fun switchViews(trackBallSelection: Boolean) {
+ val selectedEvent: Event? = mSelectedEvent
+ mPopup.dismiss()
+ mLastPopupEventID = INVALID_EVENT_ID
if (mNumDays > 1) {
// This is the Week view.
// With touch, we always switch to Day/Agenda View
@@ -1392,7 +981,7 @@
if (trackBallSelection) {
if (selectedEvent != null) {
if (mIsAccessibilityEnabled) {
- mAccessibilityMgr.interrupt();
+ mAccessibilityMgr.interrupt()
}
}
}
@@ -1400,91 +989,89 @@
}
@Override
- public boolean onKeyUp(int keyCode, KeyEvent event) {
- mScrolling = false;
- return super.onKeyUp(keyCode, event);
+ fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+ mScrolling = false
+ return super.onKeyUp(keyCode, event)
}
@Override
- public boolean onKeyDown(int keyCode, KeyEvent event) {
- return super.onKeyDown(keyCode, event);
+ fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
+ return super.onKeyDown(keyCode, event)
}
-
@Override
- public boolean onHoverEvent(MotionEvent event) {
- return true;
+ fun onHoverEvent(event: MotionEvent?): Boolean {
+ return true
}
- private boolean isTouchExplorationEnabled() {
- return mIsAccessibilityEnabled && mAccessibilityMgr.isTouchExplorationEnabled();
- }
+ private val isTouchExplorationEnabled: Boolean
+ private get() = mIsAccessibilityEnabled && mAccessibilityMgr.isTouchExplorationEnabled()
- private void sendAccessibilityEventAsNeeded(boolean speakEvents) {
+ private fun sendAccessibilityEventAsNeeded(speakEvents: Boolean) {
if (!mIsAccessibilityEnabled) {
- return;
+ return
}
- boolean dayChanged = mLastSelectionDayForAccessibility != mSelectionDayForAccessibility;
- boolean hourChanged = mLastSelectionHourForAccessibility != mSelectionHourForAccessibility;
- if (dayChanged || hourChanged ||
- mLastSelectedEventForAccessibility != mSelectedEventForAccessibility) {
- mLastSelectionDayForAccessibility = mSelectionDayForAccessibility;
- mLastSelectionHourForAccessibility = mSelectionHourForAccessibility;
- mLastSelectedEventForAccessibility = mSelectedEventForAccessibility;
-
- StringBuilder b = new StringBuilder();
+ val dayChanged = mLastSelectionDayForAccessibility != mSelectionDayForAccessibility
+ val hourChanged = mLastSelectionHourForAccessibility != mSelectionHourForAccessibility
+ if (dayChanged || hourChanged || mLastSelectedEventForAccessibility !== mSelectedEventForAccessibility) {
+ mLastSelectionDayForAccessibility = mSelectionDayForAccessibility
+ mLastSelectionHourForAccessibility = mSelectionHourForAccessibility
+ mLastSelectedEventForAccessibility = mSelectedEventForAccessibility
+ val b = StringBuilder()
// Announce only the changes i.e. day or hour or both
if (dayChanged) {
- b.append(getSelectedTimeForAccessibility().format("%A "));
+ b.append(selectedTimeForAccessibility.format("%A "))
}
if (hourChanged) {
- b.append(getSelectedTimeForAccessibility().format(mIs24HourFormat ? "%k" : "%l%p"));
+ b.append(selectedTimeForAccessibility.format(if (mIs24HourFormat) "%k" else "%l%p"))
}
if (dayChanged || hourChanged) {
- b.append(PERIOD_SPACE);
+ b.append(PERIOD_SPACE)
}
-
if (speakEvents) {
if (mEventCountTemplate == null) {
- mEventCountTemplate = mContext.getString(R.string.template_announce_item_index);
+ mEventCountTemplate = mContext.getString(R.string.template_announce_item_index)
}
// Read out the relevant event(s)
- int numEvents = mSelectedEvents.size();
+ val numEvents: Int = mSelectedEvents.size()
if (numEvents > 0) {
if (mSelectedEventForAccessibility == null) {
// Read out all the events
- int i = 1;
- for (Event calEvent : mSelectedEvents) {
+ var i = 1
+ for (calEvent in mSelectedEvents) {
if (numEvents > 1) {
// Read out x of numEvents if there are more than one event
- mStringBuilder.setLength(0);
- b.append(mFormatter.format(mEventCountTemplate, i++, numEvents));
- b.append(" ");
+ mStringBuilder.setLength(0)
+ b.append(mFormatter.format(mEventCountTemplate, i++, numEvents))
+ b.append(" ")
}
- appendEventAccessibilityString(b, calEvent);
+ appendEventAccessibilityString(b, calEvent)
}
} else {
if (numEvents > 1) {
// Read out x of numEvents if there are more than one event
- mStringBuilder.setLength(0);
- b.append(mFormatter.format(mEventCountTemplate, mSelectedEvents
- .indexOf(mSelectedEventForAccessibility) + 1, numEvents));
- b.append(" ");
+ mStringBuilder.setLength(0)
+ b.append(
+ mFormatter.format(
+ mEventCountTemplate, mSelectedEvents
+ .indexOf(mSelectedEventForAccessibility) + 1, numEvents
+ )
+ )
+ b.append(" ")
}
- appendEventAccessibilityString(b, mSelectedEventForAccessibility);
+ appendEventAccessibilityString(b, mSelectedEventForAccessibility)
}
}
}
-
if (dayChanged || hourChanged || speakEvents) {
- AccessibilityEvent event = AccessibilityEvent
- .obtain(AccessibilityEvent.TYPE_VIEW_FOCUSED);
- CharSequence msg = b.toString();
- event.getText().add(msg);
- event.setAddedCount(msg.length());
- sendAccessibilityEventUnchecked(event);
+ val event: AccessibilityEvent = AccessibilityEvent
+ .obtain(AccessibilityEvent.TYPE_VIEW_FOCUSED)
+ val msg: CharSequence = b.toString()
+ event.getText().add(msg)
+ event.setAddedCount(msg.length())
+ sendAccessibilityEventUnchecked(event)
}
}
}
@@ -1493,159 +1080,153 @@
* @param b
* @param calEvent
*/
- private void appendEventAccessibilityString(StringBuilder b, Event calEvent) {
- b.append(calEvent.getTitleAndLocation());
- b.append(PERIOD_SPACE);
- String when;
- int flags = DateUtils.FORMAT_SHOW_DATE;
+ private fun appendEventAccessibilityString(b: StringBuilder, calEvent: Event?) {
+ b.append(calEvent.getTitleAndLocation())
+ b.append(PERIOD_SPACE)
+ val `when`: String
+ var flags: Int = DateUtils.FORMAT_SHOW_DATE
if (calEvent.allDay) {
- flags |= DateUtils.FORMAT_UTC | DateUtils.FORMAT_SHOW_WEEKDAY;
+ flags = flags or (DateUtils.FORMAT_UTC or DateUtils.FORMAT_SHOW_WEEKDAY)
} else {
- flags |= DateUtils.FORMAT_SHOW_TIME;
+ flags = flags or DateUtils.FORMAT_SHOW_TIME
if (DateFormat.is24HourFormat(mContext)) {
- flags |= DateUtils.FORMAT_24HOUR;
+ flags = flags or DateUtils.FORMAT_24HOUR
}
}
- when = Utils.formatDateRange(mContext, calEvent.startMillis, calEvent.endMillis, flags);
- b.append(when);
- b.append(PERIOD_SPACE);
+ `when` = Utils.formatDateRange(mContext, calEvent.startMillis, calEvent.endMillis, flags)
+ b.append(`when`)
+ b.append(PERIOD_SPACE)
}
- private class GotoBroadcaster implements Animation.AnimationListener {
- private final int mCounter;
- private final Time mStart;
- private final Time mEnd;
-
- public GotoBroadcaster(Time start, Time end) {
- mCounter = ++sCounter;
- mStart = start;
- mEnd = end;
- }
-
+ private inner class GotoBroadcaster(start: Time, end: Time) : Animation.AnimationListener {
+ private val mCounter: Int
+ private val mStart: Time
+ private val mEnd: Time
@Override
- public void onAnimationEnd(Animation animation) {
- DayView view = (DayView) mViewSwitcher.getCurrentView();
- view.mViewStartX = 0;
- view = (DayView) mViewSwitcher.getNextView();
- view.mViewStartX = 0;
-
+ fun onAnimationEnd(animation: Animation?) {
+ var view = mViewSwitcher.getCurrentView() as DayView
+ view.mViewStartX = 0
+ view = mViewSwitcher.getNextView()
+ view.mViewStartX = 0
if (mCounter == sCounter) {
- mController.sendEvent(this, EventType.GO_TO, mStart, mEnd, null, -1,
- ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null);
+ mController.sendEvent(
+ this, EventType.GO_TO, mStart, mEnd, null, -1,
+ ViewType.CURRENT, CalendarController.EXTRA_GOTO_DATE, null, null
+ )
}
}
@Override
- public void onAnimationRepeat(Animation animation) {
+ fun onAnimationRepeat(animation: Animation?) {
}
@Override
- public void onAnimationStart(Animation animation) {
+ fun onAnimationStart(animation: Animation?) {
+ }
+
+ init {
+ mCounter = ++sCounter
+ mStart = start
+ mEnd = end
}
}
- private View switchViews(boolean forward, float xOffSet, float width, float velocity) {
- mAnimationDistance = width - xOffSet;
+ private fun switchViews(forward: Boolean, xOffSet: Float, width: Float, velocity: Float): View {
+ mAnimationDistance = width - xOffSet
if (DEBUG) {
- Log.d(TAG, "switchViews(" + forward + ") O:" + xOffSet + " Dist:" + mAnimationDistance);
+ Log.d(TAG, "switchViews($forward) O:$xOffSet Dist:$mAnimationDistance")
}
-
- float progress = Math.abs(xOffSet) / width;
+ var progress: Float = Math.abs(xOffSet) / width
if (progress > 1.0f) {
- progress = 1.0f;
+ progress = 1.0f
}
-
- float inFromXValue, inToXValue;
- float outFromXValue, outToXValue;
+ val inFromXValue: Float
+ val inToXValue: Float
+ val outFromXValue: Float
+ val outToXValue: Float
if (forward) {
- inFromXValue = 1.0f - progress;
- inToXValue = 0.0f;
- outFromXValue = -progress;
- outToXValue = -1.0f;
+ inFromXValue = 1.0f - progress
+ inToXValue = 0.0f
+ outFromXValue = -progress
+ outToXValue = -1.0f
} else {
- inFromXValue = progress - 1.0f;
- inToXValue = 0.0f;
- outFromXValue = progress;
- outToXValue = 1.0f;
+ inFromXValue = progress - 1.0f
+ inToXValue = 0.0f
+ outFromXValue = progress
+ outToXValue = 1.0f
}
-
- final Time start = new Time(mBaseDate.timezone);
- start.set(mController.getTime());
+ val start = Time(mBaseDate.timezone)
+ start.set(mController.getTime())
if (forward) {
- start.monthDay += mNumDays;
+ start.monthDay += mNumDays
} else {
- start.monthDay -= mNumDays;
+ start.monthDay -= mNumDays
}
- mController.setTime(start.normalize(true));
-
- Time newSelected = start;
-
+ mController.setTime(start.normalize(true))
+ var newSelected: Time? = start
if (mNumDays == 7) {
- newSelected = new Time(start);
- adjustToBeginningOfWeek(start);
+ newSelected = Time(start)
+ adjustToBeginningOfWeek(start)
}
-
- final Time end = new Time(start);
- end.monthDay += mNumDays - 1;
+ val end = Time(start)
+ end.monthDay += mNumDays - 1
// We have to allocate these animation objects each time we switch views
// because that is the only way to set the animation parameters.
- TranslateAnimation inAnimation = new TranslateAnimation(
- Animation.RELATIVE_TO_SELF, inFromXValue,
- Animation.RELATIVE_TO_SELF, inToXValue,
- Animation.ABSOLUTE, 0.0f,
- Animation.ABSOLUTE, 0.0f);
-
- TranslateAnimation outAnimation = new TranslateAnimation(
- Animation.RELATIVE_TO_SELF, outFromXValue,
- Animation.RELATIVE_TO_SELF, outToXValue,
- Animation.ABSOLUTE, 0.0f,
- Animation.ABSOLUTE, 0.0f);
-
- long duration = calculateDuration(width - Math.abs(xOffSet), width, velocity);
- inAnimation.setDuration(duration);
- inAnimation.setInterpolator(mHScrollInterpolator);
- outAnimation.setInterpolator(mHScrollInterpolator);
- outAnimation.setDuration(duration);
- outAnimation.setAnimationListener(new GotoBroadcaster(start, end));
- mViewSwitcher.setInAnimation(inAnimation);
- mViewSwitcher.setOutAnimation(outAnimation);
-
- DayView view = (DayView) mViewSwitcher.getCurrentView();
- view.cleanup();
- mViewSwitcher.showNext();
- view = (DayView) mViewSwitcher.getCurrentView();
- view.setSelected(newSelected, true, false);
- view.requestFocus();
- view.reloadEvents();
- view.updateTitle();
- view.restartCurrentTimeUpdates();
-
- return view;
+ val inAnimation = TranslateAnimation(
+ Animation.RELATIVE_TO_SELF, inFromXValue,
+ Animation.RELATIVE_TO_SELF, inToXValue,
+ Animation.ABSOLUTE, 0.0f,
+ Animation.ABSOLUTE, 0.0f
+ )
+ val outAnimation = TranslateAnimation(
+ Animation.RELATIVE_TO_SELF, outFromXValue,
+ Animation.RELATIVE_TO_SELF, outToXValue,
+ Animation.ABSOLUTE, 0.0f,
+ Animation.ABSOLUTE, 0.0f
+ )
+ val duration = calculateDuration(width - Math.abs(xOffSet), width, velocity)
+ inAnimation.setDuration(duration)
+ inAnimation.setInterpolator(mHScrollInterpolator)
+ outAnimation.setInterpolator(mHScrollInterpolator)
+ outAnimation.setDuration(duration)
+ outAnimation.setAnimationListener(GotoBroadcaster(start, end))
+ mViewSwitcher.setInAnimation(inAnimation)
+ mViewSwitcher.setOutAnimation(outAnimation)
+ var view = mViewSwitcher.getCurrentView() as DayView
+ view.cleanup()
+ mViewSwitcher.showNext()
+ view = mViewSwitcher.getCurrentView()
+ view.setSelected(newSelected, true, false)
+ view.requestFocus()
+ view.reloadEvents()
+ view.updateTitle()
+ view.restartCurrentTimeUpdates()
+ return view
}
// This is called after scrolling stops to move the selected hour
// to the visible part of the screen.
- private void resetSelectedHour() {
+ private fun resetSelectedHour() {
if (mSelectionHour < mFirstHour + 1) {
- setSelectedHour(mFirstHour + 1);
- setSelectedEvent(null);
- mSelectedEvents.clear();
- mComputeSelectedEvents = true;
+ setSelectedHour(mFirstHour + 1)
+ setSelectedEvent(null)
+ mSelectedEvents.clear()
+ mComputeSelectedEvents = true
} else if (mSelectionHour > mFirstHour + mNumHours - 3) {
- setSelectedHour(mFirstHour + mNumHours - 3);
- setSelectedEvent(null);
- mSelectedEvents.clear();
- mComputeSelectedEvents = true;
+ setSelectedHour(mFirstHour + mNumHours - 3)
+ setSelectedEvent(null)
+ mSelectedEvents.clear()
+ mComputeSelectedEvents = true
}
}
- private void initFirstHour() {
- mFirstHour = mSelectionHour - mNumHours / 5;
+ private fun initFirstHour() {
+ mFirstHour = mSelectionHour - mNumHours / 5
if (mFirstHour < 0) {
- mFirstHour = 0;
+ mFirstHour = 0
} else if (mFirstHour + mNumHours > 24) {
- mFirstHour = 24 - mNumHours;
+ mFirstHour = 24 - mNumHours
}
}
@@ -1653,23 +1234,22 @@
* Recomputes the first full hour that is visible on screen after the
* screen is scrolled.
*/
- private void computeFirstHour() {
+ private fun computeFirstHour() {
// Compute the first full hour that is visible on screen
- mFirstHour = (mViewStartY + mCellHeight + HOUR_GAP - 1) / (mCellHeight + HOUR_GAP);
- mFirstHourOffset = mFirstHour * (mCellHeight + HOUR_GAP) - mViewStartY;
+ mFirstHour = (mViewStartY + mCellHeight + HOUR_GAP - 1) / (mCellHeight + HOUR_GAP)
+ mFirstHourOffset = mFirstHour * (mCellHeight + HOUR_GAP) - mViewStartY
}
- private void adjustHourSelection() {
+ private fun adjustHourSelection() {
if (mSelectionHour < 0) {
- setSelectedHour(0);
+ setSelectedHour(0)
if (mMaxAlldayEvents > 0) {
- mPrevSelectedEvent = null;
- mSelectionAllday = true;
+ mPrevSelectedEvent = null
+ mSelectionAllday = true
}
}
-
if (mSelectionHour > 23) {
- setSelectedHour(23);
+ setSelectedHour(23)
}
// If the selected hour is at least 2 time slots from the top and
@@ -1682,52 +1262,48 @@
// before jumping to the all-day event area.
// Exception 2: if 12am is on screen, then allow the user to select
// 12am before going up to the all-day event area.
- int daynum = mSelectionDay - mFirstJulianDay;
- if (daynum < mEarliestStartHour.length && daynum >= 0
- && mMaxAlldayEvents > 0
- && mEarliestStartHour[daynum] > mSelectionHour
- && mFirstHour > 0 && mFirstHour < 8) {
- mPrevSelectedEvent = null;
- mSelectionAllday = true;
- setSelectedHour(mFirstHour + 1);
- return;
+ val daynum = mSelectionDay - mFirstJulianDay
+ if (daynum < mEarliestStartHour.size && daynum >= 0 && mMaxAlldayEvents > 0 && mEarliestStartHour[daynum] > mSelectionHour && mFirstHour > 0 && mFirstHour < 8) {
+ mPrevSelectedEvent = null
+ mSelectionAllday = true
+ setSelectedHour(mFirstHour + 1)
+ return
}
-
if (mFirstHour > 0) {
- mFirstHour -= 1;
- mViewStartY -= (mCellHeight + HOUR_GAP);
+ mFirstHour -= 1
+ mViewStartY -= mCellHeight + HOUR_GAP
if (mViewStartY < 0) {
- mViewStartY = 0;
+ mViewStartY = 0
}
- return;
+ return
}
}
-
if (mSelectionHour > mFirstHour + mNumHours - 3) {
if (mFirstHour < 24 - mNumHours) {
- mFirstHour += 1;
- mViewStartY += (mCellHeight + HOUR_GAP);
+ mFirstHour += 1
+ mViewStartY += mCellHeight + HOUR_GAP
if (mViewStartY > mMaxViewStartY) {
- mViewStartY = mMaxViewStartY;
+ mViewStartY = mMaxViewStartY
}
- return;
+ return
} else if (mFirstHour == 24 - mNumHours && mFirstHourOffset > 0) {
- mViewStartY = mMaxViewStartY;
+ mViewStartY = mMaxViewStartY
}
}
}
- void clearCachedEvents() {
- mLastReloadMillis = 0;
+ fun clearCachedEvents() {
+ mLastReloadMillis = 0
}
- private final Runnable mCancelCallback = new Runnable() {
- public void run() {
- clearCachedEvents();
+ private val mCancelCallback: Runnable = object : Runnable() {
+ fun run() {
+ clearCachedEvents()
}
- };
+ }
- /* package */ void reloadEvents() {
+ /* package */
+ fun reloadEvents() {
// Protect against this being called before this view has been
// initialized.
// if (mContext == null) {
@@ -1735,99 +1311,92 @@
// }
// Make sure our time zones are up to date
- mTZUpdater.run();
-
- setSelectedEvent(null);
- mPrevSelectedEvent = null;
- mSelectedEvents.clear();
+ mTZUpdater.run()
+ setSelectedEvent(null)
+ mPrevSelectedEvent = null
+ mSelectedEvents.clear()
// The start date is the beginning of the week at 12am
- Time weekStart = new Time(Utils.getTimeZone(mContext, mTZUpdater));
- weekStart.set(mBaseDate);
- weekStart.hour = 0;
- weekStart.minute = 0;
- weekStart.second = 0;
- long millis = weekStart.normalize(true /* ignore isDst */);
+ val weekStart = Time(Utils.getTimeZone(mContext, mTZUpdater))
+ weekStart.set(mBaseDate)
+ weekStart.hour = 0
+ weekStart.minute = 0
+ weekStart.second = 0
+ val millis: Long = weekStart.normalize(true /* ignore isDst */)
// Avoid reloading events unnecessarily.
if (millis == mLastReloadMillis) {
- return;
+ return
}
- mLastReloadMillis = millis;
+ mLastReloadMillis = millis
// load events in the background
// mContext.startProgressSpinner();
- final ArrayList<Event> events = new ArrayList<Event>();
- mEventLoader.loadEventsInBackground(mNumDays, events, mFirstJulianDay, new Runnable() {
-
- public void run() {
- boolean fadeinEvents = mFirstJulianDay != mLoadedFirstJulianDay;
- mEvents = events;
- mLoadedFirstJulianDay = mFirstJulianDay;
+ val events: ArrayList<Event> = ArrayList<Event>()
+ mEventLoader.loadEventsInBackground(mNumDays, events, mFirstJulianDay, object : Runnable() {
+ fun run() {
+ val fadeinEvents = mFirstJulianDay != mLoadedFirstJulianDay
+ mEvents = events
+ mLoadedFirstJulianDay = mFirstJulianDay
if (mAllDayEvents == null) {
- mAllDayEvents = new ArrayList<Event>();
+ mAllDayEvents = ArrayList<Event>()
} else {
- mAllDayEvents.clear();
+ mAllDayEvents.clear()
}
// Create a shorter array for all day events
- for (Event e : events) {
+ for (e in events) {
if (e.drawAsAllday()) {
- mAllDayEvents.add(e);
+ mAllDayEvents.add(e)
}
}
// New events, new layouts
- if (mLayouts == null || mLayouts.length < events.size()) {
- mLayouts = new StaticLayout[events.size()];
+ if (mLayouts == null || mLayouts!!.size < events.size()) {
+ mLayouts = arrayOfNulls<StaticLayout>(events.size())
} else {
- Arrays.fill(mLayouts, null);
+ Arrays.fill(mLayouts, null)
}
-
- if (mAllDayLayouts == null || mAllDayLayouts.length < mAllDayEvents.size()) {
- mAllDayLayouts = new StaticLayout[events.size()];
+ if (mAllDayLayouts == null || mAllDayLayouts!!.size < mAllDayEvents.size()) {
+ mAllDayLayouts = arrayOfNulls<StaticLayout>(events.size())
} else {
- Arrays.fill(mAllDayLayouts, null);
+ Arrays.fill(mAllDayLayouts, null)
}
-
- computeEventRelations();
-
- mRemeasure = true;
- mComputeSelectedEvents = true;
- recalc();
+ computeEventRelations()
+ mRemeasure = true
+ mComputeSelectedEvents = true
+ recalc()
// Start animation to cross fade the events
if (fadeinEvents) {
if (mEventsCrossFadeAnimation == null) {
mEventsCrossFadeAnimation =
- ObjectAnimator.ofInt(DayView.this, "EventsAlpha", 0, 255);
- mEventsCrossFadeAnimation.setDuration(EVENTS_CROSS_FADE_DURATION);
+ ObjectAnimator.ofInt(this@DayView, "EventsAlpha", 0, 255)
+ mEventsCrossFadeAnimation.setDuration(EVENTS_CROSS_FADE_DURATION)
}
- mEventsCrossFadeAnimation.start();
- } else{
- invalidate();
+ mEventsCrossFadeAnimation.start()
+ } else {
+ invalidate()
}
}
- }, mCancelCallback);
+ }, mCancelCallback)
}
- public void setEventsAlpha(int alpha) {
- mEventsAlpha = alpha;
- invalidate();
- }
-
- public int getEventsAlpha() {
- return mEventsAlpha;
- }
-
- public void stopEventsAnimation() {
- if (mEventsCrossFadeAnimation != null) {
- mEventsCrossFadeAnimation.cancel();
+ var eventsAlpha: Int
+ get() = mEventsAlpha
+ set(alpha) {
+ mEventsAlpha = alpha
+ invalidate()
}
- mEventsAlpha = 255;
+
+ fun stopEventsAnimation() {
+ if (mEventsCrossFadeAnimation != null) {
+ mEventsCrossFadeAnimation.cancel()
+ }
+ mEventsAlpha = 255
}
- private void computeEventRelations() {
+ private fun computeEventRelations() {
// Compute the layout relation between each event before measuring cell
// width, as the cell width should be adjusted along with the relation.
//
@@ -1840,235 +1409,227 @@
// Make a pass over all the events, and keep track of the maximum
// number of all-day events in any one day. Also, keep track of
// the earliest event in each day.
- int maxAllDayEvents = 0;
- final ArrayList<Event> events = mEvents;
- final int len = events.size();
+ var maxAllDayEvents = 0
+ val events: ArrayList<Event> = mEvents
+ val len: Int = events.size()
// Num of all-day-events on each day.
- final int eventsCount[] = new int[mLastJulianDay - mFirstJulianDay + 1];
- Arrays.fill(eventsCount, 0);
- for (int ii = 0; ii < len; ii++) {
- Event event = events.get(ii);
+ val eventsCount = IntArray(mLastJulianDay - mFirstJulianDay + 1)
+ Arrays.fill(eventsCount, 0)
+ for (ii in 0 until len) {
+ val event: Event = events.get(ii)
if (event.startDay > mLastJulianDay || event.endDay < mFirstJulianDay) {
- continue;
+ continue
}
if (event.drawAsAllday()) {
// Count all the events being drawn as allDay events
- final int firstDay = Math.max(event.startDay, mFirstJulianDay);
- final int lastDay = Math.min(event.endDay, mLastJulianDay);
- for (int day = firstDay; day <= lastDay; day++) {
- final int count = ++eventsCount[day - mFirstJulianDay];
+ val firstDay: Int = Math.max(event.startDay, mFirstJulianDay)
+ val lastDay: Int = Math.min(event.endDay, mLastJulianDay)
+ for (day in firstDay..lastDay) {
+ val count = ++eventsCount[day - mFirstJulianDay]
if (maxAllDayEvents < count) {
- maxAllDayEvents = count;
+ maxAllDayEvents = count
}
}
-
- int daynum = event.startDay - mFirstJulianDay;
- int durationDays = event.endDay - event.startDay + 1;
+ var daynum: Int = event.startDay - mFirstJulianDay
+ var durationDays: Int = event.endDay - event.startDay + 1
if (daynum < 0) {
- durationDays += daynum;
- daynum = 0;
+ durationDays += daynum
+ daynum = 0
}
if (daynum + durationDays > mNumDays) {
- durationDays = mNumDays - daynum;
+ durationDays = mNumDays - daynum
}
- for (int day = daynum; durationDays > 0; day++, durationDays--) {
- mHasAllDayEvent[day] = true;
+ var day = daynum
+ while (durationDays > 0) {
+ mHasAllDayEvent[day] = true
+ day++
+ durationDays--
}
} else {
- int daynum = event.startDay - mFirstJulianDay;
- int hour = event.startTime / 60;
+ var daynum: Int = event.startDay - mFirstJulianDay
+ var hour: Int = event.startTime / 60
if (daynum >= 0 && hour < mEarliestStartHour[daynum]) {
- mEarliestStartHour[daynum] = hour;
+ mEarliestStartHour[daynum] = hour
}
// Also check the end hour in case the event spans more than
// one day.
- daynum = event.endDay - mFirstJulianDay;
- hour = event.endTime / 60;
+ daynum = event.endDay - mFirstJulianDay
+ hour = event.endTime / 60
if (daynum < mNumDays && hour < mEarliestStartHour[daynum]) {
- mEarliestStartHour[daynum] = hour;
+ mEarliestStartHour[daynum] = hour
}
}
}
- mMaxAlldayEvents = maxAllDayEvents;
- initAllDayHeights();
+ mMaxAlldayEvents = maxAllDayEvents
+ initAllDayHeights()
}
@Override
- protected void onDraw(Canvas canvas) {
+ protected fun onDraw(canvas: Canvas) {
if (mRemeasure) {
- remeasure(getWidth(), getHeight());
- mRemeasure = false;
+ remeasure(getWidth(), getHeight())
+ mRemeasure = false
}
- canvas.save();
-
- float yTranslate = -mViewStartY + DAY_HEADER_HEIGHT + mAlldayHeight;
+ canvas.save()
+ val yTranslate = (-mViewStartY + DAY_HEADER_HEIGHT + mAlldayHeight).toFloat()
// offset canvas by the current drag and header position
- canvas.translate(-mViewStartX, yTranslate);
+ canvas.translate(-mViewStartX, yTranslate)
// clip to everything below the allDay area
- Rect dest = mDestRect;
- dest.top = (int) (mFirstCell - yTranslate);
- dest.bottom = (int) (mViewHeight - yTranslate);
- dest.left = 0;
- dest.right = mViewWidth;
- canvas.save();
- canvas.clipRect(dest);
+ val dest: Rect = mDestRect
+ dest.top = (mFirstCell - yTranslate).toInt()
+ dest.bottom = (mViewHeight - yTranslate).toInt()
+ dest.left = 0
+ dest.right = mViewWidth
+ canvas.save()
+ canvas.clipRect(dest)
// Draw the movable part of the view
- doDraw(canvas);
+ doDraw(canvas)
// restore to having no clip
- canvas.restore();
-
- if ((mTouchMode & TOUCH_MODE_HSCROLL) != 0) {
- float xTranslate;
- if (mViewStartX > 0) {
- xTranslate = mViewWidth;
+ canvas.restore()
+ if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
+ val xTranslate: Float
+ xTranslate = if (mViewStartX > 0) {
+ mViewWidth.toFloat()
} else {
- xTranslate = -mViewWidth;
+ -mViewWidth.toFloat()
}
// Move the canvas around to prep it for the next view
// specifically, shift it by a screen and undo the
// yTranslation which will be redone in the nextView's onDraw().
- canvas.translate(xTranslate, -yTranslate);
- DayView nextView = (DayView) mViewSwitcher.getNextView();
+ canvas.translate(xTranslate, -yTranslate)
+ val nextView = mViewSwitcher.getNextView() as DayView
// Prevent infinite recursive calls to onDraw().
- nextView.mTouchMode = TOUCH_MODE_INITIAL_STATE;
-
- nextView.onDraw(canvas);
+ nextView.mTouchMode = TOUCH_MODE_INITIAL_STATE
+ nextView.onDraw(canvas)
// Move it back for this view
- canvas.translate(-xTranslate, 0);
+ canvas.translate(-xTranslate, 0)
} else {
// If we drew another view we already translated it back
// If we didn't draw another view we should be at the edge of the
// screen
- canvas.translate(mViewStartX, -yTranslate);
+ canvas.translate(mViewStartX, -yTranslate)
}
// Draw the fixed areas (that don't scroll) directly to the canvas.
- drawAfterScroll(canvas);
+ drawAfterScroll(canvas)
if (mComputeSelectedEvents && mUpdateToast) {
- mUpdateToast = false;
+ mUpdateToast = false
}
- mComputeSelectedEvents = false;
+ mComputeSelectedEvents = false
// Draw overscroll glow
if (!mEdgeEffectTop.isFinished()) {
if (DAY_HEADER_HEIGHT != 0) {
- canvas.translate(0, DAY_HEADER_HEIGHT);
+ canvas.translate(0, DAY_HEADER_HEIGHT)
}
if (mEdgeEffectTop.draw(canvas)) {
- invalidate();
+ invalidate()
}
if (DAY_HEADER_HEIGHT != 0) {
- canvas.translate(0, -DAY_HEADER_HEIGHT);
+ canvas.translate(0, -DAY_HEADER_HEIGHT)
}
}
if (!mEdgeEffectBottom.isFinished()) {
- canvas.rotate(180, mViewWidth/2, mViewHeight/2);
+ canvas.rotate(180, mViewWidth / 2, mViewHeight / 2)
if (mEdgeEffectBottom.draw(canvas)) {
- invalidate();
+ invalidate()
}
}
- canvas.restore();
+ canvas.restore()
}
- private void drawAfterScroll(Canvas canvas) {
- Paint p = mPaint;
- Rect r = mRect;
-
- drawAllDayHighlights(r, canvas, p);
+ private fun drawAfterScroll(canvas: Canvas) {
+ val p: Paint = mPaint
+ val r: Rect = mRect
+ drawAllDayHighlights(r, canvas, p)
if (mMaxAlldayEvents != 0) {
- drawAllDayEvents(mFirstJulianDay, mNumDays, canvas, p);
- drawUpperLeftCorner(r, canvas, p);
+ drawAllDayEvents(mFirstJulianDay, mNumDays, canvas, p)
+ drawUpperLeftCorner(r, canvas, p)
}
-
- drawScrollLine(r, canvas, p);
- drawDayHeaderLoop(r, canvas, p);
+ drawScrollLine(r, canvas, p)
+ drawDayHeaderLoop(r, canvas, p)
// Draw the AM and PM indicators if we're in 12 hour mode
if (!mIs24HourFormat) {
- drawAmPm(canvas, p);
+ drawAmPm(canvas, p)
}
}
// This isn't really the upper-left corner. It's the square area just
// below the upper-left corner, above the hours and to the left of the
// all-day area.
- private void drawUpperLeftCorner(Rect r, Canvas canvas, Paint p) {
- setupHourTextPaint(p);
+ private fun drawUpperLeftCorner(r: Rect, canvas: Canvas, p: Paint) {
+ setupHourTextPaint(p)
if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
// Draw the allDay expand/collapse icon
if (mUseExpandIcon) {
- mExpandAlldayDrawable.setBounds(mExpandAllDayRect);
- mExpandAlldayDrawable.draw(canvas);
+ mExpandAlldayDrawable.setBounds(mExpandAllDayRect)
+ mExpandAlldayDrawable.draw(canvas)
} else {
- mCollapseAlldayDrawable.setBounds(mExpandAllDayRect);
- mCollapseAlldayDrawable.draw(canvas);
+ mCollapseAlldayDrawable.setBounds(mExpandAllDayRect)
+ mCollapseAlldayDrawable.draw(canvas)
}
}
}
- private void drawScrollLine(Rect r, Canvas canvas, Paint p) {
- final int right = computeDayLeftPosition(mNumDays);
- final int y = mFirstCell - 1;
-
- p.setAntiAlias(false);
- p.setStyle(Style.FILL);
-
- p.setColor(mCalendarGridLineInnerHorizontalColor);
- p.setStrokeWidth(GRID_LINE_INNER_WIDTH);
- canvas.drawLine(GRID_LINE_LEFT_MARGIN, y, right, y, p);
- p.setAntiAlias(true);
+ private fun drawScrollLine(r: Rect, canvas: Canvas, p: Paint) {
+ val right = computeDayLeftPosition(mNumDays)
+ val y = mFirstCell - 1
+ p.setAntiAlias(false)
+ p.setStyle(Style.FILL)
+ p.setColor(mCalendarGridLineInnerHorizontalColor)
+ p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
+ canvas.drawLine(GRID_LINE_LEFT_MARGIN, y, right, y, p)
+ p.setAntiAlias(true)
}
// Computes the x position for the left side of the given day (base 0)
- private int computeDayLeftPosition(int day) {
- int effectiveWidth = mViewWidth - mHoursWidth;
- return day * effectiveWidth / mNumDays + mHoursWidth;
+ private fun computeDayLeftPosition(day: Int): Int {
+ val effectiveWidth = mViewWidth - mHoursWidth
+ return day * effectiveWidth / mNumDays + mHoursWidth
}
- private void drawAllDayHighlights(Rect r, Canvas canvas, Paint p) {
+ private fun drawAllDayHighlights(r: Rect, canvas: Canvas, p: Paint) {
if (mFutureBgColor != 0) {
// First, color the labels area light gray
- r.top = 0;
- r.bottom = DAY_HEADER_HEIGHT;
- r.left = 0;
- r.right = mViewWidth;
- p.setColor(mBgColor);
- p.setStyle(Style.FILL);
- canvas.drawRect(r, p);
+ r.top = 0
+ r.bottom = DAY_HEADER_HEIGHT
+ r.left = 0
+ r.right = mViewWidth
+ p.setColor(mBgColor)
+ p.setStyle(Style.FILL)
+ canvas.drawRect(r, p)
// and the area that says All day
- r.top = DAY_HEADER_HEIGHT;
- r.bottom = mFirstCell - 1;
- r.left = 0;
- r.right = mHoursWidth;
- canvas.drawRect(r, p);
-
- int startIndex = -1;
-
- int todayIndex = mTodayJulianDay - mFirstJulianDay;
+ r.top = DAY_HEADER_HEIGHT
+ r.bottom = mFirstCell - 1
+ r.left = 0
+ r.right = mHoursWidth
+ canvas.drawRect(r, p)
+ var startIndex = -1
+ val todayIndex = mTodayJulianDay - mFirstJulianDay
if (todayIndex < 0) {
// Future
- startIndex = 0;
+ startIndex = 0
} else if (todayIndex >= 1 && todayIndex + 1 < mNumDays) {
// Multiday - tomorrow is visible.
- startIndex = todayIndex + 1;
+ startIndex = todayIndex + 1
}
-
if (startIndex >= 0) {
// Draw the future highlight
- r.top = 0;
- r.bottom = mFirstCell - 1;
- r.left = computeDayLeftPosition(startIndex) + 1;
- r.right = computeDayLeftPosition(mNumDays);
- p.setColor(mFutureBgColor);
- p.setStyle(Style.FILL);
- canvas.drawRect(r, p);
+ r.top = 0
+ r.bottom = mFirstCell - 1
+ r.left = computeDayLeftPosition(startIndex) + 1
+ r.right = computeDayLeftPosition(mNumDays)
+ p.setColor(mFutureBgColor)
+ p.setStyle(Style.FILL)
+ canvas.drawRect(r, p)
}
}
}
- private void drawDayHeaderLoop(Rect r, Canvas canvas, Paint p) {
+ private fun drawDayHeaderLoop(r: Rect, canvas: Canvas, p: Paint) {
// Draw the horizontal day background banner
// p.setColor(mCalendarDateBannerBackground);
// r.top = 0;
@@ -2083,231 +1644,226 @@
// p.setColor(mCalendarGridAreaBackground);
// canvas.drawRect(r, p);
if (mNumDays == 1 && ONE_DAY_HEADER_HEIGHT == 0) {
- return;
+ return
}
-
- p.setTypeface(mBold);
- p.setTextAlign(Paint.Align.RIGHT);
- int cell = mFirstJulianDay;
-
- String[] dayNames;
- if (mDateStrWidth < mCellWidth) {
- dayNames = mDayStrs;
+ p.setTypeface(mBold)
+ p.setTextAlign(Paint.Align.RIGHT)
+ var cell = mFirstJulianDay
+ val dayNames: Array<String?>
+ dayNames = if (mDateStrWidth < mCellWidth) {
+ mDayStrs
} else {
- dayNames = mDayStrs2Letter;
+ mDayStrs2Letter
}
-
- p.setAntiAlias(true);
- for (int day = 0; day < mNumDays; day++, cell++) {
- int dayOfWeek = day + mFirstVisibleDayOfWeek;
+ p.setAntiAlias(true)
+ var day = 0
+ while (day < mNumDays) {
+ var dayOfWeek = day + mFirstVisibleDayOfWeek
if (dayOfWeek >= 14) {
- dayOfWeek -= 14;
+ dayOfWeek -= 14
}
-
- int color = mCalendarDateBannerTextColor;
+ var color = mCalendarDateBannerTextColor
if (mNumDays == 1) {
if (dayOfWeek == Time.SATURDAY) {
- color = mWeek_saturdayColor;
+ color = mWeek_saturdayColor
} else if (dayOfWeek == Time.SUNDAY) {
- color = mWeek_sundayColor;
+ color = mWeek_sundayColor
}
} else {
- final int column = day % 7;
+ val column = day % 7
if (Utils.isSaturday(column, mFirstDayOfWeek)) {
- color = mWeek_saturdayColor;
+ color = mWeek_saturdayColor
} else if (Utils.isSunday(column, mFirstDayOfWeek)) {
- color = mWeek_sundayColor;
+ color = mWeek_sundayColor
}
}
-
- p.setColor(color);
- drawDayHeader(dayNames[dayOfWeek], day, cell, canvas, p);
+ p.setColor(color)
+ drawDayHeader(dayNames[dayOfWeek], day, cell, canvas, p)
+ day++
+ cell++
}
- p.setTypeface(null);
+ p.setTypeface(null)
}
- private void drawAmPm(Canvas canvas, Paint p) {
- p.setColor(mCalendarAmPmLabel);
- p.setTextSize(AMPM_TEXT_SIZE);
- p.setTypeface(mBold);
- p.setAntiAlias(true);
- p.setTextAlign(Paint.Align.RIGHT);
- String text = mAmString;
+ private fun drawAmPm(canvas: Canvas, p: Paint) {
+ p.setColor(mCalendarAmPmLabel)
+ p.setTextSize(AMPM_TEXT_SIZE)
+ p.setTypeface(mBold)
+ p.setAntiAlias(true)
+ p.setTextAlign(Paint.Align.RIGHT)
+ var text = mAmString
if (mFirstHour >= 12) {
- text = mPmString;
+ text = mPmString
}
- int y = mFirstCell + mFirstHourOffset + 2 * mHoursTextHeight + HOUR_GAP;
- canvas.drawText(text, HOURS_LEFT_MARGIN, y, p);
-
+ var y = mFirstCell + mFirstHourOffset + 2 * mHoursTextHeight + HOUR_GAP
+ canvas.drawText(text, HOURS_LEFT_MARGIN, y, p)
if (mFirstHour < 12 && mFirstHour + mNumHours > 12) {
// Also draw the "PM"
- text = mPmString;
- y = mFirstCell + mFirstHourOffset + (12 - mFirstHour) * (mCellHeight + HOUR_GAP)
- + 2 * mHoursTextHeight + HOUR_GAP;
- canvas.drawText(text, HOURS_LEFT_MARGIN, y, p);
+ text = mPmString
+ y =
+ mFirstCell + mFirstHourOffset + (12 - mFirstHour) * (mCellHeight + HOUR_GAP) + 2 * mHoursTextHeight + HOUR_GAP
+ canvas.drawText(text, HOURS_LEFT_MARGIN, y, p)
}
}
- private void drawCurrentTimeLine(Rect r, final int day, final int top, Canvas canvas,
- Paint p) {
- r.left = computeDayLeftPosition(day) - CURRENT_TIME_LINE_SIDE_BUFFER + 1;
- r.right = computeDayLeftPosition(day + 1) + CURRENT_TIME_LINE_SIDE_BUFFER + 1;
-
- r.top = top - CURRENT_TIME_LINE_TOP_OFFSET;
- r.bottom = r.top + mCurrentTimeLine.getIntrinsicHeight();
-
- mCurrentTimeLine.setBounds(r);
- mCurrentTimeLine.draw(canvas);
+ private fun drawCurrentTimeLine(
+ r: Rect, day: Int, top: Int, canvas: Canvas,
+ p: Paint
+ ) {
+ r.left = computeDayLeftPosition(day) - CURRENT_TIME_LINE_SIDE_BUFFER + 1
+ r.right = computeDayLeftPosition(day + 1) + CURRENT_TIME_LINE_SIDE_BUFFER + 1
+ r.top = top - CURRENT_TIME_LINE_TOP_OFFSET
+ r.bottom = r.top + mCurrentTimeLine.getIntrinsicHeight()
+ mCurrentTimeLine.setBounds(r)
+ mCurrentTimeLine.draw(canvas)
if (mAnimateToday) {
- mCurrentTimeAnimateLine.setBounds(r);
- mCurrentTimeAnimateLine.setAlpha(mAnimateTodayAlpha);
- mCurrentTimeAnimateLine.draw(canvas);
+ mCurrentTimeAnimateLine.setBounds(r)
+ mCurrentTimeAnimateLine.setAlpha(mAnimateTodayAlpha)
+ mCurrentTimeAnimateLine.draw(canvas)
}
}
- private void doDraw(Canvas canvas) {
- Paint p = mPaint;
- Rect r = mRect;
-
+ private fun doDraw(canvas: Canvas) {
+ val p: Paint = mPaint
+ val r: Rect = mRect
if (mFutureBgColor != 0) {
- drawBgColors(r, canvas, p);
+ drawBgColors(r, canvas, p)
}
- drawGridBackground(r, canvas, p);
- drawHours(r, canvas, p);
+ drawGridBackground(r, canvas, p)
+ drawHours(r, canvas, p)
// Draw each day
- int cell = mFirstJulianDay;
- p.setAntiAlias(false);
- int alpha = p.getAlpha();
- p.setAlpha(mEventsAlpha);
- for (int day = 0; day < mNumDays; day++, cell++) {
+ var cell = mFirstJulianDay
+ p.setAntiAlias(false)
+ val alpha: Int = p.getAlpha()
+ p.setAlpha(mEventsAlpha)
+ var day = 0
+ while (day < mNumDays) {
+
// TODO Wow, this needs cleanup. drawEvents loop through all the
// events on every call.
- drawEvents(cell, day, HOUR_GAP, canvas, p);
+ drawEvents(cell, day, HOUR_GAP, canvas, p)
// If this is today
if (cell == mTodayJulianDay) {
- int lineY = mCurrentTime.hour * (mCellHeight + HOUR_GAP)
- + ((mCurrentTime.minute * mCellHeight) / 60) + 1;
+ val lineY: Int =
+ mCurrentTime.hour * (mCellHeight + HOUR_GAP) + mCurrentTime.minute * mCellHeight / 60 + 1
// And the current time shows up somewhere on the screen
if (lineY >= mViewStartY && lineY < mViewStartY + mViewHeight - 2) {
- drawCurrentTimeLine(r, day, lineY, canvas, p);
+ drawCurrentTimeLine(r, day, lineY, canvas, p)
}
}
+ day++
+ cell++
}
- p.setAntiAlias(true);
- p.setAlpha(alpha);
+ p.setAntiAlias(true)
+ p.setAlpha(alpha)
}
- private void drawHours(Rect r, Canvas canvas, Paint p) {
- setupHourTextPaint(p);
-
- int y = HOUR_GAP + mHoursTextHeight + HOURS_TOP_MARGIN;
-
- for (int i = 0; i < 24; i++) {
- String time = mHourStrs[i];
- canvas.drawText(time, HOURS_LEFT_MARGIN, y, p);
- y += mCellHeight + HOUR_GAP;
+ private fun drawHours(r: Rect, canvas: Canvas, p: Paint) {
+ setupHourTextPaint(p)
+ var y = HOUR_GAP + mHoursTextHeight + HOURS_TOP_MARGIN
+ for (i in 0..23) {
+ val time = mHourStrs[i]
+ canvas.drawText(time, HOURS_LEFT_MARGIN, y, p)
+ y += mCellHeight + HOUR_GAP
}
}
- private void setupHourTextPaint(Paint p) {
- p.setColor(mCalendarHourLabelColor);
- p.setTextSize(HOURS_TEXT_SIZE);
- p.setTypeface(Typeface.DEFAULT);
- p.setTextAlign(Paint.Align.RIGHT);
- p.setAntiAlias(true);
+ private fun setupHourTextPaint(p: Paint) {
+ p.setColor(mCalendarHourLabelColor)
+ p.setTextSize(HOURS_TEXT_SIZE)
+ p.setTypeface(Typeface.DEFAULT)
+ p.setTextAlign(Paint.Align.RIGHT)
+ p.setAntiAlias(true)
}
- private void drawDayHeader(String dayStr, int day, int cell, Canvas canvas, Paint p) {
- int dateNum = mFirstVisibleDate + day;
- int x;
+ private fun drawDayHeader(dayStr: String?, day: Int, cell: Int, canvas: Canvas, p: Paint) {
+ var dateNum = mFirstVisibleDate + day
+ val x: Int
if (dateNum > mMonthLength) {
- dateNum -= mMonthLength;
+ dateNum -= mMonthLength
}
- p.setAntiAlias(true);
-
- int todayIndex = mTodayJulianDay - mFirstJulianDay;
+ p.setAntiAlias(true)
+ val todayIndex = mTodayJulianDay - mFirstJulianDay
// Draw day of the month
- String dateNumStr = String.valueOf(dateNum);
+ val dateNumStr: String = String.valueOf(dateNum)
if (mNumDays > 1) {
- float y = DAY_HEADER_HEIGHT - DAY_HEADER_BOTTOM_MARGIN;
+ val y = (DAY_HEADER_HEIGHT - DAY_HEADER_BOTTOM_MARGIN).toFloat()
// Draw day of the month
- x = computeDayLeftPosition(day + 1) - DAY_HEADER_RIGHT_MARGIN;
- p.setTextAlign(Align.RIGHT);
- p.setTextSize(DATE_HEADER_FONT_SIZE);
-
- p.setTypeface(todayIndex == day ? mBold : Typeface.DEFAULT);
- canvas.drawText(dateNumStr, x, y, p);
+ x = computeDayLeftPosition(day + 1) - DAY_HEADER_RIGHT_MARGIN
+ p.setTextAlign(Align.RIGHT)
+ p.setTextSize(DATE_HEADER_FONT_SIZE)
+ p.setTypeface(if (todayIndex == day) mBold else Typeface.DEFAULT)
+ canvas.drawText(dateNumStr, x, y, p)
// Draw day of the week
- x -= p.measureText(" " + dateNumStr);
- p.setTextSize(DAY_HEADER_FONT_SIZE);
- p.setTypeface(Typeface.DEFAULT);
- canvas.drawText(dayStr, x, y, p);
+ x -= p.measureText(" $dateNumStr")
+ p.setTextSize(DAY_HEADER_FONT_SIZE)
+ p.setTypeface(Typeface.DEFAULT)
+ canvas.drawText(dayStr, x, y, p)
} else {
- float y = ONE_DAY_HEADER_HEIGHT - DAY_HEADER_ONE_DAY_BOTTOM_MARGIN;
- p.setTextAlign(Align.LEFT);
+ val y = (ONE_DAY_HEADER_HEIGHT - DAY_HEADER_ONE_DAY_BOTTOM_MARGIN).toFloat()
+ p.setTextAlign(Align.LEFT)
// Draw day of the week
- x = computeDayLeftPosition(day) + DAY_HEADER_ONE_DAY_LEFT_MARGIN;
- p.setTextSize(DAY_HEADER_FONT_SIZE);
- p.setTypeface(Typeface.DEFAULT);
- canvas.drawText(dayStr, x, y, p);
+ x = computeDayLeftPosition(day) + DAY_HEADER_ONE_DAY_LEFT_MARGIN
+ p.setTextSize(DAY_HEADER_FONT_SIZE)
+ p.setTypeface(Typeface.DEFAULT)
+ canvas.drawText(dayStr, x, y, p)
// Draw day of the month
- x += p.measureText(dayStr) + DAY_HEADER_ONE_DAY_RIGHT_MARGIN;
- p.setTextSize(DATE_HEADER_FONT_SIZE);
- p.setTypeface(todayIndex == day ? mBold : Typeface.DEFAULT);
- canvas.drawText(dateNumStr, x, y, p);
+ x += p.measureText(dayStr) + DAY_HEADER_ONE_DAY_RIGHT_MARGIN
+ p.setTextSize(DATE_HEADER_FONT_SIZE)
+ p.setTypeface(if (todayIndex == day) mBold else Typeface.DEFAULT)
+ canvas.drawText(dateNumStr, x, y, p)
}
}
- private void drawGridBackground(Rect r, Canvas canvas, Paint p) {
- Paint.Style savedStyle = p.getStyle();
-
- final float stopX = computeDayLeftPosition(mNumDays);
- float y = 0;
- final float deltaY = mCellHeight + HOUR_GAP;
- int linesIndex = 0;
- final float startY = 0;
- final float stopY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP);
- float x = mHoursWidth;
+ private fun drawGridBackground(r: Rect, canvas: Canvas, p: Paint) {
+ val savedStyle: Style = p.getStyle()
+ val stopX = computeDayLeftPosition(mNumDays).toFloat()
+ var y = 0f
+ val deltaY = (mCellHeight + HOUR_GAP).toFloat()
+ var linesIndex = 0
+ val startY = 0f
+ val stopY = (HOUR_GAP + 24 * (mCellHeight + HOUR_GAP)).toFloat()
+ var x = mHoursWidth.toFloat()
// Draw the inner horizontal grid lines
- p.setColor(mCalendarGridLineInnerHorizontalColor);
- p.setStrokeWidth(GRID_LINE_INNER_WIDTH);
- p.setAntiAlias(false);
- y = 0;
- linesIndex = 0;
- for (int hour = 0; hour <= 24; hour++) {
- mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN;
- mLines[linesIndex++] = y;
- mLines[linesIndex++] = stopX;
- mLines[linesIndex++] = y;
- y += deltaY;
+ p.setColor(mCalendarGridLineInnerHorizontalColor)
+ p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
+ p.setAntiAlias(false)
+ y = 0f
+ linesIndex = 0
+ for (hour in 0..24) {
+ mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN
+ mLines[linesIndex++] = y
+ mLines[linesIndex++] = stopX
+ mLines[linesIndex++] = y
+ y += deltaY
}
if (mCalendarGridLineInnerVerticalColor != mCalendarGridLineInnerHorizontalColor) {
- canvas.drawLines(mLines, 0, linesIndex, p);
- linesIndex = 0;
- p.setColor(mCalendarGridLineInnerVerticalColor);
+ canvas.drawLines(mLines, 0, linesIndex, p)
+ linesIndex = 0
+ p.setColor(mCalendarGridLineInnerVerticalColor)
}
// Draw the inner vertical grid lines
- for (int day = 0; day <= mNumDays; day++) {
- x = computeDayLeftPosition(day);
- mLines[linesIndex++] = x;
- mLines[linesIndex++] = startY;
- mLines[linesIndex++] = x;
- mLines[linesIndex++] = stopY;
+ for (day in 0..mNumDays) {
+ x = computeDayLeftPosition(day).toFloat()
+ mLines[linesIndex++] = x
+ mLines[linesIndex++] = startY
+ mLines[linesIndex++] = x
+ mLines[linesIndex++] = stopY
}
- canvas.drawLines(mLines, 0, linesIndex, p);
+ canvas.drawLines(mLines, 0, linesIndex, p)
// Restore the saved style.
- p.setStyle(savedStyle);
- p.setAntiAlias(true);
+ p.setStyle(savedStyle)
+ p.setAntiAlias(true)
}
/**
@@ -2315,366 +1871,359 @@
* @param canvas
* @param p
*/
- private void drawBgColors(Rect r, Canvas canvas, Paint p) {
- int todayIndex = mTodayJulianDay - mFirstJulianDay;
+ private fun drawBgColors(r: Rect, canvas: Canvas, p: Paint) {
+ val todayIndex = mTodayJulianDay - mFirstJulianDay
// Draw the hours background color
- r.top = mDestRect.top;
- r.bottom = mDestRect.bottom;
- r.left = 0;
- r.right = mHoursWidth;
- p.setColor(mBgColor);
- p.setStyle(Style.FILL);
- p.setAntiAlias(false);
- canvas.drawRect(r, p);
+ r.top = mDestRect.top
+ r.bottom = mDestRect.bottom
+ r.left = 0
+ r.right = mHoursWidth
+ p.setColor(mBgColor)
+ p.setStyle(Style.FILL)
+ p.setAntiAlias(false)
+ canvas.drawRect(r, p)
// Draw background for grid area
if (mNumDays == 1 && todayIndex == 0) {
// Draw a white background for the time later than current time
- int lineY = mCurrentTime.hour * (mCellHeight + HOUR_GAP)
- + ((mCurrentTime.minute * mCellHeight) / 60) + 1;
+ var lineY: Int =
+ mCurrentTime.hour * (mCellHeight + HOUR_GAP) + mCurrentTime.minute * mCellHeight / 60 + 1
if (lineY < mViewStartY + mViewHeight) {
- lineY = Math.max(lineY, mViewStartY);
- r.left = mHoursWidth;
- r.right = mViewWidth;
- r.top = lineY;
- r.bottom = mViewStartY + mViewHeight;
- p.setColor(mFutureBgColor);
- canvas.drawRect(r, p);
+ lineY = Math.max(lineY, mViewStartY)
+ r.left = mHoursWidth
+ r.right = mViewWidth
+ r.top = lineY
+ r.bottom = mViewStartY + mViewHeight
+ p.setColor(mFutureBgColor)
+ canvas.drawRect(r, p)
}
} else if (todayIndex >= 0 && todayIndex < mNumDays) {
// Draw today with a white background for the time later than current time
- int lineY = mCurrentTime.hour * (mCellHeight + HOUR_GAP)
- + ((mCurrentTime.minute * mCellHeight) / 60) + 1;
+ var lineY: Int =
+ mCurrentTime.hour * (mCellHeight + HOUR_GAP) + mCurrentTime.minute * mCellHeight / 60 + 1
if (lineY < mViewStartY + mViewHeight) {
- lineY = Math.max(lineY, mViewStartY);
- r.left = computeDayLeftPosition(todayIndex) + 1;
- r.right = computeDayLeftPosition(todayIndex + 1);
- r.top = lineY;
- r.bottom = mViewStartY + mViewHeight;
- p.setColor(mFutureBgColor);
- canvas.drawRect(r, p);
+ lineY = Math.max(lineY, mViewStartY)
+ r.left = computeDayLeftPosition(todayIndex) + 1
+ r.right = computeDayLeftPosition(todayIndex + 1)
+ r.top = lineY
+ r.bottom = mViewStartY + mViewHeight
+ p.setColor(mFutureBgColor)
+ canvas.drawRect(r, p)
}
// Paint Tomorrow and later days with future color
if (todayIndex + 1 < mNumDays) {
- r.left = computeDayLeftPosition(todayIndex + 1) + 1;
- r.right = computeDayLeftPosition(mNumDays);
- r.top = mDestRect.top;
- r.bottom = mDestRect.bottom;
- p.setColor(mFutureBgColor);
- canvas.drawRect(r, p);
+ r.left = computeDayLeftPosition(todayIndex + 1) + 1
+ r.right = computeDayLeftPosition(mNumDays)
+ r.top = mDestRect.top
+ r.bottom = mDestRect.bottom
+ p.setColor(mFutureBgColor)
+ canvas.drawRect(r, p)
}
} else if (todayIndex < 0) {
// Future
- r.left = computeDayLeftPosition(0) + 1;
- r.right = computeDayLeftPosition(mNumDays);
- r.top = mDestRect.top;
- r.bottom = mDestRect.bottom;
- p.setColor(mFutureBgColor);
- canvas.drawRect(r, p);
+ r.left = computeDayLeftPosition(0) + 1
+ r.right = computeDayLeftPosition(mNumDays)
+ r.top = mDestRect.top
+ r.bottom = mDestRect.bottom
+ p.setColor(mFutureBgColor)
+ canvas.drawRect(r, p)
}
- p.setAntiAlias(true);
+ p.setAntiAlias(true)
}
- private int computeMaxStringWidth(int currentMax, String[] strings, Paint p) {
- float maxWidthF = 0.0f;
-
- int len = strings.length;
- for (int i = 0; i < len; i++) {
- float width = p.measureText(strings[i]);
- maxWidthF = Math.max(width, maxWidthF);
+ private fun computeMaxStringWidth(currentMax: Int, strings: Array<String?>, p: Paint): Int {
+ var maxWidthF = 0.0f
+ val len = strings.size
+ for (i in 0 until len) {
+ val width: Float = p.measureText(strings[i])
+ maxWidthF = Math.max(width, maxWidthF)
}
- int maxWidth = (int) (maxWidthF + 0.5);
+ var maxWidth = (maxWidthF + 0.5).toInt()
if (maxWidth < currentMax) {
- maxWidth = currentMax;
+ maxWidth = currentMax
}
- return maxWidth;
+ return maxWidth
}
- private void saveSelectionPosition(float left, float top, float right, float bottom) {
- mPrevBox.left = (int) left;
- mPrevBox.right = (int) right;
- mPrevBox.top = (int) top;
- mPrevBox.bottom = (int) bottom;
+ private fun saveSelectionPosition(left: Float, top: Float, right: Float, bottom: Float) {
+ mPrevBox.left = left.toInt()
+ mPrevBox.right = right.toInt()
+ mPrevBox.top = top.toInt()
+ mPrevBox.bottom = bottom.toInt()
}
- private void setupTextRect(Rect r) {
+ private fun setupTextRect(r: Rect) {
if (r.bottom <= r.top || r.right <= r.left) {
- r.bottom = r.top;
- r.right = r.left;
- return;
+ r.bottom = r.top
+ r.right = r.left
+ return
}
-
if (r.bottom - r.top > EVENT_TEXT_TOP_MARGIN + EVENT_TEXT_BOTTOM_MARGIN) {
- r.top += EVENT_TEXT_TOP_MARGIN;
- r.bottom -= EVENT_TEXT_BOTTOM_MARGIN;
+ r.top += EVENT_TEXT_TOP_MARGIN
+ r.bottom -= EVENT_TEXT_BOTTOM_MARGIN
}
if (r.right - r.left > EVENT_TEXT_LEFT_MARGIN + EVENT_TEXT_RIGHT_MARGIN) {
- r.left += EVENT_TEXT_LEFT_MARGIN;
- r.right -= EVENT_TEXT_RIGHT_MARGIN;
+ r.left += EVENT_TEXT_LEFT_MARGIN
+ r.right -= EVENT_TEXT_RIGHT_MARGIN
}
}
- private void setupAllDayTextRect(Rect r) {
+ private fun setupAllDayTextRect(r: Rect) {
if (r.bottom <= r.top || r.right <= r.left) {
- r.bottom = r.top;
- r.right = r.left;
- return;
+ r.bottom = r.top
+ r.right = r.left
+ return
}
-
if (r.bottom - r.top > EVENT_ALL_DAY_TEXT_TOP_MARGIN + EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN) {
- r.top += EVENT_ALL_DAY_TEXT_TOP_MARGIN;
- r.bottom -= EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN;
+ r.top += EVENT_ALL_DAY_TEXT_TOP_MARGIN
+ r.bottom -= EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN
}
if (r.right - r.left > EVENT_ALL_DAY_TEXT_LEFT_MARGIN + EVENT_ALL_DAY_TEXT_RIGHT_MARGIN) {
- r.left += EVENT_ALL_DAY_TEXT_LEFT_MARGIN;
- r.right -= EVENT_ALL_DAY_TEXT_RIGHT_MARGIN;
+ r.left += EVENT_ALL_DAY_TEXT_LEFT_MARGIN
+ r.right -= EVENT_ALL_DAY_TEXT_RIGHT_MARGIN
}
}
/**
* Return the layout for a numbered event. Create it if not already existing
*/
- private StaticLayout getEventLayout(StaticLayout[] layouts, int i, Event event, Paint paint,
- Rect r) {
- if (i < 0 || i >= layouts.length) {
- return null;
+ private fun getEventLayout(
+ layouts: Array<StaticLayout?>?, i: Int, event: Event, paint: Paint,
+ r: Rect
+ ): StaticLayout? {
+ if (i < 0 || i >= layouts!!.size) {
+ return null
}
-
- StaticLayout layout = layouts[i];
+ var layout: StaticLayout? = layouts!![i]
// Check if we have already initialized the StaticLayout and that
// the width hasn't changed (due to vertical resizing which causes
// re-layout of events at min height)
- if (layout == null || r.width() != layout.getWidth()) {
- SpannableStringBuilder bob = new SpannableStringBuilder();
+ if (layout == null || r.width() !== layout.getWidth()) {
+ val bob = SpannableStringBuilder()
if (event.title != null) {
// MAX - 1 since we add a space
- bob.append(drawTextSanitizer(event.title.toString(), MAX_EVENT_TEXT_LEN - 1));
- bob.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 0, bob.length(), 0);
- bob.append(' ');
+ bob.append(drawTextSanitizer(event.title.toString(), MAX_EVENT_TEXT_LEN - 1))
+ bob.setSpan(StyleSpan(android.graphics.Typeface.BOLD), 0, bob.length(), 0)
+ bob.append(' ')
}
if (event.location != null) {
- bob.append(drawTextSanitizer(event.location.toString(),
- MAX_EVENT_TEXT_LEN - bob.length()));
+ bob.append(
+ drawTextSanitizer(
+ event.location.toString(),
+ MAX_EVENT_TEXT_LEN - bob.length()
+ )
+ )
}
-
- switch (event.selfAttendeeStatus) {
- case Attendees.ATTENDEE_STATUS_INVITED:
- paint.setColor(event.color);
- break;
- case Attendees.ATTENDEE_STATUS_DECLINED:
- paint.setColor(mEventTextColor);
- paint.setAlpha(Utils.DECLINED_EVENT_TEXT_ALPHA);
- break;
- case Attendees.ATTENDEE_STATUS_NONE: // Your own events
- case Attendees.ATTENDEE_STATUS_ACCEPTED:
- case Attendees.ATTENDEE_STATUS_TENTATIVE:
- default:
- paint.setColor(mEventTextColor);
- break;
+ when (event.selfAttendeeStatus) {
+ Attendees.ATTENDEE_STATUS_INVITED -> paint.setColor(event.color)
+ Attendees.ATTENDEE_STATUS_DECLINED -> {
+ paint.setColor(mEventTextColor)
+ paint.setAlpha(Utils.DECLINED_EVENT_TEXT_ALPHA)
+ }
+ Attendees.ATTENDEE_STATUS_NONE, Attendees.ATTENDEE_STATUS_ACCEPTED, Attendees.ATTENDEE_STATUS_TENTATIVE -> paint.setColor(
+ mEventTextColor
+ )
+ else -> paint.setColor(mEventTextColor)
}
// Leave a one pixel boundary on the left and right of the rectangle for the event
- layout = new StaticLayout(bob, 0, bob.length(), new TextPaint(paint), r.width(),
- Alignment.ALIGN_NORMAL, 1.0f, 0.0f, true, null, r.width());
-
- layouts[i] = layout;
+ layout = StaticLayout(
+ bob, 0, bob.length(), TextPaint(paint), r.width(),
+ Alignment.ALIGN_NORMAL, 1.0f, 0.0f, true, null, r.width()
+ )
+ layouts[i] = layout
}
- layout.getPaint().setAlpha(mEventsAlpha);
- return layout;
+ layout.getPaint().setAlpha(mEventsAlpha)
+ return layout
}
- private void drawAllDayEvents(int firstDay, int numDays, Canvas canvas, Paint p) {
-
- p.setTextSize(NORMAL_FONT_SIZE);
- p.setTextAlign(Paint.Align.LEFT);
- Paint eventTextPaint = mEventTextPaint;
-
- final float startY = DAY_HEADER_HEIGHT;
- final float stopY = startY + mAlldayHeight + ALLDAY_TOP_MARGIN;
- float x = 0;
- int linesIndex = 0;
+ private fun drawAllDayEvents(firstDay: Int, numDays: Int, canvas: Canvas, p: Paint) {
+ p.setTextSize(NORMAL_FONT_SIZE)
+ p.setTextAlign(Paint.Align.LEFT)
+ val eventTextPaint: Paint = mEventTextPaint
+ val startY = DAY_HEADER_HEIGHT.toFloat()
+ val stopY = startY + mAlldayHeight + ALLDAY_TOP_MARGIN
+ var x = 0f
+ var linesIndex = 0
// Draw the inner vertical grid lines
- p.setColor(mCalendarGridLineInnerVerticalColor);
- x = mHoursWidth;
- p.setStrokeWidth(GRID_LINE_INNER_WIDTH);
+ p.setColor(mCalendarGridLineInnerVerticalColor)
+ x = mHoursWidth.toFloat()
+ p.setStrokeWidth(GRID_LINE_INNER_WIDTH)
// Line bounding the top of the all day area
- mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN;
- mLines[linesIndex++] = startY;
- mLines[linesIndex++] = computeDayLeftPosition(mNumDays);
- mLines[linesIndex++] = startY;
-
- for (int day = 0; day <= mNumDays; day++) {
- x = computeDayLeftPosition(day);
- mLines[linesIndex++] = x;
- mLines[linesIndex++] = startY;
- mLines[linesIndex++] = x;
- mLines[linesIndex++] = stopY;
+ mLines[linesIndex++] = GRID_LINE_LEFT_MARGIN
+ mLines[linesIndex++] = startY
+ mLines[linesIndex++] = computeDayLeftPosition(mNumDays).toFloat()
+ mLines[linesIndex++] = startY
+ for (day in 0..mNumDays) {
+ x = computeDayLeftPosition(day).toFloat()
+ mLines[linesIndex++] = x
+ mLines[linesIndex++] = startY
+ mLines[linesIndex++] = x
+ mLines[linesIndex++] = stopY
}
- p.setAntiAlias(false);
- canvas.drawLines(mLines, 0, linesIndex, p);
- p.setStyle(Style.FILL);
-
- int y = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN;
- int lastDay = firstDay + numDays - 1;
- final ArrayList<Event> events = mAllDayEvents;
- int numEvents = events.size();
+ p.setAntiAlias(false)
+ canvas.drawLines(mLines, 0, linesIndex, p)
+ p.setStyle(Style.FILL)
+ val y = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
+ val lastDay = firstDay + numDays - 1
+ val events: ArrayList<Event>? = mAllDayEvents
+ val numEvents: Int = events.size()
// Whether or not we should draw the more events text
- boolean hasMoreEvents = false;
+ var hasMoreEvents = false
// size of the allDay area
- float drawHeight = mAlldayHeight;
+ val drawHeight = mAlldayHeight.toFloat()
// max number of events being drawn in one day of the allday area
- float numRectangles = mMaxAlldayEvents;
+ var numRectangles = mMaxAlldayEvents.toFloat()
// Where to cut off drawn allday events
- int allDayEventClip = DAY_HEADER_HEIGHT + mAlldayHeight + ALLDAY_TOP_MARGIN;
+ var allDayEventClip = DAY_HEADER_HEIGHT + mAlldayHeight + ALLDAY_TOP_MARGIN
// The number of events that weren't drawn in each day
- mSkippedAlldayEvents = new int[numDays];
- if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount && !mShowAllAllDayEvents &&
- mAnimateDayHeight == 0) {
+ mSkippedAlldayEvents = IntArray(numDays)
+ if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount && !mShowAllAllDayEvents && mAnimateDayHeight == 0) {
// We draw one fewer event than will fit so that more events text
// can be drawn
- numRectangles = mMaxUnexpandedAlldayEventCount - 1;
+ numRectangles = (mMaxUnexpandedAlldayEventCount - 1).toFloat()
// We also clip the events above the more events text
- allDayEventClip -= MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT;
- hasMoreEvents = true;
+ allDayEventClip -= MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
+ hasMoreEvents = true
} else if (mAnimateDayHeight != 0) {
// clip at the end of the animating space
- allDayEventClip = DAY_HEADER_HEIGHT + mAnimateDayHeight + ALLDAY_TOP_MARGIN;
+ allDayEventClip = DAY_HEADER_HEIGHT + mAnimateDayHeight + ALLDAY_TOP_MARGIN
}
-
- int alpha = eventTextPaint.getAlpha();
- eventTextPaint.setAlpha(mEventsAlpha);
- for (int i = 0; i < numEvents; i++) {
- Event event = events.get(i);
- int startDay = event.startDay;
- int endDay = event.endDay;
+ var alpha: Int = eventTextPaint.getAlpha()
+ eventTextPaint.setAlpha(mEventsAlpha)
+ for (i in 0 until numEvents) {
+ val event: Event = events.get(i)
+ var startDay: Int = event.startDay
+ var endDay: Int = event.endDay
if (startDay > lastDay || endDay < firstDay) {
- continue;
+ continue
}
if (startDay < firstDay) {
- startDay = firstDay;
+ startDay = firstDay
}
if (endDay > lastDay) {
- endDay = lastDay;
+ endDay = lastDay
}
- int startIndex = startDay - firstDay;
- int endIndex = endDay - firstDay;
- float height = mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount ? mAnimateDayEventHeight :
- drawHeight / numRectangles;
+ val startIndex = startDay - firstDay
+ val endIndex = endDay - firstDay
+ var height =
+ if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) mAnimateDayEventHeight.toFloat() else drawHeight / numRectangles
// Prevent a single event from getting too big
if (height > MAX_HEIGHT_OF_ONE_ALLDAY_EVENT) {
- height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT;
+ height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT.toFloat()
}
// Leave a one-pixel space between the vertical day lines and the
// event rectangle.
- event.left = computeDayLeftPosition(startIndex);
- event.right = computeDayLeftPosition(endIndex + 1) - DAY_GAP;
- event.top = y + height * event.getColumn();
- event.bottom = event.top + height - ALL_DAY_EVENT_RECT_BOTTOM_MARGIN;
+ event.left = computeDayLeftPosition(startIndex)
+ event.right = computeDayLeftPosition(endIndex + 1) - DAY_GAP
+ event.top = y + height * event.getColumn()
+ event.bottom = event.top + height - ALL_DAY_EVENT_RECT_BOTTOM_MARGIN
if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
// check if we should skip this event. We skip if it starts
// after the clip bound or ends after the skip bound and we're
// not animating.
if (event.top >= allDayEventClip) {
- incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex);
- continue;
+ incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex)
+ continue
} else if (event.bottom > allDayEventClip) {
if (hasMoreEvents) {
- incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex);
- continue;
+ incrementSkipCount(mSkippedAlldayEvents, startIndex, endIndex)
+ continue
}
- event.bottom = allDayEventClip;
+ event.bottom = allDayEventClip
}
}
- Rect r = drawEventRect(event, canvas, p, eventTextPaint, (int) event.top,
- (int) event.bottom);
- setupAllDayTextRect(r);
- StaticLayout layout = getEventLayout(mAllDayLayouts, i, event, eventTextPaint, r);
- drawEventText(layout, r, canvas, r.top, r.bottom, true);
+ val r: Rect = drawEventRect(
+ event, canvas, p, eventTextPaint, event.top as Int,
+ event.bottom as Int
+ )
+ setupAllDayTextRect(r)
+ val layout: StaticLayout? = getEventLayout(mAllDayLayouts, i, event, eventTextPaint, r)
+ drawEventText(layout, r, canvas, r.top, r.bottom, true)
// Check if this all-day event intersects the selected day
if (mSelectionAllday && mComputeSelectedEvents) {
if (startDay <= mSelectionDay && endDay >= mSelectionDay) {
- mSelectedEvents.add(event);
+ mSelectedEvents.add(event)
}
}
}
- eventTextPaint.setAlpha(alpha);
-
+ eventTextPaint.setAlpha(alpha)
if (mMoreAlldayEventsTextAlpha != 0 && mSkippedAlldayEvents != null) {
// If the more allday text should be visible, draw it.
- alpha = p.getAlpha();
- p.setAlpha(mEventsAlpha);
- p.setColor(mMoreAlldayEventsTextAlpha << 24 & mMoreEventsTextColor);
- for (int i = 0; i < mSkippedAlldayEvents.length; i++) {
- if (mSkippedAlldayEvents[i] > 0) {
- drawMoreAlldayEvents(canvas, mSkippedAlldayEvents[i], i, p);
+ alpha = p.getAlpha()
+ p.setAlpha(mEventsAlpha)
+ p.setColor(mMoreAlldayEventsTextAlpha shl 24 and mMoreEventsTextColor)
+ for (i in mSkippedAlldayEvents.indices) {
+ if (mSkippedAlldayEvents!![i] > 0) {
+ drawMoreAlldayEvents(canvas, mSkippedAlldayEvents!![i], i, p)
}
}
- p.setAlpha(alpha);
+ p.setAlpha(alpha)
}
-
if (mSelectionAllday) {
// Compute the neighbors for the list of all-day events that
// intersect the selected day.
- computeAllDayNeighbors();
+ computeAllDayNeighbors()
// Set the selection position to zero so that when we move down
// to the normal event area, we will highlight the topmost event.
- saveSelectionPosition(0f, 0f, 0f, 0f);
+ saveSelectionPosition(0f, 0f, 0f, 0f)
}
}
// Helper method for counting the number of allday events skipped on each day
- private void incrementSkipCount(int[] counts, int startIndex, int endIndex) {
- if (counts == null || startIndex < 0 || endIndex > counts.length) {
- return;
+ private fun incrementSkipCount(counts: IntArray?, startIndex: Int, endIndex: Int) {
+ if (counts == null || startIndex < 0 || endIndex > counts.size) {
+ return
}
- for (int i = startIndex; i <= endIndex; i++) {
- counts[i]++;
+ for (i in startIndex..endIndex) {
+ counts[i]++
}
}
// Draws the "box +n" text for hidden allday events
- protected void drawMoreAlldayEvents(Canvas canvas, int remainingEvents, int day, Paint p) {
- int x = computeDayLeftPosition(day) + EVENT_ALL_DAY_TEXT_LEFT_MARGIN;
- int y = (int) (mAlldayHeight - .5f * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - .5f
- * EVENT_SQUARE_WIDTH + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN);
- Rect r = mRect;
- r.top = y;
- r.left = x;
- r.bottom = y + EVENT_SQUARE_WIDTH;
- r.right = x + EVENT_SQUARE_WIDTH;
- p.setColor(mMoreEventsTextColor);
- p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH);
- p.setStyle(Style.STROKE);
- p.setAntiAlias(false);
- canvas.drawRect(r, p);
- p.setAntiAlias(true);
- p.setStyle(Style.FILL);
- p.setTextSize(EVENT_TEXT_FONT_SIZE);
- String text = mResources.getQuantityString(R.plurals.month_more_events, remainingEvents);
- y += EVENT_SQUARE_WIDTH;
- x += EVENT_SQUARE_WIDTH + EVENT_LINE_PADDING;
- canvas.drawText(String.format(text, remainingEvents), x, y, p);
+ protected fun drawMoreAlldayEvents(canvas: Canvas, remainingEvents: Int, day: Int, p: Paint) {
+ var x = computeDayLeftPosition(day) + EVENT_ALL_DAY_TEXT_LEFT_MARGIN
+ var y = (mAlldayHeight - .5f * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - (.5f
+ * EVENT_SQUARE_WIDTH) + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN).toInt()
+ val r: Rect = mRect
+ r.top = y
+ r.left = x
+ r.bottom = y + EVENT_SQUARE_WIDTH
+ r.right = x + EVENT_SQUARE_WIDTH
+ p.setColor(mMoreEventsTextColor)
+ p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH)
+ p.setStyle(Style.STROKE)
+ p.setAntiAlias(false)
+ canvas.drawRect(r, p)
+ p.setAntiAlias(true)
+ p.setStyle(Style.FILL)
+ p.setTextSize(EVENT_TEXT_FONT_SIZE)
+ val text: String =
+ mResources.getQuantityString(R.plurals.month_more_events, remainingEvents)
+ y += EVENT_SQUARE_WIDTH
+ x += EVENT_SQUARE_WIDTH + EVENT_LINE_PADDING
+ canvas.drawText(String.format(text, remainingEvents), x, y, p)
}
- private void computeAllDayNeighbors() {
- int len = mSelectedEvents.size();
+ private fun computeAllDayNeighbors() {
+ val len: Int = mSelectedEvents.size()
if (len == 0 || mSelectedEvent != null) {
- return;
+ return
}
// First, clear all the links
- for (int ii = 0; ii < len; ii++) {
- Event ev = mSelectedEvents.get(ii);
- ev.nextUp = null;
- ev.nextDown = null;
- ev.nextLeft = null;
- ev.nextRight = null;
+ for (ii in 0 until len) {
+ val ev: Event = mSelectedEvents.get(ii)
+ ev.nextUp = null
+ ev.nextDown = null
+ ev.nextLeft = null
+ ev.nextRight = null
}
// For each event in the selected event list "mSelectedEvents", find
@@ -2684,294 +2233,295 @@
// Find the event in the same row as the previously selected all-day
// event, if any.
- int startPosition = -1;
+ var startPosition = -1
if (mPrevSelectedEvent != null && mPrevSelectedEvent.drawAsAllday()) {
- startPosition = mPrevSelectedEvent.getColumn();
+ startPosition = mPrevSelectedEvent.getColumn()
}
- int maxPosition = -1;
- Event startEvent = null;
- Event maxPositionEvent = null;
- for (int ii = 0; ii < len; ii++) {
- Event ev = mSelectedEvents.get(ii);
- int position = ev.getColumn();
+ var maxPosition = -1
+ var startEvent: Event? = null
+ var maxPositionEvent: Event? = null
+ for (ii in 0 until len) {
+ val ev: Event = mSelectedEvents.get(ii)
+ val position: Int = ev.getColumn()
if (position == startPosition) {
- startEvent = ev;
+ startEvent = ev
} else if (position > maxPosition) {
- maxPositionEvent = ev;
- maxPosition = position;
+ maxPositionEvent = ev
+ maxPosition = position
}
- for (int jj = 0; jj < len; jj++) {
+ for (jj in 0 until len) {
if (jj == ii) {
- continue;
+ continue
}
- Event neighbor = mSelectedEvents.get(jj);
- int neighborPosition = neighbor.getColumn();
+ val neighbor: Event = mSelectedEvents.get(jj)
+ val neighborPosition: Int = neighbor.getColumn()
if (neighborPosition == position - 1) {
- ev.nextUp = neighbor;
+ ev.nextUp = neighbor
} else if (neighborPosition == position + 1) {
- ev.nextDown = neighbor;
+ ev.nextDown = neighbor
}
}
}
if (startEvent != null) {
- setSelectedEvent(startEvent);
+ setSelectedEvent(startEvent)
} else {
- setSelectedEvent(maxPositionEvent);
+ setSelectedEvent(maxPositionEvent)
}
}
- private void drawEvents(int date, int dayIndex, int top, Canvas canvas, Paint p) {
- Paint eventTextPaint = mEventTextPaint;
- int left = computeDayLeftPosition(dayIndex) + 1;
- int cellWidth = computeDayLeftPosition(dayIndex + 1) - left + 1;
- int cellHeight = mCellHeight;
+ private fun drawEvents(date: Int, dayIndex: Int, top: Int, canvas: Canvas, p: Paint) {
+ val eventTextPaint: Paint = mEventTextPaint
+ val left = computeDayLeftPosition(dayIndex) + 1
+ val cellWidth = computeDayLeftPosition(dayIndex + 1) - left + 1
+ val cellHeight = mCellHeight
// Use the selected hour as the selection region
- Rect selectionArea = mSelectionRect;
- selectionArea.top = top + mSelectionHour * (cellHeight + HOUR_GAP);
- selectionArea.bottom = selectionArea.top + cellHeight;
- selectionArea.left = left;
- selectionArea.right = selectionArea.left + cellWidth;
-
- final ArrayList<Event> events = mEvents;
- int numEvents = events.size();
- EventGeometry geometry = mEventGeometry;
-
- final int viewEndY = mViewStartY + mViewHeight - DAY_HEADER_HEIGHT - mAlldayHeight;
-
- int alpha = eventTextPaint.getAlpha();
- eventTextPaint.setAlpha(mEventsAlpha);
- for (int i = 0; i < numEvents; i++) {
- Event event = events.get(i);
+ val selectionArea: Rect = mSelectionRect
+ selectionArea.top = top + mSelectionHour * (cellHeight + HOUR_GAP)
+ selectionArea.bottom = selectionArea.top + cellHeight
+ selectionArea.left = left
+ selectionArea.right = selectionArea.left + cellWidth
+ val events: ArrayList<Event> = mEvents
+ val numEvents: Int = events.size()
+ val geometry: EventGeometry = mEventGeometry
+ val viewEndY = mViewStartY + mViewHeight - DAY_HEADER_HEIGHT - mAlldayHeight
+ val alpha: Int = eventTextPaint.getAlpha()
+ eventTextPaint.setAlpha(mEventsAlpha)
+ for (i in 0 until numEvents) {
+ val event: Event = events.get(i)
if (!geometry.computeEventRect(date, left, top, cellWidth, event)) {
- continue;
+ continue
}
// Don't draw it if it is not visible
if (event.bottom < mViewStartY || event.top > viewEndY) {
- continue;
+ continue
}
-
if (date == mSelectionDay && !mSelectionAllday && mComputeSelectedEvents
- && geometry.eventIntersectsSelection(event, selectionArea)) {
- mSelectedEvents.add(event);
+ && geometry.eventIntersectsSelection(event, selectionArea)
+ ) {
+ mSelectedEvents.add(event)
}
-
- Rect r = drawEventRect(event, canvas, p, eventTextPaint, mViewStartY, viewEndY);
- setupTextRect(r);
+ val r: Rect = drawEventRect(event, canvas, p, eventTextPaint, mViewStartY, viewEndY)
+ setupTextRect(r)
// Don't draw text if it is not visible
if (r.top > viewEndY || r.bottom < mViewStartY) {
- continue;
+ continue
}
- StaticLayout layout = getEventLayout(mLayouts, i, event, eventTextPaint, r);
+ val layout: StaticLayout? = getEventLayout(mLayouts, i, event, eventTextPaint, r)
// TODO: not sure why we are 4 pixels off
- drawEventText(layout, r, canvas, mViewStartY + 4, mViewStartY + mViewHeight
- - DAY_HEADER_HEIGHT - mAlldayHeight, false);
+ drawEventText(
+ layout,
+ r,
+ canvas,
+ mViewStartY + 4,
+ mViewStartY + mViewHeight - DAY_HEADER_HEIGHT - mAlldayHeight,
+ false
+ )
}
- eventTextPaint.setAlpha(alpha);
+ eventTextPaint.setAlpha(alpha)
}
- private Rect drawEventRect(Event event, Canvas canvas, Paint p, Paint eventTextPaint,
- int visibleTop, int visibleBot) {
+ private fun drawEventRect(
+ event: Event, canvas: Canvas, p: Paint, eventTextPaint: Paint,
+ visibleTop: Int, visibleBot: Int
+ ): Rect {
// Draw the Event Rect
- Rect r = mRect;
- r.top = Math.max((int) event.top + EVENT_RECT_TOP_MARGIN, visibleTop);
- r.bottom = Math.min((int) event.bottom - EVENT_RECT_BOTTOM_MARGIN, visibleBot);
- r.left = (int) event.left + EVENT_RECT_LEFT_MARGIN;
- r.right = (int) event.right;
-
- int color = event.color;
- switch (event.selfAttendeeStatus) {
- case Attendees.ATTENDEE_STATUS_INVITED:
- if (event != mClickedEvent) {
- p.setStyle(Style.STROKE);
+ val r: Rect = mRect
+ r.top = Math.max(event.top as Int + EVENT_RECT_TOP_MARGIN, visibleTop)
+ r.bottom = Math.min(event.bottom as Int - EVENT_RECT_BOTTOM_MARGIN, visibleBot)
+ r.left = event.left as Int + EVENT_RECT_LEFT_MARGIN
+ r.right = event.right
+ var color: Int = event.color
+ when (event.selfAttendeeStatus) {
+ Attendees.ATTENDEE_STATUS_INVITED -> if (event !== mClickedEvent) {
+ p.setStyle(Style.STROKE)
+ }
+ Attendees.ATTENDEE_STATUS_DECLINED -> {
+ if (event !== mClickedEvent) {
+ color = Utils.getDeclinedColorFromColor(color)
}
- break;
- case Attendees.ATTENDEE_STATUS_DECLINED:
- if (event != mClickedEvent) {
- color = Utils.getDeclinedColorFromColor(color);
- }
- case Attendees.ATTENDEE_STATUS_NONE: // Your own events
- case Attendees.ATTENDEE_STATUS_ACCEPTED:
- case Attendees.ATTENDEE_STATUS_TENTATIVE:
- default:
- p.setStyle(Style.FILL_AND_STROKE);
- break;
+ p.setStyle(Style.FILL_AND_STROKE)
+ }
+ Attendees.ATTENDEE_STATUS_NONE, Attendees.ATTENDEE_STATUS_ACCEPTED, Attendees.ATTENDEE_STATUS_TENTATIVE -> p.setStyle(
+ Style.FILL_AND_STROKE
+ )
+ else -> p.setStyle(Style.FILL_AND_STROKE)
}
-
- p.setAntiAlias(false);
-
- int floorHalfStroke = (int) Math.floor(EVENT_RECT_STROKE_WIDTH / 2.0f);
- int ceilHalfStroke = (int) Math.ceil(EVENT_RECT_STROKE_WIDTH / 2.0f);
- r.top = Math.max((int) event.top + EVENT_RECT_TOP_MARGIN + floorHalfStroke, visibleTop);
- r.bottom = Math.min((int) event.bottom - EVENT_RECT_BOTTOM_MARGIN - ceilHalfStroke,
- visibleBot);
- r.left += floorHalfStroke;
- r.right -= ceilHalfStroke;
- p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH);
- p.setColor(color);
- int alpha = p.getAlpha();
- p.setAlpha(mEventsAlpha);
- canvas.drawRect(r, p);
- p.setAlpha(alpha);
- p.setStyle(Style.FILL);
+ p.setAntiAlias(false)
+ val floorHalfStroke = Math.floor(EVENT_RECT_STROKE_WIDTH / 2.0f) as Int
+ val ceilHalfStroke = Math.ceil(EVENT_RECT_STROKE_WIDTH / 2.0f) as Int
+ r.top = Math.max(event.top as Int + EVENT_RECT_TOP_MARGIN + floorHalfStroke, visibleTop)
+ r.bottom = Math.min(
+ event.bottom as Int - EVENT_RECT_BOTTOM_MARGIN - ceilHalfStroke,
+ visibleBot
+ )
+ r.left += floorHalfStroke
+ r.right -= ceilHalfStroke
+ p.setStrokeWidth(EVENT_RECT_STROKE_WIDTH)
+ p.setColor(color)
+ val alpha: Int = p.getAlpha()
+ p.setAlpha(mEventsAlpha)
+ canvas.drawRect(r, p)
+ p.setAlpha(alpha)
+ p.setStyle(Style.FILL)
// Setup rect for drawEventText which follows
- r.top = (int) event.top + EVENT_RECT_TOP_MARGIN;
- r.bottom = (int) event.bottom - EVENT_RECT_BOTTOM_MARGIN;
- r.left = (int) event.left + EVENT_RECT_LEFT_MARGIN;
- r.right = (int) event.right - EVENT_RECT_RIGHT_MARGIN;
- return r;
+ r.top = event.top as Int + EVENT_RECT_TOP_MARGIN
+ r.bottom = event.bottom as Int - EVENT_RECT_BOTTOM_MARGIN
+ r.left = event.left as Int + EVENT_RECT_LEFT_MARGIN
+ r.right = event.right as Int - EVENT_RECT_RIGHT_MARGIN
+ return r
}
- private final Pattern drawTextSanitizerFilter = Pattern.compile("[\t\n],");
+ private val drawTextSanitizerFilter: Pattern = Pattern.compile("[\t\n],")
// Sanitize a string before passing it to drawText or else we get little
// squares. For newlines and tabs before a comma, delete the character.
// Otherwise, just replace them with a space.
- private String drawTextSanitizer(String string, int maxEventTextLen) {
- Matcher m = drawTextSanitizerFilter.matcher(string);
- string = m.replaceAll(",");
-
- int len = string.length();
+ private fun drawTextSanitizer(string: String, maxEventTextLen: Int): String {
+ var string = string
+ val m: Matcher = drawTextSanitizerFilter.matcher(string)
+ string = m.replaceAll(",")
+ var len: Int = string.length()
if (maxEventTextLen <= 0) {
- string = "";
- len = 0;
+ string = ""
+ len = 0
} else if (len > maxEventTextLen) {
- string = string.substring(0, maxEventTextLen);
- len = maxEventTextLen;
+ string = string.substring(0, maxEventTextLen)
+ len = maxEventTextLen
}
-
- return string.replace('\n', ' ');
+ return string.replace('\n', ' ')
}
- private void drawEventText(StaticLayout eventLayout, Rect rect, Canvas canvas, int top,
- int bottom, boolean center) {
+ private fun drawEventText(
+ eventLayout: StaticLayout?, rect: Rect, canvas: Canvas, top: Int,
+ bottom: Int, center: Boolean
+ ) {
// drawEmptyRect(canvas, rect, 0xFFFF00FF); // for debugging
-
- int width = rect.right - rect.left;
- int height = rect.bottom - rect.top;
+ val width: Int = rect.right - rect.left
+ val height: Int = rect.bottom - rect.top
// If the rectangle is too small for text, then return
if (eventLayout == null || width < MIN_CELL_WIDTH_FOR_TEXT) {
- return;
+ return
}
-
- int totalLineHeight = 0;
- int lineCount = eventLayout.getLineCount();
- for (int i = 0; i < lineCount; i++) {
- int lineBottom = eventLayout.getLineBottom(i);
- if (lineBottom <= height) {
- totalLineHeight = lineBottom;
+ var totalLineHeight = 0
+ val lineCount: Int = eventLayout.getLineCount()
+ for (i in 0 until lineCount) {
+ val lineBottom: Int = eventLayout.getLineBottom(i)
+ totalLineHeight = if (lineBottom <= height) {
+ lineBottom
} else {
- break;
+ break
}
}
- // + 2 is small workaround when the font is slightly bigger then the rect. This will
+ // + 2 is small workaround when the font is slightly bigger than the rect. This will
// still allow the text to be shown without overflowing into the other all day rects.
if (totalLineHeight == 0 || rect.top > bottom || rect.top + totalLineHeight + 2 < top) {
- return;
+ return
}
// Use a StaticLayout to format the string.
- canvas.save();
- // canvas.translate(rect.left, rect.top + (rect.bottom - rect.top / 2));
- int padding = center? (rect.bottom - rect.top - totalLineHeight) / 2 : 0;
- canvas.translate(rect.left, rect.top + padding);
- rect.left = 0;
- rect.right = width;
- rect.top = 0;
- rect.bottom = totalLineHeight;
+ canvas.save()
+ // canvas.translate(rect.left, rect.top + (rect.bottom - rect.top / 2));
+ val padding = if (center) (rect.bottom - rect.top - totalLineHeight) / 2 else 0
+ canvas.translate(rect.left, rect.top + padding)
+ rect.left = 0
+ rect.right = width
+ rect.top = 0
+ rect.bottom = totalLineHeight
// There's a bug somewhere. If this rect is outside of a previous
// cliprect, this becomes a no-op. What happens is that the text draw
// past the event rect. The current fix is to not draw the staticLayout
// at all if it is completely out of bound.
- canvas.clipRect(rect);
- eventLayout.draw(canvas);
- canvas.restore();
+ canvas.clipRect(rect)
+ eventLayout.draw(canvas)
+ canvas.restore()
}
// The following routines are called from the parent activity when certain
// touch events occur.
- private void doDown(MotionEvent ev) {
- mTouchMode = TOUCH_MODE_DOWN;
- mViewStartX = 0;
- mOnFlingCalled = false;
- mHandler.removeCallbacks(mContinueScroll);
- int x = (int) ev.getX();
- int y = (int) ev.getY();
+ private fun doDown(ev: MotionEvent) {
+ mTouchMode = TOUCH_MODE_DOWN
+ mViewStartX = 0
+ mOnFlingCalled = false
+ mHandler.removeCallbacks(mContinueScroll)
+ val x = ev.getX() as Int
+ val y = ev.getY() as Int
// Save selection information: we use setSelectionFromPosition to find the selected event
// in order to show the "clicked" color. But since it is also setting the selected info
// for new events, we need to restore the old info after calling the function.
- Event oldSelectedEvent = mSelectedEvent;
- int oldSelectionDay = mSelectionDay;
- int oldSelectionHour = mSelectionHour;
+ val oldSelectedEvent: Event? = mSelectedEvent
+ val oldSelectionDay = mSelectionDay
+ val oldSelectionHour = mSelectionHour
if (setSelectionFromPosition(x, y, false)) {
// If a time was selected (a blue selection box is visible) and the click location
// is in the selected time, do not show a click on an event to prevent a situation
// of both a selection and an event are clicked when they overlap.
- boolean pressedSelected = (mSelectionMode != SELECTION_HIDDEN)
- && oldSelectionDay == mSelectionDay && oldSelectionHour == mSelectionHour;
+ val pressedSelected = (mSelectionMode != SELECTION_HIDDEN
+ && oldSelectionDay == mSelectionDay && oldSelectionHour == mSelectionHour)
if (!pressedSelected && mSelectedEvent != null) {
- mSavedClickedEvent = mSelectedEvent;
- mDownTouchTime = System.currentTimeMillis();
- postDelayed (mSetClick,mOnDownDelay);
+ mSavedClickedEvent = mSelectedEvent
+ mDownTouchTime = System.currentTimeMillis()
+ postDelayed(mSetClick, mOnDownDelay)
} else {
- eventClickCleanup();
+ eventClickCleanup()
}
}
- mSelectedEvent = oldSelectedEvent;
- mSelectionDay = oldSelectionDay;
- mSelectionHour = oldSelectionHour;
- invalidate();
+ mSelectedEvent = oldSelectedEvent
+ mSelectionDay = oldSelectionDay
+ mSelectionHour = oldSelectionHour
+ invalidate()
}
// Kicks off all the animations when the expand allday area is tapped
- private void doExpandAllDayClick() {
- mShowAllAllDayEvents = !mShowAllAllDayEvents;
-
- ObjectAnimator.setFrameDelay(0);
+ private fun doExpandAllDayClick() {
+ mShowAllAllDayEvents = !mShowAllAllDayEvents
+ ObjectAnimator.setFrameDelay(0)
// Determine the starting height
if (mAnimateDayHeight == 0) {
- mAnimateDayHeight = mShowAllAllDayEvents ?
- mAlldayHeight - (int) MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT : mAlldayHeight;
+ mAnimateDayHeight =
+ if (mShowAllAllDayEvents) mAlldayHeight - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt() else mAlldayHeight
}
// Cancel current animations
- mCancellingAnimations = true;
+ mCancellingAnimations = true
if (mAlldayAnimator != null) {
- mAlldayAnimator.cancel();
+ mAlldayAnimator.cancel()
}
if (mAlldayEventAnimator != null) {
- mAlldayEventAnimator.cancel();
+ mAlldayEventAnimator.cancel()
}
if (mMoreAlldayEventsAnimator != null) {
- mMoreAlldayEventsAnimator.cancel();
+ mMoreAlldayEventsAnimator.cancel()
}
- mCancellingAnimations = false;
+ mCancellingAnimations = false
// get new animators
- mAlldayAnimator = getAllDayAnimator();
- mAlldayEventAnimator = getAllDayEventAnimator();
- mMoreAlldayEventsAnimator = ObjectAnimator.ofInt(this,
- "moreAllDayEventsTextAlpha",
- mShowAllAllDayEvents ? MORE_EVENTS_MAX_ALPHA : 0,
- mShowAllAllDayEvents ? 0 : MORE_EVENTS_MAX_ALPHA);
+ mAlldayAnimator = allDayAnimator
+ mAlldayEventAnimator = allDayEventAnimator
+ mMoreAlldayEventsAnimator = ObjectAnimator.ofInt(
+ this,
+ "moreAllDayEventsTextAlpha",
+ if (mShowAllAllDayEvents) MORE_EVENTS_MAX_ALPHA else 0,
+ if (mShowAllAllDayEvents) 0 else MORE_EVENTS_MAX_ALPHA
+ )
// Set up delays and start the animators
- mAlldayAnimator.setStartDelay(mShowAllAllDayEvents ? ANIMATION_SECONDARY_DURATION : 0);
- mAlldayAnimator.start();
- mMoreAlldayEventsAnimator.setStartDelay(mShowAllAllDayEvents ? 0 : ANIMATION_DURATION);
- mMoreAlldayEventsAnimator.setDuration(ANIMATION_SECONDARY_DURATION);
- mMoreAlldayEventsAnimator.start();
+ mAlldayAnimator.setStartDelay(if (mShowAllAllDayEvents) ANIMATION_SECONDARY_DURATION else 0)
+ mAlldayAnimator.start()
+ mMoreAlldayEventsAnimator.setStartDelay(if (mShowAllAllDayEvents) 0 else ANIMATION_DURATION)
+ mMoreAlldayEventsAnimator.setDuration(ANIMATION_SECONDARY_DURATION)
+ mMoreAlldayEventsAnimator.start()
if (mAlldayEventAnimator != null) {
// This is the only animator that can return null, so check it
mAlldayEventAnimator
- .setStartDelay(mShowAllAllDayEvents ? ANIMATION_SECONDARY_DURATION : 0);
- mAlldayEventAnimator.start();
+ .setStartDelay(if (mShowAllAllDayEvents) ANIMATION_SECONDARY_DURATION else 0)
+ mAlldayEventAnimator.start()
}
}
@@ -2979,570 +2529,579 @@
* Figures out the initial heights for allDay events and space when
* a view is being set up.
*/
- public void initAllDayHeights() {
+ fun initAllDayHeights() {
if (mMaxAlldayEvents <= mMaxUnexpandedAlldayEventCount) {
- return;
+ return
}
if (mShowAllAllDayEvents) {
- int maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT;
- maxADHeight = Math.min(maxADHeight,
- (int)(mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT));
- mAnimateDayEventHeight = maxADHeight / mMaxAlldayEvents;
+ var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
+ maxADHeight = Math.min(
+ maxADHeight,
+ (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
+ )
+ mAnimateDayEventHeight = maxADHeight / mMaxAlldayEvents
} else {
- mAnimateDayEventHeight = (int)MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT;
+ mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
}
- }
+ }// First calculate the absolute max height
+ // Now expand to fit but not beyond the absolute max
+ // calculate the height of individual events in order to fit
+ // if there's nothing to animate just return
+ // Set up the animator with the calculated values
// Sets up an animator for changing the height of allday events
- private ObjectAnimator getAllDayEventAnimator() {
- // First calculate the absolute max height
- int maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT;
- // Now expand to fit but not beyond the absolute max
- maxADHeight =
- Math.min(maxADHeight, (int)(mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT));
- // calculate the height of individual events in order to fit
- int fitHeight = maxADHeight / mMaxAlldayEvents;
- int currentHeight = mAnimateDayEventHeight;
- int desiredHeight =
- mShowAllAllDayEvents ? fitHeight : (int)MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT;
- // if there's nothing to animate just return
- if (currentHeight == desiredHeight) {
- return null;
- }
-
- // Set up the animator with the calculated values
- ObjectAnimator animator = ObjectAnimator.ofInt(this, "animateDayEventHeight",
- currentHeight, desiredHeight);
- animator.setDuration(ANIMATION_DURATION);
- return animator;
- }
-
- // Sets up an animator for changing the height of the allday area
- private ObjectAnimator getAllDayAnimator() {
- // Calculate the absolute max height
- int maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT;
- // Find the desired height but don't exceed abs max
- maxADHeight =
- Math.min(maxADHeight, (int)(mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT));
- // calculate the current and desired heights
- int currentHeight = mAnimateDayHeight != 0 ? mAnimateDayHeight : mAlldayHeight;
- int desiredHeight = mShowAllAllDayEvents ? maxADHeight :
- (int) (MAX_UNEXPANDED_ALLDAY_HEIGHT - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - 1);
-
- // Set up the animator with the calculated values
- ObjectAnimator animator = ObjectAnimator.ofInt(this, "animateDayHeight",
- currentHeight, desiredHeight);
- animator.setDuration(ANIMATION_DURATION);
-
- animator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator animation) {
- if (!mCancellingAnimations) {
- // when finished, set this to 0 to signify not animating
- mAnimateDayHeight = 0;
- mUseExpandIcon = !mShowAllAllDayEvents;
- }
- mRemeasure = true;
- invalidate();
+ private val allDayEventAnimator: ObjectAnimator?
+ private get() {
+ // First calculate the absolute max height
+ var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
+ // Now expand to fit but not beyond the absolute max
+ maxADHeight = Math.min(
+ maxADHeight,
+ (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
+ )
+ // calculate the height of individual events in order to fit
+ val fitHeight = maxADHeight / mMaxAlldayEvents
+ val currentHeight = mAnimateDayEventHeight
+ val desiredHeight =
+ if (mShowAllAllDayEvents) fitHeight else MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
+ // if there's nothing to animate just return
+ if (currentHeight == desiredHeight) {
+ return null
}
- });
- return animator;
- }
+
+ // Set up the animator with the calculated values
+ val animator: ObjectAnimator = ObjectAnimator.ofInt(
+ this, "animateDayEventHeight",
+ currentHeight, desiredHeight
+ )
+ animator.setDuration(ANIMATION_DURATION)
+ return animator
+ }// when finished, set this to 0 to signify not animating// Calculate the absolute max height
+ // Find the desired height but don't exceed abs max
+ // calculate the current and desired heights
+
+ // Set up the animator with the calculated values
+ // Sets up an animator for changing the height of the allday area
+ private val allDayAnimator: ObjectAnimator
+ private get() {
+ // Calculate the absolute max height
+ var maxADHeight = mViewHeight - DAY_HEADER_HEIGHT - MIN_HOURS_HEIGHT
+ // Find the desired height but don't exceed abs max
+ maxADHeight = Math.min(
+ maxADHeight,
+ (mMaxAlldayEvents * MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT).toInt()
+ )
+ // calculate the current and desired heights
+ val currentHeight = if (mAnimateDayHeight != 0) mAnimateDayHeight else mAlldayHeight
+ val desiredHeight =
+ if (mShowAllAllDayEvents) maxADHeight else (MAX_UNEXPANDED_ALLDAY_HEIGHT - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT - 1).toInt()
+
+ // Set up the animator with the calculated values
+ val animator: ObjectAnimator = ObjectAnimator.ofInt(
+ this, "animateDayHeight",
+ currentHeight, desiredHeight
+ )
+ animator.setDuration(ANIMATION_DURATION)
+ animator.addListener(object : AnimatorListenerAdapter() {
+ @Override
+ fun onAnimationEnd(animation: Animator?) {
+ if (!mCancellingAnimations) {
+ // when finished, set this to 0 to signify not animating
+ mAnimateDayHeight = 0
+ mUseExpandIcon = !mShowAllAllDayEvents
+ }
+ mRemeasure = true
+ invalidate()
+ }
+ })
+ return animator
+ }
// setter for the 'box +n' alpha text used by the animator
- public void setMoreAllDayEventsTextAlpha(int alpha) {
- mMoreAlldayEventsTextAlpha = alpha;
- invalidate();
+ fun setMoreAllDayEventsTextAlpha(alpha: Int) {
+ mMoreAlldayEventsTextAlpha = alpha
+ invalidate()
}
// setter for the height of the allday area used by the animator
- public void setAnimateDayHeight(int height) {
- mAnimateDayHeight = height;
- mRemeasure = true;
- invalidate();
+ fun setAnimateDayHeight(height: Int) {
+ mAnimateDayHeight = height
+ mRemeasure = true
+ invalidate()
}
// setter for the height of allday events used by the animator
- public void setAnimateDayEventHeight(int height) {
- mAnimateDayEventHeight = height;
- mRemeasure = true;
- invalidate();
+ fun setAnimateDayEventHeight(height: Int) {
+ mAnimateDayEventHeight = height
+ mRemeasure = true
+ invalidate()
}
- private void doSingleTapUp(MotionEvent ev) {
+ private fun doSingleTapUp(ev: MotionEvent) {
if (!mHandleActionUp || mScrolling) {
- return;
+ return
}
-
- int x = (int) ev.getX();
- int y = (int) ev.getY();
- int selectedDay = mSelectionDay;
- int selectedHour = mSelectionHour;
-
+ val x = ev.getX() as Int
+ val y = ev.getY() as Int
+ val selectedDay = mSelectionDay
+ val selectedHour = mSelectionHour
if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
// check if the tap was in the allday expansion area
- int bottom = mFirstCell;
- if((x < mHoursWidth && y > DAY_HEADER_HEIGHT && y < DAY_HEADER_HEIGHT + mAlldayHeight)
- || (!mShowAllAllDayEvents && mAnimateDayHeight == 0 && y < bottom &&
- y >= bottom - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT)) {
- doExpandAllDayClick();
- return;
+ val bottom = mFirstCell
+ if (x < mHoursWidth && y > DAY_HEADER_HEIGHT && y < DAY_HEADER_HEIGHT + mAlldayHeight
+ || !mShowAllAllDayEvents && mAnimateDayHeight == 0 && y < bottom && y >= bottom - MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT
+ ) {
+ doExpandAllDayClick()
+ return
}
}
-
- boolean validPosition = setSelectionFromPosition(x, y, false);
+ val validPosition = setSelectionFromPosition(x, y, false)
if (!validPosition) {
if (y < DAY_HEADER_HEIGHT) {
- Time selectedTime = new Time(mBaseDate);
- selectedTime.setJulianDay(mSelectionDay);
- selectedTime.hour = mSelectionHour;
- selectedTime.normalize(true /* ignore isDst */);
- mController.sendEvent(this, EventType.GO_TO, null, null, selectedTime, -1,
- ViewType.DAY, CalendarController.EXTRA_GOTO_DATE, null, null);
+ val selectedTime = Time(mBaseDate)
+ selectedTime.setJulianDay(mSelectionDay)
+ selectedTime.hour = mSelectionHour
+ selectedTime.normalize(true /* ignore isDst */)
+ mController.sendEvent(
+ this, EventType.GO_TO, null, null, selectedTime, -1,
+ ViewType.DAY, CalendarController.EXTRA_GOTO_DATE, null, null
+ )
}
- return;
+ return
}
-
- boolean hasSelection = mSelectionMode != SELECTION_HIDDEN;
- boolean pressedSelected = (hasSelection || mTouchExplorationEnabled)
- && selectedDay == mSelectionDay && selectedHour == mSelectionHour;
-
+ val hasSelection = mSelectionMode != SELECTION_HIDDEN
+ val pressedSelected = ((hasSelection || mTouchExplorationEnabled)
+ && selectedDay == mSelectionDay && selectedHour == mSelectionHour)
if (mSelectedEvent != null) {
// If the tap is on an event, launch the "View event" view
if (mIsAccessibilityEnabled) {
- mAccessibilityMgr.interrupt();
+ mAccessibilityMgr.interrupt()
}
-
- mSelectionMode = SELECTION_HIDDEN;
-
- int yLocation =
- (int)((mSelectedEvent.top + mSelectedEvent.bottom)/2);
+ mSelectionMode = SELECTION_HIDDEN
+ var yLocation = ((mSelectedEvent.top + mSelectedEvent.bottom) / 2) as Int
// Y location is affected by the position of the event in the scrolling
// view (mViewStartY) and the presence of all day events (mFirstCell)
if (!mSelectedEvent.allDay) {
- yLocation += (mFirstCell - mViewStartY);
+ yLocation += mFirstCell - mViewStartY
}
- mClickedYLocation = yLocation;
- long clearDelay = (CLICK_DISPLAY_DURATION + mOnDownDelay) -
- (System.currentTimeMillis() - mDownTouchTime);
+ mClickedYLocation = yLocation
+ val clearDelay: Long = CLICK_DISPLAY_DURATION + mOnDownDelay -
+ (System.currentTimeMillis() - mDownTouchTime)
if (clearDelay > 0) {
- this.postDelayed(mClearClick, clearDelay);
+ this.postDelayed(mClearClick, clearDelay)
} else {
- this.post(mClearClick);
+ this.post(mClearClick)
}
}
- invalidate();
+ invalidate()
}
- private void doLongPress(MotionEvent ev) {
- eventClickCleanup();
+ private fun doLongPress(ev: MotionEvent) {
+ eventClickCleanup()
if (mScrolling) {
- return;
+ return
}
// Scale gesture in progress
- if (mStartingSpanY != 0) {
- return;
+ if (mStartingSpanY != 0f) {
+ return
}
-
- int x = (int) ev.getX();
- int y = (int) ev.getY();
-
- boolean validPosition = setSelectionFromPosition(x, y, false);
+ val x = ev.getX() as Int
+ val y = ev.getY() as Int
+ val validPosition = setSelectionFromPosition(x, y, false)
if (!validPosition) {
// return if the touch wasn't on an area of concern
- return;
+ return
}
-
- invalidate();
- performLongClick();
+ invalidate()
+ performLongClick()
}
- private void doScroll(MotionEvent e1, MotionEvent e2, float deltaX, float deltaY) {
- cancelAnimation();
+ private fun doScroll(e1: MotionEvent, e2: MotionEvent, deltaX: Float, deltaY: Float) {
+ cancelAnimation()
if (mStartingScroll) {
- mInitialScrollX = 0;
- mInitialScrollY = 0;
- mStartingScroll = false;
+ mInitialScrollX = 0f
+ mInitialScrollY = 0f
+ mStartingScroll = false
}
-
- mInitialScrollX += deltaX;
- mInitialScrollY += deltaY;
- int distanceX = (int) mInitialScrollX;
- int distanceY = (int) mInitialScrollY;
-
- final float focusY = getAverageY(e2);
+ mInitialScrollX += deltaX
+ mInitialScrollY += deltaY
+ val distanceX = mInitialScrollX.toInt()
+ val distanceY = mInitialScrollY.toInt()
+ val focusY = getAverageY(e2)
if (mRecalCenterHour) {
// Calculate the hour that correspond to the average of the Y touch points
- mGestureCenterHour = (mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight)
- / (mCellHeight + DAY_GAP);
- mRecalCenterHour = false;
+ mGestureCenterHour = ((mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight)
+ / (mCellHeight + DAY_GAP))
+ mRecalCenterHour = false
}
// If we haven't figured out the predominant scroll direction yet,
// then do it now.
if (mTouchMode == TOUCH_MODE_DOWN) {
- int absDistanceX = Math.abs(distanceX);
- int absDistanceY = Math.abs(distanceY);
- mScrollStartY = mViewStartY;
- mPreviousDirection = 0;
-
+ val absDistanceX: Int = Math.abs(distanceX)
+ val absDistanceY: Int = Math.abs(distanceY)
+ mScrollStartY = mViewStartY
+ mPreviousDirection = 0
if (absDistanceX > absDistanceY) {
- int slopFactor = mScaleGestureDetector.isInProgress() ? 20 : 2;
+ val slopFactor = if (mScaleGestureDetector.isInProgress()) 20 else 2
if (absDistanceX > mScaledPagingTouchSlop * slopFactor) {
- mTouchMode = TOUCH_MODE_HSCROLL;
- mViewStartX = distanceX;
- initNextView(-mViewStartX);
+ mTouchMode = TOUCH_MODE_HSCROLL
+ mViewStartX = distanceX
+ initNextView(-mViewStartX)
}
} else {
- mTouchMode = TOUCH_MODE_VSCROLL;
+ mTouchMode = TOUCH_MODE_VSCROLL
}
- } else if ((mTouchMode & TOUCH_MODE_HSCROLL) != 0) {
+ } else if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
// We are already scrolling horizontally, so check if we
// changed the direction of scrolling so that the other week
// is now visible.
- mViewStartX = distanceX;
+ mViewStartX = distanceX
if (distanceX != 0) {
- int direction = (distanceX > 0) ? 1 : -1;
+ val direction = if (distanceX > 0) 1 else -1
if (direction != mPreviousDirection) {
// The user has switched the direction of scrolling
// so re-init the next view
- initNextView(-mViewStartX);
- mPreviousDirection = direction;
+ initNextView(-mViewStartX)
+ mPreviousDirection = direction
}
}
}
-
- if ((mTouchMode & TOUCH_MODE_VSCROLL) != 0) {
+ if (mTouchMode and TOUCH_MODE_VSCROLL != 0) {
// Calculate the top of the visible region in the calendar grid.
// Increasing/decrease this will scroll the calendar grid up/down.
- mViewStartY = (int) ((mGestureCenterHour * (mCellHeight + DAY_GAP))
- - focusY + DAY_HEADER_HEIGHT + mAlldayHeight);
+ mViewStartY = ((mGestureCenterHour * (mCellHeight + DAY_GAP)
+ - focusY) + DAY_HEADER_HEIGHT + mAlldayHeight).toInt()
// If dragging while already at the end, do a glow
- final int pulledToY = (int) (mScrollStartY + deltaY);
+ val pulledToY = (mScrollStartY + deltaY).toInt()
if (pulledToY < 0) {
- mEdgeEffectTop.onPull(deltaY / mViewHeight);
+ mEdgeEffectTop.onPull(deltaY / mViewHeight)
if (!mEdgeEffectBottom.isFinished()) {
- mEdgeEffectBottom.onRelease();
+ mEdgeEffectBottom.onRelease()
}
} else if (pulledToY > mMaxViewStartY) {
- mEdgeEffectBottom.onPull(deltaY / mViewHeight);
+ mEdgeEffectBottom.onPull(deltaY / mViewHeight)
if (!mEdgeEffectTop.isFinished()) {
- mEdgeEffectTop.onRelease();
+ mEdgeEffectTop.onRelease()
}
}
-
if (mViewStartY < 0) {
- mViewStartY = 0;
- mRecalCenterHour = true;
+ mViewStartY = 0
+ mRecalCenterHour = true
} else if (mViewStartY > mMaxViewStartY) {
- mViewStartY = mMaxViewStartY;
- mRecalCenterHour = true;
+ mViewStartY = mMaxViewStartY
+ mRecalCenterHour = true
}
if (mRecalCenterHour) {
// Calculate the hour that correspond to the average of the Y touch points
- mGestureCenterHour = (mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight)
- / (mCellHeight + DAY_GAP);
- mRecalCenterHour = false;
+ mGestureCenterHour = ((mViewStartY + focusY - DAY_HEADER_HEIGHT - mAlldayHeight)
+ / (mCellHeight + DAY_GAP))
+ mRecalCenterHour = false
}
- computeFirstHour();
+ computeFirstHour()
}
-
- mScrolling = true;
-
- mSelectionMode = SELECTION_HIDDEN;
- invalidate();
+ mScrolling = true
+ mSelectionMode = SELECTION_HIDDEN
+ invalidate()
}
- private float getAverageY(MotionEvent me) {
- int count = me.getPointerCount();
- float focusY = 0;
- for (int i = 0; i < count; i++) {
- focusY += me.getY(i);
+ private fun getAverageY(me: MotionEvent): Float {
+ val count: Int = me.getPointerCount()
+ var focusY = 0f
+ for (i in 0 until count) {
+ focusY += me.getY(i)
}
- focusY /= count;
- return focusY;
+ focusY /= count.toFloat()
+ return focusY
}
- private void cancelAnimation() {
- Animation in = mViewSwitcher.getInAnimation();
- if (in != null) {
+ private fun cancelAnimation() {
+ val `in`: Animation = mViewSwitcher.getInAnimation()
+ if (`in` != null) {
// cancel() doesn't terminate cleanly.
- in.scaleCurrentDuration(0);
+ `in`.scaleCurrentDuration(0)
}
- Animation out = mViewSwitcher.getOutAnimation();
+ val out: Animation = mViewSwitcher.getOutAnimation()
if (out != null) {
// cancel() doesn't terminate cleanly.
- out.scaleCurrentDuration(0);
+ out.scaleCurrentDuration(0)
}
}
- private void doFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
- cancelAnimation();
-
- mSelectionMode = SELECTION_HIDDEN;
- eventClickCleanup();
-
- mOnFlingCalled = true;
-
- if ((mTouchMode & TOUCH_MODE_HSCROLL) != 0) {
+ private fun doFling(e1: MotionEvent, e2: MotionEvent, velocityX: Float, velocityY: Float) {
+ cancelAnimation()
+ mSelectionMode = SELECTION_HIDDEN
+ eventClickCleanup()
+ mOnFlingCalled = true
+ if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
// Horizontal fling.
// initNextView(deltaX);
- mTouchMode = TOUCH_MODE_INITIAL_STATE;
- if (DEBUG) Log.d(TAG, "doFling: velocityX " + velocityX);
- int deltaX = (int) e2.getX() - (int) e1.getX();
- switchViews(deltaX < 0, mViewStartX, mViewWidth, velocityX);
- mViewStartX = 0;
- return;
+ mTouchMode = TOUCH_MODE_INITIAL_STATE
+ if (DEBUG) Log.d(TAG, "doFling: velocityX $velocityX")
+ val deltaX = e2.getX() as Int - e1.getX() as Int
+ switchViews(deltaX < 0, mViewStartX.toFloat(), mViewWidth.toFloat(), velocityX)
+ mViewStartX = 0
+ return
}
-
- if ((mTouchMode & TOUCH_MODE_VSCROLL) == 0) {
- if (DEBUG) Log.d(TAG, "doFling: no fling");
- return;
+ if (mTouchMode and TOUCH_MODE_VSCROLL == 0) {
+ if (DEBUG) Log.d(TAG, "doFling: no fling")
+ return
}
// Vertical fling.
- mTouchMode = TOUCH_MODE_INITIAL_STATE;
- mViewStartX = 0;
-
+ mTouchMode = TOUCH_MODE_INITIAL_STATE
+ mViewStartX = 0
if (DEBUG) {
- Log.d(TAG, "doFling: mViewStartY" + mViewStartY + " velocityY " + velocityY);
+ Log.d(TAG, "doFling: mViewStartY$mViewStartY velocityY $velocityY")
}
// Continue scrolling vertically
- mScrolling = true;
- mScroller.fling(0 /* startX */, mViewStartY /* startY */, 0 /* velocityX */,
- (int) -velocityY, 0 /* minX */, 0 /* maxX */, 0 /* minY */,
- mMaxViewStartY /* maxY */, OVERFLING_DISTANCE, OVERFLING_DISTANCE);
+ mScrolling = true
+ mScroller.fling(
+ 0 /* startX */, mViewStartY /* startY */, 0 /* velocityX */,
+ (-velocityY).toInt(), 0 /* minX */, 0 /* maxX */, 0 /* minY */,
+ mMaxViewStartY /* maxY */, OVERFLING_DISTANCE, OVERFLING_DISTANCE
+ )
// When flinging down, show a glow when it hits the end only if it
// wasn't started at the top
if (velocityY > 0 && mViewStartY != 0) {
- mCallEdgeEffectOnAbsorb = true;
+ mCallEdgeEffectOnAbsorb = true
+ } else if (velocityY < 0 && mViewStartY != mMaxViewStartY) {
+ mCallEdgeEffectOnAbsorb = true
}
- // When flinging up, show a glow when it hits the end only if it wasn't
- // started at the bottom
- else if (velocityY < 0 && mViewStartY != mMaxViewStartY) {
- mCallEdgeEffectOnAbsorb = true;
- }
- mHandler.post(mContinueScroll);
+ mHandler.post(mContinueScroll)
}
- private boolean initNextView(int deltaX) {
+ private fun initNextView(deltaX: Int): Boolean {
// Change the view to the previous day or week
- DayView view = (DayView) mViewSwitcher.getNextView();
- Time date = view.mBaseDate;
- date.set(mBaseDate);
- boolean switchForward;
+ val view = mViewSwitcher.getNextView() as DayView
+ val date: Time? = view.mBaseDate
+ date.set(mBaseDate)
+ val switchForward: Boolean
if (deltaX > 0) {
- date.monthDay -= mNumDays;
- view.setSelectedDay(mSelectionDay - mNumDays);
- switchForward = false;
+ date.monthDay -= mNumDays
+ view.selectedDay = mSelectionDay - mNumDays
+ switchForward = false
} else {
- date.monthDay += mNumDays;
- view.setSelectedDay(mSelectionDay + mNumDays);
- switchForward = true;
+ date.monthDay += mNumDays
+ view.selectedDay = mSelectionDay + mNumDays
+ switchForward = true
}
- date.normalize(true /* ignore isDst */);
- initView(view);
- view.layout(getLeft(), getTop(), getRight(), getBottom());
- view.reloadEvents();
- return switchForward;
+ date.normalize(true /* ignore isDst */)
+ initView(view)
+ view.layout(getLeft(), getTop(), getRight(), getBottom())
+ view.reloadEvents()
+ return switchForward
}
// ScaleGestureDetector.OnScaleGestureListener
- public boolean onScaleBegin(ScaleGestureDetector detector) {
- mHandleActionUp = false;
- float gestureCenterInPixels = detector.getFocusY() - DAY_HEADER_HEIGHT - mAlldayHeight;
- mGestureCenterHour = (mViewStartY + gestureCenterInPixels) / (mCellHeight + DAY_GAP);
-
- mStartingSpanY = Math.max(MIN_Y_SPAN, Math.abs(detector.getCurrentSpanY()));
- mCellHeightBeforeScaleGesture = mCellHeight;
-
+ fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+ mHandleActionUp = false
+ val gestureCenterInPixels: Float = detector.getFocusY() - DAY_HEADER_HEIGHT - mAlldayHeight
+ mGestureCenterHour = (mViewStartY + gestureCenterInPixels) / (mCellHeight + DAY_GAP)
+ mStartingSpanY = Math.max(MIN_Y_SPAN, Math.abs(detector.getCurrentSpanY()))
+ mCellHeightBeforeScaleGesture = mCellHeight
if (DEBUG_SCALING) {
- float ViewStartHour = mViewStartY / (float) (mCellHeight + DAY_GAP);
- Log.d(TAG, "onScaleBegin: mGestureCenterHour:" + mGestureCenterHour
- + "\tViewStartHour: " + ViewStartHour + "\tmViewStartY:" + mViewStartY
- + "\tmCellHeight:" + mCellHeight + " SpanY:" + detector.getCurrentSpanY());
+ val ViewStartHour = mViewStartY / (mCellHeight + DAY_GAP).toFloat()
+ Log.d(
+ TAG, "onScaleBegin: mGestureCenterHour:" + mGestureCenterHour
+ + "\tViewStartHour: " + ViewStartHour + "\tmViewStartY:" + mViewStartY
+ + "\tmCellHeight:" + mCellHeight + " SpanY:" + detector.getCurrentSpanY()
+ )
}
-
- return true;
+ return true
}
// ScaleGestureDetector.OnScaleGestureListener
- public boolean onScale(ScaleGestureDetector detector) {
- float spanY = Math.max(MIN_Y_SPAN, Math.abs(detector.getCurrentSpanY()));
-
- mCellHeight = (int) (mCellHeightBeforeScaleGesture * spanY / mStartingSpanY);
-
+ fun onScale(detector: ScaleGestureDetector): Boolean {
+ val spanY: Float = Math.max(MIN_Y_SPAN, Math.abs(detector.getCurrentSpanY()))
+ mCellHeight = (mCellHeightBeforeScaleGesture * spanY / mStartingSpanY).toInt()
if (mCellHeight < mMinCellHeight) {
// If mStartingSpanY is too small, even a small increase in the
// gesture can bump the mCellHeight beyond MAX_CELL_HEIGHT
- mStartingSpanY = spanY;
- mCellHeight = mMinCellHeight;
- mCellHeightBeforeScaleGesture = mMinCellHeight;
+ mStartingSpanY = spanY
+ mCellHeight = mMinCellHeight
+ mCellHeightBeforeScaleGesture = mMinCellHeight
} else if (mCellHeight > MAX_CELL_HEIGHT) {
- mStartingSpanY = spanY;
- mCellHeight = MAX_CELL_HEIGHT;
- mCellHeightBeforeScaleGesture = MAX_CELL_HEIGHT;
+ mStartingSpanY = spanY
+ mCellHeight = MAX_CELL_HEIGHT
+ mCellHeightBeforeScaleGesture = MAX_CELL_HEIGHT
}
-
- int gestureCenterInPixels = (int) detector.getFocusY() - DAY_HEADER_HEIGHT - mAlldayHeight;
- mViewStartY = (int) (mGestureCenterHour * (mCellHeight + DAY_GAP)) - gestureCenterInPixels;
- mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight;
-
+ val gestureCenterInPixels = detector.getFocusY() as Int - DAY_HEADER_HEIGHT - mAlldayHeight
+ mViewStartY = (mGestureCenterHour * (mCellHeight + DAY_GAP)).toInt() - gestureCenterInPixels
+ mMaxViewStartY = HOUR_GAP + 24 * (mCellHeight + HOUR_GAP) - mGridAreaHeight
if (DEBUG_SCALING) {
- float ViewStartHour = mViewStartY / (float) (mCellHeight + DAY_GAP);
- Log.d(TAG, "onScale: mGestureCenterHour:" + mGestureCenterHour + "\tViewStartHour: "
- + ViewStartHour + "\tmViewStartY:" + mViewStartY + "\tmCellHeight:"
- + mCellHeight + " SpanY:" + detector.getCurrentSpanY());
+ val ViewStartHour = mViewStartY / (mCellHeight + DAY_GAP).toFloat()
+ Log.d(
+ TAG, "onScale: mGestureCenterHour:" + mGestureCenterHour + "\tViewStartHour: "
+ + ViewStartHour + "\tmViewStartY:" + mViewStartY + "\tmCellHeight:"
+ + mCellHeight + " SpanY:" + detector.getCurrentSpanY()
+ )
}
-
if (mViewStartY < 0) {
- mViewStartY = 0;
- mGestureCenterHour = (mViewStartY + gestureCenterInPixels)
- / (float) (mCellHeight + DAY_GAP);
+ mViewStartY = 0
+ mGestureCenterHour = ((mViewStartY + gestureCenterInPixels)
+ / (mCellHeight + DAY_GAP).toFloat())
} else if (mViewStartY > mMaxViewStartY) {
- mViewStartY = mMaxViewStartY;
- mGestureCenterHour = (mViewStartY + gestureCenterInPixels)
- / (float) (mCellHeight + DAY_GAP);
+ mViewStartY = mMaxViewStartY
+ mGestureCenterHour = ((mViewStartY + gestureCenterInPixels)
+ / (mCellHeight + DAY_GAP).toFloat())
}
- computeFirstHour();
-
- mRemeasure = true;
- invalidate();
- return true;
+ computeFirstHour()
+ mRemeasure = true
+ invalidate()
+ return true
}
// ScaleGestureDetector.OnScaleGestureListener
- public void onScaleEnd(ScaleGestureDetector detector) {
- mScrollStartY = mViewStartY;
- mInitialScrollY = 0;
- mInitialScrollX = 0;
- mStartingSpanY = 0;
+ fun onScaleEnd(detector: ScaleGestureDetector?) {
+ mScrollStartY = mViewStartY
+ mInitialScrollY = 0f
+ mInitialScrollX = 0f
+ mStartingSpanY = 0f
}
@Override
- public boolean onTouchEvent(MotionEvent ev) {
- int action = ev.getAction();
- if (DEBUG) Log.e(TAG, "" + action + " ev.getPointerCount() = " + ev.getPointerCount());
-
- if ((ev.getActionMasked() == MotionEvent.ACTION_DOWN) ||
- (ev.getActionMasked() == MotionEvent.ACTION_UP) ||
- (ev.getActionMasked() == MotionEvent.ACTION_POINTER_UP) ||
- (ev.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN)) {
- mRecalCenterHour = true;
+ fun onTouchEvent(ev: MotionEvent): Boolean {
+ val action: Int = ev.getAction()
+ if (DEBUG) Log.e(TAG, "" + action + " ev.getPointerCount() = " + ev.getPointerCount())
+ if (ev.getActionMasked() === MotionEvent.ACTION_DOWN ||
+ ev.getActionMasked() === MotionEvent.ACTION_UP ||
+ ev.getActionMasked() === MotionEvent.ACTION_POINTER_UP ||
+ ev.getActionMasked() === MotionEvent.ACTION_POINTER_DOWN
+ ) {
+ mRecalCenterHour = true
}
-
- if ((mTouchMode & TOUCH_MODE_HSCROLL) == 0) {
- mScaleGestureDetector.onTouchEvent(ev);
+ if (mTouchMode and TOUCH_MODE_HSCROLL == 0) {
+ mScaleGestureDetector.onTouchEvent(ev)
}
-
- switch (action) {
- case MotionEvent.ACTION_DOWN:
- mStartingScroll = true;
+ return when (action) {
+ MotionEvent.ACTION_DOWN -> {
+ mStartingScroll = true
if (DEBUG) {
- Log.e(TAG, "ACTION_DOWN ev.getDownTime = " + ev.getDownTime() + " Cnt="
- + ev.getPointerCount());
+ Log.e(
+ TAG,
+ "ACTION_DOWN ev.getDownTime = " + ev.getDownTime().toString() + " Cnt="
+ + ev.getPointerCount()
+ )
}
-
- int bottom = mAlldayHeight + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN;
- if (ev.getY() < bottom) {
- mTouchStartedInAlldayArea = true;
+ val bottom =
+ mAlldayHeight + DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
+ mTouchStartedInAlldayArea = if (ev.getY() < bottom) {
+ true
} else {
- mTouchStartedInAlldayArea = false;
+ false
}
- mHandleActionUp = true;
- mGestureDetector.onTouchEvent(ev);
- return true;
-
- case MotionEvent.ACTION_MOVE:
- if (DEBUG) Log.e(TAG, "ACTION_MOVE Cnt=" + ev.getPointerCount() + DayView.this);
- mGestureDetector.onTouchEvent(ev);
- return true;
-
- case MotionEvent.ACTION_UP:
- if (DEBUG) Log.e(TAG, "ACTION_UP Cnt=" + ev.getPointerCount() + mHandleActionUp);
- mEdgeEffectTop.onRelease();
- mEdgeEffectBottom.onRelease();
- mStartingScroll = false;
- mGestureDetector.onTouchEvent(ev);
+ mHandleActionUp = true
+ mGestureDetector.onTouchEvent(ev)
+ true
+ }
+ MotionEvent.ACTION_MOVE -> {
+ if (DEBUG) Log.e(
+ TAG,
+ "ACTION_MOVE Cnt=" + ev.getPointerCount() + this@DayView
+ )
+ mGestureDetector.onTouchEvent(ev)
+ true
+ }
+ MotionEvent.ACTION_UP -> {
+ if (DEBUG) Log.e(
+ TAG,
+ "ACTION_UP Cnt=" + ev.getPointerCount() + mHandleActionUp
+ )
+ mEdgeEffectTop.onRelease()
+ mEdgeEffectBottom.onRelease()
+ mStartingScroll = false
+ mGestureDetector.onTouchEvent(ev)
if (!mHandleActionUp) {
- mHandleActionUp = true;
- mViewStartX = 0;
- invalidate();
- return true;
+ mHandleActionUp = true
+ mViewStartX = 0
+ invalidate()
+ return true
}
-
if (mOnFlingCalled) {
- return true;
+ return true
}
// If we were scrolling, then reset the selected hour so that it
// is visible.
if (mScrolling) {
- mScrolling = false;
- resetSelectedHour();
- invalidate();
+ mScrolling = false
+ resetSelectedHour()
+ invalidate()
}
-
- if ((mTouchMode & TOUCH_MODE_HSCROLL) != 0) {
- mTouchMode = TOUCH_MODE_INITIAL_STATE;
+ if (mTouchMode and TOUCH_MODE_HSCROLL != 0) {
+ mTouchMode = TOUCH_MODE_INITIAL_STATE
if (Math.abs(mViewStartX) > mHorizontalSnapBackThreshold) {
// The user has gone beyond the threshold so switch views
- if (DEBUG) Log.d(TAG, "- horizontal scroll: switch views");
- switchViews(mViewStartX > 0, mViewStartX, mViewWidth, 0);
- mViewStartX = 0;
- return true;
+ if (DEBUG) Log.d(
+ TAG,
+ "- horizontal scroll: switch views"
+ )
+ switchViews(
+ mViewStartX > 0,
+ mViewStartX.toFloat(),
+ mViewWidth.toFloat(),
+ 0f
+ )
+ mViewStartX = 0
+ return true
} else {
// Not beyond the threshold so invalidate which will cause
// the view to snap back. Also call recalc() to ensure
// that we have the correct starting date and title.
- if (DEBUG) Log.d(TAG, "- horizontal scroll: snap back");
- recalc();
- invalidate();
- mViewStartX = 0;
+ if (DEBUG) Log.d(
+ TAG,
+ "- horizontal scroll: snap back"
+ )
+ recalc()
+ invalidate()
+ mViewStartX = 0
}
}
-
- return true;
-
- // This case isn't expected to happen.
- case MotionEvent.ACTION_CANCEL:
- if (DEBUG) Log.e(TAG, "ACTION_CANCEL");
- mGestureDetector.onTouchEvent(ev);
- mScrolling = false;
- resetSelectedHour();
- return true;
-
- default:
- if (DEBUG) Log.e(TAG, "Not MotionEvent " + ev.toString());
+ true
+ }
+ MotionEvent.ACTION_CANCEL -> {
+ if (DEBUG) Log.e(
+ TAG,
+ "ACTION_CANCEL"
+ )
+ mGestureDetector.onTouchEvent(ev)
+ mScrolling = false
+ resetSelectedHour()
+ true
+ }
+ else -> {
+ if (DEBUG) Log.e(
+ TAG,
+ "Not MotionEvent " + ev.toString()
+ )
if (mGestureDetector.onTouchEvent(ev)) {
- return true;
- }
- return super.onTouchEvent(ev);
+ true
+ } else super.onTouchEvent(ev)
+ }
}
}
- public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) {
- MenuItem item;
+ fun onCreateContextMenu(menu: ContextMenu, view: View?, menuInfo: ContextMenuInfo?) {
+ var item: MenuItem
// If the trackball is held down, then the context menu pops up and
// we never get onKeyUp() for the long-press. So check for it here
// and change the selection to the long-press state.
if (mSelectionMode != SELECTION_LONGPRESS) {
- invalidate();
+ invalidate()
}
-
- final long startMillis = getSelectedTimeInMillis();
- int flags = DateUtils.FORMAT_SHOW_TIME
- | DateUtils.FORMAT_CAP_NOON_MIDNIGHT
- | DateUtils.FORMAT_SHOW_WEEKDAY;
- final String title = Utils.formatDateRange(mContext, startMillis, startMillis, flags);
- menu.setHeaderTitle(title);
-
- mPopup.dismiss();
+ val startMillis = selectedTimeInMillis
+ val flags: Int = (DateUtils.FORMAT_SHOW_TIME
+ or DateUtils.FORMAT_CAP_NOON_MIDNIGHT
+ or DateUtils.FORMAT_SHOW_WEEKDAY)
+ val title: String = Utils.formatDateRange(mContext, startMillis, startMillis, flags)
+ menu.setHeaderTitle(title)
+ mPopup.dismiss()
}
/**
@@ -3553,201 +3112,191 @@
* @param x the x position of the touch
* @param y the y position of the touch
* @param keepOldSelection - do not change the selection info (used for invoking accessibility
- * messages)
+ * messages)
* @return true if the touch position is valid
*/
- private boolean setSelectionFromPosition(int x, final int y, boolean keepOldSelection) {
-
- Event savedEvent = null;
- int savedDay = 0;
- int savedHour = 0;
- boolean savedAllDay = false;
+ private fun setSelectionFromPosition(x: Int, y: Int, keepOldSelection: Boolean): Boolean {
+ var x = x
+ var savedEvent: Event? = null
+ var savedDay = 0
+ var savedHour = 0
+ var savedAllDay = false
if (keepOldSelection) {
// Store selection info and restore it at the end. This way, we can invoke the
// right accessibility message without affecting the selection.
- savedEvent = mSelectedEvent;
- savedDay = mSelectionDay;
- savedHour = mSelectionHour;
- savedAllDay = mSelectionAllday;
+ savedEvent = mSelectedEvent
+ savedDay = mSelectionDay
+ savedHour = mSelectionHour
+ savedAllDay = mSelectionAllday
}
if (x < mHoursWidth) {
- x = mHoursWidth;
+ x = mHoursWidth
}
-
- int day = (x - mHoursWidth) / (mCellWidth + DAY_GAP);
+ var day = (x - mHoursWidth) / (mCellWidth + DAY_GAP)
if (day >= mNumDays) {
- day = mNumDays - 1;
+ day = mNumDays - 1
}
- day += mFirstJulianDay;
- setSelectedDay(day);
-
+ day += mFirstJulianDay
+ selectedDay = day
if (y < DAY_HEADER_HEIGHT) {
- sendAccessibilityEventAsNeeded(false);
- return false;
+ sendAccessibilityEventAsNeeded(false)
+ return false
}
-
- setSelectedHour(mFirstHour); /* First fully visible hour */
-
- if (y < mFirstCell) {
- mSelectionAllday = true;
+ setSelectedHour(mFirstHour) /* First fully visible hour */
+ mSelectionAllday = if (y < mFirstCell) {
+ true
} else {
// y is now offset from top of the scrollable region
- int adjustedY = y - mFirstCell;
-
+ val adjustedY = y - mFirstCell
if (adjustedY < mFirstHourOffset) {
- setSelectedHour(mSelectionHour - 1); /* In the partially visible hour */
+ setSelectedHour(mSelectionHour - 1) /* In the partially visible hour */
} else {
- setSelectedHour(mSelectionHour +
- (adjustedY - mFirstHourOffset) / (mCellHeight + HOUR_GAP));
+ setSelectedHour(
+ mSelectionHour +
+ (adjustedY - mFirstHourOffset) / (mCellHeight + HOUR_GAP)
+ )
}
-
- mSelectionAllday = false;
+ false
}
-
- findSelectedEvent(x, y);
-
- sendAccessibilityEventAsNeeded(true);
+ findSelectedEvent(x, y)
+ sendAccessibilityEventAsNeeded(true)
// Restore old values
if (keepOldSelection) {
- mSelectedEvent = savedEvent;
- mSelectionDay = savedDay;
- mSelectionHour = savedHour;
- mSelectionAllday = savedAllDay;
+ mSelectedEvent = savedEvent
+ mSelectionDay = savedDay
+ mSelectionHour = savedHour
+ mSelectionAllday = savedAllDay
}
- return true;
+ return true
}
- private void findSelectedEvent(int x, int y) {
- int date = mSelectionDay;
- int cellWidth = mCellWidth;
- ArrayList<Event> events = mEvents;
- int numEvents = events.size();
- int left = computeDayLeftPosition(mSelectionDay - mFirstJulianDay);
- int top = 0;
- setSelectedEvent(null);
-
- mSelectedEvents.clear();
+ private fun findSelectedEvent(x: Int, y: Int) {
+ var y = y
+ val date = mSelectionDay
+ val cellWidth = mCellWidth
+ var events: ArrayList<Event>? = mEvents
+ var numEvents: Int = events.size()
+ val left = computeDayLeftPosition(mSelectionDay - mFirstJulianDay)
+ val top = 0
+ setSelectedEvent(null)
+ mSelectedEvents.clear()
if (mSelectionAllday) {
- float yDistance;
- float minYdistance = 10000.0f; // any large number
- Event closestEvent = null;
- float drawHeight = mAlldayHeight;
- int yOffset = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN;
- int maxUnexpandedColumn = mMaxUnexpandedAlldayEventCount;
+ var yDistance: Float
+ var minYdistance = 10000.0f // any large number
+ var closestEvent: Event? = null
+ val drawHeight = mAlldayHeight.toFloat()
+ val yOffset = DAY_HEADER_HEIGHT + ALLDAY_TOP_MARGIN
+ var maxUnexpandedColumn = mMaxUnexpandedAlldayEventCount
if (mMaxAlldayEvents > mMaxUnexpandedAlldayEventCount) {
// Leave a gap for the 'box +n' text
- maxUnexpandedColumn--;
+ maxUnexpandedColumn--
}
- events = mAllDayEvents;
- numEvents = events.size();
- for (int i = 0; i < numEvents; i++) {
- Event event = events.get(i);
+ events = mAllDayEvents
+ numEvents = events.size()
+ for (i in 0 until numEvents) {
+ val event: Event = events.get(i)
if (!event.drawAsAllday() ||
- (!mShowAllAllDayEvents && event.getColumn() >= maxUnexpandedColumn)) {
+ !mShowAllAllDayEvents && event.getColumn() >= maxUnexpandedColumn
+ ) {
// Don't check non-allday events or events that aren't shown
- continue;
+ continue
}
-
if (event.startDay <= mSelectionDay && event.endDay >= mSelectionDay) {
- float numRectangles = mShowAllAllDayEvents ? mMaxAlldayEvents
- : mMaxUnexpandedAlldayEventCount;
- float height = drawHeight / numRectangles;
+ val numRectangles =
+ if (mShowAllAllDayEvents) mMaxAlldayEvents.toFloat() else mMaxUnexpandedAlldayEventCount.toFloat()
+ var height = drawHeight / numRectangles
if (height > MAX_HEIGHT_OF_ONE_ALLDAY_EVENT) {
- height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT;
+ height = MAX_HEIGHT_OF_ONE_ALLDAY_EVENT.toFloat()
}
- float eventTop = yOffset + height * event.getColumn();
- float eventBottom = eventTop + height;
+ val eventTop: Float = yOffset + height * event.getColumn()
+ val eventBottom = eventTop + height
if (eventTop < y && eventBottom > y) {
// If the touch is inside the event rectangle, then
// add the event.
- mSelectedEvents.add(event);
- closestEvent = event;
- break;
+ mSelectedEvents.add(event)
+ closestEvent = event
+ break
} else {
// Find the closest event
- if (eventTop >= y) {
- yDistance = eventTop - y;
+ yDistance = if (eventTop >= y) {
+ eventTop - y
} else {
- yDistance = y - eventBottom;
+ y - eventBottom
}
if (yDistance < minYdistance) {
- minYdistance = yDistance;
- closestEvent = event;
+ minYdistance = yDistance
+ closestEvent = event
}
}
}
}
- setSelectedEvent(closestEvent);
- return;
+ setSelectedEvent(closestEvent)
+ return
}
// Adjust y for the scrollable bitmap
- y += mViewStartY - mFirstCell;
+ y += mViewStartY - mFirstCell
// Use a region around (x,y) for the selection region
- Rect region = mRect;
- region.left = x - 10;
- region.right = x + 10;
- region.top = y - 10;
- region.bottom = y + 10;
-
- EventGeometry geometry = mEventGeometry;
-
- for (int i = 0; i < numEvents; i++) {
- Event event = events.get(i);
+ val region: Rect = mRect
+ region.left = x - 10
+ region.right = x + 10
+ region.top = y - 10
+ region.bottom = y + 10
+ val geometry: EventGeometry = mEventGeometry
+ for (i in 0 until numEvents) {
+ val event: Event = events.get(i)
// Compute the event rectangle.
if (!geometry.computeEventRect(date, left, top, cellWidth, event)) {
- continue;
+ continue
}
// If the event intersects the selection region, then add it to
// mSelectedEvents.
if (geometry.eventIntersectsSelection(event, region)) {
- mSelectedEvents.add(event);
+ mSelectedEvents.add(event)
}
}
// If there are any events in the selected region, then assign the
// closest one to mSelectedEvent.
if (mSelectedEvents.size() > 0) {
- int len = mSelectedEvents.size();
- Event closestEvent = null;
- float minDist = mViewWidth + mViewHeight; // some large distance
- for (int index = 0; index < len; index++) {
- Event ev = mSelectedEvents.get(index);
- float dist = geometry.pointToEvent(x, y, ev);
+ val len: Int = mSelectedEvents.size()
+ var closestEvent: Event? = null
+ var minDist = (mViewWidth + mViewHeight).toFloat() // some large distance
+ for (index in 0 until len) {
+ val ev: Event = mSelectedEvents.get(index)
+ val dist: Float = geometry.pointToEvent(x, y, ev)
if (dist < minDist) {
- minDist = dist;
- closestEvent = ev;
+ minDist = dist
+ closestEvent = ev
}
}
- setSelectedEvent(closestEvent);
+ setSelectedEvent(closestEvent)
// Keep the selected hour and day consistent with the selected
// event. They could be different if we touched on an empty hour
// slot very close to an event in the previous hour slot. In
// that case we will select the nearby event.
- int startDay = mSelectedEvent.startDay;
- int endDay = mSelectedEvent.endDay;
+ val startDay: Int = mSelectedEvent.startDay
+ val endDay: Int = mSelectedEvent.endDay
if (mSelectionDay < startDay) {
- setSelectedDay(startDay);
+ selectedDay = startDay
} else if (mSelectionDay > endDay) {
- setSelectedDay(endDay);
+ selectedDay = endDay
}
-
- int startHour = mSelectedEvent.startTime / 60;
- int endHour;
- if (mSelectedEvent.startTime < mSelectedEvent.endTime) {
- endHour = (mSelectedEvent.endTime - 1) / 60;
+ val startHour: Int = mSelectedEvent.startTime / 60
+ val endHour: Int
+ endHour = if (mSelectedEvent.startTime < mSelectedEvent.endTime) {
+ (mSelectedEvent.endTime - 1) / 60
} else {
- endHour = mSelectedEvent.endTime / 60;
+ mSelectedEvent.endTime / 60
}
-
if (mSelectionHour < startHour && mSelectionDay == startDay) {
- setSelectedHour(startHour);
+ setSelectedHour(startHour)
} else if (mSelectionHour > endHour && mSelectionDay == endDay) {
- setSelectedHour(endHour);
+ setSelectedHour(endHour)
}
}
}
@@ -3755,213 +3304,204 @@
// Encapsulates the code to continue the scrolling after the
// finger is lifted. Instead of stopping the scroll immediately,
// the scroll continues to "free spin" and gradually slows down.
- private class ContinueScroll implements Runnable {
-
- public void run() {
- mScrolling = mScrolling && mScroller.computeScrollOffset();
+ private inner class ContinueScroll : Runnable {
+ fun run() {
+ mScrolling = mScrolling && mScroller.computeScrollOffset()
if (!mScrolling || mPaused) {
- resetSelectedHour();
- invalidate();
- return;
+ resetSelectedHour()
+ invalidate()
+ return
}
-
- mViewStartY = mScroller.getCurrY();
-
+ mViewStartY = mScroller.getCurrY()
if (mCallEdgeEffectOnAbsorb) {
if (mViewStartY < 0) {
- mEdgeEffectTop.onAbsorb((int) mLastVelocity);
- mCallEdgeEffectOnAbsorb = false;
+ mEdgeEffectTop.onAbsorb(mLastVelocity.toInt())
+ mCallEdgeEffectOnAbsorb = false
} else if (mViewStartY > mMaxViewStartY) {
- mEdgeEffectBottom.onAbsorb((int) mLastVelocity);
- mCallEdgeEffectOnAbsorb = false;
+ mEdgeEffectBottom.onAbsorb(mLastVelocity.toInt())
+ mCallEdgeEffectOnAbsorb = false
}
- mLastVelocity = mScroller.getCurrVelocity();
+ mLastVelocity = mScroller.getCurrVelocity()
}
-
if (mScrollStartY == 0 || mScrollStartY == mMaxViewStartY) {
// Allow overscroll/springback only on a fling,
// not a pull/fling from the end
if (mViewStartY < 0) {
- mViewStartY = 0;
+ mViewStartY = 0
} else if (mViewStartY > mMaxViewStartY) {
- mViewStartY = mMaxViewStartY;
+ mViewStartY = mMaxViewStartY
}
}
-
- computeFirstHour();
- mHandler.post(this);
- invalidate();
+ computeFirstHour()
+ mHandler.post(this)
+ invalidate()
}
}
/**
* Cleanup the pop-up and timers.
*/
- public void cleanup() {
+ fun cleanup() {
// Protect against null-pointer exceptions
if (mPopup != null) {
- mPopup.dismiss();
+ mPopup.dismiss()
}
- mPaused = true;
- mLastPopupEventID = INVALID_EVENT_ID;
+ mPaused = true
+ mLastPopupEventID = INVALID_EVENT_ID
if (mHandler != null) {
- mHandler.removeCallbacks(mDismissPopup);
- mHandler.removeCallbacks(mUpdateCurrentTime);
+ mHandler.removeCallbacks(mDismissPopup)
+ mHandler.removeCallbacks(mUpdateCurrentTime)
}
-
- Utils.setSharedPreference(mContext, GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT,
- mCellHeight);
+ Utils.setSharedPreference(
+ mContext, GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT,
+ mCellHeight
+ )
// Clear all click animations
- eventClickCleanup();
+ eventClickCleanup()
// Turn off redraw
- mRemeasure = false;
+ mRemeasure = false
// Turn off scrolling to make sure the view is in the correct state if we fling back to it
- mScrolling = false;
+ mScrolling = false
}
- private void eventClickCleanup() {
- this.removeCallbacks(mClearClick);
- this.removeCallbacks(mSetClick);
- mClickedEvent = null;
- mSavedClickedEvent = null;
+ private fun eventClickCleanup() {
+ this.removeCallbacks(mClearClick)
+ this.removeCallbacks(mSetClick)
+ mClickedEvent = null
+ mSavedClickedEvent = null
}
- private void setSelectedEvent(Event e) {
- mSelectedEvent = e;
- mSelectedEventForAccessibility = e;
+ private fun setSelectedEvent(e: Event?) {
+ mSelectedEvent = e
+ mSelectedEventForAccessibility = e
}
- private void setSelectedHour(int h) {
- mSelectionHour = h;
- mSelectionHourForAccessibility = h;
- }
- private void setSelectedDay(int d) {
- mSelectionDay = d;
- mSelectionDayForAccessibility = d;
+ private fun setSelectedHour(h: Int) {
+ mSelectionHour = h
+ mSelectionHourForAccessibility = h
}
/**
* Restart the update timer
*/
- public void restartCurrentTimeUpdates() {
- mPaused = false;
+ fun restartCurrentTimeUpdates() {
+ mPaused = false
if (mHandler != null) {
- mHandler.removeCallbacks(mUpdateCurrentTime);
- mHandler.post(mUpdateCurrentTime);
+ mHandler.removeCallbacks(mUpdateCurrentTime)
+ mHandler.post(mUpdateCurrentTime)
}
}
@Override
- protected void onDetachedFromWindow() {
- cleanup();
- super.onDetachedFromWindow();
+ protected fun onDetachedFromWindow() {
+ cleanup()
+ super.onDetachedFromWindow()
}
- class DismissPopup implements Runnable {
-
- public void run() {
+ internal inner class DismissPopup : Runnable {
+ fun run() {
// Protect against null-pointer exceptions
if (mPopup != null) {
- mPopup.dismiss();
+ mPopup.dismiss()
}
}
}
- class UpdateCurrentTime implements Runnable {
-
- public void run() {
- long currentTime = System.currentTimeMillis();
- mCurrentTime.set(currentTime);
+ internal inner class UpdateCurrentTime : Runnable {
+ fun run() {
+ val currentTime: Long = System.currentTimeMillis()
+ mCurrentTime.set(currentTime)
//% causes update to occur on 5 minute marks (11:10, 11:15, 11:20, etc.)
- if (!DayView.this.mPaused) {
- mHandler.postDelayed(mUpdateCurrentTime, UPDATE_CURRENT_TIME_DELAY
- - (currentTime % UPDATE_CURRENT_TIME_DELAY));
+ if (!mPaused) {
+ mHandler.postDelayed(
+ mUpdateCurrentTime, UPDATE_CURRENT_TIME_DELAY
+ - currentTime % UPDATE_CURRENT_TIME_DELAY
+ )
}
- mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime.gmtoff);
- invalidate();
+ mTodayJulianDay = Time.getJulianDay(currentTime, mCurrentTime.gmtoff)
+ invalidate()
}
}
- class CalendarGestureListener extends GestureDetector.SimpleOnGestureListener {
+ internal inner class CalendarGestureListener : GestureDetector.SimpleOnGestureListener() {
@Override
- public boolean onSingleTapUp(MotionEvent ev) {
- if (DEBUG) Log.e(TAG, "GestureDetector.onSingleTapUp");
- DayView.this.doSingleTapUp(ev);
- return true;
+ fun onSingleTapUp(ev: MotionEvent): Boolean {
+ if (DEBUG) Log.e(TAG, "GestureDetector.onSingleTapUp")
+ doSingleTapUp(ev)
+ return true
}
@Override
- public void onLongPress(MotionEvent ev) {
- if (DEBUG) Log.e(TAG, "GestureDetector.onLongPress");
- DayView.this.doLongPress(ev);
+ fun onLongPress(ev: MotionEvent) {
+ if (DEBUG) Log.e(TAG, "GestureDetector.onLongPress")
+ doLongPress(ev)
}
@Override
- public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
- if (DEBUG) Log.e(TAG, "GestureDetector.onScroll");
- eventClickCleanup();
+ fun onScroll(
+ e1: MotionEvent,
+ e2: MotionEvent,
+ distanceX: Float,
+ distanceY: Float
+ ): Boolean {
+ var distanceY = distanceY
+ if (DEBUG) Log.e(TAG, "GestureDetector.onScroll")
+ eventClickCleanup()
if (mTouchStartedInAlldayArea) {
if (Math.abs(distanceX) < Math.abs(distanceY)) {
// Make sure that click feedback is gone when you scroll from the
// all day area
- invalidate();
- return false;
+ invalidate()
+ return false
}
// don't scroll vertically if this started in the allday area
- distanceY = 0;
+ distanceY = 0f
}
- DayView.this.doScroll(e1, e2, distanceX, distanceY);
- return true;
+ doScroll(e1, e2, distanceX, distanceY)
+ return true
}
@Override
- public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
- if (DEBUG) Log.e(TAG, "GestureDetector.onFling");
-
+ fun onFling(e1: MotionEvent, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean {
+ var velocityY = velocityY
+ if (DEBUG) Log.e(TAG, "GestureDetector.onFling")
if (mTouchStartedInAlldayArea) {
if (Math.abs(velocityX) < Math.abs(velocityY)) {
- return false;
+ return false
}
// don't fling vertically if this started in the allday area
- velocityY = 0;
+ velocityY = 0f
}
- DayView.this.doFling(e1, e2, velocityX, velocityY);
- return true;
+ doFling(e1, e2, velocityX, velocityY)
+ return true
}
@Override
- public boolean onDown(MotionEvent ev) {
- if (DEBUG) Log.e(TAG, "GestureDetector.onDown");
- DayView.this.doDown(ev);
- return true;
+ fun onDown(ev: MotionEvent): Boolean {
+ if (DEBUG) Log.e(TAG, "GestureDetector.onDown")
+ doDown(ev)
+ return true
}
}
@Override
- public boolean onLongClick(View v) {
- return true;
+ fun onLongClick(v: View?): Boolean {
+ return true
}
- // The rest of this file was borrowed from Launcher2 - PagedView.java
- private static final int MINIMUM_SNAP_VELOCITY = 2200;
-
- private class ScrollInterpolator implements Interpolator {
- public ScrollInterpolator() {
- }
-
- public float getInterpolation(float t) {
- t -= 1.0f;
- t = t * t * t * t * t + 1;
-
+ private inner class ScrollInterpolator : Interpolator {
+ fun getInterpolation(t: Float): Float {
+ var t = t
+ t -= 1.0f
+ t = t * t * t * t * t + 1
if ((1 - t) * mAnimationDistance < 1) {
- cancelAnimation();
+ cancelAnimation()
}
-
- return t;
+ return t
}
}
- private long calculateDuration(float delta, float width, float velocity) {
+ private fun calculateDuration(delta: Float, width: Float, velocity: Float): Long {
/*
* Here we compute a "distance" that will be used in the computation of
* the overall snap duration. This is a function of the actual distance
@@ -3969,13 +3509,13 @@
* size in order to reduce the variance in snap duration as a function
* of the distance the page needs to travel.
*/
- final float halfScreenSize = width / 2;
- float distanceRatio = delta / width;
- float distanceInfluenceForSnapDuration = distanceInfluenceForSnapDuration(distanceRatio);
- float distance = halfScreenSize + halfScreenSize * distanceInfluenceForSnapDuration;
-
- velocity = Math.abs(velocity);
- velocity = Math.max(MINIMUM_SNAP_VELOCITY, velocity);
+ var velocity = velocity
+ val halfScreenSize = width / 2
+ val distanceRatio = delta / width
+ val distanceInfluenceForSnapDuration = distanceInfluenceForSnapDuration(distanceRatio)
+ val distance = halfScreenSize + halfScreenSize * distanceInfluenceForSnapDuration
+ velocity = Math.abs(velocity)
+ velocity = Math.max(MINIMUM_SNAP_VELOCITY, velocity)
/*
* we want the page's snap velocity to approximately match the velocity
@@ -3983,14 +3523,16 @@
* the derivative of the scroll interpolator at zero, ie. 5. We use 6 to
* make it a little slower.
*/
- long duration = 6 * Math.round(1000 * Math.abs(distance / velocity));
+ val duration: Long = 6 * Math.round(1000 * Math.abs(distance / velocity))
if (DEBUG) {
- Log.e(TAG, "halfScreenSize:" + halfScreenSize + " delta:" + delta + " distanceRatio:"
- + distanceRatio + " distance:" + distance + " velocity:" + velocity
- + " duration:" + duration + " distanceInfluenceForSnapDuration:"
- + distanceInfluenceForSnapDuration);
+ Log.e(
+ TAG, "halfScreenSize:" + halfScreenSize + " delta:" + delta + " distanceRatio:"
+ + distanceRatio + " distance:" + distance + " velocity:" + velocity
+ + " duration:" + duration + " distanceInfluenceForSnapDuration:"
+ + distanceInfluenceForSnapDuration
+ )
}
- return duration;
+ return duration
}
/*
@@ -4000,9 +3542,355 @@
* method to moderate the effect that the distance of travel has on the
* overall snap duration.
*/
- private float distanceInfluenceForSnapDuration(float f) {
- f -= 0.5f; // center the values about 0.
- f *= 0.3f * Math.PI / 2.0f;
- return (float) Math.sin(f);
+ private fun distanceInfluenceForSnapDuration(f: Float): Float {
+ var f = f
+ f -= 0.5f // center the values about 0.
+ f *= 0.3f * Math.PI / 2.0f
+ return Math.sin(f)
}
-}
+
+ companion object {
+ private const val TAG = "DayView"
+ private const val DEBUG = false
+ private const val DEBUG_SCALING = false
+ private const val PERIOD_SPACE = ". "
+ private var mScale = 0f // Used for supporting different screen densities
+ private const val INVALID_EVENT_ID: Long = -1 //This is used for remembering a null event
+
+ // Duration of the allday expansion
+ private const val ANIMATION_DURATION: Long = 400
+
+ // duration of the more allday event text fade
+ private const val ANIMATION_SECONDARY_DURATION: Long = 200
+
+ // duration of the scroll to go to a specified time
+ private const val GOTO_SCROLL_DURATION = 200
+
+ // duration for events' cross-fade animation
+ private const val EVENTS_CROSS_FADE_DURATION = 400
+
+ // duration to show the event clicked
+ private const val CLICK_DISPLAY_DURATION = 50
+ private const val MENU_DAY = 3
+ private const val MENU_EVENT_VIEW = 5
+ private const val MENU_EVENT_CREATE = 6
+ private const val MENU_EVENT_EDIT = 7
+ private const val MENU_EVENT_DELETE = 8
+ private var DEFAULT_CELL_HEIGHT = 64
+ private var MAX_CELL_HEIGHT = 150
+ private var MIN_Y_SPAN = 100
+ private val CALENDARS_PROJECTION = arrayOf<String>(
+ Calendars._ID, // 0
+ Calendars.CALENDAR_ACCESS_LEVEL, // 1
+ Calendars.OWNER_ACCOUNT
+ )
+ private const val CALENDARS_INDEX_ACCESS_LEVEL = 1
+ private const val CALENDARS_INDEX_OWNER_ACCOUNT = 2
+ private val CALENDARS_WHERE: String = Calendars._ID.toString() + "=%d"
+ private const val FROM_NONE = 0
+ private const val FROM_ABOVE = 1
+ private const val FROM_BELOW = 2
+ private const val FROM_LEFT = 4
+ private const val FROM_RIGHT = 8
+ private const val ACCESS_LEVEL_NONE = 0
+ private const val ACCESS_LEVEL_DELETE = 1
+ private const val ACCESS_LEVEL_EDIT = 2
+ private var mHorizontalSnapBackThreshold = 128
+
+ //Update the current time line every five minutes if the window is left open that long
+ private const val UPDATE_CURRENT_TIME_DELAY = 300000
+ private var mOnDownDelay: Int
+ protected var mStringBuilder: StringBuilder = StringBuilder(50)
+
+ // TODO recreate formatter when locale changes
+ protected var mFormatter: Formatter = Formatter(mStringBuilder, Locale.getDefault())
+
+ // The number of milliseconds to show the popup window
+ private const val POPUP_DISMISS_DELAY = 3000
+ private var GRID_LINE_LEFT_MARGIN = 0f
+ private const val GRID_LINE_INNER_WIDTH = 1f
+ private const val DAY_GAP = 1
+ private const val HOUR_GAP = 1
+
+ // This is the standard height of an allday event with no restrictions
+ private var SINGLE_ALLDAY_HEIGHT = 34
+
+ /**
+ * This is the minimum desired height of a allday event.
+ * When unexpanded, allday events will use this height.
+ * When expanded allDay events will attempt to grow to fit all
+ * events at this height.
+ */
+ private var MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = 28.0f // in pixels
+
+ /**
+ * This is how big the unexpanded allday height is allowed to be.
+ * It will get adjusted based on screen size
+ */
+ private var MAX_UNEXPANDED_ALLDAY_HEIGHT = (MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT * 4).toInt()
+
+ /**
+ * This is the minimum size reserved for displaying regular events.
+ * The expanded allDay region can't expand into this.
+ */
+ private const val MIN_HOURS_HEIGHT = 180
+ private var ALLDAY_TOP_MARGIN = 1
+
+ // The largest a single allDay event will become.
+ private var MAX_HEIGHT_OF_ONE_ALLDAY_EVENT = 34
+ private var HOURS_TOP_MARGIN = 2
+ private var HOURS_LEFT_MARGIN = 2
+ private var HOURS_RIGHT_MARGIN = 4
+ private var HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN
+ private var NEW_EVENT_MARGIN = 4
+ private var NEW_EVENT_WIDTH = 2
+ private var NEW_EVENT_MAX_LENGTH = 16
+ private var CURRENT_TIME_LINE_SIDE_BUFFER = 4
+ private var CURRENT_TIME_LINE_TOP_OFFSET = 2
+
+ /* package */
+ const val MINUTES_PER_HOUR = 60
+
+ /* package */
+ const val MINUTES_PER_DAY = MINUTES_PER_HOUR * 24
+
+ /* package */
+ const val MILLIS_PER_MINUTE = 60 * 1000
+
+ /* package */
+ const val MILLIS_PER_HOUR = 3600 * 1000
+
+ /* package */
+ const val MILLIS_PER_DAY = MILLIS_PER_HOUR * 24
+
+ // More events text will transition between invisible and this alpha
+ private const val MORE_EVENTS_MAX_ALPHA = 0x4C
+ private var DAY_HEADER_ONE_DAY_LEFT_MARGIN = 0
+ private var DAY_HEADER_ONE_DAY_RIGHT_MARGIN = 5
+ private var DAY_HEADER_ONE_DAY_BOTTOM_MARGIN = 6
+ private var DAY_HEADER_RIGHT_MARGIN = 4
+ private var DAY_HEADER_BOTTOM_MARGIN = 3
+ private var DAY_HEADER_FONT_SIZE = 14f
+ private var DATE_HEADER_FONT_SIZE = 32f
+ private var NORMAL_FONT_SIZE = 12f
+ private var EVENT_TEXT_FONT_SIZE = 12f
+ private var HOURS_TEXT_SIZE = 12f
+ private var AMPM_TEXT_SIZE = 9f
+ private var MIN_HOURS_WIDTH = 96
+ private var MIN_CELL_WIDTH_FOR_TEXT = 20
+ private const val MAX_EVENT_TEXT_LEN = 500
+
+ // smallest height to draw an event with
+ private var MIN_EVENT_HEIGHT = 24.0f // in pixels
+ private var CALENDAR_COLOR_SQUARE_SIZE = 10
+ private var EVENT_RECT_TOP_MARGIN = 1
+ private var EVENT_RECT_BOTTOM_MARGIN = 0
+ private var EVENT_RECT_LEFT_MARGIN = 1
+ private var EVENT_RECT_RIGHT_MARGIN = 0
+ private var EVENT_RECT_STROKE_WIDTH = 2
+ private var EVENT_TEXT_TOP_MARGIN = 2
+ private var EVENT_TEXT_BOTTOM_MARGIN = 2
+ private var EVENT_TEXT_LEFT_MARGIN = 6
+ private var EVENT_TEXT_RIGHT_MARGIN = 6
+ private var ALL_DAY_EVENT_RECT_BOTTOM_MARGIN = 1
+ private var EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN
+ private var EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_BOTTOM_MARGIN
+ private var EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN
+ private var EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_RIGHT_MARGIN
+
+ // margins and sizing for the expand allday icon
+ private var EXPAND_ALL_DAY_BOTTOM_MARGIN = 10
+
+ // sizing for "box +n" in allDay events
+ private var EVENT_SQUARE_WIDTH = 10
+ private var EVENT_LINE_PADDING = 4
+ private var NEW_EVENT_HINT_FONT_SIZE = 12
+ private var mEventTextColor = 0
+ private var mMoreEventsTextColor = 0
+ private var mWeek_saturdayColor = 0
+ private var mWeek_sundayColor = 0
+ private var mCalendarDateBannerTextColor = 0
+ private var mCalendarAmPmLabel = 0
+ private var mCalendarGridAreaSelected = 0
+ private var mCalendarGridLineInnerHorizontalColor = 0
+ private var mCalendarGridLineInnerVerticalColor = 0
+ private var mFutureBgColor = 0
+ private var mFutureBgColorRes = 0
+ private var mBgColor = 0
+ private var mNewEventHintColor: Int
+ private var mCalendarHourLabelColor = 0
+ private var mMoreAlldayEventsTextAlpha = MORE_EVENTS_MAX_ALPHA
+ private var mCellHeight = 0 // shared among all DayViews
+ private var mMinCellHeight = 32
+ private var mScaledPagingTouchSlop = 0
+
+ /**
+ * Whether to use the expand or collapse icon.
+ */
+ private var mUseExpandIcon = true
+
+ /**
+ * The height of the day names/numbers
+ */
+ private var DAY_HEADER_HEIGHT = 45
+
+ /**
+ * The height of the day names/numbers for multi-day views
+ */
+ private var MULTI_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT
+
+ /**
+ * The height of the day names/numbers when viewing a single day
+ */
+ private var ONE_DAY_HEADER_HEIGHT = DAY_HEADER_HEIGHT
+
+ /**
+ * Whether or not to expand the allDay area to fill the screen
+ */
+ private var mShowAllAllDayEvents = false
+ private var sCounter = 0
+
+ /**
+ * The initial state of the touch mode when we enter this view.
+ */
+ private const val TOUCH_MODE_INITIAL_STATE = 0
+
+ /**
+ * Indicates we just received the touch event and we are waiting to see if
+ * it is a tap or a scroll gesture.
+ */
+ private const val TOUCH_MODE_DOWN = 1
+
+ /**
+ * Indicates the touch gesture is a vertical scroll
+ */
+ private const val TOUCH_MODE_VSCROLL = 0x20
+
+ /**
+ * Indicates the touch gesture is a horizontal scroll
+ */
+ private const val TOUCH_MODE_HSCROLL = 0x40
+
+ /**
+ * The selection modes are HIDDEN, PRESSED, SELECTED, and LONGPRESS.
+ */
+ private const val SELECTION_HIDDEN = 0
+ private const val SELECTION_PRESSED = 1 // D-pad down but not up yet
+ private const val SELECTION_SELECTED = 2
+ private const val SELECTION_LONGPRESS = 3
+
+ // The rest of this file was borrowed from Launcher2 - PagedView.java
+ private const val MINIMUM_SNAP_VELOCITY = 2200
+ }
+
+ init {
+ mContext = context
+ initAccessibilityVariables()
+ mResources = context.getResources()
+ mNewEventHintString = mResources.getString(R.string.day_view_new_event_hint)
+ mNumDays = numDays
+ DATE_HEADER_FONT_SIZE =
+ mResources.getDimension(R.dimen.date_header_text_size) as Int.toFloat()
+ DAY_HEADER_FONT_SIZE = mResources.getDimension(R.dimen.day_label_text_size) as Int.toFloat()
+ ONE_DAY_HEADER_HEIGHT = mResources.getDimension(R.dimen.one_day_header_height)
+ DAY_HEADER_BOTTOM_MARGIN = mResources.getDimension(R.dimen.day_header_bottom_margin)
+ EXPAND_ALL_DAY_BOTTOM_MARGIN = mResources.getDimension(R.dimen.all_day_bottom_margin)
+ HOURS_TEXT_SIZE = mResources.getDimension(R.dimen.hours_text_size) as Int.toFloat()
+ AMPM_TEXT_SIZE = mResources.getDimension(R.dimen.ampm_text_size) as Int.toFloat()
+ MIN_HOURS_WIDTH = mResources.getDimension(R.dimen.min_hours_width)
+ HOURS_LEFT_MARGIN = mResources.getDimension(R.dimen.hours_left_margin)
+ HOURS_RIGHT_MARGIN = mResources.getDimension(R.dimen.hours_right_margin)
+ MULTI_DAY_HEADER_HEIGHT = mResources.getDimension(R.dimen.day_header_height)
+ val eventTextSizeId: Int
+ eventTextSizeId = if (mNumDays == 1) {
+ R.dimen.day_view_event_text_size
+ } else {
+ R.dimen.week_view_event_text_size
+ }
+ EVENT_TEXT_FONT_SIZE = mResources.getDimension(eventTextSizeId) as Int.toFloat()
+ NEW_EVENT_HINT_FONT_SIZE = mResources.getDimension(R.dimen.new_event_hint_text_size)
+ MIN_EVENT_HEIGHT = mResources.getDimension(R.dimen.event_min_height)
+ MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT = MIN_EVENT_HEIGHT
+ EVENT_TEXT_TOP_MARGIN = mResources.getDimension(R.dimen.event_text_vertical_margin)
+ EVENT_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN
+ EVENT_ALL_DAY_TEXT_TOP_MARGIN = EVENT_TEXT_TOP_MARGIN
+ EVENT_ALL_DAY_TEXT_BOTTOM_MARGIN = EVENT_TEXT_TOP_MARGIN
+ EVENT_TEXT_LEFT_MARGIN = mResources
+ .getDimension(R.dimen.event_text_horizontal_margin)
+ EVENT_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN
+ EVENT_ALL_DAY_TEXT_LEFT_MARGIN = EVENT_TEXT_LEFT_MARGIN
+ EVENT_ALL_DAY_TEXT_RIGHT_MARGIN = EVENT_TEXT_LEFT_MARGIN
+ if (mScale == 0f) {
+ mScale = mResources.getDisplayMetrics().density
+ if (mScale != 1f) {
+ SINGLE_ALLDAY_HEIGHT *= mScale.toInt()
+ ALLDAY_TOP_MARGIN *= mScale.toInt()
+ MAX_HEIGHT_OF_ONE_ALLDAY_EVENT *= mScale.toInt()
+ NORMAL_FONT_SIZE *= mScale
+ GRID_LINE_LEFT_MARGIN *= mScale
+ HOURS_TOP_MARGIN *= mScale.toInt()
+ MIN_CELL_WIDTH_FOR_TEXT *= mScale.toInt()
+ MAX_UNEXPANDED_ALLDAY_HEIGHT *= mScale.toInt()
+ mAnimateDayEventHeight = MIN_UNEXPANDED_ALLDAY_EVENT_HEIGHT.toInt()
+ CURRENT_TIME_LINE_SIDE_BUFFER *= mScale.toInt()
+ CURRENT_TIME_LINE_TOP_OFFSET *= mScale.toInt()
+ MIN_Y_SPAN *= mScale.toInt()
+ MAX_CELL_HEIGHT *= mScale.toInt()
+ DEFAULT_CELL_HEIGHT *= mScale.toInt()
+ DAY_HEADER_HEIGHT *= mScale.toInt()
+ DAY_HEADER_RIGHT_MARGIN *= mScale.toInt()
+ DAY_HEADER_ONE_DAY_LEFT_MARGIN *= mScale.toInt()
+ DAY_HEADER_ONE_DAY_RIGHT_MARGIN *= mScale.toInt()
+ DAY_HEADER_ONE_DAY_BOTTOM_MARGIN *= mScale.toInt()
+ CALENDAR_COLOR_SQUARE_SIZE *= mScale.toInt()
+ EVENT_RECT_TOP_MARGIN *= mScale.toInt()
+ EVENT_RECT_BOTTOM_MARGIN *= mScale.toInt()
+ ALL_DAY_EVENT_RECT_BOTTOM_MARGIN *= mScale.toInt()
+ EVENT_RECT_LEFT_MARGIN *= mScale.toInt()
+ EVENT_RECT_RIGHT_MARGIN *= mScale.toInt()
+ EVENT_RECT_STROKE_WIDTH *= mScale.toInt()
+ EVENT_SQUARE_WIDTH *= mScale.toInt()
+ EVENT_LINE_PADDING *= mScale.toInt()
+ NEW_EVENT_MARGIN *= mScale.toInt()
+ NEW_EVENT_WIDTH *= mScale.toInt()
+ NEW_EVENT_MAX_LENGTH *= mScale.toInt()
+ }
+ }
+ HOURS_MARGIN = HOURS_LEFT_MARGIN + HOURS_RIGHT_MARGIN
+ DAY_HEADER_HEIGHT = if (mNumDays == 1) ONE_DAY_HEADER_HEIGHT else MULTI_DAY_HEADER_HEIGHT
+ mCurrentTimeLine = mResources.getDrawable(R.drawable.timeline_indicator_holo_light)
+ mCurrentTimeAnimateLine = mResources
+ .getDrawable(R.drawable.timeline_indicator_activated_holo_light)
+ mTodayHeaderDrawable = mResources.getDrawable(R.drawable.today_blue_week_holo_light)
+ mExpandAlldayDrawable = mResources.getDrawable(R.drawable.ic_expand_holo_light)
+ mCollapseAlldayDrawable = mResources.getDrawable(R.drawable.ic_collapse_holo_light)
+ mNewEventHintColor = mResources.getColor(R.color.new_event_hint_text_color)
+ mAcceptedOrTentativeEventBoxDrawable = mResources
+ .getDrawable(R.drawable.panel_month_event_holo_light)
+ mEventLoader = eventLoader
+ mEventGeometry = EventGeometry()
+ mEventGeometry.setMinEventHeight(MIN_EVENT_HEIGHT)
+ mEventGeometry.setHourGap(HOUR_GAP)
+ mEventGeometry.setCellMargin(DAY_GAP)
+ mLastPopupEventID = INVALID_EVENT_ID
+ mController = controller
+ mViewSwitcher = viewSwitcher
+ mGestureDetector = GestureDetector(context, CalendarGestureListener())
+ mScaleGestureDetector = ScaleGestureDetector(getContext(), this)
+ if (mCellHeight == 0) {
+ mCellHeight = Utils.getSharedPreference(
+ mContext,
+ GeneralPreferences.KEY_DEFAULT_CELL_HEIGHT, DEFAULT_CELL_HEIGHT
+ )
+ }
+ mScroller = OverScroller(context)
+ mHScrollInterpolator = ScrollInterpolator()
+ mEdgeEffectTop = EdgeEffect(context)
+ mEdgeEffectBottom = EdgeEffect(context)
+ val vc: ViewConfiguration = ViewConfiguration.get(context)
+ mScaledPagingTouchSlop = vc.getScaledPagingTouchSlop()
+ mOnDownDelay = ViewConfiguration.getTapTimeout()
+ OVERFLING_DISTANCE = vc.getScaledOverflingDistance()
+ init(context)
+ }
+}
\ No newline at end of file
