Curso de wxWidgets, post 4: Posicionando com sizers

Se você tentou adicionar novos widgets no frame do nosso "Hello, world!", possa ser que tenha tido problemas para posicioná-los. É isto que vamos fazer agora!

Bem, no wxWidgets, você não precisa especificar as coordenadas de cada widget (nem deve). Ao invés disso, usamos os sizers, que são objetos do wxWidgets que auxiliam no posicionamento dos widgets. Funciona mais ou menos como uma tabela, você adiciona sizers horizontais ou verticais e vai inserindo os widgets nas "células" deles.

No post de hoje, vamos fazer a seguinte janela para demonstrar o uso de sizers:



Para que você entenda o funcionamento dos sizers, vou mostrar como ela foi divida por eles:



Nesta janela foram usados dois sizers: um vertical (vermelho) e um horizontal (azul). O sizer horizontal tem dois widgets: um wxTextCtrl e um wxButton. O sizer vermelho tem um wxStaticText e o sizer horizontal. O sizer horizontal vai ficar dentro do vertical, de forma a fazer esta arrumação.

Para fazer esta janela, vamos modificar o nosso "Hello, world!". Na definição da classe do frame, declare os widgets que vamos usar:

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);

private:
 wxStaticText    *lb_hello;
 wxTextCtrl      *txt_name;
 wxButton        *btn_say;
};

E no construtor do frame, vamos criar os sizers, os widgets e posicioná-los:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu Programa"))
{
 // Criação dos sizers
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);

 // Criação dos widgets
 lb_hello = new wxStaticText(this, wxID_ANY, wxT("Digite seu nome na caixa:"));
 txt_name = new wxTextCtrl(this, wxID_ANY);
 btn_say = new wxButton(this, wxID_ANY, wxT("Hello!"));

 // Posicionamento dos widgets
 sizer_h->Add(txt_name, 1, wxALL, 5);
 sizer_h->Add(btn_say, 0, wxALL, 5);

 sizer_v->Add(lb_hello, 0, wxALL, 5);
 sizer_v->Add(sizer_h, 0, wxALL | wxEXPAND, 5);

 SetSizerAndFit(sizer_v);
}

Vamos entender melhor os sizers. No início do construtor, criamos os dois sizers que vamos utilizar. No wxBoxSizer, você insere os widgets nas "células" e ele os encaixa usando o tamanho mínimo necessário por aquele widget. Como parâmetro do wxBoxSizer, passamos sua orientação, que pode ser wxHORIZONTAL ou wxVERTICAL.

Em seguida, criamos os widgets normalmente, chamando os construtores de cada um deles.

Por último, os widgets são inseridos nos sizers com o método wxSizer::Add(). Neste método, passamos os seguintes parâmetros:

txt_name: o widget a ser inserido.

1: a proporção (se ele deve se esticar na orientação do sizer e em que proporção de acordo com os outros widgets no mesmo sizer).

wxALL | wxEXPAND: flags deste elemento. wxALL diz que deve haver um espaçamento em todas as direções do widget e wxEXPAND diz que esse widget deve expandir para usar todo o espaço dado a ele. Outras flags podem ser encontradas na documentação do wxSizer.

5: o tamanho da borda que será usada com wxALL.

Por último, devemos dizer ao frame qual o sizer principal e que ele deve ser usado como base para o tamanho da janela. Para isso, chamamos o método wxWindow::SetSizerAndFit() e passamos o sizer vertical como parâmetro, já que ele contém todos os widgets e sizers dentro dele.

O uso de sizers é bastante fácil. Basta criar os sizers, criar os widgets e adicionar os widgets nos sizers. Experimente adicionar outros widgets junto com mais sizers, criando arrumações diferentes.

Leia também a documentação do wxWidgets para ver os outros sizers e veja o tópico "Sizer overview", esta página contém informações úteis na utilização de sizers.

PS.: Caso tenha dúvida em qualquer assunto de algum post do curso, deixe um comentário com sua pergunta. Se os leitores participarem no blog, outras pessoas também aprenderão.

WinPolicy na rede Globo

Um usuário do WinPolicy postou a seguinte mensagem na comunidade do WinPolicy no Orkut:

"O WinPolicy apareceu por um acaso nessa reportagem da Rede Globulo de Cuiaba. A materia nao trata sobre o WinPolicy, mas sobre senhas na internet e em geral, e em um dos takes de filmagem aparece claramente no computador de uma Lan House láááááááááá de Cuiaba o WinPolicy sendo utilizado:

http://www.youtube.com/watch?v=eJDEjKIP4n0&NR

Aparece logo nos 00:17" de vídeo... muito legal..."

A URL do post original é:

http://www.orkut.com/CommMsgs.aspx?cmm=3711091&tid=2488845812591714844&start=1

Propaganda gratuita na rede Globo! Que legal! rsrs :)

Curso de wxWidgets, post 3: Entendendo o "Hello, world!" do post 2

Agora sim, vamos ver como aquilo tudo funciona! :) Estou supondo que todos já conseguiram compilar o wxWidgets e botar ele pra trabalhar. Quem ainda não conseguiu, deixe comentários no post 2.

Voltando ao "Hello, world!"... Em primeiro lugar, devemos incluir os cabeçalhos do wxWidgets (acho que isso é óbvio):

#include "wx/wx.h"

Essa linha inclui os principais cabeçalhos do wx, mas você pode também inserir apenas os cabeçalhos das classes que deseja usar. Por exemplo, se em seu programa você estiver usando apenas um wxFrame e um wxButton, você poderia fazer assim:

#include "wx/app.h"    // Este é para o wxApp
#include "wx/frame.h"  // Este é para o wxFrame
#include "wx/button.h" // Este é para o wxButton

Iniciando o programa

Como todo programador C/C++ sabe, o programa sempre começa na função main(). Com wxWidgets, essa função não será mais utilizada. Na verdade, ela é utilizada internamente pelo wxApp, então, ao invés de usar main(), no wxWidgets usamos wxApp::OnInit().

Primeiro, precisamos criar uma classe que irá representar nosso programa. Essa classe deverá ser derivada de wxApp. Veja o código:

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

Esse trecho de código vai criar a classe MeuPrograma que é derivada de wxApp (para os novatos em orientação a objetos, isso significa que a nossa nova classe vai herdar todos os atributos e métodos de wxApp. É como um wxApp + os métodos e atributos que criarmos nesta classe). O método sobrecarregado MeuPrograma::OnInit() será o main() do nosso programa. É este método que será chamado ao executarmos o aplicativo.

Criação da janela principal

Porém, queremos criar uma janela para o nosso programa. Uma janela em wxWidgets é um wxFrame. Então, para criarmos nossa janela específica, vamos criar uma classe para a janela. Essa classe deve ser derivada de wxFrame, já que queremos usar todo o "comportamento" de um wxFrame, mas com algumas coisas a mais e específicas que iremos implementar:

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);
};

Como na classe MeuPrograma, a classe MeuFrame é uma classe derivada de wxFrame, todos os métodos e atributos dela serão herdadas por nossa classe.

Implementando o programa

Bem, já temos uma classe para nosso aplicativo (MeuPrograma) e uma para nossa janela (MeuFrame). Agora, vamos voltar ao MeuPrograma::OnInit(). Devemos começar a programar aqui:

bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

Primeiro, declaramos um ponteiro do tipo MeuFrame e criamos uma instância da nossa classe. Na segunda linha, chamamos o método wxFrame::Show() para exibir a janela. Esse método faz com que a janela seja mostrada na tela. Na terceira linha, o método wxApp::SetTopWindow() define a janela instanciada em frame como a janela principal do nosso programa. E por último, return true indica que a inicialização do programa foi feita com sucesso e que ele deve continuar rodando. Se algo acontecesse errado, um return false iria fechar o programa imediatamente.

Bem, isto é o que de fato deve ser feito em wxApp::OnInit(). O resto da implementação deve ficar em outras classes. Mas por enquanto, vamos apenas criar nossa janela. Devemos implementar o construtor dela:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu programa"))
{
}

Nada é feito neste construtor. Na verdade, apenas passamos alguns parâmetros para o construtor do wxFrame. O primeiro parâmetro indica qual janela é pai desta janela. Como esta é a janela principal, ela não tem pai (NULL). O segundo parâmetro diz qual a ID desta janela. Como não fizemos nenhum evento da janela em si, não é preciso especificar uma ID agora (wxID_ANY). O terceiro parâmetro configura o título da janela (wxT("Meu programa")). Verifique a ajuda do construtor do wxFrame para ver os detalhes de todos os parâmetros.

Agora, devemos dizer ao wxWidgets qual é a nossa classe de aplicativo com a macro:

IMPLEMENT_APP(MeuPrograma)

Pronto! Este é o nosso "Hello, world!" explicado. Mas agora, vamos adicionar algumas coisas a ele.

Adicionando objetos

Primeiro, que tal um texto escrito "Hello, world!"? A classe para textos estáticos no wxWidgets é a wxStaticText. Os principais parâmetros do seu construtor (usaremos apenas estes):

wxWindow *parent: a janela pai deste objeto.
wxWindowID id: a ID deste objeto (caso desejamos criar um evento para ele).
wxString &label: o texto que será exibido.

Primeiro, vamos declarar nosso objeto na definição de MeuFrame. Basta adicionar a declaração na definição da classe, vai ficar assim:

class MeuFrame: wxFrame
{
public:
 MeuFrame(void);

private:
 wxStaticText *text;
};

E em seguida, instanciamos a classe no construtor de MeuFrame, adicionando a seguinte linha:

text = new wxStaticText(this, wxID_ANY, wxT("Hello, world!"));

Vai ficar assim:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu programa"))
{
 text = new wxStaticText(this, wxID_ANY, wxT("Hello, world!"));
}

Compile o programa novamente e execute. Você vai ver o texto "Hello, world!". Explicando os parâmetros:

this: indica que a janela MeuFrame é a janela pai do objeto.
wxID_ANY: indica que não estamos associando nenhuma ID específica ao objeto.
wxT("Hello, world!"): o texto que será exibido.

Uma breve explicação sobre a macro wxT()

Vocês devem ter notado que todas as strings estão envoltas na macro wxT(). Bem, antigamente, as strings eram representadas no formato ASCII, cada caractere ocupava um byte na memória. Porém, alguns idiomas contém caracteres especiais, como o japonês, chinês, árabe..., e um byte não era suficiente para representar todos eles, já que com um byte podemos representar apenas 256 valores diferentes. Surgiram então várias codificações de caracteres para representar cada idioma ou região. Então, para padronizar isso, o padrão UNICODE foi criado. Neste padrão, mais de um byte pode ser utilizado.

Mas o wxWidgets pode estar sendo utilizado em um sistema operacional sem suporte a UNICODE, ou até mesmo, o wxWidgets pode ter sido compilado sem suporte a UNICODE, como eu ensinei no post 2. Para não haver problemas com isso e tornar seu código portável, use a macro wxT(). Essa macro não faz nada em compilações sem UNICODE, mas vai converter a string ASCII para UNICODE, caso sua compilação do wxWidgets esteja usando UNICODE.

Faça mais no "Hello, world!"

Para prática, sugiro criar outros objetos na nossa janela. Algumas sugestões: wxButton, wxTextCtrl, wxComboBox, wxCheckBox e wxRadioBox.

No próximo post, vou mostrar como posicionar os objetos na janela (você vai perceber esse problema quando tentar adicionar novos objetos). Em caso de dúvidas, deixem comentários. :)

Curso de wxWidgets, post 2: Configurando uma IDE e compilando o wxWidgets

Bom, vamos começar! Primeiro, escolha uma IDE para programar. Algumas sugestões:

Eclipse: minha IDE favorita. O problema é que não é muito leve, já que foi feita em Java e pra Java :) Mas eu recomendo, tem muitos recursos bons embutidos. Se decidir usar o Eclipse, você precisa instalar um plug-in chamado CDT, ele adiciona recursos para programação em C/C++ no Eclipse (como eu disse, ele foi feito pra Java). http://www.eclipse.org

MinGW Developer Studio: Uma espécie de clone do Microsoft Visual Studio. É leve e bem legal. O problema é que não está mais sendo desenvolvido. http://www.parinyasoft.com

Dev-C++: Uma IDE leve, desenvolvida em Delphi. Não tem muitos recursos como o Eclipse, mas também é agradável de usar. http://www.bloodshed.net

Todas essas IDEs usam o compilador GCC da GNU. O GCC é instalado junto com as IDEs. No caso do Eclipse, você precisa instalar o compilador a parte. Sendo assim, basta baixar o MinGW no site http://www.mingw.org (o link direto para o download da versão 5.0.2 é http://prdownloads.sf.net/mingw/MinGW-5.0.2.exe?download). Baixe também o MSYS (http://prdownloads.sf.net/mingw/MSYS-1.0.11-2004.04.30-1.exe?download), ele é uma espécie de shell para Windows, será necessário mais tarde para compilar o wxWidgets além de possuir alguns programas necessários para o Eclipse.

Se você usa Linux, baixe o Eclipse e certifique-se de que possui o GCC instalado na sua distribuição.

Instalando o MinGW e o MSYS

Se você estiver usando Linux, pule esta parte.

Primeiro, instale o MinGW. O executável vai baixar os pacotes selecionados da Internet e instalar em C:\MinGW. Faça a instalação completa, apesar de precisarmos apenas dos compiladores, do make e da API do Windows (Win32). A instalação é fácil (leia: next, next, next...) :P.

Após instalar o MinGW, vamos ao MSYS. Ele vai fazer uma instalação gráfica e em seguida vai abrir um prompt de comando. Ele vai perguntar onde o MinGW está instalado. Se estiver em C:\MinGW, responda como c:/mingw.

As instalações ainda não acabaram. Precisamos atualizar a variável de ambiente PATH. No Windows NT e seus derivados (2000, 2003 e XP), clique com o botão direito em “Meu Computador -> Propriedades”. Vá na aba “Avançado” e clique no botão “Variáveis de ambiente”. Procure pela variável “PATH” e clique em “Editar”. No final do valor da variável, adicione: ;C:\MinGW\bin;C:\msys\1.0\bin. No Windows 95, 98 e Me, edite C:\autoexec.bat para configurar o valor de PATH.

Isso fará com que os programas instalados possam ser acessados em qualquer diretório pelo prompt do DOS. Então vamos fazer um teste. Abra o prompt do DOS e execute primeiro gcc --version. Será exibida a versão do GCC instalado, significa que o MinGW foi instalado. Em seguida, tente o comando uname -a, esse comando vai mostrar a versão do Windows, significa que o MSYS foi instalado.

Se algum dos comandos não funcionar, tente refazer a instalação do programa que falhou.

Compilando o wxWidgets

Primeiro, baixe a biblioteca do site oficial em http://www.wxwidgets.org. Se estiver no Linux, baixe o wxGTK, no Windows, baixe o wxMSW.

Depois do download, é hora de compilar! No Linux, abra uma janela do terminal ou vá para o modo texto. No Windows, abra o MSYS.

Descompacte o código fonte do wxWidgets em um diretório qualquer e entre neste diretório:

$ cd /caminho/para/o/wx

