Tutorial wxWidgets e sqlite3 parte 6 - Criando o Projeto e a Interface do programa

Vamos iniciar com a criação do projeto, aqui vou iniciar um projeto no Linux, para quem estiver usando o Visual C++ 2008 no Windows, veja como fazê-lo nos tutoriais anteriores aqui e aqui.

Crie uma pasta onde o projeto será salvo, aqui estou criando em /home/alex/Documentos/tuto_sqlite e vou chamar meu projeto de “agenda”, no caso vai ser bem simples, o objetivo é exatamente incentivar vocês a criarem um projeto com mais campos, depois de terminarmos com os tutoriais, para fixarem bem o conhecimento.

Abrindo o Code::Blocks vamos iniciar um novo projeto wxWidgets, a única coisa que vocês precisam ficar atentos é nesta parte:

Vamos criar um projeto vazio, sem arquivos, pois criaremos tudo na unha como dizem por aí...

Com o projeto aberto criem 6 novos arquivos:

Arquivos de cabeçalho:

main.h

framep.h

//Neste arquivo vamos criar as funções do wxSqlite3

sqlf.h

Aquivos de implementação:

main.cpp

framep.cpp

//Neste arquivo vamos criar as funções do wxSqlite3

sqlf.cpp

Vamos criar então o Aplicativo e a Interface de controle:

Obs.: A explicação está nos comentários do fonte, tentem escrever o programa linha por linha e passe adiante só depois de ter entendido bem o que cada coisa significa, se não conseguirem, os comentários aí do blog servem pra isso mesmo, tirar dúvidas...

O arquivo main.h ficará assim:

//ARQUIVO DO BLOG - http://wxnewbie.blogspot.com
//TUTORIAL wxWidgets + sqlite3 usando wxSqlite3

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

#include <wx/wx.h>

class wxAppTutorial: public wxApp
{
    public:
        bool OnInit(void);
};

#endif

O arquivo main.cpp

//ARQUIVO DO BLOG - http://wxnewbie.blogspot.com
//TUTORIAL wxWidgets + sqlite3 usando wxSqlite3

#include "main.h"
#include "framep.h"

bool wxAppTutorial::OnInit(void)
{
    //Crio o Frame que vai controlar a aplicação
    wxFramePrincipal *frameprincipal = new wxFramePrincipal();

    //Mostro o Frame
    frameprincipal->Show();

    //Passo para wxApp que este frame irá controlar a aplicação...
    //quando ele for fechado, a aplicação também será fechada...
    SetTopWindow(frameprincipal);

    return true;
}

IMPLEMENT_APP(wxAppTutorial)

O arquivo framep.h (Formulário que vai controlar a aplicação)

//ARQUIVO DO BLOG - http://wxnewbie.blogspot.com
//TUTORIAL wxWidgets + sqlite3 usando wxSqlite3

#ifndef FRAMEP_H_INCLUDED
#define FRAMEP_H_INCLUDED

#include <wx/wx.h>
#include <wx/grid.h>

class wxFramePrincipal: public wxFrame
{
    public:
        wxFramePrincipal();
    private:

        //Campos para pegar o ID na edição
        //Também irei usá-lo para saber se
        //está em modo de edição ou inserção...
        //Se for igual a -1 é inserção...
        //Se for diferente de -1 é edição
        int ID;

        //O grid que vai exibir os dados existentes na tabela...
        wxGrid *lista_contatos;

        //Labels dos campos...
        wxStaticText *label_nome;
        wxStaticText *label_idade;

        //Os campos de texto onde preencheremos os campos...
        wxTextCtrl *nome;
        wxTextCtrl *idade;

        //Os botões onde iremos executar os eventos de edição do banco...
        wxButton *salvar;
        wxButton *limpar;
        wxButton *deletar;

        //Declaro a tabela de eventos...
        DECLARE_EVENT_TABLE()

        //Eventos...
        //Evento para salvar no banco de dados...
        void OnClickSalvar(wxCommandEvent& event);
        //Evento para limpar os campos e cancelar edição...
        void OnClickLimpar(wxCommandEvent& event);
        //Evento para deletar um campo...
        void OnClickDeletar(wxCommandEvent& event);

