SQL de +770 profissões e cargos

Muito bem, após procurar na internet a lista de cargos e profissões para inserir em um auto completar de um sistema de cadastro de vagas de emprego e não encontrar nada mastigado, somente uma lista em txt de profissões, tive de transformar isso em arquivo SQL válido para inserir no MySQL.
O resultado foi este aqui neste link:

http://www.4shared.com/document/-SQN3yd-/profissoes.html

=========================================================================
O trabalho que tive não se repetirá mais e faço minha parte em contribuir com este SQL mastigado agora.  Espero ter contribuido a quem precisar.
Um abraço e até logo.

Instalando o Blue Fish Editor no Windows (Programação em PHP+Apache+MySQL)

Olá a todos,
Neste tutorial vou mostrar como é simples a instalação de um poderoso editor de Códigos para diferentes linguagens de programação, oBlueFish:

• C/C++
• CSS
• CFML
• gettext PO
• HTML, XHTML and HTML5
• Java
• JavaScript
• JSP
• Octave/MATLAB
• Pascal
• Perl
• PHP
• Python
• R
• Ruby
• Shell
• SQL
• XML

Se você for desenvolvedor ou aprendiz de desenvolvimento PHP, sugiro este editor para o tutorial em questão, visto trabalhar com Open Source é um privilégio para quem não pode pagar a licença de softwares proprietários.
A instalação do BlueFish para Windows é bem simples e intuitiva como veremos a segui.
Primeiro baixe o aplicativo no seguinte endereço:
http://sourceforge.net/projects/bluefish/files/bluefish/2.0.2/Bluefish-2.0.2-1-setup.exe/download

Feito isso siga dos passos de instalação que pode ser vistos a seguir nas figuras abaixo:

Este passo em especial é interessante para configurar a  linguagem para português brasileiro, basta selecionar a opção em "Select Components to install:"

 Neste passo é solicitado a linguagem do pacote da biblioteca gráfica GTK, sendo igualmente intuitivo a sua instalação:

Após a instalação da biblioteca GTK, o instalador dá continuidade a finalização da instalação:

Clique em "Next" para escolher as plataformas de desenvolvimento que você pretende desenvolver agora ou no futuro:

Após clicarmos em "Finish", pronto seu poderoso editor está configurado para trabalhar!

Esta é a sua tela de trabalho instalada e rodando corretamente no S.O Windows:

Observe a barra de ferramentas "Padrão" do Blue Fish, sem dúvida automatiza bastante a construção de estruras com apenas alguns cliques de conteúdo para tabelas, formulários, inserção de imagens, CSS entre outros:

Barra de ferramenta "Fontes":

Barra de ferramentas "Tabelas":

Barra de ferramentas "Frames":

Barra de ferramentas "Formulários":

Barra de ferramentas "Lista":

Barra de ferramentas "CSS":

Sendo feito este pequeno tutorial para apresentar como se instala e um pouco sobre o software, fiquem a vontade em testar e inclusive visitem o site oficial para maiores informações sobre o uso do mesmo. 

No meu caso uso o Blue Fish instalado na máquina local para desenvolvimento rápido de formulários em aplicações que rodam em servidor Apache local (WAMP Server) e feita a programação colaborativa com o Plugin do "Eclipse For PHP" para SVN (Subversion).  Mais informações a respeito podem ser encontradas em: http://www.ibm.com/developerworks/br/library/os-ecl-subversion/.

Estarei em novos tutoriais mostrando como instalar no Linux Ubuntu, que inclusive é ainda mais simples que no próprio Windows.  Neste exemplo usei o Windows 7 Pro para instalar a última versão do Blue Fish 2.0.2.

Um abraço a todos e até a próxima. 

Curso de Python

    Bom gente, estou a um bom tempo sem postar neste blog, mas acredito que agora vou postar com mais freqüencia. Estou aqui só para prepara-los e dizer que vou postar uma série de postagens neste blog sobre python.
    Não vou prometer para vocês um cursos completo, mas nos meus planos estava em fazer pelo menos o básico. Depois conforme for eu vou postando coisas mais avançadas.
   Não esqueçam de comentar galera!

Vamos participar deste Projeto? Stella NFe

PROJETO DE DESENVOLVIMENTO COMUNITÁRIO DE SOFTWARE DE NOTA FISCAL ELETRÔNICA (NF-e)

