//Constructor
public ScheduleWindow()
{
InitializeComponent();
dayView = new DayView()
{
AllowInplaceEditing = false,
AllowNew = false,
StartDate = new DateTime(2018, 10, 1),
HalfHourHeight = 30,
StartHour = 8,
WorkingMinuteStart = 0,
SelectionStart = new DateTime(2018, 10, 1),
SelectionEnd = new DateTime(2018, 10, 8),
DaysToShow = 7,
Font = new Font("Segoe UI", 24)
};
dayView.ResolveAppointments += DayView_ResolveAppointments;
dayView.SelectionChanged += DayView_SelectionChanged;
this.WFH.Child = dayView;
startTime = "0830";
endTime = "0930";
dayIndex = 0;
caAppointments = new List <Calendar.Appointment>();
EventsManager.AppointmentAdded += OnAppointmentAdded;
EventsManager.AppointmentRemoved += OnAppointmentRemoved;
EventsManager.DatasDownloaded += OnDatasDownloaded;
InitializeSchedule();
}
private void CreateDayView()
{
bool requiresLayout = false;
if (dayView == null)
{
dayView = new DayView();
dayView.Visibility = Visibility.Hidden;
dayView.OnZoomOutEvent += dayView_OnZoomOutEvent;
dayView.OnBeginEditEvent += dayView_OnBeginEditEvent;
dayView.OnEndEditEvent += dayView_OnEndEditEvent;
dayView.OnSelectedChangedEvent += dayView_OnSelectedChangedEvent;
dayView.OnExportEvent += dayView_OnExportEvent;
dayView.ReminderChanged += dayView_ReminderChanged;
Panel.SetZIndex(dayView, 2);
calendarGrid.Children.Add(dayView);
}
if (dayView.Zoom != statusStrip.Zoom / 100)
{
dayView.ZoomNoAnimate(statusStrip.Zoom / 100);
requiresLayout = true;
}
if (weekView != null && dayView.ScrollOffset != weekView.ScrollOffset)
{
dayView.ScrollOffset = weekView.ScrollOffset;
requiresLayout = true;
}
if (requiresLayout)
{
dayView.UpdateLayout();
}
}
public DataSet ShowBtn(DayView obj)
{
SqlConnection con = new SqlConnection(strConnLive);
try
{
con.Open();
SqlCommand cmd = new SqlCommand("HRAlign_Inland.dbo.Usp_WeeklyPlanCalender", con);
cmd.CommandType = CommandType.StoredProcedure;
SqlDataAdapter sda = new SqlDataAdapter(cmd);
cmd.Parameters.AddWithValue("@mode", "GetDayPlans");
cmd.Parameters.AddWithValue("@empcd", obj.Empcd);
cmd.Parameters.AddWithValue("@eventdate", obj.PlanDate);
DataSet ds = new DataSet();
sda.Fill(ds);
return(ds);
}
catch (Exception ex)
{
return(null);
}
finally
{
con.Close();
}
}
private void SetDay(string day, bool Today = false)
{
GameObject temp = Instantiate(DateObject);
temp.transform.SetParent(MonthContent);
temp.GetComponent <RectTransform>().localScale = Vector3.one;
temp.SetActive(true);
DayView dv = temp.GetComponent <DayView>();
dv.Day.text = day;
dv.Btn.onClick.AddListener(delegate()
{
date = new DateTime(date.Year, date.Month, Convert.ToInt32(day));
Lucky.LuckyUtils.Log(date.ToString());
if (callback != null)
{
callback(date);
}
Dispose();
});
if (Today)
{
dv.SetColor(Blue);
}
}
public override void OnMouseWheel(PortableMouseEventArgs e)
{
DayView curView = ((SchedulerControl)provider).DayView;
int nSlots = curView.TimeSlots.Count;
if (this.myzoomEnabled)
{
if (e.Delta < 0)
{
for (int i = 0; i < nSlots; i++)
{
if (curView.TimeSlots[i].Value <= curView.TimeScale)
{
curView.TimeScale = curView.TimeSlots[i].Value;
break;
}
}
}
else
{
for (int i = nSlots - 1; i >= 0; i--)
{
if (curView.TimeSlots[i].Value >= curView.TimeScale)
{
curView.TimeScale = curView.TimeSlots[i].Value;
break;
}
}
}
}
else
{
base.OnMouseWheel(e);
}
}
public JsonResult GetWorksheetInfo(DayView view)
{
try
{
var getworksheet = _WPO.GetWorksheetInfo(view);
List <DayView> List = new List <DayView>();
DayView obj1 = new DayView();
if (getworksheet != null && getworksheet.Tables[0].Rows.Count > 0)
{
foreach (DataRow item in getworksheet.Tables[0].Rows)
{
DayView _obj = new DayView();
_obj.Start = item["start"].ToString();
_obj.End = item["end"].ToString();
_obj.Desc = item["Description"].ToString();
_obj.Empcd = item["empcd"].ToString();
_obj.PlanDate = item["Plandate"].ToString();
List.Add(_obj);
}
return(Json(List, JsonRequestBehavior.AllowGet));
}
else
{
obj1.Message = "No Data";
return(Json(obj1, JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
return(null);
}
}
public DayPresenter(DayModel model, DayView view)
{
this.model = model;
this.view = view;
view.Month = model.Month;
view.Presenter = this;
}
void CheckDemo()
{
DayView dayViewModule = (DayView)DemoBaseTesting.CurrentDemoModule;
int initialDayCount = 3;
Assert.AreEqual(SchedulerViewType.Day, dayViewModule.scheduler.ActiveViewType);
Assert.AreEqual(initialDayCount, dayViewModule.scheduler.DayView.DayCount);
for (int i = initialDayCount + 1; i <= 10; i++)
{
dayViewModule.spnDayCount.SpinUp();
UpdateLayoutAndDoEvents();
Assert.AreEqual(false, dayViewModule.spnDayCount.HasValidationError);
Assert.AreEqual(i, dayViewModule.scheduler.DayView.DayCount);
}
Assert.AreEqual(false, dayViewModule.scheduler.DayView.AllDayAreaScrollBarVisible);
Assert.AreEqual(false, dayViewModule.chkShowAllDayAreaScrollBars.IsChecked);
dayViewModule.chkShowAllDayAreaScrollBars.IsChecked = true;
UpdateLayoutAndDoEvents();
Assert.AreEqual(true, dayViewModule.scheduler.DayView.AllDayAreaScrollBarVisible);
dayViewModule.chkShowAllDayAreaScrollBars.IsChecked = false;
UpdateLayoutAndDoEvents();
Assert.AreEqual(false, dayViewModule.scheduler.DayView.AllDayAreaScrollBarVisible);
Assert.AreEqual(false, dayViewModule.scheduler.DayView.ShowWorkTimeOnly);
Assert.AreEqual(false, dayViewModule.chkShowWorkTimeOnly.IsChecked);
dayViewModule.chkShowWorkTimeOnly.IsChecked = true;
UpdateLayoutAndDoEvents();
Assert.AreEqual(true, dayViewModule.scheduler.DayView.ShowWorkTimeOnly);
dayViewModule.chkShowWorkTimeOnly.IsChecked = false;
UpdateLayoutAndDoEvents();
Assert.AreEqual(false, dayViewModule.scheduler.DayView.ShowWorkTimeOnly);
Assert.AreEqual(true, dayViewModule.scheduler.DayView.ShowDayHeaders);
Assert.AreEqual(true, dayViewModule.chkShowDayHeaders.IsChecked);
dayViewModule.chkShowDayHeaders.IsChecked = false;
UpdateLayoutAndDoEvents();
Assert.AreEqual(false, dayViewModule.scheduler.DayView.ShowDayHeaders);
dayViewModule.chkShowDayHeaders.IsChecked = true;
UpdateLayoutAndDoEvents();
Assert.AreEqual(true, dayViewModule.scheduler.DayView.ShowDayHeaders);
Assert.AreEqual(true, dayViewModule.scheduler.DayView.ShowAllDayArea, "dayViewModule.scheduler.DayView.ShowAllDayArea must be true");
Assert.AreEqual(true, dayViewModule.chkShowAllDayArea.IsChecked, "dayViewModule.chkShowAllDayArea.IsChecked must be true");
dayViewModule.chkShowAllDayArea.IsChecked = false;
UpdateLayoutAndDoEvents();
Assert.AreEqual(false, dayViewModule.scheduler.DayView.ShowAllDayArea, "dayViewModule.scheduler.WorkWeekView.ShowAllDayArea must be false");
dayViewModule.chkShowAllDayArea.IsChecked = true;
UpdateLayoutAndDoEvents();
Assert.AreEqual(true, dayViewModule.scheduler.DayView.ShowAllDayArea, "dayViewModule.scheduler.WorkWeekView.ShowAllDayArea must be true");
}
public static UserControl CreateView(string value)
{
switch (value.ToString())
{
case "Triggered by Battery Percent Changes":
if (_batteryPercentView == null)
{
_batteryPercentView = new BatteryPercentView();
}
return(_batteryPercentView);
case "Triggered by Day Changes":
if (_dayView == null)
{
_dayView = new DayView();
}
return(_dayView);
case "Triggered by Directory Changes":
if (_dirView == null)
{
_dirView = new DirectoryView();
}
return(_dirView);
case "Triggered by File Changes":
if (_fileView == null)
{
_fileView = new FileView();
}
return(_fileView);
case "Triggered by Internet Connectivity":
if (_netView == null)
{
_netView = new NetConnectivityView();
}
return(_netView);
case "Triggered by Process":
if (_procView == null)
{
_procView = new ProcessView();
}
return(_procView);
case "Triggered by Timezone Changes":
if (_tzView == null)
{
_tzView = new TimeZoneView();
}
return(_tzView);
}
return(null);
}
public void MyNavigateBackward(SchedulerControl scheduler)
{
DayView myView = scheduler.ActiveView as DayView;
if (myView != null)
{
scheduler.Start = scheduler.Start.AddDays(-DayViewVisibleDaysCount);
myView.Days = GetDays(scheduler.Start);
}
else
scheduler.ActiveView.NavigateBackward();
}
public void MyNavigateForward(SchedulerControl scheduler)
{
DayView myView = scheduler.ActiveView as DayView;
if (myView != null)
{
scheduler.Start = scheduler.Start.AddDays(DayViewVisibleDaysCount);
// Calculate a list of days to display, excluding non-working days.
myView.Days = GetDays(scheduler.Start);
}
else
scheduler.ActiveView.NavigateForward();
}
public DayViewEnsamble (string name)
: base(name, SplitOrientation.Vertical, -defaultMonthCalendarWidth)
{
Menu = new GuiMenuItem (name + "menu", "Schedule");
Menu.AddChild ("Today", "Today", (char)FontAwesomeIcons.fa_calendar_check_o);
Menu.AddSeparator ();
Menu.AddChild ("AddColumn", "Add Column", (char)FontAwesomeIcons.fa_calendar_plus_o);
Menu.AddChild ("RemoveColumn", "Remove Column", (char)FontAwesomeIcons.fa_calendar_minus_o);
Menu.AddSeparator ();
Menu.AddChild ("SplitView", "Split View").SetChecked(false).ShowOnToolbar();
Menu.AddChild ("Sidebar", "Sidebar").SetChecked(false).ShowOnToolbar();
Menu.AddChild ("Toolbar", "Toolbar").SetChecked(true);
Splitter.Style.BackColorBrush.Color = SummerGUI.Theme.CurrentTheme.StatusBar.BackColor;
Panel2.Style.BorderColorPen.Color = SummerGUI.Theme.Colors.Base0;
Panel2.Style.BackColorBrush.Color = SummerGUI.Theme.Colors.Base01;
CalendarSplitter = new SplitContainer ("calendarsplit", SplitOrientation.Horizontal, defaultMonthCalendarWidth);
this.Panel2.AddChild (CalendarSplitter);
MonthCalendar = new MonthCalendar ("monthcalendar1",
SummerGUIWindow.CurrentContext.FontManager.StatusFont,
SummerGUIWindow.CurrentContext.FontManager.BoldFont
);
CalendarSplitter.Panel1.AddChild (MonthCalendar);
GrdTasks = new DataGridView ("tasks");
CalendarSplitter.Panel2.AddChild (GrdTasks);
DayView1 = new DayView ("dayview1");
DayView2 = new DayView ("dayview2");
DayViewSplitter = new SplitContainer ("dayviewsplitter", SplitOrientation.Horizontal, 0.5f);
DayViewSplitter.Panel1.AddChild (DayView1);
DayViewSplitter.Panel2.AddChild (DayView2);
DayViewSplitter.Panel2Collapsed = true;
Panel1.AddChild (DayViewSplitter);
Tools = Panel1.AddChild (new DayViewToolBar ("dayviewtoolbar", Menu.Children, this));
Menu.Expanding += delegate {
Tools.SetupMenu();
};
CanFocus = true;
DayView1.Focus ();
}
private void FixVisibleDays(bool forward, SchedulerControl scheduler)
{
DayView myView = scheduler.ActiveView as DayView;
DateTime startDate = scheduler.Start;
if (myView != null)
{
DateTimeRange selection = scheduler.SelectedInterval;
startDate = CorrectDate(startDate, forward);
List<DateTime> visibleDays = GetDays(startDate);
// Specify DayView's visible days
myView.Days = visibleDays;
scheduler.SelectedInterval = AdjustSelection(forward, selection);
}
}
public virtual void SetupMenu()
{
DayView activeDV = ActiveDayView;
subAddColumn.Enabled = activeDV != null && activeDV.DaysToShow < 5;
subRemoveColumn.Enabled = activeDV != null && activeDV.DaysToShow > 1;
subSidebar.Checked = !Owner.Panel2Collapsed;
subSplitView.Checked = Owner.SplitScreen;
subToday.Enabled = Owner.MonthCalendar.CurrentDate.Date != DateTime.Now.Date;
subToolbar.Checked = Visible;
this.Update();
EnableControls();
}
public void ShowNewDay(string v)
{
DayModel model = new DayModel();
model.SetMonth(v);
DayView view = new DayView();
DayPresenter presenter = new DayPresenter(model, view);
view.ShowDialog();
if (model.HasAdded)
{
Presenter.GridEntryAdded();
}
}
protected SchedulerViewCellContainerCollection GetCellContainers(SchedulerViewBase view)
{
DayView dayView = view as DayView;
if (dayView != null)
{
return(dayView.ViewInfo.Columns);
}
WeekView weekView = view as WeekView;
if (weekView != null)
{
return(weekView.ViewInfo.Weeks);
}
TimelineView timeLineView = view as TimelineView;
return(timeLineView.ViewInfo.Timelines);
}
public override void OnViewModelLoadedOverride()
{
try
{
base.OnViewModelLoadedOverride();
_dayView = new DayView(ViewModel);
MainGrid.Children.Add(_dayView);
this.SetCommandBarPrimaryCommands(AppBarAdd, AppBarGoToToday);
base.Visibility = Visibility.Visible;
ViewModel.BackRequested += new WeakEventHandler <System.ComponentModel.CancelEventArgs>(ViewModel_BackRequested).Handler;
}
catch (Exception ex)
{
TelemetryExtension.Current?.TrackException(ex);
}
}
public override IViewProvider CreateDateHeaderViewProvider(DayView dayView)
{
return(new CustomDateHeaderViewProvider());
}
public override IViewProvider CreateCellViewProvider(DayView dayView)
{
return(new CustomCellViewProvider());
}
override protected bool MoveAppointment(System.Windows.Forms.MouseEventArgs e)
{
// Default implementation handles move WITHIN the respective
// 'long/short appointments' regions
if (base.MoveAppointment(e))
{
return(true);
}
// whilst we handle transitions BETWEEN the regions
// Note: we need to duplicate some of the base checks
// because we don't know what failed
if (EditMode != Mode.Move)
{
return(false);
}
Rectangle shortApptsRect = DayView.GetTrueRectangle();
Rectangle longApptsRect = DayView.GetFullDayApptsRectangle();
// Make sure the long appointments rect has a reasonable height
if (longApptsRect.Height < DayView.LongAppointmentHeight)
{
int adjustment = (DayView.LongAppointmentHeight - longApptsRect.Height);
longApptsRect.Y -= adjustment;
longApptsRect.Height += adjustment;
}
if (!shortApptsRect.Contains(e.Location) && !longApptsRect.Contains(e.Location))
{
return(false);
}
// _ _________________________________________
// | ____________ |
// | | | |
// longApptsRect | | long | ^ |
// | |____________| | |
// _ |---------|---------------------|---------|
// | | | |
// | V __|__ |
// | | | |
// | | | |
// | | | |
// shortApptsRect | |short| |
// | | | |
// | | | |
// | | | |
// | |_____| |
// | |
// _ |_________________________________________|
CalendarItem selection = (DayView.SelectedAppointment as CalendarItem);
bool longAppt = selection.IsLongAppt();
bool shortAppt = !longAppt;
bool curPtInLongApptsRect = longApptsRect.Contains(e.Location);
bool prevPtInLongApptsRect = longApptsRect.Contains(m_lastMouseMove);
bool curPtInShortApptsRect = shortApptsRect.Contains(e.Location);
bool prevPtInShortApptsRect = shortApptsRect.Contains(m_lastMouseMove);
TimeSpan length = TimeSpan.Zero;
DateTime dateAtCursor = DayView.GetDateTimeAt(e.X, e.Y, curPtInLongApptsRect);
if (shortAppt && prevPtInShortApptsRect && curPtInLongApptsRect)
{
// Short appointment dragged into long appointment rect
m_Transitioned = !base.IsEditingLongAppt;
// If the appointment was originally a long appointment we
// restore the original length else create a day-long task
length = (m_Transitioned ? new TimeSpan(24, 0, 0) : selection.OriginalLength);
}
else if (longAppt && prevPtInLongApptsRect && curPtInShortApptsRect)
{
// Long appointment dragged into short appointment rect
m_Transitioned = base.IsEditingLongAppt;
// If the appointment was originally a long appointment we
// restore the original length else create a 3-hour task
length = (m_Transitioned ? new TimeSpan(3, 0, 0) : selection.OriginalLength);
}
if (length != TimeSpan.Zero)
{
selection.StartDate = dateAtCursor.AddHours(-length.TotalHours / 2);
selection.EndDate = selection.StartDate.Add(length);
m_delta = (selection.StartDate - dateAtCursor);
m_length = TimeSpan.Zero;
return(true);
}
// all else
return(false);
}
public DayViewToolBar(string name, IGuiMenu menu, DayViewEnsamble owner)
: base(name, menu)
{
Owner = owner;
subToday = menu.FindItem("Today");
subAddColumn = menu.FindItem("AddColumn");
subRemoveColumn = menu.FindItem("RemoveColumn");
subSplitView = menu.FindItem("SplitView");
subSidebar = menu.FindItem("Sidebar");
subToolbar = menu.FindItem("Toolbar");
Padding = new Padding(54, 2, 4, 2);
Children.OfType <Button> ().ForEach(btn => {
btn.DisplayStyle = ButtonDisplayStyles.ImageAndText;
btn.Text = btn.Tooltip;
btn.Tooltip = null;
btn.CanFocus = false;
btn.Styles.SetStyle(new ComponentToolBarButtonStyle(), WidgetStates.Pressed);
});
subAddColumn.Click += delegate {
ActiveDayView.Do(dv => {
if (dv.DaysToShow < 5)
{
dv.DaysToShow++;
}
SetupMenu();
});
};
subRemoveColumn.Click += delegate {
ActiveDayView.Do(dv => {
if (dv.DaysToShow > 1)
{
dv.DaysToShow--;
}
SetupMenu();
});
};
subSidebar.Click += delegate {
Owner.Panel2Collapsed = !subSidebar.Checked;
Owner.Panel2.Update(true);
SetupMenu();
};
subSplitView.Click += delegate {
Owner.SplitScreen = subSplitView.Checked;
SetupMenu();
};
subToolbar.Click += delegate {
Visible = subToolbar.Checked;
SetupMenu();
};
subToday.Click += delegate {
Owner.MonthCalendar.Do(m => m.CurrentDate = DateTime.Now.Date);
};
Owner.MonthCalendar.SelectionChanged += (object sender, EventArgs ev) =>
{
if (Owner.MonthCalendar.CurrentDate != DateTime.MinValue)
{
ActiveDayView.StartDate = Owner.MonthCalendar.CurrentDate;
SetupMenu();
}
};
Owner.MonthCalendar.ContextMenu = Menu.Children;
Owner.MonthCalendar.SetupContextMenu += (sender, e) => SetupMenu();
Owner.DayView1.ContextMenu = Menu.Children;
Owner.DayView1.SetupContextMenu += (sender, e) => SetupMenu();
Owner.DayView2.ContextMenu = Menu.Children;
Owner.DayView2.SetupContextMenu += (sender, e) => SetupMenu();
Owner.DayView1.GotFocus += (object sender, EventArgs e) => {
Owner.MonthCalendar.CurrentDate = Owner.DayView1.StartDate;
ActiveDayView = Owner.DayView1;
SetupMenu();
};
Owner.DayView2.GotFocus += (object sender, EventArgs e) => {
Owner.MonthCalendar.CurrentDate = Owner.DayView2.StartDate;
ActiveDayView = Owner.DayView2;
SetupMenu();
};
Owner.DayView1.SelectionChanged += (object sender, EventArgs e) => {
if (Owner.DayView1.IsFocused)
{
Owner.MonthCalendar.CurrentDate = Owner.DayView1.StartDate;
SetupMenu();
}
};
Owner.DayView2.SelectionChanged += (object sender, EventArgs e) => {
if (Owner.DayView2.IsFocused)
{
Owner.MonthCalendar.CurrentDate = Owner.DayView2.StartDate;
SetupMenu();
}
};
Owner.DayView1.LostFocus += delegate {
ActiveDayView = Owner.DayView2;
SetupMenu();
};
Owner.DayView2.LostFocus += delegate {
ActiveDayView = Owner.DayView1;
SetupMenu();
};
}
protected override void CleanupUnmanagedResources()
{
DayView = null;
base.CleanupUnmanagedResources();
}
