public void Source(ISetting setting, TextWriter output)
{
output.Write (setting.BlockBegin);
output.Write ("dump ");
output.Write (this.expression);
output.Write (setting.BlockEnd);
}
public SmartCPUBehaviour(IGrid grid, ISetting setting, CPUMode difficulty)
{
_grid = grid;
_gridSimulator = new GridSimulator(grid, setting);
_outputter = new OutputBestMovement(_gridSimulator);
_grid.OnGroupAdd += new OnGroupAddEventHandler(OnGroupAddEvent);
Debug.Log("difficulty " + difficulty + "set");
switch(difficulty)
{
case CPUMode.Easy:
timeBeforeAction = 0.5f;
timeBetweenActions = 0.5f;
break;
case CPUMode.Normal:
timeBeforeAction = 0.5f;
timeBetweenActions = 0.3f;
break;
case CPUMode.Hard:
timeBeforeAction = 0.2f;
timeBetweenActions = 0.1f;
break;
case CPUMode.Kusotuyo:
timeBeforeAction = 0f;
timeBetweenActions = 0f;
break;
}
}
public ReadyForNextGroupState(ISetting setting, IGrid grid, IGroupFactory groupFactory, OnDeleteEndEventHandler onDeleteEndEvent)
{
_setting = setting;
_grid = grid;
_groupFactory = groupFactory;
_onDeleteEndEvent = onDeleteEndEvent;
}
private static void FillSettingParameterAttributes(SettingSerializerData settingSerializerData, ISetting setting, Type settingType)
{
var propertyInfos = settingType.GetProperties().ToList();
foreach (var propertyInfo in propertyInfos)
{
var settingParameterAttribute = AttributeRetrieval.GetAttribute<SettingParameterAttribute>(propertyInfo);
if (settingParameterAttribute == null)
{
continue;
}
var settingPropertyValue = propertyInfo.GetValue(setting);
RunSettingSerializationValidation(settingType, propertyInfo, settingPropertyValue);
var settingPropertyFormattedValue = RunSettingSerializationFormat(settingParameterAttribute, settingType, propertyInfo, settingPropertyValue);
settingSerializerData.Parameters.Add(new SettingSerializerDataParameter
{
Value = settingPropertyFormattedValue,
Parameter = settingParameterAttribute,
});
}
}
private static void SetInput( IBlock block, ISetting setting ) {
String lbl = "setting.inputControl";
String inputName = GetInputName( setting.Id );
String settingValue = setting.SettingValue;
int width = 500;
if (setting.DataType == SettingType.Int.ToString()) {
block.Set( lbl, Html.TextInput( inputName, settingValue, "width:40px;" ) );
}
else if (setting.DataType == SettingType.Bool.ToString()) {
block.Set( lbl, Html.CheckBox( inputName, "", "1", Convert.ToBoolean( setting.SettingValue ) ) );
}
else if (setting.DataType == SettingType.Droplist.ToString()) {
block.Set( lbl, Html.DropList( getDropOptions(setting.Options), inputName, "Name", "Value", setting.ValueInt ) );
}
else if (setting.DataType == SettingType.ShortText.ToString()) {
block.Set( lbl, Html.TextInput( inputName, settingValue, "width:" + width + "px;" ) );
}
else if (setting.DataType == SettingType.BigText.ToString()) {
block.Set( lbl, Html.TextArea( inputName, settingValue, "width:" + width + "px;height:300px;" ) );
}
else {
block.Set( lbl, Html.TextArea( inputName, settingValue, "width:" + width + "px;height:50px;" ) );
}
}
public void Source(ISetting setting, TextWriter output)
{
string keyword;
string link;
switch (this.mode)
{
case StoreMode.Local:
keyword = "declare";
link = "as";
break;
default:
keyword = "set";
link = "to";
break;
}
output.Write (setting.BlockBegin);
output.Write (keyword);
output.Write (' ');
output.Write (this.name);
output.Write (' ');
output.Write (link);
output.Write (' ');
output.Write (this.expression);
output.Write (setting.BlockEnd);
}
public void Set(ISetting setting)
{
ISetting found = _settings.FirstOrDefault(s => s.Name == setting.Name);
if (found != null)
_settings.Remove(found);
_settings.Add(setting);
}
public GeneralOptionsViewModel(ISetting<GeneralOptions> setting, ISchedulerProvider schedulerProvider)
{
var reader = setting.Value.Subscribe(options =>
{
UseDarkTheme = options.Theme== Theme.Dark;
HighlightTail = options.HighlightTail;
HighlightDuration = options.HighlightDuration;
Scale = options.Scale;
});
var writter = this.WhenAnyPropertyChanged()
.Subscribe(vm =>
{
setting.Write(new GeneralOptions(UseDarkTheme ? Theme.Dark : Theme.Light, HighlightTail, HighlightDuration, Scale));
});
HighlightDurationText = this.WhenValueChanged(vm=>vm.HighlightDuration)
.Select(value => value.ToString("0.00 Seconds"))
.ForBinding();
ScaleText = this.WhenValueChanged(vm => vm.Scale)
.Select(value => $"{value} %" )
.ForBinding();
ScaleRatio= this.WhenValueChanged(vm => vm.Scale)
.Select(value =>(decimal)value / (decimal)100)
// .Sample(TimeSpan.FromMilliseconds(250))
.ForBinding();
_cleanUp = new CompositeDisposable(reader, writter, HighlightDurationText, ScaleText, ScaleRatio);
}
public void TearDown()
{
this.setting = null;
this.settingType = default(SettingType);
this.settingValue = null;
this.possibleValues = null;
}
public IGroup Create(ISetting setting)
{
IGroup nextGroup = _groupStocks[0];
var parent = nextGroup.Parent;
if (parent != null)
{
var childCount = parent.childCount;
for(int i = 0; i < childCount; i++)
{
var child = parent.GetChild(0);
child.SetParent(setting.Parent);
child.localScale = setting.Parent.localScale;
}
parent.gameObject.AddComponent<DestroyGameObject>();
}
else
{
nextGroup.Offset = Vector3.zero;
}
_groupStocks.Remove(_groupStocks[0]);
CreateNextStock(setting);
return nextGroup;
}
public RecentSearchCollection(ILogger logger, ISetting<RecentSearch[]> setting)
{
if (logger == null) throw new ArgumentNullException("logger");
_logger = logger;
Items = _files.Connect()
.RemoveKey()
.AsObservableList();
var loader = setting.Value.Subscribe(files =>
{
_files.Edit(innerCache =>
{
//all files are loaded when state changes, so only add new ones
var newItems = files
.Where(f => !innerCache.Lookup(f.Text).HasValue)
.ToArray();
innerCache.AddOrUpdate(newItems);
});
});
var settingsWriter = _files.Connect()
.ToCollection()
.Subscribe(items =>
{
setting.Write(items.ToArray());
});
_cleanUp = new CompositeDisposable(settingsWriter, loader, _files,Items);
}
public void Source(ISetting setting, TextWriter output)
{
output.Write (setting.BlockBegin);
output.Write ("for ");
if (!string.IsNullOrEmpty (this.key))
{
output.Write (this.key);
output.Write (", ");
}
output.Write (this.value);
output.Write (" in ");
output.Write (this.from);
output.Write (":");
this.body.Source (setting, output);
if (this.empty != null)
{
output.Write (setting.BlockContinue);
output.Write ("empty:");
this.empty.Source (setting, output);
}
output.Write (setting.BlockEnd);
}
public Game(IGrid grid, ISetting setting)
{
_setting = setting;
_grid = grid;
currentControl = _grid;
}
private HtmlGenericControl getDataLineContainer(ISetting setting)
{
HtmlGenericControl div_line = new HtmlGenericControl("div");
div_line.Attributes.Add("class", "control-line-of-controls");
HtmlGenericControl div_data_label = new HtmlGenericControl("div");
div_data_label.Attributes.Add("style", "padding-top: 3px; float: left; width: 200px");
div_data_label.Attributes.Add("align", "left");
div_data_label.Attributes.Add("class", "control-label");
div_data_label.InnerText = getLocalResource(setting);
HtmlGenericControl div_data_input = new HtmlGenericControl("div");
div_data_input.Attributes.Add("style", "float: left; width: 360px");
TextBox box = new TextBox
{
Text = setting.Value.ToString()
, ID = string.Format(m_objectKey, setting.SettingAttribute.SettingName)
, CssClass = "control-textbox"
, EnableTheming = false
};
box.Attributes.Add("style", "width: 100%");
div_data_input.Controls.Add(box);
div_line.Controls.Add(div_data_label);
div_line.Controls.Add(div_data_input);
return div_line;
}
public static string Serialize(ISetting setting)
{
var settingData = GetSettingData(setting);
var settingSerializer = new SettingSerializerWriter(settingData);
return settingSerializer.Write();
}
public GridEventManager(ISetting setting, IGrid grid, IGroupFactory groupFactory)
{
_grid = grid;
_groupFactory = groupFactory;
_setting = setting;
}
public EnvironmentSetting(string machineName, string environment, string name, string provider, ISetting setting)
{
Setting = setting;
MachineName = machineName;
Environment = environment;
Name = name;
Provider = provider;
}
public EnvironmentSetting(ISetting setting)
{
Setting = setting;
Name = GetNameFromSettingName(setting);
MachineName = GetMachineName(setting);
Environment = GetEnvironment(setting);
Provider = GetProviderFromSettingName(setting);
}
public void SpawnParticle(ISetting setting, Vector2 position, Color color)
{
Transform spawnedParticle = Instantiate(particle, Vector3.zero, Quaternion.identity) as Transform;
spawnedParticle.SetParent(setting.Parent);
spawnedParticle.GetComponent<ParticleSystem>().startColor = color;
spawnedParticle.position = new Vector3(position.x, position.y, -1);
}
} // GetEnumerator
// ----------------------------------------------------------------------
public bool Contains(ISetting setting)
{
if (setting == null)
{
throw new ArgumentNullException("setting");
}
return settings.Contains(setting);
} // Contains
public Player(IActionManager bl, ISetting setting, Random rd)
: base(bl, setting, rd)
{
NbTry = 1;
CheckCharacter = new Check(bl);
gameOver = new EndGame(bl);
PropertyChanged += Play_PropertyChanged;
}
public AddGroupCommand(IGrid grid, ISetting setting, IGroup group, List<IBlock> allBlocks, OnGroupAddEventHandler onGroupAddEvent)
: base(grid)
{
_setting = setting;
_group = group;
_allBlocks = allBlocks;
_onGroupAddEvent = onGroupAddEvent;
}
public void TestTypePropertyIsNotNullWithNonDefaultConstructor()
{
foreach (object value in this.possibleValues)
{
this.setting = this.GetSetting(value);
Assert.IsNotNull(this.setting.Type);
}
}
public void InitializeFactoriesAndSetting()
{
//blockViewSpawner = Substitute.For<IBlockViewSpawner>();
blockFactory = new BlockFactory(blockViewSpawner);
groupFactory = new GroupFactory(blockFactory);
setting = TestSetting.Get();
}
private bool RemoveConnSetting(ISetting setting)
{
if (Settings.Any(s => s.Key == setting.Key))
{
_settings.Remove(Settings.Single(s => s.Key == setting.Key));
return true;
}
return false;
}
private bool RemoveAppSetting(ISetting setting)
{
if (Configuration.AppSettings.Settings.AllKeys.Any(k => k == setting.Key))
{
Configuration.AppSettings.Settings.Remove(setting.Key);
return true;
}
return false;
}
} // Contains
// ----------------------------------------------------------------------
public void Add(ISetting setting)
{
if (setting == null)
{
throw new ArgumentNullException("setting");
}
setting.ApplicationSettings = applicationSettings;
settings.Add(setting);
} // Add
public virtual void Reload()
{
if (!File.Exists(SettingPath))
{
RestoreToDefault();
Save();
}
m_Instance = ObjectXMLSerialize<ISetting>.Load(this, SettingPath);
this.Assign(m_Instance);
}
private static void FillSettingAttribute(SettingSerializerData settingSerializerData, ISetting setting, Type settingType)
{
var settingParameter = AttributeRetrieval.GetAttribute<SettingAttribute>(settingType);
if (settingParameter == null)
{
throw new Exception(string.Format("ISetting type of \"{0}\", does not contain the FilterAttribute and must.", settingParameter.Name));
}
settingSerializerData.Setting = settingParameter;
}
private static SettingAttribute GetSettingsAttribute(ISetting setting)
{
var settingsAttribute = AttributeRetrieval.GetAttribute<SettingAttribute>(setting.GetType());
if (settingsAttribute == null)
{
throw new InvalidOperationException(string.Format("ISetting \"{0}\", does not include the SettingAttribute.", setting.GetType().Name));
}
return settingsAttribute;
}
public StringComboBoxAdapter(ISetting <string> setting, ComboBox comboBox)
: base(setting.FullPath, comboBox.Items.Cast <string>().ToList(), setting.Default)
{
CustomControl = comboBox;
}
/// <summary>
/// Copies the contents of a source to a destination based on an individual setting
/// </summary>
/// <param name="setting">Contains information on a source and destination pair</param>
/// <param name="loggingBackgroundWorker">A <see cref="BackgroundWorker"/> instance to provide updates to</param>
public void Copy(ISetting setting, LoggingBackgroundWorker loggingBackgroundWorker)
{
if (setting == null)
{
throw new ArgumentNullException(nameof(setting));
}
if (loggingBackgroundWorker == null)
{
throw new ArgumentNullException(nameof(loggingBackgroundWorker));
}
if (string.IsNullOrWhiteSpace(setting.Source))
{
try
{
throw new Exception("Source path is null or whitespace.");
}
catch (Exception e)
{
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Exception = e
});
return;
}
}
if (string.IsNullOrWhiteSpace(setting.Destination))
{
try
{
throw new Exception("Destination path is null or whitespace.");
}
catch (Exception e)
{
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Exception = e
});
return;
}
}
if (!Directory.Exists(setting.Source))
{
try
{
throw new Exception($"Source path {setting.Source} doesn't exist on disk.");
}
catch (Exception e)
{
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Exception = e
});
return;
}
}
if (!Directory.Exists(setting.Destination))
{
try
{
Utilities.IO.Directory.CreateDirectory(setting.Destination);
// throw new Exception($"Destination path {setting.Destination} doesn't exist on disk.");
}
catch (Exception e)
{
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Exception = e
});
return;
}
}
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Message = $"Counting objects in {setting.Source}"
});
this.totalObjectCount = Utilities.IO.Directory.CountObjects(setting.Source, true);
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Message = $"Files and folders in source directory: {this.totalObjectCount}."
});
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Message = $"Attempting to copy from {setting.Source} \r\nto {setting.Destination}."
});
// Note: if files / subdirs are added to a directory, the lastwritetime reflects the time they were added.
// However, if files / subdirs are added to a directory's subdir, the lastwritetime is not updated
// Therefore, only iterate through a directorys subdirs not its files when the lastwritetime isn't more recent than the destination equivalent
this.CopyIfNewer(setting.Source, setting.Destination, setting.BackupMode, loggingBackgroundWorker);
loggingBackgroundWorker.OnLog(this, new LoggingEventArgs {
Message = "Done!"
});
}
////public static SqlCommand CreateDeleteCommand(SqlConnection connection, IIdentifier id, IImmutableDictionary<string, object> where)
////{
//// /*
//// DELETE FROM [dbo].[Setting] WHERE [Name] LIKE 'baz%' AND [Environment] = 'boz'
//// */
//// var sql = new StringBuilder();
//// var dbProviderFactory = DbProviderFactories.GetFactory(connection);
//// using (var commandBuilder = dbProviderFactory.CreateCommandBuilder())
//// {
//// string Sanitize(string identifier) => commandBuilder.QuoteIdentifier(identifier);
//// var table = $"{Sanitize(_tableMetadata.SchemaName)}.{Sanitize(_tableMetadata.TableName)}";
//// sql.Append($"DELETE FROM {table}").AppendLine();
//// sql.Append(where.Keys.Aggregate(
//// $"WHERE ([{EntityProperty.Name}] = @{EntityProperty.Name} OR [{EntityProperty.Name}] LIKE @{EntityProperty.Name} + N'[[]%]')",
//// (result, next) => $"{result} AND {Sanitize(next)} = @{next} ")
//// );
//// }
//// var command = connection.CreateCommand();
//// command.CommandType = CommandType.Text;
//// command.CommandText = sql.ToString();
//// // --- add parameters & values
//// (command, _tableMetadata).AddParameter(
//// ImmutableDictionary<string, object>.Empty
//// .Add(EntityProperty.Name, id.ToString())
//// .AddRange(where)
//// );
//// return command;
////}
public static SqlCommand CreateUpdateCommand(this SqlConnection connection, SqlServer datastore, ISetting setting)
{
/*
*
* UPDATE [Setting]
* SET [Value] = 'Hallo update!'
* WHERE [Name]='baz' AND [Environment] = 'boz'
* IF @@ROWCOUNT = 0
* INSERT INTO [Setting]([Name], [Value], [Environment])
* VALUES ('baz', 'Hallo insert!', 'boz')
*
*/
var sql = new StringBuilder();
var dbProviderFactory = DbProviderFactories.GetFactory(connection);
using (var commandBuilder = dbProviderFactory.CreateCommandBuilder())
{
string Sanitize(string identifier) => commandBuilder.QuoteIdentifier(identifier);
var table = $"{Sanitize(datastore.Schema)}.{Sanitize(datastore.Table)}";
sql.Append($"UPDATE {table}").AppendLine();
sql.Append($"SET [{nameof(ISetting.Value)}] = @{nameof(ISetting.Value)}").AppendLine();
sql.Append(datastore.Where.Aggregate(
$"WHERE [{nameof(ISetting.Name)}] = @{nameof(ISetting.Name)}",
(result, next) => $"{result} AND {Sanitize(next.Key)} = @{next.Key} ")
).AppendLine();
sql.Append($"IF @@ROWCOUNT = 0").AppendLine();
var columns = datastore.Where.Keys.Select(Sanitize).Aggregate(
$"[{nameof(ISetting.Name)}], [{nameof(ISetting.Value)}]",
(result, next) => $"{result}, {next}"
);
sql.Append($"INSERT INTO {table}({columns})").AppendLine();
var parameterNames = datastore.Where.Keys.Aggregate(
$"@{nameof(ISetting.Name)}, @{nameof(ISetting.Value)}",
(result, next) => $"{result}, @{next}"
);
sql.Append($"VALUES ({parameterNames})");
}
var command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = sql.ToString();
// --- add parameters
command.Parameters.AddWithValue(nameof(ISetting.Name), setting.Name.ToString());
command.Parameters.AddWithValue(nameof(ISetting.Value), setting.Value);
command.AddParameters(datastore.Where);
return(command);
}
protected void Init(ICacheFactory iCacheFactory, ISetting iSetting)
{
Cache = _iCacheFactory.Get(CacheName.App);
}
public FileAssemblyReferenceLoader(ISetting <IKernelConfiguration> kernelConfiguration)
{
_assembliesBasePath = kernelConfiguration.Value.AssembliesBasePath;
}
public CPUManager(IGrid grid, ISetting setting)
{
_grid = grid;
_setting = setting;
_behaviour = new NullBehaviour();
}
public AppServiceBase(ISetting config, IRepositoryRegistry context)
{
Config = config.Facet;
Context = context;
}
public string Serialize(ISetting setting) => setting.ObjValue?.ToString();
//ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*ﾟ+｡｡+ﾟ*｡+ﾟ ﾟ+｡*
#region // 構築・破棄
public MainViewDomain(ISetting setting)
{
this._setting = setting;
}
public static void AddSetting(this SettingsLayout aLayout, ISetting aSetting)
{
aLayout.AddSettingControl(aSetting.CreateControlBinding());
}
public void WriteSerializerSpecifier(ISetting setting)
{
BuilderBase.Append(" ");
BuilderBase.Append(SettingSerializer.Serialize(setting));
}
public IBlock Create(ISetting setting, BlockType blockType, Coord location)
{
return(Create(null, setting, blockType, location));
}
public DynamicDocument(TextReader reader, ISetting setting)
{
IParser parser = ParserFactory.BuildParser(setting);
this.main = new Function(new string[0], parser.Parse(reader), setting.Trimmer, string.Empty);
}
public IntTextBoxAdapter(ISetting <int?> setting, TextBox control)
: base(setting.FullPath, setting.Default.Value)
{
CustomControl = control;
}
public void SetValue(string value, ISetting iSetting, int zoomFlag = 1)
{
this.nameInput.Text = value;
this._zoomFlag = zoomFlag;
this._iSetting = iSetting;
}
public TailViewModel([NotNull] ILogger logger,
[NotNull] ISchedulerProvider schedulerProvider,
[NotNull] IFileWatcher fileWatcher,
[NotNull] ISelectionMonitor selectionMonitor,
[NotNull] IClipboardHandler clipboardHandler,
[NotNull] ISearchInfoCollection searchInfoCollection,
[NotNull] IInlineViewerFactory inlineViewerFactory,
[NotNull] ISetting <GeneralOptions> generalOptions,
[NotNull] ISearchMetadataCollection searchMetadataCollection,
[NotNull] IStateBucketService stateBucketService,
[NotNull] SearchOptionsViewModel searchOptionsViewModel,
[NotNull] ITailViewStateRestorer restorer,
[NotNull] SearchHints searchHints,
[NotNull] ITailViewStateControllerFactory tailViewStateControllerFactory)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (schedulerProvider == null)
{
throw new ArgumentNullException(nameof(schedulerProvider));
}
if (fileWatcher == null)
{
throw new ArgumentNullException(nameof(fileWatcher));
}
if (selectionMonitor == null)
{
throw new ArgumentNullException(nameof(selectionMonitor));
}
if (clipboardHandler == null)
{
throw new ArgumentNullException(nameof(clipboardHandler));
}
if (searchInfoCollection == null)
{
throw new ArgumentNullException(nameof(searchInfoCollection));
}
if (inlineViewerFactory == null)
{
throw new ArgumentNullException(nameof(inlineViewerFactory));
}
if (generalOptions == null)
{
throw new ArgumentNullException(nameof(generalOptions));
}
if (searchMetadataCollection == null)
{
throw new ArgumentNullException(nameof(searchMetadataCollection));
}
if (stateBucketService == null)
{
throw new ArgumentNullException(nameof(stateBucketService));
}
if (searchOptionsViewModel == null)
{
throw new ArgumentNullException(nameof(searchOptionsViewModel));
}
if (searchHints == null)
{
throw new ArgumentNullException(nameof(searchHints));
}
Name = fileWatcher.FullName;
SelectionMonitor = selectionMonitor;
SearchOptions = searchOptionsViewModel;
SearchHints = searchHints;
SearchCollection = new SearchCollection(searchInfoCollection, schedulerProvider);
CopyToClipboardCommand = new Command(() => clipboardHandler.WriteToClipboard(selectionMonitor.GetSelectedText()));
OpenFileCommand = new Command(() => Process.Start(fileWatcher.FullName));
OpenFolderCommand = new Command(() => Process.Start(fileWatcher.Folder));
SearchMetadataCollection = searchMetadataCollection;
UsingDarkTheme = generalOptions.Value
.ObserveOn(schedulerProvider.MainThread)
.Select(options => options.Theme == Theme.Dark)
.ForBinding();
HighlightTail = generalOptions.Value
.ObserveOn(schedulerProvider.MainThread)
.Select(options => options.HighlightTail)
.ForBinding();
HighlightDuration = generalOptions.Value
.ObserveOn(schedulerProvider.MainThread)
.Select(options => new Duration(TimeSpan.FromSeconds(options.HighlightDuration)))
.ForBinding();
//this deails with state when loading the system at start up and at shut-down
_stateProvider = new TailViewPersister(this, restorer);
//this controller responsible for loading and persisting user search stuff as the user changes stuff
var stateController = tailViewStateControllerFactory.Create(this);
//An observable which acts as a scroll command
var autoChanged = this.WhenValueChanged(vm => vm.AutoTail);
var scroller = _userScrollRequested.CombineLatest(autoChanged, (user, auto) =>
{
var mode = AutoTail ? ScrollReason.Tail : ScrollReason.User;
return(new ScrollRequest(mode, user.PageSize, user.FirstIndex));
})
.Do(x => logger.Info("Scrolling to {0}/{1}", x.FirstIndex, x.PageSize))
.DistinctUntilChanged();
FileStatus = fileWatcher.Status.ForBinding();
//command to add the current search to the tail collection
var searchInvoker = SearchHints.SearchRequested.Subscribe(request =>
{
searchInfoCollection.Add(request.Text, request.UseRegEx);
});
//User feedback to show file size
FileSizeText = fileWatcher.Latest.Select(fn => fn.Size)
.Select(size => size.FormatWithAbbreviation())
.DistinctUntilChanged()
.ForBinding();
//tailer is the main object used to tail, scroll and filter in a file
var lineScroller = new LineScroller(SearchCollection.Latest.ObserveOn(schedulerProvider.Background), scroller);
//load lines into observable collection
var lineProxyFactory = new LineProxyFactory(new TextFormatter(searchMetadataCollection), new LineMatches(searchMetadataCollection));
var loader = lineScroller.Lines.Connect()
.LogChanges(logger, "Received")
.Transform(lineProxyFactory.Create, new ParallelisationOptions(ParallelType.Ordered, 3))
.LogChanges(logger, "Sorting")
.Sort(SortExpressionComparer <LineProxy> .Ascending(proxy => proxy))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data, 100)
.LogChanges(logger, "Bound")
.DisposeMany()
.LogErrors(logger)
.Subscribe();
//monitor matching lines and start index,
Count = searchInfoCollection.All.Select(latest => latest.Count).ForBinding();
CountText = searchInfoCollection.All.Select(latest => $"{latest.Count.ToString("##,###")} lines").ForBinding();
LatestCount = SearchCollection.Latest.Select(latest => latest.Count).ForBinding();
////track first visible index
var firstIndexMonitor = lineScroller.Lines.Connect()
.Buffer(TimeSpan.FromMilliseconds(25)).FlattenBufferResult()
.ToCollection()
.Select(lines => lines.Count == 0 ? 0 : lines.Select(l => l.Index).Max() - lines.Count + 1)
.ObserveOn(schedulerProvider.MainThread)
.Subscribe(first =>
{
FirstIndex = first;
});
//Create objects required for inline viewing
var isUserDefinedChanged = SearchCollection.WhenValueChanged(sc => sc.Selected)
.Where(selected => selected != null)
.Select(selected => selected.IsUserDefined)
.DistinctUntilChanged()
.Replay(1)
.RefCount();
var inlineViewerVisible = isUserDefinedChanged.CombineLatest(this.WhenValueChanged(vm => vm.ShowInline),
(userDefined, showInline) => userDefined && showInline);
CanViewInline = isUserDefinedChanged.ForBinding();
InlineViewerVisible = inlineViewerVisible.ForBinding();
//return an empty line provider unless user is viewing inline - this saves needless trips to the file
var inline = searchInfoCollection.All.CombineLatest(inlineViewerVisible, (index, ud) => ud ? index : new EmptyLineProvider());
InlineViewer = inlineViewerFactory.Create(inline, this.WhenValueChanged(vm => vm.SelectedItem), lineProxyFactory);
_cleanUp = new CompositeDisposable(lineScroller,
loader,
firstIndexMonitor,
FileStatus,
Count,
LatestCount,
FileSizeText,
CanViewInline,
InlineViewer,
InlineViewerVisible,
SearchCollection,
searchInfoCollection,
HighlightTail,
UsingDarkTheme,
searchHints,
searchMetadataCollection,
SelectionMonitor,
SearchOptions,
searchInvoker,
stateController,
_userScrollRequested.SetAsComplete());
}
private static SettingSerializerData GetSettingData(ISetting setting)
{
return(SettingSerializerAttributeParser.GetSettingSerializerData(setting));
}
public void SetSettingDelegate(ISetting s)
{
settingDelegate = s;
}
/// <summary>
///
/// </summary>
/// <param name="ILog4netHelper"></param>
/// <param name="ISetting"></param>
public VendorsController(ILog4netHelper ILog4netHelper, ISetting ISetting)
{
_ILog4netHelper = ILog4netHelper;
_ISetting = ISetting;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ILog4netHelper"></param>
/// <param name="IWarehouseRepository"></param>
/// <param name="ISetting"></param>
public WarehouseController(ILog4netHelper ILog4netHelper, IWarehouseRepository IWarehouseRepository, ISetting ISetting)
{
_ILog4netHelper = ILog4netHelper;
_IWarehouseRepository = IWarehouseRepository;
_ISetting = ISetting;
}
public SettingRepoImpl(ISetting setting)
{
this._setting = setting;
}
public override ISettingEditorControl GetInstanceForSetting(ISetting setting)
{
return(new IntSettingEditor(setting));
}
protected void AddSettingBinding(ISetting <string> setting, ComboBox comboBox)
{
var adapter = new StringComboBoxAdapter(setting, comboBox);
AddControlBinding(adapter.CreateControlBinding());
}
public BoolCheckBoxAdapter(ISetting <bool?> setting, CheckBox checkBox)
: base(setting.FullPath, setting.Default.Value)
{
CustomControl = checkBox;
}
public ISetting GetSetting()
{
ISetting setting = null;
return(setting);
}
public DynamicDocument(string template, ISetting setting) :
this(new StringReader(template), setting)
{
}
protected void AddSettingBinding(ISetting <bool?> setting, CheckBox checkBox)
{
var adapter = new BoolCheckBoxAdapter(setting, checkBox);
AddControlBinding(adapter.CreateControlBinding());
}
protected void AddSettingBinding(ISetting <int?> setting, TextBox control)
{
var adapter = new IntTextBoxAdapter(setting, control);
AddControlBinding(adapter.CreateControlBinding());
}
public DealerUserShippingController(rst374_cloud12Context context, ISetting isettings)
{
_context = context;
_isettings = isettings;
}
public IntSettingEditor(ISetting setting) :
base(setting)
{
InitializeComponent();
}
