Bibliotecas para aplicações Desktop: QT e GTK

QT é uma biblioteca de desenvolvimento para aplicações Desktop para multiplas plataformas (MS-Windows, GNU/Linux, Mac OS X, Embedded Linux e Windows CE). Possui várias ferramentas de geração e edição de código, como KDeveloper e QT Design.

Atualmente, é desenvolvido pela Nokia:
http://qt.nokia.com/

GTK é também uma biblioteca de desenvolvimento para aplicações Desktop para multiplas plataformas (MS-Windows, GNU/Linux e Mac OS X). Também possui ferramentas para geração de interface e algum código.

É sustentado por uma comunidade Open Source:
http://www.gtk.org/

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Como “chamar” o telefone no iPhone em Objective C

Pelo que me disseram (tentei testar no emulador, mas não funciona :P), é só criar uma “URL” com o protocolo “tel:” mais o número do telefone. Exemplo:

//Cria o objeto NSURL com uma String (“protocolo:numero_do_telefone”)
NSURL* phoneURL = [NSURL URLWithString: @“tel:1234567890”];
//Chama a aplicação externa para abrir a URL
[[UIApplication sharedApplication] openURL: phoneURL];

Também é possivel criar uma página web para iPhone, com o mesmo protocolo:

Ligue-me&lt/a&gt

Sei lá, tomara que isso ajude alguém 🙂

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do programador java.

Que diabos são as operações &#8220;<<" e ">>&#8221; no Javascript

São operadores de bit a bit. 🙂

Hum Melhor ir as explicações:

– O operador “
var inteiro = 1; //(64 bits) -> 00000001 (1)
alert("Número original: ” + inteiro);
inteiro = inteiro 64 bits) -> 00000010 (2)
alert(“Número deslocado uma casa para a esquerda: ” + inteiro);

– E o operador “>>” descola o valor bit a bit de uma variável, da esquerda para direita. Exemplo:

var inteiro = 4; //(64 bits) -> 00000100 (4)
alert(“Número original: ” + inteiro);
inteiro = inteiro >> 2; //descola duas “casas” para a direita (64 bits) -> 00000001 (1)
alert(“Número deslocado duas casas para a direita: ” + inteiro);

Se formos pensar bem, estes operadores “multiplicam” (“>”) o número por dois. Isso acontece por causa que os computadores trabalham com números binários (“bi” igual a “dois”, entendeu? 😛 )

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Drag&#8217;n Drop de elementos gráficos (Java-AWT)

Um rapaz me perguntou como seria fazer um drag’n drop (na mão) de um elemento gráfico em uma tela.
Então resolvi postar uma resposta aqui no blog. 🙂
Como ele não especificou a linguagem, vou fazer em Java/AWT (será que alguém ainda usa isso?!? 😛 ), que foi a linguagem que mais trabalhei nos últimos 10 anos

Primeiramente, vamos criar uma janela de tamanho fixo (no caso, 300×300):

//Herda de Frame (Janela)
public class MainClass extends Frame {

    //Construtor da classe
    public MainClass() {
        //Tamanho da janela
        this.setSize(300, 300);
        //Título da janela
        this.setTitle(“Exemplo Gráfico”);
    }

    //Método principal que inicia a aplicação
    public static void main(String arg[]) {
        //Instância o objeto
        MainClass main = new MainClass();
        //Exibe a tela
        main.setVisible(true);
    }
}

Para evitar que a janela fique “ad-eterno” na tela, mesmo clicando no “X”, vamos implementar a função de fechar da janela em seu construtor:

    //Construtor da classe
    public MainClass() {
        
         //“Escutador” de eventos de janela
         this.addWindowListener(new WindowAdapter() {
             //Método que é executado quando o usuário clicar no botão de fechar da janela (ou algum evento que tenha a mesma funcionalidade, como o Ctrl+X no MS-Windows)
            @Override
            public void windowClosing(WindowEvent e) {
                //Encerra a aplicação
                System.exit(0);
            }
        });
            
    }

Legal, temos uma janela feita em Java! 🙂

Vamos para o segundo passo: criamos um objeto gráfico (neste caso, um retângulo) como uma propriedade da classe e instanciamos esta em seu construtor:

public class MainClass extends Frame {
    private Rectangle rect;
   
    public MainClass() {
         
          //Retângulo a ser desenhado
          rect = new Rectangle(50, 50, 60, 30);
         
    }
   
}

E agora vamos desenhar este retângulo na tela, reescrevendo os métodos paint e update:

   //Para evitar o “pisca-pisca” (efeito de blink) da tela
    @Override
    public void update(Graphics g) {
        this.paint(g);
    }
   
    //Desenha um retângulo vermelho em um fundo preto (retângulo do tamanho da tela)
    @Override
    public void paint(Graphics g) {
        //Pinta a tela de preto
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, this.getWidth(), this.getHeight());
        //Pinta um retângulo vermelho
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(),
                (int)rect.getWidth(), (int)rect.getHeight());
    }

Executamos e temos um retângulo vermelho em um fundo preto (eu já disse isso em algum lugar?). 🙂

Nesta terceira etapa, precisamos identificar os eventos de drag’n drop, que são (eu acho ):
1) O evento de botão do mouse pressionado para obter o efeito de “pegar” o retângulo;
2) O evento de soltar o botão do mouse para obter o efeito de “largar” o retângulo;
3)  E o evento de movimento do mouse, para que o retângulo acompanhe o “ponteiro” do mouse enquanto ele não for solto;

Com isso, a classe vai ficar mais ou menos assim:

import java.awt.*;
import java.awt.event.*;

//Herda de Frame (Janela)
public class MainClass extends Frame {

    //Retângulo a ser desenhado
    private Rectangle rect;
    //Flag que indica se o objeto esta sendo “arrastado”
    private boolean elementDragged;
    //Ponto (x,y) da tela onde o ponteiro do mouse estava inicialmente
    private Point initial;
 
    //Construtor da classe  
    public MainClass() {
        //Retângulo a ser desenhado
        rect = new Rectangle(50, 50, 50, 50);
        //Tamanho da janela
        this.setSize(300, 300);
        //Título da Janela
        this.setTitle(“Exemplo Gráfico”);
        this.addEventListener();
    }
   
     //Método privado que adiciona os eventos
    private void addEventListener() {
        //“Escutador” de eventos de janela
        this.addWindowListener(new WindowAdapter() {
             //Método que é executado quando o usuário clicar no botão de fechar da janela (ou algum evento que tenha a mesma funcionalidade, como o Ctrl+X no MS-Windows)
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        //“Escutador” de eventos do mouse
        this.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                mousePressedEvent(e);
            }           
            @Override
            public void mouseReleased(MouseEvent e) {
                mouseReleasedEvent(e);
            }
        });
        //“Escutador” de eventos de movimento do mouse
        this.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent e) {
                mouseDraggedEvent(e);
            }
        });
    }
   
    //Quando o botão do mouse é pressionado, este método é executado
    private void mousePressedEvent(MouseEvent e) {
        //Se o ponteiro do mouse esta dentro do retângulo
        if (rect.contains(e.getPoint())) {
            //Obtenho o ponto inicial do ponteiro do mouse
            initial = new Point((int)(e.getPoint().getX() rect.getX()),
                    (int)(e.getPoint().getY() rect.getY()));
            //E digo que o retângulo pode ser “arrastado”
            elementDragged = true;
        }       
    }
   
    //Quando o mouse é “arrastado”, este método é executado
    private void mouseDraggedEvent(MouseEvent e) {
        //Se o retângulo pode ser “arrastado”
        if (elementDragged) {
            //Faço ele movimentar-se de acordo com a posição do ponteiro do mouse
            rect.setLocation((int)((e.getPoint().getX() initial.getX())),
                    (int)(e.getPoint().getY() initial.getY()));
            //Redesenho a tela
            this.repaint();
        }
    }           
 
   //Quando o botão do mouse é “solto”, este método é executado
    public void mouseReleasedEvent(MouseEvent e) {
        //Digo que o retângulo não esta mais “arrastavel”
        elementDragged = false;
        //E “zero” a posição inicial
        initial = null;
    }
   
    //Para evitar o “pisca-pisca” (efeito de blink) da tela
    @Override
    public void update(Graphics g) {
        this.paint(g);
    }
   
     //Desenha um retângulo vermelho em um fundo preto (retângulo do tamanho da tela)
    @Override
    public void paint(Graphics g) {
        //Pinta a tela de preto
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, this.getWidth(), this.getHeight());
        //Pinta um retângulo vermelho
        g.setColor(Color.RED);
        g.fillRect((int)rect.getX(), (int)rect.getY(),
                (int)rect.getWidth(), (int)rect.getHeight());
    }
 
    //Método principal que inicia a aplicação (tudo começa aqui 🙂 )
    public static void main(String arg[]) {
        //Instância a classe
        MainClass main = new MainClass();
        //Exibe a tela
        main.setVisible(true);
    }
}

Parece que funciona (eu testei no MacOSX 10.7.4, com o JDK 1.6.0_33)

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Qual é a diferença entre métodos public, protected, private e &#8220;default&#8221; no Java?

Dúvida de um pessoal aqui, que vou tentar (eu disse “tentar” 😛 ) explicar.

No Java, existem quatro tipos de “permissões” de acesso a métodos (isso também vale para classes e propriedades, com algumas exceções ) que, dependendo de sua escolha, parte do seu código-fonte vai ou não “enxerga-la” durante a execução/compilação deste. São elas:

public : A mais fácil de explicar, pois todo código tem acesso a ela! 🙂
Exemplo:

Arquivo: Util.java

package teste.util;
_
_

public class Util {

           public void nothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}

Arquivo: Main.java

package teste.main;
_
_ import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      util.nothing();
           }
}

