Newsgroup: it.comp.lang.delphi
Titolo: Aggiunta tasto al DBNavigator...

Vorrei aggiungere un tasto al dbnavigator, deve attivarsi/deattivarsi nello
stesso modo del tasto "delete record", ho pensato di affiancarci
semplicemente un tasto nel mio form accanto ad esso, ma come tener traccia
del suo comportamento?
In pratica il nuovo tasto non cancella il record,ma aggiorna il record
corrente mettendo un valore "X" in una certa colonna della tabella
interessata, per questo motivo seguivo il tasto "Delete"...
Idee?
Grazie dell'attenzione :)


Secondo me, la soluzione migliore e piů breve per estendere il 
DBNavigator č...non usare il DBNavigator. :-)
Piuttosto, inserisci un componente *ActionList* e aggiungi ad esso tutte 
le azioni standard (/Standard Actions/) che si riferiscono ad un 
DataSource; successivamente, aggiungi una *ToolBar* al form e associa i 
*ToolButton* di questa alle azioni correlate al DataSource: i pulsanti 
della ToolBar si comporteranno esattamente come quelli solitamente 
presenti sul DBNavigator.
In seguito, aggiungere una tua azione personalizzata e collegare ad esso 
un nuovo ToolButton č un'operazione semplicissima.
Nell'evento /OnExecute/ della tua azione inserisci il codice da 
eseguire, mentre attraverso /OnUpdate/ definisci se l'azione stessa deve 
essere abilitata oppure no, "spuntata" oppure no e cosě via, magari 
centralizzando queste operazioni nell'evento /OnUpdate/ del componente 
ActionList, se preferisci.
Sto scegliendo sempre piů spesso questa strada perchč, oltre ad essere 
facilmente realizzabile e manutenibile, rispetto al DBNavigator mi 
consente - con poco sforzo - di creare un'interfaccia differente dal 
Data Control piů adoperato per la navigazione, che posso personalizzare 
a piacimento inserendo icone, caption, shortcut e altre caratteristiche, 
disponendo i pulsanti come e dove voglio, senza la necessitŕ di 
complicarmi la vita creando un discendente diretto del DBNavigator per 
"customizzarlo".
Ciao! :-)
-- 
Marco «Alka» Breveglieri
  ABLS Team S.n.c. - Software & Web
  Via De Gasperi, 14
  42019 Scandiano (Reggio Emilia)
 
http://www.abls.it

Per me Marco Breveglieri ha ragione.
Io non uso il componente me ne sono costruito uno con icone più belle che ha
le funzionalità
Inizio file
Avanti di 10
Avanti di 1
Indietro di 1
Indietro di 10
Fine file
Modalità Browse
Modalità Edit
Modalità Insert
Modalità Delete
Ok del cambiamento
Cancel del cambiamento
ed una edit box con trova.
Se domani lo trovo ti posto qui il codice.
Ciao
Mario - (
mari...@inwind.it
)
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

Grazie ad entrambi :)
Marco: Madň...ci devo studiare sulla tua soluzione...non sono cosě esperto
di Delphi :) ma mi piace imparare
Mario: Ti sarei grato se pubblicassi il codice :) si impara sempre dal
codice altrui :)

Ecco qui sotto il codice completo della unit :
(se vuoi anche le icone mi devi inviare a 
mari...@inwind.it
 un indirizzo
e-mail)
Ciao
Mario - (
mari...@inwind.it
)
unit uBrCla;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ComCtrls, Grids, DBGrids, ToolWin, Db, DBTables, Menus, ImgList;
type
  TfBrCla = class(TForm)
    Tool : TToolBar;
    iHot : TImageList;
    iDis : TImageList;
    tIni : TToolButton;
    tm10 : TToolButton;
    tPre : TToolButton;
    tSuc : TToolButton;
    tp10 : TToolButton;
    tFin : TToolButton;
    //
    tIns : TToolButton;
    tMod : TToolButton;
    tCan : TToolButton;
    tEsc : TToolButton;
    //
    ts : TToolButton;
    Procedure FormPaint(Sender: TObject);
    Procedure tIniClick(Sender: TObject);
    Procedure tm10Click(Sender: TObject);
    Procedure tPreClick(Sender: TObject);
    Procedure tSucClick(Sender: TObject);
    Procedure tp10Click(Sender: TObject);
    Procedure tFinClick(Sender: TObject);
    Procedure tInsClick(Sender: TObject);
    Procedure tModClick(Sender: TObject);
    Procedure tCanClick(Sender: TObject);
    Procedure Indietro ;
    Procedure Avanti ;
    Procedure Stato ;
    procedure GrdCellClick(Column: TColumn);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  fBrCla: TfBrCla;
