Visual C++ – Componentes complexos

Então, quer criar um Media Player, Browser ou algo assim em C++ e não sabe por onde começar? O Visual C++ tem vários componentes para sua aplicação que poderiam ser chamados de complexos escondidos. Se você ainda é novato no Visual C++, pode obter alguma ajuda aqui. Veremos quais são os principais:

WEBBROWSER

Um dos únicos que não está “escondido” e disponível na toolbox de cara. Você pode criar um browser simples com apenas algumas linhas de código. Parece ser o coração do Internet Explorer, porque aqui a fonte do título do meu site apareceu desconfigurada do mesmo jeito nesse browser e no IE. Apesar de algumas incompatibilidades e uma funcionalidade extremamente limitada, esse browser é bem rápido. Se quiser criar seu próprio browser “homemade” siga esse vídeo:

MEDIA PLAYER

Bem, eu so achei tutoriais sobre esse componente em Visual Basic, porém muito pouco muda em C++. Inicie um projeto de Forms no Visual C++. Este componente não está na toolbox por default, então vá em Tools, Choose toolbox items, procure Windows Media Player na aba COM e marque sua checkbox. Arraste para a janela o Media Player e o File Chooser Dialog. Clique duas vezes no Media Player e adicione esse código:

axWindowsMediaPlayer1->URL = openFileDialog1->FileName;

Agora volte ao Design da Form, clique duas vezes no File Chooser e adicione esse código:

openFileDialog1->ShowDialog();

Pronto! Já tem um Media Player funcionando. Se quiser ver o vídeo do Visua Basic aqui está:

Java – A grande Tabela das keywords

Como meu primeiro post sobre Java, resolvi criar uma tabela para consulta rápida que lista as palavras-reservadas dessa linguagem e explica sua finalidade e seu uso. Aqui está ela:

Código	Utilidade	Exemplo
abstract	Usado para declarar classes abstratas que não podem ser instanciadas.	abstract class AbstractClass  { }
assert	Usado para checar se alguma variável tem um valor inesperado durante o tratamento de erros.	assert IsMinus != false;
boolean	Usado para declarar variáveis do tipo boolean.	boolean variable = true;
break	Usado para encerrar loops antes do término normal do mesmo.	for(int i = 0; i < 10; i++) { if(i = 5) break; }
byte	Usado para declarar variáveis do tipo byte.	byte six = 6;
case	Usado para declarar condições dentro de uma condição switch.	Switch(Id) { case  45: System.out.println(“Id 45 não é aceito.”);
catch	Usado para capturar exceções dentro de um bloco try {	catch(NumberFormatException nfexc) {
char	Usado para declarar variáveis do tipo char.	Char e = ‘e’;
class	Usado para declarar classes.	public class Example {
const	Usado para declarar uma constante.	const int MyConstant = 70;
continue	Pula o fim de uma iteração de um laço, indo para o começo da próxima iteração.	for(int i = 0; i < 5; i++) { if(i = 3) continue;
default	Usado para definir uma situação default em uma condição switch.	switch(defaultSample) { default: System.out.println(default);
do	Usado para iniciar loops do-while.	do{ i++; }while(i < 10);
double	Usado para declarar variáveis do tipo double	double d = 76.45;
else	Usado para começar uma condição else ou else if.	if(i ==1) System.out.println(“1 código”); else if(I == 0) System.out.println(“Nada”); else System.out.println(i + “códigos”);
enum	Usado para declarar uma enumeração.	public enum AD { A, B, C, D }
extends	Usado para declarar que a classe é derivada de uma classe-base.	public class Son extends Father {
false	Usado para inicializar ou comparar uma variável lógica com o valor falso.	boolean b = false;
final	Usado em três casos: Variável: Garante que seu valor não será mudado. Classe: Garante que não poderá ter subclasses. Funções: Não poderam ser sobrecarregadas.	public final class FinalClass { public final int FinalFunction() { public final String finalString; } }
finally	Usado para garantir a execução de um trecho final no tratamento de exceções.	try { }finally { System.out.println(“Finally”); }
float	Usado para declarar variáveis do tipo float.	float PI = 3.14;
for	Usado para iniciar um loop for.	for(int i = 0; i < 100; i++) {
if	Usado para declarar uma condição if.	if(Pi != 3.14) {
implements	Usado para implementar funções de uma classe em outra.	public class Square implements Shapes {
import	Usado para importar classes e pacotes para seu programa.	import javax.swing.*;
instanceof	Usado para determinar a classe de uma instância	if(Xinstance instanceof X) {
int	Usado para declarar uma variável do tipo int.	int Number = 90;
interface	Usado para declarar uma classe abstrata que outras classes deverão implementar.	public interface MyInterface {
long	Usado para declarar uma variável do tipo long.	long Number = 90000;
native	Usado para dizer que um método esta implementado em outra linguagem de programação.	public static native int NativeMethod();
new	Usado para inicializar uma variável na memória do sistema.	public String newStr[] = new String[5];
null	Usado para declarar ou comparar uma variável como null.	String NullStr = null;
package	Usado para declarar um pacote, ou seja, um conjunto de classes.	package Website;
private	Usado para declarar o modo de acesso de uma variável como privado.	private double result = 76.45;
protected	Usado para declarar o acesso de uma variável/função como protegido.	protected int Nine = 9;
public	Usado para declarar o acesso de uma variável/função como público.	public char t = ‘t’;
return	Usado para retornar um valor a partir de uma função.	public int returnTen() { return 10;
short	Usado para declarar uma variável do tipo void.	void value = 5;
static	Usado para garantir que uma variável terá apenas uma referência na memória.	static float PI = 3.14;
strictfp	Usado para garantir resultados mais precisos nos cálculos com valores de ponto flutuante.	public strictfp double calc() { return 67.3434 * 45.6575; }
super	Usado para chamar o construtor da classe base de uma classe derivada.	public class AppSwing extends JFrame { public AppSwing() { super(“App”); }
switch	Usado para iniciar uma condição switch();	switch(counter) {
synchronized	Usado para sincronizar o acesso a uma classe/função/variável ou código.	synchronized int SyncFunction() {
this	Usado como uma referência para a própria classe.	double result = this.calc();
throw	Usado para lançar exceções.	throw new Exception();
throws	Usado para declarar que uma função lança certa exceção.	public int Function() throws IOException {
transient	Usado para garantir que uma variável não será serializada.	transient double Pi = 3.14;
true	Usado para inicializar ou comparar valores booleanos como verdadeiros.	boolean TrueValue = true;
try	Usado para iniciar um bloco de tratamento de exceções.	try { } catch(Exception exc) {
void	Usado para declarar uma função/variável como void.	void MyVoidVar;
volatile	Usado para garantir que múltiplas threads poderão acessar o objeto simultaneamente.	volatile int Products;
while	Usado para iniciar um loop while.	while(Products < 40) {

O arquivo(doc) para baixar segue abaixo:

http://www.4shared.com/file/135075457/7ecd790f/palavras_reservadas.html

Código	Utilidade	Exemplo
abstract	Usado para declarar classes abstratas que não podem ser instanciadas.	abstract class AbstractClass  { }
assert	Usado para checar se alguma variável tem um valor inesperado durante o tratamento de erros.	assert IsMinus != false;
boolean	Usado para declarar variáveis do tipo boolean.	boolean variable = true;
break	Usado para encerrar loops antes do término normal do mesmo.	for(int i = 0; i < 10; i++) { if(i = 5) break; }
byte	Usado para declarar variáveis do tipo byte.	byte six = 6;
case	Usado para declarar condições dentro de uma condição switch.	Switch(Id) { case  45: System.out.println(“Id 45 não é aceito.”);
catch	Usado para capturar exceções dentro de um bloco try {	catch(NumberFormatException nfexc) {
char	Usado para declarar variáveis do tipo char.	Char e = ‘e’;
class	Usado para declarar classes.	public class Example {
const	Usado para declarar uma constante.	const int MyConstant = 70;
continue	Pula o fim de uma iteração de um laço, indo para o começo da próxima iteração.	for(int i = 0; i < 5; i++) { if(i = 3) continue;
default	Usado para definir uma situação default em uma condição switch.	switch(defaultSample) { default: System.out.println(default);
do	Usado para iniciar loops do-while.	do{ i++; }while(i < 10);
double	Usado para declarar variáveis do tipo double	double d = 76.45;
else	Usado para começar uma condição else ou else if.	if(i ==1) System.out.println(“1 código”); else if(I == 0) System.out.println(“Nada”); else System.out.println(i + “códigos”);
enum	Usado para declarar uma enumeração.	public enum AD { A, B, C, D }
extends	Usado para declarar que a classe é derivada de uma classe-base.	public class Son extends Father {
false	Usado para inicializar ou comparar uma variável lógica com o valor falso.	boolean b = false;
final	Usado em três casos: Variável: Garante que seu valor não será mudado. Classe: Garante que não poderá ter subclasses. Funções: Não poderam ser sobrecarregadas.	public final class FinalClass { public final int FinalFunction() { public final String finalString; } }
finally	Usado para garantir a execução de um trecho final no tratamento de exceções.	try { }finally { System.out.println(“Finally”); }
float	Usado para declarar variáveis do tipo float.	float PI = 3.14;
for	Usado para iniciar um loop for.	for(int i = 0; i < 100; i++) {
if	Usado para declarar uma condição if.	if(Pi != 3.14) {
implements	Usado para implementar funções de uma classe em outra.	public class Square implements Shapes {
import	Usado para importar classes e pacotes para seu programa.	import javax.swing.*;
instanceof	Usado para determinar a classe de uma instância	if(Xinstance instanceof X) {
int	Usado para declarar uma variável do tipo int.	int Number = 90;
interface	Usado para declarar uma classe abstrata que outras classes deverão implementar.	public interface MyInterface {
long	Usado para declarar uma variável do tipo long.	long Number = 90000;
native	Usado para dizer que um método esta implementado em outra linguagem de programação.	public static native int NativeMethod();
new	Usado para inicializar uma variável na memória do sistema.	public String newStr[] = new String[5];
null	Usado para declarar ou comparar uma variável como null.	String NullStr = null;
package	Usado para declarar um pacote, ou seja, um conjunto de classes.	package Website;
private	Usado para declarar o modo de acesso de uma variável como privado.	private double result = 76.45;
protected	Usado para declarar o acesso de uma variável/função como protegido.	protected int Nine = 9;
public	Usado para declarar o acesso de uma variável/função como público.	public char t = ‘t’;
return	Usado para retornar um valor a partir de uma função.	public int returnTen() { return 10;
short	Usado para declarar uma variável do tipo void.	void value = 5;
static	Usado para garantir que uma variável terá apenas uma referência na memória.	static float PI = 3.14;
strictfp	Usado para garantir resultados mais precisos nos cálculos com valores de ponto flutuante.	public strictfp double calc() { return 67.3434 * 45.6575; }
super	Usado para chamar o construtor da classe base de uma classe derivada.	public class AppSwing extends JFrame { public AppSwing() { super(“App”); }
switch	Usado para iniciar uma condição switch();	switch(counter) {
synchronized	Usado para sincronizar o acesso a uma classe/função/variável ou código.	synchronized int SyncFunction() {
this	Usado como uma referência para a própria classe.	double result = this.calc();
throw	Usado para lançar exceções.	throw new Exception();
throws	Usado para declarar que uma função lança certa exceção.	public int Function() throws IOException {
transient	Usado para garantir que uma variável não será serializada.	transient double Pi = 3.14;
true	Usado para inicializar ou comparar valores booleanos como verdadeiros.	boolean TrueValue = true;
try	Usado para iniciar um bloco de tratamento de exceções.	try { } catch(Exception exc) {
void	Usado para declarar uma função/variável como void.	void MyVoidVar;
volatile	Usado para garantir que múltiplas threads poderão acessar o objeto simultaneamente.	volatile int Products;
while	Usado para iniciar um loop while.	while(Products < 40) {

C++ – Criando janelas usando apenas código

Em outro tutorial mostrei como criar janelas usando Visual C++, da Microsoft, uma forma muito fácil, mas se o leitor não gosta do estilo do Visual C++ e nem das extensões que foram incorporadas ao C++ nesse compilador, é possível criar janelas em C++ puro. Vou usar o Dev C++, um compilador bem simples para exemplificar a criação de uma janela feita “a mão” em C++, pode baixá-lo aqui. Precisará de um pouco de conhecimento em C++ e Windows, e vamos criar uma aplicação que calcula a hipotenusa a partir dos catetos! Inicie um novo projeto clicando no botão azul onde está escrito DEV, localizado no canto superior esquerdo da janela. No diálogo que será iniciado, digite um nome para o projeto e clique em Windows Application. Um código deve ter sido criado. Delete esse código, vamos começar a criação da janela passo-a-passo. Agora cole esse:

// Cabeçalhos necessários
#include <windows.h>
#include <stdlib.h>

LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

// WinMain, a função main em janelas
int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)
{

HWND hwnd;      // O objeto para indicar a janela
MSG messages;   // Objeto mensagem do Windows para controlar o acionamento de botões
WNDCLASSEX wincl;   // O objeto para criar a janela

wincl.hInstance = hThisInstance;
wincl.lpszClassName = “WindowsAppl”; // Nome da classe da janela
wincl.lpfnWndProc = WindowProcedure;
wincl.style = CS_DBLCLKS;
wincl.cbSize = sizeof (WNDCLASSEX);
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);      // Janela com icone default do Windows
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);          //Cursor default
wincl.lpszMenuName = NULL;
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;       // Cor cinza de background

if (!RegisterClassEx (&wincl))  // Se o registro da classe foi mal-sucedido return 0
return 0;

hwnd = CreateWindowEx (               // Criação da janela
0,
“WindowsAppl”,                 // Indicação da classe da janela
“Hello World”,                 // Nome da janela
WS_OVERLAPPEDWINDOW,           // Estilo da janela
350,                               // x em relação ao desktop
250,                                 // y em relação ao desktop
300,                                  // largura da janela
300,                               // altura da janela
HWND_DESKTOP,
NULL,
hThisInstance,
NULL
);

ShowWindow (hwnd, nFunsterStil);                // Mostrar a janela

while (GetMessage (&messages, NULL, 0, 0)) // Recuperar mensagens
{
TranslateMessage(&messages);
DispatchMessage(&messages);
}

return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE: // Criação da janela
break;
case WM_COMMAND:   // Interpretação da janela
break;
case WM_DESTROY:   // Destruição da janela
PostQuitMessage (0);
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}

O cabeçalho #include<windows.h> é obrigatório em qualquer aplicação que use janelas no Windows. O outro cabeçalho(stdlib.h) contém a biblioteca de funções do Windows e C++. Depois iniciamos uma Procedure do Windows e a função WinMain, que configura, cria e deixa visível a janela. Dentro dessa função precisamos definir uma variável HWND para a janela, uma variável MSG para armazenar as ações do usuário e da janela e uma variável WNDCLASSEX para configurar e criar a janela. A seguir podemos ver a variável wincl que definimos anteriormente chmando variáveis de configuração. Entre elas, podemos ver algumas importantes como lpszClassName, que define o nome da classe da janela, as outras importantes se tiver interesse pode ver nos comentários do código. Depois verificamos se a classe foi registrada com sucesso e criamos a janela com a função CreateWindowEx, pode ver os parâmetros importantes dessa função nos comentários. Depois mostramos a janela, recuperamos a variável messages determinada anteriormente, e agora uma parte importantíssima, que é a definição do WindowProcedure, a função chamada quando o usuário interage com a janela. Dentro da WindowProcedure temos um switch, e quando a condição é WM_CREATE a janela é criada, quando a condição é WM_COMMAND é porque o usuário interagiu com um componente da janela, e quando é WM_DESTROY é porque a janela foi destruída! A única dessas condições com algo além de break por enquanto é a WM_DESTROY, em que chamamos a função PostQuitMessage para destruir a janela. Aperte f9 para compilar. Isso é o que deve aparecer:

COLOCANDO OS COMPONENTES

Criamos uma janela vazia. Agora é hora de colocar os componentes!  Precisaremos de dois Textbox para a entrada dos valores dos catetos, um botão para acionar, duas labels para indicar os campos do cateto a e cateto b, e após o cálculo ser completado, disparar uma MessageBox com o resultado. Cole esse código acima da função WindowProcedure:

#define BUTTONOK 10

HINSTANCE g_inst;
HWND Cateto1, Cateto2, ButtonOk;

void DrawComponents(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {

CreateWindowEx (
0,
“STATIC”,
“Cateto a”,
WS_VISIBLE|WS_CHILD,
30, 20, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);
Cateto1 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 50, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

CreateWindowEx (
0,
“STATIC”,
“Cateto b”,
WS_VISIBLE|WS_CHILD,
30, 80, 60, 20,
hwnd,
NULL,
g_inst,
NULL
);

Cateto2 = CreateWindowEx (
WS_EX_CLIENTEDGE,
“EDIT”,
“”,
WS_VISIBLE|WS_CHILD|WS_BORDER,
30, 110, 50, 20,
hwnd,
NULL,
g_inst,
NULL
);

ButtonOk = CreateWindowEx (
0,
“BUTTON”,
“Ok”,
WS_VISIBLE|WS_CHILD,
40, 140, 20, 20,
hwnd,
(HMENU)BUTTONOK,
g_inst,
NULL
);

}

Dentro da função WindowProcedure e do switch, chame essa função que acabamos de criar desse modo dentro do WM_CREATE:

DrawComponents(hwnd,message,wParam,lParam);

Com esse código criamos uma função para desenhar os componentes na janela, e podemos ver a função CreateWindowEx ser chamada, mas dessa vez, com parâmetros diferentes. Os parâmetros mais importantes são: o segundo(tipo do componente), o terceiro(texto do componente), o quarto(Definição de que o componente será visível e filho da janela), o quinto(distância da esquerda), sexto(distância do topo), sétimo(largura do componente), e oitavo(altura do componente). Podemos também ver a declaração de algumas variáveis HWND, que guardarão os dados das Textbox e do botão, para sabermos seus valores e se foram acionados. O botão precisa excepcionalmente de um ID, criado com #define anteriormente. Finalmente chamamos a função que criamos e informamos os parâmetros definimos na função WinMain. Aperte f9 e deverá ver isso:

CRIANDO A LÓGICA DA APLICAÇÃO

Agora que já criamos todos os componentes, devemos calcular a hipotenusa. Inclua no seu programa o cabeçalho math.h para podermos calcular a raiz quadrada. Agora copie esse código para dentro do WM_COMMAND no switch do WindowProcedure.

if ((HIWORD(wParam) == BN_CLICKED))
{

SendMessage(
(HWND) Cateto1,
(UINT) EM_GETLINE,
(WPARAM) 1,
(LPARAM) &Cat1
);

SendMessage((HWND)Cateto2,(UINT)EM_GETLINE,(WPARAM)1,(LPARAM) &Cat2);

CatetoA = atoi(Cat1);
CatetoB = atoi(Cat2);
int Hipotenusa_quadrado = CatetoA*CatetoA + CatetoB*CatetoB;
hipotenusa = sqrt(Hipotenusa_quadrado);

itoa (hipotenusa,Hipot,10);

MessageBox (NULL, Hipot, “Resultado”, MB_OK);
}

Antes da função WindowProcedure também copie essas variáveis:

char Cat1[20] = “0″, Cat2[20] = “0″, Hipot[20] = “0″;
int CatetoA, CatetoB, hipotenusa;

Neste código colocamos uma condição if(HIWORD == BN_CLICKED) para determinar se o botão foi clicado. Se foi o código abaixo do if será executado. Com a função SendMessage nós recuperamos o texto digitado nas duas textBox e iniciamos duas variáveis String determinadas anteriormente com o seu valor. Depois fazemos uma conversão de String para int coma  função atoi e finalmente calculamos a hipotenusa! Mas ainda não acabou. Precisamos converter de int para String para podermos mostrar o resultado em uma MessageBox. Agora sim! Abaixo seguem a imagem do programa em ação e o link para download do código:

Download Source

CONCLUSÃO

O que levaria cinco linhas de código para fazer no Visual C++ levou mais de 100 no Dev C++. Programar janelas em C++ sem usar facilitadores como os do Visual C++ gasta muito mais tempo, mas em compensação é mais flexível e deixa o programa mais rápido. Recomendo programar assim apenas programas que realmente necessitem desse tipo de programação.

Android – Múltiplas Activities

Aplicações complexas no Android precisam de mais de apenas uma tela(Activity), então aqui vou mostrar como criar múltiplas Activities. Demonstrarei o uso desse recurso em um programa que calcula a área de um quadrado, uma aplicação clássica. Assumo que já tem uma avd Android 1.5 e o ambiente de trabalho configurado, além de um conhecimento básico do emulador, de Java e do Android. Estarei usando o Eclipse para cria-las, mas você poderá estar usando qualquer outra IDE. Para começar, crie um novo projeto do Android no Eclipse. Uma Activity principal deve ter sido criada no projeto pelo Eclipse e já configurada no Android Manifest, o arquivo de configurações. Abaixo da linha super.onCreate(bundle) na Activity, adicione setContentView(R.layout.main). Isso fará com que a aplicação use as configurações do arquivo xml main na pasta layout para definir a tela. Na estrutura do projeto, navegue até res/layout/main.xml para definir os textBox e o botão que queremos na tela principal para calcular área. Clique na tab main.xml acima do console e cole esse código antes da tag </Linear Layout>:

<EditText android:id=”@+id/Altura” android:layout_height=”wrap_content” android:layout_width=”wrap_content”></EditText>
<EditText android:id=”@+id/Comprimento” android:layout_width=”wrap_content” android:layout_height=”wrap_content”></EditText>
<Button android:layout_width=”wrap_content” android:layout_height=”wrap_content” android:id=”@+id/Ok” android:text=”Ok”></Button>

Agora que já temos tudo configurado precisamos recuperar os valores dos EditText e definir o que acontecerá quando o botão for clicado. Mas antes vamos criar a Activity que exibirá o resultado do cálculo da área. Vá em File -> New -> File, digite activity2 como nome e selecione o pacote em que está trabalhando. Agora digite esse código na Activity principal, abaixo do setContentView:

         final EditText comprimento = (EditText) findViewById(R.id.altura);
	 final EditText altura = (EditText) findViewById(R.id.comprimento);
	 final Intent it = new Intent(this, activity2.class);
	 Button b = (Button) findViewById(R.id.Ok);
	 b.setText("Clique para calcular a área!");
	 b.setOnClickListener(new Button.OnClickListener() {
		 public void onClick(View v) {
	int comprimentoi = Integer.parseInt(comprimento.getText().toString());
	int alturai = Integer.parseInt(altura.getText().toString());
	it.putExtra("values", "E o resultado é: " + alturai * comprimentoi);
	startActivity(it);
		 }
	 });

Aqui nós recuperamos os valores definidos em main.xml com o método findViewById e colocamos um Listener para o botão b, que recuperou o valor do botão ok no arquivo main. No método onClick, que possui o código a ser executado quando o botão for clicado, há apenas uma conversão para int dos valores dos EditText, e, mais importante, um parâmetro foi posto no Intent it pelo método putExtra e a activity activity2 foi iniciada pelo método startActivity.

RECUPERANDO PARÂMETROS

Agora só precisamos exibir o parâmetro do Intent it na activity2. Copie esse código para o método onCreate da activity2:

                TextView view = new TextView(this);
                view.setText("");
		Intent it = getIntent();
		if(it != null) {
			String msg = it.getStringExtra("values");
			if(msg != null) {
				view.setText(msg);
			}
		}
		setContentView(view);

Criamos uma nova TextView para exibir os valores, criamos um novo Intent para capturar o Intent que o direcionou para esta Activity, verificamos sua validade, configuramos uma String para achar o parâmetro String “values” passado pela Activity anterior e finalmente configuramos o texto para exibir essa String! Agora está tudo pronto! Abaixo vemos a aplicação em ação:

3D Studio Max 2009 – Modificando e modelando um objeto

Neste tutorial mostrarei como aplicar modificadores a objetos paramétricos e modelar objetos editáveis, as maiores ferramentas para criação de modelos complexos, e para seguir este tutorial com sucesso precisará de um conhecimento básico do 3D Studio, pode encontrar aqui. No 3D Studio Max 2009 existem dois tipos de objeto. Existe o objeto paramétrico e o editável. O paramétrico é um objeto para o qual podem ser passados parâmetros para especificar altura, tamanho, etc… Os modificadores só podem ser aplicados a objetos paramétricos. Um objeto editável, por outro lado, não pode receber esses parâmetros e nem modificadores podem ser aplicados a esse tipo. Então o que podemos fazer com objetos editáveis? Os objetos editáveis podem ser modelados, uma solução muito flexível. Abaixo podemos ver um cilindro editável com alguns segmentos a mais sendo editado.

MODIFICANDO OBJETOS PARAMÉTRICOS

As primitivas do 3D Studio são por default paramétricas. Podemos aplicar modificadores nessas primitivas no painel Modify. Não vou explicar os modificadores aqui, porque são muitos, e isso resultaria em um tutorial muito grande, e depois você pode conhecer os outros modificadores você mesmo. Para este tutorial vamos criar uma cadeia de DNA.

1. Crie a primitiva Plane no painel Create.
2. Vá ao painel Modify e preencha o parâmetro Length Segs para 11, Width Segs para 1, Length para 300 e Width para 60.
3. No topo do painel Modify há um Rollout chamado Modifier List. Nessa lista estão os modificadores que vamos aplicar. Clique nesse rollout e no Modificador Lattice.
4. Marque a Radio Box Icosa nos parâmetros do modificador Lattice na categoria Joints e digite 6 nos segmentos.
5. Clique novamente na Modifier List e selecione Twist.
6. No parâmetro Angle do Twist digite 360 e marque a Radio Box Y na categoria Twist Axis.
7. Agora nós temos algo muito semelhante com uma cadeia de DNA, mas você deve ter notado que as juntas ficaram meio achatadas. Para corrigir isso arraste o modificador Twist para baixo de Lattice.
8. Renderize a cena clicando no botão Render e temos uma cadeia de DNA pronta!

COMO ISSO FOI FEITO?

Você pode estar se perguntando pra que foram necessários todos aqueles passos. Os ajustes dos segmentos do Plane foram necessários para criar as juntas certas quando o modificador lattice fosse aplicado. O Lattice transformou os segmentos em cilindros e suas extremidades em juntas para dar ao Cilindro uma aparência de DNA, e os ajustes em seus parâmetros foram usados para transformar as juntas em esferas, como nas gravuras de DNA. Enfim, o Twist foi usado para girar o DNA em 360 graus.

MODELANDO OBJETOS EDITÁVEIS

Existem vários tipos de objetos editáveis. Neste tutorial usarei Editable Poly. Antes de começar devo explicaro uso do Soft Selection. Vamos criar algumas montanhas em um Plane agora.

1. Crie um objeto Plane(não muito pequeno) e no parâmetro Width Segs digite 12 e em Length Segs também.
2. Clique com o botão direito nesse objeto e depois em Convert To -> Editable Poly.
3. Vá ao Painel Modify e clique no botão de mais a esquerda de Editable Poly.
4. Selecione o subojeto Vertex.
5. Selecione qualquer um dos pontos que aparecem sobre o plano e você poderá escalá-lo, girá-lo, mudar sua posição e até deletá-lo! Tudo isso usando as ferramentas básicas de Scale, Rotate e Move, mas antes de começar a modificá-lo devo informar da ferramenta Soft Selection. Essa ferramenta permite uma transformação menos abrupta das vértices de um objeto editável. Para usá-la marque a checkbox Use Soft Selection. Abaixo dessa checkbox haverão valores de Fallof e Pinch para declarar quanto outras vértices serão afetadas. Divirta-se!

A cena renderizada deve ter ficado pelo menos um pouco parecida com isso: