Javascript és az osztályok

Helló!

Javascript-ben háromféleképpen hozhatunk létre osztályokat, ezeket foglyuk most végignézni. Fontos azonban megjegyezni, hogy osztályok nincsenek javascriptben, függvényekkel tudjuk szimulálni azokat.

1. Függvényt használva

Létrehozunk egy egyszerű függvényt majd létrehozunk belőle egy objektumot a new kulcsszóval. Példa:

 function Teglalap(a,b){
     this.a = a;
     this.b = b;
     this.kerulet = getKerulet;
}

//a getKerulet lehet a Teglalap fuggvenyen belul is
function getKerulet(){
     return (a + b)*2;
}

Példányosítás(és kiírás konsolra):

var t = new Teglalap(2,3);
consol.log(t.kerulet);

2. Osztályok definiálása Objektumváltózókkal

Ez egy gyorsabb megoldás, kihagyhatjuk az objektum példányosítását és egyből definiáljuk azt:

var teglalap{
   a: 0,
   b: 0,
   kerulet: (a+b)*2
}

teglalap.a = 2;
teglalap.b = 2;

conslo.log(teglalap.kerulet);

3. A kettő keveréke

A Harmadik módszer gyakorlatilag a fenti kettő kombinációja:

var teglalap = new function(){
    this.a = 2;
    this.b = 3;
    this.kerulet = function getKerulet(){ // a getKerulet lehet a fuggvenyen kivul is
        return (a + b)*2; }
}

//valtozok elerese
teglalap.a = 5;
consol.log(teglelep.kerulet);

Röviden ennyit a Js osztályokról.

Üdv.:
Balázs

Mozgás (Javascript)

Helló!

Lássuk hogyan is tudunk mozgásra bírni dolgokat a képernyőn html5-öt és js-et használva.

Hozzunk létre egy új Javascript blank app projektet és nyissuk meg a default.html fájlt, majd hozzunk létre benne két gombot “Move” (ennek hatására elindul az animációnk) és “Stop” (ez pedig megállítja) névvel és hozzuk létre a canvasunkat is.

<button onclick="m.m1()">Move</button>
<button onclick="m.m2()">Stop</button>
<canvas id="canvas"></canvas>

(az onclickről később)

Ha ezzel megvagyunk jöhet is a default.js. Nyissuk meg a fájlt majd hozzunk létre néhány szükséges változót

var canvas, context;    // canvas inicializalasahoz kell
var a = 250;    // a kor kozeppontjanak y koordinataja
var b = 1;      // jobbra vagy balra mozogjon a kor
var x = false;  // van mozgas vagy nincs

Ezután hozzuk létre az “initialize()” függvényünket amiben létrehozzuk a canvas-t és az animációkat amit a következő képpen tudunk megtenni:

window.onload = initialize;
function initialize() {
canvas = document.getElementById("canvas");
canvas.width = window.innerWidth;    //canvas szelessege kepernyo szeles
canvas.height = window.innerHeight;  //canvas szelessege kepernyo magas
context = canvas.getContext("2d");

//ketfele keppen hozhatunk letre animaciot
requestAnimationFrame(move);  // canvas ujrarajzolasa 1
setInterval(function () { redraw()}, 6); // canvas ujrarajzolasa 2
}

Akkor most irjuk meg a move() es a redraw() fuggvenyeket, hogy működjön is.

function redraw() {
context.beginPath();
context.fillStyle = "blue";
if (a > 500)     //ha a kor y koordinátája nagyobb mint 500 akkor irányváltás 
b *= -1;
if (a < 250)     //ha a kor y koordinátája kisebb mint 250 akkor irányváltás
b *= -1;
context.arc(a, 350, 20, 0, Math.PI * 2, true);  // kezdo kor kirajzolasa
//ha rákattintunk a Move gombra x=true
if(x)
//mozgatás jobbra balra y koord. szerint 250 és 500 kozott
context.arc(a += b, 350, 20, 0, Math.PI * 2, true);
context.fill();
}

Most nézzük a move() függvényt(kis különbséggel ugyan az mint az előbb):

function move() {
canvas.width = canvas.width; // képernyő törlése

context.beginPath();
context.fillStyle = "blue";
if (a > 500)
b *= -1;
if (a < 250)
b *= -1;
context.arc(a, 250, 20, 0, Math.PI * 2, true);  // kezdo kor kirajzolasa
if (x)
context.arc(a += b, 250, 20, 0, Math.PI * 2, true);  // mozgatas
context.fill();

requestAnimationFrame(move);
}

