public virtual void Handle(
HomeUi ui)
{
var r = this.runner;
var accepted = true;
r?.Run <GlobalSettingsHolder>(settings =>
{
if (settings.Prompt)
{
r.Run <UiReaderWriter, Messenger>((uiRW, m) =>
{
accepted = uiRW.Read(
m.Subscriber,
() => m.Question(
@"Really clock out?")) ==
Response.Yes;
});
}
});
if (!accepted)
{
return;
}
r?.Run <xofz.Framework.Timer>(t =>
{
t.Stop();
r.Run <LatchHolder>(timerLatch =>
{
timerLatch.Latch.WaitOne();
},
DependencyNames.Latch);
},
DependencyNames.Timer);
r?.Run <
UiReaderWriter,
TimestampWriter,
DataWatcher>(
(uiRW, writer, watcher) =>
{
uiRW.WriteSync(
ui,
() =>
{
ui.OutKeyVisible = false;
});
watcher.Stop();
writer.Write();
watcher.Start();
});
r?.Run <StartHandler>(handler =>
{
handler.Handle(ui);
});
}
public SetupHomeCommand(
HomeUi ui,
MethodWeb web)
{
this.ui = ui;
this.web = web;
}
public virtual void Handle(
HomeUi ui,
Do presentEditor)
{
var r = this.runner;
presentEditor?.Invoke();
}
public HomePresenter(
HomeUi ui,
ShellUi shell,
MethodWeb web)
: base(ui, shell)
{
this.ui = ui;
this.web = web;
}
public HomePresenter(
HomeUi ui,
MethodWeb web)
: base(ui, null)
{
this.ui = ui;
this.web = web;
this.timerHandlerFinished = new ManualResetEvent(true);
}
public virtual void Handle(
HomeUi ui)
{
var r = this.runner;
r?.Run <UiReaderWriter>(uiRW =>
{
r.Run <
StatisticsCalculator,
TimestampReader>(
(calc, reader) =>
{
var currentlyIn = calc.ClockedIn();
var editKeyEnabled = false;
foreach (var timestamp in reader.Read())
{
editKeyEnabled = true;
break;
}
uiRW.Write(ui, () =>
{
ui.InKeyVisible = !currentlyIn;
ui.OutKeyVisible = currentlyIn;
ui.EditKeyEnabled = editKeyEnabled;
});
});
r.Run <VersionReader>(
vr =>
{
var appVersion = vr.Read();
var coreVersion = vr.ReadCoreVersion();
uiRW.Write(
ui,
() =>
{
ui.Version = appVersion;
ui.CoreVersion = coreVersion;
});
});
r.Run <TitleUi, GlobalSettingsHolder>(
(shell, settings) =>
{
var title = settings.TitleText;
uiRW.Write(
shell,
() =>
{
shell.Title = title;
});
});
});
}
public virtual void Handle(
TimestampEditUi ui,
HomeNavUi hnUi,
HomeUi homeUi)
{
var r = this.runner;
r?.Run <UiReaderWriter>(uiRW =>
{
r.Run <TimestampReader>(reader =>
{
var allColl = reader.ReadAll();
var ll = allColl as XLinkedList <DateTime>
?? XLinkedList <DateTime> .Create(allColl);
const byte one = 1;
if (ll.Count < one)
{
return;
}
var lastTimestamp = ll
.Tail;
uiRW.Write(
ui,
() =>
{
ui.EditedTimestamp = lastTimestamp;
});
});
r.Run <SettingsHolder>(settings =>
{
settings.LastVisitedKeyLabel = uiRW.Read(
hnUi,
() => hnUi.ActiveKeyLabel);
uiRW.Write(
hnUi,
() =>
{
hnUi.ActiveKeyLabel = null;
});
});
uiRW.Write(
homeUi,
() =>
{
homeUi.Editing = true;
});
});
}
public SetupHomeCommand(
HomeUi ui,
ShellUi shell,
Gen <MethodRunner, TimestampReaderWriter> newReaderWriter,
Gen <MethodWeb, DataWatcher> newDataWatcher,
MethodWeb web)
{
this.ui = ui;
this.shell = shell;
this.newReaderWriter = newReaderWriter;
this.newDataWatcher = newDataWatcher;
this.web = web;
}
public virtual void Handle(
HomeUi homeUi)
{
var r = this.runner;
r?.Run <UiReaderWriter>(uiRW =>
{
uiRW.Write(
homeUi,
() =>
{
homeUi.Editing = false;
});
});
}
public virtual void Handle(
HomeUi ui)
{
var r = this.runner;
r?.Run <LatchHolder>(timerLatch =>
{
timerLatch.Latch.Reset();
},
DependencyNames.Latch);
r?.Run <
UiReaderWriter,
StatisticsCalculator,
PaddedTimeSpanViewer,
TimestampReader>(
(uiRW, calc, viewer, reader) =>
{
var timeThisWeek = calc.TimeWorkedThisWeek();
var timeToday = calc.TimeWorkedToday();
var thisWeekString = viewer.ReadableString(timeThisWeek);
var todayString = viewer.ReadableString(timeToday);
var outKeyVisible = calc.ClockedIn();
var editKeyEnabled = false;
foreach (var timestamp in reader.Read())
{
editKeyEnabled = true;
break;
}
uiRW.Write(
ui,
() =>
{
ui.EditKeyEnabled = editKeyEnabled;
ui.TimeWorkedThisWeek = thisWeekString;
ui.TimeWorkedToday = todayString;
ui.InKeyVisible = !outKeyVisible;
ui.OutKeyVisible = outKeyVisible;
});
});
r?.Run <LatchHolder>(timerLatch =>
{
timerLatch.Latch.Set();
},
DependencyNames.Latch);
}
public virtual void Handle(
HomeUi ui)
{
var r = this.runner;
r?.Run <TimerHandler>(handler =>
{
handler.Handle(ui);
});
r?.Run <xofz.Framework.Timer, GlobalSettingsHolder>(
(t, settings) =>
{
var interval = settings.TimerIntervalSeconds;
if (interval < 1)
{
interval = 1;
}
t.Start(interval * 1000);
},
DependencyNames.Timer);
}
protected virtual void onBootstrap()
{
var s = this.mainShell;
if (s == null)
{
return;
}
var m = this.newMessenger?.Invoke();
if (m != null)
{
m.Subscriber = s;
}
var e = this.executor;
e?.Execute(new SetupMethodWebCommand(
new MethodWebV2(),
m,
this.newConfigSaver,
this.newSettingsProvider));
var w = e?.Get <SetupMethodWebCommand>()?.W;
w?.Run <EventSubscriber>(sub =>
{
var cd = AppDomain.CurrentDomain;
UnhandledExceptionEventHandler handler = this.handleException;
sub.Subscribe(
cd,
nameof(cd.UnhandledException),
handler);
});
w?.RegisterDependency(s);
HomeUi homeUi = null;
HomeNavUi homeNavUi = null;
StatisticsUi statsUi = null;
TimestampsUi timestampsUi = null;
TimestampEditUi editUi = null;
DailyUi dailyUi = null;
ConfigUi configUi = null;
LicenseUi licenseUi = null;
w?.Run <UiReaderWriter, Lotter>(
(uiRW, lotter) =>
{
uiRW.WriteSync(
s,
() =>
{
homeUi = this.newHomeUi?.Invoke();
homeNavUi = this.newHomeNavUi?.Invoke(lotter);
statsUi = this.newStatsUi?.Invoke();
timestampsUi = this.newTimestampsUi?.Invoke(lotter);
editUi = this.newEditUi?.Invoke();
dailyUi = this.newDailyUi?.Invoke(lotter);
configUi = this.newConfigUi?.Invoke();
licenseUi = this.newLicenseUi?.Invoke(s);
});
});
var homeFinished = new ManualResetEvent(false);
var homeNavFinished = new ManualResetEvent(false);
var statsFinished = new ManualResetEvent(false);
var editFinished = new ManualResetEvent(false);
var timestampsFinished = new ManualResetEvent(false);
var dailyFinished = new ManualResetEvent(false);
var mainFinished = new ManualResetEvent(false);
var shutdownFinished = new ManualResetEvent(false);
var licenseFinished = new ManualResetEvent(false);
var configFinished = new ManualResetEvent(false);
w?.Run <Do <Do> >(invoker =>
{
invoker.Invoke(
() =>
{
e?.Execute(
new SetupHomeCommand(
homeUi,
s,
this.newReaderWriter,
this.newDataWatcher,
w));
homeFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupHomeNavCommand(
homeNavUi,
s.NavUi,
new NavigatorNavLogicReader(w),
w));
homeNavFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupStatisticsCommand(
statsUi,
homeUi,
w));
statsFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupTimestampEditCommand(
editUi,
homeUi,
w));
editFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupMainCommand(
s,
w,
new SettingsHolder()));
mainFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupShutdownCommand(
w));
shutdownFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupLicenseCommand(
licenseUi,
w));
licenseFinished.Set();
});
homeFinished.WaitOne();
invoker.Invoke(
() =>
{
e?.Execute(
new SetupTimestampsCommand(
timestampsUi,
homeUi,
w));
timestampsFinished.Set();
});
invoker.Invoke(
() =>
{
e?.Execute(
new SetupDailyCommand(
dailyUi,
homeUi,
new NavigatorUiReader(w),
w));
dailyFinished.Set();
});
});
// update to single-file format
w?.Run <FileTimestampManager>(manager =>
{
manager.ConvertToSingleFile();
});
w?.Run <DataWatcher>(watcher =>
{
watcher.Start();
});
w?.Run <Navigator>(
nav =>
{
nav.Present <HomePresenter>();
w.Run <Do <Do> >(invoker =>
{
homeNavFinished.WaitOne();
});
nav.PresentFluidly <HomeNavPresenter>();
w.Run <Do <Do> >(invoker =>
{
timestampsFinished.WaitOne();
});
nav.PresentFluidly <TimestampsPresenter>();
});
w?.Run <Do <Do> >(invoker =>
{
dailyFinished.WaitOne();
invoker.Invoke(() =>
{
e?.Execute(
new SetupConfigCommand(
configUi,
homeUi,
w));
configFinished.Set();
});
statsFinished.WaitOne();
editFinished.WaitOne();
mainFinished.WaitOne();
shutdownFinished.WaitOne();
licenseFinished.WaitOne();
configFinished.WaitOne();
});
}
public HomeUiLoadedEventArgs(HomeUi homeUi)
{
this.homeUi = homeUi;
}