Para quem precisa implementar de maneira funcional e objetiva para seus clientes um módulo de emissão de NF-e em seu sistema comercial ou ERP, segue o link do projeto para que os que se identificam com o desenvolvimento em Java possam contribuir para a melhoria.  Acessem este link para melhores informações de como tem andado o projeto de Nota Fiscal Eletronica em Java:
http://stella.caelum.com.br/nfe-index.html

Junte-se ao grupo e contribua!!!

Um abraço a todos e até logo.

Continuando o raciocínio da postagem anterior

Olá a todos, conforme raciocíno da postagem anterior que se referia a Tela Transparente em Java 2D, apresento de fontes em postagem em blogs relacionados a Java o seguinte codigo de exemplo:

======================================================================
    import java.awt.Dimension; 
    import java.awt.Graphics; 
    import java.awt.Image; 
    import java.awt.Point; 
    import java.awt.Rectangle; 
    import java.awt.Robot; 
    import java.awt.Toolkit; 
    import javax.swing.JComponent; 
     
   public class TransparentBackground extends JComponent { 
       private Image background; 
    
       public TransparentBackground() { 
           updateBackground(); 
       } 
    
       public void updateBackground() { 
           try { 
               Robot rbt = new Robot(); 
               Toolkit tk = Toolkit.getDefaultToolkit(); 
               Dimension dim = tk.getScreenSize(); 
                
               background = rbt.createScreenCapture( 
                       new Rectangle(0, 0, (int) dim.getWidth(), 
                       (int) dim.getHeight())); 
           } catch (Exception ex) { 
               ex.printStackTrace(); 
           } 
       } 
    
       public void paintComponent(Graphics g) { 
           Point pos = this.getLocationOnScreen(); 
           Point offset = new Point(-pos.x, -pos.y); 
           g.drawImage(background, offset.x, offset.y, null); 
       } 
   } 
    
  // ------------Outra Classe 
    
   import java.awt.AlphaComposite; 
   import java.awt.Container; 
   import java.awt.Graphics; 
   import java.awt.Graphics2D; 
   import java.awt.Image; 
    
   import javax.swing.ImageIcon; 
   import javax.swing.JFrame; 
    
   public class TranparenciaEx1 extends TransparentBackground { 
       private AlphaComposite makeComposite(float alpha) { 
           int type = AlphaComposite.SRC_OVER; 
           return (AlphaComposite.getInstance(type, alpha)); 
       } 
    
       private void drawSquares(Graphics2D g2d, float alpha) { 
           //Composite originalComposite = g2d.getComposite(); 
           //g2d.setComposite(originalComposite); //Voltar ao composite original 
            
           g2d.setComposite(makeComposite(alpha)); 
            
           ImageIcon Imagem = new javax.swing.ImageIcon( "/fundo_pbase.jpg" ); 
           //ImageIcon Imagem = new javax.swing.ImageIcon( "/bola.png" ); 
           Image Ico = new ImageIcon(Imagem.getImage().getScaledInstance(getWidth(), getHeight(), 1)).getImage(); 
           g2d.drawImage(Ico, 0, 0, this); 
            
           //g2d.setPaint(Color.BLACK); 
           //g2d.fill( this.getBounds() ); 
       } 
    
       public void paintComponent(Graphics g) { 
           super.paintComponent(g); 
    
           Graphics2D g2d = (Graphics2D) g; 
            
    
           //drawSquares(g2d, 1 * 0.1F); 
           //drawSquares(g2d, 2 * 0.1F); 
           //drawSquares(g2d, 3 * 0.1F); 
           //drawSquares(g2d, 4 * 0.1F); 
           //drawSquares(g2d, 5 * 0.1F); 
           //drawSquares(g2d, 6 * 0.1F); 
           drawSquares(g2d, 7 * 0.1F); 
           //drawSquares(g2d, 8 * 0.1F); 
           //drawSquares(g2d, 9 * 0.1F); 
           //drawSquares(g2d, 10 * 0.1F); 
            
           //g2d.translate(deltaX, 0); 
    
   //        for (int i = 0; i < 11; i++) { 
   //            drawSquares(g2d, i * 0.1F); 
   //            g2d.translate(deltaX, 0); 
   //        } 
       } 
    
       public static JFrame openInJFrame(Container content) { 
           JFrame frame = new JFrame("Transparente"); 
           //frame.setUndecorated(true); 
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
           frame.setSize(400, 400); 
         frame.setLocationRelativeTo(null); 
          
          content.setLayout(null); 
           
          frame.getContentPane().add( content ); 
   
          frame.setVisible(true); 
          return (frame); 
      } 
   
      public static void main(String[] args) { 
          openInJFrame(new TranparenciaEx1());  
      } 
  } 
