Caricare documenti e articoli online  
INFtube.com è un sito progettato per cercare i documenti in vari tipi di file e il caricamento di articoli online.
Meneame
 
Non ricordi la password?  ››  Iscriviti gratis
 

Oggetti fondamentali della libreria VCL

informatica


Inviare l'articolo a Facebook Inviala documento ad un amico Appunto e analisi gratis - tweeter Scheda libro l'a yahoo - corso di



ALTRI DOCUMENTI

Manuale Tabelle
MICROSOFT WORD
Guida Rapida all' HTML
BREVE STORIA DELL'INFORMATICA - La prima generazione, I transistor: La seconda generazione
DEFINIZIONI DI INFORMATICA
L'era dell'informazione - L'informazione elettronica
IL SISTEMA BINARIO
Guida passo passo per settare ICProg per Windows XP
IL QUICKTIME VIRTUAL REALITY (QTVR)
DISTRIBUZIONI DISCRETE - Distribuzione binomiale -

Appunti sull'uso della libreria VCL

Indice

Oggetti fondamentali del framework VCL.. 2

OGGETTI VISIBILI 2

CONTROLLI CONTENITORI 3



OGGETTI NON VISIBILI 4

Descrizione di alcune classi fondamentali 6

Classe AnsiString. 6

Classe TStrings. 7

Esercizi risolti 8

ESERCIZIO 1. 8

ESERCIZIO 2. 9

ESERCIZIO 3. 11

ESERCIZIO 5. 14

ESERCIZIO 6. 16

ESERCIZIO 7. 17

ESERCIZIO 8. 19

Gestione Eventi 20

OnClick. 20

OnMouseMove. 20

OnMouseDown. 20

OnMouseUp. 21

OnKeyPress. 21

OnKeyDown. 21


Oggetti fondamentali del framework VCL

OGGETTI VISIBILI

Una classe fondamentale che è necessario conoscere è TControl.

Da essa infatti sono derivate le seguenti classi che verranno descritte nel presente paragrafo.

Gli attributi di TControl che vengono più spesso utilizzati 929c28j sono i seguenti :

Caption = serve per specificare il nome che comparirà sul controllo

Enabled = variabile booleana che serve per specificare se il corrispondente oggetto sia abilitato

Heigth = altezza dell'oggetto

Hint = suggerimento che viene visualizzato quando si ferma il puntatore del mouse dell'oggetto
Left = distanza del lato sinistro dell'oggetto dal lato margine sinistro del contenitore espressa in
pixel

Name = identificatore dell'oggetto all'interno del codice

ShowHint = attiva la visualizzazione dei suggerimenti per l'oggetto

Visible = abilita la visibilità dell'oggetto

Width = larghezza dell'oggetto espressa in pixel

Ve ne sono in realtà molte altre ma al momento ci interessano solo queste.

Per ogni classe derivante da TControl (o da qualsiasi altra classe predefinita da BCB), è necessario verificare la visibilità dei metodi e delle proprietà perchè essa dipende da come sono state ereditate le varie classi all'interno della gerarchia di classi di BCB.

TButton (Palette Standard)

Serve per gestire un semplice pulsante sul form e consente l'accesso a Caption.

Al momento dello sviluppo dell'applicazione è possibile associare una funzione membro della classe form (del form che è in costruzione) alla pressione di un pulsante facendo doppio click su pulsante stesso.

TLabel (Palette Standard)

Serve per visualizzare delle label sul form e consente l'accesso a Caption.

TEdit (Palette Standard)

Può essere usata per gestire semplici input di tipo testo.

La proprietà Text serve per specificare il nome che comparirà nella edit-box alla sua creazione.

TMemo (Palette Standard)

Viene usata per gestire brevi documenti di testo (appunti).

La proprietà Text rappresenta il nome della Memo.

Tramite la proprietà Lines (che è di tipo TStrings) possiamo gestire il testo scritto nell'istanza della classe in uso.

TComboBox (Palette Standard)

Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci  della lista nella combo-box.

La proprietà Text contiene la stringa (di tipo AnsiString) selezionata all'interno della ComboBox.

TListBox (Palette Standard)

Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci  della lista nella list-box.

Per accedere all'elemento selezionato nella ListBox possiamo usare la proprietà ItemIndex di ListBox unitamente alla proprietà Strings[] di Items.

Possiamo cancellare l'elemento selezionato all'interno dell'elenco tramite la chiamata al metodo  DeleleSelected().

TCheckBox (Palette Standard)

Sono fondamentali per l'utilizzo delle istanze di questa classe la proprietà Checked che vale true se il pulsante è selezionato e false in caso contrario, e l'evento OnClick.

In corrispondenza di tale evento infatti è possibile descrivere il comportamento che l'applicazione dovrà avere in seguito al click del mouse sulla checkbox stessa.

La proprietà Caption serve per specificare il nome che comparirà per la check-box sul form.

TMainMenu (Palette Standard)

Serve per inserire menu utente nel form.

Il doppio click sull'oggetto trascinato sul form permette di accedere alla creazione del menu che risulta molto intuitiva e se ne tralascia pertanto la descrizione in questa sede.

TScrollBar (Palette Standard)

Visualizza una barra di scorrimento.

Le proprietà Max e Position servono rispettivamente per settare il valore di fondo scala e il valore intero corrispondente alla posizione assunta dall'indicatore sulla barra stessa.

TStringGrid (Palette Additional)

Serve per gestire strutture dati sotto forma di matrice di stringhe (AnsiString).

Nella proprietà Options troviamo la sottoproprietà GoEditing. Settata a true, questa proprietà permette all'utente di inserire a tempo di esecuzione dei valori all'interno della matrice.

La proprietà Cells (tipo AnsiString) permette di accedere alle celle della griglia facendo uso degli opportuni indici di riga e di colonna nel modo seguente :

StringGrid1->Cells[colonna][riga];

La numerazione delle righe e delle colonne parte da 0.

Il numero totale di righe e colonne di cui la griglia è composta sono contenuti rispettivamente nelle proprietà RowCount e ColCount.

Possiamo anche accedere a colonne o righe intere tramite le proprietà Cols e Rows rispettivamente (entrambe di tipo *TStrings).

TLabeledEdit (Palette Additional)

Questo controllo è l'unione di una TLabel e una TEdit.

Le proprietà e i metodi sono esattamente i medesimi descritti ai punti precedenti, semplicemente unificati in un unico controllo.

La proprietà che permette di accedere alle proprietà della label associata alla edit è EditLabel.

CONTROLLI CONTENITORI

Caption è la proprietà del controllo che specifica la stringa che verrà visualizzata a video in corrispondenza del controllo.

TRadioGroup (Palette Standard)

Questa classe serve per permetter all'utente di fare una scelta fra più alternative.

La proprietà che deve essere usata per la gestione di una istanza della classe TRadioGroup è ItemIndex (come TListBox).

Essa contiene il numero intero corrispondente alla scelta (interna al gruppo) che è stata selezionata. Questo aggiornamento avviene in modo trasparente all'utente.

Tramite la proprietà Items (di tipo TStrings) è poi possibile sia run-time (con il metodo Add) che in fase di sviluppo, selezionare quali debbano essere le voci fra cui poter scegliere all'interno del gruppo di bottoni.

TForm

Abbiamo le seguenti proprietà di interesse :

BorderStyle specifica il tipo di aspetto che si desidera per il bordo del form

BorderIcons specifica quali pulsanti di sistema debbano essere presenti nel form

Color è il colore di sfondo del form.

Per introdurre diversi form all'interno della applicazione è necessario seguire i seguenti passi :

  1. File->New->Form (creo un nuovo form) fino a quando voglio inserire nuovi form
  2. Selezionare il form dal quale vogliamo fare riferimento ad altri form
  3. premere ALT+F11 e selezionare la Unit alla quale vogliamo fare riferimento

