public void Clear()
{
UIUpdater.Invoke(() =>
{
Tasks.Clear();
});
}
public bool LoadAdditionalDlls()
{
Action onDllProcessed = () => progressCounter.IncreaseDoneWork(1);
try
{
var operandSelectors = pluginManager.GetDlls(OPERAND_SELECTORS_FOLDER);
var operations = pluginManager.GetDlls(OPERATIONS_FOLDER);
var communicationInterfaces = pluginManager.GetDlls(COMMUNICATION_INTERFACES_FOLDER);
progressCounter.Init(operandSelectors.Count + operations.Count + communicationInterfaces.Count);
pluginManager.OnDllProcessed += onDllProcessed;
pluginManager.RegisterChildren <OperandSelector>(operandSelectors);
pluginManager.RegisterChildren <Operation>(operations, new object[] { networkOperator },
op => pluginManager.LoadRegisteredInstanceToField <Operation, OperandSelector>(op, op.OperandSelectorFieldName, op.OperandSelectorType));
pluginManager.RegisterChildren <ICommunicationInterface>(communicationInterfaces);
return(true);
}
catch (IOException e)
{
UIUpdater.RaiseError(e.Message);
return(false);
}
finally
{
pluginManager.OnDllProcessed -= onDllProcessed;
}
}
public void Clear()
{
UIUpdater.InvokeAsync(() =>
{
Tasks.Clear();
}).SafeFireAndForget();
}
public void Clear()
{
UIUpdater.Invoke(() =>
{
mOutputWindow.Clear();
});
}
public void AfterExecute()
{
UIUpdater.Invoke(() =>
{
Running = false;
});
}
//public GameObject EndCanvas;
//public GameObject UICanvas;
// Start is called before the first frame update
void Awake()
{
UI = GetComponent <UIUpdater>();
UI.setScore(score);
UI.setTimer(timer);
playing = true;
}
public static void Text(string aText, int aFreezeStatusBar)
{
if (!VsServiceProvider.TryGetService(typeof(SVsStatusbar), out object statusBarService) || null == statusBarService as IVsStatusbar)
{
return;
}
var statusBar = statusBarService as IVsStatusbar;
// Make sure the status bar is not frozen
if (VSConstants.S_OK != statusBar.IsFrozen(out int frozen))
{
return;
}
UIUpdater.InvokeAsync(() =>
{
if (0 != frozen)
{
statusBar.FreezeOutput(0);
}
// Set the status bar text
statusBar.SetText(aText);
// Freeze the status bar.
statusBar.FreezeOutput(aFreezeStatusBar);
// Clear the status bar text.
if (0 == aFreezeStatusBar)
{
statusBar.Clear();
}
}).SafeFireAndForget();
}
void Start()
{
gs = GetComponent <GameState>();
uup = GetComponent <UIUpdater>();
bgm = GameObject.Find("BGM").GetComponent <BGM>();
trans = GameObject.Find("Transition").GetComponent <gameOverTransition>();
}
private void DrawCharts()
{
if (_currentSolution != TaskRunner.Config.Solution.GetType().AssemblyQualifiedName)
{
_currentSolution = TaskRunner.Config.Solution.GetType().AssemblyQualifiedName;
MinScoreSeen = TaskRunner.GARun.Population.Chromosomes.Select(o => o.FitnessScore).Min();
MaxScoreSeen = TaskRunner.GARun.Population.Chromosomes.Select(o => o.FitnessScore).Max();
}
var chromosomes = TaskRunner.GARun.Population.Chromosomes;
var min = TaskRunner.GARun.Population.Chromosomes.Select(o => o.FitnessScore).Min();
var max = TaskRunner.GARun.Population.Chromosomes.Select(o => o.FitnessScore).Max();
if (MinScoreSeen > min)
{
MinScoreSeen = min;
}
if (MaxScoreSeen < max)
{
MaxScoreSeen = max;
}
var poolScoreGenerator = new PoolScoreGenerator(TaskRunner.GARun.Population, MinScoreSeen, MaxScoreSeen);
var maxScore = poolScoreGenerator.Points.Max(o => o.Value);
if (maxScore > PoolScoreMaxYSeen)
{
PoolScoreMaxYSeen = (int)maxScore + 1;
}
UIUpdater.SetChart(Form, Controls.PoolScoreChart, poolScoreGenerator.Points, MinScoreSeen, MaxScoreSeen, PoolScoreMaxYSeen);
}
public void Clear()
{
UIUpdater.Invoke(() =>
{
mErrorWindow.Clear();
});
}
public void AddErrors(IEnumerable <TaskErrorModel> aErrors)
{
UIUpdater.Invoke(() =>
{
SuspendRefresh();
foreach (TaskErrorModel error in aErrors)
{
ErrorTask errorTask = new ErrorTask
{
ErrorCategory = error.Category,
Document = error.FilePath,
Text = error.Description,
Line = error.Line - 1,
Column = error.Column,
Category = TaskCategory.BuildCompile,
Priority = TaskPriority.High,
HierarchyItem = error.HierarchyItem
};
errorTask.Navigate += ErrorTaskNavigate;
Tasks.Add(errorTask);
}
BringToFront();
ResumeRefresh();
});
}
public Form1()
{
InitializeComponent();
languageDictionary.Load("english", "alpha");
writingObserver.Initialize(languageDictionary);
Logger.Initialize(lastMessageLabel);
StatusManager.Initialize(statusLabel);
UIUpdater.Initialize(this, predictedWordsTextBox, writingObserver);
MessagesInterpreter.Initialize(connectedComponentsTool, writingObserver);
Logger.LogInfo("app started");
this.FormClosed += Form1_FormClosed;
this.drawPanelPublic = this.drawPanel;
drawPanelPaintEventHandler = new PaintEventHandler(this.drawPanel_Paint);
drawPanelMouseUpEventHandler = new MouseEventHandler(this.drawPanel_MouseUp);
drawPanelMouseMoveEventHandler = new MouseEventHandler(this.drawPanel_MouseMove);
drawPanelMouseDownEventHandler = new MouseEventHandler(this.drawPanel_MouseDown);
ApplicationUseManager appUseManagerInstance = ApplicationUseManager.Instance;
appUseManagerInstance.Initialize(this);
appUseManagerInstance.TriggerApplicationNotReady();
ConnectionManager.StartListeningToConnections();
// !!!!!!!!!!!!!!!!!!!!!!!!! LET THE CLIENT START ALONG WITH THE MAIN APP!!!!!!!!!!!!!!
ApplicationStarter.StartPythonClientFromStartingPoint();
m_connectedComponents = new List <ConnectedComponent>();
this.m_auxiliaryBitmap = new Bitmap(drawPanel.Width, drawPanel.Height, drawPanel.CreateGraphics());
Graphics.FromImage(m_auxiliaryBitmap).Clear(Color.White);
connectedComponentsTool.Initialize(m_auxiliaryBitmap);
}
private void DrawConfigurationDetails()
{
if (TaskRunner.Config == null)
{
return;
}
UIUpdater.SetText(Form, Controls.SessionNameLbl, TaskRunner.Config.Session);
UIUpdater.SetText(Form, Controls.SolutionNameLbl, TaskRunner.Config.Solution.GetType().Name.Replace("Solution", "").ToString());
UIUpdater.SetText(Form, Controls.ConfigPoolSizeLbl, TaskRunner.Config.PopulationSize + "");
UIUpdater.SetText(Form, Controls.ConfigIterationsLbl, TaskRunner.Config.MaxGenerations + "");
UIUpdater.SetText(Form, Controls.ConfigCrossoverRateLbl, TaskRunner.Config.CrossoverRate + "");
UIUpdater.SetText(Form, Controls.ConfigMutationRateLbl, TaskRunner.Config.MutationRate + "");
UIUpdater.SetText(Form, Controls.ConfigElitismRateLbl, TaskRunner.Config.ElitismRate + "");
UIUpdater.SetText(Form, Controls.ConfigImmigrationRateLbl, TaskRunner.Config.ImmigrationRate + "");
UIUpdater.SetText(Form, Controls.ConfigMaxLifeLbl, TaskRunner.Config.MaxRetirement + "");
UIUpdater.SetText(Form, Controls.ConfigChildrenPerCoupleLbl, TaskRunner.Config.ChildrenPerParents + "");
UIUpdater.SetText(Form, Controls.ConfigParentSelectionLbl, TaskRunner.Config.ParentSelectionStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigCrossoverLbl, TaskRunner.Config.CrossoverStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigMutationLbl, TaskRunner.Config.MutationStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigRetirementLbl, TaskRunner.Config.RetirementStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigImmigrationLbl, TaskRunner.Config.ImmigrationStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigScoringLbl, TaskRunner.Config.ScoringStrategy.ToString());
UIUpdater.SetText(Form, Controls.ConfigDuplicationLbl, TaskRunner.Config.DuplicationStrategy.ToString());
}
public void Show()
{
UIUpdater.Invoke(() =>
{
mOutputWindow.Show(mDte);
});
}
private void Awake()
{
if (instance != null)
{
Debug.LogWarning("More than one instance of UIUpdater present");
}
instance = this;
}
public void RemoveErrors(IVsHierarchy aHierarchy)
{
UIUpdater.Invoke(() =>
{
mErrorWindow.SuspendRefresh();
mErrorWindow.RemoveErrors(aHierarchy);
mErrorWindow.ResumeRefresh();
});
}
public MainForm()
{
InitializeComponent();
XMLParser.PopulateGameSettingsFromFile();
SubscribeUIEvents();
InitializeToolTips();
Ticker.TickerStart();
UIUpdater.InitializePowerUpData();
}
public MainForm()
{
GameState = GameState.GenerateNew();
InitializeComponent();
InitializeGame();
MainGameLoop.RunWorkerAsync();
UIUpdater.RunWorkerAsync();
}
public void Clear()
{
mOutputContent = new OutputContentModel();
var outputWindow = mOutputWindowBuilder.GetResult();
UIUpdater.Invoke(() =>
{
outputWindow.Pane.Clear();
});
}
private void clearButton_Click(object sender, EventArgs e)
{
Graphics.FromImage(m_auxiliaryBitmap).Clear(Color.White);
drawPanel.CreateGraphics().DrawImageUnscaled(m_auxiliaryBitmap, new Point(0, 0));
connectedComponentsTool.Initialize(m_auxiliaryBitmap);
m_connectedComponents.RemoveRange(0, m_connectedComponents.Count);
UIUpdater.Clear();
writingObserver.Clear();
}
// Use this for initialization
void Start()
{
cam = Camera.main;
if (cam == null)
{
cam = FindObjectOfType <Camera>();
}
updater = FindObjectOfType <UIUpdater>();
}
public void Clear()
{
mOutputContent = new OutputContentModel();
var outputWindow = mOutputWindowBuilder.GetResult();
UIUpdater.InvokeAsync(() =>
{
outputWindow.Pane.Clear();
}).SafeFireAndForget();
}
private void Awake()
{
if (!instance)
{
instance = this;
}
else if (instance != this)
{
Destroy(this);
}
}
public void AddMessage(string aMessage)
{
UIUpdater.Invoke(() =>
{
if (String.IsNullOrWhiteSpace(aMessage))
{
return;
}
mOutputWindow.Write(aMessage);
});
}
public static void Animation(vsStatusAnimation aAnimation, int aEnableAnimation)
{
UIUpdater.Invoke(() =>
{
// Use the standard Visual Studio icon for building.
object icon = (short)Microsoft.VisualStudio.Shell.Interop.Constants.SBAI_Build;
// Display the icon in the Animation region.
mStatusBar.Animation(aEnableAnimation, ref icon);
});
}
private void UIUpdate()
{
if (ui == null)
{
ui = GameObject.Find("UIUpdater").GetComponent <UIUpdater>();
}
if (ui != null)
{
ui.UpdateUI(health, wealth);
}
}
private void DisplayErrorWindow()
{
try
{
UIUpdater.InvokeAsync(new Action(() =>
{
var window = new EncodingErrorView(ItemsCollector.GetDocumentsToEncode());
window.ShowDialog();
})).SafeFireAndForget();
}
catch (Exception) { }
}
private void UninstallFinished(object sender, EventArgs e)
{
ResetVersionUsedIfRequired();
ResetButtonsState();
UIUpdater.InvokeAsync(new Action(() =>
{
InstalledLlvms.Remove(llvmController.llvmModel.Version);
if (InstalledLlvms.Count > 0 && InstalledLlvms.Contains(VersionUsed) == false)
{
VersionUsed = InstalledLlvms[0];
}
})).SafeFireAndForget();
}
private void Start()
{
Camera cam = Camera.main;
xBounds = cam.aspect * cam.orthographicSize;
yBounds = cam.orthographicSize;
targetRadius = targetPrefab.GetComponent <CircleCollider2D>().radius;
audioPlayer = AudioPlayer.instance;
margin = targetRadius * 2; // must be done here since it uses value initialized in start method
uiUpdater = FindObjectOfType <UIUpdater>();
handSR = longHandPrefab.GetComponent <SpriteRenderer>();
SpawnTarget(); // not optimal but logic is ok
}
public void Write(string aMessage)
{
if (String.IsNullOrWhiteSpace(aMessage))
{
return;
}
var outputWindow = mOutputWindowBuilder.GetResult();
UIUpdater.Invoke(() =>
{
outputWindow.Pane.OutputStringThreadSafe(aMessage + "\n");
});
}
void Start()
{
playerController = GetComponent<PlayerController>();
updater = UI.GetComponent<UIUpdater>();
}
private void pebble_OnDisconnect(object sender, EventArgs e)
{
UIUpdater u = new UIUpdater(DisconnectUIUpdate);
Invoke(u);
}
