Classe CWinApp

Classe di base da cui deriva un oggetto applicazione Windows.

Sintassi

class CWinApp : public CWinThread

Membri

Costruttori pubblici

Nome	Descrizione
CWinApp::CWinApp	Costruisce un oggetto CWinApp.

Metodi pubblici

Nome	Descrizione
CWinApp::AddDocTemplate	Aggiunge un modello di documento all'elenco dei modelli di documento disponibili dell'applicazione.
CWinApp::AddToRecentFileList	Aggiunge un nome file all'elenco dei file usati più di recente.
CWinApp::ApplicationRecoveryCallback	Chiamato dal framework quando l'applicazione viene chiusa in modo imprevisto.
CWinApp::CloseAllDocuments	Chiude tutti i documenti aperti.
CWinApp::CreatePrinterDC	Crea un contesto di dispositivo della stampante.
CWinApp::D elRegTree	Elimina una chiave specificata e tutte le relative sottochiavi.
CWinApp::D oMessageBox	Implementa AfxMessageBox per l'applicazione.
CWinApp::D oWaitCursor	Attiva e disattiva il cursore di attesa.
CWinApp::EnableD2DSupport	Abilita il supporto D2D dell'applicazione. Chiamare questo metodo prima dell'inizializzazione della finestra principale.
CWinApp::EnableHtmlHelp	Implementa HTMLHelp per l'applicazione, anziché WinHelp.
CWinApp::EnableTaskbarInteraction	Abilita l'interazione della barra delle applicazioni.
CWinApp::ExitInstance	Eseguire l'override per eseguire la pulizia al termine dell'applicazione.
CWinApp::GetApplicationRecoveryParameter	Recupera il parametro di input per il metodo di recupero dell'applicazione.
CWinApp::GetApplicationRecoveryPingInterval	Restituisce l'intervallo di tempo in cui il gestore di riavvio attende che venga restituita la funzione di callback di ripristino.
CWinApp::GetApplicationRestartFlags	Restituisce i flag per il gestore di riavvio.
CWinApp::GetAppRegistryKey	Restituisce la chiave per HKEY_CURRENT_Uedizione Standard R\"Software"\RegistryKey\ProfileName.
CWinApp::GetDataRecoveryHandler	Ottiene il gestore di recupero dati per questa istanza dell'applicazione.
CWinApp::GetFirstDocTemplatePosition	Recupera la posizione del primo modello di documento.
CWinApp::GetHelpMode	Recupera il tipo di Guida utilizzata dall'applicazione.
CWinApp::GetNextDocTemplate	Recupera la posizione di un modello di documento. Può essere usato in modo ricorsivo.
CWinApp::GetPrinterDeviceDefaults	Recupera le impostazioni predefinite del dispositivo della stampante.
CWinApp::GetProfileBinary	Recupera i dati binari da una voce nell'oggetto dell'applicazione. File INI.
CWinApp::GetProfileInt	Recupera un numero intero da una voce nell'oggetto dell'applicazione. File INI.
CWinApp::GetProfileString	Recupera una stringa da una voce nell'oggetto dell'applicazione. File INI.
CWinApp::GetSectionKey	Restituisce la chiave per HKEY_CURRENT_Uedizione Standard R\"Software"\RegistryKey\AppName\lpszSection.
CWinApp::HideApplication	Nasconde l'applicazione prima di chiudere tutti i documenti.
CWinApp::HtmlHelp	Chiama la HTMLHelp funzione Windows.
CWinApp::InitInstance	Eseguire l'override per eseguire l'inizializzazione dell'istanza di Windows, ad esempio la creazione degli oggetti finestra.
CWinApp::IsTaskbarInteractionEnabled	Indica se l'interazione della barra delle applicazioni di Windows 7 è abilitata.
CWinApp::LoadCursor	Carica una risorsa cursore.
CWinApp::LoadIcon	Carica una risorsa icona.
CWinApp::LoadOEMCursor	Carica un cursore predefinito OEM di Windows specificato dalle costanti OCR_ in WINDOWS.H.
CWinApp::LoadOEMIcon	Carica un'icona predefinita OEM di Windows specificata dalle costanti OIC_ in WINDOWS.H.
CWinApp::LoadStandardCursor	Carica un cursore predefinito di Windows specificato dalle costanti IDC_ in WINDOWS.H.
CWinApp::LoadStandardIcon	Carica un'icona predefinita di Windows specificata dalle costanti IDI_ in WINDOWS.H.
CWinApp::OnDDECommand	Chiamato dal framework in risposta a un comando DDE (Dynamic Data Exchange).
CWinApp::OnIdle	Eseguire l'override per eseguire l'elaborazione inattiva specifica dell'applicazione.
CWinApp::OpenDocumentFile	Chiamato dal framework per aprire un documento da un file.
CWinApp::P arseCommandLine	Analizza i singoli parametri e flag nella riga di comando.
CWinApp::P reTranslateMessage	Filtra i messaggi prima che vengano inviati alle funzioni di Windows TranslateMessage e DispatchMessage.
CWinApp::P rocessMessageFilter	Intercetta determinati messaggi prima di raggiungere l'applicazione.
CWinApp::P rocessShellCommand	Gestisce argomenti e flag della riga di comando.
CWinApp::P rocessWndProcException	Intercetta tutte le eccezioni non gestite generate dai gestori di comandi e messaggi dell'applicazione.
CWinApp::Register	Esegue la registrazione personalizzata.
CWinApp::RegisterWithRestartManager	Registra l'applicazione con il gestore di riavvio.
CWinApp::ReopenPreviousFilesAtRestart	Determina se il gestore di riavvio riapre i file aperti quando l'applicazione è stata chiusa in modo imprevisto.
CWinApp::RestartInstance	Gestisce un riavvio dell'applicazione avviato dal gestore di riavvio.
CWinApp::RestoreAutosavedFilesAtRestart	Determina se il gestore di riavvio ripristina i file salvati automaticamente quando riavvia l'applicazione.
CWinApp::Run	Esegue il ciclo di messaggi predefinito. Eseguire l'override per personalizzare il ciclo di messaggi.
CWinApp::RunAutomated	Verifica la riga di comando dell'applicazione per l'opzione /Automation . Obsoleta. Usare invece il valore in CCommandLineInfo::m_bRunAutomated dopo aver chiamato ParseCommandLine.
CWinApp::RunEmbedded	Testa la riga di comando dell'applicazione per l'opzione /Embedding . Obsoleta. Usare invece il valore in CCommandLineInfo::m_bRunEmbedded dopo aver chiamato ParseCommandLine.
CWinApp::SaveAllModified	Richiede all'utente di salvare tutti i documenti modificati.
CWinApp::SelectPrinter	Seleziona una stampante indicata in precedenza da un utente tramite una finestra di dialogo di stampa.
CWinApp::SetHelpMode	Imposta e inizializza il tipo di Guida utilizzata dall'applicazione.
CWinApp::SupportsApplicationRecovery	Determina se il gestore di riavvio recupera un'applicazione che è stata chiusa in modo imprevisto.
CWinApp::SupportsAutosaveAtInterval	Determina se il gestore di riavvio aggiorna automaticamente i documenti aperti a intervalli regolari.
CWinApp::SupportsAutosaveAtRestart	Determina se il gestore di riavvio aggiorna automaticamente i documenti aperti al riavvio dell'applicazione.
CWinApp::SupportsRestartManager	Determina se l'applicazione supporta il gestore di riavvio.
CWinApp::Unregister	Annulla la registrazione di tutti gli elementi noti per essere registrati dall'oggetto CWinApp .
CWinApp::WinHelp	Chiama la WinHelp funzione Windows.
CWinApp::WriteProfileBinary	Scrive i dati binari in una voce nell'oggetto dell'applicazione. File INI.
CWinApp::WriteProfileInt	Scrive un numero intero in una voce nell'oggetto dell'applicazione. File INI.
CWinApp::WriteProfileString	Scrive una stringa in una voce nell'oggetto dell'applicazione. File INI.

Metodi protetti

Nome	Descrizione
CWinApp::EnableShellOpen	Consente all'utente di aprire i file di dati da Gestione file di Windows.
CWinApp::LoadStdProfile Impostazioni	Carica l'oggetto standard . Le impostazioni del file INI e abilitano la funzionalità elenco di file MRU.
CWinApp::OnContextHelp	Gestisce la Guida MAIUSC+F1 all'interno dell'applicazione.
CWinApp::OnFileNew	Implementa il comando ID_FILE_NEW.
CWinApp::OnFileOpen	Implementa il comando ID_FILE_OPEN.
CWinApp::OnFilePrintSetup	Implementa il comando ID_FILE_PRINT_edizione Standard TUP.
CWinApp::OnHelp	Gestisce F1 Guida all'interno dell'applicazione (usando il contesto corrente).
CWinApp::OnHelpFinder	Gestisce i comandi ID_HELP_FINDER e ID_DEFAULT_HELP.
CWinApp::OnHelpIndex	Gestisce il comando ID_HELP_INDEX e fornisce un argomento della Guida predefinito.
CWinApp::OnHelpUsing	Gestisce il comando ID_HELP_USING.
CWinApp::RegisterShellFileTypes	Registra tutti i tipi di documento dell'applicazione con Gestione file di Windows.
CWinApp::SetAppID	Imposta in modo esplicito l'ID modello utente applicazione per l'applicazione. Questo metodo deve essere chiamato prima che qualsiasi interfaccia utente venga presentata all'utente (la posizione migliore è il costruttore dell'applicazione).
CWinApp::SetRegistryKey	Fa sì che le impostazioni dell'applicazione vengano archiviate nel Registro di sistema invece di . File INI.
CWinApp::UnregisterShellFileTypes	Annulla la registrazione di tutti i tipi di documento dell'applicazione con Gestione file di Windows.

Membri dati pubblici

Nome	Descrizione
CWinApp::m_bHelpMode	Indica se l'utente è in modalità contesto della Guida (in genere richiamato con MAIUSC+F1).
CWinApp::m_eHelpType	Specifica il tipo di Guida utilizzata dall'applicazione.
CWinApp::m_hInstance	Identifica l'istanza corrente dell'applicazione.
CWinApp::m_lpCmdLine	Punta a una stringa con terminazione Null che specifica la riga di comando per l'applicazione.
CWinApp::m_nCmdShow	Specifica la modalità di visualizzazione iniziale della finestra.
CWinApp::m_pActiveWnd	Puntatore alla finestra principale dell'applicazione contenitore quando un server OLE è attivo sul posto.
CWinApp::m_pszAppID	ID modello utente applicazione.
CWinApp::m_pszAppName	Specifica il nome dell'applicazione.
CWinApp::m_pszExeName	Nome del modulo dell'applicazione.
CWinApp::m_pszHelpFilePath	Percorso del file della Guida dell'applicazione.
CWinApp::m_pszProfileName	L'oggetto dell'applicazione. Nome file INI.
CWinApp::m_pszRegistryKey	Usato per determinare la chiave del Registro di sistema completa per l'archiviazione delle impostazioni del profilo applicazione.

Membri dati protetti

Nome	Descrizione
CWinApp::m_dwRestartManagerSupportFlags	Flag che determinano il comportamento del gestore di riavvio.
CWinApp::m_nAutosaveInterval	Intervallo di tempo in millisecondi tra le operazioni di intercettazione automatica.
CWinApp::m_pDataRecoveryHandler	Puntatore al gestore di recupero dati per l'applicazione.

Osservazioni:

Un oggetto applicazione fornisce funzioni membro per l'inizializzazione dell'applicazione (e ogni istanza di essa) e per l'esecuzione dell'applicazione.

Ogni applicazione che usa le classi Microsoft Foundation può contenere solo un oggetto derivato da CWinApp. Questo oggetto viene costruito quando vengono costruiti altri oggetti globali C++ ed è già disponibile quando Windows chiama la WinMain funzione , fornita dalla libreria di classi Microsoft Foundation. Dichiarare l'oggetto derivato CWinApp a livello globale.

Quando si deriva una classe applicazione da CWinApp, eseguire l'override della funzione membro InitInstance per creare l'oggetto finestra principale dell'applicazione.

Oltre alle CWinApp funzioni membro, microsoft Foundation Class Library fornisce le funzioni globali seguenti per accedere CWinApp all'oggetto e ad altre informazioni globali:

• AfxGetApp Ottiene un puntatore all'oggetto CWinApp .

• AfxGetInstanceHandle Ottiene un handle per l'istanza dell'applicazione corrente.

• AfxGetResourceHandle Ottiene un handle per le risorse dell'applicazione.

• AfxGetAppName Ottiene un puntatore a una stringa contenente il nome dell'applicazione. In alternativa, se si dispone di un puntatore all'oggetto CWinApp , usare m_pszExeName per ottenere il nome dell'applicazione.

Per altre informazioni sulla classe, vedere CWinApp: The Application Class (CWinApp: The Application Class for more on the CWinApp class), inclusa una panoramica degli elementi seguenti:

• CWinAppCodice derivato da scritto dalla Creazione guidata applicazione.

• CWinAppruolo nella sequenza di esecuzione dell'applicazione.

• CWinAppImplementazioni predefinite della funzione membro.

• CWinApp's key overridables.

Il m_hPrevInstance membro dati non esiste più. Per determinare se è in esecuzione un'altra istanza dell'applicazione, usare un mutex denominato. Se l'apertura del mutex ha esito negativo, non sono presenti altre istanze dell'applicazione in esecuzione.