======================================================================
Outras refeências: http://www.guj.com.br/java/116365-tela-transparente
======================================================================
Espero que haja um comentário, um abraço e até logo a todos(as).

Uma visão rápida sobre o Java 2D

Olá a todos os participantes e não participantes deste blog, com o intuito de promover a tecnologia (sempre), deixo este artigo para compartilhar a todos os que tem interesse:

Uma visão rápida sobre o Java 2D Escrito por Vinícius Godoy de Mendonça

O Java 2D é uma API extensa e poderosa. Ele faz parte do JDK padrão, e inclui diversos tipos de funções para desenhar diretamente na tela, desenhar texto, manipular imagens e utilizar a impressora. Nesse artigo, vamos conhecer um pouco da terminologia básica do Java 2D, e ver de maneira resumida suas funcionalidades.

Introdução

O Java 2D é implementado como uma extensão do Abstract Window Toolkit (AWT). Ele tornou-se muito poderoso depois da adição de outra extensão: o Swing. Inicialmente, os projetistas da AWT delegavam a tarefa de desenhar janelas, botões e caixas de texto ao sistema operacional. Mas logo perceberam que isso não era muito portável, e limitava severamente a performance do Java em aplicações mais sérias. Então, decidiram associar a AWT uma nova extensão, chamada Swing, que desenharia integralmente todos os componentes de tela. Ao fazer isso, a biblioteca Java 2D ganhou grande importância.
O Swing rapidamente tornou-se o padrão do Java para todo o tipo de aplicação desktop. Entretanto, uma de suas grandes reclamações sempre foi a performance, o que motivou os desenvolvedores da Sun a investir em otimizações agressivas no Java 2D. Entre elas, está a aceleração de hardware (integrada com OpenGL), possibilidade de trabalhar em modo janela exclusivo (FSEM), otimizações agressivas na biblioteca de manipulação de imagens, entre outras coisas.
Dentre as principais capacidades do Java 2D, podemos citar:

• Um modelo uniforme de desenho para dispositivos de vídeo e impressoras;
• Um grande número de primitivas geométricas (retângulos, elipses, curvas), e um mecanismo para se desenhar qualquer forma geométrica;
• Mecanismos para detectar colisão em texto e imagens;
• Modelos de composição (Alpha Composition), que permitem escolher como combinar imagens que se interceptam;
• Modelo de cores avançado;
• Diretivas para controlar a qualidade do desenho;
• Classes para manipulação uniforme dos principais formatos de imagem;

Desenho com Java 2D

Espaço de coordenadas

O Java 2D permite o trabalho em dois tipos de sistemas de coordenadas. As coordenadas do dispositivo e as coordenadas de usuário. As coordenadas do dispositivo se referem ao sistema do hardware que está sendo trabalhado. Vão alterar de acordo com a resolução de tela, ou o tamanho da folha, por exemplo.
Já as coordenadas do usuário são um sistema lógico, usado pelo seu programa. Elas são uniformes e independentes de dispositivo, é o próprio Java 2D que se encarrega da conversão de um sistema para outro.
O sistema de coordenadas da aplicação inicialmente considera a coordenada (0,0) como o canto superior esquerdo da área de desenho. As coordenadas serão sempre crescentes, com x crescendo para direita e y para baixo. Na realidade, o Java 2D permite que essas coordenadas sejam alteradas à vontade, permitindo a criação de diversos sistemas coordenados próprios, dentro da aplicação.

O contexto gráfico

Todo desenho no Java 2D é feito através da classe Graphics2D. Essa classe. que deriva da classe Graphics, representa o contexto gráfico sobre o qual o desenho será feito. Por isso, a classe guarda informações como cor será aplicada sobre a pintura, que tipo de borda o desenho terá ou qual será a fonte utilizada no texto, entre outras coisas.
Normalmente, uma aplicação é formada não por uma só imagem, mas por várias. Seria extremamente trabalhoso garantir que uma alteração no feita em uma imagem não interferisse em outra. Por exemplo, ao desenhar o fantasminha azul acima, você poderia definir no Graphics que ele deveria usar 80% de transparência. Entretanto, se você esquecer de desfazer essa definição, o pacman, que será desenhado logo em seguida, poderia ficar transparente também. Para contornar esse problema, os projetistas do Java 2D criaram uma forma de copiar o contexto gráfico. Isso permite que você trabalhe sobre uma cópia, faça as modificações necessárias para pintar a imagem, e descarte essa cópia ao final da pintura, deixando o contexto gráfico original inalterado.

