private async Task <bool> OnSaveAs()
{
if (ProblemSet == null)
{
return(true);
}
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Judge Sharp Problem Set (*.jsps)|*.jsps";
var r = sfd.ShowDialog();
if (r.HasValue && r.Value)
{
ProblemSet.Path = sfd.FileName;
State = MainWindowStatus.Running;
StateText = "Saving Problem Set";
var result = await ProblemSet.SaveAsync().ConfigureAwait(false);
Dispatcher.BeginInvoke((Action)(() =>
{
if (result)
{
State = MainWindowStatus.Ready;
StateText = "Problem Set Saved";
}
else
{
State = MainWindowStatus.Error;
StateText = "Failed to Save Problem Set";
}
}));
return(result);
}
return(false);
}
public static ProblemSet ExecuteGetProblemSetById(string id) //
{
SqlCommand cmdNew = new SqlCommand("SELECT ProblemSets.[Name], ProblemSets.Points, ProblemSets.UsesFormula, ProblemSets.Formula, ProblemSets.[Values], ProblemSets.RandomRange, ProblemSets.Description FROM ProblemSets WHERE ProblemSets.Id = " + id, _connection);
cmdNew.CommandType = CommandType.Text;
ProblemSet setToReturn = null;
_connection.Open();
try
{
SqlDataReader reader = cmdNew.ExecuteReader();
while (reader.Read())
{
setToReturn = new ProblemSet(reader[0] + "", (int)reader[1], reader[6] + "", reader[3] + "", (int)reader[2], reader[4] + "", reader[5] + "");
}
reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("GG=========================GG");
Console.WriteLine(ex);
}
_connection.Close();
return(setToReturn);
}
public Codeforces()
: base("codeforces")
{
var req = new ProblemsRequest();
ProblemSet = req.GetProblemSetAsync().Result;
}
private async Task <bool> OnSave()
{
if (ProblemSet == null || !ProblemSet.IsDirty)
{
return(true);
}
if (File.Exists(ProblemSet.Path))
{
State = MainWindowStatus.Running;
StateText = "Saving Problem Set";
var result = await ProblemSet.SaveAsync().ConfigureAwait(false);
Dispatcher.BeginInvoke((Action)(() =>
{
if (result)
{
State = MainWindowStatus.Ready;
StateText = "Problem Set Saved";
}
else
{
State = MainWindowStatus.Error;
StateText = "Failed to Save Problem Set";
}
}));
return(result);
}
else
{
return(await OnSaveAs().ConfigureAwait(false));
}
}
public void ProblemSetTest()
{
var problemSet = new ProblemSet();
var problem0 = new Problem()
{
Type = ProblemType.Basic
};
problemSet.Problems.Add(problem0);
problemSet.Problems.Add(new Problem()
{
Type = ProblemType.Basic
});
problemSet.Problems.Add(new Problem()
{
Type = ProblemType.Advanced
});
Assert.AreEqual(problemSet.NumBasicProblems, 2);
Assert.AreEqual(problemSet.NumAdvancedPRoblems, 1);
problem0.Type = ProblemType.Advanced;
Assert.AreEqual(problemSet.NumBasicProblems, 1);
Assert.AreEqual(problemSet.NumAdvancedPRoblems, 2);
problemSet.Problems.Remove(problem0);
Assert.AreEqual(problemSet.NumBasicProblems, 1);
Assert.AreEqual(problemSet.NumAdvancedPRoblems, 1);
problem0.Type = ProblemType.Basic;
Assert.AreEqual(problemSet.NumBasicProblems, 1);
Assert.AreEqual(problemSet.NumAdvancedPRoblems, 1);
}
public static void ExecuteSaveProblemSet(Teacher teach, ProblemSet ps)
{
SqlCommand cmdString = new SqlCommand("SELECT Teachers.SavedProblemSets FROM Teachers WHERE Teachers.Id = " + teach.Id, _connection);
cmdString.CommandType = CommandType.Text;
String problemsStringForm = "";
_connection.Open();
try
{
SqlDataReader reader = cmdString.ExecuteReader();
while (reader.Read())
{
problemsStringForm = reader[0] + "";
}
reader.Close();
}
catch (Exception ex)
{
Console.WriteLine("CC=========================CC");
Console.WriteLine(ex);
}
_connection.Close();
SqlCommand cmdNew = new SqlCommand("UPDATE Teachers SET SavedProblemSets = '" + problemsStringForm + "," + ExecuteGetProblemSetIdByName(ps.Name) + "' WHERE Teachers.Id = " + teach.Id, _connection);
cmdNew.CommandType = CommandType.Text;
_connection.Open();
cmdNew.ExecuteNonQuery();
_connection.Close();
}
private void UpdateCurrentSelection()
{
currentProblemSet = problemList.problemSetList[currentProblemSetId];
if (currentProblemSet.problemList.Count > 0)
{
currentProblem = currentProblemSet.problemList[currentProblemId];
}
}
public void Dispose()
{
if (IsDisposed)
{
return;
}
ProblemSet.Dispose();
IsDisposed = true;
}
public async Task <IEnumerable <TProblem> > FetchProblemByTitleAsync(string title, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(title))
{
throw new ArgumentNullException(nameof(title));
}
Handle(cancellationToken);
return(await ProblemSet.FetchProblemByTitleAsync(title, cancellationToken));
}
public async Task <TProblem> FetchProblemAsync(string id, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id));
}
Handle(cancellationToken);
return(await ProblemSet.FetchProblemAsync(id, cancellationToken));
}
public async Task AddProblemAsync(string id, TProblem problem, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException(nameof(id));
}
Handle(cancellationToken);
await ProblemSet.AddProblemAsync(id, problem, cancellationToken);
}
private void GetSelectionPicture(int type)
{
if (Globals.ThisAddIn.Application.Selection.Range.Text != null)
{
//保存range数据
this.label1.Visible = false;
exerciseUnClassified = jsonFileHelper.GetProblemSetFromFile(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified.json");
string imgName = imgHelper.GetSelectionImg("exerciseUnClassified");
if (imgName.Equals(""))
{
return;
}
Image img = Image.FromFile(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified\\" + imgName);
this.textBox1.Visible = false;
this.pictureBox1.Visible = true;
//this.pictureBox1.Width = 660;
double beishu = (double)660 / (double)img.Width;
this.pictureBox1.Height = (int)(img.Height * beishu);
this.panel1.Height = panle1_Height + this.pictureBox1.Height - pictureBox1_Height;
this.pictureBox1.Image = img;
exerciseTemp.Question = imgName;
exerciseTemp.QuestionType = type;
if (this.button7.Visible == true)
{
ExerciseWithRange exRange = new ExerciseWithRange();
exRange.RangeStart = Globals.ThisAddIn.Application.Selection.Range.Start;
exRange.RangeEnd = Globals.ThisAddIn.Application.Selection.Range.End;
rangeList.Add(exRange);
try
{
jsonFileHelper.WriteFileString(JsonConvert.SerializeObject(rangeList), @"D:\新建文件夹\imgJsonList.json");
}
catch
{
}
}
//exerciseUnClassified.ExerciseList.Add(exerciseTemp);
//jsonFileHelper.WriteFileString(JsonConvert.SerializeObject(exerciseUnClassified), Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified.json");
}
}
public void StudentTest()
{
var problemSet = new ProblemSet();
problemSet.Problems.Add(new Problem {
Type = ProblemType.Basic
});
problemSet.Problems.Add(new Problem {
Type = ProblemType.Basic
});
problemSet.Problems.Add(new Problem {
Type = ProblemType.Basic
});
problemSet.Problems.Add(new Problem {
Type = ProblemType.Advanced
});
problemSet.Problems.Add(new Problem {
Type = ProblemType.Advanced
});
var student = new Student(problemSet);
student.Answers.Add(new Answer {
Evaluation = Evaluation.NotExecutable
});
student.Answers.Add(new Answer {
Evaluation = Evaluation.Wrong
});
student.Answers.Add(new Answer {
Evaluation = Evaluation.Correct
});
student.Answers.Add(new Answer {
Evaluation = Evaluation.NotExecutable
});
student.Answers.Add(new Answer {
Evaluation = Evaluation.Correct
});
Assert.AreEqual(100, student.Score);
Assert.AreEqual(2, student.AdvancedScore);
student.Answers[4].Evaluation = Evaluation.Wrong;
Assert.AreEqual(100, student.Score);
Assert.AreEqual(0, student.AdvancedScore);
student.Answers[2].Evaluation = Evaluation.Wrong;
Assert.AreEqual(74, student.Score);
Assert.AreEqual(0, student.AdvancedScore);
student.Answers[1].Evaluation = Evaluation.Correct;
Assert.AreEqual(94, student.Score);
Assert.AreEqual(0, student.AdvancedScore);
problemSet.Problems[1].Type = ProblemType.Advanced;
Assert.AreEqual(90, student.Score);
Assert.AreEqual(1, student.AdvancedScore);
}
void SetUpProblemObject(ProblemSet problemSet, int index)
{
Problem problem = problemSet.problemList[index];
int currentStatus = ProblemPrefsUpdater.GetProblemStatus(problemSet.ID, problem.ID);
ProblemObject po = problemList[index].GetComponent <ProblemObject>();
Text objectText = problemList[index].GetComponentInChildren <Text>();
objectText.text = problem.Title;
po.SetStatus(currentStatus);
}
public ProblemSet GetProblemSetFromFile(string filePath)
{
ProblemSet problemSetTemp = new ProblemSet();
string jsonResult = GetFileString(filePath);
if ((ProblemSet)JsonConvert.DeserializeObject(jsonResult, typeof(ProblemSet)) != null)
{
problemSetTemp = (ProblemSet)JsonConvert.DeserializeObject(jsonResult, typeof(ProblemSet));
}
return(problemSetTemp);
}
private bool AttemptProblemSetCreate(object sender)
{
if (ValidateFormData(sender)) // front-end data validation
{
ProblemSet newProblemSet = ConstructProblemSet(); // object construction
MMControl.AddProblemSet(newProblemSet); // result returned to Control object
return(true);
}
else
{
return(false);
}
}
private void listBox2_SelectedIndexChanged(object sender, EventArgs e)
{
if (listBox2.SelectedIndex >= 0)
{
_currentlySelectedProblemSet = _allProblemSets[listBox2.SelectedIndex];
//load set stats
string stats = "";
stats += $"Name : {_currentlySelectedProblemSet.Name}\n";
stats += $"Point Worth : {_currentlySelectedProblemSet.Points}\n";
stats += $"Description : \n\t{_currentlySelectedProblemSet.Description}\n";
richTextBox5.Text = "";
richTextBox5.Text = stats;
}
}
public int[] CreateDenseHash()
{
var ret = new int[16];
for (int i = 0; i < 16; i++)
{
var set = ProblemSet.Skip(i * 16).Take(16).ToArray();
if (set.Any())
{
ret[i] = set.Aggregate(0, ((i1, i2) => i1 ^ i2));
}
}
return(ret);
}
void Start()
{
SetWallsRemaining(0);
print(String.Format("map: {0}, id: {1}", GlobalState.map, GlobalState.user_id));
walls_left = GameObject.Find("WallText").GetComponent <TextMeshProUGUI>();
speed_value = GameObject.Find("HUD/Speed/Bar/Bar").GetComponent <Image>();
target_text = GameObject.Find("HUD/Target/TargetText").GetComponent <TextMeshProUGUI>();
marble_body = GetComponent <Rigidbody>();
// randomize ordering of problemset
System.Random rand = new System.Random();
ProblemSet ps = JsonConvert.DeserializeObject <ProblemSet>(AuthUrlRequest("/problemsets", GlobalState.map));
Problem[] it = ps.problems;
problemset = it.OrderBy(x => rand.Next()).ToArray();
//update UI elements
problemset_len = problemset.Length;
is_left = new bool[problemset_len];
//SetWallsRemaining(problemset_len);
SetTargetText(0);
ChangeSpeed(0);
//left_gutters = GenerateGutters(-10, 90, problemset_len * scalar);
//right_gutters = GenerateGutters(10, 270, problemset_len * scalar);
left_walls = GenerateWalls(-5, problemset_len);
right_walls = GenerateWalls(5, problemset_len);
// draw text on walls and shuffle correct answer left or right
bool[] left_correct = new bool[problemset_len];
for (int i = 0; i < problemset_len; i++)
{
if (rand.Next(0, 2) == 0)
{
is_left[i] = true;
SetWallText(left_walls[i], problemset[i].correct, true, i);
SetWallText(right_walls[i], problemset[i].incorrect, false, i);
}
else
{
is_left[i] = false;
SetWallText(left_walls[i], problemset[i].incorrect, false, i);
SetWallText(right_walls[i], problemset[i].correct, true, i);
}
}
}
public static void ExecuteAddAssignment(Classroom cls, ProblemSet assignment)
{
String problems = "";
for (int i = 0; i < cls.AssignedProblemSets.Count; i++)
{
problems += ExecuteGetProblemSetIdByName(cls.AssignedProblemSets[i].Name) + "";
if (i < cls.AssignedProblemSets.Count - 1)
{
problems += ",";
}
}
SqlCommand cmdNew = new SqlCommand("UPDATE Classrooms SET Classrooms.AssignedProblemSets = '" + "," + ExecuteGetProblemSetIdByName(assignment.Name) + "' WHERE Id = " + cls.Id + ";", _connection);
cmdNew.CommandType = CommandType.Text;
_connection.Open();
cmdNew.ExecuteNonQuery();
_connection.Close();
}
public void SetQuestionImg()
{
string filePath = Globals.ThisAddIn.exerciseJsonPath + paperName + ".json";
paper = jsonFileHelper.GetPaperFromFile(filePath);
problemSet = jsonFileHelper.GetProblemSetFromFile(filePath);
//Exercise pointExercise = new Exercise();
if (paper.PaperNodeList.Count != 0 && problemSet.ExerciseList.Count == 0)
{
exerciseOrderCount = 0;
pointExercise = GetExerciseByOrder(paper.PaperNodeList as List <PaperNode>);
}
else if (paper.PaperNodeList.Count == 0 && problemSet.ExerciseList.Count != 0)
{
exerciseOrderCount = 0;
pointExercise = GetExerciseByOrder(problemSet.ExerciseList as List <Exercise>);
}
ReSetQuestionDetail();
}
/// <summary>
/// Helper function to add the problem sets to the student
/// </summary>
/// <param name="sender">The object that raised the event</param>
/// <param name="e">The event arguments</param>
/// <history>
/// <Created 23 April 2014>Arun Gopinath && Jeff Bunce</Created>
/// <Modified 23 April 2014></Modified>
/// </history>
private void CreateAssignment()
{
List <ProblemSet> problemSetList = new List <ProblemSet> ();
List <Student> SelectedStudents = new List <Student> ();
foreach (DataGridViewRow row in dtgStudentList.SelectedRows)
{
SelectedStudents.Add(( Student )row.DataBoundItem);
}
dtgProblemSetList.Refresh();
foreach (DataGridViewRow row in dtgProblemSetList.SelectedRows)
{
ProblemSet ps = (ProblemSet)row.DataBoundItem;
problemSetList.Add(ps);
}
mmControl.AddNewAssignment(SelectedStudents, problemSetList);
UpdateBindings();
}
public void SetUpList()
{
ProblemSet problemSet = ProblemManager.Instance.currentProblemSet;
problemListTitle.text = problemSet.Title;
for (int i = 0; i < problemSet.problemList.Count; ++i)
{
if (i >= problemList.Count)
{
AddNewProblemObject(i);
}
SetUpProblemObject(problemSet, i);
problemList[i].SetActive(true);
}
for (int i = problemSet.problemList.Count; i < lastSize; ++i)
{
problemList[i].SetActive(false);
}
lastSize = problemSet.problemList.Count;
leftButton.SetActive(ProblemManager.Instance.CurrentProblemSet_CanGoLeft());
rightButton.SetActive(ProblemManager.Instance.CurrentProblemSet_CanGoRight());
}
public async void Open(string path)
{
if (await OnNew().ConfigureAwait(false))
{
ProblemSet.Path = path;
State = MainWindowStatus.Running;
StateText = "Opening Problem Set";
var result = await ProblemSet.LoadAsync().ConfigureAwait(false);
Dispatcher.BeginInvoke((Action)(() =>
{
if (result)
{
State = MainWindowStatus.Ready;
StateText = "Problem Set Opened";
}
else
{
State = MainWindowStatus.Error;
StateText = "Failed to Open Problem Set";
}
}));
}
}
public static void Main(string[] args)
{
bool run = true;
string target = "Default target";
bool useCache = false;
int generations = 1000;
int populationSize = 100;
int selectionSize = 10;
int mutationSize = 10;
while (run) {
Console.WriteLine ("Input target string for evolution ( " +
target + " ):"
);
string newTarget = Console.ReadLine ();
if (newTarget != "")
target = newTarget;
StringProblem<StringIndividual> problem = new StringProblem<StringIndividual> (target);
Console.WriteLine("Use caching in problem set ( " + useCache + " ) ?");
string newUseCache = Console.ReadLine ();
if (newUseCache != "")
useCache = readYNstring (newUseCache);
ProblemSet<StringIndividual> tester = new ProblemSet<StringIndividual> (problem, useCache);
Console.WriteLine ("Input generations amount ( " + generations + " ):");
string newGenerations = Console.ReadLine ();
if (newGenerations != "")
generations = Convert.ToInt32 (newGenerations);
Console.WriteLine ("Input population size ( " + populationSize + " ):");
string newPopulationSize = Console.ReadLine ();
if (newPopulationSize != "")
populationSize = Convert.ToInt32 (newPopulationSize);
Console.WriteLine ("Input selection size ( " + selectionSize + " ): ");
string newSelectionSize = Console.ReadLine ();
if (newSelectionSize != "")
selectionSize = Convert.ToInt32 (newSelectionSize);
Console.WriteLine ("Input mutation size ( " + mutationSize + " ): ");
string newMutationSize = Console.ReadLine ();
if (newMutationSize != "")
mutationSize = Convert.ToInt32 (newMutationSize);
Genetic.Evolution<StringIndividual> evolution = new Evolution<StringIndividual> (generations,
populationSize,
selectionSize,
mutationSize,
tester, true);
Console.WriteLine ("Evolution result: " + evolution.win ().ToString ());
Console.WriteLine ("Do you want to run again (Y/N)?");
string runAgain = Console.ReadLine ();
run = readYNstring(runAgain);
}
}
public static void Main(string[] args)
{
Console.WriteLine ("Generating random points:");
List<Problem<Chromosome<int>>> problems = new List<Problem<Chromosome<int>>> ();
for (int i=0; i<POINT_AMOUNT; i++) {
int x = rnd.Next (MIN_INT, MAX_INT);
//
// TARGET FORMULA
//
int y = x % 5;
Console.WriteLine ("(" + x.ToString () + "," + y.ToString () + ")");
problems.Add (new PointProblem<Chromosome<int>> (x, y));
}
bool useCache = true;
int generations = 100;
int populationSize = 1000;
int selectionSize = 100;
int mutationSize = 500;
bool run = true;
while (run) {
Console.WriteLine ("Use caching in problem set ( " + useCache + " ) ?");
string newUseCache = Console.ReadLine ();
if (newUseCache != "")
useCache = readYNstring (newUseCache);
// `System.Collections.Generic.List<Genetic.Programming.Arithmetic.PointProblem<Genetic.Programming.Genome.Chromosome<int>>>'
// `System.Collections.Generic.List<Genetic.Problem<Genetic.Programming.Genome.Chromosome<int>>>'
ProblemSet<Chromosome<int>> tester = new ProblemSet<Chromosome<int>> (problems, useCache);
Console.WriteLine ("Input generations amount ( " + generations + " ):");
string newGenerations = Console.ReadLine ();
if (newGenerations != "")
generations = Convert.ToInt32 (newGenerations);
Console.WriteLine ("Input population size ( " + populationSize + " ):");
string newPopulationSize = Console.ReadLine ();
if (newPopulationSize != "")
populationSize = Convert.ToInt32 (newPopulationSize);
Console.WriteLine ("Input selection size ( " + selectionSize + " ): ");
string newSelectionSize = Console.ReadLine ();
if (newSelectionSize != "")
selectionSize = Convert.ToInt32 (newSelectionSize);
Console.WriteLine ("Input mutation size ( " + mutationSize + " ): ");
string newMutationSize = Console.ReadLine ();
if (newMutationSize != "")
mutationSize = Convert.ToInt32 (newMutationSize);
List<Expression<int>> operations = new List<Expression<int>> ();
operations.Add (new Expression<int> (typeof(Addition)));
operations.Add (new Expression<int> (typeof(Subtraction)));
operations.Add (new Expression<int> (typeof(Multiplication)));
operations.Add (new Expression<int> (typeof(Division)));
operations.Add (new Expression<int> (typeof(Conditional)));
operations.Add (new Expression<int> (typeof(Maximum)));
operations.Add (new Expression<int> (typeof(Minimum)));
operations.Add (new Expression<int> (typeof(Modulo)));
operations.Add (new Expression<int> (typeof(Pop<int>)));
operations.Add (new Expression<int> (typeof(Push<int>)));
operations.Add (new Expression<int> (typeof(Input<int>)));
operations.Add (new ConstantExpression<int> (1));
operations.Add (new ConstantExpression<int> (2));
operations.Add (new ConstantExpression<int> (0));
ExpressionFactory<int> factory = new ExpressionFactory<int> (operations);
Chromosome<int>.factory = factory;
Evolution<Chromosome<int>> evolution = new Evolution<Chromosome<int>> (generations,
populationSize,
selectionSize,
mutationSize,
tester, false);
Chromosome<int> winner = evolution.win ();
Console.WriteLine ("Evolution result: " + winner.ToString ());
tester.test (winner, true);
foreach (PointProblem<Chromosome<int>> problem in problems) {
int x = problem.task.input;
int y = winner.Compute (problem.task);
int expectedY = problem.result;
Console.WriteLine ((y == expectedY ? "+" : "-") + " f(" + x + ") = " + y + " : " + expectedY);
}
if (winner is IMeasurable)
Console.WriteLine ("Complexity: " + ((IMeasurable)winner).Complexity ());
Console.WriteLine ("Fitness: " + tester.test (winner));
Console.WriteLine ("Do you want to run again (Y/N)?");
string runAgain = Console.ReadLine ();
run = readYNstring (runAgain);
}
}
private void FormTest_Load(object sender, EventArgs e)
{
string str = jsonFileHelper.GetFileString(@"D:\新建文件夹\imgJsonList.json");
List <ExerciseWithRange> rangeExerciseList = new List <ExerciseWithRange>();
rangeExerciseList = (List <ExerciseWithRange>)JsonConvert.DeserializeObject(str, rangeExerciseList.GetType());
ProblemSet problemSet = new ProblemSet();
problemSet = jsonFileHelper.GetProblemSetFromFile(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified.json");
List <Exercise> ExerciseList = problemSet.ExerciseList;
int oldImgLocation_x = 0;
int oldImgWidth = 660;
int marginTop = 0;
if (rangeExerciseList.Count != 0)
{
for (int i = 0; i < rangeExerciseList.Count; i++)
{
Image img = Image.FromFile(@"D:\新建文件夹\" + rangeExerciseList[i].Question);
marginTop += img.Height;
}
this.panel1.Height = marginTop + 100;
marginTop = 0;
for (int i = 0; i < rangeExerciseList.Count; i++)
{
Image img = Image.FromFile(@"D:\新建文件夹\" + rangeExerciseList[i].Question);
PictureBox pictureBox = new PictureBox();
pictureBox.Image = img;
pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
pictureBox.Size = new System.Drawing.Size(img.Width, img.Height);
pictureBox.Location = new Point(0, marginTop);
this.panel1.Controls.Add(pictureBox);
marginTop += img.Height;
if (img.Width > oldImgWidth)
{
oldImgWidth = img.Width;
}
if (pictureBox.Location.X + pictureBox.Width > oldImgLocation_x)
{
oldImgLocation_x = pictureBox.Location.X + pictureBox.Width;
}
}
}
oldImgLocation_x += 10;
marginTop = 0;
if (ExerciseList.Count != 0)
{
for (int i = 0; i < ExerciseList.Count; i++)
{
Image img = Image.FromFile(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified\\" + ExerciseList[i].Question);
marginTop += (int)(((double)oldImgWidth / (double)img.Width) * img.Height);
}
if (this.panel1.Height < marginTop)
{
this.panel1.Height = marginTop + 100;
}
marginTop = 0;
for (int i = 0; i < ExerciseList.Count; i++)
{
Image img = Image.FromFile(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified\\" + ExerciseList[i].Question);
PictureBox pictureBox = new PictureBox();
pictureBox.Image = img;
pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
pictureBox.Size = new System.Drawing.Size(oldImgWidth, (int)(((double)oldImgWidth / (double)img.Width) * img.Height));
pictureBox.Location = new Point(oldImgLocation_x, marginTop);
this.panel1.Controls.Add(pictureBox);
marginTop += (int)(((double)oldImgWidth / (double)img.Width) * img.Height);
}
}
}
private void CleanDash()
{
try
{
if (!Directory.Exists(_exerciseJsonPath))
{
Directory.CreateDirectory(_exerciseJsonPath);
}
if (!Directory.Exists(_exerciseJsonPath + "Deleted"))
{
Directory.CreateDirectory(_exerciseJsonPath + "Deleted");
}
if (!Directory.Exists(_exerciseJsonPath + "Uploaded"))
{
Directory.CreateDirectory(_exerciseJsonPath + "Uploaded");
}
if (!Directory.Exists(_exerciseJsonPath + "exerciseUnClassified"))
{
Directory.CreateDirectory(_exerciseJsonPath + "exerciseUnClassified");
}
//每次程序开始时，清理已组卷的题目图片
string[] zipName = Directory.GetFiles(Globals.ThisAddIn.exerciseJsonPath);
foreach (string s in zipName)
{
int index = s.LastIndexOf(".");
string fileType = "";
if (index + 4 == s.Length)
{
fileType = s.Substring(index, 4);
}
if (fileType.ToLower().Equals(".zip"))
{
File.Delete(s);
}
}
//每次程序开始时，清理已组卷的题目图片
if (!Directory.Exists(_exerciseJsonPath))
{
Directory.CreateDirectory(_exerciseJsonPath);
}
string jsonStr = jsonFileHelper.GetFileString(_exerciseJsonPath + "exerciseUnClassified.json");
ProblemSet exerciseUnClassified = new ProblemSet();
exerciseUnClassified = jsonFileHelper.GetProblemSetFromFile(_exerciseJsonPath + "exerciseUnClassified.json");
string[] allImg = Directory.GetFiles(Globals.ThisAddIn.exerciseJsonPath + "exerciseUnClassified");
if (exerciseUnClassified.ExerciseList.Count != 0)
{
foreach (string s in allImg)
{
string[] nameSplit = s.Split('\\');
if (!jsonStr.Contains(nameSplit[nameSplit.Length - 1]))
{
File.Delete(s);
}
}
}
else
{
foreach (string s in allImg)
{
File.Delete(s);
}
}
//每次程序开始时，清理已上传的试卷图片
string[] imgDire = Directory.GetDirectories(Globals.ThisAddIn.exerciseJsonPath);
foreach (string d in imgDire)
{
string[] dSplit = d.Split('\\');
string jsonFileName = dSplit[dSplit.Length - 1];
string[] jsonFile = Directory.GetFiles(Globals.ThisAddIn.exerciseJsonPath);
bool ISEX = false;
foreach (string s in jsonFile)
{
string[] jsonFileSplit = s.Split('\\');
string fullJsonFileName = jsonFileSplit[jsonFileSplit.Length - 1];
if ((jsonFileName + ".json").Equals(fullJsonFileName))
{
ISEX = true;
}
}
if (!ISEX && (!jsonFileName.Equals("Uploaded") && !jsonFileName.Equals("Papers") && !jsonFileName.Equals("Deleted")))
{
Directory.Delete(Globals.ThisAddIn.exerciseJsonPath + jsonFileName, true);
}
}
}
catch
{
MessageBox.Show("无法清理垃圾文件");
}
}