TPanel (Palette Standard)

I pannelli possono proficuamente essere utilizzati per separare diverse sezioni all'interno del medesimo form.

TFrame (Palette Standard)

Il loro utilizzo è molto simile ai pannelli ma a differenza di essi è possibile riutilizzare il medesimo frame in diverse form semplicemente inserendolo in una delle palette previste da BCB.

Inoltre mentre la proprietà Caption di TPanel permette di dare un nome visibile all'utente che sia diverso dall'identificatore del pannello all'interno del codice, TFrame assegna il medesimo nome all'identificatore del frame e al titolo del frame medesimo.

Per i contenitori possono risultare utili le seguenti proprietà :

ControlCount : memorizza il numero di componenti presenti all'interno del pannello

Controls : vettore di puntatori alla casse TControl disponibile per l'accesso ai componenti del pannello. Il primo controllo inserito nel contenitore ha indice 0.

Può risultare utile la seguente riga di codice, che permette di accedere ai bottoni del contenitore Panel1 via indice :

TButton* B = dynamic_cast<TButton*>(Panel1->Controls[i]);

(gentile suggerimento del Prof. Conti Maurizio)

Un altro utilizzo abbastanza utile è quello di usare il contenitore per far apparire e scomparire a comando dell'utente tutti i controlli posizionati su esso. Questo può essere fatto semplicemente settando a false

 la proprietà Visibile del contenitore.

OGGETTI NON VISIBILI

TTimer (Palette System)

Questa classe risulta fondamentale nella gestione del sincronismo all'interno dell'appliczione.

Semplicemente associando una funzione  all'evento OnTimer è possibile eseguire periodicamente delle istruzioni.

TTimer si differenzia da tutte le altre perché un'istanza di questa classe non determina alcun elemento grafico sul form a tempo di esecuzione.

La proprietà fondamentali che dobbiamo gestire è Interval la quale scandisce il tempo in ms che trascorrre fra due occorrenze diverse dell'evento OnTimer().

TOpenDialog / TSaveDialog (Palette Dialogs)

Richiamando il metodo Execute() di TOpenDialog (risp. TSaveDialog) viene aperta la finestra standard di Windows per aprire (risp. salvare) un file.

Le proprietà che possono risultare interessanti sono le seguenti :

Title : (tipo AnsiString)specifica il titolo della finestra di dialogo che viene aperta

Filter : (tipo AnsiString) specifica quali file debbano essere visualizzati.

La stringa assegnata a Filter  è composta nel modo seguente : prima del pipe ("|") si specifica la scritta di  informazione che viene comunicata all'utente nella finestra di dialogo aperta, la parte dopo il pipe specifica quali tipi di file debbano effettivamente essere elencati. Qualora si volesse visualizzare più formati sarebbe necessario separarli da ";" :

OpenDialog1->Filter="File di testo | *.txt ;*.pdf ;*.doc ;*.rtf";

Possiamo combinare i filtri nel modo seguente :

OpenDialog1->Filter="Testo semplice | *.txt ;*.rtf |Testo complesso |*.doc; *.pdf";

Le cartelle vengono comunque visualizzate.

FileName (tipo AnsiString) : e' il nome del file selezionato dall'utente quando ha chiuso la finestra

di dialogo premendo il pulsante OK.

TFontDialog (Palette Dialogs)

Richiamando il metodo Execute() di TFontDialog viene aperta una finestra standard  di Windows per la gestione dei caratteri.

Quando l'utente preme OK in tale finestra Execute() ritorna il valore true e le informazioni di rappresentazione del carattere vengno memorizzate nella proprietà Font di TFontDialog.

Per assegnare le caratteristiche specificate nella finestra di dialogo a Label1 possiamo pertanto scrivere quanto segue :

       Label1->Font=FontDialog1->Font;

Quando l'utente preme CANCEL nella finestra di dialogo Execute() ritorna il valore false.

