Lazarus - Formulários e o componente MainMenu

Abra um novo projeto


Salvar com os nomes
Arquivo de projeto: Formulario
Arquivo de unit: u_1_formulario


Insera um novo formulário
File / New Form

F9 – para compilar
Salve o novo formulário
Pedirá para salvar o formulário ( unit )
Salve com o nome u_2_formulario


Adicione um botão no formulário 1
Dê um duplo clique e programe com o código:

=======================================================

Form2.show;

=======================================================

É necessário adicionar a unit que é responsável por esse formulário.
Adiciona-se com o comando uses.
Antes do procedimento " TForm1.Button1Click "

=======================================================

implementation    
{ TForm1 }          
uses u_2_formulario;
procedure TForm1.Button1Click(Sender: TObject);

=======================================================


Componente TmainMenu

Adicione um TmainMenu no formulário 1.
Um clique no componente e um clique no formulário 1.

Duplo clique no componente MainMenu1
Clique em “New Item 1” e altere a propriedade “Caption” para “Arquivo”
Clicar com o botão direito no botão “Arquivo” e escolher “Create Submenu”
Clique em “New Item 2” e altere a propriedade “Caption” para “Sair”


Feche o “Menu Editor” do “MainMenu1”
Voltando ao formulário principal ( formulário 1 )
Clique em “Arquivo” e clique em “Sair” do Form1
Digite:

=======================================================

Close;

=======================================================

Execute o programa e faça um teste


Altere a propriedade Caption colocando o símbolo “&” antes do caption
&Arquivo
&Sair
Observe que a primeira letra fica sublinhada
Isso significa que é possível acessar esses comandos com a tecla “Ctrl + letra que está sublinhada” ou “Alt + letra que está sublinhada”.


Abra o “MainMenu1”
Clique com o botão direito em “Arquivo”
Clique em “Insert New Item (After)”
Altere o “Caption” para “Ajuda”
Clique com o botão direito em “Ajuda”
Clique em “Create Submenu”
Altere o “Caption” para “Sobre”
Feche o “Menu Editor” do “MainMenu1”


Voltando ao formulário principal
Clique em “Ajuda” e depois em “Sobre”
Digite:

=======================================================

Form2.Show;

=======================================================

Execute o programa e faça um teste


Altere o aspecto do formulário 2
Crie informações sobre o seu programa
Exemplo:
versão
autor
e-mail
Seja criativo
Adicione um botão “Ok” que irá fechar o formulário Sobre.


Adicione um terceiro formulário
Faça um pequeno programa que o usuário entra com dois números e imprima o menor;
Antes do menu “Sair”, adicione um menu que irá levar para o formulário de mostrar o menor, altere o “Caption” desse submenu para “Menor”.

Lazarus - Componente CheckBox

Fazer um programa para um restaurante onde o usuário irá realizar escolhas sobre uma refeição e aparecerá o preço dessa refeição.

– A interface gráfica deverá ser montada conforme mostrado em sala.

– Terão 3 RadioButtons para especificar o tamanho do prato: pequeno, médio ou grande. O usuário deverá escolher apenas uma dentre essas três opções de tamanhos.

– Terão 6 CheckBox para especificar quais os componentes o usuário deseja no prato: carne boi, carne frango, carne peixe, salada, batata frita e ovo frito. O usuário poderá escolher nenhum, um ou vários componentes.

– Os valores (R$) relacionados ao tamanho dos pratos serão: prato pequeno: 5; prato médio: 7; prato grande: 9.

– Os valores (R$) relacionados aos componentes serão: carne boi: 5; carne frango: 4; carne peixe: 3; salada: 1,5; batata frita:3; ovo frito: 1.

– Terão 3 botões: Montar, Limpar e Sair.

– O botão Montar: se não estiver nenhum tamanho de prato selecionado, deverá informar a mensagem (ShowMessage), “Por favor, escolha um tamanho de prato!”. Caso tenha algum tamanho de prato selecionado, deverá informar a mensagem (ShowMessage), “Valor do PF = R$12,50”, por exemplo.

– O botão limpar: deverá limpar a seleção de todos RaioButton e de todos CheckBox.

– O botão sair: sai do programa.

A imagem do formulário com as respectivas propriedades "Names" já alterados exibidas na janela "Object Inspector" encontra-se abaixo:

O código encontra-se abaixo:

=======================================================