implementation
  Uses uEdCla, uD ;
{$R *.DFM}
Procedure TfBrCla.FormPaint(Sender: TObject);
Begin
  If ClientWidth < 380 Then ClientWidth := 380 ;
  Stato ;
End ;
Procedure TfBrCla.tIniClick(Sender: TObject);
Begin
  d.tClassi.First ;
  Indietro ;
  Stato ;
End ;
Procedure TfBrCla.tm10Click(Sender: TObject);
Begin
  d.tClassi.MoveBy ( -10 ) ;
  Indietro ;
  Stato ;
End ;
Procedure TfBrCla.tPreClick(Sender: TObject);
Begin
  d.tClassi.Prior ;
  Indietro ;
  Stato ;
End ;
Procedure TfBrCla.tSucClick(Sender: TObject);
Begin
  d.tClassi.Next ;
  Avanti ;
  Stato ;
End ;
Procedure TfBrCla.tp10Click(Sender: TObject);
Begin
  d.tClassi.MoveBy ( +10 ) ;
  Avanti ;
  Stato ;
End ;
Procedure TfBrCla.tFinClick(Sender: TObject);
Begin
  d.tClassi.Last ;
  Avanti ;
  Stato ;
End;
Procedure TfBrCla.tInsClick(Sender: TObject);
Begin
  fEdCla.Caption := 'Inserimento' ;
  d.tClassi.Append ;
  fEdCla.ShowModal ;
  Stato ;
End;
Procedure TfBrCla.tModClick(Sender: TObject);
Begin
  d.tClassi.Edit ;
  fEdCla.ShowModal ;
End;
procedure TfBrCla.tCanClick(Sender: TObject);
Var n : String ;
begin
  If d.tClassi.RecordCount > 0 Then Begin
    n := IntToStr( d.tClassi.RecNo ) ;
    ShowMessage ( 'Cancellazione del record n° ' + n + ' dalla tabella.') ;
    if Application.MessageBox ( 'Vuoi cancellare il record ?' ,
       'Cancellazione', MB_OKCANCEL ) = IDOK Then d.tClassi.Delete ;
    Stato ;
  End ;
End;
Procedure TfBrCla.Indietro ;
Begin
  tSuc.Enabled := True ;
  tp10.Enabled := True ;
  tFin.Enabled := True ;
  If d.tClassi.RecNo < 10 Then tm10.Enabled := False
                          Else tm10.Enabled := True ;
  If d.tClassi.BOF Then
    Begin
      tIni.Enabled := False ;
      tPre.Enabled := False ;
    End ;
End;
Procedure TfBrCla.Avanti ;
Begin
  tIni.Enabled := True ;
  tm10.Enabled := True ;
  tPre.Enabled := True ;
  If d.tClassi.RecordCount - d.tClassi.RecNo < 10 Then tp10.Enabled := False
                                                  Else tp10.Enabled := True ;
  If d.tClassi.EOF Then
    Begin
      tSuc.Enabled := False ;
      tFin.Enabled := False ;
    End ;
End ;
Procedure TfBrCla.Stato ;
Var
  n, t : Integer ;