TColorDialog (Dialogs)

Richiamando il metodo Execute() di TColorDialog viene aperta una finestra standard  di Windows per la gestione dei colori.

Quando l'utente preme OK in tale finestra Execute() ritorna il valore true e le informazioni riguardanti il colore vengno memorizzate nella proprietà Color di TColorDialog.

Per assegnare le caratteristiche specificate nella finestra di dialogo a Label1 possiamo pertanto scrivere quanto segue :

       Label1->Color=ColorDialog1->Color;

Quando l'utente preme CANCEL nella finestra di dialogo Execute() ritorna il valore false.


Descrizione di alcune classi fondamentali

Alcune classi che è certamente bene conoscere perché di uso assai frequente sono AnsiString e TStrings.

Classe AnsiString



Questa classe serve a gestire delle stringhe in modo dinamico e trasparente all'utente.

I caratteri che memorizza possono essere solamente quelli del codice ASCII (ANSI) standard, che usa 8 bit per la codifica di un carattere.

Possiamo ricordare i seguenti metodi :

  • int AnsiCompare(const AnsiString& rhs);

confronta la AnsiString corrente con rhs e restituisce 0 se sono uguali

  • int AnsiPos(const AnsiString& substr);

restituisce la posizione della sottostringa substr indicata all'interno della AnsiString

  • AnsiString FloatToStrF(long double value ,.)

converte un valore float in una stringa secondo vari parametri opzionali

  • void Insert(const AnsiString& str, int Index);

inserisce la stringa str nella posizione Index

  • int Length();

restituisce la lunghezza della stringa

  • AnsiString LowerCase();
  • double ToDouble();

converte la stringa nel tipo double

  • double ToInt();

converte la stringa nel tipo int

  • int ToIntDef(int default) ;

come ToInt() ma restituisce il valore default se la stringa non è interpretabile come intero

Possiamo manipolare le varie istanze della classe AnsiString mediante i seguenti operatori con evidente significato di simboli :

!=

[]

+

+=

=

==

<

<=

>

>=

L'unica nota che si ritiene utile in questa sede è quella relativa all'uso dell'operatore [].

Esso serve per accedere all'i-esimo carattere della stringa, contando i caratteri a partire da 1 (non da 0).

Così ad esempio è possibile usare le seguenti istruzioni per visualizzare in una finestra standard di Windows i caratteri che compongono una stringa scritta dall'utente all'interno della casella di testo Edit1 :

for(int i=1;i<=Edit1->Text.Length();i++)

                ShowMessage((AnsiString)Edit1->Text[i]);


Classe TStrings

E' la classe base per manipolare una lista di stringhe.

Le proprietà fondamentali della classe sono le seguenti :

  • int Count();

conta gli elementi che compongono l'elenco delle strighe.

  • AnsiString Strings[int Index];

serve per accedere alla stringa (già esistente) di indice Index all'interno dell'elenco. La prima ha indice 0.

I metodi fondamentali sono i seguenti :

  • int Add(AnsiString str);

inserisce una nuova stringa all'interno dell'elenco

  • void AddStrings(TStrings* strings);

aggiunge un elenco al'elenco

  • void Append(AnsiString str);

funzionamento identico a Add ma non ritorna la posizione di indice dell'ultima stringa inserita

  • void Clear();

cancella tutte le stringhe presenti nell'elenco

  • void Delete(int Index);

cancella la stringa di indice Index

  • int IndexOf(AnsiString str);

ritorna l'indice della stringa str all'interno dell'elenco

  • void Insert(int Index, AnsiString str);

inserisce la stringa str nella posizione Index

  • void Move(int Pos_corrente, int Pos_futura);
  • void LoadFromFile(AnsiString NomeFile) ;

carica nella TStrings corrente il contenuto del file specificato con NomeFile

  • void SaveToFile(AnsiString NomeFile);

salva il contenuto della TStrings corrente nel file specificato con NomeFile


Esercizi risolti

