Java API By Example, From Geeks To Geeks.

1 package cve.esecutori; 2 3 import cve.osservatori.servizioOACesecSemantic.*; 4 import cve.esecutori.servizioEACesecSemantic.*; 5 6 7 import cve.core.elementEEL.*; 8 import cve.osservatori.*; 9 import cve.esecutori.components.specificaSem.*; 10 import cve.esecutori.components.specificaLV.*; 11 import wippog.*; // messo in lib 12 import wippog.tipidato.*; // messo in lib 13 import wippog.eccezioni.*; 14 import wippog.activator.*; 15 import wippog.event.*; 16 17 import diagrammaticLanguage.*; 18 import interactionSemantic.*; 19 20 import cve.staticLayout.*; 21 import cve.util.ConfigurationRead; 22 import cve.util.ElementXML; 23 24 import java.awt.*; 25 import java.util.*; 26 import javax.swing.*; 27 import javax.swing.tree.*; 28 29 import java.io.File ; 30 import java.io.IOException ; 31 32 import org.jdom.*; 33 import org.jdom.input.SAXBuilder; 34 import org.jdom.output.XMLOutputter; 35 36 import org.apache.log4j.Logger; 37 38 public class EACesecSemantic extends Esecutore implements IEsecutionSentenceSemantic 39 { 40     /** 41      * Contiene tutte le istanze della frase visuale 42      */ 43     private Vector sentence; 44      45     /** 46      * coppie nomeElemento, rappresentazione(icona, Cp) 47      */ 48     private HashMap rappresentations; 49 50     /** 51      * coppie nomeElemento, Configurazione(idIstanza, num_token) 52      */ 53     private ConfigElements configElements; 54      55     /** 56      * Contiene gli id degli elementi che devono essere disabilitati 57      */ 58     private Vector disabButton,enableButton; 59      60     /** 61      * Path assouluto 62      */ 63     private String path=ConfigurationRead.getCveRoot(); 64      65     /** 66      * nome dell'attributo identificatore dell'elemento alfabeto che sto analizzando 67      */ 68     private String nameId; 69      70     /** 71      * Elementi selezionati 72      */ 73     Vector listaSel; 74      75     /** 76      * Istanza della macchina wippog automa 77      */ 78     private WippogMachine aut; 79      80     /** 81      * Istanza della macchina wippog sentenza 82      */ 83     private WippogMachine sent; 84 85     /** 86      * Istanza di gestione macchina wippog esecuzione semantica 87      */ 88     private WippogMachine semexec; 89      90     private ResourcePool resource; 91      92     private IResource queryItem; 93 94     /** 95      * Istanza della macchina wippog Semantica 96      */ 97     private WippogMachine sem; 98      99     private String idWMSent, idWMSem; 100     private String fileOutSem; 101      102     /** 103      * Stato di errore Automa di Controllo 104      */ 105     private String stateError=""; 106      107     /** 108      * Contesto automa 109      */ 110     private int contestoAutoma; 111      112     /** 113      * Contesto sentenza 114      */ 115     private int contestoSentenza; 116 117     /** 118      * Contesto esecuzione 119      */ 120     private int contestoEsecuzione; 121      122     /** 123      * Orientazione Semantica 124      */ 125     private int orientation = TOKEN; 126     final private static int TOKEN=1; 127     final private static int HOLDER=2; 128     private String pathFileInit; 129 130     /** 131      * Stato Manipolazione Sentenza Visuale 132      */ 133     private int fase = CREATION; 134     final private static int CREATION=1; 135     final private static int INITIALIZE=2; 136     final private static int EXECUTION=3; 137     final private static int INIT=0; 138     final private static int SELEZIONE=1; 139     final private static int TRIGGER_REL=2; 140     final private static int TRIGGER_NON_REL=3; 141     final private static int QUERY=4; 142     final private static int RELATION_CREATED=5; 143     final private static int AFTER_REL_CREATED= 6; 144     final private static int EXEC=1; 145     final private static int EXEC_STEP=2; 146     final private static int EXEC_PAUSE=3; 147 148     // variabili di istanza utili alla gestione dei listener wippog 149 //private boolean produce=false,produceAut=false, init=false, selezione=false, triggerRel=false,triggerNonRel=false; 150 private String sincronizzatoreSent,sincronizzatoreAut; 151     private String sincronizzatoreSem, sincronizzatoreSem1 ,sincronizzatoreSemInit; 152     private String sincronizzatoreEx, sincronizzatoreSem0, sincronizzatoreSem01, sincronizzatoreSemIP, sincronizzatoreSemUpTC, sincronizzatoreSemUpTP; 153     private String idIstanza; 154     private int numEle=0; 155     private Collection lista=new Vector(); 156          157     // file scelti 158 private String fileSent = null; 159     private String fileLanguage = null; 160     private String fileAlf = null; 161     private String fileSem = null; 162     private String fileAssSem = null; 163     private String fileAssFile = null; 164 165     private Document document; 166     private Document docAssSem, docSem ,docSemOUT; 167     private Element treeSemOUT = null;; 168      169     private DefaultMutableTreeNode treeSinRules,treeSemRules, treeAlf, treeLang; 170     private DefaultMutableTreeNode treeSpeSem,treeAssSem, treeFileAssFile; 171      172     private Associations associations; 173     private Vector internal; 174     private IActivator activator; 175     private String s_activator; 176 177     private int num_internal, conta_init; 178      179     private String translationClass = new String (""); 180      181     /* ############ METODI PUBLICI ######################### */ 182      183     /** 184      * Inizializza modello (drawings, rappresentation) 185      */ 186     public EACesecSemantic() 187     { 188         Cve.errLog.debug(""); 189         sentence = new Vector(); 190         listaSel= new Vector(); 191         rappresentations=new HashMap(); 192         sincronizzatoreSent=new String (); 193         sincronizzatoreAut=new String (); 194         sincronizzatoreSem=new String (); 195         sincronizzatoreSem1=new String (); 196         sincronizzatoreSemInit=new String (); 197         sincronizzatoreEx=new String (); 198         sincronizzatoreSem0=new String (); 199         sincronizzatoreSem01=new String (); 200         sincronizzatoreSemIP=new String (); 201         sincronizzatoreSemUpTC=new String (); 202         sincronizzatoreSemUpTP=new String (); 203          204         associations = new Associations(); 205         configElements = new ConfigElements(); 206          207         //Attivatore di Default Semantico (StepActivator) 208 activator = new SeqActivator(); 209         s_activator = new String ("SeqActivator"); 210     } 211      212     //////////////LETTURA ALBERI 213 /** 214      * Restituisce il modello albero Alfabeto Liguaggio 215      * @return DefaultMutableTreeNode Root Albero Alfabeto 216      */ 217     public DefaultMutableTreeNode getModelAlf(){ 218           Cve.errLog.debug(""); 219         return treeAlf; 220     } 221 222     /** 223      * Restituisce il modello albero Automa di Controllo 224      * @return DefaultMutableTreeNode Root Albero Automa di Controllo 225      */ 226     public DefaultMutableTreeNode getModelLang(){ 227         Cve.errLog.debug(""); 228         return treeLang; 229     } 230 231     /** 232      * Restituisce il modello albero Regole Sintattiche 233      * @return DefaultMutableTreeNode Root Albero Sintattico 234      */ 235     public DefaultMutableTreeNode getModelSintRules(){ 236           Cve.errLog.debug(""); 237         return treeSinRules; 238     } 239      240     /** 241      * Restituisce il modello albero Regole Semantiche 242      * @return DefaultMutableTreeNode Root Albero Semantico 243      */ 244     public DefaultMutableTreeNode getModelSemRules(){ 245           Cve.errLog.debug(""); 246         return treeSemRules; 247     } 248      249     /** 250      * Restituisce il modello albero Associazione Regole Sintattiche <->Semantiche 251      * @return DefaultMutableTreeNode Root Albero Associazione Sint - Sem 252      */ 253     public DefaultMutableTreeNode getModelAssSem(){ 254           Cve.errLog.debug(""); 255         return treeAssSem; 256     } 257 258     /** 259      * Restituisce il modello albero Associazione tra File per Semantica 260      * @return DefaultMutableTreeNode Root Albero Associazione File per Semantica 261      */ 262     public DefaultMutableTreeNode getModelAssFile(){ 263           Cve.errLog.debug(""); 264         return treeFileAssFile; 265     } 266 267     /** 268      * Logica: setAlfabetoSent estrae i nomi dell'alfabeto e della sentenza 269      * e riempio la collezione di representations per ogni elemento 270      * dell'alfabeto (vedi classe Representation) 271      *@param fileAss file contenente la specifica dell'automa 272      * tale file contiene i tag <alfabeto> e <Sentenza>. 273      * 274      */ 275     public void setAssociation(String fileAss) { 276         Cve.errLog.debug(""); 277         ViewLog.writeInLog(" #E Eseguito setAssociation: "+fileAss+"\n"); 278          279         this.fileAssFile = fileAss; 280         //Creo nuovo oggetto di ricerca us FileAssFile 281 ElementXML objSearch = new ElementXML(fileAssFile); 282          283         //Prelevo file Sent_ 284 this.fileSent = objSearch.getParameter(objSearch.getRootDocument(),"SyntaxFile","nameFile",null,null); 285         this.fileSent = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//" + this.fileSent; 286         ViewLog.writeInLog(" #E setAssociation: file Automa Sentenza = "+fileSent+"\n"); 287         System.out.println(" #E setAssociation: file Automa Sentenza = "+fileSent); 288 289         //Prelevo file _Sem 290 this.fileSem = objSearch.getParameter(objSearch.getRootDocument(),"SemanticFile","nameFile",null,null); 291         this.fileSem = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//" + this.fileSem; 292         ViewLog.writeInLog(" #E setAssociation: file Automa Semantica = "+fileSem+"\n"); 293         System.out.println(" #E setAssociation: file Automa Semantica = "+fileSem); 294          295         //Prelevo il File di Associazione Regole 296 this.fileAssSem = objSearch.getParameter(objSearch.getRootDocument(),"AssociationFile","nameFile",null,null); 297         this.fileAssSem = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//" + this.fileAssSem; 298 299         //Prelevo il File di Associazione Regole 300 this.translationClass = objSearch.getParameter(objSearch.getRootDocument(),"TranslationSemanticClass","nameFile",null,null); 301         ViewLog.writeInLog(" #E setAssociation: Translation Semantic Class = "+translationClass+"\n"); 302         System.out.println(" #E setAssociation: Translation Semantic Class = "+translationClass); 303         ViewLog.writeInLog(" #E setAssociation: file Associazione Regole = "+fileSem+"\n"); 304         System.out.println(" #E setAssociation: file Associazione Regole = "+fileSem); 305 306         //Prelevo file Automa di Controllo 307 this.fileLanguage = objSearch.getParameter(objSearch.getRootDocument(),"ControlFile","nameFile",null,null); 308         this.fileLanguage = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//" + this.fileLanguage; 309          310         ViewLog.writeInLog(" #E setAssociation: file Automa Controllo = "+fileLanguage+"\n"); 311         System.out.println(" #E setAssociation: file Automa Controllo = "+fileLanguage); 312          313         //Creo oggetto di ricerca su file (language) per 314 //caricamento alfabeto 315 ElementXML objSearch2 = new ElementXML(fileLanguage); 316          317         //Prelevo file Alf 318 this.fileAlf = objSearch2.getParameter(objSearch2.getRootDocument(),"Alphabet","name",null,null); 319         this.fileAlf = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveVCARWRoot() + "//" + this.fileAlf; 320          321         ViewLog.writeInLog(" #E setAssociation: file Alfabeto = "+fileAlf+"\n"); 322         System.out.println(" #E setAssociation: file Alfabeto = "+fileAlf); 323          324         //Caricamento Elementi alfabeto 325 Vector attributiRap=new Vector(); 326         try { 327             Specifica spe=new Specifica(fileAlf); 328             // HashMap che contiene la coppia (nomeElemento, Rappresentation) 329 rappresentations.clear(); 330             rappresentations.putAll(spe.getRappresentation()); 331         } catch (java.io.IOException e){ 332             ViewLog.writeInLog(" #E setAssociation: file alfabeto Errato "+fileAlf+"\n"); 333         } 334         //Comunicazione all'OAC delle Rappresentazioni degli elementi dell'Alfabeto 335 //rappresentation viene utilizzato come comunicazione tra OAC-EAC 336 //per identificare gli oggetti 337 SentenceEvent sentEv=new SentenceEvent(); 338         sentEv.setActionUser("language"); 339         sentEv.setRappresentations(rappresentations); 340         ObservableCve ob=getObservable(); 341         ob.setDate(sentEv); 342          343         //Inizializzazione Automa di Controllo 344 345         ViewLog.writeInLog(" #E setAssociation: inizializzazione macchina WIPPOG AUTOMA DI CONTROLLO(abilitazioni,...)"+"\n"); 346         System.out.println(" #E setAssociation: inizializzazione macchina WIPPOG AUTOMA DI CONTROLLO(abilitazioni,...)"); 347         //SE NON INIZIALIZZO SI RICORDA L'ULTIMO STATO (es: REL) SI BLOCCA!!!! 348 contestoAutoma = INIT; 349         initWippogAutoma(fileLanguage); 350         System.out.println("Dopo Inizializzazione e prima di init"); 351         aut.addItemGet("init"); 352          353         //Inizializzazione Automa Sentenza 354 ViewLog.writeInLog(" #E setAssociation: inizializzazione macchina WIPPOG SENTENZA e sincronizzazione"+"\n"); 355         synchronized(lista) { 356             try { lista.wait();} 357             catch (InterruptedException e){ 358                 Cve.errLog.error(e.toString()); 359             } 360         } 361          362         //Inizializzazione WM di creazione Sentenza 363 initWippogSentence(); 364          365         //Inizializzazione Alberi 366 // Creazione Alberi 367 treeAlf = setFile(this.fileAlf, "ALPHABET"); 368         treeLang = setFile(this.fileLanguage,"CONTROL AUTOMATA"); 369         treeSinRules = setFile(this.fileSent, "SENTENCE RULES"); 370         treeSemRules = setFile(this.fileSem, "SEMANTIC RULES"); 371         treeAssSem = setFile(this.fileAssSem, "ASSOCIATION TREE"); 372         treeFileAssFile = setFile(this.fileAssFile, "ASSOCIATION FILE TREE"); 373 374         //Comunico cambiamenti agli osservatori 375 setModel(treeAlf, "setAlphabet" ,this.fileAlf); 376         setModel(treeLang, "setLanguage" ,this.fileLanguage); 377         setModel(treeSinRules, "setSintaxRules" ,this.fileSent); 378         setModel(treeSemRules, "setSemanticRules" ,this.fileSem); 379         setModel(treeAssSem, "setAssociationSemantic",this.fileAssSem); 380         setModel(treeFileAssFile,"setAssociationFile" ,this.fileAssFile); 381          382         //Caricamento Struttura di Associazioni 383 associations.loadAssociations(this.fileSem,this.fileAssSem); 384         System.out.println(associations.toString()); 385 386         //Inizializzazione Automa Costruzione Semantica 387 ViewLog.writeInLog(" #E setAssociation: inizializzazione macchina WIPPOG SEMANTICA e sincronizzazione"+"\n"); 388         System.out.println(" #E setAssociation: inizializzazione macchina WIPPOG SEMANTICA e sincronizzazione"); 389          390         //Inizializzazione WM di creazione Sentenza 391 //Impostazione Locale Orientazione e creazione file init 392 setOrientation(this.orientation); 393          394         initWippogSemantica(fileSem); 395                  396         //Impostazione OUT SEMANTICA 397 //NOME File di Semantica (In base all'id della WM di Sent) 398 idWMSent = sent.getId(); 399         fileOutSem = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeSemantic() + "//" + idWMSent + "_sem.xml"; 400         ViewLog.writeInLog(" #E setAssociation: file OUT Semantica temporaneo: " + fileOutSem+"\n"); 401         System.out.println(" #E setAssociation: file OUT Semantica temporaneo: " + fileOutSem); 402          403         //Creazione albero semantico di base rimandato all'inizializzazione Sem 404 } 405      406      407     /** 408      * Result: eliminazione di tutte le istanze della sentenza visuale 409      * e notifica a tutti gli osservatori il cambiamento nel modello 410      */ 411     public void clearAssociation(){ 412          413           Cve.errLog.debug(""); 414         ViewLog.writeInLog(" #E Eseguito clearAssociation"+"\n"); 415         System.out.println(" #E Eseguito clearAssociation"); 416 417         // modello sentenza posseduto esecutore 418 sentence.clear(); 419         rappresentations.clear(); 420         associations.clear(); 421         configElements.clear(); 422          423         ObservableCve ob=getObservable(); 424         SentenceEvent sentEv=new SentenceEvent(); 425         sentEv.setActionUser("clearLanguage"); 426         ob.setDate(sentEv); 427 428         //Pulizia Alberi 429 this.fileAlf = null; 430         this.fileLanguage= null; 431         this.fileSent = null; 432         this.fileSem = null; 433         this.fileAssSem = null; 434         this.fileAssFile = null; 435         treeSemOUT = null; 436          437         //Comunico cambiamenti agli osservatori 438 SentenceEvent sentEv1=new SentenceEvent(); 439         sentEv1.setActionUser("delAll"); 440         ob.setDate(sentEv1); 441          442     } 443 444     /** 445      * Result: eliminazione di tutte le istanze della sentenza visuale 446      * e notifica a tutti gli osservatori il cambiamento nel modello 447      */ 448     public void saveSentence(){ 449           Cve.errLog.debug(""); 450         ViewLog.writeInLog(" #E Eseguito saveSentence"+"\n"); 451          452         //Salvataggio Sentenza 453 454         //Da Implementare 455 //Salvataggio Semantica 456 CVESemanticFactory.createFile(sem,fileOutSem); 457     } 458 459     /** 460      * Result: la collezione degli elementi che compongono 461      * la frase visuale (sentence) 462      */ 463     public Collection getSentence(){ 464           Cve.errLog.debug(""); 465         ViewLog.writeInLog(" #E Eseguito getSentence " + "\n"); 466      467         Vector sentenceClone=new Vector(); 468         Iterator itSent=sentence.iterator(); 469         while(itSent.hasNext()){ 470             ReferrableElement element=(ReferrableElement)itSent.next(); 471             ReferrableElement elementClone=(ReferrableElement)element.clone(); 472             sentenceClone.add(elementClone); 473         } 474         return sentenceClone; 475     } 476      477     /** 478      * 479      * Viene presa la Representation associata all'idTipo e aggiornata 480      * la sentence.Verifica se l'elemento da creare e' una relazione. 481      * Viene aggiunta la risorsa wippog appropriata. 482      * Result: sentence con aggiunto nuovo id 483      * @param idTipo cliccato su un pulsante alfabeto identificato da idTipo (place,..) 484      * 485      */ 486     public Collection inputTrigger(String idTipo) 487     { 488         Cve.errLog.debug(""); 489         ViewLog.writeInLog(" "+"\n"); 490         ViewLog.writeInLog(" #E Eseguito inputTrigger del tipo "+ idTipo + "\n"); 491          492         // prendo rappresentazione dell'elemento identificato da id 493 Representation rap=(Representation)rappresentations.get(idTipo); 494         //metto path assoluto 495 String cp=rap.getAttribute("cp"); 496         cp=path+"/"+cp; 497         //<Wippog> chiedere la creazione di un elemento 498 String activity; 499         if (rap.getAttribute("relation").equals("true")) { //STO CREANDO UNA RELAZIONE 500 contestoAutoma=TRIGGER_REL; 501             contestoSentenza=TRIGGER_REL; 502             //ViewLog.writeInLog(" ->Cliccato su una relazione"+"\n"); 503 //<Wippog> chiedere la creazione di un elemento id 504 //prendere idIstanza, il resto uguale 505 activity="activity(idType="+idTipo+")"; 506             System.out.println(" #E inputTrigger: Creazione di una Relazione: "+activity); 507             System.out.println(" #E inputTrigger: Sincronizzazione Automa di Controllo"); 508             aut.addItemGet(activity); 509             synchronized(sincronizzatoreAut) { 510                 try { 511                   //System.out.println(" inputTrigger()->denro syncr"); 512 sincronizzatoreAut.wait(); 513                   //System.out.println(" inputTrigger()->fatto wait"); 514 } 515                 catch (InterruptedException e){ 516                     Cve.errLog.error(e.toString()); 517                 } 518             } 519              520             System.out.println(" #E inputTrigger: Sincronizzazione Automa di Sentenza"); 521             synchronized(sincronizzatoreSent) { 522                 try { //System.out.println(" inputTrigger()->denro syncr2"); 523 sincronizzatoreSent.wait(); 524                        //System.out.println(" inputTrigger()->fatto wait2 "); 525 } 526                 catch (InterruptedException e){ 527                     Cve.errLog.error(e.toString()); 528                 } 529             } 530              531         } else { // CREO UNA NON RELAZIONE 532 contestoAutoma=TRIGGER_NON_REL; 533             contestoSentenza=TRIGGER_NON_REL; 534             ViewLog.writeInLog(" #E inputTrigger: Selezionata una NON relazione: idTipo "+idTipo+"\n"); 535             activity="activity(generate="+idTipo+")"; 536             // prendo il nome dell'attributo identificatore dell'elemento 537 ViewLog.writeInLog(" #E inputTrigger: Creazione di una NON Relazione: "+activity+"\n"); 538             System.out.println(" #E inputTrigger: Creazione di una NON Relazione: "+activity); 539             sent.addItemGet(activity); 540             // ciclo in attesa che listener imposti true produce 541 System.out.println(" #E inputTrigger: Sincronizzazione Automa di Controllo"); 542             synchronized(sincronizzatoreSent) { 543                 try { 544                     //System.out.println(" inputTrigger()->denro syncr"); 545 sincronizzatoreSent.wait(); 546                     //System.out.println(" inputTrigger()->fatto wait"); 547 } 548                 catch (InterruptedException e){ 549                     Cve.errLog.error(e.toString()); 550                 } 551             } 552         } 553 554         //Aggiornamento Albero Semantico 555 //setModel(convertElementNode(treeSemOUT, "SEMANTIC SENTENCE"),"setSemantic" ,null); 556 557         //informo cambiamenti osservatori collegati 558 SentenceEvent sentEv=new SentenceEvent(); 559         sentEv.setActionUser("trigger"); 560         sentEv.setSentence(sentence); 561         ObservableCve ob=getObservable(); 562         ob.setDate(sentEv); 563         ViewLog.writeInLog(" #E inputTrigger: Fine creazione elemento"+"\n"); 564         System.out.println(" #E inputTrigger: Fine creazione elemento"); 565         return sentence; 566     } 567      568     /** 569      * Logica: e' stato selezionato (select true) l'elemento dell'alfabeto 570      * identificato da id (ad esempio place).Metto in listaSel tutti 571      * gli elementi selezionati 572      * Result: in sentence metto id come select 573      */ 574     public void inputSelected(String idTipo,String idIstanza, boolean select) 575     { 576         Cve.errLog.debug(""); 577         //Verifica del tipo delezionato 578 Representation rapre=(Representation)rappresentations.get(idTipo); 579         if (rapre.getAttribute("relation").equals("true") == false){ 580        581           // a <wippog> devo passare idTipo e idIstanza e action select 582 // metto in listaSel=listaSel wippog, 583 // wippog ritorna listasel e l'esecutore seleziona elementi corrispondenti 584 // parte che deve fare wippog 585 ViewLog.writeInLog(" #E Eseguito inputSelected del tipo: "+ idTipo + " Istanza: " + idIstanza + " Select: " + select + "\n"); 586           System.out.println(" #E Eseguito inputSelected del tipo: "+ idTipo + " Istanza: " + idIstanza + " Select: " + select); 587    588           contestoAutoma=SELEZIONE; 589           String action=""; 590           if (select){ // se seleziono 591 //VD 592 //action="action(select;"+"idInstance="+idIstanza+";idType="+idTipo+")"; 593 action="action(select=true;deselect=false;"+"idInstance="+idIstanza+";idType="+idTipo+")"; 594               ViewLog.writeInLog(" AZIONE:"+action+"\n"); 595           } 596           else { // se deseleziono 597 //VD 598 //action="action(deselect;"+"idInstance="+idIstanza+";idType="+idTipo+")"; 599 action="action(select=false;deselect=true;"+"idInstance="+idIstanza+";idType="+idTipo+")"; 600               ViewLog.writeInLog(" AZIONE:"+action+"\n"); 601           } 602            603           ViewLog.writeInLog(" #E inputSelected: AZIONE WIPPOG: "+action+"\n"); 604           System.out.println(" #E inputSelected: AZIONE WIPPOG: "+action); 605            606           aut.addItemGet(action); 607           // sincronizzo i thread 608 synchronized(lista) { 609               try { 610                  //System.out.println(" inputSelected()-> prima wait"); 611 lista.wait(); 612                  //System.out.println(" inputSelected()-> fatto wait"); 613 } 614               catch (InterruptedException e){ 615                 Cve.errLog.error(e.toString()); 616               } 617           } 618           SentenceEvent sentEv=new SentenceEvent(); 619           sentEv.setActionUser("selected"); 620           sentEv.setSentence(sentence); 621           ObservableCve ob=getObservable(); 622           ob.setDate(sentEv); 623         } //Controllo relazione 624 625     } 626      627     /** 628      * Logica: richiesta di una Query 629      * @param id 630      * @param idIstanza 631      */ 632     public void inputQuery(String idTipo,String idIstanza){ 633          Cve.errLog.debug(""); 634        ViewLog.writeInLog(" #E Eseguito inputQuery tipo "+ idTipo + " idIstanza: " + idIstanza + "\n"); 635        System.out.println(" #E Eseguito inputQuery tipo "+ idTipo + " idIstanza: " + idIstanza); 636 637        String activity="activity(idInstance="+idIstanza+";"+"query="+idTipo+")"; 638         //action (idInstance=11; query=observer) 639 // prendo il nome dell'attributo identificatore dell'elemento 640 ViewLog.writeInLog(" #E inputQuery: ATTIVITA' WIPPOG: "+activity+"\n"); 641        System.out.println(" #E inputQuery: ATTIVITA' WIPPOG: "+activity); 642        contestoSentenza=QUERY; 643        sent.addItemGet(activity); 644             synchronized(sincronizzatoreSent) { 645                 try { 646                       //System.out.println(" Prima di Query"); 647 sincronizzatoreSent.wait(); 648                       //System.out.println(" Dopo Query"); 649 } 650                 catch (InterruptedException e){ 651                     Cve.errLog.error(e.toString()); 652                 } 653             } 654         655        System.out.println("Elemento Selezionato: " + queryItem.toString()); 656        //Alla risposta della WM comunico a OAC la risorsa selezionata 657 SentenceEvent sentEv=new SentenceEvent(); 658        sentEv.setActionUser("query"); 659        sentEv.setSentence(sentence); 660        ObservableCve ob=getObservable(); 661        ob.setDate(sentEv); 662     } 663 664     /** 665      * Scrittura Elemento in Query 666      * 667      * @param IResource Risorsa Wippog in lettura 668      */ 669     public void setQueryItem(IResource item){ 670          Cve.errLog.debug(""); 671        this.queryItem = item; 672     } 673 674     /** 675      * Lettura Elemento in Query 676      * 677      * @return IResource Risorsa Wippog in lettura 678      */ 679     public IResource getQueryItem(){ 680          Cve.errLog.debug(""); 681        return this.queryItem; 682     } 683 684     /** 685      * Scrittura Stato di Errore generato da automa di controllo 686      * 687      * @param String descrizione stato di errore 688      */ 689     public void setStateError(String state){ 690          Cve.errLog.debug(""); 691        this.stateError = state; 692     } 693 694     /** 695      * Lettura Stato di Errore generato da automa di controllo 696      * 697      * @return String descrizione stato di errore 698      */ 699     public String getStateError(){ 700          Cve.errLog.debug(""); 701        return this.stateError; 702     } 703 704     /** 705      * Lettura da OAC configurazione elemento 706      * 707      * @return String descrizione stato di errore 708      */ 709     public ConfigElement getConfigElement(String idIstanza){ 710          Cve.errLog.debug(""); 711        return configElements.getConfig(idIstanza); 712     } 713      714     /** 715      * Logica: richiesta di una Modifica di attributi 716      * @param id 717      * @param idIstanza 718      */ 719     public void inputModify(String id,String idIstanza){ 720         Cve.errLog.debug(""); 721     } 722          723     /** 724      * Result: cancellazione tutte le istanze della sentenza visuale 725      * e notifica a tutti gli osservatori il cambiamento nel modello 726      */ 727     public void clearSentence(){ 728         Cve.errLog.debug(""); 729         // modello sentenza posseduto esecutore 730 ViewLog.writeInLog(" #E Eseguita Pulizia Sentenza (clearSentence) "+"\n"); 731         System.out.println(" #E Eseguita Pulizia Sentenza (clearSentence) "); 732 733         sentence.clear(); 734         configElements.clear(); 735         treeSemOUT = null; 736          737         //Ricreazione Ambiente di Semantica 738 initWippogSemantica(fileSem); 739          740         //Notifico cambiamenti --> Avviene in initWMSem 741 ObservableCve ob=getObservable(); 742         SentenceEvent sentEv=new SentenceEvent(); 743         sentEv.setActionUser("clearSentence"); 744         ob.setDate(sentEv); 745          746     } 747      748     /** 749      * Result: clear rappresentazione 750      */ 751     public void rappresentationsClear(){ 752           Cve.errLog.debug(""); 753         ViewLog.writeInLog(" #E Eseguita Pulizia Rappresentazioni (rappresentationsClear) "+"\n"); 754         rappresentations.clear(); 755     } 756      757     /** 758      * Result: clear sentenza 759      */ 760     public void sentenceClear(){ 761           Cve.errLog.debug(""); 762         ViewLog.writeInLog(" "+"\n"); 763         ViewLog.writeInLog(" #E Eseguita Pulizia Sentenza"+"\n"); 764         System.out.println(" #E Eseguita Pulizia Sentenza"); 765         sentence.clear(); 766     } 767      768     /** 769      * Result: rappresentazione degli elementi 770      */ 771     public HashMap getRappresentations(){ 772           Cve.errLog.debug(""); 773         ViewLog.writeInLog(" #E Eseguito Lettura Rappresentazioni (getRappresentations) "+"\n"); 774         System.out.println(" #E Eseguito Lettura Rappresentazioni (getRappresentations) "); 775         return rappresentations; 776     } 777      778     /** 779      * Result: restituisce la collezione contenente gli elementi disabilitati 780      */ 781     public Collection getDisableButton() { 782           Cve.errLog.debug(""); 783         ViewLog.writeInLog(" #E Eseguito Lettura Pulsanti disabilitati (getDisableButton) "+"\n"); 784         System.out.println(" #E Eseguito Lettura Pulsanti disabilitati (getDisableButton) "); 785         return disabButton; 786     } 787      788     /** 789      * Result: restituisce la collezione contenente gli elementi abilitati 790      */ 791     public Collection getEnableButton() { 792           Cve.errLog.debug(""); 793         ViewLog.writeInLog(" #E Eseguito Lettura Pulsanti abilitati (getEnableButton) :"+enableButton.toString()+"\n"); 794         System.out.println(" #E Eseguito Lettura Pulsanti abilitati (getEnableButton) :"+enableButton.toString()+"\n"); 795         return enableButton; 796     } 797 798     /* ################## METODI PILOTATI DA CONFIGURAZIONI ####################*/ 799      800     ////////ORIENTAZIONE 801 /** 802      * Impostazione orientazione semantica con caricamento file di Inizializzazione 803      * 804      * @param o Impostazione Orientazione Semantica (1=TOKEN, 2=HOLDER) 805      */ 806     public void setOrientation(int o){ 807           Cve.errLog.debug(""); 808         this.orientation = o; 809         ViewLog.writeInLog(" #E Eseguita Impostazione Orientamento Semantico: "+o+"\n"); 810         System.out.println(" #E Eseguita Impostazione Orientamento Semantico: "+o); 811         812        //Creazione File di inizializzazione 813 if (o==TOKEN){ 814           pathFileInit = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//semantic//generate_token.xml"; 815        } 816        if (o==HOLDER){ 817           pathFileInit = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "//semantic//generate_holder.xml"; 818        } 819        CVESemanticFactory.createFileInit(pathFileInit,o); 820         821     } 822 823     /** 824      * Lettura Orientazione Semantica 825      * 826      * @return int Orientazione Semantica (1=TOKEN, 2=HOLDER) 827      */ 828     public int getOrientation(){ 829           Cve.errLog.debug(""); 830           return this.orientation; 831     } 832 833      834     //////FASE MANIPOLAZIONE 835 /** 836      * Impostazione Fase di Manipolazione Sentenza 837      * 838      * @param fase_in Fase di Manipolazione (CREATION,INITIALIZE,EXECUTION) 839      */ 840     public void setFase(int fase_in){ 841        Cve.errLog.debug(""); 842        this.fase = fase_in; 843          System.out.println(" #E Eseguita Impostazione Fase Manipolazione: " + this.fase); 844         845     } 846 847     /** 848      * Lettura Fase di Manipolazione Sentenza 849      * 850      * @return int Fase di Manipolazione (CREATION,INITIALIZE,EXECUTION) 851      */ 852     public int getFase(){ 853          Cve.errLog.debug(""); 854          System.out.println(" #E Eseguita lettura Fase Manipolazione: " + this.fase); 855        return this.fase ; 856     } 857 858     ////////ATTIVATORE SEMANTICO 859 /** 860      * Impostazione Attivatore WM di Esecuzione Semantica 861      * 862      * @param act Nome Attivatore Utilizzato (Attualmente solo SeqActivator(Default) e StepActivator) 863      */ 864     public void setActivator(String act){ 865        Cve.errLog.debug(""); 866        s_activator=act; 867         868        /* 869        //Creazione Istanza Attivatore 870        if (act.equals("StepActivator")){ 871           activator = new StepActivator(); 872        } 873        if (act.equals("SeqActivator")){ 874           activator = new SeqActivator(); 875        } 876        */ 877          System.out.println(" #E Eseguita Impostazione Attivatore Semantico"); 878         879     } 880 881     /** 882      * Lettura Attivatore WM di Esecuzione Semantica 883      * 884      * @return String Nome Attivatore Utilizzato (Attualmente solo SeqActivator(Default) e StepActivator) 885      */ 886     public String getActivator(){ 887          Cve.errLog.debug(""); 888          System.out.println(" #E Eseguita lettura Attivatore Semantico "); 889        return this.s_activator ; 890     } 891 892     /** 893      * Aggiornamento Grafico e Strutturale OAC dell'InternalPool generati in INIT o da WM 894      * (SOLO TOKEN ORIENTED) 895      * 896      * @param id Identificatore Elemento Semantico 897      * @param num_token Numero di Token impostati per l'elemento Semantico 898      */ 899     public void addInternalPool(String id, int num_token){ 900        Cve.errLog.debug(""); 901        System.out.println(" #E Eseguito Aggiornamento InternalPool: id: " + id + " Num.Token: " + num_token); 902        //1. AGGIORNAMENTO CONFIGURAZIONE ELEMENTO 903 ConfigElement appo_config = configElements.getConfig(id); 904        appo_config.putParameter("num_token",Integer.toString(num_token)); 905         906        //Aggiornamento Pesi (primo inserimento) 907 //String appo_wi = appo_config.getParameter("weight_inp"); 908 //if (appo_wi == null) appo_config.putParameter("weight_inp","1"); 909 910        //String appo_wo = appo_config.getParameter("weight_out"); 911 //if (appo_wo == null) appo_config.putParameter("weight_out","1"); 912 913        //2. AGGIORNAMENTO ELENCO CONFIGURAZIONI 914 configElements.removeElement(id); 915        configElements.addElement(id,appo_config); 916         917        System.out.println(" #E Eseguito Aggiornamento Configurazioni: per id: " + id); 918 919        //TEST 920 System.out.println("CONFIGURAZIONE ATTUALE ELEMENTI"); 921        System.out.println(configElements.toString()); 922 923        //3. AGGIORNAMENTO OGGETTO GRAFICO COMPLESSO (SOLO TOKEN A VIDEO) 924 //Prelevamento CGE legato all'idIstanza Selezionato 925 ReferrableElement holder=trovaDrawingDaId(id); 926        ComplexGraphicElement cge_holder = holder.getComplexGraphicElement(); 927         928        //Prima di inserire in CGE il/i token rimuovo i possibili oggetti Token 929 cge_holder.removeToken(); 930 931        VisToken tok=new VisToken(cge_holder.getX(),cge_holder.getY(),num_token); 932        cge_holder.addGraficElement(tok); 933        System.out.println(" #E Eseguito Aggiornamento CGE: per id: " + id + " Inserito Tokens: " + num_token); 934                935        //4. AGGIORNAMENTO ALBERO SEMANTICO 936 //Creazione Vettore Elementi che hanno almeno un token 937 //Ricerco tutte le chiavi presenti nell'HashMap 938 internal = new Vector(); 939        Set setKey = (configElements.getAllConfig()).keySet(); 940        941        //Scorro tutte le chiavi e prelevo info 942 Iterator assIt = setKey.iterator(); 943        String key, appo_token; 944        ConfigElement appo_config1; 945        while (assIt.hasNext()){ 946           947          //Prelevo l'elemento relativo alla chiave 948 key = (String )assIt.next(); 949          appo_config1 = configElements.getConfig(key); 950           951          appo_token = appo_config1.getParameter("num_token"); 952           953          //Verifica se esiste il parametro per l'elemento 954 if (appo_token!=null){ 955             //Verifica se esiste almeno un token per l'elemento 956 int i_token = Integer.valueOf(appo_token).intValue(); 957             if (i_token>0){ 958                 959                //Inserimento nel vettore tanti token quanti sono configurati 960 for (int i=0;i<i_token;i++){ 961                   internal.add(key); 962                } 963             } 964          } 965        } 966         967         968        //DA MODIFICARE----------------------- 969 //bisogna passare l'elenco delle configurazioni 970 971        //Aggiornamento Albero Semantica (SemanticaCVE) 972 CVESemanticFactory.addInternalPool(sem,internal); 973        //---------------------------------------- 974 975        //Aggiornamento Albero 976 setModel(convertElementNode(CVESemanticFactory.getTree(sem), "SEMANTIC SENTENCE"),"setSemantic" ,null); 977 978         979        //5. COMUNICAZIONE CAMBIAMENTI ALL'OAC 980 SentenceEvent sentEv=new SentenceEvent(); 981        sentEv.setActionUser("trigger"); 982        sentEv.setSentence(sentence); 983        ObservableCve ob=getObservable(); 984        ob.setDate(sentEv); 985         986        synchronized( sincronizzatoreSem1 ) { 987           System.out.println("Fine AddInternalPool"); 988           sincronizzatoreSem1.notifyAll(); 989        } 990     } 991 992 993     /** 994      * Aggiornamento Grafico e Strutturale OAC dell'InternalWeight generati in INIT 995      * (SOLO TOKEN ORIENTED) 996      * 997      * @param id Identificatore Elemento Semantico 998      * @param num_weight Peso impostato per l'elemento Semantico 999      */ 1000    public void updateWeight(String id, int num_weight){ 1001       Cve.errLog.debug(""); 1002       System.out.println(" #E Eseguito Aggiornamento InternalWeight: id: " + id + " Num.Weight: " + num_weight); 1003        1004       //Aggiornamento Struttura interna EAC 1005 //1. AGGIORNAMENTO CONFIGURAZIONE ELEMENTO 1006 ConfigElement appo_config = configElements.getConfig(id); 1007       appo_config.putParameter("weight",Integer.toString(num_weight)); 1008        1009       //2. AGGIORNAMENTO ELENCO CONFIGURAZIONI 1010 configElements.removeElement(id); 1011       configElements.addElement(id,appo_config); 1012        1013       System.out.println(" #E Eseguito Aggiornamento Configurazioni: per id: " + id + " Inserito Weight: " + num_weight); 1014 1015       //TEST 1016 System.out.println("CONFIGURAZIONE ATTUALE ELEMENTI"); 1017       System.out.println(configElements.toString()); 1018        1019       //------ 1020 //2.1 Aggiornamento parametri pesi per ogni oggetto Holder nelle Configurazioni 1021 // Trovare source e target della relazione ed aggiornare pesi nelle configurazioni 1022 1023       //3. AGGIORNAMENTO OGGETTO GRAFICO COMPLESSO 1024 //Prelevamento CGE legato all'idIstanza Selezionato (Da Generalizzare 1025 ReferrableConnection re_labeled=(ReferrableConnection)trovaDrawingDaId(id); 1026        1027       //if (re_labeled instanceof ReferrableConnection) re_labeled = (ReferrableConnection)re_labeled; 1028 1029       ComplexGraphicElement cge_labeled = re_labeled.getComplexGraphicElement(); 1030        1031       //Prima di Configurare il peso elimino l'etichetta weight precedentemente impostata 1032 //NOTA: Attualemnte è gestita una sola etichetta weight 1033 cge_labeled.removeLabel("weight"); 1034 1035       VisLabel label=new VisLabel("weight",Integer.toString(num_weight)); 1036       cge_labeled.addGraficElement(label); 1037       System.out.println(" #E Eseguito Aggiornamento CGE: per id: " + id + " Inserito Weight: " + num_weight); 1038        1039       //reimpostazione elemento cge 1040 re_labeled.setComplexGraphicElement(cge_labeled); 1041 1042       //Aggiornamento Struttura Semantica 1043 //CVESemanticFactory.addInternalPool(sem,internal); 1044 CVESemanticFactory.updateWeight(sem,id,num_weight); 1045 1046       //Aggiornamento Albero 1047 setModel(convertElementNode(CVESemanticFactory.getTree(sem), "SEMANTIC SENTENCE"),"setSemantic" ,null); 1048 1049       //5. COMUNICAZIONE CAMBIAMENTI ALL'OAC 1050 SentenceEvent sentEv=new SentenceEvent(); 1051       sentEv.setActionUser("trigger"); 1052       sentEv.setSentence(sentence); 1053       ObservableCve ob=getObservable(); 1054       ob.setDate(sentEv); 1055        1056    } 1057 1058    /** 1059     * Aggiornamento Grafico e Strutturale OAC dell'InternalWeight generati in INIT 1060     * (SOLO TOKEN ORIENTED) 1061     * 1062     * @param id Identificatore Elemento Semantico 1063     * @param num_weight Peso impostato per l'elemento Semantico 1064     */ 1065    public void updateMaxToken(String id, int max_token){ 1066       System.out.println(" #E Eseguito updateMaxToken: id: " + id + " MaxToken: " + max_token); 1067       //Aggiornamento Struttura interna EAC 1068 //1. AGGIORNAMENTO CONFIGURAZIONE ELEMENTO 1069 ConfigElement appo_config = configElements.getConfig(id); 1070       appo_config.putParameter("max_token",Integer.toString(max_token)); 1071        1072       //2. AGGIORNAMENTO ELENCO CONFIGURAZIONI 1073 configElements.removeElement(id); 1074       configElements.addElement(id,appo_config); 1075        1076       System.out.println(" #E Eseguito Aggiornamento Configurazioni: per id: " + id + " Inserito Max token: " + max_token); 1077 1078       //TEST 1079 System.out.println("CONFIGURAZIONE ATTUALE ELEMENTI"); 1080       System.out.println(configElements.toString()); 1081        1082       //------ 1083 //2.1 Aggiornamento parametri pesi per ogni oggetto Holder nelle Configurazioni 1084 // Trovare source e target della relazione ed aggiornare pesi nelle configurazioni 1085 1086       //3. AGGIORNAMENTO OGGETTO GRAFICO COMPLESSO 1087 //Prelevamento CGE legato all'idIstanza Selezionato (Da Generalizzare 1088 ReferrableElement re_labeled=trovaDrawingDaId(id); 1089        1090       //if (re_labeled instanceof ReferrableConnection) re_labeled = (ReferrableConnection)re_labeled; 1091 1092       ComplexGraphicElement cge_labeled = re_labeled.getComplexGraphicElement(); 1093        1094       //Prima di Configurare il peso elimino l'etichetta weight precedentemente impostata 1095 //NOTA: Attualemnte è gestita una sola etichetta weight 1096 cge_labeled.removeLabel("max token"); 1097 1098       VisLabel label=new VisLabel(cge_labeled.getX(),cge_labeled.getY(),"max token",Integer.toString(max_token)); 1099       cge_labeled.addGraficElement(label); 1100       System.out.println(" #E Eseguito Aggiornamento CGE: per id: " + id + " Inserito maxToken: " + max_token); 1101        1102       //reimpostazione elemento cge 1103 re_labeled.setComplexGraphicElement(cge_labeled); 1104 1105        1106       //Aggiornamento Struttura Semantica 1107 CVESemanticFactory.updateMaxToken(sem,id,max_token); 1108        1109       //Aggiornamento Albero 1110 setModel(convertElementNode(CVESemanticFactory.getTree(sem), "SEMANTIC SENTENCE"),"setSemantic" ,null); 1111 1112       //5. COMUNICAZIONE CAMBIAMENTI ALL'OAC 1113 SentenceEvent sentEv=new SentenceEvent(); 1114       sentEv.setActionUser("trigger"); 1115       sentEv.setSentence(sentence); 1116       ObservableCve ob=getObservable(); 1117       ob.setDate(sentEv); 1118        1119    } 1120 1121 1122 1123    /** 1124     * Avvio Esecuzione Semantica 1125     * 1126     */ 1127    public void startSent(){ 1128       1129      System.out.println(" #E Eseguito Avvio Semantica"); 1130      contestoEsecuzione = INIT; 1131      activator = null; 1132      semexec = null; 1133       1134      //Scrivo il File semantico (nome standard da WM Sintattico) 1135 CVESemanticFactory.createFile(sem,fileOutSem); 1136     1137      initWippogSemExecution(fileOutSem); 1138 1139   } 1140       1141    /** 1142     * Esecuzione Semantica Step by Step (caso StepActivator) 1143     * 1144     */ 1145   public void stepSent(){ 1146      System.out.println(" #E Esecuzione Semantica Passo Passo"); 1147      semexec.getActivator().trigger(); 1148   } 1149  1150    /** 1151     * Arresto Esecuzione Semantica 1152     * 1153     */ 1154   public void stopSent(){ 1155      Cve.errLog.debug(""); 1156      System.out.println(" #E Arresto Esecuzione Semantica"); 1157      try{ 1158         semexec.stop(); 1159         semexec.clearResources(); 1160      } catch(WippogException e){ 1161         Cve.errLog.error(e.toString()); 1162      } 1163            1164      contestoEsecuzione = INIT; 1165      System.out.println("FINE ESECUZIONE"); 1166      //Alla risposta della WM comunico a OAC la risorsa selezionata 1167 SentenceEvent sentEv=new SentenceEvent(); 1168      sentEv.setActionUser("endSemantic"); 1169      sentEv.setSentence(sentence); 1170      ObservableCve ob=getObservable(); 1171      ob.setDate(sentEv); 1172   } 1173 1174    /* ############# METODI PRIVATI ############################ 1175    ########################################################## */ 1176     1177    /** 1178     * Configurazione delle liste enableButton e disabButton a secondo se 1179     * il parametro enable vale true false. 1180     * Result: vengono messi nella lista disabButton (enableButton) gli id di tutti gli element che devono essere 1181     * disabilitati (abilitati) 1182     * @param stateList 1183     * @param enable 1184     */ 1185    private void setButtonState(Collection stateList,boolean enable){ 1186        Cve.errLog.debug(""); 1187          System.out.println(" #E setButtonState: Abilitazione: " + enable +" Elenco: "+ stateList.toString()); 1188        if (enable) 1189            this.enableButton=new Vector(stateList); 1190        else 1191            this.disabButton=new Vector(stateList); 1192    } 1193     1194    /** 1195     * Viene aggiunto un elemento grafico 1196     * @param d 1197     */ 1198    private void addDrawing(ReferrableElement d) 1199    { 1200        Cve.errLog.debug(""); 1201        //System.out.println(" sentence size prima->"+sentence.size()); 1202 sentence.addElement(d); 1203        //System.out.println(" sentence size dopo->"+sentence.size()); 1204 } 1205 1206 1207    /** 1208     * Viene aggiunto un Associazione 1209     * @param d 1210     */ 1211    private void addAssociation(String idSint, Association ass) 1212    { 1213        Cve.errLog.debug(""); 1214        //System.out.println(" sentence size prima->"+sentence.size()); 1215 associations.addAss(idSint,ass); 1216        //System.out.println(" sentence size dopo->"+sentence.size()); 1217 } 1218 1219     1220    /** 1221     * Verifica se idIstanza e' in listasel 1222     */ 1223    private boolean isInListaSel(String idIst){ 1224        Cve.errLog.debug(""); 1225        for (int i=0;i<listaSel.size();i++){ 1226            Object idIstListaO=listaSel.elementAt(i); 1227            String idIstLista=idIstListaO.toString(); 1228            //System.out.println ("sto visualizzando lista sel idIstLista "+idIstLista); 1229 if (idIst.equals(idIstLista)) 1230                return true; 1231        } 1232        return false; 1233    } 1234     1235    /** 1236     * Viene istanziata un listener di eventi wipppog automa. In funzione della variabile 1237     * contestoAutoma viene interpretato il risultato delle transizione Wippog. 1238     */ 1239    private void initWippogAutoma(String fileAut){ 1240        Cve.errLog.debug(""); 1241        System.out.println(" #E Inizializzazione Listener WIPPOG AUTOMA da "+fileAut); 1242        try { 1243            //java.io.PrintWriter wo = new java.io.PrintWriter( new java.io.FileOutputStream("wippog.log") ); 1244 //wippog.Log.setTraceWriter(wo); 1245 //aut=WippogFactory.load(ConfigurationRead.getCveRoot()+"/VisualLanguage/SpecificheWippog/miniCveLanguage.xml",true); 1246 aut=WippogFactory.load(fileAut,true); 1247            contestoAutoma = INIT; 1248             1249            // ################## LISTENER WIPPOG ############## 1250 aut.addWippogListener(new WippogAdapter() { 1251             1252              //Inizializzazione variabili di utilizzo nei metodi del WippogListener 1253 java.util.List items; 1254              WippogMachine wm; 1255              Collection rules; 1256              Iterator itRules; 1257              Transition t; 1258               1259              //Produzione di Risorse vera e propria 1260 public void resourceProduced( WippogEvent event ) { 1261                  Cve.errLog.debug(""); 1262                    System.out.println(" #E <WippogAut>: Ascoltatore AUT resourceProduced"); 1263                     1264                    //Inizializzazione 1265 items=event.getResouces(); 1266                    wm = event.getSource(); 1267                    try{ 1268                       wm.run(); 1269                    } catch (WippogException e){ 1270                       Cve.errLog.error(e.toString()); 1271                    } 1272                        1273                    System.out.println(" #E <WippogAut>: Ascoltatore AUT resourceProduced: Passo eseguito"); 1274              } 1275               1276              //Transizione eseguita 1277 public void stepExecuted( StepEvent event ) { 1278                  Cve.errLog.debug(""); 1279                    System.out.println(" #E <WippogAut>: Ascoltatore AUT stepExecuted: Passo eseguito"); 1280                    Iterator itItems; 1281                    IResource item; 1282                     1283                    // passo il controllo al thread principale per far eseguire wait() 1284 Thread.yield(); 1285                    //System.out.println(" init Wippog Aut dopo yield"); 1286 switch (contestoAutoma) { 1287                        case INIT: 1288                        ViewLog.writeInLog(" #E <WippogAut>: INIZIALIZZAZIONE:abilitazione pulsanti"+ "\n"); 1289                        System.out.println(" #E <WippogAut>: INIZIALIZZAZIONE:abilitazione pulsanti"); 1290                         1291                            itItems=items.iterator(); 1292                            while (itItems.hasNext()){ 1293                                item=(IResource)itItems.next(); 1294                                String nameItem=item.getTypeName(); 1295                                //ViewLog.writeInLog(" <WippogA> nome item "+ nameItem+"\n"); 1296 if (nameItem.equals("activity")){ 1297                                    Collection dButton=(Collection)item.getAttribute("dButton"); 1298                                    Iterator itbut=dButton.iterator(); 1299                                    setButtonState(dButton,false); 1300                                    SentenceEvent sentEv=new SentenceEvent(); 1301                                    sentEv.setActionUser("deselectButton"); 1302                                    ObservableCve ob=getObservable(); 1303                                    ob.setDate(sentEv); 1304                                } 1305                            } 1306                            synchronized( lista ) { 1307                                  System.out.println("Rilascio Lista da INIT"); 1308                                lista.notifyAll(); 1309                            } 1310                            break; 1311                        case SELEZIONE: 1312                             ViewLog.writeInLog(" #E <WippogAut>: Azione SELECT-DESELECT"+ "\n"); 1313                             System.out.println(" #E <WippogAut>: Azione SELECT-DESELECT"); 1314                              1315                            itItems=items.iterator(); 1316                            while (itItems.hasNext()){ 1317                                item=(IResource)itItems.next(); 1318                                String nameItem=item.getTypeName(); 1319 1320                                if (nameItem.equals("state")){ 1321                                   String stateValue = ((Stringa)item.getAttribute("current")).toString(); 1322                                   System.out.println(" #E <WippogAut>: Stato corrente: "+ stateValue); 1323                                   if (stateValue.endsWith("E")){ 1324                                      //Impostazione Stato di errore 1325 setStateError(stateValue); 1326                                       1327                                   }else{ 1328                                      setStateError(""); 1329                                   } 1330                                } 1331                                if (nameItem.equals("listaSel")){ 1332                                    listaSel.clear(); 1333                                    listaSel.addAll( (Collection)item.getAttribute("lista")); 1334                                    setSelectCp(listaSel); // configuro selezionati 1335 } 1336                                if (nameItem.equals("activity")){ 1337                                    Collection eButton=(Collection)item.getAttribute("eButton"); 1338                                    Collection dButton=(Collection)item.getAttribute("dButton"); 1339                                    if (eButton.size()>0){ 1340                                        Iterator itbut=eButton.iterator(); 1341                                        //VD 1342 System.out.println(" #E pulsanti da abilitare-->"+eButton.toString()); 1343                                        setButtonState(eButton,true); 1344                                        SentenceEvent sentEv=new SentenceEvent(); 1345                                        sentEv.setActionUser("selectButton"); 1346                                        ObservableCve ob=getObservable(); 1347                                        ob.setDate(sentEv); 1348                                    } 1349                                    if (dButton.size()>0){ 1350                                        Iterator itbut=dButton.iterator(); 1351                                        //VD 1352 System.out.println(" #E pulsanti da disabilitare-->"+dButton.toString()); 1353                                        setButtonState(dButton,false); 1354                                        SentenceEvent sentEv=new SentenceEvent(); 1355                                        sentEv.setActionUser("deselectButton"); 1356                                        ObservableCve ob=getObservable(); 1357                                        ob.setDate(sentEv); 1358                                    } 1359                                } 1360                            } 1361                            synchronized( lista ) { 1362                                System.out.println(" <AUT>: Rilascio Lista da SELEZIONE"); 1363                                 lista.notifyAll(); 1364                                 } 1365                            break; 1366                        case TRIGGER_REL: 1367                            // prendo source e target della relazione 1368 ViewLog.writeInLog(" #E <WippogAut>: creazione RELAZIONE"+ "\n"); 1369                            System.out.println(" #E <WippogAut>: creazione RELAZIONE"); 1370                             1371                            Iterator itItemsRel=items.iterator(); 1372                            while (itItemsRel.hasNext()){ 1373                                item=(IResource)itItemsRel.next(); 1374                                String nameItem=item.getTypeName(); 1375                                 // da lista sel prendo source e target 1376 if (nameItem.equals("listaSel")){ 1377                                    ViewLog.writeInLog(" #E <WippogAut>: Creazione relazione in specifica sentenza"+"\n"); 1378                                    System.out.println(" #E <WippogAut>: Creazione relazione in specifica sentenza"); 1379                                    listaSel.clear(); 1380                                    // metto tutti gli elementi selzionati in listaSel 1381 listaSel.addAll( (Collection)item.getAttribute("lista")); 1382                                } 1383                            } 1384                            synchronized( sincronizzatoreAut ) { 1385                                System.out.println(" <AUT>: Rilascio da TRIGGER_REL"); 1386                                sincronizzatoreAut.notifyAll(); 1387                            } 1388                            break; 1389                         1390                        case RELATION_CREATED: 1391                            // disabilito pulsante rel e deseleziono cp 1392 ViewLog.writeInLog(" #E <WippogAut>: RELAZIONE CREATA"+ "\n"); 1393                             System.out.println(" #E <WippogAut>: RELAZIONE CREATA"); 1394                            listaSel.clear(); 1395                            setSelectCp(listaSel); 1396                            Iterator itItemsCre=items.iterator(); 1397                            while (itItemsCre.hasNext()){ 1398                                item=(IResource)itItemsCre.next(); 1399                                String nameItem=item.getTypeName(); 1400                                if (nameItem.equals("activity")){ 1401                                    Collection dButton=(Collection)item.getAttribute("dButton"); 1402                                    if (dButton.size()>0){ 1403                                        Iterator itbut=dButton.iterator(); 1404                                        setButtonState(dButton,false); 1405                                        SentenceEvent sentEv=new SentenceEvent(); 1406                                        sentEv.setActionUser("deselectButton"); 1407                                        ObservableCve ob=getObservable(); 1408                                        ob.setDate(sentEv); 1409                                    } 1410                                } 1411                            } 1412                             1413                            contestoAutoma = AFTER_REL_CREATED; 1414                             1415                            synchronized( sincronizzatoreAut ) { 1416                                System.out.println(" <AUT>: Rilascio da RELATION_CREATED"); 1417                                sincronizzatoreAut.notifyAll(); 1418                            } 1419                            break; 1420                         1421                    }// chiudo switch 1422 } 1423            } ); // chiudo listener 1424 } catch (Exception e) { 1425           Cve.errLog.error(e.toString()); 1426           e.printStackTrace(); 1427           ViewLog.writeInLog(" #E# problemi in wippog automa"+"\n"); 1428        } 1429    } 1430     1431    /** 1432     * Viene istanziata un listener di eventi wipppog sentenza. In funzione della variabile 1433     * contestoSentenza viene interpretato il risultato delle transizione Wippog. 1434     * Creazione di un nuovo elemento: viene assegnato ad idIstanza id elemento appena creato 1435     * Click su una relazione: vengono inseriti in listaSel (var ambiente) membri relazione 1436     */ 1437    private void initWippogSentence(){ 1438        Cve.errLog.debug(""); 1439        System.out.println(" #E Inizializzazione Listener WIPPOG SENT da "+fileSent); 1440        try { 1441            //CREAZIONE AUTOMA 1442 sent=WippogFactory.load(fileSent,true); 1443            sent.addWippogListener(new WippogAdapter() { 1444                1445              //Inizializzazione variabili di utilizzo nei metodi del WippogListener 1446 java.util.List items; 1447              WippogMachine wm; 1448              Collection rules; 1449              Iterator itRules; 1450              Transition t; 1451               1452              //Risorse prodotte per l'eseterno 1453 public void exportsPerformed( WippogEvent event){ 1454                Cve.errLog.debug(""); 1455                System.out.println(" #E <WippogSentenza>: Ascoltatore SENT exportsPerformed"); 1456                  1457                //Per Sincronizzazione 1458 //Nel caso di conditionRule -->Cambio contestoAutoma = RELATION_CREATED 1459 Collection idOut = (Collection)event.getResouces(); 1460                 if (idOut != null){ 1461                    for( Iterator itOut=idOut.iterator(); itOut.hasNext(); ) { 1462                        1463                       //Prelevamento Risorsa 1464 IResource appo_resource = (IResource)itOut.next(); 1465                       String appo_name = appo_resource.getTypeName(); 1466         1467                       System.out.println("EXPORTS : elemento: " + appo_name); 1468                        1469                       //CAMBIO IL CONTESTO DELL'AUTOMA SOLO QUNADO IL SENT HA FINITO 1470 //DI CREARE LA RELAZIONE -->Ovvero quando crea uqesta risorsa 1471 if (appo_name.equals("conditionRule")){ 1472                          contestoAutoma = RELATION_CREATED; 1473                       } 1474                        1475                    } 1476                 } 1477                 1478         }; 1479 1480               1481              //Produzione di Risorse vera e propria 1482 public void resourceProduced( WippogEvent event ) { 1483                 Cve.errLog.debug(""); 1484                  System.out.println(" #E <WippogSentenza>: Ascoltatore SENT resourceProduced"); 1485                 1486                    //Inizializzazione 1487 items=event.getResouces(); 1488                    wm = event.getSource(); 1489                          1490                   try{ 1491                       wm.run(); 1492                    } catch (WippogException e){ 1493                       Cve.errLog.error(e.toString()); 1494                    } 1495                    System.out.println(" #E <WippogSentenza>: Ascoltatore SENT resourceProduced: Passo eseguito"); 1496              } 1497 1498              //Transizione eseguita 1499 public void stepExecuted( StepEvent event ) { 1500                    Cve.errLog.debug(""); 1501                    System.out.println(" #E <WippogSentenza>: Ascoltatore SENT stepExecuted: Passo eseguito"); 1502                    rules = event.getRules(); 1503                    itRules = rules.iterator();; 1504                    //Lettura PRima transizione Avvenuta 1505 t = (Transition)itRules.next(); 1506                    // passo il controllo al thread principale per far eseguire wait() 1507 Thread.yield(); 1508                    //System.out.println(" init Wippog Sent dopo yield"); 1509 Iterator itItems; 1510                    //ViewLog.writeInLog(" <WippogSentenza> sono nell'ascolatore sentenza"+"\n"); 1511 1512                    switch (contestoSentenza){ 1513                        case TRIGGER_NON_REL: 1514                            //ViewLog.writeInLog(" <WippogS> creazione elemento non relazione"+"\n"); 1515 //ViewLog.writeInLog(" <WippogS> prendo IdTipo creato,relativa rappresentazione,nuovo id, creazione elemento"+"\n"); 1516 // 1) prendo IdTipo creato 1517 // 2) prendo relativa rappresentazione 1518 // 3) prendo l'identificatore associato alla risorsa che ho creato 1519 // 4) creo elemento 1520 String idTipo=((IResource)items.get(0)).getTypeName(); 1521                            Representation rapre=(Representation)rappresentations.get(idTipo); 1522                            nameId=rapre.getAttribute("nameId"); 1523                            IWippogObject idIstanzaW=((IResource)items.get(0)).getAttribute(nameId); 1524                             1525                            ViewLog.writeInLog(" #E <WippogSentenza>: Creazione Elemento NON RELAZIONE: idTipo: "+ idTipo + " nameId: " +nameId+" idIstanza: " +idIstanzaW+"\n"); 1526                            System.out.println(" #E <WippogSentenza>: Creazione Elemento NON RELAZIONE: idTipo: "+ idTipo + " nameId: " +nameId+" idIstanza: " +idIstanzaW); 1527                             1528                            // se la rappresentazione dell'elemento e' di tipo icon 1529 if (rapre.getAttribute("cpType").equals("icon")){ 1530                              //metto path assoluto risorsa icona e creo "icona" 1531 String cp=path+"/"+rapre.getAttribute("cp"); 1532                              ComplexGraphicElement cge=new ComplexGraphicElement(); 1533                              ImageIcon icon=new ImageIcon(cp); 1534                              //System.out.println(" 1) in eacesec prima new Icon"); 1535 IconElement ge=new IconElement(icon); 1536                              cge.addGraficElement(ge); 1537 1538                              //GF Label 1539 //Creazione Label per idIstanzaW 1540 VisLabel lb_id = new VisLabel("id",idIstanzaW.toString()); 1541                              cge.addGraficElement(lb_id); 1542 1543                              diagrammaticLanguage.Entity ent=new diagrammaticLanguage.Entity("",idTipo,idIstanzaW.toString()); 1544                              ent.setComplexGraphicElement(cge); 1545                              // aggiungo nella sentenza 1546 //addDrawing(new IconElement(iconG,idTipo,idIstanzaW.toString())); 1547 addDrawing((ReferrableElement)ent); 1548                            } 1549                            if (rapre.getAttribute("cpType").equals("adj")){ 1550                              try { 1551                                 Class newIstanzaVis=Class.forName(rapre.getAttribute("cp")); 1552                                 GraphicElement ge=(GraphicElement)newIstanzaVis.newInstance(); 1553                                 ge.setAttachZone(new BorderPlace(ge)); 1554                                 ComplexGraphicElement cge=new ComplexGraphicElement(); 1555                                 cge.addGraficElement(ge); 1556 1557                                 //Creazione Label per idIstanzaW 1558 VisLabel lb_id = new VisLabel((int)ge.getX(), (int)ge.getY(), "id",idIstanzaW.toString()); 1559                                 cge.addGraficElement(lb_id); 1560 1561                                  //Verifica se ha l'attributo di limitazione 1562 if (rapre.getAttribute("max_token") != null){ 1563                                   //Creazione Label per idIstanzaW 1564 VisLabel lb_mt = new VisLabel((int)ge.getX(), (int)ge.getY()+15, "max token","1"); 1565                                   cge.addGraficElement(lb_mt); 1566                                  } 1567                                  1568                                 diagrammaticLanguage.Entity ent=new diagrammaticLanguage.Entity("",idTipo,idIstanzaW.toString()); 1569                                 ent.setComplexGraphicElement(cge); 1570                                 //Drawing visualElement=(Drawing)newIstanzaVis.newInstance(); 1571 //visualElement.setIdTipo(idTipo); 1572 //visualElement.setIdIstanza(idIstanzaW.toString()); 1573 //System.out.println(" aggiungo elemento in sentenza esecutore"); 1574 1575                                 addDrawing((ReferrableElement)ent); 1576                                 //System.out.println("sentence dim->"+sentence.size()); 1577 1578                              } catch(InstantiationException e){ 1579                                 Cve.errLog.error(e.toString()); 1580                                 ViewLog.writeInLog(" #E <WippogSentenza>: newIstance() fallita creazione istanza"+"\n"); 1581                              } catch(IllegalAccessException e1){ 1582                                 Cve.errLog.error(e1.toString()); 1583                                 ViewLog.writeInLog(" #E <WippogSentenza>: newIstance() fallito accesso"+"\n"); 1584                              } 1585                              catch(ClassNotFoundException e2){ 1586                                 Cve.errLog.error(e2.toString()); 1587                                 ViewLog.writeInLog(" #E <WippogSentenza>: newIstance() fallita ricerca classe"+"\n"); 1588                              } 1589                            } 1590                             1591                            //Aggiornamento Elenco Configurazioni 1592 //Elemento di Configurazione 1593 ConfigElement appo_config = new ConfigElement(); 1594                             1595                            //Creazione Parametro token solo se sono di tipo Holder 1596 if (rapre.getAttribute("holder").equals("true")){ 1597                                appo_config.putParameter("num_token","0"); 1598                                //Verifica se ha l'attributo di limitazione 1599 if (rapre.getAttribute("max_token") != null){ 1600                                  appo_config.putParameter("max_token","1"); 1601                                } 1602                             } 1603                             configElements.addElement(idIstanzaW.toString(), appo_config); 1604                              1605                             //Aggiornamento WM Semantica per creazione 1606 //updateCreationeSemantic(t,items); 1607 break; 1608                        case TRIGGER_REL: 1609 1610                            ViewLog.writeInLog(" #E <WippogSentenza>: Creazione Elemento RELAZIONE"+"\n"); 1611                            System.out.println(" #E <WippogSentenza>: Creazione Elemento RELAZIONE"); 1612                            // 0) Conosco il idType associato pulsante cliccato (ad esempio freccia) 1613 // 1) cerco rappresentazione associatata con idType (elemento relazione da creare) 1614 // 2) controllo dalla rappresentazione se bisogna creare un "icon" o di "adj" 1615 // 3) creo risorsa e prendo l'identificatore associato 1616 // 4) creo elemento relazione (se "adj" istanzio classe specificata in cpRappresentation) 1617 // 5) metto membri relazione 1618 itItems=items.iterator(); 1619                            while (itItems.hasNext()){ 1620                                IResource item=(IResource)itItems.next(); 1621                                idTipo=item.getTypeName(); 1622                                //idTipo=((IResource)items.get(0)).getTypeName(); 1623 rapre=(Representation)rappresentations.get(idTipo); 1624                                if ((rapre!=null)&&(rapre.getAttribute("relation").equals("true"))) { //trovata la relazione 1625 nameId=rapre.getAttribute("nameId"); 1626                                    //ERRORE NAMEID SBAGLIATO visualizza target 1627 1628                                    //System.out.println(" items "+item.toString()); 1629 idIstanzaW=item.getAttribute(nameId); 1630                                    ViewLog.writeInLog(" #E <WippogSentenza>: RELAZIONE idIstanza: "+idIstanzaW.toString()+" nameId: "+nameId +"\n"); 1631                                    System.out.println(" #E <WippogSentenza>: RELAZIONE idIstanza: "+idIstanzaW.toString()+" nameId: "+nameId); 1632                                     1633                                    // creo elemento source e target trovati dentro automaW 1634 //String idIstanzaW1="idI"; 1635 if (rapre.getAttribute("cpType").equals("adj")){ 1636                                       try { 1637                                          //CREAZIONE OGGETTO VISUALE (Complesso) 1638 ViewLog.writeInLog(" #E <WippogSentenza>: RELAZIONE Tipo: "+idTipo+" Rappresentazione: "+rapre.getAttribute("cp")+"\n"); 1639                                          System.out.println(" #E <WippogSentenza>: RELAZIONE Tipo: "+idTipo+" Rappresentazione: "+rapre.getAttribute("cp")); 1640                                           1641                                          //CALCOLO COORDINATE IN BASE A SOURCE,TARGET O MEMBERS 1642 /////CASO BINARIO 1643 ReferrableElement source = new ReferrableElement(); 1644                                          ReferrableElement target = new ReferrableElement(); 1645                                           1646                                          //DA LISTA SELEZIONE 1647 if (listaSel.size()>0){ 1648                                             String sourceId = listaSel.get(0).toString(); 1649                                             String targetId = listaSel.get(1).toString(); 1650                                             System.out.println(" #E <WippogSentenza>: TRIGGER_REL DA SEL: SOURCEID: "+sourceId+" TARGETID: "+targetId); 1651 1652                                             source=trovaDrawingDaId(sourceId); 1653                                             target=trovaDrawingDaId(targetId); 1654                                              1655                                             System.out.println(" #E <WippogSentenza>: TRIGGER_REL: Tipo SOURCE: "+source.getIdType()+" TARGET: "+target.getIdType()); 1656                                           1657                                             Touches touches=new Touches(source, target); 1658                                           1659                                             //Composizione oggetto grafico complesso 1660 Class newIstanzaVis=Class.forName(rapre.getAttribute("cp")); 1661                                             GraphicElement graphicRel=(GraphicElement)newIstanzaVis.newInstance(); 1662                                           1663                                           1664                                              //Impostazione coordinate 1665 Point sourceCentre = source.getComplexGraphicElement().getCentre(); 1666                                              Point targetCentre = target.getComplexGraphicElement().getCentre(); 1667                                           1668                                              ComplexGraphicElement cge=new ComplexGraphicElement(); 1669                                              cge.addGraficElement(graphicRel); 1670 1671                                                  //Creazione Label per idIstanzaW 1672 VisLabel lb_id2 = new VisLabel(sourceCentre, targetCentre, "id",idIstanzaW.toString(),1); 1673                                                  cge.addGraficElement(lb_id2); 1674         1675                                                  //Verifica se ha l'attributo di limitazione 1676 if (rapre.getAttribute("weight") != null){ 1677                                                    //Creazione Label per idIstanzaW 1678 VisLabel lb_w = new VisLabel(sourceCentre, targetCentre, "weight","1", 2); 1679                                                    cge.addGraficElement(lb_w); 1680                                                  } 1681 1682                                              //GF ERRORE INVERTITI ARGOMENTI IN CHIAMATA --> NON ASSOCIAVA ID ISTANZA MA ID TIPO 1683 ReferrableConnection con=new ReferrableConnection("",idTipo,idIstanzaW.toString()); 1684                                              con.setComplexGraphicElement(cge); 1685 1686                                              con.setTouches(touches); 1687                                           1688                                              addDrawing((ReferrableElement)con); 1689                                          } 1690                                           1691                                          //System.out.println("sentence dim->"+sentence.size()); 1692 } catch(InstantiationException e){ 1693                                          Cve.errLog.error(e.toString()); 1694                                       } catch(IllegalAccessException e1){ 1695                                          Cve.errLog.error(e1.toString()); 1696                                          ViewLog.writeInLog(" #E <WippogSentenza>: newIstance() fallito accesso"+"\n"); 1697                                       } catch(ClassNotFoundException e2){ 1698                                          Cve.errLog.error(e2.toString()); 1699                                          ViewLog.writeInLog(" #E <WippogSentenza>: newIstance() fallita ricerca classe"+"\n"); 1700                                       } 1701                                     1702                                     //Aggiornamento Elenco Configurazioni 1703 //Elemento di Configurazione 1704 ConfigElement appo_config1 = new ConfigElement(); 1705                                     //Verifica se ha l'attributo di limitazione 1706 if (rapre.getAttribute("weight") != null){ 1707                                          appo_config1.putParameter("weight","1"); 1708                                     } 1709                                       configElements.addElement(idIstanzaW.toString(), appo_config1); 1710                                     } 1711                                  } 1712                            } 1713                            break; 1714                        case QUERY: 1715                            ViewLog.writeInLog(" #E <WippogSentenza>: QUERY ELEMENT"+"\n"); 1716                            System.out.println(" #E <WippogSentenza>: QUERY ELEMENT"); 1717 1718                            itItems=items.iterator(); 1719                            while (itItems.hasNext()){ 1720                                 1721                                IResource item=(IResource)itItems.next(); 1722                                setQueryItem(item); 1723                                 1724                            } 1725                            break; 1726                    } //chiudo switch 1727 1728                    //Comunicazione all'automa (in ogni caso) 1729 synchronized( sincronizzatoreSent ) { 1730                      System.out.println(" <SENT> StepExecuted - All Cases!!!"); 1731                      sincronizzatoreSent.notifyAll(); 1732                    } 1733                    //-----------------------PER TUTTI I CASI-----------------// 1734 //Aggiornamento WM Semantica per creazione 1735 updateCreationeSemantic(t,items); 1736                    //****** COMNICAZIONE AUTOMA DI CONTROLLO 1737 1738                } // chiudo step 1739 } ); // chiudo listener 1740 1741                //sent.addItemGet("activity(generate=presenter)"); 1742 }catch (Exception e) { 1743             Cve.errLog.error(e.toString()); 1744             ViewLog.writeInLog(" #E <WippogSentenza>: problemi in wippog sentenza"+"\n"); 1745        } 1746    } 1747 1748    //----------------Aggironamento Semantica----------------- 1749 private void updateCreationeSemantic(Transition t, java.util.List items){ 1750            Cve.errLog.debug(""); 1751            System.out.println(" #E <WippogSentenza>: UpdateCreationSemantic t.iD= "+ t.getId() + " Items prodotti: " + items.toString()); 1752                    //Oggetti comuni utilizzati in manipolazione Risorse Create 1753 IResource item; 1754                    Representation rapre; 1755                    String idTipo; 1756                    IWippogObject idIstanzaW; 1757 1758                    //******LANCIO CREAZIONE RISORSA IN SEMANTICA (INDIPENDENTEMENTE DALLO STATO) 1759 //1. Verifica se esiste associazione per la Transizione in oggetto 1760 Association appo_ass = associations.getAss(t.getId()); 1761                    if (appo_ass != null){ 1762                        1763                       //2. Imposto le risorse create nei parametri in base al tipo id 1764 //Scrorrimento risorse create 1765 Iterator itItems=items.iterator(); 1766                       while (itItems.hasNext()){ 1767                          item=(IResource)itItems.next(); 1768                          idTipo=item.getTypeName(); 1769                          rapre=(Representation)rappresentations.get(idTipo); 1770                          if (rapre!=null){ 1771                             String nameId=rapre.getAttribute("nameId"); 1772                             idIstanzaW = item.getAttribute(nameId); 1773                              1774                             //Test 1775 System.out.println(" #E <WippogSentenza>: Name: " + nameId + " SentenceId: "+ idIstanzaW.toString() + " idTipo: " +idTipo); 1776                             1777                             //appo_ass.setParameter(nameId, ("id" + idIstanzaW.toString())); 1778 appo_ass.setParameter(nameId, idIstanzaW.toString()); 1779                               1780                             //Verifica esistenza parametri particolari (Gestiti a Video) 1781 //prelevamento configElement dell'item in corso 1782 ConfigElement appo_configP = configElements.getConfig(idIstanzaW.toString()); 1783                                 1784                             //max_token (se esiste-->esiste anche in generazione semantica) 1785 String app_token = appo_configP.getParameter("max_token"); 1786                              1787                             if (app_token != null) appo_ass.setParameter("max_token",app_token); 1788                             1789                             //weight 1790 String app_weight = appo_configP.getParameter("weight"); 1791                              1792                             if (app_weight != null) appo_ass.setParameter("weight",app_weight); 1793                          } 1794                       } 1795                        1796                       //3. Prelevo la risorsa da creare 1797 String appo_risorsa = associations.getResource(t.getId()); 1798                        1799                       System.out.println("Invio Semantica WM: " + sem.getId() + " Risorsa: " + appo_risorsa); 1800                       //4. Creo risorsa in macchina semantica 1801 CVESemanticFactory.setWMCurrent(sem); 1802                       sem.addItemGet(appo_risorsa); 1803                        1804                      synchronized(sincronizzatoreSem) { 1805                         try { 1806                              System.out.println(" Attesa aggiornamento Semantica"); 1807                              sincronizzatoreSem.wait(); 1808                              System.out.println(" Dopo attesa aggiornamento Semantica"); 1809                              } 1810                        catch (InterruptedException e){ 1811                          Cve.errLog.error(e.toString()); 1812                        } 1813                     } 1814                   //Aggiornamento Albero Semantico 1815 treeSemOUT = CVESemanticFactory.getTree(sem); 1816                   setModel(convertElementNode(treeSemOUT, "SEMANTIC SENTENCE"),"setSemantic" ,null); 1817              } 1818                     1819                    //TEST 1820 //Stampa Elenco Configurazione 1821 System.out.println("ELENCO CONFIGURAZIONI"); 1822                    System.out.println(configElements.toString()); 1823                    //-----------------FINE AGGIORNAMENTO CONFIGURAZIONE---------// 1824 } 1825 1826 1827    /** 1828     * Viene istanziata un listener di eventi wipppog automa. In funzione della variabile 1829     * contestoAutoma viene interpretato il risultato delle transizione Wippog. 1830     */ 1831    private void initWippogSemantica(String fileSem){ 1832        Cve.errLog.debug(""); 1833        System.out.println(" #E Inizializzazione Listener WIPPOG SEMANTICA da "+fileSem); 1834        try { 1835            //Creazione WM di Creazione Semantica 1836 sem=WippogFactory.load(fileSem,true); 1837           //Caricamento WM in lista Factory 1838 //CVESemanticFactory.load(sem,typeSemantic); 1839 CVESemanticFactory.load(sem,translationClass); 1840           //Impostazione Orientazione 1841 CVESemanticFactory.setOrientation(sem,this.orientation); 1842 1843           //Aggiornamento Albero Semantico 1844 treeSemOUT = CVESemanticFactory.getTree(sem); 1845           setModel(convertElementNode(treeSemOUT, "SEMANTIC SENTENCE"),"setSemantic" ,null); 1846 1847            // ################## LISTENER WIPPOG ############## 1848 sem.addWippogListener(new WippogAdapter() { 1849                1850               //Non utilizzato attualmente 1851 1852              //Transizione eseguita 1853 public void stepExecuted( StepEvent event ) { 1854              //public void resourceProduced( WippogEvent event ) { 1855 Cve.errLog.debug(""); 1856                 Thread.yield(); 1857                 /* 1858                 //Aggiornamento Albero Semantico 1859                 treeSemOUT = CVESemanticFactory.getTree(sem); 1860                 setModel(convertElementNode(treeSemOUT, "SEMANTIC SENTENCE"),"setSemantic" ,null); 1861                 */ 1862                 synchronized( sincronizzatoreSem ) { 1863                    System.out.println("Albero Semantico Creato"); 1864                    sincronizzatoreSem.notifyAll(); 1865                 } 1866              } 1867               1868            }); // chiudo listener 1869 1870        } catch (Exception e) { 1871           Cve.errLog.error(e.toString()); 1872           ViewLog.writeInLog(" #E# problemi in wippog automa SEMANTICA"+"\n"); 1873        } 1874         1875    } 1876 1877    /** 1878     * Creazione e Gestione WippogMachine per l'esecuzione semantica 1879     * 1880     * @param fileSem File di rappresentazione Semantica della Sentenza 1881     */ 1882    private void initWippogSemExecution(String fileSem){ 1883        Cve.errLog.debug(""); 1884        System.out.println(" #E Inizializzazione Listener WIPPOG ESECUZIONE SEMANTICA da "+fileSem); 1885        try { 1886            //Creazione WM di Esecuzione Semantica 1887 semexec = null; 1888            semexec=WippogFactory.load(pathFileInit,true); 1889            contestoEsecuzione = INIT; 1890            //semexec=new WippogMachine(); //Per caricamento InternalPool è necessario il Sequenzial 1891 //semexec=new WippogMachine(activator); 1892 1893            //Selezione Albero Associato all'albero di creazione semantica 1894 treeSemOUT = CVESemanticFactory.getTree(sem); 1895             1896            // ################## LISTENER WIPPOG ############## 1897 semexec.addWippogListener(new WippogAdapter() { 1898 1899              //Inizializzazione variabili di utilizzo nei metodi del WippogListener 1900 java.util.List itemsC; 1901              java.util.List itemsP; 1902              WippogMachine wm; 1903              Collection rules; 1904              Iterator itRules; 1905              Transition t; 1906              Collection idElementConsumed = null, idElementProduced = null; 1907               1908              //Produzione di Risorse vera e propria 1909 public void resourceConsumed( WippogEvent event ) { 1910                  Cve.errLog.debug(""); 1911                    System.out.println(" #E <WippogSemExec>: Ascoltatore SEM EXEC resourceConsumed"); 1912                    if (contestoEsecuzione == EXEC){ 1913                      Thread.yield(); 1914                      //Inizializzazione 1915 itemsC=event.getResouces(); 1916                      idElementConsumed = (Collection)event.getResouces(); 1917                      updateTokenConsumed(idElementConsumed); 1918                      idElementConsumed = null; 1919                    } 1920                    System.out.println(" #E <WippogSemExec>: Ascoltatore SEM EXEC resourceConsumed: Passo eseguito"); 1921              } 1922 1923              //Produzione di Risorse vera e propria 1924 public void resourceProduced( WippogEvent event ) { 1925                  Cve.errLog.debug(""); 1926                    System.out.println(" #E <WippogSemExec>: Ascoltatore SEM EXEC resourceProduced"); 1927                     1928                    if (contestoEsecuzione == EXEC){ 1929 1930                      Thread.yield(); 1931                      //Inizializzazione 1932 itemsP=event.getResouces(); 1933                      idElementProduced = (Collection)event.getResouces(); 1934                      updateTokenProduced(idElementProduced); 1935                      idElementProduced = null; 1936                      wm = event.getSource(); 1937                    } 1938                    System.out.println(" #E <WippogSemExec>: Ascoltatore SEM EXEC resourceProduced: Passo eseguito"); 1939              } 1940               1941              //Transizione eseguita 1942 public void stepExecuted( StepEvent event ) { 1943                  //System.out.println(" #E <WippogSemExec>: Ascoltatore SEM EXEC StepExecute"); 1944 1945                   //Aggiornamento InternalPool 1946 if (contestoEsecuzione == INIT){ 1947                       Thread.yield(); 1948                       synchronized( sincronizzatoreSemIP ) { 1949                         System.out.println("SEMEXEC - StepEsxecuted - Risorsa Creata!!!"); 1950                         sincronizzatoreSemIP.notifyAll(); 1951                       } 1952                    } 1953 1954                   //Aggiornamento Modello Semantico 1955 setModel(convertElementNode(treeSemOUT, "SEMANTIC SENTENCE"),"setSemantic" ,null); 1956 1957               } //fine stepexecuted 1958 1959            } ); // chiudo listener 1960 1961        } catch (Exception e) { 1962           Cve.errLog.error(e.toString()); 1963           ViewLog.writeInLog(" #E# problemi in wippog automa ESECUZIONE SEMANTICA"+"\n"); 1964        } 1965 1966        //----->Primo passaggio 1967 try{ 1968            //Esecuzione WM con regole di creazione (sempre come sequenziale) 1969 /* 1970            contestoEsecuzione = INIT; 1971            semexec.setActivator(new SeqActivator()); 1972            semexec.load(pathFileInit); 1973            semexec.run(); 1974            */ 1975 1976            //Caricamento Regole di creazione InternalPool 1977 addInternalPool(); 1978                         1979            //************Sincronizzazione************** 1980 semexec.stop(); 1981            System.out.println("WM SEM EXEC DOPO ADD INTERNAL POOL Activator: "+ s_activator); 1982            System.out.println(semexec.toString()); 1983             1984            //Caricamento Regole di Esecuzione Semantica 1985 contestoEsecuzione = EXEC; 1986            //Configurazione attivatore 1987 //Creazione Istanza Attivatore 1988 if (s_activator.equals("StepActivator")){ 1989                //activator = new StepActivator(); 1990 semexec.setActivator(new StepActivator()); 1991                System.out.println("***************Impostato attivatore Step"); 1992                 1993             } 1994             if (s_activator.equals("SeqActivator")){ 1995                //activator = new SeqActivator(); 1996 semexec.setActivator(new SeqActivator()); 1997                System.out.println("***************Impostato attivatore Seq"); 1998                 1999             } 2000              2001            //semexec.setActivator(activator); 2002 semexec.load(fileSem); 2003            semexec.run(); //primo passo 2004 //semexec.getActivator().trigger(); 2005 2006        } catch (Exception e) { 2007           Cve.errLog.error(e.toString()); 2008           ViewLog.writeInLog(" #E# problemi in wippog automa ESECUZIONE SEMANTICA"+"\n"); 2009        } 2010         2011    } 2012    2013    /** 2014     * Aggiornamento Situazione Token 'Consumati' ad ogni Transition 2015     * (SOLO TOKEN ORIENTED) 2016     * 2017     * @param idElementWhen Elenco risorse Consumate in una Transition 2018     */ 2019   private void updateTokenConsumed(Collection idElementWhen){ 2020         Cve.errLog.debug(""); 2021         //Aggiornamento TOKEN 2022 //PRE 2023 if (idElementWhen != null){ 2024            int num_token_input = 0; 2025            for( Iterator itWhen=idElementWhen.iterator(); itWhen.hasNext(); ) { 2026                2027               //Prelevamento Risorsa 2028 IResource appo_resource = (IResource)itWhen.next(); 2029                2030               //Prelevamento elemento Pre 2031 //IWippogObject id_obj = appo_resource.getAttribute("$id"); 2032 //*********************TOKEN ORIENTED 2033 IWippogObject id_obj = appo_resource.getAttribute("idH"); 2034 2035               String appoWhen = id_obj.toString(); 2036               System.out.println("updateTokenConsumed : elemento: " + appoWhen); 2037               //Prelevo il valore di Token precedente e ne tolgo uno 2038 ConfigElement appo_configEl = configElements.getConfig(appoWhen); 2039               num_token_input = Integer.valueOf(appo_configEl.getParameter("num_token")).intValue(); 2040                2041               if (num_token_input>=1){ 2042                  addInternalPool(appoWhen,num_token_input-1); 2043               } 2044            } 2045         } 2046 2047          synchronized( sincronizzatoreSemUpTC ) { 2048              System.out.println("Token Consumati Aggiornati"); 2049              sincronizzatoreSemUpTC.notifyAll(); 2050           } 2051 2052   } 2053 2054    2055    /** 2056     * Aggiornamento Situazione Token 'Prodotti' ad ogni Transition 2057     * (SOLO TOKEN ORIENTED) 2058     * 2059     * @param idElementProduced Elenco risorse Prodotte in una Transition 2060     */ 2061   private void updateTokenProduced(Collection idElementProduced){ 2062      Cve.errLog.debug(""); 2063         //Aggiornamento TOKEN 2064 //POST 2065 if (idElementProduced != null){ 2066             2067            int num_token_input = 0; 2068             2069            for( Iterator itProduced=idElementProduced.iterator(); itProduced.hasNext(); ) { 2070                2071               //Prelevamento Risorsa 2072 IResource appo_resource = (IResource)itProduced.next(); 2073                2074               //Prelevamento elemento Pre 2075 //IWippogObject id_obj = appo_resource.getAttribute("$id"); 2076 //*********************TOKEN ORIENTED 2077 IWippogObject id_obj = appo_resource.getAttribute("idH"); 2078 2079               String appoProduce = id_obj.toString(); 2080               System.out.println("updateTokenProduced : elemento: " + appoProduce); 2081                2082               //Prelevo il valore di Token precedente e ne tolgo uno 2083 ConfigElement appo_configEl = configElements.getConfig(appoProduce); 2084               num_token_input = Integer.valueOf(appo_configEl.getParameter("num_token")).intValue(); 2085               addInternalPool(appoProduce,num_token_input+1); 2086                 2087            } 2088         } 2089          synchronized( sincronizzatoreSemUpTP ) { 2090              System.out.println("Token Prodotti Aggiornati"); 2091              sincronizzatoreSemUpTP.notifyAll(); 2092           } 2093 2094          2095   } 2096 2097         2098    /** 2099     * Restituisce il reference al drawing relativo all'idIstanza passato come parametro 2100     * @param idIstanza 2101     */ 2102    private ReferrableElement trovaDrawingDaId(String idIstanza){ 2103        Cve.errLog.debug(""); 2104          System.out.println("trovaDrawingDaId idIstanza "+idIstanza); 2105        for (int i=0;i<sentence.size();i++){ 2106            ReferrableElement d=(ReferrableElement)sentence.elementAt(i); 2107            String idIst=d.getIdInstance(); 2108            System.out.println(" trovaDrawingDaId Elemento trovato idIstanza "+idIst); 2109            if(idIst.equals(idIstanza)){ 2110                 //System.out.println(" trovato elmento source o target x "+d.getX()+" y "+d.getY()); 2111 return d; 2112            } 2113        } 2114        return null; 2115    } 2116     2117    /** 2118     * Metto come selezionati elementi inseriti in listaSel 2119     * @param listaSel: collezione di tutti gli elementi selezionati 2120     */ 2121    private void setSelectCp(Collection listaSel){ 2122        Cve.errLog.debug(""); 2123        for (int i=0;i<sentence.size();i++){ 2124            ReferrableElement d=(ReferrableElement)sentence.elementAt(i); 2125            String idIst=d.getIdInstance(); 2126            if(isInListaSel(idIst)){ 2127                ViewLog.writeInLog(" #E Selected Element (setSelectCp): configuro l'elemento " + idIst + " come selezionato" + "\n"); 2128                System.out.println(" #E Selected Element (setSelectCp): configuro l'elemento " + idIst + " come selezionato" + "\n"); 2129 2130                d.setSelected(true); 2131            } else { 2132                ViewLog.writeInLog(" #E Selected Element (setSelectCp): configuro l'elemento " + idIst + " come NON selezionato" + "\n"); 2133                System.out.println(" #E Selected Element (setSelectCp): configuro l'elemento " + idIst + " come NON selezionato" + "\n"); 2134 2135                d.setSelected(false); 2136            } 2137        } 2138        SentenceEvent sentEv=new SentenceEvent(); 2139        sentEv.setActionUser("selected"); 2140        sentEv.setSentence(sentence); 2141        ObservableCve ob=getObservable(); 2142        ob.setDate(sentEv); 2143    } 2144     2145     2146    //GESTIONE ALBERI/////////////////////////////////// 2147 2148    /** 2149     * Comunicazione con Osservatore per Aggiornamento Modello\Azione 2150     */ 2151    private void setModel(DefaultMutableTreeNode treeModel, String Action, String pathFile){ 2152        Cve.errLog.debug(""); 2153        SentenceEvent sentEv=new SentenceEvent(); 2154        sentEv.setActionUser(Action); 2155        sentEv.setModelTree(treeModel); 2156        sentEv.setFileTree(pathFile); 2157        ObservableCve ob=getObservable(); 2158        ob.setDate(sentEv); 2159    } 2160 2161    /** 2162     * Conversione oggetto Element in oggetto TreeNode 2163     * 2164     * @param rootElement Element che costituisce l'elemento Root dell'albero 2165     * @param nameRoot Nome albero da assegnare 2166     * @return DefaultMutableTreeNode Albero TreeNode da visualizzare 2167     */ 2168    private DefaultMutableTreeNode convertElementNode(Element rootElement, String nameRoot){ 2169        Cve.errLog.debug(""); 2170        DefaultMutableTreeNode p1=new DefaultMutableTreeNode (nameRoot); 2171        addNodes(p1,rootElement); 2172        return p1; 2173    } 2174 2175 2176    /** 2177     * Viene preso un file xml, trasformato in un documento XML 2178     * e viene calcolato l'albero relativo 2179     * 2180     * @param fileLetto File XML relativo all'albero 2181     * @param nameRoot Nome del Root visualizzato 2182     * @return DefaultMutableTreeNode Albero costruito in base al file 2183     */ 2184    private DefaultMutableTreeNode setFile(String fileLetto,String nameRoot){ 2185        Cve.errLog.debug(""); 2186        DefaultMutableTreeNode p1=new DefaultMutableTreeNode (nameRoot); 2187         2188        try { 2189            // vanno messi i controlli di correttezza 2190 SAXBuilder builder = new SAXBuilder(false); 2191            document = builder.build(new File (fileLetto)); 2192            } catch (JDOMException e) { 2193                Cve.errLog.error(e.toString()); 2194            }catch (Exception e) { 2195               Cve.errLog.error(e.toString()); 2196            } 2197        Element root=document.getRootElement(); 2198        addNodes(p1,root); 2199        return p1; 2200    } 2201     2202     2203    /** 2204     * Viene aggiunto un nodo all'abero all'elemento XML 2205     * 2206     * @param pnode nodo padre a cui aggiungere il nodo 2207     * @param ele Elemento XML da aggiungere 2208     */ 2209    private void addNodes (DefaultMutableTreeNode pnode,Element ele){ 2210        Cve.errLog.debug(""); 2211        DefaultMutableTreeNode node; 2212        if ((ele!=null)&&(pnode!=null)) { 2213            java.util.List figli=ele.getChildren(); 2214            Iterator it=figli.iterator(); 2215            if (it!=null){ 2216                while (it.hasNext()){ 2217                    Element newEle=(Element)it.next(); 2218                    String nome=createString(newEle); 2219                    node= new DefaultMutableTreeNode(nome); 2220                    pnode.add(node); 2221                    addNodes(node,newEle); 2222                } 2223            } 2224        } 2225    } 2226 2227    /** 2228     * Viene effettuato il toString dell'elemento XML 2229     * 2230     * @param ele Elemento XML da convertire in Stringa per la visualizzazione nell'albero 2231     * @return String Conversione in Stringa dell'elemento XML 2232     */ 2233    private String createString(Element ele){ 2234        Cve.errLog.debug(""); 2235        String app=new String (); 2236        app=ele.getName(); 2237        java.util.List attrList=((Element)ele).getAttributes(); 2238        for (int i=0;i<attrList.size();i++){ 2239            String name=((Attribute)attrList.get(i)).getName(); 2240            String value=((Attribute)attrList.get(i)).getValue(); 2241            app=app+" "+name+"="+value; 2242            } 2243        return app; 2244    } 2245   2246 2247  ////////METODI DI SERVIZIO 2248 2249    /** 2250     * Inizializzazione InternalPool della WippogMachine Semantica 2251     * (SOLO TOKEN ORIENTED) 2252     * 2253     */ 2254  private void addInternalPool(){ 2255    Cve.errLog.debug(""); 2256    String appo_generate = new String (); 2257    num_internal = internal.size(); 2258     2259    //NOTA: LA CREAZIONE INTERNAL POOL VIENE FATTA SEMPRE CON SeqActivator 2260 System.out.println(" #E addInternalPool INIZIALE: " + num_internal + " internal: " + internal.toString()); 2261        2262       for (int i=0 ; i<internal.size();i++){ 2263       //Iterator itRes = internal.iterator(); 2264 //while (itRes.hasNext()){ 2265 2266           //String appoRes = (String)itRes.next(); 2267 String appoRes = (String )internal.get(i); 2268           if (orientation==TOKEN && appoRes != null){ 2269              System.out.println("Risorsa in creazione: " + appoRes + " numero: " + i); 2270              appo_generate = "generate(idH="+appoRes+")"; 2271              System.out.println(" creazione internal pool: " + appo_generate); 2272              semexec.addItemGet(appo_generate); 2273              //semexec.getActivator().trigger(); 2274 synchronized(sincronizzatoreSemIP) { 2275                 try { 2276                      System.out.println(" Attesa creazione internal pool"); 2277                      sincronizzatoreSemIP.wait(); 2278                      System.out.println(" Dopo attesa creazione internal pool"); 2279                      } 2280                catch (InterruptedException e){ 2281                  Cve.errLog.error(e.toString()); 2282                } 2283             } 2284          } 2285       } 2286  } //end addInternalPool 2287} //Fine esecutore

A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame Popular Tags