metaCASE
 
metaCASE
poslední verze
0.02.0089
Oficiální zadani


 


 

České vysoké učení technické v Praze

Fakulta elektrotechnická

 

 

 

 

 

 

 

 

 

Diplomová práce

 

Meta-CASE nástroj

 

Bc. Pavel Jareš

 

 

 

 

 

 

 

 

Vedoucí práce: Doc. Ing. Karel Richta, CSc.

 

 

 

Studijní program: Elektrotechnika a informatika strukturovaný magisterský

 

Obor: Informatika a výpočetní technika

 

květen 2008



 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Poděkování

Chtěl bych poděkovat panu Doc. Ing. Karlovi Richtovi, CSc. za vedení a kontrolu při realizaci mé diplomové práce.



 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Prohlášení

Prohlašuji, že jsem svou diplomovou práci vypracoval samostatně a použil jsem pouze podklady uvedené v přiloženém seznamu.

Nemám závažný důvod proti užití tohoto školního díla ve smyslu §60 Zákona č. 121/2000 Sb., o právu autorském, o právech souvisejících s právem autorským a o změně některých zákonů (autorský zákon).

 

V Písku dne 20. 5. 2008                ................................................................................



Abstract

The main purpose of this thesis is to design and implement pilot version of meta-Case tool. The thesis includes the summary of already developed meta-models concepts and definition of new developed concept based on project GOPRR.

The main part of thesis describes design of application and its implementation. The developed application was implemented in Java language. There is rich GUI for user support and the scripting functionality is ensured through JavaScript language.

 

Abstrakt

Cílem této diplomové práce je navrhnout a implementovat pilotní verzi meta-CASE nástroje. Obsahuje rešerši již vyvinutých konceptů meta-modelů a definici nového inspirovaného projektem GOPRR.

Práce se skládá z návrhu aplikace a popisu implementace. Výsledná aplikace je napsána v jazyce Java. Pro definici modelu je určena rozsáhlá podpora GUI a pro funkci skriptovací jazyk JavaScript.



Obsah                                                                      

Seznam obrázků                                                                                                           xiii

1       Úvod                                                                                                                                1

1.1    CASE nástroj                                                                                                                                                   1

1.2    Meta-CASE nástroj                                                                                                                                        1

1.3    Rozdíl CASE a meta-CASE nástroje                                                                                                         2

1.4    Využití meta-CASE                                                                                                                                        3

2       Popis problému, specifikace cíle                                                                5

2.1    Meta-model                                                                                                                                                      5

2.1.1      CoCoA (Complex Covering Aggregation)                                                                                        5

2.1.2      COMMA (Common Object Methodology Metamodel Architecture)                                        6

2.1.3      OPRR (Object-Property-Role-Relationship)                                                                                    6

2.1.4      GOPRR (Graph-Object-Property-Role-Relationship)                                                                     7

2.1.5      MOF (Meta Model Facility)                                                                                                                7

2.1.6      NIAM (Nijssen’s Information Analysis Methodology)                                                                 8

2.2    Architektura aplikace                                                                                                                                   9

3       Analýza a návrh řešení                                                                                   10

3.1    Struktura meta-modelu                                                                                                                              10

3.2    Navrhované součásti                                                                                                                                   10

3.2.1      Struktura modelu a meta-modelu                                                                                                   12

3.2.2      Vlastnost                                                                                                                                              13

3.2.3      Element                                                                                                                                                14

3.2.4      Vztah                                                                                                                                                    14

3.2.5      Role                                                                                                                                                       15

3.2.6      Diagram                                                                                                                                                15

3.3    Architektura aplikace                                                                                                                                 16

3.3.1      Potřebné součásti                                                                                                                                17

3.3.2      Framework                                                                                                                                           18

3.3.3      Vzhled aplikace                                                                                                                                  19

3.4    Detailnější popis součástí                                                                                                                           20

3.4.1      Grafický editor                                                                                                                                    20

3.4.2      Skript                                                                                                                                                     24

3.5    Návrh balíčků a rozložení projektu                                                                                                        25

4       Realizace                                                                                                                   26

4.1    Balíček metacase.core                                                                                                                                26

4.2    Balíček metacase.core.framework                                                                                                          26

4.3    Balíček metacase.core.framework.gui                                                                                                   26

4.3.1      Třída AboutDialog                                                                                                                             26

4.3.2      Pracovní okna                                                                                                                                     27

4.3.3      Třída JMenuBarFilled                                                                                                                        27

4.3.4      MenuContainer, MenuContainerInterface a MenuContainerDynamic                                  27

4.3.5      Třída BaseView                                                                                                                                  28

4.3.6      Třída WelcomeScreen                                                                                                                       28

4.3.7      Třída BoxComponent                                                                                                                       28

4.3.8      Třída Print                                                                                                                                            28

4.3.9      Třída PrintPreview                                                                                                                              29

4.4    Balíček metacase.core.framework.gui.editor                                                                                      29

4.4.1      PaintInterface, PaintLayerInterfacase a Moveable                                                                    29

4.4.2      Třída EditorPane                                                                                                                                29

4.4.3      ModelContainer, Diagram, Panel, PanelsTree                                                                              29

4.4.4      Inserter a zděděné třídy                                                                                                                     30

4.4.5      Třídy Element, Relationship, RelationshipLine a End                                                                30

4.4.6      Třída Rulers                                                                                                                                         30

4.5    Balíček metacase.core.framework.gui.editor.anchor                                                                        31

4.6    Balíček metacase.core.framework.gui.editor.decores                                                                       31

4.6.1      Náhledy                                                                                                                                                31

4.7    Balíček metacase.core.framework.gui.infos                                                                                        31

4.8    Balíček metacase.core.framework.gui.jtable                                                                                       32

4.9    Balíček metacase.core.framework.gui.toolbars                                                                                  32

4.10      Balíček metacase.core.framework.script                                                                                         33

4.11      Balíček metacase.core.framework.script.editor                                                                            33

4.12      Balíček metacase.core.framework.script.exceptions                                                                    34

4.13      Balíček metacase.core.framework.script.functions                                                                      34

4.14      Balíček metacase.core.framework.script.io                                                                                    34

4.15      Balíček metacase.core.framework.script.tokens                                                                            34

4.16      Balíček metacase.core.framework.script.variable                                                                        34

4.16.1    Třída LexicalAnalyzer                                                                                                                      35

4.16.2    Třída SemanticAnalyzer                                                                                                                   35

4.16.3    Třída PredefinedCode                                                                                                                       35

4.17      Balíček metacase.core.framework.undo                                                                                          35

4.18      Balíček metacase.core.framework.other                                                                                         35

4.19      Balíček metacase.core.metamodel                                                                                                     36

4.20      Balíček metacase.core.metamodel.exception                                                                                  36

4.21      Balíček metacase.core.metamodel.io                                                                                                36

4.22      Balíček metacase.core.metamodel.propertydata                                                                           36

4.23      Balíček metacase.core.metamodel.other                                                                                          37

5       Testování                                                                                                                  38

5.1    Jednotkový test                                                                                                                                             38

5.2    Integrační testování                                                                                                                                    38

5.3    Regresivní testování                                                                                                                                    38

5.4    Validační testování                                                                                                                                      38

5.5    Useability testování                                                                                                                                     39

6       Závěr                                                                                                                            40

7       Seznam literatury                                                                                             41

A      Seznam použitých zkratek                                                                                                                    42

B      UML diagramy                                                                                                                                         43

C      Uživatelská / instalační příručka                                                                                                          45

D      Přílohy skriptovacího jazyka                                                                                                                77

E      Ukázky schémat vzniklých aplikací metaCASE                                                                              86

F       Obsah přiloženého CD                                                                                                                            89

 


 

Seznam obrázků

Obrázek 1 Rozdíl CASE a meta-CASE nástroje [4]......................................................................................... 2

Obrázek 2 Jiná terminologie u meta-modelování [3].............................................................................. 3

Obrázek 3 Meta-model stavového modelu pomocí CoCoA [3]........................................................... 6

Obrázek 4 Meta-model stavového modelu pomocí OPRR [3]............................................................... 7

Obrázek 5 Meta-model stavového modelu pomocí GOPRR [3]............................................................ 7

Obrázek 6 Meta-model stavového modelu pomocí NIAM [3]............................................................... 8

Obrázek 7 Vztah role, vztahu, objektu a vlastnosti....................................................................... 12

Obrázek 8 Ukázka základních konstrukcí ER-modelu................................................................... 14

Obrázek 9 diagram tříd modelu a metamodelu.................................................................................... 16

Obrázek 10 Konceptuální model navrhované aplikace................................................................. 18

Obrázek 11 Navrhovaný vzhled (rozvržení úvodní obrazovky meta-CASE nástroje) 20

Obrázek 12 Třída v UML............................................................................................................................................ 21

Obrázek 13 Znázornění příkladu použití panelů (element třídy v UML)............................. 22

Obrázek 14 Ukázka struktury grafické reprezentace (vlastnost vzhledu)................ 22

Obrázek 15 Diagram tříd – Inserter............................................................................................................... 43

Obrázek 18 Diagram tříd - rozdělení tokenů do kategorií.......................................................... 43

Obrázek 16 Diagram tříd dekorací................................................................................................................. 44

Obrázek 17 Diagram tříd balíčku metacase.core.framework.gui.infos........................... 44

Obrázek 19 Úvodní stránka.................................................................................................................................. 45

Obrázek 20 Konktextové menu - pracovní okna.................................................................................... 46

Obrázek 21 Průzkumník metamodelu........................................................................................................... 46

Obrázek 22 Průzkumník modelu........................................................................................................................ 47

Obrázek 23 Průzkumník prvků modelu........................................................................................................ 47

Obrázek 24 Průzkumník vlastností................................................................................................................ 48

Obrázek 25 Editor složitějších datových typů..................................................................................... 48

Obrázek 26 Průzkumník metavlastností................................................................................................... 48

Obrázek 27 Průzkumník panelů návrhu...................................................................................................... 49

Obrázek 28 Konzole.................................................................................................................................................... 49

Obrázek 29 Průzkumník modelů........................................................................................................................ 50

Obrázek 30 Panely nástrojů................................................................................................................................. 50

Obrázek 31 Standardní panel nástrojů....................................................................................................... 51

Obrázek 32 Panel nástrojů – dekorace........................................................................................................ 51

Obrázek 33 Ukázka návrhu zakončení........................................................................................................ 51

Obrázek 34 Panel nástrojů - bod, vektor.................................................................................................... 51

Obrázek 35 Panel nástrojů - vzad, vpřed,.................................................................................................... 51

Obrázek 36 Panel nástrojů – přiblížení....................................................................................................... 51

Obrázek 37 Panel nástrojů – font..................................................................................................................... 52

Obrázek 38 Panel nástrojů – interpret........................................................................................................ 52

Obrázek 39 Roletové menu.................................................................................................................................... 52

Obrázek 40 Nabídka soubor.................................................................................................................................. 52

Obrázek 41 Nabídka soubor - import.............................................................................................................. 53

Obrázek 42 Nabídka soubor-export................................................................................................................ 53

Obrázek 43 Nabídka zobrazit.............................................................................................................................. 53

Obrázek 44 Nabídka zobrazení........................................................................................................................... 54

Obrázek 45 Nabídka zobrazit - panely nástrojů................................................................................... 54

Obrázek 46 Panel zobrazit - pracovní okna............................................................................................. 54

Obrázek 47 Nabídka vložit.................................................................................................................................... 55

Obrázek 48 Nabídka vložit - dekorace......................................................................................................... 55

Obrázek 49 Nabídka O programu....................................................................................................................... 55

Obrázek 50 Náhled metamodelu....................................................................................................................... 56

Obrázek 51 Náhled vztahu.................................................................................................................................... 56

Obrázek 52 Pravítka.................................................................................................................................................. 57

Obrázek 53 Náhled tisku......................................................................................................................................... 57

Obrázek 54 Otevření editoru kódu................................................................................................................. 59

Obrázek 55 Ukázka ER-schéma............................................................................................................................ 86

Obrázek 56 Ukázka schéma use-case............................................................................................................. 87

Obrázek 57 Ukázka drigramu tříd.................................................................................................................. 88



Seznam tabulek

 

Tabulka 1 Pracovní okna....................................................................................................................................... 27

Tabulka 2 Parametry MenuContainer typu String............................................................................. 27

Tabulka 3 Základní metody EditorPane..................................................................................................... 29

Tabulka 4 Účel tříd dědících třídu Inserter......................................................................................... 30

Tabulka 6 Způsoby přichycení............................................................................................................................ 31

Tabulka 7 Dekorace................................................................................................................................................... 31

Tabulka 9 Náhledy...................................................................................................................................................... 31

Tabulka 10 Renderery a editory pro PropertyData.......................................................................... 32

Tabulka 11 Panely nástrojů................................................................................................................................. 33

Tabulka 12 Výjimky používané pro skriptování.................................................................................... 34

Tabulka 13 Datové typy........................................................................................................................................... 34

Tabulka 14 Důležité metody třídy SemanticAnalyzer................................................................... 35

Tabulka 15 Třídy balíčku metacase.core.framework.other.................................................... 36

Tabulka 16 Datové typy - PropertyData...................................................................................................... 37

 

 



1         Úvod

Cílem práce je navrhnout a implementovat meta-CASE nástroj, který je programovatelný popisem použitého modelu – meta-modelem. Meta-CASE nástroj navazuje na linii CASE nástrojů a rozšiřuje je. Každá diplomová práce by měla začínat rozborem problematiky a definovat základní kameny, proto je první část zaměřena na definici pojmů a vysvětlení užití meta-CASE nástrojů. Dále pokračuje rozbor problematiky a nastínění možných způsobů implementace.

V další části je uveden návrh struktur pro implementaci. Následující kapitola je zaměřena na analytickou část, tzn. architektonický a softwarový návrh.

Na konec je popsána samotná implementace. Zde je podrobně zmapována architektura, technologie, návrhové vzory a jednotlivá rozhraní použitá v implementaci.

Přílohy jsou na přiloženém CD. Důležité materiály naleznete i na konci mé diplomové  práce.

1.1      CASE nástroj

Způsob vývoje aplikací se v průběhu let vyvíjel. Na začátku vznikaly programy bez podpory vývojového prostředí. Snahou vývojářů nebylo vždy jen vyvíjet aplikace pro koncové uživatele, ale zároveň podpořit samotný návrh a realizaci softwaru.

Postupně se zaváděly různé metodiky. Ty pomocí různých modelů snadno a přehledně popisovaly dílčí části softwaru. To byl impuls pro vývojáře vytvořit první CASE (Computer-aided software engineering) nástroj. CASE nástroj umožní uživateli vytvořit schéma, a poté na základě něj vygenerovat požadovaná data. Může se jednat o kus kódu nebo dokonce o celou aplikaci.

CASE nástroj může značně urychlit vývoj, avšak mívá i řadu nevýhod a omezení. Existuje jich celá řada a každý je uzpůsoben k jiné činnosti (některé umí pouze UML, jiné ER-modely atd.). Uživatel si pořídí CASE nástroj a může v něm modelovat pouze s  prvky a vazbami, který tento software nabízí. Není dovoleno vytvářet nové, upravovat stávající, ani definovat vlastní modely.

Samotné rozšiřování se může lišit i v exportu dat. Poměrně často vývojář vytvoří schéma a potřebuje různé exporty. Např. pro databáze základní export sestaví skript, který vytvoří databázi, jednotlivé tabulky a definuje vztahy mezi nimi (primární a cizí klíče, indexy apod.). Řada CASE nástrojů umožňuje jen určitou množinu derivací SQL jazyka, a tak se často stává, že výstupem je skript pro jiný databázový stroj. Ten je nejprve nutné upravit a až poté ho lze použít. To značně snižuje výhody použití. Pokud by však uživatel mohl dodefinovat nějaký z exportů, byla by aplikace pro něj více žádaná. Proto se v posledních letech objevuje nová možnost modelování a sice meta-CASE nástroje.

1.2      Meta-CASE nástroj

Jak již bylo naznačeno meta-CASE nástroj je aplikace, která dovoluje nadefinovat model (jaké prvky obsahuje, jak vypadají, jaké vazby lze realizovat a co znamenají) a poté vytvořit samotné importy a exporty.

Tím vznikne CASE nástroj přesně podle požadavků vývojáře. Nyní může tento nástroj používat, vytvářet schémata a ty poté převádět do potřebného kódu.

Meta-CASE nástroj lze tedy chápat jako CASE nástroj, který je použitelný pro více pro více modelů s možností úprav a definice nových, ale také jako aplikaci, určenou pro vytváření CASE nástrojů. Oba pohledy v praxi představují to samé. Rozdíl spočívá pouze ve způsobu vytváření schémat. Buď se modeluje přímo pomocí meta-CASE nástroje, nebo v aplikaci, která je vytvořena pro každý model zvlášť.

Vzhledem k tomu, že meta-CASE nástroje je možné upravit pro nějaký jiný model a lze vytvořit i výstup, bývají někdy označovány jako CAME (Computer-aided Method Engineering).

1.3      Rozdíl CASE a meta-CASE nástroje

Rozdíl klasického CASE nástroje od meta-CASE je tedy vcelku jednoduchý. CASE nástroj je oproti meta-CASE tzv. „zadrátovaný“.

To znamená, že CASE nástroj umí pouze jazyk, pro který je určen a není použitelný pro jiný model. V meta-CASE nástroji však uživatel vytváří meta-model, který odpovídá onomu „zadrátovanému“ jazyku v CASE nástroji a s tím poté pracuje.

Meta-CASE tedy nahrazuje nemodifikovatelnou definici modelu meta-modelem (viz Obrázek 1). Ten je řízen jen za pomoci zobecněných pravidel – meta-modelujícím jazykem. V něm meta-modelář vytvoří konkrétní meta-model, na základě kterého je možné vytvářet schémata (viz models).

Obrázek 1 Rozdíl CASE a meta-CASE nástroje [4]

 

Někdy se v rámci různých terminologií mluví o tzv. meta-meta-modelu. Zde je jako meta-meta-model označena vrstva, ve které se utváří meta-model, odpovídající CASE nástroji.

Meta-modelovací jazyk umožňuje práci s meta-modelem (vytvoření meta-modelu a jeho správu). Meta-model definuje možné prvky a jejich vazby. Na základě těchto pravidel je vytvářen model. Ten odpovídá schématu v CASE nástroji.

Jako meta-meta-model je označena vrstva, udržující informaci o meta-modelu (viz 2.1).

Obrázek 2 Jiná terminologie u meta-modelování [3]

 

Obrázek 2 zobrazuje jiný pohled na meta-CASE nástroje.

1.4      Využití meta-CASE

