diff --git a/pom.xml b/pom.xml
index 5698b83..f7961a7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,6 +7,26 @@
wwu
masterarbeit
1.0-SNAPSHOT
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+ 1.8
+
+
+
+
+
+
+
+ org.jfree
+ jfreechart
+ 1.0.14
+
+
\ No newline at end of file
diff --git a/src/main/java/App.java b/src/main/java/App.java
new file mode 100644
index 0000000..0bbd0ba
--- /dev/null
+++ b/src/main/java/App.java
@@ -0,0 +1,27 @@
+import Model.Arrangement;
+import Presenter.Presenter;
+import View.MainFrame;
+import View.View;
+
+import javax.swing.*;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 28.05.2017.
+ */
+public class App {
+
+
+ public static void main(String[] args) {
+
+ SwingUtilities.invokeLater(() -> {
+ View view = new MainFrame();
+ view.setPresenter(new Presenter(new Arrangement(), view));
+ });
+
+ }
+
+}
diff --git a/src/main/java/Model/Arrangement.java b/src/main/java/Model/Arrangement.java
new file mode 100644
index 0000000..9b01015
--- /dev/null
+++ b/src/main/java/Model/Arrangement.java
@@ -0,0 +1,61 @@
+package Model;
+
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 28.05.2017.
+ */
+public class Arrangement {
+
+ private LinkedList nodes;
+ private LinkedList lines;
+
+ public Arrangement(){
+ nodes = new LinkedList<>();
+ lines = new LinkedList<>();
+ }
+
+ public void addNode(Pair node){
+ this.nodes.add(node);
+ }
+
+ public void removeNode(int index){
+ this.nodes.remove(index);
+ }
+
+ public void removeNode(Pair node){
+ this.nodes.remove(node);
+ }
+
+ public void addLine(Pair line){
+ this.lines.add(line);
+ }
+
+ public void removeLine(int index){
+ this.lines.remove(index);
+ }
+
+ public void removeLine(Pair line){
+ this.lines.remove(line);
+ }
+
+ public LinkedList getNodes() {
+ return nodes;
+ }
+
+ public void setNodes(LinkedList nodes) {
+ this.nodes = nodes;
+ }
+
+ public LinkedList getLines() {
+ return lines;
+ }
+
+ public void setLines(LinkedList lines) {
+ this.lines = lines;
+ }
+}
diff --git a/src/main/java/Model/Pair.java b/src/main/java/Model/Pair.java
new file mode 100644
index 0000000..62cc44e
--- /dev/null
+++ b/src/main/java/Model/Pair.java
@@ -0,0 +1,50 @@
+package Model;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 28.05.2017.
+ */
+public class Pair implements Comparable {
+
+ private Double x;
+ private Double y;
+
+ public Pair(Double x, Double y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ public Double getX() {
+ return x;
+ }
+
+ public void setX(Double x) {
+ this.x = x;
+ }
+
+ public Double getY() {
+ return y;
+ }
+
+ public void setY(Double y) {
+ this.y = y;
+ }
+
+ @Override
+ public int compareTo(Pair o) {
+ if(this.getX() == o.getX()){
+ if (this.getY() <= o.getY()){
+ return -1;
+ } else {
+ return 1;
+ }
+ } else if (this.getX() < o.getX()){
+ return -1;
+ } else {
+ return 1;
+ }
+ }
+}
diff --git a/src/main/java/Presenter/Coordinator.java b/src/main/java/Presenter/Coordinator.java
deleted file mode 100644
index 726f2f1..0000000
--- a/src/main/java/Presenter/Coordinator.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package Presenter;
-
-/**
- * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
- *
- * @Author: Armin Wolf
- * @Email: a_wolf28@uni-muenster.de
- * @Date: 28.05.2017.
- */
-public class Coordinator implements Presenter {
-
- public void getDataFromModel() {
-
- }
-
- public void setDataByModel() {
-
- }
-
- public void getActionsFromView() {
-
- }
-
- public void setActionByView() {
-
- }
-}
diff --git a/src/main/java/Presenter/Presenter.java b/src/main/java/Presenter/Presenter.java
index 25cd3ac..e422b2b 100644
--- a/src/main/java/Presenter/Presenter.java
+++ b/src/main/java/Presenter/Presenter.java
@@ -1,5 +1,14 @@
package Presenter;
+import Model.Arrangement;
+import Model.Pair;
+import View.*;
+
+import javax.swing.*;
+import java.util.Collections;
+import java.util.LinkedList;
+
+
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
@@ -7,14 +16,97 @@ package Presenter;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
-public interface Presenter {
+public class Presenter {
- public void getDataFromModel();
+ private Arrangement model;
+ private View view;
- public void setDataByModel();
- public void getActionsFromView();
+ private LinkedList lines;
+ private Double max;
+ private Double min;
- public void setActionByView();
+ public Presenter(Arrangement model, View view){
+ this.model = model;
+ this.view = view;
+ this.lines = new LinkedList<>();
+ }
+ public void getDataFromModel() {
+
+ }
+
+ public void setDataByModel() {
+
+ }
+
+ public void getActionsFromView() {
+
+ }
+
+ public void setActionByView() {
+ Double[] x = {1d,2d,3d,4d,10d,12d,18d};
+ Double[] y = {9d,15d,19d,20d,45d,55d,78d};
+// Float[] x = {18f,24f,30f,34f,38f};
+// Float[] y = {18f,26f,30f,40f,70f};
+// Double[] x = {1d,3d,4d,5d,8d};
+// Double[] y = {4d,2d,1d,0d,0d};
+
+
+ for (int j=0;j<7;j++){
+ Pair p = new Pair(x[j], y[j]);
+ lines.add(p);
+ }
+
+ extractBounds();
+ view.createArrangement();
+ }
+ private void extractBounds(){
+ Pair pmax = Collections.max(lines);
+ Pair pmin = Collections.min(lines);
+
+ max = pmax.getX() >= pmax.getY() ? pmax.getX() : pmax.getY();
+ min = pmin.getX() <= pmin.getY() ? pmin.getX() : pmin.getY();
+ }
+
+
+ public Arrangement getModel() {
+ return model;
+ }
+
+ public void setModel(Arrangement model) {
+ this.model = model;
+ }
+
+ public View getView() {
+ return view;
+ }
+
+ public void setView(View view) {
+ this.view = view;
+ }
+
+ public LinkedList getLines() {
+ return lines;
+ }
+
+ public void setLines(LinkedList lines) {
+ this.lines = lines;
+ }
+
+ public Double getMax() {
+ return max;
+ }
+
+ public void setMax(Double max) {
+ this.max = max;
+ }
+
+ public Double getMin() {
+ return min;
+ }
+
+ public void setMin(Double min) {
+ this.min = min;
+ }
}
diff --git a/src/main/java/View/ArrangementDialog.java b/src/main/java/View/ArrangementDialog.java
new file mode 100644
index 0000000..fb33129
--- /dev/null
+++ b/src/main/java/View/ArrangementDialog.java
@@ -0,0 +1,63 @@
+package View;
+
+import Model.Pair;
+import org.jfree.chart.ChartFactory;
+import org.jfree.chart.ChartPanel;
+import org.jfree.chart.JFreeChart;
+import org.jfree.chart.plot.PlotOrientation;
+import org.jfree.data.xy.XYSeries;
+import org.jfree.data.xy.XYSeriesCollection;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.Dimension;
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 28.05.2017.
+ */
+public class ArrangementDialog extends JPanel {
+
+ private LinkedList lines;
+ private double max;
+ private double min;
+ private JFreeChart chart;
+ private ChartPanel panel;
+
+ public ArrangementDialog(){
+ super();
+ this.setPreferredSize(new Dimension(800,500));
+ }
+
+ public void setPrameters(Double pmax, Double pmin, LinkedList lines){
+ this.max = pmax;
+ this.min = pmin;
+ this.lines = lines;
+ }
+
+ public void createArrangement(){
+ XYSeriesCollection dataset = new XYSeriesCollection();
+
+ for (Pair p : lines) {
+ XYSeries series = new XYSeries(p.getX()+p.getY());
+ series.add((-1 * this.max), ((-1 * this.max) * p.getX() + p.getY()));
+ series.add(this.max, (this.max * p.getX() + p.getY()));
+ dataset.addSeries(series);
+ }
+
+ chart = ChartFactory.createXYLineChart(
+ null, null, null, dataset,
+ PlotOrientation.HORIZONTAL, false, false, false );
+ chart.getPlot().setBackgroundPaint(Color.WHITE);
+ panel = new ChartPanel(chart);
+ this.add(panel);
+ }
+
+
+
+
+}
diff --git a/src/main/java/View/MainFrame.java b/src/main/java/View/MainFrame.java
new file mode 100644
index 0000000..87c3fd8
--- /dev/null
+++ b/src/main/java/View/MainFrame.java
@@ -0,0 +1,84 @@
+package View;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.LinkedList;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 28.05.2017.
+ */
+public class MainFrame extends View {
+
+ //TODO refactoring
+ private JButton button1;
+ private JButton button2;
+ private JButton button3;
+ private JDialog dialog;
+ private ArrangementDialog arrangement;
+
+ public MainFrame(){
+ initGUI();
+ }
+
+
+ protected void initGUI(){
+ this.setTitle("MainFrame");
+ this.setSize(800,800);
+ this.setLayout(new FlowLayout());
+ dialog = new JDialog();
+ dialog.setSize(new Dimension(700,470));
+ dialog.setTitle("Arrangement Dialog");
+ dialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
+ button1 = new JButton("Button 1");
+ button2 = new JButton("Button 2");
+ button3 = new JButton("Button 3");
+
+ button1.addActionListener(new ActionListener() {
+ @Override
+ public void actionPerformed(ActionEvent e) {
+ getPresenter().setActionByView();
+ }
+ });
+ this.add(button1);
+ this.add(button2);
+ this.add(button3);
+ this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ this.setVisible(true);
+ }
+
+ @Override
+ public void createArrangement() {
+ if (arrangement == null){
+ arrangement = new ArrangementDialog();
+ arrangement.setPrameters(getPresenter().getMax(), getPresenter().getMin(), getPresenter().getLines());
+ arrangement.createArrangement();
+ SwingUtilities.invokeLater(new Runnable() {
+ @Override
+ public void run() {
+ dialog.add(arrangement);
+ dialog.setVisible(true);
+ }
+ });
+ } else {
+ dialog.setVisible(true);
+ }
+
+
+ }
+
+ @Override
+ public void createLine() {
+ //TODO
+ }
+
+ @Override
+ public void createPlot() {
+ //TODO
+ }
+}
diff --git a/src/main/java/View/PlotDialog.java b/src/main/java/View/PlotDialog.java
new file mode 100644
index 0000000..f3013be
--- /dev/null
+++ b/src/main/java/View/PlotDialog.java
@@ -0,0 +1,11 @@
+package View;
+
+/**
+ * Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
+ *
+ * @Author: Armin Wolf
+ * @Email: a_wolf28@uni-muenster.de
+ * @Date: 29.05.2017.
+ */
+public class PlotDialog {
+}
diff --git a/src/main/java/View/View.java b/src/main/java/View/View.java
index e520e10..558ddf3 100644
--- a/src/main/java/View/View.java
+++ b/src/main/java/View/View.java
@@ -1,5 +1,11 @@
package View;
+import Model.Pair;
+import Presenter.Presenter;
+
+import javax.swing.*;
+import java.util.LinkedList;
+
/**
* Implementierung verschiedener Algorithmen zur Berechnung von Ausgleichsgeraden.
*
@@ -7,5 +13,24 @@ package View;
* @Email: a_wolf28@uni-muenster.de
* @Date: 28.05.2017.
*/
-public interface View {
+public abstract class View extends JFrame {
+
+ private Presenter presenter;
+
+ public View(){
+ }
+
+ public Presenter getPresenter() {
+ return presenter;
+ }
+
+ public void setPresenter(Presenter presenter) {
+ this.presenter = presenter;
+ }
+
+ public abstract void createArrangement();
+
+ public abstract void createLine();
+
+ public abstract void createPlot();
}