Esempio n. 1
0
        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
        {
            var stopwatch = new Stopwatch();

            stopwatch.Start();

            int totalWidth = MeasureSpec.GetSize(widthMeasureSpec);

            _cellSize = totalWidth / 7;
            int heightSize     = (int)Math.Round(35 * Resources.DisplayMetrics.Density);
            int cellWidthSpec  = MeasureSpec.MakeMeasureSpec(_cellSize, MeasureSpecMode.Exactly);
            int cellHeightSpec = IsHeaderRow
                ? MeasureSpec.MakeMeasureSpec(heightSize, MeasureSpecMode.AtMost)
                : MeasureSpec.MakeMeasureSpec(heightSize, MeasureSpecMode.Exactly);
            int rowHeight = 0;

            for (int c = 0; c < ChildCount; c++)
            {
                var child = GetChildAt(c);
                child.Measure(cellWidthSpec, cellHeightSpec);
                //The row height is the height of the tallest cell.
                if (child.MeasuredHeight > rowHeight)
                {
                    rowHeight = child.MeasuredHeight;
                }
            }
            int widthWithPadding  = totalWidth + PaddingLeft + PaddingRight;
            int heightWithPadding = rowHeight + PaddingTop + PaddingBottom;

            SetMeasuredDimension(widthWithPadding, heightWithPadding);

            stopwatch.Stop();
            Logr.D("Row.OnMeasure {0} ms", stopwatch.ElapsedMilliseconds);
        }
Esempio n. 2
0
        internal List <List <MonthCellDescriptor> > GetMonthCells(MonthDescriptor month, DateTime startCal)
        {
            var cells          = new List <List <MonthCellDescriptor> >();
            var cal            = new DateTime(startCal.Year, startCal.Month, 1);
            var firstDayOfWeek = (int)cal.DayOfWeek;

            cal = cal.AddDays((int)CultureInfo.CurrentCulture.DateTimeFormat.FirstDayOfWeek - firstDayOfWeek);

            var minSelectedCal = GetMinDate(SelectedCals);
            var maxSelectedCal = GetMaxDate(SelectedCals);

            while ((cal.Month < month.Month + 1 || cal.Year < month.Year) &&
                   cal.Year <= month.Year)
            {
                Logr.D("Building week row starting at {0}", cal);
                var weekCells = new List <MonthCellDescriptor>();
                cells.Add(weekCells);
                for (int i = 0; i < 7; i++)
                {
                    var  date           = cal;
                    bool isCurrentMonth = cal.Month == month.Month;
                    bool isSelected     = isCurrentMonth && ContatinsDate(SelectedCals, cal);
                    bool isSelectable   = isCurrentMonth && IsBetweenDates(cal, MinDate, MaxDate);
                    bool isToday        = IsSameDate(cal, Today);
                    bool isHighlighted  = ContatinsDate(_highlightedCals, cal);
                    bool isFuture       = IsAfter(cal, Today);
                    bool isWeekend      = cal.DayOfWeek == DayOfWeek.Saturday || cal.DayOfWeek == DayOfWeek.Sunday;
                    int  value          = cal.Day;

                    var rangeState = RangeState.None;
                    if (SelectedCals.Count > 1)
                    {
                        if (IsSameDate(minSelectedCal, cal))
                        {
                            rangeState = RangeState.First;
                        }
                        else if (IsSameDate(maxSelectedCal, cal))
                        {
                            rangeState = RangeState.Last;
                        }
                        else if (IsBetweenDates(cal, minSelectedCal, maxSelectedCal))
                        {
                            rangeState = RangeState.Middle;
                        }
                    }

                    weekCells.Add(new MonthCellDescriptor(date, isCurrentMonth, isSelectable, isSelected,
                                                          isToday, isHighlighted, isFuture, isWeekend, value, rangeState));
                    cal = cal.AddDays(1);
                }
            }
            return(cells);
        }
Esempio n. 3
0
        public FluentInitializer Init(DateTime minDate, DateTime maxDate)
        {
            if (minDate == DateTime.MinValue || maxDate == DateTime.MinValue)
            {
                throw new IllegalArgumentException("minDate and maxDate must be non-zero. " +
                                                   Debug(minDate, maxDate));
            }
            if (minDate.CompareTo(maxDate) > 0)
            {
                throw new IllegalArgumentException("minDate must be before maxDate. " +
                                                   Debug(minDate, maxDate));
            }

            Mode = SelectionMode.Single;
            //Clear out any previously selected dates/cells.
            SelectedCals.Clear();
            SelectedCells.Clear();
            _highlightedCals.Clear();
            _highlightedCells.Clear();

            //Clear previous state.
            Cells.Clear();
            Months.Clear();
            MinDate = minDate;
            MaxDate = maxDate;
            MinDate = SetMidnight(MinDate);
            MaxDate = SetMidnight(MaxDate);

            // maxDate is exclusive: bump back to the previous day so if maxDate is the first of a month,
            // We don't accidentally include that month in the view.
            MaxDate = MaxDate.AddMinutes(-1);

            //Now iterate between minCal and maxCal and build up our list of months to show.
            _monthCounter = MinDate;
            int maxMonth = MaxDate.Month;
            int maxYear  = MaxDate.Year;

            while ((_monthCounter.Month <= maxMonth ||
                    _monthCounter.Year < maxYear) &&
                   _monthCounter.Year < maxYear + 1)
            {
                var month = new MonthDescriptor(_monthCounter.Month, _monthCounter.Year, _monthCounter,
                                                _monthCounter.ToString(MonthNameFormat));
                Cells.Add(GetMonthCells(month, _monthCounter));
                Logr.D("Adding month {0}", month);
                Months.Add(month);
                _monthCounter = _monthCounter.AddMonths(1);
            }

            ValidateAndUpdate();
            return(new FluentInitializer(this));
        }
