Controlli ActiveX MFC: argomenti avanzati
Questo articolo illustra gli argomenti avanzati relativi allo sviluppo di controlli ActiveX. tra cui:
Importante
ActiveX è una tecnologia legacy che non deve essere usata per il nuovo sviluppo. Per altre informazioni sulle tecnologie moderne che sostituisce ActiveX, vedere Controlli ActiveX.
Uso delle classi di database nei controlli ActiveX
Poiché le classi di controlli ActiveX fanno parte della libreria di classi, è possibile applicare le stesse procedure e regole per l'uso di classi di database in un'applicazione MFC standard per lo sviluppo di controlli ActiveX che usano le classi di database MFC.
Per una panoramica generale delle classi di database MFC, vedere Classi di database MFC (DAO e ODBC). L'articolo presenta sia le classi ODBC MFC che le classi DAO MFC e indirizza l'utente ad altri dettagli su entrambi.
Nota
DAO è supportato tramite Office 2013. DAO 3.6 è la versione finale e viene considerata obsoleta. L'ambiente e le procedure guidate di Visual C++ non supportano DAO (anche se le classi DAO sono incluse ed è comunque possibile usarle). Microsoft consiglia di usare i modelli OLE DB o ODBC e MFC per i nuovi progetti. È consigliabile usare DAO solo per gestire le applicazioni esistenti.
Implementazione di una proprietà con parametri
Una proprietà con parametri (talvolta detta matrice di proprietà) è un metodo per esporre una raccolta omogenea di valori come una singola proprietà del controllo. Ad esempio, è possibile usare una proprietà con parametri per esporre una matrice o un dizionario come proprietà. In Visual Basic è possibile accedere a tale proprietà usando la notazione della matrice:
x = o.Array(2, 3) ' gets element of 2D array
o.Array(2, 3) = 7 ' sets element of 2D array
Utilizzare l'Aggiunta guidata proprietà per implementare una proprietà con parametri. L'Aggiunta guidata proprietà implementa la proprietà aggiungendo una coppia di funzioni Get/Set che consentono all'utente di controllare di accedere alla proprietà utilizzando la notazione precedente o in modo standard.
Analogamente ai metodi e alle proprietà, le proprietà con parametri hanno anche un limite al numero di parametri consentiti. Nel caso di proprietà con parametri, il limite è di 15 parametri (con un parametro riservato per l'archiviazione del valore della proprietà).
La procedura seguente aggiunge una proprietà con parametri denominata Array, accessibile come matrice bidimensionale di interi.
Per aggiungere una proprietà con parametri tramite l'Aggiunta guidata proprietà
Caricare il progetto del controllo.
In Visualizzazione classi, espandere il nodo di libreria del controllo.
Fare clic con il pulsante destro del mouse sul nodo interfaccia del controllo (il secondo nodo del nodo di libreria) per aprire il menu di scelta rapida.
Scegliere Aggiungi dal menu di scelta rapida e quindi fare clic su Aggiungi proprietà.
Nella casella Nome proprietà digitare
Array.Nella casella Tipo di proprietà selezionare
short.Per Tipo di implementazione, fare clic su Metodi Get/Set.
Nelle caselle Get Function and Set Function (Ottieni funzione e Imposta funzione ) digitare nomi univoci per le funzioni Get e Set oppure accettare i nomi predefiniti.
Aggiungere un parametro, denominato row (type short), usando i controlli Nome parametro e Tipo di parametro.
Aggiungere un secondo parametro denominato column (type short).
Fare clic su Fine.
Modifiche apportate dall'Aggiunta guidata proprietà
Quando si aggiunge una proprietà personalizzata, l'Aggiunta guidata proprietà apporta modifiche all'intestazione della classe di controllo (. H) e l'implementazione (. File CPP).
Le righe seguenti vengono aggiunte alla classe del controllo . File H:
SHORT GetArray(SHORT row, SHORT column);
void SetArray(SHORT row, SHORT column, SHORT newVal);
Questo codice dichiara due funzioni chiamate GetArray e SetArray che consentono all'utente di richiedere una riga e una colonna specifica durante l'accesso alla proprietà.
Inoltre, l'Aggiunta guidata proprietà aggiunge le righe seguenti alla mappa di distribuzione dei controlli, che si trova nell'implementazione della classe di controllo (. File CPP):
DISP_PROPERTY_PARAM_ID(CMyAxUICtrl, "Array", dispidArray, GetArray, SetArray, VT_I2, VTS_I2 VTS_I2)
Infine, le implementazioni delle GetArray funzioni e SetArray vengono aggiunte alla fine di . File CPP. Nella maggior parte dei casi, si modificherà la funzione Get per restituire il valore della proprietà . La funzione Set in genere conterrà codice che deve essere eseguito, prima o dopo la modifica della proprietà.
Per rendere utile questa proprietà, è possibile dichiarare una variabile membro di matrice bidimensionale nella classe di controllo, di tipo short, per archiviare i valori per la proprietà con parametri. È quindi possibile modificare la funzione Get per restituire il valore archiviato nella riga e nella colonna appropriati, come indicato dai parametri e modificare la funzione Set per aggiornare il valore a cui fanno riferimento i parametri di riga e colonna.
Gestione degli errori nel controllo ActiveX
Se si verificano condizioni di errore nel controllo, potrebbe essere necessario segnalare l'errore al contenitore di controlli. Esistono due metodi per segnalare gli errori, a seconda della situazione in cui si verifica l'errore. Se l'errore si verifica all'interno della funzione Get o Set di una proprietà o all'interno dell'implementazione di un metodo di automazione OLE, il controllo deve chiamare COleControl::ThrowError, che segnala all'utente del controllo che si è verificato un errore. Se l'errore si verifica in qualsiasi altro momento, il controllo deve chiamare COleControl::FireError, che genera un evento Stock Error.
Per indicare il tipo di errore che si è verificato, il controllo deve passare un codice di errore a ThrowError o FireError. Un codice di errore è un codice di stato OLE, che ha un valore a 32 bit. Quando possibile, scegliere un codice di errore dal set standard di codici definiti in OLECTL. File di intestazione H. Nella tabella seguente sono riepilogati questi codici.
Codici di errore del controllo ActiveX
| Errore | Descrizione |
|---|---|
| CTL_E_ILLEGALFUNCTIONCALL | Chiamata di funzione non valida |
| CTL_E_OVERFLOW | Overflow |
| CTL_E_OUTOFMEMORY | Memoria insufficiente |
| CTL_E_DIVISIONBYZERO | Divisione per zero |
| CTL_E_OUTOFSTRINGSPACE | Spazio di stringa insufficiente |
| CTL_E_OUTOFSTACKSPACE | Spazio dello stack insufficiente |
| CTL_E_BADFILENAMEORNUMBER | Numero o nome file errato |
| CTL_E_FILENOTFOUND | File non trovato |
| CTL_E_BADFILEMODE | Modalità file non valida |
| CTL_E_FILEALREADYOPEN | File già aperto |
| CTL_E_DEVICEIOERROR | Errore di I/O del dispositivo |
| CTL_E_FILEALREADYEXISTS | Il file esiste già |
| CTL_E_BADRECORDLENGTH | Lunghezza del record non valida |
| CTL_E_DISKFULL | Disco pieno |
| CTL_E_BADRECORDNUMBER | Numero di record non valido |
| CTL_E_BADFILENAME | Nome file non valido |
| CTL_E_TOOMANYFILES | Troppi file. |
| CTL_E_DEVICEUNAVAILABLE | Dispositivo non disponibile |
| CTL_E_PERMISSIONDENIED | Autorizzazione negata |
| CTL_E_DISKNOTREADY | Disco non pronto |
| CTL_E_PATHFILEACCESedizione Standard RROR | Errore di accesso al percorso/file |
| CTL_E_PATHNOTFOUND | Impossibile trovare il percorso |
| CTL_E_INVALIDPATTERNSTRING | Stringa di ricerca non valida |
| CTL_E_INVALIDUedizione Standard OFNULL | Uso non valido di NULL |
| CTL_E_INVALIDFILEFORMAT | Formato di file non valido |
| CTL_E_INVALIDPROPERTYVALUE | Valore della proprietà non valido |
| CTL_E_INVALIDPROPERTYARRAYINDEX | Indice della matrice di proprietà non valido |
| CTL_E_edizione Standard TNOTSUPPORTEDATRUNTIME | Set non supportato in fase di esecuzione |
| CTL_E_edizione Standard TNOTSUPPORTED | Set non supportato (proprietà di sola lettura) |
| CTL_E_Nedizione Enterprise DPROPERTYARRAYINDEX | Necessario indice della matrice di proprietà |
| CTL_E_edizione Standard TNOTPERMITTED | Set non consentito |
| CTL_E_GETNOTSUPPORTEDATRUNTIME | Get non supportato in fase di esecuzione |
| CTL_E_GETNOTSUPPORTED | Get non supportato (proprietà di sola scrittura) |
| CTL_E_PROPERTYNOTFOUND | Proprietà non trovata |
| CTL_E_INVALIDCLIPBOARDFORMAT | Formato degli Appunti non valido |
| CTL_E_INVALIDPICTURE | Immagine non valida |
| CTL_E_PRINTERERROR | Errore della stampante |
| CTL_E_CANTSAVEFILETOTEMP | Impossibile salvare il file in TEMP |
| CTL_E_edizione Standard ARCHTEXTNOTFOUND | Impossibile trovare il testo cercato |
| CTL_E_REPLACEMENTSTOOLONG | Sostituzioni troppo lunghe |
Se necessario, utilizzare la macro CUSTOM_CTL_SCODE per definire un codice di errore personalizzato per una condizione non coperta da uno dei codici standard. Il parametro per questa macro deve essere un numero intero compreso tra 1000 e 32767 inclusi. Ad esempio:
#define MYCTL_E_SPECIALERROR CUSTOM_CTL_SCODE(1000)
Se si sta creando un controllo ActiveX per sostituire un controllo VBX esistente, definire i codici di errore del controllo ActiveX con gli stessi valori numerici usati dal controllo VBX per assicurarsi che i codici di errore siano compatibili.
Gestione di tasti speciali nel controllo
In alcuni casi potresti voler gestire determinate combinazioni di tasti in modo speciale; ad esempio, inserire una nuova riga quando si preme INVIO in un controllo casella di testo su più righe o spostarsi tra un gruppo di controlli di modifica quando viene premuto un ID tasto direzionale.
Se la classe base del controllo ActiveX è COleControl, è possibile eseguire l'override di CWnd::P reTranslateMessage per gestire i messaggi prima che vengano elaborati dal contenitore. Quando si usa questa tecnica, restituire sempre TRUE se si gestisce il messaggio nell'override di PreTranslateMessage.
Nell'esempio di codice seguente viene illustrato un modo possibile per gestire i messaggi correlati alle chiavi direzionali.
BOOL CMyAxUICtrl::PreTranslateMessage(MSG* pMsg)
{
BOOL bHandleNow = FALSE;
switch (pMsg->message)
{
case WM_KEYDOWN:
switch (pMsg->wParam)
{
case VK_UP:
case VK_DOWN:
case VK_LEFT:
case VK_RIGHT:
bHandleNow = TRUE;
break;
}
if (bHandleNow)
{
OnKeyDown((UINT)pMsg->wParam, LOWORD(pMsg->lParam), HIWORD(pMsg->lParam));
}
break;
}
return bHandleNow;
}
Per altre informazioni sulla gestione delle interfacce della tastiera per un controllo ActiveX, vedere la documentazione di ActiveX SDK.
Accesso ai controlli finestra di dialogo invisibili in fase di esecuzione
È possibile creare controlli di finestra di dialogo che non dispongono di interfaccia utente e sono invisibili in fase di esecuzione. Se si aggiunge un controllo ActiveX in fase di esecuzione a una finestra di dialogo e si usa CWnd::GetDlgItem per accedere al controllo, il controllo non funzionerà correttamente. È invece consigliabile usare una delle tecniche seguenti per ottenere un oggetto che rappresenta il controllo :
Usando l'Aggiunta guidata variabile membro, selezionare Variabile di controllo e quindi selezionare l'ID del controllo. Immettere un nome di variabile membro e selezionare la classe wrapper del controllo come Tipo di controllo.
-oppure-
Dichiarare una variabile locale e una sottoclasse come elemento della finestra di dialogo. Inserire codice simile al seguente (
CMyCtrlè la classe wrapper, IDC_MYCTRL1 è l'ID del controllo):CCirc myCirc; myCirc.SubclassDlgItem(IDC_CIRCCTRL2, this); // ... use myCirc ... myCirc.UnsubclassWindow();
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per