BAKALÁŘSKÁ PRÁCE. Převod Windows Forms do Windows Presentation Foundation. Converting Windows Forms into Windows Presentation Foundation

BAKALÁŘSKÁ PRÁCE

Převod Windows Forms do Windows Presentation Foundation

Converting Windows Forms into Windows Presentation Foundation

Straka Jiří

Unicorn College © 2010 Unicorn College, V kapslovně 2767/2, Praha 3, 130 00 Název práce v ČJ: Název práce v AJ:

Převod WF do WPF Converting WF into WPF

Autor:

Straka Jiří

Akademický rok:

2011

Kontakt:

E-mail: [email protected] Tel.: (+420) 774 439 398

Bakalářská práce

Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation

1. ZADÁNÍ

-4-



2. ABSTRAKT V následující práci se podíváme na historický vývoj technologií pomocí, kterých lze vyvíjet okenní aplikace pro operační systém Windows. Detailněji se podíváme na dvě nejnovější technologie společnosti Microsoft, které jsou součástí .NET Frameworku a jedná se o technologie Windows Forms a Windows Presentation Foundation (WPF). Technologie Windows Forms může být také využita např. pro vývoj aplikací pro operační systém Linux pomocí projektu Mono od společnosti Novell. Celá práce je zaměřena hlavně na technologii WPF, a proto také nahlédneme do jejího využití ve vývoji bohatých internetových aplikací pomocí Silverlight a Windows Phone 7, které nám umožňuje vyvíjet pro mobilní zařízení. Nejobsáhlejší část práce je věnována popisu aplikace pro převod Windows Forms do WPF. V popisu aplikace nalezneme např. požadavky kladené na aplikaci, třídní diagram celé aplikace, popis jednotlivých tříd, použité návrhové vzory, atd.

Aplikace umožňuje načíst

vstupní soubor, který definuje uživatelské rozhraní ve Windows Forms a převést tento soubor do, co možná nejvěrohodnější reprezentace ve WPF pomocí značkovacího jazyka XAML (Extensible Application Markup Language), který je typický pro WPF. Aplikace pro svůj vlastní převod nepodporuje všechny komponenty, které Windows Forms nabízí, ale pouze omezenou množinu vybraných komponent. U této množiny komponent je opět vybráno jen několik stěžejních vlastností, které aplikace pro převod podporuje. Rozšiřitelnost je jeden z hlavní požadavků, který musí aplikace splňovat. Proto je všechna aplikační logika pro převod mezi technologiemi soustředěna v zásuvných modulech. Zásuvné moduly umožňují snadné rozšíření portfolia podporovaných komponent a jejich vlastností pro převod. V závěru práce jsou shrnuty všechny poznatky, které byly nasbírány během vývoje aplikace. Je zde uveden výčet možných směrů, jakými by se mohlo rozšiřování aplikace ubírat, ale také faktory, které převod z Windows Forms do WPF ztěžují a v některých případech i znemožňují.

Klíčová slova: .NET Framework, Windows Forms, Windows Presentation Foundation, XAML, Silverlight, Windows Phone 7, XNA, C#, návrhový vzor, zásuvný modul.

-5-



3. ABSTRACT Inside following Bachelor's Thesis we take a look at historical development of technologies which allow us to develop form applications for operation system called Windows. We take look at the two latest Microsoft technologies which are a part of .NET Framework in detail. These technologies are Windows Forms and Windows Presentation Foundation (WPF). Technologies Windows Forms can be also used for developing applications for Linux operation system through Mono project by Novell Company. The whole Bachelor's Thesis is mainly focused on WPF. Therefore, we look into its usage in developing rich internet application via Silverlight and Windows Phone 7 which allows us to develop for mobile devices. The most extensive part of whole Bachelor’s Thesis is dedicated to description of application for converting Windows Forms into Windows Presentation Foundation. Inside the description of application we can find for example requirements for application, class diagram of whole application, description of each class, used design patterns, etc. Application allows us to load input file which defines user interface in Windows Forms technology and convert this file into as credible representation as possible in WPF using markup language XAML. This markup language is typical for WPF. The application doesn't support all the components which Windows Forms offers. But there is just limited set of selected components. Every component has selected set of supported attributes for conversion. Extensibility is one of the most important requests for application. That's why all the application logic for converting is concentrated inside plugins. Plugins allow to application be easily extensible and upgradable. The conclusion of Bachelor's Thesis summarizes all pieces of knowledge that have been collected during developing application. There is also enumeration of all possible ways how could be the application extended. But there are also facts which make converting Windows Forms into WPF more difficult.

Keywords: .NET Framework, Windows Forms, Windows Presentation Foundation, XAML, Silverlight, Windows Phone 7, XNA, C#, design pattern, plugin

-6-



4. PROHLÁŠENÍ Prohlašuji, že svou bakalářskou práci na téma Převod Windows Forms do Windows Presentation Foundation jsem vypracoval samostatně pod vedením vedoucího bakalářské práce a s použitím odborné literatury a dalších informačních zdrojů, které jsou v práci citovány a jsou též uvedeny v seznamu literatury a použitých zdrojů. Jako autor uvedené bakalářské práce dále prohlašuji, že v souvislosti s vytvořením této bakalářské práce jsem neporušil autorská práva třetích osob, zejména jsem nezasáhl nedovoleným způsobem do cizích autorských práv osobnostních a jsem si plně vědom následků porušení ustanovení § 11 a následujících autorského zákona č. 121/2000 Sb.

…….……………….

V Praze dne

Straka Jiří

-7-



5. PODĚKOVÁNÍ (DOBROVOLNÉ) Děkuji vedoucímu bakalářské práce Ing. David Hartman Ph.D. za účinnou metodickou, pedagogickou a odbornou pomoc a další cenné rady při zpracování mé bakalářské práce.

-8-



6. OBSAH 1. Zadání ............................................................................................................................... - 4 2. Abstrakt ............................................................................................................................ - 5 3. Abstract ............................................................................................................................ - 6 4. Prohlášení ........................................................................................................................ - 7 5. Poděkování (dobrovolné) ................................................................................................. - 8 6. Obsah ............................................................................................................................... - 9 7. Úvod ............................................................................................................................... - 12 7.1 Popis jednotlivých kapitol práce .............................................................................. - 12 7.2 Konvence používané v této práci ............................................................................. - 13 7.3 Konvence .................................................................................................................. - 13 8. Vývoj aplikací pro systém Windows ............................................................................... - 14 8.1 Základy architektury .NET ........................................................................................ - 15 8.2 Možnosti vývoje na platformě .NET ......................................................................... - 16 8.3 Windows Forms ....................................................................................................... - 17 8.3.1 Některé novinky Windows Forms 2 .................................................................. - 18 8.3.2 Realizace Windows Forms ................................................................................ - 19 8.4 Projekt Mono ........................................................................................................... - 20 8.4.1 Součásti projektu Mono .................................................................................... - 20 8.5 Windows Presentation Foundation ......................................................................... - 21 8.5.1 XAML ................................................................................................................. - 22 8.5.2 Ukázka XAML jazyka .......................................................................................... - 22 8.5.3 Výhody WPF oproti WinForms .......................................................................... - 23 8.5.4 Vývoj WPF ......................................................................................................... - 24 8.5.5 Vylepšení ve WPF 3.5 ........................................................................................ - 24 8.5.6 Vylepšení ve WPF 3.5 SP1 ................................................................................. - 25 8.5.7 Vylepšení ve WPF 4 ........................................................................................... - 25 8.6 Silverlight.................................................................................................................. - 27 8.6.1 Souhrn zajímavých možností technologie Silverlight ........................................ - 28 8.6.2 Jak Silverlight aplikace funguje? ....................................................................... - 29 8.6.3 Začlenění aplikace do internetové stránky ....................................................... - 29 8.7 Windows Phone 7 .................................................................................................... - 31 -9-


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation 9. Návrh a analýza aplikace ................................................................................................ - 32 9.1 Požadavky na aplikaci .............................................................................................. - 32 9.1.1 Funkční požadavky ............................................................................................ - 32 9.1.2 Nefunkční požadavky ........................................................................................ - 32 9.2 Diagram tříd ............................................................................................................. - 33 10. Implementace .............................................................................................................. - 34 10.1 Zvolené technologie ............................................................................................... - 34 10.2 Popis aplikace......................................................................................................... - 34 10.3 Podporovaní komponenty a vlastnosti pro převod ............................................... - 34 10.4 Rozhraní aplikace ................................................................................................... - 35 10.4.1 IControlCreator ............................................................................................... - 35 10.4.1.1 Decorator ..................................................................................................... - 36 10.4.1.2 Využití vzoru Decorator v aplikaci ................................................................ - 37 10.5 Popis tříd prezentační vrstvy.................................................................................. - 37 10.5.1 MainWindow................................................................................................... - 37 10.5.2 PluginWindow ................................................................................................. - 38 10.6 Popis jednotlivých tříd aplikační logiky .................................................................. - 39 10.6.1 Constants ........................................................................................................ - 39 10.6.2 ControlCreatorFactory .................................................................................... - 39 10.6.3 Attribute .......................................................................................................... - 40 10.6.4 ElementAttribute ............................................................................................ - 40 10.6.5 FormConverter ................................................................................................ - 41 10.6.5.1 Facade .......................................................................................................... - 41 10.6.5.2 Využití vzoru Facade v aplikaci..................................................................... - 42 10.6.6 FormElement................................................................................................... - 42 10.6.7 FormElementReader ....................................................................................... - 43 10.6.7.1 GetNamespace ............................................................................................. - 44 10.6.7.2 GetFormName ............................................................................................. - 44 10.6.7.3 GetElementType .......................................................................................... - 44 10.6.7.4 GetChildElements ........................................................................................ - 45 10.6.8 Logger.............................................................................................................. - 45 10.6.8.1 Singleton ...................................................................................................... - 46 10.6.8.2 Využití vzoru Singleton v aplikaci ................................................................. - 47 - 10 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation 10.6.9 LogWatcher ..................................................................................................... - 47 10.6.10 PluginManager .............................................................................................. - 48 10.6.11 TreeNodeCreator .......................................................................................... - 49 10.6.11.1 Rekurze ...................................................................................................... - 49 10.6.12 TreeViewManagment ................................................................................... - 49 10.6.13 XamlBuilder ................................................................................................... - 50 10.6.14 XamlWriter .................................................................................................... - 50 11. Dokumentace ............................................................................................................... - 52 11.1 Uživatelská dokumentace ...................................................................................... - 52 11.1.1 Načtení vstupního souboru............................................................................. - 52 11.1.2 Zobrazení náhledu .......................................................................................... - 54 11.1.3 Převedení formuláře ....................................................................................... - 54 11.2 Programátorská dokumentace .............................................................................. - 55 11.2.1 Vytvoření ukázkového pluginu pro TextBox ................................................... - 55 11.2.1.1 Implementace vlastnosti Name ................................................................... - 56 11.2.1.2 Implementace vlastnosti Version ................................................................ - 56 11.2.1.3 Implementace vlastnosti Description .......................................................... - 56 11.2.1.4 Implementace metody Create ..................................................................... - 57 12. Závěr............................................................................................................................. - 59 13. Conclusion .................................................................................................................... - 61 14. Seznam použité literatury ............................................................................................ - 63 15. Seznam použitých symbolů a zkratek .......................................................................... - 64 16. Seznam obrázků ........................................................................................................... - 65 17. Seznam tabulek ............................................................................................................ - 66 18. Seznam příloh............................................................................................................... - 67 18.1 Příloha 1 – Ukázka formuláře SampleForm1 ve WF .............................................. - 68 18.2 Příloha 2 - Ukázka převedeného SampleForm1 do WPF ....................................... - 69 18.3 Příloha 3 – Ukázka formuláře SampleForm2 ve WF .............................................. - 70 18.4 Příloha 4 - Ukázka převedeného SampleForm2 do WPF ....................................... - 71 18.5 Příloha 5 – CD ......................................................................................................... - 72 -

- 11 -



