public void Complete(TResult result) { //HRESULT hr = S_OK; //IFCEXPECT(m_isInitialized); //AssertInvariants(); //if (m_flyoutState == FlyoutState::Open) //{ // // If the flyout is not already closed or closing, then we're being called // // because the user accepted a selection, and the flyout will be closed shortly // // by PickerFlyoutBase::OnConfirmedImpl // m_flyoutState = FlyoutState::Closing; //} if (m_flyoutState == FlyoutState.Open) { m_flyoutState = FlyoutState.Closing; } //if (m_spCurrentOperation) //{ if (m_spCurrentOperation != null) { // wrl::ComPtr<wf::IAsyncInfo> spAsyncInfo; // wf::AsyncStatus asyncStatus = wf::AsyncStatus::Started; // // If an operation is deferred, then it is not associated with the current // // open/close cycle of this flyout, and we should not complete it unless it // // has been cancelled. // IFC(m_spCurrentOperation.As(&spAsyncInfo)); // IFC(spAsyncInfo->get_Status(&asyncStatus)); var asyncStatus = m_spCurrentOperation.Status; if (!m_isShowAtForCurrentOperationDeferred || asyncStatus == AsyncStatus.Canceled) { AssertCompleteOperationPreconditions(); // // nulls out m_spCurrentOperation. This is important in the case of rentrancy; // // the consumer's CompleteOperation handler may trigger another call to Start, // // in which case we want Start to be able to return a deferred operation // // rather than failing. // wrl::ComPtr<xaml_controls::IPickerFlyoutAsyncOperation<TResult>> spCurrentOperation; // spCurrentOperation.Swap(m_spCurrentOperation); m_isShowAtForCurrentOperationDeferred = false; m_tpTargetForDeferredShowAt = null; m_spCurrentOperation.CompleteOperation(result); m_spCurrentOperation = null; // IFC(spCurrentOperation->CompleteOperation(result)); } //} //Cleanup: //RRETURN(hr); } AssertInvariants(); }
public IAsyncOperation <TResult> Start(FrameworkElement pTarget) { //HRESULT hr = S_OK; PickerFlyoutAsyncOperation <TResult> spAsyncOp; //// Validation //IFCEXPECT(m_isInitialized); //AssertInvariants(); //if (m_spCurrentOperation) //{ // ROERROR_LOOKUP(E_ASYNC_OPERATION_NOT_STARTED, ERR_ASYNC_ALREADY_IN_PROGRESS); //} if (m_spCurrentOperation != null) { throw new InvalidOperationException("Async operation in progress."); } //if (m_flyoutState == FlyoutState::Open) //{ // ROERROR_LOOKUP(E_ASYNC_OPERATION_NOT_STARTED, ERR_FLYOUT_ALREADY_OPEN); //} //IFC((wrl::MakeAndInitialize<xaml_controls::PickerFlyoutAsyncOperation<TResult, OpName>>(&spAsyncOp))); spAsyncOp = new PickerFlyoutAsyncOperation <TResult>(); //IFC(spAsyncOp->StartOperation(m_pAssociatedFlyoutNoRef)); spAsyncOp.StartOperation(m_pAssociatedFlyoutNoRef); //pTarget = m_tpTargetForDeferredShowAt; //IFC(SetPtrValue(m_tpTargetForDeferredShowAt, pTarget)); // UNO-TODO: TEMPORARY DISABLE THIS FEATURE // m_isShowAtForCurrentOperationDeferred = true; //if (m_flyoutState == FlyoutState::Closed) //{ // IFC(BeginAttemptStartDeferredOperation()); //} if (m_flyoutState == FlyoutState.Closed) { // The flyout is currently closed so we can try to show now, but we have to treat this // as a deferred op anyway and show asynchronously in case we're being called from the // closed event handler, as FlyoutBase may swallow a synchronous call to ShowAt in that case. BeginAttemptStartDeferredOperation(); } //m_spCurrentOperation = static_cast<xaml_controls::IPickerFlyoutAsyncOperation<TResult>*>(spAsyncOp.Get()); m_spCurrentOperation = spAsyncOp; //IFC(spAsyncOp.CopyTo(ppOperation)); AssertInvariants(); //Cleanup: //RRETURN(hr); return(spAsyncOp); }