1340 lines
38 KiB
C#
1340 lines
38 KiB
C#
#if FRAMEWORK20
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.ScrollBar;
|
|
using DevComponents.DotNetBar.Touch;
|
|
|
|
namespace DevComponents.DotNetBar.Schedule
|
|
{
|
|
public class CalendarPanel : BaseItem
|
|
{
|
|
#region Private variables
|
|
|
|
private CalendarView _CalendarView; // Associated CalendarView
|
|
|
|
private HScrollBarAdv _HScrollBar; // Horizontal scroll bar
|
|
private int _HScrollPos;
|
|
private int _HsMaximum;
|
|
|
|
private VScrollBarAdv _VScrollBar; // Vertical scroll bar
|
|
private int _VScrollPos;
|
|
private int _VsMaximum;
|
|
|
|
private Size _AutoScrollMinSize = Size.Empty;
|
|
private Point _AutoScrollPosition = Point.Empty;
|
|
|
|
private TouchHandler _TouchHandler;
|
|
private Rectangle _InnerBounds;
|
|
|
|
private HScrollBarAdv _AHScrollBar; // Active Horizontal scroll bar
|
|
private VScrollBarAdv _AVScrollBar; // Active Vertical scroll bar
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// This is the main container panel for all
|
|
/// BaseView and TimeRulerPanel objects
|
|
/// </summary>
|
|
/// <param name="calendarView">CalendarView</param>
|
|
public CalendarPanel(CalendarView calendarView)
|
|
{
|
|
_CalendarView = calendarView;
|
|
|
|
SetIsContainer(true);
|
|
|
|
_CalendarView.SelectedViewChanged += _CalendarView_SelectedViewChanged;
|
|
|
|
if (BarFunctions.IsWindows7 && TouchHandler.IsTouchEnabled)
|
|
{
|
|
_TouchHandler = new TouchHandler(_CalendarView, eTouchHandlerType.Gesture);
|
|
|
|
_TouchHandler.PanBegin += TouchHandlerPanBegin;
|
|
_TouchHandler.Pan += TouchHandlerPan;
|
|
_TouchHandler.PanEnd += TouchHandlerPanEnd;
|
|
}
|
|
}
|
|
|
|
#region Internal properties
|
|
|
|
#region AutoScrollMinSize
|
|
|
|
internal Size AutoScrollMinSize
|
|
{
|
|
get { return (_AutoScrollMinSize); }
|
|
|
|
set
|
|
{
|
|
_AutoScrollMinSize = value;
|
|
|
|
RecalcSize();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AutoScrollPosition
|
|
|
|
internal Point AutoScrollPosition
|
|
{
|
|
get
|
|
{
|
|
Point pt = Point.Empty;
|
|
|
|
if (_AHScrollBar != null && _AHScrollBar.Visible == true)
|
|
pt.X = _AHScrollBar.Value * _CalendarView.TimeLineColumnWidth;
|
|
|
|
if (_AVScrollBar != null && _AVScrollBar.Visible == true)
|
|
pt.Y = _AVScrollBar.Value;
|
|
|
|
return (pt);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_CalendarView.SelectedView == eCalendarView.TimeLine)
|
|
{
|
|
if (_CalendarView.TimeLineColumnWidth > 0)
|
|
value.X /= _CalendarView.TimeLineColumnWidth;
|
|
}
|
|
|
|
if (_AHScrollBar != null && _AHScrollBar.Visible == true)
|
|
{
|
|
if (value.X != _AHScrollBar.Value)
|
|
{
|
|
_AHScrollBar.Value =
|
|
Math.Min(_AHScrollBar.Maximum,
|
|
Math.Max(_AHScrollBar.Minimum, value.X));
|
|
}
|
|
}
|
|
|
|
if (_AVScrollBar != null && _AVScrollBar.Visible == true)
|
|
{
|
|
if (value.Y != _AVScrollBar.Value)
|
|
{
|
|
_AVScrollBar.Value =
|
|
Math.Min(_AVScrollBar.Maximum,
|
|
Math.Max(_AVScrollBar.Minimum, value.Y));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AHScrollBar
|
|
|
|
internal HScrollBarAdv AHScrollBar
|
|
{
|
|
get { return (_AHScrollBar); }
|
|
set { _AHScrollBar = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AVScrollBar
|
|
|
|
internal VScrollBarAdv AVScrollBar
|
|
{
|
|
get { return (_AVScrollBar); }
|
|
set { _AVScrollBar = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Checkit
|
|
|
|
internal bool Checkit
|
|
{
|
|
get { return (m_CheckMouseMovePressed); }
|
|
set { m_CheckMouseMovePressed = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region HScrollBar
|
|
|
|
internal HScrollBarAdv HScrollBar
|
|
{
|
|
get { return (_HScrollBar); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InnerBounds
|
|
|
|
internal Rectangle InnerBounds
|
|
{
|
|
get { return (_InnerBounds); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region VScrollBar
|
|
|
|
internal VScrollBarAdv VScrollBar
|
|
{
|
|
get { return (_VScrollBar); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Event processing
|
|
|
|
/// <summary>
|
|
/// Handles SelectedView changes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void _CalendarView_SelectedViewChanged(object sender, SelectedViewEventArgs e)
|
|
{
|
|
if (e.OldValue == eCalendarView.TimeLine)
|
|
{
|
|
if (_AVScrollBar != null)
|
|
_AVScrollBar.Visible = false;
|
|
}
|
|
|
|
if (e.NewValue == eCalendarView.TimeLine)
|
|
{
|
|
if (_HScrollBar != null)
|
|
_HScrollBar.Visible = false;
|
|
}
|
|
|
|
switch (e.NewValue)
|
|
{
|
|
case eCalendarView.TimeLine:
|
|
AVScrollBar = VScrollBar;
|
|
AHScrollBar = _CalendarView.TimeLineHScrollPanel.ScrollBar;
|
|
break;
|
|
|
|
case eCalendarView.Day:
|
|
case eCalendarView.Week:
|
|
AVScrollBar = _CalendarView.WeekDayVScrollBar;
|
|
AHScrollBar = HScrollBar;
|
|
break;
|
|
|
|
case eCalendarView.Year:
|
|
AVScrollBar = _CalendarView.YearVScrollPanel.ScrollBar;
|
|
AHScrollBar = HScrollBar;
|
|
break;
|
|
|
|
default:
|
|
AVScrollBar = null;
|
|
AHScrollBar = null;
|
|
break;
|
|
}
|
|
|
|
Size asMinSize = Size.Empty;
|
|
|
|
if (_AVScrollBar != null && _AVScrollBar.Visible == true)
|
|
asMinSize.Height = _AVScrollBar.Maximum;
|
|
|
|
if (_AHScrollBar != null && _AHScrollBar.Visible == true)
|
|
{
|
|
asMinSize.Width = _AHScrollBar.Maximum;
|
|
|
|
if (e.NewValue == eCalendarView.TimeLine)
|
|
asMinSize.Width *= _CalendarView.TimeLineColumnWidth;
|
|
}
|
|
|
|
_AutoScrollMinSize = asMinSize;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RecalcSize
|
|
|
|
/// <summary>
|
|
/// Performs object recalc processing
|
|
/// </summary>
|
|
public override void RecalcSize()
|
|
{
|
|
_InnerBounds = Bounds;
|
|
|
|
if (SubItems.Count > 0)
|
|
{
|
|
if (Bounds.Width > 0 && Bounds.Height > 0)
|
|
{
|
|
switch (_CalendarView.SelectedView)
|
|
{
|
|
case eCalendarView.Day:
|
|
case eCalendarView.Week:
|
|
RecalcWeekDay();
|
|
break;
|
|
|
|
case eCalendarView.Month:
|
|
RecalcMonth();
|
|
break;
|
|
|
|
case eCalendarView.Year:
|
|
RecalcYear();
|
|
break;
|
|
|
|
case eCalendarView.TimeLine:
|
|
RecalcTimeLine();
|
|
break;
|
|
}
|
|
|
|
base.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
#region RecalcWeekDay
|
|
|
|
/// <summary>
|
|
/// Recalculates all WeekDay views
|
|
/// </summary>
|
|
private void RecalcWeekDay()
|
|
{
|
|
// Calculate the necessary params for calculating
|
|
// the divided width for each subItems in our panel
|
|
|
|
int trWidth = 0;
|
|
int vsWidth = 0;
|
|
|
|
int vCount = SubItems.Count;
|
|
|
|
if (SubItems[0] is VScrollPanel)
|
|
{
|
|
vCount--;
|
|
vsWidth = _CalendarView.VsWidth;
|
|
|
|
if (SubItems[1] is TimeRulerPanel)
|
|
{
|
|
vCount--;
|
|
trWidth = _CalendarView.TimeRulerWidth;
|
|
}
|
|
}
|
|
|
|
// Configure the subItems based upon the
|
|
// previously calculated display params
|
|
|
|
if (vCount > 0)
|
|
ConfigureWeekDayItems(vCount, trWidth, vsWidth);
|
|
|
|
_InnerBounds.X += trWidth;
|
|
_InnerBounds.Width -= (trWidth + vsWidth);
|
|
|
|
_InnerBounds.Y += _CalendarView.WeekDayVScrollBar.Location.Y;
|
|
_InnerBounds.Height -= _InnerBounds.Y;
|
|
}
|
|
|
|
#region ConfigureWeekDayItems
|
|
|
|
/// <summary>
|
|
/// Configures the CalendarPanel subItems
|
|
/// </summary>
|
|
/// <param name="vCount">View count</param>
|
|
/// <param name="trWidth">TimeRuler width</param>
|
|
/// <param name="vsWidth">Vert Scrollbar width</param>
|
|
private void ConfigureWeekDayItems(int vCount, int trWidth, int vsWidth)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
// Calculate our default viewWidth
|
|
|
|
int bvWidth = Bounds.Width - (trWidth + vsWidth);
|
|
float viewWidth = (float)bvWidth / vCount;
|
|
|
|
// Sync our current item params with our current
|
|
// horizontal scrollBar states
|
|
|
|
ConfigDhScrollBar(ref r,
|
|
ref viewWidth, vCount, trWidth, vsWidth);
|
|
|
|
// If we have a TimRulerPanel, then
|
|
// set it's location and size
|
|
|
|
if (trWidth > 0)
|
|
{
|
|
r.X = Bounds.X;
|
|
r.Width = trWidth;
|
|
|
|
SubItems[1].Bounds = r;
|
|
SubItems[1].RecalcSize();
|
|
}
|
|
|
|
// Loop through each BaseView item,
|
|
// setting it's location and size
|
|
|
|
_CalendarView.StartSlice = -1;
|
|
_CalendarView.NumberOfSlices = 0;
|
|
|
|
float fxPos = Bounds.X + trWidth + _HScrollPos;
|
|
BaseView view = null;
|
|
|
|
int n = vCount;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if (SubItems[i] is BaseView)
|
|
{
|
|
r.X = (int)fxPos;
|
|
fxPos += viewWidth;
|
|
|
|
r.Width = (int)(fxPos - r.X - (--n > 0 ? 2 : 0));
|
|
|
|
SubItems[i].Bounds = r;
|
|
SubItems[i].Displayed = r.IntersectsWith(Bounds);
|
|
|
|
if (SubItems[i].Displayed == true)
|
|
{
|
|
view = SubItems[i] as BaseView;
|
|
|
|
if (view != null)
|
|
{
|
|
view.NeedRecalcLayout = true;
|
|
view.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we need to align the WorkDay times, then
|
|
// make sure all displayed WeekDay views are kept in sync
|
|
|
|
if (_CalendarView.ShowOnlyWorkDayHours == true && _CalendarView.IsMultiCalendar == true)
|
|
{
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
WeekDayView wv = SubItems[i] as WeekDayView;
|
|
|
|
if (wv != null && wv.Displayed == true)
|
|
{
|
|
if (wv.LocalStartSlice != _CalendarView.StartSlice ||
|
|
wv.LocalNumberOfSlices != _CalendarView.NumberOfSlices)
|
|
{
|
|
wv.NeedRecalcLayout = true;
|
|
wv.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we have a VScrollPanel, then
|
|
// set it's location and size
|
|
|
|
if (vsWidth > 0)
|
|
{
|
|
r.X = Bounds.Right - vsWidth;
|
|
r.Width = vsWidth;
|
|
|
|
int delta = _CalendarView.AllDayPanelHeight;
|
|
|
|
r.Y = delta;
|
|
r.Height = 50;
|
|
|
|
if (view != null)
|
|
{
|
|
r.Y += view.ClientRect.Y + view.DayOfWeekHeaderHeight;
|
|
r.Height = Math.Max(r.Height, view.ClientRect.Height - (delta + view.DayOfWeekHeaderHeight));
|
|
}
|
|
|
|
SubItems[0].Bounds = r;
|
|
SubItems[0].RecalcSize();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RecalcMonth
|
|
|
|
/// <summary>
|
|
/// Recalculates Month views
|
|
/// </summary>
|
|
private void RecalcMonth()
|
|
{
|
|
// Configure the subItems based upon the
|
|
// previously calculated display params
|
|
|
|
ConfigureMonthItems(SubItems.Count);
|
|
}
|
|
|
|
#region ConfigureMonthItems
|
|
|
|
/// <summary>
|
|
/// Configures the CalendarPanel subItems
|
|
/// </summary>
|
|
/// <param name="vCount">View count</param>
|
|
private void ConfigureMonthItems(int vCount)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
// Calculate our default viewWidth
|
|
|
|
float viewWidth = (float)Bounds.Width / vCount;
|
|
|
|
// Sync our current item params with our current
|
|
// horizontal scrollBar states
|
|
|
|
ConfigDhScrollBar(ref r, ref viewWidth, vCount, 0, 0);
|
|
|
|
// Loop through each BaseView item,
|
|
// setting it's location and size
|
|
|
|
float fxPos = Bounds.X + _HScrollPos;
|
|
int n = vCount;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if (SubItems[i] is BaseView)
|
|
{
|
|
r.X = (int)fxPos;
|
|
fxPos += viewWidth;
|
|
|
|
r.Width = (int)(fxPos - r.X - (--n > 0 ? 2 : 0));
|
|
|
|
SubItems[i].Bounds = r;
|
|
SubItems[i].Displayed = r.IntersectsWith(Bounds);
|
|
|
|
if (SubItems[i].Displayed == true)
|
|
{
|
|
BaseView view = SubItems[i] as BaseView;
|
|
|
|
if (view != null)
|
|
{
|
|
view.NeedRecalcLayout = true;
|
|
view.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RecalcYear
|
|
|
|
/// <summary>
|
|
/// Recalculates all Year views
|
|
/// </summary>
|
|
private void RecalcYear()
|
|
{
|
|
// Calculate the necessary params for calculating
|
|
// the divided width for each subItems in our panel
|
|
|
|
int vsWidth = 0;
|
|
|
|
int vCount = SubItems.Count;
|
|
|
|
if (SubItems[0] is VScrollPanel)
|
|
{
|
|
vCount--;
|
|
vsWidth = _CalendarView.VsWidth;
|
|
}
|
|
|
|
// Configure the subItems based upon the
|
|
// previously calculated display params
|
|
|
|
if (vCount > 0)
|
|
ConfigureYearItems(vCount, vsWidth);
|
|
|
|
_InnerBounds.Y = _CalendarView.YearVScrollPanel.ScrollBar.Location.Y;
|
|
_InnerBounds.Height -= _InnerBounds.Y;
|
|
|
|
}
|
|
|
|
#region ConfigureYearItems
|
|
|
|
/// <summary>
|
|
/// Configures the CalendarPanel subItems
|
|
/// </summary>
|
|
/// <param name="vCount">View count</param>
|
|
/// <param name="vsWidth">Vert Scrollbar width</param>
|
|
private void ConfigureYearItems(int vCount, int vsWidth)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
// Calculate our default viewWidth
|
|
|
|
int bvWidth = Bounds.Width;
|
|
float viewWidth = (float) bvWidth/vCount;
|
|
|
|
// Sync our current item params with our current
|
|
// horizontal scrollBar states
|
|
|
|
ConfigDhScrollBar(ref r, ref viewWidth, vCount, 0, vsWidth);
|
|
|
|
// Locate and calculate the default size of our YearView
|
|
|
|
BaseView view = null;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
view = SubItems[i] as BaseView;
|
|
|
|
if (view != null)
|
|
{
|
|
Rectangle t = r;
|
|
t.Width = (int) viewWidth;
|
|
|
|
SubItems[i].Bounds = t;
|
|
|
|
view.NeedRecalcLayout = true;
|
|
view.RecalcSize();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (view != null)
|
|
{
|
|
// If we have a VScrollPanel, then
|
|
// set it's location and size
|
|
|
|
if (vsWidth > 0)
|
|
{
|
|
if (_CalendarView.YearViewMax + 1 == view.ClientRect.Height)
|
|
{
|
|
SubItems[0].Visible = false;
|
|
((VScrollPanel)SubItems[0]).DisableScrollBar();
|
|
}
|
|
else
|
|
{
|
|
bvWidth = Bounds.Width - vsWidth;
|
|
viewWidth = (float)bvWidth / vCount;
|
|
|
|
r = Bounds;
|
|
ConfigDhScrollBar(ref r, ref viewWidth, vCount, 0, vsWidth);
|
|
|
|
Rectangle t = r;
|
|
t.Y += view.ClientRect.Y;
|
|
t.Height = Math.Max(50, view.ClientRect.Height);
|
|
|
|
t.X = Bounds.Right - vsWidth;
|
|
t.Width = vsWidth;
|
|
|
|
SubItems[0].Bounds = t;
|
|
SubItems[0].RecalcSize();
|
|
SubItems[0].Visible = true;
|
|
}
|
|
}
|
|
|
|
// Loop through each BaseView item,
|
|
// setting it's location and size
|
|
|
|
float fxPos = Bounds.X + _HScrollPos;
|
|
int n = vCount;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if (SubItems[i] is BaseView)
|
|
{
|
|
r.X = (int) fxPos;
|
|
fxPos += viewWidth;
|
|
|
|
r.Width = (int) (fxPos - r.X - (--n > 0 ? 2 : 0));
|
|
|
|
SubItems[i].Bounds = r;
|
|
SubItems[i].Displayed = r.IntersectsWith(Bounds);
|
|
|
|
if (SubItems[i].Displayed == true)
|
|
{
|
|
view = SubItems[i] as BaseView;
|
|
|
|
if (view != null)
|
|
{
|
|
view.NeedRecalcLayout = true;
|
|
view.RecalcSize();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RecalcTimeLine
|
|
|
|
/// <summary>
|
|
/// Recalculates TimeLine views
|
|
/// </summary>
|
|
private void RecalcTimeLine()
|
|
{
|
|
int vCount = SubItems.Count;
|
|
|
|
if (SubItems.Contains("TimeLineHScrollPanel"))
|
|
vCount--;
|
|
|
|
if (SubItems.Contains("TimeLineHeaderPanel"))
|
|
vCount--;
|
|
|
|
if (vCount > 0)
|
|
ConfigureTItems(vCount);
|
|
}
|
|
|
|
#region ConfigureTItems
|
|
|
|
/// <summary>
|
|
/// Configures TimeLine view items
|
|
/// </summary>
|
|
/// <param name="vCount"></param>
|
|
private void ConfigureTItems(int vCount)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
if (_CalendarView.TimeLineShowHScrollBar == true)
|
|
r.Height -= _CalendarView.HsHeight;
|
|
|
|
// TimeLineHeaderPanel
|
|
|
|
int headerHeight = 0;
|
|
int iHeaderPanel = SubItems.IndexOf("TimeLineHeaderPanel");
|
|
|
|
if (iHeaderPanel >= 0)
|
|
{
|
|
if (iHeaderPanel != 0)
|
|
{
|
|
BaseItem bi = SubItems[iHeaderPanel];
|
|
|
|
SubItems.RemoveAt(iHeaderPanel);
|
|
SubItems.Insert(0, bi);
|
|
|
|
iHeaderPanel = 0;
|
|
}
|
|
|
|
if (_CalendarView.TimeLineShowIntervalHeader == true)
|
|
headerHeight += _CalendarView.TimeLineIntervalHeaderHeight;
|
|
|
|
if (_CalendarView.TimeLineShowPeriodHeader == true)
|
|
headerHeight += _CalendarView.TimeLinePeriodHeaderHeight;
|
|
|
|
r.Y += headerHeight;
|
|
r.Height -= headerHeight;
|
|
}
|
|
|
|
_InnerBounds.Y = r.Y;
|
|
_InnerBounds.Height = r.Height;
|
|
|
|
// Calculate our viewHeight
|
|
|
|
int vsWidth = 0;
|
|
|
|
float viewHeight = (float) r.Height/vCount;
|
|
|
|
if (_CalendarView.TimeLineHeight > viewHeight)
|
|
{
|
|
viewHeight = _CalendarView.TimeLineHeight;
|
|
vsWidth = _CalendarView.VsWidth;
|
|
}
|
|
|
|
// VScrollPanel
|
|
|
|
ConfigureTvScrollBar(r, vCount, vsWidth);
|
|
|
|
// Sync our current item params with our current
|
|
// horizontal scrollBar states
|
|
|
|
r.Width -= vsWidth;
|
|
|
|
Rectangle r2 = r;
|
|
|
|
if (_CalendarView.IsMultiCalendar == true &&
|
|
_CalendarView.ShowTabs == true)
|
|
{
|
|
if (_CalendarView.TimeLineMultiUserTabOrientation == eOrientation.Vertical)
|
|
{
|
|
r2.X += _CalendarView.MultiUserTabHeight + 4;
|
|
r2.Width -= (_CalendarView.MultiUserTabHeight + 4);
|
|
}
|
|
else
|
|
{
|
|
r2.X += _CalendarView.TimeLineMultiUserTabWidth + 4;
|
|
r2.Width -= (_CalendarView.TimeLineMultiUserTabWidth + 4);
|
|
}
|
|
|
|
_InnerBounds.X = r2.X;
|
|
_InnerBounds.Width = r2.Width;
|
|
}
|
|
|
|
// TimeLineHeaderPanel
|
|
|
|
if (iHeaderPanel >= 0)
|
|
{
|
|
r2.Y = Bounds.Y;
|
|
r2.Height = headerHeight;
|
|
|
|
SubItems[iHeaderPanel].Bounds = r2;
|
|
SubItems[iHeaderPanel].RecalcSize();
|
|
}
|
|
|
|
// TimeLineView
|
|
|
|
r2 = r;
|
|
|
|
float fxPos = r2.Y + _VScrollPos;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if (SubItems[i] is TimeLineView)
|
|
{
|
|
r2.Y = (int) fxPos;
|
|
fxPos += viewHeight;
|
|
|
|
r2.Height = (int) (fxPos - r2.Y);
|
|
|
|
SubItems[i].Bounds = r2;
|
|
SubItems[i].Displayed = r2.IntersectsWith(Bounds);
|
|
|
|
if (SubItems[i].Displayed == true)
|
|
SubItems[i].RecalcSize();
|
|
}
|
|
}
|
|
|
|
// If we have an HScrollPanel, then
|
|
// set it's location and size
|
|
|
|
int iScrollPanel = SubItems.IndexOf("TimeLineHScrollPanel");
|
|
|
|
if (iScrollPanel >= 0)
|
|
{
|
|
if (_CalendarView.IsMultiCalendar == true &&
|
|
_CalendarView.ShowTabs == true)
|
|
{
|
|
if (_CalendarView.TimeLineMultiUserTabOrientation == eOrientation.Vertical)
|
|
{
|
|
r.X += (_CalendarView.MultiUserTabHeight + 4);
|
|
r.Width -= (_CalendarView.MultiUserTabHeight + 4);
|
|
}
|
|
else
|
|
{
|
|
r.X += (_CalendarView.TimeLineMultiUserTabWidth + 4);
|
|
r.Width -= (_CalendarView.TimeLineMultiUserTabWidth + 4);
|
|
}
|
|
}
|
|
|
|
r.Y = Bounds.Bottom - _CalendarView.HsHeight;
|
|
r.Height = _CalendarView.HsHeight;
|
|
|
|
SubItems[iScrollPanel].Bounds = r;
|
|
SubItems[iScrollPanel].RecalcSize();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Horizontal scrollbar support
|
|
|
|
#region ConfigDhScrollBar
|
|
|
|
/// <summary>
|
|
/// Configures default view horizontal scrollBar
|
|
/// </summary>
|
|
/// <param name="r"></param>
|
|
/// <param name="viewWidth"></param>
|
|
/// <param name="vCount"></param>
|
|
/// <param name="trWidth"></param>
|
|
/// <param name="vsWidth"></param>
|
|
private void ConfigDhScrollBar(ref Rectangle r,
|
|
ref float viewWidth, int vCount, int trWidth, int vsWidth)
|
|
{
|
|
if (_CalendarView.ViewWidth > viewWidth)
|
|
{
|
|
viewWidth = _CalendarView.ViewWidth + 2;
|
|
r.Height -= _CalendarView.HsHeight;
|
|
|
|
_HsMaximum = (int)(viewWidth * vCount);
|
|
|
|
if (_HScrollBar == null)
|
|
SetUpDhScrollBar();
|
|
|
|
if (_HScrollBar != null)
|
|
{
|
|
UpdateDhScrollBar(trWidth, vsWidth);
|
|
|
|
if (_HScrollBar.Value > _HsMaximum - _HScrollBar.LargeChange + 1)
|
|
{
|
|
_HScrollPos = -_HsMaximum - _HScrollBar.LargeChange;
|
|
_HScrollBar.Value = _HsMaximum - _HScrollBar.LargeChange;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_HScrollBar != null)
|
|
{
|
|
_HScrollPos = 0;
|
|
_HScrollBar.Value = 0;
|
|
|
|
_HScrollBar.Visible = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetUpDhScrollBar
|
|
|
|
/// <summary>
|
|
/// Sets up default view horizontal scrollbar
|
|
/// </summary>
|
|
private void SetUpDhScrollBar()
|
|
{
|
|
_HScrollBar = new HScrollBarAdv();
|
|
_HScrollBar.Height = _CalendarView.HsHeight;
|
|
|
|
Control c = (Control)this.GetContainerControl(true);
|
|
|
|
if (c != null)
|
|
c.Controls.Add(_HScrollBar);
|
|
|
|
_HScrollBar.ValueChanged += DhScrollBarValueChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UpdateDhScrollBar
|
|
|
|
/// <summary>
|
|
/// Updates default view horizontal scrollbar
|
|
/// </summary>
|
|
private void UpdateDhScrollBar(int trWidth, int vsWidth)
|
|
{
|
|
Point pt = new Point(Bounds.X + trWidth,
|
|
Bounds.Bottom - _CalendarView.HsHeight);
|
|
|
|
_HScrollBar.Location = pt;
|
|
_HScrollBar.Width = Math.Max(50, Bounds.Width - (trWidth + vsWidth));
|
|
|
|
_HScrollBar.SmallChange = 10;
|
|
_HScrollBar.LargeChange = _HScrollBar.Width;
|
|
_HScrollBar.Maximum = _HsMaximum;
|
|
|
|
_HScrollBar.Visible = true;
|
|
_HScrollBar.BringToFront();
|
|
|
|
_HScrollBar.Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DhScrollBarValueChanged
|
|
|
|
/// <summary>
|
|
/// Processes default view horizontal
|
|
/// scrollbar value changes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void DhScrollBarValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (_HScrollPos != -_HScrollBar.Value)
|
|
{
|
|
_HScrollPos = -_HScrollBar.Value;
|
|
|
|
NeedRecalcSize = true;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Vertical scrollbar support
|
|
|
|
#region ConfigureTvScrollBar
|
|
|
|
/// <summary>
|
|
/// Configures TimeLine View vertical scrollbar
|
|
/// </summary>
|
|
/// <param name="r"></param>
|
|
/// <param name="vCount"></param>
|
|
/// <param name="vsWidth"></param>
|
|
private void ConfigureTvScrollBar(Rectangle r, int vCount, int vsWidth)
|
|
{
|
|
if (vsWidth > 0)
|
|
{
|
|
_VsMaximum = _CalendarView.TimeLineHeight * vCount + 2;
|
|
|
|
if (_VScrollBar == null)
|
|
SetUpTvScrollBar();
|
|
|
|
if (_VScrollBar != null)
|
|
{
|
|
UpdateTvScrollBar(r, vsWidth);
|
|
|
|
if (_VScrollBar.Value > _VsMaximum)
|
|
_VScrollBar.Value = _VsMaximum;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_VScrollBar != null)
|
|
{
|
|
_VScrollPos = 0;
|
|
_VScrollBar.Value = 0;
|
|
|
|
_VScrollBar.Visible = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetUpTvScrollBar
|
|
|
|
/// <summary>
|
|
/// Sets up TimeLine vertical scrollbar
|
|
/// </summary>
|
|
private void SetUpTvScrollBar()
|
|
{
|
|
_VScrollBar = new VScrollBarAdv();
|
|
_VScrollBar.Width = _CalendarView.VsWidth;
|
|
|
|
Control c = (Control)this.GetContainerControl(true);
|
|
|
|
if (c != null)
|
|
c.Controls.Add(_VScrollBar);
|
|
|
|
_VScrollBar.ValueChanged += VScrollBar_ValueChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UpdateTvScrollBar
|
|
|
|
/// <summary>
|
|
/// Updates our vertical scrollbar
|
|
/// </summary>
|
|
/// <param name="r"></param>
|
|
/// <param name="vsWidth"></param>
|
|
private void UpdateTvScrollBar(Rectangle r, int vsWidth)
|
|
{
|
|
Point pt = new Point(r.Right - vsWidth, r.Top);
|
|
|
|
_VScrollBar.Location = pt;
|
|
_VScrollBar.Height = Math.Max(30, r.Height);
|
|
|
|
_VScrollBar.SmallChange = _CalendarView.TimeLineHeight;
|
|
_VScrollBar.LargeChange = _VScrollBar.Height;
|
|
_VScrollBar.Maximum = _VsMaximum;
|
|
|
|
_VScrollBar.Visible = true;
|
|
_VScrollBar.BringToFront();
|
|
|
|
_VScrollBar.Refresh();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region VScrollBar_ValueChanged
|
|
|
|
/// <summary>
|
|
/// Processes TimeLine vertical scrollbar changes
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void VScrollBar_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (_VScrollPos != -_VScrollBar.Value)
|
|
{
|
|
_VScrollPos = -_VScrollBar.Value;
|
|
|
|
NeedRecalcSize = true;
|
|
Refresh();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Paint
|
|
|
|
/// <summary>
|
|
/// Paint processing
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
public override void Paint(ItemPaintArgs e)
|
|
{
|
|
if (_CalendarView.IsUpdateSuspended == false)
|
|
{
|
|
if (SubItems.Count > 0)
|
|
{
|
|
PaintNonViewItems(e);
|
|
PaintBaseViewItems(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints the non-BaseView items
|
|
/// </summary>
|
|
/// <param name="e">ItemPaintArgs</param>
|
|
private void PaintNonViewItems(ItemPaintArgs e)
|
|
{
|
|
// Loop through each item, initiating
|
|
// a paint on each one
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if ((SubItems[i] is BaseView) == false)
|
|
{
|
|
if (SubItems[i].Bounds.IntersectsWith(e.ClipRectangle))
|
|
SubItems[i].Paint(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Paints the BaseView items
|
|
/// </summary>
|
|
/// <param name="e">ItemPaintArgs</param>
|
|
private void PaintBaseViewItems(ItemPaintArgs e)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
if (_CalendarView.SelectedView == eCalendarView.TimeLine)
|
|
{
|
|
int n = 0;
|
|
|
|
if (_CalendarView.TimeLineShowIntervalHeader == true)
|
|
n += _CalendarView.TimeLineIntervalHeaderHeight;
|
|
|
|
if (_CalendarView.TimeLineShowPeriodHeader == true)
|
|
n += _CalendarView.TimeLinePeriodHeaderHeight;
|
|
|
|
r.Y += n;
|
|
|
|
if (_CalendarView.TimeLineShowHScrollBar == true)
|
|
r.Height -= (_CalendarView.HsHeight + n);
|
|
}
|
|
else
|
|
{
|
|
if (SubItems[0] is VScrollPanel)
|
|
{
|
|
if (SubItems[0].Visible == true)
|
|
r.Width -= _CalendarView.VsWidth;
|
|
}
|
|
|
|
if (SubItems.Count > 1 && SubItems[1] is TimeRulerPanel)
|
|
{
|
|
r.X = _CalendarView.TimeRulerWidth;
|
|
r.Width -= _CalendarView.TimeRulerWidth;
|
|
}
|
|
}
|
|
|
|
Region rgnSave = e.Graphics.Clip;
|
|
|
|
using (Region rgn = new Region(r))
|
|
{
|
|
e.Graphics.Clip = rgn;
|
|
|
|
for (int i = 0; i < SubItems.Count; i++)
|
|
{
|
|
if (SubItems[i] is BaseView)
|
|
{
|
|
if (SubItems[i].Displayed == true)
|
|
SubItems[i].Paint(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
e.Graphics.Clip = rgnSave;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Touch Handling
|
|
|
|
#region Private variables
|
|
|
|
private bool _TouchDrag;
|
|
|
|
private Point _TouchStartLocation;
|
|
private Point _TouchStartScrollPosition;
|
|
|
|
private Rectangle _TouchInnerBounds;
|
|
|
|
#endregion
|
|
|
|
#region Private properties
|
|
|
|
private int MaximumReversePageOffset
|
|
{
|
|
get { return 0; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TouchHandlerPanBegin
|
|
|
|
private void TouchHandlerPanBegin(object sender, Touch.GestureEventArgs e)
|
|
{
|
|
if (_CalendarView.TouchEnabled == true)
|
|
{
|
|
_TouchInnerBounds = _InnerBounds;
|
|
_TouchStartLocation = e.Location;
|
|
_TouchStartScrollPosition = AutoScrollPosition;
|
|
_TouchDrag = true;
|
|
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TouchHandlerPan
|
|
|
|
private void TouchHandlerPan(object sender, Touch.GestureEventArgs e)
|
|
{
|
|
if (_TouchDrag)
|
|
{
|
|
Point autoScrollPosition = AutoScrollPosition;
|
|
Size autoScrollMinSize = AutoScrollMinSize;
|
|
|
|
int offset = (_TouchStartLocation.X - e.Location.X);
|
|
int offsetChange = offset + _TouchStartScrollPosition.X;
|
|
|
|
// X Scroll
|
|
|
|
bool overflowH = false;
|
|
|
|
if (autoScrollMinSize.Width > _TouchInnerBounds.Width)
|
|
{
|
|
if (offsetChange + MaximumReversePageOffset > autoScrollMinSize.Width)
|
|
{
|
|
autoScrollPosition.X = autoScrollMinSize.Width;
|
|
overflowH = true;
|
|
}
|
|
else if (offsetChange < MaximumReversePageOffset)
|
|
{
|
|
autoScrollPosition.X = MaximumReversePageOffset;
|
|
overflowH = true;
|
|
}
|
|
else
|
|
autoScrollPosition.X = offsetChange;
|
|
}
|
|
|
|
// Y Scroll
|
|
|
|
bool overflowV = false;
|
|
|
|
if (autoScrollMinSize.Height > _TouchInnerBounds.Height)
|
|
{
|
|
offset = (_TouchStartLocation.Y - e.Location.Y);
|
|
offsetChange = offset + _TouchStartScrollPosition.Y;
|
|
|
|
if (offsetChange + MaximumReversePageOffset > autoScrollMinSize.Height)
|
|
{
|
|
autoScrollPosition.Y = autoScrollMinSize.Height;
|
|
overflowV = true;
|
|
}
|
|
else if (offsetChange < MaximumReversePageOffset)
|
|
{
|
|
autoScrollPosition.Y = MaximumReversePageOffset;
|
|
overflowV = true;
|
|
}
|
|
else
|
|
autoScrollPosition.Y = offsetChange;
|
|
}
|
|
|
|
if (AutoScrollPosition != autoScrollPosition)
|
|
{
|
|
AutoScrollPosition = autoScrollPosition;
|
|
Update();
|
|
}
|
|
|
|
if (overflowH && overflowV && e.IsInertia)
|
|
EndTouchPan();
|
|
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TouchHandlerPanEnd
|
|
|
|
private void TouchHandlerPanEnd(object sender, Touch.GestureEventArgs e)
|
|
{
|
|
if (_TouchDrag)
|
|
{
|
|
EndTouchPan();
|
|
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region EndTouchPan
|
|
|
|
private void EndTouchPan()
|
|
{
|
|
_TouchDrag = false;
|
|
|
|
Point autoScrollPosition = AutoScrollPosition;
|
|
Size autoScrollMinSize = AutoScrollMinSize;
|
|
|
|
if (autoScrollMinSize.Width > _TouchInnerBounds.Width)
|
|
{
|
|
if (autoScrollMinSize.Width < autoScrollPosition.X)
|
|
autoScrollPosition = new Point(autoScrollMinSize.Width, autoScrollPosition.Y);
|
|
|
|
else if (autoScrollPosition.X < 0)
|
|
autoScrollPosition = new Point(0, autoScrollPosition.Y);
|
|
}
|
|
|
|
if (autoScrollMinSize.Height > _TouchInnerBounds.Height)
|
|
{
|
|
if (autoScrollMinSize.Height < autoScrollPosition.Y)
|
|
autoScrollPosition = new Point(autoScrollPosition.X, autoScrollMinSize.Height);
|
|
|
|
else if (autoScrollPosition.Y < 0)
|
|
autoScrollPosition = new Point(autoScrollPosition.X, 0);
|
|
}
|
|
|
|
if (AutoScrollPosition != autoScrollPosition)
|
|
AutoScrollPosition = autoScrollPosition;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns copy of the item.
|
|
/// </summary>
|
|
public override BaseItem Copy()
|
|
{
|
|
CalendarPanel objCopy = new CalendarPanel(_CalendarView);
|
|
CopyToItem(objCopy);
|
|
|
|
return (objCopy);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copies the CalendarPanel specific properties to new instance of the item.
|
|
/// </summary>
|
|
/// <param name="copy">New CalendarPanel instance</param>
|
|
protected override void CopyToItem(BaseItem copy)
|
|
{
|
|
CalendarPanel objCopy = copy as CalendarPanel;
|
|
base.CopyToItem(objCopy);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
#endif
|
|
|