Esempio n. 4
0
        protected override void OnLayout(bool changed, int l, int t, int r, int b)
        {
            var stopwatch = Stopwatch.StartNew();

            t = 0;
            for (int c = 0; c < ChildCount; c++)
            {
                var child     = GetChildAt(c);
                int rowHeight = child.MeasuredHeight;
                child.Layout(l, t, r, t + rowHeight);
                t += rowHeight;
            }

            stopwatch.Stop();
            Logr.D("Grid.OnLayout {0} ms", stopwatch.ElapsedMilliseconds);
        }
Esempio n. 5
0
        public void Init(MonthDescriptor month, List <List <MonthCellDescriptor> > cells, int Language)
        {
            Logr.D("Initializing MonthView ({0:d}) for {1}", GetHashCode(), month);
            var stopWatch = new Stopwatch();

            stopWatch.Start();


            //  _title.Text = month.Label;

            _title.Text = GetMonthTitle(month, Language);

            int numOfRows = cells.Count;

            _grid.NumRows = numOfRows;
            for (int i = 0; i < 6; i++)
            {
                var weekRow = (CalendarRowView)_grid.GetChildAt(i + 1);
                weekRow.ClickHandler = _clickHandler;
                if (i < numOfRows)
                {
                    weekRow.Visibility = ViewStates.Visible;
                    var week = cells[i];
                    for (int c = 0; c < week.Count; c++)
                    {
                        var cell     = week[c];
                        var cellView = (CalendarCellView)weekRow.GetChildAt(c);
                        cellView.Text    = cell.Value.ToString();
                        cellView.Enabled = cell.IsCurrentMonth;

                        cellView.Selectable     = cell.IsSelectable;
                        cellView.Selected       = cell.IsSelected;
                        cellView.IsCurrentMonth = cell.IsCurrentMonth;
                        cellView.IsToday        = cell.IsToday;
                        cellView.IsHighlighted  = cell.IsHighlighted;
                        cellView.RangeState     = cell.RangeState;
                        cellView.Tag            = cell;
                    }
                }
                else
                {
                    weekRow.Visibility = ViewStates.Gone;
                }
            }
            stopWatch.Stop();
            Logr.D("MonthView.Init took {0} ms", stopWatch.ElapsedMilliseconds);
        }
Esempio n. 6
0
        protected override void OnLayout(bool changed, int l, int t, int r, int b)
        {
            var stopwatch = new Stopwatch();

            stopwatch.Start();

            int cellHeight = b - t;

            for (int c = 0; c < ChildCount; c++)
            {
                var child = GetChildAt(c);
                child.Layout(c * _cellSize, 0, (c + 1) * _cellSize, cellHeight);
            }

            stopwatch.Stop();
            Logr.D("Row.OnLayout {0} ms", stopwatch.ElapsedMilliseconds);
        }
Esempio n. 7
0
        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
        {
            Logr.D("Grid.OnMeasure w={0} h={1}", MeasureSpec.ToString(widthMeasureSpec),
                   MeasureSpec.ToString(heightMeasureSpec));

            int widthMeasureSize = MeasureSpec.GetSize(widthMeasureSpec);

            if (_oldWidthMeasureSize == widthMeasureSize)
            {
                Logr.D("SKIP Grid.OnMeasure");
                SetMeasuredDimension(MeasuredWidth, MeasuredHeight);
                return;
            }

            var stopwatch = Stopwatch.StartNew();

            _oldWidthMeasureSize = widthMeasureSize;
            int cellSize = widthMeasureSize / 7;

            //Remove any extra pixels since /7 us unlikey to give whole nums.
            widthMeasureSize = cellSize * 7;
            int heightSize    = (int)Math.Round(40 * (Context.Resources.DisplayMetrics.Ydpi / (int)DisplayMetricsDensity.Default));
            int totalHeight   = 0;
            int rowWidthSpec  = MeasureSpec.MakeMeasureSpec(widthMeasureSize, MeasureSpecMode.Exactly);
            int rowHeightSpec = MeasureSpec.MakeMeasureSpec(heightSize, MeasureSpecMode.Exactly);

            for (int c = 0; c < ChildCount; c++)
            {
                var child = GetChildAt(c);
                if (child.Visibility == ViewStates.Visible)
                {
                    MeasureChild(child, rowWidthSpec,
                                 c == 0 ? MeasureSpec.MakeMeasureSpec(heightSize, MeasureSpecMode.AtMost) : rowHeightSpec);
                    totalHeight += child.MeasuredHeight;
                }
            }
            int measuredWidth = widthMeasureSize + 2; // Fudge factor to make the borders show up right.

            SetMeasuredDimension(measuredWidth, totalHeight);

            stopwatch.Stop();
            Logr.D("Grid.OnMeasure {0} ms", stopwatch.ElapsedMilliseconds);
        }