        //Evento de seleção do registro que será editado...
        void OnDoubleClickCell(wxGridEvent& event);

        //Aqui eu vejo se os campos estão em branco, e também se idade é um número...
        bool ConfereCampos();
        //Aqui escrevo uma função para limpar os campos
        //Está função será usada para cancelar uma edição
        //e após executar alterações...
        void LimparCampos();

        enum{
            //Identificador do botão salvar
            ID_SALVAR = 1000,
            //Identificador do botão limpar
            ID_LIMPAR,
            //Identificador do botão deletar...
            ID_DELETAR,
            //Identificador do grid...
            ID_GRID,
        };
};

#endif // FRAMEP_H_INCLUDED

O arquivo framep.cpp

//ARQUIVO DO BLOG - http://wxnewbie.blogspot.com
//TUTORIAL wxWidgets + sqlite3 usando wxSqlite3

#include "framep.h"

wxFramePrincipal::wxFramePrincipal():wxFrame(NULL, wxID_ANY, wxT("Teste Tutorial Sqlite3"))
{
    //Altero a cor do background do Frame
    this->SetBackgroundColour(*wxWHITE);

    //Meu BoxSizer Principal...
    wxBoxSizer *boxp = new wxBoxSizer(wxVERTICAL);

    //Inicio a construção do grid...
    lista_contatos = new wxGrid(this, ID_GRID);

    //Começo com 0 linhas e 3 colunas, lembre-se que o número de colunas deve ser igual ao numero de campos
    //Da view que iremos carregar ou do comando select que iremos carregar...
    lista_contatos->CreateGrid(0, 3);

    //Aqui altero o valor dos rótulos de cada coluna...
    //Nunca se esqueça, o vetor começa em 0, tanto para colunas como para linhas...
    lista_contatos->SetColLabelValue(0, wxT("ID"));
    lista_contatos->SetColLabelValue(1, wxT("Nome"));
    lista_contatos->SetColLabelValue(2, wxT("Idade"));

    //Altero a largura padrão do rótulo da linha para 25px...
    //Altero a altura padrão do rótulo da coluna para 25px...
    lista_contatos->SetRowLabelSize(25);
    lista_contatos->SetColLabelSize(25);

    //Desabilito a edição dos valores no grid, a alteração de valores será feita
    //pelos wxTextCtrl's
    lista_contatos->EnableEditing(false);

    //Adiciono o grid no BoxSizer principal...
    boxp->Add(lista_contatos, 1, wxEXPAND, 0);

    //Aqui eu adiciono um separador...
    boxp->Add(0, 0, 0, wxALL, 10);

    //Aqui crio um BoxSizer para arranjar os campos de preenchimento de valores...
    wxBoxSizer *box_texts = new wxBoxSizer(wxVERTICAL);

    //o rótulo para o campo nome...
    label_nome = new wxStaticText(this, wxID_ANY, wxT("Nome"));
    //adiciono o rótulo no box dos valores de preenchimento...
    box_texts->Add(label_nome, 0, wxALL, 2);

    //Faço o mesmo que fiz anteriormente para todos os outros campos...
    nome = new wxTextCtrl(this, wxID_ANY, wxEmptyString ,wxDefaultPosition, wxSize(200, -1));
    box_texts->Add(nome, 0, wxALL, 5);

    label_idade = new wxStaticText(this, wxID_ANY, wxT("Idade"));
    box_texts->Add(label_idade, 0, wxALL, 2);

    idade = new wxTextCtrl(this, wxID_ANY, wxEmptyString ,wxDefaultPosition, wxSize(120, -1));
    box_texts->Add(idade, 0, wxALL, 5);

    //Aqui adiciono o box dos campos de preenchimento no box principal...
    boxp->Add(box_texts, 0, wxLEFT, 40);

    //Agora um box para arranjar os botões...
    wxBoxSizer *box_btns = new wxBoxSizer(wxHORIZONTAL);

    //Um separador...
    box_btns->Add(0, 0, 0, wxLEFT, 40);

    //Botão salvar...
    salvar = new wxButton(this, ID_SALVAR, wxT("Salvar"));
    //Adiciono ao box dos botões...
    box_btns->Add(salvar, 0, wxALL, 5);

    limpar = new wxButton(this, ID_LIMPAR, wxT("Limpar Campos"));
    box_btns->Add(limpar, 0, wxALL, 5);

    deletar = new wxButton(this, ID_DELETAR, wxT("Deletar"));
    box_btns->Add(deletar, 0, wxALL, 5);

    //Adiciono o box dos botões ao box principal...
    boxp->Add(box_btns, 1, wxEXPAND, 0);

    //"Digo" ao meu frame que o boxp é o box principal...
    this->SetSizer(boxp);

    //Aqui apenas faço com que tudo seja arranjado de maneira correta...
    this->Layout();

    //Seto o ID como -1 para saber que inicio em modo de inserção...
    ID = -1;
}