?

1 2 3 4 5 6 7 8 9 10 11 12 13

/** Método paint do fantasma */ public void paint(Graphics g) {    //1. Copiamos o contexto gráfico    Graphics2D g2d = (Graphics2D) g.create();      //2. Desenhamos o fantasma 80% transparente    AlphaComposite alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8);    g2d.setComposite(alpha);    g2d.drawImage(x, y, phantomImage, null);      //3. Descartamos a cópia do contexto gráfico    g2d.dispose(); }

Uma confusão comum feita pelos iniciantes em Java 2D é pensar que a classe Graphics representa a superfície de desenho em si. Isso não é verdade. Ela só representa o estado exato em que será feita a pintura. Por isso, copiar esse contexto como sugerido acima é uma operação extremamente eficiente e barata. Assim como descarta-lo ao final da pintura não destruirá o desenho. De fato, isso nos leva a primeira regra de ouro ao desenhar em Java 2D:
“Jamais altere o estado do objeto Graphics recebido como parâmetro nas funções de pintura”.
Caso contrário, o Swing poderá usar esse objeto na hora de desenhar partes de sua janela, e você poderá obter efeitos muito estranhos, diferentes do esperado e difíceis de corrigir.
Dentre os estados no interior da classe Graphics2D, podemos citar:

• A largura que as bordas de uma figura são desenhadas (Pen, Stroke);
• Como duas bordas se conectam;
• A área, não necessariamente retangular, em que o desenho será realizado (Clipping path);
• Transformações de translação, rotação, escala e shear (AffineTransform);
• Cores e padrões de pintura;
• Composições entre múltiplos objetos (Composite);

Entretanto, a classe Graphics2D não guarda somente estados, mas também provê métodos para realizar a pintura em si. E isso nos leva ao próximo tópico.

Primitivas geométricas

As primitivas geométricas do Java 2D são: pontos, linhas, retângulos, arcos e elipses e curvas. As classes que lidam com cada uma dessas geometrias são definidas no pacote java.awt.geom. Por questões de performance e conveniência, o objeto Graphics também fornece métodos para a pintura direta dessas primitivas, sem a necessidade de criação de um objeto. Além dessas, o Java 2D fornece uma classe chamada GeneralPath, que permite a criação de formas arbitrárias, baseadas em linhas e curvas de Bézier.



As classes de primitivas também fornecem diversos métodos bastante práticos, como distância entre dois pontos (Point2D), área de figuras sólidas, teste se um ponto está contido em uma determinada forma, etc. O Java ainda fornece a classe Area, que permite realizar operações comuns como interseção ou subtração de duas formas.

Texto

O Java 2D fornece diversas classes para trabalhar com texto. Embora a forma mais direta e mais comumente usada seja simplesmente chamar os métodos setFont e drawString da classe Graphics, a API fornece classes auxiliares, que facilitam recursos mais avançados, como o posicionamento do texto. Essas classes, são parte do pacote java.awt.Font.
Chamamos de Glyph a forma usada para representar um caractere dentro de uma fonte. Um caractere de texto real pode ser formado por uma combinação de dois glyphs, como é o caso da maior parte das letras acentuadas. Da mesma forma, podem haver Glyphs que representam o desenho de mais de um caractere, como esse aqui o do símbolo de peseta: ₧
Uma fonte, é portanto, um conjunto de Glyphs, com o mesmo estilo artístico. Essa fonte pode ter uma série de variações, como itálico ou negrito, e essas variações são chamadas de faces. O conjunto de todas as faces de uma fonte é chamada de família. Podemos questionar o Java sobre diversas propriedades da fonte em questão, tais como altura, largura e outras métricas. Essas propriedades são encapsuladas na classe FontMetrics.
Antes do texto ser exibido, entretanto, ele deve ser formatado. Quem realiza essa tarefa é a classe TextLayout. Ela fornece métodos para lidar com fontes misturadas, idiomas diferentes e texto bidirecional. Caso você queira um controle ainda mais refinado sobre as opções de layout, o Java 2D fornece uma classe de mais baixo nível, chamada GlyphVector.

Imagens

Por último, mas não menos importante, o Java 2D fornece diversos recursos para a manipulação de imagens. O primeiro recurso interessante é certamente uma classe que permite a carga e escrita de diversos tipos de imagem de maneira uniforme, chamada ImageIO.
As imagens representadas pela classe BufferedImage. Um dos recursos mais interessantes do Java 2D, é que podemos requisitar o objeto Graphics de qualquer imagem, e realizar pintura ou escrever texto sobre imagens da mesma forma que fazemos para desenhar os componentes de tela.
O Java ainda suporta filtros sobre imagens, através da classe BufferedImageOp. Alguns sites de terceiros, como o jhlabs, já tem diversos desses filtros implementados, o que pode adicionar efeitos bastante interessantes aos jogos.
Por fim, o Java permite ainda a manipulação direta e eficiente dos pixels de uma imagem, através de suas definições, contidas na classe Raster. Essa manipulação avançada é geralmente necessária apenas para quem vai trabalhar com aplicações que geram filtros diretamente e, se esse é o seu caso, pode ser interessante consultar o tutorial “Using Rasters for Image Processing”, do Java Boutique. Fique atento, pois o tutorial também tem uma segunda parte.
Infelizmente, a biblioteca Java2D cobre bem apenas imagens formadas por mapas de bits. Para imagens vetoriais, é necessário utilizar bibliotecas de terceiros.

Conclusões

Nesse artigo, vimos rapidamente os recursos do Java 2D, e conhecemos a terminologia básica da maior parte de seus componentes. Deixamos de fora somente a parte de impressão, menos importante para jogos. Embora ainda não possamos desenhar nada, já podemos ter uma boa noção do quão poderosa a biblioteca é. Mais importante, aprendemos a terminologia do Java 2D, associada ao nome de diversas de suas principais classes.

Buscapé lança buscapé para desenvolvedores

  
    Bom gente, o BuscaPé, em parceria com o IMasters, lançou o Buscapé Developer. O BD é um espaço que está lá todo o web service do site para quem estiver interessado.
    Além disso, no próprio site tem vários tutorias, video aulas, e mais algumas coisas sobre a questão do web service.
   Na questão monetária, isso tudo antes mencionado é gratuito, entretanto todo o ganho que você obtiver com o serviço web, será dividido com o buscapé.
   A buscapé também está fazendo uma coisa no mínimo interessante, se a empresa gostar do seu trabalho ou tecnologia desenvolvida, e vai negociar a compra com você!
   Não esqueçam de comentar gente!

Malware que ataca Mac

  
    Bom gente, primeiramente desculpa todo mundo por eu não estar postando nada, agora, se Deus quiser, eu vou postar mais. :)
    Agora vamos direto ao assunto, nessa semana que passou, a empresa SecureMac anunciou que existe um novo malware para mac rondando por ai, pelo facebook, para variar só um pouquinho, e algumas outras redes sociais.
    O vírus funciona da seguinte maneira: vamos supor que você está no facebook, e se depara com a seguinte mensagem: Is this you in this video. ai, você ficou curioso e clicou, imediatamente, o malware entra no seu mac, se auto-instala no seu HD, e toda hora que você acessar ou o facebook ou outra rede social, o inquilino indesejável vai gerar o link que você clicou, e outras pessoas vão ser infectadas.
    Só para constar, não sei se alguém reparou, mas este malware tem o comportamento igualzinho a alguns vírus para windows. rsrsrs.
   Não esqueçam de comentar gente!

