Numele meu este Andrei și începând cu acest tutorial voi prezenta programul de grafică 3D Google SketchUp® și modul de lucru cu acest program.

În acest prim tutorial am încercat să fac o descriere cât mai succintă a programului (deși durează aproape o oră) și a primilor pași de lucru cu uneltele sale.

Orice părere de-a voastră este bine venită și sigur va avea un aport constructiv pentru realizarea tutorialelor viitoare, dar țin să menționez că mă aflu la prima experiență în ceea ce privește susținerea fără audiență fizică a unei prezentări educative și sigur este loc de mai bine. În ceea ce privește sunetul din tutorialul video îmi cer scuze și vă rog să aveți grija la volumul sunetului, deoarece exceptând intro-ul și outro-ul sunetul pe durata întregii înregistrări este scăzut.

În continuare, vizionare/lectură plăcută și vă încurajez să faceți cat mai mult uz de acest soft gratuit care vă va scutii de foarte multe situații neplăcute pe viitor în ceea ce privește o mare parte din activitățile voastre cotidiene.

(Pentru orice intrebari puteti sa ma gasiti la adresa: stefan.andrei.vet [at] gmail [dot] com)

Despre Google SketchUp ®

Google SketchUp® reprezintă un program (softwere) de modelare tridimensională (3D) cu aplicabilitate în diverse domenii: arhitectură, construcții civile, inginerie mecanică, cinematografie, conceperea de jocuri pentru PC etc. Programul este realizat în așa fel încât să fie ușor de utilizat, chiar și de persoane care nu au avut tangență cu un astfel de program până la momentul respectiv.

Proiectele realizate pot fi puse la dispoziția publicului larg, prin plasarea acestora în Google’s 3D Warehouse®, un depozit virtual destinat tuturor celor care doresc să-și facă publice lucrăriile.

De asemenea Google SketchUp® permite amplasarea geografică a proiectelor realizate prin interacțiunea cu Google Earth®, proiectele astfel realizate vor putea fi vizualizate în timp real fie cu ajutorul programului Google Earth®, fi prin interfața on-line Google Maps®.

1. Interfața cu utilizatorul (user interface) a programului Google SketchUp®

1) Axele Roșu/Verde/Albastru – o reprezentare mai simpla a axelor x/y/z
2) Bara de meniuri
3) Standard – „bara standard”
4) Large tool set – bara de unelte „mare”
5) Measurements – bara de dialog și de interacționare în ceea ce privește editarea/vizualizarea unităților de măsură
6) Instructor – bara unde se pot vizualiza indicațiile oferite de către program
7) Suprafața de lucru

1.1. Axele Roșu/Verde/Albastru

Axele Roșu/Verde/Albastru sunt reprezentarea mai interactivă a sistemului de coordonate „clasic” 0-X-Y-Z. Înlocuirea notării clasice cu reprezentarea prin intermediul culorilor (rosu, verde, albastru), se dorește a veni în ajutorul utilizatorului, accesând latura intuitivă a procesului proiectare. Pe parcursul procesului de proiectare aceste axe vor servii ca linii de referință, aspect ce va fi dezvoltat în lecțiile următoare.

1.2. Bara de meiuri

Cu ajutorul barei de meniuri putem accesa diferite comenzi prezente în meniurile derulante ce se acționează în momentul când facem clic pe acestea (File, Edit, View, Camera, Draw, Tools, Window, Plugins, Help).

1.3. Standard – „bara standard”

Pe această bară de unelte se găsesc comenzile tipice unui program ce rulează în MS Windows® (New, Open, Save, Copy/Cut, Paste, Erase, Undo/Redo, Print, Model Info), iar dacă sistemul de operare este altul (Linux®, Mac OSX®) atunci această bară de unelte va corespunde configurației respective.

1.4. Large tool set – bara de unelte „mare”

Asemănător altor programe pentru editare grafică (e.g. AutoCAD®) și Google SketchUp® utilizează gruparea uneltelor de lucru și dispunerea acestora pe bare de unelte. Spre deosebire de alte programe uneltele sunt grupate în așa fel încât să fie ușor de accesat, într-o manieră intuitivă. Bara de unelte Large tool set grupează toate elementele generale de editare grafică, spre deosebire de bara de unelte Getting started, care apare implicit in momentul în care rulam programul Google SketchUp® pentru prima oară.

Orice bară de unelte poate activată/inactivată astfel: Meniul View → Toolbars… .

1.5. Measurements

Acest element al ferestrei Google SketchUp® reprezintă mijlocul prin care putem să vizualizăm sau să editam cotele unui element din spațiul de desenare. În ceea ce privește inserarea dimensiunilor unui obiect, după ce am indicat cu ajutorul cursorului primul punct pe spațiul de lucru și am indicat direcția de trasare, putem introduce valoarea numerică a distanței celui de-al doilea punct față de primul.

Un alt lucru important ce trebuie menționat este acela că între două cote introducem semnul „ , ”, iar în cazul în care lucrăm cu zecimale introducem după numărul întreg semnul „ . ”. De asemenea dacă dorim să utilizăm unități de măsură, altele decât cele setate în prealabil, atunci putem tasta simbolul unității de măsură dorite (m, cm, mm, feet, inch) imediat după valoarea numerică, fără a lăsa spațiu între cele două.

Ce trebuie reținut este faptul că în Google SketchUp® desenăm la scară reală.

1.6. Instructor

În această regiune a ferestrei Google SketchUp®, programul ne oferă indicații privind comenzile care le avem activate la momentul respectiv, oferindu-ne și opțiuni secundare ale acestora prin indicarea tastelor sau grupurilor de taste corespunzătoare.

1.7. Suprafața de lucru

Acest spațiu este destinat realizării desenului nostru. Elementele principale și esențiale din acest spațiu sunt reprezentate de cele trei axe: Axa Roșie, Axa Verde și Axa Albastră. Aceste trei axe sunt varianta mai „simplă” a celor trei axe de coordonate OX, OY și OZ. Un alt element ce apare în spațiul de lucru la prima rulare a programului, este silueta umană („Susan”) care ne oferă posibilitatea să ne raportăm elementele desenate la înălțimea standard a unui om.

2. Large tool set – bara de unelte „mare”

Uneltele de desenare din această bară pot fi activate în grupuri din Meniul View → Toolbars…, de asemenea și alte grupuri de unelte care nu se află în bara Large tool set. În continuare vor fi enumerate pe grupuri fiecare comandă din bara Large tool set.

Large tool set

• Principal:

• Select – permite selectarea unui element desenat (o față, o dreaptă, un segment, un grup, o componentă)
• Make Component – permite transformarea unei entități desenate într-o componentă (Component)
• Paint Bucket – la lansarea acestei comenzi se va deschide o fereastră ce permite alegerea unei texturi pe care apoi o atribuim unei suprafețe
• Eraser – cu ajutorul acestei unelte putem elimina entități prin selectare individuală sau prin selectare multiplă (se menține activată comanda și se trece cursorul peste elementul de șters)

• Drawing:

• Line/Pencil Tool – permite trasarea linilor de dreaptă sau prin închiderea unui perimetru se realizează marginile unei suprafețe
• Arc – permite trasarea unui arc de cerc, prin indicarea unui punct de început, a unui punct final și a razei arcului de cerc
• Freehand – cu această unealtă se realizează linii „trasate manual”. Dacă linia se închide în punctul de pornire se va delimita astfel și o față
• Rectangle – prin indicarea unui punct de început și a unui punct de încheiere pe diagonală, se va trasa un dreptunghi
• Circle – prin indicarea unui centru de cerc și a razei acestuia se va trasa un cerc
• Polygon – se introduce în bara Measurements numărul de laturi ale poligonului, se indică centrul poligonului, iar apoi raza poligonului

• Modification:

• Move – cu această unealtă se pot muta, copia și/sau întinde („strech”) entități. De asemenea cu această unealtă se pot modifica și suprafețe prin repoziționarea uneia/unor laturi
• Push/Pull – cu această unealtă împingem sau tragem de fețele unui obiect desenat pentru a adăuga sau a elimina volum obiectului respectiv
• Rotate – permite rotirea, întinderea, distorsionarea sau copiere urmărind un traseu circular
• Follow Me – multiplică o față de lungul unui traseu
• Scale – permite redimensionarea și întinderea unei porțiuni al unei figuri geometrice prin raportarea la un alt obiect
• Offset – permite crearea unor copii de linii la o distanță uniformă de original

• Construction:

• Tape Measure/Ruleta – permite măsurarea distanțelor, crearea liniilor și/sau a punctelor de ghidare, sau redimensionarea unui model
• Dimension – permite inserarea cotelor entităților desenate
• Protractor – permite măsurarea unghiurilor și crearea de linii de construcție la diferite unghiuri
• Text – permite inserarea de text
• Axes – permite mutarea sau reorientarea axelor de desenare
• 3D Text – la acționarea comenzii va apărea o fereastra unde se va edita și apoi plasa în desen un text tridimensional (acest text va acea proprietățile unei componente)

• Camera:

• Orbit – permite rotirea perspectivei de vizualizare în raport cu modelul
• Pan – permite modificarea poziției perspectivei de vizualizare a utilizatorului, pe verticală sau pe orizontala
• Zoom – permite mărirea sau micșorarea perspectivei de vizualizare (zoom in și zoom out)
• Previous – revine la modul/-urile de vizualizare anterior/-oare
• Next – trece la modul/-urile de vizualizare urmator/-oare
• Zoom extents – încadrează întregul desen în spațiul de desenare

• Walkthrough:

• Position Camera – permite poziționarea perspectivei de vizualizare (perspectiva utilizatorului) la o înălțime indicată pentru a verifica o anumită perspectivă sau pentru a pășii în/pe lângă obiectul desenat
• Walk – permite „plimbarea” prin/pe lângă obiectul desenat
• Look Around – pivotarea perspectivei de vizualizare printr-un punct fix
• Section Plane – permite crearea unor planuri de secțiune

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android – Stocarea Datelor

In Android exista mai multe moduri in care puteti sa stocati datele:

• Shared Preferences – stocheaza doar date in forma key-value (datele care sunt salvate pot fi de tipul: String, boolean, float, int, long)
• Stocare interna – folosirea memorie device-ului
• Stocare externa – folosirea unui dispozitiv extern, de obicei un SD Card.
• Baza de date – folosirea unei baze de date SQLite

Puteti de asemenea sa aveti deja date predefinite, dar cand Read Only. Acestea se pot gasi in:

• directorul Assets
• directorul res/raw

Android – Stocare interna

Exemplu de stocare a datelor intr-un fisier.

EditorApp.java

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
 
public class EditorApp extends Activity {
	private final static String NOTES="notes.txt";
	private EditText editor;
	Button btn;
 
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        editor = (EditText)findViewById(R.id.editor);
        btn = (Button)findViewById(R.id.close);
 
        btn.setOnClickListener(new Button.OnClickListener() {
        	public void onClick(View v) {
        		finish();
        	}
        });
    }
 
    public void onResume() {
    	super.onResume();
 
    	try {
	    	InputStream in = openFileInput(NOTES);
	    	if (in != null) {
		    	InputStreamReader tmp = new InputStreamReader(in);
		    	BufferedReader reader = new BufferedReader(tmp);
		    	String str;
 
		    	StringBuffer buf = new StringBuffer();
 
		    	while ((str = reader.readLine()) != null) {
		    		buf.append(str+"\n");
		    	}
		    	in.close();
 
		    	editor.setText(buf.toString());
	    	}
    	} catch (java.io.FileNotFoundException e) {
    		// that's OK, we probably haven't created it yet
    	} catch (Throwable t) {
    	Toast.makeText(this, "Exception: " + t.toString(), 2000).show();
    	}
    }
 
    public void onPause() {
    	super.onPause();
    	try {
	    	OutputStreamWriter out = new OutputStreamWriter(openFileOutput(NOTES, 0));
	    	out.write(editor.getText().toString());
	    	out.close();
    	} catch (Throwable t) {
    	Toast.makeText(this, "Exception: " + t.toString(), 2000).show();
    	}
    }
}

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
 
	<Button android:id="@+id/close"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"
		android:text="Close" />
	<EditText
		android:id="@+id/editor"
		android:layout_width="fill_parent"
		android:layout_height="fill_parent"
		android:singleLine="false"/>
 
</LinearLayout>

Dupa cum observati aplicatia are si un buton Close folosit pentru a incheia activitatea cu ajutorul functiei finish().

Android – Stocare externa

Pentru a afla calea catre dispozitivul extern va trebui sa folositi functia getExternalStorageDirectory(). Exemplu:

String path = Environment.getExternalStorageDirectory().toString();
String filePath = path + "fisierulMeu.txt";
InputStream input = new FileInputStream (new File (filePath));

Un good practice este sa verificati inainte ca puteti sa cititi/scrieti pe un dispozitiv extern. Un exemplu de cod ar fi:

boolean mExternalStorageAvailable = false;
boolean mExternalStorageWriteable = false;
String state = Environment.getExternalStorageState();
 
if (Environment.MEDIA_MOUNTED.equals(state)) {
    // We can read and write the media
    mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
    // We can only read the media
    mExternalStorageAvailable = true;
    mExternalStorageWriteable = false;
} else {
    // Something else is wrong. It may be one of many other states, but all we need
    //  to know is we can neither read nor write
    mExternalStorageAvailable = mExternalStorageWriteable = false;
}

Link-uri utile

• developer.android.com

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android – Stocarea Datelor

In Android exista mai multe moduri in care puteti sa stocati datele:

• Shared Preferences – stocheaza doar date in forma key-value (datele care sunt salvate pot fi de tipul: String, boolean, float, int, long)
• Stocare interna – folosirea memorie device-ului
• Stocare externa – folosirea unui dispozitiv extern, de obicei un SD Card.
• Baza de date – folosirea unei baze de date SQLite

Puteti de asemenea sa aveti deja date predefinite, dar cand Read Only. Acestea se pot gasi in:

• directorul Assets
• directorul res/raw

Android – Shared Preferences

Exemplu de salvare/restaurare a unei date folosind Shared Preferences

public class Example extends Activity {
    public static final String PREFS_NAME = "MyPrefsFile";
 
    @Override
    protected void onCreate(Bundle state){
       super.onCreate(state);
       . . .
 
       // Restore preferences
       SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
       boolean silent = settings.getBoolean("silentMode", false);
       setSilent(silent);
    }
 
    @Override
    protected void onStop(){
       super.onStop();
 
      // We need an Editor object to make preference changes.
      SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
      SharedPreferences.Editor editor = settings.edit();
      editor.putBoolean("silentMode", mSilentMode);
 
      // Commit the edits!
      editor.commit();
    }
}

Exemplu complet de utilizare PreferenceActivity

PreferenceActivityEx.java

import android.os.Bundle;
import android.preference.PreferenceActivity;
 
public class PreferenceActivityEx extends PreferenceActivity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.settings);
    }
}

PrefActivity.java

import android.app.Activity;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
 
public class PrefActivity extends Activity{
	Button settings;
	TextView name;
	TextView student;
	TextView year;
 
	/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        settings = (Button)findViewById(R.id.button1);
        name = (TextView) findViewById(R.id.textView4);
        student = (TextView) findViewById(R.id.textView5);
        year = (TextView) findViewById(R.id.textView6);
 
        settings.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				// construim un Intent
		        Intent intent = new Intent ();
 
		        // setam componenta de destinatie (activitatea implmentata in clasa ActivitateDePornit)
		        intent.setClass(PrefActivity.this, PreferenceActivityEx.class);
		        startActivity(intent);
			}
		});
 
        SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(this);
        name.setText (pref.getString("name", "(no name)"));
        if (pref.getBoolean("student", false) == true)
        	student.setText("yes");
        else
        	student.setText ("no");
        year.setText (pref.getString ("year", "0"));
    }
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.jupiter.preferenceactivityex"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />
 
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".PrefActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
 
        <activity android:name=".PreferenceActivityEx"
                  android:label="Config Settings">
        </activity>
 
    </application>
</manifest>

main.xml

