Utilizzo delle interfacce in delphi. Funzionalità di lavorare con le interfacce in Delphi. Elementi dell'interfaccia standard
L'articolo è stato scritto sulla base dei risultati dell'analisi dei programmi scritti dai giovani sviluppatori del nostro gruppo.
Organizziamo correttamente la sequenza dei componenti di commutazione
Molti utenti, soprattutto quelli che in precedenza hanno lavorato in DOS, hanno l'abitudine di passare da un campo di input all'altro non con il mouse, ma utilizzando la tastiera con il tasto Tab. Inoltre, è molto più veloce che selezionare ciascun campo con il mouse. Pertanto, l'ordine di commutazione dei componenti deve essere impostato correttamente. Ciò vale sia per i componenti all'interno di tutti i componenti contenitore (pannelli, GroupBox e simili), sia per i componenti contenitori stessi, se ce ne sono diversi nel modulo.
L'ordine di cambio dei componenti all'interno del contenitore è specificato dalla proprietà TabOrder. Il primo componente ad attivarsi è quello con TabOrder uguale a 0, il secondo con 1, ecc., finché non vengono enumerati tutti i componenti. Inoltre, il componente dispone di una proprietà TabStop, che indica se il componente riceverà il focus quando attivato/disattivato con il tasto Tab. Se è necessario impedire il passaggio a qualsiasi componente, impostarne TabStop = false. In questo caso è possibile passare a questo componente solo utilizzando il mouse.
Ci sono casi in cui gli utenti che sono abituati a cambiare con una determinata chiave in un programma, per abitudine, continuano a usarla in altri. Ciò accade spesso con gli utenti 1C, dove è possibile utilizzare il tasto Invio per navigare tra i campi di input. Ebbene, daremo loro questa opportunità nei nostri programmi se lo richiederanno. Imposta la proprietà KeyPreview del modulo su true e scrivi un gestore eventi OnKeyPress:
Procedura TForm1.FormKeyPress(Sender: TObject; var Key: Char);
inizio
se ord(key)=vk_Return allora
Form1.SelectNext(PriemForm.ActiveControl, true, true);
FINE;
Questo gestore fornisce la navigazione tra gli elementi del modulo quando viene premuto il tasto Invio. Va notato che questo metodo non funziona con i pulsanti, perché... premendo Invio su un pulsante viene fatto clic su di esso, mentre premendo Tab si attiva il componente successivo nella sequenza di commutazione.
Pulsanti predefiniti
Tutti gli stessi utenti si abituano rapidamente al fatto che nelle finestre di dialogo dell'applicazione, di norma, è possibile confermare la scelta con il tasto Invio e annullare con il tasto Esc. Non deludiamoli con i nostri programmi, soprattutto perché è molto facile da realizzare. Per un pulsante che risponde a Invio, impostare la proprietà Default su true. Per il pulsante che risponde a Esc, imposta la proprietà Cancel su true. È tutto.
sì o no
Tutto finestre di dialogo, che richiede azioni all'utente, deve avere almeno due pulsanti: conferma dell'azione e rifiuto dell'azione (Sì/No, Salva/Annulla, ecc.). L'azione può essere annullata chiudendo la finestra con il pulsante [X] nel titolo della finestra. Non è accettabile se c'è un solo pulsante per confermare l'azione e per rifiutarla è necessario chiudere la finestra con il pulsante [X] nel titolo, altrimenti non c'è alcuna possibilità di rifiuto. Ciò confonde l'utente, sollevando una domanda logica: come rifiutare?
Inoltre, non dimenticare quanto detto sopra nel paragrafo “Pulsanti predefiniti”.
Tutte le finestre di dialogo dovrebbero aprirsi al centro dello schermo
Centrati, non dove sono stati creati in modalità progettazione. In primo luogo, è più visivo e, in secondo luogo, elimina automaticamente il problema delle diverse risoluzioni dello schermo per utenti diversi.
Viene fatta un'eccezione se la finestra di dialogo non è modale e, come risultato del lavoro dell'utente in questa finestra, le modifiche si verificano immediatamente nella finestra principale (ad esempio, filtraggio di un set di dati, ridisegno di grafici, ecc.).
Le dimensioni delle finestre non devono superare le dimensioni dello schermo
In nessun caso. È una vergogna quando parte della finestra si estende oltre lo schermo. Questo requisito non dipende dalla risoluzione dello schermo dell'utente, ad es. scuse come “Lascia che impostino una risoluzione più alta” non funzionano.
Ridimensionamento corretto degli elementi della finestra
Gli elementi della finestra dovrebbero essere ridimensionati o spostati correttamente quando la finestra viene ridimensionata, quando la finestra viene ingrandita e quando la finestra viene ripristinata dopo l'ingrandimento.
Tutto è sempre visibile
La riduzione delle dimensioni della finestra non dovrebbe comportare la scomparsa degli elementi della finestra e, preferibilmente, non dovrebbe comportare la comparsa di barre di scorrimento (scroller) della finestra stessa. Puoi limitare le dimensioni minime della finestra in modo che tutti gli elementi siano visibili e accessibili. Se non è possibile posizionare i componenti in modo che siano tutti visibili nella finestra, è possibile utilizzare i segnalibri (come PageControl) per dividere i componenti in gruppi. Inoltre, non ignoriamo le scuse relative alla risoluzione dello schermo.
Suggerimenti ovunque, suggerimenti sempre
Per i pulsanti, soprattutto sulle barre degli strumenti (come la Barra degli strumenti), dovrebbero essere specificati dei suggerimenti in modo che sia sempre chiaro il motivo per cui è necessario questo o quel pulsante.
Spettro dei colori
Non dovresti dipingere i componenti del modulo con tutti i colori dell'arcobaleno. Questo stanca gli occhi e distrae l'attenzione dell'utente. Non sembra "bello". L'evidenziazione viene utilizzata quando è necessario attirare l'attenzione dell'utente su un elemento specifico o su una parte specifica della finestra. Ad esempio, i record di colore che contengono errori con il colore rosso chiaro o, al contrario, i record di record che sono stati controllati con successo con il colore verde chiaro.
Conclusione
Esiste un ottimo metodo che ti consente di trovare difetti nel programma in generale e nell'interfaccia in particolare. È semplice: immagina te stesso al posto dell'utente e per mezz'ora prova a lavorare come lavora lui. È ancora meglio se l'utente si trova nel raggio d'azione (ad esempio, lavora nella stessa organizzazione). In questo caso sedetevi accanto a lui, o meglio ancora al suo posto, e provate a fare il suo lavoro. Inserisci dati, modificali, visualizza report, ecc. Se non sai come farlo nel modo giusto, chiedi al tuo utente. Non eseguire solo una o due operazioni dello stesso tipo, come nella modalità debug, ma 20-30, o anche più operazioni diverse, in ordini diversi. Dimentica di inserire qualcosa o inseriscilo in modo errato e guarda come reagisce il programma. Vedrai rapidamente i punti deboli del tuo programma.
L'autore dell'articolo ha automatizzato il lavoro del comitato per l'ammissione all'università e, nel primo anno di introduzione del programma, ha trascorso 3-4 ore al giorno nel comitato per l'ammissione, registrando i candidati, compilando i loro dati personali e fornendo loro rapporti d'esame. E per il resto tempo di lavoro corretto errori e carenze. Credimi, l'anno prossimo non ci saranno praticamente più problemi. La stessa cosa è accaduta quando è stato introdotto il modulo del personale.
Pertanto, tieni a mente l'esperienza dell'utente. Rendi loro facile e piacevole lavorare con i tuoi programmi.
Uno e il più punti di forza ambiente Programmazione Delphiè la sua architettura aperta, grazie alla quale Delphi consente una sorta di metaprogrammazione, permettendo di “programmare l’ambiente di programmazione”. Questo approccio traduce Delphi in alta qualità nuovo livello sistemi di sviluppo di applicazioni e consente di incorporare strumenti aggiuntivi in questo prodotto che supportano quasi tutte le fasi della creazione sistemi applicativi. Una gamma così ampia di possibilità si apre grazie al concetto delle cosiddette interfacce aperte implementate in Delphi, che sono l'anello di congiunzione tra l'IDE (Integrated Development Environment) e gli strumenti esterni.
Questo articolo è dedicato alle interfacce aperte di Delphi e fornisce una panoramica delle funzionalità che forniscono. Delphi definisce sei interfacce aperte: interfaccia strumento, interfaccia progettazione, interfaccia esperto, interfaccia file, interfaccia modifica e interfaccia controllo versione. È improbabile che nell'ambito di questo articolo saremo in grado di coprire e illustrare in dettaglio le capacità di ciascuno di essi. I testi originali di Delphi ti aiuteranno a comprendere più a fondo le questioni in esame; fortunatamente gli sviluppatori hanno fornito loro commenti dettagliati. Le dichiarazioni delle classi che rappresentano le interfacce pubbliche sono contenute nei moduli corrispondenti nella directory...\Delphi\Source\ToolsAPI. L'interfaccia di progettazione (modulo DsgnIntf.pas) fornisce strumenti per la creazione di editor di proprietà ed editor di componenti.
Gli editor di proprietà e componenti sono un argomento degno di una discussione separata, quindi ricordiamo solo che l'editor di proprietà controlla il comportamento dell'Ispettore oggetto quando si tenta di modificare il valore della proprietà corrispondente e l'editor di componenti viene attivato quando doppio click tasto sinistro del mouse sull'immagine del componente inserito nel form. L'interfaccia di controllo della versione (modulo VCSIntf.pas) è destinata alla creazione di sistemi di controllo della versione. Dalla versione 2.0, Delphi supporta il sistema di controllo della versione integrato Intersolv PVCS, quindi nella maggior parte dei casi non è necessario sviluppare il proprio sistema. Per questo motivo tralasceremo anche la considerazione dell'interfaccia di controllo della versione. L'interfaccia file (modulo FileIntf.pas) consente di sovrascrivere il file system di lavoro dell'IDE, consentendo di scegliere il proprio metodo di archiviazione dei file (ad esempio nei campi Memo sul server del database). Modifica interfaccia (modulo EditIntf.pas) fornisce l'accesso al buffer del testo sorgente, che consente di analizzare e generare codice, determinare e modificare la posizione del cursore nella finestra dell'editor di codice e anche controllare l'evidenziazione sintattica del testo sorgente.
Classi speciali forniscono interfacce ai componenti inseriti nel modulo (definendo il tipo di componente, ottenendo riferimenti ai componenti padre e figlio, accedendo alle proprietà, spostando il focus, eliminando, ecc.), al modulo stesso e al file di risorse del progetto. Modifica interfaccia consente inoltre di identificare i cosiddetti notificatori modulari che determinano la reazione a eventi come la modifica del testo sorgente di un modulo, la modifica di un modulo, la ridenominazione di un componente, il salvataggio, la ridenominazione o l'eliminazione di un modulo, la modifica di un file di risorse del progetto, ecc. L'interfaccia dello strumento (modulo ToolIntf. pas) fornisce agli sviluppatori un mezzo per ottenere informazioni generali sullo stato dell'IDE e sull'esecuzione di azioni come l'apertura, il salvataggio e la chiusura di progetti e singoli file, la creazione di un modulo, l'ottenimento di informazioni sul progetto corrente (numero di moduli e moduli, i loro nomi, ecc.), la registrazione file system, organizzazione delle interfacce ai singoli moduli, ecc. Oltre ai notificatori modulari, Tool Interface definisce notificatori aggiuntivi che notificano eventi come l'apertura/chiusura di file e progetti, il caricamento e il salvataggio di un file di progetto desktop, l'aggiunta/esclusione di moduli di progetto, l'installazione/disinstallazione di pacchetti, la compilazione di un progetto e in A differenza dei notificatori modulari, i notificatori aggiuntivi consentono di annullare l'esecuzione di alcuni eventi.
Inoltre, l'interfaccia dello strumento fornisce un mezzo per accedere al menu principale dell'IDE Delphi, consentendo di incorporare elementi aggiuntivi al suo interno. Expert Interface (modulo ExtIntf.pas) è la base per la creazione di esperti: moduli software integrati nell'IDE per espanderne le funzionalità. Un esempio di esperto è la procedura guidata del modulo database Delphi, che genera un modulo per visualizzare e modificare il contenuto di una tabella di database. Dopo aver definito la classe Expert, dobbiamo assicurarci che Delphi “impara” a conoscere il nostro Expert. Per fare ciò è necessario registrarlo chiamando la procedura RegisterLibraryExpert, passandogli un'istanza della classe expert come parametro. A titolo illustrativo, creiamo un semplice esperto in stile esStandard che, quando si seleziona la voce di menu Delphi corrispondente, visualizza un messaggio che indica che è in esecuzione. Come puoi vedere dalla tabella sopra, lo stile esStandard richiede l'override di sei metodi:
Affinché l'esperto possa essere “messo in azione”, è necessario selezionare la voce di menu Componente/Installa componente..., selezionare il modulo contenente l'esperto (nel nostro caso exmpl_01.pas) nella finestra di dialogo Sfoglia, fare clic su OK e dopo aver compilato il pacchetto dclusr30.dpk Nel menu principale di Delphi, nella sezione Aiuto, dovrebbe apparire la voce Simple Expert 1, quando selezionata, apparirà il messaggio informativo “Standard Expert avviato!”. Il motivo per cui Delphi inserisce la voce del menu Esperto nella sezione Aiuto rimane un mistero. Se non ti piace il fatto che la voce di menu appaia dove vuole Delphi e non dove vuoi, è possibile la seguente opzione: crea un esperto nello stile del componente aggiuntivo, che elimina la creazione automatica della voce di menu e aggiungere la voce di menu “manualmente” utilizzando l'interfaccia dello strumento. Ciò ti consentirà di impostare la posizione del nuovo elemento nel menu principale in modo arbitrario.
Per aggiungere una voce di menu, utilizzare la classe TIToolServices - la base dell'interfaccia dello strumento - e le classi TIMainMenuIntf, TIMEuItemIntf, che implementano le interfacce al menu principale dell'IDE e ai suoi elementi. Un'istanza della classe ToolServices TIToolServices viene creata dall'IDE stesso quando viene inizializzato. Tieni presente che la responsabilità del rilascio delle interfacce per il menu principale di Delphi e dei suoi elementi spetta interamente allo sviluppatore. Intanto complichiamo un po' il carico funzionale dell'esperto: quando attivi la sua voce di menu, emetterà un certificato sul nome del progetto aperto in questo momento nell'ambiente: in questo esempio, il posto centrale è occupato dalla funzione AddIDEMenuItem, che aggiunge una voce di menu al menu principale dell'IDE Delphi. Riceve come parametri il testo della nuova voce di menu, il suo identificatore, l'identificatore della voce davanti alla quale viene inserita la nuova voce, la rappresentazione simbolica del tasto, che insieme al tasto Ctrl può essere utilizzato per accesso veloce a un nuovo elemento e un gestore eventi corrispondente alla selezione di un nuovo elemento. Abbiamo aggiunto una nuova voce di menu nella sezione Visualizza prima della voce Orologi.
Ora facciamo conoscenza con i notificatori. Definiamo un add-in notifier che traccia la chiusura/apertura dei progetti e adegua di conseguenza il campo memorizzando il nome del progetto attivo (ometteremo per brevità l'implementazione di metodi che non hanno subito modifiche rispetto all'esempio precedente): implementare il notificatore, abbiamo definito la classe TAddInNotifier, che è un discendente di TIAddInNotifier, e sovrascritto il metodo FileNotification. L'IDE chiamerà questo metodo ogni volta che si verifica un evento a cui il notificatore del componente aggiuntivo può rispondere (ciascuno di questi eventi è indicato da una costante corrispondente di tipo TFileNotification). Viene utilizzato il campo Expert nella classe TAddInNotifier feedback con un esperto (metodo TAddInNotifier.FileNotification). Nel distruttore dell'esperto, il notificatore non è registrato e viene distrutto. Ora illustriamo l’uso dei notificatori modulari. Creiamo un esperto del componente aggiuntivo che emette messaggi su ogni atto di salvataggio di un file di progetto (per brevità, non presentiamo l'implementazione di metodi a noi già familiari): In questo esempio, l'esperto del componente aggiuntivo monitora gli eventi corrispondente all'apertura/chiusura dei progetti.
Ogni volta che viene aperto un progetto, viene registrato un notificatore modulare corrispondente al file di progetto. In termini di implementazione, i notificatori modulari sono simili ai notificatori aggiuntivi: definiamo la classe TModuleNotifier, che è un discendente di TIModuleNotifier, e sovrascriviamo i suoi metodi Notify e ComponentRenamed. L'IDE chiama il metodo Notify quando si verificano determinati eventi relativi a questo modulo; All'interno di questo metodo, viene determinata la reazione a un particolare evento. Il metodo ComponentRenamed viene chiamato quando viene modificato il nome di un componente nel modulo del modulo. Tieni presente che non utilizziamo questo metodo, ma dobbiamo sovrascriverlo, altrimenti quando il nome del componente cambia, verrà chiamato un metodo astratto della classe base, il che porta a conseguenze imprevedibili.
La registrazione di un notificatore modulare è un processo leggermente più complesso rispetto alla registrazione di un notificatore aggiuntivo: prima otteniamo l'interfaccia del modulo (TIModuleInterface), quindi registriamo il notificatore utilizzando l'interfaccia del modulo. Quando il progetto viene chiuso, il notificatore modulare viene annullato dalla registrazione (sempre utilizzando TIModuleInterface) e il notificatore viene distrutto. In conclusione, mostreremo come determinare la posizione del cursore nella finestra dell'editor di codice. Creiamo un esperto che, selezionando la voce di menu appropriata, visualizzi un messaggio contenente il nome del file attivo e la posizione del cursore al suo interno (viene mostrata l'implementazione solo dei metodi essenziali per questo esempio): Per determinare la posizione del cursore, dobbiamo ottenere la seguente sequenza di interfacce: interfaccia modulare (TIModuleInterface); interfaccia dell'editor di codice (TIEditorInterface); interfaccia di presentazione del modulo nella finestra dell'editor (TIEditView).
Se quando si seleziona una voce del menu Expert è attivo il file di testo sorgente (*.pas), viene visualizzato un messaggio contenente il nome del file attivo e la posizione attuale del cursore al suo interno. Se il file attivo non è un file pas, il messaggio non viene emesso. Per ottenere il nome del file attivo, utilizzare il metodo GetCurrentFile della classe TIToolServices. Con questo si conclude la nostra considerazione sui modi di utilizzare le interfacce aperte. Il CD-ROM contiene il codice sorgente di tutti gli esempi forniti. Il CD-ROM contiene anche un esempio più complesso e dettagliato, contenente un componente aggiuntivo esperto che consente all'utente di aggiungere ai segnalibri il testo sorgente dei moduli Delphi. Una breve guida all'installazione e all'utilizzo di Bookmarks Expert è contenuta nel file bkmrks97.htm. Pertanto, questo articolo fornisce una panoramica generale delle interfacce aperte e fornisce esempi del loro utilizzo. Ripetiamolo ancora una volta: grazie alla disponibilità di codici sorgente per interfacce aperte, puoi facilmente comprendere i dettagli che ti interessano. Ci auguriamo che la varietà di possibilità offerte dalle interfacce aperte ti dia più di un'idea audace e utile.
solo per il risultato
rispetto rigoroso delle scadenze
Trasparenza
attuazione del progetto
supporto tecnico come regalo
Programmazione, modifiche, consultazioni su 1C
Come stiamo lavorando
1. Discutiamo del problema al telefono. In presenza di accesso remoto- mostra sullo schermo del tuo computer.
2. Se il progetto è grande, stimiamo il lavoro in rubli, altrimenti il numero approssimativo di ore.
3. Portiamo a termine il lavoro.
4. Accetti il lavoro nel tuo programma, se ci sono dei difetti, noi li correggiamo.
5. Noi emettiamo fattura, tu paghi.
Costo del lavoro
1. Tutto il lavoro è diviso in 3 categorie: consultazione, aggiornamento di una configurazione standard, sviluppo o programmazione di un nuovo report, elaborazione, pulsante, ecc.
3. Il lavoro superiore a 10 ore deve essere preparato in anticipo. compito tecnico con descrizione e costo del lavoro. I lavori iniziano dopo aver concordato con voi le specifiche tecniche.
Supporto tecnico
1. Se entro 3 mesi trovi errori nel lavoro precedentemente accettato, li correggiamo gratuitamente.
2. Per i clienti abituali correggiamo gratuitamente eventuali carenze nel nostro lavoro entro un anno.
Software per gestire la tua attività.
Acquista 1C:Enterprise
Noi siamo rivenditore ufficiale Azienda 1C, puoi acquistare da noi vari prodotti software e licenze. Oltre ad acquistare la “scatola”, ti aiuteremo a configurare il programma, forniremo consigli ed effettueremo le impostazioni di base.
- Contabilità
- Automazione del negozio
- Vendita all'ingrosso
- Assistenza all'installazione e configurazione iniziale incluso nel pacchetto!
- Perfezionamento delle configurazioni in base alle esigenze del cliente, sviluppo di nuovi moduli in assenza delle funzioni necessarie nella configurazione standard.
 |
 |
 |
 |