La presente collezione di esercizi non ha lo scopo di risultare esaustiva ma semplicemente esemplificativa dell'utilizzo dei componenti descritti precedentemente.

Si precisa che la soluzione presentata non è "la migliore", anzi eventuali suggerimenti sono certamente ben accettati.

Si raccomanda però di sforzarsi di risolvere i problemi prima di leggere la soluzione che deve essere vista nell'ottica di un confronto costruttivo fra metodologie di programmazione, non come un sistema per avere "una soluzione per ogni caso". Tale tentativo sarebbe infatti sterile tenendo conto della vasta casistica di esercizi che anche solo con l'ausilio dei componenti di base è possibile realizzare.

ESERCIZIO 1

Costruire un form che permetta di gestire due Memo secondo le seguenti specifiche :

  1. inserimento da utente di stringhe
  2. inibizione della modalità di modifica
  3. trasferiemento stringhe fra due memo
  4. salvataggio dati memo
  5. apertura dati nella memo
  6. cancellazione elementi memo tramite pressione di un tasto

Prevedere inoltre la chiusura della form tramite voce di un menu utente.

Soluzione:


Unit1.h


#ifndef Unit1H

#define Unit1H

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <Dialogs.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif



Unit1.cpp

#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::CopiaClick( TObject *Sender )

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::ApriClick( TObject *Sender )

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::SalvaClick( TObject *Sender )


ESERCIZIO 2

Realizzare un form che assegnato un testo ne esegua lo shift verso destra o verso sinistra a discrezione dell'utente di un numero di caratteri scelto sempre a discrezione dell'utente.

Soluzione:


Unit1.h

#ifndef Unit1H

#define Unit1H

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <ExtCtrls.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif



Unit1.cpp

#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

                        Str[1]=aux;

                }//fine singola rotazione a destra

                else

                        Str[lunghezza]=aux;

                }//fine else

        }//fine rotazione

        Label1->Caption=Str;

}



ESERCIZIO 3

Realizzare il prodotto "riga*colonna" e la somma (algebrica) di due matrici assegnate dall'utente a tempo di esecuzione.

Soluzione:


Unit1.h

#ifndef Unit1H

#define Unit1H

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <Grids.hpp>

#include <ExtCtrls.hpp>

#include <Menus.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------




extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif




Unit1.cpp

#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::CalcolaProdotto(TObject *Sender)

}

//--------------------------------------------------------------------------------------------------void __fastcall TForm1::CalcolaSomma(TObject *Sender)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::Chiudi1Click(TObject *Sender)



ESERCIZIO 4

Realizzare un form che permetta di inserire stringhe all'interno a una memo attraverso il solo utilizzo di una casella di testo.

Si preveda inoltre la possibilità di cancellare singolarmente le stringhe inserite, di cambiare il colore di sfondo della memo e di chiudere il form tramite la pressione di un pulsante.

Soluzione:


Unit1.h

#ifndef MemoH

#define MemoH

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <Dialogs.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif



Unit1.cpp


#include <vcl.h>

#pragma hdrstop

#include "Memo.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::InsertClick(TObject *Sender)

//--------------------------------------------------------------------------------------------------void __fastcall TForm1::DeleteClick(TObject *Sender)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::ColorClick(TObject *Sender)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::ExitClick(TObject *Sender)


ESERCIZIO 5

Inserire elementi all'interno di una lista di stringhe tramite una casella di testo e la pressione di un pulsante.

Devono inoltre essere previste la funzionalità di saluto tramite una finestra di messaggio di Windows della stringa selezionata nella lista (se nessuna stringa è selezionata non deve essere visualizzata alcuna finestra) e la cancellazione delle stringhe.

La cancellazione deve avvenire nel modo seguente: se viene selezionata una voce nella lista tale voce dovrà essere selezionata indipendentemente dal contenuto della casella di testo mentre se non è selezionata alcuna stringa della lista dovrà essere cancellata la stringa presente nella casella di testo.