Gerarchia di ereditarietà

CObject

CCmdTarget

Cwinthread

CWinApp

Requisiti

Intestazione: afxwin.h

CWinApp::AddDocTemplate

Chiamare questa funzione membro per aggiungere un modello di documento all'elenco dei modelli di documento disponibili che l'applicazione gestisce.

void AddDocTemplate(CDocTemplate* pTemplate);

Parametri

pTemplate
Puntatore all'oggetto CDocTemplate da aggiungere.

Osservazioni:

È consigliabile aggiungere tutti i modelli di documento a un'applicazione prima di chiamare RegisterShellFileTypes.

Esempio

// The following code is produced by the Application Wizard when you
// choose the MDI (multiple document interface) option.
CMultiDocTemplate *pDocTemplate;
pDocTemplate = new CMultiDocTemplate(IDR_MYTYPE,
                                     RUNTIME_CLASS(CMyDoc),
                                     RUNTIME_CLASS(CChildFrame), // custom MDI child frame
                                     RUNTIME_CLASS(CMyView));
if (!pDocTemplate)
   return FALSE;
AddDocTemplate(pDocTemplate);

CWinApp::AddToRecentFileList

Chiamare questa funzione membro per aggiungere lpszPathName all'elenco di file MRU.

virtual void AddToRecentFileList(LPCTSTR lpszPathName);

Parametri

lpszPathName
Percorso del file.

Osservazioni:

È necessario chiamare la funzione membro LoadStdProfile Impostazioni per caricare l'elenco di file MRU corrente prima di usare questa funzione membro.

Il framework chiama questa funzione membro quando apre un file o esegue il comando Salva con nome per salvare un file con un nuovo nome.

Esempio

// This adds the pathname c:\temp\test.doc to the top of
// the most recently used (MRU) list in the File menu.
AfxGetApp()->AddToRecentFileList(_T("c:\\temp\\test.doc"));

CWinApp::ApplicationRecoveryCallback

Chiamato dal framework quando l'applicazione viene chiusa in modo imprevisto.

virtual DWORD ApplicationRecoveryCallback(LPVOID lpvParam);

Parametri

lpvParam
[in] Riservato per uso futuro.

Valore restituito

0 se questo metodo ha esito positivo; diverso da zero se si verifica un errore.

Osservazioni:

Se l'applicazione supporta gestione riavvio, il framework chiama questa funzione quando l'applicazione viene chiusa in modo imprevisto.

L'implementazione predefinita di ApplicationRecoveryCallback utilizza per CDataRecoveryHandler salvare l'elenco dei documenti attualmente aperti nel Registro di sistema. Questo metodo non salva automaticamente alcun file.

Per personalizzare il comportamento, eseguire l'override di questa funzione in una classe CWinApp derivata o passare il proprio metodo di ripristino dell'applicazione come parametro a CWinApp::RegisterWithRestartManager.

CWinApp::CloseAllDocuments

Chiamare questa funzione membro per chiudere tutti i documenti aperti prima di uscire.

void CloseAllDocuments(BOOL bEndSession);

Parametri

bEndSession
Specifica se la sessione di Windows è terminata o meno. È VERO se la sessione viene terminata; altrimenti FAL edizione Standard.

Osservazioni:

Chiamare HideApplication prima di chiamare CloseAllDocuments.

CWinApp::CreatePrinterDC

Chiamare questa funzione membro per creare un contesto di dispositivo della stampante dalla stampante selezionata.

BOOL CreatePrinterDC(CDC& dc);

Parametri

dc
Riferimento a un contesto di dispositivo della stampante.

Valore restituito

Diverso da zero se il contesto del dispositivo della stampante viene creato correttamente; in caso contrario, 0.

Osservazioni:

CreatePrinterDC inizializza il contesto di dispositivo passato per riferimento, in modo da poterlo usare per stampare.

Se la funzione ha esito positivo, al termine della stampa, è necessario eliminare definitivamente il contesto del dispositivo. È possibile consentire al distruttore dell'oggetto CDC di eseguire questa operazione oppure è possibile farlo in modo esplicito chiamando CDC::D eleteDC.

CWinApp::CWinApp

Costruisce un CWinApp oggetto e passa lpszAppName da archiviare come nome dell'applicazione.

CWinApp(LPCTSTR lpszAppName = NULL);

Parametri

lpszAppName
Stringa con terminazione Null che contiene il nome dell'applicazione usato da Windows. Se questo argomento non viene fornito o è NULL, CWinApp usa la stringa di risorsa AFX_IDS_APP_TITLE o il nome file del file eseguibile.

Osservazioni:

È necessario costruire un oggetto globale della CWinAppclasse derivata da . È possibile avere un CWinApp solo oggetto nell'applicazione. Il costruttore archivia un puntatore all'oggetto CWinApp in modo che WinMain possa chiamare le funzioni membro dell'oggetto per inizializzare ed eseguire l'applicazione.

CWinApp::D elRegTree

Elimina una chiave del Registro di sistema specifica e tutte le relative sottochiavi.

LONG DelRegTree(
    HKEY hParentKey,
    const CString& strKeyName);

LONG DelRegTree(
    HKEY hParentKey,
    const CString& strKeyName,
    CAtlTransactionManager* pTM = NULL);

Parametri

hParentKey
Handle in una chiave del Registro di sistema.

strKeyName
Nome della chiave del Registro di sistema da eliminare.

Ptm
Puntatore all'oggetto CAtlTransactionManager.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è ERROR_SUCCESS. Se la funzione ha esito negativo, il valore restituito è un codice di errore diverso da zero definito in Winerror.h.

Osservazioni:

Chiamare questa funzione per eliminare la chiave specificata e le relative sottochiavi.

CWinApp::D oMessageBox

Il framework chiama questa funzione membro per implementare una finestra di messaggio per la funzione globale AfxMessageBox.

virtual int DoMessageBox(
    LPCTSTR lpszPrompt,
    UINT nType,
    UINT nIDPrompt);

Parametri

lpszPrompt
Indirizzo di testo nella finestra di messaggio.

nType
Stile della finestra di messaggio.

nIDPrompt
Indice di una stringa di contesto della Guida.

Valore restituito

Restituisce gli stessi valori di AfxMessageBox.

Osservazioni:

Non chiamare questa funzione membro per aprire una finestra di messaggio; usare AfxMessageBox invece .

Eseguire l'override di questa funzione membro per personalizzare l'elaborazione a livello di applicazione delle AfxMessageBox chiamate.

CWinApp::D oWaitCursor

Questa funzione membro viene chiamata dal framework per implementare CWaitCursor, CCmdTarget::BeginWaitCursor, CCmdTarget::EndWaitCursor e CCmdTarget::RestoreWaitCursor.

virtual void DoWaitCursor(int nCode);

Parametri

Ncode
Se questo parametro è 1, viene visualizzato un cursore di attesa. Se 0, il cursore di attesa viene ripristinato senza incrementare il conteggio dei riferimenti. Se -1, termina il cursore di attesa.

Osservazioni:

Il valore predefinito implementa un cursore di clessidra. DoWaitCursor gestisce un conteggio dei riferimenti. Se positivo, viene visualizzato il cursore di clessidra.

Anche se in genere non si chiama DoWaitCursor direttamente, è possibile eseguire l'override di questa funzione membro per modificare il cursore di attesa o per eseguire un'ulteriore elaborazione mentre viene visualizzato il cursore di attesa.

Per un modo più semplice e semplificato per implementare un cursore di attesa, usare CWaitCursor.

Esempio

// The following example shows how to display the
// hourglass cursor during some lengthy processing
void CMdiView::OnLButtonDown(UINT nFlags, CPoint point)
{
   UNREFERENCED_PARAMETER(nFlags);
   UNREFERENCED_PARAMETER(point);

   AfxGetApp()->DoWaitCursor(1); // 1->>display the hourglass cursor

   // do some lengthy processing
   Sleep(1000);

   AfxGetApp()->DoWaitCursor(-1); // -1->>remove the hourglass cursor
}

// The next example shows DoWaitCursor with parameter 0. It restores
// the hourglass cursor.
void CMdiView::OnMButtonDown(UINT nFlags, CPoint point)
{
   UNREFERENCED_PARAMETER(nFlags);
   UNREFERENCED_PARAMETER(point);

   AfxGetApp()->DoWaitCursor(1); // display the hourglass cursor

   // do some lengthy processing

   // The message box will normally change the cursor to
   // the standard arrow cursor, and leave the cursor in
   // as the standard arrow cursor when the message box is
   // closed.
   AfxMessageBox(_T("DoWaitCursor Sample"));

   // Call DoWaitCursor with parameter 0 to restore
   // the cursor back to the hourglass cursor.
   AfxGetApp()->DoWaitCursor(0);

   // do some more lengthy processing
   Sleep(1000);

   AfxGetApp()->DoWaitCursor(-1); // remove the hourglass cursor
}

CWinApp::EnableD2DSupport

È necessario Visual Studio 2010 SP1.

Abilita il supporto D2D dell'applicazione. Chiamare questo metodo prima dell'inizializzazione della finestra principale.

BOOL EnableD2DSupport(
    D2D1_FACTORY_TYPE d2dFactoryType = D2D1_FACTORY_TYPE_SINGLE_THREADED,
    DWRITE_FACTORY_TYPE writeFactoryType = DWRITE_FACTORY_TYPE_SHARED);

Parametri

d2dFactoryType
Modello di threading della factory D2D e delle risorse create.

writeFactoryType
Valore che specifica se l'oggetto factory di scrittura verrà condiviso o isolato

Valore restituito

Restituisce TRUE se il supporto D2D è stato abilitato, FAL edizione Standard ; in caso contrario,

CWinApp::EnableHtmlHelp

Chiamare questa funzione membro dall'interno del costruttore della CWinAppclasse derivata da per usare HTMLHelp per la Guida dell'applicazione.

void EnableHtmlHelp();

Osservazioni:

CWinApp::EnableShellOpen

Chiamare questa funzione, in genere dall'override InitInstance , per consentire agli utenti dell'applicazione di aprire i file di dati quando fanno doppio clic sui file dall'interno di Gestione file di Windows.

void EnableShellOpen();

Osservazioni:

Chiamare la RegisterShellFileTypes funzione membro insieme a questa funzione oppure specificare un oggetto . File REG con l'applicazione per la registrazione manuale dei tipi di documento.

Esempio

// The following code fragment is from CMyApp::InitInstance.
// CMyApp is a CWinApp-derived class.

// enable file manager drag/drop and DDE Execute open
EnableShellOpen();
RegisterShellFileTypes();

CWinApp::EnableTaskbarInteraction

Abilita l'interazione della barra delle applicazioni.

BOOL EnableTaskbarInteraction(BOOL bEnable = TRUE);

Parametri

bEnable
Specifica se l'interazione con la barra delle applicazioni di Windows 7 deve essere abilitata (TRUE) o disabilitata (FAL edizione Standard).

Valore restituito

Restituisce TRUE se l'interazione della barra delle applicazioni può essere abilitata o disabilitata.

Osservazioni:

Questo metodo deve essere chiamato prima della creazione della finestra principale, altrimenti asserisce e restituisce FAL edizione Standard.

CWinApp::ExitInstance

Chiamato dal framework dall'interno della Run funzione membro per uscire da questa istanza dell'applicazione.

virtual int ExitInstance();

Valore restituito

Codice di uscita dell'applicazione; 0 indica che non sono presenti errori e i valori maggiori di 0 indicano un errore. Questo valore viene usato come valore restituito da WinMain.

Osservazioni:

Non chiamare questa funzione membro da qualsiasi posizione, ma all'interno della Run funzione membro.

L'implementazione predefinita di questa funzione scrive le opzioni del framework nell'oggetto dell'applicazione. File INI. Eseguire l'override di questa funzione per eseguire la pulizia al termine dell'applicazione.

Esempio

int CMyApp::ExitInstance()
{
   if (m_pMySampleMem)
      delete m_pMySampleMem;

   DoCleanup();

   return CWinApp::ExitInstance();
}

CWinApp::GetApplicationRecoveryParameter

Recupera il parametro di input per il metodo di recupero dell'applicazione.

virtual LPVOID GetApplicationRecoveryParameter();

Valore restituito

Parametro di input predefinito per il metodo di recupero dell'applicazione.

Osservazioni:

Il comportamento predefinito di questa funzione restituisce NULL.

Per altre informazioni, vedere CWinApp::ApplicationRecoveryCallback.

CWinApp::GetApplicationRecoveryPingInterval

Restituisce l'intervallo di tempo in cui il gestore di riavvio attende che venga restituita la funzione di callback di ripristino.

virtual DWORD GetApplicationRecoveryPingInterval();

Valore restituito

Intervallo di tempo in millisecondi.

Osservazioni:

Quando un'applicazione registrata con il gestore di riavvio viene chiusa in modo imprevisto, l'applicazione tenta di salvare documenti aperti e chiama la funzione di callback di ripristino. La funzione di callback di ripristino predefinita è CWinApp::ApplicationRecoveryCallback.

Il tempo di attesa del framework per la restituzione della funzione di callback di ripristino è l'intervallo di ping. È possibile personalizzare l'intervallo di ping eseguendo l'override CWinApp::GetApplicationRecoveryPingInterval o fornendo un valore personalizzato a RegisterWithRestartManager.

CWinApp::GetApplicationRestartFlags

Restituisce i flag per il gestore di riavvio.

virtual DWORD GetApplicationRestartFlags();

Valore restituito

Flag per il gestore di riavvio. L'implementazione predefinita restituisce 0.

Osservazioni:

I flag per il gestore di riavvio non hanno alcun effetto con l'implementazione predefinita. Vengono forniti per un uso futuro.

I flag vengono impostati quando si registra l'applicazione con il gestore di riavvio usando CWinApp::RegisterWithRestartManager.

I valori possibili per i flag di gestione di riavvio sono i seguenti:

• RESTART_NO_CRASH

• RESTART_NO_HANG

• RESTART_NO_PATCH

• RESTART_NO_REBOOT

CWinApp::GetAppRegistryKey

Restituisce la chiave per HKEY_CURRENT_Uedizione Standard R\"Software"\RegistryKey\ProfileName.

HKEY GetAppRegistryKey(CAtlTransactionManager* pTM = NULL);

Parametri

Ptm
Puntatore a un oggetto CAtlTransactionManager.

Valore restituito

Chiave dell'applicazione se la funzione ha esito positivo; in caso contrario NULL.

Osservazioni:

CWinApp::GetDataRecoveryHandler

Ottiene il gestore di recupero dati per questa istanza dell'applicazione.

virtual CDataRecoveryHandler *GetDataRecoveryHandler();

Valore restituito

Gestore di recupero dati per questa istanza dell'applicazione.

Osservazioni:

Ogni applicazione che usa il gestore di riavvio deve avere un'istanza della classe CDataRecoveryHandler. Questa classe è responsabile del monitoraggio dei documenti aperti e dei file di salvataggio automatico. Il comportamento di CDataRecoveryHandler dipende dalla configurazione del gestore di riavvio. Per altre informazioni, vedere Classe CDataRecoveryHandler.

Questo metodo restituisce NULL nei sistemi operativi precedenti a Windows Vista. Gestione riavvio non è supportato nei sistemi operativi precedenti a Windows Vista.

Se l'applicazione non dispone attualmente di un gestore di recupero dati, questo metodo ne crea uno e ne restituisce un puntatore.

CWinApp::GetFirstDocTemplatePosition

Ottiene la posizione del primo modello di documento nell'applicazione.

POSITION GetFirstDocTemplatePosition() const;

Valore restituito

Valore POSITION che può essere utilizzato per il recupero dell'iterazione o del puntatore a oggetti; NULL se l'elenco è vuoto.

Osservazioni:

Usare il valore POSITION restituito in una chiamata a GetNextDocTemplate per ottenere il primo oggetto CDocTemplate.

CWinApp::GetHelpMode

Recupera il tipo di Guida utilizzata dall'applicazione.

AFX_HELP_TYPE GetHelpMode();

Valore restituito

Tipo di guida usato dall'applicazione. Per altre informazioni, vedere CWinApp::m_eHelpType .

CWinApp::GetNextDocTemplate

Ottiene il modello di documento identificato da pos, quindi imposta pos sul valore POSITION.

CDocTemplate* GetNextDocTemplate(POSITION& pos) const;

Parametri

pos
Riferimento a un valore POSITION restituito da una chiamata precedente a GetNextDocTemplate o GetFirstDocTemplatePosition. Il valore viene aggiornato alla posizione successiva da questa chiamata.

Valore restituito

Puntatore a un oggetto CDocTemplate .

Osservazioni:

È possibile usare GetNextDocTemplate in un ciclo di iterazione in avanti se si stabilisce la posizione iniziale con una chiamata a GetFirstDocTemplatePosition.

È necessario assicurarsi che il valore POSITION sia valido. Se non è valido, la versione debug della libreria di classi Microsoft Foundation asserisce.

Se il modello di documento recuperato è l'ultimo disponibile, il nuovo valore di pos viene impostato su NULL.

CWinApp::GetPrinterDeviceDefaults

Chiamare questa funzione membro per preparare un contesto di dispositivo della stampante per la stampa.

BOOL GetPrinterDeviceDefaults(struct tagPDA* pPrintDlg);

Parametri

pPrintDlg
Puntatore a una struttura PRINTDLG .

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Recupera le impostazioni predefinite della stampante corrente da Windows. File INI in base alle esigenze o usa l'ultima configurazione della stampante impostata dall'utente in Programma di installazione di stampa.

Esempio

void CMyApp::SetLandscapeMode()
{
   PRINTDLG pd;
   pd.lStructSize = (DWORD)sizeof(PRINTDLG);
   BOOL bRet = GetPrinterDeviceDefaults(&pd);
   if (bRet)
   {
      // protect memory handle with ::GlobalLock and ::GlobalUnlock
      DEVMODE FAR *pDevMode = (DEVMODE FAR*)::GlobalLock(pd.hDevMode);
      // set orientation to landscape
      pDevMode->dmOrientation = DMORIENT_LANDSCAPE;
      ::GlobalUnlock(pd.hDevMode);
   }
}

CWinApp::GetProfileBinary

Chiamare questa funzione membro per recuperare i dati binari da una voce all'interno di una sezione specificata del Registro di sistema dell'applicazione o . File INI.

BOOL GetProfileBinary(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    LPBYTE* ppData,
    UINT* pBytes);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce.

lpszEntry
Punta a una stringa con terminazione null che contiene la voce il cui valore deve essere recuperato.

ppData
Punta a un puntatore che riceverà l'indirizzo dei dati.

pBytes
Punta a un oggetto UINT che riceverà le dimensioni dei dati (in byte).

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Questa funzione membro non fa distinzione tra maiuscole e minuscole, pertanto le stringhe nei parametri lpszSection e lpszEntry possono variare nel caso.

Nota

GetProfileBinary alloca un buffer e restituisce il relativo indirizzo in * ppData. Il chiamante è responsabile della liberazione del buffer tramite l'eliminazione [].

Importante

I dati restituiti dalla funzione non sono necessariamente con terminazione null e il chiamante deve eseguire la convalida. Per altre informazioni, vedere Evitare sovraccarichi del buffer.

Esempio

CWinApp* pApp = AfxGetApp();

const TCHAR* pszKey = _T("My Section");
struct complex {
  double re, im;
} myData = { 1.4142, -0.5 };

// Write the information to the registry.

pApp->WriteProfileBinary(pszKey, _T("ComplexData"), (LPBYTE)&myData, 
   sizeof(myData));

// Read the information from the registry.

complex* pData;
UINT n;
BOOL ret = pApp->GetProfileBinary(pszKey, _T("ComplexData"), (LPBYTE*)&pData, 
   &n);

ASSERT(ret);
ASSERT(n == sizeof(complex));
ASSERT(myData.re == pData->re);
ASSERT(myData.im == pData->im);
delete [] pData; // free the buffer

Per un esempio aggiuntivo, vedere CWinApp::WriteProfileBinary.

CWinApp::GetProfileInt

Chiamare questa funzione membro per recuperare il valore di un intero da una voce in una sezione specifica del Registro di sistema dell'applicazione o del file INI.

UINT GetProfileInt(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    int nDefault);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce.

lpszEntry
Punta a una stringa con terminazione null che contiene la voce il cui valore deve essere recuperato.

nDefault
Specifica il valore predefinito per restituire se il framework non riesce a trovare la voce.

Valore restituito

Valore intero della stringa che segue la voce specificata se la funzione ha esito positivo. Il valore restituito è il valore del parametro nDefault se la funzione non trova la voce. Il valore restituito è 0 se il valore che corrisponde alla voce specificata non è un intero.

Questa funzione supporta la notazione esadecimale per il valore nel file INI. Quando si recupera un intero con segno, è necessario eseguire il cast del valore in un oggetto int.

Osservazioni:

Questa funzione membro non fa distinzione tra maiuscole e minuscole, pertanto le stringhe nei parametri lpszSection e lpszEntry possono variare nel caso.

Importante

I dati restituiti dalla funzione non sono necessariamente con terminazione null e il chiamante deve eseguire la convalida. Per altre informazioni, vedere Evitare sovraccarichi del buffer.

Esempio

CWinApp *pApp = AfxGetApp();

const TCHAR *pszKey = _T("My Section");
const TCHAR *pszName = _T("Julian");
int iAge = 26;

// Write the information to the registry.

pApp->WriteProfileString(pszKey, _T("Name"), pszName);
pApp->WriteProfileInt(pszKey, _T("Age"), iAge);

// Read the information from the registry.

CString strName = pApp->GetProfileString(pszKey, _T("Name"));
int iAge2 = pApp->GetProfileInt(pszKey, _T("Age"), 0);

ASSERT(strName == pszName);
ASSERT(iAge2 == iAge);

Per un esempio aggiuntivo, vedere CWinApp::WriteProfileInt.

CWinApp::GetProfileString

Chiamare questa funzione membro per recuperare la stringa associata a una voce all'interno della sezione specificata nel Registro di sistema dell'applicazione o . File INI.

CString GetProfileString(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    LPCTSTR lpszDefault = NULL);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce.

lpszEntry
Punta a una stringa con terminazione Null contenente la voce la cui stringa deve essere recuperata. Questo valore non deve essere NULL.

lpszDefault
Punta al valore stringa predefinito per la voce specificata se non è possibile trovare la voce nel file di inizializzazione.

Valore restituito

Il valore restituito è la stringa dell'oggetto dell'applicazione. File INI o lpszDefault se non è possibile trovare la stringa. La lunghezza massima della stringa supportata dal framework è _MAX_PATH. Se lpszDefault è NULL, il valore restituito è una stringa vuota.

Osservazioni:

Importante

I dati restituiti dalla funzione non sono necessariamente con terminazione null e il chiamante deve eseguire la convalida. Per altre informazioni, vedere Evitare sovraccarichi del buffer.

Esempio

CWinApp *pApp = AfxGetApp();

CString strSection = _T("My Section");
CString strStringItem = _T("My String Item");
CString strIntItem = _T("My Int Item");

pApp->WriteProfileString(strSection, strStringItem, _T("test"));

CString strValue;
strValue = pApp->GetProfileString(strSection, strStringItem);
ASSERT(strValue == _T("test"));

pApp->WriteProfileInt(strSection, strIntItem, 1234);

int nValue;
nValue = pApp->GetProfileInt(strSection, strIntItem, 0);
ASSERT(nValue == 1234);

Per un altro esempio, vedere l'esempio per CWinApp::GetProfileInt.

CWinApp::GetSectionKey

Restituisce la chiave per HKEY_CURRENT_Uedizione Standard R\"Software"\RegistryKey\AppName\lpszSection.

HKEY GetSectionKey(
    LPCTSTR lpszSection,
    CAtlTransactionManager* pTM = NULL);

Parametri

lpszSection
Nome della chiave da ottenere.

Ptm
Puntatore a un oggetto CAtlTransactionManager.

Valore restituito

Tasto sezione se la funzione ha esito positivo; in caso contrario NULL.

Osservazioni:

CWinApp::HideApplication

Chiamare questa funzione membro per nascondere un'applicazione prima di chiudere i documenti aperti.

void HideApplication();

CWinApp::HtmlHelp

Chiamare questa funzione membro per richiamare l'applicazione HTMLHelp.

virtual void HtmlHelp(
    DWORD_PTR dwData,
    UINT nCmd = 0x000F);

Parametri

dwData
Specifica dati aggiuntivi. Il valore usato dipende dal valore del parametro nCmd . Il valore predefinito è 0x000FHH_HELP_CONTEXT.

nCmd
Specifica il tipo di Guida richiesto. Per un elenco dei valori possibili e di come influiscono sul parametro dwData, vedere il parametro uCommand descritto nelle funzioni API HtmlHelpW o HtmlHelpA in Windows SDK.

Osservazioni:

Il framework chiama anche questa funzione per richiamare l'applicazione HTMLHelp.

Il framework chiuderà automaticamente l'applicazione HTMLHelp al termine dell'applicazione.

CWinApp::InitInstance

Windows consente l'esecuzione contemporaneamente di più copie dello stesso programma.

virtual BOOL InitInstance();

Valore restituito

Diverso da zero se l'inizializzazione ha esito positivo; in caso contrario, 0.

Osservazioni:

L'inizializzazione dell'applicazione è concettualmente divisa in due sezioni: l'inizializzazione monouso dell'applicazione che viene eseguita la prima volta che il programma viene eseguito e l'inizializzazione dell'istanza che viene eseguita ogni volta che viene eseguita una copia del programma, inclusa la prima volta. L'implementazione del framework di WinMain chiama questa funzione.

Eseguire l'override InitInstance per inizializzare ogni nuova istanza dell'applicazione in esecuzione in Windows. In genere, si esegue l'override InitInstance per costruire l'oggetto finestra principale e impostare il CWinThread::m_pMainWnd membro dati in modo che punti a tale finestra. Per altre informazioni sull'override di questa funzione membro, vedere CWinApp: The Application Class.For more information on overriding this member function, see CWinApp: The Application Class.

Nota

Le applicazioni MFC devono essere inizializzate come apartment a thread singolo (STA). Se si chiama CoInitializeEx nell'override InitInstance , specificare COINIT_APARTMENTTHREADED anziché COINIT_MULTITHREADED.

Esempio

// AppWizard implements the InitInstance overridable function 
// according to options you select.  For example, the multiple document
// interface (MDI) option was chosen for the AppWizard code created
// below. You can add other per-instance initializations to the code
// created by AppWizard.

BOOL CMFCListViewApp::InitInstance()
{
   AfxSetAmbientActCtx(FALSE);
   // Remainder of function definition omitted.

   CWinApp::InitInstance();

   // Initialize OLE libraries
   if (!AfxOleInit())
   {
      AfxMessageBox(_T("OleInit failed."));
      return FALSE;
   }

   // Standard initialization
   // If you are not using these features and wish to reduce the size
   // of your final executable, you should remove from the following
   // the specific initialization routines you do not need
   // Change the registry key under which our settings are stored
   // TODO: You should modify this string to be something appropriate
   // such as the name of your company or organization
   SetRegistryKey(_T("Local AppWizard-Generated Applications"));
   LoadStdProfileSettings(4);  // Load standard INI file options (including MRU)
   // Register the application's document templates.  Document templates
   //  serve as the connection between documents, frame windows and views
   CMultiDocTemplate* pDocTemplate;
   pDocTemplate = new CMultiDocTemplate(IDR_MFCListViewTYPE,
      RUNTIME_CLASS(CMFCListViewDoc),
      RUNTIME_CLASS(CChildFrame), // custom MDI child frame
      RUNTIME_CLASS(CMyListView));
   if (!pDocTemplate)
      return FALSE;
   AddDocTemplate(pDocTemplate);

   // create main MDI Frame window
   CMainFrame* pMainFrame = new CMainFrame;
   if (!pMainFrame || !pMainFrame->LoadFrame(IDR_MAINFRAME))
   {
      delete pMainFrame;
      return FALSE;
   }
   m_pMainWnd = pMainFrame;
   // call DragAcceptFiles only if there's a suffix
   //  In an MDI app, this should occur immediately after setting m_pMainWnd


   // Parse command line for standard shell commands, DDE, file open
   CCommandLineInfo cmdInfo;
   ParseCommandLine(cmdInfo);


   // Dispatch commands specified on the command line.  Will return FALSE if
   // app was launched with /RegServer, /Register, /Unregserver or /Unregister.
   if (!ProcessShellCommand(cmdInfo))
      return FALSE;
   // The main window has been initialized, so show and update it
   pMainFrame->ShowWindow(m_nCmdShow);
   pMainFrame->UpdateWindow();

   return TRUE;
}

CWinApp::IsTaskbarInteractionEnabled

Indica se l'interazione della barra delle applicazioni di Windows 7 è abilitata.

virtual BOOL IsTaskbarInteractionEnabled();

Valore restituito

Restituisce TRUE se EnableTaskbarInteraction è stato chiamato e il sistema operativo è Windows 7 o versione successiva.

Osservazioni:

L'interazione della barra delle applicazioni indica che l'applicazione MDI visualizza il contenuto degli elementi figlio MDI in anteprime a schede separate visualizzate quando il puntatore del mouse si trova sul pulsante della barra delle applicazioni.

CWinApp::LoadCursor

Carica la risorsa cursore denominata da lpszResourceName o specificata da nIDResource dal file eseguibile corrente.

HCURSOR LoadCursor(LPCTSTR lpszResourceName) const;  HCURSOR LoadCursor(UINT nIDResource) const;

Parametri

lpszResourceName
Punta a una stringa con terminazione Null contenente il nome della risorsa cursore. È possibile utilizzare un CString oggetto per questo argomento.

nIDResource
ID della risorsa cursore. Per un elenco delle risorse, vedere LoadCursor in Windows SDK.

Valore restituito

Handle a un cursore se ha esito positivo; in caso contrario NULL.

Osservazioni:

LoadCursor carica il cursore in memoria solo se non è stato caricato in precedenza; in caso contrario, recupera un handle della risorsa esistente.

Usare la funzione membro LoadStandardCursor o LoadOEMCursor per accedere ai cursori di Windows predefiniti.

Esempio

HCURSOR hCursor;

// Load a cursor resource that was originally created using
// the Graphics Editor and assigned the i.d. IDC_MYCURSOR.
hCursor = AfxGetApp()->LoadCursor(IDC_MYCURSOR);

CWinApp::LoadIcon

Carica la risorsa icona denominata da lpszResourceName o specificata da nIDResource dal file eseguibile.

HICON LoadIcon(LPCTSTR lpszResourceName) const;  HICON LoadIcon(UINT nIDResource) const;

Parametri

lpszResourceName
Punta a una stringa con terminazione Null contenente il nome della risorsa icona. È anche possibile utilizzare un CString oggetto per questo argomento.

nIDResource
Numero ID della risorsa icona.

Valore restituito

Handle di un'icona se l'operazione riesce; in caso contrario NULL.

Osservazioni:

LoadIcon carica l'icona solo se non è stata caricata in precedenza; in caso contrario, recupera un handle della risorsa esistente.

È possibile usare la funzione membro LoadStandardIcon o LoadOEMIcon per accedere alle icone di Windows predefinite.

Nota

Questa funzione membro chiama la funzione API Win32 LoadIcon, che può caricare solo un'icona le cui dimensioni sono conformi ai valori delle metriche di sistema SM_CXICON e SM_CYICON.

CWinApp::LoadOEMCursor

Carica la risorsa cursore predefinita di Windows specificata da nIDCursor.

HCURSOR LoadOEMCursor(UINT nIDCursor) const;

Parametri

nIDCursor
Identificatore di costante manifesto OCR_ che specifica un cursore di Windows predefinito. È necessario avere #define OEMRESOURCE prima #include \<afxwin.h> di ottenere l'accesso alle costanti OCR_ in WINDOWS.H.

Valore restituito

Handle a un cursore se ha esito positivo; in caso contrario NULL.

Osservazioni:

Usare la LoadOEMCursor funzione membro o LoadStandardCursor per accedere ai cursori di Windows predefiniti.

Esempio

// In the stdafx.h file, add #define OEMRESOURCE to
// include the windows.h definitions of OCR_ values.
#define OEMRESOURCE
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions

 

HCURSOR hCursor;
// Load the predefined WIndows "size all" cursor.
hCursor = AfxGetApp()->LoadOEMCursor(OCR_SIZEALL);

CWinApp::LoadOEMIcon

Carica la risorsa icona predefinita di Windows specificata da nIDIcon.

HICON LoadOEMIcon(UINT nIDIcon) const;

Parametri

nIDIcon
Identificatore di costante manifesto OIC_ che specifica un'icona di Windows predefinita. È necessario avere #define OEMRESOURCE prima #include \<afxwin.h> di accedere alle costanti OIC_ in WINDOWS.H.

Valore restituito

Handle di un'icona se l'operazione riesce; in caso contrario NULL.

Osservazioni:

Usare la LoadOEMIcon funzione membro o LoadStandardIcon per accedere alle icone di Windows predefinite.

CWinApp::LoadStandardCursor

Carica la risorsa cursore predefinita di Windows specificata da lpszCursorName .

HCURSOR LoadStandardCursor(LPCTSTR lpszCursorName) const;

Parametri

lpszCursorName
Identificatore di costante manifesto IDC_ che specifica un cursore di Windows predefinito. Questi identificatori sono definiti in WINDOWS.H. L'elenco seguente mostra i possibili valori e significati predefiniti per lpszCursorName:

• IDC_ARROW cursore freccia Standard

• IDC_IBEAM cursore standard di inserimento del testo

• IDC_WAIT cursore Clessidra usato quando Windows esegue un'attività dispendiosa in termini di tempo

• IDC_CROSS cursore tra capelli per la selezione

• IDC_UPARROW Freccia che punta dritto verso l'alto

• IDC_SIZE obsoleto e non supportato; usare IDC_SIZEALL

• IDC_SIZEALL Freccia a quattro punte. Cursore da utilizzare per ridimensionare una finestra.

• IDC_ICON Obsoleto e non supportato. Usare IDC_ARROW.

• IDC_SIZENWedizione Standard freccia a due punte con estremità in alto a sinistra e in basso a destra

• IDC_SIZENESW freccia a due punte con estremità in alto a destra e in basso a sinistra

• IDC_SIZEWE freccia a due punte orizzontali

• IDC_SIZENS freccia verticale a due punte

Valore restituito

Handle a un cursore se ha esito positivo; in caso contrario NULL.

Osservazioni:

Utilizzare la LoadStandardCursor funzione membro o LoadOEMCursor per accedere ai cursori di Windows predefiniti.

Esempio

HCURSOR hCursor;

// Load the predefined Windows "up arrow" cursor.
hCursor = AfxGetApp()->LoadStandardCursor(IDC_UPARROW);

CWinApp::LoadStandardIcon

Carica la risorsa icona predefinita di Windows specificata da lpszIconName .

HICON LoadStandardIcon(LPCTSTR lpszIconName) const;

Parametri

lpszIconName
Identificatore costante del manifesto che specifica un'icona di Windows predefinita. Questi identificatori sono definiti in WINDOWS.H. Per un elenco dei possibili valori predefiniti e delle relative descrizioni, vedere il parametro lpIconName in LoadIcon in Windows SDK.

Valore restituito

Handle di un'icona se l'operazione riesce; in caso contrario NULL.

Osservazioni:

Usare la LoadStandardIcon funzione membro o LoadOEMIcon per accedere alle icone di Windows predefinite.

CWinApp::LoadStdProfile Impostazioni

Chiamare questa funzione membro dall'interno della funzione membro InitInstance per abilitare e caricare l'elenco dei file usati più di recente (MRU) e dell'ultimo stato di anteprima.

void LoadStdProfileSettings(UINT nMaxMRU = _AFX_MRU_COUNT);

Parametri

nMaxMRU
Numero di file usati di recente da tenere traccia.

Osservazioni:

Se nMaxMRU è 0, non verrà mantenuto alcun elenco MRU.

CWinApp::m_bHelpMode

TRUE se l'applicazione è in modalità contesto della Guida (richiamata convenzionalmente con MAIUSC + F1); altrimenti FAL edizione Standard.

BOOL m_bHelpMode;

Osservazioni:

In modalità contesto della Guida, il cursore diventa un punto interrogativo e l'utente può spostarlo sullo schermo. Esaminare questo flag se si vuole implementare una gestione speciale quando si usa la modalità Guida. m_bHelpMode è una variabile pubblica di tipo BOOL.

CWinApp::m_dwRestartManagerSupportFlags

Flag che determinano il comportamento del gestore di riavvio.

DWORD m_dwRestartManagerSupportFlags;

Osservazioni:

Per abilitare gestione riavvio, impostare m_dwRestartManagerSupportFlags sul comportamento desiderato. Nella tabella seguente vengono illustrati i flag disponibili.

Contrassegno	Descrizione
AFX_RESTART_MANAGER_SUPPORT_RESTART	L'applicazione viene registrata usando CWinApp::RegisterWithRestartManager. Il gestore di riavvio è responsabile del riavvio dell'applicazione se si chiude in modo imprevisto.
- AFX_RESTART_MANAGER_SUPPORT_RECOVERY	L'applicazione viene registrata con il gestore di riavvio e il gestore di riavvio chiama la funzione di callback di ripristino quando riavvia l'applicazione. La funzione di callback di ripristino predefinita è CWinApp::ApplicationRecoveryCallback.
- AFX_RESTART_MANAGER_AUTOSAVE_AT_RESTART	Il salvataggio automatico è abilitato e il gestore di riavvio aggiorna automaticamente tutti i documenti aperti al riavvio dell'applicazione.
- AFX_RESTART_MANAGER_AUTOSAVE_AT_INTERVAL	Il salvataggio automatico è abilitato e il gestore di riavvio aggiorna automaticamente tutti i documenti aperti a intervalli regolari. L'intervallo è definito da CWinApp::m_nAutosaveInterval.
- AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES	Il gestore di riavvio apre documenti aperti in precedenza dopo il riavvio dell'applicazione da un'uscita imprevista. La classe CDataRecoveryHandler gestisce l'archiviazione dell'elenco di documenti aperti e il ripristino.
- AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES	Il gestore di riavvio richiede all'utente di ripristinare i file salvati automaticamente dopo il riavvio dell'applicazione. La CDataRecoveryHandler classe esegue una query sull'utente.
- AFX_RESTART_MANAGER_SUPPORT_NO_AUTOSAVE	Unione di AFX_RESTART_MANAGER_SUPPORT_RESTART, AFX_RESTART_MANAGER_SUPPORT_RECOVER e AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES.
- AFX_RESTART_MANAGER_SUPPORT_ALL_ASPECTS	Unione di AFX_RESTART_MANAGER_SUPPORT_NO_AUTOSAVE, AFX_RESTART_MANAGER_AUTOSAVE_AT_RESTART, AFX_RESTART_MANAGER_AUTOSAVE_AT_INTERVAL e AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES.
- AFX_RESTART_MANAGER_SUPPORT_RESTART_ASPECTS	Unione di AFX_RESTART_MANAGER_SUPPORT_RESTART, AFX_RESTART_MANAGER_AUTOSAVE_AT_RESTART, AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES e AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES.
- AFX_RESTART_MANAGER_SUPPORT_RECOVERY_ASPECTS	L'unione ofAFX_RESTART_MANAGER_SUPPORT_RECOVERY, AFX_RESTART_MANAGER_AUTOSAVE_AT_INTERVAL, AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES e AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES.

