package paolomind.multitalk.toolwrapper;
   
   import java.awt.event.KeyEvent;
   import java.awt.event.MouseEvent;
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.Properties;
   
   import org.python.core.PyInstance;
  import org.python.core.PyJavaInstance;
  import org.python.core.PyString;
  import org.python.util.PythonInterpreter;
  
  import paolomind.multitalk.netmessage.IMessage;
  import paolomind.multitalk.netmessage.MessageException;
  import paolomind.multitalk.netmessage.Sender;
  import paolomind.multitalk.plugin.ToolInterface;
  
  /**
   * Classe di involucro per i tool scritti in python.
   * @author paolo
   *
   */
  /**
   * @author paolo
   *
   */
  public class PythonToolWrapper implements ToolInterface, Sender {
  
    /** */
    private PythonInterpreter engine;
    /** */
    private PyInstance ptool;
  
    /** */
    private Sender sender;
  
    /**
     * costruisce il wrapper leggendo da un inputstream
     * e facendo interpretare lo script da un interprete.<br/>
     * Lo script deve definire una classe Tool basandosi sul seguente template:
     * <pre>class Tool:
  
      name="Pencil"
  
      def __init__(self):
          pass
  
      def selected(self):
          pass
  
      def mouseDown(self,evt):
          self.sel=1
          self.x0 = evt.getX()
          self.y0 = evt.getY()
  
      def mouseDrag(self,evt):
          pass
  
      def mouseUp(self,evt):
          pass
  
      def mouseMove(self,evt):
          pass
  
      def mouseClick(self,evt):
          pass
  
      def mouseIn(self,evt):
          pass
  
      def mouseOut(self,evt):
          pass
  
      def keyDown(self,evt):
          pass
  
      def keyUp(self,evt):
          pass
  
      def keyType(self,evt):
          pass
  
      def receive(self,m):
          pass
  </pre>
  L'attributo name definisce un nome univoco per il tool ed è necessario.<br/>
  Tutti i metodi sono necessario.
     * @param in lo stream da cui leggere
     * @param python l'interprete python
     * @throws IOException rilancia l'eccezione in caso di errori di I/O
     */
    public PythonToolWrapper(final InputStream in, final PythonInterpreter python)
        throws IOException {
      this.engine = python;
      engine.execfile(in);
      ptool = (PyInstance) python.eval("Tool()");
      ptool.__setattr__("sender", new PyJavaInstance((Sender) this));
    }
 
   /**
    * Propriet&agrave; del tool.
    * @return Informazioni sul tool
    * @see paolomind.multitalk.plugin.ToolInterface#getPropertes()
    */
   public final Properties getPropertes() {
     return null;
   }
 
   /**
    * invocato quando il tool viene selezionato.
    * @see paolomind.multitalk.plugin.ToolInterface#select()
    */
   public final void select() {
     ptool.invoke("selected");
   }
 
   /**
    * restituisce il proprio id.
    * @return l'identificativo dell'ogetto
    * @see paolomind.commons.NamedObject#getSelfId()
    */
   public final String getSelfId() {
     return ptool.__findattr__("name").toString();
   }
 
   /**
    * setta l'id.
    * @param name l'id con cui sarà identificato l'oggetto
    * @see paolomind.commons.NamedObject#setSelfId(java.lang.String)
    */
   public final void setSelfId(final String name) {
     ptool.__setattr__("name", new PyString(name));
   }
 
   /**
    * ricezione di un messaggio.
    *
    * @param m
    *            il messaggio da ricevere
    * @throws MessageException
    *             rilancia l'accezione in caso di errori nel messaggio
    *
    * @see paolomind.multitalk.netmessage.Receiver#receive(paolomind.multitalk.netmessage.IMessage)
    */
   public final void receive(final IMessage m) throws MessageException {
     ptool.invoke("receive", new PyJavaInstance(m));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
    */
   public final void mouseClicked(final MouseEvent e) {
     ptool.invoke("mouseClick", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
    */
   public final void mouseEntered(final MouseEvent e) {
     ptool.invoke("mouseIn", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
    */
   public final void mouseExited(final MouseEvent e) {
     ptool.invoke("mouseOut", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
    */
   public final void mousePressed(final MouseEvent e) {
     ptool.invoke("mouseDown", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
    */
   public final void mouseReleased(final MouseEvent e) {
     ptool.invoke("mouseUp", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
    */
   public final void mouseDragged(final MouseEvent e) {
     ptool.invoke("mouseDrag", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento del mouse
    * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)
    */
   public final void mouseMoved(final MouseEvent e) {
     ptool.invoke("mouseMove", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento della tastiera
    * @see java.awt.event.KeyListener#keyPressed(java.awt.event.KeyEvent)
    */
   public final void keyPressed(final KeyEvent e) {
     ptool.invoke("keyDown", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento della tastiera
    * @see java.awt.event.KeyListener#keyReleased(java.awt.event.KeyEvent)
    */
   public final void keyReleased(final KeyEvent e) {
     ptool.invoke("keyUp", new PyJavaInstance(e));
   }
 
   /**
    * @param e evento della tastiera
    * @see java.awt.event.KeyListener#keyTyped(java.awt.event.KeyEvent)
    */
   public final void keyTyped(final KeyEvent e) {
     ptool.invoke("keyType", new PyJavaInstance(e));
   }
 
   /**
    * @param m messaggio da inviare
    * @see paolomind.multitalk.netmessage.Sender#send(paolomind.multitalk.netmessage.IMessage)
    */
   public final void send(final IMessage m) {
     m.addInfo(this.getSelfId());
     sender.send(m);
   }
 
   /**
    * restituisce il sender a cui il tool invia i messaggi.
    * @return il sender a cui il tool invia i messaggi
    */
   public final Sender getSender() {
     return sender;
   }
 
   /**
    * setta il sender a cui il tool invia i messaggi.
    * @param psender il sender a cui il tool invia i messaggi
    */
   public final void setSender(final Sender psender) {
     this.sender = psender;
   }
 
 }