Begin
  n := d.tClassi.RecNo ;
  t := d.tClassi.RecordCount ;
  Stat.Panels[0].Text :='Record n° : ' + IntToStr ( n ) ;
  Stat.Panels[1].Text :='Totale Record : ' + IntToStr ( t ) ;
  If t = 0 Then Begin
    tCan.Enabled := False ;
    tMod.Enabled := False ;
    End ;
End ;
Procedure TfBrCla.GrdCellClick(Column: TColumn);
Begin
  If d.tClassi.BOF Then
    Begin
      tIni.Enabled := False ;
      tPre.Enabled := False ;
    End
  Else
    Begin
      tIni.Enabled := True ;
      tPre.Enabled := True ;
    End ;
  If d.tClassi.EOF Then
    Begin
      tSuc.Enabled := False ;
      tFin.Enabled := False ;
    End
  Else
    Begin
      tSuc.Enabled := True ;
      tFin.Enabled := True ;
    End ;
  If d.tClassi.RecNo < 10 Then tm10.Enabled := False
                          Else tm10.Enabled := True ;
  If d.tClassi.RecordCount - d.tClassi.RecNo < 10 Then tp10.Enabled := False
                                                  Else tp10.Enabled := True ;
  Stato ;
End;
END.


 di Delphi :) ma mi piace imparare
Forse la soluzione così come l'ho espressa sembra più complicata di 
quello che è in realtà. ;-)
Il componente *ActionList* ti permette di definire le azioni (comandi) 
che puoi eseguire all'interno di una finestra di dialogo (form); ad 
esempio, aprire e salvare un file, eseguire una stampa, uscire 
dall'applicazione sono tutti comandi che possono essere impartiti nella 
maggior parte dei programmi.
Molti linguaggi gestiscono tali azioni usando esclusivamente i controlli 
visuali che danno accesso ai comandi (pulsanti delle toolbar, voci di 
menu e così via), delegando l'esecuzione del codice relativo al clic.
Delphi offre una soluzione che, secondo la mia modestissima opinione, è 
eccezionale: separa concettualmente l'entità "azione" dal controllo che 
la esegue, fornendo la possibilità di aggiungere le azioni di cui si 
desidera disporre usando il componente *ActionList* (pagina /Standard/ 
della Palette) che saranno poi associate ai controlli che le mandano in 
esecuzione in un secondo momento.
La soluzione che ti ho proposto fa uso di azioni già incorporate 
all'interno di Delphi e implementate nella VCL, dette "Standard Actions".
Un esempio pratico: prova a mettere un componente *TActionList* sulla 
form e fare doppio clic su di esso; ti apparirà l'editor del componente 
(Component Editor). Dal pulsante "New" scegli dall'elenco a discesa "New 
Standard Action" e, successivamente, seleziona dalla finestra di dialogo 
tutti gli elementi che appartengono alla categoria DataSet.
Delphi aggiungerà automaticamente una serie di azioni eseguibili nel 
form, già implementate a livello di codice, che fanno ciò che il nome 
dell'azione - intuitivo - suggerisce.
Come usarle? Collega la proprietà /DataSource/ di ciascun'azione al 
componente *TDataSource* di riferimento (quello che avresti associato al 
DBNavigator, per intenderci); poi, aggiungi al form una ToolBar con 
diversi ToolButton, oppure un Menu con vari MenuItem e associa ciascun 
pulsante o voce di menu all'azione che intendi fare eseguire ad esso 
attraverso la proprietà /Action/ del controllo.
Quando lanci l'applicazione, ciascun controllo avrà uno stato di 
abilitazione ben determinato, governato dal codice già presente nella 
VCL che si occupa di gestire le azioni collegate al DataSource, 
definendo se esse possono essere utilizzate oppure no a seconda dello 
stato del DataSet cui fanno riferimento attraverso, appunto, il DataSource.
Facendo clic sui controlli collegati alle suddette azioni, puoi 
innescare il codice corrispondente per aggiungere nuovi record, entrare 
in modalità Edit, eliminare un record, spostarti avanti e indietro, al 
primo o all'ultimo; in parole povere, "esegui l'azione".
I vantaggi sono immediati e di facile comprensione:
1) non hai scritto una riga di codice per gestire le abilitazioni delle 
azioni (e quindi dei controlli collegati) e il codice da eseguire a 
fronte del clic;
2) hai sviluppato un'interfaccia a tuo piacimento, liberamente, senza 
doverti adattare alle limitazioni del DBNavigator, e senza prenderti la 
briga di creare un controllo discendente (che in questo caso rientra 
davvero nelle problematiche riservate a utenti medio-esperti di Delphi);
3) puoi aggiungere azioni "custom" al componente ActionList e collegare 
ad esse pulsanti e voci di menu da affiancare a quelli esistenti.


 quello che è in realtà. ;-)