<?xml version="1.0" encoding="utf-8"?>
    <AbsoluteLayout android:id="@+id/absoluteLayout1" 
    	android:layout_width="fill_parent" 
    	android:layout_height="fill_parent" 
    	xmlns:android="http://schemas.android.com/apk/res/android">
        <TextView android:layout_x="37dip" 
        	android:text="Name:" 
        	android:layout_height="wrap_content" 
        	android:id="@+id/textView1" 
        	android:layout_width="50px" 
        	android:layout_y="33dip">
        </TextView>
        <TextView android:layout_x="36dip" 
        	android:text="Year:" 
        	android:layout_height="wrap_content" 
        	android:id="@+id/textView3" 
        	android:layout_width="50px" 
        	android:layout_y="105dip">
        </TextView>
        <TextView android:text="Student:" 
        	android:layout_height="wrap_content"
        	android:id="@+id/textView2" 
        	android:layout_width="50px" 
        	android:layout_x="36dip" 
        	android:layout_y="66dip">
        </TextView>
        <Button android:layout_x="109dip" 	
        	android:layout_height="wrap_content" 
        	android:layout_width="wrap_content" 
        	android:text="Settings" 
        	android:id="@+id/button1" 
        	android:layout_y="196dip">
        </Button>
        <TextView android:layout_x="170dip" 
        	android:text="" 
        	android:layout_height="wrap_content" 
        	android:id="@+id/textView4" 
        	android:layout_width="wrap_content" 
        	android:layout_y="33dip">
        </TextView>
        <TextView android:text="" 
        	android:layout_height="wrap_content" 
        	android:id="@+id/textView5" 
        	android:layout_width="wrap_content" 
        	android:layout_x="170dip" 
        	android:layout_y="64dip">
        </TextView>
        <TextView android:layout_x="170dip" 
        	android:text="" 
        	android:layout_height="wrap_content" 
        	android:id="@+id/textView6" 
        	android:layout_width="wrap_content" 
        	android:layout_y="97dip">
        </TextView>
    </AbsoluteLayout>

array.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="years">
        <item>First</item>
        <item>Second</item>
        <item>Third</item>
        <item>Forth</item>
    </string-array>
	<string-array name="years_values">
		<item>1</item>
		<item>2</item>
		<item>3</item>
		<item>4</item>
	</string-array>
</resources>

settings.xml

<?xml version="1.0" encoding="utf-8"?>
 
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
	<PreferenceCategory android:title="Person">
		<EditTextPreference android:key="name"
			android:title="Name"
			android:summary="Enter your name"
			android:defaultValue="(no name)"/>
	</PreferenceCategory>
 
	<PreferenceCategory android:title="Education">
		<CheckBoxPreference android:key="student"
			android:title="Student"
			android:defaultValue="false"
			android.summary="Are you a student?" />
 
		<ListPreference android:key="year"
			android:title="Year"
			android.defaultValue="0"
			android.summary="In which year of study?"
			android:entries="@array/years"
			android:entryValues="@array/years_values"/>		
	</PreferenceCategory>
</PreferenceScreen>

Link-uri utile

• developer.android.com

Salut,bine ati venit pe itassistant.org, eu sunt Razvan si vreau sa inaugurez o noua serie de tutoriale, si anume aplicatii folositoare pentru Android.

Prima aplicatie pe care vreau sa o prezint este “Advanced Task Killer“, o aplicatie care ne inchide restul aplicatiilor pentru ca bateria sa aiba o durata mai lunga.

Instalare Android – Advanced Task Killer

Sa incepem, aplicatia este gratuita in “Android Market“, scriem in casuta de cautare “advanced task killer” si aplicatia este primul rezultat:

Dupa instalare deschidem aplicatia pentru a o configura.

Configurare Android – Advanced Task Killer

Dupa ce am intrat in aplicatie apasam pe butonul “Meniu” (al telefonului), si mergem la setari. Bifam “Auto start”

Navigam la tag-ul “Auto Kill”

Si de acolo intram in meniul “Auto Kill Level” si bifam “Crazy“

Din meniul anterior intram si in “Auto Kill Frequency” si bifam “When screen off”

Acum toate aplicatiile se vor inchide atunci cand ecranul se va stinge iar viata bateriei telefonului vostru va fi prelungita!

Salutari si bine ati venit pe itassistant.org eu sunt Mihai si sunt aici pentru a va inveseli ziua cu un nou tutorial de grafica si animatie in cinema 4d in care vom vorbi mai in amanunt depre interfata programului cu functiile si uneltele pe care le detine acesta.

Cinema 4d – View

Sa incepem cu View-urile. Ce sunt view-urile? Pai un view este un elemnt de BAZA al orcarui pachet tridimensional, in el putem vedea si manipula efectiv obiectele create.

Cinema 4d dispune de 4 view-uri, ele sunt:

• perspecti (vedem obiectul din perspectiva)
• top (vedem obiectul de sus)
• right (vedem obiectul din dreapta)
• front (vedem obiectul din fata)

Obiectele le putem crea din acest panou cat si spline-urile (sunt diferite modalitati de a trasa linii astfel sa ajungem la obiecte mai complexe sau sa stabilim tractoria unui obiect in miscare), nurb-urile (diverse efecte care se aplica pe obiecte si spline-uri), conectorii (sunt proprietati de interactione ale obiectelor intre ele), deformatorii (cu ei putem deforma obiectele in diferite pozitii), luminile si bakgroundul si simulatoarele (ele ne ajuta in animatie sa simulam diverse efecte, ex: un simulatoor de particule ne ajuta sa cream foc ).

Toate obiectele, spline-urile, narb-urile, conectorii, deformatorii sau simulatoarele ne sunt afistate sub forma de lista (asezate erarhic) in object manager. Pentru ca acestea sa ineractioneze trebuie sa cream ierarhii cu ele.

Sub object manager gasim attributes maneger de unde putem controla diferitele atribute ale obiectelor si nu numai.

Putem modifica obictele create modificatnd valori din attributes manager, sau folosind uneletele de move, scale si rotate pentru a muta redimensiona respectiv roti obiectul:

Pentru a putea modela obiectul in functie de segmente trebuie mai intai sa il convertim intr-un obiect editatbil, putem face asta selectand obiectul si apasand tasta “C“. Apoi cu una din uneltele de selectie:

Putem selecta puncte, laturi, sau polgoane, in functie de optiunea de selectia pe care o folositi (ele se pot selecta din panoul din stanga view-ului).

In parte de jos a programului putem observa un timeline, el este instrumentul principal atunci cand cream o animatie deoarece cu el putem controla in timp obictele.

Sub timeline gasim managerul de materiale. Materialele sunt cele care creaza “invelisul obiectelor”, creand un material pentru un obiect ii determinam culoare, transparenta, luminozitatea, etc.

Putem crea materiale dand dublu clic in managerul de materiale. Ca sa editam noul material creat putem sa o facem din attributes manager, sau dand dublu clic pe noul materia si ni se va deschide o fereastra din care putem edita mai complex materialul.

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android – Meniuri

Meniurile sunt o parte importanta din interfata grafica a unei aplicatii, ele oferind posibilitatea utilizatorului de a accesa rapid actiuni comune (de exemplu in aplicatia pentru email sincronizarea inbox-ului).

Mai jos este prezentat meniul din Browser-ul Android.

Este recomandat ca meniul sa fie declarat intr-un fisier XML. Aceste trebuie sa se gaseasca in: res/menu/. Mai jos este prezentat un astfel de fisier.

menu.options_menu.xml

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/dashboard_refresh"
          android:title="@string/dashboard_refresh"
          android:icon="@drawable/refresh" />
    <item android:id="@+id/dashboard_settings"
          android:title="@string/dashboard_settings"
          android:icon="@android:drawable/ic_menu_preferences" />
    <item android:id="@+id/dashboard_about"
          android:title="@string/dashboard_about"
          android:icon="@drawable/about" />
    <item android:id="@+id/dashboard_help"
          android:title="@string/dashboard_help"
          android:icon="@drawable/help" />
</menu>

Observatii:

• fiecare element al meniului este declarat in tag-ul <item>
• id-ul elementului este declarat in atributul android:id
• textul este declarat in atributul android:title (este o practica buna ca string-urile sa fie externalizate in fisierul string.xml)
• fiecare element poate avea si o imagine; aceste imagini pot fi ale sistemului, caz in care vom folosi android:icon=”@android:drawable/nume_imagine” sau incarcate de programator in folderul /res/drawable/, caz in care vor fi referite astfel: android:icon=”@drawable/help” (este de preferat ca imaginile pe care le folosit in aplicatiile voastre sa fie PNG)

Mai jos este prezentat si fisierul string.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
 
    <string name="hello">Hello World, MenuExampleActivity!</string>
    <string name="app_name">MenuExample</string>
 
        <!-- The menu entry for dashboard -->
    <string name="dashboard_refresh">Sync</string>
    <string name="dashboard_settings">Settings</string>
    <string name="dashboard_about">About</string>
    <string name="dashboard_help">Help</string>
 
</resources>

Incarcarea unui meniu intr-o Activitate se face utilizand functia MenuInflater.inflate() in timpul executiei onCreateOptionsMenu() (acesta functie va trebui suprascrisa).

Exemplu Android Meniu

In continuare este prezentata o Activitate care incarca meniul declarat anterior si afiseaza un mesaj (Toast) in momentul in care user-ul actioneaza un element.