private : A mais restrita das quatro, onde somente a classe que a declarou tem acesso:

Arquivo: Util.java

package teste.util;
_
_ public class Util {
            //Este método é chamado somente dentro desta classe
           private void privateNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
_
_            public void publicNothing() {
                    System.out.println(“Será que chamo?”);
                    this.privateNothing();
           }
}

Arquivo: Main.java

package teste.main;
_
_ import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.privateNothing(); //NÃO FUNCIONA
                      util.publicNothing();
           }
}

(Até aqui, foi bem simples explicar. Mas a partir de agora que vem o problema :P)

protected : Este “acesso” é meio estranho, mas vamos lá: a classe que declarou, as classes que estão no mesmo pacote e a classe que herdou desta, tem acesso a ela.
Putz Confuso não? Melhor pedir ajuda ao exemplo. (universitários? nem pensar!) 😛

Arquivo: Util.java

package teste.util;
_
_ public class Util {
           protected void protectedNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}
_
_ Arquivo: Inutil.java

package teste.util;
_
_ //Não herdou mas esta no mesmo pacote (isto funciona!)
public class Inutil {
           public void nothing() {
_                   __Util util = new Util();_
_                   util.__protectedNothing();_
_           }_
_}_
_
_ Arquivo: HerancaUtil.java

package teste.heranca;
import teste.util.Util;
_
_ //Herdou, mas não esta no mesmo pacote (isto funciona!)
public class HerancaUtil extends Util {
           public void nothing() {
_                   super__.__protectedNothing();_
_           }_
_}_

Arquivo: Main.java

package teste.main;

__import teste.heranca.HerancaUtil;

import teste.util.Inutil;

import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.protectedNothing(); //NÃO FUNCIONA
                      Inutil inutil = new __Inutil();_
_                      inutil.nothing();_
_                      __HerancaUtil
 h__erancaUtil__ = new HerancaUtil();

                      h__erancaUtil.nothing();
           }
}

(Só falta uma 🙂 )

default : O acesso é restrito as classes que estão no mesmo pacote, ou seja, classes que não estejam no mesmo pacote, mesmo as que herdam da que declarou o método, não o acessam.

Arquivo: Util.java

package teste.util;
_
_ public class Util {
           void defaultNothing() {
                    System.out.printf(“Estou fazendo %s\n”,“Nada”);
           }
}
_
_ Arquivo: Inutil.java

package teste.util;
_
_ //Não herdou mas esta no mesmo pacote (isto funciona!)
public class Inutil {
           public void nothing() {
                   Util util = new Util();_
_                   util.__defaultNothing
();

           }
}
_
_ Arquivo: HerancaUtil.java

package teste.heranca;
import teste.util.Util;
_
_ //Herdou, mas não esta no mesmo pacote (NÃO funciona!)
public class HerancaUtil extends Util {
           public void nothing() {
                   //super__.default__Nothing(); //NÃO FUNCIONA
           }
}

Arquivo: Main.java

package teste.main;

__import teste.heranca.HerancaUtil;

import teste.util.Inutil;

import teste.util.Util;
_
_ public class Main {
           public static void main(String args) {
                      Util util = new Util();
                      //util.defaultNothing(); //NÃO FUNCIONA
_                      __Inutil inutil = new __Inutil();_
_                      inutil.nothing();_
_           }_
_}_

(Ufa, terminou! 🙂 )

Espero que alguém compreenda o que esta escrito 😛

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Whitespace: Programando com espaços em branco

Essa sugestão é de um colega meu. 🙂

Sabia que dá para programar somente com espaços em brancos, tabs e enters?

Pois é, existe uma linguagem chamada Whitespace, onde você programa somente com caracteres não visuais.
Quer saber mais da linguagem e baixar ela? Entre no site:
http://compsoc.dur.ac.uk/whitespace/index.php

Abaixo, o exemplo de “Hello World”:

Say hello. Estranho, não? (não testei, portanto, nem sei se funciona ) 😛

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Robomind: Robocode + Logo

Robomind é mais uma aplicação educacional para ensinar as pessoas a entender este mundo louco e maravilhoso dos programadores (ou seja, ela ensina a programar :P).

O conceito básico do aplicativo: você tem um “robô” que é comandado por instruções do tipo “ande para frente”, “vire a esquerda” e outros. O objetivo é criar programas que façam o robô caminhar sem bater nos obstáculos (ou algo parecido ).

Quem estiver interessado, pode obter mais informações e baixar o aplicativo no site:
http://www.robomind.net/pt/index.html

Programação Java é aqui. Acesse as o blog para ficar atualizado sobre o mundo da **Linguagem Java. Dicas, informações e muitos truques para se usar no dia-a-da do **programador java.

Application Craft: Desenvolvendo aplicações nas nuvens!

Muito se fala em Cloud Computing, em HTML5 e em Mobile, todas tecnologias “novas” onde a maioria das empresas desta área estão começando a se interessar

Pensando nisso, surgiram algumas