//--------------------------------------------------------------------------
//タスク追加
//--------------------------------------------------------------------------
private void AddTask(string path)
{
var editTask = new TaskData();
//かぶらないファイル名を作る
var co = 1;
while (true)
{
var NumberTaskName = "新しいタスク" + co++;
if (gTaskList.Count(t => t.Name == NumberTaskName) == 0)
{
editTask.Name = NumberTaskName;
break;
}
}
var eco = 1;
while (true)
{
var NumberExportFolder = "NewTask" + eco++;
if (gTaskList.Count(t => t.LogFolder == NumberExportFolder) == 0)
{
editTask.LogFolder = NumberExportFolder;
break;
}
}
editTask.ProjectPath = path;
editTask.ProjectPaths.Add(path);
editTask.LogPath = path;
var form = new TaskForm(editTask, gTaskList);
if (form.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
editTask.Checked = true;
gTaskList.Add(editTask);
AddDataGridView(editTask, taskDataBindingSource.Add(editTask));
}
}
public TaskForm(TaskData data, TaskList lists)
{
InitializeComponent();
gTaskData = data;
gTaskList = lists;
foreach (var task in lists)
{
LogPathComboBox.Items.Add(task.LogPath);
ProjectPathComboBox.Items.Add(task.ProjectPath);
}
NameTextBox.Text = data.Name;
LogFolderTextBox.Text = data.LogFolder;
if (data.LogNumber == -1)
{
for (int i = 0; i <= lists.Count; i++)
{
if (lists.Cast<TaskData>().Count(t => t.LogNumber == i) == 0)
{
LogNumericUpDown.Value = i;
break;
}
}
}
else
{
LogNumericUpDown.Value = data.LogNumber;
}
}
public void タスクの取得()
{
var data = new TaskData();
data.ProjectPaths.Add(@"C:\Program Files");
gTaskList.Add(data);
Assert.True(gTaskList[0].ProjectPath == data.ProjectPath);
}
// 初始化任务
private void InitAvatarTaskList(int taskMain)
{
if (taskMain < 1)
{
// to do key
LoggerHelper.Debug("任务ID初始化不合法");
taskMain = 1;
}
if (taskMain == 1)
isFirstTask = true;
if (TaskData.dataMap.ContainsKey(taskMain))
m_playerCurrentTask = TaskData.dataMap[taskMain];
if (MogoUIManager.Instance.m_NormalMainUI != null)
{
if (m_playerCurrentTask == null)
{
NormalMainUIViewManager.Instance.SetAutoTaskText(LanguageData.GetContent(46854)); // 副本
NormalMainUIViewManager.Instance.SetAutoTaskIcon(IconData.dataMap.Get(31309).path);
}
else
{
NormalMainUIViewManager.Instance.SetAutoTaskText(LanguageData.GetContent(46855)); // 自动任务
NormalMainUIViewManager.Instance.SetAutoTaskIcon(IconData.dataMap.Get(31309).path);
ShowTaskTips();
}
}
}
public void タスクに存在するパスで追加()
{
var data = new TaskData();
data.ProjectPath = @"C:\Program Files";
gTaskList.Add(data);
Assert.True(gTaskList.Count == 1);
}
public void タスクに存在しないパスで追加()
{
var data = new TaskData();
data.ProjectPath = @"C:\Program Files2";
gTaskList.Add(data);
Assert.False(gTaskList.Count == 0);
}
public void CreateRecipes()
{
//Init sequencer
seq = new Sequencer();
//Recipe 1
TaskData t1 = new TaskData(1, 15, false);
TaskData t2 = new TaskData(2, 5, true);
TaskData t3 = new TaskData(3, 2, true);
TaskData t4 = new TaskData(4, 13, true);
TaskData t5 = new TaskData(5, 20, false);
TaskData t6 = new TaskData(6, 4, true);
TaskData t7 = new TaskData(7, 3, true);
TaskData t8 = new TaskData(8, 10, false);
TaskData t9 = new TaskData(9, 1, true);
TaskData t10 = new TaskData(10, 3, true);
t10.addPrereq(t9);
t10.addPrereq(t8);
t8.addPrereq(t7);
t7.addPrereq(t6);
t9.addPrereq(t5);
t5.addPrereq(t4);
t4.addPrereq(t3);
t3.addPrereq(t2);
t2.addPrereq(t1);
r1 = new RecipeData();
r1.finalStep = t10;
//Recipe 2
TaskData t11 = new TaskData(11, 10, false);
TaskData t12 = new TaskData(12, 6, true);
TaskData t13 = new TaskData(13, 4, true);
TaskData t14 = new TaskData(14, 15, true);
t14.addPrereq(t13);
t13.addPrereq(t12);
t12.addPrereq(t11);
r2 = new RecipeData();
r2.finalStep = t14;
//Recipe 3
TaskData t15 = new TaskData(15, 9, false);
TaskData t16 = new TaskData(16, 3, true);
TaskData t17 = new TaskData(17, 5, true);
TaskData t18 = new TaskData(18, 4, true);
TaskData t19 = new TaskData(19, 1, true);
TaskData t20 = new TaskData(20, 15, false);
t20.addPrereq(t19);
t19.addPrereq(t18);
t19.addPrereq(t17);
t19.addPrereq(t16);
t19.addPrereq(t15);
r3 = new RecipeData();
r3.finalStep = t20;
}
public void コマンドの追加()
{
var task = new TaskData();
var command = new CommandData();
task.ProjectPaths.Add(@"C:\Program Files");
gTaskList.Add(task);
task.CommandDataList.Add(command);
Assert.True(task.CommandDataList.Count == 1);
}
public void タスクセーブ()
{
var task = new TaskData();
var command = new CommandData();
task.ProjectPaths.Add(@"C:\Program Files");
gTaskList.Add(task);
task.CommandDataList.Add(command);
Assert.True(gTaskList.Save(@"C:\My Program\FullAutomationSupportSystem\FullAutomationSupportSystemTest\fas.fas") == true);
}
public void StartJobAsync(Task task, TaskData taskData) {
try {
this.TaskId = task.Id;
originalTaskData = taskData;
Prepare(task);
StartTaskInAppDomain(taskData);
}
catch (Exception) {
// make sure to clean up if something went wrong
DisposeAppDomain();
throw;
}
}
public void AddTask(Task task, long activeStates)
{
TaskData td = new TaskData();
td.Task = task;
task.TaskManager = this;
td.ActiveStates = activeStates;
m_tasks.Add(td);
#if UNITY_EDITOR
m_taskSamplers.Add(CustomSampler.Create(task.GetType().Name));
#endif
m_taskCount = m_tasks.Count;
}
public void RunTask()
{
var taskRunner = GetComponent <TaskRunner>();
var task = new TaskData <Vector2Int, float[, ]>
{
Title = $"Generate {size.x}x{size.y} Height Map",
Action = MyTask,
Arg1 = size,
Callback = OnTaskComplete,
Join = true
};
taskRunner.RunTask(task);
}
public Folders(TaskData taskData)
{
Contract.Requires(null != taskData, "taskList");
m_taskData = taskData;
m_setCurrentCommand = new DelegateCommand <BaseFolder>(
val => m_taskData.CurrentFolder = val,
val => m_taskData.CurrentFolder != val);
m_setCurrentColorCommand = new DelegateCommand <Color?>(
var => m_taskData.CurrentFolder.Color = var.Value,
var => IsCurrentUserFolder
);
}
public void Create_a_task_in_db()
{
// Arrange
TaskData appRepository = new TaskData();
// Act
var result = appRepository.CreateTask(new Task()
{
Task1 = "TestTask2", Priority = 1, Start_Date = DateTime.Now.Date, End_Date = DateTime.Now.Date.AddDays(1)
});
// Assert
Assert.NotZero(result);
}
public string DeleteSingle(string key)
{
MyDemoProjectContext context = new MyDemoProjectContext();
TaskData task = context.TaskData.Find(key);
if (task != null)
{
context.TaskData.Remove(task);
context.SaveChanges();
return("Task has been deleted");
}
return("Task was not found and not deleted");
}
public override string replace(string mark, object obj)
{
TaskData data = (TaskData)obj;
switch (mark)
{
case ReplaceTextMarkType.NeedNum:
{
return(data.config.needNum.ToString());
}
}
return(mark);
}
async private void CreateNewDayButton_Clicked(object sender, EventArgs e)
{
string day;
string teamId;
string teamMembers;
string equipmentId;
string equipmentType;
bool validForm = false;
while (true)
{
if (EntryCellFieldDayTeam.Text == null || EntryCellTeamMembers.Text == null || EntryCellEquipmentType.Text == null || EntryCellEquipmentType.Text == null)
{
DisplayAlert("Incomplete form", "Please enter values in all cells", "Ok");
break;
}
if (!Regex.IsMatch(EntryCellFieldDayTeam.Text, "[Gg][0-9][0-9]"))
{
DisplayAlert("Invalid Team Id", "Team ID must be G##. Ex/ G03", "Ok");
break;
}
if (!Regex.IsMatch(EntryCellFieldDayEquipment.Text, "[AaEe][0-9][0-9]"))
{
DisplayAlert("Invalid Equipment ID", "Equipment ID must be A## (for array) or E## (for Person portable)", "Ok");
break;
}
validForm = true;
break;
}
if (validForm)
{
var dateId = DatePicker.Date.ToString("yyyyMMdd");
string fieldDayId = dateId + EntryCellFieldDayTeam.Text + EntryCellFieldDayEquipment.Text;
day = DatePicker.Date.ToString("MM/dd/yyyy");
teamId = EntryCellFieldDayTeam.Text.ToUpper();
teamMembers = EntryCellTeamMembers.Text;
equipmentId = EntryCellFieldDayEquipment.Text.ToUpper();
equipmentType = EntryCellEquipmentType.Text;
var taskData = new TaskData();
taskData.createNewDay(fieldDayId, day, teamId, teamMembers, equipmentId, equipmentType);
await Navigation.PopAsync();
}
}
//Sobreescribir el fichero JSON con la nueva informacion (tareas nuevas o editadas)
private void SaveTaskData()
{
string filePath = Path.Combine(Application.persistentDataPath, taskDataFileName);
//Crear objeto TaskData y guardar en el la lista de tareas actuales
TaskData taskDataAux = new TaskData {
tasks = tasks
};
//Convertir objeto TaskData (y, con el, la lista de tareas) a JSON
string dataAsJson = JsonUtility.ToJson(taskDataAux);
//Sobreescribir el archivo json con el nuevo texto (si no existe el fichero, lo crea)
File.WriteAllText(filePath, dataAsJson);
}
//删除任务
public void DeleteTask(ref List <TaskData> TaskList, int TaskID)
{
TaskData temp = null;
foreach (TaskData data in TaskList)
{
if (data.ID == TaskID)
{
temp = data;
break;
}
}
TaskList.Remove(temp);
}
private void FormTasksList_FormClosing(object sender, FormClosingEventArgs e)
{
if (_taskData != null)
{
_taskData.DebugData.Runner.OutputDataReceived -= TaskData_OutputDataReceived;
_taskData.DebugData.Runner.ErrorDataReceived -= TaskData_OutputDataReceived;
_taskData.DebugData.Runner.Exited -= TaskData_Exited;
_taskData.DebugData.Runner.StatusChanged -= Runner_StatusChanged;
_taskData.DebugData.Runner.TaskNotification -= Runner_TaskNotification;
_taskData.DebugData.Runner.ManagementDataReceived -= Runner_ManagementDataReceived;
_taskData = null;
}
Controller.Instance.SaveData("");
}
public void StartJobAsync(Task task, TaskData taskData)
{
try {
this.TaskId = task.Id;
originalTaskData = taskData;
Prepare(task);
StartTaskInAppDomain(taskData);
}
catch (Exception) {
// make sure to clean up if something went wrong
DisposeAppDomain();
throw;
}
}
private void MnuTasksRun_Click(object sender, EventArgs e)
{
string id = (string)(lstTasks.SelectedItems[0].Tag);
TaskData taskData = FindClickedTask(id);
if (taskData.DebugData.Runner.IsRunning())
{
MessageBox.Show("Selected task is already running!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
RunTaskNow(taskData);
}
}
public void RunTask()
{
var taskRunner = GetComponent <TaskRunner>();
var task = new TaskData <int, string>
{
Title = $"Count to {countTo}",
Action = MyTask,
Arg1 = countTo,
Callback = OnTaskComplete,
Join = true
};
taskRunner.RunTask(task);
}
protected override ContentProcessResult Process(TaskData td)
{
Task task = td.Task;
byte[] bytes = td.Bytes;
AmazonTaskType att = (AmazonTaskType)task.Type;
ContentProcessResult result = new ContentProcessResult();
//set to true, but could fail
result.Success = true;
if (att == AmazonTaskType.IMAGE
//|| att == AmazonTaskType.IMAGE_ORI
)
{
//DoImage();
}
else
{
string html = GetString(bytes, null);
if (!Validate(html))
{
result.Success = false;
return(result);
}
switch (att)
{
case AmazonTaskType.INDEX:
DoIndex(task, html, result);
break;
case AmazonTaskType.CATEGORY:
// DoCategory(task, html, result);
break;
case AmazonTaskType.MORE_CATEGORY:
DoMoreCategory(task, html, result);
break;
case AmazonTaskType.PAGES:
DoPages(task, html, result, null);
break;
case AmazonTaskType.PAGE:
DoPage(task, html, result);
break;
}
}
return(result);
}
public static async Task <int> PostTask(TaskData task)
{
var client = new HttpClient();
var values = new List <KeyValuePair <string, string> >();
if (task.ServerId < 0)
{
values.Add(new KeyValuePair <string, string>("Id", task.ServerId.ToString()));
}
values.Add(new KeyValuePair <string, string>("TaskName", task.TaskName));
values.Add(new KeyValuePair <string, string>("Description", task.Description));
values.Add(new KeyValuePair <string, string>("Priority", task.Priority));
values.Add(new KeyValuePair <string, string>("User", task.User));
values.Add(new KeyValuePair <string, string>("Status", task.Status));
values.Add(new KeyValuePair <string, string>("DueDate", task.DueDate.ToString()));
values.Add(new KeyValuePair <string, string>("LastModifiedDate", DateTime.UtcNow.ToString()));
if (SettingServices.AccessToken == null)
{
return(0);
}
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", SettingServices.AccessToken);
HttpResponseMessage response = new HttpResponseMessage();
try
{
response = await client.PostAsync(
"https://sit313apiserver.azurewebsites.net/api/TaskModels/", new FormUrlEncodedContent(values));
if (response.StatusCode == System.Net.HttpStatusCode.Created)
{
var content = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <TaskData>(content).Id);
}
return(0);
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", "Error attempting to insert the task from the server - " + ex.Message, "OK", "Cancel");
return(0);
}
}
private void MnuTasksStop_Click(object sender, EventArgs e)
{
string id = (string)(lstTasks.SelectedItems[0].Tag);
TaskData taskData = FindClickedTask(id);
if (taskData.DebugData.Runner.IsRunning())
{
KillTaskNow(taskData);
Controller.Instance.SaveData("");
}
else
{
MessageBox.Show("Selected task is not currently running! ", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public TaskData getTaskDataById(int task_id)
{
TaskData taskData = null;
for (int i = 0; i < m_taskDataList.Count; i++)
{
if (m_taskDataList[i].task_id == task_id)
{
taskData = m_taskDataList[i];
break;
}
}
return(taskData);
}
public async Task PostAPIData()
{
HunterAPI hunterAPI = new HunterAPI();
var data = await hunterAPI.GetDeviceTasks();
var task = data.Entity[0];
TaskData tasksData = new TaskData();
tasksData.TasksId = task.Id;
tasksData.Data = "{\"name\":\"OnePlus 39\"}";
await hunterAPI.PostTasksData(tasksData);
Assert.IsNotNull(data);
}
public void CreateTaskData()
{
if (connection.Table <TaskData>().Count() == 0)
{
TaskData newTask1 = new TaskData("Finish Work", "I need to finish my work", "High", "*****@*****.**", "To Do", Convert.ToDateTime("20/SEP/18"), DateTime.Now);
TaskData newTask2 = new TaskData("Submit Report", "The report on Visual Studio", "Medium", "*****@*****.**", "In Progress", Convert.ToDateTime("21/OCT/18"), DateTime.Now);
TaskData newTask3 = new TaskData("File papers", "Have to file all those papers", "Low", "*****@*****.**", "Completed", Convert.ToDateTime("15/AUG/18"), DateTime.Now);
TaskData newTask4 = new TaskData("Develop application", "The Task management application needs In Progress", "High", "*****@*****.**", "In Progress", Convert.ToDateTime("26/SEP/18"), DateTime.Now);
connection.Insert(newTask1);
connection.Insert(newTask2);
connection.Insert(newTask3);
connection.Insert(newTask4);
}
}
public int StartTask(Task<QueryResult> task, ExecuterStatistics stats, CancellationTokenSource canceller)
{
Contract.Requires(task != null && stats != null && canceller != null);
var data = new TaskData(tasks.Count, TaskKind.Query, task, stats, canceller);
tasks.Add(data.Id, data);
if (IsWaitOn)
{
task.RunSynchronously();
}
else
{
task.Start();
}
return data.Id;
}
//constructor to take the navigation and the selected task
public TaskDetailViewModel(INavigation navigation, int selectedTask)
{
//set the variables from the inherited class
nav = navigation;
task = new TaskData();
task.Id = selectedTask;
taskRepo = new TaskDataRepository();
//set the commands
UpdateTaskComm = new Command(async() => await UpdateTask());
DeleteTaskComm = new Command(async() => await DeleteTask());
//call the fetch task method
FetchTask();
}
/// <summary>
/// 复制(深拷贝)
/// </summary>
protected override void toCopy(BaseData data)
{
if (!(data is TaskData))
{
return;
}
TaskData mData = (TaskData)data;
this.instanceID = mData.instanceID;
this.id = mData.id;
this.num = mData.num;
}
public async Task <IActionResult> OnGetAsync(string id)
{
if (id == null)
{
return(NotFound());
}
TaskData = await _context.Tasks.FirstOrDefaultAsync(m => m.Id == id);
if (TaskData == null)
{
return(NotFound());
}
return(Page());
}
public bool ExistTaskData(string sDescription, int iTarea, int iGrupo)
{
var chocorroles = new TaskData();
var swap = chocorroles.getAll();
var qbo = (from s in swap where s.sDescription.Equals(sDescription) && s.iIdTask.Equals(iTarea) && s.iIdData.Equals(iGrupo) select s).Count();
if (qbo < 1)
{
return(false);
}
else
{
return(true);
}
}
private void setTitle(Widget widget)
{
if (widget is PictureBoxWidget)
{
PictureBoxWidget pictureBoxWidget = widget as PictureBoxWidget;
TaskData taskData = pictureBoxWidget.UserData as TaskData;
Log.Debug("Setting title to " + taskData.Title.ToString());
Windows.SetText(Title, taskData.Title.ToString());
}
else
{
Windows.SetText(Title, widget.GetText());
}
}
public TaskData Get(uint id)
{
if (taskDataTable == null)
{
return(null);
}
TaskData taskData = taskDataTable.Get(id);
if (taskData == null)
{
Log.TableError(this, id);
return(null);
}
return(taskData);
}
public void DeleteTasks()
{
IEnumerable <int> list = this.Tasks.Where(d => d.IsSelected)
.Select(d => (int)d.ID);
var sql = new TaskData();
foreach (int id in list)
{
sql.DeleteTask(id);
}
SetTaskList();
this.ListRequestRefresh();
// MessageBox.Show(msg);
}
public TaskData GetTaskData(IRestResponse response)
{
EncodeTaskData encodeTaskData = _deserializer.EncodeTaskDataDeserealize(response);
string resource = GetHeaderValue(response, HeaderParameters.Location);
string contentType = GetHeaderValue(response, HeaderParameters.ContentType);
TypeOfTask type = GetTypeOfTask(contentType);
var taskData = new TaskData
{
Id = encodeTaskData.TaskId,
Resource = resource,
Type = type
};
return(taskData);
}
public ComputerInTaskHandler(ExecutedTaskData _executedTaskData, List <ClientHandler> _clients, int _index, List <string> _ipAddresses, Semaphore _semaphoreFotSaveFile, ListView _listViewAll, ListView _listViewSelected)
{
step = "WAITING FO ACK";
semaphoreForTask.WaitOne();
this.executedTaskData = _executedTaskData;
this.clients = _clients;
this.index = _index;
this.ipAddresses = _ipAddresses;
this.taskData = executedTaskData.taskData;
this.semaphoreForSaveFile = _semaphoreFotSaveFile;
this.listViewAll = _listViewAll;
this.listViewSelected = _listViewSelected;
receivePacket = new Packet(DataIdentifier.CLOSE);
computer = executedTaskData.taskData.TargetComputers[index];
}
public static void FillStatus(StatusData statusData)
{
statusData.Tasks.Clear();
List <TaskModel> tasks = Find(new string[] { "StatusID = " + statusData.ID })
.OrderBy(task => task.SortOrder)
.ThenBy(task => task.ID)
.ToList();
foreach (TaskModel taskModel in tasks)
{
TaskData taskData = taskModel.ToData(statusData);
statusData.Tasks.Add(taskData);
}
}
//--------------------------------------------------------------------------
//dataGridView追加
//--------------------------------------------------------------------------
private void AddDataGridView(TaskData task, int count)
{
task.SetLastRun();
var folders = new List<string>();
if (task.ProjectPaths != null && task.ProjectPaths.Count != 0)
{
folders.AddRange(task.ProjectPaths);
var combobind = dataGridView1["ProjectPaths", count] as DataGridViewComboBoxCell;
combobind.DataSource = new BindingSource(folders, string.Empty);
dataGridView1["ProjectPaths", count].Value = task.ProjectPaths[0];
}
dataGridView1["ProjectPath", count].Value = GetShortPathName(task.ProjectPath);
dataGridView1["LogPath", count].Value = GetShortPathName(task.LogPath);
dataGridView1["Log", count].Value = "ログ";
dataGridView1["Run", count].Value = "実行";
}
public MainWindow()
{
Tasks t = new Tasks();
TaskData td;
MyTaskList = new TaskDataList();
InitializeComponent();
foreach (string s in t.RetrieveDistinctTaskCategories())
{
td = new TaskData();
td.Category = s;
MyTaskList.Add(td);
}
this.DataContext = this;
}
/// <summary>
/// Istanzia un nuovo oggetto della classe TaskExecution con i parametri specificati.
/// </summary>
/// <param name="serviceUri">indirizzo del servizio di elaborazione del task</param>
/// <param name="pollingInterval">tempo di attesa nella verifica di completamento del task</param>
/// <exception cref="UriFormatException">
/// Se si specifica un URI non valido come indirizzo del servizio di elaborazione.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Se si specifica il valore null come indirizzo del servizio di elaborazione.
/// </exception>
public TaskExecution(string serviceUri, TimeSpan pollingInterval)
{
m_PollingInterval = pollingInterval;
m_PollingWaitHandle = new ManualResetEvent(false);
m_Binding = new BasicHttpBinding();
m_Endpoint = new EndpointAddress(serviceUri);
m_Proxy = null;
m_CommunicationErrorsMapping = new Dictionary<Type, TaskExecutionState>()
{
{ typeof(TimeoutException), TaskExecutionState.TimeoutError },
{ typeof(EndpointNotFoundException), TaskExecutionState.ServiceNotFoundError },
{ typeof(CommunicationException), TaskExecutionState.CommunicationError }
};
m_TaskRequestId = string.Empty;
m_TaskData = new TaskData() { Name = string.Empty, Contents = string.Empty };
m_TaskResults = null;
}
public TaskItemTree(TaskData source, ICollection<IItemTree> collection)
{
Entity = source.Entity;
Container = source.Container;
Type = source.Type;
ParentType = source.Entity.ParentType;
Creator = source.Creator;
LastModifier = source.LastModifier;
source.TotalEffort = ((Task)Entity).Effort;
source.TotalEffortEstimation = ((Task)Entity).EffortEstimation;
Children = collection;
foreach(var child in Children)
{
source.TotalEffort += ((Task)(child.Entity)).Effort;
source.TotalEffortEstimation += ((Task)(child.Entity)).EffortEstimation;
}
TotalEffort = source.TotalEffort;
TotalEffortEstimation = source.TotalEffortEstimation;
}
private void StartTaskInAppDomain(TaskData taskData) {
executor.Start(taskData.Data);
waitForStartBeforeKillSem.Release();
StartExecutorMonitoringThread();
}
private void PopulateTLP(List<EnumWindows.WindowInfo> windowList)
{
Log.Debug("Starting to populate table layout panel...");
int appCount = windowList.Count;
if (appCount == 0)
{
return;
}
int columnWidth;
_widgetList = new List<PictureBoxWidget>();
// add rows and columns
dtlp.ColumnCount = NumAppsPerRow;
dtlp.RowCount = (int)Math.Ceiling((double)appCount / (double)NumAppsPerRow);
columnWidth = ColumnWidth;
dtlp.ColumnStyles.Clear();
// add each column
for (int y = 0; y < NumAppsPerRow; y++)
{
dtlp.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, columnWidth));
}
// start adding app icons
// used to break out of loop once we have processed all the apps
int i = 0;
dtlp.RowStyles.Clear();
for (int x = 0; x < dtlp.RowCount; x++)
{
dtlp.RowStyles.Add(new RowStyle(SizeType.Absolute, RowHeight));
}
for (int currentRow = 0, index = 0; currentRow < dtlp.RowCount; currentRow++)
{
for (int currentColumn = 0; currentColumn < NumAppsPerRow; currentColumn++)
{
PictureBox pbxAppIcon1 = new PictureBox();
pbxAppIcon1.Name = "ListItem" + index++;
pbxAppIcon1.SizeMode = PictureBoxSizeMode.CenterImage;
PictureBoxWidget pictureBoxWidget = _dialogCommon.GetWidgetManager().Layout.CreateWidget(typeof(PictureBoxWidget), pbxAppIcon1) as PictureBoxWidget;
pictureBoxWidget.EvtActuated += new WidgetEventDelegate(bitmapWidget_EvtActuated);
pictureBoxWidget.EvtHighlightOn += new HighlightOnDelegate(bitmapWidget_EvtHighlightOn);
Log.Debug("Bitmap widget is " + ((pictureBoxWidget == null) ? "null" : "not null"));
TaskData taskData = new TaskData();
taskData.Handle = windowList[i].Handle;
taskData.Title = windowList[i].Title;
pictureBoxWidget.UserData = taskData;
IntPtr handle = windowList[i].Handle;
Icon icon = EnumWindows.GetAppIcon(handle);
if (icon == null)
{
Log.Debug("No app icon found for hWnd=" + handle.ToString() + " title=" + windowList[i].Title);
Log.Debug("Loading default icon");
Image img = Image.FromFile(FileUtils.GetImagePath("taskSwitchdefaultIcon.bmp"));
if (img != null)
{
pbxAppIcon1.Image = img;
}
}
else
{
Log.Debug("Icon found for hWnd=" + handle.ToString() + " icon=" + icon.ToString() + " title=" + windowList[i].Title);
pbxAppIcon1.Image = icon.ToBitmap();
}
pbxAppIcon1.BorderStyle = BorderStyle.None;
pbxAppIcon1.Anchor = AnchorStyles.None;
pbxAppIcon1.Dock = DockStyle.Fill;
pbxAppIcon1.SizeMode = PictureBoxSizeMode.StretchImage;
dtlp.Controls.Add(pbxAppIcon1, currentColumn, currentRow);
_widgetList.Add(pictureBoxWidget);
// TODO: do something else with spare cells
if (i < (appCount - 1))
{
i++;
}
else
{
break;
}
}
}
#if FORCE_FIXED_TABLE_SIZE
this.Size = new System.Drawing.Size(1000, 1000);
#else
int newFormWidth = FormWidthBase + (NumAppsPerRow * ColumnWidth);
int newFormHeight = 20 + (FormHeightBase + Convert.ToInt32(Math.Ceiling(dtlp.RowCount * RowHeight)));
Log.Debug("newFormWidth=" + newFormWidth + " newFormHeight=" + newFormHeight);
_dialogCommon.Resize(new System.Drawing.Size(newFormWidth, newFormHeight));
onResize();
Log.Debug("form width=" + this.Size.Width.ToString() + " form height=" + this.Size.Height.ToString());
Log.Debug("title width=" + Title.Size.Width);
#endif
}
private void OnTaskFailed(SlaveTask slaveTask, TaskData taskData, Exception exception) {
var handler = TaskFailed;
if (handler != null) handler(this, new EventArgs<Tuple<SlaveTask, TaskData, Exception>>(new Tuple<SlaveTask, TaskData, Exception>(slaveTask, taskData, exception)));
}
public Tuple<TaskData, DateTime> GetTaskDataSnapshot() {
if (taskDataInvalid) return null;
Tuple<TaskData, DateTime> snapshot = null;
if (task == null) {
if (CurrentException == null) {
CurrentException = new Exception("Task with id " + this.TaskId + " is null, sending empty task");
}
} else {
var taskData = new TaskData();
var pausedTrigger = new EventWaitHandle(false, EventResetMode.ManualReset);
EventHandler pausedHandler = null;
pausedHandler = (s, e) => {
task.TaskPaused -= pausedHandler;
task.TaskPaused += Task_TaskPaused;
pausedTrigger.Set();
};
task.TaskPaused -= Task_TaskPaused;
task.TaskPaused += pausedHandler;
task.Pause();
pausedTrigger.WaitOne();
taskData.Data = PersistenceUtil.Serialize(task);
var timestamp = DateTime.Now;
EventHandler startedHandler = null;
startedHandler = (s, e) => {
task.TaskStarted -= startedHandler;
task.TaskStarted += Task_TaskStarted;
};
task.TaskStarted -= Task_TaskStarted;
task.TaskStarted += startedHandler;
task.Start();
taskData.TaskId = TaskId;
snapshot = Tuple.Create(taskData, timestamp);
}
return snapshot;
}
public void TestSortFirstSteps()
{
TaskData t1 = new TaskData(1, 10, false);
TaskData t2 = new TaskData(2, 8, true);
TaskData t3 = new TaskData(3, 2, false);
TaskData t4 = new TaskData(4, 5, true);
RecipeData rec1 = new RecipeData();
rec1.finalStep = t1;
RecipeData rec2 = new RecipeData();
rec2.finalStep = t2;
RecipeData rec3 = new RecipeData();
rec3.finalStep = t3;
RecipeData rec4 = new RecipeData();
rec4.finalStep = t4;
List<RecipeData> recs = new List<RecipeData>();
recs.Add(rec1);
recs.Add(rec2);
recs.Add(rec3);
recs.Add(rec4);
Assert.AreEqual("4,2,3,1", createTestIdString(seq.sortFinalSteps(recs)));
}
public void StartTaskAsync(Task task, TaskData taskData) {
SlaveTask slaveTask = null;
slaveTasksLocker.EnterUpgradeableReadLock();
try {
if (slaveTasks.ContainsKey(task.Id)) {
SlaveStatusInfo.IncrementTasksFailed();
throw new TaskAlreadyRunningException(task.Id);
} else {
slaveTask = new SlaveTask(pluginManager, task.CoresNeeded, log);
AddSlaveTask(task, slaveTask);
SlaveStatusInfo.IncrementTasksFetched();
}
}
finally { slaveTasksLocker.ExitUpgradeableReadLock(); }
if (slaveTask != null) {
try {
slaveTask.StartJobAsync(task, taskData);
}
catch (Exception) {
RemoveSlaveTask(task.Id, slaveTask); // clean up and rethrow
slaveTask.DisposeAppDomain();
throw;
}
}
}
internal static void SaveBufferDuration(int taskId, dynamic durationInMinutes)
{
if (GetRepository().TaskDatas.Keys.Contains(taskId))
{
var taskData = GetRepository().TaskDatas.FirstOrDefault(o => o.Key == taskId).Value;
taskData.AuxDurationInMinutes = durationInMinutes;
}
else
{
var taskData = new TaskData {
TaskId = taskId,
AuxDurationInMinutes = durationInMinutes,
};
repository.TaskDatas.Add(taskId, taskData);
}
Save();
}
public Task()
{
data = new TaskData();
ready = false;
}
public TaskData GetTaskData() {
if (taskDataInvalid) return null;
if (task != null && task.ExecutionState == ExecutionState.Started) {
throw new InvalidStateException("Task is still running");
}
TaskData taskData = null;
if (task == null) {
if (CurrentException == null) {
CurrentException = new Exception("Task with id " + this.TaskId + " is null, sending empty task");
}
} else {
taskData = new TaskData();
taskData.Data = PersistenceUtil.Serialize(task);
taskData.TaskId = TaskId;
}
return taskData;
}
public Task(TaskData data)
{
this.data = data;
ready = false;
}
private void OnTaskPaused(SlaveTask slaveTask, TaskData taskData) {
var handler = TaskPaused;
if (handler != null) handler(this, new EventArgs<SlaveTask, TaskData>(slaveTask, taskData));
}
private void bitmapWidget_EvtActuated(object sender, WidgetEventArgs e)
{
Widget widget = e.SourceWidget;
Log.Debug("widget=" + widget.ToString());
if (widget is PictureBoxWidget)
{
PictureBoxWidget pictureBoxWidget = widget as PictureBoxWidget;
TaskData taskData = pictureBoxWidget.UserData as TaskData;
Log.Debug("Bringing selected window to foreground hWnd=" + taskData.Handle + " title=" + taskData.Title.ToString());
setTitle(widget);
_selectedTask = null;
Windows.ActivateWindow(taskData.Handle);
_selectedTask = taskData;
}
else
{
Log.Debug("actuated non-BitmapWidget");
}
}
public bool Load(string fileName)
{
if (File.Exists(fileName) == false) return false;
bool bSuccess = false;
XmlReaderSettings settings = new XmlReaderSettings();
using (var reader = XmlReader.Create(fileName, settings))
{
TaskData task = new TaskData();
CommandData command = new CommandData();
bool bTaskData = false;
bool bCommandData = false;
bool bOptionData = false;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == "TaskData")
{
bTaskData = true;
}
if (reader.Name == "CommandData")
{
bCommandData = true;
}
if (reader.Name == "OptionData")
{
bOptionData = true;
}
if (bCommandData)
{
command.XmlReader(reader);
}
else if (bTaskData)
{
task.XmlReader(reader);
}
else if (bOptionData)
{
//一旦仮バッファにいれるべきか？
OptionData.GetInstance().XmlReader(reader);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == "TaskData")
{
this.SaveData.TaskList.Add((TaskData)task.Clone());
//初期化。コンストラクタと同一化するのがベター
task.CommandDataList.Clear();
bTaskData = false;
}
if (reader.Name == "CommandData")
{
task.CommandDataList.Add((CommandData)command.Clone());
bCommandData = false;
}
}
}
}
bSuccess = true;
return bSuccess;
}
public void UpdateTaskData(TaskData taskData) {
Db.SubmitChanges();
}
// 两个任务间的连接，这里处理上一个任务的奖励，接受下一个任务，弹出提示
// 对于副本通关类型的来说，这里之前会被截停，直到回到王城才执行
public void TaskInterimPeriod()
{
Mogo.Util.LoggerHelper.Debug("GoToNextTask " + m_playerCurrentTask.id);
if (!TaskData.dataMap.ContainsKey(m_playerCurrentTask.nextId))
{
LoggerHelper.Debug("All Task Complete!");
m_playerCurrentTask = null;
if (MogoUIManager.Instance.m_NormalMainUI != null)
{
NormalMainUIViewManager.Instance.SetAutoTaskText(LanguageData.GetContent(46854)); // 副本
NormalMainUIViewManager.Instance.SetAutoTaskIcon(IconData.dataMap.Get(31309).path);
}
return;
}
//MogoGlobleUIManager.Instance.ShowFinishedTaskSign(true);
MogoFXManager.Instance.AttachTaskOverFX();
// EventDispatcher.TriggerEvent(Events.OperationEvent.CheckFirstShow);
GuideSystem.Instance.TriggerEvent<int>(GlobalEvents.FinishTask, m_playerCurrentTask.id);
m_playerCurrentTask = TaskData.dataMap[m_playerCurrentTask.nextId];
UpdateAutoTaskSign();
GuideSystem.Instance.TriggerEvent<int>(GlobalEvents.GetTask, m_playerCurrentTask.id);
CheckTaskNPCInRange();
ShowTaskTips();
int curTipNPC = 0;
int nextTipNPC = 0;
if (MogoWorld.thePlayer.CurrentTask != null)
{
if (MogoWorld.thePlayer.CurrentTask.isShowNPCTip == 1)
{
nextTipNPC = MogoWorld.thePlayer.CurrentTask.npc;
}
if (MogoWorld.thePlayer.CurrentTask.conditionType == 1 && MogoWorld.thePlayer.CurrentTask.condition != null && MogoWorld.thePlayer.CurrentTask.condition.Count >= 3)
{
curTipNPC = TaskData.dataMap.Get(MogoWorld.thePlayer.CurrentTask.condition[2]).npc;
}
}
EventDispatcher.TriggerEvent(Events.TaskEvent.NPCSetSign, curTipNPC, nextTipNPC);
}
/// <summary>
/// Renders the scene
/// </summary>
/// <returns>The constructed bitmap</returns>
public Bitmap Render()
{
Bitmap output = new Bitmap(config.OutputWidth, config.OutputHeight);
Matrix view = Matrix.LookAt(config.ViewportData.Up, config.ViewportData.Position, config.ViewportData.Target);
// calcualte the camera position using the view matrix
cameraPosition = new Vector3(0, 0, 0);
cameraPosition.Z = (config.OutputHeight / (2.0f * (float)Math.Tan((config.ViewportData.FieldOfView / 2.0f) * (float)Math.PI / 180.0f)));
cameraPosition = view * cameraPosition;
Vector3 right = new Vector3(1, 0, 0);
Vector3 up = new Vector3(0, 1, 0);
// Get the left and top side of the viewport in screen coordinates
Vector3 viewportLeftWorldSpace = (-(config.ViewportData.Width / 2.0f) * right);
Vector3 viewportTopWorldSpace = ((config.ViewportData.Height / 2.0f) * up);
// Get the number of world units per pixel
float horizontalUnitsPerPixel = config.ViewportData.Width / config.OutputWidth;
float verticalUnitsPerPixel = config.ViewportData.Height / config.OutputHeight;
// Keep track of all the tasks we start (one for each ray emitted by camera
Task[] tasks = new Task[config.OutputWidth * config.OutputHeight];
// Keep track of the final color of each pixel. Bitmap doesnt allow concurrent access
Vector4[,] colors = new Vector4[config.OutputWidth, config.OutputHeight];
// Start casting the rays and tracing
for (int h = 0; h < config.OutputHeight; h++)
{
for (int w = 0; w < config.OutputWidth; w++)
{
// Store current loop state to pass to the task
TaskData d = new TaskData();
d.x = w;
d.y = h;
tasks[h * config.OutputWidth + w] = Task.Factory.StartNew((td) =>
{
TaskData data = (TaskData)td;
// Get the position of the ray target in the viewport
Vector3 viewportPos =
right * data.x * horizontalUnitsPerPixel + viewportLeftWorldSpace
- up * data.y * verticalUnitsPerPixel + viewportTopWorldSpace;
// Calculate the viewport position using the view matrix
viewportPos = view * viewportPos;
// Calculate the direction of the ray
Vector3 direction = viewportPos - cameraPosition;
// Create the ray
Ray r = new Ray(cameraPosition, direction);
// Cast the ray into the scene and store the resultant color
colors[data.x, data.y] = CastRay(r);
}, (object)d);
}
}
Task.WaitAll(tasks);
for (int x = 0; x < config.OutputWidth; x++)
{
for (int y = 0; y < config.OutputHeight; y++)
{
ScaleColor(ref colors[x, y]);
colors[x, y] *= 255;
output.SetPixel(x, y,
Color.FromArgb(
(int)colors[x, y].W,
(int)colors[x, y].X,
(int)colors[x, y].Y,
(int)colors[x, y].Z));
}
}
// Do anti-aliasing and other post processing effects here
return output;
}