Agora você vai precisar executar o script de configuração. Geralmente uso da seguinte forma (no Windows, troque o /usr/local/wx/2.6 para algo do tipo /c/wxMSW-2.6:

$ ./configure --prefix=/usr/local/wx/2.6 --disable-debug --enable-shared --disable-unicode

--prefix=/diretorio:
O diretório onde o wxWidgets vai ser instalado

--disable-debug:
Desabilita símbolos de debug (são usados para debugar no GDB)

--enable-shared:
Compila a biblioteca em vários arquivos .so ou .dll

--disable-unicode:
Desabilita o suporte a UNICODE (meio problemático no Windows 9x e NT, pois precisam de uma biblioteca a parte, por isso costumo desabilitar, não vamos escrever programas em árabe mesmo :P)

O script de configuração será executado e vai exibir um pequeno relatório no final. Leia a saída e verifique se condiz com a configuração feita.

Após feita a configuração, compile!

$ make

E depois de toda a compilação (pode demorar um pouco), instale!

$ make install

No Linux, basta agora executar ldconfig pra atualizar a lista de bibliotecas. No Windows, temos que copiar as DLLs pro diretório do sistema:

$ cp -af /c/wxMSW-2.6/lib/*.dll /c/WINDOWS/System32/

Também é necessário copiar uma DLL do MinGW:

$ cp -af /c/MinGW/bin/mingwm10.dll /c/WINDOWS/System32/

Pronto! wxWidgets e compiladores instalados.

Vamos fazer um pequeno teste

Abra sua IDE e copie o seguinte código fonte:

#include <wx/wx.h>

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

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);
};

bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu Programa"))
{
}

IMPLEMENT_APP(MeuPrograma)

Compile ele na sua IDE. Provavelmente ela ainda não vai estar configurada para usar o wxWidgets, mas você pode compilar manualmente, basta abrir um terminal ou o MSYS no Windows e digitar o comando:

$ g++ -o wx testewx.cpp `wx-config --cxxflags` `wx-config --libs`

No Windows, você vai precisar especificar o caminho do wx-config por completo, /c/wxMSW-2.6/bin/wx-config --cxxflags...):

$ g++ -o wx testewx.cpp `/c/wxMSW-2.6/bin/wx-config --cxxflags` `/c/wxMSW-2.6/bin/wx-config --libs`

E execute o programa:

$ ./wx

Você deverá ver uma janela vazia com o título “Meu Programa”. Esse é nosso “Hello, World”. No próximo post vou explicar esse programa com detalhes.

wxWidgets é isso aí! Se não deu certo, refaça tudo, passo a passo até achar o erro. Por enquanto, tente entender o código sozinho ou até mesmo modificá-lo.

Entendendo o wx-config e configurando sua IDE

Todo programador C/C++ sabe que ao usar a linha de comando, podemos passar alguns argumentos para o gcc e para o g++, como por exemplo, incluir uma biblioteca. Quem nunca usou -lm para incluir o math.h? O que o wx-config faz é justamente isso. Experimente executar wx-config --cxxflags e wx-config --libs no seu terminal. O que você vai ver são os argumentos que devem ser incluídos no g++ na hora de compilar (--cxxflags) e na hora de “linkar” (--libs).

Se você quer usar uma IDE para compilar seus programas em wxWidgets, você precisa inserir esses parâmetros nas propriedades do seu projeto. No Eclipse, por exemplo, basta clicar com o botão direito do mouse na pasta do projeto e escolher a opção “Properties” no menu de contexto. Clique em “C/C++ Build” no painel à esquerda e insira `wx-config --cxxflags` nos argumentos de comando do g++ em “GCC C++ Compiler” e `wx-config --libs` em “GCC C++ Linker”. Veja a figura abaixo:



Se estiver usando Windows, você precisa executar o wx-config no MSYS, copiar a saída e inserir no Eclipse. Ou, você pode configurar cada configuração individualmente (Preprocessor, Directories, Optimization...)

OBSERVAÇÃO: No Eclipse do Windows, substitua o /c da saída do wx-config por c:/. Por exemplo: ao invés de -I/c/wxMSW-2.6/include, use -Ic:/wxMSW-2.6/include.

Windows Vista

Estava eu curioso para ver o sucessor do Windows XP, o Vista. Então, abri o aMule e fiz uma busca. Baixei o DVD do Windows Vista beta 2 e instalei em um computador com a seguinte configuração de hardware:

Pentium 4 HT 3.0 GHz
512 MB de memória RAM
Plca de vídeo on-board
HD de 80 GB (não lembro a marca)
Placa de rede on-board SiS
Placa de rede off-board D-Link AirPlus G+ (rede sem-fio)

Comecei a instalação. Concordo que o novo instalador está realmente bonito, isso me deixou mais ansioso pra ver a cara do novo Windows.

Ao final da instalação, os tambores batiam enquanto o Windows Vista carregava nesse computador. Efetuei logon e entrei no sistema. Papel de parede bonito...

Bem, logo de cara pude perceber que a nova barra de tarefas do Windows Vista parece o painél do KDE, o botão "Iniciar" virou um círculo preto com o logotipo do Windows (estilo o menu K). As bordas das janelas parecem ter sido inspiradas nos inúmeros temas existentes para o GNOME e KDE. Os botões parecem com os do Mac e a cara do Windows Explorer me lembrou uma mistura de Nautilus (GNOME) com Konqueror (KDE) - não falando do tema, mas da organização das coisas.

Ora, mas ficou bonito!!! Isso é que importa. Mais importante que essa beleza toda (que eu já havia saboreado no Linux) é minha memória RAM. Esse Vista é um ladrão! Basta efetuar logon no sistema para consumir 380 MB (inserimos um pen drive USB e o consumo de memória subiu pra 400 MB).

Pra quem gosta de jogar paciência, campo minado e aqueles joguinhos do Windows, sugestão: compre uma placa 3D. Ao abrir Paciência, ele me avisou que eu não tenho placa aceleradora 3D, portanto, o jogo poderia ficar lento... e ficou (e como!!!). Ah! Se você pretende ver vídeos no seu Vista, compre uma placa 3D também, pois sem ela o Media Player nem abre o vídeo (pelo menos não abriu nessa on-board).

Bem, o novo KDE 3.5 roda suavemente em um laptop Pentium III 600 MHz com 312 MB de RAM e é mais bonito que o Windows Vista.

Não escrevi esse post pra esculhambar a Microsoft, mas acho que ela poderia ter feito um trabalho melhor. E não falo de interface gráfica bonita, mas de programação eficiente que não sugue tantos recursos da máquina. Minha opinião é que esse tipo de coisa é proposital, pra alavancar o consumo de hardwares caros.

Pelo menos o WinPolicy rodou sem problemas no Windows Vista. :)

Curso de wxWidgets em C++

Olá, pessoal.

Decidi finalmente começar meu curso de wxWidgets através do meu blog. Eu já vinha idealizando ele desde o meu primeiro dia de blogueiro. É um tipo de "Aprenda você mesmo wxWidgets em x posts" (o "x" significa que não sei em qual post vou parar). O objetivo é ensinar como fazer bons softwares com interfaces gráficas usando C++.

Muita gente pensa que programar em C e C++ é extremamente complicado. A culpa é da API do Windows! Realmente ela é um pouco chata de aprender, pelo menos esta é minha opinião. Aí, infelizmente, as pessoas tendem a correr pro Java.

OBSERVAÇÃO: A partir deste ponto, é necessário avisar que no percurso deste curso, e provavelmente em alguns outros posts do meu blog, você verá frases e afirmações não muito amigáveis à esta linguagem. Não tenho nada contra Java, até conheço um pouco da linguagem (não tanto quanto C e C++), mas faço isso porque gosto de pirraçar programadores Java, é meu esporte favorito.

Voltando ao curso, minha tarefa aqui é resgatar as pobres almas perdidas no mundo do Java, Delphi, Visual Basic e outros, trazendo-as pro lado do C/C++. Você vai aprender que programar com interfaces gráficas em C++ usando wxWidgets é ainda mais fácil que programar em Java.

"O que eu NÃO vou aprender?"

Processos de desenvolvimento de software, documentação, análise, etc. Bem, provavelmente eu fale um pouco sobre essas coisas, mas não vou entrar em detalhes. O objetivo do curso é o wxWidgets no C++.

"O que é preciso para estudar através deste curso?"

Bem, se você já souber C e C++, já é o suficiente. Mas se você sabe pouco ou nada sobre estas linguagens, não se desespere! Existe um curso on-line de C da UFMG em http://ead1.eee.ufmg.br/cursos/C/ . Mas é bom lembrar que você precisa saber pelo menos o básico de orientação a objetos em C++, já que o wxWidgets é orientado a objetos.

"Que bom! Quais serão os tópicos estudados?"

Não tenho um cronograma fixo para seguir, mas pretendo começar da seguinte forma:

- Introdução a wxWidgets, como configurar, instalar e usar;
- "Hello, world" em wxWidgets;
- E aí vamos nos infiltrando nas outras classes da Framework...

Referências bibliográficas

Para dúvidas de C++, uso o livro "C++: Como Programar" de Deitel. Para dúvidas sobre o wxWidgets, uso a documentação on-line no endereço http://www.wxwidgets.org/
Mais uma vez, recomendo o curso de C da UFMG.

Outros detalhes

Tentarei escrever um post por semana, isso vai dar tempo para os visitantes estudarem o post e para que eu possa preparar o próximo ("tentarei", porque preciso dividir meu tempo com outras coisas, inclusive o lazer). Cada post também terá um código de exemplo do assunto abordado e os visitantes poderão deixar comentários, podendo tirar dúvidas com outros visitantes ou comigo mesmo, ou até mesmo sugerir alguma coisa.

Então, espero que isso dê certo. Além de divulgar o conhecimento, pretendo também melhorar o meu próprio conhecimento. :)