CWinApp::m_eHelpType

Il tipo di questo membro dati è il tipo enumerato AFX_HELP_TYPE, definito all'interno della CWinApp classe .

AFX_HELP_TYPE m_eHelpType;

Osservazioni:

L'enumerazione AFX_HELP_TYPE è definita come segue:

enum AFX_HELP_TYPE {
    afxWinHelp = 0,
    afxHTMLHelp = 1
    };

• Per impostare la Guida dell'applicazione su Guida HTML, chiamare SetHelpMode e specificare afxHTMLHelp.

• Per impostare la Guida dell'applicazione su WinHelp, chiamare SetHelpMode e specificare afxWinHelp.

CWinApp::m_hInstance

Corrisponde al parametro hInstance passato da Windows a WinMain.

HINSTANCE m_hInstance;

Osservazioni:

Il m_hInstance membro dati è un handle per l'istanza corrente dell'applicazione in esecuzione in Windows. Viene restituito dalla funzione globale AfxGetInstanceHandle. m_hInstance è una variabile pubblica di tipo HINSTANCE.

Esempio

// Typically you do not need to pass the application's hInstance
// to Windows APIs directly because there are equivalent MFC
// member functions that pass the hInstance for you.  The following
// example is not typical:

HCURSOR hCursor;
hCursor = ::LoadCursor(AfxGetApp()->m_hInstance, 
   MAKEINTRESOURCE(IDC_MYCURSOR));

// A more direct way to get the application's hInstance is to
// call AfxGetInstanceHandle:
hCursor = ::LoadCursor(AfxGetInstanceHandle(), 
   MAKEINTRESOURCE(IDC_MYCURSOR));

// If you need the hInstance to load a resource, it is better
// to call AfxGetResourceHandle instead of AfxGetInstanceHandle:
hCursor = ::LoadCursor(AfxGetResourceHandle(), 
   MAKEINTRESOURCE(IDC_MYCURSOR));

// A better way to load the cursor resource is to call
// CWinApp::LoadCursor
hCursor = AfxGetApp()->LoadCursor(IDC_MYCURSOR);

CWinApp::m_lpCmdLine

Corrisponde al parametro lpCmdLine passato da Windows a WinMain.

LPTSTR m_lpCmdLine;

Osservazioni:

Punta a una stringa con terminazione Null che specifica la riga di comando per l'applicazione. Usare m_lpCmdLine per accedere a qualsiasi argomento della riga di comando immesso dall'utente all'avvio dell'applicazione. m_lpCmdLine è una variabile pubblica di tipo LPTSTR.

Esempio

if (m_lpCmdLine[0] == _T('\0'))
{
   // Create a new (empty) document.
   OnFileNew();
}
else
{
   // Open a file passed as the first command line parameter.
   OpenDocumentFile(m_lpCmdLine);
}

CWinApp::m_nAutosaveInterval

Intervallo di tempo in millisecondi tra le operazioni di intercettazione automatica.

int m_nAutosaveInterval;

Osservazioni:

È possibile configurare gestione riavvio per salvare automaticamente i documenti aperti a intervalli impostati. Se l'applicazione non salva automaticamente i file, questo parametro non ha alcun effetto.

CWinApp::m_nCmdShow

Corrisponde al parametro nCmdShow passato da Windows a WinMain.

int m_nCmdShow;

Osservazioni:

È consigliabile passare m_nCmdShow come argomento quando si chiama CWnd::ShowWindow per la finestra principale dell'applicazione. m_nCmdShow è una variabile pubblica di tipo int.

Esempio

// The following code fragment is taken from CMyApp::InitInstance.
// CMyApp is derived from CWinApp.

// The main window has been initialized, so show and update it
// using the nCmdShow parameter passed to the application when it
// was first launched.
// pMainFrame is the main MDI frame window of our app and is derived
// from CMDIFrameWnd.
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();

CWinApp::m_pActiveWnd

Utilizzare questo membro dati per archiviare un puntatore alla finestra principale dell'applicazione contenitore OLE con l'applicazione server OLE attivata sul posto.

Osservazioni:

Se questo membro dati è NULL, l'applicazione non è attiva sul posto.

Il framework imposta questa variabile membro quando la finestra cornice è attivata sul posto da un'applicazione contenitore OLE.

CWinApp::m_pDataRecoveryHandler

Puntatore al gestore di recupero dati per l'applicazione.

CDataRecoveryHandler* m_pDataRecoveryHandler;

Osservazioni:

Il gestore di recupero dati di un'applicazione monitora i documenti aperti e li aggiorna automaticamente. Il framework usa il gestore di recupero dati per ripristinare i file salvati automaticamente quando un'applicazione viene riavviata dopo la chiusura imprevista. Per altre informazioni, vedere Classe CDataRecoveryHandler.

CWinApp::m_pszAppName

Specifica il nome dell'applicazione.

LPCTSTR m_pszAppName;

Osservazioni:

Il nome dell'applicazione può provenire dal parametro passato al costruttore CWinApp o, se non specificato, alla stringa di risorsa con l'ID di AFX_IDS_APP_TITLE. Se il nome dell'applicazione non viene trovato nella risorsa, proviene dal nome file EXE del programma.

Restituito dalla funzione globale AfxGetAppName. m_pszAppName è una variabile pubblica di tipo const char*.

Nota

Se si assegna un valore a m_pszAppName, deve essere allocato dinamicamente nell'heap. Il CWinApp distruttore chiama free( ) con questo puntatore. Si vuole usare la funzione della _tcsduplibreria di runtime ( ) per eseguire l'allocazione. Liberare inoltre la memoria associata al puntatore corrente prima di assegnare un nuovo valore. Ad esempio:

//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszAppName);
//Change the name of the application file.
//The CWinApp destructor will free the memory.
m_pszAppName = _tcsdup(_T("c:\\somedir\\myapp.exe"));

Esempio

CWnd *pWnd = AfxGetMainWnd();
// Set pWnd to some CWnd object whose window has already
// been created.

// The following call to CWnd::MessageBox uses the application
// title as the message box caption.
pWnd->MessageBox(_T("Some message"), AfxGetApp()->m_pszAppName);

// A more direct way to get the application title is to
// call AfxGetAppName:
pWnd->MessageBox(_T("Some message"), AfxGetAppName());

// An easier way to display a message box using the application
// title as the message box caption is to call AfxMessageBox:
AfxMessageBox(_T("Some message"));

CWinApp::m_pszExeName

Contiene il nome del file eseguibile dell'applicazione senza estensione.

LPCTSTR m_pszExeName;

Osservazioni:

A differenza di m_pszAppName, questo nome non può contenere spazi vuoti. m_pszExeName è una variabile pubblica di tipo const char*.

Nota

Se si assegna un valore a m_pszExeName, deve essere allocato dinamicamente nell'heap. Il CWinApp distruttore chiama free( ) con questo puntatore. Si vuole usare la funzione della _tcsduplibreria di runtime ( ) per eseguire l'allocazione. Liberare inoltre la memoria associata al puntatore corrente prima di assegnare un nuovo valore. Ad esempio:

//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszExeName);
//Change the name of the .EXE file.
//The CWinApp destructor will free the memory.
m_pszExeName = _tcsdup(_T("c:\\somedir\\myapp"));

CWinApp::m_pszHelpFilePath

Contiene il percorso del file della Guida dell'applicazione.

LPCTSTR m_pszHelpFilePath;

Osservazioni:

Per impostazione predefinita, il framework inizializza m_pszHelpFilePath il nome dell'applicazione con ". HLP" aggiunto. Per modificare il nome del file della Guida, impostare m_pszHelpFilePath in modo che punti a una stringa contenente il nome completo del file della Guida desiderato. Una posizione comoda per eseguire questa operazione si trova nella funzione InitInstance dell'applicazione. m_pszHelpFilePath è una variabile pubblica di tipo const char*.

Nota

Se si assegna un valore a m_pszHelpFilePath, deve essere allocato dinamicamente nell'heap. Il CWinApp distruttore chiama free( ) con questo puntatore. Si vuole usare la funzione della _tcsduplibreria di runtime ( ) per eseguire l'allocazione. Liberare inoltre la memoria associata al puntatore corrente prima di assegnare un nuovo valore. Ad esempio:

//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszHelpFilePath);
//Change the name of the .HLP file.
//The CWinApp destructor will free the memory.
m_pszHelpFilePath = _tcsdup(_T("c:\\somedir\\myhelp.hlp"));

CWinApp::m_pszProfileName

Contiene il nome dell'oggetto dell'applicazione. File INI.

LPCTSTR m_pszProfileName;

Osservazioni:

m_pszProfileName è una variabile pubblica di tipo const char*.

Nota

Se si assegna un valore a m_pszProfileName, deve essere allocato dinamicamente nell'heap. Il CWinApp distruttore chiama free( ) con questo puntatore. Si vuole usare la funzione della _tcsduplibreria di runtime ( ) per eseguire l'allocazione. Liberare inoltre la memoria associata al puntatore corrente prima di assegnare un nuovo valore. Ad esempio:

//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszProfileName);
//Change the name of the .INI file.
//The CWinApp destructor will free the memory.
m_pszProfileName = _tcsdup(_T("c:\\somedir\\myini.ini"));

CWinApp::m_pszRegistryKey

Usato per determinare dove, nel registro o nel file INI, vengono archiviate le impostazioni del profilo applicazione.

LPCTSTR m_pszRegistryKey;

Osservazioni:

In genere, questo membro dati viene considerato di sola lettura.

• Il valore viene archiviato in una chiave del Registro di sistema. Il nome dell'impostazione del profilo applicazione viene aggiunto alla chiave del Registro di sistema seguente: HKEY_CURRENT_Uedizione Standard R/Software/LocalAppWizard-Generated/.

Se si assegna un valore a m_pszRegistryKey, deve essere allocato dinamicamente nell'heap. Il CWinApp distruttore chiama free( ) con questo puntatore. Si vuole usare la funzione della _tcsduplibreria di runtime ( ) per eseguire l'allocazione. Liberare inoltre la memoria associata al puntatore corrente prima di assegnare un nuovo valore. Ad esempio:

//First free the string allocated by MFC at CWinApp startup.
//The string is allocated before InitInstance is called.
free((void*)m_pszRegistryKey);
//Change the name of the registry key.
//The CWinApp destructor will free the memory.
m_pszRegistryKey = _tcsdup(
    _T("HKEY_CURRENT_USER\\Software\\mycompany\\myapp\\thissection\\thisvalue"));

CWinApp::m_pszAppID

ID modello utente applicazione.

LPCTSTR m_pszAppID;

Osservazioni:

CWinApp::OnContextHelp

Gestisce la Guida MAIUSC+F1 all'interno dell'applicazione.

afx_msg void OnContextHelp();

Osservazioni:

Per abilitare questa funzione membro, è necessario aggiungere un'istruzione ON_COMMAND( ID_CONTEXT_HELP, OnContextHelp ) alla CWinApp mappa messaggi della classe e aggiungere anche una voce di tabella dell'acceleratore, in genere MAIUSC+F1.

OnContextHelp inserisce l'applicazione in modalità Guida. Il cursore passa a una freccia e a un punto interrogativo e l'utente può quindi spostare il puntatore del mouse e premere il pulsante sinistro del mouse per selezionare una finestra di dialogo, una finestra, un menu o un pulsante di comando. Questa funzione membro recupera il contesto della Guida dell'oggetto sotto il cursore e chiama la funzione Windows WinHelp con tale contesto della Guida.

CWinApp::OnDDECommand

Chiamato dal framework quando la finestra cornice principale riceve un messaggio di esecuzione DDE.

virtual BOOL OnDDECommand(LPTSTR lpszCommand);

Parametri

lpszCommand
Punta a una stringa di comando DDE ricevuta dall'applicazione.

Valore restituito

Diverso da zero se il comando viene gestito; in caso contrario, 0.

Osservazioni:

L'implementazione predefinita controlla se il comando è una richiesta per aprire un documento e, in tal caso, apre il documento specificato. Gestione file di Windows invia in genere tali stringhe di comando DDE quando l'utente fa doppio clic su un file di dati. Eseguire l'override di questa funzione per gestire altri comandi DDE, ad esempio il comando da stampare.

Esempio

BOOL CMyApp::OnDDECommand(LPTSTR lpszCommand)
{
   if (CWinApp::OnDDECommand(lpszCommand))
      return TRUE;

   // Handle any DDE commands recognized by your application
   // and return TRUE.  See implementation of CWinApp::OnDDEComand
   // for example of parsing the DDE command string.

   // Return FALSE for any DDE commands you do not handle.
   return FALSE;
}

CWinApp::OnFileNew

Implementa il comando ID_FILE_NEW.

afx_msg void OnFileNew();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_FILE_NEW, OnFileNew ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitata, questa funzione gestisce l'esecuzione del comando File New.

Per informazioni sul comportamento predefinito e indicazioni su come eseguire l'override di questa funzione membro, vedere La nota tecnica 22 .

Esempio

// The following message map, produced by the Application Wizard, binds
// the File New, Open, and Print Setup menu commands to default
// framework implementations of these commands.
BEGIN_MESSAGE_MAP(CStdApp, CWinApp)
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, &CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, &CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()

 