procedure TFrmMontar.BtnMontarClick(Sender: TObject);
var Preco : Real;
begin
   Preco := 0;

   if ((RdBtnPFPequeno.Checked=false) and (RdBtnPFMedio.Checked=false) and (RdBtnPFGrande.Checked=false))
      then ShowMessage('Por favor, escolha um tamanho de prato!');

   if (RdBtnPFPequeno.Checked)
      then Preco := 5
      else if (RdBtnPFMedio.Checked)
         then Preco := 7
         else if (RdBtnPFGrande.checked)
            then Preco := 9;

   if (ChckBxBoi.Checked) then Preco := Preco + 5;
   if (ChckBxFrango.Checked) then Preco := Preco + 4;
   if (ChckBxPeixe.Checked) then Preco := Preco + 3;
   if (ChckBxSalada.Checked) then Preco := Preco + 1.5;
   if (ChckBxBatata.Checked) then Preco := Preco + 3;
   if (ChckBxOvo.Checked) then Preco := Preco + 1;

   if ((RdBtnPFPequeno.Checked) or (RdBtnPFMedio.Checked) or (RdBtnPFGrande.Checked))
      then ShowMessage('Valor do PF = R$ ' + FormatFloat('0.00;-0.00;zero', Preco));

end;

procedure TFrmMontar.BtnLimparClick(Sender: TObject);
begin
   RdBtnPFPequeno.checked := False;
   RdBtnPFMedio.checked := False;
   RdBtnPFGrande.checked := False;
   ChckBxBoi.Checked := False;
   ChckBxFrango.Checked := False;
   ChckBxPeixe.Checked := False;
   ChckBxSalada.Checked := False;
   ChckBxBatata.Checked := False;
   ChckBxOvo.Checked := False;
end;

procedure TFrmMontar.BtnSairClick(Sender: TObject);
begin
  close
end;

=======================================================

Debian 6.0.6 - Instalando o navegador Google Chrome

Para instalar o navegador Google Chrome no Debian 6.0.6 Squeeze pode se proceder da seguinte maneira.

Será utilizado o repositório do Chrome no sources.list, com isso, o navegador Google Chrome também será atualizado caso seja feito uma atualização para o sistema.

Abra o terminal: " Ctrl + Alt + T "

Entre como root: "su"

:~$ su

Senha:

#

Edite o sources.list:

# gedit /etc/apt/sources.list

Adicione a seguinte linha no sources.list e salve esse arquivo:

deb http://dl.google.com/linux/chrome/deb/ stable main

Após salvar e voltar ao terminal, adicione a chave gpg ao apt:

# wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add -

OK

#

Atualize o sistema:

# apt-get update

Instale o navegador Google Chrome:

# apt-get install google-chrome-stable

Debian 6.0.6 - GRUB não reconhece o sistema que já estava instalado

Ao instalar o Debian GNU/Linux 6.0.6 Squeeze i386 paralelamente com outro sistema operacional que já esteja instalado no PC, o GRUB (programa que é executado ao ligar o PC para escolher em qual sistema operacional irá "entrar") não reconheceu o sistema que já estava instalado.

Para que o GRUB reconheça outros sistemas que já estavam instalados antes de instalar o Debian é necessário atualizar o GRUB, uma das formas é a seguinte:

Abrir o terminal. Pode ser aberto com o atalho utilizando as teclas Ctrl + Alt + T.

Entre como superusuário, bastando digitar "su", em seguida digite a senha, e estará como root (#):

~:$ su
Senha:
#

Basta digitar: "update-grub":

# update-grub

Ao digitar esse último comando, irá aparecer no terminal os sistemas que ficarão como opção para escolha ao iniciar o PC. Reinicie o PC e verifique se o(s) sistema(s) que não foi(ram) reconhecido(s) está(ão) disponível(is) para inicialização no GRUB.

Solver - resolvendo um problema e interpretando seus relatórios

Resolver o seguinte problema:

Variáveis: X1 = Cadeira e X2 = Mesa

Maximizar Lucro = 4 * X1 + 1 * X2

S.A: Madeira) 2 * X1 + 3 * X2 >= 12

Metal) 2 * X1 + 1 * X2 >= 8

Primeiramente, deve-se preencher as células da planilha:

Como exemplo:

A5:A6 [ Variáveis ]

A9:A10 [ Restrições]

B3 [ Lucro ]

B5 [ Cadeira ]

B6 [ Mesa ]

B9 [ Madeira]

B10 [ Metal ]

C3 [ =4*C5+1*C6 ]

C5 [ 1 ]

C6 [ 1 ]

C9 [ =2*C5+3*C6 ]

C10 [ =2*C5+1*C6]

D8 [ Limites ]

D9 [ 12 ]

D10 [ 8 ]

Clicar em Dados / Solver.

Caso o solver não esteja “ativado”, deverá se ativado da seguinte forma:

• clicar no símbolo (círculo) no canto superior esquerdo;
• clicar em “Opções”;
• clicar em “Suplementos”;
• clicar em “Solver” (selecionar);
• clicar em “ir...”
• clicar em “solver” (selecionar);
• clicar em “Ok”;
• se preguntar se “Deseja instalá-lo agora?” Clicar em “Sim”.

Após clicar em “Dados / Solver” irá abrir a “janela do Solver”.

Entrar com os seguinte dados:

• Definir célula de destino: $C$3
• Igual a: Máx
• Células variáveis: $C$5:$C$6
• Submeter às restrições: Adicionar: $C$10 <= $D$10 Adicionar: $C$9 <= $D$9
• Clicar em opções, marcar a opção: Presumir não negativos. Com isso X1 e X2 >= 0
• Clicar em Ok
• Clicar em Resolver
• Relatórios, marcar: Resposta, Sensibilidade e Limites

Interpretação dos relatórios para o exemplo dado:

Relatório de resposta:

• célula de destino: valor do lucro (valor final). Lucro = 16
• células ajustáveis: valor de cadeira e mesa a ser produzido (valor final). Cadeira = 4; Mesa = 0
• restrições status: sem agrupar, a solução obtida não coincide com o valor limite da restrição; agrupar, a solução obtida coincide com o valor limite da restrição. Madeira = sem agrupar; Metal = Agrupar;
• Restrição transigência: diferença entre o valor limite e o valor obtido pela restrição. Madeira = 12-8=4; Metal = 8-8=0;

Relatório de sensibilidade:

• Reduzido gradiente: mede o crescimento do objetivo por unidade na célula ajustável, ou seja, quanto varia o lucro se passar a produzir mais um produto. Se passar a produzir mais uma mesa o lucro passa a ser 15. Se passar a produzir mais duas mesas o lucro para a ser 14; Cadeira = 0; Mesa = -1;
• Lagrange Multiplicador: Alteração da F.O. para um aumento unitário nos limites das restrições. Se for zero, significa uma restrição cuja solução não atingiu o limite especificado; Madeira = 0; Metal = 2

Relatório de limites

• Limite inferior: menor valor que a variável pode assumir, em função das restrições e do resultado. Cadeira = 0; Mesa = 0;
• Limite superior: maior valor que a variável pode assumir, em função das restrições e do resultado; Cadeira = 4; Mesa = 0;
• Destino resultado: o valor de F.O. caso esteja nesse limite (inferior ou superior).
• Obs.: nesse exemplo, como não se produz mesa, o destino será sempre 16, para a mesa, pois a mesma não é produzida. Caso não se produza cadeira, o destino resultado será 0, caso produza o máximo de cadeira, o destino resultado será 16.

Lazarus - Componente GroupBox

Componente GroupBox

Monte a estrutura abaixo com 2 componetes GroupBox. Um com a propriedade Caption sendo Sexo e o outro sendo Idade. Em seguida adicione dois RadioButton em cada Group Box. Verifique a "hierarquia" na janela ObjectInspector.

Adicione os outros componentes, altere a propriedade Caption e Name de cada componente, conforme abaixo:

O programa deverá mostrar as seguintes informações através do ShowMessage, conforme as opções que forem selecionadas:
- Feminino e Maior 18 anos = “Mulher liberada”
- Feminino e Menor 18 anos = “Mulher não liberada”
- Masculino e Maior 18 anos = “Homem liberado”
- Masculino e Menor 18 anos = “Homem não liberado”
Caso não se selecione o sexo, deverá aparecer a informação: "Favor informar o sexo".
Caso não se selecione a idade, deverá aparecer a informação: "Favor informar a idade".

Programe o botão Calcular com o seguinte código:


------------------------------------------------------------------------------------
procedure TFrmControle.BtnCalcularClick(Sender: TObject);
begin
  if (RdBtnMaior.Checked)
     then if (RdBtnFeminino.Checked)
          then showmessage('Mulher liberada.')
          else if (RdBtnMasculino.Checked) then showmessage('Homem liberado.');
  if (RdBtnMenor.Checked)
     then if (RdBtnFeminino.Checked)
          then showmessage('Mulher não liberada.')
          else if (RdBtnMasculino.Checked) then showmessage('Homem não liberado.');
  if (RdBtnFeminino.Checked = False) and (RdBtnMasculino.Checked = False)
     then showmessage('Favor escolher uma opção de sexo.');
  if (RdBtnMaior.Checked = False) and (RdBtnMenor.Checked = False)
     then showmessage('Favor escolher uma opção de idade.');
end;  
------------------------------------------------------------------------------------


Programe o botão Limpar com o seguinte código:
------------------------------------------------------------------------------------
 procedure TFrmControle.BtnLimparClick(Sender: TObject);
begin
     RdBtnMaior.Checked := False;
     RdBtnMenor.Checked := False;
     RdBtnFeminino.Checked := False;
     RdBtnMasculino.Checked := False;
end;
------------------------------------------------------------------------------------

 Programe o botão Sair com o seguinte código:
------------------------------------------------------------------------------------
 procedure TFrmControle.BtnSairClick(Sender: TObject);
begin
  Close;
end; 
------------------------------------------------------------------------------------

Lazarus - Componente RadioButton

Monte um formulário com 3 label, 3 edit, 3 botton e 4 radiobutton.

Alterar a propriedade Name:

Form1 = FrmCalculadora
Label1 = LblN1
Label2 = LblN2
Label3 =LblResultado
Edit1 = EdtN1
Edit2 = EdtN2
Edit3 = EdtResultado
Button1 = BtnCalcular
Button2 = BtnLimpar
Button3 = BtnSair
RadioButton1 = RdBtnSoma
RadioButton2 = RdBtnSubtracao
RadioButton3 = RdBtnMultiplicacao
RadioButton4 = RdBtnDivisao

Após alteras a propriedade Name dos Componentes o Formulário e o Object Inspector terá a seguinte aparência

Alterar as propriedades Caption / text:

FrmCalculadora: caption = Calculadora
LblN1: caption = Número 1
LblN2: caption = Número 2
LblResultado: caption = Resultado
EdtN1: text = vazio (em branco)
EdtN2: text = vazio (em branco)
EdtResultado: text = vazio (em branco)
BtnCalcular: caption = Calcular
BtnLimpar: caption = Limpar
BtnSair: caption = Sair
RdBtnSoma: caption = Soma
RdBtnSubtracao: caption = Subtração
RdBtnMultiplicacao: caption = Multiplicação
RdBtnDivisao: caption = Divisão

Após alteras a propriedade Caption/Text dos Componentes o Formulário e o Object Inspector terá a seguinte aparência:

Alterar a propriedade ReadOnly do EdtResultado para True. Com isso, esse componente terá a capacidad3e de apresentar um valor, não permitindo a sua alteração.

Para programar o botão Calcular, duplo clique nesse botão. Inserir o código:

=======================================================
procedure TFrmCalculadora.BtnCalcularClick(Sender: TObject);
Var A, B, R : real;
begin
  if ((EdtN1.text = '') or (EdtN2.text = ''))
    then ShowMessage ('Preencha os campos número 1 e o númer 2')
    else
    begin
      A := StrToFloat(EdtN1.text);
      B := StrToFloat(EdtN2.text);
      if (RdBtnSoma.checked)
        then R := A + B
        else if (RdBtnSubtracao.checked)
          then R := A - B
          else if (RdBtnMultiplicacao.checked)
            then R := A * B
            else if (RdBtnDivisao.checked)
              then if (B = 0)
                then
                begin
                  EdtResultado.text := 'Erro';
                  ShowMessage('Número 2 deve ser diferente de zero');
                end
                else R := A / B;
  end;
  if (RdBtnDivisao.checked=false)or(b<>0)
    then EdtResultado.text := FormatFloat('0.00;-0.00;zerado', R);
  if ((EdtN1.text = '') or (EdtN2.text = ''))
    then EdtResultado.text := '';
  EdtN1.setFocus;
end;
=======================================================

Para programar o botão Sair e Limpar.

Duplo clique no botão Sair:
=======================================================
Close
=======================================================

Duplo clique no botão Limpar:
=======================================================
EdtN1.text := '';
EdtN2.text := '';
EdtResultado.text := '';
RdBtnSoma.Checked := True
=======================================================

Referência


MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Exercício do triângulo

-->

Faça um programa que receba o valor dos três lados de um triângulo e mostre a seguinte informação (showmessage = Não é triângulo) ou (showmessage = Triângulo equilátero) ou (showmessage = Triângulo escaleno) ou (showmessage = Triângulo isósceles).

Duplo clique no botão calcular para "programá-lo" , o código encontra-se abaixo.

============================================

 procedure TForm1.BtnCalcularClick(Sender: TObject);
var A, B, C : Integer;
begin
     A := StrToInt(edtA.text);
     B := StrToInt(edtB.text);
     C := StrToInt(edtC.text);
     if (A < B+C ) and (B < A+C) and (C < A+B)
     then
        if (A = B) and (B = C)
        then
           ShowMessage ('Triângulo Equilátero')
        else
            if (A = B) or (A = C) or (C = B)
            then
                ShowMessage ('Triângulo Isósceles')
            else
                ShowMessage ('Triângulo Escaleno')
     else
         ShowMessage ('Não é Triângulo');
     edtA.SetFocus
end;  

============================================

 

-->

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Aplicação com tipo de dado real

Montar a seguinte interface gráfica

Fazer um programa para somar dois números reais, limpar os dados e sair.

Utilize a função FormatFloat que utiliza dois parâmetros, sendo o primeiro a máscara de formatação e o segundo o valor a ser formatado. O valor formatado é transformado em uma string.

A máscara de formatação que será utilizada é a seguinte ('#,##0.00'), onde

# (tralha) estabelece a supressão de valores zerados, quando eles existirem;
, (vírgula) estabelece a separação de milhares (notação norte-americana);
. (ponto) estabelece a separação do ponto para casas decimais (notação norte-americana).

Exemplos de exibição para o número 2.546,58 e o número 44,32:
0,000.00 exibirá 2,546.58 e 0,044.32
#,##0.00 exibirá 2,546.58 e 44.32

