sábado, 27 de outubro de 2012

wxAutomationObject – Parte 4 – Exibir ou esconder o Excel

Agora começaremos a trabalhar com propriedades, na classe wxAutomationObject usamos dois métodos para isto, um chamado GetPropert para pegarmos o valor de uma propriedade e PutPropert para alterarmos uma propriedade, note que a partir daqui iremos utilizar com frequência wxVariants, então recomendo que vocês leiam a documentação da mesma.

Primeiro vamos verificar se o Excel está visível ou se está correndo em segundo plano.

Na classe wxAutomationExcel em public digitamos a declaração da função.

bool GetVisible();

no arquivo mexcel.cpp sua contrução.

bool wxAutomationExcel::GetVisible()
{
     if(this == NULL)
         return false;

     wxVariant m_show = this->GetProperty(wxT("Visible"));

     return m_show.GetBool();
}

No código acima, vemos o uso do método GetProperty, passamos para o mesmo o nome da propriedade que queremos pegar o valor e passamos esse para um wxVariant, veja que antes verifico se wxAutomationExcel é nulo, se o Excel estiver visível nossa função retornará verdadeiro, caso contrário, falso...

Agora, vamos alterar essa propriedade, escondendo ou exibindo a instância do Excel que estiver setada em nosso wxAutomationExcel.

Na classe wxAutomationExcel em public digitamos a declaração da função.

bool SetVisible(bool visible);

no arquivo mexcel.cpp sua contrução.

bool wxAutomationExcel::SetVisible(bool visible)
{
     if(this == NULL)
         return false;

    if(!this->PutProperty(wxT("Visible"), visible))
    {
        wxLogError(wxT("Excel não pode ser exibido"));
         return false;
    }

     return true;
}

Nessa função utilizamos o método PutProperty, esse método é utilizado para pegarmos alguma propriedade do objeto setado em nossa classe, passamos primeiro o nome da propriedade e depois o valor que queremos dar para ela, no caso da propriedade Visible passamos um valor booleano.

Vale lembrar que essa classe está trabalhando apenas com o Excel.Application, então todos os métodos e propriedades passados como parâmetros servem apenas para a aplicação em si.

Para testarmos as duas funções apresentadas nesse tutorial:

wxAutomationExcel m_excel;

if(!m_excel.GetExcelInstance())
     return;

//ou
//if(!m_excel.CreateExcelInstance())
//   return;

//Vejo se o Excel está visível...
if(m_excel.GetVisible())//...se sim...
     m_excel.SetVisible(false);//...escondo...
else//...se não...
     m_excel.SetVisible(true);//...exibo o mesmo...

No próximo tutorial iremos iniciar com Workbooks, até.

quarta-feira, 24 de outubro de 2012

wxAutomationObject – Parte 3 – Criando uma nova instância do Excel.

Criaremos agora uma função que executa uma nova instância do Excel, ela  será publica e do tipo booleana também.

Na classe wxAutomationExcel em public digite a função.

bool CreateExcelInstance();

no arquivo mexcel.cpp sua contrução.

bool wxAutomationExcel::CreateExcelInstance()
{
     if(!this->CreateInstance(wxT("Excel.Application")))
     {
         wxLogError(wxT("Não foi possível criar a instância"));
         return false;
     }

     return true;
}

Nesse código utilizamos outro método da classe wxAutomationObject, CreateInstance passando para o mesmo a string "Excel.Application", ela retornará verdadeiro se conseguir criar uma nova instância do Excel passando o ponteiro para nosso wxAutomationExcel, se ocorrer algum problema ela retornará falso e nosso wxAutomationExcel será nulo.

Para testar a função:

wxAutomationExcel m_excel;
if(!m_excel.CreateExcelInstance())
     return;

//Aqui poderíamos seguir...

wxAutomationObject – Parte 2 – Verificando se o Excel está em execução:

Vamos iniciar criando uma função que verifica se o Excel está em execução, ela será pública do tipo booleana, se uma instância do Excel estiver em execução ela retornará verdadeiro, se não, retornará falso.

Na classe wxAutomationExcel em public digite:

bool GetExcelInstance();

no arquivo mexcel.cpp sua construção.

bool wxAutomationExcel::GetExcelInstance()
{
     if(!this->GetInstance(wxT("Excel.Application")))
     {
         wxLogError(wxT("Excel não está em execução"));
         return false;
     }

     return true;
}


No código acima vemos a função GetInstance da classe wxAutomationObject, ela verificará se o Excel está rodando, se o mesmo estiver executando, ele passará o ponteiro da aplicação para nosso wxAutomationExcel e retornará verdadeiro, nesse ponto já podemos trabalhar com a automação, se o Excel não estiver rodando, ele retornará falso e nosso wxAutomationExcel será nulo, ou seja, não estará preparado para executar a automação.

Uma coisa que você deve ter em mente é que, se mais de uma instancia do Excel existir, ele  pegará como ponteiro a primeira instancia criada.

Para testar essa função :

wxAutomationExcel m_excel;

if(!m_excel.GetExcelInstance())
     return;

//Aqui poderíamos prosseguir...

segunda-feira, 22 de outubro de 2012

wxAutomationObject - Excel - Reiniciando

Voltando com os tutoriais sobre wxAutomationObject, como sempre, vou postando as coisas sem muito critério e as elas acabam ficando um pouco complicadas, vou reiniciar do zero pra explicar melhor como as coisas funcionam, e criar classes para gerenciar o conteúdo das explicações.

wxAutomationObject é uma classe que fornece um ponteiro IDispath, que nada mais é que uma referência para um COM/OLE Object, permitindo a execução e automação do Excel, por exemplo.

*Importante: wxAtomationObject é uma classe exclusiva para wxMSW, ou seja, você só conseguirá compilar os exemplos no Sistema Operacional Windows.

Para entendermos a estrutura das classes, vamos entender como é estruturado um arquivo do Excel.


No diagrama podemos ver claramente cada objeto que iremos utilizar:

A instância do programa seria o Excel que está sendo executado na memória naquele momento, seria o Excel.exe sendo executado.

O Workbook é a pasta de trabalho ou o arquivo em si.

Dentro de um Workbook podemos ter uma ou mais planilhas, que no diagrama vemos como Sheet ou Worksheet, por padrão, ao iniciarmos um novo Workbook o mesmo conterá 3 planilhas (Sheet).

E as células, que são os locais onde iremos inserir ou ler os dados que queremos.

Talvez as coisas fiquem mais claras com a imagem abaixo.



Em 1, temos o Excel em execução, é ele que vai gerenciar a automação e execução dos procedimentos e propriedades.

Em 2 temos a pasta de trabalho, é nosso arquivo em si, ele que vai conter todas as nossas planilhas, usaremos o mesmo para salvar o documento ou inserirmos e deletarmos planilhas.

Em 3 temos as planilhas que irão conter as células, podemos alterar seu nome, por exemplo, e gerenciar as células existentes.

Em 4, as células, elas irão conter os valores, como data, textos, números, etc... podemos alterar suas propriedades também, como a cor de fundo, tipo de borda...

Agora que temos de forma clara como é a estrutura de um arquivo Excel, assim como de sua instância, vamos iniciar com os códigos. Criaremos 2 arquivos para armazenar as classes, um chamado mexcel.h e outro mexcel.cpp.

Primeiro iremos trabalhar com uma classe que vai representar o Excel em si, vou chamá-la de wxAutomationExcel e ela será derivada de wxAutomationObject, ele será aqui na nossa estrutura de desenvolvimento, a “Instância”.

No arquivo mexcel.h digite:

#include <wx/wx.h>
#include <wx/msw/ole/automtn.h>

class wxAutomationExcel: public wxAutomationObject
{
public:
          wxAutomationExcel();
          ~wxAutomationExcel();
private:
};

E no arquivo mexcel.cpp:

#include "mexcel.h"

wxAutomationExcel::wxAutomationExcel():wxAutomationObject()
{
}

wxAutomationExcel::~wxAutomationExcel()
{
}

No próximo tutorial vamos iniciar com as funções que irão fazer parte da classe.