//Aqui minha tabela de eventos declarada...
BEGIN_EVENT_TABLE(wxFramePrincipal, wxFrame)
//Veja que digo para cada evento, que o controle que estiver com
//determinado id, é o que será responsável por executá-lo
//No exemplo de salvar:
//Eu digo que é um evento do tipo EVT_BUTTON, ou seja, um evento executado por um botão...
//O botão responsável pelo evento é o que tiver o identificador: ID_SALVAR
//e o evento que ele vai executar é o OnClickSalvar...

//É muito importante o entendimento desta parte para não acontecer nada de errado...
EVT_BUTTON(ID_SALVAR, wxFramePrincipal::OnClickSalvar)
EVT_BUTTON(ID_LIMPAR, wxFramePrincipal::OnClickLimpar)
EVT_BUTTON(ID_DELETAR, wxFramePrincipal::OnClickDeletar)

//Quando você for criar um evento para grid's repare que alguns levam um CMD no nome e outros não...
//Se você estiver criando uma classe derivada de wxGrid, vc não usa o comando que contém o CMD
//Veja que este comando sem CMD como é o caso de EVT_GRID_CELL_LEFT_DCLICK (comando que é executado
//quando dou 2 cliques em uma célula) não recebe ID nenhum como parâmetro...
//agora se eu for executar o mesmo comando usando um wxGrid como controle no meu frame ou dialogo
//eu uso o comando com CMD como é o caso do evento abaixo...
EVT_GRID_CMD_CELL_LEFT_DCLICK(ID_GRID, wxFramePrincipal::OnDoubleClickCell)
END_EVENT_TABLE()

//Aqui eu inicio a implementação do evento para salvar um registro...
void wxFramePrincipal::OnClickSalvar(wxCommandEvent& event)
{
    //...Os comandos que usaremos aqui, será escrito depois...
}

//Aqui o evento que vai limpar os campos...
void wxFramePrincipal::OnClickLimpar(wxCommandEvent& event)
{
    //...Os comandos que usaremos aqui, será escrito depois...
}

//Aqui o evento quando eu clicar no botão deletar...
void wxFramePrincipal::OnClickDeletar(wxCommandEvent& event)
{
    //...Os comandos que usaremos aqui, será escrito depois...
}

//Aqui o evento que será exxecutado
//quando eu der 2 cliques em uma célula...
void wxFramePrincipal::OnDoubleClickCell(wxGridEvent& event)
{
    //...Os comandos que usaremos aqui, será escrito depois...
}

//Esta função eu vou usar para limpar os campos
//como eu precisarei fazer isto sempre que eu completar uma alteração
//vou escrever este código em uma função em separado...
void wxFramePrincipal::LimparCampos()
{
    //...Os comandos que usaremos aqui, será escrito depois...
}

//Aqui vou conferir os campos para ver se o usuário digitou algo errado...
bool wxFramePrincipal::ConfereCampos()
{
    //...Os comandos que usaremos aqui, será escrito depois...
    return true;
}

Estudem o código, já coloquei nele os eventos que serão usados para o controle das ações. O resultado final da Interface é esse:

No próximo tutorial explicarei como executar alguns comandos usando wxSqlite3 e escreveremos os códigos para fazer a agenda funcionar.

Até a próxima.

wxWidgets – Usando argc e argv em wxApp

Continuando com o tutorial básico de wxWidgets, hoje vou explicar como utilizar argc e argv de wxApp.

São valores que são passados na inicialização de programas, onde argc me retorna o número de argumentos passados e argv os valores dos argumentos.

