Java > Open Source Codes > cve > osservatori > OACesecSemantic


1 package cve.osservatori;
2
3 import cve.core.elementEEL.*;
4
5 import cve.esecutori.*;
6 import cve.esecutori.servizioEACesecSemantic.*;
7 import cve.esecutori.components.specificaSem.*;
8 import cve.esecutori.components.specificaLV.*;
9
10 import cve.osservatori.servizioOACesecSemantic.*;
11 import interactionHandler.*;
12 import interactionGraphics.*;
13
14 import cve.staticLayout.*;
15 import org.apache.log4j.Logger;
16
17 import cve.util.ConfigurationRead;
18
19 import wippog.*;
20
21 import java.io.File ;
22 import java.io.IOException ;
23 import java.io.*;
24
25 import java.awt.*;
26 import java.awt.event.*;
27 import java.util.*;
28
29 //swing classes
30 import javax.swing.text.*;
31 import javax.swing.*;
32 import javax.swing.event.*;
33
34 /**
35  * Osservatore cve finalizzato alla gestione del modello che descrive gli aspetti
36  * visuali di un linguaggio visuale. Vengono svolte le seguenti macro attivita':
37  * 1) Manipolazione degli attributi legati ad aspetti visuali della sentenza
38  * (coordinate, colori, dimensioni,...)
39  *
40  * 2) Gestione della mappatura fra l'alfabeto dei gesti eseguiti dall'utente con l'alfabeto delle azioni utente
41  * 3)Gestione della mappatura fra le azioni dell'utente e le attivita' eseguite dall'esecutore collegato
42  * 4) Definizione delle attività visuali associabili al Presenter collegato (java action)
43  * L'osservatore e' composto da:
44  * un controller di eventi (treeContr), 4 container visuali (TreeCve) ed infine il riferimento all'esecutore
45  * che implementa l'interfaccia SpecificationLanguage.
46  * Questo osservatore riceve eventi di tipo SpecificationEvent
47  *
48  * @author Francesco Guerrisi
49  * @version 1.0
50  *
51  */
52 public class OACesecSemantic extends Osservatore {
53     /**
54      * controller associato ad osservatore
55      */
56     private ControllerOACesecSemantic med;
57
58     /**
59      * Controller associato
60      */
61     private ControllerTree treeContr;
62     // container
63 private TreeCve contSemantic;
64     private TreeCve contAlphabet;
65     private TreeCve contLanguage;
66     private TreeCve contSintRules;
67     private TreeCve contSemRules;
68     private TreeCve contAssSem;
69     private TreeCve contFileAssFile;
70
71     
72     /**
73      * pulsanti afabeto
74      */
75     private HashMap buttonAlf=new HashMap();
76     
77     /**
78      * componente toolbar dell'osservatore
79      */
80     private IJTool tbar;
81     
82     /**
83     * componente canvas dell'osservatore
84     */
85     private IJCanvas canvas;
86
87     /**
88     * componente tabbed dell'osservatore
89     */
90     private IJTabbed tab;
91     
92     /**
93     * per essere compatibile un esecutore deve rispettare interfaccia
94     */
95     private IEsecutionSentenceSemantic eseGS;
96     
97     /**
98     * modalità di interazione attiva di default
99     */
100     private String modality="Modality 1";
101     
102     /**
103     * reference all'istanza attiva della classe
104     */
105     private OACesecSemantic istOACesec=this;
106         
107     //Riferimento File
108 // file scelti
109 private String fileAlf = null;
110     private String fileLanguage = null;
111     private String fileSinRules = null;
112     private String fileSemRules = null;
113     private String fileAssSem = null;
114     private String fileAssFile = null;
115     
116     private boolean semantic = false;
117     
118     //---Parametri PRE-Configurazione---
119 //Orientazione
120 private int orientation = TOKEN;
121     final private static int TOKEN=1;
122     final private static int HOLDER=2;
123     
124     //Tipo Traduzione Semantica
125 private int typeSemantic = PN_CE;
126     final private static int PN_CE=1; //PetriNet: Condition-Event
127 final private static int PN_PT=2; //PetriNet: Place-Transition
128 //----------------------------------
129
130     //---Parametri POST-Configurazione---
131 //Stato Manipolazione Sentenza Visuale
132 private int fase = CREATION;
133     final private static int CREATION=1;
134     final private static int INITIALIZE=2;
135     final private static int EXECUTION=3;
136     
137     //Attivatore Semantico Corrente
138 private String activator;
139     
140     //-----------------------------------
141 private Vector disabledButton;
142     private boolean disButton = false;
143     
144     //Maschere di Configurazione\Query
145 private ConfigurationFrame configFrame;
146     private QueryFrame queryFrame;
147     private interactionHandler.MappingEventActivity mappingEventFrame;
148     
149     //Flag di Frame Aperti
150 private boolean configFrameIsOpen = false;
151     private boolean configElementIsOpen = false;
152     //private boolean queryElementIsOpen = false;
153
154     private Presenter pre;
155     private String titlePresenter;
156     
157     /* ############# ACTION ###########################
158     ##################################################### */
159
160
161     //***MENU VISUAL SENTENCE***//
162
163     /**
164     * Apre box per scegliere un file contenete un automa,
165     * lancia esecutore.setLanguage, prende dall'esecutore la
166     * rappresentazione degli elementi dell'alfabeto
167     * crea bottoni alfabeto (action java)
168     */
169     public Action getAssociation = new AbstractAction("") {
170         public void actionPerformed(ActionEvent e) {
171               Cve.errLog.debug("");
172             ViewLog.writeInLog(" #O# Eseguita attivita' (action) getAssociation"+"\n");
173  
174             File current=new File (ConfigurationRead.getCveRoot()+"/VisualLanguage/SpecificheWippog");
175             String fileAssFile=Osservatore.getFileXml(current);
176
177             if (fileAssFile.equals("")==false ){
178                // metodo adpater rispetto ad esecutore
179 setAssociation(fileAssFile);
180                
181                //Impostazione Comandi
182 getAssociation.setEnabled(false);
183                cancAssociation.setEnabled(true);
184                cancSentence.setEnabled(false);
185                saveSentence.setEnabled(false);
186                
187                //Inizializzazione Titolo
188 pre = getPresenter();
189                if (titlePresenter == null){
190                   titlePresenter = pre.getTitle();
191                }
192                setTitle();
193             }else {
194                 
195             }
196             repaint();
197             repaintAll();
198          }
199      };
200
201     /**
202     * Cancello elementi in tbar e canvas (cancello elementi in drawings). (action java)
203     */
204     public Action cancAssociation = new AbstractAction("") {
205         public void actionPerformed(ActionEvent e) {
206             Cve.errLog.debug("");
207             ViewLog.writeInLog(" #O# Eseguita attivita' (action) cancAssociation"+"\n");
208             
209             //Impostazione file
210 fileAlf = null;
211             fileLanguage = null;
212             fileSinRules = null;
213             fileSemRules = null;
214             fileAssSem = null;
215             fileAssFile = null;
216             
217             //Pulizia totale
218 clearAssociation();
219             
220             //Impostazione comandi
221 cancAssociation.setEnabled(false);
222             cancSentence.setEnabled(false);
223             saveSentence.setEnabled(false);
224             getAssociation.setEnabled(true);
225             repaint();
226             repaintAll();
227             }
228         };
229
230     /**
231     * Caricamento Sentenza già esistente
232     */
233     public Action getSentence = new AbstractAction("") {
234         public void actionPerformed(ActionEvent e) {
235             Cve.errLog.debug("");
236             ViewLog.writeInLog(" #O# Eseguita attivita' (action) getSentence"+"\n");
237            //da implementare
238 }
239     };
240
241     /**
242     * Salvataggio Sentenza
243     */
244     public Action saveSentence = new AbstractAction("") {
245         public void actionPerformed(ActionEvent e) {
246               Cve.errLog.debug("");
247             ViewLog.writeInLog(" #O# Eseguita attivita' (action) saveSentence"+"\n");
248             saveSentence();
249         }
250     };
251
252     
253     /**
254     * Cancello elementi in tbar e canvas (cancello elementi in drawings).(action java)
255     */
256     public Action cancSentence = new AbstractAction("") {
257         public void actionPerformed(ActionEvent e) {
258             ViewLog.writeInLog(" #O# Eseguita attivita' (action) cancSentence"+"\n");
259             clearSentence();
260             //enableCreate();
261 repaint();
262             repaintAll();
263             }
264         };
265
266     //***MENU SETTING SENTENCE***//
267
268     /**
269     * Pannello di configurazione Sentenza come:
270     * Velocità Animazione, Selezione\Impostazione velore oggetti
271     *
272     */
273     public Action openConfiguration = new AbstractAction("") {
274         public void actionPerformed(ActionEvent e) {
275               Cve.errLog.debug("");
276             ViewLog.writeInLog(" #O# Eseguita attivita' (action) openConfiguration"+"\n");
277         
278            openConfigFrame();
279         }
280     };
281
282     /**
283     * Avvio Animazione Semantica
284     *
285     */
286     public Action startSent = new AbstractAction("") {
287         public void actionPerformed(ActionEvent e) {
288             Cve.errLog.debug("");
289             ViewLog.writeInLog(" #O# Eseguita attivita' (action) startSent"+"\n");
290             System.out.println(" #O# Eseguita attivita' (action) startSent");
291             
292             startExecution();
293         }
294     };
295
296
297     /**
298     * Avvio Animazione Semantica Step by Step
299     *
300     */
301     public Action stepSent = new AbstractAction("") {
302         public void actionPerformed(ActionEvent e) {
303             Cve.errLog.debug("");
304             ViewLog.writeInLog(" #O# Eseguita attivita' (action) stepSent"+"\n");
305             System.out.println(" #O# Eseguita attivita' (action) stepSent");
306             stepExecution();
307         }
308     };
309
310
311     /**
312     * Stop Animazione Semantica
313     *
314     */
315     public Action stopSent = new AbstractAction("") {
316         public void actionPerformed(ActionEvent e) {
317             Cve.errLog.debug("");
318             ViewLog.writeInLog(" #O# Eseguita attivita' (action) stopSent"+"\n");
319            stopExecution();
320         }
321     };
322
323     //***MENU SETTING ENV***//
324
325     /**
326     * Cambio modalità di interazione
327     */
328     public Action changeEventAction = new AbstractAction("") {
329         public void actionPerformed(ActionEvent e) {
330               Cve.errLog.debug("");
331             ViewLog.writeInLog(" #O# Eseguita attivita' (action) changeEventAction"+"\n");
332             
333             //Nuova Gestione Configurazione EVENTI-AZIONI Utente
334 openMappingFrame();
335             //MappingEventActivity mEventAction=new MappingEventActivity(istOACesec);
336 }
337         };
338
339     
340     /**
341     * Selezione colore oggetti in selezione
342     */
343     public Action colorSelect = new AbstractAction("") {
344         public void actionPerformed(ActionEvent e) {
345               Cve.errLog.debug("");
346             ViewLog.writeInLog(" #O# Eseguita attivita' (action) colorSelect"+"\n");
347             canvas.setColorSelected();
348             }
349         };
350
351     /**
352     * Selezione colore oggetti non selezionati
353     */
354     public Action colorDummy = new AbstractAction("") {
355         public void actionPerformed(ActionEvent e) {
356               Cve.errLog.debug("");
357             ViewLog.writeInLog(" #O# Eseguita attivita' (action) colorDummy"+"\n");
358             canvas.setColorDummy();
359             }
360         };
361
362     /**
363     * Caratteristiche avanzate
364     */
365     public Action advancedFeature = new AbstractAction("") {
366         public void actionPerformed(ActionEvent e) {
367               Cve.errLog.debug("");
368             ViewLog.writeInLog(" #O# Eseguita attivita' (action) advancedFeature"+"\n");
369         
370             canvas.advanced();
371             }
372         };
373    
374    
375     /* ######## METODI PUBLICI ########################
376     #####################################################*/
377
378     public void setMediator(Controller med){
379         Cve.errLog.debug("");
380        //med = new ControllerOACesecSemantic(this);
381 }
382     
383     /**
384     * Creazione dell'osservatore( assegnazione del controller)
385     */
386     public OACesecSemantic(){
387           Cve.errLog.debug("");
388         med = new ControllerOACesecSemantic(this);
389         setMediator(med);
390         
391         //creo controller Alberi
392 treeContr=new ControllerTree();
393
394         // creo i container Alberi
395 contSemantic = new TreeCve(treeContr);
396         contAlphabet = new TreeCve(treeContr);
397         contLanguage = new TreeCve(treeContr);
398         contSintRules = new TreeCve(treeContr);
399         contSemRules = new TreeCve(treeContr);
400         contAssSem = new TreeCve(treeContr);
401         contFileAssFile = new TreeCve(treeContr);
402         
403         //Impostazione Flag MappingEvent aperta
404 setMappingFrameOpen(false);
405         setQueryElementOpen(false);
406         
407         }
408
409     /**
410      * Comunica il file di Associazione scelto all'esecutore
411      * @param file Associazione (Sint-Sem-Ass)
412      *
413      */
414     public void setAssociation(String file) {
415         Cve.errLog.debug("");
416         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
417         if (eseGS!=null){
418             eseGS.setAssociation(file);
419             }
420         }
421
422     /**
423     * Comunica all'esecutore di cancellare il linguaggio scelto
424     */
425     public void clearAssociation() {
426           Cve.errLog.debug("");
427         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
428         eseGS.clearAssociation();
429         }
430     
431     /**
432     *Nel descrittore, all'interno di param, vi sono indicati
433     * i componets dell'osservatore.Associo ad un osservatore le istanze dei suoi componenti
434     * @param param componenti visuali dell'osservatore
435     */
436     public void setComponents (Collection param){
437         Cve.errLog.debug("");
438         Iterator itParam=param.iterator();
439         while (itParam.hasNext()){
440             Object component=itParam.next();
441             if (component instanceof IJCanvas){
442                 canvas=(IJCanvas)component;
443                 }
444             if (component instanceof IJTool){
445                 tbar=(IJTool)component;
446                 }
447             if (component instanceof IJTabbed){
448                 tab=(IJTabbed)component;
449                 }
450             }
451         // associo ai componeti il controller
452 canvas.setController(med);
453         tbar.setController(med);
454         tab.setController(med);
455         
456         tab = (JTabbed)tab.addCve("Sentence", (ACanvas)canvas);
457         tab = (JTabbed)tab.addCve("Semantic", contSemantic);
458         tab = (JTabbed)tab.addCve("Alphabet", contAlphabet);
459         tab = (JTabbed)tab.addCve("Automata", contLanguage);
460         tab = (JTabbed)tab.addCve("Synt.Rules", contSintRules);
461         tab = (JTabbed)tab.addCve("Sem.Rules", contSemRules);
462         tab = (JTabbed)tab.addCve("Ass.Rules", contAssSem);
463         tab = (JTabbed)tab.addCve("Ass.File", contFileAssFile);
464
465         cveCont.setLayout(new BorderLayout());
466         cveCont.add("Center",(Component)tab);
467
468         /*
469         // imposto il layout
470         cveCont.setLayout(new BorderLayout());
471         cveCont.add("Center",(Component)canvas);
472         */
473         
474         cveCont.add("East",(Component)tbar);
475         impostaComandi();
476         
477         }
478     
479     /**
480     *Restituisce il controller
481     *
482     */
483     public Controller getMediator() {
484           Cve.errLog.debug("");
485         return med;
486         }
487     
488     
489     /* ////////////////////////METODI PILOTATI DA ConfigurationPanel ////////////////////////// */
490
491     //ORIENTAZIONE
492 /**
493     * Impostazione Orientazione Semantica (TOKEN ORIENTED,HOLDER ORIENTED)
494     *
495     * @param Orientation Tipo Orientazione (1=Token, 2=Holder)
496     */
497     public void setOrientation(int Orientation){
498       Cve.errLog.debug("");
499       //Controllo se è già iniziata la creazione di una Sentenza
500 if (semantic && Orientation!=orientation){
501           JOptionPane.showMessageDialog(null,"L'orientazione della Semantica non è modificabile in creazione della Sentenza!","ATTENZIONE",JOptionPane.WARNING_MESSAGE);
502       }else{
503         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
504         eseGS.setOrientation(Orientation);
505         orientation = Orientation;
506       }
507     }
508
509     /**
510     * Lettura Orientazione Semantica (TOKEN ORIENTED,HOLDER ORIENTED)
511     *
512     * @return int Tipo Orientazione (1=Token, 2=Holder)
513     */
514     public int getOrientation(){
515           Cve.errLog.debug("");
516         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
517         return eseGS.getOrientation();
518     }
519
520
521     /**
522     * Verifica se già Avviata la fase di creazione Sentenza\Semantica
523     *
524     * @return boolean Flag di Inizio Creazione Semantica
525     */
526     public boolean getSemanticFlag(){
527        Cve.errLog.debug("");
528        return semantic;
529     }
530
531
532     //FASE MANIPOLAZIONE
533 /**
534     * Impostazione Fase di Manipolazione Sentenza\Semantica
535     *
536     * @param fase_in Impostazione Fase Manipolazione Sentenza\Semantica(1=CREATION,2=INIT,3=EXEC)
537     */
538     public void setFase(int fase_in){
539          Cve.errLog.debug("");
540          System.out.println(" #O Eseguita Impostazione Fase Manipolazione: " + fase_in);
541        
542        //Comunicazione all'esecutore della fase
543 eseGS=(IEsecutionSentenceSemantic)getEsecutore();
544         eseGS.setFase(fase_in);
545         fase = fase_in;
546         
547         setTitle();
548     }
549
550     /**
551     * Lettura Fase di Manipolazione Sentenza\Semantica
552     *
553     * @return fase_in Impostazione Fase Manipolazione Sentenza\Semantica(1=CREATION,2=INIT,3=EXEC)
554     */
555     public int getFase(){
556           Cve.errLog.debug("");
557         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
558         fase = eseGS.getFase();
559         System.out.println(" #O Eseguita lettura Fase Manipolazione: " + fase);
560         return fase;
561     }
562
563     /**
564     * Impostazione Attivatore Wippog di esecuzione Semantica
565     * (Attualmente sono gestiti solo StepActivator(Default) e SeqActivator
566     *
567     * @param act Nome Classe Attivatore Wippog Semantico Impostato
568     */
569     public void setActivator(String act){
570         Cve.errLog.debug("");
571         System.out.println(" #O Eseguita Impostazione Attivatore Semantico: " + act);
572           activator = act;
573
574         //Controllo Attivatore Selezinato
575 if (activator.equals("StepActivator")==false && activator.equals("SeqActivator")==false){
576              //Attivatore Non gestito...viene impostato lo StepActivator sdi Default
577 JOptionPane.showMessageDialog(null,"Attivatore Non Gestito!Viene impostato lo StepActivator per Default.","ATTENZIONE",JOptionPane.WARNING_MESSAGE);
578             activator = "StepActivator";
579        }
580        eseGS=(IEsecutionSentenceSemantic)getEsecutore();
581        eseGS.setActivator(activator);
582     }
583
584     /**
585     * Lettura Attivatore Wippog di esecuzione Semantica
586     *
587     * @return String Nome Classe Attivatore Wippog Semantico Impostato
588     */
589     public String getActivator(){
590         Cve.errLog.debug("");
591         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
592         activator = eseGS.getActivator();
593         System.out.println(" #O Eseguita lettura Attivatore Semantico: " + activator);
594         return activator;
595     }
596
597     /**
598     * Impostazione Titolo Frame in base a Fase di Manipolazione
599     *
600     */
601     public void setTitle(){
602
603         Cve.errLog.debug("");
604         String appo_fase = new String ();
605         
606         if (fase==CREATION) appo_fase = " - FASE: CREATION";
607         if (fase==INITIALIZE) appo_fase = " - FASE: INITIALIZE";
608         if (fase==EXECUTION) appo_fase = " - FASE: EXECUTION";
609         
610         if (titlePresenter == null) {
611         }
612         pre.setTitle(titlePresenter + appo_fase);
613     
614     }
615
616     /**
617      * Apertura maschera di configurazione Semantica Elemento
618      *
619      * @param idTipo Tipo Elemento da Configurare
620      * @param idIstanza Istanza Elemento da Configurare
621      */
622     public void configElement(String idTipo,String idIstanza){
623         
624         //Controllo Fase
625 Cve.errLog.debug("");
626         if (fase==EXECUTION){
627            JOptionPane.showMessageDialog(null,"La modifica dello stato di un'oggetto è possibile solo nelle fasi di CREATION ed INITIALIZE!!!","ATTENZIONE",JOptionPane.WARNING_MESSAGE);
628         }else{
629            ViewLog.writeInLog(" #O# Eseguita attivita' configElement id: "+ id + " idIstanza: "+ idIstanza +"\n");
630            System.out.println(" #O# Eseguita attivita' configElement id: "+ id + " idIstanza: "+ idIstanza +"\n");
631
632            //Apertura Maschera Visualizzazione Informazioni
633 ConfigElementFrame configElementFrame = new ConfigElementFrame("Config Element","/resource/QueryView.GIF");
634        
635            //Impostazioni Frame
636 configElementFrame.setOAC(this);
637            configElementFrame.init(idIstanza);
638        
639            //Visualizzazione
640 JDesktopPane desktop;
641            desktop =Cve.getDesktop();
642            desktop.add(configElementFrame);
643
644            try{
645               configElementFrame.setSelected(true);
646            }catch (Exception e){
647               Cve.errLog.error(e.toString());
648            }
649          }
650         
651     }
652
653    /**
654     * Impostazione Flag Maschera di Configurazione Frame Aperta
655     *
656     * @param flag Flag di Maschera di Configurazione Frame Aperta
657     */
658     public void setConfigFrameOpen(boolean flag){
659         Cve.errLog.debug("");
660         configFrameIsOpen = flag;
661     }
662
663    /**
664     * Lettura Flag Maschera di Configurazione Frame Aperta
665     *
666     * @return boolean Flag di Maschera di Configurazione Frame Aperta
667     */
668     public boolean getConfigFrameOpen(){
669         Cve.errLog.debug("");
670         return configFrameIsOpen;
671     }
672
673
674    /**
675     * Impostazione Flag Maschera di Configurazione Elemento Aperta
676     *
677     * @param flag Flag di Maschera di Configurazione Elemento Aperta
678     */
679     public void setConfigElementOpen(boolean flag){
680         Cve.errLog.debug("");
681         configElementIsOpen = flag;
682     }
683
684    /**
685     * Lettura Flag Maschera di Configurazione Elemento Aperta
686     *
687     * @return boolean Flag di Maschera di Configurazione Elemento Aperta
688     */
689     public boolean getConfigElementOpen(){
690         Cve.errLog.debug("");
691         return configElementIsOpen;
692     }
693
694   
695     /**
696      * Aggiornamento Internal Pool Albero per WippogMachine Semantica (SOLO ALBERO,CONFIGURAZIONI E GRAFICA)
697      *
698      * @param id idIstanza Elemento da Configurare
699      * @param num_token Numero di Token da Configurare per l'elemento selezionato
700      */
701     public void addInternalPool(String id, int num_token){
702         Cve.errLog.debug("");
703         ViewLog.writeInLog(" #O# Eseguita attivita' addInternalPool id: "+ id + " Num.Token: "+ num_token+"\n");
704         System.out.println(" #O# Eseguita attivita' addInternalPool id: "+ id + " Num.Token: "+ num_token);
705         
706         //Rimando la gestione all'esecutore
707 eseGS=(IEsecutionSentenceSemantic)getEsecutore();
708         eseGS.addInternalPool(id,num_token);
709    
710     }
711
712     /**
713      * Aggiornamento peso arco per WippogMachine Semantica (SOLO ALBERO,CONFIGURAZIONI E GRAFICA)
714      *
715      * @param id idIstanza Elemento da Configurare
716      * @param num_weight Peso da Configurare per l'elemento selezionato
717      */
718     public void updateWeight(String id, int num_weight){
719         Cve.errLog.debug("");
720         ViewLog.writeInLog(" #O# Eseguita attivita' updateWeight id: "+ id + " Weight: "+ num_weight+"\n");
721         System.out.println(" #O# Eseguita attivita' updateWeight id: "+ id + " Weight: "+ num_weight);
722         
723         //Rimando la gestione all'esecutore
724 eseGS=(IEsecutionSentenceSemantic)getEsecutore();
725         eseGS.updateWeight(id,num_weight);
726    
727     }
728
729     /**
730      * Aggiornamento Limitazioni token in place
731      * per WippogMachine Semantica (SOLO ALBERO,CONFIGURAZIONI E GRAFICA)
732      *
733      * @param id idIstanza Elemento da Configurare
734      * @param max_token Limitazione numero di token per un place
735      */
736     public void updateMaxToken(String id, int max_token){
737         Cve.errLog.debug("");
738         ViewLog.writeInLog(" #O# Eseguita attivita' updateMaxToken id: "+ id + " MaxToken: "+ max_token+"\n");
739         System.out.println(" #O# Eseguita attivita' updateMaxToken id: "+ id + " MaxToken: "+ max_token);
740         
741         //Rimando la gestione all'esecutore
742 eseGS=(IEsecutionSentenceSemantic)getEsecutore();
743         eseGS.updateMaxToken(id,max_token);
744    
745     }
746
747     /**
748      * Lettura Oggetto Configurazione Semantica per elemento in Sentenza
749      *
750      * @param idIstanza Elemento in esame
751      * @return ConfigElement Oggetto di Configurazione Semantica Oggetto in Sentenza
752      */
753     public ConfigElement getConfigElement(String idIstanza){
754         Cve.errLog.debug("");
755         ViewLog.writeInLog(" #O# Eseguita attivita' getConfigElement id: "+ idIstanza+"\n");
756         System.out.println(" #O# Eseguita attivita' getConfigElement id: "+ idIstanza);
757         
758         //Rimando la gestione all'esecutore
759 eseGS=(IEsecutionSentenceSemantic)getEsecutore();
760         return eseGS.getConfigElement(idIstanza);
761     }
762
763
764     ///////////////////////METODI PILOTATI A SEGUITO DI AZIONI UTENTE IN CANVAS/////////////////
765 //Vedere InteractionGraphics
766
767     /**
768     * Metodo selezionato dal Canvas a seguito dell'azione Utente di 'Creazione Elemento'
769     *
770     * @param idTipo Tipo elemento da Creare
771     */
772     public void trigger(String idTipo){
773           Cve.errLog.debug("");
774         if (eseGS!=null) {
775             eseGS.inputTrigger(idTipo);
776             }
777         }
778
779    /**
780     * Metodo selezionato dal Canvas a seguito dell'azione Utente di 'Selezione Elemento'
781     *
782     * @param id Tipo Elemento selezionato
783     * @param idIstanza Istanza Elemento Selezionato
784     * @param select Azione Selezione(true)-Deselezione(false)
785     */
786     public void inputSelected(String id,String idIstanza, boolean selected){
787         Cve.errLog.debug("");
788         ViewLog.writeInLog(" #O# Eseguita attivita' inputSelected id: "+ id + " idIstanza: "+ idIstanza + " selected: "+ selected +"\n");
789         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
790         eseGS.inputSelected(id,idIstanza,selected);
791         }
792     
793     /**
794      * Metodo selezionato dal Canvas a seguito dell'azione Utente di 'Query Elemento'
795      *
796      * @param idTipo Elemento Selezionato
797      * @param idIstanza Istanza Elemento Selezionato
798      */
799     public void query(String idTipo,String idIstanza){
800           Cve.errLog.debug("");
801         ViewLog.writeInLog(" #O# Eseguita attivita' query id: "+ id + " idIstanza: "+ idIstanza +"\n");
802         System.out.println(" #O# Eseguita attivita' query id: "+ id + " idIstanza: "+ idIstanza);
803         eseGS=(IEsecutionSentenceSemantic)getEsecutore();
804         eseGS.inputQuery(idTipo,idIstanza);
805     }
806
807
808    
809    //////////GESTIONE ABILITAZIONE PULSANTI IN CAMBIAMENTO FASI///////////////////////
810 //In fase <> CREATION disabilito i pulsanti di creazione Sentenza
811 //Nota: per la riabilitazione utilizzo setStateButton
812
813     /**
814      * Disabilitazione di tutti i pulsanti Alfabeto in stato <> CREATION Sentence
815      *
816      */
817    public void disableButton(){
818
819      Cve.errLog.debug("");
820      //Flag disabilitazione pulsanti
821 disButton = true;
822  
823      //Registro i pulsanti attualmente Disabilitati
824 Vector allButton=new Vector (buttonAlf.values());
825      
826      //Inizializzazione Vettore Elenco pulsanti disabilitati
827 disabledButton = new Vector();
828      for (int i=0;i<allButton.size();i++){
829         AlfButton ref=(AlfButton)allButton.elementAt(i);
830
831         if (ref.isEnabled()==false){
832           disabledButton.add(ref.getActionCommand());
833         }
834      }
835      //Disabilitazione di tutti i pulsanti
836 for (int j=0;j<allButton.size();j++){
837          AlfButton ref1=(AlfButton)allButton.elementAt(j);
838          ref1.setEnabled(false);
839      }
840    }
841
842     /**
843      * Lettura di tutti i Pulsanti Alfabeto attualmente Disabilitati
844      *
845      * @return Collection Elenco Pulsanti Disabilitati
846      */
847    public Collection getDisabledButton(){
848       Cve.errLog.debug("");
849       return disabledButton;
850    }
851
852     /**
853      * Verifica se i pulsanti alfabeto sono attualmente disabilitati
854      *
855      * @return boolean Flag Pulsanti Alfabeto Abilitati\Disabilitati
856      */
857    public boolean getDisButton(){
858       Cve.errLog.debug("");
859       return disButton;
860    }
861     
862     /**
863      * Gestisce l'abilitazione o disabiltazione
864      *
865      * @param disab contiene la lista degli id dei bottoni
866      * da disabilitare o abilitare
867      * @param enable se devo disabilitare o abilitare
868      */
869     public void setStateButton(Collection disab, boolean enable){
870         
871         Cve.errLog.debug("");
872         disButton = false;
873         
874         //La riabilitazione avviene solo se è stato caricato l'ambiente
875 // prima abilito tutti
876 Vector allButton=new Vector (buttonAlf.values());
877            
878            // poi disabilito abilito quelli presenti nella lista
879 Iterator disabIt=disab.iterator();
880            while (disabIt.hasNext()){
881              // prendo id bottone
882 Object idButton=disabIt.next();
883              // prendo il ref al button identificato dall'id
884 String idButtonS=idButton.toString();
885              
886              AlfButton refButton=(AlfButton)buttonAlf.get(idButtonS);
887              if (enable)
888                  refButton.setEnabled(true);
889              else
890                  refButton.setEnabled(false);
891              }
892            repaint();
893         }
894     
895     
896     //*************ABILITAZIONE PULSANTI A CAMBIAMENTO DI STATO*********//
897
898     /**
899      * Abilitazione Pulsanti in fase di Creazione Sentenza\Semantica
900      *
901      */
902     public void enableCreate(){
903           Cve.errLog.debug("");
904         startSent.setEnabled(false);
905         stopSent.setEnabled(false);
906         
907         //Abilitazione Pulsanti possibili
908 getAssociation.setEnabled(false);
909         cancAssociation.setEnabled(true);
910         getSentence.setEnabled(true);
911         cancSentence.setEnabled(true);
912         saveSentence.setEnabled(false);
913         openConfiguration.setEnabled(true);
914     }
915
916     /**
917      * Abilitazione Pulsanti in fase di Inizializzazione Semantica
918      *
919      */
920     public void enableInit(){
921         Cve.errLog.debug("");
922         startSent.setEnabled(false);
923         stopSent.setEnabled(false);
924         
925         //Abilitazione Pulsanti possibili
926 getAssociation.setEnabled(false);
927         cancAssociation.setEnabled(false);
928         getSentence.setEnabled(false);
929         cancSentence.setEnabled(false);
930         saveSentence.setEnabled(false);
931         openConfiguration.setEnabled(true);
932     }
933
934     /**
935      * Abilitazione Pulsanti in fase di Esecuzione Semantica
936      *
937      */
938     public void enableExecution(){
939           Cve.errLog.debug("");
940         startSent.setEnabled(true);
941         //stopSent.setEnabled(true);
942
943         //Disabilitazione di tutti gli altri
944 getAssociation.setEnabled(false);
945         cancAssociation.setEnabled(false);
946         getSentence.setEnabled(false);
947         cancSentence.setEnabled(false);
948         saveSentence.setEnabled(false);
949         openConfiguration.setEnabled(true);
950     }
951
952     /**
953      * Abilitazione Pulsanti di Animazione dopo Start
954      *
955      */
956     public void enableExecStart(){
957           Cve.errLog.debug("");
958         startSent.setEnabled(false);
959         stopSent.setEnabled(true);
960         
961         if (activator.equals("StepActivator")){
962            stepSent.setEnabled(true);
963         } else {
964            stepSent.setEnabled(false);
965         }
966     }
967
968     /**
969      * Abilitazione Pulsanti di Animazione dopo aver effettuato STOP
970      *
971      */
972     public void enableExecEnd(){
973           Cve.errLog.debug("");
974         startSent.setEnabled(true);
975         stepSent.setEnabled(false);
976         stopSent.setEnabled(false);
977     }
978     
979     //**************************************************************//
980
981     /* ################# METODI PROTETTI