Már csak a gombok kezelése van hátra. Elöszőr is írjuk meg a két (on(), off()) fügvényünket ami nem lesz túl bonyolult mindössze az “x” változót állítja “true”-ra  vagy “false”-ra

function on() {
x = true;

function off() {
x = false;
}

Ha ez is megvan már csak egy aprócska lépés van hátra mégpedig, hogy létrehozzunk egy névteret amin keresztül elérjük ezeket a függvényeket a html fájlunkból:

WinJS.Namespace.define("m", { m1: on, m2:off}); // namespace a gombokhoz

Ezután az ‘az oncllick’-nek már átadható m1() ill. m2() függvény ahogy ezt az elején csináltuk.

A gombok középre helyezéséhez a  default.css-be írjuk be a következőket:

body {
text-align:center;
background-color:coral;
}

Ha mindennel megvagyunk futtasuk a projektet és próbáljuk ki.
A forrás innen letölthető: CanvasDemo2

Üdv: Balázs

Az első Windows Phone 8 alkalmazásom

Windows Phone SDK 8.0

A Windows Phone  SDK 8.0 2012. október 29-én este jelent meg a Windows Phone Dev Center weboldalán, ami ingyen letölthető.  Az új SDK visszamenőleg kompatibilitást biztosít a WP 7.X –re fejlesztett  alkalmazásokkal, de az új élmények kihasználásához feltétlenül szükséges az új platformot használni.

Az SDK telepíti a Micorsoft Visual Studio Express  2012 for Windows Phone ingyenes fejlesztői környezetet, de ha már meg van a teljes Microsoft Visual Studio akkor csak a Windows Phone Add-in for Visual Studio komponenst telepíti. Megtalálható a Windows Phone 8 emulator a telepítőben. Az emulator 3 fajta kijelző méretet biztosít (WVGA (800 × 480), WXGA (1280 × 768), 720p (1280 × 720)). A Win Phone 8 SDK telepítéséhez 64 bites Windows 8 operációs rendszer szükséges. Az emulátorhoz pedig a W8-nak a Professional változata kell, valamint 4 GB RAM (nálam 3GB RAM-mal is tökéletes), valamint igényli a hardware-es virtualizációt.  A teljes rendszerkövetelmény itt található.

A Win Phone 8 SDK telepítésével különböző nyelvek és eszközök települnek Win Phone 8-ra fejleszthetünk játékokat és egyéb WP Store alkalmazásokat. Játékokat C++ és Direct3D nyelven készíthetünk (native). Ezen kívül a fejleszthetünk alkalmazás XAML és C#/VB.NET/C++ nyelveken (managed). A menedzselt kódú programokba beágyazhatók a Direct3D/C++ natív kódok, ami elősegíti a C++ programok újrafelhasználását (fordítva nem lehetséges). Continue reading

Az alkalmazás beállításainak változtatása futásidőben.

Mivel a Windows 8 alkalmazásoknak a beállításai az egységesített Settings Panelen találhatóak, ezért nem közvetlenül az alkalmazásból, hanem egy “külső” felugró UserControlból lehet elérni a beállításokat.

Mivel ez közvetlen nem fér hozzá az alkalmazásunkhoz, ezért egy megoldásként készíthetünk egy publikus eseményt, mely a Settings Panelen lévő változtatáskor meghívódik, és az alkalmazásunkban pedig feliratkozunk erre az eseményre, és az új értékeknek megfelelően módosítja az alkalmazásunkat is.

Először létrehozzuk a User Control kódjában, majd például egy combobox selectionchanged eseményében meghívjuk:

public static event EventHandler SettingsChangedEvent;
public void ComboBox_SelectionChanged_1(object sender, SelectionChangedEventArgs e)
 {
   //eltároljuk a változásokat
   SettingsChangedEvent(this, EventArgs.Empty);
 }

Nincs más dolgunk, mint az alkalmazásban megmondani, hogy mit csináljon ha ez az esemény megtörténik:

UserControl.SettingsChangedEvent += new EventHandler(UpdateSettingsEvent);
private void UpdateSettingsEvent(object sender, EventArgs e)
 {
 //Megcsináljuk a módosításokat
 }

Ez akkor hasznos, ha rögtön látni szeretnénk a változás eredményeit, például ha különböző színű témák közül szeretnénk választani, de az alkalmazás nyelvét is megváltoztathatjuk anélkül, hogy újra kellene indítani az alkalmazást.

Stílusok I.

Stílusok I.

A stílusok szerepe:  A témák kialakításának egy nagyon fontos építőköve.  Például panelek esetén közös háttérszín. A stílusokra legegyszerűbben úgy érdemes gondolni, hogy azok valójában nem mások, mint tulajdonság halmazok. Fogunk egy köteg közös jellemzőt, és azokat egyetlen stílusba rakjuk. A stílus objektumot helyezzük el erőforrásként.  A stílusokat a Silverlightban a Style objektum segítségével lehet definiálni, miközben a TargetType tulajdonságot beállítjuk arra a típusra, amelyre a stílus készül. A stílusok esetében az egyes tulajdonságok beállítása a Setter-ek segítségével történik. Nézzünk erre egy példát is, hogy érthetőbb legyen:

 

Ha a tulajdonságokhoz tartozó érték komplex és így nem lehet azt egyetlen stringben leírni, akkor a Setter elem Value értéke 1-es, azaz attribútum helyett XML elemként használható. A Style tulajdonságot a FrameworkElement ősosztály definiálja, így például minden vezérlő és panel rendelkezik vele. A stílus alkalmazására nézzünk egy példát :

Stílusok öröklődése:  Nem kell mindig minden stílust a nulláról építeni. Számos esetben építkezhetünk valamilyen alapstílusból kiindulva, amelyből később leszármaztatva specifikusabb stílusokat lehet készíteni. A Silverlight 3 óta a Style objektum rendelkezik a BasedOn attribútummal, amely lehetővé teszi a hivatkozást egy ősstílusra, így szolgáltatva közös alapot más stílusok számára.

Ez a stílus rendelkezik, minden olyan tulajdonsággal, amivel a myBorderStyle, de felüldefiniálja a BorderBrush értéket, ami itt most piros szín lesz. Az ősstílus tulajdonságait felülírják a leszármazott stílusok tulajdonságai. Bármely stílus beállítását felüldefiniálja a közvetlenül a vezérlőn definiált, lokálisan meghatározott érték.

A következő alkalommal szintén a stílusokkal fogunk foglalkozni.

Stílusok és testreszabhatóság a Silverlightban II.

Stílusok és testreszabhatóság a Silverlightban II.

Az előzőleg félbehagyott erőforrásokkal foglalkozunk, majd ha lesz még idő, akkor áttérnénk a stílusokra.

Az erőforrások használata:

Az erőforrást a következő kódrészlettel tudjuk definiálni:

<UserControl.Resources>

<SolidColorBrush x:Key=”bgColor” Color=”Blue” />

</UserControl.Resources>

A fenti UserControl-on belül ez az erőforrás minden objektum számára látható és elérhető. Hivatkozni az x:Key attribútum értékén keresztül lehet rá a StaticResource nyelvi kiterjesztés használatával. Szemléltessük ezt egy példán keresztül, hogy érthetőbb legyen:

 

<Objektum PropertyNev=”{StaticResource resourceKey}” />

<Grid Background=”{StaticResource bgColor}” >

….

<Grid/>

SolidColorBrush brush = this.Resources[“bgColor”] as SolidColorBrush;

A this kulcsszónak itt a UserConrol-ra kell vonatkoznia. A resources gyűjtemény értéke mindig object típusú, ezért van szükség a típuskonverzióra (as operátor). A key attribútum értékének egyedinek kell lennie. Ezt az erőforrás lekötést Expression Blend-ben is meg tudjuk valósítani az Advanced Property Options segítségével.

Az erőforrás fájlok:

Az alkalmazáshoz épített stílusok újrafelhasználhatósága előbb – utóbb fontos cél lesz. Ezekre a problémákra megoldás a ResourceDictonary. Ezt az objektumot egy külső XAML fájlban definiáljuk, és a felhasználás során meghivatkozzuk. Egy ilyen xaml fájlra nézzünk is egy példát:

Ezt az erőforrás – könyvtárat használó App.xaml tartalma az alábbi módon nézhet ki, amennyiben az xaml fájlunk neve ResourceDictionary1.xaml:

Application szintre emeltük be a ResourceDictionary1.xaml és a ResourceDictionary2.xaml tartalmát. Így a fenti bgColor erőforrás az alkalmazás tetszőleges pontján meghivatkozható. Ezek az XAML fájlok átvihetők más projektekbe is. A ResourceDictionary objektumok létrehozását és kezelését az Expression Blend is támogatja.

Következő alkalommal áttérünk a Stílusokra.

 

 

 

Stílusok és testreszabhatóság a Silverlightban I.

Stílusok és testreszabhatóság a Silverlightban I.

 A mai világban rendkívül magasak az elvárások az alkalmazásokkal szemben. Ez alól nem kivétel a felhasználói élmény sem. Egy szoftver felhasználói élményét sok tényező együttes működése és hatása határozza meg. Az egyik legfontosabb és egyben legszembetűnőbb felhasználói felület a GUI (graphical user interface). Ebben a fejezetben megismerhetjük, hogy a silverlight miként támogatja az egységes felhasználó felület kialakítását.

Erőforrások a Silverlightban:

Az erőforrások szerepe: Először is ismerjük meg az erőforrás pontos definícióját. Az erőforrások olyan tetszőleges típusú objektumok, melyeket nem csak lokálisan, hanem egymástól független helyen is fel kívánunk használni. Egy ilyen erőforrás objektum lehet akár egy szín is.

Például, ha kiválasztunk egy Brush objektumot, és ezt több helyen is szeretnénk szerepeltetni. Mindenhová begépelhetjük,de gondban leszünk, ha később cserélni szeretnénk. Ebből az esetből kiindulva adódik a szituáció,hogy ezt a Brush objektumot el tudjuk eltárolni, és bármikor fel tudjuk alkalmazni.

Silverlightban egy statikus erőforrás a StaticResource. Azért statikus, mert jelen állás szerint a silverlightban nincs dinamikus erőforrás. Ez az erőforrás azt jelenti,hogy már forduláskor belekötésre kerül a hivatkozott objektum, és futás közben nem cserélhető le.

 Az erőforrások hozzáfélhetősége: Felvetődik a kérdés, hogy ezeket pontosan hol is definiáljuk? A válasz egyszerű: a Resources szekcióban. A resources tuljadonság a FrameworkElement ősosztályban került definiálásra, értéke egy IDictionary <string, object> típusú objektum. Az erőforrásokat több szinten is lehet definiálni:

  • Application szint
  • UserControl szint
  • Vezérlő szint

Azt, hogy az adott erőforrást melyik szinten definiáljuk, egyértelműen meghatározza, hogy mely objektumok számára lesz elérhető. Ha pl. az Application objektum Resources gyűjteményében helyezünk el egy erőforrást, akkor az az alkalmazásban mindenhol hivatkozható lesz. Egyfajta öröklődési láncról beszélhetünk.

Következő alkalommal megnézzük az erőforrások használatát, az erőforrás fájlait és rátérünk a stílusokra.

Második feladatok – 5. rész

A mai bejegyzés folyamán a maradék 2 animációt szeretném megcsinálni, illetve a kép beillesztéses kérdésre is választ szeretnék adni.

Kezdjük a képek beillesztésével.

Ennek megoldására találtam egy olyan PictureBox nevezetű Controlt. Ebbe könnyen bele lehet tenni a képet.

Nézzük meg közelebbről. Létrehozunk egy új projektet a Visual Studioban. Toolbox segítségével hozzáadunk egy PictureBoxot. Jobb oldalt a Properties-nél van egy Image “rész”, ahol a …-ra kattintva beilleszthetjük a képeinket. Ahhoz, hogy a képünk teljes módban látszódjon, mind a form méretét, mind a picturebox méretét át kell állítani. Ezt a Size-nál tehetjük meg. Íme a végeredmény:

A második animációnál az volt a feladat, hogy egy gomb lenyomására történjen valami animáció.

Ezt egy piros pöttyel oldottam meg, illetve egy gombbal, amit ha megnyomunk akkor jobbra, majd ha ismét megnyomjuk, akkor a pötty visszaugrik az eredeti pozícióba.

Na, de lássuk a kódot:

Létrehozok egy x változót, ez majd a mozgatásnál lesz segítségemre, az y változó pedig a pötty kirajzolásához kell. Majd létrehozom a gombot, egy segédváltozót, ami szintén a mozgatásnál segít. A konstruktorba a gomb feliratát helyeztem el, illetve magát a gombot, és hogy a gomb megnyomásnál hozzáadom a mozgatásos eseményt.

Az idozito metódusnál próbáltam volna felhasználni a villogó gombnál használt dolgokat, de valamiért állandó mozgásra nem sikerült a pöttyöt bírnom.

Az OnPaint metódussal rajzolódik ki egy pöttyünk, majd a main-nel a program futtatását tesszük lehetővé.

A kódot innen le lehet tölteni: ButtonToMove

 

Egy MVVM mintapéldával és az összetettebb animációval még adós vagyok.