Utilizando o mesmo código anterior de wxApp, vamos ver como funciona:

Vou criar um novo projeto, onde o executável está em /home/alex/Documentos/wxapp_tuto/tuto_wxapp/bin/Debug

Vamos ao código:

//main.h
#include <wx/wx.h>

class wxAppTuto: public wxApp
{
    public:
        bool OnInit(void);
};

//main.cpp
#include “main.h”
bool wxAppTuto::OnInit()
{
    //Aqui eu pego o valor de argc e argv...
    //Lembre-se que eles são membros de wxApp
    int get_argc = argc;
    wxString get_argv = *argv;

    //Aqui mostro estes valores em um wxMessageBox
    wxMessageBox(wxString::Format(wxT("Números de parâmetros - %d \n\n Valores - "), get_argc) + get_argv);
    return false;
}

IMPLEMENT_APP(wxAppTuto)

O resultado da execução do programa será o seguinte:

Vejam que mesmo eu não tendo passado nenhum valor na inicialização ele me retornou um valor, que é o caminho completo para o executável, este valor sempre será apresentado no primeiro valor...

Agora vamos alterar um pouco o código para pegarmos todos os argumentos que possam ser passados:

//main.cpp
#include “main.h”
bool wxAppTuto::OnInit()
{
    int get_argc = argc;

    wxString get_argv;

    //Aqui eu pego o número de argumentos e vou adicionando
    //cada um deles a wxString get_argv...
    for(int i = 0; i < argc; i++)
    {
        get_argv += wxString::Format(wxT("%s\n"), argv[i]);
    }

    wxMessageBox(wxString::Format(wxT("Números de parâmetros - %d \n\n Valores - "), get_argc) + get_argv);
    return false;
}

Agora vou reabrir o programa pela linha de comando da seguinte maneira.

//tuto_wxapp é o nome do executável...
./tuto_wxapp teste1 teste2 teste3

O resultado será o seguinte:

Veja que ele pegou cada um dos valores em um argumento, se fossemos passar uma string com espaços precisaríamos apenas passar este valor entre aspas como em “teste tutorial wxApp”.

./tuto_wxapp “teste tutorial wxApp”

Uma aplicação prática, seria quando abrimos um arquivo usando o “Abrir com...” diretamente pelo nosso programa, quando fazemos isto, o caminho para este arquivo é passado no argumento, se tentarmos abrir vários arquivos de uma vez serão passados vários argumentos, pegaríamos cada um deles e passaríamos para o sistema, isto é útil se tivermos criando um programa para exibir imagens ou um editor de textos por exemplo.

Espero que aproveitem a explicação e até a próxima.

Instalando e configurando Firebird 2.5 no Ubuntu 11.04

Neste tutorial vou explicar como instalar e configurar o Firebird 2.5 no Ubuntu 11.04

Abra o gerenciador de pacotes Synaptic

Sistema → Administração → Gerenciador de pacotes Synaptic

ou

sudo synaptic

Digite sua senha

No “filtro rápido”, digite firebird

Marque para instalação o pacote

firebird2.5-super

Abrirá um diálogo com os outros pacotes necessário, clique em marcar.

Na janela do Synaptic clique em aplicar e no diálogo que se abre, também clique em aplicar.

Após as alterações terem sido feitas, feche o Synaptic e abra um terminal.

Digite o comando abaixo e sua senha logo em seguida para usar a conta root...

sudo su

Agora vamos reconfigurar o firebird, nesta etapa iniciaremos o servidor e configuraremos uma senha para o usuário SYSDBA.

Digite o comando abaixo:

dpkg-reconfigure firebird2.5-super

Nesta tela selecione sim para ativar o servidor Firebird

Nesta tela selecione OK para configurar a senha do SYSDBA

Digite a nova senha:

Você voltará ao terminal e serão exibidas as mensagens a seguir.

Para iniciarmos o servidor Firebird 2.5 usamos o comando:

sudo /etc/init.d/firebird2.5-super start

Para pararmos o servidor usamos o comando:

sudo /etc/init.d/firebird2.5-super stop

Para reiniciar o servidor usamos o comando:

sudo /etc/init.d/firebird2.5-super restart

