From f1082cb7248ad1c19cd9c3c471eebf2d84706be6 Mon Sep 17 00:00:00 2001 From: Matijn Woudt Date: Fri, 1 Oct 2010 13:19:10 +0200 Subject: [PATCH] Fix java tree..(part 2) --- java/Graph | 0 java/Graph Editor/.classpath | 6 + java/Graph Editor/.project | 17 ++ .../.settings/org.eclipse.core.resources.prefs | 3 + .../.settings/org.eclipse.jdt.core.prefs | 12 + java/Graph Editor/Todo.txt | 8 + java/Graph Editor/bin/app/Main.class | Bin 0 -> 1208 bytes .../bin/controllers/SelectionController.class | Bin 0 -> 7380 bytes .../bin/controllers/actions/AddEdge.class | Bin 0 -> 1441 bytes .../bin/controllers/actions/AddNode.class | Bin 0 -> 1395 bytes .../bin/controllers/actions/DeleteNode.class | Bin 0 -> 2252 bytes .../bin/controllers/actions/Move.class | Bin 0 -> 1246 bytes .../bin/controllers/actions/Rename.class | Bin 0 -> 1757 bytes .../Graph Editor/bin/interfaces/GraphFrame$1.class | Bin 0 -> 1940 bytes java/Graph Editor/bin/interfaces/GraphFrame.class | Bin 0 -> 6603 bytes java/Graph Editor/bin/interfaces/GraphPanel.class | Bin 0 -> 3919 bytes java/Graph Editor/bin/models/GraphEdge.class | Bin 0 -> 1127 bytes java/Graph Editor/bin/models/GraphModel.class | Bin 0 -> 5838 bytes java/Graph Editor/bin/models/GraphVertex.class | Bin 0 -> 2358 bytes java/Graph Editor/src/app/Main.java | 41 +++ .../src/controllers/SelectionController.java | 274 +++++++++++++++++++++ .../src/controllers/actions/AddEdge.java | 44 ++++ .../src/controllers/actions/AddNode.java | 47 ++++ .../src/controllers/actions/DeleteNode.java | 73 ++++++ .../Graph Editor/src/controllers/actions/Move.java | 45 ++++ .../src/controllers/actions/Rename.java | 53 ++++ java/Graph Editor/src/interfaces/GraphFrame.java | 201 +++++++++++++++ java/Graph Editor/src/interfaces/GraphPanel.java | 117 +++++++++ java/Graph Editor/src/models/GraphEdge.java | 42 ++++ java/Graph Editor/src/models/GraphModel.java | 155 ++++++++++++ java/Graph Editor/src/models/GraphVertex.java | 98 ++++++++ 31 files changed, 1236 insertions(+) create mode 100644 java/Graph create mode 100644 java/Graph Editor/.classpath create mode 100644 java/Graph Editor/.project create mode 100644 java/Graph Editor/.settings/org.eclipse.core.resources.prefs create mode 100644 java/Graph Editor/.settings/org.eclipse.jdt.core.prefs create mode 100644 java/Graph Editor/Todo.txt create mode 100644 java/Graph Editor/bin/app/Main.class create mode 100644 java/Graph Editor/bin/controllers/SelectionController.class create mode 100644 java/Graph Editor/bin/controllers/actions/AddEdge.class create mode 100644 java/Graph Editor/bin/controllers/actions/AddNode.class create mode 100644 java/Graph Editor/bin/controllers/actions/DeleteNode.class create mode 100644 java/Graph Editor/bin/controllers/actions/Move.class create mode 100644 java/Graph Editor/bin/controllers/actions/Rename.class create mode 100644 java/Graph Editor/bin/interfaces/GraphFrame$1.class create mode 100644 java/Graph Editor/bin/interfaces/GraphFrame.class create mode 100644 java/Graph Editor/bin/interfaces/GraphPanel.class create mode 100644 java/Graph Editor/bin/models/GraphEdge.class create mode 100644 java/Graph Editor/bin/models/GraphModel.class create mode 100644 java/Graph Editor/bin/models/GraphVertex.class create mode 100644 java/Graph Editor/src/app/Main.java create mode 100644 java/Graph Editor/src/controllers/SelectionController.java create mode 100644 java/Graph Editor/src/controllers/actions/AddEdge.java create mode 100644 java/Graph Editor/src/controllers/actions/AddNode.java create mode 100644 java/Graph Editor/src/controllers/actions/DeleteNode.java create mode 100644 java/Graph Editor/src/controllers/actions/Move.java create mode 100644 java/Graph Editor/src/controllers/actions/Rename.java create mode 100644 java/Graph Editor/src/interfaces/GraphFrame.java create mode 100644 java/Graph Editor/src/interfaces/GraphPanel.java create mode 100644 java/Graph Editor/src/models/GraphEdge.java create mode 100644 java/Graph Editor/src/models/GraphModel.java create mode 100644 java/Graph Editor/src/models/GraphVertex.java diff --git a/java/Graph b/java/Graph new file mode 100644 index 0000000..e69de29 diff --git a/java/Graph Editor/.classpath b/java/Graph Editor/.classpath new file mode 100644 index 0000000..07ca123 --- /dev/null +++ b/java/Graph Editor/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/java/Graph Editor/.project b/java/Graph Editor/.project new file mode 100644 index 0000000..57e2558 --- /dev/null +++ b/java/Graph Editor/.project @@ -0,0 +1,17 @@ + + + Graph Editor + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/java/Graph Editor/.settings/org.eclipse.core.resources.prefs b/java/Graph Editor/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..f4592a7 --- /dev/null +++ b/java/Graph Editor/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,3 @@ +#Thu Sep 30 18:32:08 CEST 2010 +eclipse.preferences.version=1 +encoding//src/controllers/SelectionController.java=UTF-8 diff --git a/java/Graph Editor/.settings/org.eclipse.jdt.core.prefs b/java/Graph Editor/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..b5fff6c --- /dev/null +++ b/java/Graph Editor/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +#Thu Sep 23 11:32:08 CEST 2010 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.6 diff --git a/java/Graph Editor/Todo.txt b/java/Graph Editor/Todo.txt new file mode 100644 index 0000000..edba33b --- /dev/null +++ b/java/Graph Editor/Todo.txt @@ -0,0 +1,8 @@ +Todo: + + Optioneel: + Bestandsformaat (Extra bestandsformaten toevoegen, b.v.GraphViz.) + Kopieren+Plakken (Van knopen) + Gerichte Graven + + \ No newline at end of file diff --git a/java/Graph Editor/bin/app/Main.class b/java/Graph Editor/bin/app/Main.class new file mode 100644 index 0000000000000000000000000000000000000000..ae19ac801c379f8d630b49707254aa8b7e35e076 GIT binary patch literal 1208 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 JDgdaC{{wvuJ3asa literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/controllers/actions/AddEdge.class b/java/Graph Editor/bin/controllers/actions/AddEdge.class new file mode 100644 index 0000000000000000000000000000000000000000..31c6f1bee17c3a3ec8d70994f6cf5efb3b9b3259 GIT binary patch literal 1441 zcwU8*-A)rh6vzM5T_~)}S1AQrDjy2ArBFptw20OMMpKDNr3reqZO5`^yK8p0$c+!- zdw8LVK%&71@Ljz1(s*XODWx=Wu{-C?%=w-FoHO(5@AsboRc?5AY_L5ciMq=m~lSnW-Ze&t5zmgc3hjb?vkUG4Zc;?U4~(Y+q!0y zh(nCsXPXS{Im1AnfUah`CCzB?o=<<$$G_{Vw`kE~2o>s9l^agxsja==7b&w0qYgK? zCnVpJ#xPrG7h1fyg(7>`byIgY7z&AVVAACB!)({N%c#i`gPf;81rkCk1~JMYC6c8e z#^}(U`hys!V_i(7AdE>79c7qEyy+$-S?UMFlnMn`gmqPgiUEbJ85Of4tzz@4mGcxb z3>9>f?=R7UdA^iQVv1dn)HlSBk(5tKjYLkYc#OsS_dJx#Cr zrek|r!7#QRgGZn+%)iz5^#jd&Z`w7jVH=KC*!6suuI^Bv?^=A*Fnxw0kGrOBRS1VL zb{=gou*VDoMFRA7+pp+WgZF&+z0~|wU%kSR^ti<(U$L!#VYbw%r+oTKo?sn@RH;q^ zEl+#s>hJc5)aM6u)VpTdroYZGmpKzCTVYU&gc3s-2^Dc98N!)tB?^WS6*2TjFvgHL z%@o5Z65`r~3Kat}+MQD|B>-YBH=KgxVi+u$Hs5a4ce(paI7MJ3r%ER2WEI6hQt|gp zk726xpI+o+xQO`(<`|~Wc$ta?Tw>^}asP>sPOr&iPxvL%gqX!*1UZJ`Q->;+uuK@b zVaOyyI`gWV=h=!7rm46LYHGj7{gxtbFpOooSI~=vOTzc-DorBUrijTBiJK}`krdKy ztGFXH^t-(7>~jerxYktM6(#Xj{+MpS^vY(OVge2Ly^2_$(->WzVGlFw^yjCWvAg*`IafVr3M{Y5%rj*-iPV` z6vhO4&`VK-q7eG%OA{pbG$OQ$vp5FncZj0bR1ufQ+~Ofpxo;SKafI}t%uRll zrRV8)lz>4+3KEDSi4=X(7{RnWlOUKOA&@&k$|y_I7*Lg|p3yp+`+`&x7nJWr6sBOj z+(bqs#lDG^W6HRE(-@JY33^;osV$Iziiy4j1bJG;S(J2NJE^?|G)3CalO@v~K+!hP zY8&WzTj>#QbW?k)mCPR#BnTQb6$<7^=RAQfbXB{KdjZK(pf;p@Y@_tbOtzyk)ULdb aLQuIJRE84|KK)a=+))~Cmu|>gn|}eTup4Ip literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/controllers/actions/DeleteNode.class b/java/Graph Editor/bin/controllers/actions/DeleteNode.class new file mode 100644 index 0000000000000000000000000000000000000000..372dc308d26e75538da878151db160bcf0ace9ac GIT binary patch literal 2252 zcwU86%TgOh6g@2o1Y&qU0uFCOA|Z?n7#kadO#l-dfr({Ez$VThH85BY*J!~00RKRi zS!R_@7D-i5s#0ZtK>os8S7n#V(#h$bK?tG53u$iO?tAXJ_nz)Q-v9mvzyvZu_yl^B zxvXR7(rIbuV`kE^a@l-rQKqFM*K#QtL_lEp&^$I@#_}($?0)Pho65!Jck_);uX_HVZ|50t4|9kZyMR9&*{p@YM+OYkhtP$OgSaHn_W?8m-RKc$-j|NM zD^qUK0v+K=b1ZJEg(%lXn)sv08(Mi3RKA^lZFRiM3$wRUULR}3_uF@zY# zgSg6?FB~%{!%1C>%BHfYE>swp8bOnpN|h0c;ktnv3L?l&H@=C~E*!gMUkPpT4|e? zSbwQlewBQi(9Hi9uD0p-@!K)-8(K%ACp4l3be^D>j{aYC+-0>-bTB@^$XZ4=qZRFF z!;s$72pGmEfVNadK`*E7<(cJ5D1?z;(NRE{pV0!w&Ju()NGC~lX;8yG?t%K$xc(Pv zsvN3^P`wqQri)O2v7P|GJ04U4H{Zf$9UfwVB~f}<$0C+kRwJL^d$jy~HikWGSr=aY9xXw9E<~fR zty9f=u-Jj8gjL-c=D1h*`@-$Ss@IUfYpieiRe^~D9+t}?#^zn6)W(@(f-EOX+CA(s z73vOp$!7Rfd$mmT)p>n2XcgZe;4}emmH^cjfwqc3Nso1eAlv*ssYLf1<#cCbmNTDa zqB$nILz&!Vm*-0oMv4g~_Pm6n9&=ydry^3d_AHb{`ihbJIPfB`c#-}V>*uo2<≻ KG4z=}mHrnZJI3Vz literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/controllers/actions/Move.class b/java/Graph Editor/bin/controllers/actions/Move.class new file mode 100644 index 0000000000000000000000000000000000000000..a56caf99cd1a2c156256531c863d2cc002c75346 GIT binary patch literal 1246 zcwTi<*-{fh6uq5H5)vl_LRdnG?2-)22!dM>i^8R1MM?`vp>IRdhOs6y)XW6<4d49) zAGFF~l@ES^|Kh8UmZv*o2rfxY-=*(4eeUi4_VdeEB3h&SF$ysnt2wssI+n#DZqB)H&fXQW(v@F;0v#-8(hyhTgL4j=p{9`7Y}A5g3OSe^@ttMgtyqO~a~!1O)r# z2aMPgM#&wp`G)OR4Xec?Z+|SEe{XKAV$)%isWhEBw>hrS_qqyUm4bwKP z1C*6};+KpRo1Y$Z45H|!X`B8QqgjKYOtHBM+oP^ySa6N#HDt&2p`^!Ch#ZN4^ZxEDE$SB!=l+<)eBkK4W>6zv*KNX`_B74ZOc z%fR*T`7T~TsgE{M-w`!+!rf!bFnj=4FqS>1<<|HkQ}i1bJ*@~hO=EOnytyciQv@rc z7@`pM;lm9`AM=;CKd`C54oE97gOtWPgyH^r0~yxKMUqbaLa6`-jh{ZzW{@S%h3P; literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/controllers/actions/Rename.class b/java/Graph Editor/bin/controllers/actions/Rename.class new file mode 100644 index 0000000000000000000000000000000000000000..8b6d473703b2360b81e6dc1546c476c45e82c7b0 GIT binary patch literal 1757 zcwU86O;a035Pc&F1Y(7;3u#zOWJk95MsNsCLkUQWLJq7NGGUE`#|;l_;-uihz#7&C(gcjgahTlB0BP5U z1|ET9nD$Rx&rQi;={bzDWZa!M>}%wltp&32{f68>QBfynNsO@%(QXs7$rKCe+zL;{$C064I)L3F z9G!f4t&NMGk1jd0_f2FrgE$}dpER-C;Ymyt;Q(!uQw jPs}dfi4N~=tjCe_abz-A|Mh>Nx4J@;ozNGd*USF^D)MV@ literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/interfaces/GraphFrame$1.class b/java/Graph Editor/bin/interfaces/GraphFrame$1.class new file mode 100644 index 0000000000000000000000000000000000000000..0a68b9c9e4b0b232c0443df662dfd2f860c31080 GIT binary patch literal 1940 zcwUWE&vz456#gEGOfx)a#nKiig+i=pD@;>Q=~mCt!ohP~b6mQ1;o7}hkM~VNX7Hq7a+2Kn^1bif_uYHnZ~r{|6~H9E z)Np{I-*y7&-4~|xja#1B*_!i2O{TLNk_V>lRW*?xM0vp3oY6IgFF522@S{T4EysqPGXQDRgpo-t$QXV)0-JB{MXi;jv<`UaGK#* z#~e9^ah9P=n1qMkPV8%3sQ%dSAK9e8P?S!6K9IF=i!{gE&?B9!0^i}t#Kk9djNx4k z<1f{}^c9u2#&I4O$WZy%4(KN{uY4H71V=V5aZ!O6IWEOFyQIJ?98+=TWd&a4xQ1K= zUSXK}f5)pkmTRoiS5Y{kB0W0g4ZN>`I&1J%JdO`k7bO+0GWd{VHlFL00`nYm@m!~s z_(vS`;ZjdFmwwDqh_kM0SY$Y9x=!G^)vEM-quE=&F=JVa)X{3yGRG&lO`Y+g5>(P_ z`=2?kR+3d23eL7cI(88&YBW|E(wW!NRn=}_o#Rt%FlfTE@|G&-*-U45)fg#8Zgf*6 ze~05Ub>w#P)JLD=o`x@IY+kcBhfwyVEO$ojS_$1SIjoliCpFw>80uu=P0|cx(?^LF zs)X<=Y@wx0DV%>2|Yy7G(9Us9~=J} zeC!F1{1|fHR9N_rTD^dy6mg0b`WAXa{22P0D(rhC6_*_v-$Vb{PvB2+s)57J=-e*; zj_{EN^u$w)?&8k~G}`3JT|AHQ%Z(S&^d7D^qnTYaBF4=)<5rvTO~hDeV5G(P1;veK zxby_2J*=&_7nGs}n{COZJ=|?GvJs=)z`3@hj3g^DNo8Xqv~iPc0?p-%V wS^ApRx5}cTE!b3;?XXx~1HJvj!xO{jDVqmjX{)HwZ<5;G!A{6wVPWa@FEtC~u>b%7 literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/interfaces/GraphFrame.class b/java/Graph Editor/bin/interfaces/GraphFrame.class new file mode 100644 index 0000000000000000000000000000000000000000..8e16aba31da71068e31c9ffacae306bdab34b144 GIT binary patch literal 6603 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 literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/models/GraphEdge.class b/java/Graph Editor/bin/models/GraphEdge.class new file mode 100644 index 0000000000000000000000000000000000000000..00399a94f1ea6ea1cda5a9349431aa7885de4eab GIT binary patch literal 1127 zcwU83&2AD=7(JI63Jet5Y57s8RNE@hL=s$9-89yiV7sWHNnH(a3!@a8VQ4h2OneEK zZgkTHCjKNY`T)L)uVB=3hsj6?#s%};?{d!h&OP7vU*9eP)KG~aB(QWkXv^NP`p~h? zx)0hN8G$aa`pi1Fsw3C#RS%j&>6}~5o)if82_6chpVp^o4e7Y@#g2e6lUU&Y zKr59S0{Sk21~kMIh#+b}U@?Itq5`S@z_m|aP6kMax~aO|m;0mBrgWZ6CYtp@%jz{O z$5y?6sk>c!sQ#PvP74cn?Y`~a7s!?7nk+YznM?vJh{k9pmp~W`~TW7x0NJqL#Sjirj=X158(;}M#qKt1}C9G14v+wx5qL=@b z`Qc#XwB(+x<|TtDZmSLAI)yZDTOg#K$y0=P+yif7>~>fMYpn7WM&%0)^9!~~3Gn5?gv;i@mRM^=c{pisK9{TbO=r9~^z%#=-1KN(J)Pn09e0B{P_5;s!RTS@c*U&g15s6{z^R%&plKZ17>5 e#BTj(1vhca*Q^FBpxbdEx8Plt=Eh(0P~|`HzODuU literal 0 HcwPel00001 diff --git a/java/Graph Editor/bin/models/GraphModel.class b/java/Graph Editor/bin/models/GraphModel.class new file mode 100644 index 0000000000000000000000000000000000000000..f0ed12c1c063504525652f935c76704605b87b95 GIT binary patch literal 5838 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 U{YZIlNs!(}P~$y36nRJg0TYr)`v3p{ literal 0 HcwPel00001 diff --git a/java/Graph Editor/src/app/Main.java b/java/Graph Editor/src/app/Main.java new file mode 100644 index 0000000..dd82445 --- /dev/null +++ b/java/Graph Editor/src/app/Main.java @@ -0,0 +1,41 @@ +package app; + +import controllers.*; +import models.*; +import interfaces.*; + +public class Main { + private GraphModel model; + private GraphFrame frame; + + private boolean twoWindows = false; + public Main(String[] args){ + if(args.length > 0){ + try{ + model = GraphModel.fromFile(args[0]); + }catch(Exception e){ + javax.swing.JOptionPane.showMessageDialog(null, "Error reading file!"); + model = new GraphModel(); + } + }else{ + model = new GraphModel(); + } + + frame = new GraphFrame(model); + new SelectionController(frame, model); + + if(twoWindows){ + //Test code voor 2 vensters! + GraphFrame frame2 = new GraphFrame(model); + new SelectionController(frame2, model); + } + } + + /** + * @param args + */ + public static void main(String[] args) { + new Main(args); + } + +} diff --git a/java/Graph Editor/src/controllers/SelectionController.java b/java/Graph Editor/src/controllers/SelectionController.java new file mode 100644 index 0000000..d7bb51c --- /dev/null +++ b/java/Graph Editor/src/controllers/SelectionController.java @@ -0,0 +1,274 @@ +package controllers; + +import interfaces.*; + +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; +import java.awt.event.MouseEvent; +import java.awt.event.MouseListener; +import java.awt.event.MouseMotionListener; + +import models.GraphModel; +import models.GraphVertex; + +import controllers.actions.AddEdge; +import controllers.actions.Move; +import controllers.actions.Rename; + +public class SelectionController implements MouseListener,MouseMotionListener,KeyListener{ + private GraphPanel object = null; + private GraphFrame frame = null; + private GraphVertex selectedObject = null; + private GraphModel model = null; + + private String typedStr; + private String originalName; + private boolean isChangingName; + private int OriginalNameLength; + + private boolean isAddingEdge; + private GraphVertex edgeObject1; + + + private int clickX = 0; + private int clickY = 0; + private int mouseClickX =0; + private int mouseClickY =0; + + private int mouseX = 0; + private int mouseY = 0; + + public int getMouseX(){ + return mouseX; + } + public int getMouseY(){ + return mouseY; + } + + + public SelectionController(GraphFrame frame, GraphModel model){ + isChangingName = false; + isAddingEdge = false; + this.frame = frame; + frame.setSelectionController(this); + frame.addKeyListener(this); + + setObject(frame.getPanel()); + setModel(model); + } + + public void doAddEdge() + { + if(isChangingName){ + this.doChangeName(); + } + isAddingEdge = true; + edgeObject1 = this.getSelectedVertex(); + } + + public boolean isAddingEdge(){ + return isAddingEdge; + } + + private void finishAddingEdge(){ + frame.addAction(new AddEdge(edgeObject1,this.getSelectedVertex(),this)); + isAddingEdge = false; + } + + public GraphModel getModel() { + return model; + } + public void setSelected(GraphVertex o) + { + frame.selectedObject(o != null); + if(isChangingName) + this.doChangeName(); + + if(selectedObject != null) + selectedObject.setSelected(false); + selectedObject = o; + + if(selectedObject != null){ + o.setSelected(true); + if(isAddingEdge){ + finishAddingEdge(); + } + }else{ + isAddingEdge = false; // Didn't click object, cancel action + } + } + public GraphVertex getSelectedVertex() + { + return selectedObject; + } + + public void removeSelected() + { + this.setSelected(null); + } + + + public void setObject(GraphPanel panel){ + if(object != null){ + object.removeMouseListener(this); + object.removeMouseMotionListener(this); + object.removeKeyListener(this); + } + object = panel; + object.addMouseListener(this); + object.addMouseMotionListener(this); + object.addKeyListener(this); + } + + public void setModel(GraphModel model){ + removeSelected(); + this.model = model; + } + + + // Called when the typing stops, Either Return has been pressed or a + // other object has been selected. + private void doChangeName(){ + selectedObject.setName(originalName); + this.frame.addAction(new Rename(typedStr,this)); + this.isChangingName = false; + } + + public GraphPanel getPanel() + { + return this.object; + } + + private void doCancelNameChange(){ + selectedObject.setName(this.originalName); + selectedObject.setWidth(this.OriginalNameLength); + isChangingName = false; + } + + + private void handleDoubleClick() + { + if(selectedObject != null){ + this.typedStr = ""; + isChangingName = true; + originalName = selectedObject.getName(); + OriginalNameLength = selectedObject.getWidth(); + } + } + + public void mouseClicked(MouseEvent arg0) { + if(arg0.getButton() == MouseEvent.BUTTON1){ + if(arg0.getClickCount() == 2){ + handleDoubleClick(); + }else{ + this.setSelected(model.getGraphByCoordinate(arg0.getX(), arg0.getY())); + } + } + } + + public void mouseEntered(MouseEvent arg0) { + } + + public void mouseExited(MouseEvent arg0) { + } + + public void mousePressed(MouseEvent arg0) { + this.setSelected(model.getGraphByCoordinate(arg0.getX(), arg0.getY())); + + clickX = arg0.getX(); + clickY = arg0.getY(); + + mouseClickX = arg0.getX(); + mouseClickY = arg0.getY(); + } + + public void mouseReleased(MouseEvent arg0) { + if(selectedObject != null){ + if(arg0.getX() != mouseClickX || arg0.getY() != mouseClickY){ + int newX = this.getSelectedVertex().getX(); + int newY = this.getSelectedVertex().getY(); + int orgX = newX - ( arg0.getX() - mouseClickX); + int orgY = newY - ( arg0.getY() - mouseClickY); + frame.addAction(new Move(orgX,orgY,newX,newY,this.getSelectedVertex())); + } + } + } + + @Override + public void mouseDragged(MouseEvent arg0) { + if(selectedObject != null){ + selectedObject.setX(selectedObject.getX() + (arg0.getX() - clickX)); + selectedObject.setY(selectedObject.getY() + (arg0.getY() - clickY)); + clickX = arg0.getX(); + clickY = arg0.getY(); + } + } + + @Override + public void mouseMoved(MouseEvent arg0) { + this.mouseX = arg0.getX(); + this.mouseY = arg0.getY(); + if(this.isAddingEdge){ + this.object.repaint(); + } + } + + private void setGraphText(GraphVertex o, String text){ + int width = 20 + this.getPanel().getDrawTextWidth(text); + o.setWidth(width); + o.setName(text); + } + + private void removeLastCharacterFromInput(){ + this.typedStr = this.typedStr.substring(0,this.typedStr.length()-1); + setGraphText(selectedObject,typedStr); + } + + private void handleKey(int key) + { + switch(key){ + case KeyEvent.VK_ENTER: + doChangeName(); + break; + case KeyEvent.VK_BACK_SPACE: + removeLastCharacterFromInput(); + break; + case KeyEvent.VK_ESCAPE: + doCancelNameChange(); + break; + default: + break; + } + } + + @Override + public void keyPressed(KeyEvent arg0) { + int key = arg0.getKeyCode(); + if(this.isChangingName && selectedObject != null){ + handleKey(key); + } + } + + @Override + public void keyReleased(KeyEvent arg0) { + + } + + private boolean acceptKeyForName(char a){ + String l = new String(); + l += a; + String acceptKeys = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_+=-`[]{};'\":<>?,./\\| «①∞⁵‰‽fl○"; + return acceptKeys.contains(l); + } + + @Override + public void keyTyped(KeyEvent arg0) { + // Todo Fix VK_ENTER + VK_ESCAPE + if(this.isChangingName && selectedObject != null && !arg0.isActionKey()){ + if(arg0.getKeyChar() != KeyEvent.CHAR_UNDEFINED && acceptKeyForName(arg0.getKeyChar())){ + this.typedStr += arg0.getKeyChar(); + setGraphText(selectedObject,typedStr); + } + } + } +} diff --git a/java/Graph Editor/src/controllers/actions/AddEdge.java b/java/Graph Editor/src/controllers/actions/AddEdge.java new file mode 100644 index 0000000..d228a23 --- /dev/null +++ b/java/Graph Editor/src/controllers/actions/AddEdge.java @@ -0,0 +1,44 @@ +package controllers.actions; +import javax.swing.undo.AbstractUndoableEdit; + +import models.GraphEdge; +import models.GraphVertex; +import controllers.*; + +public class AddEdge extends AbstractUndoableEdit { + private static final long serialVersionUID = -7929100929760152271L; + private GraphEdge o; + private SelectionController selectionController; + + public AddEdge(GraphVertex a, GraphVertex b,SelectionController selectionController) + { + o = new GraphEdge(a,b); + this.selectionController = selectionController; + redoAction(); + } + + private void redoAction() + { + selectionController.getModel().addEdge(o); + } + + public void redo() + { + super.redo(); + redoAction(); + } + + public void undo() + { + super.undo(); + selectionController.getModel().removeEdge(o); + } + + public boolean isSignificant(){ + return true; + } + + public String getPresentationName(){ + return "Edge toevoegen."; + } +} diff --git a/java/Graph Editor/src/controllers/actions/AddNode.java b/java/Graph Editor/src/controllers/actions/AddNode.java new file mode 100644 index 0000000..bf5590c --- /dev/null +++ b/java/Graph Editor/src/controllers/actions/AddNode.java @@ -0,0 +1,47 @@ +package controllers.actions; + +import javax.swing.undo.AbstractUndoableEdit; + +import controllers.SelectionController; + +import models.GraphVertex; + +public class AddNode extends AbstractUndoableEdit { + private static final long serialVersionUID = -7929100929760152271L; + private SelectionController selectionController; + private GraphVertex o; + + + + public AddNode(SelectionController selectionController) + { + this.selectionController = selectionController; + o = new GraphVertex(); + redoAction(); + } + private void redoAction(){ + selectionController.getModel().addGraph(o); + selectionController.setSelected(o); + } + + public void redo() + { + super.redo(); + redoAction(); + } + + public void undo() + { + super.undo(); + selectionController.getModel().removeGraph(o); + selectionController.removeSelected(); + } + + public boolean isSignificant(){ + return true; + } + + public String getPresentationName(){ + return "Vertex toevoegen."; + } +} diff --git a/java/Graph Editor/src/controllers/actions/DeleteNode.java b/java/Graph Editor/src/controllers/actions/DeleteNode.java new file mode 100644 index 0000000..c8ef85c --- /dev/null +++ b/java/Graph Editor/src/controllers/actions/DeleteNode.java @@ -0,0 +1,73 @@ +package controllers.actions; + +import javax.swing.undo.AbstractUndoableEdit; + +import models.GraphEdge; +import models.GraphVertex; +import controllers.*; + +public class DeleteNode extends AbstractUndoableEdit { + private static final long serialVersionUID = -7929100929760152271L; + private GraphVertex o; + private SelectionController selectionController; + private GraphEdge[] affectedEdges; + + public DeleteNode(SelectionController selectionController) + { + this.selectionController = selectionController; + this.o = selectionController.getSelectedVertex(); + redoAction(); + } + + private void removeAffectedEdges() + { + selectionController.getModel().removeEdge(affectedEdges); + } + + private void addAffectedEdges() + { + selectionController.getModel().addEdge(affectedEdges); + } + + private void getAffectedEdges(){ + GraphEdge[] arr = selectionController.getModel().getEdges(); + int count = 0; + for(int i=0; i < arr.length; i++) + if(arr[i].EdgeOf(o)) + count++; + affectedEdges = new GraphEdge[count]; + count = 0; + for(int i=0; i < arr.length; i++) + if(arr[i].EdgeOf(o)) + affectedEdges[count++] = arr[i]; + } + + private void redoAction() + { + getAffectedEdges(); + removeAffectedEdges(); + selectionController.removeSelected(); + selectionController.getModel().removeGraph(o); + } + + public void redo() + { + super.redo(); + redoAction(); + } + + public void undo() + { + super.undo(); + addAffectedEdges(); + selectionController.getModel().addGraph(o); + selectionController.setSelected(o); + } + public boolean isSignificant(){ + return true; + } + + public String getPresentationName(){ + return "Vertex verwijderen."; + } +} diff --git a/java/Graph Editor/src/controllers/actions/Move.java b/java/Graph Editor/src/controllers/actions/Move.java new file mode 100644 index 0000000..57d40b4 --- /dev/null +++ b/java/Graph Editor/src/controllers/actions/Move.java @@ -0,0 +1,45 @@ +package controllers.actions; +import javax.swing.undo.AbstractUndoableEdit; +import models.GraphVertex; + +public class Move extends AbstractUndoableEdit { + private static final long serialVersionUID = -7929100929760152271L; + private GraphVertex o; + private int originalX, originalY, newX, newY; + + public Move(int originalX, int originalY, + int newX, int newY, GraphVertex o) + { + this.o = o; + this.originalX = originalX; + this.originalY = originalY; + this.newX = newX; + this.newY = newY; + redoAction(); + } + + private void redoAction(){ + o.setX(newX); + o.setY(newY); + } + public void redo() + { + super.redo(); + redoAction(); + } + + public void undo() + { + super.undo(); + o.setX(originalX); + o.setY(originalY); + } + + public boolean isSignificant(){ + return true; + } + + public String getPresentationName(){ + return "Vertex verplaatsen."; + } +} diff --git a/java/Graph Editor/src/controllers/actions/Rename.java b/java/Graph Editor/src/controllers/actions/Rename.java new file mode 100644 index 0000000..0347b09 --- /dev/null +++ b/java/Graph Editor/src/controllers/actions/Rename.java @@ -0,0 +1,53 @@ +package controllers.actions; + +import javax.swing.undo.AbstractUndoableEdit; +import models.GraphVertex; +import controllers.*; + +public class Rename extends AbstractUndoableEdit { + private static final long serialVersionUID = -7929100929760152271L; + private GraphVertex o; + private String savedName; + private int originalWidth; + private SelectionController selectionController; + + public Rename(String name, SelectionController selectionController) + { + this.selectionController = selectionController; + this.savedName = name; + this.o = selectionController.getSelectedVertex(); + originalWidth = o.getWidth(); + this.redoAction(); + } + + private void redoAction(){ + int width = 20 + this.selectionController.getPanel().getDrawTextWidth(savedName); + if(width > o.getWidth()) + o.setWidth(width); + + String objectName = o.getName(); + o.setName(savedName); + savedName = objectName; + } + public void redo() + { + super.redo(); + redoAction(); + } + + public void undo() + { + super.undo(); + String objectName = o.getName(); + o.setName(savedName); + o.setWidth(originalWidth); + savedName = objectName; + } + public boolean isSignificant(){ + return true; + } + + public String getPresentationName(){ + return "Vertex Hernoemen."; + } +} diff --git a/java/Graph Editor/src/interfaces/GraphFrame.java b/java/Graph Editor/src/interfaces/GraphFrame.java new file mode 100644 index 0000000..739642e --- /dev/null +++ b/java/Graph Editor/src/interfaces/GraphFrame.java @@ -0,0 +1,201 @@ +package interfaces; + +import models.*; +import controllers.SelectionController; +import controllers.actions.*; +import java.awt.Event; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyEvent; +import java.io.File; + +import javax.swing.*; +import javax.swing.undo.*; + + +public class GraphFrame extends JFrame { + private static final long serialVersionUID = -7929100929760152271L; + private SelectionController selectionController; + private GraphPanel panel; + private UndoManager undoManager; + + private JMenuBar menubar; + private JMenu menuOptionFile; + private JMenu menuOptionEdit; + + private JMenuItem menuOptionFileOpen; + private JMenuItem menuOptionFileSave; + private JMenuItem menuOptionFileClose; + + private JMenuItem menuOptionEditUndo; + private JMenuItem menuOptionEditRedo; + private JMenuItem menuOptionEditAddNode; + private JMenuItem menuOptionEditAddEdge; + private JMenuItem menuOptionEditRemoveNode; + + private ActionListener actionListener; + + public GraphFrame(GraphModel model){ + + this.setTitle("Graph Editor"); + this.setSize(500, 500); + menubar = new JMenuBar(); + this.setFocusable(true); + + menuOptionFile = new JMenu("File"); + menuOptionFile.setMnemonic(KeyEvent.VK_F); + menuOptionEdit = new JMenu("Edit"); + menuOptionEdit.setMnemonic(KeyEvent.VK_E); + + menuOptionFileClose = new JMenuItem("Close program",KeyEvent.VK_C); + menuOptionFileClose.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_E, Event.CTRL_MASK)); + + menuOptionFileOpen = new JMenuItem("Openen",KeyEvent.VK_O); + menuOptionFileOpen.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, Event.CTRL_MASK)); + + menuOptionEditUndo = new JMenuItem("Ongedaan maken",KeyEvent.VK_Z); + menuOptionEditUndo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK)); + + menuOptionEditAddNode = new JMenuItem("Knoop toevoegen",KeyEvent.VK_N); + menuOptionEditAddNode.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, Event.CTRL_MASK)); + + menuOptionEditAddEdge = new JMenuItem("Kant toevoegen",KeyEvent.VK_M); + menuOptionEditAddEdge.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_M, Event.CTRL_MASK)); + + menuOptionEditRemoveNode = new JMenuItem("Delete Node",KeyEvent.VK_D); + menuOptionEditRemoveNode.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE,Event.SHIFT_MASK)); + + menuOptionEditRedo = new JMenuItem("Herhalen",KeyEvent.VK_R); + menuOptionEditRedo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,Event.CTRL_MASK)); + + menuOptionFileSave = new JMenuItem("Opslaan",KeyEvent.VK_S); + menuOptionFileSave.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,Event.CTRL_MASK)); + + actionListener = new ActionListener(){ + public void actionPerformed(ActionEvent arg0) { + if(arg0.getSource() == menuOptionFileSave) + saveFile(); + else if(arg0.getSource() == menuOptionFileClose) + System.exit(0); + else if(arg0.getSource() == menuOptionFileOpen) + openFile(); + else if(arg0.getSource() == menuOptionEditUndo) { + undoManager.undo(); + notifyUndoManagerChanged(); + } else if (arg0.getSource() == menuOptionEditRedo) { + undoManager.redo(); + notifyUndoManagerChanged(); + } else if(arg0.getSource() == menuOptionEditAddNode) { + GraphFrame.this.undoManager.addEdit(new AddNode(GraphFrame.this.selectionController)); + notifyUndoManagerChanged(); + } else if(arg0.getSource() == menuOptionEditAddEdge) { + selectionController.doAddEdge(); + notifyUndoManagerChanged(); + } else if(arg0.getSource() == menuOptionEditRemoveNode) { + undoManager.addEdit(new DeleteNode(selectionController)); + notifyUndoManagerChanged(); + } + } + }; + + menuOptionFileOpen.addActionListener(actionListener); + menuOptionFileSave.addActionListener(actionListener); + menuOptionFileClose.addActionListener(actionListener); + + menuOptionEditAddNode.addActionListener(actionListener); + menuOptionEditAddEdge.addActionListener(actionListener); + menuOptionEditUndo.addActionListener(actionListener); + menuOptionEditRedo.addActionListener(actionListener); + menuOptionEditRemoveNode.addActionListener(actionListener); + + menuOptionFile.add(menuOptionFileOpen); + menuOptionFile.add(menuOptionFileSave); + menuOptionFile.addSeparator(); + menuOptionFile.add(menuOptionFileClose); + + menuOptionEdit.add(menuOptionEditAddNode); + menuOptionEdit.add(menuOptionEditAddEdge); + menuOptionEdit.addSeparator(); + menuOptionEdit.add(menuOptionEditUndo); + menuOptionEdit.add(menuOptionEditRedo); + menuOptionEdit.add(menuOptionEditRemoveNode); + + menubar.add(menuOptionFile); + menubar.add(menuOptionEdit); + setJMenuBar(menubar); + + panel = new GraphPanel(model); + add(panel); + undoManager = new UndoManager(); + this.notifyUndoManagerChanged(); + + setVisible(true); + } + + private void openFile() + { + final JFileChooser fc = new JFileChooser(); + int returnVal = fc.showOpenDialog(this); + if(returnVal == JFileChooser.APPROVE_OPTION){ + doOpenFile(fc.getSelectedFile()); + } + } + + private void notifyUndoManagerChanged(){ + menuOptionEditRedo.setEnabled(undoManager.canRedo()); + menuOptionEditUndo.setEnabled(undoManager.canUndo()); + + menuOptionEditRedo.setText(this.undoManager.getRedoPresentationName()); + menuOptionEditUndo.setText(this.undoManager.getUndoPresentationName()); + } + + + private void doOpenFile(File f) { + try { + GraphModel model = GraphModel.fromFile(f); + panel.setModel(model); + this.undoManager.discardAllEdits(); + notifyUndoManagerChanged(); + } catch (Exception e) { + JOptionPane.showMessageDialog(this, + "An error occured trying to read the input file. \r\n" + e.getMessage(), + "Error", JOptionPane.ERROR_MESSAGE); + } + } + + private void saveFile() + { + final JFileChooser fc = new JFileChooser(); + int returnVal = fc.showSaveDialog(this); + if(returnVal == JFileChooser.APPROVE_OPTION){ + File file = fc.getSelectedFile(); + try{ + panel.getModel().writeToFile(file); + }catch(Exception e){ + JOptionPane.showMessageDialog(this, + "An error occured trying to save the current state to a file. \r\n" + e.getMessage() , + "Error", JOptionPane.ERROR_MESSAGE); + } + } + } + + public void addAction(UndoableEdit action){ + undoManager.addEdit(action); + notifyUndoManagerChanged(); + } + + public void selectedObject(boolean selected) { + menuOptionEditAddEdge.setEnabled(selected); + menuOptionEditRemoveNode.setEnabled(selected); + } + + public void setSelectionController(SelectionController s) { + selectionController = s; + this.getPanel().setSelectionController(s); + } + public GraphPanel getPanel() + { + return panel; + } + +} diff --git a/java/Graph Editor/src/interfaces/GraphPanel.java b/java/Graph Editor/src/interfaces/GraphPanel.java new file mode 100644 index 0000000..921bb08 --- /dev/null +++ b/java/Graph Editor/src/interfaces/GraphPanel.java @@ -0,0 +1,117 @@ +package interfaces; +import java.awt.Color; +import java.awt.FontMetrics; +import java.awt.Graphics; +import java.util.Observable; +import java.util.Observer; + +import javax.swing.*; + +import controllers.SelectionController; +import models.GraphEdge; +import models.GraphModel; +import models.GraphVertex; + +public class GraphPanel extends JPanel implements Observer{ + private static final long serialVersionUID = 1388592199136335514L; + private GraphModel model; + private SelectionController selectionController; + + protected GraphPanel(GraphModel model){ + this.setSize(500, 400); + this.setBackground(Color.BLUE); + this.model = model; + model.addObserver(this); + } + + public void setSelectionController(SelectionController controller) + { + this.selectionController = controller; + } + + public void setModel(GraphModel model){ + if(this.model != null){ + this.model.deleteObserver(this); + } + this.model = model; + model.addObserver(this); + selectionController.setModel(model); + repaint(); + } + + public GraphModel getModel(){ + return model; + } + + public int getDrawTextWidth(String in) + { + FontMetrics fm = this.getFontMetrics(this.getFont()); + int width = fm.stringWidth(in); + return width; + } + + + private void fillBackGround(Graphics g){ + g.setColor(this.getBackground()); + g.fillRect(0, 0, getWidth(), getHeight()); + } + + private void drawEdges(Graphics g){ + GraphEdge[] edges = model.getEdges(); + g.setColor(Color.cyan); + for(int i=0; i < edges.length; i++){ + GraphEdge edge = edges[i]; + GraphVertex[] vertexes = edge.getNodes(); + g.drawLine(vertexes[0].getX() + (vertexes[0].getWidth()/2), + vertexes[0].getY() + (vertexes[0].getHeight()/2), + vertexes[1].getX() + (vertexes[1].getWidth()/2), + vertexes[1].getY() + (vertexes[0].getHeight()/2)); + } + } + + private void drawVertexLine(Graphics g) + { + // Draw Adding vertex line if needed + if(this.selectionController != null && this.selectionController.isAddingEdge()){ + + g.setColor(Color.red); + GraphVertex origen = this.selectionController.getSelectedVertex(); + g.drawLine( origen.getX() + (origen.getWidth()/2), + origen.getY() + (origen.getHeight()/2), + selectionController.getMouseX(),selectionController.getMouseY()); + } + } + + private void drawVertixes(Graphics g) + { + GraphVertex[] objects = model.getVertexes(); + for(int i=0; i < objects.length; i++){ + GraphVertex o = objects[i]; + g.setColor(Color.white); + g.fillRect(o.getX(), o.getY(), o.getWidth(), o.getHeight()); + if(o.isSelected()){ + g.setColor(Color.red); + }else{ + g.setColor(Color.black); + } + g.drawRect(o.getX(), o.getY(),o.getWidth(), o.getHeight()); + g.setColor(Color.black); + g.drawString(o.getName(), o.getX()+10, o.getY()+25); + } + } + + public void paintComponent(Graphics g) + { + fillBackGround(g); + drawEdges(g); + drawVertexLine(g); + drawVertixes(g); + } + + @Override + public void update(Observable arg0, Object arg1) { + if(arg0 == model){ + repaint(); + } + } +} diff --git a/java/Graph Editor/src/models/GraphEdge.java b/java/Graph Editor/src/models/GraphEdge.java new file mode 100644 index 0000000..bbb3a51 --- /dev/null +++ b/java/Graph Editor/src/models/GraphEdge.java @@ -0,0 +1,42 @@ +package models; + +import java.util.Observable; + +public class GraphEdge extends Observable{ + private GraphVertex[] nodes; + + public synchronized void setChanged() { + super.setChanged(); + notifyObservers(); + } + + public GraphEdge(GraphVertex ... nodes){ + this.nodes = nodes; + } + + public GraphEdge(){ + } + + public boolean EdgeOf(GraphVertex o){ + for(int i=0; i < nodes.length; i++) + if(nodes[i] == o) + return true; + return false; + } + + protected GraphVertex getEdge(boolean src){ + if(src) + return nodes[0]; + else + return nodes[1]; + } + + public void setNodes(GraphVertex[] nodes){ + this.nodes = nodes; + setChanged(); + } + + public GraphVertex[] getNodes(){ + return nodes; + } +} diff --git a/java/Graph Editor/src/models/GraphModel.java b/java/Graph Editor/src/models/GraphModel.java new file mode 100644 index 0000000..4aec25f --- /dev/null +++ b/java/Graph Editor/src/models/GraphModel.java @@ -0,0 +1,155 @@ +package models; + +import java.io.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Observable; +import java.util.Observer; +import java.util.Scanner; + + +public class GraphModel extends Observable implements Observer{ + private List edges; + private List vertexes; + + + public GraphVertex[] getVertexes(){ + GraphVertex[] a = new GraphVertex[vertexes.size()]; + return vertexes.toArray(a); + } + public GraphEdge[] getEdges(){ + GraphEdge[] a = new GraphEdge[edges.size()]; + return edges.toArray(a); + } + + public GraphModel(){ + edges = new ArrayList(); + vertexes = new ArrayList(); + } + + public synchronized void setChanged() { + super.setChanged(); + notifyObservers(); + } + + public void addEdge(GraphEdge ... edge){ + for(int i=0; i < edge.length; i++){ + edges.add(edge[i]); + edge[i].addObserver(this); + } + setChanged(); + } + + public void addGraph(GraphVertex ... vertex){ + for(int i=0; i < vertex.length; i++){ + vertexes.add(vertex[i]); + vertex[i].addObserver(this); + } + setChanged(); + } + + public void removeEdge(GraphEdge ... edge){ + for(int i=0; i < edge.length; i++){ + edges.remove(edge[i]); + edge[i].deleteObserver(this); + } + setChanged(); + } + public void removeGraph(GraphVertex ... vertex){ + for(int i=0; i < vertex.length; i++){ + vertexes.remove(vertex[i]); + vertex[i].deleteObserver(this); + } + setChanged(); + } + + public GraphVertex getGraphByCoordinate(int x, int y){ + for(int i=0; i < vertexes.size(); i++){ + if(vertexes.get(i).isAt(x, y)) + return vertexes.get(i); + } + return null; + } + + public void saveModel() throws IOException { + System.out.println("Saving model..."); + PrintWriter pw = new PrintWriter(new FileWriter("file.graph")); + pw.println(vertexes.size() + "," + edges.size()); + for(int i=0; i < vertexes.size(); i++) { + pw.println(vertexes.get(i).getX() +","+ vertexes.get(i).getY() +","+ vertexes.get(i).getHeight() +","+ vertexes.get(i).getWidth() +","+ vertexes.get(i).getName()); + } + for(int i=0; i < edges.size(); i++) { + + } + } + + @Override + public void update(Observable arg0, Object arg1) { + if(vertexes.contains(arg0) || edges.contains(arg0)){ + this.setChanged(); + } + } + + + //File IO Code + public void writeToFile(File file) throws Exception + { + OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file), "UTF-8"); + + out.write(vertexes.size() + " " + edges.size() + "\r\n"); + for(int i=0; i < vertexes.size(); i++) + out.write(vertexes.get(i).getX() + " " + vertexes.get(i).getY() + " " + vertexes.get(i).getWidth() + " " + vertexes.get(i).getHeight() +" "+ vertexes.get(i).getName() + "\r\n"); + for(int i=0; i < edges.size(); i++) + out.write(vertexes.indexOf(edges.get(i).getEdge(true)) + " " + vertexes.indexOf(edges.get(i).getEdge(false)) + "\r\n"); + out.close(); + } + + + + private static GraphVertex[] readVertexes(int count, Scanner s) + { + GraphVertex[] vertexes = new GraphVertex[count]; + for(int i=0; i < count; i++) + vertexes[i] = new GraphVertex(s); + return vertexes; + } + + + public static GraphModel fromFile(File file) throws Exception + { + GraphModel model = new GraphModel(); + Scanner scanner = new Scanner(file, "UTF-8"); + + int numKnopen = scanner.nextInt(); + int numKanten = scanner.nextInt(); + scanner.nextLine(); + + GraphVertex[] vertexes = readVertexes(numKnopen,scanner); + + model.addEdge(readKanten(scanner, numKanten, vertexes)); + model.addGraph(vertexes); + + return model; + } + private static GraphEdge[] readKanten(Scanner scanner, int numKanten, + GraphVertex[] vertexes) { + GraphEdge[] edges = new GraphEdge[numKanten]; + for (int i = 0; i < numKanten; i++) { + int obj1 = scanner.nextInt(); + int obj2 = scanner.nextInt(); + edges[i] = new GraphEdge(vertexes[obj1], vertexes[obj2]); + if(i != (numKanten-1)){ + scanner.nextLine(); + } + } + return edges; + } + + + public static GraphModel fromFile(String fileName) throws Exception + { + File file = new File(fileName); + return fromFile(file); + } + +} diff --git a/java/Graph Editor/src/models/GraphVertex.java b/java/Graph Editor/src/models/GraphVertex.java new file mode 100644 index 0000000..9f582df --- /dev/null +++ b/java/Graph Editor/src/models/GraphVertex.java @@ -0,0 +1,98 @@ +package models; + +import java.awt.Rectangle; +import java.util.Observable; +import java.util.Scanner; + +public class GraphVertex extends Observable{ + private String name; + private Rectangle shape; + private boolean selected; + + public boolean isSelected(){ + return selected; + } + + + public GraphVertex(String name){ + this.name = name; + shape = new Rectangle(); + shape.height = 50; + shape.width = 100; + } + + public GraphVertex(Scanner s){ + shape = new Rectangle(); + this.shape.x = s.nextInt(); + this.shape.y = s.nextInt(); + this.shape.width = s.nextInt(); + this.shape.height = s.nextInt(); + this.name = s.nextLine(); + } + + public GraphVertex(){ + this("default."); + } + + public int getX(){ + return shape.x; + } + + public int getY(){ + return shape.y; + } + + public void setX(int x){ + shape.x = x; + setChanged(); + } + + public void setY(int y){ + shape.y = y; + setChanged(); + } + + public synchronized void setChanged() { + super.setChanged(); + notifyObservers(); + } + + public int getWidth(){ + return shape.width; + } + + public void setWidth(int w){ + shape.width = w; + setChanged(); + } + + public void setHeight(int h){ + shape.height = h; + setChanged(); + } + + public int getHeight(){ + return shape.height; + } + + protected boolean isAt(int x, int y){ + if(x >= shape.x && x <= shape.x + shape.width) + if(y >= shape.y && y <= shape.y + shape.height) + return true; + return false; + } + + public void setSelected(boolean flag){ + selected = flag; + setChanged(); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + setChanged(); + } +} -- 2.11.4.GIT