Soluzione:

Unit1.h


#ifndef Src_ListBoxH

#define Src_ListBoxH

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif


Unit1.cpp


#include <vcl.h>

#pragma hdrstop

#include "Src_ListBox.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

//---------------------------------------------------------------------------

void __fastcall TForm1::InserisciClick(TObject *Sender)

//---------------------------------------------------------------------------

void __fastcall TForm1::CancellaClick(TObject *Sender)



ESERCIZIO 6

Realizzare una applicazione che permetta di inserire stringhe all'interno di una lista a combinazione.

Alla pressione del pulsante opportuno deve essere visualizzata una finestra di Windows che contiene un saluto alla stringa selezionata nella lista.

Prevedere inoltre un pulsante, che sempre attraverso una finestra standard di Windows, permetta di visualizzare il numero corrente di elementi presenti nella lista.

Soluzione:

Unit1.h


#ifndef Src_ComboBoxH

#define Src_ComboBoxH

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif


Unit1.cpp


#include <vcl.h>

#pragma hdrstop

#include "Src_ComboBox.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

    : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)


ESERCIZIO 7

Costruire una applicazione Windows che permetta di visualizzare alternativamente 3 pannelli ognuno dei quali presenta il proprio nome e il contatore di accessi ad esso.

Si preveda inoltre un pulsante che consenta di modificare il font del contatore stesso all'interno dei tre pannelli. Si supponga che lo stesso tipo di font scelto dall'utente venga poi assegnato ai tre contatori.

Soluzione:

Unit1.h


#ifndef Unit1H

#define Unit1H

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>



#include <ExtCtrls.hpp>

#include <Dialogs.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif



Unit1.cpp


#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::RadioGroup1Click(TObject *Sender)

//fine switch

}

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::TipoFontClick(TObject *Sender)

}



ESERCIZIO 8

Elaborare una applicazione Windows che permetta di settare il colore dello sfondo o del testo di una label alternativamente mediante 3 barre di scorrimento associate alle componenti RGB del colore medesimo.

Soluzione:

Unit1.h


#ifndef Unit1H

#define Unit1H

//--------------------------------------------------------------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

#include <ExtCtrls.hpp>

//--------------------------------------------------------------------------------------------------

class TForm1 : public TForm

;

//--------------------------------------------------------------------------------------------------

extern PACKAGE TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

#endif


Unit1.cpp


#include <vcl.h>

#pragma hdrstop

#include "Unit1.h"

//--------------------------------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//--------------------------------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

//--------------------------------------------------------------------------------------------------

void __fastcall TForm1::CambiaColore(TObject *Sender)

//fine switch

}



Gestione Eventi

GESTIONE DI TASTIERA E MOUSE

Considereremo i seguenti fondamentali eventi nella gestione di mouse e tastiera tramite BCB:

  • OnClick
  • OnMouseMove
  • OnMouseDown
  • OnMouseUp
  • OnKeyPress
·        OnKeyDown