package org.menuexample;
 
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.widget.Toast;
 
public class MenuExampleActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
 
    /*
	 * Create Menu Option
	 * @see android.app.Activity#onCreateOptionsMenu(android.view.Menu)
	 */
	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.options_menu, menu);
		return true;
	}
 
	/*
	 * @see android.app.Activity#onOptionsItemSelected(android.view.MenuItem)
	 */
	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
 
		switch (item.getItemId()) {
		case R.id.dashboard_refresh:
			Toast.makeText(this, "Sync", Toast.LENGTH_SHORT).show();
			return true;
		case R.id.dashboard_settings:
			Toast.makeText(this, "Settings", Toast.LENGTH_SHORT).show();
			return true;
		case R.id.dashboard_about:
			Toast.makeText(this, "About", Toast.LENGTH_SHORT).show();
			return true;
		case R.id.dashboard_help:
			Toast.makeText(this, "Help", Toast.LENGTH_SHORT).show();
			return true;
		default:
			return false;
		}
	}
}

Dupa cum observati din exemplu de mai sus, pentru a raspunde la actiunile user-ului va trebui suprascrisa functia onOptionsItemSelected()

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android Intents

Android este o platforma mobila bazate pe o arhitectura orientata pe servicii. Aplicatiile sunt compuse din componente independente care isi ofera servicii una alteia. Legatura dintre aceste componente se face prin Intent-uri. Acestea sunt de fapt obiecte ce sunt serializate si trimise catre sistem. Sistemul le analizeaza, hotareste care este cea mai buna componenta de destinatie, porneste componenta, si trimite Intent-ul mai departe acesteia.

Propietatiile

Fiecare Intent are urmatoarele propietati:

• action:String – denumeste actiunea ce trebuie efectuata. Nu poate lipsi.
• data:Uri – datele asupra carora trebuie efectuata actiunea. Nu poate lipsi.
• category:String[] – o lista de informatii suplimentare ce definesc actiunea
• component:String/class – componenta care sa efectueze actiunea
• type:String – tipul datelor
• extra:Bundle – date suplimentare trimise componentei de destinatie

Action

Acesta propietate defineste actiunea ce se doreste a fi indeplinita. Exemple de actiuni sunt:

• ACTION_SEND
• ACTION_CALL
• ACTION_VIEW
• ACTION_EDIT
• ACTION_MAIN

Din punct de vedere al Java, actiunea este stocata sub forma unui String.

Acesta propietate nu poate lipsi.

Exemplu

// crearea Intent-ului
Intent intent = new Intent ();
 
// setarea unei actiuni predefinite in Android
intent.setAction (Intent.ACTION_EDIT);
 
// setarea unei actiuni definite de catre programator
intent.setAction ("actiunea mea");

Data

Acesta propietate reprezinta datele asupra carora sa se efectueze actiunea. Din punct de vedere Java, datele sunt stocate sub forma unui Uri. Exemple ar fi:

• tel:071334434
• file:///sdcard/fisierul.txt
• content://contacts/un_nume_de_contact

Acesta propietate nu poate lipsi.

Se poate face urmatoarea analogie: daca intent-ul reprezinta o cerere HTTP, actiunea este metoda din HTTP iar datele sunt URL-ul.

Spre exemplu:

HTTP

GET /index.html HTTP/1.1
Host: www.android.com

Intent