// The following message map illustrates how to rebind the
// File New, Open and Print Setup menu commands to handlers that
// you implement in your CWinApp-derived class.
// Note, you can name the handler CCustomApp::OnFileNew instead of
// CCustomApp::OnMyFileNew, and likewise for the other handlers, if desired.
BEGIN_MESSAGE_MAP(CCustomApp, CWinApp)
ON_COMMAND(ID_FILE_NEW, &CCustomApp::OnMyFileNew)
ON_COMMAND(ID_FILE_OPEN, &CCustomApp::OnMyFileOpen)
ON_COMMAND(ID_FILE_PRINT_SETUP, &CCustomApp::OnMyFilePrintSetup)
END_MESSAGE_MAP()

CWinApp::OnFileOpen

Implementa il comando ID_FILE_OPEN.

afx_msg void OnFileOpen();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_FILE_OPEN, OnFileOpen ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitata, questa funzione gestisce l'esecuzione del comando File Open.

Per informazioni sul comportamento predefinito e indicazioni su come eseguire l'override di questa funzione membro, vedere La nota tecnica 22.

Esempio

// The following message map, produced by the Application Wizard, binds
// the File New, Open, and Print Setup menu commands to default
// framework implementations of these commands.
BEGIN_MESSAGE_MAP(CStdApp, CWinApp)
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, &CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, &CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()

 

// The following message map illustrates how to rebind the
// File New, Open and Print Setup menu commands to handlers that
// you implement in your CWinApp-derived class.
// Note, you can name the handler CCustomApp::OnFileNew instead of
// CCustomApp::OnMyFileNew, and likewise for the other handlers, if desired.
BEGIN_MESSAGE_MAP(CCustomApp, CWinApp)
ON_COMMAND(ID_FILE_NEW, &CCustomApp::OnMyFileNew)
ON_COMMAND(ID_FILE_OPEN, &CCustomApp::OnMyFileOpen)
ON_COMMAND(ID_FILE_PRINT_SETUP, &CCustomApp::OnMyFilePrintSetup)
END_MESSAGE_MAP()

CWinApp::OnFilePrintSetup

Implementa il comando ID_FILE_PRINT_edizione Standard TUP.

afx_msg void OnFilePrintSetup();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_FILE_PRINT_SETUP, OnFilePrintSetup ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitata, questa funzione gestisce l'esecuzione del comando Stampa file.

Per informazioni sul comportamento predefinito e indicazioni su come eseguire l'override di questa funzione membro, vedere La nota tecnica 22.

Esempio

// The following message map, produced by the Application Wizard, binds
// the File New, Open, and Print Setup menu commands to default
// framework implementations of these commands.
BEGIN_MESSAGE_MAP(CStdApp, CWinApp)
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, &CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, &CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, &CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()

 

// The following message map illustrates how to rebind the
// File New, Open and Print Setup menu commands to handlers that
// you implement in your CWinApp-derived class.
// Note, you can name the handler CCustomApp::OnFileNew instead of
// CCustomApp::OnMyFileNew, and likewise for the other handlers, if desired.
BEGIN_MESSAGE_MAP(CCustomApp, CWinApp)
ON_COMMAND(ID_FILE_NEW, &CCustomApp::OnMyFileNew)
ON_COMMAND(ID_FILE_OPEN, &CCustomApp::OnMyFileOpen)
ON_COMMAND(ID_FILE_PRINT_SETUP, &CCustomApp::OnMyFilePrintSetup)
END_MESSAGE_MAP()

CWinApp::OnHelp

Gestisce F1 Guida all'interno dell'applicazione (usando il contesto corrente).

afx_msg void OnHelp();

Osservazioni:

In genere si aggiungerà anche una voce di tasto di scelta rapida per il tasto F1. L'abilitazione della chiave F1 è solo una convenzione, non un requisito.

È necessario aggiungere un'istruzione ON_COMMAND( ID_HELP, OnHelp ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitato, chiamato dal framework quando l'utente preme il tasto F1.

L'implementazione predefinita di questa funzione del gestore messaggi determina il contesto della Guida che corrisponde alla finestra corrente, alla finestra di dialogo o alla voce di menu e quindi chiama WINHELP.EXE. Se non è attualmente disponibile alcun contesto, la funzione usa il contesto predefinito.

Eseguire l'override di questa funzione membro per impostare il contesto della Guida su un valore diverso da quello della finestra, della finestra di dialogo, della voce di menu o del pulsante della barra degli strumenti con lo stato attivo. Chiamare WinHelp con l'ID contesto della Guida desiderato.

CWinApp::OnHelpFinder

Gestisce i comandi ID_HELP_FINDER e ID_DEFAULT_HELP.

afx_msg void OnHelpFinder();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_HELP_FINDER, OnHelpFinder ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitato, il framework chiama questa funzione del gestore messaggi quando l'utente dell'applicazione seleziona il comando Help Finder da richiamare WinHelp con l'argomento standard HELP_FINDER .

CWinApp::OnHelpIndex

Gestisce il comando ID_HELP_INDEX e fornisce un argomento della Guida predefinito.

afx_msg void OnHelpIndex();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_HELP_INDEX, OnHelpIndex ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Se abilitato, il framework chiama questa funzione del gestore messaggi quando l'utente dell'applicazione seleziona il comando Indice della Guida da richiamare WinHelp con l'argomento standard HELP_INDEX .

CWinApp::OnHelpUsing

Gestisce il comando ID_HELP_USING.

afx_msg void OnHelpUsing();

Osservazioni:

È necessario aggiungere un'istruzione ON_COMMAND( ID_HELP_USING, OnHelpUsing ) al mapping dei messaggi della CWinApp classe per abilitare questa funzione membro. Il framework chiama questa funzione del gestore di messaggi quando l'utente dell'applicazione seleziona il comando Help Using per richiamare l'applicazione WinHelp con l'argomento standard HELP_HELPONHELP .

CWinApp::OnIdle

Eseguire l'override di questa funzione membro per eseguire l'elaborazione inattiva.

virtual BOOL OnIdle(LONG lCount);

Parametri

lCount
Un contatore incrementato ogni volta OnIdle che viene chiamato quando la coda dei messaggi dell'applicazione è vuota. Questo conteggio viene reimpostato su 0 ogni volta che viene elaborato un nuovo messaggio. È possibile usare il parametro lCount per determinare la durata relativa dell'inattività dell'applicazione senza elaborare un messaggio.

Valore restituito

Diverso da zero per ricevere più tempo di elaborazione inattiva; 0 se non è necessario più tempo di inattività.

Osservazioni:

OnIdle viene chiamato nel ciclo di messaggi predefinito quando la coda di messaggi dell'applicazione è vuota. Usare l'override per chiamare le attività del gestore inattivo in background.

OnIdle deve restituire 0 per indicare che non è necessario alcun tempo di elaborazione inattiva. Il parametro lCount viene incrementato ogni volta OnIdle che viene chiamato quando la coda dei messaggi è vuota e reimposta su 0 ogni volta che viene elaborato un nuovo messaggio. È possibile chiamare le diverse routine inattive in base a questo conteggio.

Di seguito viene riepilogato l'elaborazione del ciclo di inattività:

1. Se il ciclo di messaggi nella libreria di classi di Microsoft Foundation controlla la coda dei messaggi e non trova messaggi in sospeso, chiama OnIdle l'oggetto applicazione e fornisce 0 come argomento lCount .

2. OnIdle esegue un'elaborazione e restituisce un valore diverso da zero per indicare che deve essere chiamato di nuovo per eseguire un'ulteriore elaborazione.

3. Il ciclo di messaggi controlla nuovamente la coda dei messaggi. Se non sono presenti messaggi in sospeso, chiama OnIdle di nuovo, incrementando l'argomento lCount .

4. Infine, OnIdle completa l'elaborazione di tutte le attività inattive e restituisce 0. Questo indica al ciclo di messaggi di interrompere la chiamata OnIdle fino a quando il messaggio successivo non viene ricevuto dalla coda di messaggi, a questo punto il ciclo di inattività viene riavviato con l'argomento impostato su 0.

Non eseguire attività lunghe durante OnIdle perché l'applicazione non può elaborare l'input dell'utente fino a OnIdle quando non viene restituito.

Nota

L'implementazione predefinita degli aggiornamenti degli OnIdle oggetti dell'interfaccia utente del comando, ad esempio voci di menu e pulsanti della barra degli strumenti, esegue la pulizia interna della struttura dei dati. Pertanto, se si esegue l'override lCount di , è necessario chiamare CWinApp::OnIdle con nella versione sottoposta a overrideOnIdle. Chiamare prima di tutto l'elaborazione inattiva della classe base, ovvero fino a quando la classe OnIdle base non restituisce 0. Se è necessario eseguire operazioni prima del completamento dell'elaborazione della classe base, esaminare l'implementazione della classe di base per selezionare il valore lCount appropriato durante il quale eseguire il lavoro.

Se non si desidera OnIdle chiamare ogni volta che un messaggio viene recuperato dalla coda di messaggi, è possibile eseguire l'override di CWinThreadIsIdleMessage. Se un'applicazione ha impostato un timer molto breve o se il sistema invia il messaggio di WM_SYSTIMER, OnIdle verrà chiamato ripetutamente e si riducono le prestazioni.

Esempio

I due esempi seguenti illustrano come usare OnIdle. Il primo esempio elabora due attività inattive usando lCount argomento per classificare in ordine di priorità le attività. La prima attività è alta priorità ed è consigliabile eseguirla ogni volta che possibile. La seconda attività è meno importante e deve essere eseguita solo quando è presente una pausa prolungata nell'input dell'utente. Si noti la chiamata alla versione della classe base di OnIdle. Il secondo esempio gestisce un gruppo di attività inattive con priorità diverse.

BOOL CMyApp::OnIdle(LONG lCount)
{
   BOOL bMore = CWinApp::OnIdle(lCount);

   if (lCount == 0)
   {
      TRACE(_T("App idle for short period of time\n"));
      bMore = TRUE;
   }
   else if (lCount == 10)
   {
      TRACE(_T("App idle for longer amount of time\n"));
      bMore = TRUE;
   }
   else if (lCount == 100)
   {
      TRACE(_T("App idle for even longer amount of time\n"));
      bMore = TRUE;
   }
   else if (lCount == 1000)
   {
      TRACE(_T("App idle for quite a long period of time\n"));
      // bMore is not set to TRUE, no longer need idle
      // IMPORTANT: bMore is not set to FALSE since CWinApp::OnIdle may
      // have more idle tasks to complete.
   }

   return bMore;
   // return TRUE as long as there are any more idle tasks
}

CWinApp::OpenDocumentFile

Il framework chiama questo metodo per aprire il file CDocument denominato per l'applicazione.

virtual CDocument* OpenDocumentFile(
    LPCTSTR lpszFileName
    BOOL bAddToMRU = TRUE);

Parametri

lpszFileName
[in] Nome del file da aprire.

bAddToMRU
[in] TRUE indica che il documento è uno dei file più recenti; FAL edizione Standard indica che il documento non è uno dei file più recenti.

Valore restituito

Puntatore a un oggetto CDocument se ha esito positivo; in caso contrario, NULL.

Osservazioni:

Se un documento con tale nome è già aperto, la prima finestra cornice che contiene tale documento otterrà lo stato attivo. Se un'applicazione supporta più modelli di documento, il framework usa l'estensione del nome file per trovare il modello di documento appropriato per provare a caricare il documento. In caso di esito positivo, il modello di documento crea quindi una finestra cornice e una visualizzazione per il documento.

Esempio

if (m_lpCmdLine[0] == _T('\0'))
{
   // Create a new (empty) document.
   OnFileNew();
}
else
{
   // Open a file passed as the first command line parameter.
   OpenDocumentFile(m_lpCmdLine);
}

CWinApp::P arseCommandLine

Chiamare questa funzione membro per analizzare la riga di comando e inviare i parametri, uno alla volta, a CCommandLineInfo::P arseParam.

void ParseCommandLine(CCommandLineInfo& rCmdInfo);

Parametri

rCmdInfo
Riferimento a un oggetto CCommandLineInfo .

Osservazioni:

Quando si avvia un nuovo progetto MFC usando l'Applicazione guidata, la Creazione guidata applicazione creerà un'istanza locale di CCommandLineInfoe quindi chiamerà ProcessShellCommand e ParseCommandLine nella funzione membro InitInstance . Una riga di comando segue la route descritta di seguito:

1. Dopo essere stato creato in InitInstance, l'oggetto CCommandLineInfo viene passato a ParseCommandLine.

2. ParseCommandLine quindi chiama CCommandLineInfo::ParseParam ripetutamente, una volta per ogni parametro.

3. ParseParam riempie l'oggetto CCommandLineInfo , che viene quindi passato a ProcessShellCommand.

4. ProcessShellCommand gestisce gli argomenti e i flag della riga di comando.

Si noti che è possibile chiamare ParseCommandLine direttamente in base alle esigenze.

Per una descrizione dei flag della riga di comando, vedere CCommandLineInfo::m_nShellCommand.

CWinApp::P reTranslateMessage

Eseguire l'override di questa funzione per filtrare i messaggi della finestra prima che vengano inviati alle funzioni di Windows TranslateMessage e DispatchMessage L'implementazione predefinita esegue la conversione dei tasti di scelta rapida, quindi è necessario chiamare la CWinApp::PreTranslateMessage funzione membro nella versione sottoposta a override.

virtual BOOL PreTranslateMessage(MSG* pMsg);

Parametri