Intel, upgrade de processador por download

    Quem, no ramo da informática, não ouviu a pergunta: "Onde que eu paixo mais memória?", antigamente essa pessoa seria zoada até ir para o inferno, entretanto hoje em dia, a intel vai fazer isso se tornar realidade.
     Ela vai por limitações em se hardware, e por apenas U$50,00 vai ser disponibilizado um software "desbloqueador", para o processador.
    A fábrica de processadores já está, em relação a recente tecnologia, em fase de testes, o processador em questão é o pentiun G6951, sendo que se o usuário efetuar o download da aplicação o processador vai ganhar 1MB de L3 cache e tecnologia Hyper Threading

fonte[Zoom Dogotal]

GReader em tela cheia

    Gente, venho trazer um notícia muito boa para os leitores de feed que usam o Google Reader para para ler-los. A google anunciou uma nova funcionalidade do serviço, agora, você será capaz de ler os seu feeds em tela cheia, basta precionar a tecla f.
    Entretanto o que muita gente deve estar se perguntando, mas o GR já era capaz de "minimizar" a lista de feeds. Essa funcionalidade é diferente, com ela, o seus feeds que você está visualizando fica bem maior, em vez de aparecer o template, aparece a os feeds.
    Além disso, se você quiser consultar a lista de seus feeds, mas não sair da tela inteira, é só apertar Shift + u. Irá aparecer um menu flutuante com a lista, se não quizer-la mais, é só aperta Shift + u novamente.