{action=android.intent.action.VIEW; data=http://www.android.com/index.html}

Exemplu

// crearea Intent-ului
Intent intent = new Intent ();
// setarea unei actiuni predefinite in Android
intent.setAction (Intent.ACTION_VIEW);
 
// setarea datelor, in cazul de fata pagina www.android.com
intent.setData (Uri.parse ("http://www.android.com");

Category

Categoriile sunt memorate sub forma unui sir de String-uri. Acestea reprezinta informatii suplimentare despre actiunea ce trebui indeplinita. Cu ajutorul acestora, sistemul poate identifica mai bine cea mai buna componenta care sa efectueze actiunea. Exemple de categorii sunt:

• CATEGORY_LAUNCHER
• CATEGORY_HOME
• CATEGORY_DEFAULT

Spre exemplu, componentele care pot efectua actiunea ACTION_MAIN sunt componentele de intrare intr-o aplicatie (in analogie cu programele standard, sunt clasele ce contin functia main). In functie de categorie, componentele sunt (lista este departe de a fi completa):

• plasate in meniul principal al telefonului (CATEGORY_LAUNCHER)
• pornite cand se apasa butonul Home (CATEGORY_HOME)

Exemplu

// crearea Intent-ului
Intent intent = new Intent ();
 
// setarea categoriilor carora le este destinate Intent-ul
intent.addCategory (Intent.CATEGORY_DEFAULT);
intent.addCategory ("categorie nestandard");

Component

Acesta propietate permite specificare exacta a componentei care trebuie sa efectueze actiunea. In general, componenta nu este speficicata ci este dedusa dupa analizarea celorlalte propietati. In cazul in care se specifica o componenta, sistemul o va porni direct, fara sa mai analizeze propietatiile celelalte.

Spre exemplu, daca dorim sa trimitem un email, vom specifica actiunea ACTION_SEND, adresa de destinatie si textul email-ului. Sistemul va determina automat care este programul de email predefinit si ne va deschide fereastra de editare a email-ului. In alanogie cu HTTP, avem acolo adresele mailto:nume@adresa.de.email.

In cazul in care dorim sa trimitem un email cu un anumit program, vom specifica actiunea ACTION_SEND si vom seta drept componenta de destinatie clasa din programul dorit.

Exemplu

// crearea Intent-ului
Intent intent = new Intent ();
 
// setarea componente, in cazul in care este in aceelasi pachet cu componenta ce va emite evenimentul
// this reprezinta Contextul
intent.setClass (this, NumeClasa.class);
 
// daca componenta este in alta aplicatie (alt APK)
intent.setClassName ("un.pachet", "NumeClasa");

Type

Acesta propietate este un String ce specifica tipul datelor din Intent. Daca nu este explicit specificat, tipul este dedus din Uri-ul datelor. Exemple

image/jpeg
audio/mp3
text/html>

Exemplu

// crearea unui Intent
Intent intent = new Intent ();
 
// setarea tipului
intent.setType ("image/jpg");

Extra

Acesta este un parametru de tip Bundle cu ajutorul caruia putem atasa parametrii Intent-ului. Acest Bundle este trimis componentei de destinatie. Functiile puse la dispozitie sunt:

void putExtra (String key, String value);
void putExtra (String key, int value);
void putExtra (String key, double value);
void putExtra (String key, long value);
void putExtra (String key, boolean value);
void putExtra (String key, String[] value);
void putExtra (String key, byte value);
void putExtra (String key, byte[] value);
// etc.
 
String getStringExtra (String key);
String[] getStringArrayExtra (String key);
double getDoubleExtra (String key, double defaultValue);
int getIntExtra (String key, int defaultValue);
long getLongExtra (String key, long defaultValue);
boolean getBooleanExtra (String key, boolean defaultValue);
ArrayList<String> getStringArrayListExtra (String key);
// etc.

Functiile get…Extra(…) intorc null in cazul in care parametru nu exista. Functiile care intorc tipuri primare (long, int, float, double, boolean, byte etc.) nu pot intoarce null (null este valid doar pentru obiecte), si astfel intoc valoarea lui defaultValue in cazul in care parametru nu exista.

Exemple de utilizare

In functie de tipul componentei de destinatie, pentru a emite un Intent, se folosesc una din functii:

// daca componenta este o activitate
void startActivity (Intent intent);
 
// daca componenta este o activitate si acesta trebuie sa intoarce o valoare
void startActivityForResult (Intent intent, int requestCode);
 
// daca componenta este un serviciu
void startService (Intent intent);

Pornirea unei componente

Unul din cele mai simple exemple de utilizare a unui Intent este pornirea unei alte componente din aceelasi pachet (program). Deoarece cunoastem exact ce componente dorim sa pornim, vom seta direct parametru component. Dearece componenta este o clasa, vom folosi functia setClass in loc de setComponent.

// construim un Intent
Intent intent = new Intent ();
 
// setam componenta de destinatie (activitatea implmentata in clasa ActivitateDePornit)
intent.setClass(this, ActivitateDePornit.class);
 
// componenta de destinatie stim ca este o activitate, deci emitem Intent-ul cu startActivity
// atentie, functia startActivity intoarce imediat, urmand ca sistemul sa porneasca la un moment dat fereastra
startActivity (intent);

Pasarea de parametrii cartre alta componenta

Din cauza modului de pornire a unei noi componente (o porneste sistemul, nu noi), ne este imposibil sa pasam direct parametrii. Nu avem nici o referinta (pointer) catre noua componenta. Astfel, pasarea parametrilor se face prin intermediul propietatii extre din intent-ul de pornire. Vom modifica in continuare exemplul de mai sus pentru a trimite un parametru ferestrei noi create:

// construim un Intent
Intent intent = new Intent ();
 
// setam componenta de destinatie (activitatea implmentata in clasa ActivitateDePornit)
intent.setClass(this, ActivitateDePornit.class);
 
// setam parametrul doi parametrii, un String cu numele "nume" si un numar cu numele "numar"
intent.putExtra("nume", "un nume");
intent.putExtra("numar", 10);
 
// componenta de destinatie stim ca este o activitate, deci emitem Intent-ul cu startActivity
// atentie, functia startActivity intoarce imediat, urmand ca sistemul sa porneasca la un moment dat fereastra
startActivity (intent);

In activitatea pornita, preluam parametrii in felul urmator:

// preluam Intent-ul care ne-a pornit
Intent intent = getIntent ();
 
// preluam parametrii
String nume = intent.getStringExtra("nume");
int numar = intent.getIntExtra("numar", 0);
 
// afisam in log parametrii primiti
Log.d ("intent", "nume: "+nume);
Log.d ("intent", "nume: "+numar);

Asteptarea unui raspuns

De multe ori apar situatii in care o fereastra trebuie sa intoarca niste date ferestrei care a pornit-o. De exemplu, avem un program ce pastreaza o lista de filme.

Dorim sa adaugam un film nou, dar cum formularul de adaugare este mai mare, dorim sa cream o fereastra noua. Astfel, utilizatorul apasa pe butonul Adaugare, se deschide o fereatsra nou, utilizatorul completeaza datele noului film si apasa Adauga. Fereastra cu formularul se inchide si trimite datele inapoi fereastrei cu lista. Actiunea acestea se face in felul urmator:

Codul pentru butonul Adaugare din lista de filme:

Intent adauga = new Intent ();
 
// stim excat cine este componenta de destinatie
adauga.setClass (ListaFilme.this, FormularAdaugare.class);
 
// pronim activitatea si specificam ca dorim un raspuns
// numarul 100 reprezinta un numar definit de noi
startActivityForResult (adauga, 100);

Intoarcerea datelor se face prin intermediul unui obiect de tip Intent. Astfel, fereastra cu formularul va crea un nou Intent si il va trimit drept raspuns fereastrei cu lista.

Codul pentru butonul Adauga din formular este:

// cream obiectul de raspuns
Intent raspuns = new Intent ();
 
// setam parametrii
raspuns.putExtra ("nume", nume.getText().toString());
raspuns.putExtra ("an", Integer.parseInt (an.getText().toString()));
raspuns.putExtra ("regizor", regizor.getText().toString());
 
// setam raspunsul, numarul 1 reprezinta un cod numeric al raspuinsului, definit de catre noi
// in cazul nostru reprezinta butonul apasat 
// 1 - pentru Adauga
// 0 - pentru renunte (vezi exemplul urmator)
setResult (1, raspuns);
 
// inchidem formularul
finish ();

Vom presupune ca formularul nostru are si un buton de renunta. Codul pentru acest buton este:

// in cazul acesta nici nu mai trimitem un Intent, nu are rost 
// deoarece nu trimitem nici o informatie despre vreun film
setResult (0);
 
// inchidem formularul
finish ();

In activitatea cu lista de filme, vom suprascrie functie onActivityResult(…). Functia este apelata pentru orice activitate care intoarce un rezultat catre lista de filme (formular de adaugare, formular de modficare etc.), iar selectia se face dupa requestCode.

    @Override
    public void onActivityResult (int requestCode, int responseCode, Intent data)
    {
    	// raspunsul vine de la formularul de adaugare
    	// acolo am cerut raspunsul cu nr 100
    	if (requestCode == 100)
    	{
    		// s-a apasat butonul Adauga
    		if (responseCode==1)
    		{
    			String nume = data.getStringExtra("nume");
    			int an = data.getIntExtra("an", 0);
    			String regizor = data.getStringExtra("regizor");
 
    			// adaptor.adaugaFilm (nume, an, regizor);
    		}
    		// s-a apasat butonul Renunta
    		else if (responseCode==0)
    		{
    		}
    	}
    }

Android – Filtre de Intent-uri

Fiecare componenta trebuie sa declare (in manifest) la ce Intent-uri raspunde, practic cu ce Intent-uri poate fi pornita. Astfel, fiecare componenta trebuie/poate declara:

• actiunea
• categorie
• tipul

Exemplul urmator ilustreaza o activitate ce raspunde la actiunile EDIT si VIEW pentru tipul image/jpeg din categoria DEFAULT.

        <activity android:name=".ImageActivity"
                  android:label="Image Activity">
            <intent-filter>
                <action android:name="android.intent.action.EDIT" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:nameType="image/jpeg"/>
            </intent-filter>
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:nameType="image/jpeg"/>
            </intent-filter>
        </activity>

Salut! Bine ati venit pe ITassistant.org! Eu sunt Vlad si o sa va prezint in acest tutorial cum se defragmenteaza HDD-ul (hard disk drive-ul) cu ajutorul programului Auslogics Disk Defrag.

Pe Itassistant.org mai este un tutorial pe aceasta tema: http://itassistant.org/os-usage/os-tweaks/windows-os-tweaks/cum-si-de-ce-sa-ti-defragmentezi-hard-disk-ul.html

Pentru a downloada Auslogiucs Disk Defrag accesati linkul urmator si dati clik pe download : http://www.auslogics.com/en/software/disk-defrag/

Instalare program defragmentare – Auslogics Disk Defrag

Dupa ce ati downloadat executabilul il rulati prin dublu-clik. In fereastra care a aparut in dreapta jos se afla butonul NEXT pe care o sa dam clik.

Acceptam termenii contractuali bifand optiunea “I accept the agreement” si dand clik pe next.

La acest pas setup-ul ne va intreba unde sa se instaleze programul de defragmentare Auslogics Disk Defrag. Pentru a schimba locatia dam clik pe Browse… . Pentru a continua clik pe next.

Acum vom fi intrebati in ce folder sa se instaleze programul. (eu va recomand sa nu il schimbati) Dam clik pe next.

Daca vrem sa ne faca o iconita pe desktop cu o scurtatura catre program lasam bifata casuta “Create desktop icon” iar daca nu vrem debifam casuta. Clik pe next.

O sa inceapa setup-ul. Instalarea nu o sa dureze foarte mult.

La ultimul pas o sa ne intrebe daca vrem sa lanseze automat programul. Daca nu vrem debifam casuta “Launch Auslogics Disk Defram” si dam clik pe finish.

Asa arata programul la prima lansare:

In partea de sus sunt afisate partitiile. Selectam partitia care vrem sa o defragmentam apoi dam clik dreapta pe ea si selectam optiunea pe care o vrem sa o executam.

Optiuni defragmentare – Auslogics Disk Defrag

• analize – pentru a analiza partitia
• defrag – pentru a defragmenta partitia
• defrag & optimize – pentru defragmentare si optimizare
• quick defrag – pentru defragmentare repida
• check for errors –cautare erori
• properties – pentru proprietati
• check all – pentru verificarea tuturor partitiilor
• uncheck – pentru debifare
• invert checkboxes – pentru a inversa casutele
• check local disk drive – pentru a verifica unitatea de disk locala

Sper ca va placut acest tutorial! Eu am fost Vlad iar voi ati fost pe Itassistant.org. Pentru mai multe tutoriale vizitati Itassistant.org. La revedere!

Salut numele meu este Paul, sunt aici din partea ITAssistang.org, si in acest tutorial va voi arata cum sa creati un nou grup pe forumul vostru phpBB (phpBB inseamna php bulletin board si este unul dintre cele mai folosite script-uri de forum din lume. Asta datorita faptului ca este gratis, usor de instalat si de modificat).

Pasii pentru crearea unui grup pt forumul phpBB sunt:

Pentru inceput ne logam pe contul de adminstrator si intram in Utilizatori si grupuri -> Administrare grupuri

Aici vom scrie in casuta aceea numele noului grup dupa care dati TRIMITE!

Daca vrem ca grupul sa apara in legenda bifam “Arata grupul in legenda“

Daca vrem ca grupul sa primeasca mesaje private bifam “Grupul poate sa primeasca mesaje private“

Pentru a seta grupului culoarea cautam in “Culoarea Grupului“

Dam click pe “Monstra culoare web-safe” si alegem culoarea

Dupa ce am facut urmarit toti acesti pasi apasam pe butonul Trimite

Acum grupul este creat, mai trebuie doar sa facem permisiunile la el, dar acest lucru va fi prezentat in alt tutorial.

Bine ati venit pe itassistant.org, eu sunt Mihai Robert Craciun, iar voi sunteti la primul tutorial de grafica si animatie tridimensionala aici pe site. Pentru aceasta am ales un pachet de 3d destul de cunosut, el se numeste cinema 4d Studio (momentan versiunea R12).

Stiu ca nu este un tutorial relativ nou pentru multi dintre dumneavoastra acest soft a mai fost prezentat si in trecut in romania de alte persoane dar cum nu i sa acordat o importanta prea mare ne-am gandit ca sa deschidem aceasta serie de tutoriale in care vom valorifica la maxim acest program.

De ce am ales Cinema 4d?

Raspunsul este foarte simplu: Pentru usurinta in folosire a acestuia. Sa nu intelegeti din asta ca nu este un program profesional, din contra este un program profesional dar care vine cu o interfata aerisiat, bine structurata in care, pentru a o utiliza talentul nu este necesar dar este binevenit.

Pe langa multele atuuri ale acestui program el poate comunica foarte usor cu alte programe, de exemplu poate importa si exporta fisiere de photoshop, illustrator, chiar si 3ds max.

Mai vreau sa adaug ca folosesc aproximativ de 2 ani acest program si sunt foarte multumit de el, asta este si unul dintre motivele pentru care incep aceasta serie de tutoriale. Cu toate ca este un program comercial mi se pare relativ ieftin in comparatie cu cea ce face si daca stam sa ne gandim un program cum ar fi Maya 3d costa o avere plus cartile sau cursurile pe care la un moment dat ar trebui sa le platiti ar lasa un gol destul de adanc in buzunarele dumnevoastra.

Salut, bine ati venit pe ITassistant.org, in tutorialul de mai jos, va prezint un sistem PC, pe care o sa il folosim la un sistem de supraveghere de 4 sau 32 de camera, sau video din alte surse.

Avem nevoie de un sistem low power, care nu consuma multe resurse. Am ales o placa de la Intel, si un processor tot de la Intel, ca sa nu existe incompatibilitati de sistem. Dupa cum stiti placa Intel de baza, are o mica chestie, care alte placi nu o au, booteaza foarte repede in comparative cu alte placi.

Memoria RAM 4GB este de ajuns in modul Dual Channel.

La partea de HDD este optional, pentru ca stiti ca in perioada aceasta HDD-urile sunt foarte scumpe, din cauza inundatilor din Thailanda. Si am pus o carcasa Mini-ITX care nu ocupa spatiu, care are o sursa Chieftec de 200W reali.

Si pentru economisirea cablurilor de retea, am pus si un modul Wireless care va ajuta sa numai folositi cablurile RJ-45, asta bineinteles daca aveti router wireless. Si in caz ca si pachetul de camera al vostru contine si iesire pe Wireless, economisiti si mai multe fire, o idee buna zic eu.

Link-uri produse – sistem de streaming video

• Placa de Baza
• Procesor
• Memorie
• Carcasa
• HDD
• Modul Wireless

Daca intampinati ceva probleme, lasati-ne feedback!

Atentie! Pe acest sistem, bagati doar softurile necesare pentru video, si folositi Windows 7 Home Premium.

Salut, numele meu este Mihai si inainte de a ataca subiectul de astazi tin sa va urez “Sarbatori Fericite!” si “La Multi Ani!“. Sa ne vedem cu bine si in anul 2012!

Foarte multi dintre voi va uitati la tutoriale video pe Internet. Unii dintre cei care o faceti doriti si voi sa faceti tutoriale video, chiar pe ITAssistant.org. Asa ca m-am gandit sa postez un mic ghid despre cum se face un tutorial video bun si de calitate.

Pasul I: Alegerea subiectului

Nu putem vorbi despre orice. Subiectul trebuie ales cu grija. Ne uitam si noi daca nu s-a mai facut un tutorial asemenator, sau daca subiectul nu este prea comun, adica un tutorial despre cum se da Copy-Paste. Exista sanse mari sa primiti multe comentarii si voturi negative, din cauza ca ei care se uita la tutorial il considera “prea usor”.

Subiectul in general trebuie sa fie unul original. Originalitatea este una din conditiile succesului unui tutorial video, mai ales daca acesta este postat pe YouTube.

Pasul II: Documendarea si organizarea prezentarii

Avem subiectul, dar cum il abordam? Nu putem doar sa vorbim despre el din ce stim noi, sau ce am auzit de la prieteni. Acest gen de tutorial intra la “Asa NU”.

Fara o documentare solida, nu putem sa ne prezentam in fata privitorilor nostri. Daca printre ei se nimereste un “expert”, care stie foarte multe despre acel subiect?

Asa ca ne punem pe citit. Sa zicem ca vrem sa facem un tutorial despre un soft. In primul rand descarcam soft-ul si ne uitam atent la el si toate optiunile sale.

Daca exista un lucru pe care nu stim cum sa il abordam, sau care nu stim cum se face (de exemplu o functie), folosim un motor de cautare si mai mult ca sigur ca vom afla.

Dupa ce cunoastem bine program-ul, este bine (macar la primele doua-trei tutoriale video) sa ne facem un plan de prezentare, adica sa ne organizam pe o foaie modul de a prezenta acel soft. Nu putem sa incepem de oriunde, trebuie sa avem un fir logic pentru a putea fi urmariti mai usor.

ATENTIE! Nu folositi cuvinte si/sau expresii pe care nu le stapaniti bine, doar ca sa dati impresia ca sunteti superiori. Se trezeste vreun vizitator sa va intrebe ce inseamna acel cuvant/expresie si voi sa nu stiti. Nu e sinonim cu “m-am facut de ras”?

Incercati sa folositi un limbaj cat mai explicit. Daca introduceti o notiune noua, incercati sa o explicati cat mai bine.

Sa nu va fie frica sa faceti analogii cu viata reala. Dand exemple din viata reala (desi pare o tammpenie), utilizatorii neinitiati vor intelege mult mai bine, facand conexiuni.

Pasul III: Inregistrarea tutorialului

Aici vine partea cea mai grea. Tin minte ca la primul meu tutorial de baiat mare, am avut emotii mari cat casa, a trebuit sa il inregistrez de zeci de ori, pana sa iasa bine. Ideea era ca trebuia sa fie perfect, asa cerea “seful” meu de atunci si avea motive sa o faca.

Chiar si astazi sunt foarte dur cu mine si la orice greseala intrerupt captura si o reiau de la capat.

Trebuie sa avem grija si la modul in care vorbim. Nu incepem sa vorbim repede si apoi incet, ca ne-am plictisit, trebuie sa continuam in aceiasi nota. Iarasi foarte important, aici nu se aplica regula “Pauzele lungi si dese, cheia marilor succese!”. Facand pauze, dam dovada de nesiguranta si pe deasupra, cel care ne vede se poate plictisi, oprind vizionarea tutorialului.

Din punct de vedere tehnic, realizati captura la o rezolutie decenta (recomandat 1280*720). Nu vorbiti departe de microfon si nu tipati, oricat de bucurosi sunteti ca veti aparea pe Internet.

Pasul IV: Codarea si postarea tutorialului

Codarea este bine sa se faca in format MP4 (calitate 50% e suficient). E bine sa puneti un watermark (logo, imagine) pe tutorialele voastre, pentru a nu fi copiate si puse pe alte canale de YouTube, sau pe alte site-uri.

Titlul tutorialui trebuie sa fie atragator. De exemplu daca facem un tutorial despre cum se instaleaza Windows XP, nu il numim “Movie_1.mp4″, ci putem sa ii spunem “Tutorial video instalare Windows XP [HD]“. Astazi se pune accent foarte mult pe continutul HD.

Pasul V: Discutia cu utilizatorii

Este foarte importanta comunicarea cu utilizatorii. De aceea spuneam mai sus ca este foarte important modul in care ne documentam. Trebuie sa stim bine despre ceea ce vorbim si poate un pic mai mult. Sunt foarte multi useri care au nelamuriri si noi suntem oarecum obligati sa le clarificam. Daca ei simt ca noi nu suntem stapani pe subiect, ne vor privi tutorialele cu scepticism.

Sper ca acest articol sa va fie util. In cazul in care vreti sa postati tutoriiale la noi pe site, nu ezitati sa ne contactati. Mai multe detalii gasiti in drepta site-ului. O zi buna in continuare!

Salut prieteni! Bine ati venit pe Itassistant.org astazi o sa va arat cum se intsaleaza Microsoft Windows 8 Developer Preview.

Acest sistem se poate instala pe masina virtuala (ex: Virtual Box sau VMware) doar daca procesorul vostru suporta virtualizare.

Fiecare stie ce procesor are si daca acesta suporta virtualizare

Cerintele de sistem pentru acest nou Windows sunt urmatoarele:

• Procesor 1 GHz sau mai bun
• 1 GB RAM ( 2GB pentru versiunea pe 64bit)
• 16 GB liberi pe HDD (20 GB pentru versiunea pe 64bit)
• driver grafic DirectX 9 cu WDDM 1.0 sau mai bun

Dupa cum ati putut vedea cerintelea cestui Windows nu sunt exagerate. (asemanatoare cu cele pt Windows 7).

Dupa ce ati downloadat imaginea ISO cu Windows 8 o ardeti pe un DVD sau o puneti pe un stik USB (merge doar cu soft-ul de la Microsoft) intrati in BIOS setati ca sa booteze de pe Dvd sau stikul USB.

1. Introduceti Dvd cu Windows 8 in unitatea optica si dati restart la PC.
2. Cand apare mesajul “Press any key to boot from CD or DVD” ca saintre in Setup apasati orice tasta.

3. Selectati limba (recomand sa lasati English)

4. Aceptati termenii contractuali

5. Acum am ajuns la pasul in la care trebuie sa creem partitiile. (In cazul in care avetiun HDD mai mic sau egal de 30 GB eu recomand sa lasati doar o partitie)

6. Acum asteptati sa copieze fisierele de pe DVD/stik USB in HDD. Eventual PC-ul se va restarta de cateva ori.

7. Acceptam iar termenii si conditiile

8. Dam numele Pc-ului, apoi dam clik pe butonul NEXT.

9. Datorita faptului ca Windows 8 este un sistem de operare dual el vine si cu un dublu mod de autentificare si anume:
• mod local – prin care se creaza un nume de utilizator
• mod web – prin care se poatefolosii un cont de windows live

Deoarece in momentul crearii contului de autentificare nu avem si posibilitatea crearii unei conexiuni de tip PPPOE cei care folosesc acest mod vor trebui sa foloseasca modul de autentificare local.

Pentru cei care nu stiu la ce m-am referit aici este vorba de iconita aceea de la RDS sau Romtelecom in care trebuie sa aveti introdus un user si o parola ca sa va mearga Internetul.

10. Creati userul si daca doriti puteti sa puneti si o parola.

11. Daca ati urmat pasi de mai sus corect acum ar trebui ca Windows 8 sa fie gata de utilizare.

Pentru cei care nu stiu puteti downloada Windows 8 de aici: http://msdn.microsoft.com/en-us/windows/apps/br229516 ; tot aici gasiti si alte detalii despre Windows 8.

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android – Liste – BaseAdapter

Pentru lista ce trebuie sa afiseze informatii mai complexe decat un rand de text, trebuie sa scriem un adaptor (o clasa ce implmenteaza interfata ListAdapter). Pentru ca interfata ListAdapter are foarte multe metode, un mod mai simplu este sa extindem clasa BaseAdapater. De fapt trebuie sa implementam urmatoarele patru functii:

class MyAdapter extends BaseAdapter
{
	@Override
	public View getView (int position, View convertView, ViewGroup list) 
	{
		// functia trebuie sa intoarca view-ul de pe pozitia position din lista
		// convertView este un element din lista ce nu mai este vizibil si poate fi convertit
	}
 
	@Override
        public int getCount ()
        {
		// intaorce nr de elemente din lista
	}
 
	@Override
	public Object getItem(int position) 
	{
		// intoarce elementul de pe pozitia position din model
	}
 
	@Override
	public long getItemId(int position) 
	{
		// fiecare element din lista poate avea un id, nu este insa obligatoriu
	}
}

Pentru a exemplifica mai bine, vom modifica exemplul de mai sus, astfel incat sa afisam doua linii de text. Clasa Personaj ramane aceeasi ca in exemplul: Invata Sistemul de Operare Android – Partea 5.

Primul pas este sa realizam un nou fisier XML (separat) ce va descrie cum arata fiecare element grafic (View) din lista. Il vom plasa in

res/layout/personaj.xml

personaj.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:orientation="vertical">
  	<TextView android:id="@+id/personaj_nume"
  	     android:layout_width="fill_parent"
  	     android:layout_height="wrap_content"
  	     android:textStyle="bold"/>
 
  	<TextView android:id="@+id/personaj_desen"
  	     android:layout_width="fill_parent"
  	     android:layout_height="wrap_content"/>
</LinearLayout>

Urmeaza sa realizam fisierul cu codul sursa. Acesta va contine o clasa ce extinde BaseAdapter si clasa activitatii (ListActivity).

class Personaj
{
    public String nume;
    public String desen;
 
    @Override
    public String toString ()
    {
        // acesta functie este apelata de catre ArrayAdapter pentru a transforma obiectul intr-un String ce
        // sa fie afisat in lista
        return nume+" din desenul animat "+desen;
    } 
}
 
class PersonajeAdapter extends BaseAdapter
{
	private Activity context;
	ArrayList<Personaj> personaje;
 
	public PersonajeAdapter (Activity _context)
	{
		this.context = _context;
		personaje = new ArrayList<Personaj>();
	}
 
	@Override
	public View getView (int position, View convertView, ViewGroup list) 
	{
		// functia trebuie sa intoarca view-ul de pe pozitia position din lista
		// convertView este un element din lista ce nu mai este vizibil si poate fi convertit
		View element;
		LayoutInflater inflater = context.getLayoutInflater();
		element = inflater.inflate(R.layout.personaj, null);
 
		TextView nume = (TextView)element.findViewById(R.id.personaj_nume);
		TextView desen = (TextView)element.findViewById(R.id.personaj_desen);
 
		nume.setText(personaje.get(position).nume);
		desen.setText(personaje.get(position).desen);
 
		return element;
	}
 
	@Override
        public int getCount ()
        {
		// intaorce nr de elemente din lista
                return personaje.size ();
	}
 
	@Override
	public Object getItem(int position) 
	{
		// intoarce elementul de pe pozitia position din model
		return personaje.get(position);
	}
 
	@Override
	public long getItemId(int position) 
	{
		// fiecare element din lista poate avea un id, nu este insa obligatoriu
		return 0;
	}
 
        public void adaugaFunnyGuy (String nume, String desen)
        {
              Personaj p = new Personaj ();
              p.nume = nume;
              p.desen = desen;
              personaje.add (p);
              // acesta functie deterimina adaptorul sa ceara listei sa reafiseze continutul
              this.notifyDataSetChanged();
        }
}
 
public class ListaDeseneAnimate extends ListActivity
{
    // ArrayList<Personaj> personaje; -> mutat in PersonajeAdapter
    PersonajeAdapter adapter;
 
    @Override
    public void onCreate (Bundle savedInstanceBundle)
    {
    	super.onCreate (savedInstanceBundle);
        // personaje = new ArrayList<Personaj>(); -> mutat in Personaje Adapter
        adapter = new PersonajeAdapter (this);
        setContentView (R.layout.main);
        setListAdapter (adapter);
 
        // adaugam cateva personaje in lista
        adapter.adaugaFunnyGuy("Bugs Bunny", "Looney Toons");
        adapter.adaugaFunnyGuy("Fred Flinstone", "The Flinstones");
        adapter.adaugaFunnyGuy("Betty Rubble", "The Flinstones");
 
        // pentru a seta actiunea click lung
        getListView().setOnItemLongClickListener(new OnItemLongClickListener() 
		{
 
			public boolean onItemLongClick(AdapterView<?> listAdapter, View view,
					int position, long id) 
			{
                                Personaj p = (Personaj)adapter.getItem (position);
                                Toast.makeText(ListaDeseneAnimate.this, "click lung pe "+p.nume, Toast.LENGTH_LONG).show();
				return true;
			}
		});
    }
 
    @Override
    public void onListItemClick (ListView list, View v, int position, long id)
    {
        // afisam numele personajului pe care s-a dat click folosind un Toast
        Personaj p = (Personaj)adapter.getItem (position);
        Toast.makeText(this, p.nume, Toast.LENGTH_LONG).show();
    }
}

Sunt importante urmatoarele observatii:

• modelul (ArrayList) a fost mutat in adaptor. Acesta este de fapt legatura intre lista si date, deci el este cel care trebuie sa cunoasca datele, si nu fereastra
• implementarea functiei getView() nu este eficienta, nu este folosit parametrul convertView.
• setarea actiunii pentru click-ul lung se face direct pe lista, nu exista o functie in ListActivity ce sa poata fi suprascrisa

Implementarea eficienta presupune folosirea parametrului convertView. Acesta este fie null, caz in care trebuie ignorat, fie un obiect intors aterior de catre getView(), insa obiect care nu mai este vizibil. Ideea este ca, in loc de a crea un nou View de fiecare data, sa se refoloseasca View-urile create anterior si care nu mai sunt vizibile.

        @Override
	public View getView (int position, View convertView, ViewGroup list) 
	{
		// functia trebuie sa intoarca view-ul de pe pozitia position din lista
		// convertView este un element din lista ce nu mai este vizibil si poate fi convertit
		View element;
                if (convertView == null)
                {
		         LayoutInflater inflater = context.getLayoutInflater();
		         element = inflater.inflate(R.layout.personaj, null);
                }
                else element = convertView;
 
		TextView nume = (TextView)element.findViewById(R.id.personaj_nume);
		TextView desen = (TextView)element.findViewById(R.id.personaj_desen);
 
		nume.setText(personaje.get(position).nume);
		desen.setText(personaje.get(position).desen);
 
		return element;
	}

In imaginea de mai jos este prezentat modul in care poate arata o lista construita cu BaseAdapter (acestea pot fi liste mai complexe, care pot contine eventual alte componente cum ar fi imagini, pentru liste simple construite cu ArrayAdapter puteti urmari: Invata Sistemul de Operare Android – Partea 5)

Android – GridView

GridView este o componenta similara cu ListView, doar ca afiseaza elementele sub forma unui grid. Functioneaza pe aceelasi principiu ca ListView si foloseste aceelasi tip de adaptor.

Modificarile ce trebuiesc facte sunt:

• XML-ul fiecarui element din lista, deoarece trebuie tinut cont ca acesta nu mai este singur pe linie, deci trebuie sa aiba o dimensiune limitate
• nu se poate folosi ListActivity, fereastra trebuie sa fie una normala. Pentru a atasa adaptorul pe GridView, trebuie sa obtineti prima data un pointer catre acesta cu ajutorul functiei getViewById.

Android – Gallery

Gallery este o componenta similara cu ListView, doar ca afiseaza elementele sub forma unui benzi derulante. Functioneaza pe aceelasi principiu ca ListView si foloseste aceelasi tip de adaptor.

Modificarile ce trebuiesc facte sunt:

• XML-ul fiecarui element din lista, deoarece trebuie tinut cont ca acesta nu mai este singur pe linie, deci trebuie sa aiba o dimensiune limitate
• nu se poate folosi ListActivity, fereastra trebuie sa fie una normala. Pentru a atasa adaptorul pe Gallery, trebuie sa obtineti prima data un pointer catre acesta cu ajutorul functiei getViewById.

Bine ati venit pe ItAssistant. Aceasta noua serie de tutoriale isi propune sa va familiarizeze cu Sistemul de Operare Android astfel incat sa puteti sa scrieti singuri aplicatii pentru propriul SmartPhone, si de ce nu, aplicatia sa ajunga in top pe Android Market.

Inainte de a incepe trebuie sa cunoasteti destul de bine limbajul de programare Java si conceptele Programarii Orientata Obiect; puteti sa aruncati o privire peste tutorialele noastre avansate: Invata Java

Android – Liste

Astazi ne vom ocupa de implementarea listelor. Sub platforma Android, acestea sunt implementate folosind modelul MVC (Model View Controller). Modelul este reprezentat de datele ce trebuie afisate, View-ul este lista propriu-zisa si Controller-ul este programul care controleaza modul de afisare.

Mai exact vom vorbi despre listele implementate cu ArrayAdapter (pentru liste implementate cu BaseAdapter puteti urmari Invata Sistemul de Operare Android – Partea 6).

ListActivity

Un View de tip ListView poate fi plasat pe orice tip de activitate (Activity). In mod normal, descriem ListView-ul in fisierul XML atasat activitatii, ii dam un id si in codul java luam un pointer catre el (vezi findViewById (R.id.)).

Exista insa un mod mai simplu. In general, pe o activitate exista o singura lista, astfel ca Android ne pune la dispozitie un tip special de activitate, numit ListActivity, care rezolva automat preluarea pointer-ului listei. In xml, trebuie declarat obligatoriu un ListView cu id-ul @android:id/list.

De asemenea, ListActivity pune la dispozitie urmatoarele functii:

// seteaza adaptorul pentru lista de pe ferastra
void setListAdapter (ListAdapater adapter);
 
// intoarce adaptorul listei de pe fereastra
ListAdapter getListAdapter ();
 
// intoarce un pointer catre lista din fereastra
ListView getListView ();

O alta functie oferita de catre ListActivity este onListItemClick(). Acesta este apelata automat de fiecare data cand se executa un click asupra unui element din lista. Initial functia este vida, in alte cuvinte, nu face nimic. Pentru a-i adauga o actiune, programatorul trebuie sa suprascrie acesta functie.

    @Override
    public void onListItemClick (ListView list, View v, int position, long id)
    {
        // list - este lista de pe fereastra
        // v - este elementul din lista pe care s-a dat click
        // position - este pozitia pe care s-a dat click (de fapt pozitia la care se afla elementul v in lista)
        // id - este id-ul elementului (obtinut prin functia getItemId () a adaptorului	
    }

ListAdapter

In Android, lista este de fapt un ScrollView vertical. Sarcina programatorlui este de fapt crearea componentelor View pentru fiecare linie din acest ScrollView. In alte cuvinte, daca ne uitam la poza de mai sus, ceea ce trebuie noi sa facem este sa scriem componenta Adapter. Din punct de vedere ar programarii, asta inseamna crearea unui obiect care sa implementeze interfata ListAdapater.

Biblioteciile Android ne pun la dispozitie mai multe variante de a implmenta ListAdapter.

Android – ArrayAdapter

Pentru lista simple, ce contin element cu o singura linie de text se poate folosi o clasa mult simplificata, si anume ArrayAdapter. Acesta presupune ca toate elementele sunt stocate intr-un sir (ex: Object[]) sau o lista (orice obiect ce implementeaza interfata List).

Deoarece fiecare element din lista este o linie de text si in sir sau lista noi pastram obiecte, adaptorul va apela functia toString() pe fiecare obiect.

Un exemplu de folosire este urmatorul:

class Personaj
{
    public String nume;
    public String desen;
 
    @Override
    public String toString ()
    {
        // acesta functie este apelata de catre ArrayAdapter pentru a transforma obiectul intr-un String ce
        // sa fie afisat in lista
        return nume+" din desenul animat "+desen;
    } 
}
 
public class ListaDeseneAnimate extends ListActivity
{
    ArrayList<Personaj> personaje;
    ArrayAdapter<Personaj> adapter;
 
    @Override
    public void onCreate (Bundle savedInstanceBundle)
    {
    	super.onCreate (savedInstanceBundle);
        personaje = new ArrayList<Personaj>();
        adapter = new ArrayAdapter<Personaj>(this, android.R.layout.simple_list_item_1, personaje);
        setContentView (R.layout.main);
        setListAdapter (adapter);
 
        // adaugam cateva personaje in lista
        adaugaFunnyGuy("Bugs Bunny", "Looney Toons");
        adaugaFunnyGuy("Fred Flinstone", "The Flinstones");
        adaugaFunnyGuy("Betty Rubble", "The Flinstones");
    }
 
    @Override
    public void onListItemClick (ListView list, View v, int position, long id)
    {
        // afisam numele personajului pe care s-a dat click folosind un Toast
        Toast.makeText(ListaDeseneAnimate.this, personaje.get(position).nume, Toast.LENGTH_LONG).show();
    }
 
    private void adaugaFunnyGuy (String nume, String desen)
    {
        Personaj p = new Personaj ();
        p.nume = nume;
        p.desen = desen;
        personaje.add (p);
        // acesta functie deterimina adaptorul sa ceara listei sa reafiseze continutul
        adapter.notifyDataSetChanged();
    }
}

In imaginea de mai jos este prezentat modul in care va arata o lista construita cu ArrayAdapter (dupa cum am precizat, sunt liste simple, doar cu text; pentru liste mai complexe puteti urmari Invata Sistemul de Operare Android – Partea 6).