7. ÚVOD Windows Forms jsou stále jednou z nejpoužívanějších technologií pro vývoj aplikací pro operační systémy Windows, přestože je zde tato technologie od roku 2001, kdy vyšel .NET Framework 1. O pět let později to je roku 2006 vychází v pořadí třetí verze .NET Frameworku a jeho součástí je nová technologie pro vývoj desktopových aplikací systému Windows s názvem Windows Presentation Foundation (WPF). WPF nabízí nové možnosti vývoje aplikací pro systém Windows v podobě nových komponent uživatelského rozhraní, hardwarovou akceleraci, vektorovou grafiku, animace, deklarativní programování, podporu médií atd. O rok později se WPF rozšíří i do webových aplikací pomocí produktu z dílny Microsoft s názvem Silverlight. Další uplatnění se nachází v mobilních zařízeních, které podporují operační systém Windows Phone 7 a vyšší. Aplikace pro tyto zařízení mohou být psány pomocí technologie WPF a nebo XNA Frameworku (XNA je mimo rozsah této práce). Cílem této práce je, vytvořil aplikaci, která je schopná převádět jednotlivé formuláře vytvořené v technologii Windows Forms do novější technologie WPF. V současné době není autorovi známá žádná aplikace, která by umožňovala převádět formuláře z technologie Windows Forms do WPF. Aplikace nepodporuje veškeré komponenty Windows Forms a kompletní výčet jejich vlastností, ale pouze omezenou množinu předem vybraných relativně jednoduchých komponent. U každé komponenty aplikace podporuje jen určité vlastnosti. Jedním z nejvýznamnějších požadavků na aplikaci, je její snadná rozšiřitelnost a schopnost aktualizace, aniž by se musely překompilovat všechny zdrojové kódy stávající aplikace. Těchto požadavků bude docíleno pomocí tzv. zásuvných modulů, které aplikace podporuje a veškerá aplikační logika pro konkrétní reprezentaci WPF na základě vstupních souborů z Windows Forms je soustředěna v těchto zásuvných modulech.

7.1 Popis jednotlivých kapitol práce 

Kapitola 8: Vývoj aplikací pro systém Windows – V této části se podíváme na historický vývoj psaní aplikací pro operační systémy Windows v závislosti na čase a používané technologii.



Kapitola 9: Návrh a analýza aplikace – Před pohledem na konkrétní implementaci se podíváme na high-level schémata aplikace.



Kapitola 10: Implementace – V této kapitole se seznámíme s detailní implementací aplikace na převod Windows Forms do WPF.



Kapitola 11 – Obsahuje uživatelskou dokumentaci, jak obsluhovat aplikace a také programátorskou dokumentaci, jak naimplementovat další zásuvný modul.

- 12 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation 

Kapitola 12 – Shrnutí poznatků celé práce, možnosti budoucího vývoje a diskuze o možném využití aplikace.

7.2 Konvence pouţívané v této práci Informace v této práci jsou uspořádány tak, aby byly snadno srozumitelné. Před čtením vlastního textu práce doporučují přečíst si pár typografických konvencí, které jsou v práci použity.

7.3 Konvence 

Neproporcionální písmo – je použito, jak je k tomu v každém vývojovém prostředí pro odlišení výrazových prostředků programovacího jazyka v textu, jako jsou např. příkazy, proměnné, atributy, jmenné prostory, vlastnosti, metody, hodnoty, události, objekty atd.



Tučné písmo – použito pro zvýraznění důležitých nebo klíčových pojmů v textu.



VELKE_NEPROPORCIONÁLNÍ_PÍSMO

– velké neproporcionální písmo oddělené

podtržítky místo mezer je použito pro zvýraznění konstant v ukázkách kódu.

- 13 -



8. VÝVOJ APLIKACÍ PRO SYSTÉM WINDOWS Na podzim roku 1985 společnost Microsoft vydala svojí první verzi operačního systému Windows pod názvem Windows 1.0. Jednalo se pouze o nástavbu nad operačním systémem DOS. Významná změna přišla s příchodem Windows 95, kdy operační systém pracuje na 32bitové architektuře. Další významný milník nastal v roce 2001, když Microsoft vydal svojí pátou verzi systému Windows s označením Windows XP. Tato nová verze přinesla 64bitovou architekturu, která se používá i v dnes poslední verzi Windows 7. První verze Windows podporovali pouze vývoj aplikací pomocí programovacího jazyka C a rozhraní s názvem Windows API, které obsahuje základní funkce i funkce pro vytváření uživatelského rozhraní. Postupem času se pro vývoj aplikací pro systém Windows přizpůsobily již existující programovací jazyky, jako jsou Microsoft Visual Basic nebo C++ anebo vznikl nový programovací jazyk C#, který je založen na jazyce C. Následující diagram uvádí vývoj programovacích jazyků založeným na programovacím jazyku C a rozhraních používaných pro vývoj aplikací. (Petzold, 2008)

1985 C

Rozhraní Windows API 1992

C++

Knihovna Microsoft Foundation Class 2001

C# nebo C++

Windows Forms 2006

C# nebo C++

Windows Presentation Foundation

Obrázek 1 - Vývoj programování aplikací pro systém Windows Zdroj: Mistrovství ve Windows Presentation Foundation, vlastní tvorba V digramu je vidět, že v roce 2001 nastal zlom ve vývoji aplikací pro systém Windows. Byl představen první nativní objektově orientovaný programovací jazyk C# pro vývoj aplikací pro Windows společně s frameworkem Windows Forms, který jsou součástí .NET Frameworku 1.

- 14 -



8.1 Základy architektury .NET Architektura .NET byla vyvinuta formou Microsoft a vypuštěna do světa v roce 2002. Cílem této nové platformy bylo zjednodušit a sjednotit vývoj aplikací. Technologie .NET se tak stala hlavním konkurentem platformě Java od firmy Sun Microsystems. Platforma .NET nám přináší: 

Nové programovací jazyky



Common Intermediate Language (CIL)



Modul CLR



Just-in-Time kompilátor



Kooperaci různých jazyků



Obrovské množství knihoven



Vývojové prostředí Visual Studio

Více informací o jednotlivých tématech viz. (Nash, 2010) S příchodem platformy se objevili o nové programovací jazyky, jako jsou například J#, F#, C# atd. Snad nejrozšířenější a nejpoužívanější je jazyk C#. Jedná se o vysokoúrovňový objektově orientovaný programovací jazyk. Svojí inspiraci syntaxe čerpal v programovacích jazycích C++ a Java. Jazyk C# je mnohoúčelový a můžeme se s ním tedy setkat u vývoje formulářových aplikací, webových aplikací, služeb systému Windows, webových služeb atd. Časový vývoj platformy .NET zachycuje následující obrázek:

- 15 -



.NET Framework 2.0

.NET Framework 3.0

WinForms

WPF

.NET Framework 3.5

.NET Framework 4.0

LINQ

Parallel LINQ

ADO.NET Entity Framework

Task Parallel Library

ASP.NET WCF ADO.NET WinForms Base Class Library CLR

Card Space

Obrázek 2 - Vývoj .NET Frameworku Zdroj: http://en.wikipedia.org/wiki/.NET_Framework, vlastní tvorba

8.2 Moţnosti vývoje na platformě .NET Jednou z velkých výhod platformy .NET je nepřeberné množství druhů projektů, které lze vyvíjet. Ať je jedná o aplikace běžící přímo v operačním systému Windows, webové aplikace, zásuvné moduly pro Microsoft Office atd. Začneme přiblížením první skupinou typy aplikací. Jedna z možností je vývoj klasické konzolové aplikace. Dále mnohem více uživatelsky přívětivější tzv. formulářové aplikace za pomocí technologie Windows Forms, která využívá volání Win32 API nebo pomocí novější technologie Windows Presentation Foundation. O obou technologiích pro vývoj formulářových aplikací budou detailněji pojednávat následující stránky. Další typ projektu, který můžeme najít pod .NET platformou jsou Windows Služby. Služba je aplikace, která běží na pozadí sytému a není v přímém kontaktu s uživatelem. Druhou skupinou jsou webové aplikace, které poslední dobou získávají stále více na oblibě. Zde nám platforma .NET nabízí možnost vývoje webových aplikací pomocí technologií např. ASP.NET WebForms, tato technologie nám nabízí vývoj stavových aplikací nad nestavovým

- 16 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation protokolem HTTP. Další možností je ASP.NET MVC, jak název napovídá umožnuje vývoj aplikací založený na architektuře Model-View-Controller. Jednou z nejnovějších možností je psaní aplikací pro Cloud Computing, kde aplikace jsou hostovány na serverech třetích stran, a výkon je možné škálovat dle potřeb. Přístup do aplikace je možný, jak pomocí tenkého klienta, tak tlustého klienta. Mezi ostatní typy projektů bych zmínil vývoj tzv. knihoven. Knihovny implementují určitou funkcionalitu, kterou lze využít ve všech typech předešlých projektů.

8.3 Windows Forms Technologie Windows Forms byla představena společně s .NET 1 v roce 2002, jedná se o grafické programovací rozhraní pro aplikace (API). Nahrazovala dosavadní technologie, jako jsou MFC nebo Win32. Volání toho rozhraní odkazuje na nativní rozhraní Microsoft Windows. Zabaluje již existující Windows API do řízeného kódu (managed code). Tento řízený kód je spouštěn pod virtuálním strojem Common Language Runtime. Pomocí Windows Forms můžeme vytvářet aplikace s bohatým uživatelským rozhraním, které se snadno vyvíjí a udržují aktualizované. Základním stavebním kamenem technologie Windows Forms je formulář. Aplikace musí obsahovat alespoň jeden takovýto formulář. Formulář zde slouží k zobrazování informací uživateli, jedná se o kontejner pro komponenty. Komponenta je prvek uživatelského rozhraní (GUI), který buď zobrazuje informace uživateli anebo čeká na uživatelský vstup. Windows Forms jsou založeny na událostně řízeném modelu. To znamená, že například po stisknutí tlačítka uživatelem je vyvolána událost, v tomto případě událost tlačítka OnClick a je spuštěn obslužný kód této události tzv. EventHandler. Formulář vytvořený pomocí technologie Windows Forms viz. Obrázek 3. Oproti klasickému vývoji formulářových aplikací pomocí C++ a volání funkcí Win32 nám Windows Forms přináší tyto výhody: 

Nezávislost na platformě – existují implementace pro Linux, FreeBSD, Mac OS X, atd., viz. projekt Mono níže.



Skutečné objektově orientované paradigma pro vývoj



Jednodušší, rychlejší a pohodlnější vývoj aplikací



Výběr z mnoha programovacích jazyků platformy .NET např. Visual Basic, C# atd.

Windows Forms ve své první verzi přišly s celou řadou již předdefinovaných komponent, jako jsou například: 

Button – Představuje tlačítko s popiskem na formuláři.



CheckBox – Slouží pro výběr hodnot z uzavřené množiny možností.

- 17 -



GroupBox – Slučuje komponenty do logických celků.



Label – Přidává popisek k jednotlivým komponentám na formuláři.



TextBox – Slouží převážně k přijímání uživatelského vstupu.



Atd.

8.3.1 Některé novinky Windows Forms 2 V roce 2005 byl představena nová verze .NET Frameworku společně s novou verzí Windows Forms 2.0 Celý model Windows Forms zůstal nezměněn, ale přibyly např. následující nové změny: 

Přidání komponenty SplitContainer – Jedná se o kontejnerový prvek tzn. může obsahovat jiné prvky uživatelského rozhraní. Umožnuje rozdělit formulář na dvě části, kterým zle po spuštění aplikace měnit velikost pomocí myši.



Přidání komponenty WebBrowser – Umožnuje zobrazit internetovou stránku na formuláři aplikace, jak z lokálního zdroje, tak ze vzdáleného.



Přidání komponenty DataGridView – Nahrazuje komponentu DataGrid z .NET Frameworku 1. Přináší nové možnosti do zobrazování dat na formuláři.



Přidání komponenty BackgroundWorker – Slouží pro zpracování úloh v dalším vlákně, tak aby uživatelské rozhraní nezamrzlo a reagovalo na uživatelské vstupy.



ClickOnce – Je technologie, která umožňuje uživateli nainstalovat a spustit aplikaci pomocí kliknutí na odkaz uvnitř internetoví stránky.



Vizuální styly – S nástupem Windows XP přišla i možnost pomocí nový tříd vytvořit komponenty s vlastním vizuálním vzhledem.



Přidání komponenty MaskedEdit – Poskytuje vstup pro uživatelské vstupy, které musí odpovídat předem definovanému formátu.

- 18 -



Obrázek 3 - Ukázka formuláře z technologie Windows Forms Zdroj: http://www.alitopaloglu.com/c-windows-form-olusturma/, převzato