Observe que a utilização de máscaras de formatação possibilita a especificação de três formatos diferentes simultaneamente, separados por ponto-e-vírgula. Com isso é possível ter uma máscara para valores positivos, negativos e zeros. Verifique no código seguinte.

O código encontra-se abaixo:

=================================================
procedure TForm1.Button1Click(Sender: TObject);
var a,b,soma: real;
begin
    if ((edit1.text='') or (edit2.text=''))
    then showmessage('Favor preencher os dois números!')
    else
    begin
        a := strtofloat(edit1.text);
        b := strtofloat(edit2.text);
        soma := a + b;
        label1.caption := formatfloat('#,##0.00;(#,##0.00); zerado', Soma);
    end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
    edit1.text := '';
    edit2.text := '';
    label1.caption := '';
    edit1.setfocus;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
    Close;
end;
=================================================

 Faça o seguinte programa:
1 – obter o valor para a variável HT (horas de trabalho no mês);
2 – obter o valor para a variável VH (valor da hora trabalhada);
3 – obter o valor para a variável PD (percentual de desconto);
4 – Calcular o salário bruto (SB): SB = HT x VH;
5 – Calcular o total de desconto (TD): TD = (PD/100) x SB;
6 – Calcular o salário líquido (SL): SL = SB – tudo;
7 – Apresentar o valor do salário líquido: SL.

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Lazarus - Entrada e saída de dados numéricos

Entrada e saída de dados numéricos

Dados numéricos são apresentados sob o tipo caracteres (string);

Antes de serem repassados ao programa, esses dados numéricos devem ser transformados de caracteres para numérico. E o contrário, quando forem apresentados no formulário;

As funções do FPL que fazem essas tarefas são:

StrToFloat e StrToInt – Transforma de caractere (string) para numérico (real e inteiro respectivamente).

FloatToStr e IntToStr - Transforma de numérico (real e inteiro respectivamente) para caractere (string).

Entrada e saída com tipo de dado inteiro

Monte a seguinte interface gráfica para somar dois números inteiros

Dê um duplo clique no botão Somar e digite o código

--------------------------------------------------------------------
procedure TForm1.Btn1Click(Sender: TObject);
Var a, b, r : integer;
begin
     a := strtoint(Edt1.text);
     b := strtoint(Edt2.text);
     r := a + b;
     Lbl4.caption := inttostr(r);
end;
--------------------------------------------------------------------

Basta executar (F9) e testar.

Referência

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

Ordenação de vetores dançando (bubble, insertion, quick)

Criado em Sapientia, uma instituição de ensino superior húngaro na região histórica da Transilvânia, Romênia.

 Método bubble-sort:

Método insertion-sort:

Método quick-sort:

Lazarus - Primeiros programas em FPL (Free Pascal Lazarus)

Primeiro programa em FPL em ambiente console

Para criar um programa em ambiente console basta clicar nos seguintes:

File / New... / Project / Program

Aparecerá uma janela:

Save changes new project ..............
Clique em No

Basta digitar o código

Para compilar basta digitar:

Ctrl + F9

Para executar basta digitar:

F9

Primeiro programa em FPL em ambiente de janela

Primeiramente é bom fechar os projetos que porventura estejam abertos:

File / Close all editor files

Criando uma nova aplicação em ambiente de janelas

File / New / Project / Application

Save changes to...
Clique em No 

 Faça o seguinte programa para o algoritmo:
– Ler um nome fornecido pelo teclado
– Preparar a apresentação do nome
– Apresentar o nome

Para isso utilize:
– um Form
– um Edit
– um Button
– um Label

Para inserir um determinado componente no formulário, basta dar um clique com o ponteiro do mouse sobre o componente escolhido, depois posicionar o ponteiro do mouse sobre o formulário Form1 e dar um outro clique

Observar que:

– os componentes inseridos (Form, Edit, Button e Label) ficam visíveis na janela Object Inspector

Form: é o formulário, a "base" para os outros componentes, ou seja, a janela onde o programa será criado
Edit: permite a entrada (e a exibição) de textos e valores
Label: permite a exibição de textos e valores
Button: é um botão que o usuário pode pressionar para iniciar uma ação no aplicativo. Para o programador criar o código referente aquele botão basta dar um duplo clique sobre o mesmo no ambiente de programação

Os componentes Button e Label possuem propriedade Caption
O componente Edit possui propriedade Text

As propriedades Caption e Text desses componentes são similares

Propriedade Name: faz referência ao nome físico da propriedade (“razão social”)
Propriedade Caption: faz referência ao nome virtual da propriedade (“nome fantasia”)
Propriedade Text: "similar" à propriedade caption, faz referência ao conteúdo do componente edit

Alterar a propriedade Name dos componentes

Name do Formulário = Frm1
Name do Edit = Edt1
Name do Button = Btn1
Name do Label = Lbl1

