Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[4348] branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ ebli
|
From: <had...@us...> - 2009-01-13 19:15:37
|
Revision: 4348
http://fudaa.svn.sourceforge.net/fudaa/?rev=4348&view=rev
Author: hadouxad
Date: 2009-01-13 19:15:33 +0000 (Tue, 13 Jan 2009)
Log Message:
-----------
fleches + persistance des donnees des courbes
Added Paths:
-----------
branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/commun/EbliEditorArrow.java
branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetArrowEditor.java
branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetControllerFlecheEditor.java
branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/creator/EbliWidgetCreatorArrowEditor.java
Added: branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/commun/EbliEditorArrow.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/commun/EbliEditorArrow.java (rev 0)
+++ branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/commun/EbliEditorArrow.java 2009-01-13 19:15:33 UTC (rev 4348)
@@ -0,0 +1,528 @@
+package org.fudaa.ebli.commun;
+
+import java.awt.Color;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.awt.image.BufferedImage;
+import java.awt.image.ImageProducer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JToolBar;
+
+import org.fudaa.ctulu.image.CtuluImageProducer;
+import org.fudaa.ctulu.image.CtuluLibImage;
+import org.fudaa.ebli.ressource.EbliResource;
+import org.fudaa.ebli.trace.TraceLigne;
+import org.fudaa.ebli.trace.TraceLigneModel;
+
+
+
+import com.memoire.bu.BuPanel;
+
+
+/**
+ * Editeur de fleche.
+ * Gere 4 points (2 pour le segment) et 2 pour les extr\xE9mit\xE9s
+ * Gere 2 type: plein ou vide
+ *
+ * Permet \xE0 l'utilisateur de modifier sa fleche en cliquant dessus
+ *
+ * @author Adrien Hadoux
+ *
+ */
+public class EbliEditorArrow extends BuPanel implements CtuluImageProducer, MouseListener, MouseMotionListener {
+
+ public final static int ExtremiteTete=0;
+ public final static int ExtremiteQueue=1;
+ public final static int ExtremiteGauche=2;
+ public final static int ExtremiteDroite=3;
+
+
+ public EbliEditorArrow(){
+ this(new Point[ExtremiteDroite+1]);
+ //-- on initialise --//
+
+ creationFlecheClassique();
+ repaint();
+ }
+
+ /**
+ * Constructeur appel\xE9 pour une cr\xE9ation de base.
+ * @param points
+ */
+ public EbliEditorArrow(Point[] points){
+ points_=points;
+ setSize(200, 150);
+ this.addMouseListener(this);
+ this.addMouseMotionListener(this);
+ this.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
+ repaint();
+ }
+
+
+ private Point[] points_;
+
+
+
+
+ /**
+ * Model traceligne appel\xE9 a chaque edition de la fleche pour mettre a jour le trac\xE9.
+ */
+ public TraceLigneModel model_;
+ public Color background_=Color.white;
+ public Color foreground_=Color.black;
+
+ public Point getExtremiteTete(){
+ return points_[ExtremiteTete];
+ }
+
+ public Point getExtremiteQueue(){
+ return points_[ExtremiteQueue];
+ }
+
+
+ public Point getExtremiteGauche(){
+ return points_[ExtremiteGauche];
+ }
+
+ public Point getExtremiteDroite(){
+ return points_[ExtremiteDroite];
+ }
+
+ public Point[] getPoints_() {
+ return points_;
+ }
+
+ public void setPoints_(Point[] points_) {
+ this.points_ = points_;
+ }
+
+ public void modifieExtremite(Point newPoint, int position){
+ if(position>ExtremiteDroite || points_==null)return;
+ points_[position]=newPoint;
+ repaint();
+ }
+
+ public void clearArrow(){
+ points_=new Point[ExtremiteDroite+1];
+ repaint();
+ }
+
+
+
+ int previousWidth_=0;
+ int previousHeight_=0;
+
+
+ public void recalculatePosition(int w,int h){
+ if(points_==null)return;
+ if(previousWidth_==0)previousWidth_=getWidth();
+ if(previousHeight_==0)previousHeight_=getHeight();
+ if(previousWidth_==0)return;
+ if(previousHeight_==0)return;
+
+ double ratioW=1.0*w/previousWidth_;
+ double ratioH=1.0*h/previousHeight_;
+
+
+ for(int i=0;i<points_.length;i++){
+ if(points_[i]!=null){
+ points_[i].x=(int)(points_[i].x*ratioW);
+ points_[i].y=(int)(points_[i].y*ratioH);
+ }
+ }
+ previousWidth_=w;
+ previousHeight_=h;
+ }
+
+ /**
+ * Methode qui dessine la fleche.
+ */
+ public void print(Graphics _g,int w,int h) {
+
+
+ //recalculatePosition(w,h);
+
+ final BufferedImage image = CtuluLibImage.createImage(w, h, new HashMap());
+ final Graphics2D g2d = image.createGraphics();
+ image.flush();
+
+
+
+
+ if(points_==null)return;
+
+ if(existeAucunPoint()){
+ g2d.setColor(Color.black);
+ g2d.drawString("Veuillez cliquer sur les 4 points pour cr\xE9er la fl\xE8che", 10, 10);
+ g2d.drawString("Modifier: faire des glisser-d\xE9pos\xE9 pr\xE8s des extr\xE9mit\xE9s", 10, 20);
+
+ }
+
+ // -- creation du traceligne --//
+ final TraceLigne traceligne = new TraceLigne(model_);
+ traceligne.setCouleur(foreground_);
+
+ //-- on trace le segment initial --//
+ if(getExtremiteTete()!=null && getExtremiteQueue()!=null){
+ traceligne.dessineTrait(g2d, getExtremiteTete().x, getExtremiteTete().y, getExtremiteQueue().x,getExtremiteQueue().y);
+ }else{
+ // pas de segment complet, on trace juste les points existants
+ if(getExtremiteTete()!=null)
+ traceligne.dessineRectangle(g2d,getExtremiteTete().x-traceligne.getEpaisseur()/2,getExtremiteTete().y-traceligne.getEpaisseur()/2,traceligne.getEpaisseur(), traceligne.getEpaisseur());
+ if(getExtremiteQueue()!=null)
+ traceligne.dessineRectangle(g2d,getExtremiteQueue().x-traceligne.getEpaisseur()/2,getExtremiteQueue().y-traceligne.getEpaisseur()/2,traceligne.getEpaisseur(), traceligne.getEpaisseur());
+
+ }
+ //-- on trace le segment tete/gauche --//
+ if(getExtremiteTete()!=null && getExtremiteGauche()!=null){
+ traceligne.dessineTrait(g2d, getExtremiteTete().x, getExtremiteTete().y, getExtremiteGauche().x,getExtremiteGauche().y);
+ }else{
+ // pas de segment complet, on trace juste les points existants
+ if(getExtremiteGauche()!=null)
+ traceligne.dessineRectangle(g2d,getExtremiteGauche().x-traceligne.getEpaisseur()/2,getExtremiteGauche().y-traceligne.getEpaisseur()/2,traceligne.getEpaisseur(), traceligne.getEpaisseur());
+
+ }
+ //-- on trace le segment tete/droite --//
+ if(getExtremiteTete()!=null && getExtremiteDroite()!=null){
+ traceligne.dessineTrait(g2d, getExtremiteTete().x, getExtremiteTete().y, getExtremiteDroite().x,getExtremiteDroite().y);
+ }else{
+ // pas de segment complet, on trace juste les points existants
+ if(getExtremiteDroite()!=null)
+ traceligne.dessineRectangle(g2d,getExtremiteDroite().x-traceligne.getEpaisseur()/2,getExtremiteDroite().y-traceligne.getEpaisseur()/2,traceligne.getEpaisseur(), traceligne.getEpaisseur());
+
+ }
+
+ //-- on dessine l'image --//
+ _g.drawImage(image, 0,0, null);
+
+ }
+
+ @Override
+ public void paintComponent(Graphics _g) {
+
+ //-- empecher de voir d'autres dessins par dessus --//
+ _g.setColor(background_);
+ _g.fillRect(0, 0, getWidth(), getHeight());
+ _g.setColor(foreground_);
+ print(_g,getWidth(),getHeight() );
+
+ //-- on affiche les marqueurs drag and drop --//
+ if(marqueurDeplacement_ && positionPointToMove_!=-1){
+ _g.setColor(Color.RED);
+ //-- position initiale --//
+ _g.fillRect(points_[positionPointToMove_].x-3,points_[positionPointToMove_].y-3,6,6);
+
+ //-- position deplacement --//
+ if(positionDeplacement_!=null){
+ _g.setColor(Color.GREEN);
+
+ _g.fillRect(positionDeplacement_.x-3,positionDeplacement_.y-3,6,6);
+ }
+
+
+ }
+
+ }
+
+ public BufferedImage produceImage(final int _w, final int _h, final Map _params) {
+
+ recalculatePosition(_w,_h);
+
+ final BufferedImage i = CtuluLibImage.createImage(_w, _h, _params);
+ final Graphics2D g2d = i.createGraphics();
+ CtuluLibImage.setBestQuality(g2d);
+ if (CtuluLibImage.mustFillBackground(_params)) {
+ g2d.setColor(Color.WHITE);
+ g2d.fillRect(0, 0, _w, _h);
+ }
+
+ if (getWidth() != _w || getHeight() != _h) {
+
+ // this.setPreferredSize(new Dimension(_w, _h));
+
+ g2d.scale(CtuluLibImage.getRatio(_w, getWidth()), CtuluLibImage.getRatio(_h, getHeight()));
+ setSize(_w, _h);
+ }
+
+ print(g2d,_w,_h);
+ g2d.dispose();
+ i.flush();
+ return i;
+ }
+
+ @Override
+ public Dimension getDefaultImageDimension() {
+ // TODO Auto-generated method stub
+ return getSize();
+ }
+
+ @Override
+ public BufferedImage produceImage(Map _params) {
+ final BufferedImage i = CtuluLibImage.createImage(getWidth(), getHeight(), _params);
+ final Graphics2D g2d = i.createGraphics();
+ CtuluLibImage.setBestQuality(g2d);
+ if (CtuluLibImage.mustFillBackground(_params)) {
+ g2d.setColor(Color.WHITE);
+ g2d.fillRect(0, 0, getWidth(), getHeight());
+ }
+
+
+ print(g2d);
+ g2d.dispose();
+ i.flush();
+ return i;
+ }
+
+ /**
+ * Methode qui est appel\xE9e apr\xE8s un clic et qui d\xE9termine le point manquant \xE0 ajouter:
+ * @param p
+ */
+ public void determinePointAajouter(Point p){
+ if(p==null)return;
+
+ if(getExtremiteTete()==null)
+ modifieExtremite(p, ExtremiteTete);
+ else
+ if(getExtremiteQueue()==null)
+ modifieExtremite(p, ExtremiteQueue);
+ else
+ if(getExtremiteGauche()==null)
+ modifieExtremite(p, ExtremiteGauche);
+ else
+ if(getExtremiteDroite()==null)
+ modifieExtremite(p, ExtremiteDroite);
+ else return;
+ }
+
+
+ /**
+ * Retourne true si le point est a ajouter ou false si il s'agit d'un d\xE9placement
+ * @return
+ */
+ public boolean ajout(){
+ if(getExtremiteTete()==null)
+ return true;
+ if(getExtremiteQueue()==null)
+ return true;
+ if(getExtremiteDroite()==null)
+ return true;
+ if(getExtremiteGauche()==null)
+ return true;
+ return false;
+ }
+
+ public boolean existeAucunPoint(){
+ if(getExtremiteTete()!=null)
+ return false;
+ if(getExtremiteQueue()!=null)
+ return false;
+ if(getExtremiteDroite()!=null)
+ return false;
+ if(getExtremiteGauche()!=null)
+ return false;
+ return true;
+ }
+
+ /**
+ * Methode qui determine le point a modifier de la fleche, c'est a dire le point qui se trouve le plus proche du clic utilisateur au point p.
+ * @param p
+ * @return
+ */
+ public int determinePointAmodifier(Point p){
+
+ double distanceMin=p.distance(getExtremiteTete());
+ int position=ExtremiteTete;
+
+ if(distanceMin>p.distance(getExtremiteQueue())){
+ distanceMin=p.distance(getExtremiteQueue());
+ position=ExtremiteQueue;
+ }
+
+ if(distanceMin>p.distance(getExtremiteDroite())){
+ distanceMin=p.distance(getExtremiteDroite());
+ position=ExtremiteDroite;
+ }
+
+ if(distanceMin>p.distance(getExtremiteGauche())){
+ distanceMin=p.distance(getExtremiteGauche());
+ position=ExtremiteGauche;
+ }
+
+ return position;
+ }
+
+
+ public void mouseClicked(MouseEvent e) {
+
+ if(ajout())
+ determinePointAajouter(new Point(e.getX(),e.getY()));
+ else{
+
+ //-- mode modification du point --//
+ // modifieExtremite(new Point(e.getX(),e.getY()), determinePointAmodifier(new Point(e.getX(),e.getY())));
+ //RIEN FAIRE
+ }
+ repaint();
+ }
+
+ @Override
+ public void mouseEntered(MouseEvent e) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void mouseExited(MouseEvent e) {
+ // TODO Auto-generated method stub
+
+ }
+ /**
+ * lors d'un drag and drop, on retient la position du point qu'on veut deplacer
+ * et lors du relachement souris ou remplace les infos
+ */
+ int positionPointToMove_=-1;
+
+ /**
+ * marqueur qui s'active dans le cas du drag and drop et qui marque le point initial ainsi que le point destination jusqu'au lacher.
+ */
+ boolean marqueurDeplacement_=false;
+ @Override
+ public void mousePressed(MouseEvent e) {
+ // TODO Auto-generated method stub
+ if(!ajout()){
+ positionPointToMove_=determinePointAmodifier(new Point(e.getX(),e.getY()));
+ marqueurDeplacement_=true;
+ System.out.println("Souris pressed: positionToMove:"+positionPointToMove_);
+ repaint();
+ }
+ else
+ positionPointToMove_=-1;
+
+
+ }
+
+ @Override
+ public void mouseReleased(MouseEvent e) {
+ // TODO Auto-generated method stub
+ if(!ajout() && positionPointToMove_!=-1){
+ modifieExtremite(new Point(e.getX(),e.getY()), positionPointToMove_);
+ positionPointToMove_=-1;
+ System.out.println("Souris released: positionToMove:"+positionPointToMove_);
+ marqueurDeplacement_=false;
+ positionDeplacement_=null;
+ repaint();
+ }
+ }
+
+ Point positionDeplacement_=null;
+ @Override
+ public void mouseDragged(MouseEvent e) {
+ //System.out.println("Souris dragged: "+positionPointToMove_);
+ if(marqueurDeplacement_){
+ positionDeplacement_=new Point(e.getX(),e.getY());
+ repaint();
+ }
+ }
+
+ @Override
+ public void mouseMoved(MouseEvent e) {
+ // TODO Auto-generated method stub
+ System.out.println("Souris MOVED: "+positionPointToMove_);
+ }
+
+
+ public EbliEditorArrow duplicate(){
+ EbliEditorArrow duplic=new EbliEditorArrow(points_.clone());
+ duplic.model_=new TraceLigneModel(model_);
+ return duplic;
+ }
+
+
+ public void creationFlecheClassique(){
+ clearArrow();
+ if(model_==null)
+ model_=new TraceLigneModel();
+ modifieExtremite(new Point((int)(getWidth()-model_.getEpaisseur()),(int)(getHeight()/2.0-model_.getEpaisseur()/2.0)), ExtremiteTete);
+ modifieExtremite(new Point((int)(0+model_.getEpaisseur()),(int)(getHeight()/2.0-model_.getEpaisseur()/2.0)), ExtremiteQueue);
+ modifieExtremite(new Point((int)(2.0/3.0*getWidth()),(int)(model_.getEpaisseur())), ExtremiteDroite);
+ modifieExtremite(new Point((int)(2.0/3.0*getWidth()),(int)(getHeight()-model_.getEpaisseur())), ExtremiteGauche);
+ repaint();
+ }
+
+ public void creationDoubleFlecheClassique(){
+ clearArrow();
+ if(model_==null)
+ model_=new TraceLigneModel();
+ modifieExtremite(new Point((int)(getWidth()-model_.getEpaisseur()),(int)(getHeight()/2.0-model_.getEpaisseur()/2.0)), ExtremiteTete);
+ modifieExtremite(new Point((int)(0+model_.getEpaisseur()),(int)(getHeight()/2.0-model_.getEpaisseur()/2.0)), ExtremiteQueue);
+ modifieExtremite(new Point((int)(2.0/3.0*getWidth()),(int)(model_.getEpaisseur())), ExtremiteDroite);
+ modifieExtremite(new Point((int)(2.0/3.0*getWidth()),(int)(getHeight()-model_.getEpaisseur())), ExtremiteGauche);
+ repaint();
+ }
+
+ JToolBar toolbar_;
+ JMenuBar menuBar_;
+ public JToolBar getToolBar( ) {
+ if(toolbar_==null){
+ toolbar_=new JToolBar();
+ for(EbliActionSimple action:getActions())
+ toolbar_.add(action);
+ }
+ return toolbar_;
+ }
+
+ public JMenuBar getMenuBar( ) {
+ if(menuBar_==null){
+ menuBar_=new JMenuBar();
+ JMenu principal=new JMenu("Menu");
+ for(EbliActionSimple action:getActions())
+ principal.add(action);
+ menuBar_.add(principal);
+ }
+ return menuBar_;
+ }
+
+
+ List<EbliActionSimple> getActions(){
+ List<EbliActionSimple> liste=new ArrayList<EbliActionSimple>();
+
+ EbliActionSimple action=new EbliActionSimple(EbliResource.EBLI.getString("Initialiser"),EbliResource.EBLI
+ .getIcon("restore"),"Restaurer"){
+ public void actionPerformed(final ActionEvent _evt) {
+ clearArrow();
+ }
+ };
+ liste.add(action);
+ action=new EbliActionSimple(EbliResource.EBLI.getString("Fl\xE8che"),EbliResource.EBLI.getToolIcon("crystal_bu_link"),"Fl\xE8che"){
+ public void actionPerformed(final ActionEvent _evt) {
+ creationFlecheClassique();
+ }
+ };
+ liste.add(action);
+// action=new EbliActionSimple(EbliResource.EBLI.getString("Double Fl\xE8che"),EbliResource.EBLI.getToolIcon("crystal_bu_scrollpane_corner"),"Double Fl\xE8che"){
+// public void actionPerformed(final ActionEvent _evt) {
+// creationDoubleFlecheClassique();
+// }
+// };
+// liste.add(action);
+ return liste;
+ }
+
+
+
+
+}
Added: branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetArrowEditor.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetArrowEditor.java (rev 0)
+++ branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetArrowEditor.java 2009-01-13 19:15:33 UTC (rev 4348)
@@ -0,0 +1,125 @@
+package org.fudaa.ebli.visuallibrary;
+
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.fudaa.ctulu.image.CtuluLibImage;
+import org.fudaa.ebli.commun.EbliEditorArrow;
+import org.netbeans.api.visual.action.ActionFactory;
+import org.netbeans.api.visual.action.InplaceEditorProvider;
+import org.netbeans.api.visual.action.WidgetAction;
+import org.netbeans.api.visual.widget.Widget;
+
+import com.memoire.fu.FuLog;
+
+
+
+/**
+ * Classe editeur de Fleche
+ * @author Adrien Hadoux
+ *
+ */
+public class EbliWidgetArrowEditor extends EbliWidget implements InplaceEditorProvider<EbliEditorArrow>{
+
+ public EbliEditorArrow editor_;
+ BufferedImage imageFleche;
+
+
+ public EbliWidgetArrowEditor(EbliScene scene,EbliEditorArrow editor) {
+ super(scene, false);
+ // TODO Auto-generated constructor stub
+ editor_=editor;
+ editor_.model_=getTraceLigneModel();
+ editor_.foreground_=getColorContour();
+ // -- creation de l action pour editor --//
+ //final WidgetAction editorAction = ActionFactory.createInplaceEditorAction(this);
+
+ // -- ajout de l action au widget correspondant --//
+ // this.getActions().addAction(editorAction);
+
+ final EbliWidgetControllerFlecheEditor controller = new EbliWidgetControllerFlecheEditor(this);
+ controller.setEditable(true);
+ setController(controller);
+
+ }
+
+
+ protected void paintWidget() {
+ final Rectangle rec = getClientArea();
+ final Graphics2D g = getGraphics();
+ // g.translate(rec.x, rec.y);
+ if (rec.width > 0 && rec.height > 0) {
+
+
+ // mode edition
+ //if (imageFleche == null || imageFleche.getWidth() != (rec.width-1) || imageFleche.getHeight() != (rec.height-1)) {
+ FuLog.debug("EWI: recreate image");
+ final Map params = new HashMap();
+ CtuluLibImage.setCompatibleImageAsked(params);
+ editor_.model_=getTraceLigneModel();
+ editor_.foreground_=getColorContour();
+ imageFleche = editor_.produceImage(rec.width - 1, rec.height - 1, params);
+
+ //}
+ g.drawImage(imageFleche, rec.x, rec.y, rec.width - 1, rec.height - 1, null);
+ }
+ }
+
+
+ @Override
+ public EbliEditorArrow createEditorComponent(
+ org.netbeans.api.visual.action.InplaceEditorProvider.EditorController controller,
+ Widget widget) {
+ //-- on met a jour le traceligne model --//
+ editor_.model_=getTraceLigneModel();
+ editor_.foreground_=getColorContour();
+ final Rectangle rec = getClientArea();
+ editor_.setSize(new Dimension(rec.width,rec.height));
+ editor_.setPreferredSize(new Dimension(rec.width,rec.height));
+
+ return editor_;
+ }
+
+ @Override
+ public EnumSet<org.netbeans.api.visual.action.InplaceEditorProvider.ExpansionDirection> getExpansionDirections(
+ org.netbeans.api.visual.action.InplaceEditorProvider.EditorController controller,
+ Widget widget, EbliEditorArrow editor) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Rectangle getInitialEditorComponentBounds(
+ org.netbeans.api.visual.action.InplaceEditorProvider.EditorController controller,
+ Widget widget, EbliEditorArrow editor, Rectangle viewBounds) {
+ // TODO Auto-generated method stub
+ final Rectangle rec = convertLocalToScene(getClientArea());
+ rec.width -= 1;
+ rec.height -= 1;
+ return rec;
+ }
+
+ @Override
+ public void notifyClosing(
+ org.netbeans.api.visual.action.InplaceEditorProvider.EditorController controller,
+ Widget widget, EbliEditorArrow editor, boolean commit) {
+ // TODO Auto-generated method stub
+ imageFleche =null;
+ repaint();
+ editingStop();
+ }
+
+ @Override
+ public void notifyOpened(
+ org.netbeans.api.visual.action.InplaceEditorProvider.EditorController controller,
+ Widget widget, EbliEditorArrow editor) {
+ // TODO Auto-generated method stub
+ editingStart();
+ }
+
+}
Added: branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetControllerFlecheEditor.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetControllerFlecheEditor.java (rev 0)
+++ branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/EbliWidgetControllerFlecheEditor.java 2009-01-13 19:15:33 UTC (rev 4348)
@@ -0,0 +1,92 @@
+package org.fudaa.ebli.visuallibrary;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JPopupMenu;
+import javax.swing.JToolBar;
+
+import org.fudaa.ctulu.CtuluResource;
+import org.fudaa.ctulu.gui.CtuluHtmlEditorPanel;
+import org.fudaa.ebli.commun.EbliEditorArrow;
+import org.fudaa.ebli.ressource.EbliResource;
+import org.fudaa.ebli.visuallibrary.actions.EbliActionEditorOneClick;
+import org.netbeans.api.visual.action.InplaceEditorProvider;
+
+import com.memoire.bu.BuMenuBar;
+import com.memoire.bu.BuPanel;
+
+/**
+ * Controller de l'editeur de fleches.
+ * @author Adrien Hadoux
+ *
+ */
+public class EbliWidgetControllerFlecheEditor extends EbliWidgetController {
+
+ EbliActionEditorOneClick<EbliEditorArrow> editorAction_;
+ EbliEditorArrow editor_;
+
+ public EbliWidgetControllerFlecheEditor(EbliWidgetArrowEditor _widget) {
+ super(_widget);
+ editor_ = _widget.editor_;
+ addActionSpecifiques();
+
+ }
+
+
+ public void MenuEditer() {
+ // -- executer l action d edition --//
+ editorAction_.openEditor(getWidget());
+
+ }
+
+ public void addActionSpecifiques() {
+
+ editorAction_ = new EbliActionEditorOneClick<EbliEditorArrow>((InplaceEditorProvider) widget_);
+ // -- ajout de l action au widget correspondant --//
+ widget_.getActions().addAction(editorAction_);
+
+ }
+
+ @Override
+ protected void buildPopupMenu(final JPopupMenu _menu) {
+ constructPopupMenuSpecifique(_menu);
+ // -- creation du menu commun a tous les widgets
+ constructPopupMenuBase(_menu);
+ }
+
+
+ private void constructPopupMenuSpecifique(final JPopupMenu _popup) {
+ JMenuItem menuItem = new JMenuItem(EbliResource.EBLI.getString("Editer la fl\xE8che"));
+ _popup.add(menuItem, 0);
+ menuItem.setIcon(CtuluResource.CTULU.getIcon("crystal_editer"));
+ menuItem.addActionListener(new ActionListener() {
+ public void actionPerformed(final ActionEvent e) {
+ MenuEditer();
+ }
+ });
+ }
+
+
+ public JToolBar getToolbarComponent() {
+ if (editor_ != null)
+ return editor_.getToolBar();
+ else
+ return new JToolBar();
+ }
+
+ JMenuBar menuBar_;
+
+ public JMenuBar getMenubarComponent() {
+ if (editor_ == null)
+ return new BuMenuBar();
+
+ if (menuBar_ == null)
+ menuBar_ = editor_.getMenuBar();
+ return menuBar_;
+
+ }
+
+ }
Added: branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/creator/EbliWidgetCreatorArrowEditor.java
===================================================================
--- branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/creator/EbliWidgetCreatorArrowEditor.java (rev 0)
+++ branches/Prepro-0.92-SNAPSHOT/ebli/src/org/fudaa/ebli/visuallibrary/creator/EbliWidgetCreatorArrowEditor.java 2009-01-13 19:15:33 UTC (rev 4348)
@@ -0,0 +1,81 @@
+package org.fudaa.ebli.visuallibrary.creator;
+
+import java.awt.Point;
+import java.util.Map;
+
+import org.fudaa.ebli.commun.EbliEditorArrow;
+import org.fudaa.ebli.visuallibrary.EbliNode;
+import org.fudaa.ebli.visuallibrary.EbliNodeDefault;
+import org.fudaa.ebli.visuallibrary.EbliScene;
+import org.fudaa.ebli.visuallibrary.EbliWidget;
+import org.fudaa.ebli.visuallibrary.EbliWidgetArrowEditor;
+import org.fudaa.ebli.visuallibrary.EbliWidgetBordureSingle;
+
+import org.fudaa.ebli.visuallibrary.EbliWidgetWithBordure;
+
+public class EbliWidgetCreatorArrowEditor implements EbliWidgetCreator {
+
+ EbliWidgetArrowEditor res;
+ //EbliWidgetWithBordure res;
+ /**
+ * Le type de l objet a creer.
+ */
+ EbliEditorArrow editor_;
+
+
+
+
+
+ public EbliWidgetCreatorArrowEditor(final EbliEditorArrow _typeObject) {
+ super();
+
+ editor_ = _typeObject;
+ }
+
+ public EbliWidgetCreatorArrowEditor() {
+
+ }
+
+ public EbliWidget create(final EbliScene _scene) {
+ // res = new EbliWidgetBordureSingle(new EbliWidgetArrowEditor(_scene, editor_));
+ res=new EbliWidgetArrowEditor(_scene, editor_);
+ return res;
+ }
+
+ public EbliWidget getWidget() {
+ return res;
+ }
+
+ public EbliNode duplicate(final EbliNode _nodeAdupliquer) {
+
+ final EbliNode duplique = new EbliNodeDefault();
+
+ duplique.setCreator(new EbliWidgetCreatorArrowEditor(editor_.duplicate()));
+
+ duplique.setTitle(_nodeAdupliquer.getTitle());
+ // recopie des tailles
+ duplique.setPreferedSize(_nodeAdupliquer.getPreferedSize());
+ // -- calcul nouvelle position
+ final Point nouvellePosition = new Point(getWidget().getLocation().x, (getWidget().getLocation().y + getWidget()
+ .getClientArea().height));
+ duplique.setPreferedLocation(nouvellePosition);
+
+ return duplique;
+ }
+
+ public EbliWidgetWithBordure getBordure() {
+ return null;
+ }
+
+ public Object getPersistData(final Map parameters) {
+ return editor_.getPoints_();
+ }
+
+ public void setPersistData(final Object data, final Map parameters) {
+ if (data == null) editor_ = new EbliEditorArrow();
+ else {
+ editor_ = new EbliEditorArrow((Point[])data);
+ }
+ }
+
+ }
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