Meta-CASE se vyvíjí v zásadě ze dvou důvodů:

-          jako produkt pro cílového zákazníka

-          interní verze vytvářeného CASE nástroje

 

Na trhu meta-CASE nástroj není častý, protože cílová skupina uživatelů schopná vytvářet nové a upravovat staré metodiky je poměrně malá. I přesto je možné takovou aplikaci získat. K nejznámějším patří MetaEdit+ (http://www.metacase.com).

Druhá varianta je mnohem častější. Vývojáři CASE nástrojů často vyvíjí meta-CASE, ale před vydáním z něj vytvoří klasický CASE nástroj. Tím zvyšují prodejnost nových verzí. Inovace je pro ně mnohem jednodušší a nemusí řadu změn dělat přímo ve zdrojovém kódu, ale stačí pouze změnit meta-model. Společné prvky, které obsahuje každý z CASE nástrojů, mění (přidávají) jednotně. Tím dosahují vyšší produktivity a zároveň snižují počet chyb.

2         Popis problému, specifikace cíle

Cílem práce je navrhnout a implementovat meta-CASE nástroj. Samotný návrh se skládá ze dvou hlavních částí.

Je nutné navrhnout především způsob uložení a spravování dat v rámci meta-modelu a dále rozvržení aplikace jako takové. Návrh aplikace musí respektovat rozšiřitelnost a modifikovatelnost, jak na úrovni aplikace (uživatelským vstupem), tak i na úrovni kódu (předpokladem je, že vznikne aplikace, která bude obsahovat základní části a pro její široce použitelnou verzi bude nutný další rozvoj).

2.1      Meta-model

Návrh meta-modelu je stěžejní částí práce. Koncept uložení dat je základní částí, a proto je vhodné, aby nedocházelo v průběhu vývoje k velkým změnám. Veškeré součásti aplikace (import, export, správa dat, algoritmy pro práci s grafy, GUI a další) budou od prvních sestavení využívat meta-model a tak každá jeho úprava může představovat opravu celého projektu.

Z těchto důvodů je vhodné nejen správně navrhnout strukturu, ale dbát i na robustnost. Tzn. vytvořit abstraktní model spolu s mnoha rutinami tak, aby jednotlivé součásti aplikace nepřistupovaly přímo k datům, ale přistupovaly k datům prostřednictvím metod pomocných tříd. Tím se do značné míry odstíní samotné uložení dat a jejich užití. Díky tomu bude teoreticky možné zaměnit i samotnou strukturu (bude-li to v budoucnu nutné) a zachovat zpětnou kompatibilitu.

Tento projekt nevyžaduje žádné konkrétní struktury, nicméně výzkum v této oblasti nabízí řadu popsaných implementací. Proto se dále zaměřím na již navržené řešení a v další kapitole (3) popíši svůj návrh. Nebude se tedy jednat o převzatý koncept, ale o vlastní způsob řešení inspirovaný ověřenými modely:

-          CoCoA (Complex Covering Aggregation)

-          COMMA (Common Object Methodology Metamodel Architecture)

-          OPRR (Object-Property-Role-Relationship)

-          GOPRR (Graph-Object-Property-Role-Relationship)

-          MOF (Meta Model Facility)

-          NIAM (Nijssen’s Information Analysis Methodology)

2.1.1      CoCoA (Complex Covering Aggregation)

CoCoA byl vyvinut pro podporu konceptuálních modelů a pro datové modelování komplexních problémů.

Zahrnuje:

-          entity (entities)

-          pojmenované relace (names relationships)

-          n-ární relace (n-ary relationships)

-          alternativní pojmenování (alias name)

-          kategorie entit (entity categories)

Obrázek 3 Meta-model stavového modelu pomocí CoCoA [3]

2.1.2      COMMA (Common Object Methodology Metamodel Architecture)

Projekt COMMA se snažil vytipovat společné prvky všech objektově orientovaných metodik a ty následně reprezentovat jako základní pojmy meta-modelu a tím vytvořit meta-modely nejrozšířenějších objektově orientovaných metodik.

Používá tyto základní pojmy:

-          pojem (concept) – má jméno a atributy

-          dědění (inheritance) – vyjadřuje relaci specializace

-          asociace (association) – vyjadřuje vztah mezi pojmy

-          agregace (aggregation) – vyjadřuje skládání, je to speciální případ asociace

-          role (role) – objevuje se, když objekt přijímá charakteristiky jiného objektu. Role je dočasná a objekt může mít i více rolí najednou.

 

Projekt vyprodukoval velmi jednoduchý ale mocný objektově orientovaný meta-modelovací jazyk. Současnou nevýhodou je, že neexistuje napojení na CASE nástroje (projekt byl již ukončen).

2.1.3      OPRR (Object-Property-Role-Relationship)

Model OPRR byl vyvinut pány Welke a Smolander. Jazyk je zaměřen na modelovací techniky od základních po specifické. Rozšiřuje ER-model o roli (role). Ta je reprezentována kružnicí a rozděluje model na části se společnými vlastnostmi.

Obrázek 4 Meta-model stavového modelu pomocí OPRR [3]

2.1.4      GOPRR (Graph-Object-Property-Role-Relationship)

Jazyk pro meta-modelování GOPRR vznikl rozšířením jazyka OPRR jako součást disertační práce pana Kellyho. Úkolem bylo vytvořit s pomocí GOPRR CAME nástroj MetaEdit+.

Základními prvky GOPRR jsou:

-          diagram (graph) – je kolekce objektů, vztahů a rolí, která definuje, co a jak lze spojovat dohromady

-          objekt (object) – definuje entitu, která může existovat samostatně

-          vlastnost (property) – charakterizuje graf, objekt, roli nebo vztah

-          vztah (relationship) – existuje mezi dvěma a více objekty

-          role (role) – existuje mezi vztahem a objektem

Obrázek 5 Meta-model stavového modelu pomocí GOPRR [3]

2.1.5      MOF (Meta Model Facility)

Jedná se o standard vyvinutý OMG (Object Management Group) pro meta-meta-model. Spolu s jazykem UML (Unified Modeling Langue) a konverzním prostředkem XMI (XML Metadata Interchange) tvoří tzv. modelem řízenou architekturu MDA (Model Driven Architecture).

MOF, UML a XMI jsou určeny pro různé části aplikace. Zatímco MOF popisuje meta-meta-model, UML je využíváno na úrovni meta-modelu (vizualizace), XMI se používá pro mapování MOF do XML. Tím je možná výměna meta-modelů a jejich instancí.

Základní prvky MOF jsou:

-          třída (class) – určená pro definování různých meta-dat

-          asociace (association) – slouží k definování binárních relací mezi třídami. Má 2 zakončení (association end) obsahující jméno (name), typ (type), násobnost (multiplicity) a agregaci (aggregation).

-          typ dat (data types) – jsou navrženy k určení typů meta-dat, která nemají objektovou identitu (možnost modelovat jako objekty nebo jako hodnoty).

-          balík (package) – určen pro modularizaci meta-modelů. Zpravidla totožný s MOF meta-modelem.

-          omezení (constraint) – třída, asociace a typ dat utváří jednoduchý model pro meta-data. Umožňuje omezit meta-data, aby byla dobře formulovaná či sémanticky smysluplná.

2.1.6      NIAM (Nijssen’s Information Analysis Methodology)

NIAM byl původně navržen pro informační analýzu, ale později se použil v několika meta-modelovacích technikách.

Základní prvky NIAM jsou:

-          stav (state)

-          přechod (transition)

-          třída (class)

-          atribut (attribute)

-          operace (operation)

 

Je vhodný pro tvorbu stavového modelu.

Obrázek 6 Meta-model stavového modelu pomocí NIAM [3]

 

2.2      Architektura aplikace

Cílem této kapitoly není určit architekturu výsledné aplikace, ale spíše naznačit, z jakých je možné vybírat.

Nejdůležitější je určit, jaký druh softwaru je vyvíjen. Protože výsledným produktem bude možné vytvořit CASE nástroj, je otázkou, jakým způsobem bude použitelný. Většina meta-CASE nástrojů rozšiřují spolu s novými CASE nástroji svou nabídku a tím nabízí uživateli větší doménu modelů. To by pochopitelně měla zahrnovat i výsledná aplikace.

Existuje však i jiný pohled. Aplikace by mohla uživateli nabídnout vytvoření  nového CASE nástroje . Ten by poté byl výsledným projektem, který by bylo možné za pomoci frameworku spustit jako samostatný CASE nástroj. Ač se může zdát tento požadavek poněkud zbytečný, není tomu zdaleka tak. V praxi je naopak často žádáno, aby úpravy na vyšší úrovni uskutečňovala jen malá skupina vývojářů a ostatní  mohli CASE nástroj  pouze používat.

K tomuto účelu je daný framework, protože neumožňuje úpravu, ale pouze používání onoho CASE nástroje.

Tento koncept do jisté míry vede k alespoň částečné modularitě architektury. Není sice nutné navrhovat architekturu jako modulární, ale měla by být schopná využívat pluginy, resp. přídavné knihovny.

Monolitická architektura je možná také. Ta však zřejmě bude mít nevýhodu ve dvojité kompilaci a komplikovanějším vytváření dedikovaného CASE nástroje.

Jiný způsob implementace by nabízela architektura server-klient. Server jakožto jádro aplikace by nabízel všechny funkce od používání CASE nástrojů přes jejich správu a úpravu po vytváření nových modelů. Klient by mohl určovat, jaké volby aplikace budou aktivní, tzn., co uživatel bude moci používat (zda bude aplikace spuštěna jako meta-CASE nebo CASE nástroj).

Implementace musí být robustní a vhodná pro vytváření celé řady nástrojů. Musí být schopna zahrnovat i různé domény vývoje. To vyvolává požadavek na bázi metod připravených pro vývojáře nových CASE nástrojů. Uživatel bude jistě vytvářet nové importy a exporty. K tomuto účelu zde musí mít připravenou podporu.

Přístup k tomuto problému opět není jednoznačný. Zjednodušeně lze vyjmenovat základní dva přístupy.

Jednodušší z hlediska vývoje aplikace je vytvořit podporu pluginů. Každý by se zaregistroval a zobrazil jako volba v menu. Při jeho vyvolání by mu byl model zpřístupněn pomocí rozhraní a veškerou výkonnou část by převzal daný  plugin.

Složitější, ale zato rozvinutější formou je implementovat jistou podporu - nějaký skriptovací jazyk. Jazyk nemusí být syntakticky složitý, ale dostatečný pro procházení modelu (podpora přístupu k datům), transformaci dat (báze metod a přístup k nim), vstup a výstup (I/O funkce). Import dat je složitější, protože zahrnuje lexikální, syntaktickou a sémantickou analýzu. Ta musí být opět univerzální k široké doméně formátů.

Některé importy a exporty budou shodné. Jedná se například o ukládání obrázků, tisk nebo standardizovaný formát aplikace. Ty bude možné implementovat jak pomocí pluginů, tak přímo v aplikaci.

Obdobnou roli zde hrají i jiné funkcionality. Typickým příkladem jsou grafické doplňky. U většiny CASE nástrojů je vždy nabídka, kterou lze do modelu vložit text, obrazec či obrázek, který z hlediska modelu nemá žádný význam (jedná se pouze o kosmetickou úpravu modelu). Jedinými místy, kde se tyto prvky projeví, jsou import/export standardizovaného výstupu aplikace, tisk a export do obrázků.

3         Analýza a návrh řešení

3.1      Struktura meta-modelu

Meta-model má být schopen reprezentovat jakýkoliv model, který bude v rámci aplikace vytvářen. Proto musí odrážet reálné modely.

Každý model se skládá z entit a vazeb mezi nimi. O každé součásti lze evidovat řadu vlastností (název, číslo či jinou datovou strukturu definující parametry). Řada modelů, resp. CASE nástrojů však nabízí uživateli více možností a voleb. Ty mají modeláři ušetřit práci a čas, případně zvýšit kvalitu návrhu.

Vzhledem k předchozí kapitole, kde byly ukázky některých modelů, je nutné v této kapitole pouze shrnout prvky meta-modelu, které budou implementovány. Hlavním vodítkem bude koncept GOPRR, ale výsledný návrh nebude pouhou kopií, resp. nasazením. GOPRR byl zvolen, protože nejlépe vystihuje můj pohled na problematiku a vzhledem k jeho nasazení v metaEdit+, také pro jeho prověření.

3.2      Navrhované součásti

GOPRR se skládá z malého množství konstruktů (viz Obrázek 5). Daná terminologie se snaží spojit hlavní součást pod pojem graph. Ten představuje model, resp. schéma. Obsahuje množiny objektů, vlastností, rolí a vztahů. Pro snadnější popsání modelu budu postupovat od zdola nahoru.

-          vlastnost

o       hodnota blíže specifikující

§         objekt

§         vztah

§         roli

§         diagram

o       je pevně spjatá s daným prvkem

o       může být

§         předem definovaná

·         každý typ objektu je nutné pojmenovat

·         objekty a vztahy musí definovat svou grafickou reprezentaci

§         volitelná

·         až meta-modelář bude přidávat vlastnosti na základě požadovaného modelu

·         je podstatná z hlediska generování exportů, vykreslování elementů a vztahů, či ke kontrole skriptovacím jazykem

-          objekt

o       představuje jakoukoliv součást, např.

§         entita v ER-modelu

§         třída v diagramu tříd

o       může být definovaná řadou vlastností

§         pevně ukotvené

·         druh, resp. název objektu

·         grafická reprezentace (je vždy vyžadována, ale vytvářená uživatelem)

·         lokální jméno

·         dědičnost (role nebo objekt)

§         volně dodefinované, např.:

·         název generované tabulky v ER-modelu

·         private/protected/public u diagramu tříd

·         popis

-          vztah

o       jedná se o jakoukoliv relaci mezi n-ticí resp. dvojicí objektů

o       vlastnosti definují

§         možné objekty, se kterými ji lze použít (napojitelnost)

§         grafickou reprezentaci

§         uživatelem definované vlastnosti popisující typ vztahu

-          role

o       role je prvek slučující vlastnosti objektů. Každý objekt, který má nějakou roli, přebírá její vlastnosti.

§         lze definovat možný vztah role-objekt a pouhým přidáním objektu do role, rozšířit možnosti objektu.

§         představuje polymorfismus při návrhu

-          graf

o       představuje kompletní návrh modelu

o       skládá se z použitých

§         rolí

§         objektů

§         vztahů

§         vlastností

o       definuje možné propojení elementů

o       může mít své vlastnosti, např.:

§         popis

§         autor

§         DPI

 

Objekt a role se mohou vyskytovat samostatně v nějakém repositáři a případně je lze využívat ve více modelech. Modelář poté nemusí shodné objekty vytvářet pro různé modely znovu, což může do jisté míry zrychlit vývoj.

Naopak vlastnost, relace a diagram nemohou, protože:

-          vlastnost je vždy pevně spjatá z nějakým prvkem (grafem, objektem, rolí nebo vztahem)

-          relace je určena s konkrétními objekty (v určitém grafu), se kterými se pojí

-          graf představuje konkrétní model a proto není možné ho při vývoji znovu používat

 

Obrázek 7 Vztah role, vztahu, objektu a vlastnosti

 

Diagram (Obrázek 7) zobrazuje možnou reprezentaci modelu. Graph obsahuje 4 druhy prvků (role, objekt, vlastnost a vztah).

Role může dědit pouze jinou roli a tím přebírat její vlastnosti. Objekt může vzniknout jak děděním rolí tak i objektů. Obsahuje grafickou reprezentaci a řadu vlastností.

Vztah je připuštěn pouze binární. V konečném důsledku může být spojen pouze s objekty. Při návrhu je však možné definovat spoj i s rolí. Díky tomu bude spoj možný se všemi potomky.

Takový model je zobecněním všech modelů, která obsahující objekty a binární vazby, včetně těch, která lze na ně zjednodušit (např. rozdělením n-árního vztahu na binární).

3.2.1      Struktura modelu a meta-modelu

Model a meta-model budou obsahovat podobné součásti. Bude zde vždy existovat dvojice meta-model – model (definice – instance).

To do jisté míry odpovídá objektovému návrhu ve vyšších programovacích jazycích založených na virtuálním stroji (Java, SmallTalk aj.). Např. v meta-modelu bude objekt MetaGraph, reprezentující nějaký konkrétní meta-model a pro modely bude N instancí objektu Graph. Ty budou pevně spojeny s konkrétním objektem MetaGraph a budou představovat konkrétní diagram (schéma).

Pro snadnější práci s modelem resp. meta-modelem zde přibudou dvě dvojice tříd, které nemají s modelem ze sémantického hlediska nic společného:

-          Object (MetaObject)

o       Reprezentuje jakoukoliv třídu v modelu (meta-modelu)

o       Zobecněná součást

o       Nabízí práci se názvy

-          WithProperty (MetaWithProperty)

o       Představuje podskupinu tříd modelu (meta-modelu), které mohou mít definované vlastnosti (diagram, objekt, vztah nebo role)

o       Spravuje vlastnosti (přidávání, odebírání a jejich úpravu)

 

Zavedení třídy Object představuje zároveň terminologický spor. Object jako základní třída modelu nebo jako prvek modelu. Proto se budu od tohoto místa o objektu reprezentující prvek modelu vyjadřovat jako o elementu.

Object resp. MetaObject bude zahrnovat všechny společné části. Jedná se o podporu pro generování nových názvů a jejich úpravu. Na této úrovni se nejedná o vlastnost. Ta je vygenerována na základě názvu až v objektu WithProperty, resp. MetaWithProperty.

WithProperty resp. MetaWithProperty bude zobecněná třída pro graf, vztah, element a roli. Její zavedení umožňuje snadnější práci se všemi součástmi obsahující vlastnosti.

3.2.2      Vlastnost

Vlastnost představuje základní část, která může být vlastně spojena s jakoukoliv jinou částí, tzn. s:

-          rolí

-          elementem

-          vztahem

-          grafem

 

Její využití bude v aplikaci klíčové. Všechny ostatní prvky modelů budou pomocí vlastností definovány. Vlastnost bude představovat veškerá možná data zadaná uživatelem:

-          jméno objektu (mimo vlastnosti samotné)

-          vzhled (elementu a vztahu)

-          pozici a velikost

-          data, která reprezentuje element nebo vztah

-          dědičnost (role, element)

-          připojitelnost (konce vztahů)

-          uživatelská data a jiné

 

Vzhled bude realizován tak, že bude v rámci aplikace pouze jedna instance vzhledu. Před vykreslením budou nastaveny parametry (vlastnosti) a vykreslen náhled.

To vyvolává otázku, jakým způsobem bude měněna hodnota textů v textových polích, či jak bude možné ovlivnit vzhled na základě vlastností. Zde na řadu přichází skript. Skript bude možné spustit před každým čtením vlastnosti, tzn. i před vykreslením, a nastaví správnou hodnotu. Proto meta-vlastnost nebude zahrnovat pouze název a typ, ale i skripty vyvolávané událostmi (po inicializaci, před čtením a po zápisu).

Typ dat je obecně možné zadat buď pomocí předpisu, který poté vygeneruje danou vlastnost, nebo tak, že meta-vlastnost bude obsahovat již vytvořený datový typ a ten se bude kopírovat. Druhá varianta je jednodušší a přináší i možnost přednastavené hodnoty. Proto bude pro implementaci využito kopírování přednastavené hodnoty.

Data mohou nabývat celou škálu datových typů:

-          celočíselná hodnota

-          číslo s plovoucí čárkou

-          hodnota boolean

-          řetězec

-          vektor (seznam) hodnot

-          záznam (několik dvojic název-hodnota)

-          součást modelu nebo jeho instanci

-          objekt vytvořený skriptem

3.2.3      Element

Element z hlediska modelu představuje několik vlastností, kterými je definován:

-          dědičnost (element nebo role)

-          vzhled

-          název

-          uživatelem definované hodnoty popisující jeho význam

 

Tyto vlastnosti jsou definovány na úrovni meta-modelu. Při vytváření instance elementu budou vytvářet pouze instance meta-vlastností definovaných uživatelem a ostatní budou společné pro všechny instance, tzn., že stačí v elementu udržovat ukazatel na meta-element.

Element by měl nabízet metody pro zjištění dědičnosti (metoda instanceOf určí jestli MetaObject je předchůdcem nebo ne) a metody getter-setter pro získání základních vlastností (napojitelnost, dědičnost, vzhled aj.).

Ostatní podpora elementu bude implementována v jiných částech kódu (mimo model resp. meta-model).

3.2.4      Vztah

Vztah je objekt, určený spojením dvojic element-element, element-role nebo role-role. Výsledné spojení ve schématu je možné pro jakoukoliv dvojici elementů, které jsou potomky objektů, pro které je definováno napojení.

Vztah je z grafického hlediska složen z dvou polovin. Tyto poloviny jsou odděleny středem. Ten bude realizován za pomoci drageru (úchytu).

Každá z polovin se skládá z čáry (spojnice) a zakončení. Pro zakončení je podobný grafický návrh jako pro element. Spojnice jsou učeny na základě barvy, tloušťky a stylu čáry (plná, přerušovaná aj.)

Obě zakončení a spojnice tvoří vzhled vztahu.

Dvě datové struktury omezují možnosti napojení pro každý konec zvlášť a další dvě vlastnosti určují způsob napojení (na střed, k obvodu obdélníků příp. jiné).

Vztah z hlediska modelování může být často n-ární, např. v ER-modelu.

Obrázek 8 Ukázka základních konstrukcí ER-modelu

Zjednodušení vztahů pouze na binární však neznamená, že by takový vztah nešel v plánované aplikaci vytvořit a má navíc i další výhody.

Obecně nelze popsat všechny možné vztahy, protože mohou být rozmanitější, a z hlediska návrhu meta-CASE nástroje není možné dopředu omezit množství zakončení či složitějších grafický prvků, které obsahuje. Je ale možné takový vztah rozložit na elementy a řadu binárních vztahů.

Příklad (viz Obrázek 8) by se tedy rozložil na 2 druhy elementů:

-          Entita (viz entity1, entity2, entity3 nebo subentity3)

-          Vztah (viz relationship)

 

Jeden typ vztahu spojuje oba druhy elementů. Toto omezení stačí k tomu, aby nešlo přímo spojovat elementy relací nebo entit.

Obdobným způsobem lze realizovat atributy. Atribut i klíč jsou elementy. K jejich propojení jsou určeny jiné binární vztahy.

Proto se takováto změna neprojeví zhoršením návrhu. Ten bude pouze o něco složitější při vytváření exportů (skript bude muset procházet model do větší hloubky).

3.2.5      Role

Role je specifická součást. Ta má obdobné vlastnosti jako Element. Rozdíl mezi rolí a elementem je pouze v tom, že role nemůže vzniknout děděním elementu a nemá grafickou reprezentaci.

3.2.6      Diagram

Diagram je objekt, který zahrnuje všechny použité elementy, role, vztahy včetně jejich vlastností. Diagram obsahuje i své vlastnosti. Některé z nich budou povinné:

-          autor

-          název

-          popis

-          DPI (rozlišení, v kterém je schéma vytvářeno – má vliv pouze na tisk)

Obrázek 9 diagram tříd modelu a meta-modelu

3.3      Architektura aplikace

Architektura aplikace vychází z dříve zmiňovaných předpokladů (viz 2.2). Musí být navržena pro podporu:

-          importu

-          exportu

 

Výhodou aplikace by byla podpora pluginů. Import, export a případné pluginy budou používány pouze za pomoci skriptu. Nebude tedy možné např. vložit plugin, resp. načíst třídu mimo skript (např. jako vzhled).

Použít modulární architekturu je vzhledem k očekávanému dělení příliš náročné, protože součásti, které budou použity pouze v meta-CASE, se týkají úpravy meta-modelu. To zahrnuje pouze náhledy na meta-model, ale meta-model sám o sobě nikoliv. Části pro editaci vzhledu, vlastností, skriptu a další části budou pro CASE a meta-CASE nástroj společné (záleží na způsobu užití komponent). Díky tomu je těžké vyčlenit součásti, a tak rozdělení bude realizováno dvěma různými sestaveními, která se budou lišit v množství přídavných knihoven. Tyto knihovny budou obsahovat i upravené třídy, např. uvítací stránka nebude obsahovat volbu vytvořit CASE.

3.3.1      Potřebné součásti

Aplikace se skládá z několika částí. Základním blokem je meta-model, resp. model (viz 3.1, Obrázek 9). S modelem blízce souvisí třídy určené pro ukládání a načítání modelu, resp. meta-modelu.

Pro úpravu a vytváření modelů je dále součástí grafická reprezentace modelu, resp. meta-modelu. S tímto blokem blízce souvisí GUI, zahrnující všechny dedikované prvky uživatelského rozhraní.

Pro plnou funkci modelů je určena komponenta skriptu. Skript se dále člení do lexikální a sémantické analýzy. Na sémantickou analýzu blízce navazuje interpret a předdefinované funkce a objekty.

Všechny součásti jsou ale velmi svázány:

-          grafická reprezentace modelu s modelem samotným

-          skript s meta-vlastnostmi, resp. vlastnostmi

-          meta-model s modelem

-          aplikační část komponent pro práci s grafickou reprezentací a meta-modelem, resp. modelem

-          grafická reprezentace se skriptem

 

Je proto těžké rozdělit projekt do samostatných částí, kdyby byla zvlášť grafická reprezentace, model, skript, GUI a další součásti. V řadě případů by se jednalo spíše o zbytečnou komplikaci. Vůči návrhu MVC (model-view-controller) je samozřejmě vhodné oddělit grafickou část od modelu.

V implementaci budou použity anonymní třídy, které budou složité (vyčleněné) komponenty rozšiřovat pro specifický účel. Nebude se jednat o kroky proti MVC, ačkoliv přístup ke grafickým komponentám, které jsou přímo spjaty s modelem, budou inicializovány v třídách modelu. Je vhodné, aby tyto třídy udržovali jednu instanci i v momentě, kdy komponenta není používaná a nedocházelo tak ke ztrátě informací (např. rozvržení elementů a vztahů v diagramu).

Pro znázornění plánované aplikace, resp. součástí aplikace a jejich návaznosti dostatečně poslouží konceptuální model (Obrázek 10). Konceptuální model nepředstavuje žádný formalizovaný model, ale je dostatečně ilustrativní.

Na modelu jsou jasně vyznačeny všechny součásti návrhu a jejich vzájemná spojitost a obsáhlost. Zároveň je zde naznačena oblast potřebná jak pro meta-CASE, tak i pro dedikovaný CASE nástroj. Je zněj poměrně zřejmě vidět, že pro rozdělení na dvě aplikace modularita nijak významně nepomůže a proč je nutné vytvořit dvě různá sestavení.

Obrázek 10 Konceptuální model navrhované aplikace

3.3.2      Framework

Framework bude část aplikace určená pro uložení všech aditivních i základních funkcí pro chod aplikace. Ve výsledné aplikaci bude framework představovat prakticky veškeré funkce a podpory. Mimo něj bude součástí aplikace pouze model včetně jeho správy, spouštěcí třídy a použité knihovny.

Jeho vyčlenění bude značně odlišné od konceptuálního modelu, který se snažil naznačit spojitosti a co nejvíce rozčlenit návrh pro představu o součástech.

Jak již bylo řečeno dříve (viz 3.3.1) veškeré celky frameworku jsou na sobě více, či méně závislé, není tedy možné využívat model bez meta-modelu samostatně, grafickou reprezentaci bez skriptu, apod.

3.3.2.1  GUI

Součást frameworku bude balík GUI. Jedná se o repositář všech použitých komponent vyvinutých pro aplikaci:

-          editor (EditorPane)

o       bude pracovat s grafickým návrhem, náhledem i se samotným modelem (schématem)

-          náhled tisku (PrintPreview)

-          pracovní okna

o       jedná se o dokovací okna, reprezentují jiné informace o upravovaném modelu, resp. meta-modelu

§         průzkumník vlastností

§         průzkumník meta-vlastností

§         průzkumník modelu

§         okna pro návrh vzhledu

§         konzole

-          nástrojové lišty

o       standardní (uložit, načíst a další)

o       výběr fontu

o       grafické prvky

o       přiblížení

o       interpret

-          dialog pro volbu souboru

o       vznikne rozšířením JFileChooser

-          uvítací stránka a její součásti

-          roletové menu

o       obsahující položky menu, včetně jejich spravování

-          renderery a editory hodnot vlastností pomocí JTable

-          dialogové okno pro změnu hodnoty vlastnosti

-          dialogové okno pro nastavení typu dat

-          podpora pro práci s kontextovými menu

-          náhledy meta-modelu a meta-vztahu

3.3.2.2  Součást skriptovací jazyk

Tato součást bude zahrnovat celý skriptovací jazyk včetně editoru. Skriptovací jazyk bude jednoduchý – podmnožina JavaScript.

JavaScript je jazyk vycházející z Javy. Jeho základní konstrukty jsou jednoduché, blízké jazyku C++ a celosvětově známé. JavaScript sice nenabízí složitější konstrukce, ale ty také nebudou vyžadovány. Nejsložitější částí zde bude jistě přístup k datům a zápis do souboru. Ať by byl použit jakýkoliv skriptovací jazyk, bylo by nutné pro I/O funkce vytvořit knihovny, a proto rozšíření o vlastní metody není považováno za komplikaci.

JavaScript má řadu výhod pro aplikaci. Není nutné deklarovat typy a provádět typovou kontrolu. U objektu se dají používat nedefinované proměnné, což může značně pomáhat při vytváření importu a exportu. Například při procházení modelu prohledáváním do šířky je možné u každého elementu evidovat proměnné určující stav prohledávání, aniž by bylo nutné dopředu (mimo skript) proměnné explicitně definovat.

Tento skriptovací jazyk zároveň přináší výborné vlastnosti z pohledu překonávání chyb.

3.3.3      Vzhled aplikace

Aplikace bude mít jednoduché GUI ve stylu klasických CASE nástrojů. Bude se jednat o SDI (Single Dialog Interface).

Více otevřených dokumentů bude možné přepínat pomocí záložek na horní straně okna (obdobně jako u vývojových prostředí).

Grafický návrh se vlastně týká úvodní stránky. Vzhled celé aplikace bude rozšířen o roletové menu, panely nástrojů a pracovní okna. Ty budou volitelné a posouvatelné díky dokování resp. knihovně FlexDock.

 

Obrázek 11 Navrhovaný vzhled (rozvržení úvodní obrazovky meta-CASE nástroje)

3.4      Detailnější popis součástí

3.4.1      Grafický editor

Grafický editor bude reprezentován třídou EditorPane. Pomocí ní bude návrhář definovat elementy, prohlížet si náhledy i vytvářet schémata.

3.4.1.1  Návrh vzhledu

Vzhled může být definován pro element, nebo zakončení vztahu. Pro návrh vzhledu budou použity základní grafické prvky (čára, obdélní, polygon, textové pole a další), dále jen dekorace. Dekorace je možné používat, jak pro návrh vzhledu, tak i jako doplněk do vzniklého schématu.

Každá dekorace je vykreslena na základě vlastností, jakými jsou například tloušťka a typ čáry, barva a jiné. Hlavními vlastnostmi jsou body, na základě kterých je určen rozměr a pozice dekorace.

Protože všechny elementy mohou být „roztahovací“, musí návrh respektovat změny velikosti. Každý bod musí být možné specifikovat relativně. Cílem je umožnit maximum volnosti a jednoduchost návrhu. Výhodou je, že takový návrh bude proveden pouze jednou (při vytváření CASE) a poté jen používán.


Proto bude použita lokalizace 2 typů:

1.      relativní souřadnice, např.:

·         5px od levého okraje (obálky)

·         0px od pravého

2.      relativní pozice, např.:

·         20% horizontálně (od levého okraje)

·         0% vertikálně (od horního okraje)

 

Tím je možné jak rozdělit plochu na 2 části v určitém poměru, tak i vložit detail k nějakému z rohů.

Obdobný způsob využívá SmallTalk při návrhu GUI. Návrh je tak zproštěn o layout managery a přesto je dynamický.

Druhá část návrhu je složitější. Jedná se o vložení textových polí. Textové pole může obsahovat různě velký text. Problém nespočívá v umístění jednoho textového pole. To se dá snadno vyřešit pomocí roztáhnutí elementu.

Problém přichází až u návrhů, které obsahují více těchto textových polí. Dopředu není jasné, kolik řádek bude každé textové pole obsahovat, resp. jak dlouhé bude mít řádky. Typickým příkladem pro tuto problematiku je vzhled třídy v UML. Obsahuje 3 různá textová pole, přičemž minimálně u dvou nejsou dopředu jasné rozměry a je nutné použít složitější techniku k definici.

Obrázek 12 Třída v UML

Výše zmíněný návrh vzhledu pracuje pouze s jediným panelem (plátno ve tvaru obdélníku).

Problém je řešen rozdělováním panelu. Každý panel bude možné rozdělit vertikálně, resp. horizontálně na dva potomky. Tím vzniká binární strom panelů. Na úrovni každého z nich je možné přidávat dekorace. Rozměry všech potomků jsou určeny na základě preferovaných velikostí, tzn., že pro každý z panelů se vypočítá hodnota preferované velikosti a velikost hlavního panelu (který je členěn) se rozdělí v poměru preferovaných velikostí potomků.


Třída by se vytvářela např. tímto způsobem (relativní adresy jsou vůči levému hornímu rohu):

1.      hlavní panel se rozdělí horizontálně

2.      horní z panelů se opět rozdělí horizontálně

3.      do hlavního panelu se vloží bílý plný obdélník ([0%,0%]-[100%,100%])

4.      do hlavního panelu se vloží černý obdélník ([0%,0%]-[100%,100%])

5.      do spodních 2 nerozdělených panelů se vloží černá čára na horní hranu ([0%,0%]-[100%,0%])

6.      do každého nerozděleného (listového) panelu se vloží textové pole ([5%,5%]-[95%,95%])

7.      pro každé pole se vytvoří metoda, která vrátí text, např.:

·         getName() // vrátí řetězec vlastnosti název

·         getAttributes() // vrátí řetězec s názvy atributů oddělených \n

·         getOperations() // vrátí řetězec s názvy operací oddělených \n

8.      propojí se patřičná textová pole s metodami

Obrázek 13 Znázornění příkladu použití panelů (element třídy v UML)

 

Jiný pohled je možné ukázat na struktuře. Panel může mít definovány 2 potomky, resp. buď žádné, nebo právě dva. Způsob rozdělení (horizontální nebo vertikální) a dále seznam dekorací.

Každá dekorace poté zahrnuje několik vlastností, kterými je deklarována.

 

Obrázek 14 Ukázka struktury grafické reprezentace (vlastnost vzhledu)

3.4.1.2  ModelContainer

Třída ModelContainer bude představovat prvky, se kterými editor pracuje. Bude umožňovat přidávání a odstraňování prvků.

Dále se bude starat o jejich seřazení podle vrstvy a pomocí jejich metod bude možné získat seznam prvků pro vykreslení nebo pro výběr.

Děděním vzniknou dvě varianty:

-          Panel (pro návrh vzhledu)

-          Diagram (pro náhledy a práci s modelem)

3.4.1.3  EditorPane

EditorPane je komponenta, která využívá ModelContainer. Zprostředkovává vykreslování, přidávání prvků, jejich úpravu (posun, změna velikosti) a tisk.

Mezi základní operace patří změna velikosti pracovní plochy, přiblížení, resp. oddálení a vyvolávání kontextových menu u zobrazovaných prvků. Dále umožňuje pracovat se vztahy (napojování a odpojování).

 

3.4.1.4   Náhled tisku

Náhled tisku bude realizován úpravou EditorPane. Ten mimo jiné vykresluje pracovní plochu. Přetížením metod pro přidávání a odebírání prvků vznikne komponenta bez možnosti úprav (vkládání dekorací apod.). Dále bude přetížena metoda paintComponent, určena pro vykreslení editovaných prvků. Pomocí ní bude vykreslen samotný náhled.

Komponenta bude opatřena panelem nástrojů pro volbu formátu a čísla stránky. Další tlačítko panelu bude sloužit k vytisknutí dokumentu.

3.4.1.5  Dialog pro výběr souboru

Výběr souboru bude možný pomocí speciálního dialogu. Ten bude využívat JFileChooser. Dialog bude nabízet možnost přidání filtru souborů. Pomocí něj bude možné odfiltrovat soubory na základě přípony.

Přidání filtru bude určeno pomocí přípony, popisu filtru a případně posluchačem ActionListener. Posluchač bude vyvolán v případě, že by byl vybrán daný filtr a soubor byl zvolen.

3.4.1.6  Úvodní stránka

Úvodní stránka (viz Obrázek 11) se bude skládat z několika částí. V pravém horním rohu bude seznam až 5 posledních otevřených souborů. V levém horním rohu bude uvedeno číslo verze a logo aplikace.

Spodní část bude rozdělena na dva sloupce. V levém se bude nacházet několik komponent BoxComponent (viz 3.4.1.7) pro zobrazení zajímavých informací o aplikaci. Celkem jsou plánovány tři kategorie:

-          novinky

-          tipy

-          zpětná vazba

o       hlasování o kvalitě aplikace

o       možnost zaslat textovou zprávu vývojáři

 

V pravém sloupci bude dekorativní řádka s 2 volbami (přidat a vytvořit CASE nástroj). Pod ním se bude nacházet řádka umožňující filtraci výpisu meta-modelů, který se nachází pod ním.

Každý záznam o meta-modelu bude obsahovat název, popis, jméno autora, datum sestavení a základní volby (vytvořit CASE, upravit meta-model).

3.4.1.7  BoxComponent

Jedná se o jednoduchou komponentu schopnou zobrazit několik stránek.

Bude obsahovat tři tlačítka. Dvě se budou nacházet ve spodní části a budou určena k posunu v rámci stránek (předchozí a následující strana). V horní části bude titulek a tlačítko, kterým bude možné komponentu minimalizovat, resp. maximalizovat.

3.4.2      Skript

Jak již bylo řečeno v kapitole 3.3.2.2 pro skriptování bude použita podmnožina jazyku JavaScript. Použití celého standardu není potřeba a ani žádoucí. Velké množství funkcí a podpory je totiž spojeno s HTML kódem a proto nepoužitelné pro potřeby aplikace.

 

3.4.2.1  Podporované části

Implementovány budou některé cykly (do-while, while a klasický for), výrazy, volání metody, funkce, definice proměnných, definice konstant a základy OOP.

Dále je nutné implementovat základní metody a objekty např.:

-          Math

-          document.write, document.writeln

-          eval

 

Prvky modelu, resp. meta-modelu bude nutné obohatit o metody, aby je bylo možné procházet a vytvářet. Dále je nutné zajistit podporu pro práci se soubory. K tomu budou určeny objekty FileWriter a FileReader. Tyto objekty nejsou součástí JavaScriptu, ani nerespektují stejnojmenné objekty v Javě. Jedná se o nestandardní objekty pro snadnou práci se soubory. Detailní popis všech předdefinovaných metod a objektů je uveden v příloze D.

3.4.2.2  Gramatika

Skriptovací jazyk využívá k překladu LL(1) gramatiku uvedenou v příloze D. Pro překlad kódu bude využit rekurzivní sestup, přičemž názvy metod budou respektovat názvy pravidel.


3.5      Návrh balíčků a rozložení projektu

Každý moderní návrh aplikace využívá rozdělení aplikace do balíčků. Rozdělení respektuje blízkost tříd a umožňuje snazší přístup k jednotlivým celkům.

Package Icon

metacase

Hlavní balíček, spustitelné části

 

 

Package Icon

res

 

 

Obrázky a jiné zdroje

 

 

Package Icon

core

 

 

Balíček obsahující jádro a komunikační celky mezi součástmi

 

 

 

 

Package Icon

framework

 

 

 

 

Balík frameworku

 

 

 

 

 

 

Package Icon

gui

 

 

 

 

 

 

Vlastní komponenty

 

 

 

 

 

 

 

 

Package Icon

editor

 

 

 

 

 

 

 

 

Hlavní součásti editoru

 

 

 

 

 

 

 

 

 

 

Package Icon

anchor

 

 

 

 

 

 

 

 

 

 

Způsoby přichycení zakončení vztahu k elementu

 

 

 

 

 

 

 

 

 

 

Package Icon

decores

 

 

 

 

 

 

 

 

 

 

Všechny dekorace

 

 

 

 

 

 

 

 

Package Icon

infos

 

 

 

 

 

 

 

 

Představuje data pro komponenty novinky, tipy a zpětná vazba

 

 

 

 

 

 

 

 

Package Icon

jtable

 

 

 

 

 

 

 

 

Renderery a editory JTable pro PropertyData

 

 

 

 

 

 

 

 

Package Icon

toolbars

 

 

 

 

 

 

 

 

Všechny panely nástrojů

 

 

 

 

 

 

Package Icon

other

 

 

 

 

 

 

Nezařaditelné

 

 

 

 

 

 

Package Icon

script

 

 

 

 

 

 

Skript - JavaScript

 

 

 

 

 

 

 

 

Package Icon

editor

 

 

 

 

 

 

 

 

Editor skriptu

 

 

 

 

 

 

 

 

Package Icon

exceptions

 

 

 

 

 

 

 

 

Výjimky používané při kompilaci a interpretaci skriptu

 

 

 

 

 

 

 

 

Package Icon

functions

 

 

 

 

 

 

 

 

Základní funkce a operace skriptu (přiřazení, sčítaní aj.)

 

 

 

 

 

 

 

 

Package Icon

io

 

 

 

 

 

 

 

 

Vlastní datové proudy

 

 

 

 

 

 

 

 

Package Icon

tokens

 

 

 

 

 

 

 

 

Veškeré tokeny (lexikální elementy) použité při lexikální analýze

 

 

 

 

 

 

 

 

Package Icon

variable

 

 

 

 

 

 

 

 

Definice typů proměnných skriptu

 

 

 

 

 

 

Package Icon

undo

 

 

 

 

 

 

Správce akcí zpět-vpřed

 

 

 

 

Package Icon

metamodel

 

 

 

 

Balík zahrnující model, metamodel a jejich podporu

 

 

 

 

 

 

Package Icon

exceptions

 

 

 

 

 

 

Výjimky generované funkcemi podpory

 

 

 

 

 

 

Package Icon

io

 

 

 

 

 

 

Ukládání / načítání modelu a metamodelu

 

 

 

 

 

 

Package Icon

other

 

 

 

 

 

 

Nezařaditelné

 

 

 

 

 

 

propertydata

 

Třídy reprezentující data vlastností

4         Realizace

Při realizaci aplikace byl plně respektován návrh. Implementace se zaměřila pouze na meta-CASE nástroj. Možnost vytvořit derivovaný CASE nástroj nebyla implementována. Případná její realizace však představuje pouze drobné úpravy.

V této kapitole budou postupně procházeny všechny balíčky (package) a popsány jejich základní třídy včetně použitých návrhových vzorů.

Veškerá implementace aplikace se nachází v hlavním balíčku metacase. Ta obsahuje všechny součásti implementace aplikace. Její součástí je spustitelná třída MetaCase a dva balíčky:

-          core

o       samotná implementace (všechny další třídy aplikace)

-          res

o       obsahuje ikony, obrázky a textový soubor s číslem verze

4.1      Balíček metacase.core

Skládá se ze dvou balíčků:

-          framework

o       Obsahuje GUI a další součásti mimo model a s ním přímo spojené třídy

-          metamodel

o       Model, meta-model, typy vlastností

o       Ukládání a načítání XML souborů

4.2      Balíček metacase.core.framework

Framework se rozděluje na tři, resp. čtyři základní části. Těm odpovídají i názvy balíčků:

-          gui

o       součásti uživatelského rozhraní

o       vlastní komponenty

o       editor a jeho prvky

-          script

o       lexikální analýza

o       sémantická analýza

o       interpret

o       editor kódu

-          undo

o       správce změn

o       nabízí funkce zpět a vpřed

-          other

o       nezařaditelné součásti

4.3      Balíček metacase.core.framework.gui

4.3.1      Třída AboutDialog

Dialogové okno „o programu“. Vypíše verzi a text o programu.


4.3.2      Pracovní okna

Pracovní okna jsou realizována na technologii FlexDock. Implementovány byly pouze komponenty, tvořící jejich těla. Každá taková komponenta je navržena tak, že obsahuje statickou proměnnou zahrnující všechny instance pracovního okna.

Dále jsou zde statické metody refreshAll nebo resetAll. Ty obnoví stav všech instancí. Komponenta tedy představuje náhled editované části.

V aplikaci je v současné době možné zobrazit každý panel maximálně jednou. Šlo by tedy použít návrhový vzor soliton. Obě varianty mají stejný způsob použití, ale použitý styl dovoluje větší rozšiřitelnost (možnost vytvoření různých variant pracovních oken zobrazovaných v jeden moment).

Název okna

Jméno třídy

Popis viz

Průzkumník metamodelu

MetaCaseExplorer

C.3.1

Průzkumník metavlastností

MetaPropertiesExplorer

C.3.5

Průzkumník prvků modelu

ModelComponentExplorer

C.3.3

Průzkumník modelu

CaseExplorer

C.3.2

Konzole

Console

C.3.7

Průzkumník vlastností

PropertiesExplorer

C.3.4

Průzkumník panelů návrhu

PanelsExplorer

C.3.6

Průzkumník modelů

ModelsExpolorer

C.3.8

Tabulka 1 Pracovní okna

4.3.3      Třída JMenuBarFilled

JMenuBarFilled je komponenta roletového menu. Vznikla zděděním třídy javax.swing.JMenuBar. V konstruktoru je komponenta naplněna všemi menu a volbami (viz C.5).

Komponenta zahrnuje vnořenou třídu JMenuRight. Jedná se o komponentu, reprezentující prázdné místo v roletovém menu. Její rozměry jsou určeny šířkou celého menu a součtem všech nabídek. Vkládá se před poslední nabídku. Díky tomu se poslední menu zarovná doprava.

4.3.4      MenuContainer, MenuContainerInterface a MenuContainerDynamic

Aplikace obsahuje spoustu komponent, které mají vlastní kontextové menu. Pro snadnou správu vzniklo několik tříd a rozhraní.

MenuContainerInterface je rozhraní, které dědí všechny komponenty obsahující kontextové menu (součásti modelu i GUI). Nabízí dvě metody, které vrací objekt typu MenuContainer pro komponentu, resp. pro pozici v ní. To se využívá například u editoru. Zde jsou zobrazeny grafické reprezentace modelu a editor vypočítává, kterého prvku se akce týká.

MenuContainer je třída, do které se snadno přidávají nové volby. Každá volba může být zadána několika řetězci.

Název parametru

Význam

path

Pozice v menu, např. „soubor.otevřít“ vytvoří menu soubor s podmenu otevřít a do něj vloží volbu

text

(Zobrazovaný) název volby

actionCommand

Řetězec identifikující akci

Tabulka 2 Parametry MenuContainer typu String

Volba může být obohacena o ikonu (ImageIcon) nebo akci, která se provede při vyvolání (ActionListener).

Zadání položky může být realizováno i za použití standardních objektů typu JMenu, JMenuItem nebo jejich potomky.

Objekt MenuContainer vytvoří kontextové menu, vrátí ho a nakonec se vyhodnotí funkce, zda byla provedena správná akce (pravé tlačítko myši nebo klávesa pro vyvolání kontextového menu) pro vyvolání menu a případně ho zobrazí.

Výše popsané prvky se vytváří pouze na úrovni implementovaného kódu. Některá menu je však možné vytvářet i na úrovni skriptu (pro rychlejší práci s vytvářeným modelem). Proto je zde k dispozici MenuContainerDynamic. Tato třída vytváří podobnou strukturu jako MenuContainer, ale za pomoci skriptu. Nabízí možnost vložit své volby do nějakého MenuContainer a tím obě kontextová menu „spojit“. Taková menu je možné vytvářet u tříd Relationship (vztah), Element (element) a End (zakončení vztahu). Při jejich volbě se provede volání metody skriptu.

4.3.5      Třída BaseView

Třída BaseView je komponenta založená na javax.swing.JTabbedPane. Je hlavní součástí aplikace. Umožňuje zobrazovat editory, úvodní stránku, náhledy meta-modelu a náhled tisku. Spravuje jejich přepínání (při přepnutí mezi záložkami obnovuje data pracovních oken), umožňuje jejich přidání a odebrání.

Tato třída může být v aplikaci pouze jednu instanci a využívá návrhový vzor soliton.

4.3.6      Třída WelcomeScreen

Úvodní stránka je první záložka, která se po startu aplikace zobrazí v komponentě BaseView (viz 4.3.5 a C.1).

Ač může mít v celé aplikaci maximálně jednu instanci, nevyužívá návrhový vzor soliton, protože instanci vytváří pouze třída BaseView. Ta vytvoří instanci úvodní stránky na začátku a udržuje jí po celou dobu.

Skládá se z řady komponent:

-          BoxComponent – nabídky novinky, tipy a zpětná vazba

-          MetaCaseList – seznam meta-modelů k práci

-          LastOpenedFiles – udržuje N (5) naposled otevřených souborů

4.3.7      Třída BoxComponent

Komponenta umožňuje prohlížení množiny dokumentů, či komponent. Zprostředkovává jejich přepínání a zobrazování.

Abstraktní třída metacase.core.framework.gui.infos.DataContainer (viz Obrázek 18) nabízí jednoduché metody pro zjištění pozice a počtu stránek. Další metody umožňují změnu pozice (vpřed a vzad) a zjištění informací o ní (možnost posunu vpřed a vzad). Děděním třídy DataContainer vznikla pro každou komponentu s informacemi zvláštní třída udržující a spravující množinu zobrazovaných stránek (třídy News, Feedback a Tips).

4.3.8      Třída Print

Třída Print představuje obsluhu tisku. Vstupem je obrázek vygenerovaný editorem. Pokud je obrázek větší než formát papíru, rozloží ho na několik stránek. Třída zprostředkovává jak samotný tisk, tak i vykreslování náhledu tisku (viz 4.3.9).


4.3.9      Třída PrintPreview

Náhled tisku je založen na dvou třídách:

-          EditorPane

o       K zobrazení náhledu (vykreslí papír a zajistí přibližování)

-          Print

o       Výsledný tisk

o       Vykreslování obsahu dokumentu

4.4      Balíček metacase.core.framework.gui.editor

Balíček zahrnuje všechny použité součásti pro editor a jeho grafické reprezentace.

Obsahuje další dva balíčky:

-          anchor

o       přichycení zakončení vztahu k elementu

-          decores

o       všechny dekorace pro práci v editoru a interface pro vkládání

4.4.1      PaintInterface, PaintLayerInterfacase a Moveable

Trojice rozhraní pro práci s grafickými prvky.

Rozhraní PaintInterface nabízí metodu pro vykreslení prvku do java.awt.Graphics2D. Rozhraní PaintLayerInterface ho rozšiřuje tím, že přidává metody pro změnu a zjištění vrstvy, na které se prvek nachází.

Poslední rozhraní Moveable je určeno pro všechny prvky umožňující pohyb po plátně. Nabízí metody pro pohyb i metody pro zjištění, zda obsahují nějaký konkrétní bod a vzájemnou polohu dvou prvků.

4.4.2      Třída EditorPane

Představuje editor se základními metodami pro jeho správu:

Metoda

Funkce

setInserter

Nastaví vkládání prvku

removeInserter

Zruší vkládání prvku

add

Vloží nový prvek

remove

Odstraní prvek

setZoom

Nastavení přiblížení

setWorkPlaceSize

Nastavení velikosti pracovní plochy

Tabulka 3 Základní metody EditorPane

 

Editor dále spravuje události myši a klávesnice, tzn. pohyb prvky, mazání pomocí klávesy delete, označování mnoha prvků a další.

4.4.3      ModelContainer, Diagram, Panel, PanelsTree

ModelContainer je abstraktní třída reprezentující obsah editovaného modelu. Používají se třídy vzniklé jeho zděděním: Diagram a Panel, resp. PanelsTree.

Diagram je určen pro modely, protože zahrnuje nejen dekorace, ale i elementy a vztahy.

Naproti tomu Panel se používá při vytváření vzhledu (elementu nebo zakončení vztahu). Může obsahovat pouze dekorace. Protože analýza předpokládala strukturu panelů (viz 3.4.1.1) a třída Panel představuje pouze jeden z nich, vznikla děděním třída PanelsTree. Ta nabízí stejné možnosti a navíc i dělení (včetně zobrazování potomků).

4.4.4      Inserter a zděděné třídy

Inserter je abstraktní třída určená pro vkládání prvků do editoru. Pro vložení je třeba definovat všechny body prvku. Inserter se vytvoří, nastaví se mu žádaný prvek. Postupně se mu pomocí metody setNext předávají definované body. Prvek se tak zpřesňuje. Pokud se vkládání nezruší získá editor prvek pomocí metody get.

Třída Inserter nabízí také náhled (metoda preview), což umožňuje snadnější vkládání uživateli.

Jak již bylo řečeno, jedná se pouze o abstraktní třídu. Je to z toho důvodu, že pomocí něj se vkládají dekorace, elementy i vztahy. Každý prvek se ale vkládá jiným způsobem.

Pro určení elementu je třeba určit jeden bod (levý horní roh). Rozměry se vypočítají na základě preferované velikosti.

Vložení vztahu vyžaduje nalezení elementů, se kterými se má spojit.

Dekorace se dají z pohledu vkládání rozdělit na dvě skupiny:

-          s předem definovaným počtem bodů

-          polygony

Proto vznikly děděním 4 třídy podle druhu vkládaného prvku (viz Obrázek 15):

Název třídy

Použití

InserterByProperties

Dekorace, kromě polygonů

InserterRelationship

Vztahy

InserterElement

Elementy

InserterPolygon

Dekorace polygonu

Tabulka 4 Účel tříd dědících třídu Inserter

4.4.5      Třídy Element, Relationship, RelationshipLine a End

Třídy reprezentují grafickou reprezentaci elementů a vztahů. Jsou navrženy jako renderery, tzn., že vzhled každého z objektů je určen patřičným meta-objektem (meta-vztah nebo meta-element). Na něj má element i vztah odkaz.

Element tedy před vykreslením nastaví vzhledu vlastnosti (pozice, velikost) a poté ho vykreslí. U vztahu je tento princip také využit, jen vzhledem ke struktuře vztahu složitěji. Zakončení vztahu nejprve provede rotaci (natočení zakončení) a vykreslí ho stejným způsobem jako element. Spojnice je reprezentována třídou RelationshipLine. Ta má stromovou strukturu odrážející zalamování spojnice.

Každá třída Relationship, tzn., každý vztah má svou spojnici. Ta se tedy vykresluje přímo.

4.4.6      Třída Rulers

Každý editor a náhled tisku může být opatřen pravítky (C.8). Třída Rulers zahrnuje trojici komponent (tlačítko pro přepnutí jednotek, horizontální a vertikální pravítka).

Tlačítko je upravená komponenta javax.swing.JLabel a pravítko je realizováno jako nová komponenta, tzn. dědí javax.swing.JComponent.

Pravítka mohou zobrazovat 3 jednotky (pixely, palce a centimetry).

4.5      Balíček metacase.core.framework.gui.editor.anchor

Obsahuje rozhraní AnchorInterface pro práci s všemi přichyceními zakončení vztahu k elementu. Umožňuje tedy nastavit obdélník elementu, ke kterému se přichytává, získat normálový vektor přichycení a bod napojení spojnice.

V balíčku se dále nachází dva druhy přichycení:

Název třídy

Způsob přichycení

AnchorOnCenter

Na střed obdélníku elementu

AnchorOnRect

Na obvod obdélníku elementu

Tabulka 5 Způsoby přichycení

4.6      Balíček metacase.core.framework.gui.editor.decores

Obsahuje všechny použitelné dekorace a rozhraní pro jejich přidávání AddDecoreInterface. Ten dědí třídy Diagram a Panel, resp. ModelContainer (viz 4.4.3).

Název třídy

Typ dekorace

Počet bodů

DecoreDrawArc

Část kružnice

3

DecoreDrawOval

Elipsa

2

DecoreDrawPolygon

Polygon

≥3

DecoreDrawRect

Obdélník

2

DecoreFillArc

Výseč kruhu

3

DecoreFillOval

Plná elipsa

2

DecoreFillPolygon

Plný polygon

≥3

DecoreFillRect

Plný obdélník

2

DecoreLine

Čára

2

DecorePoint

Bod

1

DecoreTextArea

Textové pole

2

DecoreVector

Vektor

2

Tabulka 6 Dekorace

 

Dekorace vznikly děděním abstraktní třídy Decore (viz Obrázek 17). Ta zajišťuje práci s dragery (úchyty pro změnu bodů), vykreslováním, serializaci a deserealizaci XML kódu.

4.6.1      Náhledy

Aplikace obsahuje řadu náhledů. Všechny jsou založeny na třídách Diagram a EditorPane. Obě jsou zděděny a přetíženy jejich metody, které umožňují strukturální změny. Blokuje se tedy mazání elementů a spojování, resp. odpojování vztahů.

Název náhledu

Třída

Náhled meta-modelu

MetaGraphViewer

Náhled meta-vztahu

MetaRelationshipViewer

Náhled tisku

PrintPreview

Tabulka 7 Náhledy

4.7      Balíček metacase.core.framework.gui.infos

Balíček obsahuje třídy pro udržování dat informačních komponent na úvodní stránce (viz C.1):

-          novinky

-          tipy

-          zpětná vazba

 

Základem je abstraktní třída DataContainer. Ta spravuje index (pozici – číslo stánky). Nabízí a kontroluje posun. Aktuální stránka se vrací jako komponenta metodou getComponent. Novinky (News) a tipy (Tips) jsou třídy zobrazující HTML stránky. Liší se pouze úložištěm zpráv, proto Tips dědí News a pouze přetíží metodu getDir (vrací adresář úložiště).

Naopak třída FeedBack vrací vlastní komponentu (anonymní třídu) buď pro hlasování, nebo pro zaslání zprávy. Informace se posílají pomocí http protokolu pomocí POST na webovou stránku umístěnou na http://metacase.ree-systems.cz/. Výsledek otevření PHP skriptu se zobrazí v dialogovém okně.

4.8      Balíček metacase.core.framework.gui.jtable

Obsahuje renderery a editory pro JTable. Jsou určeny pro data vlastností a meta-vlastností. Ty jsou využívány průzkumníky vlastností (viz C.3.4), meta-vlastností (viz C.3.5) a dialogovým oknem pro změnu hodnoty.

V průzkumnících se ve stejném sloupci mohou editovat hodnoty různého typu. Proto je třeba, aby byl jeden renderer resp. editor zastupující řadu rendererů resp. editorů. Protože cílem nebylo mít jinou komponentu pro zobrazování a jinou pro editaci, byly renderery a editory spojeny.

Zastřešujícím rendererem resp. editorem pro data vlastností je třída PropertyDataRendererEditor, pro meta-vlastnosti MetaPropertyRendererEditor.

PropertyDataRendererEditor má pro každý typ jednu instanci konkrétního rendereru resp. editoru, a tu používá, je-li to třeba. Obsahuje i složité, tzn. zobrazované velkými komponentami. Pokud se ale mají zobrazit v JTable, použije se tzv. defaultní. Ten obsahuje popis dat a tlačítko pro vyvolání dialogového okna k úpravě hodnoty.

Název třídy

Určen pro

AnchorBoxTableCellRendererEditor

AnchorBox

BooleanBoxTableCellRendererEditor

BooleanBox

ColorBoxTableCellRendererEditor

ColorBox

DefaultTableCellRenderer

Defaultní pro všechny PropertyData

ElementAndRoleBoxTableCellRendererEditor

ElementAndRoleBox

FloatingPointBoxTableCellRendererEditor

FloatingPointBox

FontBoxTableCellRendererEditor

FontBox

ChoiceBoxTableCellRendererEditor

ChoiceBox

IntBoxTableCellRendererEditor

IntBox

PointBoxRelativeTableCellRendererEditor

PointBoxRelative

PointBoxTableCellRendererEditor

PointBox

PropertyDataRendererEditor

Zastřešuje všechny PropertyData

RecordBoxTableCellRendererEditor

RecordBox

StringBoxTableCellRendererEditor

StringBox

StrokeBoxTableCellRendererEditor

StrokeBox

VectorBoxTableCellRendererEditor

VectorBox

Tabulka 8 Renderery a editory pro PropertyData

4.9      Balíček metacase.core.framework.gui.toolbars

Balíček obsahuje všechny panely nástrojů (viz C.4). Ty jsou založeny na abstraktní třídě JToolBarUndecored. Ta vznikla zděděním javax.swing.JToolBar. Odstraňuje rám dialogového okna a nabízí metody pro snadné přidávání a vytváření tlačítek (JToogleButton a JButton).

Panely jsou navrženy stejně jako pracovní okna. V aplikaci je dovolena maximálně jedna instance každého z panelů. Každý panel je však navržen robustně a tedy pro více instancí. Obsahují statické metody pro správu všech instancí najednou. To nabízí možnost rozšiřitelnosti u budoucích verzí (dovolí to různé varianty stejného typu panelu).

Název třídy

Název panelu nástrojů

Popis viz

DecoresExtToolBar

Bod, vektor

C.4.3

DecoresToolBar

Dekorace

C.4.2

FontToolBar

Font

C.4.6

InterpretToolBar

Interpret

C.4.7

StandardToolBar

Standardní

C.4.1

UndoToolBar

Zpět, vpřed

C.4.4

ZoomToolBar

Přiblížení

C.4.5

Tabulka 9 Panely nástrojů

4.10Balíček metacase.core.framework.script

Zahrnuje všechny součásti skriptu:

-          definici lexikálních elementů

-          lexikální analýzu

-          sémantickou analýzu

-          základní funkce, operace a objekty

-          interpret

-          editor kódu

-          proměnné (definice, funkce)

-          výjimky překladu

4.11Balíček metacase.core.framework.script.editor

Obsahuje editor kódu. Ten se rozděluje do čtyř tříd:

-          JavaScriptContext

-          JavaScriptDocument

-          JavaScriptEditor

-          JavaScriptEditorKit

 

Ty nejen definují nový dokument (pro kód JavaScriptu) ale i EditorKit pro práci a především zobrazení kódu. Kód je obarvován po každé změně. K tomu je třeba aplikovat lexikální analyzátor. Ten vytvoří seznam lexikálních elementů (tokenů). Každý patří do nějaké skupiny a podle toho je u něj definován styl fontu a barva.

Pokud je lexikální analýza úspěšná, je spuštěn i sémantický překlad. Ten vytvoří strukturu vhodnou pro interpretaci. Pokud dojde při překladu k chybě, je označen token, který nebyl očekáván (přijat) a při překreslení editoru je zvýrazněn. Zároveň se vypíše hláška o chybě do konzole.


4.12Balíček metacase.core.framework.script.exceptions

Nachází se zde řada výjimek určených pro řízení běhu skriptu, interpretaci příkazů a jako výjimky překladu.

Název třídy

Použití

BreakException

Vykoná příkaz break

ContinueException

Vykoná příkaz continue

InterpretException

Obecná chyba při interpretaci

ParserException

Chyba při překladu

ReturnException

Vykoná příkaz return

StopException

Zastaví interpretaci (viz C.4.7)

ThrowException

Vykoná příkaz throw

Tabulka 10 Výjimky používané pro skriptování

4.13Balíček metacase.core.framework.script.functions

Obsahuje všechny základní operace a příkazy pro interpretaci skriptu, tzn. např. +, -, *=, return a další.

4.14Balíček metacase.core.framework.script.io

Balíček obsahuje pouze dvě třídy:

-          BackupInputStream

o       Udržuje N posledních hodnot a dovoluje se vrátit zpět

o       Využívá se při lexikální analýze

-          TextInputStream

o       Vytváří vstupní proud z řetězce

o       Využívá se při lexikální analýze

4.15Balíček metacase.core.framework.script.tokens

Obsahuje třídy všech tokenů (pro každý token je zvláštní třída). Třídy vytváří hierarchii (dělí se na druhy tokenů). Každý druh určuje styl a barvu fontu (viz Obrázek 16).

4.16Balíček metacase.core.framework.script.variable

Obsahuje datové typy skriptu. Všechny jsou odvozeny od abstraktní třídy Variable. Ta dovoluje převod na jiný datový typ (konverze mezi řetězci, čísly a pravdivostní hodnotou).

Pro vytváření objektů se Variable používá také, ale jako anonymní třída v reprezentovaném objektu.

Název třídy

Reprezentuje data

ArrayVariable

Pole

BooleanVariable

Pravdivostní hodnota (true / false)

FloatingPointVariable

Číslo s plovoucí řádovou čárkou

IntegerVariable

Celočíselná hodnota

NullVariable

Hodnota null

ObjectVariable

Obecný objekt (nahrazeno anonymními třídami)

StringVariable

Řetězec

Variable

Cokoliv

Tabulka 11 Datové typy

4.16.1 Třída LexicalAnalyzer

Provádí lexikální analýzu. Data pro překlad musí být typu InputStream (viz 4.21). Výstupem je seznam tokenů přístupné přes metodu get(i), případně za pomoci getIndex(i) určující index na základě pozice v kódu.

Pro čtení sémantickým analyzátorem se používá vnořená třída SemanticAnalyzer.LexicalAnalyzerFilter.

4.16.2 Třída SemanticAnalyzer

Provádí sémantickou analýzu. Vstupem je LexicalAnalyzer, který je proudově čten za pomoci SemanticAnalyzer.LexicalAnalyzerFilter.

Za použití LL(1) gramatiky (viz 3.4.2.2)  vytvoří stromovou strukturu pro interpretaci.

Obsahuje několik metod, které se používají až po překladu:

Název metody

Funkce

getCode

Vrátí stromovou strukturu kódu pro interpretaci

setThis

Nastaví objekt reprezentovaný this

getThis

Vrátí hodnotu this

evalCode

Odpovídá příkazu eval (pro překlad skriptů meta-vlastností)

Tabulka 12 Důležité metody třídy SemanticAnalyzer

4.16.3 Třída PredefinedCode

Vygeneruje použitelné funkce a objekty skriptu. Jedná se o metody parseInt, parseFloat, isNaN, isFinite, alert, prompt, confirm, createGraph a objekty Date, Math, Array, FileReader, FileWriter a document.

4.17Balíček metacase.core.framework.undo

Třídy určené pro ovládání funkcí zpět a vpřed.

Hlavní součástí je třída UndoManager. Ta udržuje změny všech PropertyData (hodnot vlastností) a na základě nich provádí změny vpřed a vzad.

Protože existují operace, které nejsou reprezentovány pouze změnou hodnoty PropertyData (posun prvku, přidání resp. odebrání prvku) obsahuje balíček třídu MoveableAsPropertyData. Ta reprezentuje pohyb prvků jako PropertyData. Přidávání a odebírání prvků je reprezentováno vnitřní třídou UndoManager.ChageRemove resp. UndoManager.ChangeAdd.

UndoManager je určen výhradně pro práci s PropertyData. To ale neumožňuje používat zpět resp. vpřed v editoru kódu. Pro tuto funkci je určena třída TextEditorUndoManager vzniklá zděděním třídy UndoManager.

4.18Balíček metacase.core.framework.other

Obsahuje pět nezařaditelných tříd a rozhraní, tzn. třídy použitelné z různých částí.


 

Název třídy

Použití

LastOpenedModels

Datová struktura udržující seznam naposledy otevřených souborů

MetaPropertiesContainerInterface

Rozhraní pro přístup k meta-vlastnostem objektu

NormalVector

Normálový vektor (viz 4.4.5)

PropertiesContainerInterface

Rozhraní pro přístup k vlastnostem objektu

SortedList

Seřazený seznam objektů typu Comparable

Tabulka 13 Třídy balíčku metacase.core.framework.other

4.19Balíček metacase.core.metamodel

Obsahuje třídy reprezentující modely, meta-modely a balíčky pro práci s nimi.

4.20Balíček metacase.core.metamodel.exception

Obsahuje pouze jedinou výjimku: UnsupportedObjectException. Ta se používá u polymorfních metod modelu a meta-modelu, pokud byl zadán parametr nepodporovaného typu.

4.21Balíček metacase.core.metamodel.io

Nachází se zde rozhraní Loader, kterého se týká veškerá serializace a deserializace XML kódu. Nabízí metody pro snadné načítání XML. Zároveň všechny objekty, které ho dědí, generují metodou toString XML kód.

Třídy ModelLoader resp. ModelSaver slouží pro načítání resp. ukládání všech potomků Loader. Proto pracuje nejen s modely a meta-modely, ale i se strukturami reprezentující poslední otevřené soubory, rozložení panelů nástrojů a vzhled.

4.22Balíček metacase.core.metamodel.propertydata

Nacházejí se zde veškeré typy dat vlastností a rozhraní pro odchyt událostí (po inicializaci, před čtením a po zápisu) CheckPropertyDataListener. Základní abstraktní třída PropertyData nabízí registraci posluchačů a všechny zděděné třídy pouze volají její metody pro vyvolání událostí. Ty se využívají pro spouštění skriptů definovaných u meta-vlastností a detekci změny u složitějších datových typů. Ty poslouchají změny u hodnot, ze kterých je složen (RecordBox, VectorBox a další).


 

Název třídy

Typ dat

AnchorBox

Způsob přichycení zakončené k elementu

BooleanBox

Pravdivostní hodnota (true / false)

ColorBox

Barva

ElementAndRoleBox

Seznam elementů a rolí (dědičnost, připojitelnost)

FloatingPointBox

Číslo s plovoucí řádovou čárkou

FontBox

Font, styl a zarovnání

ChoiceBox

Volba 1 z N

IntBox

Celočíselná hodnota

PanelBox

Vzhled (viz 4.4.3)

PointBox

Bod (2 x IntBox)

PointBoxRelative

Bod s relativními souřadnicemi (potomek PointBox)

RecordBox

Množina dvojic název – data typu PropertyData

RectBox

Obdélník (2 x PointBox nebo PointBoxRelative)

StringBox

Řetězec

StringConcatBox

Řetězec vzniklý spojením řetězců

StrokeBox

Styl čáry

VectorBox

Seznam dat typu PropertyData

Tabulka 14 Datové typy - PropertyData

4.23Balíček metacase.core.metamodel.other

Obsahuje rozhraní NameInterface umožňující práci s názvem objektu (modelu a meta-modelu) a třídu Sorter. Ta seřadí množinu objektů, které dědí NameInterface podle názvu a vrátí ji v seznamu.

 

 

5         Testování

Testování aplikace mělo 2 hlavní fáze. 1. fáze se konala již během psaní aplikace, jednalo se o průběžné testování každé z komponent (např. jednotkový test) a další probíhala po dokončení aplikace jako celku.

5.1      Jednotkový test

Test byl prováděn po dokončení každého z celků. Součástí tohoto testování byla i kontrola funkčnosti GUI, zda je správně zobrazováno, jestli reaguje na všechny možné vstupy, jak má, zda není jejich funkčnost omezena vlivem jiných objektů.

Jednotkové testy byly největším zdrojem chyb, protože se jednalo zpravidla o první spuštění a používání jednotlivých komponent.

Každá komponenta byla podrobena kontrole všech možných užití i všech variant. Tím se získala poměrně stabilní součást.

Dalším krokem u složitějších komponent bylo využití těchto jednodušších komponent díky jejich sloučení. Pro takové komponenty byl opět proveden kognitivní test. Tyto další testy již odhalovaly jen minimum chyb z jednodušších komponent, ale i tak se bral zřetel na jejich funkčnost.

5.2      Integrační testování

Integrační testy ve své podstatě provázely také celý vývoj aplikace. Jednalo se o testy, které následovaly po vložení celé nové funkcionality do aplikace. Jejich test spočíval především v odhalování případných chyb závislých na okolních částech.

Tyto testy odhalovaly chyby především ze začátku, kdy framework neobsahoval skript a často chyběly i jiné celky, bez kterých nešlo z uživatelského hlediska danou část plně používat a tudíž ani otestovat.

Jednalo se například o nemožnost zprovoznit diagram tříd (pro zobrazování textů je nutný skript a nastavení typu dat vlastnosti).

5.3      Regresivní testování

Pomocí testů tohoto typu se má odhalit chyba, která se vyskytla jako vedlejší efekt při úpravě jiné součásti.

Jedná se o velmi těžce odhalitelné chyby, protože se často na ně přijde až při dalších testech.

Toto testování znamenalo především kontrolovat komponenty používající jiné, které se právě upravovaly. Těmto chybám se snažila předcházet již analýza aplikace, kdy nejen definovala jednotlivé součásti, ale určila postup vývoje, který stále rozšiřoval kód, aniž by bylo třeba se vracet zpět (metoda „olejové skvrny“).

Přesto tyto testy pomohly během vývoje odstranit několik chyb. Nejpodstatnější chyba se objevila v náhledu meta-modelu, kdy se po změně funkce textového pole přestaly vypisovat texty ukázkových elementů.

5.4      Validační testování

Validační testování mělo především za úkol ověřit, zda aplikace obsahuje vše, co bylo vyžadováno. Tyto testy byly zahájeny zároveň s dokončováním aplikace.

Skládaly se z postupného používání všech možných předpokládaných modelů přístupů. Vždy byl simulován některý z možných uživatelů (modelář a meta-modelář) a jeho možné ovládání aplikace, které bude takový uživatel provádět. Jednalo se tedy o kognitivní průchod po dokončení všech plánovaných částí aplikace.

Výsledkem těchto testů byla kontrola všech komponent z pohledu uživatele, zda se chovají a nabízejí, co mají.

Při těchto testech byly odhaleny detailní nedostatky:

-          Absence načítání a ukládání vzhledů

-          Pamatování si stavu stromu v průzkumnících

5.5      Useability testování

Veškerá zmíněná testování byla prováděna pouze formou simulace, a tedy nemusí plně vystihovat skutečné potřeby uživatele. Proto by bylo vhodné použít useability testování na skutečných uživatelích. Pro nedostatek času nebylo možné tyto testy uskutečnit.

 

 

6         Závěr

Cílem práce bylo vytvořit pilotní implementaci meta-CASE nástroje, který by dovolil modelovat různá schémata. Pro ukládání dat byl vytvořen model inspirovaný konceptem GOPRR.

Vzniklá aplikace dovoluje editovat libovolné vzhledy a binární vztahy. V rámci meta-modelu je možné nadefinovat omezující podmínky pro napojení. Většina funkční částí je však převedena na skript. Skript umožňuje jak měnit vzhled elementů, tak i vytvářet importy a exporty. To dovoluje modeláři značně zvýšit návrh od pouhého nakreslení schématu.

Pomocí aplikace je možné vytvořit řadu CASE nástrojů a doplnit je i o funkční části. Aplikace obsahuje několik ukázek a jeden hotový CASE nástroj. Jedná se o ER schéma včetně exportu inicializačního skriptu databáze.

Výsledná aplikace sice neodpovídá komerčnímu trhu, ale nabízí všechny důležité součásti pro návrh. Případné navazující diplomové práce by mohly uživatelnost a součásti upravit pro širokou škálu uživatelů. Jedná se spíše o zjednodušení složitějších akcí uživatele zavedením průvodců, spojením vkládání více prvků pomocí maker apod.

Diplomová práce splnila zadání a v některých částech ho i doplnila a rozšířila. Vznikla pilotní implementace vhodná pro další rozvoj, jak na úrovni meta-modelů, tak i součástí aplikace.

 

7         Seznam literatury

[1]

MOF 2.0 / XMI Mapping Specification, v2.1

 

http://www.omg.org/technology/documents/formal/xmi.htm

 

[2]

UML2 a unifikovaný proces vývoje aplikace

 

Jim Arlow, Ila Neustadt

ISBN 978-80-251-1503-9, Computer Press, a.s.

Rok vydání: 2007

 

[3]

Metamodels and metamodeling languages

 

http://www.cs.jyu.fi/~jpt/doc/thesis/ime-Title.html

 

[4]

Metamodelování : Open Soul Metamodeler UML profily v EA

 

ZENTER, Albert

http://nb.vse.cz/~repa/CASE/metamodeling.ppt

 

[5]

JavaScript Tutorial 2 - Syntax and Grammar

 

http://home.cogeco.ca/~ve3ll/jstutor2.htm

 

[6]

ClientJava.com - Flexdock 0.4 Java Web Start Demos Now Available

 

http://www.clientjava.com/blog/2005/10/27/1130431508156.html

 

[7]

Method Engineering, Principles of method construction and tool support

 

Sjaak Brinkkemper, Kalle Lyytinen and Richard J. Welke

ISBN 0-412-79750-X, Chapman & Hall

Rok vydání: 1996

 


 

 

 


A     Seznam použitých zkratek

CAME (Computer-aided Method Engineering)

CASE (Computer-aided software engineering)

CoCoA (Complex Covering Aggregation)

COMMA (Common Object Methodology Metamodel Architecture)

GOPRR (Graph-Object-Property-Role-Relationship)

GUI (Graphics User Interface)

MDA (Model Driven Architecture)

MDI (Multiply Dialog Interface)

MOF (Meta Model Facility)

NIAM (Nijssen’s Information Analysis Methodology)

OMG (Object Management Group)

OPRR (Object-Property-Role-Relationship)

SDI (Single Dialog Interface)

UML (Unified Modeling Langue)

XMI (XML Metadata Interchange)


B     UML diagramy

Obrázek 15 Diagram tříd – Inserter

Obrázek 16 Diagram tříd - rozdělení tokenů do kategorií

 

Obrázek 17 Diagram tříd dekorací

 

Obrázek 18 Diagram tříd balíčku metacase.core.framework.gui.infos

 

 


C     Uživatelská / instalační příručka

C.1   Úvodní stránka

Obrázek 19 Úvodní stránka

 

Při startu aplikace se zobrazí úvodní stránka. Tato stránka nabízí základní operace s metaCASE.

Uprostřed jsou dvě volby

-          přidat CASE nástroj

o       nahraje nový CASE z uloženého XML souboru

-          vytvořit CASE nástroj

o       vytvoří prázdný projekt meta-modelu, který je poté možné vytvářet, až vznikne nový CASE.

 

Po levé straně jsou tři nabídky, pomocí nich je možné se dozvědět aktuální novinky, tipy na práci s aplikací nebo díky zpětné vazbě zaslat zprávu vývojáři.

Pokud se chcete vrátit k souboru používaného minule, můžete použít seznam naposledy otevřených souborů vpravo nahoře.

Pokud chcete vytvořit schéma za pomoci již vytvořeného meta-modelu, najděte správný meta-model v seznamu a klikněte na vytvořit model. Pokud máte zájem upravit již vytvořený meta-model, je nutné kliknout na otevřít metamodel. Po jeho otevření je možné meta-model upravovat stejným způsobem, jako se vytváří.

Výpis meta-modelu je možné filtrovat dle kategorií. K tomu je určena volba změnit v řádce nad seznamem meta-modelů.

C.2   Vytvořit nový metamodel

Při vytváření meta-modelu je nejprve nutné vytvořit prázdný meta-model. Toho docílíte pomocí volby vytvořit CASE nástroj na úvodní stránce (viz C.1).

Poté přibude v pracovním okně průzkumník metamodelu (viz C.3.1) nový meta-model. Ten neobsahuje žádný element, vztah, ani roli. Má jen základní nutné vlastnosti. Meta-model postupně vzniká přidáváním elementů, rolí a vztahu za pomoci kontextového menu v průzkumníku metamodelu (viz C.3.1).

Nakonec je často nutné vytvořit skripty, které zajistí funkčnost nástroje (viz 0).

C.3   Pracovní okna

Pracovní okna se ovládají pomocí kontextového menu na hlavním okně nebo na některé pracovní liště. Další možností je využít roletové menu (viz C.5.2.2).

Těmito menu je možné zobrazovat, resp. schovávat jednotlivé panely nástrojů.

Obrázek 20 Konktextové menu - pracovní okna

 

Bližší informace o jednotlivých panelech nástrojů naleznete v kapitole C.4.

Panely nástrojů se zobrazují v plovoucím režimu bez dekorace dialogového okna (bez rámu).


C.3.1                      Průzkumník metamodelu

Průzkumník metamodelu má za úkol zobrazovat všechny otevřené meta-modely a jejich strukturu.

Každý uzel reprezentující meta-model tedy má několik potomků:

-          meta-elementy

-          meta-role

-          meta-vztahy

-          meta-vlastnosti (meta-modelu)

 

Všichni tito potomci, kromě meta-vlastností, mohou obsahovat řadu meta-vlastností.

Všechny prvky meta-modelu jsou opatřeny kontextovými menu. Díky nim je možné vyvolat editor vzhledu a kódu, vytvořit nový prvek meta-modelu, nastavit typ dat meta-vlastnosti, či nadefinovat vlastnosti meta-vztahů.

Obrázek 21 Průzkumník metamodelu

Kontextové menu pro meta-model navíc umožňuje vytvořit CASE. To značně zjednodušuje vývoj, kdy lze po každé změně otestovat funkčnost.

Bez tohoto průzkumníka není možné vytvořit meta-model, protože v jiné části aplikace není možné provádět výše zmíněné operace.

 


C.3.2                      Průzkumník modelu

Obrázek 22 Průzkumník modelu

Průzkumník modelu je obdoba průzkumníka metavlastností (viz C.3.1). Podobně zobrazuje modely, jejich elementy, vztahy a vlastnosti.

Role mají význam pouze na úrovni meta-modelu a skriptu.

Pomocí tohoto průzkumníka lze upravovat hodnoty jednotlivých vlastností, mazat vztahy a elementy. Výběrem prvku modelu se zvolí patřičný grafický zástupce v editoru.

Jeho účel je spíše informativní, protože všechny operace, které nabízí, jsou přístupné z editoru, průzkumníka vlastností (viz C.3.4), nebo standardního panelu nástrojů (viz C.4.1).

Veškeré funkce jsou dostupné pomocí kontextových menu, vyvolaných nad patřičnými uzly stromu.


C.3.3                      Průzkumník prvků modelu

Tento průzkumník je nezbytný pro vytváření modelu (schéma). Pomocí této komponenty se dají do modelu vkládat elementy a vztahy. Jedná se o jediný způsob, jak je vložit.

Vkládání se netýká jiných grafických prvků, tzn., že např. dekorace tímto způsobem vložit nejde.

Komponenta obsahuje několik záložek. V první se nachází všechny možné vztahy, v druhé všechny elementy.

Další záložky odpovídají všem rolím. (Pokud meta-model neobsahuje žádnou meta-roli, bude komponenta obsahovat pouze ony dvě záložky).

Obrázek 23 Průzkumník prvků modelu

Při řazení podle rolí se vloží všechny elementy, které roli dědí a vztahy, které je možné s nimi navázat.


C.3.4                      Průzkumník vlastností

Obrázek 24 Průzkumník vlastností

Průzkumník vlastností pracuje s grafickým prvkem, který je v editoru vybrán, nebo s diagramem.

Zobrazuje soupis všech vlastností a dovoluje jejich změnu. Jedná se jak o povinné (např. body), tak i o volitelné vlastnosti (např. note viz Obrázek 24).

Průběžné úpravy hodnot jsou průběžně zobrazovány v editoru. Změny vyvolané editorem (pohyb, změna velikosti aj.) jsou naopak okamžitě promítány do průzkumníka.

Některé typy dat vlastností jsou jednoduché a dají se editovat přímo (číslo, bod, řetězec, bod ad.), u ostatních se zobrazuje zástupná komponenta. Skládající se z popisu a tlačítka (…), kterým se vyvolá dialogové okno pro změnu hodnoty.

Obrázek 25 Editor složitějších datových typů

C.3.5                      Průzkumník metavlastností

Průzkumník metavlastností tvoří obdobu průzkumníka vlastností na úrovni meta-modelu.

Jeho použití následuje po zvolení typu dat meta-vlastnosti (viz C.3.1). Každá meta-vlastnost se skládá ze 4 údajů Každé odpovídá jedna záložka:

První záložka používá stejný editor jako průzkumník vlastností. Jeho hodnotu bude mít vlastnost po inicializaci.

Další tři záložky představují skript volaný při události (po inicializaci, před čtením, po zápisu).

Události po inicializaci a po zápisu jsou vhodné pro generování nových hodnot. Událost před čtením je volána před každým použitím, tudíž i před vykreslením. Protože vzhled je pro všechny instance meta-objektu stejný, je nutné nastavit všechny dynamické hodnoty před vykreslením.

Obrázek 26 Průzkumník metavlastností

Skript se chová podobně jako tělo funkce, tzn., že je zde možné použít konstrukci return (viz C.13.4.12). Hodnota, kterou nese, se poté nastaví patřičné vlastnosti. U jednoduchých operací, např., když vytváříme element pro poznámku v UML, stačí přidat elementu vlastnost, kterou uživatel nastaví text (např. note) a skript bude mít tvar return this.note;.

U složitějších výpočtů je vhodné vytvořit výslednou hodnotu za pomoci ostatních událostí (viz C.11). Díky tomu je možné použít při vykreslování podobně jednoduchý kód, jako u poznámky.

Klíčové slovo this označuje objekt, ze kterého je skript volán (vztah, element nebo graph).


C.3.6                      Průzkumník panelů návrhu

 

 

 

 

 

 

 

 

 

Obrázek 27 Průzkumník panelů návrhu

Při vytváření vzhledu využíváme tzv. panely. Panel představuje obdélníkovou pracovní plochu. U některých návrhů je nutné vložit více textových polí. U nich je složité určit velikost pokud jsou texty generovány skriptem.

Proto je možné každý panel rozdělit na dva potomky a vkládat dekorace do každého zvlášť. Výsledná velikost návrhu se poté vypočítává na základě poměru preferovaných velikostí, a tak, pokud je každé textové pole v jiném panelu, zobrazují se texty bez problémů.

Aby bylo možné strukturu panelů používat, a vytvářet je nutné využívat průzkumník panelů návrhu. Ten umožňuje strukturu panelu měnit za pomoci kontextových menu (viz nabídky rozdělit vertikálně nebo horizontálně a odstranit potomky). Druhou nutnou funkcí je přepínání panelů v editoru. To se děje automaticky po zvolení některého panelu v průzkumníku.


C.3.7                      Konzole

Konzole je jednoduché pracovní okno, které slouží pro standardní výstup (metody document.write a document.writeln viz 0).

Obrázek 28 Konzole

Do konzole se dále vypisují chyby při sémantickém překladu. Ten probíhá průběžně při změně kódu. Při nalezení chyby smaže konzoly a vypíše hlášku.

Konzole obsahuje vlastní panel nástrojů. Tím je možné konzoly smazat, nebo uložit její obsah do textového souboru.


C.3.8                      Průzkumník modelů

Průzkumník modelů zobrazuje stromovou strukturu všech dekorací, vztahů a elementů.

Element může být potomkem jiného v této reprezentaci, pokud je uvnitř něj.

V první úrovni jsou tedy zobrazeny všechny prvky a v dalších mohou být znovu (v jiném kontextu).

Při výběru uzlu je zvolen patřičný prvek v editoru.

 

 

 

 

 

Obrázek 29 Průzkumník modelů


C.4   Panely nástrojů

Kontextové menu pro správu panelů nástrojů je možné vyvolovat stiskem pravého tlačítka nad hlavním oknem aplikace nebo nad volným prostorem jakéhokoliv panelu nástrojů.

Zobrazuje soupis všech panelů a umožňuje kliknutím zobrazit, resp. schovat konkrétní panel.

Obrázek 30 Panely nástrojů


C.4.1                      Standardní

Tento panel nástrojů zahrnuje některé základní funkce:

-          otevřít

o       otevře model nebo meta-model ze souboru

-          uložit

o       uloží právě zobrazený model do souboru. Pokud nebyl nikdy ukládán, vyvolá dialogové okno pro výběr souboru

-          tisk

o       vyvolá standardní dialogové okno pro tisk

-          náhled

o       zobrazí náhled tisku (viz C.9)

-          kopírovat

o       zkopíruje výběr do schránky (podporuje pouze editor kódu)

-          vložit

o       vloží obsah schránky (podporuje pouze editor kódu)

-          vyjmout

o       vloží do schránky výběr (podporuje pouze editor kódu)


Obrázek 31 Standardní panel nástrojů

C.4.2                      Dekorace

Panel slouží pro vložení dekorace do modelu nebo návrhu vzhledu. Použití je jednoduché, kliknutím na dekoraci se zvolí a editor přejde do módu pro vložení dekorace (několik následujících kliknutí do editoru vybere body pro vložení).

Vkládání je možné zrušit pomocí tlačítka s ikonou kurzoru myši nebo dvojklikem při vkládání polygonu.

Stejnou funkci nabízí nabídka menu vložit – dekorace (viz C.5.3.1)

Obrázek 32 Panel nástrojů – dekorace

C.4.3                      Dekorace – bod, vektor

Panel slouží pro vložení bodu, nebo vektoru do návrhu vzhledu. Použití je jednoduché, kliknutím na dekoraci se zvolí a editor přejde do módu pro vložení dekorace (několik následujících kliknutí do editoru vybere body pro vložení).

Vkládání je možné zrušit pomocí tlačítka s ikonou kurzoru myši.

Bod představuje místo napojení (viz místo napojení spojnice vztahu v zakončení vztahu). Vektor se používá pouze u vytváření zakončení vztahu, určuje místo spoje zakončení s elementem a směr, jakým má být konec orientován.

Obrázek 33 Ukázka návrhu zakončení

 

Stejnou funkci nabízí nabídka menu vložit – dekorace (viz C.5.3.1)

Obrázek 34 Panel nástrojů - bod, vektor

C.4.4                      Vpřed, vzad

Panel umožňuje vrátit se zpět resp. vpřed při práci s editorem (návrhu, diagramu i kódu). Panel se vztahuje vždy ke komponentě zobrazené v hlavní záložce.

Obrázek 35 Panel nástrojů - vzad, vpřed,

C.4.5                      Přiblížení

Panel přiblížení nabízí uživateli základní operace s velikostí zobrazovaného obsahu editoru. Pomocí něj je možné přibližovat, resp. oddalovat návrh vzhledu, náhledy (meta-modelu, meta-vztahu aj.), náhled tisku i model.

Funkce panelu je možné využívat i z roletového menu (viz C.5.2.1).

Obrázek 36 Panel nástrojů – přiblížení

C.4.6                      Font

Panel umožňuje rychlou práci s textovými poli. Jeho funkce nabízí stejnou funkci jako editor v průzkumníku vlastností (viz C.3.4).

Nabízí volbu fontu, velikosti, typu fontu (tučné, kurzíva) a zarovnání horizontální a vertikální.

Obrázek 37 Panel nástrojů – font

C.4.7                      Interpret

Panel slouží k interpretaci skriptu. Je aktivní pouze v editoru kódu. Pokud kód neobsahuje detekovatelné chyby (lexikální a sémantický překlad), je aktivní jedno z tlačítek.

Interpretovat lze současně pouze jeden kód, nemůže tedy nastat situace, kdy by běžel skript vícekrát.

Zastavit interpretaci lze jak za pomoci levého tlačítka, tak i změnou kódu (každá změna kódu vyvolá nový překlad a tudíž zastavení běžícího skriptu).

Obrázek 38 Panel nástrojů – interpret

C.5   Roletové menu

Roletové menu je neoddělitelná součást aplikace. Obsahuje pouze 4 nabídky popsané v následujících kapitolách.

Obrázek 39 Roletové menu

C.5.1                      Nabídka soubor

Nabídka soubor nabízí základní funkce pro práci s aplikací.

V první části se jedná o načítání XML souborů. Jsou zde dvě nabídky: načtení meta-modelu / modelu. Načíst model znamená otevřít uložené schéma (musí být již načtený patřičný meta-model). Načtení meta-modelu se liší od volby přidat CASE na úvodní stránce (viz C.1) tím, že nezkopíruje meta-model do databáze, a tužíš se neotevře při dalším spuštění aplikace.

Obrázek 40 Nabídka soubor

Další dvě volby se shodují s nabídkami ve standardním panelu (viz C.4.1). Jsou určeny k tisku obsahu editoru, resp. k vyvolání náhledu tisku (viz C.9).

Nabídky import a export jsou popsány v dalších kapitolách (viz C.5.1.1, resp. viz C.5.1.2)



C.5.1.1             Nabídka soubor – import

Aplikace nenabízí žádné standardní importy (pouze možnost načíst XML soubor generovaný aplikací).

Všechny importy jsou tedy definovány konkrétním meta-modelem. To je možné pomocí metody grafu addImport (viz 0).

Import se vztahuje k obsahu otevřeného editoru, tzn., každý model může mít různé importy.

Pokud nebyl žádný import definován, nebude nabídka aktivní.

Obrázek 41 Nabídka soubor - import


 

C.5.1.2             Nabídka soubor – export

Menu export je aktivní, pokud je zobrazen nějaký editor.

Jeho obsah může být členěn na dvě skupiny. První obsahuje standardní exporty a případná druhá uživatelsky dodefinované exporty v meta-modelu, vytvořené pomocí metody addExport objektu Graph (viz 0).

Obrázek 42 Nabídka soubor-export

V současné době aplikace obsahuje pouze jediný standardní export – obrázek. Ten vyvolá dialogové okno pro uložení souboru. Volbou typu souboru může uživatel vybrat výsledný formát (BMP, GIF, PNG nebo JPEG). Výsledný obrázek představuje pracovní plochu bez výběru prvků.

 

C.5.2                      Nabídka zobrazit

Obrázek 43 Nabídka zobrazit

Nabídka zobrazit zahrnuje menu přiblížení, panely nástrojů a pracovní okna. Ty jsou popsány v dalších kapitolách a přístupné i jiným způsobem, než jen z roletového menu.

Nabídka úvodní strana přidá úvodní stránku, pokud není zobrazována a zobrazí ji.

Volba pravítka umožňuje přidávat, resp. schovávat pravítka (viz C.8).



C.5.2.1             Nabídka zobrazit – přiblížení

Tato nabídka obsahuje tři možné volby:

-          přiblížit

o       odpovídá tlačítku + v panelu přiblížení (viz C.4.5)

-          100%

o       nastaví přiblížení na 100% (originální rozlišení)

Obrázek 44 Nabídka zobrazení

-          oddálit

o       odpovídá tlačítku v panelu přiblížení (viz C.4.5)


C.5.2.2             Nabídka zobrazit – panely nástrojů

Obrázek 45 Nabídka zobrazit - panely nástrojů

Pomocí tohoto menu je možné zobrazovat, resp. schovávat všechny panely nástrojů.

Je shodné s kontextovým menu vyvolaným na nějakém panelu nástrojů nebo hlavním okně (viz C.4).


C.5.2.3             Nabídka zobrazit - pracovní okna

Pomocí tohoto menu je možné zobrazovat, resp. schovávat všechna pracovní okna.

Je shodné s kontextovým menu vyvolaným na nějakém panelu nástrojů nebo hlavním okně (viz C.3).

Obrázek 46 Panel zobrazit - pracovní okna



C.5.3                      Nabídka vložit

Nabídka vložit obsahuje pouze jednu nabídku – menu dekorace. Ta je posaná v kapitole C.5.3.1.

Obrázek 47 Nabídka vložit


C.5.3.1             Nabídka vložit – dekorace

Obsahuje volby pro každou dekoraci zvlášť a volbu zrušit. Funkcí odpovídá dvojice panelů nástrojů:

-          dekorace (viz C.4.2)

-          bod, vektor (viz C.4.3)

 

Zvolená dekorace je vyznačena pomocí komponenty RadioButton. Zrušit vkládání poté lze volbou zrušit.

Obrázek 48 Nabídka vložit - dekorace

 

 

 

 

 

 


C.5.4                      Nabídka O programu

Obrázek 49 Nabídka O programu

Poslední nabídka roletového menu je určena pro informace o aplikaci.

Nachází se zde pouze dvě volby:

-          pro zobrazení nápovědy

-          pro zobrazení základních informací o aplikaci



C.6   Náhled meta-modelu

Obrázek 50 Náhled meta-modelu

Náhled meta-modelu je možné vyvolat z průzkumníka metamodelu (viz C.3.1), pomocí kontextového menu nad konkrétním meta-modelem, vyvolaným pravým tlačítkem.

Náhled používá pro zobrazení elementů a rolí zástupné symboly. Ty obsahují název a soupis vlastností (povinné jsou v závorkách kurzívou).

Mezi rolemi a elementy je naznačena dědičnost a zobrazeny možné vztahy.

Každý vztah může být zobrazen vícekrát (pokud je definován pro více dvojic, připojitelných elementů, resp. rolí).

Pokud se vztah nezobrazí, ale je definován, může to být způsobeno špatnou definicí. Pokud nejsou nastaveny připojitelné prvky meta-modelu pro jeden z konců vztahu, není možné ji v náhledu zobrazit. Ve výsledném modelu takový vztah použít lze, nicméně nebude napojitelný, a proto je jeho význam sporný.

Náhled nedovoluje žádné úpravy z hlediska struktury meta-modelu. Je dovoleno pouze pracovat s rozvržením grafu. Veškeré změny meta-modelu se provádí v průzkumníku metavlastností (viz C.3.5) a průzkumníku metamodelu (viz C.3.1).

C.7   Náhled vztahu

U každého meta-vztahu je možné zobrazit náhled. V průzkumníku metamodelu lze pravým tlačítkem vyvolat kontextové menu nad meta-vlastností a volbou zobrazit náhled se otevře editor s náhledem.

Zobrazený vztah nabízí základní operace pro otestování funkce (zalamování, pohyb).

Obrázek 51 Náhled vztahu


C.8   Pravítka

Pravítka jsou grafické komponenty, které je možné zobrazovat v každém editoru a náhledu tisku.

Skládají se ze tří částí:

-          levý horní roh

o       přepíná jednotku pravítek

§         in (palec)

§         px (pixely)

Obrázek 52 Pravítka

§         cm (centimetry)

-          horizontální pravítko

-          vertikální pravítko

 

Pravítka lze zobrazovat, resp. schovávat najednou, tzn., že nelze mít v stejný moment některé editory s a některé bez pravítek. Jejich užívání se nastavuje pomocí roletového menu (viz C.5.2).


C.9   Náhled tisku

Obrázek 53 Náhled tisku

Pro každý editor (modelu – CASE, náhledy) je možné zobrazit náhled tisku za pomoci standardního panelu nástrojů (viz C.4.1) nebo nabídky soubor (viz C.5.1).

Náhled tisku zahrnuje vlastní panel nástrojů, kterým lze dokument vytisknout, nastavit formát papíru a zobrazit stránku tisku.

Zobrazený dokument lze přibližovat, resp. oddalovat stejně jako editor – panelem nástrojů přiblížení (viz C.4.5) nebo roletovým menu (viz C.5.2.1).


 


C.10 Skript

V rámci aplikace se používá podmnožina JavaScriptu (viz další kapitoly). Skriptování se používá na dvou různých místech:

-          meta-vlastnosti (C.3.5)

o       používá se pro úpravu vzhledu na základě dat

o       vyvolává se při událostech

§         po inicializaci

§         před čtením

§         po zápisu

-          skript pro celý meta-model

o       vytvoří importy a exporty

o       obsahuje funkce pro složitější vyhodnocování událostí meta-vlastností

C.11 Skript meta-vlastností

Jak již bylo naznačeno, každá meta-vlastnost může mít až tři různé skripty. Každý z nich se pojí s jinou událostí.

U všech meta-vlastností, které mají mít svou hodnotu, určenou na základě nějaké jiné (z pravidla uživatelem definované) vlastnosti elementu, resp. vztahu, je nutné použít událost před čtením. Každý vzhled je totiž shodný pro všechny elementy, nebo vztahy stejného druhu. Touto událostí se tedy před každým vykreslením nastaví správná hodnota.

Typickým případem je hodnota nápisu v textovém poli, ale obecně se může jednat o jakýkoliv typ dat.

V rámci skriptu mohou být použity všechny konstrukce a mohou využívat části skriptu meta-modelu (viz C.12), tzn. metody, proměnné i konstanty. Samotný kód může být složen z libovolného množství příkazů, ale vzhledem k přehlednosti je vhodné výkonnou část napsat v kódu meta-modelu.

Pokud chce uživatel měnit hodnotu, musí využít konstrukci return. Její výsledek je poté nastaven jako hodnota.

Některé výpočty mohou být složité. V tom případě je vhodné události kombinovat.

Příklad:

            po inicializaci:

                        this.value=computeValue();

            po zápisu:

                        this.value=computeValue();

            před čtením:

                        return this.value;

            metoda v kódu meta-modelu:

                        function computeValue() {

                                   var out=”<html>”;

                                   // příklad obsahu

                                   for (var i=0;i<10;i++) {

                                               out+=i;

                                               out+=”<br>”;

                                   }

                                   return out+”</html>”;

}

 

Klíčové slovo this zastupuje objekt, v rámci kterého je volán, tzn. buď vztah, element nebo graph.

 

C.12 Skript meta-modelu

Každý meta-model má povinnou meta-vlastnost code. Při vyvolání kontextového menu nad ní, je možné pomocí volby zobrazit editor kód otevřít a následně editovat (viz Obrázek 54).

Kód může obsahovat funkce i osamocené příkazy. Osamocené příkazy je možné použít pro inicializaci modelu (jsou vykonány při vytvoření modelu). Pomocí nich se definují např. importy a exporty.

 

 

Obrázek 54 Otevření editoru kódu


C.13 Konstrukce skriptu

C.13.1                Klíčové slovo

Klíčové slovo je řetězec, který je vyhrazen pro konstrukce skriptu. V implementované podmnožině JavaScriptu jsou použita  tato klíčová slova (popis viz další kapitoly): if, else, function, var, switch, const, case, break, continue, do, while, for, return, default, new, try, catch, throw, finally, this, null.

C.13.2                Identifikátor

Identifikátor je základní prvek kódu. Jedná se o posloupnost znaků, číslic a podtržítek, které nezačínají číslicí. Identifikátor představuje podmnožinu této definice. Pokud je řetězec klíčovým slovem nejedná se identifikátor.

Identifikátor se používá pro pojmenování konstant, proměnných, funkcí, parametrů a dalších konstrukcí s názvem.

C.13.3                Literál

Literál je taková část kódu, která reprezentuje nějakou hodnotu – konstantu. Může se jednat o číselnou hodnotu, řetězec nebo označení objektu.

Literál null označuje prázdný odkaz, a this objekt, ve kterém je použit.

C.13.3.1       Číselná hodnota

V rámci kódu mohou být dvě různé reprezentace čísla:

-          celočíselná hodnota

-          číslo s plovoucí řádovou čárkou

 

Protože skript aplikace je zjednodušením JavaScriptu, je možné využívat pouze dekadickou soustavu. U čísel s plovoucí řádovou čárkou se používá řádová tečka a není povolena konstrukce s exponentem (např. 4.3E+3).

C.13.3.2       Řetězec, znak

Literál znaku je ve skriptu reprezentován, jako řetězec délky jedna, resp. není mezi nimi rozdíl.

Řetězec je možné zapsat dvěma způsoby:

-          ohraničen apostrofem

-          ohraničen uvozovkami

 

Může obsahovat escape znaky:

-          \n   - odřádkování

-          \t    - tabulátor

-          \    - apostrof

-          \“   - uvozovky

-          \r    - přesun na začátek řádky

-          \\    - symbol \

 

Příklad:

            Let’s go!                     “Let\’s go!”

            “\’\                             ‘\”\\\’\\\t\”\’

C.13.3.3       Deklarace proměnných a konstant

JavaScript neumožňuje definovat typ proměnné, a proto v každé proměnné nebo funkci může být hodnota libovolného typu.

Mimo funkce je možné deklarovat konstanty, tedy hodnoty, které nelze v průběhu kódu měnit. Zápis se skládá z klíčového slova const, identifikátoru konstanty, symbolu = a výrazu.

Příklad:

            const PI=3.141528;

 

V rámci kódu se samozřejmě mohou deklarovat proměnné. Jejich zápis se skládá z klíčového slova var, identifikátoru proměnné a případně přiřazovacího příkazu pro inicializaci proměnné.

Příklad:

            var a, b;

            var c=4-2;

            var text=“ahoj světe“;

C.13.4                Příkazy

C.13.4.1       Prázdný příkaz

Prázdný příkaz, je příkaz, který nevykoná žádnou operaci. Její syntaxe je jednoduchá - ;. Využívá se u složitějších konstrukcí, v částech, které se musí deklarovat, ale nejsou požadovány.

Příklad:

            ;;;;;;;;

            // řada prázdných příkazů


C.13.4.2       Složený příkaz

{

            příkaz1

           

            příkazN

}

           

Složený příkaz se skládá z posloupnosti příkazů (i nulové délky) a zapisuje se mezi složené závorky. Mohou být v rámci něj deklarovány proměnné.

 

Příklad:

            {}

 

            {

                        var a,b;

                        {

;;;

                        }

            }

C.13.4.3       Výraz

Výraz je příkaz, který představuje jakýkoliv aritmetický výpočet. Výraz má výsledek, a ten je možné pomocí přiřazovacího příkazu (viz C.13.4.4) dosadit do nějaké proměnné.

Skládá se z posloupností literálů (řetězců, číslic), volání funkcí, závorek a operací.

 

Příklad:

            var i=3;

            document.write(6*i+3%2-(5*1.5));

            // vypíše : 11.5

C.13.4.4       Přiřazovací příkaz

Přiřazovací příkaz dovoluje nastavit proměnné hodnotu. Jeho zápis se skládá z identifikátoru proměnné, symbolu přiřazovacího příkazu (=, +=, -=, /=, *=, %=, <<=, >>=, >>>=, |=, &=, ^=) a výrazu.

Výraz se nejprve vyhodnotí, a poté pokud je použitý symbol = dosadí do proměnné. V případě jiných symbolů se provede operace (viz začátek symbolu) proměnné s výrazem, a ta se dosadí.

 

Příklad:

            var a, b;

            a=5;

            b=3;

            b+=a;

            document.write(a+“,“+b);

            // vypíše : 5,8

C.13.4.5       Podmíněný příkaz

if ( podmínka ) příkaz1 else příkaz2

if ( podmínka ) příkaz1

 

Vypočítá se podmínka. Je-li výsledkem pravda, provede se příkaz1, jinak pokud existuje, příkaz2.

 

Příklad:

            if (5>3+2) {

                        document.write(“5 je větší než 3+2);

} else document.write(“5 není větší než 3+2);

// vypíše : 5 není větší než 3+2

 

if (true) {

document.write(“ahoj světe“);

}

// vypíše : ahoj světe

C.13.4.6       switch

switch ( výraz ) {

            case výraz1 :

                        příkazy1

           

            case výrazN :

                        příkazyN

            default:

                        příkazyDef

}

 

Příkaz switch představuje zobecněný if. Obsahuje několik celků case a volitelný blok default. Postupně porovnává výraz se všemi výrazy(1..N). Pokud se shodují, začne je postupně vykonávat (poté pokračuje dalším case blokem), dokud nenarazí na příkaz break. Ten vykonávání přeruší.

Nebyl-li vykonán žádný case blok, budou vykonány příkazyDef.

 

Příklad:

            switch (i) {

                        case 0:

                                   document.write(0);

                                   document.write(0);

                        case 1:

                                   document.write(1);

                                   break;

                        case 2:

                                   document.write(2);

                        default:

                                   document.write(3);

                                   document.write(3);

}

/*

            Při i     vypíše

0                    001

1                    1

2                    2

jinak    33

            */

C.13.4.7       Ternární výraz

podmínka ? výraz1 : výraz2

 

Vyhodnotí podmínku. Pokud je její hodnota pravda, je výsledkem výraz1, jinak výraz2.

C.13.4.8       Volání funkce

Volání funkce se skládá z identifikátoru funkce, otevírací závorky, posloupnosti výrazů oddělených čárkami, zavírací závorky a středníku.

Každá funkce očekává určitý počet parametrů (viz C.13.4.3). Pokud je při volání zadáno málo parametrů, bude za neudané dosazena hodnota null. Přebytečné parametry budou vyhodnoceny a v rámci výpočtu funkce ignorovány.

 

Příklad:

            // definice volané funkce

            function fakt(i) {

                        if (i<0) throwšpatný argument funkce fakt : i<0”;

                        if (i<2) return 1;

                        return i*fakt(i-1);

            }

 

            document.write(fakt(5)+“,“+fakt(fakt(3)));

            // vypíše : 120, 720

C.13.4.9       throw

Příkaz throw vygeneruje výjimku nesoucí nějakou hodnotu. Výjimka může reprezentovat například chybu.

Pro práci s výjimkami je určena konstrukce try-catch-finally (C.13.4.10).

 

Příklad:

            throw “Chyba! Špatný parametr“;

            throw 4+2;

C.13.4.10 try-catch-finally

try

            příkaz1

catch (identifikátor výjimky)

            příkaz2

finally

            příkaz3

 

Konstrukce try-catch-finally se skládá z dvou povinných (try a catch) a jednoho nepovinného (finally) bloku.

Nejprve se pokusí vykonat příkaz1. Pokud je během něj generována výjimka pomocí throw (viz C.13.4.9), která není odchycena jinou konstrukcí try-catch-finally, ukončí se její vykonávání a přejde se do bloku catch. Identifikátor výjimky se chová jako deklarace proměnné s hodnotou, kterou nesla výjimka.

Blok finally, resp. příkaz3 se provede, ať k výjimce došlo, či nikoliv.

 

Příklad:

            try {

                        throw “ahoj”;

} catch (e) {

            document.write(e);

} finally {

            document.write(“ světe”);

}

 

document.write(“,”);

 

try {

            5/0;

} catch (e) {

            document.write(e);

}

 

// vypíše : ahoj světe,divide with 0

C.13.4.11 Cykly

C.13.4.11.1               for

Je implementován pouze základní typ cyklu for:

            for (příkaz pro inicializaci; podmínka; výraz pro změnu)

                        příkaz

 

Nejprve se provede příkaz pro inicializaci (může se použít i deklarace proměnné – viz C.13.3.3), poté se provádí dvojice příkaz a výraz pro změnu, dokud se vyhodnocuje podmínka jako pravda.

 

Příklad:

            for (var i=7; i>=3; i--)

                        dokument.write(i);

            // vypíše : 76543

C.13.4.11.2               while

while (podmínka) příkaz

 

Příkaz se provádí, dokud se podmínka vyhodnocuje jako pravda. Nejprve se testuje podmínka a tak se příkaz nemusí provádět ani jednou.


Příklad:

                        var i=10;

                        while (i>0) {

                                   document.write(--i);

}

// vypíše : 9876543210

C.13.4.11.3               do-while

do příkaz while (podmínka)

 

Příkaz se provádí, pokud se podmínka vyhodnocuje jako pravda. U cyklu do-while se vždy nejprve provede příkaz a až poté podmínka. Proto se cyklus musí provést alespoň jednou.

 

Příklad:

            var i=0;

            do {

                        var j=0;

                        do {

                                   document.write(j++);

} while (j<5);

            } while (i!=0);

            // vypíše : 01234

 

C.13.4.12 return

return výraz;

 

Konstrukce return je určena pro vrácení hodnoty funkce.

C.13.4.13 Funkce

Funkce je samostatný celek kódu, který může být volán z různých míst. Představuje kus často používaného kódu.

Zapíše se, jako posloupnost klíčového slova function, identifikátoru funkce, otevírací závorky, řady identifikátorů (názvů parametrů) oddělených čárkou, uzavírací závorky a bloku. Blok má stejný zápis, jako složený příkaz (viz C.13.4.2). Představuje tělo funkce, tedy část, která je při volání vykonávána.

Příkazem return (viz C.13.4.12) je možné vrátit hodnotu – výsledek funkce.


Příklad:

            function showHelloWorld() {

            document.writeln(“Ahoj světe”);

}

 

function sum(a,b) {

            return a+b;

}

 

function copy(nr, text) {

            if (nr<0) throw špatná hodnota parametru copy.nr“;

            if (nr==0) return “”;

            // rekurze – funkce volá sama sebe

            return text+copy(nr-1,text);

}

 

showHelloWorld();

document.writeln(sum(4,8));

document.writeln(6,”.”);

/* vypíše:

            Ahoj světe

            12

            ……

*/

C.13.4.14 break

Příkaz break ukončí předčasně vykonávání cyklu. Může být využit i uvnitř příkazu switch (viz C.13.4.6).

 

Příklad:

            for (var i=0;i<5;i++) {

                        document.write(i);

                        break;

                        document.write(”!!”);

}

// vypíše : 0

C.13.4.15 continue

Příkaz continue ukončí předčasně tělo cyklu, ale cyklus bude pokračovat.

 

Příklad:

            for (var i=0;i<5;i++) {

                        document.write(i);

                        continue;

                        document.write(”!!”);

}

// vypíše : 01234

C.13.4.16 new

Jedná se o klíčové slovo, které vytváří objekt. Objektem může být libovolná metoda. Při vytváření vlastního objektu se definují proměnné a funkce objektu pomocí klíčového slova this.

 

Příklad:

            function _show() {

                        document.write(this.sum);

}

 

function _add(i) {

            return this.sum+=i;

}

 

function counter() {

            this.sum=0;

            this.show=_show;

            this.add=_add;

}

 

var a=new counter(), b=new counter();

a.add(4);

a.add(3);

b.add(7);

b.add(9);

a.show();

document.write(“,”);

b.show();

 

// vypíše : 7,16

C.13.5                Předefinované metody

createGraph(name)

Vytvoří a vrátí instanci meta-modelu (model) s názvem name.

alert(text)

Vyvolá informativní dialogové okno s textem text.

prompt(text, value)

Vyvolá dialogové okno pro získání uživatelského vstupu se zprávou text a přednastavenou hodnotou value (nepovinný parametr, při nezadání bude použit prázdný řetězec)

confirm(text)

Vyvolá dialogové okno s otázkou text a volbami ano a ne. Výsledkem metody je hodnota typu boolean (ano=true, ne a zavření dialogu=false)

isNaN(value)

Vrátí true pokud není value číslo (viz not a number u čísel s plovoucí čárkou)

isFinite(value)

Vrátí true, pokud je value končené číslo (není nekonečno)

parseFloat(text)

Převede řetězec text  na číslo s plovoucí čárkou.

parseInt(text)

Převede řetězec text na celočíselnou hodnotu.

C.13.6                Objekt Math

C.13.6.1       Funkce

Math.abs(i)

Vrátí absolutní hodnotu čísla i.

 

Příklad:

            document.write(Math.abs(-4));

            // vypíše : 4

Math.exp(i)

Vrátí hodnotu ei.

 

Příklad:

            document.write(Math.exp(2));

            // vypíše : 7,3890560989306502274463271505434

Math.log(i)

Vrátí hodnotu přirozeného logaritmu – ln(i).

 

Příklad:

            document.write(Math.log(10));

            // vypíše : 2,3025850929940456840179914546844

Math.max(a,b)

Vrátí vyšší hodnotu z a a b.

 

Příklad:

            document.write(Math.max(-4,6));

            // vypíše : 6


Math.min(a,b)

Vrátí menší hodnotu z a a b.

 

Příklad:

            document.write(Math.min(-4,6));

            // vypíše : -4

Math.pow(a,b)

Vrátí hodnotu ab.

 

Příklad:

            document.write(Math.pow(2,10));

            // vypíše : 1024

Math.random()

Vrátí náhodné číslo s plovoucí čárkou na intervalu <0,1>.

Math.sqrt(i)

Vrátí druhou odmocninu z čísla i.

 

Příklad:

            document.write(Math.sqrt(16));

            // vypíše : 4

Math.ceil(i)

Pokud má číslo i desetinnou část (není celé číslo) vrátí vyšší celé číslo.

 

Příklad:

            document.write(Math.ceil(4.5));

            // vypíše : 5

Math.floor(i)

Pokud má číslo i desetinnou část (není celé číslo) vrátí celočíselnou hodnotu.

 

Příklad:

            document.write(Math.floor(4.5));

            // vypíše : 4

Math.round(i)

Vrátí zaokrouhlené číslo i.

 

Příklad:

            document.write(Math.floor(4.5));

            // vypíše : 5

Math.acos(i)

Vrátí arccos(i).

Math.asin(i)

Vrátí arcsin(i).

Math.atan(i)

Vrátí arctg(i).

Math.atan2(x,y)

Vrátí úhel v radiánech od osy x do bodu [x,y].

Math.cos(i)

Vrátí cos(i).

Math.sin(i)

Vrátí sin(i).

Math.tan(i)

Vrátí tg(i).

C.13.6.2       Kontanty

Math.E

Základ přirozeného logaritmu

Math.LN10

Přirozený logaritmus 10 – ln(10)

Math.LN2

Přirozený logaritmus 2 – ln(2)

Math.LN10E

Desítkový logaritmus e – log10(e)

Math.LN2E

Dvojkový logaritmus e – log2(e)

Math.PI

Hodnota π (s přesností double).

Math.SQRT2

Odmocnina z 2.

Math.SQRT1_2

Odmocnina z ½.

C.13.7                Objekt dokument

C.13.7.1       Funkce

document.write(text)

Vypíše do konzole řetězec text.

document.writeln(text)

Vypíše do konzole řetězec text a odřádkuje.

C.13.8                Objekt String

C.13.8.1       Funkce

length()

Vrátí délku řetězce.

 

Příklad:

            document.write(“ahoj svete“.length());

            // vypíše : 10

toLowerCase()

Vrátí řetězec převedený na malá písmena.

 

Příklad:

            document.write(“aBcD“.toLowerCase());

            // vypíše : abcd

toUpperCase()

Vrátí řetězec převedený na velká písmena.

 

Příklad:

            document.write(“aBcD“.toLowerCase());

            // vypíše : ABCD

toString()

Vrátí kopii řetězce.

 

Příklad:

            document.write(“aBcD“.toLowerCase());

            // vypíše : aBcD

charAt(i)

Vrátí i-tý znak řetězce.

 

Příklad:

            document.write(“aBcD“.charAt(3));

            // vypíše : D

charCodeAt(i)

Vrátí číselnou hodnotu i-tého znaku řetězce.

 

Příklad:

            document.write(“aBcD“.charCodeAt(1));

            // vypíše : 66

subString(a,b)

Vrátí řetězec začínající na indexu a a konče na indexu b (bez b-tého znaku).

 

Příklad:

            document.write(“aBcD“.subString(1,3));

            // vypíše : Bc

substr(a,b)

Vrátí řetězec délky b začínající na indexu a.

 

Příklad:

            document.write(“aBcD“.substr(1,2));

            // vypíše : Bc

indexOf(text)

Vrátí index, na kterém se objevuje první výskyt řetězce text. Pokud takový index neexistuje, je výsledkem funkce -1.

 

Příklad:

            document.write(“abababa“.indexOf(ba));

            // vypíše : 1

lastIndexOf(text)

Vrátí index, na kterém se objevuje poslední výskyt řetězce text. Pokud takový index neexistuje, je výsledkem funkce -1.

 

Příklad:

            document.write(“abababa“.lastIndexOf(ba));

            // vypíše : 5

C.13.9                Objekt FileWriter

C.13.9.1       Konstruktor

Konstruktor může mít jeden parametr. Ten určuje soubor, který se má otevřít. Pokud soubor není zadán, vyvolá se dialogové okno pro výběr souboru.

C.13.9.2       Funkce

close()

Uzavře výstupní proud pro zápis dat.

write(i)

Pokud je i

-          pole

o       zapíše postupně všechny jeho hodnoty bez oddělovačů.

o       pro zápis hodnot pole používá stejná pravidla jako pro funkci write

-          celočíselná hodnota

o       zapíše znak s kódem i

-          řetězec

o       zapíše řetězec

writeln(i)

Provede write(i) (viz 0) a odřádkuje.

 

C.13.10          Objekt FileReader

C.13.10.1 Konstruktor

Konstruktor může mít jeden parametr. Ten určuje soubor, který se má otevřít. Pokud soubor neexistuje, nebo není zadán, vyvolá se dialogové okno pro výběr souboru.

C.13.10.2 Funkce

close()

Uzavře vstupní proud pro čtení dat.

read()

Přečte znak a vrátí jeho kód. Pokud byl soubor přečten celý vrátí -1.

readLine()

Přečte řádku ze souboru a vrátí ji jako řetězec. Pokud byl soubor přečten celý, vrátí null.

skip(i)

Přeskočí i znaků ve čteném souboru.

C.13.11          Objekt Graph (diagram)

C.13.11.1 Funkce

getElements()

Vrátí pole elementů, které diagram obsahuje.

getRelationships()

Vrátí pole vztahů, které diagram obsahuje.

getRoles()

Vrátí pole rolí, které diagram obsahuje.

createElement(name)

Vytvoří nový element podle jména meta-elementu name.

createRelationships(name)

Vytvoří nový vztah podle jména meta-vztahu name.

addImport(name, fce)

Přidá import diagramu se jménem name. Při vyvolání importu bude zavolána funkce, určená parametrem fce. Při zpětném volání bude zadán parametr, obsahující diagram, ze kterého byl volán.

 

Příklad:

            function importA(graph) {

                        document.write(“importuj do ” + graph.getName());

}

 

            addImport(“ukázkový import“,importA);

addExport(name, fce)

Přidá export diagramu se jménem name. Při vyvolání exportu bude zavolána funkce, určená parametrem fce. Při zpětném volání bude zadán parametr, obsahující diagram, ze kterého byl volán.

 

Příklad:

            function exportA(graph) {

                        document.write(“exportuj z ” + graph.getName());

}

 

            addImport(“ukázkový export“,exportA);

C.13.12          Objekt Relationship

C.13.12.1 Funkce

getEnd(i)

Vrátí i-tý (0,1) konec vztahu.

C.13.12.2 Proměnné

end

Obsahuje pole s konci vztahu

C.13.13          Objekt End

C.13.13.1 Funkce

connectTo(elm)

Připojí konec k elementu elm.

disconnect()

Odpoj zakončení, je-li připojen k nějakému elementu.

getConnected()

Vrátí element, ke kterému je konec připojen. Není-li, vrátí null.

C.13.14          Typ dat vektor

C.13.14.1 Funkce

size()

Vrátí počet prvků vektoru

get(i)

Vrátí i-tý prvek vektoru.

remove(i)

Odstraní i-tý prvek vektoru.

set(i, value)

Nastaví jako i-tý prvek hodnotu value.

add(value)

Přidá na konec vektoru prvek value.

C.13.15          Objekt Array – pole

C.13.15.1 Funkce

lenght

Vrátí délku pole.

 

 

 

 

    

 

 


D     Přílohy skriptovacího jazyka

D.1   Gramatika

codeà const1

codeà var ; code

codeà function code

codeà command ; code

 

const1à const identifikátor = term const2

const2à , identifikátor = term const2

const2à ;

 

functionà function identifikátor ( functionVar ) block

functionà ε

functionVarà identifikátor functionVar2

functionVar2à , identifikátor functionVar2

functionVar2à ε

 

commandà block

commandà call

commandà assign

commandà term

commandà if

commandà for

commandà while

commandà do

commandà var

commandà ;

commandà return

commandà throw1

commandà try1

 

blockà { block2

block2à command ; block2

block2à }

 

callà getter identifikátor ( callTerm )

callTermà ε

callTermà term callTerm2

callTerm2à , term callTerm2

callTerm2à ε

 

assignà getter identifikátor = term

 

if1à if ( term ) command if2

if2à else command

if2à ε

 

for1à for ( command ; term ; command ) command

 

while1à while ( term ) command

 

do1à do command while ( term )

 

varà var <ident> var2 var3

var2à = term

var3à , identifikátor var2

var3à ε

 

returnà return ;

returnà return term ;

 

geterà identifikátor .

 

termà t2 t1

termà [ t26 ]

 

t1à ? term : term

t1à ε

 

t2à t4 t3

t3à || t4 t3

t3à ε

 

t4à t6 t5

t5à && t6 t5

t5à ε

 

t6à t8 t7

t7à | t8 t7

t7à ε

 

t8à t10 t9

t9à ^ t10 t9

t9à ε

 

t10à t12 t11

t11à & t12 t11

t11à ε

 

t12à t14 t13

t13à == t14 t13

t13à != t14 t13

t13à === t14 t13

t13à !== t14 t13

t13à ε

 

t14à t16 t15

t15à < t16 t15

t15à <= t16 t15

t15à > t16 t15

t15à <= t16 t15

t15à ε

 

t16à t18 t17

t17à << t18 t17

t17à >> t18 t17

t17à >>> t18 t17

t17à ε

 

t18à t20 t19

t19à + t20 t19

t19à - t20 t19

t19à ε

 

t20à t22 t21

t21à * t22 t21

t21à / t22 t21

t21à % t22 t21

t21à ε

 

t22à ++ <ident>

t22à -- <ident>

t22à - t23

t22à ~ t23

t22à ! t23

t22à t23

 

t23à ( term )

t23à literál t25

t23à identifikátor t25 t24

t23à call t25

t23à new identifikátor

 

t24à ++

t24à --

t24à [ term ] t25

 

t25à . call

t25à . identifikátor

t25à ε

 

t26à term t27

t26à ε

t27à , term t27

t27à ε

 

D.2   Předefinované metody

createGraph(name)

Vytvoří a vrátí instanci meta-modelu (model) s názvem name.

alert(text)

Vyvolá informativní dialogové okno s textem text.

prompt(text, value)

Vyvolá dialogové okno pro získání uživatelského vstupu se zprávou text a přednastavenou hodnotou value (nepovinný parametr, při nezadání bude použit prázdný řetězec)

confirm(text)

Vyvolá dialogové okno s otázkou text a volbami ano a ne. Výsledkem metody je hodnota typu boolean (ano=true, ne a zavření dialogu=false)

isNaN(value)

Vrátí true pokud není value číslo (viz not a number u čísel s plovoucí čárkou)

isFinite(value)

Vrátí true, pokud je value končené číslo (není nekonečno).

parseFloat(text)

Převede řetězec text na číslo s plovoucí řádovou čárkou.

parseInt(text)

Převede řetězec text na celočíselnou hodnotu.

D.3   Objekt Math

D.3.1                      Funkce

Math.abs(i)

Vrátí absolutní hodnotu čísla i.

Math.exp(i)

Vrátí hodnotu ei.

Math.log(i)

Vrátí hodnotu přirozeného logaritmu – ln(i).

Math.max(a,b)

Vrátí vyšší hodnotu z a a b.

Math.min(a,b)

Vrátí menší hodnotu z a a b.

Math.pow(a,b)

Vrátí hodnotu ab.

Math.random()

Vrátí náhodné číslo s plovoucí čárkou na intervalu <0,1>.

Math.sqrt(i)

Vrátí druhou odmocninu z čísla i.

Math.ceil(i)

Pokud má číslo i desetinnou část (není celé číslo) vrátí vyšší celé číslo.

Math.floor(i)

Pokud má číslo i desetinnou část (není celé číslo) vrátí celočíselnou hodnotu.

Math.round(i)

Vrátí zaokrouhlené číslo i.

Math.acos(i)

Vrátí arccos(i).

Math.asin(i)

Vrátí arcsin(i).

Math.atan(i)

Vrátí arctg(i).

Math.atan2(x,y)

Vrátí úhel v radiánech od osy x do bodu [x,y].

Math.cos(i)

Vrátí cos(i).

Math.sin(i)

Vrátí sin(i).

Math.tan(i)

Vrátí tg(i).

D.3.2                      Konstanty

Math.E

Základ přirozeného logaritmu

Math.LN10

Přirození logaritmus 10 – ln(10)

Math.LN2

Přirozený logaritmus 2 – ln(2)

Math.LN10E

Desítkový logaritmus e – log10(e)

Math.LN2E

Dvojkový logaritmus e – log2(e)

Math.PI

Hodnota π (s přesností double).

Math.SQRT2

Odmocnina z 2.

Math.SQRT1_2

Odmocnina z ½.

D.4   Objekt Dokument

D.4.1                      Funkce

document.write(text)

Vypíše do konzole řetězec text.

document.writeln(text)

Vypíše do konzole řetězec text a odřádkuje.

D.5   Objekt String

D.5.1                      Funkce

length()

Vrátí délku řetězce.

toLowerCase()

Vrátí řetězec převedený na malá písmena.

toUpperCase()

Vrátí řetězec převedený na velká písmena.

toString()

Vrátí kopii řetězce.

charAt(i)

Vrátí i-tý znak řetězce.

charCodeAt(i)

Vrátí číselnou hodnotu i-tého znaku řetězce.

subString(a,b)

Vrátí řetězec začínající na indexu a a konče na indexu b (bez b-tého znaku).

substr(a,b)

Vrátí řetězec délky b začínající na indexu a.

indexOf(text)

Vrátí index, na kterém se objevuje první výskyt řetězce text. Pokud takový index neexistuje, je výsledkem funkce -1.

lastIndexOf(text)

Vrátí index, na kterém se objevuje poslední výskyt řetězce text. Pokud takový index neexistuje, je výsledkem funkce -1.

D.6   Objekt FileWriter

D.6.1                      Konstruktor

Konstruktor může mít jeden parametr. Ten určuje soubor, který se má otevřít. Pokud soubor není zadán, vyvolá se dialogové okno pro výběr souboru.

D.6.2                      Funkce

close()

Uzavře výstupní proud pro zápis dat.

write(i)

Pokud je i

-          pole