Para criarmos novos bancos de dados, o diretório pré configurado com permissões para o firebird é:

/var/lib/firebird/2.5/system

Se vocês tentarem criar um banco de dados em um diretório sem as permissões para o firebird dará erro.

Uma alternativa é criar uma pasta onde vocês querem salvar os arquivos de banco de dados do firebird e dar as devidas permissões.

Um jeito bem simples é o seguinte:

Crie uma pasta onde vocês querem criar o banco de dados, no meu caso, vou criar um diretório no seguinte caminho, /home/alex/firebird_data

Agora vou abrir o Nautilus (o gerenciador de arquivos que estou usando aqui) como root, com o comando:

sudo nautilus

Vou até o local onde criei meu diretório firebird_data e clicando com o botão direito do mouse seleciono Propriedades.

No diálogo que se abre, vá até a aba Permissões e altere os valores como na figura:

 

Feche o diálogo, o Nautilus e o terminal.

Pronto, esta pasta já está apta para receber bancos de dados do Firebird.

Basicamente, a instalação e configuração do firebird no Ubuntu é isto, se vocês optarem por outra versão do firebird, basta alterar os comandos e caminhos para os mesmos, como por exemplo em “sudo /etc/init.d/firebird2.1-super start” ou “sudo /etc/init.d/firebird2.5-classic start”, etc...

Depois darei um exemplo de como criar um banco de dados no firebird usando o flamerobin e o isql.

Espero que tenha ajudado nesta parte e qualquer dúvida deixem nos comentários que tentarei ajudar.

Até a próxima.

wxWidgets – Pegando o diretório da aplicação em wxWidgets

Um erro comum em wxWidgets é usar wxGetCwd() para pegar o diretório da aplicação, este comando retorna o diretório de trabalho atual, em alguns casos, onde nenhum arquivo fora do diretório da aplicação é acessado, este comando pode até funcionar, mas quando saímos do diretório da aplicação este comando retorna um valor diferente do esperado.

Vejam por exemplo o que este comando retorna quando eu tento abrir um arquivo que está no meu Desktop diretamente em um sistema que está em /home/alex/Documentos/gerbsox/bin/Debug

E se eu tentar executar o mesmo pelo Code::Blocks o resultado será o seguinte:

Para contornar esta situação eu uso uma função bem simples que segue a baixo:

//Primeiro adiciono o arquivo de cabeçalho que contém wxStandardPaths
#include <wx/stdpaths.h>

//Aqui implemento um função chamada GetExecPath() que me retornará uma wxString...

wxString GetExecPath()
{
    //Esta função wxStandardPaths::Get().GetExecutablePath()
    //me retorna um caminho completo para o executável
    //incluindo o nome do executável, o que não é o que nós queremos...
    wxString path_c = wxStandardPaths::Get().GetExecutablePath();

    //Resolvemos o problema usando wxPathOnly(...)
    //que vai retornar apenas o valor do diretório removendo o nome do arquivo...
    wxString path_ok = wxPathOnly(path_c);

    //Agora é só eu retornar o valor correto do diretório da aplicação...
   return path_ok;

    //poderíamos economizar código escrevendo a função inteira assim:
    //return wxPathOnly(wxStandardPaths::Get().GetExecutablePath());
}

Vejam que se eu não usar o wxPathOnly(...), o nome do executável também aparecerá na string

 

Onde /home/alex/Documentos/gerbsox/bin/Debug é o diretório da minha aplicação e gerbsox é o meu executável...

Vamos repetir o que foi feito anteriormente para ver o que o comando vai nos retornar.

Aqui executando o aplicativo pelo CodeBlocks...

...e aqui abrindo o arquivo que estava na área de trabalho...

Espero ter ajudado em alguma coisa.

Até a próxima...

Tutorial wxWidgets e sqlite3 parte 5 - Iniciando com o exemplo

Para iniciarmos com o sistema de exemplo, vamos entender melhor como o mesmo vai funcionar:

Teremos 6 arquivos no projeto:

main.h e main.cpp

Nesses dois arquivos teremos a aplicação em si, ou seja, a declaração (main.h) e implementação (main.cpp) de wxApp.

framep.h e framep.cpp

