public static FileTableColumn Create(ControlRow control)
{
switch (control.Type)
{
case Constant.Control.Note:
case Constant.DatabaseColumn.File:
case Constant.DatabaseColumn.RelativePath:
return new FileTableNoteColumn(control);
case Constant.DatabaseColumn.ImageQuality:
return new FileTableChoiceColumn(control);
case Constant.Control.Counter:
return new FileTableCounterColumn(control);
case Constant.DatabaseColumn.DateTime:
return new FileTableDateTimeColumn(control);
case Constant.DatabaseColumn.DeleteFlag:
case Constant.Control.Flag:
return new FileTableFlagColumn(control);
case Constant.Control.FixedChoice:
return new FileTableChoiceColumn(control);
case Constant.DatabaseColumn.UtcOffset:
return new FileTableUtcOffsetColumn(control);
default:
throw new NotSupportedException(String.Format("Unhandled control type {0}.", control.Type));
}
}
protected DataEntryControl(ControlRow control, DataEntryControls styleProvider)
{
// populate properties from database definition of control
// this.Content and Tooltip can't be set, however, as the caller hasn't instantiated the content control yet
this.Copyable = control.Copyable;
this.DataLabel = control.DataLabel;
this.DefaultValue = control.DefaultValue;
// Create the stack panel
this.Container = new StackPanel();
Style style = styleProvider.FindResource(Constant.ControlStyle.ContainerStyle) as Style;
this.Container.Style = style;
// use the containers's tag to point back to this so event handlers can access the DataEntryControl
// this is needed by callbacks such as DataEntryHandler.Container_PreviewMouseRightButtonDown() and CarnassialWindow.CounterControl_MouseLeave()
this.Container.Tag = this;
}
public FileTableCounterColumn(ControlRow control)
: base(control)
{
}
/// <summary>
/// Update the database row for the control to the current content of the template table. The caller is responsible for ensuring the data row wrapped
/// by the ControlRow object is present in both the data table and database versions of the template table.
/// </summary>
public void SyncControlToDatabase(ControlRow control)
{
this.CreateBackupIfNeeded();
this.Database.Update(Constant.DatabaseTable.Controls, control.GetColumnTuples());
}
public void RemoveUserDefinedControl(ControlRow controlToRemove)
{
this.CreateBackupIfNeeded();
string controlType = controlToRemove.Type;
if (Constant.Control.StandardTypes.Contains(controlType))
{
throw new NotSupportedException(String.Format("Standard control of type {0} cannot be removed.", controlType));
}
// capture state
long removedControlOrder = controlToRemove.ControlOrder;
long removedSpreadsheetOrder = controlToRemove.SpreadsheetOrder;
// drop the control from the database and data table
string where = Constant.DatabaseColumn.ID + " = " + controlToRemove.ID;
this.Database.DeleteRows(Constant.DatabaseTable.Controls, where);
this.GetControlsSortedByControlOrder();
// regenerate counter and spreadsheet orders; if they're greater than the one removed, decrement
List<ColumnTuplesWithWhere> controlUpdates = new List<ColumnTuplesWithWhere>();
foreach (ControlRow control in this.Controls)
{
long controlOrder = control.ControlOrder;
long spreadsheetOrder = control.SpreadsheetOrder;
if (controlOrder > removedControlOrder)
{
List<ColumnTuple> controlUpdate = new List<ColumnTuple>();
controlUpdate.Add(new ColumnTuple(Constant.Control.ControlOrder, controlOrder - 1));
control.ControlOrder = controlOrder - 1;
controlUpdates.Add(new ColumnTuplesWithWhere(controlUpdate, control.ID));
}
if (spreadsheetOrder > removedSpreadsheetOrder)
{
List<ColumnTuple> controlUpdate = new List<ColumnTuple>();
controlUpdate.Add(new ColumnTuple(Constant.Control.SpreadsheetOrder, spreadsheetOrder - 1));
control.SpreadsheetOrder = spreadsheetOrder - 1;
controlUpdates.Add(new ColumnTuplesWithWhere(controlUpdate, control.ID));
}
}
this.Database.Update(Constant.DatabaseTable.Controls, controlUpdates);
// update the in memory table to reflect current database content
// should not be necessary but this is done to mitigate divergence in case a bug results in the delete lacking perfect fidelity
this.GetControlsSortedByControlOrder();
}
private ComboBox CreateComboBox(DataEntryControls styleProvider, ControlRow control)
{
ComboBox comboBox = new ComboBox();
comboBox.ToolTip = control.Tooltip;
comboBox.Width = control.Width;
foreach (string choice in control.GetChoices())
{
comboBox.Items.Add(choice);
}
comboBox.SelectedIndex = 0;
Style style = styleProvider.FindResource(ControlContentStyle.ChoiceComboBox.ToString()) as Style;
comboBox.Style = style;
return comboBox;
}
private UtcOffsetPicker CreateUtcOffsetPicker(ControlRow control)
{
UtcOffsetPicker utcOffsetPicker = new UtcOffsetPicker();
utcOffsetPicker.ToolTip = control.Tooltip;
utcOffsetPicker.Value = Constant.ControlDefault.DateTimeValue.Offset;
utcOffsetPicker.Width = control.Width;
return utcOffsetPicker;
}
public bool Synchronize(ControlRow other)
{
bool synchronizationMadeChanges = false;
if (this.Copyable != other.Copyable)
{
this.Copyable = other.Copyable;
synchronizationMadeChanges = true;
}
if (this.ControlOrder != other.ControlOrder)
{
this.ControlOrder = other.ControlOrder;
synchronizationMadeChanges = true;
}
if (this.DefaultValue != other.DefaultValue)
{
this.DefaultValue = other.DefaultValue;
synchronizationMadeChanges = true;
}
if (this.Label != other.Label)
{
this.Label = other.Label;
synchronizationMadeChanges = true;
}
if (this.List != other.List)
{
this.List = other.List;
synchronizationMadeChanges = true;
}
if (this.SpreadsheetOrder != other.SpreadsheetOrder)
{
this.SpreadsheetOrder = other.SpreadsheetOrder;
synchronizationMadeChanges = true;
}
if (this.Tooltip != other.Tooltip)
{
this.Tooltip = other.Tooltip;
synchronizationMadeChanges = true;
}
if (this.Visible != other.Visible)
{
this.Visible = other.Visible;
synchronizationMadeChanges = true;
}
if (this.Width != other.Width)
{
this.Width = other.Width;
synchronizationMadeChanges = true;
}
return synchronizationMadeChanges;
}
private CheckBox CreateFlag(DataEntryControls styleProvider, ControlRow control)
{
CheckBox checkBox = new CheckBox();
checkBox.Visibility = Visibility.Visible;
checkBox.ToolTip = control.Tooltip;
Style style = styleProvider.FindResource(ControlContentStyle.FlagCheckBox.ToString()) as Style;
checkBox.Style = style;
return checkBox;
}
private DateTimeOffsetPicker CreateDateTimePicker(ControlRow control)
{
DateTimeOffsetPicker dateTimePicker = new DateTimeOffsetPicker();
dateTimePicker.Value = Constant.ControlDefault.DateTimeValue;
dateTimePicker.ToolTip = control.Tooltip;
dateTimePicker.Width = control.Width;
return dateTimePicker;
}
private RadioButton CreateCounterLabelButton(DataEntryControls styleProvider, ControlRow control)
{
RadioButton radioButton = new RadioButton();
radioButton.GroupName = "DataEntryCounter";
radioButton.Content = control.Label;
radioButton.ToolTip = control.Tooltip;
Style style = styleProvider.FindResource(ControlLabelStyle.CounterButton.ToString()) as Style;
radioButton.Style = style;
return radioButton;
}
private void VerifyControl(ControlRow control)
{
Assert.IsTrue(control.ControlOrder > 0);
// nothing to sanity check for control.Copyable
Assert.IsFalse(String.IsNullOrWhiteSpace(control.DataLabel));
// nothing to sanity check for control.DefaultValue
Assert.IsTrue(control.ID >= 0);
Assert.IsFalse(String.IsNullOrWhiteSpace(control.Label));
// nothing to sanity check for control.List
Assert.IsTrue(control.SpreadsheetOrder > 0);
Assert.IsTrue(control.Width > 0);
Assert.IsFalse(String.IsNullOrWhiteSpace(control.Tooltip));
Assert.IsFalse(String.IsNullOrWhiteSpace(control.Type));
// nothing to sanity check for control.Visible
}
public void Verify(ControlRow control)
{
Assert.IsTrue(control.ControlOrder == this.ControlOrder, "{0}: Expected ControlOrder '{1}' but found '{2}'.", this.DataLabel, this.ControlOrder, control.ControlOrder);
Assert.IsTrue(control.Copyable == this.Copyable, "{0}: Expected Copyable '{1}' but found '{2}'.", this.DataLabel, this.Copyable, control.Copyable);
Assert.IsTrue(control.DataLabel == this.DataLabel, "{0}: Expected DataLabel '{1}' but found '{2}'.", this.DataLabel, this.DataLabel, control.DataLabel);
Assert.IsTrue(control.DefaultValue == this.DefaultValue, "{0}: Expected DefaultValue '{1}' but found '{2}'.", this.DataLabel, this.DefaultValue, control.DefaultValue);
Assert.IsTrue(control.ID == this.ID, "{0}: Expected ID '{1}' but found '{2}'.", this.DataLabel, this.ID, control.ID);
Assert.IsTrue(control.Label == this.Label, "{0}: Expected Label '{1}' but found '{2}'.", this.DataLabel, this.Label, control.Label);
Assert.IsTrue(control.List == this.List, "{0}: Expected List '{1}' but found '{2}'.", this.DataLabel, this.List, control.List);
Assert.IsTrue(control.SpreadsheetOrder == this.SpreadsheetOrder, "{0}: Expected SpreadsheetOrder '{1}' but found '{2}'.", this.DataLabel, this.SpreadsheetOrder, control.SpreadsheetOrder);
Assert.IsTrue(control.Width == this.TextBoxWidth, "{0}: Expected TextBoxWidth '{1}' but found '{2}'.", this.DataLabel, this.TextBoxWidth, control.Width);
Assert.IsTrue(control.Tooltip == this.Tooltip, "{0}: Expected Tooltip '{1}' but found '{2}'.", this.DataLabel, this.Tooltip, control.Tooltip);
Assert.IsTrue(control.Type == this.Type, "{0}: Expected Type '{1}' but found '{2}'.", this.DataLabel, this.Type, control.Type);
Assert.IsTrue(control.Visible == this.Visible, "{0}: Expected Visible '{1}' but found '{2}'.", this.DataLabel, this.Visible, control.Visible);
}
public FileTableDateTimeColumn(ControlRow control)
: base(control)
{
}
private ColumnDefinition CreateFileDataColumnDefinition(ControlRow control)
{
if (control.DataLabel == Constant.DatabaseColumn.DateTime)
{
return new ColumnDefinition(control.DataLabel, "DATETIME", DateTimeHandler.ToDatabaseDateTimeString(Constant.ControlDefault.DateTimeValue));
}
if (control.DataLabel == Constant.DatabaseColumn.UtcOffset)
{
// UTC offsets are typically represented as TimeSpans but the least awkward way to store them in SQLite is as a real column containing the offset in
// hours. This is because SQLite
// - handles TIME columns as DateTime rather than TimeSpan, requiring the associated DataTable column also be of type DateTime
// - doesn't support negative values in time formats, requiring offsets for time zones west of Greenwich be represented as positive values
// - imposes an upper bound of 24 hours on time formats, meaning the 26 hour range of UTC offsets (UTC-12 to UTC+14) cannot be accomodated
// - lacks support for DateTimeOffset, so whilst offset information can be written to the database it cannot be read from the database as .NET
// supports only DateTimes whose offset matches the current system time zone
// Storing offsets as ticks, milliseconds, seconds, minutes, or days offers equivalent functionality. Potential for rounding error in roundtrip
// calculations on offsets is similar to hours for all formats other than an INTEGER (long) column containing ticks. Ticks are a common
// implementation choice but testing shows no roundoff errors at single tick precision (100 nanoseconds) when using hours. Even with TimeSpans
// near the upper bound of 256M hours, well beyond the plausible range of time zone calculations. So there does not appear to be any reason to
// avoid using hours for readability when working with the database directly.
return new ColumnDefinition(control.DataLabel, "REAL", DateTimeHandler.ToDatabaseUtcOffsetString(Constant.ControlDefault.DateTimeValue.Offset));
}
if (String.IsNullOrWhiteSpace(control.DefaultValue))
{
return new ColumnDefinition(control.DataLabel, Constant.Sql.Text);
}
return new ColumnDefinition(control.DataLabel, Constant.Sql.Text, control.DefaultValue);
}
private Label CreateLabel(DataEntryControls styleProvider, ControlRow control)
{
Label label = new Label();
label.Content = control.Label;
label.ToolTip = control.Tooltip;
Style style = styleProvider.FindResource(ControlLabelStyle.DefaultLabel.ToString()) as Style;
label.Style = style;
return label;
}
protected FileTableColumn(ControlRow control)
{
this.ControlType = control.Type;
this.DataLabel = control.DataLabel;
}
private TextBox CreateTextBox(DataEntryControls styleProvider, ControlRow control)
{
TextBox textBox = new TextBox();
textBox.Text = control.DefaultValue;
textBox.ToolTip = control.Tooltip;
textBox.Width = control.Width;
Style style = styleProvider.FindResource(ControlContentStyle.NoteCounterTextBox.ToString()) as Style;
textBox.Style = style;
return textBox;
}
public FileTableFlagColumn(ControlRow control)
: base(control)
{
}
public FileTableChoiceColumn(ControlRow control)
: base(control)
{
this.choices = control.GetChoices();
this.defaultValue = control.DefaultValue;
}