pMsg
Puntatore a una struttura MSG che contiene il messaggio da elaborare.

Valore restituito

Diverso da zero se il messaggio è stato elaborato completamente in PreTranslateMessage e non deve essere elaborato ulteriormente. Zero se il messaggio deve essere elaborato in modo normale.

CWinApp::P rocessMessageFilter

La funzione hook del framework chiama questa funzione membro per filtrare e rispondere a determinati messaggi di Windows.

virtual BOOL ProcessMessageFilter(
    int code,
    LPMSG lpMsg);

Parametri

code
Specifica un codice hook. Questa funzione membro usa il codice per determinare come elaborare lpMsg.

lpMsg
Puntatore a un troncamento MSGdi Windows.

Valore restituito

Diverso da zero se il messaggio viene elaborato; in caso contrario, 0.

Osservazioni:

Una funzione hook elabora gli eventi prima che vengano inviati all'elaborazione normale dei messaggi dell'applicazione.

Se si esegue l'override di questa funzionalità avanzata, assicurarsi di chiamare la versione della classe base per gestire l'elaborazione hook del framework.

CWinApp::P rocessShellCommand

Questa funzione membro viene chiamata da InitInstance per accettare i parametri passati dall'oggetto CCommandLineInfo identificato da rCmdInfo ed eseguire l'azione indicata.

BOOL ProcessShellCommand(CCommandLineInfo& rCmdInfo);

Parametri

rCmdInfo
Riferimento a un oggetto CCommandLineInfo .

Valore restituito

Diverso da zero se il comando della shell viene elaborato correttamente. Se 0, restituire FAL edizione Standard da InitInstance.

Osservazioni:

Quando si avvia un nuovo progetto MFC usando l'Applicazione guidata, la Creazione guidata applicazione creerà un'istanza locale di CCommandLineInfoe quindi chiamerà ProcessShellCommand e ParseCommandLine nella InitInstance funzione membro. Una riga di comando segue la route descritta di seguito:

1. Dopo essere stato creato in InitInstance, l'oggetto CCommandLineInfo viene passato a ParseCommandLine.

2. ParseCommandLinechiama quindi ripetutamente CCommandLineInfo::P arseParam, una volta per ogni parametro.

3. ParseParam riempie l'oggetto CCommandLineInfo , che viene quindi passato a ProcessShellCommand.

4. ProcessShellCommand gestisce gli argomenti e i flag della riga di comando.

I membri dati dell'oggetto CCommandLineInfo , identificati da CCommandLineInfo::m_nShellCommand, sono del tipo enumerato seguente, definito all'interno della CCommandLineInfo classe .

enum {
    FileNew,
    FileOpen,
    FilePrint,
    FilePrintTo,
    FileDDE
    };

Per una breve descrizione di ognuno di questi valori, vedere CCommandLineInfo::m_nShellCommand.

CWinApp::P rocessWndProcException

Il framework chiama questa funzione membro ogni volta che il gestore non rileva un'eccezione generata in uno dei gestori di comandi o messaggi dell'applicazione.

virtual LRESULT ProcessWndProcException(
    CException* e,
    const MSG* pMsg);

Parametri

e
Puntatore a un'eccezione non rilevata.

pMsg
Troncamento MSGche contiene informazioni sul messaggio di Windows che ha causato la generazione di un'eccezione da parte del framework.

Valore restituito

Valore che deve essere restituito a Windows. In genere si tratta di 0L per i messaggi di Windows, 1L ( TRUE) per i messaggi di comando.

Osservazioni:

Non chiamare direttamente questa funzione membro.

L'implementazione predefinita di questa funzione membro crea una finestra di messaggio. Se l'eccezione non rilevata ha origine con un menu, una barra degli strumenti o un errore di comando dell'acceleratore, nella finestra di messaggio viene visualizzato un messaggio "Comando non riuscito". in caso contrario, viene visualizzato un messaggio di errore interno dell'applicazione.

Eseguire l'override di questa funzione membro per fornire la gestione globale delle eccezioni. Chiamare la funzionalità di base solo se si desidera visualizzare la finestra di messaggio.

CWinApp::Register

Esegue qualsiasi attività di registrazione non gestita da RegisterShellFileTypes.

virtual BOOL Register();

Valore restituito

Diverso da zero in caso di esito positivo; in caso contrario, 0.

Osservazioni:

L'implementazione predefinita restituisce semplicemente TRUE. Eseguire l'override di questa funzione per fornire eventuali passaggi di registrazione personalizzati.

CWinApp::RegisterShellFileTypes

Chiamare questa funzione membro per registrare tutti i tipi di documento dell'applicazione con Gestione file di Windows.

void RegisterShellFileTypes(BOOL bCompat = FALSE);

Parametri

bCompat
[in] TRUE aggiunge voci di registrazione per i comandi della shell Stampa e Stampa a, consentendo a un utente di stampare i file direttamente dalla shell o trascinando il file in un oggetto stampante. Aggiunge anche una chiave DefaultIcon. Per impostazione predefinita, questo parametro è FAL edizione Standard per garantire la compatibilità con le versioni precedenti.

Osservazioni:

Ciò consente all'utente di aprire un file di dati creato dall'applicazione facendo doppio clic su di esso all'interno di Gestione file. Chiamare dopo aver chiamato RegisterShellFileTypesAddDocTemplate per ognuno dei modelli di documento nell'applicazione. Chiamare anche la funzione membro EnableShellOpen quando si chiama RegisterShellFileTypes.

RegisterShellFileTypes scorre l'elenco di oggetti CDocTemplate che l'applicazione gestisce e, per ogni modello di documento, aggiunge voci al database di registrazione gestito da Windows per le associazioni di file. Gestione file usa queste voci per aprire un file di dati quando l'utente fa doppio clic su di esso. In questo modo si elimina la necessità di spedire un oggetto . File REG con l'applicazione.

Nota

RegisterShellFileTypes funziona solo se l'utente esegue il programma con diritti di amministratore. Se il programma non dispone di diritti di amministratore, non può modificare le chiavi del Registro di sistema.

Se il database di registrazione associa già una determinata estensione del nome file a un altro tipo di file, non viene creata alcuna nuova associazione. Vedere la CDocTemplate classe per il formato delle stringhe necessarie per registrare queste informazioni.

CWinApp::RegisterWithRestartManager

Registra l'applicazione con il gestore di riavvio.

virtual HRESULT RegisterWithRestartManager(
    BOOL bRegisterRecoveryCallback,
    const CString& strRestartIdentifier);

virtual HRESULT RegisterWithRestartManager(
    LPCWSTR pwzCommandLineArgs,
    DWORD dwRestartFlags,
    APPLICATION_RECOVERY_CALLBACK pRecoveryCallback,
    LPVOID lpvParam,
    DWORD dwPingInterval,
    DWORD dwCallbackFlags);

Parametri

bRegisterRecoveryCallback
[in] TRUE indica che questa istanza dell'applicazione usa una funzione di callback di ripristino; FAL edizione Standard indica che non lo fa. Il framework chiama la funzione di callback di ripristino quando l'applicazione viene chiusa in modo imprevisto. Per altre informazioni, vedere CWinApp::ApplicationRecoveryCallback.

strRestartIdentifier
[in] Stringa univoca che identifica questa istanza del gestore di riavvio. L'identificatore del gestore di riavvio è univoco per ogni istanza di un'applicazione.

pwzCommandLineArgs
[in] Stringa che contiene eventuali argomenti aggiuntivi dalla riga di comando.

dwRestartFlags
[in] Flag facoltativi per il gestore di riavvio. Per altre informazioni, vedere la sezione Osservazioni.

pRecoveryCallback
[in] Funzione di callback di ripristino. Questa funzione deve accettare un parametro LPVOID come input e restituire una DWORD. La funzione di callback di ripristino predefinita è CWinApp::ApplicationRecoveryCallback.

lpvParam
[in] Parametro di input per la funzione di callback di ripristino. Per altre informazioni, vedere CWinApp::ApplicationRecoveryCallback.

dwPingInterval
[in] Periodo di tempo in cui il gestore di riavvio attende che venga restituita la funzione di callback di ripristino. Questo parametro è espresso in millisecondi.

dwCallbackFlags
[in] Flag passati alla funzione di callback di ripristino. Riservato a un uso futuro.

Valore restituito

S_OK se il metodo ha esito positivo; in caso contrario, un codice di errore.

Osservazioni:

Se l'applicazione usa l'implementazione MFC predefinita per i file di salvataggio automatico, è consigliabile usare la versione semplice di RegisterWithRestartManager. Usare la versione complessa di RegisterWithRestartManager se si vuole personalizzare il comportamento di salvataggio automatico dell'applicazione.

Se si chiama questo metodo con una stringa vuota per strRestartIdentifier, RegisterWithRestartManager crea una stringa di identificatore univoco per questa istanza del gestore di riavvio.

Quando un'applicazione viene chiusa in modo imprevisto, il gestore di riavvio riavvia l'applicazione dalla riga di comando e fornisce l'identificatore di riavvio univoco come argomento facoltativo. In questo scenario, il framework chiama RegisterWithRestartManager due volte. La prima chiamata proviene da CWinApp::InitInstance con una stringa vuota per l'identificatore di stringa. Il metodo CWinApp::P rocessShellCommand chiama RegisterWithRestartManager quindi con l'identificatore di riavvio univoco.

Dopo aver registrato un'applicazione con il gestore di riavvio, il gestore di riavvio monitora l'applicazione. Se l'applicazione viene chiusa in modo imprevisto, il gestore di riavvio chiama la funzione di callback di ripristino durante il processo di arresto. Il gestore di riavvio attende dwPingInterval per ottenere una risposta dalla funzione di callback di ripristino. Se la funzione di callback di ripristino non risponde entro questo periodo di tempo, l'applicazione viene chiusa senza eseguire la funzione di callback di ripristino.

Per impostazione predefinita, i dwRestartFlags non sono supportati, ma vengono forniti per un uso futuro. I valori possibili per dwRestartFlags sono i seguenti:

• RESTART_NO_CRASH

• RESTART_NO_HANG

• RESTART_NO_PATCH

• RESTART_NO_REBOOT

CWinApp::ReopenPreviousFilesAtRestart

Determina se il gestore di riavvio riapre i file aperti quando l'applicazione è stata chiusa in modo imprevisto.

virtual BOOL ReopenPreviousFilesAtRestart() const;

Valore restituito

TRUE indica che il gestore di riavvio riapre i file aperti in precedenza; FAL edizione Standard indica che il gestore del riavvio non lo fa.

CWinApp::RestartInstance

Gestisce un riavvio dell'applicazione avviato dal gestore di riavvio.

virtual BOOL CWinApp::RestartInstance();

Valore restituito

TRUE se il gestore di recupero dati apre documenti aperti in precedenza; FAL edizione Standard se il gestore di recupero dati presenta un errore o se non sono presenti documenti aperti in precedenza.

Osservazioni:

Quando il gestore di riavvio riavvia un'applicazione, il framework chiama questo metodo. Questo metodo recupera il gestore di recupero dati e ripristina i file salvati automaticamente. Questo metodo chiama CDataRecoveryHandler::RestoreAutosavedDocuments per determinare se l'utente vuole ripristinare i file salvati automaticamente.

Questo metodo restituisce FAL edizione Standard se CDataRecoveryHandler determina che non sono presenti documenti aperti. Se non sono presenti documenti aperti, l'applicazione viene avviata normalmente.

CWinApp::RestoreAutosavedFilesAtRestart

Determina se il gestore di riavvio ripristina i file salvati automaticamente quando riavvia l'applicazione.

virtual BOOL RestoreAutosavedFilesAtRestart() const;

Valore restituito

TRUE indica che il gestore di riavvio ripristina i file salvati automaticamente; FAL edizione Standard indica che il gestore del riavvio non lo fa.

CWinApp::Run

Fornisce un ciclo di messaggi predefinito.

virtual int Run();

Valore restituito

Valore int restituito da WinMain.

Osservazioni:

Run acquisisce e invia messaggi di Windows fino a quando l'applicazione non riceve un messaggio WM_QUIT. Se la coda di messaggi dell'applicazione non contiene attualmente messaggi, Run chiama OnIdle per eseguire l'elaborazione inattiva. I messaggi in arrivo passano alla funzione membro PreTranslateMessage per l'elaborazione speciale e quindi alla funzione TranslateMessage Windows per la traduzione della tastiera standard. Infine, viene chiamata la DispatchMessage funzione Windows.

Run viene raramente sottoposto a override, ma è possibile eseguirne l'override per fornire un comportamento speciale.

CWinApp::RunAutomated

Chiamare questa funzione per determinare se è presente l'opzione "/Automation" o " -Automation", che indica se l'applicazione server è stata avviata da un'applicazione client.

BOOL RunAutomated();

Valore restituito

Diverso da zero se l'opzione è stata trovata; in caso contrario, 0.

Osservazioni:

Se presente, l'opzione viene rimossa dalla riga di comando. Per altre informazioni sull'automazione OLE, vedere l'articolo Server di automazione.

CWinApp::RunEmbedded

Chiamare questa funzione per determinare se è presente l'opzione " /Embedding" o " -Embedding", che indica se l'applicazione server è stata avviata da un'applicazione client.

BOOL RunEmbedded();

Valore restituito

Diverso da zero se l'opzione è stata trovata; in caso contrario, 0.

Osservazioni:

Se presente, l'opzione viene rimossa dalla riga di comando. Per altre informazioni sull'incorporamento, vedere l'articolo Server: Implementazione di un server.

CWinApp::SaveAllModified

Chiamato dal framework per salvare tutti i documenti quando la finestra cornice principale dell'applicazione deve essere chiusa o tramite un messaggio WM_QUERYENDedizione Standard SSION.

virtual BOOL SaveAllModified();

Valore restituito

Diverso da zero se sicuro per terminare l'applicazione; 0 se non è sicuro terminare l'applicazione.

Osservazioni:

L'implementazione predefinita di questa funzione membro chiama a sua volta la funzione membro CDocument::SaveModified per tutti i documenti modificati all'interno dell'applicazione.

CWinApp::SelectPrinter

Chiamare questa funzione membro per selezionare una stampante specifica e rilasciare la stampante selezionata in precedenza nella finestra di dialogo Stampa.

void SelectPrinter(
    HANDLE hDevNames,
    HANDLE hDevMode,
    BOOL bFreeOld = TRUE);

Parametri

hDevNames
Handle per un troncamento DEVNAMESche identifica i nomi di porta di driver, dispositivo e output di una stampante specifica.

hDevMode
Handle di una struttura DEVMODE che specifica informazioni sull'inizializzazione e sull'ambiente del dispositivo di una stampante.

bFreeOld
Libera la stampante selezionata in precedenza.

Osservazioni:

Se sia hDevMode che hDevNames sono NULL, SelectPrinter usa la stampante predefinita corrente.

CWinApp::SetHelpMode

Imposta il tipo di guida dell'applicazione.

void SetHelpMode(AFX_HELP_TYPE eHelpType);

Parametri

eHelpType
Specifica il tipo di guida da usare. Per altre informazioni, vedere CWinApp::m_eHelpType .

Osservazioni:

Imposta il tipo di Guida dell'applicazione.

Per impostare il tipo di Guida dell'applicazione su HTMLHelp, è possibile chiamare EnableHTMLHelp. Dopo aver chiamato EnableHTMLHelp, l'applicazione deve usare HTMLHelp come applicazione della Guida. Se si vuole modificare per usare WinHelp, è possibile chiamare SetHelpMode e impostare eHelpType su afxWinHelp.

CWinApp::SetRegistryKey

Fa sì che le impostazioni dell'applicazione vengano archiviate nel Registro di sistema anziché nei file INI.

void SetRegistryKey(LPCTSTR lpszRegistryKey);
void SetRegistryKey(UINT nIDRegistryKey);

Parametri

lpszRegistryKey
Puntatore a una stringa contenente il nome della chiave.

nIDRegistryKey
ID di una risorsa stringa contenente il nome della chiave del Registro di sistema.

Osservazioni:

Questa funzione imposta m_pszRegistryKey, che viene quindi usata dalle GetProfileIntfunzioni membro , WriteProfileIntGetProfileString, e WriteProfileString di CWinApp. Se questa funzione è stata chiamata, anche l'elenco dei file usati più di recente viene archiviato nel Registro di sistema. La chiave del Registro di sistema è in genere il nome di una società. Viene archiviato in una chiave del formato seguente: HKEY_CURRENT_Uedizione Standard R\Software\<nome azienda\nome applicazione\<nome> sezione\nome> valore<<>.>

CWinApp::SupportsApplicationRecovery

Determina se il gestore di riavvio recupera un'applicazione che è stata chiusa in modo imprevisto.

virtual BOOL SupportsApplicationRecovery() const;

Valore restituito

TRUE indica che il gestore di riavvio recupera l'applicazione; FAL edizione Standard indica che il gestore del riavvio non lo fa.

CWinApp::SupportsAutosaveAtInterval

Determina se il gestore di riavvio aggiorna automaticamente i documenti aperti a intervalli regolari.

virtual BOOL SupportsAutosaveAtInterval() const;

Valore restituito

TRUE indica che il gestore di riavvio esegue automaticamente l'intercettazione automatica dei documenti aperti; FAL edizione Standard indica che il gestore del riavvio non lo fa.

CWinApp::SupportsAutosaveAtRestart

Determina se il gestore di riavvio aggiorna automaticamente i documenti aperti al riavvio dell'applicazione.

virtual BOOL SupportsAutosaveAtRestart() const;

Valore restituito

TRUE indica che il gestore di riavvio aggiorna automaticamente i documenti aperti al riavvio dell'applicazione; FAL edizione Standard indica che il gestore del riavvio non lo fa.

CWinApp::SupportsRestartManager

Determina se l'applicazione supporta il gestore di riavvio.

virtual BOOL SupportsRestartManager() const;

Valore restituito

TRUE indica che l'applicazione supporta il gestore di riavvio; FAL edizione Standard indica che l'applicazione non è disponibile.

CWinApp::Unregister

Annulla la registrazione di tutti i file registrati dall'oggetto applicazione.

virtual BOOL Unregister();

Valore restituito

Diverso da zero in caso di esito positivo; in caso contrario, 0.

Osservazioni:

La Unregister funzione annulla la registrazione eseguita dall'oggetto applicazione e dalla funzione Register . In genere, entrambe le funzioni vengono chiamate in modo implicito da MFC e pertanto non verranno visualizzate nel codice.

Eseguire l'override di questa funzione per eseguire passaggi di annullamento della registrazione personalizzati.

CWinApp::UnregisterShellFileTypes

Chiamare questa funzione membro per annullare la registrazione di tutti i tipi di documento dell'applicazione con Gestione file di Windows.

void UnregisterShellFileTypes();

CWinApp::WinHelp

Chiamare questa funzione membro per richiamare l'applicazione WinHelp.

virtual void WinHelp(
    DWORD_PTR dwData,
    UINT nCmd = HELP_CONTEXT);

Parametri

dwData
Specifica dati aggiuntivi. Il valore usato dipende dal valore del parametro nCmd .

nCmd
Specifica il tipo di Guida richiesto. Per un elenco dei valori possibili e del modo in cui influiscono sul parametro dwData , vedere la funzione Windows WinHelp .

Osservazioni:

Il framework chiama anche questa funzione per richiamare l'applicazione WinHelp.

Il framework chiuderà automaticamente l'applicazione WinHelp al termine dell'applicazione.

Esempio

// Header File: HELPIDS.H
//
// This example header file is #include'd twice:
// (1) It is #include'd by the .CPP file that passes the DWORD
//     context i.d. to CWinApp::WinHelp.
// (2) It is #include'd in the [MAP] section of the .HPJ file,
//     to associate the help context string "HID_MYTOPIC" with
//     the help context numeric i.d., 101.
// The help context string "HID_MYTOPIC" is what identifies the
// help topic in the help .RTF source file, in the "#" footnote:
//     # HID_MYTOPIC
//
// Note, it is not necessary to manage help context id's this way
// for help topics associated with command id's and user interface
// id's defined in your RESOURCE.H file; you should use the MAKEHM
// tool via the custom build rule on your resource.h file to produce
// a help map (.HM) file for these id's.  It is necessary to manage
// help context id's as illustrated here only for help topics not
// associated with command id's or user interface id's.

#define HID_MYTOPIC 101

// Show the custom help topic that has the context string
// "HID_MYTOPIC" in the help .RTF file, and which is mapped
// to the DWORD i.d. HID_MYTOPIC in the above HELPIDS.H file.
AfxGetApp()->WinHelp(HID_MYTOPIC);

// The following is one line of code in the help map (.HM)
// file produced by the MAKEHM tool, which is called by the custom
// build rule on the resource.h file.  The MAKEHM tool reads the
// following #define in the application's RESOURCE.H file:
#define ID_MYCOMMAND 0x08004
// and adds a help id offset value of 0x10000 to create the
// help context DWORD value 0x18004:
// HID_MYCOMMAND                           0x18004
// See MFC Tech Note 28 for more information on help id offset values.

// Rarely will you need to directly call WinHelp yourself
// with the help context i.d. for a command or user interface
// object. The framework will call WinHelp automatically when
// the user, for example, hits F1 when the focus is on a
// My Command menu item. However, if you do want to directly
// call WinHelp for the help topic associated with the command,
// here is how you would do it:

AfxGetApp()->WinHelp(0x10000 + ID_MYCOMMAND);

CWinApp::WriteProfileBinary

Chiamare questa funzione membro per scrivere dati binari nella sezione specificata del Registro di sistema dell'applicazione o . File INI.

BOOL WriteProfileBinary(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    LPBYTE pData,
    UINT nBytes);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce. Se la sezione non esiste, viene creata. Il nome della sezione è indipendente dal caso; la stringa può essere qualsiasi combinazione di lettere maiuscole e minuscole.

lpszEntry
Punta a una stringa con terminazione Null contenente la voce in cui deve essere scritto il valore. Se la voce non esiste nella sezione specificata, viene creata.

pData
Punta ai dati da scrivere.

nBytes
Contiene il numero di byte da scrivere.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Esempio

Questo esempio usa CWinApp* pApp = AfxGetApp(); per ottenere la classe CWinApp che illustra un modo che WriteProfileBinary e GetProfileBinary può essere usato da qualsiasi funzione in un'applicazione MFC.

CWinApp *pApp = AfxGetApp();

CString strSection = _T("My Section");
CString strItem = _T("My Binary Item");
double myData = 123.456e12;

pApp->WriteProfileBinary(strSection, strItem, (LPBYTE)&myData, sizeof(myData));
double *pData;
UINT n;
pApp->GetProfileBinary(strSection, strItem, (LPBYTE*)&pData, &n);
ASSERT(n == sizeof(myData));
ASSERT(myData = *pData);
delete[] pData; // free the buffer

Per un altro esempio, vedere l'esempio per CWinApp::GetProfileBinary.

CWinApp::WriteProfileInt

Chiamare questa funzione membro per scrivere il valore specificato nella sezione specificata del Registro di sistema dell'applicazione o . File INI.

BOOL WriteProfileInt(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    int nValue);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce. Se la sezione non esiste, viene creata. Il nome della sezione è indipendente dal caso; la stringa può essere qualsiasi combinazione di lettere maiuscole e minuscole.

lpszEntry
Punta a una stringa con terminazione Null contenente la voce in cui deve essere scritto il valore. Se la voce non esiste nella sezione specificata, viene creata.

nValue
Contiene il valore da scrivere.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Esempio

Questo esempio usa CWinApp* pApp = AfxGetApp(); per ottenere la classe CWinApp che illustra un modo in cui WriteProfileString, WriteProfileIntGetProfileString, e GetProfileInt può essere usato da qualsiasi funzione in un'applicazione MFC.

CWinApp *pApp = AfxGetApp();

CString strSection = _T("My Section");
CString strStringItem = _T("My String Item");
CString strIntItem = _T("My Int Item");

pApp->WriteProfileString(strSection, strStringItem, _T("test"));

CString strValue;
strValue = pApp->GetProfileString(strSection, strStringItem);
ASSERT(strValue == _T("test"));

pApp->WriteProfileInt(strSection, strIntItem, 1234);

int nValue;
nValue = pApp->GetProfileInt(strSection, strIntItem, 0);
ASSERT(nValue == 1234);

Per un altro esempio, vedere l'esempio per CWinApp::GetProfileInt.

CWinApp::WriteProfileString

Chiamare questa funzione membro per scrivere la stringa specificata nella sezione specificata del Registro di sistema dell'applicazione o . File INI.

BOOL WriteProfileString(
    LPCTSTR lpszSection,
    LPCTSTR lpszEntry,
    LPCTSTR lpszValue);

Parametri

lpszSection
Punta a una stringa con terminazione null che specifica la sezione che contiene la voce. Se la sezione non esiste, viene creata. Il nome della sezione è indipendente dal caso; la stringa può essere qualsiasi combinazione di lettere maiuscole e minuscole.

lpszEntry
Punta a una stringa con terminazione Null contenente la voce in cui deve essere scritto il valore. Se la voce non esiste nella sezione specificata, viene creata. Se questo parametro è NULL, la sezione specificata da lpszSection viene eliminata.

lpszValue
Punta alla stringa da scrivere. Se questo parametro è NULL, la voce specificata dal parametro lpszEntry viene eliminata.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Esempio

CWinApp *pApp = AfxGetApp();

CString strSection = _T("My Section");
CString strStringItem = _T("My String Item");
CString strIntItem = _T("My Int Item");

pApp->WriteProfileString(strSection, strStringItem, _T("test"));

CString strValue;
strValue = pApp->GetProfileString(strSection, strStringItem);
ASSERT(strValue == _T("test"));

pApp->WriteProfileInt(strSection, strIntItem, 1234);

int nValue;
nValue = pApp->GetProfileInt(strSection, strIntItem, 0);
ASSERT(nValue == 1234);

Per un altro esempio, vedere l'esempio per CWinApp::GetProfileInt.

CWinApp::SetAppID

Imposta in modo esplicito l'ID modello utente applicazione per l'applicazione. Questo metodo deve essere chiamato prima che qualsiasi interfaccia utente venga presentata all'utente (la posizione migliore è il costruttore dell'applicazione).

void SetAppID(LPCTSTR lpcszAppID);

Parametri

lpcszAppID
Specifica l'ID modello utente applicazione.

Osservazioni:

Vedi anche

Classe CWinThread
Grafico della gerarchia
Procedura: Aggiungere il supporto di Gestione riavvio