Nesses dois arquivos teremos o formulário que irá controlar a aplicação, neste formulário teremos os seguintes widgets:

1 wxGrid que exibirá a lista com os dados existentes no database.

2 wxStaticText's que exibirão os nomes dos campos para inserção e edição.

2 wxTextCtrl's onde iremos digitar os dados para inserção e edição.

3 Botões, sendo um para limpar os campos, um para salvar os dados e um para excluir os dados.

sqlitef.h e sqlitef.cpp

Nesses dois arquivos iremos criar as funções que irão fazer o controle do banco de dados.

O que iremos aprender aqui:

Como criar uma banco de dados em sqlite3 usando wxWidgets e wxSqlite3.

Abrir um banco de dados em sqlite3.

Criar tabelas em um banco de dados sqlite3.

Fazer operações de edição, inserção e exclusão em um banco de dados sqlite3 usando dados provenientes de um wxTextCtrl.

Fazer operação de seleção em um banco de dados sqlite3 e exibi-los em wxGrid.

O que você já precisa saber:

Você deve conhecer o básico de SQL e de wxWidgets, além de ter todas as dependências explicadas anteriormente (wxWidgets, sqlite3 e wxSqlite3).

Neste tutorial eu irei explicar utilizando uma plataforma Linux (Ubuntu) e a IDE Code::Blocks, mas você poderá executá-lo no Windows.

No próximo tutorial iremos criar o projeto, e explicar o código fonte da interface.

Até a próxima.

Tutorial wxWidgets e sqlite3 parte 4 – Compilando wxSqlite3 no Linux

Os passos para a compilação da biblioteca do wxsqlite3 no Linux:

No meu caso, estou utilizando o Ubuntu 11.04.

A primeira coisa que temos que ver são as dependências, além das ferramentas de compilação, devemos observar se estão instalados:

Sqlite3

1 – O programa em linha de comando do sqlite3 para criarmos os bancos de dados.

2 – O pacote de desenvolvimento do sqlite3 (no gerenciador de pacotes de estar como libsqlite3-dev, ou algo parecido).

3 – Biblioteca dinâmica do sqlite3 (libsqlite3-0, ou algo parecido).

wxWidgets:

1 – libwxgtk2.8-dev – Pacote de desenvolvimento wxGtk

2 – libwxgtk2.8-0 – Pacote com as bibliotecas do wxGtk

3 – wx2.8-headers – Arquivos de cabeçalho do wxWidgets

4 – libwxbase2.8-dev – Pacote de desenvolvimento wxBase

5 – libwxbase2.8-0 – Pacote com as bibliotecas do wxBase

Depois de conferidas as dependências:

1 – Faça o download da versão 1.9.9 do wxSqlite3 aqui.

2 – Mova o arquivo da pasta do download para o diretório “/tmp”.

3 – Vá para o diretório /tmp (cd /tmp [enter])

4 – Descompacte o arquivo (tar vzxf wxsqlite3-1.9.9.tar.gz [enter])

5 – Entre no diretório onde os arquivos foram descompactados (cd /wxsqlite3-1.9.9 [enter])

6 – Digite o comando:

./configure [enter]

7 – Digite o comando:

make [enter]

8 – Digite o comando:

sudo make install [enter]

9 – Confirme sua senha [enter]

Pronto, a biblioteca do wxSqlite3 foi compilada e instalada no sistema, para conferir se está tudo OK, entre no diretório /usr/local/lib e veja se a biblioteca está lá, depois vá para /usr/local/include e veja se os arquivos *.h do wxsqlite3 estão lá.

No próximo tutorial iremos iniciar uma explicação sobre conexão e gerenciamento de bancos de dados sqlite3 usando esta biblioteca.

Vídeo com a explicação

Até a próxima.

wxWidgets: Começando com wxApp

Hoje escreveremos nosso primeiro programa em wxWidgets, na verdade ele não terá função nenhuma, apenas criaremos uma instância de programa e a fecharemos. O objetivo é apenas explicar como funciona wxApp.

Vamos ao código:

Primeiro vamos escrever o arquivo de cabeçalho que eu chamei de “main.h”.

//Arquivo main.h
//Tutorial wxApp parte – 1 do blog http://wxnewbie.blogspot.com

//Aqui eu adicionei o arquivo de cabeçalho do wxWidgets, ou seja, “wx.h”...
#include <wx/wx.h>

//Aqui crio uma classe publica chamada wxAppTutorial, que é derivada de wxApp...
class wxAppTutorial: public wxApp
{
    public:
        //Aqui eu declaro a função OnInit(), que é uma cópia da mesma função
        //encontrada na classe wxApp...
        bool OnInit(void);
};//Não se esqueça de colocar o ";" no final da declaração das classes...

Agora o arquivo de implementação “main.cpp”

//Arquivo main.cpp
//Tutorial wxApp parte – 1 do blog http://wxnewbie.blogspot.com

//Aqui eu adiciono o arquivo de cabeçalho “main.h”, que criei com as declarações.
#include “main.h”

//Aqui eu implemento a função OnInit()...
//Lembre-se que ela é do tipo bool e pertence a classe wxAppTutorial...
bool wxAppTutorial::OnInit(void)
{

	//...Tudo que eu colocar aqui será inicializado com o programa...//

	//Aqui eu preciso retornar um valor booleano
	//Coloco como false para finalizar o programa
	//Se eu colocar como true, o programa continuará rodando
	//até que seja executado um comando para fechá-lo...
	return false;
}

//Neste ponto eu executo a macro IMPLEMENT_APP(wxAppTutorial)
//Para mostrar ao wxWidgets como criar uma instância da sua classe de aplicativo.
IMPLEMENT_APP(wxAppTutorial) //Não é necessário colocar o ";" para finalizar MACROS...

Para entendermos melhor como o código todo funciona, vamos pensar da seguinte maneira:

Quando criamos uma classe derivada de wxApp, estamos criando a classe que representa a nossa aplicação em si, quando implementamos a função OnInit(), mostramos como iniciar o processamento do aplicativo, mas isto tudo não é suficiente para que o sistema rode, precisamos mostrar ao wxWidgets que esta classe é a responsável pela criação da instância do seu aplicativo, e fazemos isto com IMPLEMENT_APP().

Uma coisa que deve ficar clara no exemplo, é que eu apenas setei o “return” da função “OnInit()” como “false” para que o programa não fique rodando em background sem termos como pará-lo usando a própria aplicação, se você colocar este valor como true, não haverá problema algum, você apenas terá que fechar o programa usando o gerenciador de processos do seu sistema operacional.

Nos próximos tutoriais, irei mostrar algumas outras coisas que podem ser feitas usando wxApp.

O código fonte do exemplo1 está disponível aqui para download.

Até a próxima.

wxWidgets – Utilizando o Projeto Base

Hoje vamos ver como iniciar um novo projeto tomando como base o projeto criado no tutorial anterior.

1 – Abra o Visual C++.

2 – Crie uma pasta em algum local do seu computador para salvar o projeto.

3 – Abra o projeto que você criou que foi explicado aqui.

4 – Remova os arquivos “minimal.cpp” e “sample.rc”.

5 – Salve tudo, em “File”->”Save All”.

Será criado um arquivo com a extensão “*.sln”, clique em salvar.

6 – Agora vamos criar o novo projeto, clique sobre o nome do projeto e vá em “File”->“Save minimal As”, selecione a pasta que você criou e digite um nome qualquer, no meu caso, será “tutorial_sqlite3”, pois vou usá-lo para os tutoriais do sqlite3.

7 – Feche o projeto “minimal” e quando for perguntado se você quer salvar este projeto, clique em “NO”, não se esqueça de sempre que for criar um projeto novo a partir deste, nunca salvar o projeto “minimal”.

8 – Agora vamos abrir o diretório onde você salvou o projeto novo.

Clique com o botão direito do mouse sobre o arquivo de projeto e selecione abrir com o bloco de notas.

Por padrão, o bloco de notas não é um aplicativo indicado pelo Windows para abrir arquivos “*.vcproj”, você deve selecioná-la usando a opção “Escolher programa padrão...”.

9 – Com o programa aberto no Bloco de Notas, vá em “Editar”->”Substituir”, 

No campo Localizar: coloque “minimal”

Em Substituir por: coloque o nome do seu novo projeto (no meu caso “tutorial_sqlite3”)

Clique em “Substituir Tudo”

Feche esta janela, salve o arquivo e feche o Bloco de Notas.

O projeto está pronto para ser utilizado, no próximo tutorial iremos começar a explicação sobre o sqlite3.

Até a próxima.

Vídeo com as explicações.

wxWidgets: Criando um projeto base no Visual C++

1 – Abra o Visual C++;

2 – Clique no menu: “File -> Open -> Project/Solution”

3 – Procure o projeto de exemplo chamado “minimal” no local onde o wxWidgets foi instalado, deve estar no caminho:

“C:\SourceCode\Libraries\wxWidgets2.8\samples\minimal”

Abra o arquivo “minimal.dsp”.

No diálogo que aparece, clique em Yes To All

Clique com o botão direito do mouse sobre “minimal” no canto esquerdo superior e depois clique em “Properties”

Na janela “minimal Property Pages” clique em “Configuration Manager...”, veja se a configuração atual está como “Debug”, se não estiver selecione está opção e clique em “Close”

No lado esquerdo da janela “minimal Property Pages” procure “Configuration Properties”-> “C/C++” -> “General”.

Na opção “Additional Include Directories” clique em “...”

Substitua os seguintes valores:

“.\..\..\lib\vc_lib\mswd” por “$(WXWIN)\lib\vc_lib\mswd”

“.\..\..\include” por “$(WXWIN)\include”

Veja que o que fizemos foi trocar o caminho “.\..\..” pelo valor da variável do sistema que criamos aqui, ou seja, $(WXWIN).

E delete a linha “.\..\..\samples”.

Clique em “OK”.

Deve ficar assim:

Agora em linker, vamos configurar o valor alterarando o caminho para a biblioteca do wxWdigets.

Altere o valor “.\..\..\lib\vc_lib” por “$(WXWIN)\lib\vc_lib”

Faça a mesma configuração para a opção Release, antes de fechar, se assim desejar, só não se esqueça de manter o caminho correto para as pastas include:

“.\..\..\lib\vc_lib\msw” por “$(WXWIN)\lib\vc_lib\msw”, veja que agora eu uso o caminho para a biblioteca estática em release, ou seja, sem o "d" no final.

Agora vamos salvar este projeto em um local diferente, lembre-se que sempre que iniciarmos um novo projeto, usaremos este como base.

No meu caso, eu criei uma pasta no Desktop com o nome “projetobase”.

Clique sobre o “minimal” em “Solution Explorer”, vá no menu “File”->”Save minimal As”

Selecione o diretório onde você irá salvar o projeto base e clique em “Salvar”.

Agora uma coisa muito importante, feche o projeto anterior, e quando ele perguntar se você quer salvá-lo clique em “NO”.

Agora temos um projeto base, que poderá ser usado sempre que começarmos um projeto novo.

Até a próxima.

Download e instalação do wxPack no Windows

1 – Faça o download da última versão da biblioteca do wxWidgets no seguinte endereço:

http://wxpack.sourceforge.net/Main/Downloads

2 – Faça a instalação padrão do mesmo.

3 – Ele será salvo em um caminho parecido com este:

C:\SourceCode\Libraries\wxWidgets2.8

4 – Finalizando a instalação vamos criar uma variável do sistema com este caminho:

Clique com o botão direito sobre o ícone “Computador”, selecione “Propriedades”.

Se você estiver no XP a caixa de diálogo com as “Propriedades do Sistema” já se abrirá, no Windows 7 clique em “Configurações avançadas do sistema” na lista à esquerda.

Em “Propriedades do Sistema”, clique em “Variáveis de Ambiente”.

Em “Variáveis do sistema” clique em “Novo...”.

Na janela “Nova Variável de Sistema” preencha da seguinte forma:

Nome da Variável = WXWIN

Valor da variável: "Caminho para o wxWidgets" (no meu caso, C:\SourceCode\Libraries\wxWidgets2.8)

Clique em “OK”, na janela “Variáveis de Ambiente” também em “OK” e Propriedades do Sistema “OK”.

Pronto, o wxWidgets está instalado e pronto para ser configurado no Visual C++ assim como em outras IDE’s como o Code::Blocks.

Até a próxima.