Alterar a propriedade Caption dos componentes

Caption do Formulário = Escrever
Caption do Button = Ok
Caption do Label =

Alterar a propriedade Text do componente

Text do Edit =

Programando o botão Ok:
– duplo clique no botão Ok
– inserir o código:

  lbl1.caption := edt1.text;

Compilar: Ctrl + F9
Rodar: F9

Digite valores no edite do executável e clique no botão ok para testar

Salvar da seguinte forma:

– crie uma pasta
– salve nesta pasta criada
– primeiro arquivo: Nome.lpi
– segundo arquivo: u_nome.pas

Para abrir basta ir até a pasta onde foi salvo
– dê um duplo clique no arquivo: Nome.lpi (Lazarus Project Information)
Abrirá o projeto com a unit u_nome.pas

Faça o seguinte programa para o algoritmo:

– ler o nome
– ler o sobrenome
– concatenar o nome com o sobrenome
– um botão para apresentar o nome completo
– um botão para limpar o nome completo (edit e label)

Para isso construa o formulário como segue

O formulário ficará da seguinte forma:

Programando o botão Concatenar, basta dar um duplo clique sobre o botão concatenar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button1Click(sender: TObject);
Begin
    Label3.Caption := Edit1.Text+' '+Edit2.Text;
End;
---------------------------------------------------------------------

Programando o botão Limpar, basta dar um duplo clique sobre o botão limpar e inserir o código abaixo:
---------------------------------------------------------------------
Procedure Tform1.Button2Click(Sender: TObject);
Begin
    Edit1.Text := ' ';
    Edit2.Text := ' ';
    Label3.Caption := ' ';
    Edit1.SetFocus;
End;
---------------------------------------------------------------------

Referências

MANZANO, José Augusto Navarro Garcia; MENDES, Sandro Santa Vicca. Estudo dirigido de Delphi 7. São Paulo: Érica, 2003.

MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.

Lazarus - Iniciando no Lazarus

Lazarus foi iniciado em fevereiro de 1999. Foi fundada principalmente por três indivíduos: Cliff Baeseman, Shane Miller, Michael A. Hess.

Todos os três tinham tentado se envolver com o projeto de Megido que dissolveu. Na frustração que iniciou o projeto Lazarus. Ele teve um crescimento constante de apoiadores e desenvolvedores durante os anos seguintes.

Dos três fundadores, apenas Michael A. Hess ainda está envolvido com o projeto.

O membro mais antigo próximo da equipe é Marc Weustink. Ele se envolveu com o projeto em agosto de 1999.

Seguindo ele é Mattias Gaertner, que se envolveu em setembro de 2000.

Ambos foram os principais contribuintes para o núcleo do que faz Lazarus assinalar.

Lázarus é a bibliotecas de classes para Free Pascal que emulam Delphi.

O Lazarus é uma alternativa de código aberto (open source) ao Delphi®, com a grande vantagem de ser multiplataforma. Trata-se de um Ambiente Integrado de Desenvolvimento (IDE) com base na linguagem Pascal e no compilador Free Pascal, que há décadas são utilizados no meio acadêmico.

O Free Pascal é um compilador de código fonte aberto com duas notáveis características: um grau elevado de compatibilidade com Delphi e com capacidade para ser executado em Windows, Mac e Linux.

Tanto o Free Pascal como o Lazarus são escritos em Pascal. O código fonte completo está disponível para o compilador Free Pascal e Lazarus.

Lazarus é o nome do ambiente de programação que agrega uma IDE ( Integrated Development Environment – Ambiente de Desenvolvimento Integrado ) com o compilador Free Pascal.

O ambiente de programação Lazarus caracteriza-se por ser uma ferramenta de programação do tipo RAD ( Rapide Application Development – Desenvolvimento Rápido de Aplicações ), em que é possível por meio de interface gráfica, construir aplicações complexas.

O Lazarus pode ser obtido no endereço

http://www.lazarus.freepascal.org

na opção Downloads.

A tela principal do Lazarus é formada por cinco janelas.

Deixando na forma padrão:
File / New … / Project Application / OK

A primeira, localizada no alto do desktop, é chamada de Lazarus IDE v0.9.30.4 – project1.
Esta é a principal janela de controle de projetos e contém o Menu Principal, a Barra de Botões e a Paleta de Componentes.

A segunda, sob a janela do Editor do Lazarus irá aparecer, à esquerda, a janela do Object Inspector. Apresenta os objetos e suas propriedades.

A terceira, à direita da janela do Object Inspector, tem-se a janela Source Edition, na qual o código será montado.

A quarta é a janela Form1, apresenta o local em que a parte visual de uma aplicação será realizada e projetada.

A quinta é a janela Messages, que exibe as mensagens do compilador, erros ou relatórios de progresso no projeto.

Para alterar entre o Form e o Source Edition utiliza-se a tecla F12.