E' importante notare subito che l'evento viene rilevato solamente se avviene quando la finestra (o il controllo se l'evento è previsto anche per un controllo) è attiva (o attivo).

Per intercettare l'evento in ogni caso è necessario fare uso delle API di Windows (vedi HOOK di Windows).

Analizziamo separatamente le intestazioni di definizione di funzioni associate agli eventi corrispondenti.

Notiamo anzitutto che a tutte le member function seguenti viene passato un puntatore che permetta alla member function stessa di accedere alle proprietà e ai metodi dell'oggetto che la ha richiamata (TObject *Sender).

OnClick

Intestazione:

void __fastcall TForm1::ClickSingolo(TObject *Sender)

Richiamata alla pressione del tasto sinistro del mouse. Ha il vantaggio di essere molto semplice ma assai poco flessibile, pertanto è sconsigliabile se l'applicazione richiede un certo grado di controllo.

OnMouseMove

Intestazione:

void __fastcall (__closure *TMouseMoveEvent)(  System::TObject* Sender,

Classes::TShiftState Shift,

int X,

int Y

)

Richiamata quando il puntatore del mouse viene mosso sul controllo.

Permette di risalire alle seguenti informazioni:

  • se almeno uno fra i tasti SHIFT, ALT, CTRL fossero abbassati o meno al momento del movimento del mouse (Shift)
  • la posizione corrente del mouse (X e Y)

OnMouseDown

Intestazione:

void __fastcall TForm1::MouseDown(      TObject *Sender,

TMouseButton Button,

TShiftState Shift,

int X,

int Y

)

Richiamata alla pressione di un tasto del mouse quando il puntatore del mouse è sul controllo, permette di risalire alle seguenti informazioni:

  • quale sia il pulsante che è stato premuto (Button)
  • se almeno uno fra i tasti SHIFT, ALT, CTRL fossero abbassati o meno al momento della pressione (Shift)
  • la posizione dove è stato premuto di pressione di un tasto (X e Y)

OnMouseUp

Occurs when the user releases a mouse button that was pressed with the mouse pointer over a component.

void __fastcall (__closure *TMouseEvent)(

                         System::TObject* Sender,

     TMouseButton Button,

     Classes::TShiftState Shift,

     int X, int Y

)

Richiamata al rilascio di un tasto del mouse quando il puntatore del mouse è sul controllo, permette di risalire alle seguenti informazioni:

  • quale sia il pulsante ad essere rilasciato (Button)
  • se almeno uno fra i tasti SHIFT, ALT, CTRL fossero abbassati o meno al momento del rilascio (Shift)
  • la posizione dove è stato rilasciato il tasto (X e Y)

OnKeyPress

Intestazione:

void __fastcall TForm1::PulsantePremuto(TObject *Sender, char &Key)

Viene richiamata quando viene premuto un tasto della tastiera al quale sia associato un codice ASCII.

Key specifica il caratere ASCII del tasto premuto sulla tastiera.

OnKeyDown

Intestazione:

void __fastcall TForm1::PulsanteAbbassato(     TObject *Sender,

WORD &Key,

TShiftState Shift

)

Viene richiamata quando viene premuto un tasto qualsiasi (della tastiera o del mouse) e permette di risalire alle seguenti informazioni :

  • codice virtual" del tasto premuto (Key)
  • stato dei tasti SHIFT, ALT, CTRL (Shift)

Il codice virtuale dei tasti può essere ottenuto tramite la guida di C++ Builder ed essendo tali codici di tipo enumerativo, è possibile utilizzarli all'interno di uno blocco switch (ad esempio) per facilitarne l'uso.


I codici virtuali sono tutti codificati in un  formato del tipo VK_TASTO.

Ad esempio, il codice virtuale di alcuni tasti è riportato nella tabella seguente:

Tasto sulla tastiera

Codice tasto virtuale

freccia direzionale in alto

VK_UP

freccia direzionale in basso

VK_DOWN

freccia direzionale a destra

VK_RIGHT

freccia direzionale a sinistra

VK_LEFT

tasto HOME

VK_HOME

tasto END

VK_END

tasto funzione F1

VK_F1

Pulsante sinistro del mouse

VK_LBUTTON

Pulsante destro del mouse

VK_RBUTTON

Numero 1 sul tastierino numerico

VK_NUMPAD1

Per i caratteri del codice ASCII il codice virtuale corrisponde al codice ASCII stesso (ad esempio il tasto "1" ha codice virtuale=codice ASCII 49).


A titolo di completezza, per autonomia nella verifica delle informazioni date sino ad ora si riporta di seguito la tabella dei codici ASCII:







Privacy

Articolo informazione


Hits: 1902
Apprezzato: scheda appunto

Commentare questo articolo:

Non sei registrato
Devi essere registrato per commentare

ISCRIVITI

E 'stato utile?



Copiare il codice

nella pagina web del tuo sito.


Copyright InfTub.com 2019