/*++ Copyright (c) 1995-2000 Microsoft Corporation Module Name: fileq5.c Abstract: Default queue callback function. Author: Ted Miller (tedm) 24-Feb-1995 Revision History: --*/ #include "precomp.h" #pragma hdrstop #define QUEUECONTEXT_SIGNATURE (DWORD)(0x43515053) // 'CQPS' typedef struct _QUEUECONTEXT { DWORD Signature; // an attempt to catch re-use of deleted queuecontext HWND OwnerWindow; DWORD MainThreadId; HWND ProgressDialog; HWND ProgressBar; BOOL Cancelled; PTSTR CurrentSourceName; BOOL ScreenReader; BOOL MessageBoxUp; WPARAM PendingUiType; PVOID PendingUiParameters; UINT CancelReturnCode; BOOL DialogKilled; // // If the SetupInitDefaultQueueCallbackEx is used, the caller can // specify an alternate handler for progress. This is useful to // get the default behavior for disk prompting, error handling, etc, // but to provide a gas gauge embedded, say, in a wizard page. // // The alternate window is sent ProgressMsg once when the copy queue // is started (wParam = 0. lParam = number of files to copy). // It is then also sent once per file copied (wParam = 1. lParam = 0). // // NOTE: a silent installation (i.e., no progress UI) can be accomplished // by specifying an AlternateProgressWindow handle of INVALID_HANDLE_VALUE. // HWND AlternateProgressWindow; UINT ProgressMsg; UINT NoToAllMask; HANDLE UiThreadHandle; // // instead of posting responses to main thread, use an event with flags // HANDLE hEvent; BOOL bDialogExited; LPARAM lParam; #ifdef NOCANCEL_SUPPORT BOOL AllowCancel; #endif } QUEUECONTEXT, *PQUEUECONTEXT; typedef struct _VERDLGCONTEXT { PQUEUECONTEXT QueueContext; UINT Notification; UINT_PTR Param1; UINT_PTR Param2; } VERDLGCONTEXT, *PVERDLGCONTEXT; #define WMX_PROGRESSTHREAD (WM_APP+0) #define WMX_KILLDIALOG (WM_APP+1) #define WMX_HELLO (WM_APP+2) #define WMX_PERFORMUI (WM_APP+3) #define UI_NONE 0 #define UI_COPYERROR 1 #define UI_DELETEERROR 2 #define UI_RENAMEERROR 3 #define UI_NEEDMEDIA 4 #define UI_MISMATCHERROR 5 #define UI_BACKUPERROR 6 typedef struct _COPYERRORUI { TCHAR Buffer[MAX_PATH]; PTCHAR Filename; PFILEPATHS FilePaths; DWORD Flags; PTSTR PathOut; } COPYERRORUI, *PCOPYERRORUI; typedef struct _NEEDMEDIAUI { PSOURCE_MEDIA SourceMedia; DWORD Flags; PTSTR PathOut; } NEEDMEDIAUI, *PNEEDMEDIAUI; PCTSTR DialogPropName = TEXT("_context"); INT_PTR pSetupProgressDlgProc( IN HWND hdlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam ); LPARAM pPerformUi ( IN PQUEUECONTEXT Context, IN UINT UiType, IN PVOID UiParameters ); VOID __cdecl pSetupProgressThread( IN PVOID Context ) /*++ Routine Description: Thread entry point for setup file progress indicator. Puts up a dialog box. Arguments: Context - supplies queue context. Return Value: 0 if unsuccessful, non-0 if successful. --*/ { PQUEUECONTEXT context; INT_PTR i; MSG msg; // // Force this thread to have a message queue, just in case. // PeekMessage(&msg,NULL,0,0,PM_NOREMOVE); // // The thread parameter is the queue context. // context = Context; // // Create the progress dialog box. // i = DialogBoxParam( MyDllModuleHandle, MAKEINTRESOURCE(IDD_FILEPROGRESS), context->OwnerWindow, pSetupProgressDlgProc, (LPARAM)context ); // // flag that this is the very last time hEvent will be set // context->bDialogExited = TRUE; SetEvent(context->hEvent); // // Done. // _endthread(); } BOOL pWaitForUiResponse( IN OUT PQUEUECONTEXT Context ) /*++ Routine Description: Waits for UI event to be set Arguments: Context - supplies queue-context structure Return Value: FALSE = failure --*/ { BOOL KeepWaiting = TRUE; DWORD WaitProcStatus; if (Context->hEvent == NULL) { MYASSERT(Context->hEvent); return FALSE; } if (Context->bDialogExited) { // // dialog has already exited, we wont get another event // return FALSE; } while (KeepWaiting) { WaitProcStatus = MyMsgWaitForMultipleObjectsEx( 1, &Context->hEvent, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE); switch (WaitProcStatus) { case WAIT_OBJECT_0 + 1: { // Process gui messages MSG msg; while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } // fall through ... } case WAIT_IO_COMPLETION: break; case WAIT_OBJECT_0: case WAIT_TIMEOUT: default: KeepWaiting = FALSE; break; } } return TRUE; } UINT PostUiMessage ( IN PQUEUECONTEXT Context, IN UINT UiType, IN UINT CancelCode, IN OUT PVOID UiParameters ) { MSG msg; if(IsWindow(Context->ProgressDialog)) { // // Let progress ui thread handle it. // Context->lParam = FILEOP_ABORT; // in case nobody gets chance to set Context->lParam PostMessage( Context->ProgressDialog, WMX_PERFORMUI, MAKEWPARAM(UiType,CancelCode), (LPARAM)UiParameters ); pWaitForUiResponse(Context); return (UINT)Context->lParam; } else { // // There is no progress thread so do it synchronously. // return (UINT)pPerformUi(Context,UiType,UiParameters); } return 0; } UINT pNotificationStartQueue( IN PQUEUECONTEXT Context ) /*++ Routine Description: Handle SPFILENOTIFY_STARTQUEUE. Creates a progress dialog in a separate thread. Arguments: Context - supplies queue context. Return Value: 0 if unsuccessful, non-0 if successful. --*/ { ULONG_PTR Thread; MSG msg; // // SetupCommitFileQueue could have been called in a different // thread. Adjust the thread id. // Context->MainThreadId = GetCurrentThreadId(); // // Force this thread to have a message queue. If we don't do this, // then PostMessage, PostThreadMessage, etc can fail, which results // in hangs in some cases since we rely heavily on these for // progress, synchronization, etc. // PeekMessage(&msg,NULL,0,0,PM_NOREMOVE); if(Context->AlternateProgressWindow) { // // Either the caller is supplying their own window for progress UI, // or this is a silent install (AlternateProgressWindow is // INVALID_HANDLE_VALUE). // return(TRUE); } else { // // Fire up the progress dialog in a separate thread. // This allows it to be responsive without suspending // the file operations. // Thread = _beginthread( pSetupProgressThread, 0, Context ); if(Thread == -1) { // // assume OOM // SetLastError(ERROR_NOT_ENOUGH_MEMORY); return(0); } // // Wait for notification from the thread about the state // of the dialog. Assume out of memory if we fail // if(!pWaitForUiResponse(Context) || Context->bDialogExited) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return FALSE; } else { return TRUE; } } } UINT pNotificationStartEndSubqueue( IN PQUEUECONTEXT Context, IN BOOL Start, IN UINT_PTR Operation, IN UINT_PTR OpCount ) /*++ Routine Description: Handle SPFILENOTIFY_STARTSUBQUEUE, SPFILENOTIFY_ENDSUBQUEUE. Initializes/terminates a progress control. Also sets progress dialog caption. Arguments: Context - supplies queue context. Start - if TRUE, then this routine is being called to handle a subqueue start notification. Otherwise it's supposed to handle a subqueue end notification. Operation - one of FILEOP_COPY, FILEOP_DELETE, FILEOP_RENAME. OpCount - supplies number of copies, renames, or deletes. Return Value: 0 if unsuccessful, non-0 if successful. --*/ { UINT rc; UINT CaptionStringId; TCHAR ParentText[256]; BOOL GotParentText; PCTSTR CaptionText; UINT AnimationId; HWND Animation; rc = 1; // assume success. if(Context->Cancelled) { SetLastError(ERROR_CANCELLED); return(0); } if(Start) { if(IsWindow(Context->OwnerWindow) && GetWindowText(Context->OwnerWindow,ParentText,256)) { GotParentText = TRUE; } else { GotParentText = FALSE; } // // Clean out the text fields first. // if(IsWindow(Context->ProgressDialog)) { SetDlgItemText(Context->ProgressDialog,IDT_TEXT1,TEXT("")); SetDlgItemText(Context->ProgressDialog,IDT_TEXT2,TEXT("")); } switch(Operation) { case FILEOP_COPY: // // IDT_TEXT1 = target name sans path // IDT_TEXT2 = target name with path // if(IsWindow(Context->ProgressDialog)) { ShowWindow(GetDlgItem(Context->ProgressDialog,IDT_TEXT2),SW_SHOW); } CaptionStringId = GotParentText ? IDS_COPY_CAPTION1 : IDS_COPY_CAPTION2; AnimationId = IDA_FILECOPY; break; case FILEOP_RENAME: if(IsWindow(Context->ProgressDialog)) { ShowWindow(GetDlgItem(Context->ProgressDialog,IDT_TEXT2),SW_SHOW); } CaptionStringId = GotParentText ? IDS_RENAME_CAPTION1 : IDS_RENAME_CAPTION2; AnimationId = IDA_FILECOPY; break; case FILEOP_DELETE: // // IDT_TEXT1 = target name sans path // IDT_TEXT2 = path // if(IsWindow(Context->ProgressDialog)) { ShowWindow(GetDlgItem(Context->ProgressDialog,IDT_TEXT2),SW_HIDE); } CaptionStringId = GotParentText ? IDS_DELETE_CAPTION1 : IDS_DELETE_CAPTION2; AnimationId = IDA_FILEDEL; break; case FILEOP_BACKUP: // handle the new backup case (this is for a backup queue as opposed to on demand if(IsWindow(Context->ProgressDialog)) { ShowWindow(GetDlgItem(Context->ProgressDialog,IDT_TEXT2),SW_SHOW); } CaptionStringId = GotParentText ? IDS_BACKUP_CAPTION1 : IDS_BACKUP_CAPTION2; AnimationId = IDA_FILECOPY; break; default: SetLastError(ERROR_INVALID_PARAMETER); rc = 0; break; } if(rc) { // // Set dialog caption. // if(GotParentText) { CaptionText = FormatStringMessage(CaptionStringId,ParentText); } else { CaptionText = MyLoadString(CaptionStringId); } if(CaptionText) { if(IsWindow(Context->ProgressDialog)) { if(!SetWindowText(Context->ProgressDialog,CaptionText)) { SetWindowText(Context->ProgressDialog,TEXT("")); } } MyFree(CaptionText); } if(Context->AlternateProgressWindow) { // // If this is really an alternate progress window, notify it // about the number of operations. Copy only. // if((Operation == FILEOP_COPY) && (Context->AlternateProgressWindow != INVALID_HANDLE_VALUE)) { SendMessage(Context->AlternateProgressWindow, Context->ProgressMsg, 0, OpCount ); } } else { // // Set up the progress control. Each file will be 1 tick. // if(IsWindow(Context->ProgressBar)) { SendMessage(Context->ProgressBar,PBM_SETRANGE,0,MAKELPARAM(0,OpCount)); SendMessage(Context->ProgressBar,PBM_SETSTEP,1,0); SendMessage(Context->ProgressBar,PBM_SETPOS,0,0); } // // And set up the animation control based on the operation type. // if(OpCount && IsWindow(Context->ProgressDialog)) { Animation = GetDlgItem(Context->ProgressDialog,IDA_ANIMATION); if(Animation) { Animate_Open(Animation,MAKEINTRESOURCE(AnimationId)); Animate_Play(Animation,0,-1,-1); } } } } } else { // // Stop the animation control. Note that if the op count was 0 // then we never started it, so stopping/unloading will give an error, // which we ignore. It's not harmful. // if(!Context->AlternateProgressWindow && IsWindow(Context->ProgressDialog)) { Animation = GetDlgItem(Context->ProgressDialog,IDA_ANIMATION); if (Animation) { Animate_Stop(Animation); Animate_Close(Animation); } } } return(rc); } UINT pNotificationStartOperation( IN PQUEUECONTEXT Context, IN PFILEPATHS FilePaths, IN UINT_PTR Operation ) /*++ Routine Description: Handle SPFILENOTIFY_STARTRENAME, SPFILENOTIFY_STARTDELETE, SPFILENOTIFY_STARTCOPY or SPFILENOTIFY_STARTBACKUP. Updates text in the progress dialog to indicate the files involved in the operation. Arguments: Context - supplies queue context. Start - if TRUE, then this routine is being called to handle a subqueue start notification. Otherwise it's supposed to handle a subqueue end notification. Operation - one of FILEOP_COPY, FILEOP_DELETE, FILEOP_RENAME. OpCount - supplies number of copies, renames, or deletes. Return Value: FILEOP_ABORT if error, otherwise FILEOP_DOIT. --*/ { PCTSTR Text1,Text2; PTSTR p; TCHAR Target[MAX_PATH]; UINT rc; DWORD ec; if(Context->Cancelled) { SetLastError(ERROR_CANCELLED); return(FILEOP_ABORT); } Text1 = Text2 = NULL; rc = FILEOP_ABORT; ec = ERROR_NOT_ENOUGH_MEMORY; switch(Operation) { case FILEOP_COPY: lstrcpyn(Target,FilePaths->Target,MAX_PATH); if(p = _tcsrchr(Target,TEXT('\\'))) { // // Ignore the source filename completely. // *p++ = 0; Text1 = DuplicateString(p); Text2 = FormatStringMessage(IDS_FILEOP_TO,Target); } else { // // Assume not full path -- strange case, but deal with it anyway. // Text1 = DuplicateString(FilePaths->Target); Text2 = DuplicateString(TEXT("")); } break; case FILEOP_RENAME: Text1 = DuplicateString(FilePaths->Source); if(p = _tcsrchr(FilePaths->Target,TEXT('\\'))) { p++; } else { p = (PTSTR)FilePaths->Target; } Text2 = FormatStringMessage(IDS_FILEOP_TO,p); break; case FILEOP_DELETE: lstrcpyn(Target,FilePaths->Target,MAX_PATH); if(p = _tcsrchr(Target,TEXT('\\'))) { *p++ = 0; Text1 = DuplicateString(p); Text2 = FormatStringMessage(IDS_FILEOP_FROM,Target); } else { // // Assume not full path -- strange case, but deal with it anyway. // Text1 = DuplicateString(FilePaths->Target); Text2 = DuplicateString(TEXT("")); } break; case FILEOP_BACKUP: lstrcpyn(Target,FilePaths->Source,MAX_PATH); if(p = _tcsrchr(Target,TEXT('\\'))) { // // FilePaths->Source = what we're backing up (which is target of a restore) // FilePaths->Target = where we're backing up to (block backup) or NULL (demand backup) // *p++ = 0; if (FilePaths->Target == NULL) { // Backing up Text1 = FormatStringMessage(IDS_FILEOP_BACKUP,p); } else { // (title already says Backing up) Text1 = DuplicateString(p); } // From Text2 = FormatStringMessage(IDS_FILEOP_FROM,Target); } else { // // Assume not full path -- strange case, but deal with it anyway. // if (FilePaths->Source == NULL) { Text1 = FormatStringMessage(IDS_FILEOP_BACKUP,Target); } else { Text1 = DuplicateString(Target); } Text2 = DuplicateString(TEXT("")); } break; default: ec = ERROR_INVALID_PARAMETER; break; } if(Text1 && Text2) { if(IsWindow(Context->ProgressDialog)) { SetDlgItemText(Context->ProgressDialog,IDT_TEXT1,Text1); SetDlgItemText(Context->ProgressDialog,IDT_TEXT2,Text2); } rc = FILEOP_DOIT; } if(Text1) { MyFree(Text1); } if(Text2) { MyFree(Text2); } SetLastError(ec); return(rc); } UINT pNotificationErrorCopy( IN PQUEUECONTEXT Context, IN PFILEPATHS FilePaths, OUT PTSTR PathOut ) { UINT rc; COPYERRORUI CopyError; CopyError.FilePaths = FilePaths; CopyError.PathOut = PathOut; // // Buffer gets the pathname part of the source // and p points to the filename part of the source. // lstrcpyn(CopyError.Buffer,FilePaths->Source,MAX_PATH); CopyError.Filename = _tcsrchr(CopyError.Buffer,TEXT('\\')); *CopyError.Filename++ = 0; // // The noskip and warnifskip flags are really mutually exclusive // but we don't try to enforce that here. Just pass through as // appropriate. // CopyError.Flags = 0; if(FilePaths->Flags & SP_COPY_NOSKIP) { CopyError.Flags |= IDF_NOSKIP; } if(FilePaths->Flags & SP_COPY_WARNIFSKIP) { CopyError.Flags |= IDF_WARNIFSKIP; } // // Also pass through the 'no browse' flag. // if(FilePaths->Flags & SP_COPY_NOBROWSE) { CopyError.Flags |= IDF_NOBROWSE; } rc = PostUiMessage (Context, UI_COPYERROR, DPROMPT_CANCEL, &CopyError); switch(rc) { case DPROMPT_SUCCESS: // // If a new path is indicated, verify that it actually changed. // if(CopyError.PathOut[0] && !lstrcmpi(CopyError.Buffer,CopyError.PathOut)) { CopyError.PathOut[0] = 0; } rc = FILEOP_RETRY; break; case DPROMPT_SKIPFILE: rc = FILEOP_SKIP; break; case DPROMPT_CANCEL: SetLastError(ERROR_CANCELLED); rc = FILEOP_ABORT; break; default: SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FILEOP_ABORT; break; } return(rc); } UINT pNotificationStartRegistration( IN PQUEUECONTEXT Context, IN PSP_REGISTER_CONTROL_STATUS ControlStatus, IN BOOL Register ) { return FILEOP_DOIT; } UINT pNotificationErrorDelete( IN PQUEUECONTEXT Context, IN PFILEPATHS FilePaths ) { UINT rc; // // Certain errors are not actually errors. // if((FilePaths->Win32Error == ERROR_FILE_NOT_FOUND) || (FilePaths->Win32Error == ERROR_PATH_NOT_FOUND)) { return(FILEOP_SKIP); } rc = PostUiMessage (Context, UI_DELETEERROR, DPROMPT_CANCEL, FilePaths); switch(rc) { case DPROMPT_SUCCESS: return(FILEOP_RETRY); case DPROMPT_SKIPFILE: return(FILEOP_SKIP); case DPROMPT_CANCEL: SetLastError(ERROR_CANCELLED); return(FILEOP_ABORT); default: SetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FILEOP_ABORT); } } UINT pNotificationErrorRename( IN PQUEUECONTEXT Context, IN PFILEPATHS FilePaths ) { UINT rc; rc = PostUiMessage (Context, UI_RENAMEERROR, DPROMPT_CANCEL, FilePaths); switch(rc) { case DPROMPT_SUCCESS: return(FILEOP_RETRY); case DPROMPT_SKIPFILE: return(FILEOP_SKIP); case DPROMPT_CANCEL: SetLastError(ERROR_CANCELLED); return(FILEOP_ABORT); default: SetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FILEOP_ABORT); } } UINT pNotificationErrorBackup( IN PQUEUECONTEXT Context, IN PFILEPATHS FilePaths ) { UINT rc; if(!(FilePaths->Flags & SP_BACKUP_SPECIAL)) { return FILEOP_SKIP; } rc = PostUiMessage (Context, UI_BACKUPERROR, DPROMPT_CANCEL, FilePaths); switch(rc) { case DPROMPT_SUCCESS: return(FILEOP_RETRY); case DPROMPT_SKIPFILE: return(FILEOP_SKIP); case DPROMPT_CANCEL: SetLastError(ERROR_CANCELLED); return(FILEOP_ABORT); default: SetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FILEOP_ABORT); } } UINT pNotificationNeedMedia( IN PQUEUECONTEXT Context, IN PSOURCE_MEDIA SourceMedia, OUT PTSTR PathOut ) { UINT rc; TCHAR Buffer[MAX_PATH]; NEEDMEDIAUI NeedMedia; if(Context->Cancelled) { SetLastError(ERROR_CANCELLED); return(FILEOP_ABORT); } NeedMedia.SourceMedia = SourceMedia; NeedMedia.PathOut = PathOut; // // Remember the name of this media. // if(Context->CurrentSourceName) { MyFree(Context->CurrentSourceName); Context->CurrentSourceName = NULL; } if(SourceMedia->Description) { Context->CurrentSourceName = DuplicateString(SourceMedia->Description); if(!Context->CurrentSourceName) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); return(FILEOP_ABORT); } } // // Set the source file in the progress dialog // so it matches the file being sought. // if(!(SourceMedia->Flags & SP_FLAG_CABINETCONTINUATION)) { if(IsWindow(Context->ProgressDialog) && !Context->ScreenReader) { DWORD chars; lstrcpyn(Buffer,SourceMedia->SourcePath,MAX_PATH); pSetupConcatenatePaths(Buffer,SourceMedia->SourceFile,MAX_PATH,NULL); SetTruncatedDlgItemText(Context->ProgressDialog,IDT_TEXT1,Buffer); SetDlgItemText(Context->ProgressDialog,IDT_TEXT2,TEXT("")); } } // // The noskip and warnifskip flags are really mutually exclusive // but we don't try to enforce that here. Just pass through as // appropriate. // // Allow skip if this is not a cabinet continuation and // the noskip flag is not set. // NeedMedia.Flags = IDF_CHECKFIRST; if(SourceMedia->Flags & (SP_FLAG_CABINETCONTINUATION | SP_COPY_NOSKIP)) { NeedMedia.Flags |= IDF_NOSKIP; } if(SourceMedia->Flags & SP_COPY_WARNIFSKIP) { NeedMedia.Flags |= IDF_WARNIFSKIP; } if(SourceMedia->Flags & SP_COPY_NOBROWSE) { NeedMedia.Flags |= IDF_NOBROWSE; } rc = PostUiMessage (Context, UI_NEEDMEDIA, DPROMPT_CANCEL, &NeedMedia); switch(rc) { case DPROMPT_SUCCESS: // // If the path really has changed, then return NEWPATH. // Otherwise return DOIT. Account for trailing backslash // differences. // lstrcpyn(Buffer,SourceMedia->SourcePath,MAX_PATH); rc = lstrlen(Buffer); if(rc && (*CharPrev(Buffer,Buffer+rc) == TEXT('\\'))) { Buffer[rc-1] = TEXT('\0'); // valid to do if last char is '\' } rc = lstrlen(NeedMedia.PathOut); if(rc && (*CharPrev(NeedMedia.PathOut,NeedMedia.PathOut+rc) == TEXT('\\'))) { NeedMedia.PathOut[rc-1] = TEXT('\0'); // valid to do if last char is '\' } rc = (lstrcmpi(SourceMedia->SourcePath,NeedMedia.PathOut) ? FILEOP_NEWPATH : FILEOP_DOIT); // // Make sure : ends with a \. // if(NeedMedia.PathOut[0] && (NeedMedia.PathOut[1] == TEXT(':')) && !NeedMedia.PathOut[2]) { NeedMedia.PathOut[2] = TEXT('\\'); NeedMedia.PathOut[3] = TEXT('\0'); } break; case DPROMPT_SKIPFILE: rc = FILEOP_SKIP; break; case DPROMPT_CANCEL: SetLastError(ERROR_CANCELLED); rc = FILEOP_ABORT; break; default: SetLastError(ERROR_NOT_ENOUGH_MEMORY); rc = FILEOP_ABORT; break; } return(rc); } INT_PTR pNotificationVersionDlgProc( IN HWND hdlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam ) { PVERDLGCONTEXT context; PFILEPATHS filePaths; HWND hwnd; TCHAR text[128]; TCHAR Buffer[MAX_PATH*2]; PCTSTR message; int i; TCHAR SourceLangName[128]; TCHAR TargetLangName[128]; switch(msg) { case WM_INITDIALOG: context = (PVERDLGCONTEXT)lParam; MYASSERT(context != NULL); filePaths = (PFILEPATHS)context->Param1; if(!SetProp(hdlg,DialogPropName,(HANDLE)context)) { goto no_memory; } // // Set the source and target filenames. Hack: if the source filename // looks like one of our temporary filenames from a cabinet extraction, // hide it. // message = pSetupGetFileTitle(filePaths->Source); i = lstrlen(message); if((i > 8) && (_totupper(message[0]) == TEXT('S')) && (_totupper(message[1]) == TEXT('E')) && (_totupper(message[2]) == TEXT('T')) && (_totupper(message[3]) == TEXT('P')) && !_tcsicmp(message+(i-4),TEXT(".TMP"))) { ShowWindow(GetDlgItem(hdlg,IDT_TEXT7),SW_HIDE); } else { GetDlgItemText(hdlg,IDT_TEXT7,text,SIZECHARS(text)); message = FormatStringMessageFromString(text,filePaths->Source); if (message == NULL) goto no_memory; SetTruncatedDlgItemText(hdlg,IDT_TEXT7,message); MyFree(message); } GetDlgItemText(hdlg,IDT_TEXT8,text,SIZECHARS(text)); message = FormatStringMessageFromString(text,filePaths->Target); if (message == NULL) goto no_memory; SetTruncatedDlgItemText(hdlg,IDT_TEXT8,message); MyFree(message); if (context->Notification & SPFILENOTIFY_LANGMISMATCH) { // // Language mismatch has the highest priority. // context->Notification = SPFILENOTIFY_LANGMISMATCH; // force other bits off, for NoToAll // // Format the overwrite question. // if(PRIMARYLANGID(LOWORD(context->Param2))==LANG_NEUTRAL) { LoadString( MyDllModuleHandle, IDS_LANG_NEUTRAL, SourceLangName, SIZECHARS(SourceLangName) ); } else { i = GetLocaleInfo( MAKELCID(LOWORD(context->Param2),SORT_DEFAULT), LOCALE_SLANGUAGE, SourceLangName, SIZECHARS(SourceLangName) ); if(!i) { LoadString( MyDllModuleHandle, IDS_LANG_UNKNOWN, SourceLangName, SIZECHARS(SourceLangName) ); } } if(PRIMARYLANGID(HIWORD(context->Param2))==LANG_NEUTRAL) { LoadString( MyDllModuleHandle, IDS_LANG_NEUTRAL, TargetLangName, SIZECHARS(TargetLangName) ); } else { i = GetLocaleInfo( MAKELCID(HIWORD(context->Param2),SORT_DEFAULT), LOCALE_SLANGUAGE, TargetLangName, SIZECHARS(TargetLangName) ); if(!i) { LoadString( MyDllModuleHandle, IDS_LANG_UNKNOWN, TargetLangName, SIZECHARS(TargetLangName) ); } } GetDlgItemText(hdlg,IDT_TEXT4,text,SIZECHARS(text)); message = FormatStringMessageFromString(text,TargetLangName,SourceLangName); if (message == NULL) goto no_memory; SetDlgItemText(hdlg,IDT_TEXT4,message); MyFree(message); // // Turn off the TARGETNEWER and TARGETEXISTS messages. // hwnd = GetDlgItem(hdlg,IDT_TEXT2); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT3); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT5); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT6); ShowWindow(hwnd,SW_HIDE); } else if (context->Notification & SPFILENOTIFY_TARGETNEWER) { // // Target being newer has second highest priority. // context->Notification = SPFILENOTIFY_TARGETNEWER; // force other bits off, for NoToAll // // Turn off the LANGMISMATCH and TARGETEXISTS messages. // hwnd = GetDlgItem(hdlg,IDT_TEXT1); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT3); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT4); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT6); ShowWindow(hwnd,SW_HIDE); } else { // must be exactly SPFILENOTIFY_TARGETEXISTS // // Target existing has the lowest priority. // // Turn off the LANGMISMATCH and TARGETNEWER messages. // hwnd = GetDlgItem(hdlg,IDT_TEXT1); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT2); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT4); ShowWindow(hwnd,SW_HIDE); hwnd = GetDlgItem(hdlg,IDT_TEXT5); ShowWindow(hwnd,SW_HIDE); } PostMessage(hdlg,WMX_HELLO,0,0); break; case WMX_HELLO: // // If this guy has no owner force him to the foreground. // This catches cases where people are using a series of // dialogs and then some setup apis, because when they // close a dialog focus switches away from them. // hwnd = GetWindow(hdlg,GW_OWNER); if(!IsWindow(hwnd)) { SetForegroundWindow(hdlg); } break; case WM_COMMAND: context = (PVERDLGCONTEXT)GetProp(hdlg,DialogPropName); MYASSERT(context != NULL); switch (GET_WM_COMMAND_ID(wParam,lParam)) { case IDYES: EndDialog(hdlg,IDYES); // copy this file break; case IDNO: EndDialog(hdlg,IDNO); // skip this file break; case IDB_NOTOALL: // // No to All was selected. Add this notification type to the // NoToAllMask so that we don't ask about it again. // context->QueueContext->NoToAllMask |= context->Notification; EndDialog(hdlg,IDNO); // skip this file break; } break; default: return FALSE; } return TRUE; no_memory: pSetupOutOfMemory( IsWindow(context->QueueContext->ProgressDialog) ? context->QueueContext->ProgressDialog : context->QueueContext->OwnerWindow ); EndDialog(hdlg,IDNO); // skip this file return TRUE; } LPARAM pPerformUi ( IN PQUEUECONTEXT Context, IN UINT UiType, IN PVOID UiParameters ) { PCOPYERRORUI CopyError; PFILEPATHS FilePaths; PNEEDMEDIAUI NeedMedia; INT_PTR rc; HWND Animation; if(!Context->AlternateProgressWindow && IsWindow(Context->ProgressDialog)) { Animation = GetDlgItem(Context->ProgressDialog,IDA_ANIMATION); } else { Animation = NULL; } switch (UiType) { case UI_COPYERROR: CopyError = (PCOPYERRORUI)UiParameters; if (Animation) { Animate_Stop(Animation); } rc = SetupCopyError( IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, NULL, Context->CurrentSourceName, CopyError->Buffer, CopyError->Filename, CopyError->FilePaths->Target, CopyError->FilePaths->Win32Error, CopyError->Flags, CopyError->PathOut, MAX_PATH, NULL ); if (Animation) { Animate_Play(Animation,0,-1,-1); } break; case UI_DELETEERROR: FilePaths = (PFILEPATHS)UiParameters; if (Animation) { Animate_Stop(Animation); } rc = SetupDeleteError( IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, NULL, FilePaths->Target, FilePaths->Win32Error, 0 ); if (Animation) { Animate_Play(Animation,0,-1,-1); } break; case UI_RENAMEERROR: FilePaths = (PFILEPATHS)UiParameters; if(Animation) { Animate_Stop(Animation); } rc = SetupRenameError( IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, NULL, FilePaths->Source, FilePaths->Target, FilePaths->Win32Error, 0 ); if(Animation) { Animate_Play(Animation,0,-1,-1); } break; case UI_BACKUPERROR: FilePaths = (PFILEPATHS)UiParameters; if(Animation) { Animate_Stop(Animation); } rc = SetupBackupError( IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, NULL, FilePaths->Source, FilePaths->Target, FilePaths->Win32Error, 0 ); if(Animation) { Animate_Play(Animation,0,-1,-1); } break; case UI_NEEDMEDIA: NeedMedia = (PNEEDMEDIAUI)UiParameters; if(Animation) { Animate_Stop(Animation); } rc = SetupPromptForDisk( IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, NULL, NeedMedia->SourceMedia->Description, NeedMedia->SourceMedia->SourcePath, NeedMedia->SourceMedia->SourceFile, NeedMedia->SourceMedia->Tagfile, NeedMedia->Flags, NeedMedia->PathOut, MAX_PATH, NULL ); if(Animation) { Animate_Play(Animation,0,-1,-1); } break; case UI_MISMATCHERROR: if(Animation) { Animate_Stop(Animation); } if(GlobalSetupFlags & (PSPGF_NONINTERACTIVE|PSPGF_UNATTENDED_SETUP)) { rc = DPROMPT_CANCEL; } else { rc = DialogBoxParam( MyDllModuleHandle, MAKEINTRESOURCE(IDD_REPLACE), IsWindow(Context->ProgressDialog) ? Context->ProgressDialog : Context->OwnerWindow, pNotificationVersionDlgProc, (LPARAM)UiParameters ); } if(Animation) { Animate_Play(Animation,0,-1,-1); } break; default: MYASSERT (0); rc = 0; } return rc; } INT_PTR pSetupProgressDlgProc( IN HWND hdlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam ) { BOOL b; PQUEUECONTEXT Context; HWND hwnd; PTSTR p; INT_PTR i; MSG m; BOOL Cancelled; HANDLE h; static UINT uQueryCancelAutoPlay = 0; switch(msg) { case WM_INITDIALOG: #ifdef PRERELEASE if (GuiSetupInProgress) { MYASSERT( FALSE && TEXT("bringing up file progress dialog (IDD_FILEPROGRESS) during gui-mode setup, which is a UI violation. Click yes and retrive a stack trace to determine errant caller.\n")); } #endif Context = (PQUEUECONTEXT)lParam; MYASSERT(Context != NULL); if(!SetProp(hdlg,DialogPropName,(HANDLE)Context)) { // // running out of resources, kill this dialog // EndDialog(hdlg, -1); return TRUE; // TRUE or FALSE, it really doesn't matter } #ifdef NOCANCEL_SUPPORT // // If cancel is not allowed, disable the cancel button. // if(!Context->AllowCancel) { RECT rect; RECT rect2; hwnd = GetDlgItem(hdlg,IDCANCEL); ShowWindow(hwnd,SW_HIDE); EnableWindow(hwnd,FALSE); GetWindowRect(hdlg,&rect); GetWindowRect(hwnd,&rect2); SetWindowPos( hdlg, NULL, 0,0, rect.right - rect.left, (rect.bottom - rect.top) - (rect.bottom - rect2.top), SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER ); } #endif // // Center the progress dialog relative to the parent window. // pSetupCenterWindowRelativeToParent(hdlg); SetFocus(GetDlgItem(hdlg,IDCANCEL)); // // The main thread is processing SPFILENOTIFY_STARTQUEUE and is // waiting for some notification about the state of the UI thread. // Let the main thread know we succeeded, and pass back a real // handle to this thread that can be used to wait for it to terminate. // b = DuplicateHandle( GetCurrentProcess(), // source process GetCurrentThread(), // source handle GetCurrentProcess(), // target process &h, // new handle 0, // ignored with DUPLICATE_SAME_ACCESS FALSE, // not inheritable DUPLICATE_SAME_ACCESS ); if(!b) { // // Since we cannot duplicate the handle, we must kill this dialog, // because otherwise the inter-thread communication will be broken // and things go horribly wrong. // EndDialog(hdlg, -1); return TRUE; // TRUE or FALSE, it really doesn't matter } // // Store the dialog and progress bar handles in the context structure. // Context->ProgressDialog = hdlg; Context->ProgressBar = GetDlgItem(hdlg,IDC_PROGRESS); Context->UiThreadHandle = h; PostMessage(hdlg,WMX_HELLO,0,0); // put WMX_HELLO on our message queue SetEvent(Context->hEvent); // inform caller we've done initialization b = FALSE; break; case WMX_HELLO: // // If this guy has no owner force him to the foreground. // This catches cases where people are using a series of // dialogs and then some setup apis, because when they // close a dialog focus switches away from them. // hwnd = GetWindow(hdlg,GW_OWNER); if(!IsWindow(hwnd)) { SetForegroundWindow(hdlg); } b = TRUE; break; case WMX_PERFORMUI: b = TRUE; Context = (PQUEUECONTEXT)GetProp(hdlg,DialogPropName); MYASSERT(Context != NULL); // // We'd better not already have any UI pending... // MYASSERT(Context->PendingUiType == UI_NONE); if (Context->MessageBoxUp == TRUE) { Context->PendingUiType = LOWORD (wParam); Context->CancelReturnCode = HIWORD (wParam); Context->PendingUiParameters = (PVOID)lParam; } else { Context->lParam = pPerformUi (Context, LOWORD(wParam), (PVOID)lParam); SetEvent(Context->hEvent); // wakeup main thread (lParam has Ui result) } break; case WM_COMMAND: Context = (PQUEUECONTEXT)GetProp(hdlg,DialogPropName); MYASSERT(Context != NULL); if((HIWORD(wParam) == BN_CLICKED) && (LOWORD(wParam) == IDCANCEL)) { p = MyLoadString(IDS_CANCELFILEOPS); Cancelled = FALSE; if(p) { // // While the message box is up, the main thread is still copying files, // and it might just complete. If that happens, the main thread will // post us WMX_KILLDIALOG, which would cause this dialog to nuke itself // out from under the message box. The main thread would then continue // executing while the message box is sitting there. Some components // actually unload setupapi.dll at that point, and so when the user // dismisses the message box, an AV results. // // We can't freeze the main thread via SuspendThread because then // that thread, which probably owns this dialog's parent window, // will not be able to process messages that result from the message box's // creation. Result is that the message box never comes up and the process // is deadlocked. // // We'd better not already have a message box up! // MYASSERT(!Context->MessageBoxUp); Context->MessageBoxUp = TRUE; i = MessageBox( hdlg, p, TEXT(""), MB_YESNO | MB_APPLMODAL | MB_DEFBUTTON2 | MB_SETFOREGROUND | MB_ICONQUESTION ); Context->MessageBoxUp = FALSE; // // We set b to TRUE if the dialog is going away. // We set Cancelled to TRUE if the user clicked the CANCEL button. // if(Context->DialogKilled) { b = TRUE; Cancelled = (i == IDYES); } else { b = (i == IDYES); Cancelled = b; } MyFree(p); } else { pSetupOutOfMemory(hdlg); Cancelled = TRUE; b = TRUE; } if(b) { if(Cancelled) { Context->Cancelled = TRUE; } PostMessage(hdlg,WMX_KILLDIALOG,0,0); if (Context->PendingUiType != UI_NONE) { // // We now allow the main thread to continue. Once we do // so, the UI parameters that we passed to us are invalid. // Cancel the pending UI. // Context->PendingUiType = UI_NONE; Context->lParam = Context->CancelReturnCode; SetEvent(Context->hEvent); // wake up main thread (lParam has UI result) } } else { if (Context->PendingUiType != UI_NONE) { Context->lParam = pPerformUi(Context, (UINT)Context->PendingUiType, Context->PendingUiParameters); Context->PendingUiType = UI_NONE; SetEvent(Context->hEvent); // wake up main thread (lParam has UI result) } } b = TRUE; } else { b = FALSE; } break; case WMX_KILLDIALOG: // // Exit unconditionally. Clean up first. // b = TRUE; Context = (PQUEUECONTEXT)GetProp(hdlg, DialogPropName); MYASSERT(Context != NULL); if(Context->MessageBoxUp) { // // The user was still interacting with the "are you sure you // want to cancel" dialog and the copying finished. So we don't want // to nuke the dialog out from under the message box. // Context->DialogKilled = TRUE; break; } DestroyWindow(Context->ProgressBar); EndDialog(hdlg, 0); break; default: // // we disable autorun because it confuses the user. // if (!uQueryCancelAutoPlay) { uQueryCancelAutoPlay = RegisterWindowMessage(TEXT("QueryCancelAutoPlay")); } if (msg == uQueryCancelAutoPlay) { SetWindowLongPtr( hdlg, DWLP_MSGRESULT, 1 ); return 1; // cancel auto-play } b = FALSE; break; } return(b); } PVOID SetupInitDefaultQueueCallbackEx( IN HWND OwnerWindow, IN HWND AlternateProgressWindow, OPTIONAL IN UINT ProgressMessage, IN DWORD Reserved1, IN PVOID Reserved2 ) { PQUEUECONTEXT Context; BOOL b; Context = MyMalloc(sizeof(QUEUECONTEXT)); if(Context) { ZeroMemory(Context,sizeof(QUEUECONTEXT)); Context->Signature = QUEUECONTEXT_SIGNATURE; Context->hEvent = CreateEvent(NULL,FALSE,FALSE,NULL); if (Context->hEvent == NULL) { MyFree(Context); return NULL; } Context->OwnerWindow = OwnerWindow; Context->MainThreadId = GetCurrentThreadId(); Context->ProgressMsg = ProgressMessage; Context->NoToAllMask = 0; // // If the caller specified NULL for the alternate progress window, and // we're running non-interactively, we want to treat this just as if // they'd specified INVALID_HANDLE_VALUE (i.e., suppress all progress // UI). // if((GlobalSetupFlags & PSPGF_NONINTERACTIVE) && !AlternateProgressWindow) { Context->AlternateProgressWindow = INVALID_HANDLE_VALUE; } else { Context->AlternateProgressWindow = AlternateProgressWindow; } if(SystemParametersInfo(SPI_GETSCREENREADER,0,&b,0) && b) { Context->ScreenReader = TRUE; } else { Context->ScreenReader = FALSE; } #ifdef PRERELEASE // // if we're running in gui-mode setup, we suppress all setupapi progress UI // and only allow AlternateProgressWindow UI // if (GuiSetupInProgress && (Context->AlternateProgressWindow != (HWND)INVALID_HANDLE_VALUE) && !IsWindow(Context->AlternateProgressWindow)) { MYASSERT( FALSE && TEXT("SetupInitDefaultQueueCallbackEx() called in gui-setup without INVALID_HANDLE_VALUE, which means UI may be presented. Click yes and retrieve the stack trace to detect errant caller.\n")); } #endif } return(Context); } PVOID SetupInitDefaultQueueCallback( IN HWND OwnerWindow ) { #ifdef PRERELEASE if (GuiSetupInProgress) { MYASSERT( FALSE && TEXT("SetupInitDefaultQueueCallback() called in gui-setup, which means UI may be presented. Click yes and retrieve the stack trace to detect the errant caller.\n")); } #endif return(SetupInitDefaultQueueCallbackEx(OwnerWindow,NULL,0,0,NULL)); } VOID SetupTermDefaultQueueCallback( IN PVOID Context ) { PQUEUECONTEXT context; context = Context; try { if(context && context->Signature == QUEUECONTEXT_SIGNATURE) { if(context->CurrentSourceName) { MyFree(context->CurrentSourceName); } if (context->hEvent) { CloseHandle(context->hEvent); } context->Signature = 0; } MyFree(Context); } except(EXCEPTION_EXECUTE_HANDLER) { ; } } #ifdef UNICODE // // ANSI version // UINT SetupDefaultQueueCallbackA( IN PVOID Context, IN UINT Notification, IN UINT_PTR Param1, IN UINT_PTR Param2 ) { UINT u; u = pSetupCallDefaultMsgHandler( Context, Notification, Param1, Param2 ); return(u); } #else // // Unicode stub // UINT SetupDefaultQueueCallbackW( IN PVOID Context, IN UINT Notification, IN UINT_PTR Param1, IN UINT_PTR Param2 ) { UNREFERENCED_PARAMETER(Context); UNREFERENCED_PARAMETER(Notification); UNREFERENCED_PARAMETER(Param1); UNREFERENCED_PARAMETER(Param2); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return(0); } #endif UINT SetupDefaultQueueCallback( IN PVOID Context, IN UINT Notification, IN UINT_PTR Param1, IN UINT_PTR Param2 ) { UINT rc; DWORD err; PQUEUECONTEXT context = Context; MSG msg; VERDLGCONTEXT dialogContext; DWORD waitResult; // // a little sanity check on context // err = NO_ERROR; try { if (context == NULL || context->Signature != QUEUECONTEXT_SIGNATURE) { err = ERROR_INVALID_PARAMETER; } } except(EXCEPTION_EXECUTE_HANDLER) { err = ERROR_INVALID_PARAMETER; } if (err != NO_ERROR) { return pGetCallbackErrorReturn(Notification,err); } switch(Notification) { case SPFILENOTIFY_STARTQUEUE: rc = pNotificationStartQueue(context); break; case SPFILENOTIFY_ENDQUEUE: // // Make sure the progress dialog is dead. // if(context->AlternateProgressWindow) { // // If we have an alternate progress window, then we'd better not // have our own progress dialog, nor should we have a UI thread // handle. // MYASSERT(!context->ProgressDialog); MYASSERT(!context->UiThreadHandle); } else { if(IsWindow(context->ProgressDialog)) { // // Post a message to the dialog, instructing it to terminate, // then wait for it to confirm. // PostMessage(context->ProgressDialog, WMX_KILLDIALOG, 0, 0); } // // The dialog may have been marked for delete (thus IsWindow() fails), // and yet the dialog has not yet been destroyed. Therefore, we always // want to wait for the thread message that assures us that everything // has been cleaned up in the other thread. // // Also, before returning we need to make sure that the UI thread is // really gone, or else there's a hole where our caller could unload // the library and then the UI thread would fault. // We have seen this happen in stress. // while (pWaitForUiResponse(context)) /* nothing */; if(context->UiThreadHandle) { waitResult = WaitForSingleObject(context->UiThreadHandle,INFINITE); MYASSERT(waitResult != WAIT_FAILED); CloseHandle(context->UiThreadHandle); } } rc = TRUE; // return value for this notification is actually ignored. break; case SPFILENOTIFY_STARTSUBQUEUE: rc = pNotificationStartEndSubqueue(context,TRUE,Param1,Param2); break; case SPFILENOTIFY_ENDSUBQUEUE: rc = pNotificationStartEndSubqueue(context,FALSE,Param1,0); break; case SPFILENOTIFY_STARTDELETE: case SPFILENOTIFY_STARTRENAME: case SPFILENOTIFY_STARTCOPY: case SPFILENOTIFY_STARTBACKUP: // // Update display to indicate the files involved // in the operation, unless a screen reader is active. // if(context->ScreenReader) { rc = FILEOP_DOIT; } else { rc = pNotificationStartOperation(context,(PFILEPATHS)Param1,Param2); } break; case SPFILENOTIFY_ENDDELETE: case SPFILENOTIFY_ENDRENAME: case SPFILENOTIFY_ENDCOPY: case SPFILENOTIFY_ENDBACKUP: case SPFILENOTIFY_ENDREGISTRATION: if(context->AlternateProgressWindow) { // // If this is really is an alternate progress window, then 'tick' it. // Copy only. // if((Notification == SPFILENOTIFY_ENDCOPY) && (context->AlternateProgressWindow != INVALID_HANDLE_VALUE)) { SendMessage(context->AlternateProgressWindow, context->ProgressMsg, 1, 0); } } else { if(IsWindow(context->ProgressBar)) { // // Update gas gauge. // SendMessage(context->ProgressBar,PBM_STEPIT,0,0); } } rc = TRUE; // return value for these notifications is actually ignored. break; case SPFILENOTIFY_DELETEERROR: rc = pNotificationErrorDelete(context,(PFILEPATHS)Param1); break; case SPFILENOTIFY_RENAMEERROR: rc = pNotificationErrorRename(context,(PFILEPATHS)Param1); break; case SPFILENOTIFY_BACKUPERROR: rc = pNotificationErrorBackup(context,(PFILEPATHS)Param1); break; case SPFILENOTIFY_COPYERROR: rc = pNotificationErrorCopy(context,(PFILEPATHS)Param1,(PTSTR)Param2); break; case SPFILENOTIFY_NEEDMEDIA: // // Perform prompt. // rc = pNotificationNeedMedia(context,(PSOURCE_MEDIA)Param1,(PTSTR)Param2); break; case SPFILENOTIFY_STARTREGISTRATION: rc = pNotificationStartRegistration(context,(PSP_REGISTER_CONTROL_STATUS)Param1,(BOOL)Param2); break; default: // // The notification is either an unknown ordinal or a version mismatch. // if(Notification & (SPFILENOTIFY_LANGMISMATCH | SPFILENOTIFY_TARGETNEWER | SPFILENOTIFY_TARGETEXISTS)) { // // It's one or more of our known version mismatches. First // check to see whether No to All has already been specified // for the mismatch(es). Turn off the bits in the notification // that are set in NoToAllMask; if there are still bits set, // we need to notify about this mismatch. If there are no // longer any bits set, then don't copy this file. // Notification &= ~context->NoToAllMask; if (Notification != 0) { // // Notify about this mismatch. // dialogContext.QueueContext = context; dialogContext.Notification = Notification; dialogContext.Param1 = Param1; dialogContext.Param2 = Param2; rc = PostUiMessage ( context, UI_MISMATCHERROR, DPROMPT_CANCEL, &dialogContext); rc = (rc == IDYES); } else { // // No To All has already been specified for this notification type. // Skip the file. // rc = 0; } } else { // // Unknown notification. Skip the file. // rc = 0; } break; } return(rc); }