private void NegativeScoresAllowed(bool value)
{
SettingsUtil.SetNegativeScoresAllowed(value);
}
public ZXSpectrumSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public GPGXSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public AmstradCPCSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public QuickNESSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public ChannelFSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public VectrexSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public void Bus_PublishAsync_EventHub_Nominal()
{
var id = Guid.NewGuid();
bool testOk = false;
var message = new TestMessage()
{
SomeData = id.ToString()
};
var serializer = new JSONSerializer();
var publisher = new AzureEventHubPublishTransport(serializer);
IBus bus = new Bus(serializer, new AzureStorageQueueSendTransport(serializer), publisher);
bus.Context = new AFBusMessageContext();
bus.PublishAsync(message, TOPICNAME).Wait();
var eventProcessorHost = new EventProcessorHost(TOPICNAME, PartitionReceiver.DefaultConsumerGroupName, SettingsUtil.GetSettings <string>(SETTINGS.AZURE_EVENTHUB), SettingsUtil.GetSettings <string>(SETTINGS.AZURE_STORAGE), "eventhubcontainer");
// Registers the Event Processor Host and starts receiving messages
var readingTask = eventProcessorHost.RegisterEventProcessorFactoryAsync(new AzureStreamProcessorFactory(stringMessage =>
{
var finalMessageEnvelope = JsonConvert.DeserializeObject <AFBusMessageEnvelope>(stringMessage, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
});
var finalMessage = JsonConvert.DeserializeObject <TestMessage>(finalMessageEnvelope.Body, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple
});
testOk = testOk || (id.ToString() == finalMessage.SomeData);
}));
Task.Delay(5000).Wait();
// Disposes of the Event Processor Host
eventProcessorHost.UnregisterEventProcessorAsync().Wait();
Assert.IsTrue(testOk);
}
public void ToggleSFX()
{
SettingsUtil.ToggleSFXMuted();
}
public A7800Settings()
{
SettingsUtil.SetDefaultValues(this);
}
private static void PostBuildCheck(IPostBuildReporter rep)
{
SettingsUtil.PostBuildStep <Settings>(rep);
}
static void Main()
{
Console.OutputEncoding = Encoding.UTF8;
Console.WindowWidth = 200;
Console.WindowHeight = 40;
var curUser = Environment.UserName;
curUser = curUser.Substring(0, 1).ToUpper() + curUser.Substring(1).ToLower();
Settings settings;
SettingsUtil.LoadSettings(out settings);
var highscore = settings.Highscores[curUser];
var recent = new AutoDictionary <string, Highscore>(_ => new Highscore());
int cur = 0;
ConsoleColoredString lastAttemptOutcome = null;
while (true)
{
Console.Clear();
Console.WriteLine("Current highscores, in milliseconds:");
WriteToConsole(settings.Highscores.Concat(recent).ToDictionary());
if (lastAttemptOutcome != null)
{
Console.WriteLine();
ConsoleUtil.WriteLine("Last attempt: " + lastAttemptOutcome);
}
Console.WriteLine();
Console.WriteLine("Type every letter A-Z exactly once, either alphabetically or in any order. Wait 1 second when done, or press space to restart.");
Console.WriteLine();
var pressed = new Dictionary <char, DateTime>();
Console.Title = string.Join(" ", Enumerable.Range('A', 26).Select(x => (char)x).Except(pressed.Keys).OrderBy(x => x));
while (true)
{
var key = Console.ReadKey(true);
Console.Write((key.KeyChar + " ").ToUpper());
if (key.KeyChar < 'a' || key.KeyChar > 'z')
{
break;
}
var chr = char.ToUpper(key.KeyChar);
if (pressed.ContainsKey(chr))
{
break;
}
pressed[chr] = DateTime.UtcNow;
Console.Title = string.Join(" ", Enumerable.Range('A', 26).Select(x => (char)x).Except(pressed.Keys).OrderBy(x => x));
if (pressed.Count == 26)
{
break;
}
}
Console.WriteLine();
Console.WriteLine('\x7');
if (pressed.Count == 26)
{
Console.WriteLine("Don't press anything now, to confirm you've typed just the 26 letters accurately and nothing else!");
var wait = DateTime.UtcNow;
while (DateTime.UtcNow < wait + TimeSpan.FromSeconds(1) && !Console.KeyAvailable)
{
Thread.Sleep(10);
}
}
if (pressed.Count == 26 && !Console.KeyAvailable)
{
UpdateHighscore(highscore, pressed);
cur++;
UpdateHighscore(recent[$"Recent: {cur:00}"], pressed);
if (recent.ContainsKey($"Recent: {cur - 20:00}"))
{
recent.Remove($"Recent: {cur - 20:00}");
}
lastAttemptOutcome = "";
char expected = 'A';
bool alphabetic = true;
foreach (var kvp in pressed.OrderBy(kvp => kvp.Value))
{
if (kvp.Key != expected)
{
alphabetic = false;
}
lastAttemptOutcome += $"{kvp.Key} ".Color(kvp.Key != expected ? ConsoleColor.Red : alphabetic ? ConsoleColor.Green : ConsoleColor.White);
expected = (char)(kvp.Key + 1);
}
lastAttemptOutcome = (alphabetic ? "ALPHABETIC" : "any order") + " " + lastAttemptOutcome;
settings.Save();
}
else
{
lastAttemptOutcome = "OOPS!...".Color(ConsoleColor.Magenta);
}
Console.WriteLine();
Console.WriteLine();
}
}
private void listViewDevices_MouseClick(object sender, MouseEventArgs e)
{
if (IsInBenchmark)
{
return;
}
if (IsMining)
{
return;
}
if (e.Button == MouseButtons.Right)
{
if (listViewDevices.FocusedItem.Bounds.Contains(e.Location) == true)
{
contextMenuStrip1.Items.Clear();
var tsi = new ToolStripMenuItem("Rename", null, (o, args) =>
{
var d = listViewDevices.FocusedItem;
var renameForm = new Form_DeviceRename();
renameForm.SetCurrentName(d.Text);
if (renameForm.ShowDialog() == DialogResult.OK)
{
d.Text = renameForm.NewName;
SettingsUtil.SetNameForDevice(d.Text, (d.Tag as ComputeDevice).UUID);
SettingsUtil.SaveSettings();
}
});
contextMenuStrip1.Items.Add(tsi);
if (IsSettingsCopyEnabled)
{
var CDevice = listViewDevices.FocusedItem.Tag as ComputeDevice;
var sameDevTypes = ComputeDeviceManager.Avaliable.GetSameDevicesTypeAsDeviceWithUUID(CDevice.UUID);
if (sameDevTypes.Count > 0)
{
var copyBenchItem = new ToolStripMenuItem();
//copyBenchItem.DropDownItems
foreach (var cDev in sameDevTypes)
{
if (cDev.Enabled)
{
var copyBenchDropDownItem = new ToolStripMenuItem();
copyBenchDropDownItem.Text = cDev.Name;
copyBenchDropDownItem.Checked = cDev.UUID == CDevice.BenchmarkCopyUUID;
copyBenchDropDownItem.Click += toolStripMenuItemCopySettings_Click;
copyBenchDropDownItem.Tag = cDev.UUID;
copyBenchItem.DropDownItems.Add(copyBenchDropDownItem);
}
}
copyBenchItem.Text = International.GetText("DeviceListView_ContextMenu_CopySettings");
contextMenuStrip1.Items.Add(copyBenchItem);
}
}
contextMenuStrip1.Show(Cursor.Position);
}
}
}
public static string GetLocalUacPath(Artifact.Artifact artifact, string ext)
{
return(Path.Combine(SettingsUtil.GetLocalRepositoryPath(), string.Format(@"{0}\{1}\{1}{2}-{3}", Tokenize(artifact.GroupId), artifact.ArtifactId, artifact.Version, ext)));
}
public override void LoadSettings(Dictionary <string, string> Settings)
{
this.QueryTextBox.Text =
Convert.ToString(
SettingsUtil.GetDictionarySetting(Settings, ReportsConstants.SETTING_Query, Null.NullString));
}
public SaturnSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public void UpdateMusicVolume()
{
musicSource.volume = SettingsUtil.GetMusicVolume() / 100;
}
private static byte[] _key = "cbe1fe22283c8d5a7d54dc38a19255ed2b275fb91b33d694604a9b00cb10112e".FromHex(); // exactly 32 bytes protected override string DecryptPassword(string encrypted) => SettingsUtil.DecryptPassword(encrypted, _key);
protected override string CreateConnectionString()
{
var connStr = base.CreateConnectionString();
if (!string.IsNullOrEmpty(connStr))
{
return(connStr);
}
// No connection string setting, we need to build it
// First validate the fields
var server = Convert.ToString(
SettingsUtil.GetDictionarySetting(this.CurrentReport.DataSourceSettings,
ReportsConstants.SETTING_Server,
string.Empty));
var database = Convert.ToString(
SettingsUtil.GetDictionarySetting(this.CurrentReport.DataSourceSettings,
ReportsConstants.SETTING_Database,
string.Empty));
var useIntegratedSecurity = Convert.ToBoolean(
SettingsUtil.GetDictionarySetting(this.CurrentReport.DataSourceSettings,
ReportsConstants.SETTING_Sql_UseIntegratedSecurity,
false));
var userName = Convert.ToString(
SettingsUtil.GetDictionarySetting(this.CurrentReport.DataSourceSettings,
ReportsConstants.SETTING_UserName,
string.Empty));
var password = Convert.ToString(
SettingsUtil.GetDictionarySetting(this.CurrentReport.DataSourceSettings,
ReportsConstants.SETTING_Password,
string.Empty));
var csBuilder = new SqlConnectionStringBuilder();
if (!string.IsNullOrEmpty(server))
{
csBuilder.Add("Server", server);
}
if (!string.IsNullOrEmpty(database))
{
csBuilder.Add("Database", database);
}
if (!useIntegratedSecurity)
{
if (!string.IsNullOrEmpty(userName))
{
csBuilder.Add("User ID", userName);
}
if (!string.IsNullOrEmpty(password))
{
csBuilder.Add("Password", password);
}
csBuilder.Add("Trusted_Connection", "False");
}
else
{
csBuilder.Add("Trusted_Connection", "True");
}
return(csBuilder.ConnectionString);
}
protected override string EncryptPassword(string decrypted) => SettingsUtil.EncryptPassword(decrypted, _key);
public override void DataBind()
{
// Get the report for this module
if (!this.ValidateDataSource() || !this.ValidateResults())
{
this.litContent.Visible = false;
}
else
{
this.litContent.Visible = true;
// Get the extension objects
IEnumerable <ExtensionObjectInfo> extensionObjects =
ReportsController.GetXsltExtensionObjects(this.TabModuleId);
var argList = new XsltArgumentList();
foreach (var extensionObject in extensionObjects)
{
object obj = this.CreateExtensionObject(extensionObject.ClrType);
if (obj != null)
{
argList.AddExtensionObject(extensionObject.XmlNamespace, obj);
}
}
// Get the Xslt Url
var sXsl = SettingsUtil.GetDictionarySetting(this.Report.VisualizerSettings,
ReportsController.SETTING_Xslt_TransformFile,
string.Empty);
if (string.IsNullOrEmpty(sXsl))
{
return;
}
if (sXsl.ToLower().StartsWith("fileid="))
{
sXsl = Utilities.MapFileIdPath(this.ParentModule.PortalSettings, sXsl);
}
else
{
sXsl = Path.Combine(this.ParentModule.PortalSettings.HomeDirectoryMapPath, sXsl.Replace("/", "\\"));
}
if (string.IsNullOrEmpty(sXsl))
{
return;
}
// Serialize the results to Xml
var sbSource = new StringBuilder();
using (var srcWriter = new StringWriter(sbSource))
{
this.ReportResults.WriteXml(srcWriter);
}
// Load the Transform and transform the Xml
var sbDest = new StringBuilder();
var xform = new XslCompiledTransform();
using (var destWriter = new XmlTextWriter(new StringWriter(sbDest)))
{
xform.Load(sXsl);
xform.Transform(new XPathDocument(new StringReader(sbSource.ToString())), argList, destWriter);
}
var objSec = new PortalSecurity();
this.litContent.Text = objSec.InputFilter(sbDest.ToString(), PortalSecurity.FilterFlag.NoScripting);
}
base.DataBind();
}
public NullEmulatorSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public QuickNESSettings()
{
SettingsUtil.SetDefaultValues(this);
SetDefaultColors();
}
private static int mainCore(string[] args)
{
Mutex mutex = null;
if (_args.MutexName != null && !_args.ShadowCopy)
{
var sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var mutexsecurity = new MutexSecurity();
mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.FullControl, AccessControlType.Allow));
mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.ChangePermissions, AccessControlType.Deny));
mutexsecurity.AddAccessRule(new MutexAccessRule(sid, MutexRights.Delete, AccessControlType.Deny));
bool created;
mutex = new Mutex(false, _args.MutexName, out created, mutexsecurity);
if (!created)
{
throw new TellUserException("The mutex \"{0}\" is already acquired by another application.".Fmt(_args.MutexName), returnCode: ExitCode.MutexInUse, silent: true);
}
}
string destPath = null;
if (_args.ShadowCopy)
{
var source = Assembly.GetExecutingAssembly();
int i = 0;
while (true)
{
i += Rnd.Next(65536);
destPath = Path.Combine(Path.GetTempPath(), "RunLogged-" + i);
if (Directory.Exists(destPath))
{
continue;
}
try
{
Directory.CreateDirectory(destPath);
_shadowLock = File.Open(Path.Combine(destPath, "lock"), FileMode.CreateNew, FileAccess.Write, FileShare.None);
// Now verify that another copy of RunLogged hasn't copied itself over just before we created the directory,
// which is theoretically possible
var entries = Directory.GetFileSystemEntries(destPath);
if (entries.Length != 1 || !entries[0].EndsWith("lock"))
{
continue;
}
break;
}
catch { }
}
var destAssembly = Path.Combine(destPath, Path.GetFileName(source.Location));
var newArgs = args.Where(arg => arg != "--shadowcopy").Select(arg => arg.Any(ch => "&()[]{}^=;!'+,`~ ".Contains(ch)) ? "\"" + arg + "\"" : arg).JoinString(" ");
File.Copy(source.Location, destAssembly);
foreach (var dep in source.GetReferencedAssemblies())
{
var file = new[] { ".dll", ".exe" }.Select(ext => Path.Combine(Path.GetDirectoryName(source.Location), dep.Name + ext)).FirstOrDefault(fn => File.Exists(fn));
if (file == null)
{
continue;
}
File.Copy(file, Path.Combine(destPath, Path.GetFileName(file)));
}
Process.Start(new ProcessStartInfo
{
FileName = destAssembly,
Arguments = "--wipe-after-shutdown \"" + destPath + "\" " + newArgs,
UseShellExecute = true,
// shell execute = true: a new console window will be created
// shell execute = false: will attach to existing console window, but because the original process exits, this
// fools cmd.exe into becoming interactive again while RunLogged is still logging to it. This looks very broken.
// Hence the least evil seems to be to just create a new console window; it's unlikely that someone who wants
// to use RunLogged interactively would specify --shadowcopy anyway.
});
return(0);
}
SettingsUtil.LoadSettings(out _settings);
_settings.SaveQuiet();
_originalCurrentDirectory = Directory.GetCurrentDirectory();
Console.CancelKeyPress += (_, __) => { processCtrlC(); };
WinAPI.SetConsoleCtrlHandler(_ => { processCtrlC(); return(true); }, true);
try
{
try { Directory.CreateDirectory(Path.GetDirectoryName(_args.LogFilename)); }
catch { }
_log = File.Open(_args.LogFilename, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
_log.Seek(0, SeekOrigin.End);
_logStartOffset = _log.Position;
var t = new Thread(threadLogFlusher);
t.IsBackground = true;
t.Start();
}
catch (Exception e)
{
throw new TellUserException("Could not open the log file for writing. File \"{0}\".\n{1}".Fmt(_args.LogFilename, e.Message), returnCode: ExitCode.CannotOpenLogFile);
}
_runner = new CommandRunner();
_runner.SetCommand(_args.CommandToRun);
_runner.WorkingDirectory = Directory.GetCurrentDirectory();
_runner.StdoutText += runner_StdoutText;
_runner.StderrText += runner_StderrText;
_readingThread = new Thread(readingThread);
_readingThread.Start();
if (_args.TrayIcon != null)
{
_tooltipPrefix = Path.GetFileName(_args.CommandToRun[0].Split(' ').FirstOrDefault("RunLogged").SubstringSafe(0, 50));
_trayIcon = new NotifyIcon
{
Icon = new System.Drawing.Icon(_args.TrayIcon),
ContextMenuStrip = new ContextMenuStrip(),
Visible = true,
Text = _tooltipPrefix,
};
_miPause = (ToolStripMenuItem)_trayIcon.ContextMenuStrip.Items.Add("&Pause for...", null, pause);
_trayIcon.ContextMenuStrip.Items.Add("E&xit", null, (_, __) => { _runner.Abort(); });
_trayIcon.ContextMenuStrip.Renderer = new NativeToolStripRenderer();
_trayIcon.ContextMenuStrip.Opening += updateResumeMenu;
_runner.CommandResumed += () => { updateResumeMenu(); };
}
Application.Run();
GC.KeepAlive(mutex);
return(_readingThreadExitCode);
}
public void ToggleMusicMute()
{
SettingsUtil.ToggleMusicMuted(!SettingsUtil.MusicMuted);
}
public A2600SyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public GBLink3xSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public GambatteSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public MSXSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
void PenaltiesAllowed(bool value)
{
SettingsUtil.SetPenaltiesAllowed(value);
}
