MainWindow.xaml.cs 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531
  1. using Microsoft.Win32;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Linq;
  5. using System.Reflection;
  6. using System.Text;
  7. using System.Threading;
  8. using System.Threading.Tasks;
  9. using System.Timers;
  10. using System.Windows;
  11. using System.Windows.Controls;
  12. using System.Windows.Controls.Primitives;
  13. using System.Windows.Data;
  14. using System.Windows.Documents;
  15. using System.Windows.Input;
  16. using System.Windows.Media;
  17. using System.Windows.Media.Imaging;
  18. using System.Windows.Navigation;
  19. using System.Windows.Shapes;
  20. using System.Windows.Threading;
  21. namespace SketchAssistantWPF
  22. {
  23. /// <summary>
  24. /// Interaction logic for MainWindow.xaml
  25. /// </summary>
  26. public partial class MainWindow : Window, MVP_View
  27. {
  28. public MainWindow()
  29. {
  30. bool InDebugMode = false;
  31. String[] commArgs = Environment.GetCommandLineArgs();
  32. InitializeComponent();
  33. if (commArgs.Length > 1)
  34. {
  35. if (commArgs[1].Equals("-debug"))
  36. {
  37. InDebugMode = true;
  38. }
  39. }
  40. if(!InDebugMode)
  41. {
  42. DebugMode.Visibility = Visibility.Collapsed;
  43. }
  44. ProgramPresenter = new MVP_Presenter(this);
  45. // DispatcherTimer setup
  46. dispatcherTimer = new DispatcherTimer(DispatcherPriority.Render);
  47. dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
  48. dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 10);
  49. ProgramPresenter.Resize(new Tuple<int, int>((int)LeftCanvas.Width, (int)LeftCanvas.Height),
  50. new Tuple<int, int>((int)RightCanvas.Width, (int)RightCanvas.Height));
  51. }
  52. public enum ButtonState
  53. {
  54. Enabled,
  55. Disabled,
  56. Active
  57. }
  58. DispatcherTimer dispatcherTimer;
  59. /// <summary>
  60. /// Dialog to select a file.
  61. /// </summary>
  62. OpenFileDialog openFileDialog = new OpenFileDialog();
  63. /// <summary>
  64. /// All Lines in the current session
  65. /// </summary>
  66. List<Tuple<bool, InternalLine>> rightLineList = new List<Tuple<bool, InternalLine>>();
  67. /// <summary>
  68. /// Queue for the cursorPositions
  69. /// </summary>
  70. Queue<Point> cursorPositions = new Queue<Point>();
  71. /// <summary>
  72. /// The Presenter Component of the MVP-Model
  73. /// </summary>
  74. MVP_Presenter ProgramPresenter;
  75. /// <summary>
  76. /// The line currently being drawn
  77. /// </summary>
  78. Polyline currentLine;
  79. /// <summary>
  80. /// If the debug function is running.
  81. /// </summary>
  82. bool debugRunning = false;
  83. /// <summary>
  84. /// Point collections for debugging.
  85. /// </summary>
  86. DebugData debugDat = new DebugData();
  87. /********************************************/
  88. /*** WINDOW SPECIFIC FUNCTIONS START HERE ***/
  89. /********************************************/
  90. /// <summary>
  91. /// Resize Function connected to the form resize event, will refresh the form when it is resized
  92. /// </summary>
  93. private void Window_SizeChanged(object sender, SizeChangedEventArgs e)
  94. {
  95. ProgramPresenter.Resize(new Tuple<int, int>((int)LeftCanvas.ActualWidth, (int)LeftCanvas.ActualHeight),
  96. new Tuple<int, int>((int)RightCanvas.ActualWidth, (int)RightCanvas.ActualHeight));
  97. }
  98. /// <summary>
  99. /// Redo an Action.
  100. /// </summary>
  101. private void RedoButton_Click(object sender, RoutedEventArgs e)
  102. {
  103. ProgramPresenter.Redo();
  104. }
  105. /// <summary>
  106. /// Undo an Action.
  107. /// </summary>
  108. private void UndoButton_Click(object sender, RoutedEventArgs e)
  109. {
  110. ProgramPresenter.Undo();
  111. }
  112. /// <summary>
  113. /// Changes the state of the program to deletion
  114. /// </summary>
  115. private void DeleteButton_Click(object sender, RoutedEventArgs e)
  116. {
  117. ProgramPresenter.ChangeState(false);
  118. }
  119. /// <summary>
  120. /// Changes the state of the program to drawing
  121. /// </summary>
  122. private void DrawButton_Click(object sender, RoutedEventArgs e)
  123. {
  124. ProgramPresenter.ChangeState(true);
  125. }
  126. /// <summary>
  127. /// Hold left mouse button to start drawing.
  128. /// </summary>
  129. private void RightCanvas_MouseDown(object sender, MouseButtonEventArgs e)
  130. {
  131. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Down);
  132. //System.Diagnostics.Debug.WriteLine("ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Down);");
  133. }
  134. /// <summary>
  135. /// Lift left mouse button to stop drawing and add a new Line.
  136. /// </summary>
  137. private void RightCanvas_MouseUp(object sender, MouseButtonEventArgs e)
  138. {
  139. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Up);
  140. //System.Diagnostics.Debug.WriteLine("ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Up);");
  141. }
  142. /// <summary>
  143. /// If the mouse leaves the canvas, it is treated as if the mouse was released.
  144. /// </summary>
  145. private void RightCanvas_MouseLeave(object sender, MouseEventArgs e)
  146. {
  147. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Up);
  148. }
  149. /// <summary>
  150. /// If the finger leaves the canvas, it is treated as if the finger was released.
  151. /// </summary>
  152. private void RightCanvas_TouchLeave(object sender, TouchEventArgs e)
  153. {
  154. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Up);
  155. }
  156. /// <summary>
  157. /// Get current Mouse positon within the right picture box.
  158. /// </summary>
  159. private void RightCanvas_MouseMove(object sender, MouseEventArgs e)
  160. {
  161. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Move, e.GetPosition(RightCanvas));
  162. //System.Diagnostics.Debug.WriteLine("new Point(" + ((int)e.GetPosition(RightCanvas).X).ToString() + "," + ((int)e.GetPosition(RightCanvas).Y).ToString() + "), ");
  163. }
  164. /// <summary>
  165. /// Button to create a new Canvas. Will create an empty image
  166. /// which is the size of the left image, if there is one.
  167. /// If there is no image loaded the canvas will be the size of the right picture box
  168. /// </summary>
  169. private void CanvasButton_Click(object sender, RoutedEventArgs e)
  170. {
  171. ProgramPresenter.NewCanvas();
  172. }
  173. /// <summary>
  174. /// Sends inputs to the presenter simulating drawing, used for testing and debugging.
  175. /// Takes 7000ms
  176. /// </summary>
  177. private void DebugOne_Click(object sender, RoutedEventArgs e)
  178. {
  179. Debug(1);
  180. }
  181. /// <summary>
  182. /// Sends inputs to the presenter simulating drawing, used for testing and debugging.
  183. /// Takes 24000ms
  184. /// </summary>
  185. private void DebugTwo_Click(object sender, RoutedEventArgs e)
  186. {
  187. Debug(2);
  188. }
  189. /// <summary>
  190. /// Ticks the Presenter.
  191. /// </summary>
  192. private void dispatcherTimer_Tick(object sender, EventArgs e)
  193. {
  194. ProgramPresenter.Tick();
  195. //System.Diagnostics.Debug.WriteLine("ProgramPresenter.Tick();");
  196. }
  197. /// <summary>
  198. /// Import button, will open an OpenFileDialog
  199. /// </summary>
  200. private void MenuItem_Click(object sender, RoutedEventArgs e)
  201. {
  202. ProgramPresenter.ExamplePictureToolStripMenuItemClick();
  203. }
  204. /*************************/
  205. /*** PRESENTER -> VIEW ***/
  206. /*************************/
  207. /// <summary>
  208. /// Returns the cursor position.
  209. /// </summary>
  210. /// <returns>The cursor Position</returns>
  211. public Point GetCursorPosition()
  212. {
  213. return Mouse.GetPosition(RightCanvas);
  214. }
  215. /// <summary>
  216. /// If the mouse is pressed or not.
  217. /// </summary>
  218. /// <returns>Whether or not the mouse is pressed.</returns>
  219. public bool IsMousePressed()
  220. {
  221. if (!debugRunning) {
  222. return (Mouse.LeftButton.Equals(MouseButtonState.Pressed) || Mouse.RightButton.Equals(MouseButtonState.Pressed)); }
  223. else return true;
  224. }
  225. /// <summary>
  226. /// Remove the current line.
  227. /// </summary>
  228. public void RemoveCurrLine()
  229. {
  230. RightCanvas.Children.Remove(currentLine);
  231. }
  232. /// <summary>
  233. /// Display the current line.
  234. /// </summary>
  235. /// <param name="line">The current line to display</param>
  236. public void DisplayCurrLine(Polyline line)
  237. {
  238. if (RightCanvas.Children.Contains(currentLine))
  239. {
  240. RemoveCurrLine();
  241. }
  242. RightCanvas.Children.Add(line);
  243. currentLine = line;
  244. }
  245. /// <summary>
  246. /// Removes all Lines from the left canvas.
  247. /// </summary>
  248. public void RemoveAllLeftLines()
  249. {
  250. LeftCanvas.Children.Clear();
  251. }
  252. /// <summary>
  253. /// Removes all lines in the right canvas.
  254. /// </summary>
  255. public void RemoveAllRightLines()
  256. {
  257. RightCanvas.Children.Clear();
  258. }
  259. /// <summary>
  260. /// Adds another Line that will be displayed in the left display.
  261. /// </summary>
  262. /// <param name="newLine">The new Polyline to be added displayed.</param>
  263. public void AddNewLineLeft(Polyline newLine)
  264. {
  265. newLine.Stroke = Brushes.Black;
  266. newLine.StrokeThickness = 2;
  267. LeftCanvas.Children.Add(newLine);
  268. }
  269. /// <summary>
  270. /// Adds another Line that will be displayed in the right display.
  271. /// </summary>
  272. /// <param name="newLine">The new Polyline to be added displayed.</param>
  273. public void AddNewLineRight(Polyline newLine)
  274. {
  275. newLine.Stroke = Brushes.Black;
  276. newLine.StrokeThickness = 2;
  277. RightCanvas.Children.Add(newLine);
  278. }
  279. /// <summary>
  280. /// Adds a point to the right canvas
  281. /// </summary>
  282. /// <param name="newPoint">The point</param>
  283. public void AddNewPointRight(Ellipse newPoint)
  284. {
  285. newPoint.Height = 3; newPoint.Width = 3;
  286. newPoint.Fill = Brushes.Black;
  287. RightCanvas.Children.Add(newPoint);
  288. }
  289. /// <summary>
  290. /// Adds a point to the left canvas
  291. /// </summary>
  292. /// <param name="newPoint">The point</param>
  293. public void AddNewPointLeft(Ellipse newPoint)
  294. {
  295. newPoint.Height = 3; newPoint.Width = 3;
  296. newPoint.Fill = Brushes.Black;
  297. LeftCanvas.Children.Add(newPoint);
  298. }
  299. /// <summary>
  300. /// Enables the timer of the View, which will tick the Presenter.
  301. /// </summary>
  302. public void EnableTimer()
  303. {
  304. dispatcherTimer.Start();
  305. }
  306. /// <summary>
  307. /// A function that opens a file dialog and returns the filename.
  308. /// </summary>
  309. /// <param name="Filter">The filter that should be applied to the new Dialog.</param>
  310. /// <returns>Returns the FileName and the SafeFileName if the user correctly selects a file,
  311. /// else returns a tuple with empty strigns</returns>
  312. public Tuple<string, string> openNewDialog(string Filter)
  313. {
  314. openFileDialog.Filter = Filter;
  315. if (openFileDialog.ShowDialog() == true)
  316. {
  317. return new Tuple<string, string>(openFileDialog.FileName, openFileDialog.SafeFileName);
  318. }
  319. else
  320. {
  321. return new Tuple<string, string>("", "");
  322. }
  323. }
  324. /// <summary>
  325. /// Sets the contents of the last action taken indicator label.
  326. /// </summary>
  327. /// <param name="message">The new contents</param>
  328. public void SetLastActionTakenText(string message)
  329. {
  330. LastActionBox.Text = message;
  331. }
  332. /// <summary>
  333. /// Changes the states of a tool strip button.
  334. /// </summary>
  335. /// <param name="buttonName">The name of the button.</param>
  336. /// <param name="state">The new state of the button.</param>
  337. public void SetToolStripButtonStatus(string buttonName, MainWindow.ButtonState state)
  338. {
  339. ButtonBase buttonToChange;
  340. bool isToggleable = false;
  341. switch (buttonName)
  342. {
  343. case "canvasButton":
  344. buttonToChange = CanvasButton;
  345. break;
  346. case "drawButton":
  347. buttonToChange = DrawButton;
  348. isToggleable = true;
  349. break;
  350. case "deleteButton":
  351. buttonToChange = DeleteButton;
  352. isToggleable = true;
  353. break;
  354. case "undoButton":
  355. buttonToChange = UndoButton;
  356. break;
  357. case "redoButton":
  358. buttonToChange = RedoButton;
  359. break;
  360. default:
  361. Console.WriteLine("Invalid Button was given to SetToolStripButton. \nMaybe you forgot to add a case?");
  362. return;
  363. }
  364. if (isToggleable)
  365. {
  366. switch (state)
  367. {
  368. case ButtonState.Active:
  369. ((ToggleButton)buttonToChange).IsEnabled = true;
  370. ((ToggleButton)buttonToChange).IsChecked = true;
  371. ((ToggleButton)buttonToChange).Opacity = 1;
  372. ((ToggleButton)buttonToChange).Background = Brushes.SkyBlue;
  373. break;
  374. case ButtonState.Disabled:
  375. ((ToggleButton)buttonToChange).IsEnabled = false;
  376. ((ToggleButton)buttonToChange).IsChecked = false;
  377. ((ToggleButton)buttonToChange).Opacity = 0.5;
  378. ((ToggleButton)buttonToChange).Background = Brushes.LightGray;
  379. break;
  380. case ButtonState.Enabled:
  381. ((ToggleButton)buttonToChange).IsEnabled = true;
  382. ((ToggleButton)buttonToChange).IsChecked = false;
  383. ((ToggleButton)buttonToChange).Opacity = 1;
  384. ((ToggleButton)buttonToChange).Background = Brushes.LightGray;
  385. break;
  386. }
  387. }
  388. else
  389. {
  390. switch (state)
  391. {
  392. case ButtonState.Disabled:
  393. ((Button)buttonToChange).IsEnabled = false;
  394. ((Button)buttonToChange).Opacity = 0.5;
  395. break;
  396. default:
  397. ((Button)buttonToChange).IsEnabled = true;
  398. ((Button)buttonToChange).Opacity = 1;
  399. break;
  400. }
  401. }
  402. }
  403. /// <summary>
  404. /// Sets the contents of the load status indicator label.
  405. /// </summary>
  406. /// <param name="message">The new contents</param>
  407. public void SetToolStripLoadStatus(string message)
  408. {
  409. LoadStatusBox.Text = message;
  410. }
  411. /// <summary>
  412. /// shows the given info message in a popup and asks the user to aknowledge it
  413. /// </summary>
  414. /// <param name="message">the message to show</param>
  415. public void ShowInfoMessage(string message)
  416. {
  417. MessageBox.Show(message);
  418. }
  419. /// <summary>
  420. /// Shows a warning box with the given message (Yes/No Buttons)and returns true if the user aknowledges it.
  421. /// </summary>
  422. /// <param name="message">The message of the warning.</param>
  423. /// <returns>True if the user confirms (Yes), negative if he doesn't (No)</returns>
  424. public bool ShowWarning(string message)
  425. {
  426. MessageBoxResult result = MessageBox.Show(message, "Warning", MessageBoxButton.YesNo, MessageBoxImage.Warning);
  427. return (result.Equals(MessageBoxResult.Yes));
  428. }
  429. /// <summary>
  430. /// Updates the colour of a canvas.
  431. /// </summary>
  432. /// <param name="canvasName">The name of the canvas to be updated.</param>
  433. /// <param name="active">Whether or not the canvas is active.</param>
  434. public void SetCanvasState(string canvasName, bool active)
  435. {
  436. Canvas canvas;
  437. switch (canvasName){
  438. case ("LeftCanvas"):
  439. canvas = LeftCanvas;
  440. break;
  441. case ("RightCanvas"):
  442. canvas = RightCanvas;
  443. break;
  444. default:
  445. throw new InvalidOperationException("Unknown canvas name, Check that the canvas passed is either LeftCanvas or RightCanvas");
  446. }
  447. if (active)
  448. {
  449. canvas.Background = Brushes.White;
  450. }
  451. else
  452. {
  453. canvas.Background = Brushes.SlateGray;
  454. }
  455. }
  456. /************************/
  457. /*** HELPING FUNCTION ***/
  458. /************************/
  459. /// <summary>
  460. /// A function which simulates canvas input for debugging.
  461. /// </summary>
  462. /// <param name="option"></param>
  463. private async void Debug(int option)
  464. {
  465. Point[] points;
  466. if (option == 1)
  467. points = debugDat.debugPoints1;
  468. else if (option == 2)
  469. points = debugDat.debugPoints2;
  470. else { return; }
  471. dispatcherTimer.Stop();
  472. debugRunning = true;
  473. ProgramPresenter.Tick(); await Task.Delay(10);
  474. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Move, new Point(50, 50));
  475. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Down); await Task.Delay(10);
  476. for (int x = 0; x < points.Length; x++)
  477. {
  478. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Move, points[x]);
  479. await Task.Delay(1);
  480. if (x % 5 == 0)
  481. {
  482. ProgramPresenter.Tick();
  483. await Task.Delay(1);
  484. }
  485. }
  486. ProgramPresenter.MouseEvent(MVP_Presenter.MouseAction.Up); await Task.Delay(1);
  487. debugRunning = false;
  488. dispatcherTimer.Start();
  489. }
  490. }
  491. }