Quoto e straquoto alla grande. Anch'io ho scoperto la sua esistenza solo un
mesetto fa, e devo dire che, per me che odio il DBNavigator, è stata una
scoperta molto gradevole.
Inoltre imparare ad usare le ActionList, sebbene all'inizio siano un po'
disorientanti, è una soddisfazione.
-- 
Jax
====
Ogni nostra cognizione prencipia da sentimenti. (Leonardo da Vinci)

Jax
	Ciao
	MassimoB
 
---------------------------
http://www.massimobeschi.it/

 una proprietà Action ...
Vero, però se non mi sbaglio è stata una novità da D6 (non mi pare che nel 5
ci fossero...), e all'epoca forse sono stati un po' snobbati.
Ok, da me, sicuramente. ;)
-- 
Jax
====
L'uomo è certamente pazzo: non sa fare un verme e fa dei a dozzine
(Montaigne)

Ok, da me, sicuramente. ;)
non so, io ho iniziato dal 6 e ti dico che dopo una
settimana che avevo il mio mitico D6 ogni volta che
facevo un nuovo form che doveva avere un minimo di
interazione con l'utente la prima cosa che ci mettevo
su era una ActionList.
Poi ripensando ai vari software modulari con packages
che ho fatto ... le Actionsono state fondamentali per
lo scambio di "azioni" utente fra i vari moduli ed il
merging con la main application.


 Ok, da me, sicuramente. ;)
Uhm...io ho iniziato da Delphi 4 (studiando su un libro che riguardava 
Delphi 2), ma mi pare ActionList e Actions ci fossero già a quei tempi. :-)


 tempi. :-)
Cappero, spero che tu ti sbagli, altrimenti mi sto rincitrullendo alla
grande... a parte che le versioni me le sono passate tutte quindi forse un
po' di confusione è giustificata ;)
-- 
Jax
====
L'amore non è un sentimento, ma dei sentimenti ne è la loro somma.

No, so state introdotte (nella component Palette) in D6.
Io non le ho mai usate e da quanto dite sono obsoleto.
Ciao
Mario -(
mari...@inwind.it
)


 No, so state introdotte (nella component Palette) in D6.
Nel corso di HTML.it (
http://programmazione.html.it
) vengono spiegate le 
azioni o si usa come versione di riferimento Delphi 5.
In questo tutorial
http://www.delphipages.com/news/detaildocs.cfm?ID=16
si parla di ActionList, azioni e StandardActions e si cita come 
riferimento Delphi 4.


 Io non le ho mai usate e da quanto dite sono obsoleto.
ROTFL, tu hai giocato troppo a Unreal Tournament
non so se hai mai sentito il tipo robotico che dice "SEI OBSOLETO!"
:D
-- 
Jax
====
E Dio disse : "Pkunzip Universo".

Io ho usato D5 Ent per parecchio tempo e non le ho mai viste.
Comunque mi fido.



In D4, Tab "Standard", ci sono.
Ciao.
--
ACSH
[D4]
---------------------------
Chi fa da se'
fatica il doppio

 In D4, Tab "Standard", ci sono.
Azz.
-- 
Jax
====
Quando non si fa nulla, ci si crede responsabili di tutto. (Jean Paul
Sartre)