| contabilità 1c | 1C: Gestione commerciale | 1C: vendita al dettaglio | 1C: Gestione delle retribuzioni e del personale |
| Da 3300 rubli. | Da 6700 rubli. | Da 3300 rubli. | Da 7400 rubli. |
Fornitura di server.
Configurazione istantanea del server + 1C.
Nessun server? Nessun problema, selezioneremo e configureremo velocemente un server nel cloud. Pagando una piccola spesa ottieni una soluzione molto affidabile.
- Disponibilità 24 ore su 24, 7 giorni su 7
- Non c'è bisogno di mantenere il tuo amministratore di sistema(il risparmio coprirà i costi del server).
- Setup ed installazione rapida di 1C sul server, in 3 giorni avrai già un sistema completamente funzionante.
- Puoi trasferirti a server locale, se la soluzione non è soddisfacente.
SMS dal tuo 1C
Vuoi che i tuoi clienti vengano informati su promozioni e sconti? I clienti non ritornano? Configura l'invio di SMS direttamente da 1C!
La nostra azienda sarà in grado di impostare rapidamente l'invio di SMS ai tuoi clienti direttamente da 1C. Esempi di eventi che possono essere automatizzati:
- Grazie per l'acquisto e i bonus vengono assegnati immediatamente dopo l'acquisto successivo.
- Accumulo di bonus sulla carta come regalo per un compleanno\altro significativo o festività.
- Notifica dell'arrivo della merce in magazzino.
- Scadenza dei bonus regalo.
- Notifica di ricezione del pagamento anticipato e prenotazione della merce.
- Indirizzo con indicazioni per il negozio/ufficio, numeri di telefono.
- E così via.
La configurazione in 1C può essere eseguita dai nostri specialisti o dai tuoi dipendenti. Puoi visualizzare le tariffe nella pagina Tariffe SMS.
- Consegna SMS garantita, il denaro viene addebitato solo per gli SMS consegnati.
- Tariffe separate per ogni SMS.
- Ricarica il tuo saldo in diversi modi.
- Visualizza in qualsiasi momento la cronologia di tutti gli SMS inviati.
- Il nome del mittente invece del numero digitale nel telefono del destinatario del messaggio.
La programmazione orientata agli oggetti (OOP), oltre al concetto di classe, prevede anche il concetto fondamentale di interfaccia.
Cos'è un'interfaccia e quali sono le caratteristiche per lavorarci nel linguaggio di programmazione Delphi?
L'interfaccia è un costrutto semantico e sintattico nel codice di programma utilizzato per specificare i servizi forniti da una classe o componente (Wikipedia).
Essenzialmente, un'interfaccia definisce un elenco di proprietà e metodi che devono essere utilizzati quando si lavora con la classe implementata da questa interfaccia, nonché la loro firma (nome, tipo di dati, parametri accettati (per procedure e funzioni), ecc.). Pertanto, una classe che implementa una particolare interfaccia deve implementare tutti i suoi componenti. Inoltre, in stretta conformità con il modo in cui sono descritti in esso.
Le interfacce vengono spesso paragonate a classi astratte, ma nonostante tutte le somiglianze, questo confronto non è del tutto corretto. Come minimo, le classi astratte consentono di controllare la visibilità dei membri. Allo stesso tempo, gli ambiti non sono definiti per le interfacce.
Le interfacce consentono di rendere l'architettura più flessibile, poiché unificano l'accesso a questa o quella funzionalità, e consentono inoltre di evitare una serie di problemi associati all'ereditarietà delle classi (le interfacce possono anche essere ereditate l'una dall'altra).
Per dichiarare un'interfaccia in Delphi, utilizzare la parola chiave interfacce. Questa è la stessa parola chiave che definisce la sezione del modulo a cui è possibile accedere dall'esterno (tra le parole chiave dell'interfaccia e dell'implementazione). Tuttavia, quando si dichiara un'interfaccia, viene utilizzata una sintassi diversa, simile alla dichiarazione delle classi.
Delfi/Pascal
IMyNewInterface = procedura di interfaccia InterfaceProc; FINE;
IMyNewInterface =interfaccia procedura InterfaceProc ; FINE ; |
Pertanto, la sintassi stessa della dichiarazione dell'interfaccia non è fondamentalmente diversa da altri linguaggi di programmazione (le caratteristiche della sintassi basata su Pascal non contano). Allo stesso tempo, l'implementazione delle interfacce presenta una serie di caratteristiche.
Il fatto è che le interfacce Delphi sono state originariamente introdotte per supportare la tecnologia COM. Pertanto, l'interfaccia IInterface, che in Delphi è l'antenato di tutte le altre interfacce (una sorta di analogo di TObject), contiene già tre metodi di base per lavorare con questa tecnologia: QueryInterface, _AddRef, _Release. Di conseguenza, se una classe implementa un'interfaccia, deve implementare anche questi metodi. Anche se questa classe non è destinata al lavoro COM.
A causa di questa caratteristica dell'interfaccia IInterface, in Delphi l'uso delle interfacce, nella maggior parte dei casi, porta all'aggiunta di funzionalità ovviamente inutilizzate alla classe.
Esiste una classe di libreria TInterfaceObject che contiene già l'implementazione di questi metodi e, quando si eredita da essa, non è necessario implementarli da soli. Ma poiché Delphi non supporta l'ereditarietà di classi multiple, il suo utilizzo spesso causa solo ulteriori difficoltà nella progettazione e nell'implementazione delle funzionalità già richieste.
Tutto ciò ha portato al fatto che, nonostante tutte le possibilità offerte dalle interfacce, loro uso pratico In Delphi, quasi nulla è andato oltre il lavoro con COM.
Essendo ottimizzate per funzionare principalmente con questa tecnologia, le interfacce, o meglio le funzionalità e le restrizioni architetturali che necessariamente aggiungono, non si giustificano nella risoluzione di altri problemi.
Pertanto, molti programmatori Delphi sono ancora, di fatto, privi di uno strumento potente e flessibile per lo sviluppo dell'architettura applicativa.
Creazione interfaccia l'utente si riduce a selezionare da una tavolozza di componenti necessari per il funzionamento del programma Componenti Delphi, dipendenti interfaccia gestione, nonché interfaccia visualizzare le informazioni e trasferirle nel Form con successivo layout.
L'interfaccia utente creata dovrebbe utilizzare elementi standard familiari agli utenti e fornire la massima comodità. Tutto ciò è in definitiva determinato da un criterio come l'efficacia dell'interfaccia: massimi risultati con il minimo sforzo.
I principi per creare un'interfaccia user-friendly sono noti. Come i principi più generali durante la creazione interfacce utente Si possono considerare tre punti principali:
- Il programma dovrebbe aiutare a completare un'attività e non diventare quell'attività.
- Quando si lavora con il programma, l'utente non dovrebbe sentirsi uno sciocco.
- Il programma dovrebbe funzionare in modo tale che l'utente non consideri il computer uno sciocco.
Secondo principio significa trascurare le capacità intellettuali degli utenti. Dalla mia esperienza, so che spesso gli utenti non solo non sanno lavorare su un computer, ma hanno semplicemente paura di fare qualsiasi cosa da soli. Pertanto, l'interfaccia utente dovrebbe essere il più amichevole possibile.
Inoltre, i timori degli utenti sono spesso giustificati, perché il costo del programma, e anche del computer stesso, non può essere paragonato al costo, ad esempio, di un database creato in molti anni di impegno. Questo è il motivo per cui, quando crea un'interfaccia utente, un programmatore deve sempre integrare nel programma una "protezione infallibile" contro azioni errate e immissione di dati errati da parte dell'utente. Ma alcuni programmatori si lasciano trasportare troppo da tale protezione, la rendono troppo invadente e, di conseguenza, il funzionamento del programma ricorda il famoso “un passo a sinistra, un passo a destra è considerato una via di fuga”! E ciò che il programmatore crea come soluzione a un problema inizia a creare esso stesso problemi.
Per conformarsi secondo principio non è necessario consentire al programma di “correggere” le azioni dell’utente e di indicare esattamente come dovrebbe agire, costringendolo in un quadro ristretto. Inoltre, non dovresti lasciarti trasportare troppo dalla visualizzazione di messaggi informativi, in particolare quelli di dialogo, poiché ciò distrae l'utente dal lavoro. Sarebbe meglio fornire la possibilità di disabilitare del tutto i suggerimenti.
Terzo principioè creare un programma con le più elevate capacità "mentali" possibili. Nonostante il rapido sviluppo apparecchiature informatiche, anche i programmi ampiamente utilizzati possono essere definiti dotati di intelligenza artificiale solo in modo molto condizionato. Interferiscono con il lavoro dell'utente visualizzando finestre di dialogo con domande stupide che causano confusione anche nelle situazioni più semplici. Di conseguenza, gli utenti esclamano in cuor loro: “Che macchina stupida!”
Personalmente sono irritato dalle continue domande di quasi tutti editor di testo se salvare il testo modificato, sebbene il testo originale e quello attuale non differiscano in nessun simbolo. Sì, ho scritto qualcosa, ma poi ho restituito tutto, è davvero impossibile capirlo! Devo controllare se non ho rovinato nulla, dopotutto.
Cerca di rispettare le seguenti regole:
Elementi dell'interfaccia standard
Utilizza componenti standard per questo elemento dell'interfaccia. Avendo incontrato il tuo programma, l'utente non perderà tempo a conoscersi, ma inizierà immediatamente a lavorare: questo è uno dei segni di un programma realizzato professionalmente.Piccola tavolozza di strumenti
Cerca di non utilizzare troppi componenti diversi. E naturalmente, avendo utilizzato un componente standard da qualche parte in un posto, usalo anche in un caso simile.Spaziatura uguale tra i controlli
Posiziona gli elementi dell'interfaccia alla stessa distanza l'uno dall'altro. I componenti sparsi a casaccio creano la sensazione di un prodotto realizzato in modo non professionale. E viceversa, il posizionamento attentamente verificato di pulsanti, interruttori, caselle di controllo e altri componenti che compongono l'interfaccia sul modulo è un segno di lavoro di alta qualità.SchedaOrdine. "Giusto ordine
SchedaOrdineè l'ordine in cui il cursore a video si sposta sui controlli quando viene premuto un tasto Tab. In un programma scritto correttamente, il cursore si sposta seguendo la logica del lavoro dell'utente con il programma. Quando crea un programma, il programmatore spesso modifica i componenti, ne rimuove alcuni e ne aggiunge altri secondo necessità. Di conseguenza, nel programma finito il cursore salta in modo caotico attorno al modulo. Dopo aver completato il programma, non dimenticare di configurare SchedaOrdine.Selezione del carattere
Lascia stare i caratteri. I caratteri predefiniti di Delphi sono adatti a qualsiasi sistema su cui il tuo programma può essere eseguito. Utilizza il carattere in grassetto solo per evidenziare elementi importanti. Applicazione corsivo e specialmente sottolineando, che l'utente potrebbe confondere con un collegamento ipertestuale è una cattiva forma.Scelta dei colori
Per quanto riguarda i colori degli elementi dell'interfaccia, proprio come nel caso dei font, è meglio lasciarli standard, per impostazione predefinita. Delphi utilizza la tavolozza di sistema di Windows e l'utente può facilmente personalizzare i colori modificandoli.Gestione alternativa
Un programma realizzato professionalmente dovrebbe poter essere controllato non solo con il mouse, ma anche con la tastiera. Non dovrebbero esserci funzioni che possono essere eseguite solo con il mouse (disegno con redattori grafici non conta!). Per le funzioni più utilizzate, dovresti fornire “tasti di scelta rapida” per un accesso rapido.Mattoni di interfaccia
Per quanto riguarda elementi specifici dell'interfaccia utente, la qualità dell'interazione dell'utente con il programma dipende da:- conformità dell'elemento di controllo al compito che svolge;
- regole in base alle quali opera l’elemento di controllo.
Questa pagina discute le regole per la creazione di alcuni elementi dell'interfaccia.
Per prima cosa disporre i componenti uno rispetto all'altro nell'ordine corretto è necessario evidenziarli. Puoi semplicemente cerchiare l'area del modulo che contiene i componenti selezionati. Oppure tenendo premuto " Spostare", utilizzare lo stesso mouse per indicare ciascun componente da selezionare. Fare nuovamente clic con il mouse sul componente selezionato (tenendo premuto " Spostare") lo deseleziona.
I componenti selezionati possono essere gestiti come un tutt'uno: spostati nel modulo, assegnati valori alle stesse proprietà, copiati (per l'installazione, ad esempio, su un altro modulo), persino eliminati.
Ora fai clic con il pulsante destro del mouse su uno dei componenti e seleziona dal menu a comparsa Posizione -> Allinea... Apparirà una finestra di dialogo che ti consentirà di regolare la posizione orizzontale e verticale dei componenti nel gruppo. Ad esempio, dobbiamo allineare i nostri quattro pulsanti a sinistra e assicurarci che abbiano la stessa distanza verticale tra loro. Per fare ciò, seleziona i pulsanti di opzione Orizzontale: lato sinistro E Verticale: spazio equamente.
Selezionando l'oggetto Centro, disporremo i componenti in modo che i loro centri si trovino sulla stessa linea orizzontale o verticale e l'articolo Centro nella finestra sposta i componenti al centro della finestra, anche orizzontalmente o verticalmente.
Nella stessa riga del menu Tab O ordine... fa apparire una finestra di dialogo che controlla il modo in cui il cursore si sposta attraverso gli elementi dell'interfaccia quando viene premuto un tasto Tab. Quando il Modulo appare sullo schermo, il cursore si troverà naturalmente sul componente situato nella prima riga della finestra di dialogo. E poi si sposterà verso il basso nell'elenco. Nella finestra di dialogo, due frecce blu su e giù controllano la posizione del componente selezionato. Selezionare il componente richiesto, utilizzare le frecce per spostarlo sulla riga desiderata nell'elenco e così via.
Quando si seleziona una voce di menu Controllo -> Appare un sottomenu composto da due voci:
- Portare in primo piano
- Mandare indietro
