Show ClientCommunicator.java syntax highlighted
package persister.distributed;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Timestamp;
import java.util.HashMap;
import javax.swing.event.EventListenerList;
import persister.AgilePlannerClient;
import persister.AsynchronousPersister;
import persister.Backlog;
import persister.ConnectionFailedException;
import persister.ForbiddenOperationException;
import persister.IndexCardNotFoundException;
import persister.Iteration;
import persister.Keystroke;
import persister.Message;
import persister.MouseMove;
import persister.NotConnectedException;
import persister.PlannerDataChangeListener;
import persister.PlannerUIChangeListener;
import persister.Project;
import persister.StoryCard;
import persister.UIEventPropagator;
import persister.impl.data.BacklogDataObject;
import persister.impl.data.EventDataObject;
import persister.impl.data.IterationDataObject;
import persister.impl.data.MessageDataObject;
import persister.impl.data.ProjectDataObject;
import persister.impl.data.StoryCardDataObject;
import persister.network.NetworkClient;
public class ClientCommunicator implements AsynchronousPersister,
AgilePlannerClient, UIEventPropagator, CallbackCommunicator {
private static final long serialVersionUID = -6487839317162366027L;
private static final int NUM_SKIP_MOUSE_MOVES = 5;
private static final int PORT = 5050;
private Project rootproject;
private EventListenerList plannerDataChangeListeners;
private EventListenerList plannerUIChangeListeners;
// private Hashtable<Long, AbstractRoot> lookup;
private long clientid = 0;
private int mmcounter = 0;
private boolean saveAsRequested = false;
private boolean loadRequested = false;
private boolean getProjectFilesRequested = false;
private Timestamp start = new Timestamp(0);
private Timestamp end = new Timestamp(Long.MAX_VALUE);
private NetworkClient nc;
public ClientCommunicator(String url, int port) throws IOException {
this.rootproject = new ProjectDataObject();
this.rootproject.setId(1);
this.plannerDataChangeListeners = new EventListenerList();
this.plannerUIChangeListeners = new EventListenerList();
// this.lookup = new Hashtable<Long, AbstractRoot>();
if (url != null)
nc = new NetworkClient(url, port, this);
}
/***************************************************************************
* CONNECTION *
**************************************************************************/
public void connect() throws ConnectionFailedException {
Message msg = new MessageDataObject(Message.CONNECT);
try {
nc.send(msg);
} catch (IOException e) {
throw new ConnectionFailedException("Could not send connect message to server");
}
}
public void connectForProjectNames(String hostname) {
try {
if (!connected())
connect();
// if(connect(hostname)){
getProjectFilesRequested = true;
try {
getProjectNames();
} catch (NotConnectedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// connect(hostname, projectSelected());
// }
} catch (ConnectionFailedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//
}
// public boolean connect(String hostname, String projectName) throws
// ConnectionFailedException
// {
// connect(hostname);
// try {
// this.load(projectName);
// } catch (NotConnectedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// return false;
// }
public boolean connected() {
if (this.nc == null) {
return false;
} else {
return true;
}
}
public boolean disconnect() /* throws RemoteException */{
try {
sendMessage(new MessageDataObject(Message.DELETE_REMOTE_MOUSE));
// GT.disconnect();
// this.server = null;
return true;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
}
}
/***************************************************************************
* LOAD AND SAVE *
**************************************************************************/
public void getProjectNames() throws NotConnectedException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.GET_PROJECT_NAMES);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void load(String projectName) throws NotConnectedException {
if (connected()) {
loadRequested = true;
MessageDataObject message = new MessageDataObject(this.clientid,
Message.LOAD, projectName);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void load(String projectName, Timestamp start, Timestamp end)
throws NotConnectedException {
if (connected()) {
Object[] msg = { projectName, start, end };
MessageDataObject message = new MessageDataObject(this.clientid,
Message.TIMEBOX_LOAD, msg);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
// public boolean save() throws NotConnectedException {
// if (connected()) {
// MessageDataObject message = new MessageDataObject(this.clientid,
// Message.SAVE);
//
// this.server.send(message);
// return true;
// } else {
// throw new NotConnectedException("Server unreachable!");
// }
// }
public boolean saveAs(String fileName) throws NotConnectedException {
if (connected()) {
saveAsRequested = true;
MessageDataObject message = new MessageDataObject(this.clientid,
Message.SAVE_AS, fileName);
sendMessage(message);
return true;
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void upload(String fileStr) throws NotConnectedException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UPLOAD, readFromFile(fileStr));
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public String[] readFromFile(String localPath) {
String[] fileStr = new String[2];
fileStr[0] = "";
fileStr[1] = "";
File file = new File(localPath);
fileStr[0] = file.getName();
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String str = "";
while ((str = in.readLine()) != null) {
fileStr[1] = fileStr[1] + str;
}
in.close();
} catch (IOException e) {
}
return fileStr;
}// end method
/***************************************************************************
* CREATE *
**************************************************************************/
public void createBacklog(int width, int height, int locationX,
int locationY) throws NotConnectedException,
ForbiddenOperationException {
if (connected()) {
if (this.rootproject.getBacklog() != null) {
throw new ForbiddenOperationException(
"Only one Backlog allowed per Project!", rootproject
.getBacklog().getId());
} else {
if (connected()) {
BacklogDataObject backlog = new BacklogDataObject(width,
height, locationX, locationY);
MessageDataObject message = new MessageDataObject(
this.clientid, Message.CREATE_BACKLOG, backlog);
// this.server.addMessage(message);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void createIteration(String name, String description, int width,
int height, int locationX, int locationY, float availableEffort,
Timestamp startDate, Timestamp endDate)
throws NotConnectedException {
if (connected()) {
IterationDataObject iteration = new IterationDataObject(name,
description, width, height, locationX, locationY,
availableEffort, startDate, endDate);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.CREATE_ITERATION, iteration);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void createProject(String name) throws NotConnectedException {
if (connected()) {
ProjectDataObject project = new ProjectDataObject(name);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.CREATE_PROJECT, project);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void createStoryCard(String name, String description, int width,
int height, int locationX, int locationY, long parentid,
float bestCaseEstimate, float mostlikelyEstimate,
float worstCaseEstimate, float actualEffort, String status)
throws NotConnectedException, IndexCardNotFoundException {
if (connected()) {
StoryCardDataObject storycard = new StoryCardDataObject(parentid,
name, description, width, height, locationX, locationY,
bestCaseEstimate, mostlikelyEstimate, worstCaseEstimate,
actualEffort, status);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.CREATE_STORYCARD, storycard);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* DELETE *
**************************************************************************/
public void deleteBacklog(long id) throws NotConnectedException,
ForbiddenOperationException {
throw new ForbiddenOperationException(
"You cannot delete the Backlog without deleting the Project!");
}
public void deleteIteration(long id) throws NotConnectedException,
IndexCardNotFoundException {
if (connected()) {
//Iteration iteration = this.findIterationById(id);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.DELETE_ITERATION, id);
this.fireDeletedIterationEvent(id);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
// public void deleteProject(long id) throws NotConnectedException {
// if (connected()) {
// MessageDataObject message = new MessageDataObject(this.clientid,
// Message.DELETE_PROJECT, this.rootproject);
//
// this.fireDeletedProjectEvent(this.rootproject);
//
// this.server.send(message);
// } else {
// throw new NotConnectedException("Server unreachable!");
// }
// }
public void deleteStoryCard(long id) throws NotConnectedException,
IndexCardNotFoundException {
if (connected()) {
//StoryCard storycard = this.findStoryCardById(id);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.DELETE_STORYCARD, id);
this.fireDeletedStoryCardEvent(id);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* UNDELETE *
**************************************************************************/
// public void undeleteBacklog(long id, long parentid, int width, int height,
// int locationX, int locationY) throws NotConnectedException,
// ForbiddenOperationException {
// if (this.rootproject.getBacklog() != null) {
// throw new ForbiddenOperationException(
// "Only one Backlog allowed per Project!", rootproject
// .getBacklog().getId());
// } else {
// if (connected()) {
// BacklogDataObject backlog = new BacklogDataObject(id, parentid,
// width, height, locationX, locationY);
//
// MessageDataObject message = new MessageDataObject(
// this.clientid, Message.UNDELETE_BACKLOG, backlog);
//
// // this.server.addMessage(message);
//
// this.fireUndeletedBacklogEvent(backlog);
//
// this.server.send(message);
// } else {
// throw new NotConnectedException("Server unreachable!");
// }
// }
// }
//
public void undeleteIteration(Iteration iteration) throws NotConnectedException,
IndexCardNotFoundException, ForbiddenOperationException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UNDELETE_ITERATION, iteration);
this.fireUndeletedIterationEvent(iteration);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
// public void undeleteProject(long id, String name)
// throws NotConnectedException {
// if (connected()) {
// ProjectDataObject project = new ProjectDataObject(name);
// project.setId(id);
//
// MessageDataObject message = new MessageDataObject(this.clientid,
// Message.UNDELETE_PROJECT, project);
//
// this.fireUndeletedProjectEvent(project);
//
// this.server.send(message);
// } else {
// throw new NotConnectedException("Server unrechable!");
// }
// }
public void undeleteStoryCard(StoryCard storyCard)
throws NotConnectedException, IndexCardNotFoundException,
ForbiddenOperationException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UNDELETE_STORYCARD, storyCard);
this.fireUndeletedStoryCardEvent(storyCard);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* USER INTERFACE *
**************************************************************************/
public void moveMouse(String name, int x, int y)
throws NotConnectedException {
if (this.mmcounter == NUM_SKIP_MOUSE_MOVES) {
this.mmcounter = 0;
if (connected()) {
EventDataObject mm = new EventDataObject(this.clientid, name,
x, y);
MessageDataObject message = new MessageDataObject(
this.clientid, Message.MOUSE_MOVE, mm);
// this.server.addMessage(message);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
} else {
this.mmcounter++;
}
}
public void bringToFront(long id) throws NotConnectedException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.BRING_TO_FRONT, id);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void deleteRemoteMouse(long id) throws NotConnectedException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.DELETE_REMOTE_MOUSE, id);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* UPDATE BACKLOG *
**************************************************************************/
public void updateBacklog(Backlog backlog)
throws NotConnectedException, IndexCardNotFoundException {
if (connected()) {
// BacklogDataObject backlog = (BacklogDataObject) ((BacklogDataObject) this.rootproject
// .getBacklog()).clone();
//
// backlog.setWidth(width);
// backlog.setHeight(height);
this.fireUpdatedBacklogEvent(backlog);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UPDATE_BACKLOG, backlog);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* UPDATE ITERATION *
**************************************************************************/
public void updateIteration(Iteration iteration)
throws NotConnectedException, IndexCardNotFoundException {
if (connected()) {
// IterationDataObject iteration = (IterationDataObject) this
// .findIterationById(id).clone();
// iteration.setAvailableEffort(availableEffort);
this.fireUpdatedIterationEvent(iteration);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UPDATE_ITERATION, iteration);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* UPDATE STORYCARD *
**************************************************************************/
public void updateStoryCard(StoryCard sc)
throws NotConnectedException, IndexCardNotFoundException {
if (connected()) {
// StoryCardDataObject storycard = (StoryCardDataObject) this
// .findStoryCardById(id).clone();
// storycard.setActualEffort(actualEffort);
this.fireUpdatedStoryCardEvent(sc);
MessageDataObject message = new MessageDataObject(this.clientid,
Message.UPDATE_STORYCARD, sc);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* UPDATE PROJECT *
**************************************************************************/
// TODO check if it is really necessary to implement that method for planner
// as project is not displayed
// public void updateProjectName(long id, String name)
// throws NotConnectedException, IndexCardNotFoundException {
// if (connected()) {
// if (this.rootproject.getId() == id) {
//
// this.rootproject.setName(name);
// this.fireUpdatedProjectNameEvent(this.rootproject);
//
// MessageDataObject message = new MessageDataObject(
// this.clientid, Message.UPDATE_PROJECT_NAME, name);
// this.server.send(message);
//
// } else {
// throw new IndexCardNotFoundException("Project with id " + id
// + " not found!", id);
// }
// } else {
// throw new NotConnectedException("Server unreachble!");
// }
//
// }
/***************************************************************************
* MOVE STORYCARD BETWEEN PARENTS *
**************************************************************************/
public void moveStoryCardToNewParent(StoryCard sc, long newparentid, int locationX, int locationY)
throws IndexCardNotFoundException, NotConnectedException {
if (connected()) {
HashMap<String, String> additionalData = new HashMap();
additionalData.put("newparentid", String.valueOf(newparentid));
additionalData.put("locationX", String.valueOf(locationX));
additionalData.put("locationY", String.valueOf(locationY));
MessageDataObject message = new MessageDataObject(this.clientid,
Message.MOVE_STORYCARD_TO_NEW_PARENT, sc, additionalData);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
/***************************************************************************
* PLANNERDATACHANGELISTENER *
**************************************************************************/
public void addPlannerDataChangeListener(PlannerDataChangeListener listener) {
this.plannerDataChangeListeners.add(PlannerDataChangeListener.class,
listener);
}
public void removePlannerDataChangeListener(
PlannerDataChangeListener listener) {
this.plannerDataChangeListeners.remove(PlannerDataChangeListener.class,
listener);
}
/***************************************************************************
* PLANNERUICHANGELISTENER *
**************************************************************************/
public void addPlannerUIChangeListener(PlannerUIChangeListener listener) {
this.plannerUIChangeListeners.add(PlannerUIChangeListener.class,
listener);
}
public void removePlannerUIChangeListener(PlannerUIChangeListener listener) {
this.plannerUIChangeListeners.remove(PlannerUIChangeListener.class,
listener);
}
/** ************************************************************************* */
private void fireGotProjectNamesFromServerEvent(String[] strings) {
Object[] listeners = plannerUIChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerUIChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerUIChangeListener) listeners[i + 1])
.gotProjectsNameFromServerListener(strings);
System.out.println("firedGotProjectEvent");
}
}
}
/***************************************************************************
* FIRE CREATE EVENTS *
**************************************************************************/
private void fireCreatedBacklogEvent(Backlog backlog) {
// if (this.rootproject.getBacklog() == null) {
// this.rootproject.setBacklog(backlog);
// //this.lookup.put(backlog.getId(), backlog);
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.createdBacklog(backlog);
}
}
}
private void fireCreatedIterationEvent(Iteration iteration) {
// if (!this.lookup.containsKey(iteration.getId())) {
//
// this.rootproject.addIteration(iteration);
// this.lookup.put(iteration.getId(), iteration);
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.createdIteration(iteration);
}
}
}
private void fireCreatedProjectEvent(Project project) {
// this.rootproject = project;
// this.lookup.clear();
//
// // load cards into lookup
// ArrayList<Iteration> iterations = new ArrayList<Iteration>();
// iterations.addAll(project.getIterationChildren());
// Backlog backlog = project.getBacklog();
// for (Iteration iter : iterations) {
// if ((iter.getEndDate().after(this.start) && iter.getEndDate()
// .before(this.end))
// || (iter.getStartDate().after(this.start) && (iter
// .getStartDate().before(this.end)))) {
// lookup.put(iter.getId(), iter);
//
// if (!(iter.getStoryCardChildren().isEmpty())) {
// for (StoryCard storycard : iter.getStoryCardChildren()) {
// lookup.put(storycard.getId(), storycard);
// }// end of storycard for
// }// end of
// }// end of
// }// end of for
//
// if (backlog != null) {
// lookup.put(backlog.getId(), backlog);
// if (!(backlog.getStoryCardChildren().isEmpty())) {
// for (StoryCard storycard : backlog.getStoryCardChildren()) {
// lookup.put(storycard.getId(), storycard);
// }
// }
// }
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.createdProject(project);
}
}
}
private void fireCreatedStoryCardEvent(StoryCard storycard) {
// if (!this.lookup.containsKey(storycard.getId())) {
// try {
// this.findParentCardById(storycard.getParent()).addStoryCard(
// storycard);
// } catch (IndexCardNotFoundException e) {
// System.out.println("Unable to add incoming StoryCard!\n\n"
// + storycard.toString());
// e.printStackTrace();
// }
// this.lookup.put(storycard.getId(), storycard);
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.createdStoryCard(storycard);
}
}
}
/***************************************************************************
* FIRE DELETE EVENTS *
**************************************************************************/
// private void fireDeletedBacklogEvent(Backlog backlog) {
//// this.rootproject.setBacklog(null);
//// this.lookup.remove(backlog.getId());
//
// Object[] listeners = plannerDataChangeListeners.getListenerList();
// // loop through each listener and pass on the event if needed
// int numListeners = listeners.length;
// for (int i = 0; i < numListeners; i += 2) {
// if (listeners[i] == PlannerDataChangeListener.class) {
// // pass the event to the listeners event dispatch method
// ((PlannerDataChangeListener) listeners[i + 1])
// .deletedBacklog(backlog);
// }
// }
// }
private void fireDeletedIterationEvent(long id) {
// this.rootproject.removeIteration(iteration);
// this.lookup.remove(iteration.getId());
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.deletedIteration(id);
}
}
}
//
// private void fireDeletedProjectEvent(Project project) {
// this.rootproject = null;
// this.lookup.clear();
//
// Object[] listeners = plannerDataChangeListeners.getListenerList();
// // loop through each listener and pass on the event if needed
// int numListeners = listeners.length;
// for (int i = 0; i < numListeners; i += 2) {
// if (listeners[i] == PlannerDataChangeListener.class) {
// // pass the event to the listeners event dispatch method
// ((PlannerDataChangeListener) listeners[i + 1])
// .deletedProject(project);
// }
// }
// }
private void fireDeletedStoryCardEvent(long id) {
// try {
// this.findParentCardById(indexCard.getParent()).removeStoryCard(
// indexCard);
// this.lookup.remove(indexCard.getId());
// } catch (IndexCardNotFoundException e) {
// System.out
// .println("Unable to process incoming removal of StoryCard!\n\n"
// + indexCard.toString());
// e.printStackTrace();
// }
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.deletedStoryCard(id);
}
}
}
private void fireMovedStoryCardToNewParentEvent(StoryCard storycard) {
// try {
// long oldparentid = this.findStoryCardById(storycard.getId())
// .getParent();
// long newparentid = storycard.getParent();
//
// this.findStoryCardById(storycard.getId()).setLocationX(
// storycard.getLocationX());
// this.findStoryCardById(storycard.getId()).setLocationY(
// storycard.getLocationY());
//
// this.findParentCardById(oldparentid).removeStoryCard(storycard);
// this.findParentCardById(newparentid).addStoryCard(storycard);
//
// } catch (IndexCardNotFoundException e) {
// System.out.println("Unable to process incoming event!\n");
// e.printStackTrace();
// }
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.movedStoryCardToNewParent(storycard);
}
}
}
/***************************************************************************
* FIRE UNDELETE EVENTS *
**************************************************************************/
// private void fireUndeletedBacklogEvent(Backlog backlog) {
//// this.rootproject.setBacklog(backlog);
//// this.lookup.put(backlog.getId(), backlog);
//
// Object[] listeners = plannerDataChangeListeners.getListenerList();
// // loop through each listener and pass on the event if needed
// int numListeners = listeners.length;
// for (int i = 0; i < numListeners; i += 2) {
// if (listeners[i] == PlannerDataChangeListener.class) {
// // pass the event to the listeners event dispatch method
// ((PlannerDataChangeListener) listeners[i + 1])
// .undeletedBacklog(backlog);
// }
// }
// }
private void fireUndeletedIterationEvent(Iteration iteration) {
// this.rootproject.addIteration(iteration);
// this.lookup.put(iteration.getId(), iteration);
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.undeletedIteration(iteration);
}
}
}
//
// private void fireUndeletedProjectEvent(Project project) {
// this.rootproject = project;
// this.lookup.clear();
//
// Object[] listeners = plannerDataChangeListeners.getListenerList();
// // loop through each listener and pass on the event if needed
// int numListeners = listeners.length;
// for (int i = 0; i < numListeners; i += 2) {
// if (listeners[i] == PlannerDataChangeListener.class) {
// // pass the event to the listeners event dispatch method
// ((PlannerDataChangeListener) listeners[i + 1])
// .undeletedProject(project);
// }
// }
// }
private void fireUndeletedStoryCardEvent(StoryCard storyCard) {
// try {
// this.findParentCardById(indexCard.getParent()).addStoryCard(
// indexCard);
// } catch (IndexCardNotFoundException e) {
// System.out.println("Unable to process incoming event!\n");
// e.printStackTrace();
// }
// this.lookup.put(indexCard.getId(), indexCard);
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.undeletedStoryCard(storyCard);
}
}
}
/***************************************************************************
* FIRE UPDATE BACKLOG EVENTS *
**************************************************************************/
private void fireUpdatedBacklogEvent(Backlog backlog) {
try {
// this.rootproject.getBacklog().update(backlog);
// this.rootproject.getBacklog().setWidth(backlog.getWidth());
// this.rootproject.getBacklog().setHeight(backlog.getHeight());
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.updatedBacklog(backlog);
}
}
} catch (Exception e) {
System.out.println("Unable to process incoming event!\n");
e.printStackTrace();
}
}
/***************************************************************************
* FIRE UPDATE ITERATION EVENTS *
**************************************************************************/
private void fireUpdatedIterationEvent(Iteration iteration) {
// Iteration iter = null;
// try {
// // this.findIterationById(iteration.getId()).update(iteration);
// iter = findIterationById(iteration.getId());
// iter.setAvailableEffort(iteration.getAvailableEffort());
// } catch (IndexCardNotFoundException e) {
// System.out.println("Unable to process incoming event!\n");
// e.printStackTrace();
// }
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.updatedIteration(iteration);
}
}
}
/***************************************************************************
* FIRE UPDATE STORYCARD EVENTS *
**************************************************************************/
private void fireUpdatedStoryCardEvent(StoryCard sc) {
// StoryCard sc = null;
// try {
// sc = this.findStoryCardById(storycard.getId());
// sc.setActualEffort(storycard.getActualEffort());
// } catch (IndexCardNotFoundException e) {
// System.out.println("Unable to process incoming event!\n");
// e.printStackTrace();
// }
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.updatedStoryCard(sc);
}
}
}
/***************************************************************************
* FIRE UPDATE PROJECT EVENTS *
**************************************************************************/
// private void fireUpdatedProjectNameEvent(Project project) {
// Project prj = this.rootproject;
//
// if (prj.getId() == project.getId()) {
// prj.setName(project.getName());
//
// Object[] listeners = plannerDataChangeListeners.getListenerList();
// // loop through each listener and pass on the event if needed
// int numListeners = listeners.length;
// for (int i = 0; i < numListeners; i += 2) {
// if (listeners[i] == PlannerDataChangeListener.class) {
// // pass the event to the listeners event dispatch method
// ((PlannerDataChangeListener) listeners[i + 1])
// .updatedProjectName(project);
// }
// }
// }
// }
/***************************************************************************
* FIRE USERINTERFACE EVENTS *
**************************************************************************/
private void fireMovedMouseEvent(MouseMove mm) {
if (mm.getId() != this.clientid) {
System.out.println("this is a mouse move: " + mm.getId()
+ " and this is from client: " + this.clientid);
Object[] listeners = plannerUIChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerUIChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerUIChangeListener) listeners[i + 1]).movedMouse(mm);
}
}
}
}
private void fireBroughtToFrontEvent(long id) {
Object[] listeners = plannerUIChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerUIChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerUIChangeListener) listeners[i + 1]).broughtToFront(id);
}
}
}
private void fireDeletedRemoteMouseEvent(long id) {
Object[] listeners = plannerUIChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerUIChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerUIChangeListener) listeners[i + 1])
.deletedRemoteMouse(id);
}
}
}
private void fireKeyStrokeEvent(Keystroke ks) {
Object[] listeners = plannerUIChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerUIChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerUIChangeListener) listeners[i + 1])
.sendKeyEventLocally(ks);
}
}
}
/***************************************************************************
* CLIENT FUNCTIONALITY *
**************************************************************************/
public synchronized void receiveMessage(Message message) {
switch (message.getMessageType()) {
case Message.EXCEPTION:
this.fireExecption( (Exception) message.getMessage());
break;
case Message.MOUSE_MOVE:
this.fireMovedMouseEvent((MouseMove) message.getMessage());
break;
case Message.BRING_TO_FRONT:
this.fireBroughtToFrontEvent((Long) message.getMessage());
break;
case Message.KEYSTROKE:
this.fireKeyStrokeEvent((Keystroke) message.getMessage());
break;
case Message.CREATE_BACKLOG:
this.fireCreatedBacklogEvent((Backlog) message.getMessage());
break;
case Message.CREATE_ITERATION:
this.fireCreatedIterationEvent((Iteration) message.getMessage());
break;
case Message.CREATE_PROJECT:
this.fireCreatedProjectEvent((Project) message.getMessage());
break;
case Message.CONNECT:
this.fireCreatedProjectEvent((Project) message.getMessage());
break;
case Message.CREATE_STORYCARD:
this.fireCreatedStoryCardEvent((StoryCard) message.getMessage());
break;
// case Message.DELETE_BACKLOG:
// this.fireDeletedBacklogEvent((Backlog) message.getMessage());
// break;
case Message.DELETE_ITERATION:
this.fireDeletedIterationEvent(((Iteration) message.getMessage()).getId());
break;
// case Message.DELETE_PROJECT:
// this.fireDeletedProjectEvent((Project) message.getMessage());
// break;
case Message.DELETE_STORYCARD:
this.fireDeletedStoryCardEvent(((StoryCard) message.getMessage()).getId());
break;
case Message.DELETE_REMOTE_MOUSE:
this.fireDeletedRemoteMouseEvent((Long) message.getMessage());
break;
case Message.GET_PROJECT_FILES_NAME:
if (getProjectFilesRequested) {
this.fireGotProjectNamesFromServerEvent((String[]) message
.getMessage());
// this.setFilesNameFromServer((String[]) message.getMessage());
getProjectFilesRequested = false;
}
break;
case Message.LOAD:
System.out.println("Message received at Client back.");
this.fireCreatedProjectEvent((Project) message.getMessage());
break;
case Message.MOVE_STORYCARD_TO_NEW_PARENT:
this.fireMovedStoryCardToNewParentEvent((StoryCard) message
.getMessage());
break;
case Message.UNDELETE_ITERATION:
this.fireUndeletedIterationEvent((Iteration) message.getMessage());
break;
// case Message.UNDELETE_PROJECT:
// this.fireUndeletedProjectEvent((Project) message.getMessage());
// break;
case Message.UNDELETE_STORYCARD:
this.fireUndeletedStoryCardEvent((StoryCard) message.getMessage());
break;
case Message.UPDATE_BACKLOG:
this.fireUpdatedBacklogEvent((Backlog) message.getMessage());
break;
case Message.UPDATE_ITERATION:
this.fireUpdatedIterationEvent((Iteration) message.getMessage());
break;
case Message.UPDATE_STORYCARD:
this.fireUpdatedStoryCardEvent((StoryCard) message
.getMessage());
break;
case Message.SAVE_AS:
if (saveAsRequested) {
saveAsRequested = false;
String[] returnedData = (String[]) message.getMessage();
this.writeToFile(returnedData[0], returnedData[1]);
System.out.println(returnedData[0] + returnedData[1]);
}
break;
default:
break;
}
}
private void fireExecption(Exception exception) {
Object[] listeners = plannerDataChangeListeners.getListenerList();
// loop through each listener and pass on the event if needed
int numListeners = listeners.length;
for (int i = 0; i < numListeners; i += 2) {
if (listeners[i] == PlannerDataChangeListener.class) {
// pass the event to the listeners event dispatch method
((PlannerDataChangeListener) listeners[i + 1])
.asynchronousException(exception);
}
}
}
/***************************************************************************
* SETTER & GETTER *
**************************************************************************/
public long getClientId() /* throws RemoteException */{
return this.clientid;
}
public void setClientId(long id) /* throws RemoteException */{
this.clientid = id;
}
public void sendKeystrokeOut(Keystroke ks) throws NotConnectedException {
if (connected()) {
MessageDataObject message = new MessageDataObject(this.clientid,
Message.KEYSTROKE, ks);
sendMessage(message);
} else {
throw new NotConnectedException("Server unreachable!");
}
}
public void writeToFile(String filename, String content) {
BufferedWriter out;
try {
out = new BufferedWriter(new FileWriter(filename));
out.write(content);
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public File getProjectDirectory() {
// TODO Auto-generated method stub
return null;
}
public void getProjectAsXML() throws NotConnectedException {
// TODO Auto-generated method stub
}
public void sendMessage(Message msg){
try {
nc.send(msg);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}// end class
See more files for this project here