Interfaccia IOleParentUndoUnit (ocidl.h)
Abilita l'annullamento delle unità per contenere unità figlio di annullamento. Ad esempio, un'azione complessa può essere presentata all'utente finale come singola azione di annullamento, anche se sono coinvolte numerose azioni separate. Tutte le azioni di annullamento subordinate sono contenute all'interno dell'unità di annullamento padre di primo livello.
Un'unità padre di annullamento viene inizialmente creata usando il metodo IOleUndoManager::Open. L'aggiunta di unità di annullamento deve essere sempre eseguita tramite il gestore di annullamento. IOleParentUndoUnit::Open e IOleParentUndoUnit::Close metodi nelle unità padre verranno chiamati dal manager di annullamento. L'esecuzione di una chiamata di unità padre al gestore di annullamento causerà una ricorsione infinita.
Anche se un'unità padre è aperta, il gestore annulla aggiunge unità di annullamento chiamando IOleParentUndoUnit::Add. Quando il gestore di annullamento chiude un elemento padre di primo livello, l'intera unità di annullamento con i relativi subordinati annidati viene posizionata sopra lo stack di annullamento.
È necessario aprire un elemento padre di abilitazione nello stack prima che sia possibile aggiungere altre unità di annullamento. Se non è aperto, lo stack deve essere cancellato. Si tratta di garantire che le unità di annullamento vengano aggiunte solo in seguito alle azioni utente e non alle azioni a livello di codice. Ad esempio, se l'applicazione vuole fare clic su un determinato pulsante annullabile, ma questa stessa azione viene esposta anche tramite il modello a oggetti. Tale azione deve essere annullata tramite l'interfaccia utente, ma non il modello a oggetti perché non è possibile ripristinare lo stato del codice script dell'utente. Poiché lo stesso codice implementa la modifica in entrambi i casi, il codice dell'interfaccia utente che gestisce il pulsante deve aprire un elemento padre di abilitazione nello stack, chiamare il codice appropriato e quindi chiudere l'unità padre. Il codice del modello a oggetti non apre un'unità padre, causando la cancellazione dello stack di annullamento.
Un padre di blocco viene usato quando non si vuole che il codice chiami altro codice che si sa potrebbe provare a aggiungere unità di annullamento allo stack. Ad esempio, è consigliabile usare un padre di blocco se si chiama il codice che crea unità di annullamento, che il codice esterno ha già creato che annulla completamente tutto il comportamento desiderato.
Un elemento padre non abilitato viene usato quando si attiva un evento in risposta a un'azione utente. Lo stack verrà cancellato solo se il gestore eventi ha eseguito qualcosa che ha tentato di creare un'unità di annullamento, ma se non esiste alcun gestore, lo stack di annullamento verrà mantenuto.
Se un oggetto deve creare un'unità padre, esistono diversi casi da considerare:
- Per creare un'unità padre abilitante, l'oggetto chiama IOleUndoManager::GetOpenParentState nella gestione annullamento e controlla il valore restituito. Se il valore è S_FALSE, l'oggetto crea l'elemento padre di abilitazione e lo apre. Se il valore restituito è S_OK, è già aperto un elemento padre. Se l'elemento padre aperto è bloccato (UAS_BLOCKED set di bit) o un elemento padre di abilitazione (UAS_BLOCKED e UAS_NOPARENTENABLE bit non impostati), non è necessario creare l'elemento padre abilitato. Se l'elemento padre aperto è un elemento padre di disabilitazione (UAS_NOPARENTENABLE set di bit), l'abilitazione padre deve essere creato e aperto per riattivare l'aggiunta di unità di annullamento. Si noti che UAS_NORMAL ha un valore pari a zero, che significa che è l'assenza di tutti gli altri bit e non è un flag di bit che può essere impostato. Se si confronta *pdwState con UAS_NORMAL, mascherare i bit inutilizzati da pdwState con UAS_MASK per consentire l'espansione futura.
- Per creare un padre bloccato, l'oggetto chiama IOleUndoManager::GetOpenParentState e verifica la presenza di un elemento padre aperto già bloccato. Se esiste, non è necessario creare il nuovo elemento padre di blocco. In caso contrario, l'oggetto lo crea e lo apre nello stack.
- Per creare un padre di disabilitazione, l'oggetto chiama IOleUndoManager::GetOpenParentState e verifica la presenza di un elemento padre aperto bloccato o disabilitato. Se uno esiste, non è necessario creare il nuovo elemento padre. In caso contrario, l'oggetto crea l'elemento padre e lo apre nello stack.
Quando l'unità padre di annullamento viene contrassegnata come bloccata, elimina eventuali unità di annullamento ricevute.
Ereditarietà
L'interfaccia IOleParentUndoUnit eredita da IOleUndoUnit. IOleParentUndoUnit include anche questi tipi di membri:
Metodi
L'interfaccia IOleParentUndoUnit include questi metodi.
| IOleParentUndoUnit::Add Aggiunge un'unità di annullamento semplice alla raccolta. |
| IOleParentUndoUnit::Close Chiude l'unità di annullamento padre specificata. (IOleParentUndoUnit.Close) |
| IOleParentUndoUnit::FindUnit Indica se l'unità specificata è un elemento figlio di questa unità di annullamento o uno dei relativi elementi figlio, ovvero se l'unità specificata fa parte della gerarchia in questa unità padre. |
| IOleParentUndoUnit::GetParentState Recupera le informazioni sullo stato sull'unità padre più aperta all'interno. (IOleParentUndoUnit.GetParentState) |
| IOleParentUndoUnit::Open Apre una nuova unità padre di annullamento, che diventa parte dello stack di annullamento dell'unità contenente. |
Requisiti
| Requisito | Valore |
|---|---|
| Client minimo supportato | Windows 2000 Professional [solo app desktop] |
| Server minimo supportato | Windows 2000 Server [solo app desktop] |
| Piattaforma di destinazione | Windows |
| Intestazione | ocidl.h |