Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
c9f4c33ba17d1dd84b0464160c02c77ed276c6e9
SourceCode/PROMS/DotNetBar Source Code/DevComponents.DotNetBar.Schedule/WeekView/WeekDayView.cs

4461 lines
133 KiB
C#
Raw Blame History

#if FRAMEWORK20
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using DevComponents.Schedule.Model;
namespace DevComponents.DotNetBar.Schedule
{
public class WeekDayView : BaseView
{
#region Constants
private const int HoursPerDay = 24;
private const int MinutesPerHour = 60;
private const int MaxNumberOfColumns = 3 * 31;
#endregion
#region Private variables
private AllDayPanel _AllDayPanel; // AllDay items panel
private DayColumn[] _DayColumns; // Array of DayColumns
private int _NumberOfColumns; // Number of DayColumns
private Size[] _DayColumnSize; // Array of day text sizes
private CalendarWeekDayColor _ViewColor = // View display color table
new CalendarWeekDayColor(eCalendarColor.Automatic);
private int _LastCol; // Last processed column
private Point _LastMovePoint; // Last mouse move Point
private Point _LastPointOffset; // Last Point offset
private Rectangle _LastBounds; // MouseDown item bounds
int _LastMoveCol;
int _LastDm;
private bool _IsPanelResizing; // Flag denoting panel resizing
private bool _WasAllDayItem;
private int _SelectedSliceStart; // Absolute slice start
private int _SelectedSliceEnd; // Absolute slice end (e.g. 450 - 1440)
private Timer _ScrollViewTimer; // Timer used to implement auto view scrolling
private int _VScrollPos; // Vertical scroll bar pos
private Color _BusyColor; // Cached brush colors
private Color _WorkColor;
private Color _OffWorkColor;
private Color _SelectedColor;
private Brush _BusyBrush; // Cached brushes
private Brush _WorkBrush;
private Brush _OffWorkBrush;
private Brush _SelectedBrush;
private Brush _AllDayBrush;
private Color _AllDayColor;
private int _LocalStartSlice;
private int _LocalNumberOfSlices;
#endregion
/// <summary>
/// Constructor
/// </summary>
/// <param name="calendarView">CalendarView</param>
/// <param name="eCalendarView"></param>
public WeekDayView(CalendarView calendarView, eCalendarView eCalendarView)
: base(calendarView, eCalendarView)
{
// Allocate our AllDayPanel
_AllDayPanel = new AllDayPanel(this);
_AllDayPanel.Displayed = true;
// Set our non-client drawing info and CalendarColor
NClientData = new NonClientData(
eTabOrientation.Horizontal,
(int)eCalendarWeekDayPart.OwnerTabBorder,
(int)eCalendarWeekDayPart.OwnerTabForeground,
(int)eCalendarWeekDayPart.OwnerTabBackground,
(int)eCalendarWeekDayPart.OwnerTabContentBackground,
(int)eCalendarWeekDayPart.OwnerTabSelectedForeground,
(int)eCalendarWeekDayPart.OwnerTabSelectedBackground);
CalendarColorTable = _ViewColor;
// Hook onto our events
HookEvents(true);
}
#region Public properties
#region DayColumns
/// <summary>
/// Gets the view DayColumns
/// </summary>
public DayColumn[] DayColumns
{
get { return (_DayColumns); }
}
#endregion
#region NumberOfColumns
/// <summary>
/// Gets the view's number of DayColumns
/// </summary>
public int NumberOfColumns
{
get { return (_NumberOfColumns); }
}
#endregion
#region VScrollBar
/// <summary>
/// Gets the WeekDay vertical scrollbar
/// </summary>
public VScrollBarAdv VScrollBar
{
get { return (CalendarView.WeekDayVScrollBar ); }
}
#endregion
#endregion
#region Internal properties
#region Base calendar properties
/// <summary>
/// Gets the Sub-Day view rectangle
/// </summary>
internal Rectangle ViewRect
{
get
{
Rectangle r = ClientRect;
int n = DayOfWeekHeaderHeight + _AllDayPanel.PanelHeight;
r.Y += n;
r.Height -= (n + 1);
return (r);
}
}
/// <summary>
/// Gets the CalendarColor
/// </summary>
internal CalendarWeekDayColor WeekDayColor
{
get { return (_ViewColor); }
}
#endregion
#region DayColumn properties
/// <summary>
/// Gets the local StartSlice
/// </summary>
internal int LocalStartSlice
{
get { return (_LocalStartSlice); }
}
/// <summary>
/// Gets the local NumberOfSlices
/// </summary>
internal int LocalNumberOfSlices
{
get { return (_LocalNumberOfSlices); }
}
#endregion
#region AllDayPanel properties
/// <summary>
/// Gets the view's AllDayPanel
/// </summary>
internal AllDayPanel AllDayPanel
{
get { return (_AllDayPanel); }
}
#endregion
#endregion
#region Private properties
#region DayColumnWidth
/// <summary>
/// Gets the DayColumnWidth
/// </summary>
private float DayColumnWidth
{
get { return (((float)ClientRect.Width - 1) / _NumberOfColumns); }
}
#endregion
#region AllDay Panel properties
/// <summary>
/// Gets the maximum AllDayPanel height
/// </summary>
private int MaximumAllDayPanelHeight
{
get { return (CalendarView.MaximumAllDayPanelHeight); }
}
#endregion
#region Time Slice properties
/// <summary>
/// Gets the TimeSlotDuration
/// </summary>
private int TimeSlotDuration
{
get { return (CalendarView.TimeSlotDuration); }
}
/// <summary>
/// Gets the default Time Slice height
/// </summary>
private float TimeSliceHeight
{
get { return (CalendarView.TimeSliceHeight); }
set { CalendarView.TimeSliceHeight = value; }
}
/// <summary>
/// Gets the SlotsPerHour
/// </summary>
private int SlotsPerHour
{
get { return (CalendarView.SlotsPerHour); }
}
/// <summary>
/// Gets the NumberOfSlices
/// </summary>
private int NumberOfSlices
{
get { return (CalendarView.NumberOfSlices); }
set { CalendarView.NumberOfSlices = value; }
}
/// <summary>
/// Gets the NumberOfActiveSlices
/// </summary>
private int NumberOfActiveSlices
{
get { return (CalendarView.NumberOfActiveSlices); }
}
/// <summary>
/// Gets the StartSlice
/// </summary>
private int StartSlice
{
get { return (CalendarView.StartSlice); }
set { CalendarView.StartSlice = value; }
}
#endregion
#region BusyBrush
/// <summary>
/// Gets and sets the Busy time brush
/// </summary>
private Brush BusyBrush
{
get
{
Color color = _ViewColor.GetColor(
(int)eCalendarWeekDayPart.DayAllDayEventBackground);
if (_BusyColor != color)
{
_BusyColor = color;
BusyBrush = new SolidBrush(color);
}
return (_BusyBrush);
}
set
{
if (_BusyBrush != value)
{
if (_BusyBrush != null)
_BusyBrush.Dispose();
_BusyBrush = value;
}
}
}
#endregion
#region WorkBrush
/// <summary>
/// Gets and sets the Work time brush
/// </summary>
private Brush WorkBrush
{
get
{
Color color = _ViewColor.GetColor(
(int)eCalendarWeekDayPart.DayWorkHoursBackground);
if (_WorkColor != color)
{
_WorkColor = color;
WorkBrush = new SolidBrush(color);
}
return (_WorkBrush);
}
set
{
if (_WorkBrush != value)
{
if (_WorkBrush != null)
_WorkBrush.Dispose();
_WorkBrush = value;
}
}
}
#endregion
#region OffWorkBrush
/// <summary>
/// Gets and sets the Off-hours work time brush
/// </summary>
private Brush OffWorkBrush
{
get
{
Color color = _ViewColor.GetColor(
(int)eCalendarWeekDayPart.DayOffWorkHoursBackground);
if (_OffWorkColor != color)
{
_OffWorkColor = color;
OffWorkBrush = new SolidBrush(color);
}
return (_OffWorkBrush);
}
set
{
if (_OffWorkBrush != value)
{
if (_OffWorkBrush != null)
_OffWorkBrush.Dispose();
_OffWorkBrush = value;
}
}
}
#endregion
#region AllDayBrush
/// <summary>
/// Gets and sets the Off-hours work time brush
/// </summary>
private Brush AllDayBrush
{
get
{
Color color = _ViewColor.GetColor(
(int)eCalendarWeekDayPart.DayAllDayEventBackground);
if (_AllDayColor != color)
{
_AllDayColor = color;
AllDayBrush = new SolidBrush(color);
}
return (_AllDayBrush);
}
set
{
if (_AllDayBrush != value)
{
if (_AllDayBrush != null)
_AllDayBrush.Dispose();
_AllDayBrush = value;
}
}
}
#endregion
#region SelectedBrush
/// <summary>
/// Gets and sets the selected brush
/// </summary>
private Brush SelectedBrush
{
get
{
Color color = _ViewColor.GetColor(
(int)eCalendarWeekDayPart.SelectionBackground);
if (_SelectedColor != color)
{
_SelectedColor = color;
SelectedBrush = new SolidBrush(color);
}
return (_SelectedBrush);
}
set
{
if (_SelectedBrush != value)
{
if (_SelectedBrush != null)
_SelectedBrush.Dispose();
_SelectedBrush = value;
}
}
}
#endregion
#region FirstOnScreenSlice
private int FirstOnScreenSlice
{
get { return ((int)(-_VScrollPos / TimeSliceHeight)); }
}
#endregion
#region LastOnScreenSlice
private int LastOnScreenSlice
{
get { return (FirstOnScreenSlice + OnScreenSlices - 1); }
}
#endregion
#region OnScreenSlices
private int OnScreenSlices
{
get { return ((int)Math.Ceiling(VsPanel.ScrollBar.Height / TimeSliceHeight)); }
}
#endregion
#region VsPanel
/// <summary>
/// Gets the WeekDay vertical scroll panel
/// </summary>
private VScrollPanel VsPanel
{
get { return (CalendarView.WeekDayVScrollPanel); }
}
#endregion
#endregion
#region Hook / Unhook Events
/// <summary>
/// Routine hooks all necessary events for this control
/// </summary>
/// <param name="hook">True to hook, false to unhook</param>
private void HookEvents(bool hook)
{
if (hook == true)
{
CalendarView.SelectedViewChanged += SelectedViewChanged;
CalendarView.TimeSlotDurationChanged += TimeSlotDurationChanged;
CalendarView.FixedAllDayPanelHeightChanged += FixedAllDayPanelHeightChanged;
CalendarView.MaximumAllDayPanelHeightChanged += MaximumAllDayPanelHeightChanged;
CalendarView.WeekDayVScrollPanel.ScrollBarChanged += VScrollPanelScrollBarChanged;
if (this.ECalendarView == eCalendarView.Day)
{
CalendarView.DayViewDateChanged += DayViewDateChanged;
}
else
{
CalendarView.WeekViewStartDateChanged += WeekViewStartDateChanged;
CalendarView.WeekViewEndDateChanged += WeekViewEndDateChanged;
}
}
else
{
CalendarView.SelectedViewChanged -= SelectedViewChanged;
CalendarView.TimeSlotDurationChanged -= TimeSlotDurationChanged;
CalendarView.FixedAllDayPanelHeightChanged -= FixedAllDayPanelHeightChanged;
CalendarView.MaximumAllDayPanelHeightChanged -= MaximumAllDayPanelHeightChanged;
CalendarView.WeekDayVScrollPanel.ScrollBarChanged -= VScrollPanelScrollBarChanged;
if (this.ECalendarView == eCalendarView.Day)
{
CalendarView.DayViewDateChanged -= DayViewDateChanged;
}
else
{
CalendarView.WeekViewStartDateChanged -= WeekViewStartDateChanged;
CalendarView.WeekViewEndDateChanged -= WeekViewEndDateChanged;
}
}
}
#endregion
#region Event handling routines
#region SelectedViewChanged
/// <summary>
/// Processes view changes
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">SelectedViewEventArgs</param>
void SelectedViewChanged(object sender, SelectedViewEventArgs e)
{
// Update our IsViewSelected state
IsViewSelected = (e.NewValue == this.ECalendarView);
if (IsViewSelected == true)
{
AutoSyncViewDate(e.OldValue);
UpdateDateSelection();
}
else
{
ResetView();
}
// Update our AllDayPanel view
_AllDayPanel.UpdateView();
}
#endregion
#region DayViewDateChanged
/// <summary>
/// Processes DayViewDate changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void DayViewDateChanged(object sender, DateChangeEventArgs e)
{
StartDate = e.NewValue;
EndDate = e.NewValue;
}
#endregion
#region WeekViewStartDateChanged
/// <summary>
/// Processes StartDate changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void WeekViewStartDateChanged(object sender, DateChangeEventArgs e)
{
StartDate = e.NewValue;
}
#endregion
#region WeekViewEndDateChanged
/// <summary>
/// Processes EndDate changes
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void WeekViewEndDateChanged(object sender, DateChangeEventArgs e)
{
EndDate = e.NewValue;
}
#endregion
#region TimeSlotDurationChanged
/// <summary>
/// Handles TimeSlotDurationChanged events
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">TimeSlotDurationChangedEventArgs</param>
void TimeSlotDurationChanged(
object sender, TimeSlotDurationChangedEventArgs e)
{
// Reset our slice selection range and
// invalidate our control
_SelectedSliceStart = 0;
_SelectedSliceEnd = 0;
NeedRecalcLayout = true;
RecalcSize();
}
#endregion
#region FixedAllDayPanelHeightChanged
/// <summary>
/// Handles FixedAllDayPanelHeightChanged events
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void FixedAllDayPanelHeightChanged(
object sender, FixedAllDayPanelHeightChangedEventArgs e)
{
NeedRecalcLayout = true;
}
#endregion
#region MaximumAllDayPanelHeightChanged
/// <summary>
/// Handles MaximumAllDayPanelHeightChanged events
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void MaximumAllDayPanelHeightChanged(
object sender, MaximumAllDayPanelHeightChangedEventArgs e)
{
NeedRecalcLayout = true;
}
#endregion
#region VScrollPanel_ScrollBarChanged
/// <summary>
/// Handles ScrollBarChanged events
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void VScrollPanelScrollBarChanged(object sender, EventArgs e)
{
int vdelta = -VsPanel.ScrollBar.Value - _VScrollPos;
if (vdelta != 0)
{
_VScrollPos = -VsPanel.ScrollBar.Value;
// Offset our DayColumn accordingly
for (int i = 0; i < _NumberOfColumns; i++)
{
DayColumn dayColumn = _DayColumns[i];
Rectangle r = dayColumn.Bounds;
r.Y += vdelta;
dayColumn.Bounds = r;
for (int j = 0; j < dayColumn.CalendarItems.Count; j++)
{
dayColumn.CalendarItems[j].Displayed =
dayColumn.CalendarItems[j].Bounds.IntersectsWith(ClientRect);
}
}
// Redraw our view
InvalidateRect(ViewRect);
}
}
#endregion
#endregion
#region GetViewAreaFromPoint
/// <summary>
/// Gets the view area under the given mouse
/// point (tab, header, content, etc)
/// </summary>
/// <param name="pt">Point</param>
/// <returns>eViewArea</returns>
public override eViewArea GetViewAreaFromPoint(Point pt)
{
if (Bounds.Contains(pt) == true)
{
if (pt.Y >= ClientRect.Y)
{
if (AllDayPanel.Bounds.Contains(pt))
return (eViewArea.InAllDayPanel);
if (pt.Y < ClientRect.Y + DayOfWeekHeaderHeight)
return (eViewArea.InDayOfWeekHeader);
return (eViewArea.InContent);
}
return (base.GetViewAreaFromPoint(pt));
}
return (eViewArea.NotInView);
}
#endregion
#region GetDateSelectionFromPoint
/// <summary>
/// Gets the date selection from the given point. The startDate
/// and endDate will vary based upon the view type (WeekDay / Month)
/// </summary>
/// <param name="pt">Point in question</param>
/// <param name="startDate">out start date</param>
/// <param name="endDate">out end date</param>
/// <returns>True if a valid selection exists
/// at the given point</returns>
public override bool GetDateSelectionFromPoint(
Point pt, out DateTime startDate, out DateTime endDate)
{
base.GetDateSelectionFromPoint(pt, out startDate, out endDate);
int col, slice;
if (GetPointItem(pt, out col, out slice, true) == true)
{
startDate = GetTime(_DayColumns[col].Date, slice, 0);
endDate = startDate.AddMinutes(TimeSlotDuration);
return (true);
}
return (false);
}
#endregion
#region GetDateBounds
/// <summary>
/// Gets the bounding display rectangle for the given date/time.
/// </summary>
/// <param name="date">The date/time</param>
/// <returns>Bounding display rectangle</returns>
public Rectangle GetDateBounds(DateTime date)
{
int col = GetColumnFromDate(date);
if (col >= 0)
{
int slice = GetDateSlice(date);
if (slice >= 0)
return (GetSliceRect(col, slice));
}
return (Rectangle.Empty);
}
/// <summary>
/// Gets the bounding display rectangle for the given
/// starting and ending date/time range.
/// </summary>
/// <param name="startDate">Start date</param>
/// <param name="endDate">End date</param>
/// <returns>Bounding display rectangle</returns>
public Rectangle GetDateBounds(DateTime startDate, DateTime endDate)
{
Rectangle r1 = GetDateBounds(startDate);
Rectangle r2 = GetDateBounds(endDate);
return (Rectangle.Union(r1, r2));
}
#endregion
#region IsAllDayItem
internal bool IsAllDayItem(CalendarItem item)
{
if (item.Equals(SelectedItem) &&
(IsEndResizing || IsStartResizing || IsMoving))
{
return (false);
}
return (IsAllDayItem(item.StartTime, item.EndTime));
}
internal bool IsAllDayItem(Appointment item)
{
if (SelectedItem != null && item.Equals(SelectedItem.ModelItem) &&
(IsEndResizing || IsStartResizing || IsMoving))
{
return (false);
}
return (IsAllDayItem(item.StartTime, item.EndTime));
}
private bool IsAllDayItem(DateTime startTime, DateTime endTime)
{
//if (NumberOfColumns > 1 ||
if ( CalendarView.AllDayDisplayMode != eAllDayDisplayMode.None)
{
if ((endTime - startTime).TotalDays >= 1)
return (true);
}
//if (NumberOfColumns > 1 ||
if ( CalendarView.AllDayDisplayMode == eAllDayDisplayMode.ByDayBoundary)
{
return (startTime.Day != endTime.Day ||
(endTime - startTime).TotalDays > 1);
}
return (false);
}
#endregion
#region SetSelectedItem
/// <summary>
/// Handles selected item changes
/// </summary>
/// <param name="sender">CalendarItem</param>
/// <param name="e">EventArgs</param>
internal void ItemIsSelectedChanged(object sender, EventArgs e)
{
CalendarItem ci = sender as CalendarItem;
if (ci != null)
{
if (ci.IsSelected == true)
{
SelectedItem = SetSelectedItem(SelectedItem, ci);
}
else
{
if (ci == SelectedItem)
SelectedItem = null;
}
}
}
#region SetSelectedItem
protected override CalendarItem SetSelectedItem(CalendarItem pci, CalendarItem nci)
{
CalendarItem selItem = null;
for (int i = 0; i < DayColumns.Length; i++)
selItem = SetSelectedCalendarItem(nci, DayColumns[i].CalendarItems, selItem);
selItem = SetSelectedCalendarItem(nci, AllDayPanel.CalendarItems, selItem);
return (selItem);
}
#region SetSelectedCalendarItem
private CalendarItem SetSelectedCalendarItem(
CalendarItem nci, List<CalendarItem> items, CalendarItem selItem)
{
for (int i = 0; i < items.Count; i++)
{
CalendarItem item = items[i];
item.IsSelected = (nci != null ? (item.ModelItem == nci.ModelItem) : false);
if (item.IsSelected == true && selItem == null)
{
selItem = item;
SelectedItem = item;
}
}
return (selItem);
}
#endregion
#endregion
#endregion
#region UpdateDateSelection
#region UpdateDateSelection
/// <summary>
/// Updates our slice selection range to reflect
/// the given date selection start and end values
/// </summary>
protected override void UpdateDateSelection()
{
if (IsViewSelected == true)
{
// Get the new absolute slice selection range
int sliceStart = 0;
int sliceEnd = 0;
if (DateSelectionStart.HasValue && DateSelectionEnd.HasValue)
{
sliceStart = GetDateSlice(DateSelectionStart);
sliceEnd = GetDateSlice(DateSelectionEnd);
if (sliceStart < 0 && sliceEnd < 0)
{
sliceStart = 0;
sliceEnd = 0;
}
if (sliceStart < 0)
sliceStart = 0;
if (sliceEnd < 0)
sliceEnd = _NumberOfColumns * NumberOfActiveSlices;
}
// Limit our range to only those slices
// that are visible on the screen
int s1 = (int)(-_VScrollPos / TimeSliceHeight);
int s2 = (int)(s1 + ViewRect.Height / TimeSliceHeight + 2);
if (s2 > s1)
{
ProcessSelRange(sliceStart, sliceEnd, s1, s2);
// Save our new selection range
_SelectedSliceStart = sliceStart;
_SelectedSliceEnd = sliceEnd;
}
}
}
#endregion
#region GetDateSlice
/// <summary>
/// Gets the absolute slice value for the given date
/// </summary>
/// <param name="selDate">Selection date</param>
/// <returns>Absolute slice</returns>
private int GetDateSlice(DateTime? selDate)
{
if (selDate.HasValue)
return (GetDateSlice(selDate.Value));
return (-1);
}
private int GetDateSlice(DateTime selDate)
{
// Loop through each column
for (int i = 0; i < _NumberOfColumns; i++)
{
DateTime date = _DayColumns[i].Date;
// If we have found our containing column, then
// calculate the absolute slice value and return it
if (selDate >= date && selDate < date.AddDays(1))
{
int slice = ((selDate.Hour * MinutesPerHour) + selDate.Minute) / TimeSlotDuration;
return (i * NumberOfActiveSlices + slice - StartSlice);
}
}
return (-1);
}
#endregion
#region ProcessSelRange
/// <summary>
/// Processes the selection time slice range
/// </summary>
/// <param name="sliceStart">Slice range start</param>
/// <param name="sliceEnd">Slice range end</param>
/// <param name="s1">Slice start limit</param>
/// <param name="s2">Slice end limit</param>
private void ProcessSelRange(int sliceStart, int sliceEnd, int s1, int s2)
{
// Calculate our starting and ending column range
int fcol = Math.Min(_SelectedSliceStart / NumberOfActiveSlices, sliceStart / NumberOfActiveSlices);
int lcol = Math.Max(_SelectedSliceEnd / NumberOfActiveSlices, sliceEnd / NumberOfActiveSlices);
lcol = Math.Min(_NumberOfColumns - 1, lcol);
// Loop through each column
for (int i = fcol; i <= lcol; i++)
{
// Get the selection status for the given range
bool[] oldSelected = SelectedSlices(s1, s2, i, _SelectedSliceStart, _SelectedSliceEnd);
bool[] newSelected = SelectedSlices(s1, s2, i, sliceStart, sliceEnd);
// Invalidate those slices whose
// selection status changed
Rectangle vRect = ViewRect;
for (int j = 0; j < s2 - s1; j++)
{
if (oldSelected[j] != newSelected[j])
{
Rectangle r = GetSliceRect(i, s1 + j);
r.Intersect(vRect);
if (r.Width > 0 && r.Height > 0)
InvalidateRect(r);
}
}
}
}
#endregion
#region SelectedSlices
/// <summary>
/// Gets an array of slice selection values
/// over the given range of column slices
/// </summary>
/// <param name="s1">Slice start limit</param>
/// <param name="s2">Slice end limit</param>
/// <param name="col">Column</param>
/// <param name="sliceStart">Slice range start</param>
/// <param name="sliceEnd">Slice range end</param>
/// <returns>Array of selection values</returns>
private bool[] SelectedSlices(int s1, int s2, int col, int sliceStart, int sliceEnd)
{
// Calculate our number of entries and
// allocate our IsSelected array accordingly
int n = s2 - s1;
bool[] sel = new bool[n + 1];
// Loop through the range of entries determining if
// the specific slice is within the selection range
int slice = col * NumberOfActiveSlices + s1;
for (int i = 0; i < n; i++)
{
sel[i] = (slice >= sliceStart && slice < sliceEnd);
slice++;
}
// Return the array to the caller
return (sel);
}
#endregion
#endregion
#region RecalcSize routines
#region RecalcSize
/// <summary>
/// Performs NeedRecalcSize requests
/// </summary>
public override void RecalcSize()
{
base.RecalcSize();
if (IsViewSelected == true)
{
// Normalize our start and end dates
DateTime startDate;
DateTime endDate;
NormalizeDates(out startDate, out endDate);
if (NeedRecalcLayout == true)
_DayColumnSize = null;
// Allocate our DayColumns
AllocateDayColumns(startDate, endDate);
// Update our Model connection view,
// AllDayPanel, CalendarItems, and DateSelection
UpdateView();
UpdateAllDayPanelItems();
UpdateDayColumns(startDate, endDate);
UpdateCalendarItems();
UpdateDateSelection();
// Set our display view rectangle
Rectangle r = ClientRect;
r.Y += DayOfWeekHeaderHeight;
r.Height -= DayOfWeekHeaderHeight;
SetViewRectangle(r);
// Final Recalc cleanup
if (DaysOfTheWeek != null)
DaysOfTheWeek.NeedsMeasured = true;
NeedRecalcLayout = false;
CalendarView.DoViewLoadComplete(this);
}
}
#endregion
#region NormalizeDates
/// <summary>
/// Normalizes the user specified start and end dates
/// </summary>
/// <param name="startDate">[out] Normalized start date</param>
/// <param name="endDate">[out] Normalized end date</param>
protected virtual void NormalizeDates(out DateTime startDate, out DateTime endDate)
{
startDate = this.StartDate;
endDate = this.EndDate;
}
#endregion
#region AllocateDayColumns
/// <summary>
/// Allocates out DayColumns
/// </summary>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
private void AllocateDayColumns(DateTime startDate, DateTime endDate)
{
// Allocate our DayColumns array to
// hold our info
_NumberOfColumns = (endDate - startDate).Days + 1;
_NumberOfColumns = Math.Max(_NumberOfColumns, 1);
_NumberOfColumns = Math.Min(_NumberOfColumns, MaxNumberOfColumns);
if (_DayColumns == null || _DayColumns.Length != _NumberOfColumns)
_DayColumns = new DayColumn[_NumberOfColumns];
// Prepare to update display info on each time slot
Rectangle r = ViewRect;
r.Y += _VScrollPos;
// Loop through each day column
float dcWidth = DayColumnWidth;
float x1 = r.X;
// Update each DayColumn
for (int i = 0; i < _NumberOfColumns; i++)
{
if (_DayColumns[i] == null)
_DayColumns[i] = new DayColumn(0);
_DayColumns[i].Date = startDate.AddDays(i);
float x2 = (i == _NumberOfColumns - 1) ? r.Right - 1 : x1 + dcWidth;
if (IsLayoutNeeded(i) == true)
_DayColumns[i].Bounds = new Rectangle((int) x1, r.Y, (int) x2 - (int) x1, r.Height);
x1 = x2;
}
}
#endregion
#region UpdateView
/// <summary>
/// Updates our connection model view
/// </summary>
private void UpdateView()
{
// If we have had a date range change, just
// reset our entire view
if (DateRangeChanged == true)
ResetView();
// If we have no Model connection, attempt
// to reconnect if this view is selected
if (Connector == null)
{
if (CalendarModel != null)
{
Connector = new ModelWeekDayViewConnector(CalendarModel, this);
SubItems.Insert(0, _AllDayPanel);
}
}
}
#endregion
#region ResetView
/// <summary>
/// Disconnects and resets the Model connection
/// </summary>
internal override void ResetView()
{
_AllDayPanel.ResetView();
base.ResetView();
}
#endregion
#region UpdateAllDayPanelItems
/// <summary>
/// Updates our AllDayPanel items
/// </summary>
private void UpdateAllDayPanelItems()
{
if (NeedRecalcLayout == true)
{
// Initiate a RecalcSize for the panel
_AllDayPanel.WidthInternal = ClientRect.Width;
_AllDayPanel.HeightInternal = MaximumAllDayPanelHeight;
_AllDayPanel.RecalcSize();
// Set the panel's bounding rect accordingly
Rectangle r = ClientRect;
r.Width = _AllDayPanel.WidthInternal;
r.Y += DayOfWeekHeaderHeight;
r.Height = _AllDayPanel.HeightInternal;
_AllDayPanel.Bounds = r;
}
}
private bool IsLayoutNeeded(int col)
{
return (NeedRecalcLayout == true ||
_DayColumns[col].NeedRecalcLayout == true);
}
#endregion
#region UpdateDayColumns
/// <summary>
/// Calculates and updates DayColumn bounds
/// </summary>
/// <param name="startDate">Start date</param>
/// <param name="endDate">End date</param>
protected void UpdateDayColumns(DateTime startDate, DateTime endDate)
{
// Establish our current TimeSlice range
GetTimeSliceData();
// Updating display info on each column
Rectangle r = ViewRect;
r.Y += _VScrollPos;
r.Height = (int) (TimeSliceHeight * NumberOfSlices);
for (int i = 0; i < _NumberOfColumns; i++)
{
_DayColumns[i].TimeSliceHeight = TimeSliceHeight;
if (IsLayoutNeeded(i) == true)
{
_DayColumns[i].Bounds = new
Rectangle(_DayColumns[i].Bounds.X, r.Y, _DayColumns[i].Bounds.Width, r.Height);
InvalidateRect(_DayColumns[i].Bounds);
}
}
}
#region GetTimeSliceData
private void GetTimeSliceData()
{
_LocalStartSlice = 0;
_LocalNumberOfSlices = (HoursPerDay * MinutesPerHour) / TimeSlotDuration + 1;
if (CalendarView.ShowOnlyWorkDayHours == true)
{
WorkTime startTime = new WorkTime(23, 59);
WorkTime endTime = new WorkTime(0, 0);
for (int i = 0; i < NumberOfColumns; i++)
{
DayColumn dc = _DayColumns[i];
if (dc.WorkStartTime.IsEmpty == false || dc.WorkEndTime.IsEmpty == false)
{
if (dc.WorkStartTime <= dc.WorkEndTime)
{
if (dc.WorkStartTime < startTime)
startTime = dc.WorkStartTime;
if (dc.WorkEndTime > endTime)
endTime = dc.WorkEndTime;
}
else
{
startTime = new WorkTime(0, 0);
endTime = new WorkTime(23, 59);
break;
}
}
}
if (endTime > startTime)
{
int startMinutes = (startTime.Hour * MinutesPerHour) + startTime.Minute;
int endMinutes = (endTime.Hour * MinutesPerHour) + endTime.Minute;
_LocalStartSlice = startMinutes / TimeSlotDuration;
_LocalNumberOfSlices = (endMinutes - startMinutes) / TimeSlotDuration + 1;
}
if (StartSlice >= 0)
{
int endSlice = _LocalStartSlice + _LocalNumberOfSlices - 1;
if (_LocalStartSlice > StartSlice)
_LocalStartSlice = StartSlice;
if (StartSlice + NumberOfSlices > endSlice)
endSlice = StartSlice + NumberOfSlices - 1;
_LocalNumberOfSlices = endSlice - _LocalStartSlice + 1;
}
}
StartSlice = _LocalStartSlice;
NumberOfSlices = _LocalNumberOfSlices;
TimeSliceHeight = (float)ViewRect.Height / NumberOfActiveSlices;
}
#endregion
#endregion
#region UpdateCalendarItems
/// <summary>
/// Updates our CalendarItems list
/// </summary>
private void UpdateCalendarItems()
{
List<ColumnList> list = new List<ColumnList>();
for (int i = 0; i < _NumberOfColumns; i++)
{
if (IsLayoutNeeded(i) == true)
{
if (_DayColumns[i].CalendarItems.Count > 0)
{
List<CalendarItem> items = SortCalendarItems(i);
list.Clear();
for (int j = 0; j < items.Count; j++)
{
ColumnList colList = GetColList(list, items[j]);
colList.AddColumnSlot(items[j], 0);
}
foreach (ColumnList colList in list)
colList.CountColumns();
CalcAppointmentBounds(i, list);
}
_DayColumns[i].NeedRecalcLayout = false;
}
}
}
#region GetColList
private ColumnList GetColList(List<ColumnList> list, CalendarItem item)
{
int id = CalendarView.DoGetAppointmentGroupId(item, -1);
int index;
if (GetColListIndex(list, id, out index) == true)
return (list[index]);
ColumnList clist = new ColumnList(id);
if (index < list.Count)
list.Insert(index, clist);
else
list.Add(clist);
return (clist);
}
#region GetColListIndex
private bool GetColListIndex(List<ColumnList> list, int id, out int index)
{
for (index=0; index < list.Count; index++)
{
ColumnList colList = list[index];
if (colList.Id == id)
return (true);
if (colList.Id > id)
break;
}
return (false);
}
#endregion
#endregion
#region SortCalendarItems
/// <summary>
/// Sorts the DayColumn CalendarItem list
/// </summary>
/// <param name="col">DayColumn index</param>
private List<CalendarItem> SortCalendarItems(int col)
{
List<CalendarItem> items = new List<CalendarItem>();
items.AddRange(_DayColumns[col].CalendarItems);
if (items.Count > 0)
{
items.Sort(
delegate(CalendarItem c1, CalendarItem c2)
{
if (c1.StartTime > c2.StartTime)
return (1);
if (c1.StartTime < c2.StartTime)
return (-1);
if (c1.EndTime - c1.StartTime > c2.EndTime - c2.StartTime)
return (1);
if (c1.EndTime - c1.StartTime < c2.EndTime - c2.StartTime)
return (-1);
int result = 0;
CalendarView.DoDetailSortEvent(this, c1, c2, ref result);
return (result);
}
);
}
return (items);
}
#endregion
#region CalcAppointmentBounds
/// <summary>
/// Calculates normal appointment bounds
/// </summary>
/// <param name="col">DayColumn column</param>
/// <param name="colList">Accumulated ColumnList</param>
private void CalcAppointmentBounds(int col, List<ColumnList> list)
{
Rectangle r = _DayColumns[col].Bounds;
r.X++;
r.Width -= 8;
for (int k = 0; k < list.Count; k++)
{
ColumnList colList = list[k];
Rectangle r3 = r;
float dx3 = (float)r3.Width / list.Count;
r3.X += (int)(dx3 * k);
r3.Width = (int)dx3;
for (int i = 0; i < colList.SList.Count; i++)
{
for (int j = 0; j < colList.SList[i].Count; j++)
{
Rectangle r2 = r3;
SlotItem si = colList.SList[i][j];
CalendarItem item = si.CItem;
float dx = (float)r2.Width / si.Count;
r2.X += (int)(dx * i);
if (si.SList != null && si.SList.Count == 1)
r2.Width = (int)(dx * (si.SList[0].Column - si.Column));
else if (si.SList == null)
r2.Width = r3.Width - (r2.X - r3.X);
else
r2.Width = (int)dx;
DateTime startTime = item.StartTime;
if (startTime.Date < _DayColumns[col].Date)
startTime = _DayColumns[col].Date;
DateTime endTime = item.EndTime;
if (endTime > _DayColumns[col].Date.AddDays(1))
endTime = _DayColumns[col].Date.AddDays(1);
DateTime date = startTime.Date;
TimeSpan ts1 = startTime.AddMinutes(-StartSlice * TimeSlotDuration) - date;
TimeSpan ts2 = endTime - startTime;
int pos = (int)(ts1.TotalMinutes / TimeSlotDuration * TimeSliceHeight);
int height = (int)Math.Round(ts2.TotalMinutes / TimeSlotDuration * TimeSliceHeight);
AppointmentView view = item as AppointmentView;
if (view != null)
{
Font font = view.Font ?? CalendarView.Font;
if (font != null)
height = Math.Max(font.Height + 6, height);
}
r2.Y = r.Y + (int)pos;
r2.Height = height;
// Now that we have calculated the items height and
// width, invoke a Recalc on the item
item.WidthInternal = r2.Width;
item.HeightInternal = r2.Height - 1;
item.RecalcSize();
// Set our bounds for the item
r2.Width = item.WidthInternal;
r2.Height = item.HeightInternal;
if (item.Bounds != r2)
{
InvalidateRect(item.Bounds);
InvalidateRect(r2);
}
item.Bounds = r2;
// Set it's display state
item.Displayed = r2.IntersectsWith(ClientRect);
}
}
}
}
#endregion
#endregion
#endregion
#region Paint processing
#region Root paint code
/// <summary>
/// Paint processing
/// </summary>
/// <param name="e">ItemPaintArgs</param>
public override void Paint(ItemPaintArgs e)
{
Graphics g = e.Graphics;
// Set our current color table
_ViewColor.SetColorTable();
// Only draw something if we have something to draw
if (_DayColumns != null)
{
// Calculate our drawing ranges
int dayStart, dayEnd;
int sliceStart, sliceEnd;
int dayCount = GetDayRange(e, out dayStart, out dayEnd);
int sliceCount = GetSliceRange(e, out sliceStart, out sliceEnd);
// Draw our calendar parts
if (dayCount > 0)
DrawDayOfTheWeekHeader(e, dayStart, dayEnd);
if (sliceCount > 0 && dayCount > 0)
{
// Set our clipping region
Rectangle r = ViewRect;
r.X = ClientRect.X;
r.Width = ClientRect.Width;
Region regSave = g.Clip;
g.SetClip(r, CombineMode.Intersect);
// Draw our slices and appointments
DrawSlices(e, sliceStart, sliceEnd, dayStart, dayEnd);
DrawTimeIndicators(g, sliceStart, sliceEnd, eTimeIndicatorLevel.Bottom);
if (Connector != null && Connector.IsConnected)
DrawWeekAppointments(e, dayStart, dayEnd);
DrawTimeIndicators(g, sliceStart, sliceEnd, eTimeIndicatorLevel.Top);
// Restore our original clip region
g.Clip = regSave;
}
// Initiate the painting of our AllDay Panel
_AllDayPanel.Paint(e);
// Update our Alt-Key window
UpdatePosWin(ViewRect);
}
// Let the base painting take place
base.Paint(e);
}
#region Clip range routines
/// <summary>
/// Calculates the range of days needed to be drawn
/// to satisfy the specified paint request
/// </summary>
/// <param name="e">ItemPaintArgs</param>
/// <param name="dayStart">[out] Day start index</param>
/// <param name="dayEnd">[out] Day end index</param>
/// <returns>Day range count (end - start)</returns>
private int GetDayRange(ItemPaintArgs e, out int dayStart, out int dayEnd)
{
// Calc our starting index
int start = 0;
while (start < _NumberOfColumns)
{
if (_DayColumns[start].Bounds.Right > e.ClipRectangle.X)
break;
start++;
}
// Calc our ending index
int end = start;
while (end < _NumberOfColumns)
{
if (_DayColumns[end].Bounds.X >= e.ClipRectangle.Right)
break;
end++;
}
// Set the user supplied 'out' values, and
// return the range count to the caller
if (end - start == 0)
{
dayStart = 0;
dayEnd = 0;
return (0);
}
dayStart = start;
dayEnd = end - 1;
return (end - start);
}
/// <summary>
/// Calculates the range of slices needed to be drawn
/// to satisfy the specified paint request
/// </summary>
/// <param name="e">ItemPaintArgs</param>
/// <param name="sliceStart">[out] Slice start index</param>
/// <param name="sliceEnd">[out] Slice end index</param>
/// <returns>Slice range count (end - start)</returns>
internal int GetSliceRange(ItemPaintArgs e, out int sliceStart, out int sliceEnd)
{
// Calc our starting index
int start = 0;
Rectangle v = ViewRect;
while (start < NumberOfSlices)
{
Rectangle r = GetSliceRect(0, start);
if (r.Bottom > v.Top)
{
if (r.Bottom > e.ClipRectangle.Y)
break;
}
start++;
}
// Calc our ending index
int end = start;
while (end < NumberOfSlices)
{
Rectangle r = GetSliceRect(0, end);
if (r.Y >= e.ClipRectangle.Bottom)
break;
end++;
}
// Set the user supplied 'out' values, and
// return the range count to the caller
if (end - start == 0)
{
sliceStart = 0;
sliceEnd = 0;
return (0);
}
sliceStart = start;
sliceEnd = end - 1;
return (end - start);
}
private bool SliceIsSelected(int col, int slice)
{
int nslice = col * NumberOfActiveSlices + slice;
return (nslice >= _SelectedSliceStart && nslice < _SelectedSliceEnd);
}
#endregion
#endregion
#region DayOfTheWeek header drawing
#region DrawDayOfTheWeekHeader
/// <summary>
/// Draws the top Day of the week header
/// </summary>
/// <param name="e">ItemPaintArgs</param>
/// <param name="dayStart">Start day index</param>
/// <param name="dayEnd">End day index</param>
private void DrawDayOfTheWeekHeader(ItemPaintArgs e, int dayStart, int dayEnd)
{
Graphics g = e.Graphics;
Rectangle r = new Rectangle(
_DayColumns[dayStart].Bounds.X, ClientRect.Y,
_DayColumns[dayEnd].Bounds.Right -
_DayColumns[dayStart].Bounds.X, DayOfWeekHeaderHeight);
if (r.Width > 0 && r.Height > 0)
{
// Establish our Days Of The Week text type
DaysOfTheWeek.eDayType type = GetDaysOfTheWeekType(g);
// Loop through each day, drawing the
// day of the week text in the header area
int nowHeader = -1;
using (Brush br =
_ViewColor.BrushPart((int) eCalendarWeekDayPart.DayHeaderBackground, r))
{
using (Pen pen = new Pen(
_ViewColor.GetColor((int) eCalendarWeekDayPart.DayHeaderBorder)))
{
for (int i = dayStart; i <= dayEnd; i++)
{
if (CalendarView.HighlightCurrentDay == true &&
_DayColumns[i].Date.Date.Equals(DateTime.Now.Date))
{
nowHeader = i;
continue;
}
DrawColumnHeader(g, i, type, r, br, pen, eCalendarWeekDayPart.DayHeaderForeground);
}
}
}
// Draw the current "Now" header
if (nowHeader >= 0)
{
using (Brush br =
_ViewColor.BrushPart((int) eCalendarWeekDayPart.NowDayHeaderBackground, r))
{
using (Pen pen = new Pen(
_ViewColor.GetColor((int) eCalendarWeekDayPart.NowDayHeaderBorder)))
{
DrawColumnHeader(g, nowHeader, type, r, br, pen, eCalendarWeekDayPart.NowDayHeaderForeground);
}
}
}
}
}
#region DrawColumnHeader
/// <summary>
/// DrawColumnHeader
/// </summary>
/// <param name="g"></param>
/// <param name="i"></param>
/// <param name="type"></param>
/// <param name="r"></param>
/// <param name="br"></param>
/// <param name="pen"></param>
/// <param name="part"></param>
private void DrawColumnHeader(Graphics g, int i,
DaysOfTheWeek.eDayType type, Rectangle r, Brush br, Pen pen, eCalendarWeekDayPart part)
{
r.X = _DayColumns[i].Bounds.X;
r.Width = _DayColumns[i].Bounds.Width;
g.FillRectangle(br, r);
g.DrawRectangle(pen, r);
Rectangle t = r;
if (CalendarView.DoPreRenderWeekDayHeader(g, this, i, t) == false)
{
// Draw the header text
int n = i % DaysInWeek;
eTextFormat tf = eTextFormat.VerticalCenter | eTextFormat.NoPadding;
r.Inflate(-2, 0);
r.X += 1;
TextDrawing.DrawString(g,
_DayColumns[i].Date.Day.ToString(), BoldFont, Color.Black, r, tf);
r.X += _DayColumnSize[n].Width;
r.Width -= _DayColumnSize[n].Width;
if (type != DaysOfTheWeek.eDayType.None)
{
tf |= eTextFormat.HorizontalCenter;
TextDrawing.DrawString(g, DaysOfTheWeek.DayText[(int) type][n],
Font, _ViewColor.GetColor((int) part), r, tf);
}
CalendarView.DoPostRenderWeekDayHeader(g, this, i, t);
}
}
#endregion
#endregion
#region GetDaysOfTheWeekType
/// <summary>
/// Get the index for our day of the week text
/// </summary>
/// <param name="g">Graphics handle</param>
/// <returns>Index to header text</returns>
private DaysOfTheWeek.eDayType GetDaysOfTheWeekType(Graphics g)
{
// Resize our DayColumn day text if it
// hasn't been resized previously
if (_DayColumnSize == null)
{
_DayColumnSize = new Size[_NumberOfColumns];
for (int i = 0; i < _NumberOfColumns; i++)
{
_DayColumnSize[i] = TextDrawing.MeasureString(g,
_DayColumns[i].Date.Day.ToString(), BoldFont, 0, eTextFormat.NoPadding);
}
}
// Determine if the current DayRect bounds
// are constrained by the text threshold
DaysOfTheWeek.MeasureText(g, Font);
for (int i = 0; i < _NumberOfColumns; i++)
{
if (_DayColumns[i].Bounds.Width <
_DayColumnSize[i].Width + DaysOfTheWeek.DaySize[(int)DaysOfTheWeek.eDayType.Short][i % 7].Width)
{
return (DaysOfTheWeek.eDayType.None);
}
}
for (int i = 0; i < _NumberOfColumns; i++)
{
if (_DayColumns[i].Bounds.Width <
_DayColumnSize[i].Width + DaysOfTheWeek.DaySize[(int)DaysOfTheWeek.eDayType.Long][i % 7].Width)
{
return (DaysOfTheWeek.eDayType.Short);
}
}
return (DaysOfTheWeek.eDayType.Long);
}
#endregion
#endregion
#region DrawSlices
#region DrawSlices
/// <summary>
/// Draws Normal Appointment time slices
/// </summary>
/// <param name="e">ItemPaintArgs</param>
/// <param name="sliceStart">Start slice</param>
/// <param name="sliceEnd">End slice</param>
/// <param name="dayStart">Day start</param>
/// <param name="dayEnd">Day end</param>
private void DrawSlices(ItemPaintArgs e,
int sliceStart, int sliceEnd, int dayStart, int dayEnd)
{
Graphics g = e.Graphics;
DaySlot[,] daySlots = GetDaySlots(sliceStart, sliceEnd, dayStart, dayEnd);
DrawContent(g, sliceStart, sliceEnd, dayStart, dayEnd, daySlots);
DrawDaySlot(g, sliceStart, sliceEnd, dayStart, dayEnd, daySlots, false);
DrawBorders(g, sliceStart, sliceEnd, dayStart, dayEnd, daySlots);
DrawDaySlot(g, sliceStart, sliceEnd, dayStart, dayEnd, daySlots, true);
}
#endregion
#region GetDaySlots
/// <summary>
/// Gets the array of DaySlot information
/// </summary>
/// <param name="sliceStart"></param>
/// <param name="sliceEnd"></param>
/// <param name="dayStart"></param>
/// <param name="dayEnd"></param>
/// <returns>array of DaySlots</returns>
private DaySlot[,] GetDaySlots(int sliceStart, int sliceEnd, int dayStart, int dayEnd)
{
DaySlot[,] daySlots = new DaySlot[dayEnd - dayStart + 1, sliceEnd - sliceStart + 1];
for (int i = dayStart; i <= dayEnd; i++)
{
for (int j = sliceStart; j <= sliceEnd; j++)
{
DaySlot daySlot = new DaySlot();
daySlots[i - dayStart, j - sliceStart] = daySlot;
daySlot.Bounds = GetSliceRect(i, j);
daySlot.Selected = SliceIsSelected(i, j);
if (j <= sliceEnd &&
CalendarView.HasViewDisplayCustomizations == true)
{
int start = ((StartSlice + j) * TimeSlotDuration) % 1440;
int end = Math.Min(start + TimeSlotDuration, 1439);
WorkTime wkStart = new WorkTime(start / MinutesPerHour, start % MinutesPerHour);
WorkTime wkEnd = new WorkTime(end / MinutesPerHour, end % MinutesPerHour);
daySlot.Appearance = CalendarView.ViewDisplayCustomizations.GetDaySlotAppearance(
OwnerKey, _DayColumns[i].Date, wkStart, wkEnd);
}
}
}
return (daySlots);
}
#endregion
#region DrawContent
/// <summary>
/// Time slice content drawing
/// </summary>
/// <param name="g">Graphics</param>
/// <param name="sliceStart">Start slice</param>
/// <param name="sliceEnd">End slice</param>
/// <param name="dayStart">Day start</param>
/// <param name="dayEnd">Day end</param>
/// <param name="daySlots"></param>
private void DrawContent(Graphics g,
int sliceStart, int sliceEnd, int dayStart, int dayEnd, DaySlot[,] daySlots)
{
// Loop through each day in each week, displaying
// the associated day content
for (int i = dayStart; i <= dayEnd; i++)
{
for (int j = sliceStart; j <= sliceEnd; j++)
{
DaySlot daySlot = daySlots[i - dayStart, j - sliceStart];
DaySlotAppearance dsa = daySlot.Appearance;
if (CalendarView.DoPreRenderWeekDaySlotBackground(g, this, i, j, daySlot.Bounds) == false)
{
if (dsa != null && daySlot.Selected == false)
{
using (Brush br = new SolidBrush(dsa.BackColor))
g.FillRectangle(br, daySlot.Bounds);
continue;
}
g.FillRectangle(GetContentBrush(daySlot, i, j), daySlot.Bounds);
}
CalendarView.DoPostRenderWeekDaySlotBackground(g, this, i, j, daySlot.Bounds);
}
}
}
#region GetContentBrush
/// <summary>
/// Gets the background content brush
/// for the given time slice
/// </summary>
/// <param name="daySlot"></param>
/// <param name="col">Column index</param>
/// <param name="slice">Time slice</param>
/// <returns>Background brush</returns>
private Brush GetContentBrush(DaySlot daySlot, int col, int slice)
{
int start = (StartSlice + slice) * TimeSlotDuration;
if (slice < NumberOfActiveSlices)
{
if (daySlot.Selected == true)
return (SelectedBrush);
WorkTime wkStart = new
WorkTime(start / MinutesPerHour, start % MinutesPerHour);
if (_DayColumns[col].IsWorkTime(wkStart) == true)
return (WorkBrush);
if (_DayColumns[col].IsBusyTime(wkStart) == true)
return (BusyBrush);
}
else
{
return (AllDayBrush);
}
return (OffWorkBrush);
}
#endregion
#endregion
#region DrawDaySlot
/// <summary>
/// Initiates DaySlot drawing
/// </summary>
/// <param name="g"></param>
/// <param name="sliceStart"></param>
/// <param name="sliceEnd"></param>
/// <param name="dayStart"></param>
/// <param name="dayEnd"></param>
/// <param name="daySlots"></param>
/// <param name="onTop">On top of borders</param>
private void DrawDaySlot(Graphics g, int sliceStart,
int sliceEnd, int dayStart, int dayEnd, DaySlot[,] daySlots, bool onTop)
{
List<DaySlotAppearance> dsaList = null;
Rectangle dRect = Rectangle.Empty;
for (int i = dayStart; i <= dayEnd; i++)
{
DaySlot lastDaySlot = null;
for (int j = sliceStart; j <= sliceEnd; j++)
{
DaySlot daySlot = daySlots[i - dayStart, j - sliceStart];
Rectangle r = daySlot.Bounds;
DaySlotAppearance dsa = daySlot.Appearance;
if (lastDaySlot != null &&
(lastDaySlot.Appearance != dsa || lastDaySlot.Selected != daySlot.Selected))
{
FlushDaySlotText(g, i, dsaList, ref dRect, lastDaySlot.Selected);
}
lastDaySlot = daySlot;
if (dsa != null)
{
if (dsa.OnTop == onTop)
{
if (daySlot.Selected == true)
{
if (dsa.ShowTextWhenSelected == true)
dRect = dRect.IsEmpty ? r : Rectangle.Union(dRect, r);
}
else
{
dRect = dRect.IsEmpty ? r : Rectangle.Union(dRect, r);
}
if (dsaList == null)
dsaList = new List<DaySlotAppearance>();
if (dsaList.Contains(dsa) == false)
dsaList.Add(dsa);
}
continue;
}
}
if (lastDaySlot != null)
FlushDaySlotText(g, i, dsaList, ref dRect, lastDaySlot.Selected);
}
}
#region FlushDaySlotText
/// <summary>
/// Flushes out pending DaySlot drawing
/// </summary>
/// <param name="g"></param>
/// <param name="dayCol"></param>
/// <param name="dsaList"></param>
/// <param name="dRect">Display rect</param>
/// <param name="selected"></param>
private void FlushDaySlotText(Graphics g,
int dayCol, List<DaySlotAppearance> dsaList, ref Rectangle dRect, bool selected)
{
if (dsaList != null && dsaList.Count > 0)
{
if (dRect.IsEmpty == false)
DrawDaySlotText(g, dayCol, dsaList, dRect, selected);
dsaList.Clear();
dRect = Rectangle.Empty;
}
}
#endregion
#region DrawDaySlotText
/// <summary>
/// Draws the DaySlot Text
/// </summary>
/// <param name="g"></param>
/// <param name="dayCol"></param>
/// <param name="dsaList"></param>
/// <param name="cRect"></param>
/// <param name="selected"></param>
private void DrawDaySlotText(Graphics g,
int dayCol, IEnumerable<DaySlotAppearance> dsaList, Rectangle cRect, bool selected)
{
foreach (DaySlotAppearance dsa in dsaList)
{
DateTime startTime = GetSlotTime(dayCol, dsa.StartTime);
DateTime endTime = GetSlotTime(dayCol, dsa.EndTime);
DateTime e = endTime.AddMinutes(-1);
WorkTime wkEnd = new WorkTime(e.Hour, e.Minute);
int start = GetWorkTimeSlice(dsa.StartTime);
int end = GetWorkTimeSlice(wkEnd);
Rectangle r = GetSliceRect(dayCol, start);
r = Rectangle.Union(r, GetSliceRect(dayCol, end));
Region rgnSave = g.Clip;
g.SetClip(cRect, CombineMode.Intersect);
string text = dsa.Text;
if (CalendarView.DoRenderDaySlotAppearanceText(g,
r, dsa, startTime, endTime, selected, ref text) == false)
{
if (String.IsNullOrEmpty(dsa.Text) == false)
{
eTextFormat tf = GetTextFormat(dsa.TextAlignment);
Font font = dsa.Font ?? Font;
Color color = (selected == true)
? (dsa.SelectedTextColor.IsEmpty ? Color.Black : dsa.SelectedTextColor)
: (dsa.TextColor.IsEmpty ? Color.Black : dsa.TextColor);
TextDrawing.DrawString(g, text, font, color, r, tf);
}
}
g.Clip = rgnSave;
}
}
#region GetSlotTime
private DateTime GetSlotTime(int dayCol, WorkTime wkTime)
{
DateTime time = _DayColumns[dayCol].Date;
time = time.AddHours(wkTime.Hour);
time = time.AddMinutes(wkTime.Minute);
return (time);
}
#endregion
#region GetWorkTimeSlice
private int GetWorkTimeSlice(WorkTime wkTime)
{
int slice = ((wkTime.Hour * MinutesPerHour) +
wkTime.Minute) / TimeSlotDuration;
return (slice - StartSlice);
}
#region GetTextFormat
private eTextFormat GetTextFormat(ContentAlignment alignment)
{
eTextFormat tf = eTextFormat.WordBreak;
switch (alignment)
{
case ContentAlignment.TopLeft:
tf |= eTextFormat.Top | eTextFormat.Left;
break;
case ContentAlignment.TopCenter:
tf |= eTextFormat.Top | eTextFormat.HorizontalCenter;
break;
case ContentAlignment.TopRight:
tf |= eTextFormat.Top | eTextFormat.Right;
break;
case ContentAlignment.MiddleLeft:
tf |= eTextFormat.VerticalCenter | eTextFormat.Left;
break;
case ContentAlignment.MiddleCenter:
tf |= eTextFormat.VerticalCenter | eTextFormat.HorizontalCenter;
break;
case ContentAlignment.MiddleRight:
tf |= eTextFormat.VerticalCenter | eTextFormat.Right;
break;
case ContentAlignment.BottomLeft:
tf |= eTextFormat.Bottom | eTextFormat.Left;
break;
case ContentAlignment.BottomCenter:
tf |= eTextFormat.Bottom | eTextFormat.HorizontalCenter;
break;
case ContentAlignment.BottomRight:
tf |= eTextFormat.Bottom | eTextFormat.Right;
break;
}
return (tf);
}
#endregion
#endregion
#endregion
#endregion
#region DrawTimeIndicators
#region DrawTimeIndicators
/// <summary>
/// Draw view TimeIndicators
/// </summary>
/// <param name="g"></param>
/// <param name="sliceStart"></param>
/// <param name="sliceEnd"></param>
private void DrawTimeIndicators(Graphics g,
int sliceStart, int sliceEnd, eTimeIndicatorLevel level)
{
DateTime start = _DayColumns[0].Date;
DateTime end = _DayColumns[_NumberOfColumns - 1].Date.AddDays(1);
Rectangle r = Rectangle.Union(GetSliceRect(0, sliceStart), GetSliceRect(0, sliceEnd));
for (int i = 0; i < CalendarView.TimeIndicators.Count; i++)
{
TimeIndicator ti = CalendarView.TimeIndicators[i];
if (ti.IndicatorLevel == level)
{
if (ti.IndicatorArea == eTimeIndicatorArea.All ||
ti.IndicatorArea == eTimeIndicatorArea.Content)
{
if (ti.IsVisible(CalendarView, this))
{
DateTime time = ti.IndicatorDisplayTime;
if (time >= start && time < end)
DrawTimeIndicator(g, r, ti);
}
}
}
}
}
#endregion
#region DrawTimeIndicator
#region DrawTimeIndicator
/// <summary>
/// Draws individual view TimeIndicator
/// </summary>
/// <param name="g"></param>
/// <param name="sRect"></param>
/// <param name="ti"></param>
private void DrawTimeIndicator(Graphics g, Rectangle sRect, TimeIndicator ti)
{
Rectangle r = GetIndicatorRect(ti);
if (r.IntersectsWith(sRect) == true)
{
if (r.Height > 0)
{
ColorDef cdef = GetIndicatorColor(ti);
if (cdef != null)
{
using (Brush br = _ViewColor.BrushPart(cdef, r))
{
if (br is LinearGradientBrush)
((LinearGradientBrush) br).WrapMode = WrapMode.TileFlipX;
g.FillRectangle(br, r);
}
}
}
Color color = GetIndicatorBorder(ti);
if (color.IsEmpty == false)
{
using (Pen pen = new Pen(color))
g.DrawLine(pen, r.X + 1, r.Bottom, r.Right - 1, r.Bottom);
}
}
}
#endregion
#region GetIndicatorRect
/// <summary>
/// Gets the TimeIndicator rectangle
/// </summary>
/// <param name="ti"></param>
/// <returns></returns>
internal override Rectangle GetIndicatorRect(TimeIndicator ti)
{
return (GetIndicatorRect(ti, ti.IndicatorDisplayTime));
}
/// <summary>
/// Gets the TimeIndicator rectangle for the
/// given DataTime
/// </summary>
/// <param name="ti"></param>
/// <param name="time"></param>
/// <returns></returns>
internal override Rectangle GetIndicatorRect(TimeIndicator ti, DateTime time)
{
DateTime startTime = GetTime(_DayColumns[0].Date, 0, 0);
DateTime endTime = GetTime(_DayColumns[NumberOfColumns - 1].Date, NumberOfActiveSlices, 0);
if (time >= startTime && time < endTime)
{
int offset = (int) (time.Hour * SlotsPerHour * TimeSliceHeight +
(TimeSliceHeight * time.Minute) / TimeSlotDuration);
offset -= (int) (StartSlice * TimeSliceHeight);
Rectangle r = ViewRect;
r.Width -= 1;
r.Y = _DayColumns[0].Bounds.Y + offset - ti.Thickness;
r.Height = ti.Thickness;
return (r);
}
return (Rectangle.Empty);
}
#endregion
#region GetIndicatorColor
/// <summary>
/// Gets the Indicator Back color
/// </summary>
/// <param name="ti"></param>
/// <returns></returns>
private ColorDef GetIndicatorColor(TimeIndicator ti)
{
ColorDef cdef = ti.IndicatorColor;
if (cdef == null || cdef.IsEmpty == true)
cdef = _ViewColor.GetColorDef((int)eCalendarWeekDayPart.TimeIndicator);
return (cdef);
}
#endregion
#region GetIndicatorBorder
/// <summary>
/// Gets the Indicator Border color
/// </summary>
/// <param name="ti"></param>
/// <returns></returns>
private Color GetIndicatorBorder(TimeIndicator ti)
{
return (ti.BorderColor.IsEmpty == false ? ti.BorderColor :
_ViewColor.GetColor((int)eCalendarWeekDayPart.TimeIndicatorBorder));
}
#endregion
#endregion
#endregion
#region DrawBorders
#region DrawBorders
/// <summary>
/// Draws time slice borders
/// </summary>
/// <param name="g">Graphics</param>
/// <param name="sliceStart">Start slice</param>
/// <param name="sliceEnd">End slice</param>
/// <param name="dayStart">Day start</param>
/// <param name="dayEnd">Day end</param>
/// <param name="daySlots"></param>
private void DrawBorders(Graphics g,
int sliceStart, int sliceEnd, int dayStart, int dayEnd, DaySlot[,] daySlots)
{
// Draw the horizontal and vertical borders, and
// the current "Now" border
DrawHorizontalBorders(g, sliceStart, sliceEnd, dayStart, dayEnd, daySlots);
DrawVerticalBorders(g, sliceStart, sliceEnd, dayStart, dayEnd);
if (CalendarView.HighlightCurrentDay == true)
DrawNowBorder(g, dayStart, dayEnd);
}
#endregion
#region DrawHorizontalBorders
/// <summary>
/// Draws horizontal borders
/// </summary>
/// <param name="g"></param>
/// <param name="sliceStart"></param>
/// <param name="sliceEnd"></param>
/// <param name="dayStart"></param>
/// <param name="dayEnd"></param>
/// <param name="daySlots"></param>
private void DrawHorizontalBorders(Graphics g,
int sliceStart, int sliceEnd, int dayStart, int dayEnd, DaySlot[,] daySlots)
{
if (CalendarView.HasViewDisplayCustomizations == true)
{
int n = MinutesPerHour / TimeSlotDuration;
Color hourBorderColor = _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHourBorder);
Color halfHourBorderColor = _ViewColor.GetColor((int)eCalendarWeekDayPart.DayHalfHourBorder);
for (int i = dayStart; i <= dayEnd; i++)
{
for (int j = sliceStart; j <= sliceEnd; j++)
{
DaySlot daySlot = daySlots[i - dayStart, j - sliceStart];
Rectangle r = daySlot.Bounds;
DaySlotAppearance dsa = daySlot.Appearance;
Point pt1 = r.Location;
Point pt2 = new Point(r.Right - 1, r.Y);
if (dsa != null && daySlot.Selected == false)
{
using (Pen pen = new Pen(j % n == 0 ? dsa.HourBorderColor : dsa.HalfHourBorderColor))
g.DrawLine(pen, pt1, pt2);
continue;
}
using (Pen pen = new Pen(j % n == 0 ? hourBorderColor : halfHourBorderColor))
g.DrawLine(pen, pt1, pt2);
}
}
}
else
{
using (Pen pen1 = new Pen(
_ViewColor.GetColor((int) eCalendarWeekDayPart.DayHourBorder)))
{
using (Pen pen2 = new Pen(
_ViewColor.GetColor((int) eCalendarWeekDayPart.DayHalfHourBorder)))
{
Point pt1 = new Point(_DayColumns[dayStart].Bounds.X, 0);
Point pt2 = new Point(_DayColumns[dayEnd].Bounds.Right - 1, 0);
int n = MinutesPerHour/TimeSlotDuration;
for (int i = sliceStart; i <= sliceEnd; i++)
{
Rectangle r = GetSliceRect(0, i);
pt1.Y = pt2.Y = r.Y;
g.DrawLine((i%n) == 0 ? pen1 : pen2, pt1, pt2);
}
}
}
}
}
#endregion
#region DrawVerticalBorders
/// <summary>
/// Draws the vertical borders
/// </summary>
/// <param name="g"></param>
/// <param name="sliceStart"></param>
/// <param name="sliceEnd"></param>
/// <param name="dayStart"></param>
/// <param name="dayEnd"></param>
private void DrawVerticalBorders(Graphics g,
int sliceStart, int sliceEnd, int dayStart, int dayEnd)
{
Rectangle r1 = GetSliceRect(0, sliceStart);
Rectangle r2 = GetSliceRect(0, sliceEnd);
using (Pen pen1 = new Pen(
_ViewColor.GetColor((int)eCalendarWeekDayPart.DayViewBorder)))
{
Point pt1 = new Point(0, r1.Y);
Point pt2 = new Point(0, r2.Bottom);
for (int i = dayStart; i <= dayEnd; i++)
{
pt1.X = pt2.X = _DayColumns[i].Bounds.X;
g.DrawLine(pen1, pt1, pt2);
}
pt1.X = pt2.X = _DayColumns[dayEnd].Bounds.Right;
g.DrawLine(pen1, pt1, pt2);
}
}
#endregion
#region DrawNowBorder
/// <summary>
/// Draws the Current-Day Now border
/// </summary>
/// <param name="g"></param>
/// <param name="dayStart"></param>
/// <param name="dayEnd"></param>
private void DrawNowBorder(Graphics g, int dayStart, int dayEnd)
{
// Draw the "Current" day border
for (int i = dayStart; i <= dayEnd; i++)
{
if (_DayColumns[i].Date.Date.Equals(DateTime.Now.Date))
{
Rectangle r = _DayColumns[i].Bounds;
using (Pen pen = new Pen(
_ViewColor.GetColor((int)eCalendarWeekDayPart.NowDayHeaderBorder)))
{
g.DrawRectangle(pen, r);
}
break;
}
}
}
#endregion
#endregion
#endregion
#region DrawWeekAppointments
/// <summary>
/// Initiates the drawing of weekly appointments
/// </summary>
/// <param name="e">ItemPaintArgs</param>
/// <param name="dayStart">Day start index</param>
/// <param name="dayEnd">Day end index</param>
private void DrawWeekAppointments(ItemPaintArgs e, int dayStart, int dayEnd)
{
if (e.ClipRectangle.IntersectsWith(ViewRect) == true)
{
// Loop through each day in each week, displaying
// the associated day content
List<CalendarItem> selItems = null;
for (int i = 0; i <= dayEnd; i++)
{
List<CalendarItem> items = _DayColumns[i].CalendarItems;
if (items != null && items.Count > 0)
{
int right = _DayColumns[i].Bounds.Right - 1;
for (int j = 0; j < items.Count; j++)
{
CalendarItem item = items[j];
if ((item.Displayed == true) &&
(i >= dayStart || item.Bounds.Right > right))
{
if (item.IsSelected == false)
{
item.Paint(e);
}
else
{
if (selItems == null)
selItems = new List<CalendarItem>();
selItems.Add(item);
}
}
}
}
}
if (selItems != null)
{
foreach (CalendarItem item in selItems)
item.Paint(e);
}
}
}
#endregion
#endregion
#region Mouse routines
#region MouseDown processing
/// <summary>
/// MouseDown event processing
/// </summary>
/// <param name="objArg"></param>
public override void InternalMouseDown(MouseEventArgs objArg)
{
// Forward on the event
base.InternalMouseDown(objArg);
if (SelectedItem != null)
_WasAllDayItem = IsAllDayItem(SelectedItem);
if (objArg.Button == MouseButtons.Left)
{
if (IsTabMoving == false)
{
// Locate where the event took place
if (InPanelResize(objArg.Location) == true)
{
MyCursor = Cursors.HSplit;
_IsPanelResizing = true;
}
else if (ViewRect.Contains(objArg.Location) == true)
{
int col, slice;
if (GetPointItem(objArg.Location, out col, out slice, true))
{
MyCursor = GetContentCursor();
if (ProcessCilButtonDown(col, objArg) == false)
ProcessDvlButtonDown(col, slice);
IsMouseDown = true;
}
IsCopyDrag = false;
}
}
}
}
#region CalendarItem MouseDown processing
/// <summary>
/// CalendarItem left mouseDown processing
/// </summary>
/// <param name="col">DayColumn col index</param>
/// <param name="objArg">MouseEventArgs</param>
private bool ProcessCilButtonDown(int col, MouseEventArgs objArg)
{
CalendarItem item = m_HotSubItem as CalendarItem;
if (item != null)
{
_WasAllDayItem = IsAllDayItem(item);
if (item.HitArea != CalendarItem.eHitArea.None)
{
// Give the user a chance to cancel the
// operation before it starts
if (CalendarView.DoBeforeAppointmentViewChange(this, item,
((item.HitArea == CalendarItem.eHitArea.Move) ?
eViewOperation.AppointmentMove : eViewOperation.AppointmentResize)) == false)
{
_LastCol = col;
_LastBounds = item.Bounds;
_LastPointOffset = objArg.Location;
_LastMovePoint = objArg.Location;
_LastMoveCol = -1;
_LastDm = int.MinValue;
if (IsResizing == false && IsMoving == false)
{
OldStartTime = item.StartTime;
OldEndTime = item.EndTime;
OldOwnerKey = OwnerKey;
}
// Flag appropriate action
if (item.HitArea == CalendarItem.eHitArea.TopResize)
IsStartResizing = true;
else if (item.HitArea == CalendarItem.eHitArea.BottomResize)
IsEndResizing = true;
else if (item.HitArea == CalendarItem.eHitArea.Move)
IsMoving = true;
// Update our initial PosWin display
UpdatePosWin(ViewRect);
}
}
return (true);
}
return (false);
}
#endregion
#region DayView MouseDown processing
/// <summary>
/// Handles DayView left MouseDown events
/// </summary>
/// <param name="col">DayColumn col index</param>
/// <param name="slice">Time slice</param>
private void ProcessDvlButtonDown(int col, int slice)
{
DateTime startDate = GetTime(_DayColumns[col].Date, slice, 0);
DateTime endDate = startDate.AddMinutes(TimeSlotDuration);
ExtendSelection(ref startDate, ref endDate);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
SelectedItem = null;
}
#endregion
#endregion
#region MouseUp processing
/// <summary>
/// MouseUp event processing
/// </summary>
/// <param name="objArg">MouseEventArgs</param>
public override void InternalMouseUp(MouseEventArgs objArg)
{
base.InternalMouseUp(objArg);
CancelScrollTimer();
// Reset our panel resizing flag
_IsPanelResizing = false;
if (SelectedItem != null &&
(IsAllDayItem(SelectedItem) != _WasAllDayItem))
{
ReloadView();
}
}
#endregion
#region MouseMove processing
#region InternalMouseMove
/// <summary>
/// MouseMove event processing
/// </summary>
/// <param name="objArg">MouseEventArgs</param>
public override void InternalMouseMove(MouseEventArgs objArg)
{
// Forward on the event, but only if we are not in
// the middle of moving or resizing a CalendarItem
if (Control.MouseButtons == MouseButtons.None)
ClearMouseStates();
if (!IsMoving && !IsStartResizing && !IsEndResizing)
base.InternalMouseMove(objArg);
if (IsTabMoving == false)
{
if (_IsPanelResizing == true)
{
MyCursor = Cursors.HSplit;
ProcessPanelMove(objArg);
}
else
{
if (InPanelResize(objArg.Location) == true)
{
MyCursor = Cursors.HSplit;
}
else
{
MyCursor = GetContentCursor();
if (objArg.Button == MouseButtons.Left)
ProcessContentMove(objArg);
}
}
}
}
#endregion
#region InPanelResize
/// <summary>
/// Determines if the mouse is in the
/// panel resize area
/// </summary>
/// <param name="pt">Mouse location</param>
/// <returns>true if in the resize area</returns>
private bool InPanelResize(Point pt)
{
if (CalendarView.IsMultiCalendar == true)
{
Rectangle r = ViewRect;
if (pt.X > r.Left && pt.X < r.Right &&
pt.Y > r.Y - 3 && pt.Y < r.Y + 3)
{
return (true);
}
}
return (false);
}
#endregion
#region ProcessPanelMove
/// <summary>
/// Processes the actual panel resizing
/// </summary>
/// <param name="objArg">MouseEventArgs</param>
private void ProcessPanelMove(MouseEventArgs objArg)
{
if (_IsPanelResizing == true)
{
Point pt = objArg.Location;
if (pt.Y < ClientRect.Y + DayOfWeekHeaderHeight)
pt.Y = ClientRect.Y + DayOfWeekHeaderHeight;
else if (pt.Y > ClientRect.Bottom - 50)
pt.Y = ClientRect.Bottom - 50;
int n = pt.Y - (ClientRect.Y + DayOfWeekHeaderHeight);
CalendarView.FixedAllDayPanelHeight = n;
}
}
#endregion
#region ProcessContentMove
/// <summary>
/// Processes content mouse moves
/// </summary>
/// <param name="objArg">MouseEventArgs</param>
private void ProcessContentMove(MouseEventArgs objArg)
{
// Locate where the event took place
// and process it accordingly
int col, slice;
if (GetPointItem(objArg.Location, out col, out slice, false))
{
// The slice is visible, so no need to
// enable scrolling - just process the event
EnableViewScrolling(false);
ProcessMouseMove(col, slice, objArg);
}
else if (IsMouseDown == true)
{
if (DragDropAppointment(objArg) == false)
{
// The selected slice is not visible,
// so we need to enable scrolling
EnableViewScrolling(true);
// Only process the event if the user is selecting
// time slice cells (auto moving apps is intrusive looking)
if (DateSelectionAnchor != null)
{
if (col >= 0)
{
if (slice < 0)
slice = 0;
ProcessDvMouseMove(col, slice);
}
}
}
}
}
#region DragDropAppointment
/// <summary>
/// Initiates a user "DragDrop" operation - if enabled
/// </summary>
/// <param name="objArgs"></param>
/// <returns>True if operation started</returns>
private bool DragDropAppointment(MouseEventArgs objArgs)
{
if (IsMoving == true && CanDrag == true)
{
Point pt = objArgs.Location;
BaseView bv = CalendarView.GetViewFromPoint(pt);
WeekDayView wv = bv as WeekDayView;
if (wv != null && wv != this)
{
eViewArea area = bv.GetViewAreaFromPoint(pt);
if (area == eViewArea.InContent)
{
if (CalendarView.DoAppointmentViewChanging(SelectedItem, wv.OwnerKey, SelectedItem.StartTime,
SelectedItem.EndTime, eViewOperation.AppointmentMove, IsNewCopyDrag) == false)
{
DragCopy();
ClearMouseStates();
CancelScrollTimer();
if (PosWin != null)
PosWin.Hide();
AppointmentView av = SelectedItem as AppointmentView;
if (av != null)
return (wv.DragAppointment(this, av, objArgs.Location));
CustomCalendarItem ci = SelectedItem as CustomCalendarItem;
if (ci != null)
return (wv.DragCustomItem(this, ci, objArgs.Location));
}
}
}
}
return (false);
}
#region DragCustomItem
private bool DragCustomItem(WeekDayView pv, CustomCalendarItem ci, Point pt)
{
// Set the new owner and selected view, and
// recalc the new layout
if (ci.BaseCalendarItem != null)
ci = ci.BaseCalendarItem;
ci.OwnerKey = OwnerKey;
_LastMoveCol = 0;
_LastDm = int.MinValue;
if (NumberOfColumns > 1)
{
DateTime sd = ci.StartTime;
TimeSpan ts = ci.EndTime.Subtract(ci.StartTime);
if (Bounds.X > pv.Bounds.X)
{
ci.StartTime = new DateTime(_DayColumns[0].Date.Year,
_DayColumns[0].Date.Month, _DayColumns[0].Date.Day, sd.Hour, sd.Minute, 0);
}
else
{
_LastMoveCol = NumberOfColumns - 1;
ci.StartTime = new DateTime(_DayColumns[NumberOfColumns - 1].Date.Year,
_DayColumns[NumberOfColumns - 1].Date.Month,
_DayColumns[NumberOfColumns - 1].Date.Day, sd.Hour, sd.Minute, 0);
}
ci.EndTime = ci.StartTime.Add(ts);
}
NeedRecalcLayout = true;
RecalcSize();
CalendarView.SelectedOwnerIndex = this.DisplayedOwnerKeyIndex;
// Get the new view
CustomCalendarItem view = GetCustomCalendarItem(ci);
if (view != null)
SetNewDragItem(pv, view, pt);
return (true);
}
#endregion
#region DragAppointment
/// <summary>
/// Drags the given appointment from one view to another
/// </summary>
/// <param name="pv">Previous view</param>
/// <param name="av">Item to move</param>
private bool DragAppointment(WeekDayView pv, AppointmentView av, Point pt)
{
// Set the new owner and selected view, and
// recalc the new layout
av.Appointment.OwnerKey = OwnerKey;
_LastMoveCol = 0;
_LastDm = int.MinValue;
if (NumberOfColumns > 1)
{
DateTime sd = av.Appointment.StartTime;
if (Bounds.X > pv.Bounds.X)
{
av.Appointment.MoveTo(
new DateTime(_DayColumns[0].Date.Year, _DayColumns[0].Date.Month,
_DayColumns[0].Date.Day, sd.Hour, sd.Minute, 0));
}
else
{
_LastMoveCol = NumberOfColumns - 1;
av.Appointment.MoveTo(
new DateTime(_DayColumns[NumberOfColumns - 1].Date.Year,
_DayColumns[NumberOfColumns - 1].Date.Month,
_DayColumns[NumberOfColumns - 1].Date.Day, sd.Hour, sd.Minute, 0));
}
}
NeedRecalcLayout = true;
RecalcSize();
CalendarView.SelectedOwnerIndex = this.DisplayedOwnerKeyIndex;
// Get the new view
AppointmentView view = GetAppointmentView(av.Appointment);
if (view != null)
SetNewDragItem(pv, view, pt);
return (true);
}
#endregion
#region SetNewDragItem
private void SetNewDragItem(WeekDayView pv, CalendarItem view, Point pt)
{
_LastBounds = pv._LastBounds;
_LastMovePoint = pv._LastMovePoint;
_LastPointOffset = pv._LastPointOffset;
int dy = _LastPointOffset.Y - _LastBounds.Y;
CalendarView.CalendarPanel.InternalMouseMove(new
MouseEventArgs(MouseButtons.None, 0, view.Bounds.X, view.Bounds.Y - dy, 0));
MouseEventArgs args = new
MouseEventArgs(MouseButtons.Left, 1, view.Bounds.X, view.Bounds.Y + dy, 0);
IsMoving = true;
InternalMouseMove(args);
CalendarView.CalendarPanel.InternalMouseDown(args);
SelectedItem = view;
IsNewCopyDrag = true;
}
#endregion
#endregion
#endregion
#region GetContentCursor
/// <summary>
/// Gets the cursor
/// </summary>
/// <returns>Cursor</returns>
private Cursor GetContentCursor()
{
CalendarItem item = m_HotSubItem as CalendarItem;
if (item != null)
{
switch (item.HitArea)
{
case CalendarItem.eHitArea.TopResize:
case CalendarItem.eHitArea.BottomResize:
return (Cursors.SizeNS);
case CalendarItem.eHitArea.Move:
return (IsMoving ? Cursors.SizeAll : DefaultCursor);
}
}
return (DefaultCursor);
}
#endregion
#region ProcessMouseMove
/// <summary>
/// Processes user MouseMove
/// </summary>
/// <param name="col">DayColumn</param>
/// <param name="slice">Slice</param>
/// <param name="objArg"></param>
private void ProcessMouseMove(int col, int slice, MouseEventArgs objArg)
{
if (DateSelectionAnchor != null)
{
ProcessDvMouseMove(col, slice);
}
else if (SelectedItem != null)
{
if (objArg.Location.Equals(_LastMovePoint) == false)
{
if (IsMoving == true)
ProcessItemMove(col, slice, objArg);
else if (IsStartResizing == true)
ProcessItemTopResize(col, slice, objArg);
else if (IsEndResizing == true)
ProcessItemBottomResize(col, slice, objArg);
_LastMovePoint = objArg.Location;
}
}
}
#endregion
#region DayView mouseMove processing
/// <summary>
/// Processes DayView mouseMove events
/// </summary>
/// <param name="col">DayColumn col index</param>
/// <param name="slice">Time slice</param>
private void ProcessDvMouseMove(int col, int slice)
{
DateTime date = GetTime(_DayColumns[col].Date, slice, 0);
// Let the user select forwards or backwards
if (date >= DateSelectionAnchor)
{
CalendarView.DateSelectionStart = DateSelectionAnchor.Value;
CalendarView.DateSelectionEnd = date.AddMinutes(TimeSlotDuration);
}
else
{
CalendarView.DateSelectionStart = date;
CalendarView.DateSelectionEnd = DateSelectionAnchor.Value.AddMinutes(TimeSlotDuration);
}
}
#endregion
#region CalendarItem MouseMove processing
#region ProcessItemMove
/// <summary>
/// Processes CalendarItem mouseMove events
/// </summary>
/// <param name="col">DayColumn col index</param>
/// <param name="slice">Time slice</param>
/// <param name="objArg"></param>
private void ProcessItemMove(int col, int slice, MouseEventArgs objArg)
{
// Calculate our new item date
int dm = GetDeltaMinutes(slice, true, objArg);
if (_LastDm == int.MinValue)
_LastDm = dm;
int ddm = dm - _LastDm;
if (_LastMoveCol == -1)
_LastMoveCol = col;
if (col != _LastMoveCol)
ddm += ((col - _LastMoveCol) * HoursPerDay * MinutesPerHour);
_LastDm = dm;
_LastMoveCol = col;
DateTime newDate = SelectedItem.StartTime.AddMinutes(ddm);
TimeSpan ts = SelectedItem.EndTime - SelectedItem.StartTime;
if (newDate != SelectedItem.StartTime)
{
if (CalendarView.AllDayDisplayMode != eAllDayDisplayMode.None)
{
// Make sure we don't cross day boundaries
DateTime start = GetTime(_DayColumns[col].Date, 0, 0);
DateTime end = start.AddMinutes(NumberOfActiveSlices * TimeSlotDuration);
if (newDate < start)
newDate = start;
if (newDate + ts > end)
newDate -= (newDate + ts) - end;
}
// If we have a new date, set our item to it
if (newDate != SelectedItem.StartTime)
{
if (DragCopy() == false)
{
try
{
if (SelectedItem is CustomCalendarItem)
CalendarView.CustomItems.BeginUpdate();
else
CalendarModel.BeginUpdate();
// Make the move
if (CalendarView.DoAppointmentViewChanging(SelectedItem, null, newDate,
newDate + ts, eViewOperation.AppointmentMove,
IsCopyDrag) == false)
{
SelectedItem.StartTime = newDate;
SelectedItem.EndTime = newDate + ts;
InvalidateItems(col);
}
}
finally
{
if (SelectedItem is CustomCalendarItem)
CalendarView.CustomItems.EndUpdate();
else
CalendarModel.EndUpdate();
}
}
else
{
_LastMoveCol = _LastCol;
}
}
}
}
#endregion
#endregion
#region CalendarItem MouseResize processing
#region ProcessItemTopResize
/// <summary>
/// Processes CalendarItem left resizing
/// </summary>
/// <param name="slice">Time slice</param>
/// <param name="objArg"></param>
private void ProcessItemTopResize(int col, int slice, MouseEventArgs objArg)
{
int dm = GetDeltaMinutes(slice, true, objArg);
DateTime newStartTime;
if (CalendarView.AllDayDisplayMode != eAllDayDisplayMode.None)
{
newStartTime = new DateTime(
SelectedItem.StartTime.Year, SelectedItem.StartTime.Month, SelectedItem.StartTime.Day);
newStartTime = GetTime(newStartTime, 0, dm);
}
else
{
newStartTime = GetTime(_DayColumns[col].Date.Date, 0, dm);
if (newStartTime < _DayColumns[0].Date)
newStartTime = _DayColumns[0].Date;
}
if (newStartTime != SelectedItem.StartTime && newStartTime < SelectedItem.EndTime)
{
if ((SelectedItem.EndTime - newStartTime).TotalMinutes < 0)
newStartTime = SelectedItem.EndTime.AddMinutes(-1);
ResizeItem(_LastCol, newStartTime, SelectedItem.EndTime);
}
}
#endregion
#region ProcessItemBottomResize
/// <summary>
/// Processes CalendarItem right resizing
/// </summary>
/// <param name="slice">Time slice</param>
/// <param name="objArg"></param>
private void ProcessItemBottomResize(int col, int slice, MouseEventArgs objArg)
{
int dm = GetDeltaMinutes(slice, false, objArg);
DateTime newEndTime;
DateTime end;
if (CalendarView.AllDayDisplayMode != eAllDayDisplayMode.None)
{
newEndTime = new DateTime(
SelectedItem.StartTime.Year, SelectedItem.StartTime.Month, SelectedItem.StartTime.Day);
if (newEndTime < _DayColumns[0].Date)
newEndTime = _DayColumns[0].Date;
newEndTime = GetTime(newEndTime, 0, dm);
end = GetTime(_DayColumns[_LastCol].Date, NumberOfActiveSlices, 0);
}
else
{
newEndTime = GetTime(_DayColumns[col].Date.Date, 0, dm);
if (newEndTime < _DayColumns[0].Date)
newEndTime = _DayColumns[0].Date;
end = GetTime(_DayColumns[_DayColumns.Length - 1].Date, NumberOfActiveSlices, 0);
}
if (newEndTime > end)
newEndTime = end;
if (newEndTime != SelectedItem.EndTime && newEndTime > SelectedItem.StartTime)
{
if ((newEndTime - SelectedItem.StartTime).TotalMinutes < 0)
newEndTime = SelectedItem.StartTime.AddMinutes(1);
ResizeItem(_LastCol, SelectedItem.StartTime, newEndTime);
}
}
#endregion
#region ResizeItem
/// <summary>
/// Initiates the resize of the selected item
/// </summary>
/// <param name="col"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
private void ResizeItem(int col, DateTime startTime, DateTime endTime)
{
// Let the user cancel the operation if desired
if (CalendarView.DoAppointmentViewChanging(SelectedItem, null, startTime,
endTime, eViewOperation.AppointmentResize, IsNewCopyDrag) == false)
{
InvalidateItems(col);
SelectedItem.StartTime = startTime;
SelectedItem.EndTime = endTime;
}
}
#endregion
#endregion
#region GetDeltaMinutes
/// <summary>
/// Gets the changes in minutes
/// from the last mouse operation (move or resize)
/// </summary>
/// <param name="slice">Current slice</param>
/// <param name="ftop">Flag denoting top or bottom delta</param>
/// <param name="objArg">MouseEventArgs</param>
/// <returns>Delta minutes</returns>
private int GetDeltaMinutes(int slice, bool ftop, MouseEventArgs objArg)
{
// Calculate our delta minutes
Rectangle t = GetSliceRect(0, slice);
int dm = (objArg.Location.Y - _LastPointOffset.Y);
dm += ftop ? _LastBounds.Top - t.Top
: _LastBounds.Bottom - t.Bottom;
dm = (int)(TimeSlotDuration * dm / TimeSliceHeight);
// If the Alt key is not pressed, then round
// our value off to the nearest slice
if ((Control.ModifierKeys & Keys.Alt) != Keys.Alt)
{
slice += (dm / TimeSlotDuration);
dm = 0;
}
dm += (slice * TimeSlotDuration);
// Make sure we don't cross our day boundaries
if (CalendarView.AllDayDisplayMode != eAllDayDisplayMode.None)
{
if (ftop == true)
{
if (dm < 0)
dm = 0;
}
else
{
dm += TimeSlotDuration;
if (dm >= MinutesPerHour * HoursPerDay)
dm = MinutesPerHour * HoursPerDay - 1;
}
}
return (dm);
}
#endregion
#region InvalidateItems
/// <summary>
/// Invalidates altered DayColumns
/// </summary>
/// <param name="col">Current column</param>
internal void InvalidateItems(int col)
{
if (SelectedItem.IsRecurring == false)
{
_DayColumns[_LastCol].NeedRecalcLayout = true;
_DayColumns[col].NeedRecalcLayout = true;
InvalidateRect(_DayColumns[col].Bounds, true);
if (_LastCol != col)
InvalidateRect(_DayColumns[_LastCol].Bounds);
}
else
{
NeedRecalcLayout = true;
}
_LastCol = col;
}
#endregion
#region View Scrolling support
#region EnableViewScrolling
/// <summary>
/// Routine to enable or disable view scrolling
/// </summary>
/// <param name="enable">true to enable</param>
private void EnableViewScrolling(bool enable)
{
if (enable == true)
{
if (VsPanel.ScrollBar.Maximum > VsPanel.ScrollBar.LargeChange)
{
if (_ScrollViewTimer == null)
{
_ScrollViewTimer = new Timer();
_ScrollViewTimer.Interval = 10;
_ScrollViewTimer.Tick += ScrollViewTimerTick;
_ScrollViewTimer.Start();
}
}
}
else
{
CancelScrollTimer();
}
}
#endregion
#region CancelScrollTimer
/// <summary>
/// Cancels the view scroll timer
/// </summary>
private void CancelScrollTimer()
{
// Dispose of our scroll timer
if (_ScrollViewTimer != null)
{
_ScrollViewTimer.Stop();
_ScrollViewTimer.Tick -= ScrollViewTimerTick;
_ScrollViewTimer = null;
}
}
#endregion
#region ScrollAmount
/// <summary>
/// Determines the amount to scroll (which is
/// based loosely upon the delta magnitude)
/// </summary>
/// <param name="delta">Point delta</param>
/// <returns>Scroll amount</returns>
private int ScrollAmount(int delta)
{
int dy = Math.Abs(delta);
int amt = (dy < 16 ? 2 : dy < 32 ? 8 : 32);
return (delta < 0 ? -amt : amt);
}
#endregion
#region ScrollViewTimer_Tick
/// <summary>
/// Handles view scroll timer ticks
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">EventArgs</param>
private void ScrollViewTimerTick(object sender, EventArgs e)
{
Control c = (Control)this.GetContainerControl(true);
if (c != null)
{
// Calculate our delta
Point pt = c.PointToClient(Cursor.Position);
Rectangle r = ViewRect;
int dy = (pt.Y < r.Top) ? ScrollAmount(pt.Y - r.Top) :
(pt.Y >= r.Bottom) ? ScrollAmount(pt.Y - r.Bottom) : 0;
// Scroll if necessary
if (dy != 0)
{
int value = VsPanel.ScrollBar.Value + dy;
value = Math.Max(value, 0);
value = Math.Min(value, VsPanel.ScrollBar.Maximum);
if (VsPanel.ScrollBar.Value != value)
{
VsPanel.ScrollBar.Value = value;
if (PosWin != null)
PosWin.Hide();
InternalMouseMove(new
MouseEventArgs(MouseButtons.Left, 0, pt.X, pt.Y, 0));
}
}
}
}
#endregion
#endregion
#endregion
#endregion
#region InternalKeyDown
#region InternalKeyDown
/// <summary>
/// Processes KeyDown events
/// </summary>
/// <param name="objArg"></param>
public override void InternalKeyDown(KeyEventArgs objArg)
{
switch (objArg.KeyData)
{
case Keys.Up:
case Keys.Up | Keys.Shift:
case Keys.Up | Keys.Control:
case Keys.Up | Keys.Control | Keys.Shift:
ProcessUpDownKey(objArg, -CalendarView.TimeSlotDuration);
break;
case Keys.Down:
case Keys.Down | Keys.Shift:
case Keys.Down | Keys.Control:
case Keys.Down | Keys.Control | Keys.Shift:
ProcessUpDownKey(objArg, CalendarView.TimeSlotDuration);
break;
case Keys.Left:
case Keys.Left | Keys.Shift:
case Keys.Left | Keys.Control:
case Keys.Left | Keys.Control | Keys.Shift:
ProcessLeftRightKey(objArg, -1);
break;
case Keys.Right:
case Keys.Right | Keys.Shift:
case Keys.Right | Keys.Control:
case Keys.Right | Keys.Control | Keys.Shift:
ProcessLeftRightKey(objArg, 1);
break;
case Keys.Home:
case Keys.Home | Keys.Shift:
case Keys.Home | Keys.Control:
case Keys.Home | Keys.Control | Keys.Shift:
ProcessHomeKey(objArg);
break;
case Keys.End:
case Keys.End | Keys.Shift:
case Keys.End | Keys.Control:
case Keys.End | Keys.Control | Keys.Shift:
ProcessEndKey(objArg);
break;
case Keys.PageUp:
case Keys.PageUp | Keys.Shift:
case Keys.PageUp | Keys.Control:
case Keys.PageUp | Keys.Control | Keys.Shift:
ProcessPageUpDownKey(objArg, -1);
break;
case Keys.PageDown:
case Keys.PageDown | Keys.Shift:
case Keys.PageDown | Keys.Control:
case Keys.PageDown | Keys.Control | Keys.Shift:
ProcessPageUpDownKey(objArg, 1);
break;
}
}
#endregion
#region ProcessUpDownKey
/// <summary>
/// Processes Up and Down key events
/// </summary>
/// <param name="objArg"></param>
/// <param name="dy"></param>
protected virtual void ProcessUpDownKey(KeyEventArgs objArg, int dy)
{
if (ValidDateSelection())
{
DateTime startDate = CalendarView.DateSelectionStart.Value;
DateTime endDate = CalendarView.DateSelectionEnd.Value;
if (startDate.Equals(DateSelectionAnchor.Value) == true)
startDate = endDate.AddMinutes(-TimeSlotDuration);
startDate = startDate.AddMinutes(dy);
DateTime viewStart = GetTime(DayColumns[0].Date, 0, 0);
DateTime viewEnd = viewStart.AddMinutes(NumberOfActiveSlices * TimeSlotDuration);
endDate = startDate.AddMinutes(TimeSlotDuration);
if (startDate >= viewStart && endDate <= viewEnd)
{
ExtendSelection(ref startDate, ref endDate);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
EnsureSelectionVisible();
}
}
objArg.Handled = true;
}
#endregion
#region ProcessLeftRightKey
/// <summary>
/// Processes Left and Right key events
/// </summary>
/// <param name="objArg"></param>
/// <param name="dx"></param>
protected virtual void ProcessLeftRightKey(KeyEventArgs objArg, int dx)
{
if (CalendarView.WeekDayCanExtendRange == true)
{
DateTime oldDate = CalendarView.DayViewDate;
DateTime newDate = CalendarView.DayViewDate.AddDays(dx);
if (CalendarView.DoViewDateChanging(this,
oldDate, oldDate, ref newDate, ref newDate) == false)
{
if (ValidDateSelection())
{
dx = (newDate - oldDate).Days;
DateTime startDate = CalendarView.DateSelectionStart.Value;
DateTime endDate = CalendarView.DateSelectionEnd.Value;
startDate = startDate.AddDays(dx);
endDate = endDate.AddDays(dx);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
DateSelectionAnchor = DateSelectionAnchor.Value.AddDays(dx);
}
CalendarView.DayViewDate = CalendarView.DayViewDate.AddDays(dx);
}
}
objArg.Handled = true;
}
#endregion
#region ProcessHomeKey
/// <summary>
/// Processes Home key events
/// </summary>
/// <param name="objArg"></param>
protected virtual void ProcessHomeKey(KeyEventArgs objArg)
{
int col = GetHomeEndCol();
if (col >= 0)
{
DateTime startDate = GetTime(DayColumns[col].Date, 0, 0);
if ((objArg.Modifiers & Keys.Control) != Keys.Control)
{
WorkTime wt = DayColumns[col].WorkStartTime;
if (wt.IsEmpty == false)
startDate = DayColumns[col].Date.AddMinutes(wt.Hour * 60 + wt.Minute);
}
DateTime endDate = startDate.AddMinutes(TimeSlotDuration);
ExtendSelection(ref startDate, ref endDate);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
EnsureSelectionVisible();
}
objArg.Handled = true;
}
#endregion
#region ProcessEndKey
/// <summary>
/// Processes End Key events
/// </summary>
/// <param name="objArg"></param>
protected virtual void ProcessEndKey(KeyEventArgs objArg)
{
int col = GetHomeEndCol();
if (col >= 0)
{
DateTime startDate = GetTime(DayColumns[col].Date, NumberOfActiveSlices, 0);
if ((objArg.Modifiers & Keys.Control) != Keys.Control)
{
WorkTime wt = DayColumns[col].WorkEndTime;
if (wt.IsEmpty == false)
startDate = DayColumns[col].Date.AddMinutes(wt.Hour * 60 + wt.Minute);
}
DateTime endDate = startDate;
startDate = startDate.AddMinutes(-TimeSlotDuration);
ExtendSelection(ref startDate, ref endDate);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
EnsureSelectionVisible();
}
objArg.Handled = true;
}
#endregion
#region ProcessPageUpDownKey
/// <summary>
/// Processes Page Up and Down key events
/// </summary>
/// <param name="objArg"></param>
/// <param name="dy">Paging direction (-1, 1)</param>
protected virtual void ProcessPageUpDownKey(KeyEventArgs objArg, int dy)
{
if (ValidDateSelection())
{
DateTime startDate = CalendarView.DateSelectionStart.Value;
DateTime endDate = CalendarView.DateSelectionEnd.Value;
int col = GetColumnFromDate(startDate);
if ((uint)col < DayColumns.Length)
{
DateTime viewStart = GetTime(DayColumns[col].Date, 0, 0);
DateTime viewEnd = viewStart.AddMinutes(NumberOfActiveSlices * TimeSlotDuration);
if (startDate.Equals(DateSelectionAnchor.Value) == true)
startDate = endDate.AddMinutes(-TimeSlotDuration);
startDate = (dy < 0)
? GetPageUpStartDate(viewStart, startDate)
: GetPageDownStartDate(viewStart, viewEnd, startDate);
endDate = startDate.AddMinutes(TimeSlotDuration);
if (startDate >= viewStart && endDate <= viewEnd)
{
ExtendSelection(ref startDate, ref endDate);
CalendarView.DateSelectionStart = startDate;
CalendarView.DateSelectionEnd = endDate;
EnsureSelectionVisible();
}
}
}
objArg.Handled = true;
}
private DateTime GetPageUpStartDate(
DateTime viewStart, DateTime startDate)
{
DateTime fosDate = viewStart.AddMinutes(TimeSlotDuration*FirstOnScreenSlice);
if (startDate.Equals(fosDate) == false)
return (fosDate);
startDate = startDate.AddMinutes(-TimeSlotDuration * OnScreenSlices);
if (startDate < viewStart)
startDate = viewStart;
return (startDate);
}
private DateTime GetPageDownStartDate(
DateTime viewStart, DateTime viewEnd, DateTime startDate)
{
DateTime eosDate = viewStart.AddMinutes(TimeSlotDuration * LastOnScreenSlice);
if (startDate.Equals(eosDate) == false)
return (eosDate);
startDate = eosDate.AddMinutes(TimeSlotDuration * OnScreenSlices);
if (startDate > viewEnd)
startDate = viewEnd;
return (startDate);
}
#endregion
#region GetHomeEndCol
/// <summary>
/// Gets the Home and End column from the current
/// selection range
/// </summary>
/// <returns></returns>
private int GetHomeEndCol()
{
if (ValidDateSelection() == true)
{
if (CalendarView.DateSelectionStart.Equals(DateSelectionAnchor.Value) == true)
return (GetColumnFromDate(DateSelectionEnd.Value.AddMinutes(-TimeSlotDuration)));
return (GetColumnFromDate(DateSelectionStart.Value));
}
return ((NumberOfColumns == 1) ? 0 : -1);
}
#endregion
#region GetColumnFromDate
/// <summary>
/// Gets the view column from the given date
/// </summary>
/// <param name="date"></param>
/// <returns>The DayColumns index, or -1 if invalid.</returns>
public int GetColumnFromDate(DateTime date)
{
for (int i = 0; i < DayColumns.Length; i++)
{
DateTime dc = DayColumns[i].Date.Date;
if (dc <= date && dc.AddDays(1) > date)
return (i);
}
return (-1);
}
#endregion
#region EnsureSelectionVisible
/// <summary>
/// Ensures the given selection is visible
/// </summary>
protected virtual void EnsureSelectionVisible()
{
DateTime start = CalendarView.DateSelectionStart.Value;
DateTime end = CalendarView.DateSelectionEnd.Value;
bool refreshed = start.Equals(DateSelectionAnchor) ?
EnsureDateVisible(end.AddMinutes(-CalendarView.TimeSlotDuration)) :
EnsureDateVisible(start);
if (refreshed == false)
Refresh();
}
#endregion
#region EnsureDateVisible
/// <summary>
/// Ensures the given date is visible
/// </summary>
/// <param name="date"></param>
/// <returns></returns>
protected virtual bool EnsureDateVisible(DateTime date)
{
if (CalendarView.WeekDayVScrollPanel.ScrollBar.Maximum >
CalendarView.WeekDayVScrollPanel.ScrollBar.LargeChange)
{
Rectangle r = ViewRect;
int offset = (int)(date.Hour * CalendarView.SlotsPerHour * CalendarView.TimeSliceHeight +
(CalendarView.TimeSliceHeight * date.Minute) / CalendarView.TimeSlotDuration);
offset -= (int)(CalendarView.StartSlice * CalendarView.TimeSliceHeight);
int top = CalendarView.WeekDayVScrollPanel.ScrollBar.Value;
int bottom = top + r.Height;
if (offset < top || offset + CalendarView.TimeSliceHeight > bottom)
{
if (offset + CalendarView.TimeSliceHeight > bottom)
offset -= (int)(r.Height - CalendarView.TimeSliceHeight);
offset = Math.Min(offset, CalendarView.WeekDayVScrollPanel.ScrollBar.Maximum);
offset = Math.Max(offset, 0);
CalendarView.WeekDayVScrollPanel.ScrollBar.Value = offset;
return (true);
}
return (false);
}
return (true);
}
#endregion
#endregion
#region TimeSlice support routines
#region GetPointItem
/// <summary>
/// Gets the column and slice index item for
/// the given point
/// </summary>
/// <param name="pt">Point</param>
/// <param name="col">[out] DayColumn column</param>
/// <param name="slice">[out] Time slice</param>
/// <param name="partial"></param>
/// <returns>Item visible state</returns>
private bool GetPointItem(Point pt, out int col, out int slice, bool partial)
{
slice = -1;
if ((col = GetPointCol(pt)) >= 0)
{
slice = GetPointSlice(pt, col);
if (slice >= 0 && slice < NumberOfActiveSlices)
return (IsSliceVisible(col, slice, partial));
}
return (false);
}
#endregion
#region IsSliceVisible
/// <summary>
/// Determines if a given slice is visible
/// </summary>
/// <param name="col">DayColumn</param>
/// <param name="slice">Slice in question</param>
/// <param name="partial">Partially visible is ok</param>
/// <returns>Slice visibility</returns>
private bool IsSliceVisible(int col, int slice, bool partial)
{
Rectangle r = GetSliceRect(col, slice);
Rectangle t = ViewRect;
if (partial == true)
{
if (r.Bottom < t.Top)
return (false);
if (r.Top > t.Bottom)
return (false);
}
else
{
if (r.Top < t.Top)
return (false);
if (r.Bottom > t.Bottom)
return (false);
}
return (true);
}
#endregion
#region GetSliceRect
/// <summary>
/// Gets the given slice rectangle
/// </summary>
/// <param name="col">Column</param>
/// <param name="slice">Slice</param>
/// <returns>Bounding rectangle</returns>
private Rectangle GetSliceRect(int col, int slice)
{
if ((uint)col < _DayColumns.Length)
{
Rectangle r = _DayColumns[col].Bounds;
float n = slice * TimeSliceHeight;
r.Y += (int)(n);
r.Height = (int)(n + TimeSliceHeight) - (int)n;
return (r);
}
return (Rectangle.Empty);
}
#endregion
#region GetPointCol
/// <summary>
/// Gets the col index for the given point
/// </summary>
/// <param name="pt">Point</param>
/// <returns>Column</returns>
private int GetPointCol(Point pt)
{
for (int i = 0; i < _NumberOfColumns; i++)
{
if (pt.X >= _DayColumns[i].Bounds.X &&
pt.X < _DayColumns[i].Bounds.Right)
{
return (i);
}
}
return (-1);
}
#endregion
#region GetPointSlice
/// <summary>
/// Gets the slice index for the given point
/// </summary>
/// <param name="pt">Point</param>
/// <param name="col"></param>
/// <returns>Slice index</returns>
private int GetPointSlice(Point pt, int col)
{
int s1 = (int)(-_VScrollPos / TimeSliceHeight);
Rectangle r = GetSliceRect(col, s1);
if (pt.Y < r.Top)
return (s1 - 1);
for (int i = s1; i < NumberOfActiveSlices; i++)
{
r = GetSliceRect(col, i);
if (pt.Y >= r.Top && pt.Y < r.Bottom)
return (i);
}
return (NumberOfActiveSlices - 1);
}
#endregion
#region GetTime
/// <summary>
/// Gets the DateTime adjusted by the given
/// slice and minutes delta
/// </summary>
/// <param name="date"></param>
/// <param name="slice"></param>
/// <param name="minutes"></param>
/// <returns></returns>
private DateTime GetTime(DateTime date, int slice, int minutes)
{
return (date.AddMinutes((StartSlice + slice) * TimeSlotDuration + minutes));
}
#endregion
#endregion
#region IDisposable Members
protected override void Dispose(bool disposing)
{
if (disposing == true && IsDisposed == false)
{
ResetView();
BusyBrush = null;
WorkBrush = null;
OffWorkBrush = null;
SelectedBrush = null;
HookEvents(false);
}
base.Dispose(disposing);
}
#endregion
#region Copy object support
/// <summary>
/// Returns copy of the item.
/// </summary>
public override BaseItem Copy()
{
WeekDayView objCopy = new WeekDayView(this.CalendarView, this.ECalendarView);
CopyToItem(objCopy);
return (objCopy);
}
/// <summary>
/// Copies the WeekDayView specific properties to new instance of the item.
/// </summary>
/// <param name="copy">New WeekDayView instance</param>
protected override void CopyToItem(BaseItem copy)
{
WeekDayView objCopy = copy as WeekDayView;
base.CopyToItem(objCopy);
}
#endregion
#region DaySlot class def
private class DaySlot
{
public Rectangle Bounds;
public bool Selected;
public DaySlotAppearance Appearance;
}
#endregion
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink