diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/BibliothequeGreffons.java b/linotte-greffons/src/main/java/org/linotte/greffons/BibliothequeGreffons.java index 0c52ab4..6432d50 100755 --- a/linotte-greffons/src/main/java/org/linotte/greffons/BibliothequeGreffons.java +++ b/linotte-greffons/src/main/java/org/linotte/greffons/BibliothequeGreffons.java @@ -124,20 +124,30 @@ private static void greffonsInternesAutres() throws Exception { LinotteFacade.creationPrototype(null, new Metronome(), "métronome"); LinotteFacade.creationPrototype(null, new Pipette(), "pipette"); LinotteFacade.creationPrototype(null, new Police(), "police"); + LinotteFacade.creationPrototype(null, new Queue(), "queue"); try { LinotteFacade.creationPrototype(null, new GreffonRobot(), "robot"); } catch (Exception e1) { - //e1.printStackTrace(); + e1.printStackTrace(); } LinotteFacade.creationPrototype(null, new Rss(), "rss"); LinotteFacade.creationPrototype(null, new SQL(), "sql"); LinotteFacade.creationPrototype(null, new Tweak(), "tweak"); LinotteFacade.creationPrototype(null, new Webonotte(), "webonotte"); + LinotteFacade.creationPrototype(null, new RepertoireTube(), "répertoire"); LinotteFacade.creationPrototype(null, new PressePapier(), "pressepapier"); LinotteFacade.creationPrototype(null, new Horodatage(), "horodatage"); + LinotteFacade.creationPrototype(null, new FichierTube(), "fichier"); + LinotteFacade.creationPrototype(null, new PileTube(), "pile"); LinotteFacade.creationPrototype(null, new Conduit(), "conduit"); - + { + Map attributs = new HashMap(); + attributs.put("adresse", new Attribut(TEXTE, "")); + attributs.put("état", new Attribut(NOMBRE, "0")); + attributs.put("port", new Attribut(NOMBRE, "8777")); + LinotteFacade.creationPrototype(attributs, new PontTube(), "pont"); + } { Map attributs = new HashMap(); attributs.put("texte", new Attribut(TEXTE, "http://www.codevallee.fr")); @@ -187,7 +197,7 @@ private static void greffonsInternesAutres() throws Exception { LinotteFacade.creationPrototype(attributs, new Notification(), "notification"); } catch (Exception e) { // Bloc sous une console Linux - //e.printStackTrace(); + e.printStackTrace(); } } { diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/FichierTube.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/FichierTube.java new file mode 100755 index 0000000..83c9119 --- /dev/null +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/FichierTube.java @@ -0,0 +1,264 @@ +package org.linotte.greffons.impl; + +import org.linotte.greffons.externe.Tube; + +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.math.BigDecimal; +import java.util.Scanner; + +/** + * + * Tube fichier + * + * @author Mounès Ronan + * + */ +public class FichierTube extends Tube { + + private static final String RETOUR_CHARIOT = System.getProperty("line.separator"); + + private Scanner in = null; + + private FileWriter out = null; + + private static final String ETAT_LECTURE = "lecture"; + + private static final String ETAT_ECRITURE_AJOUT = "ajout"; + + private static final String ETAT_ECRITURE_ECRASEMENT = "écrasement"; + + public static final void main(String[] params) { + // Exemples d'utilisation + + try { + // Création du fichier vide avec 4 acteurs + FichierTube fichierTube = new FichierTube(); + fichierTube.ouvrir(ETAT_ECRITURE_ECRASEMENT, "c:/temp/tube.txt"); + Acteur acteur1 = new Acteur(ROLE.TEXTE, "acteur1", "valeur 1"); + fichierTube.charger(acteur1); + Acteur acteur2 = new Acteur(ROLE.TEXTE, "acteur2", "valeur 2"); + fichierTube.charger(acteur2); + fichierTube.fermer(); + } catch (GreffonException e) { + System.err.println(e.getMessage()); + } + + try { + // Création du fichier vide avec 4 acteurs + FichierTube fichierTube = new FichierTube(); + fichierTube.ouvrir(ETAT_ECRITURE_AJOUT, "c:/temp/tube.txt"); + Acteur acteur3 = new Acteur(ROLE.TEXTE, "acteur2", "valeur 3"); + Acteur acteur4 = new Acteur(ROLE.TEXTE, "acteur2", "valeur 4"); + Casier casier = new Casier(ROLE.TEXTE); + casier.add(acteur3); + casier.add(acteur4); + fichierTube.charger(casier); + fichierTube.fermer(); + } catch (GreffonException e) { + System.err.println(e.getMessage()); + } + + try { + // Cas fichier avec 4 acteurs : + FichierTube fichierTube = new FichierTube(); + fichierTube.ouvrir(ETAT_LECTURE, "c:/temp/tube.txt"); + System.out.println(fichierTube.decharger(new Acteur(ROLE.TEXTE, "acteur1", null))); + System.out.println(fichierTube.decharger(new Acteur(ROLE.TEXTE, "acteur2", null))); + System.out.println(fichierTube.decharger(new Acteur(ROLE.TEXTE, "acteur3", null))); + System.out.println(fichierTube.decharger(new Acteur(ROLE.TEXTE, "acteur4", null))); + fichierTube.fermer(); + } catch (GreffonException e) { + System.err.println(e.getMessage()); + } + + try { + // Cas fichier avec 1 casier d'acteurs : + FichierTube fichierTube = new FichierTube(); + fichierTube.ouvrir(ETAT_LECTURE, "c:/temp/tube.txt"); + Casier casier = new Casier(ROLE.TEXTE); + casier.add(new Acteur(ROLE.TEXTE, null, null)); + System.out.println(fichierTube.decharger(casier)); + fichierTube.fermer(); + } catch (GreffonException e) { + System.err.println(e.getMessage()); + } + + try { + // Cas fichier avec 1 casier d'espèce : + FichierTube fichierTube = new FichierTube(); + fichierTube.ouvrir(ETAT_LECTURE, "c:/temp/tube.txt"); + Casier casier = new Casier(ROLE.TEXTE); + Espece espece = new Espece("test"); + espece.add(new Acteur(ROLE.TEXTE, "attribut 1", null)); + espece.add(new Acteur(ROLE.TEXTE, "attribut 2", null)); + casier.add(espece); + System.out.println(fichierTube.decharger(casier)); + fichierTube.fermer(); + } catch (GreffonException e) { + System.err.println(e.getMessage()); + } + + } + + public FichierTube() { + } + + @Override + public boolean ouvrir(String état, String paramètres) throws GreffonException { + RessourceManager ressourceManager = getRessourceManager(); + String fichier; + if (ressourceManager != null) + fichier = ressourceManager.analyserChemin(paramètres); + else + fichier = paramètres; + + try { + if (ETAT_LECTURE.equals(état)) { + in = new Scanner(new FileReader(fichier)); + out = null; + } else if (ETAT_ECRITURE_AJOUT.equals(état)) { + creationRepertoire(fichier); + out = new FileWriter(fichier, true); + in = null; + } else if (ETAT_ECRITURE_ECRASEMENT.equals(état)) { + creationRepertoire(fichier); + out = new FileWriter(fichier, false); + in = null; + } else { + throw new GreffonException( + "l'état doit être écriture '" + ETAT_ECRITURE_AJOUT + "', '" + ETAT_ECRITURE_ECRASEMENT + "' ou '" + ETAT_LECTURE + "' !"); + } + } catch (Exception e) { + throw new GreffonException("Impossible d'ouvrir et de créer ce fichier (" + e.getMessage() + ") : " + fichier); + } + return false; + } + + private void creationRepertoire(String fichier) { + try { + new File(fichier).getParentFile().mkdirs(); + } catch (Exception e) { + } + } + + @Override + public ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException { + try { + if (in == null) { + throw new GreffonException("Le tube doit être ouvert en lecture avant d'être déchargé !"); + } + if (structure instanceof Acteur) { + Acteur acteur = (Acteur) structure; + if (!in.hasNext()) { + throw new GreffonException("Le tube est vide !"); + } + String valeur = in.nextLine(); + if (acteur.getRole() == ROLE.NOMBRE) { + try { + acteur.setValeur(new BigDecimal(valeur.trim())); + } catch (Exception e) { + throw new GreffonException("Impossible de charger le nombre !"); + } + } else + acteur.setValeur(valeur); + return acteur; + } else if (structure instanceof Casier) { + Casier casier = (Casier) structure; + Casier retour = new Casier(null); + for (ObjetLinotte element : casier) { + if (element instanceof Acteur) { + while (in.hasNext()) { + retour.add(decharger(element.clone())); + } + } else if (element instanceof Espece) { + while (in.hasNext()) { + retour.add(decharger(element.clone())); + } + } else { + throw new GreffonException("Structure incorrecte !"); + } + } + return retour; + } else if (structure instanceof Espece) { + Espece espece = (Espece) structure; + for (Acteur acteur : espece) { + decharger(acteur); + } + return espece; + } else { + throw new GreffonException("Structure incorrecte !"); + } + } catch (Exception e) { + throw new GreffonException("Le tube a recontré un problème : " + e.getMessage()); + } + } + + @Override + public ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException { + return decharger(structure); + } + + @Override + public boolean charger(ObjetLinotte structure) throws GreffonException { + try { + if (out == null) { + throw new GreffonException("Le tube doit être ouvert en écriture pour être chargé !"); + } + if (structure instanceof Acteur) { + Acteur acteur = (Acteur) structure; + try { + out.write(String.valueOf(acteur.getValeur())); + out.write(RETOUR_CHARIOT); + } catch (IOException e) { + return false; + } + return true; + } else if (structure instanceof Casier) { + Casier casier = (Casier) structure; + for (ObjetLinotte objet : casier) { + charger(objet); + } + } else if (structure instanceof Espece) { + Espece espece = (Espece) structure; + for (ObjetLinotte objet : espece) { + charger(objet); + } + } else { + throw new GreffonException("Structure incorrecte !"); + } + return false; + } catch (Exception e) { + throw new GreffonException("Le tube a recontré un problème : " + e.getMessage()); + } + } + + @Override + public boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException { + return charger(valeurs); + } + + @Override + public boolean fermer() throws GreffonException { + if (in != null) { + in.close(); + return true; + } else if (out != null) { + try { + out.close(); + } catch (IOException e) { + } + return true; + } else { + throw new GreffonException("Le tube doit être ouvert avant d'être fermé !"); + } + } + + @Override + public boolean configurer(String paramètres) throws GreffonException { + return true; + } + +} diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/ImageX.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/ImageX.java index 7542132..136e4d1 100755 --- a/linotte-greffons/src/main/java/org/linotte/greffons/impl/ImageX.java +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/ImageX.java @@ -173,6 +173,10 @@ public boolean fireProperty(String attribut) { return false; } + @Override + public void modifier(String value, String attribute, String id) throws GreffonException { + } + @Slot(nom = "négatif") public boolean negatif() throws GreffonException { chargerImage(getAttributeAsString("image")); diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/PileTube.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/PileTube.java new file mode 100755 index 0000000..e5440ba --- /dev/null +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/PileTube.java @@ -0,0 +1,53 @@ +package org.linotte.greffons.impl; + +import org.linotte.greffons.externe.Tube; + +import java.util.EmptyStackException; +import java.util.Stack; + +public class PileTube extends Tube { + + Stack pile = new Stack(); + + private static final String ERREUR = "Ce verbe ne s'utilise pas avec une 'pile' !"; + + @Override + public boolean charger(ObjetLinotte valeurs) throws GreffonException { + return pile.push(valeurs) == null; + } + + @Override + public boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean configurer(String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException { + try { + return pile.pop(); + } catch (EmptyStackException e) { + return null; + } + } + + @Override + public ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean fermer() throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean ouvrir(String état, String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + +} diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/PontTube.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/PontTube.java new file mode 100755 index 0000000..cb71fd7 --- /dev/null +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/PontTube.java @@ -0,0 +1,139 @@ +package org.linotte.greffons.impl; + +import org.linotte.greffons.externe.Tube; + +import java.io.*; +import java.math.BigDecimal; +import java.net.ServerSocket; +import java.net.Socket; +import java.net.UnknownHostException; + +public class PontTube extends Tube { + + private ServerSocket service; + private Socket connexion; + private InputStream entree; + private OutputStream sortie; + + public static final int PORT = 8777; + + private static final String ERREUR = "Ce verbe ne s'utilise pas avec un 'pont' !"; + + private static final String ERREUR_CONNEXION = "La connexion n'est pas ouverte !"; + + @Override + public boolean charger(ObjetLinotte valeurs) throws GreffonException { + try { + if (sortie != null) { + ObjectOutputStream oos = new ObjectOutputStream(sortie); + oos.writeObject(valeurs); + } else { + throw new GreffonException(ERREUR_CONNEXION); + } + } catch (IOException e) { + setValeur("état", new BigDecimal(-4)); + e.printStackTrace(); + } catch (Exception e) { + setValeur("état", new BigDecimal(-9)); + e.printStackTrace(); + } + return true; + } + + @Override + public boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean configurer(String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException { + try { + if (entree != null) { + ObjectInputStream oos = new ObjectInputStream(entree); + return (ObjetLinotte) oos.readObject(); + } else { + throw new GreffonException(ERREUR_CONNEXION); + } + } catch (IOException e) { + setValeur("état", new BigDecimal(-5)); + e.printStackTrace(); + } catch (ClassNotFoundException e) { + setValeur("état", new BigDecimal(-6)); + e.printStackTrace(); + } catch (Exception e) { + setValeur("état", new BigDecimal(-7)); + e.printStackTrace(); + } + return null; + } + + @Override + public ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean fermer() throws GreffonException { + try { + if (entree != null) + entree.close(); + if (sortie != null) + sortie.close(); + if (connexion != null) + connexion.close(); + if (service != null) + service.close(); + + } catch (IOException e) { + e.printStackTrace(); + setValeur("état", new BigDecimal(-3)); + } catch (Exception e) { + e.printStackTrace(); + setValeur("état", new BigDecimal(-10)); + } + return false; + } + + @Override + public boolean ouvrir(String état, String paramètres) throws GreffonException { + if (((Acteur) getAttribute("adresse")).getValeur() == null || (((String) ((Acteur) getAttribute("adresse")).getValeur())).trim().length() == 0) { + System.out.println("Mode serveur..."); + System.out.println("Port : " + getAttribute("port")); + BigDecimal port = ((BigDecimal) ((Acteur) getAttribute("port")).getValeur()); + try { + service = new ServerSocket(port == null ? PORT : port.intValue()); + connexion = service.accept(); + entree = connexion.getInputStream(); + sortie = connexion.getOutputStream(); + setValeur("état", new BigDecimal(1)); + } catch (Exception e) { + e.printStackTrace(); + setValeur("état", new BigDecimal(-1)); + } + } else { + System.out.println("Mode client..."); + System.out.println("Adresse : " + getAttribute("adresse")); + System.out.println("Port : " + getAttribute("port")); + BigDecimal port = ((BigDecimal) ((Acteur) getAttribute("port")).getValeur()); + try { + connexion = new Socket((String) ((Acteur) getAttribute("adresse")).getValeur(), port == null ? PORT : port.intValue()); + entree = connexion.getInputStream(); + sortie = connexion.getOutputStream(); + setValeur("état", new BigDecimal(1)); + } catch (UnknownHostException e) { + setValeur("état", new BigDecimal(-3)); + e.printStackTrace(); + } catch (Exception e) { + setValeur("état", new BigDecimal(-1)); + e.printStackTrace(); + } + } + return false; + } + +} diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/Queue.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/Queue.java new file mode 100755 index 0000000..0731eb2 --- /dev/null +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/Queue.java @@ -0,0 +1,58 @@ +package org.linotte.greffons.impl; + +import org.linotte.greffons.externe.Tube; + +import java.util.EmptyStackException; +import java.util.concurrent.ConcurrentLinkedQueue; + +public class Queue extends Tube { + + private java.util.Queue pile = new ConcurrentLinkedQueue(); + + private static final String ERREUR = "Ce verbe ne s'utilise pas avec une 'pile' !"; + + @Slot + public int taille() throws GreffonException { + return pile.size(); + } + + @Override + public boolean charger(ObjetLinotte valeurs) throws GreffonException { + return pile.offer(valeurs); + } + + @Override + public boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean configurer(String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException { + try { + return pile.poll(); + } catch (EmptyStackException e) { + return null; + } + } + + @Override + public ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean fermer() throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean ouvrir(String état, String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + +} diff --git a/linotte-greffons/src/main/java/org/linotte/greffons/impl/RepertoireTube.java b/linotte-greffons/src/main/java/org/linotte/greffons/impl/RepertoireTube.java new file mode 100755 index 0000000..89a833c --- /dev/null +++ b/linotte-greffons/src/main/java/org/linotte/greffons/impl/RepertoireTube.java @@ -0,0 +1,49 @@ +package org.linotte.greffons.impl; + +import org.linotte.greffons.externe.Tube; + +import java.util.HashMap; +import java.util.Map; + +public class RepertoireTube extends Tube { + + Map registre = new HashMap(); + + private static final String ERREUR = "Ce verbe ne s'utilise pas avec un 'répertoire' !"; + + @Override + public boolean charger(ObjetLinotte valeurs) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException { + return registre.put(paramètres, valeurs) == null; + } + + @Override + public boolean configurer(String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException { + return registre.get(paramètres); + } + + @Override + public boolean fermer() throws GreffonException { + throw new GreffonException(ERREUR); + } + + @Override + public boolean ouvrir(String état, String paramètres) throws GreffonException { + throw new GreffonException(ERREUR); + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/frame/atelier/Atelier.java b/linotte-moteur/src/main/java/org/linotte/frame/atelier/Atelier.java index 12d9000..4924b6a 100755 --- a/linotte-moteur/src/main/java/org/linotte/frame/atelier/Atelier.java +++ b/linotte-moteur/src/main/java/org/linotte/frame/atelier/Atelier.java @@ -26,7 +26,10 @@ import org.linotte.frame.coloration.StyleLinotte; import org.linotte.frame.gui.JTextPaneText; import org.linotte.frame.gui.PopupListener; -import org.linotte.frame.latoile.*; +import org.linotte.frame.latoile.Couleur; +import org.linotte.frame.latoile.JPanelLaToile; +import org.linotte.frame.latoile.LaToile; +import org.linotte.frame.latoile.Toile; import org.linotte.frame.moteur.ConsoleProcess; import org.linotte.frame.moteur.Formater; import org.linotte.frame.moteur.FrameProcess; @@ -63,7 +66,6 @@ import java.io.FileOutputStream; import java.io.IOException; import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; import java.util.List; import java.util.*; @@ -104,14 +106,13 @@ public class Atelier extends AtelierFrame implements WindowListener { /** * Crée un nouvel atelier Linotte * + * @param nom Le titre de la fenêtre, usuellement "Atelier Linotte" */ public Atelier() { super(); atelier = this; } - - public static void initialisationFrameAtelierEtToile() throws InvocationTargetException, InterruptedException { Preference preference = Preference.getIntance(); // Avant chargement de la fenetre : @@ -143,8 +144,6 @@ public static void initialisationFrameAtelierEtToile() throws InvocationTargetEx atelier.initialisationComposantsAtelier(); atelier.setResizable(true); - Java6.appliquerIcone(Ressources.getImageIcon("linotte_new.png").getImage()); ; - int taille = TAILLE_H + 10; int taille2 = taille + LaToile.LARGEUR + 10; int width = Toolkit.getDefaultToolkit().getScreenSize().width; diff --git a/linotte-moteur/src/main/java/org/linotte/frame/atelier/AtelierFrame.java b/linotte-moteur/src/main/java/org/linotte/frame/atelier/AtelierFrame.java index 9ad9718..c951fa1 100755 --- a/linotte-moteur/src/main/java/org/linotte/frame/atelier/AtelierFrame.java +++ b/linotte-moteur/src/main/java/org/linotte/frame/atelier/AtelierFrame.java @@ -841,9 +841,7 @@ private JMenuItem getJMenuEspeces() { } protected JMenu getJMenuCouleurs(int m) { - VerticalGridLayout menuGrid = new VerticalGridLayout(0, 2); JMenu jMenuCouleurs = new JMenu(); - jMenuCouleurs.getPopupMenu().setLayout(menuGrid); jMenuCouleurs.setActionCommand("Couleurs"); jMenuCouleurs.setText("Couleurs " + m); jMenuCouleurs.setBackground(menuBarColor); diff --git a/linotte-moteur/src/main/java/org/linotte/frame/latoile/Java6.java b/linotte-moteur/src/main/java/org/linotte/frame/latoile/Java6.java index 70c82b4..42c9b73 100755 --- a/linotte-moteur/src/main/java/org/linotte/frame/latoile/Java6.java +++ b/linotte-moteur/src/main/java/org/linotte/frame/latoile/Java6.java @@ -2,8 +2,6 @@ import java.awt.*; import java.io.IOException; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; import java.net.URI; public class Java6 { @@ -20,27 +18,6 @@ public void browse(URI uri) throws IOException { } } - public static void appliquerIcone(Image className) - { - try { - Class util = Class.forName("com.apple.eawt.Application"); - Method getApplication = util.getMethod("getApplication", new Class[0]); - Object application = getApplication.invoke(util); - Class params[] = new Class[1]; - params[0] = Image.class; - Method setDockIconImage = util.getMethod("setDockIconImage", params); - setDockIconImage.invoke(application, className); - } catch (ClassNotFoundException e) { - // log exception - } catch (NoSuchMethodException e) { - // log exception - } catch (InvocationTargetException e) { - // log exception - } catch (IllegalAccessException e) { - // log exception - } - } - public static boolean isJava9() { double version = Double.parseDouble(System.getProperty("java.specification.version")); return version >= 9; diff --git a/linotte-moteur/src/main/java/org/linotte/frame/latoile/LaToileListener.java b/linotte-moteur/src/main/java/org/linotte/frame/latoile/LaToileListener.java index a0e12a5..29ae44a 100755 --- a/linotte-moteur/src/main/java/org/linotte/frame/latoile/LaToileListener.java +++ b/linotte-moteur/src/main/java/org/linotte/frame/latoile/LaToileListener.java @@ -180,7 +180,7 @@ public void run() { s = LaToileListener.TOUCHE_ENTREE; break; } - //System.out.println(KeyEvent.getKeyText(i)); + System.out.println(KeyEvent.getKeyText(i)); if (recepteur == null || !recepteur.evenementTouche(s)) { touches.add(s); reveillerMoteur(); diff --git a/linotte-moteur/src/main/java/org/linotte/greffons/GreffonsChargeur.java b/linotte-moteur/src/main/java/org/linotte/greffons/GreffonsChargeur.java index 6c407d8..42be2f7 100755 --- a/linotte-moteur/src/main/java/org/linotte/greffons/GreffonsChargeur.java +++ b/linotte-moteur/src/main/java/org/linotte/greffons/GreffonsChargeur.java @@ -17,113 +17,127 @@ /** * Cette classe centralise les fonctions pour trouver, instancier, stocker les * greffons en Java, Python - * + * * @author CPC + * */ public class GreffonsChargeur { - private static GreffonsChargeur instance; - - private static Map fabriques = new HashMap<>(); - - public Map cache = new HashMap<>(); - - private Map greffons = new HashMap<>(); - - static { - try { - // Prendre en compte les .class dans les repertoires greffons - URL urls[] = {Ressources.getGreffons().toURI().toURL()}; - fabriques.put("java", new JavaFactory(urls)); - - instance = new GreffonsChargeur(); - - } catch (Throwable e) { - if (Version.isBeta()) - e.printStackTrace(); - } - } - - - /** - * Retourne la liste de tous les greffons chargés - * - * @return Tous les greffons - */ - public List getGreffons() { - return new ArrayList(greffons.values()); - } - - /** - * Retourne le greffon nom - * - * @param nom - * @return un greffon - */ - public Greffon getGreffon(String nom) { - return greffons.get(nom); - } - - /** - * Retourne une nouvelle instance d'un greffon - * - * @param id - * @return le greffon - */ - public org.linotte.greffons.externe.Greffon newInstance(String id) { - Greffon greffon = greffons.get(id); - if (greffon != null) { - return greffon.newInstance(); - } else - return null; - } - - /** - * Fabrique un nouveau greffon dans le langage lang - * - * @param id - * @param classe - * @param lang - * @return le greffon - */ - public Greffon ajouterGreffon(String id, String classe, String lang) { - FabriqueGreffon fabriqueGreffon = fabriques.get(lang); - if (fabriqueGreffon == null) { - fabriqueGreffon = fabriques.get(lang); - } - if (greffons.get(id) != null) { - // Greffon déjà présent : - return null; - } else { - Greffon greffon = fabriqueGreffon.produire(id, classe); - greffons.put(id, greffon); - return greffon; - } - } - - /** - * Ajoute un nouveau jar dans le classpath - * - * @param jar - * @return - */ - public boolean ajouterJar(String jar) { - - JavaFactory fabriqueGreffonJava = (JavaFactory) fabriques.get("java"); - - File fj = new File(jar.replace("\\", "/")); - try { - fabriqueGreffonJava.addURL(fj.toURI().toURL()); - } catch (MalformedURLException e) { - e.printStackTrace(); - return false; - } - return true; - } - - - public static synchronized GreffonsChargeur getInstance() { - return instance; - } + private static GreffonsChargeur instance; + + private static Map fabriques = new HashMap<>(); + + public Map cache = new HashMap<>(); + + private Map greffons = new HashMap<>(); + + static { + try { + //SplashWindow.setProgressValue("Greffon : initialisation de JPython"); + //fabriques.put("python", new PythonFactory()); + + // Prendre en compte les .class dans les repertoires greffons + URL urls[] = {Ressources.getGreffons().toURI().toURL()}; + //for (URL url : urls) { + // new File(url.toURI()).mkdirs(); + //} + + fabriques.put("java", new JavaFactory(urls)); + + instance = new GreffonsChargeur(); + + } catch (Throwable e) { + if (Version.isBeta()) + e.printStackTrace(); + } + } + + /** + * Retourne la liste de tous les greffons chargés + * + * @return Tous les greffons + */ + public List getGreffons() { + return new ArrayList(greffons.values()); + } + + /** + * Retourne le greffon nom + * + * @param nom + * @return un greffon + */ + public Greffon getGreffon(String nom) { + return greffons.get(nom); + } + + /** + * Retourne une nouvelle instance d'un greffon + * + * @param id + * @return le greffon + */ + public org.linotte.greffons.externe.Greffon newInstance(String id) { + Greffon greffon = greffons.get(id); + if (greffon != null) { + return greffon.newInstance(); + } else + return null; + } + + /** + * Fabrique un nouveau greffon dans le langage lang + * + * @param id + * @param classe + * @param lang + * @return le greffon + */ + public Greffon ajouterGreffon(String id, String classe, String lang) { + FabriqueGreffon fabriqueGreffon = fabriques.get(lang); + if (fabriqueGreffon == null) { + if (lang != null) { + String[] p = lang.split(":"); + if (p.length > 1 && p[0].equals("jsr223")) { + fabriqueGreffon = fabriques.get("jsr223"); + } + } + if (fabriqueGreffon == null) { + fabriqueGreffon = fabriques.get("java"); + } + } + if (greffons.get(id) != null) { + // Greffon déjà présent : + return null; + } else { + Greffon greffon = fabriqueGreffon.produire(id, classe); + greffons.put(id, greffon); + return greffon; + } + } + + /** + * Ajoute un nouveau jar dans le classpath + * + * @param jar + * @return + */ + public boolean ajouterJar(String jar) { + + JavaFactory fabriqueGreffonJava = (JavaFactory) fabriques.get("java"); + + File fj = new File(jar.replace("\\", "/")); + try { + fabriqueGreffonJava.addURL(fj.toURI().toURL()); + } catch (MalformedURLException e) { + e.printStackTrace(); + return false; + } + return true; + } + + public static synchronized GreffonsChargeur getInstance() { + return instance; + } } \ No newline at end of file diff --git a/linotte-moteur/src/main/java/org/linotte/greffons/LinotteFacade.java b/linotte-moteur/src/main/java/org/linotte/greffons/LinotteFacade.java index b7d7f7c..d01aa8b 100755 --- a/linotte-moteur/src/main/java/org/linotte/greffons/LinotteFacade.java +++ b/linotte-moteur/src/main/java/org/linotte/greffons/LinotteFacade.java @@ -171,7 +171,7 @@ public static ITransparence getTransparence() { /** * Création d'un prototype depuis un greffon * - * @param xattributs + * @param attributs * Les attributs du prototypes * @param greffon * Greffon @@ -189,7 +189,7 @@ public static Prototype creationPrototype(Map xattributs, org. if (g != null) { g.setEspece(type); g.setNom(Character.toUpperCase(type.charAt(0)) + type.substring(1)); - g.setAuteur("cpc6128"); + g.setAuteur("cpc"); g.setDescription("greffon interne"); g.setVersion("1.0"); g.setAttributs(xattributs == null ? new HashMap() : xattributs); diff --git a/linotte-moteur/src/main/java/org/linotte/greffons/externe/Graphique.java b/linotte-moteur/src/main/java/org/linotte/greffons/externe/Graphique.java index 83a21a4..95e80b6 100755 --- a/linotte-moteur/src/main/java/org/linotte/greffons/externe/Graphique.java +++ b/linotte-moteur/src/main/java/org/linotte/greffons/externe/Graphique.java @@ -28,4 +28,17 @@ public abstract class Graphique extends Greffon { */ public abstract Shape getShape(); + /** + * n'est plus utilisée + * @param espece + * @param p1 + * @param p2 + * @param p3 + * @throws GreffonException + */ + @Deprecated + public void modifier(String p1, String p2, String p3) throws GreffonException { + + } + } diff --git a/linotte-moteur/src/main/java/org/linotte/greffons/externe/Tube.java b/linotte-moteur/src/main/java/org/linotte/greffons/externe/Tube.java new file mode 100755 index 0000000..94b8a51 --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/greffons/externe/Tube.java @@ -0,0 +1,71 @@ +package org.linotte.greffons.externe; + +/** + * Ce greffon permet de créer des tubes + * + * @author Ronan Mounès + * + */ +@Deprecated +public abstract class Tube extends Greffon { + + /** + * Tu ouvres EspeceTube avec "état" depuis "paramètres" + * + * @param état + * @param paramètres + * @return + */ + public abstract boolean ouvrir(String état, String paramètres) throws GreffonException; + + /** + * Tu fermes EspeceTube + * + * @param état + * @param paramètres + * @return + */ + public abstract boolean fermer() throws GreffonException; + + /** + * Tu charges Acteur dans EspeceTube + * + * @param parametre + * @param valeurs + * @return + */ + public abstract boolean charger(ObjetLinotte valeurs) throws GreffonException; + + /** + * Tu charges Acteur dans EspeceTube avec "paramètres" + * + * @param paramètres + * @param valeurs + * @return + */ + public abstract boolean charger(String paramètres, ObjetLinotte valeurs) throws GreffonException; + + /** + * Tu décharges Acteur depuis EspeceTube + * + * @return + */ + public abstract ObjetLinotte decharger(ObjetLinotte structure) throws GreffonException; + + /** + * Tu décharges Acteur depuis EspeceTube avec "paramètres" + * + * @param paramètres + * @return + */ + public abstract ObjetLinotte decharger(String paramètres, ObjetLinotte structure) throws GreffonException; + + /** + * Tu configures Acteur avec "paramètres" + * + * @param paramètres + * @return + */ + public abstract boolean configurer(String paramètres) throws GreffonException; + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/RegistreDesActions.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/RegistreDesActions.java index b9a9cca..adb2906 100755 --- a/linotte-moteur/src/main/java/org/linotte/moteur/xml/RegistreDesActions.java +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/RegistreDesActions.java @@ -103,6 +103,7 @@ public void initEtatsDuSysteme() { addAction(new ImportLivreAction()); addAction(new ParcourirDeAction()); addAction(new OterAction()); + addAction(new ModifierAction()); addAction(new RafraichirAction()); addAction(new AvancerDeAction()); addAction(new TournerADroiteAction()); @@ -110,6 +111,11 @@ public void initEtatsDuSysteme() { addAction(new ReculerDeAction()); addAction(new AppelerAction()); addAction(new ObserverAction()); + addAction(new OuvrirAction()); + addAction(new FermerTubeAction()); + addAction(new ChargerAction()); + addAction(new DechargerAction()); + addAction(new ConfigurerAction()); addAction(new EvaluerAction()); addAction(new FusionnerAction()); addAction(new FaireReagirAction()); diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ChargerAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ChargerAction.java new file mode 100755 index 0000000..04ae2e8 --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ChargerAction.java @@ -0,0 +1,91 @@ +/*********************************************************************** + * Linotte * + * Version release date : December 15, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.greffons.externe.Greffon.ObjetLinotte; +import org.linotte.greffons.externe.Tube; +import org.linotte.greffons.outils.ObjetLinotteFactory; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class ChargerAction extends Action implements IProduitCartesien { + + public ChargerAction() { + super(); + } + + @Override + public String clef() { + return "charger tube"; + } + + @Override + public ETAT analyse(String param, Job linotte, ItemXML[] valeurs, String[] annotations) throws Exception { + + Acteur[] liste = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_CHARGER, linotte, valeurs); + int nb_parametre = liste.length; + Acteur a = liste[0]; + Acteur a1 = liste[1]; + Acteur a2 = null; + if (nb_parametre > 2) { + a2 = liste[2]; + } + + if (!(a1.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CHARGER, a.toString()); + + if (a2 != null && !(a2.getRole() == Role.TEXTE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CHARGER, a2.toString()); + + Prototype e = (Prototype) a1; + Greffon greffon = e.getGreffon(); + if (greffon == null) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CHARGER, a1.toString()); + + if (!(greffon instanceof Tube)) { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CHARGER, a1.toString()); + } + + Tube tube = (Tube) greffon; + + ObjetLinotte source = ObjetLinotteFactory.copy(a); + + try { + if (a2 == null) + tube.charger(source); + else + tube.charger(a2.getValeur().toString(), source); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ConfigurerAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ConfigurerAction.java new file mode 100755 index 0000000..a1e713a --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ConfigurerAction.java @@ -0,0 +1,78 @@ +/*********************************************************************** + * Linotte * + * Version release date : December 15, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.greffons.externe.Tube; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class ConfigurerAction extends Action implements IProduitCartesien { + + public ConfigurerAction() { + super(); + } + + @Override + public String clef() { + return "configurer tube"; + } + + @Override + public ETAT analyse(String param, Job linotte, ItemXML[] valeurs, String[] annotations) throws Exception { + Acteur[] liste = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_CONFIGURER, linotte, valeurs); + Acteur a = liste[0]; + Acteur a2 = liste[1]; + + if (!(a.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CONFIGURER, a.toString()); + + if (!(a2.getRole() == Role.TEXTE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CONFIGURER, a2.toString()); + + Prototype e = (Prototype) a; + Greffon greffon = e.getGreffon(); + if (greffon == null) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CONFIGURER, a.toString()); + + if (!(greffon instanceof Tube)) { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_CONFIGURER, a.toString()); + } + + Tube tube = (Tube) greffon; + + try { + tube.configurer(a2.getValeur().toString()); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/DechargerAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/DechargerAction.java new file mode 100755 index 0000000..03b120f --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/DechargerAction.java @@ -0,0 +1,96 @@ +/*********************************************************************** + * Linotte * + * Version release date : December 15, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.greffons.externe.Greffon.ObjetLinotte; +import org.linotte.greffons.externe.Tube; +import org.linotte.greffons.outils.ObjetLinotteFactory; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.RuntimeContext; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class DechargerAction extends Action implements IProduitCartesien { + + public DechargerAction() { + super(); + } + + @Override + public String clef() { + return "décharger tube"; + } + + @Override + public ETAT analyse(String param, Job job, ItemXML[] valeurs, String[] annotations) throws Exception { + RuntimeContext runtimeContext = (RuntimeContext) job.getRuntimeContext(); + + Acteur[] liste = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_DECHARGER, job, valeurs); + int nb_parametre = liste.length; + Acteur a = liste[0]; + Acteur a1 = liste[1]; + Acteur a2 = null; + if (nb_parametre > 2) { + a2 = liste[2]; + } + + if (!(a1.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_DECHARGER, a.toString()); + + if (a2 != null && !(a2.getRole() == Role.TEXTE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_DECHARGER, a2.toString()); + + Prototype e = (Prototype) a1; + Greffon greffon = e.getGreffon(); + if (greffon == null) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_DECHARGER, a1.toString()); + + if (!(greffon instanceof Tube)) { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_DECHARGER, a1.toString()); + } + + Tube tube = (Tube) greffon; + + ObjetLinotte structure = ObjetLinotteFactory.createStructure(a, runtimeContext.getLibrairie()); + + try { + ObjetLinotte retour; + if (a2 == null) + retour = tube.decharger(structure); + else + retour = tube.decharger(a2.getValeur().toString(), structure); + ObjetLinotteFactory.copy(retour, a, runtimeContext.getLibrairie()); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/FermerTubeAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/FermerTubeAction.java new file mode 100755 index 0000000..8db4eba --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/FermerTubeAction.java @@ -0,0 +1,76 @@ +/*********************************************************************** + * Linotte * + * Version release date : December 15, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.greffons.externe.Tube; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class FermerTubeAction extends Action implements IProduitCartesien { + + public FermerTubeAction() { + super(); + } + + @Override + public String clef() { + return "fermer tube"; + } + + @Override + public ETAT analyse(String param, Job linotte, ItemXML[] valeurs, String[] annotations) throws Exception { + + Acteur[] liste = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_FERMER, linotte, valeurs); + Acteur a = liste[0]; + + if (!(a.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_FERMER, a.toString()); + + Prototype e = (Prototype) a; + Greffon greffon = e.getGreffon(); + if (greffon == null) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_FERMER, a.toString()); + + if (!(greffon instanceof Tube)) { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_FERMER, a.toString()); + } + + Tube tube = (Tube) greffon; + + try { + tube.fermer(); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ModifierAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ModifierAction.java new file mode 100755 index 0000000..9e4d1b9 --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/ModifierAction.java @@ -0,0 +1,87 @@ +/*********************************************************************** + * Linotte * + * Version release date : Febrary 04, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Graphique; +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.PrototypeGraphique; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class ModifierAction extends Action implements IProduitCartesien { + + public ModifierAction() { + super(); + } + + @Override + public String clef() { + return "verbe modifier"; + } + + @SuppressWarnings("deprecation") + @Override + public ETAT analyse(String param, Job linotte, ItemXML[] valeurs, String[] annotations) throws Exception { + + Acteur[] acteurs = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_MODIFIER, linotte, valeurs); + Acteur acteur1 = acteurs[0]; + Acteur acteur2 = acteurs[1]; + Acteur acteur3 = acteurs[2]; + Acteur acteur4 = acteurs[3]; + + if (!(acteur2.getRole() == Role.TEXTE) && !(acteur3.getRole() == Role.TEXTE) && !(acteur4.getRole() == Role.TEXTE) + && !(acteur1.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_MODIFIER); + + Prototype e = (Prototype) acteur1; + if (!e.isEspeceGraphique()) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_MODIFIER, e.toString()); + + PrototypeGraphique eg = (PrototypeGraphique) e; + if (!eg.getTypeGraphique().equals(PrototypeGraphique.TYPE_GRAPHIQUE.GREFFON)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_MODIFIER, e.toString()); + + Greffon greffon = eg.getGreffon(); + if (greffon instanceof Graphique) { + Graphique graphique = (Graphique) greffon; + String value = (String) acteur2.getValeur(); + String attribute = (String) acteur3.getValeur(); + String id = (String) acteur4.getValeur(); + try { + graphique.modifier(value, attribute, id); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + } else { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_MODIFIER, e.toString()); + } + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/OuvrirAction.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/OuvrirAction.java new file mode 100755 index 0000000..e47c690 --- /dev/null +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/actions/OuvrirAction.java @@ -0,0 +1,93 @@ +/*********************************************************************** + * Linotte * + * Version release date : December 18, 2008 * + * Author : Mounes Ronan ronan.mounes@amstrad.eu * + * * + * http://langagelinotte.free.fr * + * * + * This code is released under the GNU GPL license, version 2 or * + * later, for educational and non-commercial purposes only. * + * If any part of the code is to be included in a commercial * + * software, please contact us first for a clearance at * + * ronan.mounes@amstrad.eu * + * * + * This notice must remain intact in all copies of this code. * + * This code is distributed WITHOUT ANY WARRANTY OF ANY KIND. * + * The GNU GPL license can be found at : * + * http://www.gnu.org/copyleft/gpl.html * + * * + ***********************************************************************/ + +package org.linotte.moteur.xml.actions; + +import org.linotte.greffons.externe.Greffon; +import org.linotte.greffons.externe.Greffon.GreffonException; +import org.linotte.greffons.externe.Tube; +import org.linotte.moteur.entites.Acteur; +import org.linotte.moteur.entites.Prototype; +import org.linotte.moteur.entites.Role; +import org.linotte.moteur.exception.Constantes; +import org.linotte.moteur.exception.ErreurException; +import org.linotte.moteur.outils.Ressources; +import org.linotte.moteur.xml.alize.kernel.Action; +import org.linotte.moteur.xml.alize.kernel.Job; +import org.linotte.moteur.xml.alize.kernel.RuntimeContext; +import org.linotte.moteur.xml.alize.kernel.i.IProduitCartesien; +import org.linotte.moteur.xml.analyse.ItemXML; + +public class OuvrirAction extends Action implements IProduitCartesien { + + public OuvrirAction() { + super(); + } + + @Override + public String clef() { + return "ouvrir tube"; + } + + @Override + public ETAT analyse(String param, Job job, ItemXML[] valeurs, String[] annotations) throws Exception { + RuntimeContext runtimeContext = (RuntimeContext) job.getRuntimeContext(); + + Acteur[] liste = extractionDesActeurs(Constantes.SYNTAXE_PARAMETRE_OUVRIR, job, valeurs); + Acteur a = liste[0]; + Acteur a1 = liste[1]; + Acteur a2 = liste[2]; + + if (!(a.getRole() == Role.ESPECE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_OUVRIR, a.toString()); + + if (!(a1.getRole() == Role.TEXTE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_OUVRIR, a1.toString()); + + if (!(a2.getRole() == Role.TEXTE)) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_OUVRIR, a2.toString()); + + Prototype e = (Prototype) a; + Greffon greffon = e.getGreffon(); + if (greffon == null) + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_OUVRIR, a.toString()); + + if (!(greffon instanceof Tube)) { + throw new ErreurException(Constantes.SYNTAXE_PARAMETRE_OUVRIR, a.toString()); + } + + Tube tube = (Tube) greffon; + + if (tube.getRessourceManager() == null) { + //TODO Ne doit plus servir ici : + tube.setRessourceManager(new Ressources(runtimeContext.getLibrairie().getToilePrincipale())); + } + runtimeContext.getTubes().add(tube); + + try { + tube.ouvrir(a1.getValeur().toString(), a2.getValeur().toString()); + } catch (GreffonException e1) { + throw new ErreurException(Constantes.ERREUR_GREFFON, e1.getMessage()); + } + + return ETAT.PAS_DE_CHANGEMENT; + } + +} diff --git a/linotte-moteur/src/main/java/org/linotte/moteur/xml/alize/kernel/RuntimeContext.java b/linotte-moteur/src/main/java/org/linotte/moteur/xml/alize/kernel/RuntimeContext.java index ba7eb41..3b423c5 100755 --- a/linotte-moteur/src/main/java/org/linotte/moteur/xml/alize/kernel/RuntimeContext.java +++ b/linotte-moteur/src/main/java/org/linotte/moteur/xml/alize/kernel/RuntimeContext.java @@ -27,6 +27,7 @@ import org.linotte.frame.latoile.LaToile; import org.linotte.frame.outils.ITransparence; import org.linotte.greffons.externe.Composant; +import org.linotte.greffons.externe.Tube; import org.linotte.moteur.entites.PrototypeGraphique; import org.linotte.moteur.outils.Ressources; import org.linotte.moteur.xml.Linotte; @@ -68,6 +69,7 @@ public class RuntimeContext extends AKRuntimeContextI { private IHM ihm = null; private File reference; private Map> threads = new ConcurrentHashMap>(); + private List tubes = new ArrayList(); private List composants = new ArrayList(); // Evenements à nettoyer : private List evenements = new CopyOnWriteArrayList(); @@ -169,7 +171,14 @@ private void setStopLecture() { } reveille(); - + // On force la fermeture des tubes : + for (Tube tube : tubes) { + try { + tube.fermer(); + } catch (Exception e) { + e.printStackTrace(); + } + } // On ferme les composants : for (Composant composant : composants) { try { @@ -287,6 +296,8 @@ private void nettoyerMemoire() { reference = null; threads.clear(); threads = null; + tubes.clear(); + tubes = null; composants.clear(); composants = null; evenements.clear(); @@ -317,6 +328,14 @@ public void setEvenements(List evenements) { this.evenements = evenements; } + public List getTubes() { + return tubes; + } + + public void setTubes(List tubes) { + this.tubes = tubes; + } + public Map> getThreads() { return threads; } diff --git a/linotte-resources/src/main/exemples/00_quoideneuf.liv b/linotte-resources/src/main/exemples/00_quoideneuf.liv index f0ce702..c601bb7 100644 --- a/linotte-resources/src/main/exemples/00_quoideneuf.liv +++ b/linotte-resources/src/main/exemples/00_quoideneuf.liv @@ -21,8 +21,8 @@ Historique des versions : ------------------------- *10/04/21 - Linotte 3.9 --Evolution : Suppression de la notion de greffon tube --Evolution : Ajout de l'option petit menu dans l'Atelier + -Evolution : Suppression de la notion de greffon tube + -Evolution : Ajout de l'option petit menu dans l'Atelier *17/03/21 - Linotte 3.8 -Correction : Ne se lance pas avec Java 16 diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_ecriture.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_ecriture.liv new file mode 100644 index 0000000..281399e --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_ecriture.liv @@ -0,0 +1,12 @@ +principale : + Connecteur est un fichier + Prénom est un texte valant "Ronan" + Prénom2 est un texte valant "Magali" + Nom est un texte valant "Dupond" + Nom2 est un texte valant "Durand" + ouvre connecteur avec "écrasement" depuis "c:/temp/test_tube.txt" + charge prénom dans connecteur + charge nom dans connecteur + charge prénom2 dans connecteur + charge nom2 dans connecteur + ferme connecteur diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_lecture.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_lecture.liv new file mode 100644 index 0000000..1099453 --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_fichier_lecture.liv @@ -0,0 +1,12 @@ +prototype + Nom est un texte + Prénom est un texte + type contact contient nom, prénom + +principale : + connecteur est un fichier + c est un casier de contact + ouvre connecteur avec "lecture" depuis "c:/temp/test_tube.txt" + décharge c depuis connecteur + ferme connecteur + affiche c diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_pile.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_pile.liv new file mode 100644 index 0000000..943b115 --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_pile.liv @@ -0,0 +1,19 @@ +/*http://fr.wikipedia.org/wiki/Pile_(informatique)*/ +globale + data est un pile + +principale : + charge "pile !" dans data + charge "une" dans data + charge "dans" dans data + charge "suis" dans data + charge "je" dans data + charge "Bonjour," dans data + va vers suite + +suite : + texte est un texte valant "rien" + tant que texte != "" + décharge texte depuis data + texte ! + ferme diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_repertoire.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_repertoire.liv new file mode 100644 index 0000000..ae6dbaa --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/greffons/tube_repertoire.liv @@ -0,0 +1,16 @@ +globale + dictionnaire est un répertoire + +principale : + âge est un nombre valant 15 + Charge "Bertrand dupont" dans dictionnaire avec "utilisateur1" + Charge âge dans dictionnaire avec "utilisateur1_age" + Va vers suite + +suite : + nb est un nombre + texte est un texte + Décharge nb depuis dictionnaire avec "utilisateur1_age" + nb ! + Décharge texte depuis dictionnaire avec "utilisateur1" + texte ! diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_client.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_client.liv new file mode 100644 index 0000000..0222fd6 --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_client.liv @@ -0,0 +1,10 @@ +connexion : + connexion est un pont, adresse prend "localhost" + message est un texte valant "Bonjour !" + Ouvre connexion avec "" depuis "" + état de connexion ! + Charge message dans connexion + Décharge message depuis connexion + "Voici la réponse du serveur :" ! + Affiche message + Ferme connexion diff --git a/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_serveur.liv b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_serveur.liv new file mode 100644 index 0000000..fadc654 --- /dev/null +++ b/linotte-resources/src/main/exemples/plus_d_exemples_ici/j_expert/reseau/pont_serveur.liv @@ -0,0 +1,12 @@ +connexion : + connexion est un pont + réponse est un texte + Affiche "Lancement du serveur, on va attendre une connexion" + ouvre connexion avec "" depuis "" + Affiche "Connexion ok avec un client" + Décharge réponse depuis connexion + Affiche "Voici le message du client :" + Affiche réponse + état de connexion ! + Charge "ça marche !" dans connexion + Ferme connexion diff --git a/linotte-resources/src/main/resources/Info.plist b/linotte-resources/src/main/resources/Info.plist deleted file mode 100644 index 4abe6d7..0000000 --- a/linotte-resources/src/main/resources/Info.plist +++ /dev/null @@ -1,8 +0,0 @@ - - - - - JVMOptions - Atelier Linotte - -