Quando se salva um projeto no ambiente Lazarus, dois arquivos básicos serão gravados no disco, cujas extensões são *.pas (arquivo da Unit) e *.lpi (arquivo do Project).

Mais arquivos serão gravados, mas apenas estes dois requerem que sejam nomeados pelo usuário.

É importante ressaltar que esses dois arquivos devem ter nomes diferentes: isto é uma exigência do compilador.

Salvar um projeto:
File / Save
Nome do primeiro arquivo: Teste.lpi
Nome do segundo arquivo: u_teste.pas

Depois de salvar são gerados mais arquivos

teste.exe – programa principal em formato binário executável.
teste.lpi – Arquivo principal do projeto Lazarus (Lazarus Project Information).
teste.lpr – Arquivo fonte do programa principal no formato Pascal.
testeu.lfm – Desenho do formulário. Este arquivo é utilizado para gerar um arquivo fonte, que está incluído na seção de inicio da Unit.
testeu.pas – Arquivo da Unit que contém o código-fonte do formulário.

Para se declarar variáveis, constantes, procedures e functions de maneira correta em qualquer linguagem, são necessários o conhecimento de sua estrutura e a identificação dos pontos onde elas podem ser declaradas.

Uma Unit é, na maioria das vezes, associada a um formulário (Form) que contém seu código, ou seja, as declarações de variáveis, os componentes utilizados e as rotinas definidas.
É possível verificar que, à medida que componentes são inseridos, são também adicionados automaticamente linhas de código na Unit relacionada. A Unit tem áreas predefinidas e que devem ser respeitadas para que a programação tenha êxito.

unit xxxx – Representa o nome físico do arquivo onde está o código da referida unidade.
Por meio desse nome, units podem usar outras units.

interface – A seção interface começa com a palavra reservada interface e termina no inicio da seção implementation. Nessa seção, são declarados constantes (const), tipos (types), variáveis (var), procedures e functions, que estão disponíveis para outras units ou outros programas. Essas declarações são chamadas de públicas (public), indicando que as mesmas podem ser usadas por quaisquer outras unidades dentro do mesmo programa. A declaração de procedure e function, na seção interface, refere-se apenas ao cabeçalho das mesmas.

Estrutura Básica de uma Unit do Lazarus

uses – É a lista de outras units que estão ligadas ao programa atual.

type – Esta declaração especifica um identificador que denotará um novo tipo que, normalmente, não é oferecido.

var - Nessa área, são declaradas todas as variáveis que podem ser acessadas em qualquer
lugar do programa, portanto, consideradas públicas.

implementation - Esta seção começa com a palavra reservada implementation e termina em initialization. Neste local estão descritas todas as procedures e functions do programa.

{$mode objfpc}{$H+} e {$R *.lfm} – estes códigos são diretivas de compilação, que têm a função de passar informações ao compilador no instante de se criar o arquivo executável do aplicativo.

Estrutura Básica de um Arquivo de Projeto do Lazarus

O arquivo de projeto também é conhecido como Lazarus Project (LPR).

Para visualizar este arquivo:
View / Units... / project1.lpr

begin/end. – estas duas palavras reservadas indicam inicio e fim do projeto.

Application.Initialize; – Inicitialize é o primeiro método chamado pelo arquivo-fonte do projeto que, por padrão, simplesmente inicializa a aplicação.

Application.CreateForm(TForm1, Form1); – cria um objeto formulário da classe TForm1. Aqui são listados todos os formulários criados pela aplicação.

Application.Run; - quando um projeto é criado, o IDE insere automaticamente a linha de código com o método Application.Run, responsável pela execução da aplicação.

Funções (Functions) e Procedimentos (Procedures)

Funções são rotinas que recebem valores, passados como parâmetros, a partir da unidade ou fora dela, e retornam apenas um valor como resultado.

Procedimentos são semelhantes às funções, porém não retornam um valor como parte
de sua definição.

Sintaxe das funções:

Function NomeDaFunção (Parâmetro1: Tipo; ParâmetroN: Tipo): Tipo do valor de retorno;
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;

Sintaxe dos procedimentos:

Procedure NomeDoProcedimento (Parâmetro1: Tipo; ParâmetroN : Tipo);
var {declaração de variáveis locais á função quando necessárias}
begin
{bloco de instruções}
end;

Referências

http://www.lazarus.freepascal.org

http://www.lazarus.freepascal.org/index.php/page,7.html

MELO, Evandro de Castro. Free Pascal Lazarus, Ambiente Windows. Apostila da UFV. ENG 390 Prof. Evandro de Castro Melo, DS.

Lazarus - Resolvido problema instalar Lazarus no Linux - Debian (lgdk_pixbuf-2.0, gtk, libgtk)

Para instalar o Lazarus do Debian 6.0.6 basta fazer da seguinte forma: entrar como superusuário e instalar normalmente:

:~$ su
Senha
# apt-get install lazarus

Pronto, normalmente irá funcionar.

Pode acontecer o seguinte problema:

Após instalar o Lazarus no Linux - Debian (através do Synaptic), ao tentar compilar (ou executar), pode aparecer um erro que não está encontrando "lgdk_pixbuf-2.0", ou algo semelhante.

Para resolver esse problema deve-se instalar o gtk (libgtk2.0-dev).

Entre no terminal como superusuário:
$ su
Senha:

A seguir edite o sources.list adicionando a linha:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe
Para isso digite:

# gedit /etc/apt/sources.list

Adicionar a linha abaixo no sources.list:
deb http://www.hu.freepascal.org/lazarus/ lazarus-stable universe

Salvar e fechar o sources.list

Em seguida execute a atualização:

# apt-get update

Instalando o liggtk2.0-dev (gtk, lgdk_pixbuf-2.0)

# apt-get install -t squeeze-backports libgtk2.0-dev


Se ocorrer algum erro digite o comando abaixo e  repita o comando de instalação:

# apt-get -f install
# apt-get install -t squeeze-backports libgtk2.0-dev

Estou supondo que já tenha instalado o "pkg-config" e o "gcc", caso não tenha instalado esses dois, instale.

Referâncias:

http://crunchbanglinux.org/forums/topic/18322/solved-cannot-install-libgtk20dev/

http://celde.wordpress.com/2007/10/05/roda-roda-roda-que-a-ide-e-um-sonho-que-vai-compilaaaarrr/#comment-392

R - Iniciando no R com Linux Ubuntu

Estou iniciando no R.
Para quem está iniciando, vou começar a colocar o que estou aprendendo, serei bem objetivo (prático).
Utilizando o Linux Ubuntu.

Instalando o R:
1 : Abrir o terminal: Ctrl + Alt + t
2 : Digitar: sudo apt-get install r-base

Utilizando o Nautilus
1 : Abra o Nautilus Ctrl+o (ou outro gerenciador de arquivos)
2 : Vá até o local onde estão os arquivos com os dados que serão trabalhados (arquivos com números, no meu caso cada número está em uma linha, o arquivo possui somente números, arquivo do tipo .txt)
3 : Digite: Ctrl+l, para aparecer o "caminho"
4 : Digite: Ctrl+c, copiar esse "caminho"
5 : Vá para o terminal

A partir de agora, trabalhando dentro do terminal.
1 : Digite: cd Ctrl+Shift+v, irá para o endereço onde estão os arquivos com os dados (isso serve para quando entrar no R já estar dentro da pasta)
2 : Entrar no R, digite: R

A partir de agora, trabalhando dentro do R.
O prompt de comando do R é um sinal de maior (>).
Crie um arquivo de texto com alguns números, cada um em cada linha, com o nome teste.txt.

Criando e armazenando os dados desse arquivo em um objeto chamado teste:
> teste <- scan("teste.txt")
Read 15 items
Resposta: 15 dados lidos.

Imprimir o conteúdo de um objeto, digite:
> teste
 [1] 5 5 5 3 3 3 4 4 7 7 7 7 7 2 8
Resposta: elementos do objeto teste.

Verificando se os dados são numéricos, digite:
> is.numeric(teste)
[1] TRUE
Resposta: TRUE, siginifando que os dados são numéricos.

Verificar a quantidade de itens no objeto, digite:
> length(teste)
[1] 15
Resposta: 15 dados em um "vetor".

Criando uma tabela de valores absolutos acumulados
> teste.tb <- table(teste)
> teste.tb
teste
2 3 4 5 7 8
1 3 2 3 5 1
Resposta: quantidade de cada elemento.

Saber quantidade de elementos em cada objeto.
> length(teste)
[1] 15
> length(teste.tb)
[1] 6

Criando uma tabela de valores relativos acumulados
> teste.tbr <-prop.table(teste)

Verificando média (cria-se um objeto teste.me que armazena a média dos dados):
> teste.me <- mean(teste)
> teste.me

Assim como a média, segue-se para variância, desvio padrão, coeficiente de variabilidade, máximo, mínimo e moda.
Variância:
> teste.var <- var(teste)
> teste.var

Desvio padrão:
> teste.sd <- sd(teste)
> teste.sd

Coeficiente de variabilidade:
> teste.cv <- 100*teste.sd/teste.me
> teste.cv

Mediana:
> teste.md <- median(teste)
> teste.md

Máximo:
> teste.max <- max(teste)
> teste.max

Mínimo:
> teste.min <- min(teste)
> teste.min

Moda:
> teste.mo <- (teste.tb)[which.max(teste.tb)]
> teste.mo

Quartil:
> quantile(teste)

Percentil de 5%, 20% e 80%:
> quantile(teste,c(0.05,0.20,0.8))

Para sair do R basta digitar
> q()
Poderá salvar os dados.