8.3.2 Realizace Windows Forms Při vytváření každého formuláře ve vývojovém prostředí Microsoft Visual Studio (MSVS) se vždy generují dva soubory (třídy) s příponou .cs (pokud programujeme v jazyce C#) pro jeden formulář. Ve skutečnosti se jedná o jednu třídu, která je označená klíčovým slovem partial, toto klíčové slovo umožňuje rozdělit definici třídy do několika samostatných souborů, která jsou spojeny, když je aplikace zkompilována. Představme si, že přidáváme do projektu formulář s názvem OdeslaniObjednavky. V tomto případě MSVS vygeneruje tyto soubory:

OdeslaniObjednavky.Designer.cs

a

OdeslaniObjednavky.cs.

Soubor

OdeslaniObjednavky.Designer.cs obsahuje definici uživatelského rozhraní formuláře. Celá tato definice se ukrývá v metodě InitializeComponents, která se volá v konstruktoru každého formuláře. Obsah metody je automaticky generován designérem v MSVS a její obsah se nedoporučuje ručně upravovat. (Sharp, 2006) Následující ukázka zdrojového kódu zobrazuje krátkou metodu InitializeComponent: private void InitializeComponent() { this.button1 = new System.Windows.Forms.Button(); this.SuspendLayout(); // // button1 // this.button1.Location = new System.Drawing.Point(112, 52); this.button1.Name = "button1"; this.button1.Size = new System.Drawing.Size(75, 23); this.button1.TabIndex = 0; this.button1.Text = "tlačítko";

- 19 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation this.button1.UseVisualStyleBackColor = true; this.button1.Click += new System.EventHandler(this.button1_Click); // // Form1 // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(284, 262); this.Controls.Add(this.button1); this.Name = "Form1"; this.Text = "Form1"; this.ResumeLayout(false); }

Na začátku metody je vidět, že se inicializují všechny privátní členy třídy (formuláře) ve formě komponent na formuláři. V této ukázce se jedná pouze o komponentu tlačítka. Dále jsou jim přes tečkovou notaci nastavovány všechny potřebné vlastnosti jako jsou: Name, Text, Size, atd. Také zde mohou být nastaveny odkazy na metody pomocí delegátů, které se mají spustit po vyvolání nějaké události. V ukázce se například nastavuje, která metoda se spustí po klepnutí (Click) na tlačítko. Druhou polovinu třídy tvoří soubor OdeslaniObjednavky.cs, někdy se tomuto souboru také říká tzv. code-behind (kód, která se skrývá za formulářem). V tomto souboru jsou popsány všechny reakce na události komponent formuláře.

8.4 Projekt Mono Mono je softwarová platforma navržená tak, aby umožnila vývojářům co nejjednodušší vývoj aplikací napříč platformami. Jedná se o open-source projekt, jehož hlavním cílem je vytvořit sadu nástrojů kompatibilní s Microsoft .NET založeného na ECMA standardech pro programovací jazyk C# a Common Language Runtime. V době, kdy je tato práce psaná projekt Mono podporuje celý .NET 4.0 kromě WPF, EntityFramework, System.Managment a System.EnterpriseServices.

8.4.1 Součásti projektu Mono Projekt Mono tvoří několik následujících částí: 

C# kompilátor – Mono kompilátor pro programovací jazyk C# podporuje tyto verze jazyka: 1.0, 2.0, 3.0 a 4.0 (ECMA).



Mono runtime – stejně jako Microsoft .NET i v Mono projektu můžeme najít Common Language Infrastructure, Just-In-Time kompilátor, Garbage Collector, podporu vláken, atd.

- 20 -



Základní bázové knihovny - poskytuje obrovské množství knihoven, na kterých můžeme stavět vlastní aplikace. Tyto knihovny jsou kompatibilní s Microsoft .NET třídami.



Mono knihovny – Mono navazuje na Microsoft .NET základní bázové knihovny a poskytuje nadstavbu nad těmito knihovnami, které jsou převážně využívaní při tvorbě aplikací pro Linux. Mezi tyto knihovny patří: Gtk+, Zip files, LDAP, OpenGL, POSIX, atd.

8.5 Windows Presentation Foundation WPF byla poprvé představena v listopadu roku 2007 jako součást .NET Frameworku 3.0. WPF, dříve známo jako projekt Avalon je technologie používaná pro vykreslování bohatého 1

grafického uživatelského rozhraní založeném na DirectX .

Dalo by se říci, že WPF je

následníkem Windows Forms, který nabízí nové možnosti ve vývoji aplikací, jenž nebyly ve WinForms vůbec realizovatelné za využití 2D a 3D grafiky, vektorovou a bitmapovou grafikou, anebo dokonce audiem a videem. Jedním z největších přínosů WPF je oddělení vzhledu aplikace od samotného kódu, jako je tomu např. u třívrstvé architektury. Aby toto oddělení bylo možné je potřeba nějakého jazyku pro definování uživatelského rozhraní, a tím je XAML. Náhled aplikace s bohatým uživatelským rozhraním demonstruje následující obrázek:

Obrázek 4 - Ukázka okna s bohatým uživatelským rozhraní vytvořeného ve WPF Zdroj: http://www.infragistics.com/innovations/vs2010/wpf.aspx#WPF, převzato

1

DirectX – je množina knihoven poskytující přímé ovládání moderního hardwaru. Součástí DirectX je i knihovna s názvem Direct3D, kterou používá WPF pro vykreslování grafiky.

- 21 -



8.5.1 XAML XAML (čteno „zamel“) je zkratka z anglického XML for Application Markup Language – značkovací XML jazyk pro aplikace. Jedná se o rozšíření jazyka XML. Jazyk XAML nám umožňuje

deklarativním

způsobem

definovat

bohaté uživatelské rozhraní

a jeho

hierarchickou strukturu. Kde používáme XAML elementy pro vytváření samotných prvků uživatelského rozhraní a pro definování jejich vlastností využíváme buď jiných XAML elementů (ve WPF muže např. tlačítko obsahovat video) nebo atributy XAML elementů. Každý XAML element je reprezentován stejnojmennou třídou ve jmenném prostoru System.Windows.Controls pro vytváření a přístupu k uživatelskému rozhraní např. ve vlastních třídách. (Stephens, 2010) Klíčovou myšlenkou značkovacího jazyka XAML je oddělení definice uživatelského rozhraní od programové části. Toto oddělení nám umožnuje paralelní práci vývojářů a návrhářů uživatelského rozhraní, kteří sami o sobě programovat neumí. Tato myšlenka dala vzniknout grafickému nástroji pro návrh uživatelského rozhraní Microsoft Expression Blend. Jedná se o nástroj, kde je možné vyvíjet aplikace pro desktopové, webové (Silverlight – o který bude popsán na následujících stranách) a mobilní aplikace (Windows Phone 7 – také bude popsáno později).

8.5.2 Ukázka XAML jazyka <Window x:Class="WpfApplication1.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> <Button Content="Button" Height="23" Margin="12" Name="btn" Width="75"> <Button.Background> V následující ukázce je možno vidět defaultní kód, který vygeneruje Visual Studio po vytvoření WPF aplikace a následné přidání jednoho tlačítka. Povšimneme si elementu Button, tento element obsahuje atributy Content, Height, Margin atd, jenž tvoří vlastnosti objektu “btn”. Ale také obsahuje vlastnost, která je opět element. Kde hodnota je definována tzv. podřízeným elementem v našem případě .

- 22 -



8.5.3 Výhody WPF oproti WinForms 

Deklarativní programovaní – Stejně jako během tvorby internetových stránek používáme HTML tagy pro definování struktury stránky, tak ve WPF aplikacích používáme značkovací jazyk XAML.



Hardwarová akcelerace – WPF je založena na Direct3D tzv., že všechen obsah ve WPF aplikaci (2D i 3D grafika) je převedena na trojúhelníky a ty jsou potom vykreslovány pomocí hardware. Přesunutí výpočetní kapacity na grafickou kartu. Neznamená to ovšem, že potřebujeme výkonné grafické karty, protože vykreslovaní uživatelského rozhraní může probíhat i na procesoru.



Bohaté přizpůsobení komponent - Pomocí XAML jazyka můžeme např. definovat tlačítko, které bude obsahovat video nebo animovat prvky uživatelského rozhraní na základě událostí. WPF aplikace podporují vytváření tzv. skinů – jedná se o naprosto odlišné vzhledy uživatelského rozhraní (velikosti jednotlivých prvků, jejich uspořádání, barevné rozložení jednotlivých prvků na formuláři atd.).



Nezávislost na rozlišení obrazovky – Jednotka používaná ve WPF pro specifikování velikosti komponent se jmenuje Device Independent Pixel (DIP). Jedná se o logický pixel nezávislý na rozlišení obrazovky. Standardně se používají obrazovky s DPI (Dots per Inche – Počet bodů na palec) 96 x 96. Jestliže např. ve WPF řekneme, že tlačítko má šíři 96, to se rovná 1 palec, a tuto aplikaci spustíme na monitoru s hodnotou DPI 120, šířka tlačítka se přepočítá a velikost každého pixelu vyjde 1.25 pixelů. A výsledkem bude skutečnost, že šíře tlačítka i na monitoru s DPI 120 bude 1 palec.



Vektorová grafika – WPF podporuje tzv. vektorovou grafiku, ta pro uchovávání svého vlastního obsahu používá body, úsečky a jiné geometrické prvky. Zatímco bitmapová grafika shromažďuje informace o jednotlivých pixelech obrázku. Výhodami vektorové grafiky je nižší paměťová náročnost a libovolné zvětšení a zmenšení obrázku bez ztráty kvality.



Animace – ve Windows Forms jsme mohli použít časovač pomocí něj složitě animovat prvky na formuláři. WPF nám nabízí výkonné prostředí pro animování libovolné vlastnosti prvku a vytvoření tak naprosto interaktivní vzhledu aplikace.



Podpora audio a video formátů – technologie WPF podporuje nejrůznější formáty obrázků, audio souborů a dokonce i video formáty, aby poskytlo, co možná nejpřitažlivější uživatelské rozhraní.

- 23 -



Nové prvky uţivatelského rozhraní – WPF přichází s novou sadou prvků uživatelského rozhraní pro rozmístění jejich potomků. Mezi příklady bych uvedl: Grid, který umisťuje prvky v řádcích a sloupcích, StackPanel slouží k umístění prvku v jednom sloupci či řádku a DockPanel, který zachytává svoje potomky k vlastním hranám. (MacDonald, 2008)

8.5.4 Vývoj WPF První verze WPF nese název WPF 3.0, protože byla vypuštěna společně s .NET Frameworkem v roce 2006. Další verze téměř o rok později v roce 2007 pod označením WPF 3.5. Třetí verze byla uvolněna jako opravný balíček pro .NET Framework 3.5, avšak nejedná se o klasický opravný balíček, protože přináší spousty nových možností a vylepšení. Poslední verze WPF vyšla v roce 2010 s pořadovým číslem 4. Časový vývoj verzí WPF zachycuje následující obrázek:

2006

WPF 3.0

WPF 3.5

2007

WPF

2008 3.5 SP1

2010 WPF 4

Obrázek 5 - Vývoj technologie WPF v závislosti na čase Zdroj: vlastní tvorba

8.5.5 Vylepšení ve WPF 3.5 Některé z novinek, které nám přineslo WPF 3.5 oproti verzi WPF 3.0: 

Interaktivní 2D na 3D – Nová funkčnost, která umožňuje zobrazit interaktivní 2D grafiku na 3D objektu.



Firefox podpora pro XBAPs – WPF nyní umožnuje spustit aplikaci WPF hostovanou v internetovém prohlížeči (známé jako XBAPs) Firefox stejně jako v Internet Explorer.



Podpora LINQ pro data binding – LINQ je nová technologie pro dotazovaní nad daty přímo v programovacím jazyce. Jedná se o rozšiřující metody, které se nalézají v namespace System.Linq. Obrovskou předností jazyka LINQ je, že se všemi datovými zdroji pracuje stejným způsobem. Mezi tyto datové zdroje patří: objekty v paměti, XML soubory a databáze. (MacDonald, 2008)

- 24 -



8.5.6 Vylepšení ve WPF 3.5 SP1 Následující výčet jsou některé ze zajímavých novinek, které přináší WPF 3.5 SP1: 

Vylepšený data binding (vázání dat) – WPF přichází s podporou XLINQ, lepší validací a debuggováním.



Vylepšené speciální efekty – Efekty, které byly součástí první verze WPF s oficiálním doporučením je nepoužívat, kvůli jejich nízkému výkonu byly přepracovány za pomocí hardwarové akcelerace a došlo k zvýšení jejich výkonu.



Direct3D – Byla přidána interoperabilita pro podporu Direct3D. Nyní je možné vložit přímo 3D scénu vykreslenou pomocí Direct3D do obrázků nebo textur WPF aplikace.



Vylepšení z oblasti Textu – WPF přináší vylepšený výkon pro vykreslování textu a mezinárodní podporu znaků.



Vylepšené nasazení aplikace a .NET Framework – proces instalace .NET Frameworku je nyní na straně klienta rychlejší. Obsahuje novou Bootstrapper komponentu, která se stará o .NET Framework instalace a upgrady místo uživatele. A nové možnosti ClickOnce.



Vylepšený výkon – celá technologie WPF dosáhla mnohem lepších výkonnostních výsledků, jako jsou např. rychlejší spuštění aplikace (hlavně první spuštění), animace jsou nyní mnohem plynulejší, rychlejší data binding atd.



Splashscreen (spouštěcí obrazovka) – Některé obsáhlé aplikace napsané ve WPF se mohou načítat poměrně dlouho dobu, a proto přibyla možnost vybrat statický obrázek, který se zobrazí během načítání aplikace uživateli. (Nathan, 2010)

8.5.7 Vylepšení ve WPF 4 Seznam nejzajímavějších novinek ve WPF 4: 

Podpora Multi-touch – Přichází společně Windows 7, které sami o sobě multitouch podporují. Dotyky pomocí několika prstů zároveň jsou reprezentovány novými událostmi u jednotlivých prvků uživatelského rozhraní. Kromě Windows multi-touch 2

také plně využívá Microsoft Surface .

2

Microsoft Surface – jedná se o počítač ve formě konferenčního stolku, který obsahuje velkou multi dotykovou obrazovku. Tato obrazovka nahrazuje klasickou klávesnici a myš. Ovládání probíhá pomocí gest uživatele.

- 25 -



Integrace s Windows 7 Shell – WPF 4 přichází s novinkami ve formě integrace s novými možnostmi v operačním systému Windows 7. Hlavní s těchto novinek je možnost integrace s Hlavním panelem. Mezi možnosti práce s Hlavním panelem patří: Aero náhledy oken aplikací, tzv. jump lists, které usnadňují spouštění např. naposledy otevřených souborů, podsvícení ikony barvou, ve kterém stavu se aplikace nachází (Normal, Error, atd.), přidávání tlačítek do náhledu okna, atd.



Nové komponenty – WPF nyní obsahuje komponenty, jako jsou DataGrid, Calendar a DatePicker.



Easing funkce pro animaci – Easing funkce nám dovolují přidat matematické formule do animací. Za pomocí těchto matematických formulí animace vypadá přirozeně a plynule. WPF 4 přichází s 11 již předdefinovaných matematických formulí, jako jsou např. BounceEase, ElasticEase a SineEase.



Vylepšené nasazení aplikace – Klient .NET Frameworku může být nainstalován společně s plnou verzí .NET Frameworku.



Vylepšený výkon – Aby byl výkon vektorové grafiky možná co nejlepší WPF nyní umí vykreslené výsledky kešovat jako bitmapy a znovu je použít. V pokročilých případech je zde možnost ovlivnit toto chování pomocí vlastnosti CacheMode. (Nathan, 2010)

- 26 -



8.6 Silverlight Jedná se o konkurenta produktu Flash nebo Flex od společnosti Adobe. Stejně jako v případě Flash technologie jedná se o lightweight (asi 4MB) zásuvný modul, který se instaluje do internetového prohlížeče. V současné době jsou podporovány tyto prohlížeče: Internet Explorer, Mozilla Firefox, Safari a Google Chrome. Pomocí technologie Silverlight může vytvářet tzv. internetové aplikace s bohatým uživatelským rozhraním (RIA). Silverlight aplikace mohou pracovat v režimu mimo okno prohlížeče, a dokonce i v tzv. off-line režimu, kdy internetový prohlížeč není připojen k internetu. Porovnání Silverlight aplikace s bohatým uživatelským rozhraním s běžnou HTML stránkou:

Obrázek 6 - Silverlight RIA aplikace Zdroj: http://community.citrix.com/, převzato

- 27 -



Obrázek 7 - Běžná HTML stránka Zdroj: www.zive.cz, printscreen Uživatelské rozhraní Silverlight aplikací je deklarováno pomocí XAML jazyka stejně jako u WPF. Aplikace typu Silverlight tvoří svými možnostmi podmnožinu WPF aplikací, která se s každou další verzí Silverlight přibližuje WPF aplikacím. Při vytváření aplikací můžeme využívat vývojové nástroje, jako jsou Microsoft Visual Studio 2010 a Microsoft Expression Blend, které jsou založeny na Commom Language Runtime, to znamená, že při vývoji si můžeme vybrat z velkého množství programovacích jazyků, jako jsou např. C#, Visual Basic anebo dokonce z některých dynamických jazyků: Ruby nebo Python. Protože je celý Silverlight postaven na .NET Frameworku můžeme ve svým aplikacích používat Base Class Libraries, výsledkem je, že můžeme pracovat s obrovským množstvím již naprogramovaných tříd, jako jsou např. různé kolekce, práce s vlákny, práce s řetězci atd.

8.6.1 Souhrn zajímavých moţností technologie Silverlight 

Silverlight je rozšířený napříč platformami a napříč nejrůznějšími internetovými prohlížeči.

- 28 -



Silverlight aplikace mohou být naprogramovány v těchto vývojových prostředích: Visual Studio, Expression Blend a dokonce Eclipse.



Přináší podporu nejrůznějších vysoce kvalitních video a audio formátů. Mezi video formáty, které Silverlight nativně podporuje, patří: Windows Media VC-1/WMA, MPEG-4 s H.264 kódováním a to až do velikosti videa 720p+. Z podporovaných audio formátů bych uvedl AAC.



Standardně Microsoft přináší přes 60 komponent, avšak existuje další obrovské množství komponent, které byly vyvinuty třetími stranami.



Práce s vlákny je další z jeho klíčových předností. V aplikacích Silverlight můžeme využít tento prvek moderních aplikací dnešní doby. Složitější výpočty nebo komunikace s webovými službami může probíhat na pozadí aplikace.



Silverlight nabízí animaci, která je založená na čase, na rozdíl od největšího konkurenta Flash, kde je animace založena na snímcích.



Silverlight nabízí možnost nahrávat a streamovat audio a video zdroje přímo z koncových zařízení, které se nacházení u koncového uživatele.



Ve svých Silverlight aplikacích můžeme využít různé možnosti, jako jsou např. tisk, navigace, drag-and-drop podpora, kontextové nabídky, kopírování do schránky atd. (Lair, 2010)

8.6.2 Jak Silverlight aplikace funguje? Celá aplikace typu Silverlight je uložena v souboru XAP, pokud uživatel navštíví stránku, která je vytvořena pomocí Silverlight a má nainstalovaný potřebný zásuvný modul pro internetový prohlížeč, tak se dotáže pomocí klasického požadavku GET na tento soubor XAP. Soubor XAP je pouze výsledný archív celé aplikace se soubory DLL. DLL obsahují samotný funkční kód, obrázky, zvuky, soubory grafiky a jiné možné zdroje aplikace.

8.6.3 Začlenění aplikace do internetové stránky Když v Microsoft Visual Studio zakládáme nový projekt, tak se nás Visual Studio zeptá, do jakého typu webové aplikace chceme, aby byla Silverlight aplikace vložena. Na výběr je z možností ASP.NET Web Application, ASP.NET Web Site a ASP.NET MVC. Při zvolení typu projektu ASP.NET Web Application vypadá internetová stránka se Silverlight následovně:

- 29 -



<iframe id="_sl_historyFrame" style="visibility:hidden;height:0px;width:0px; border:0px">

V ukázce je vidět, že k samotnému vložení Silverlight aplikace do HTML stránky dochází v tagu object. V atributech tohoto tagu se nastavuje velikost Silverlight aplikace, v tomto případě je šířka i výška aplikace 100%. V prvním parametru s názvem source se nastavuje samotný odkaz na Silverlight aplikaci. Další ze zajímavých parametrů jsou barva pozadí a minimální verze Silverlight zásuvného modulu do internetového prohlížeče pro spuštění aplikace. Za pozornost stojí také odkaz je formě tagu , protože tento odkaz se zobrazí, pokud není v internetovém prohlížeči nainstalovaný zásuvný modul pro podporu Silverlight aplikace.

- 30 -



8.7 Windows Phone 7 Je operační systém pro mobilní zařízení, jedná se o přímého následníka Windows Mobile. Windows Phone představuje konkurenci pro iOS od společnosti Apple a Android od společnosti Google. Pro vývojáře je Windows Phone 7 zajímavá technologie, protože nabízí dva naprosto odlišné způsoby psaní aplikací: Silverlight – je technologie, která se převážně používá pro vývoj aplikací. Jak již bylo zmíněno v předešlé kapitole, celý Silverlight je založen na WPF, a proto je vhodný pro vytváření sofistikovaných bohatých uživatelských rozhraní s využitím tradičních ovládacích prvků, vysoce kvalitního textu, vektorové grafiky, animací, médií, vázáním dat, atd. XNA – jak by se na první pohled mohlo zdát, že se jedná o zkratku tří anglických slov, tak tomu tak není. XNA je označení herní platformy společnosti Microsoft, která podporuje, jak 2D grafiku, tak 3D grafika s běžnou herní smyčkou. XNA se spíše používá pro vývoj her na Xbox 360 a PC, ale dá se použít i pro vývoj her na Windows Phone 7. (Henry Lee, 2010)

- 31 -



9. NÁVRH A ANALÝZA APLIKACE Na začátku kapitoly se budeme věnovat definování funkčních a nefunkčních požadavků na aplikaci, co uživatelé mohou od aplikace očekávat. V druhé polovině kapitoly se podíváme na třídní diagramy a rozdělení aplikace do tří vrstev, kterými jsou: GUI, aplikační logika a vstupně/výstupní operace.

9.1 Poţadavky na aplikaci Následující dvě tabulky představují všechny funkční a nefunkční požadavky kladené na aplikaci.

9.1.1 Funkční poţadavky Označení poţadavku

Popis

REQ01

Aplikace umožní vybrat vstupní soubor s příponou .Designer.cs pro převod do WPF

REQ02

Aplikace umožní vybrat výstupní cestu, kam se zapíše výsledný soubor

REQ03

Aplikace umožní převést formulář (ne kompletní výčet komponent a jejich vlastností) z WF do WPF

REQ04

Aplikace bude obsahovat okno pro zobrazení struktury vstupního souboru

REQ05

Aplikace bude umožnovat otevřít všechny uzly v náhledu

REQ06

Aplikace bude umožnovat zavřít všechny uzly v náhledu

REQ07

Aplikace bude umožnovat zobrazit jednotlivé vlastnosti komponent v náhledovém okně

REQ08

Aplikace umožní zobrazit náhled okna před samotných převedením vstupního souboru

REQ09

Aplikace bude obsahovat okno s výpisem všech dostupných zásuvných modulech

Tabulka 1 - Funkční požadavky aplikace

9.1.2 Nefunkční poţadavky Označení poţadavku

Popis

REQ01

Zdrojové kódy aplikace budou napsány v anglickém jazyce

REQ02

Uživatelské rozhraní bude v českém jazyce

REQ03

Aplikace bude lehce ovladatelná

REQ04

Aplikace bude snadno rozšiřitelná pomocí zásuvných modulů

REQ05

Aplikace bude podporovat operační systém Windows XP SP3 a vyšší

- 32 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation Tabulka 2 - Nefunkční požadavky aplikace

9.2 Diagram tříd

Obrázek 8 - Třídní diagram aplikace Zdroj: vlastní tvorba

- 33 -



10. IMPLEMENTACE 10.1 Zvolené technologie Aplikace je implementován za využití .NET Frameworku 4. Z této platformy je zvolen jako programovací jazyk C# a pro vytvoření okenní aplikace technologie Windows Presentation Foundation (WPF). Hlavním důvodem pro upřednostnění WPF před Windows Forms je fakt, že aplikace slouží pro převod Windows Forms do WPF. Další motivací byla funkčnost, která má za úkol zobrazit náhled převáděného okna. Tato funkčnost by obtížně implementovala ve Windows Forms.

10.2 Popis aplikace Celá aplikace je rozdělena do tří vrstev. Nejvyšší vrstva je prezentační, která tvoří uživatelské rozhraní. Součástí této vrstvy je hlavní okno aplikace MainWindow a PluginWindow. Další z vrstev je vrstva aplikační logiky, která se skládá z několika tříd a pluginů tzv. zásuvných modulů, pomocí kterých může být aplikace snadno rozšířena. Poslední a nejnižší vrstva je I/O vrstva, která zpracovává vstupy a výstupy celé aplikace. Při načtení vstupního souboru se pomocí třídy FormElementReader analyzuje vstupní soubor a na jeho základě se vytvoří objekt typu FormElement. Tento objekt nese všechny důležité informace o vstupním formuláři, jako jsou komponenty, které se na formuláři nachází, jejich hierarchická struktura a jejich vlastnosti. Objekt je dále vstupem pro dvě třídy, které s ním nadále pracují. První z těchto dvou tříd je TreeNodeCreator, která na jeho základě sestaví objekt typu TreeNode pro komponentu TreeView, která znázorňuje hierarchickou strukturu vstupního souboru. Druhou třídou, která využívá objekt FormElement je XamlBuilder. Jejím hlavním úkolem je na základě objektu sestavit XAML reprezentaci komponent. Tato reprezentace je nyní tvořena objektem typu XmlNode. Na závěr celého konverzního procesu se takto vytvořený XmlNode zapíše pomocí třídy XamlWriter na požadovanou cestu, kterou uživatel zadal. Zdrojové kódy celé aplikace viz. “Příloha 5 – CD“.

10.3 Podporovaní komponenty a vlastnosti pro převod Jak již, bylo zmíněno ve funkčních požadavcích na aplikaci, aplikace nebude podporovat kompletní seznam všech komponent pro převod, které Windows Forms nabízejí ale pouze jejich podmnožinu. A u těchto vybraných nejpoužívanější komponent nebudou podporovány všechny jejich vlastnosti, protože to by bylo nad rámec této práce, ale zase pouze jen

- 34 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation podmnožina těch nejvýznamnějších vlastností. Následující tabulka ukazuje podporované komponenty a jejich vlastnosti: Komponenta

Vlastnosti

Button

Name, Location, Size a Text

GroupBox


CheckBox

Name, Location, Size, Text a Checked

Label


RadioButton

Name, Location, Size, Text a Checked

TabControl

Name, Location a Size

TabPage


TextBox

Name, Location, Size, Text a ReadOnly

Tabulka 3 - Podporované komponenty pro převod do WPF a jejich vlastnosti Nyní známe popis vrstev aplikace, hlavního procesu aplikace, ale také požadavky na aplikaci kladené. A proto si teď přiblížíme detailní popis jednotlivých tříd aplikace.

10.4 Rozhraní aplikace 10.4.1 IControlCreator Je jediné, ale za to velmi důležité rozhraní celé aplikace. Protože je aplikace založená na zásuvných modulech (plugin) je důležité, aby všechny pluginy implementovali toto jednoduché rozhraní. Tato technika je známá jako State Pattern ze standartu GOF. IControlCreator definuje následující členy: 

string Name { get; } – Název zásuvného modulu. Název musí být shodný s typem komponenty ve Windows Forms. Jako příklad může být komponenta, která slouží pro zadávaní nebo zobrazování textu ve Windows Forms, a ta se nazývá TextBox. Z předešlých vět tedy plyne, že vlastnost Name bude v tomto případě mít hodnotu “TextBox”. Dodržovaní této jmenné konvence je jedním z důležitých pravidel pro správné fungování celé aplikace, protože když aplikace chce převést právě komponentu typu TextBox projde všechny zásuvné moduly a zkontroluje jejich vlastnost Name. Pokud existuje takový modul s touto hodnou s hodnou “TextBox” použije aplikace právě tento modul pro převod komponenty.



string Version { get; } – Verze zásuvného modulu.



string Description { get; } – Krátký popis zásuvného modulu.

- 35 -



XmlNode Create(FormElement element, IControlCreator creator) – Jediná metoda celého rozhraní, která z objektu typu FormElement vygeneruje jeho XML (XAML) reprezentaci.

Protože se v jednotlivých zásuvných modulech vyskytuje návrhový vzor Decorator, tak si tento vzor v krátkosti představíme.

10.4.1.1 Decorator Účel Umožňuje již existující objektům přidávat nové dynamické chování a vlastnosti bez nutnosti vytváření odvozené třídy. Návrh Rozhraní IComponent představuje společného předka, pro všechny objekty, které budou dekorovány. Třída Decorator zahrnuje ve svých privátních členech vlastnost typu IComponent, její jednota může být např. objekt typu Component. Ve třídě Decorator dále zavoláme metodu Operation nad objektem IComponent a dále metodu Operation objektu Decorator a tímto postupem změníme např. objektu typu Component chování nebo stav, aniž by sám o sobě o tom věděl. (Bishopová, 2010)

Obrázek 9 - UML diagram vzoru Decorator Zdroj: vlastní tvorba

- 36 -



10.4.1.2 Vyuţití vzoru Decorator v aplikaci Návrhový vzor Decorator můžeme najít u jednotlivých zásuvných modulů aplikace. Všechny pluginy implementují rozhraní IControlCreator, které odpovídá rozhraní IComponent z předešlé

ukázky.

V případě

zásuvných

modulů

jsou

„dekoruje“

objekt

typu

CommonAttributes všechny ostatní, kterými jsou např. ButtonCreator, LabelCreator, TextBoxCreator, atd. Vše si detailně popíšeme na příkladu s ButtonCreator. ButtonCreator vytvoří základní XML (XAML) tag, který je charakteristický pro tlačítko ve WPF a CommonAttribues tomuto tlačítku přidá všechny vlastnosti, které jsou společné pro všechny WPF komponenty. ButtonCreator neví, že se něco takového děje a CommonAttributes upravuje jeho vnitřní stav.

Obrázek 10 - UML diagram využití vzoru Decorator Zdroj: vlastní tvorba

10.5 Popis tříd prezentační vrstvy 10.5.1 MainWindow Jedná se o hlavní okno celé aplikace. Představuje rozhraní mezi vrstvou aplikační logiky a uživatelem. V horní části okna se nachází hlavní panel s kontextovými nabídkami. Dále Hlavní okno obsahuje dvě textová pole, která zobrazují vstupní cestu k souboru pro převod a výstupní cestu, kde bude převedený soubor uložen. Po načtení vstupního souboru se zobrazí hierarchická struktura komponent vstupního souboru v části “Detaily vstupního souboru“ na kartě “Rozložení souboru”. Druhá karta s názvem Log slouží pro výpis logovacího souboru. Poslední s důležitých prvků na Hlavním okně je tlačítko v dolní pravé

- 37 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation části okna, které slouží pro samotný převod vstupního souboru. Celé Hlavní okno s načteným vstupním soubor je zobrazeno na obrázku 11:

Obrázek 11 - Hlavní okno aplikace Zdroj: printscreen aplikace, vlastní tvorba

10.5.2 PluginWindow Druhé okno prezentační vrstvy je dialogové okno pro podporované doplňky. Dialogové okno se otevře z hlavního panelu záložka Nápověda a dále klepnutím na Podporované doplňky. V okně jsou vypsány všechny zásuvné moduly, kterými aplikace disponuje. U každého zásuvného modulu je uveden jeho název, verze a jeho popis. Dialogové okna s podporovanými doplňky je zachyceno na obrázku 12:

- 38 -



Obrázek 12 - Okno s podporovanými doplňky Zdroj: printscreen aplikace, vlastní tvorba

10.6 Popis jednotlivých tříd aplikační logiky 10.6.1 Constants Třída Constants je velice jednoduchá svojí implementací. Jedná se o statickou třídu. Obsahuje pouze velké množství vlastností, převážně typu string, které jak již název třídy napovídá, slouží jako centralizované uložiště všech konstant. Centralizované uložiště je zvoleno, aby bylo v budoucnu možné jednotlivé konstanty jednoduše změnit na jednom místě aplikace bez nutnosti přepisování všech hodnot v různých třídách aplikace.

10.6.2 ControlCreatorFactory Jedná se o jednu z klíčových tříd aplikace. Úkolem třídy je rozhodnou, který zásuvný modul se použije pro vytvoření XAML tagu z objektu FormElement. V konstruktoru třídy se načtou všechny zásuvné moduly do proměnné plugins pomocí třídy PluginManager. Třída ControlCreatorFactory je obsahuje pouze jedinou metodu a tou je FactoryMethod. public XmlNode FactoryMethod(FormElement element) { try { XmlNode result = null;

- 39 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation // Vytvoření XAML elementu podle typu elementu if (plugins.ContainsKey(element.Type) && plugins.ContainsKey("CommonAttributes")) { if (plugins[element.Type] is IControlCreator) { result = ((IControlCreator)plugins["CommonAttributes"]) .Create(element, (IControlCreator)plugins[element.Type]); } } return result; } catch (Exception ex) { // kód byl z důvodů přehlednosti odstraněn } }

Metoda vrací objekt typu XmlNode, který představuje XAML reprezentaci prvku na formuláři. FactoryMethod pracuje způsobem, že se podívá do proměnné plugins, jestli obsahuje potřebný zásuvný modul pro převedení prvku formuláře a plugin s obecnými vlastnostmi pro převod. Pokud proměnná plugins tyto zásuvný moduly neobsahuje, bude prvek ignorován a ve výsledném převedeném formuláři nebude zobrazen. Když je zásuvný modul nalezen a implementuje rozhraní IControlCreator zavolá se nad tímto zásuvným modulem metoda Create, která se postará o sestavení objektu typu XmlNode. A tento XmlNode je vrácen metodou.

10.6.3 Attribute Jedná se o abstraktní třídu, která slouží pro odvozování konkrétních typů, jako jsou ElementAttribute a FormAttribute. Tato třída je velice jednoduchá a obsahuje pouze dvě veřejné vlastnosti a těmi jsou: Name a Content. Vlastnost Name představuje název vlastnosti, jedno prvku formuláře. Touto vlastností může např. být: Text, Size, Location, atd. Zatímco vlastnost Content uchovává samotný obsah vlastnosti, která byla načtena ze vstupního souboru pro převod k názvu vlastnosti konkrétního prvku.

10.6.4 ElementAttribute Třída ElementAttribute je odvozená od abstraktní třídy Attribute. Typ ElementAttribute slouží pro uchovávání vlastností jednotlivých prvku formuláře. Příkladem může být tlačítko ve vstupním souboru s popiskem „Odešli objednávku“. Potom bude stav objektu ElementAttribute vypadat následovně: Vlastnost Name bude mít hodnotu Text a vlastnost Content bude obsahovat hodnotu typu string „Odešli objednávku“.

- 40 -



10.6.5 FormConverter FormConverter představuje vysokoúrovňové rozhraní pro převod vstupního formuláře z Windows Forms do WPF, které je založené na návrhovém vzoru Facade (vzor je popsán dále v textu). Tato třída v sobě zapouzdřuje následující typy: FormElementReader, TreeNodeCreator

a

XamlWriter.

Umožňuje,

přistup

k těmto

typům

pomocí

tří

jednoduchých metod a těmi jsou: RenderTreeView, ShowPreview a WriteXaml. Motivace k vytvoření této třídy bylo odlehčení tzv. code behind v hlavním formuláři aplikace MainWindow, kde se nyní reaguje na události prvků pouze pomocí voláním některé z tří výše uvedených metod.

10.6.5.1 Facade Účel Poskytnou uživateli vysokoúrovňové rozhraní např. na třídy, komponenty, subsystémy, systémy atd. Jejich detaily jsou buď uživateli záměrně skryty anebo slouží pouze k zjednodušení. Jednotlivé operace mohou byt sestaveny z různých prvků. Návrh Uživatel aplikace komunikuje pomocí Facade. Facade získává požadavky od uživatele. Tyto požadavky dále zasílá příslušným objektům, které tvoří její datové složky. Vzor Facade je rozhraní, ale je implementováno jako třída.

Obrázek 13 - UML diagram vzoru Facade Zdroj: vlastní tvorba

- 41 -



10.6.5.2 Vyuţití vzoru Facade v aplikaci V aplikaci můžeme nalézt návrhový vzor Facade implementovaný ve třídě FormConverter, kde vytváří rozhraní pro třídy: FormElementReader, TreeNodeCreator a XamlWriter. Využívá některých jejich metody a transformuje tyto metody do vysokoúrovňového rozhraní.

Obrázek 14 - UML diagram využití vzoru Facade Zdroj: vlastní tvorba

10.6.6 FormElement FormElement je klíčovou entitou celé aplikace. Představuje každý prvek (komponenta), který je umístěn na vstupním formuláři. Každý prvek se skládá s unikátních vlastností, které ho charakterizují a jinak tomu není ani u entity FormElement. Tato entity slouží pro zapouzdření všech podporovaných vlastností (atributů) u jednotlivých prvků formuláře. Vlastnosti entity FormElement jsou: 

IsOnFormElement – Je booleovská hodnota, která říká, jestli je prvek umístěn přímo na formuláři nebo je součástí nějakého kontejnerového prvku např. GroupBox, protože v případě, kdy je prvek uvnitř kontejnerového prvku je počátek jeho souřadnic v technologii WPF odlišný, než když je umístěn přímo na formuláři. Prvky gbDetails a tpCustomer budou mít tuto hodnotu nastavenou na true viz obrázek 15.



LevelOfNesting

–

Představuje

číselnou

hodnotu

zanoření

prvku

v jiných

kontejnerových prvcích. Tato vlastnost je nutná z důvodu korekce pozice prvku,

- 42 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation protože pozice je odlišná, pokud je prvek v jednou nebo třech GroupBoxech. Pro tlačítko btnUpdate bude tato hodnota 2 viz obrázek 15. 

ChildElement – Každý FormElement může obsahovat další FormElement entity (potomky), tímto způsobem je vytvořena odpovídající hierarchie prvků na formuláři. Pro prvek gbAddress budou jeho potomci lblFirstName, tbFirstName a btnUpdate viz obrázek 15.



Attributes – Hešovací tabulka, která uchovává všechny podporované vlastnosti pro převod prvku do WPF jako jsou jeho pozice, velikost atd.



Type – Reprezentuje typ prvku (komponenty) např. TextBox, GroupBox, Label atd.



Name – Název prvku na vstupním formuláři pro převod do WPF např. txtFirstName.

Obrázek 15 - Ukázka hierarchie komponent na formuláři Zdroj: vlastní tvorba

10.6.7 FormElementReader Třída FormElementReader je nejdůležitější třída celé aplikace, protože se tato třída stará o načtení vstupního souboru a sestavení objektu typu FormElement, který se používá v celé aplikaci. FormElement vzniká parsování vstupního souboru výrazů, který definuje uživatelské rozhraní Windows Forms. Parsuje se převážně pomocí regulárních výrazů a metod třídy String. Ukázka toho souboru se nachází v kapitole “8.3.2 Realizace Windows Forms”. Tento objekt je použit pro zobrazení náhledu výsledného okna, sestavení stromové struktury po načtení vstupního souboru a samozřejmě také pro sestavení výsledného XAML souboru.

- 43 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation FormElementReader je svojí implementací nejrozsáhlejší třída. Třída se skládá s jedné veřejné metody a tou je metoda GetFormHierarchy. Úkolem této metody je samotné vytvoření hierarchické struktury, jak je ukázáno na obrázku 13 - Ukázka hierarchie komponent na formuláři. Metodě při parsování pomáhá několik soukromých metod: 

GetNamespace – Metoda získá ze vstupního souboru jmenný prostor, v jakém se převáděný formulář nachází.



GetFormName – Metoda získá název vstupního formuláře.



GetChildElements – Metoda nalezne všechny potomky kontejnerové komponenty.



GetElementType – Metoda vyhledá jakého je typu převáděná komponenta.



GetElementAttributes – Metoda získá všechny atributy jednoho konkrétního elementu.

Nyní si přiblížíme implementace jednotlivých metod třídy FormElementReader.

10.6.7.1 GetNamespace Metoda je svojí implementací velice jednoduchá, jak již bylo napsáno, nalezne pouze jmenný prostor převáděného formuláře. Jmenný prostor je nalezen na základě jednoduchého regulárního výrazu, který vypadá následovně:

"namespace ([A-Za-z0-9]+(\.)?)+ " Takto nalezený jmenný prostor je následně metodou vrácen jako řetězec.

10.6.7.2 GetFormName Její implementaci je analogicky velice podobná metodě GetNamespace.

10.6.7.3 GetElementType Metoda přijímá jediný parametr a tím je objekt typu FormElement, pro který chceme zjistit typ. Pro nalezení typu metoda využívá následující regulární výraz: "this\.{0} = new System\.Windows\.Forms\.[A-Za-z]+" Složené

závorky s nulou

uprostřed

v regulárním

výrazu

jsou

nahrazeny

názvem

komponenty. Ukázkový řádek, které regulární výraz hledá: this.txtLabel = new System.Windows.Forms.TextBox(); S výše uvedeného řádku dále metoda odstraní všechny znaky až po poslední tečku a vrátí typ objektu jako řetězcovou hodnotu.

- 44 -



10.6.7.4 GetChildElements Úkolem metody je nalézt všechny vnořené komponenty v kontejnerovém prvku na základě názvu komponenty, který se předává jako parametr metodě. Ve vstupním souboru jsou komponenty přidávány do kontejnerového prvku následovně: this.grbDocumentOutline.Controls.Add(this.trvDocumentOutline); V uvedené ukázce se do komponenty typu GroupBox s názvem grbDocumentOutline přidává komponenta TreeView s názvem trvDocumentOutline. Tento způsob vkládání se pro všechny prvky stejný proto platí, že následující regulární výraz vyhledá všechny řádky, kde se do kontejnerové komponenty vkládají komponenty vnořené: "this\.{0}\.Controls\.Add\(this\.[A-Za-z0-9]+\)" Složené závorky s nulou jsou vždy nahrazený názvem komponenty, který se předává jako parametr metodě. Nalezené řádky se dále uříznou o nežádoucí znaky a nechá se pouze název komponenty. Vytvoří se objekt typu FormElement a jeho vlastnosti Name se nastaví na právě nalezený název komponenty. Pomocí metody GetElementType se zjistí typ komponenty a uloží se do vlastnosti Type objektu FormElement. Pokud se právě nalezeny prvek nachází přímo na formuláři, tak se vlastnost IsOnFormElement objektu typu FormElement nastaví na true, jinak false. Tato vlastnost je následně využívaná při korekci umísťování

ve

výsledné

WPF

reprezentaci

formuláře.

Dále

se

pomocí

metody

GetElementAttributes naleznou všechny atributy komponenty. Předposledním krokem je rekurzivní zavolání metody GetChildElements pro všechny nalezené komponenty. Posledním krokem je přidání sestaveného objektu typu FormElement do rodičovského seznamu potomků.

10.6.8 Logger Tato třída je navržena podle strukturálního návrhového vzoru Singleton, který bude obecně popsán i s detailním využitím ve třídě Logger později. Třída Logger slouží pro zapisování jednotlivých

klíčových

událostí do

výstupního

souboru,

který je

možno

nastavit

v konfiguračním souboru aplikace pod názvem logFile. Třída disponuje pouze dvěma statickými metodami pro zápis a čtení logovacího souboru. Ukázka kódu pro zápis do logovacího souboru aplikace. public static void Write(string logMessage) { using (FileStream fs = new FileStream(logPath, FileMode.Append)) { using (StreamWriter sw = new StreamWriter(fs)) { lock (padlock)

- 45 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation { sw.WriteLine(String.Format("{0} - {1}", DateTime.Now, logMessage)); } } } }

Ukázková metoda Write pro zápis do logovacího souboru přijímá jedený parametr a tím je text logovací zprávy, který se propíše do souboru. Zajímavostí na metodě je použití klíčového slova using jazyka C#, které deklaruje proměnou, jež je přístupná pouze ve složených závorkách. Takto inicializovaná proměnná musí implementovat rozhraní IDisposable, protože po ukončení příkazu using dojde k zavolání metody Dispose, která se uvolní veškeré prostředky pro Garbage Collector a není nutno uzavírat používané proudy. Uvnitř prvního příkazu using je deklarován proud pro připsání textové zprávy za veškerý text v již existujícím souboru. Samotný zápis do souboru je uzamčen zámkem, aby nemohlo dojít k situaci, kdy jedno vlákno aplikace bude např. zapisovat do souboru a druhé vlákno aplikace

bude

číst

soubor.

V tomto

případě

by

došlo

k vyvolání

výjimky typu:

System.IO.IOException.

10.6.8.1 Singleton Účel Účelem vzoru Singleton je zajistit, aby byla v aplikace pouze jediná instance daného typu a k této instanci existuje pouze jediný přístupový bod. Návrh Návrhový vzor Singleton je implementovaný pouze pomocí jediné třídy a tím je třída Singleton. Třída obsahuje jeden soukromý statický člen s názvem singleton, jedná se o instanci samotné třídy Singleton, která není vnějšímu okolí viditelná. Soukromý člen je dále statický, aby byl sdílený mezi všemi instancemi třídy a ne pouze v rámci jediné jeho instance. K členu se přistupuje pomocí veřejné metody GetInstace. Dále je konstruktor třídy privátní, aby nebylo možné k němu přistupovat z vnější.

- 46 -



Obrázek 16 - UML diagram vzoru Singleton Zdroj: vlastní tvorba

10.6.8.2 Vyuţití vzoru Singleton v aplikaci Vytvářecí návrhový vzor Singleton je v aplikaci použit pro implementaci třídy Logger, která se stará o zápis, čtená a smazaní logovacího souboru aplikace. Postup implementace vzoru Singleton je u této třídy trošku odlišný. Na rozdíl od obecné ukázky výše třída Logger obsahuje veřejný konstruktor, ve kterém se volá soukromá metoda GetInstance, aby se každé čtení nebo zápis do souboru omezil pouze na jediný řádek kódu a byla zachována struktura jedináčka. Zde je ukázka, jak probíhá zápis do logovacího souboru: Logger.Write("Zobrazení náhledu formuláře.");

Obrázek 17 - UML diagram využití vzoru Singleton Zdroj: vlastní tvorba

10.6.9 LogWatcher Pokaždé, když jakákoliv z tříd v programu zapíše do logovacího souboru, změní se tím i velikost souboru na harddisku. A právě sledování změny velikosti logovacího souboru je hlavní úkol třídy LogWatcher, respektive její metoda Watch. Třída obsahuje privátní metodu

- 47 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation PrivateWatch, aby bylo možné jednoduše v metodě Watch spustit metodu PrivateWatch ve svém vlastním vlákně. Když dojde ke změně velikosti “hlídaného” souboru dojde ke spuštění události LogChanged.

10.6.10 PluginManager Jedním z požadavků na aplikaci je její snadná rozšiřitelnost a nahrazení stávajících knihoven (pluginů - *.dll souborů) za novější verzi bez rekompilace zdrojových kódů aplikace. Aby byl tento požadavek splněn, musela vzniknout třída PluginManager, jejíž starostí je při spuštění aplikace načíst všechny pluginy, které se nacházejí v potřebné složce. Umístění této složky je možno nastavit přes konfigurační soubor aplikace, jedná se o vlastnost s názvem sourceFolder. PluginManager implementuje pouze jedinou metodu pro načtení všech pluginů a vracení výsledku ve formě datové struktury Slovníku (Dictionary). Jako klíč je použit název pluginu a hodnota je vytvořená instance typy IControlCreator. Ukázka metody Load pro načtení pluginů: public Dictionary<string, IControlCreator> Load(string folder) { try { string[] dllFiles = Directory.GetFiles(folder, DLL_EXTENSION); foreach (string dllFile in dllFiles) { Assembly assembly = Assembly.LoadFrom(dllFile); foreach (Type type in assembly.GetTypes()) { if (type.GetInterface(INTERFACE_NAME) == typeof(IControlCreator)) { IControlCreator plugin = Activator.CreateInstance(type) as IControlCreator; plugins.Add(plugin.Name, plugin); } } } return plugins; } }

Celá výše uvedená metoda je naimplementována pomocí tzv. reflexe. Pomocí reflexe můžeme za běhu programu dynamicky zjišťovat informace o existujících typech nebo např. vytvářet jejich instance jako je to i v následující metodě. Metoda pro načtení všech pluginů přijímá jediný parametr a tím je složka, ve které se nacházení pluginy pro načtení. Pomocí statické metody Directory.GetFiles z jmenného prostoru System.IO vyhledáme všechny soubory s příponou *.dll ve zvolené složce a cesty k těmto souborům si uložíme do

- 48 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation proměnné dllFiles. Ve smyčce procházíme všechny nalezené soubory, které splnily výše uvedené podmínky a načítáme každý soubor do sestavení. Pro každé sestavení si načteme všechny typy, které se v daném sestavení nachází a otestujeme je, zda implementují rozhraní IControlCreator. Jestli toto rozhraní implementuje právě procházený typ, potom vytvoříme instanci tohoto typu a uložíme instanci do výsledné datové struktury slovníku pod klíč, kterým je název pluginu. (Watson, 2010)

10.6.11 TreeNodeCreator Třída TreeNodeCreator slouží pro vytváření objektu TreeViewItem, který reprezentuje náhled stromové struktury v komponentě TreeView. Metoda obsahuje celkem tři metody z toho pouze jedna je veřejná a zbylé dvě jsou soukromé. Veřejná metoda MakeTree vytváří samotný strom hierarchie elementů na formuláři za pomocí dvou soukromých metod ConvertElementToTreeNode a MakeTreeViewItem. Tato metoda přijímá pouze jedený parametr a tím je logická pravda či nepravda, jestli se u každého z prvků formuláře mají zobrazit jeho vlastnosti jako potomci tohoto uzlu. První ze dvou soukromých metod je ConvertElementToTreeNode, která slouží pro rekurzivní (pojem rekurze viz. Rekurze níže) vytvoření hierarchie formuláře. Druhá je privátní metoda s názvem MakeTreeViewItem, která je volána z první soukromé metody ConvertElementToTreeNode, metoda má za úkol vytvořit jeden konkrétní uzel pro komponentu TreeView. Tento uzel se skládá z ikony a názvu prvku, název v sobě skrývá typ prvku a za pomlčkou následuje jeho původní název.

10.6.11.1 Rekurze V imperativním programování můžeme za pomocí rekurze v metodě volat tuto samotnou metodu opakovaně, aniž by došlo k ukončení přechozího volání. Důležitou součástí rekurze je ukončovací podmínka, aby nedošlo k vytvoření nekonečného cyklu.

10.6.12 TreeViewManagment TreeViewManagment patří mezi jednodušší třídy aplikace. Obsahuje pouze dvě metody a to ExpandAllItems a CollapseAllItems. V klasických WinForms aplikací, k

de je

komponenta TreeView s vlastností Expand, která nám umožnuje po nastavení hodnoty na true rekurzivně otevřít všechny elementy uzlu. Obdoba této vlastnosti ve WPF chybí, a proto je zde třída TreeViewManagment, která nám toto otevření a zavření uzlů zajistí. Ukázka kódu pro otevření všech uzlů elementu: public static void ExpandAllItems(this ItemCollection items) { foreach (TreeViewItem item in items) { item.IsExpanded = true;

- 49 -



if (item.HasItems) ExpandAllItems(item.Items); } }

Metoda je napsána jako tzv. rozšiřující, to nám umožní zavolat metodu přímo na kolekci typu ItemCollection. Metoda ve smyčce prochází všechny jednotlivé prvky kolekce a nastavuje jejich vlastnost IsExpanded na true, která se stará o otevření uzlu. Jestli prvek obsahuje další uzly jako svoje potomky, potom se rekurzivně volá metoda nad těmito potomky. Opačná metoda CollapseAllItems, která všechny položky zavře, pracuje obdobným způsobem, ale analogicky opačným.

10.6.13 XamlBuilder Třída XamlBuilder je svojí implementací jedna z jednodušších tříd aplikace. Obsahuje pouze jedinou metodu Build. Tato metoda se stará o vytvoření celé hierarchické struktury XAML souboru. Metoda Build využívá rekurzivní algoritmus k poskládání celé struktury. Více o rekurzi v kapitole “10.6.11 TreeNodeCreator”. V prvním volání metody Build dojde k nastavení proměnné parentNode na XmlNode jehož vnitřní tag nese název Window. Dále se v metodě projdou všechny potomci elementu Window a dojde k jejich převedení na XAML reprezentaci pomocí metody FactoryMethod. Zkontroluje se, jest-li výsledný navrácený objekt se nerovná hodnotě null. Táto hodnota je metodou FactoryMethod vrácena v případě, že komponenta není podporována převodem (neexistuje zásuvný modul pro převod této komponenty z Windows Forms) nebo došlo k chybě během převodu. Pokud je výsledný objekt typu XmlNode odlišný od null hodnoty, importuje se pomocí objektu doc. Pokud by nedošlo k tomuto importu, byla by vyvolána výjimka, která říká, že XmlNode je jiného původu a následně by nemohl být vložen do rodičovského XmlNodu. Další z podmínek zjišťuje, jestli je rodičovský uzel kontejnerový tag. Musí platit podmínka, že obsahuje potomka a tento potomek musí mít zároveň název “Grid”. Pokud je tato podmínka splněna přidáme převedený XmlNode do elementu Grid rodičovského uzlu. Jinak se vloží za poslední uzel v rodičovském uzlu. Celá metoda Build je dále rekurzivně volána s parametry potomka. Na závěr je rodičovský objekt typu XmlNode vrácen pomocí klíčového slova return.

10.6.14 XamlWriter Jedná se o nepříliš rozsáhlou a jednoúčelovou třídu pro zápis výsledného XAML do souboru. Třída obsahuje pouze jednu privátní a jednu veřejnou metodu. Privátní metoda s názvem GetDefaultTemplateData nedělá nic jiného, než že načte text ze souboru, který slouží jako šablona pro vygenerované okno. Obsah šablony je následující: <Window

- 50 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="{2}" Height="{3}" Width="{4}">

V šabloně je vidět rodičovský element Windows, který obsahuje výchozí direktivy při vytvoření okenní aplikace ve WPF. V tagu Windows se dále nacházení vlastnosti: Title, Height a Width, jejíž hodnoty budou později nastaveny na konkrétní hodnoty. Poslední je tag Grid, jehož obsah bude tvořit vygenerovaný XML (XAML) aplikací. Veřejná metoda Write se v aplikaci používá pro dva případy: 1. Vytvoření dočasného souboru s příponou .dat pro funkčnost Zobrazení náhledu, která soubor načte a zobrazí okno. 2. Pro zapsání výsledného XAML do souboru. Metoda Write přijímá dva parametry path typu string – cesta, kde se výsledný soubor zapíše a objekt typu FormElement – nese všechny důležité informace o vstupním formuláři pro převod. Pokud je parametr path nastaven na hodnotu null, tak je metoda Write využita k vytvoření dočasného souboru s příponou .dat, který se vytvoří ve složce s aplikací. Uvnitř těla metody se otevře proud pro zápis do souboru na zvolené cestě. Pomocí soukromé metody se načte výše uvedená šablona pro zápis do lokální proměnné typu XmlDocument s názvem doc. Po načtení šablony se nastaví konkrétní hodnoty vlastností tagu W indow podle vstupního parametru metody form

v proměnné doc. Další důležitý krok je sestavení

samotného XML (XAML) kódu pro zápis pomocí třídy XamlBuilder. Když je XAML kód vygenerován je zapsán do tagu Grid unitř proměnné doc. Na závěr se vše pomocí metody Save objektu doc zapíše do souboru.

- 51 -



11. DOKUMENTACE 11.1 Uţivatelská dokumentace V rámci uživatelské dokumentace se seznámíme se všemi funkčnostmi, které aplikace nabízí.

11.1.1 Načtení vstupního souboru Pro vybrání vstupního souboru vybereme s hlavní lišty ze záložky “Soubor” položku “Otevřít…”. Ukázky možných vstupních souborů viz. “Příloha 1“ a “Příloha 3” Vše demonstruje obrázek.

Obrázek 18 - Výběr vstupního souboru Zdroj: printscreen aplikace, vlastní tvorba Po klepnutí na položku “Otevřít…” se zobrazí dialogové okno pro vybrání souboru s příponou *.Designer.cs. Vše demonstruje následující obrázek.

- 52 -



Obrázek 19 - Dialogové okno pro výběr vstupního souboru Zdroj: printscreen aplikace, vlastní tvorba Po načtení vstupního souboru se aktualizuje textové pole s cestou ke vstupnímu souboru (1) a v části formuláře s názvem “Detaily vstupního souboru” se zobrazí stromová struktura načteného formuláře (2).

Obrázek 20 - Aktualizované hlavní okno po načtení vstupního souboru Zdroj: printscreen aplikace, vlastní tvorba

- 53 -



11.1.2 Zobrazení náhledu Pro zobrazení náhledu výsledného převedeného okna do WPF se zobrazí po klepnutí na položku “Zobrazit náhled…” (1) ze záložky “Náhled” hlavní lišty aplikace, poté se zobrazí samotný náhled okna (2). Vše demonstruje následující obrázek.

Obrázek 21 - Zobrazení náhledu převáděného formuláře Zdroj: printscreen aplikace, vlastní tvorba

11.1.3 Převedení formuláře Pro úspěšné převedení vstupního formuláře je potřeba provést výběr vstupního souboru podle kapitoly “11.1.1 Načtení vstupního souboru”. Dále je potřeba vybrat výstupní cestu, kde bude převedený soubor uložen. Výběr se provede vybráním položky “Výstupní cesta…” ze záložky “Soubor” (1), následně se zobrazí dialogové okno pro vybrání výstupní cesty (2).

- 54 -



Obrázek 22 - Výběr výstupní cesty Zdroj: printscreen aplikace, vlastní tvorba Posledním krokem po vybrání vstupního souboru a výstupní cesty je klepnutí na tlačítko “Convert Now”. Pokud dojde k úspěšnému převedení formuláře, zobrazí se dialogové okno se zprávou o úspěšném převedení. Ukázky již převedených formulářů viz. “Příloha 2” a “Příloha 4”.

11.2 Programátorská dokumentace V následující si představíme ukázkové vytvoření pluginu pro převod textového pole.

11.2.1 Vytvoření ukázkového pluginu pro TextBox V následující části si ukážeme, jak naimplementovat zásuvný modul pro aplikaci, pomocí kterého přidáme aplikaci funkčnost převádět textová pole. Každý plugin pro aplikaci ConvertingWFIntoWPF představuje samostatný projekt v Microsoft Visual Studio typu Class Library. Uvnitř toho projektu se nachází pouze jedna třída, která bude sloužit pro převod komponenty v našem případě pojmenovaná TextBoxCreator, protože se bude převádět komponenty

typu

TextBox.

Třída

TextBoxCreator

musí

implementovat

rozhraní

IControlCreator, které zaručí, že třída bude obsahovat všechny potřebné členy pro převod. Detailní popis tohoto rozhraní viz. kapitola 10.3.1 IControlCreator. Následující obrázek ilustruje pouze všechny členy rozhraní IControlCreator.

- 55 -



Obrázek 23 - Rozhraní IControlCreator Zdroj: vlastní tvorba

11.2.1.1 Implementace vlastnosti Name Vlastnost Name tedy v zásuvném modulu pro převod komponent typu TextBox má hodnotu “TextBox”. Její implementace potom vypadá následovně: public string Name { get { return "TextBox"; } }

11.2.1.2 Implementace vlastnosti Version Další vlastnost s názvem Version je pouhé číselné označení verze zásuvného modulu, které volí sám vývojář podle stádia vývoje, v jakém se zásuvný modul nachází. Číselné verzování se opírá o standard společnosti Microsoft. Celé číslo verze se skládá ze čtyř čísel, které jsou odděleny tečkami. Příklad takového číslování může být verze 7.3.4206.1500. První číslice je označení primární verze, druhá číslice udává sekundární verzi, třetí číslice označuje číslo sestavení (build) a poslední čtvrtá číslice opravný baličky a hotfixy. V našem případě lze říct, že verze obsahuje opravný balíček číslo 1 a 500 hotfixů. (XXX.XXX.XXX.1500). Implementace vlastnosti Version vypadá následovně: public string Version { get { return "2.95.125.1200"; } }

11.2.1.3 Implementace vlastnosti Description Poslední vlastnost rozhraní je Description. Tato vlastnost slouží pouze ke krátkému popisu zásuvného modulu. Všechny tři výše uvedené vlastnosti se zobrazují v dialogovém okně “O Doplňcích…”, viz. kapitola 10.5.2.

- 56 -



11.2.1.4 Implementace metody Create Metoda Create slouží pro vytvoření XAML (XML) tagů Windows Forms komponent. Na začátku implementace každé metody Create se vytváří objekt typu XmlDocument, který představuje XAML tag pro WPF. XmlDocument doc = new XmlDocument(); XmlNode node = doc.CreateElement(Constants.CTRL_TEXTBOX); Metoda doc.CreateElement(Constants.CTRL_TEXTBOX)

vytvoří v objektu doc XML

element, který vypadá následovně: Pro každou komponent jsou typické naprosto odlišné vlastnosti, pro textové pole jsou to např. vlastnosti Text – jedná se o text, který je v textovém poli již předvyplněný a ReadOnly – hodnota v textovém poli slouží pouze pro čtení a nelze zadávat vlastní text. Zásuvný modul pro převod komponenty TextBox bude tedy podporovat tyto dvě vlastnosti, které jsou pro něj klíčové. Přidání podpory pro předvyplnění textového pole textem stačí pouze XAML elementu přidat atribut s názvem “TEXT”. Celé přidání vypadá následovně: if (element.Attributes.ContainsKey(Constants.ATTR_TEXT)) { XmlAttribute ctrlText = doc.CreateAttribute(Constants.ATTR_TEXT); ElementAttribute text = ElementAttribute)element.Attributes[Constants.ATTR_TEXT]; ctrlText.Value = text.Content.ToString(); node.Attributes.Append(ctrlText); } V podmínce se zjistí, jest-li objekt typy FormElement obsahuje vlastnost s názvem “Text”, pokud takovou vlastnosti obsahuje, dojde k vytvoření XML atributu s názvem Text. Atributu se nastaví hodnota, která odpovídá hodnotě vlastnosti Text objektu FormElement. A celý atribut se přidá do objektu doc. Výsledný objekt doc po přidání atributu potom vypadá následovně: Druhá vlastnosti, kterou bude zásuvný modul pro převod textového pole podporovat je vlastnost ReadOnly. Aby bylo textové pole ve WPF pouze ke čtení stačí XAML elementu přidat pouze vlastnost ReadOnly s hodnou true. Ukázka zdrojového kódu pro přidání odpory vlastnosti ReadOnly: if (element.Attributes.ContainsKey(Constants.ATTR_READ_ONLY))

- 57 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation { XmlAttribute ctrlReadOnly = doc.CreateAttribute(Constants.ATTR_IS_READ_ONLY); ElementAttribute readOnly = (ElementAttribute)element.Attributes[Constants.ATTR_READ_ONLY ]; ctrlReadOnly.Value = readOnly.Content.ToString(); node.Attributes.Append(ctrlReadOnly); } Přidání vlastnosti ReadOnly textovému poli je analogické jako v případě vlastnosti Text. Výsledný objekt doc po přidání vlastnosti ReadOnly vypadá následovně: Takto vytvořený zásuvný modul stačí překompilovat a vložit do příslušné složky v aplikaci, ve které se nachází zásuvné moduly. Ve výchozím nastavení aplikace se zásuvné moduly nachází ve složce s názvem source. Avšak název složky, která slouží pro zásuvné moduly, se může lehce změnit v konfiguračním souboru aplikace.

- 58 -



12. ZÁVĚR V rámci práce byla naimplementována aplikace pro převod formuláře s Windows Forms do novější technologie Windows Presentation Foundation (WPF), které jsou součástí Microsoft .NET Frameworku. Aplikace je naimplementovaná pomocí objektově orientovaného programovacího jazyka C# za využití právě WPF, která umožňuje lehce zobrazit náhled výsledného okna oproti Windows Forms. Aplikace demonstruje snadné přizpůsobení všech formulářových prvků ve WPF. Aplikace umožňuje vybrat vstupní soubor (s příponou .Designer.cs), který deklaruje uživatelské rozhraní a převést tento soubor na jeho, co možná nejvěrohodnější reprezentaci ve WPF pomocí značkovacího jazyka XAML. WPF využívá XAML jako značková jazyk pro deklarování uživatelského rozhraní. Pomocí jazyka XAML umožňuje oddělit definici uživatelského rozhraní od aplikační logiky aplikace. Aplikace dále umožňuje např. zobrazení hierarchické struktury vstupního souboru, zobrazení náhledu okna, vybrání cesty, kde bude výsledný převedený soubor uložen atd. Aplikace nepodporuje všechny komponenty Windows Forms, ale pouze vybranou množiny těch nejpoužívanějších a nejrozšířenějších, jako jsou např. textové pole, popisek, tlačítko, přepínatko atd. U každé z těchto komponent aplikace

opět

podporuje

pouze

vybranou

množinu

jejich

vlastností.

Jeden

z

hlavních požadavků na implementaci byla snadná rozšiřitelnost. A proto je veškerá aplikační logika soustředěna do zásuvných modulů. Moduly jsou prezentovány knihovnami typu .dll. Ke každé komponentě, kterou má aplikace podporovat musí existovat zásuvný modul. Pomocí těch zásuvných modulů může být aplikace snadno rozšířena bez rekompilace zdrojových kódu celé aplikace. Stačí pouze vytvořit nový zásuvný modul pro novou komponentu, kterou má aplikace podporovat a nahrát tento modul do složky určené pro tyto zásuvné modulu a aplikace bude při dalším spuštění podporovat i tuto komponentu. Během vývoj aplikace se zjistilo, že jedním z největších problému, se kterými se na začátku vůbec nepočítalo je umisťování prvků ve WPF. Celý problém začíná už ve velikosti formuláře. Formulářová aplikace o velikosti 500x500 pixelu ve Windows Forms vůbec neodpovídá formulářové aplikace o stejné velikosti ve WPF. To samé platí i o samotných komponentách ve WPF. Každá komponenta ve WPF nese naprosto jiný souřadnicový počátek, než jak je tomu u obdobné komponenty ve Windows Forms. Další z možných problémů, který může nastat nejen u umísťování komponent na jejich pozice, ale u všeobecné analýzy jejich vlastností pro převod je dynamická úprava těchto vlastností z kódu na pozadí aplikace. Např. v implementaci konstruktoru formuláře může být umístěný kód, který dynamicky nastavuje vlastnosti formuláře na základě nějakého parametru předaného v konstruktoru. Další z faktorů, které znemožňují přímou konverzi Windows Forms do WPF je, že ne všechny komponenty z Windows Forms jsou ve WPF zastoupeny.

- 59 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation Cest, kterými by se mohl budoucí vývoj aplikace ubírat, je mnoho. Prvním z možných vylepšení aplikace je samotné vylepšení umísťování prvků na formulář ve výsledném XAML souboru. Dále by se mohli vyvíjet zásuvné moduly pro podporu dalších komponent z Windows Forms. Aplikace by se mohla rozšířit na převádění celých projektů a nejen pouze jednotlivých formulářů. V dalších verzích by aplikace mohla přinést i podporu pro převádění kódu na pozadí formulářů. A nakonec také podporu databindingu (vázání dat na komponenty z různých datových zdrojů např. databáze nebo XML). Aplikace by mohla najít své uplatnění v malých a středních firmách, které vlastní informační systémy, které jim byla navrženy na míru a chtějí je modernizovat. Aplikace by ušetřila značné náklady na vývoj informačního systému, protože by nemusel být vyvíjen od začátku.

- 60 -



13. CONCLUSION During this Bachelor’s Thesis has been developed application for converting form from Windows Forms technology into newer technology called Windows Presentation Foundation. Both technologies are part of .NET Framework. Application has been developed using object-oriented C# programming language together with WPF. WPF is used because it is easier to implement preview of converted form in WPF then in Windows Forms. Application also demonstrates customization of all form controls. Application allows user to select input file (with extension .Designer.cs) which defines user interface in Windows Forms technology and convert this file into its WPF representation as credible as possible. WPF uses XAML as declarative language for defining user interface. XAML allows to application easily separate definition of user interface from application logic. This application offers user following: display hierarchical structure of input file, display windows preview, select path, where the output file would be saved and so on. Application doesn’t support all Windows Forms controls for converting but there is just select set of the most used controls. Among these controls are textbox, label, button, checkbox and so on. At every control application supports selected set of its attributes. One of the most important requirements for application was extensibility. That’s why all application logic for converting controls is centered in plugins. Plugins are represented like *.dll libraries. For each control that application supports must be plugin. Using these plugins can be application easily extended without recompiling all the source code. Simply another plugin can be implemented which should support application for converting and put this plugin into folder which contains these plugins and when the application starts again it will use this new plugin for converting. During application development, it was found that one of the biggest problems faced at the beginning of no account is placing control in WPF. The whole problem starts at the size of the form. Windows Forms application with dimensions 500 x 500 pixel doesn’t correspond to the application of the same size in WPF. And the same is true for WPF controls. Every WPF control has different zero coordinates then its same control in Windows Form technology. Another big problem not only for positing the controls is dynamic assigning of their attributes. Controls’ attributes can be set from code behind. For example inside the constructor of form can be placed some parameter which is used to set some control attribute. Another one of facts that complicates straight conversion of Windows Forms into WPF is that there are not all available controls in WPF to represent Windows Forms controls. There are many paths which could be the future development of application. The first of the possible enhancements to the application is better control placing in output XAML file. Next plugins could be also developed to support more Windows Forms control for conversion. Conversion could be spread to support whole projects and not only file which defines user

- 61 -


Převod Windows Forms do Windows Presentation Foundation Converting Windows Forms into Windows Presentation Foundation interface. Later stages of development could bring support of converting code behind files. And finally application could be able to convert controls with data binding values. Application could find its place in small and medium companies which own information systems designed to order and they want to modernize them. Application would save a lot of costs because the information system won’t be developed from begin.

- 62 -



14. SEZNAM POUŢITÉ LITERATURY 1. SHARP, John. Microsoft Visual C# 2005 Krok za krokem. Brno: Computer Press, 2006. 528 s. ISBN 80-251-1156-3. 2. BISHOPOVÁ, Judith. C# návrhové vzory. Brno: Zoner Press, 2010. 328 s. ISBN 978-80-7413-076-2. 3. NAGEL, C., EVJEN, B., GLYNN, J., SKINNER, M., WATSON, K. C# 2008 Programujeme profesionálně. Brno: Computer Press, 2009. 1898 s. ISBN 978-80251-2401-7. 4. ARLOW, J., NEUSTADT, I. UML2 a unifikovaný proces vývoje aplikací. Brno: Computer Press, 2007. 563 s. ISBN 978-80-251-1503-9. 5. WATSON, Ben. C# 4.0 HOW-TO. Indianapolis: SAMS, 2010. 653 s. ISBN 978-0672-33063-6. 6. NATHAN, Adam. WPF 4 Unleashed. Indianapolis: SAMS, 2010. 825 s. ISBN 978-0672-33119-0. 7. MACDONALD, Matthew. Pro WPF in C# 2008. New York: Apress, 2008. 1040 s. ISBN 978-1-4302-0576-0. 8. LAIR, Robert. Beginning Silverlight 4 in C#. New York: Apress, 2010. 395 s. ISBN 978-1-4302-2989-6. 9. LEE, H., CHUVYROV, E. Beginning Windows Phone 7 Development. New York: Apress, 2010. 458 s. ISBN 978-1-4302-3217-9. 10. NASH, Trey. Accelerated C# 2010. New York: Apress, 2010. 627 s. ISBN 978-14302-2538-6 11. What is Mono [online], http://www.mono-project.com/What_is_Mono

- 63 -



15. SEZNAM POUŢITÝCH SYMBOLŮ A ZKRATEK Zkratka

Popisek

WF

Windows Forms

WPF

Windows Presentation Foundation

XAML

Extensible Application Markup Language

XML

Extensible Markup Language

REQ

Požadavek

GUI

Graphic User Interface

API

Application Programming Interface

CLR

Common Language Runtime

MSVS

Microsoft Visual Studio

DPI

Dots Per Inch

RIA

Rich Internet Application

- 64 -



16. SEZNAM OBRÁZKŮ Obrázek 1 - Vývoj programování aplikací pro systém Windows ........................................ - 14 Obrázek 2 - Vývoj .NET Frameworku ................................................................................ - 16 Obrázek 3 - Ukázka formuláře z technologie Windows Forms .......................................... - 19 Obrázek 4 - Ukázka okna s bohatým uživatelským rozhraní vytvořeného ve WPF .......... - 21 Obrázek 5 - Vývoj technologie WPF v závislosti na čase .................................................. - 24 Obrázek 6 - Silverlight RIA aplikace .................................................................................. - 27 Obrázek 7 - Běžná HTML stránka ..................................................................................... - 28 Obrázek 8 - Třídní diagram aplikace .................................................................................. - 33 Obrázek 9 - UML diagram vzoru Decorator ....................................................................... - 36 Obrázek 10 - UML diagram využití vzoru Decorator .......................................................... - 37 Obrázek 11 - Hlavní okno aplikace .................................................................................... - 38 Obrázek 12 - Okno s podporovanými doplňky ................................................................... - 39 Obrázek 13 - UML diagram vzoru Facade ......................................................................... - 41 Obrázek 14 - UML diagram využití vzoru Facade.............................................................. - 42 Obrázek 15 - Ukázka hierarchie komponent na formuláři ................................................. - 43 Obrázek 16 - UML diagram vzoru Singleton ...................................................................... - 47 Obrázek 17 - UML diagram využití vzoru Singleton .......................................................... - 47 Obrázek 18 - Výběr vstupního souboru ............................................................................. - 52 Obrázek 19 - Dialogové okno pro výběr vstupního souboru .............................................. - 53 Obrázek 20 - Aktualizované hlavní okno po načtení vstupního souboru ........................... - 53 Obrázek 21 - Zobrazení náhledu převáděného formuláře ................................................. - 54 Obrázek 22 - Výběr výstupní cesty .................................................................................... - 55 Obrázek 23 - Rozhraní IControlCreator ............................................................................. - 56 -

- 65 -



17. SEZNAM TABULEK Tabulka 1 - Funkční požadavky aplikace ........................................................................... - 32 Tabulka 2 - Nefunkční požadavky aplikace ....................................................................... - 33 Tabulka 3 - Podporované komponenty pro převod do WPF a jejich vlastnosti ................. - 35 -

- 66 -



18. SEZNAM PŘÍLOH 1. Příloha 1 – Ukázka formuláře SampleForm1 ve WF 2. Příloha 2 - Ukázka převedeného SampleForm1 do WPF 3. Příloha 3 – Ukázka formuláře SampleForm2 ve WF 4. Příloha 4 - Ukázka převedeného SampleForm2 do WPF 5. Příloha 5 – CD

- 67 -



18.1 Příloha 1 – Ukázka formuláře SampleForm1 ve WF

- 68 -



18.2 Příloha 2 - Ukázka převedeného SampleForm1 do WPF

- 69 -



18.3 Příloha 3 – Ukázka formuláře SampleForm2 ve WF

- 70 -



18.4 Příloha 4 - Ukázka převedeného SampleForm2 do WPF

- 71 -



18.5 Příloha 5 – CD CD je přiloženo u tištěné verze bakalářské práce. Adresářová struktura CD: 

Složka Aplikace o



Složka Bakalářská práce o



Obsahuje finální verzi aplikace pro převod Windows Forms do WPF

Obsahuje digitální verzi bakalářské práce ve formátu .docx a .pdf

Složka Zdrojové kódy o

Obsahuje kompletní projekt aplikace pro Microsoft Visual Studio 2010 Ultimate

- 72 -

BAKALÁŘSKÁ PRÁCE. Převod Windows Forms do Windows Presentation Foundation. Converting Windows Forms into Windows Presentation Foundation

Recommend Documents