<?xml version="1.0" encoding="UTF-8"?><!-- generator="wordpress.com" -->
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	>

<channel>
	<title>prototipi-in-plone &amp;laquo; WordPress.com Tag Feed</title>
	<link>http://en.wordpress.com/tag/prototipi-in-plone/</link>
	<description>Feed of posts on WordPress.com tagged "prototipi-in-plone"</description>
	<pubDate>Wed, 23 Dec 2009 17:13:51 +0000</pubDate>

	<generator>http://en.wordpress.com/tags/</generator>
	<language>en</language>

<item>
<title><![CDATA[Decima settimana - dal 19 novembre al 25 novembre]]></title>
<link>http://progettomycampus.wordpress.com/2008/01/03/decima-settimana-dal-19-novembre-al-25-novembre/</link>
<pubDate>Thu, 03 Jan 2008 18:29:25 +0000</pubDate>
<dc:creator>Maurizio Moscatelli</dc:creator>
<guid>http://progettomycampus.wordpress.com/2008/01/03/decima-settimana-dal-19-novembre-al-25-novembre/</guid>
<description><![CDATA[Primi prototipi su Plone Per iniziare a famigliarizzare con la struttura file system stile di Plone ]]></description>
<content:encoded><![CDATA[<div class='snap_preview'><p><H1><A NAME="SECTION001110000000000000000"><br />
Primi prototipi su Plone</A><br />
</H1><br />
Per iniziare a famigliarizzare con la struttura file system stile di Plone abbiamo iniziato a creare dei prototipi rappresentativi per myCampus.</p>
<p><P></p>
<p><H2><A NAME="SECTION001111000000000000000"><br />
Prototipo 1: Folder</A><br />
</H2><br />
Il primo prototipo &#232; la versione pi&#249; semplice del corso di laurea: mediante l&#8217;oggetto Folder di Plone, abbiamo creato la struttura del generico corso.</p>
<p><P></p>
<p><H2><A NAME="SECTION001112000000000000000"><br />
Prototipo 2: Schema Manager</A><br />
</H2><br />
Schema Manager &#232; una funzionalit&#224; disponibile installando la Product ATSchemaEditorNG 0.4.4, disponibile solo per Plone 2.5.<br />
Essa consente di creare dei nuovi tipi di oggetti sulla base di oggetti gi&#224; esistenti nel sistema, e di personalizzarne aspetto, comportamento e, soprattuto, di personalizzare i tipi di oggetto che il nuovo tipo sar&#224; disponibile ad inglobare.<br />
In questo modo, abbiamo creato l&#8217;oggetto Corso di laurea, che permette di avere al suo interno solamente gli oggetti Professore e Link.<br />
Notare che parte di queste funzionalit&#224; sono altres&#236; disponibili nell&#8217;interfaccia di gestione di Zope.</p>
<p><P></p>
<p><H2><A NAME="SECTION001113000000000000000"><br />
Prototipo 3: ArchGenXML</A><br />
</H2></p>
<p><P><br />
ArchGenXML &#232; una libreria Python in grado generare, dato un diagramma UML appositamente costruito e taggato, un Product, ossia un nuovo tipo di oggetto che Plone (Zope) &#232; in grado di gestire e di rappresentare.</p>
<p><P></p>
<p><H3><A NAME="SECTION001113100000000000000"><br />
ArgoUML</A><br />
</H3></p>
<p><P><br />
ArgoUML &#232; risultata la scelta migliore per poter generare diagrammi UML compatibili con ArchGenXML: questo programma, scritto in java (quindi portabile pressoch&#233; su tutti i sistemi) genera di default i diagrammi salvandoli in formato .zargo, uno dei formati perfettamente compatibili con ArchGen.</p>
<p><P></p>
<p><H3><A NAME="SECTION001113200000000000000"><br />
Utilizzo di ArchGenXML</A><br />
</H3></p>
<p><P><br />
ArchGenXML &#232; praticamente subito pronto per essere eseguito, l&#8217;unica cosa che abbiamo preferito fare, &#232; stata di installare in Python le librerie i18ndude e stripogram.<br />
Dopo aver generato il file .zargo, lo si da in pasto ad ArchGen e, se non sono trovati errori, la libreria produce la cartella del nuovo prodotto, gi&#224; pronto per essere installato.<br />
Ovviamente, il servizio Zope va riavviato per permettere di trovare la nuova libreria; fatto questo sar&#224; sufficiente andare in Configurazione del sito Aggiungi / rimuovi prodotti per installare il nuovo prodotto.<br />
Abbiamo notato che le cardinalit&#224; nelle relazioni fra una classe e l&#8217;altra non sortiscono alcun effetto nella traduzione dal diagramma alla Product.</p>
<p><P></p>
<p><H1><A NAME="SECTION001120000000000000000"><br />
Prototipo 4: Python</A><br />
</H1></p>
<p><P><br />
Abbiamo pianificato che il prototipo 4 sar&#224; costituito dallo sfruttare il pi&#249; possibile il supporto di ArchGen, al fine di disegnare col maggior dettaglio possibile, l&#8217;architettura del sistema. In seguito, dopo aver generato il prodotto, andremo a raffinare le sorgenti python generate per rendere il sistema meglio conforme alle nostre pianificazioni.</p>
<p><P></p>
<p><H1><A NAME="SECTION001130000000000000000"><br />
approfondimento su ArchGenXml</A><br />
</H1></p>
<p><P><br />
Questo applicativo serve a trasformare progetti UML in prodotti utilizzabili in Plone.</p>
<p><P></p>
<p><H2><A NAME="SECTION001131000000000000000"><br />
Prima fase</A><br />
</H2><br />
Aprire il tool UML a vostra scelta (Noi abbiamo utilizzato ArgoUml). Creare un nuovo modello<br />
UML e aggiungere diagrammi di classe. Scegliere il tool per creare le classi e aggiungeere classi al<br />
diagramma (Sempre ArgoUml). Dare un nome al progetto come MyFirstAGXContent e aggiungere<br />
un attributo MyTextField di tipo text. Per esempio: example_1.xmi</p>
<p><P></p>
<p><H2><A NAME="SECTION001132000000000000000"><br />
Seconda fase (generazione del prodotto)</A><br />
</H2><br />
Salvare/esportare il modello come un file XMI con il nome MyFirstExample.xmi (o in un formato<br />
contenitore di xmi come .zargo o .zuml). Poi dare il comando:<br />
<SPAN CLASS="textit">ArchGenXml.py MyFirstAGXExample.xmi</SPAN>.<br />
ArchGenXml iniziera a generare codice. Quando questo sar&#224; completo si sara creata una nuova<br />
cartella MyFirstAGXExample nella cartella di ArchGenXml (Si puo sovrascrivere il nome della<br />
cartella usando l&#8217;opzione -o).</p>
<p><P></p>
<p><H2><A NAME="SECTION001133000000000000000"><br />
Installazione e uso del prodotto generato</A><br />
</H2><br />
Spostare la cartella creata dentro la cartella Products di Plone (plone/data/products).<br />
Aprire plone e loggarsi come amministratore. Scegliere plone setup dalla barra personale e<br />
scegliere Aggiungi/rimuovi Prodotti. Il nuovo prodotto MyFirstAGXContent dovrebbe apparire<br />
nella lista dei prodotti avviabili per l&#8217;installazione. Sceglierlo e cliccare installa. Andare alla<br />
cartella personale. Nella lista degli oggetti che si possono aggiungere alla propria cartella potrete trovare il nuovo prodotto. Aggiungere a un&#8217;istanza di test per vedere se funziona.</p>
<p><P></p>
<p><H2><A NAME="SECTION001134000000000000000"><br />
Interfaccia</A><br />
</H2><br />
Di default, quando viene creata una classe nel proprio diagramma di classi, questa rappresenta un tipo di contenuto<br />
Archetypes.<br />
Si puo aggiungere operazioni al proprio modello per generare metodi nelle classi, e attributi per<br />
generare campi nello schema. Alla fine di questo tutorial c&#8217;&#232; una veloce lista dei tipi di campi che si possono usare.<br />
Ci sono tre modi base con cui si possono modificare il modo con cui questi tipi sono generati:</p>
<p><P></p>
<p><UL><br />
<LI>Si possono impostare uno o piu stereotipi nella propria classe, il quale modifica il tipo di<br />
classe. Uno stereotipo &#171;portal_tool&#187;, per esempio, significa che si puo generare un portal<br />
tool piuttosto che un sempilce content types.<br />
</LI><br />
<LI>Si possono usare valori taggati nel proprio modello per configurare molti aspetti delle<br />
proprie classi, i loro attributi e i loro metodi. Una lista di valori taggati riconosciuti per<br />
classi, campi e metodi si pu&#242; trovare alla fine del tutorial.<br />
Quando vengono letti i valori taggati, ArchGenXml generalmente li trattera come stringhe,<br />
con poche eccezioni dove sono permessi solo valori non stringhe, come richiesto da valori<br />
taggati. Se non si vuole che i valori siano quotati come stringhe, prefissatelo con python: Per<br />
esempio, se si vuole impostare il valore taggato di default per python : [high, low] sulla<br />
linea degli attributi, si potr&#224; dare default=[high, low] nel LinesFields del proprio<br />
schema.<br />
</LI><br />
<LI>ArchGenXml comprende le aggregazioni e le composizioni. Se le proprie classi sono<br />
aggregate ad altre classi, le prime saranno automaticamente generate dentro la cartella con<br />
queste classi come content type.<br />
Se si usa composizioni (identificate da un pentagono nel diagramma) anziche aggregazioni, i<br />
contenuti delle classi sara aggiungibili solo nel contenitore, altrimenti saranno aggiungibili<br />
globalmente dal tuo portale di default.<br />
</LI><br />
</UL></p>
<p><P></p>
<p><H2><A NAME="SECTION001135000000000000000"><br />
Variazioni di Content Types</A><br />
</H2></p>
<p><P></p>
<p><H3><A NAME="SECTION001135100000000000000"><br />
Classi Semplici</A><br />
</H3><br />
Una classe semplice e basata su <SPAN CLASS="textit">BaseContent</SPAN>. Questo e di default se nessun altra opzione la soprascrive.</p>
<p><P></p>
<p><H3><A NAME="SECTION001135200000000000000"><br />
Eredita delle Classi</A><br />
</H3><br />
Il modo pi&#249; facile per far un <SPAN CLASS="textit">content type</SPAN> &#232; introdurre composizioni o aggregazioni nel proprio modello. Le classi genitori faranno da cartella principale e i figli potranno essere creati solo dentro essi. Si pu&#242; anche fare delle classi genitori solo dandogli come stereotipo &#171;folder&#187;. Molti di questi approci risulteranno in un oggetto derivato dal BaseFolder.<br />
Si pu&#242; anche dare alla classe lo stereotipo &#171;ordered&#187; (possibilmente in aggiunta a &#171;folder&#187;)<br />
inoltre per fare questo eridita da OrderedBaseFolder. Alternativamente, si pu&#242; impostare il valore<br />
taggato base_class nella classe da OrderedBaseFolder. Questa e generalmente la tecnica che si puo<br />
usare per sovrascrivere la cartella di base di cui si puo aver bisogno.<br />
Come in una famiglia, i valori taggati additional_parents vi permettono di ereditare da molti oggetti parenti.<br />
Altri valori taggati che potrebbero essere utili per generare cartelle sono:</p>
<p><P><br />
<DL><br />
<DT><STRONG>filter_content_types</STRONG></DT><br />
<DD>Impostare questo 0 o 1 per accendere/spegnere filtri di content types. Se i content types non sono filtrati, le classi saranno trattate come cartelle generali per aggiungere contenuti globalmente.<br />
</DD><br />
<DT><STRONG>allowed_content_types</STRONG></DT><br />
<DD>Per specificare impostazioni di allocazioni di content types, per esempio per allocare solo immagini e documenti, impostare su: <SPAN CLASS="textit">image, document</SPAN>. Notare che se si usa aggregazioni o composizioni per creare ereditarieta questi settaggi manuali non sono necessari.<br />
</DD><br />
</DL></p>
<p><P></p>
<p><H2><A NAME="SECTION001136000000000000000"><br />
Tools del Portale</A><br />
</H2><br />
Un tool del portale e un unica istanza che altri oggetti potrebbero trovare via <SPAN CLASS="textit">getToolByName</SPAN> e<br />
utilizzarlo. Ci sono molti tools utilizzabili con plone, come <SPAN CLASS="textit">portal_action</SPAN> o <SPAN CLASS="textit">portal_skin</SPAN>. Per creare un tool per il portale che istanzi un regolare content types, date alla vostra classe lo stereotipo<br />
&#171;portal_tool&#187;. Tools possono trattenre attributi e fornire metodi solo come regolari content types.<br />
Tipicamente, questa configurazione trattiene dati e metodi utili per il resto del vostro prodotto da<br />
usare. Tools potrebbero anche avere conflitti -pagina di configurazione nel pannello di controllo di<br />
plone. Vedere la veloce lista alla fine del tutorial per dettagli sui valori taggati che bisogna<br />
impostare per non generare conflitti.</p>
<p><P></p>
<p><H2><A NAME="SECTION001137000000000000000"><br />
Classi miste astratte</A><br />
</H2><br />
Marcando la vostra classe come astratta nel vostro modello (di solito opzione spuntabile), questa<br />
non sara aggiunta al content types che sono logicamente parte del tuo modello, ma che non sara<br />
appartenti al vostro prodotto. Per istanza potrete creare un STUB per il tipo di immagini standard di<br />
plone se vorrete includere questo in un oggetto aggregato dentro il vostro content type questo e, il<br />
vostro content type o classe mista nelle vostre classi.</p>
<p><P></p>
<p><H2><A NAME="SECTION001138000000000000000"><br />
Classi eredi/sottoclassi</A><br />
</H2><br />
Eredi e sottoclassi di una classe sono usate per estendere classi esistenti, o cambiare il loro<br />
comportamento. Usando generalizzazioni di freccie nel vostro modello, potrete ereditare i metodi e<br />
schemi altri content types o classi miste nella vostra classe.</p>
<p><P></p>
<p><H2><A NAME="SECTION001139000000000000000"><br />
Derivazioni Semplici</A><br />
</H2><br />
Tutti i content type in Archetypes sono derivati da una delle classi basi -BaseContent, BaseFolder,<br />
OrderedBaseFolder e cosi via. Se si volesse spegnere cio, per esempio perche la classe base e stata<br />
ereditata da una classe genitore, si puo settare il valore taggato base_class con valore 0.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011310000000000000000"><br />
Derivazioni multiple</A><br />
</H2><br />
Si pu&#242; ovviamente usare multiple ereditarieta via molteplici generalizzazioni di freccie nel vostro<br />
modello. Inoltre, se si ha bisogno di usare una classe base che non e nel vostro modello, si puo<br />
impostare il valore taggato additional_parents nella vostra classe con una lista di classi parenti.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011311000000000000000"><br />
Ereditarieta da altri prodotti</A><br />
</H2><br />
Se si vuole ereditare dalla classe di un altro prodotto bisogna creare un STUB classe con il valore<br />
taggato &#8216;import_from&#8217;: questo generera una linea di importazione from value import CLASSNAME<br />
nella classe derivata da questa classe.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011312000000000000000"><br />
Interfacce</A><br />
</H2><br />
Le interfacce sono un modo di FORMALLY DOCUMENTING l&#8217;interfaccia pubblica per il tuo<br />
codice. Per convenzione, loro sono di solito nel pacchetto <SPAN CLASS="textit">interface</SPAN> (vedi BELOW). Usate<br />
l&#8217;interfaccia del vostro software UML per creare nuove interfacce.<br />
Le interfacce non hanno molti FLUFF aggiunti che i content types fanno loro non hanno mai corpi<br />
dei metodi. Loro, comunque, hanno documenti di estensione. Una classe si dice <SPAN CLASS="textit">realise</SPAN> di un interfaccia quando questa prevede implementazioni per i metodi definite nell&#8217;interfaccia. La<br />
realizzazione UML delle freccie (una linea DOTTED con un vuoto ARROWHEAD) assicurera che<br />
i vostri content types saranno linkati alle interfaccie corrette attraverso l&#8217;attributo <SPAN CLASS="textit">_implements_</SPAN>.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011313000000000000000"><br />
Pacchetti &#8211; Mantieni ordinato il tuo codice</A><br />
</H2><br />
Pacchetti sono entrambi un concetto UML e un concetto Python. In python, i pacchetti sono cartelle<br />
sotto il vostro prodotto contenente un set di moduli (file .py). In UML, un pacchetto e un gruppo<br />
logico di classi, raccolto in una grande cartella con classi al suo interno. Per modulare prodotti<br />
complessi, dovreste sempre usare gruppi di pacchetti.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011314000000000000000"><br />
Come controllare i campi del vostro schema</A><br />
</H2><br />
Lo schema dei vostri content types, generato dagli attributi del vostro modello e dai suoi valori<br />
taggati, contiene campi Archetypes. Ogni campo ha un tipo e un widget. La documentazione Archetypes e la veloce lista alla fine di questo tutorial descrivono come i campi sono avviabili e quali parametri prendono come configurazione.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011315000000000000000"><br />
Uso di valori taggati</A><br />
</H2><br />
Se si vuole impostare un valore taggato su un attributo della vostra classe, in generale, questo valore taggato passera attraverso come parametro per la generazione di campi Archetypes. Inoltre, se si vuole impostare il valore taggato <SPAN CLASS="textit">enforceVocabulary</SPAN> con il valore 1 su un attributo, dovrete dare <SPAN CLASS="textit">enforceVocabulary=1</SPAN> per questo campo nello schema generato. Similmente, si puo impostare il widget delle proprieta dei campi preimpostando il valore taggato con <SPAN CLASS="textit">widget:widget:label</SPAN> impostando l&#8217;etichetta del widget, per istanza.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011316000000000000000"><br />
Valori taggati diversi da stringhe</A><br />
</H2><br />
Come prima, durante la lettura dei valori taggati, ArchGenXml li trattera come stringe, con poche<br />
eccezioni dove sono permessi solo valori non stringhe, come richiesto da valori taggati. Se non si<br />
vuole che i valori siano quotati come stringhe, prefissatelo con python: Per esempio, se si vuole<br />
impostare il valore taggato di default per python : [high, low] sulla linea degli attributi, si potr&#224; dare default=[high, low] nel LinesFields del proprio schema.</p>
<p><P></p>
<p><H2><A NAME="SECTION0011317000000000000000"><br />
Indice nel catalog</A><br />
</H2><br />
Per creare un indice in portal_catalog per questo campo aggiungere il valore taggato index con<br />
valore <SPAN CLASS="textit">fieldIndex</SPAN>. Un fieldIndex con il nome dei campi accessori (esempio get) verra creato.<br />
Indici multipli possono essere definiti in una tupla, indici per cataloghi speciali possono essere<br />
prefissati con il nome del catalogo seguito da / (per esempio python: (FieldIndex, member_catalog/textIndex)).<br />
Per includere indici nel catalogo metadata (e avere gli attributi pronti da usare nel nucleo degli<br />
oggetti), inserire :brains (stesso come ordina: schema), (esempio FieldIndex: brains)</p>
<p><P></p>
<p><H2><A NAME="SECTION0011318000000000000000"><br />
Riciclare Campi &#8211; copiarli da schemi genitori e modificarli</A><br />
</H2><br />
Potreste aver bisogno di un campo description che solitamente e definito da una schema di classe<br />
genitore (BaseContent, BaseFolder) ma appare sotto un tab delle proprieta e non nella vostra form di<br />
base_edit. Per far si che venga mostrato come campo bisogna solo cambiare una proprieta di questo<br />
campo: <SPAN CLASS="textit">schemata = default</SPAN>.<br />
Soluzione: Copiare la definizione del campo. nell&#8217;UML aggiungere un attributo alla vostra classe,<br />
dare a questo il tipo <SPAN CLASS="textit">copy</SPAN> e un valore taggato schemata con valore <SPAN CLASS="textit">default</SPAN>. Impostare valori su i campi copiati e sui loro widget con alcuni dettagli differenti da i nuovi campi definiti, facendo attenzione a questo.</p>
<p><P></p>
<p><H1><A NAME="SECTION001140000000000000000"><br />
approfondimento su ArgoUML</A><br />
</H1></p>
<p><P></p>
<p><H2><A NAME="SECTION001141000000000000000"><br />
Introduzione</A><br />
</H2><br />
ArgoUml e un potente e facile software di sviluppo grafico che supporta il design, lo sviluppo e la<br />
documentazione di applicazioni software orientata agli oggetti.<br />
Le sue caratteristiche sono:</p>
<p><P></p>
<p><UL><br />
<LI>Supporta XMI, SVG e PGML<br />
</LI><br />
<LI>100% Piattaforma indipendente grazie all&#8217;uso esclusivo di Java<br />
</LI><br />
<LI>Open Source<br />
</LI><br />
<LI>Caratteristiche cognitive come: riflettivita, design opportunistico, comprensione e<br />
risoluzione dei problemi</p>
<p><P><br />
</LI><br />
</UL></p>
<p><P></p>
<p><H2><A NAME="SECTION001142000000000000000"><br />
Requisiti di sistema</A><br />
</H2></p>
<p><P></p>
<p><UL><br />
<LI>Qualsiasi Sistema Operativo che supporta Java<br />
</LI><br />
<LI>10 Mb di spazio disponibile<br />
</LI><br />
<LI>Mouse e Tastiera<br />
</LI><br />
<LI>Java 2 JRE o JDK versione 1.4 o superiore<br />
</LI><br />
</UL></p>
<p><P></p>
<p><H2><A NAME="SECTION001143000000000000000"><br />
Opzioni di Installazione</A><br />
</H2><br />
Esistono due opzioni di installazione:<br />
<DL><br />
<DT><STRONG>Java Web Start</STRONG></DT><br />
<DD>Questa alternativa e ottima per utenti occasionali e test. E&#8217; il modo piu semplice e veloce per<br />
iniziare a usare ArgoUml. &#201; richiesta la connessione alla homepage di ArgoUml<br />
([HTML] 0011FF http://www.argouml.org/):</p>
<p><OL><br />
<LI>Assicurarsi di avere java web start (http://java.sun.com/products/javawebstart/)<br />
installato.<br />
</LI><br />
<LI>Successivamente lanciare l&#8217;Argouml link dalla homepage di ArgoUml.<br />
</LI><br />
<LI>ArgoUml sar&#224; scaricato, caricato temporaneamente e inizializzato.<br />
</LI><br />
<LI>Successivamente, ArgoUml e avviabile solo con la Java Web Start Console (senza<br />
che sia necessariamente collegato alla rete internet) e (se connesso), in modo<br />
completamente automatico, verra scaricata, ogni volta, l&#8217;ultima versione disponibile.<br />
</LI><br />
</OL></p>
<p><P><br />
</DD><br />
<DT><STRONG>Distribuzione binaria</STRONG></DT><br />
<DD>Questa versione &#232; ottima per utenti regolari e garantisce che la versione di argoUml non cambi durante il corso del vostro progetto. L&#8217;utente dovr&#224;:</p>
<p><OL><br />
<LI>Assicurarsi di avere Java 2 JRE installato.<br />
</LI><br />
<LI>Scaricare l&#8217;ArgoUml distribuzione binaria dalla homepage di ArgUml<br />
Potrebbe, anche, includere il fatto di dover copiare questa versione su di un floppy<br />
disk o cd a seconda se il computer abbia o meno una connessione ad internet.<br />
</LI><br />
<LI>Creare una directory di installazione per ArgoUml.<br />
</LI><br />
<LI>Estrarre i file di ArgoUml dentro questa directory<br />
</LI><br />
<LI>Far partire il software facendo il doppio click su argouml.jar, o eseguendo il seguente<br />
comando : java -jar argouml.jar sulla linea di comando, o via batch file<br />
</LI><br />
</OL></p>
<p><P><br />
</DD><br />
</DL></p>
<p><P></p>
<p><H2><A NAME="SECTION001144000000000000000"><br />
Installare Moduli Ausiliari</A><br />
</H2><br />
L&#8217;installazione standard di ArgoUml non supporta codici di programmazione come C++, php e C#.<br />
Per far si che questo sia possibile bisogna scaricare, sempre dal sito di ArgoUml, i moduli ausiliari.<br />
Bisogna, poi, scompattare i file scaricati, nella stessa directory di ArgoUml.<br />
Il risultato dovrebbe essere che, la directory che contiene il file argouml.jar, ora contenga anche una sottodirectory chiamata ext, nella quale si trovano dei file .jar per i linguaggi extra.</p>
<p><P></p>
<p><H2><A NAME="SECTION001145000000000000000"><br />
Opzioni della Linea di Comando</A><br />
</H2></p>
<p><P><br />
Quando si fa partire ArgoUml dalla linea di comando, vi sono diverse possibilita extra. Per esempio:<br />
<SPAN CLASS="textbf">java -jar argouml.jar -help</SPAN>; apparir&#224; la seguente schermata:<br />
<BLOCKQUOTE><br />
Usage : [option] [project-file]<br />
<BR><br />
Opzioni incluse :<br />
<BR><br />
-help mostra queste informazioni<br />
<BR><br />
-big usa caratteri grandi<br />
<BR><br />
-huge usa caratteri enormi<br />
<BR><br />
-nosplash non mostrare il logo all&#8217;inizio<br />
<BR><br />
-noedem non riportare le statistiche d&#8217;uso<br />
<BR><br />
-nopreload non caricare prima le classi comuni<br />
<BR><br />
-norecentfile non caricare l&#8217;ultimo file salvato<br />
<BR><br />
-command &#60;arg&#62; comando to perform all&#8217;inizio<br />
<BR><br />
-batch non far partire GUI<br />
<BR><br />
-locale &#60;arg&#62; impostare il linguaggio (e.g. &#8216;en_GB&#8217;)<br />
<BR><br />
-open &#60;arg&#62; apri questo file all&#8217;inizio<br />
<BR><br />
-print &#60;arg&#62; stampa questo file all&#8217;inizio (e esci)</p>
<p></BLOCKQUOTE><br />
&#201; possibile anche impostare i settaggi java che influenzi il comportamento di ArgoUml:<br />
-Xms250M -Xmx500M (Far si che ArgoUml riservi molta memoria per grandi progetti).</p>
<p><P></p>
<p><H2><A NAME="SECTION001146000000000000000"><br />
Creare dei file .zargo cliccabili (in Windows)</A><br />
</H2><br />
Questo lavoro &#232; solo per chi ha installato la distribuzione binaria.</p>
<p><P><br />
Per prima cosa, trovato il file zargo, clicca con il tasto destro su di esso. Dovrebbe apparire il<br />
classico menu di windows, includendo anche apri e apri con. A questo punto, bisogna dare una<br />
descrizione per il file come ArgoUml Model, e dire a windows di usare notepad per aprire il file.<br />
Questa operazione serve a dare a windows la possibilita di accettare l&#8217;estensione .zargo come file<br />
valido.<br />
Ora, aprire Windows Explorer e dal menu di selezione View -&#62; Options (o su windows XP: tools -&#62;<br />
Folder -&#62; Options&#8230;) dovrete dare due (o pi&#249;). Cliccare il File Types e scorrere la lista la lista di descrizione da dare, ad esempio ArgoUml Model. Cliccare per selezionare questo tipo di file, e<br />
poi cliccare sul pulsante di edit.<br />
Ora, cliccare su Open e poi su Edit. Comparir&#224; una form di dialogo che ha una linea per<br />
l&#8217;inserimento del file applicativo da aprire. Ricopiare questa linea:<br />
<BLOCKQUOTE><br />
c:/programmi/Java/j2re1.2.0.01/bin/javaw.exe -jar c:/argoUml/argouml.jar</p>
<p></BLOCKQUOTE></p>
<p><P><br />
Sostituire il percorso con quello dei vostri jawaw.exe e argouml.jar se questi sono situati in una<br />
diversa locazione. Cliccare tre volte ok in altrettante finestre di dialogo.</p>
<p><P></p>
<p><H2><A NAME="SECTION001147000000000000000"><br />
Principi di ArgoUml</A><br />
</H2><br />
Quando ArgoUml parte, mostra un diagrammi di classe vuoto su cui si puo aggiungere varo oggetti.<br />
ArgoUml lavora rispettando i seguenti principi:<br />
<DL><br />
<DT><STRONG>Progetto, modello e diagramma</STRONG></DT><br />
<DD>Le operazione salvataggio e apertura dei file avviene su un progetto alla volta. Un progetto<br />
corrisponde a un modello piu informazioni sul diagramma, per esempio, tutto che puoi<br />
editare con la finestra di ArgoUml.<br />
Il modello puo contenere molti oggetti (ModelElements) che formano la descrizione<br />
completa UML del sistema che state descrivendo. Tutti i ModelElements dovrebbero essere<br />
presenti sul diagramma, ma questo non e obbligatorio. Inoltre, il modello che e salvato in<br />
ArgoUml, e indipendente dal contenuto del diagramma.<br />
Questo potrebbe essere spiegato dalla possibilita di generare codice di programmazione dal<br />
modello (non c&#8217;&#232; bisogno di altri diagrammi per questo).<br />
Un progetto contiene anche tutte le informazioni sui diagrammi, per esempio, le shapes<br />
(presentazioni) usate per rappresentare vari ModelElements, le loro posizioni, colore, ed altri ancora.<br />
Alcuni ModelElements appaiono in diagrammi multipli, alcuni in uno o in nessuno.<br />
Inoltre, salvando e aprendo progetti si hanno tutte queste informazioni. Per salvare solo il<br />
modello esiste un solo modo ovvero attraverso il menu Tools -&#62; Export as XMI.<br />
Potrebbe essere usato quando viene generato del codice da tool esterni che supportano XMI.</p>
<p><P><br />
</DD><br />
<DT><STRONG>Oggetti</STRONG></DT><br />
<DD>Per selezionare oggetti cliccare con il tasto sinistro del mouse. Le funzionalita di ArgoUml<br />
possono essere attivate dal menu, dalle toolbars, o dai menu di pop-up attivati cliccando con<br />
il tasto destro del mouse sull&#8217;oggetto. Molte di queste funzioni lavorano sull&#8217;oggetto<br />
selezionato.<br />
Tutti i diagrammi hanno delle toolbar poste in alto che sono usate per aggiungere oggetti al<br />
diagramma stesso.<br />
Molti oggetti possono essere aggiunti e rimossi dal diagramma senza cancellarlo dal<br />
modello. Si puo selezionare un oggetto sul diagramma, e poi, con l&#8217;ausilio del menu,<br />
cancellarlo, ma questo restera intatto nel modello come si potra vedere nella struttura ad<br />
albero alla sinistra dell&#8217;interfaccia. Anche se rimosso questo potra essere aggiunto al<br />
diagramma stesso o a un qualsiasi altro diagramma cliccando, con il tasto destro, sul nome<br />
dell&#8217;oggetto nello schema ad albero e selezionando Add to diagram.</p>
<p><P><br />
</DD><br />
<DT><STRONG>Overview dell&#8217;interfaccia</STRONG></DT><br />
<DD>Nella parte alta dell&#8217;interfaccia esiste un menu di comandi. Sotto la voce file e possibile<br />
trovare il comando salva (per memorizzare il progetto) e il comando apri (per aprire altri<br />
progetti precedentemente salvati).<br />
Nella parte alta sinistra viene mostrato l&#8217;albero modello del diagramma e gli oggetti. Questa<br />
vista puo essere adattata a seconda delle proprie necessita filtrando gli oggetti mostrati e<br />
modificando la struttura dell&#8217;albero.<br />
Nella parte bassa destra sono contenuti vari dettagli dell&#8217;oggetto selezionato corrente: si puo<br />
selezionare l&#8217;oggetto in uno dei livelli superiori e scegliere quali dettagli volere esaminare<br />
usando i tabs.<br />
Nella parte alta destra mostra il diagramma su cui si sta lavorando (uno alla volta). Si puo<br />
tagliare e copiare gli oggetti sul diagramma e si puo usare i veloci link che appaiono quando<br />
si seleziona un oggetto creando dei collegamenti tra i vari oggetti presenti<br />
Nella parte bassa sinistra c&#8217;e la lista delle cose da fare (consigli che il software ti da)<br />
</DD><br />
</DL></p>
</div>]]></content:encoded>
</item>

</channel>
</rss>
