/*++ Copyright (c) 1995 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 typedef struct _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; #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 WMX_FINISHEDUI (WM_APP+4) // Define a signature for WMX_FINISHEDUI (contained in wParam) that is // used to validate the sender. #define FINISHEDUI_SIG 0x55464D53 // "SMFU" (Setupapi Message Finished UI) #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"); VOID CenterWindowRelativeToParent( HWND hwnd ); INT_PTR pSetupProgressDlgProc( IN HWND hdlg, IN UINT msg, IN WPARAM wParam, IN LPARAM lParam ); VOID 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 ); if(i == -1) { // DialogBox failed. Inform the main thread, which is processing // SPFILENOTIFY_STARTQUEUE and waiting for some notification from us // about the state of the UI thread. PostThreadMessage(context->MainThreadId,WMX_PROGRESSTHREAD,FALSE,0); } else { // DialogBox worked. The main thread will wait for some notification // about this when processing SPFILENOTIFY_ENDQUEUE. // Note that the main thread ignores wParam in this case. PostThreadMessage(context->MainThreadId,WMX_PROGRESSTHREAD,0,0); } // Done. _endthread(); } 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. PostMessage( Context->ProgressDialog, WMX_PERFORMUI, MAKEWPARAM(UiType,CancelCode), (LPARAM)UiParameters ); } else { // There is no progress thread so do it synchronously. // Note that pPerformUi always posts the WMX_FINISHEDUI message. pPerformUi(Context,UiType,UiParameters); } while (GetMessage (&msg, NULL, 0, 0)) { if (msg.message == WMX_FINISHEDUI) { // Verify that this really is our message. MYASSERT(msg.wParam == FINISHEDUI_SIG); // If it isn't, then ignore it and keep on going. if(msg.wParam == FINISHEDUI_SIG) { return (UINT)(msg.lParam); } } TranslateMessage (&msg); DispatchMessage (&msg); } 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. wParam has boolean indicating success/failure. // If wParam indicates success then lParam is a real waitable // handle for the UI thread. if(WaitForPostedThreadMessage(&msg,WMX_PROGRESSTHREAD)) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); if(msg.wParam) { // We'd better have been given a valid UI thread handle... MYASSERT(msg.lParam); Context->UiThreadHandle = (HANDLE)msg.lParam; } return (UINT)(msg.wParam); } else { SetLastError(ERROR_INVALID_DATA); return FALSE; } } } 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: 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: // Only need one filename line. // (jamiehun) BUGBUG!!!???? the actual operation seems to use 2! 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 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; 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); ConcatenatePaths(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); #ifdef UNICODE if(rc && (Buffer[rc-1] == TEXT('\\'))) { Buffer[rc-1] = 0; } rc = lstrlen(NeedMedia.PathOut); if(rc && (NeedMedia.PathOut[rc-1] == TEXT('\\'))) { NeedMedia.PathOut[rc-1] = 0; } #else 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 '\' } #endif 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] = 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; SetProp(hdlg,DialogPropName,(HANDLE)context); // 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 = MyGetFileTitle(filePaths->Source); i = lstrlen(message); if((i > 8) && ((TCHAR)CharUpper((LPTSTR)message[0]) == TEXT('S')) && ((TCHAR)CharUpper((LPTSTR)message[1]) == TEXT('E')) && ((TCHAR)CharUpper((LPTSTR)message[2]) == TEXT('T')) && ((TCHAR)CharUpper((LPTSTR)message[3]) == TEXT('P')) && !lstrcmpi(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. i = GetLocaleInfo( MAKELCID(LOWORD(context->Param2),SORT_DEFAULT), LOCALE_SLANGUAGE, SourceLangName, SIZECHARS(SourceLangName) ); if(!i) { LoadString( MyDllModuleHandle, IDS_UNKNOWN_PARENS, SourceLangName, SIZECHARS(SourceLangName) ); } i = GetLocaleInfo( MAKELCID(HIWORD(context->Param2),SORT_DEFAULT), LOCALE_SLANGUAGE, TargetLangName, SIZECHARS(TargetLangName) ); if(!i) { LoadString( MyDllModuleHandle, IDS_UNKNOWN_PARENS, 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: OutOfMemory( IsWindow(context->QueueContext->ProgressDialog) ? context->QueueContext->ProgressDialog : context->QueueContext->OwnerWindow ); EndDialog(hdlg,IDNO); // skip this file return TRUE; } VOID 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) { 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); } PostThreadMessage (Context->MainThreadId, WMX_FINISHEDUI, FINISHEDUI_SIG, 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); SetProp(hdlg,DialogPropName,(HANDLE)Context); #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. CenterWindowRelativeToParent(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); PostThreadMessage(Context->MainThreadId,WMX_PROGRESSTHREAD,TRUE,(LPARAM)h); PostMessage(hdlg,WMX_HELLO,0,0); 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 { pPerformUi (Context, LOWORD(wParam), (PVOID)lParam); } 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 { OutOfMemory(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; PostThreadMessage(Context->MainThreadId, WMX_FINISHEDUI, FINISHEDUI_SIG, Context->CancelReturnCode ); } } else { if (Context->PendingUiType != UI_NONE) { pPerformUi ( Context, (UINT)Context->PendingUiType, Context->PendingUiParameters); Context->PendingUiType = UI_NONE; } } 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's lame and 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); } VOID CenterWindowRelativeToParent( HWND hwnd ) /*++ Routine Description: Centers a dialog relative to its owner, taking into account the 'work area' of the desktop. Arguments: hwnd - window handle of dialog to center Return Value: None. --*/ { RECT rcFrame, rcWindow; LONG x, y, w, h; POINT point; HWND Parent; Parent = GetWindow(hwnd,GW_OWNER); if(Parent == NULL) { return; } point.x = point.y = 0; ClientToScreen(Parent,&point); GetWindowRect(hwnd,&rcWindow); GetClientRect(Parent,&rcFrame); w = rcWindow.right - rcWindow.left + 1; h = rcWindow.bottom - rcWindow.top + 1; x = point.x + ((rcFrame.right - rcFrame.left + 1 - w) / 2); y = point.y + ((rcFrame.bottom - rcFrame.top + 1 - h) / 2); // Get the work area for the current desktop (i.e., the area that // the tray doesn't occupy). if(!SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&rcFrame, 0)) { // For some reason SPI failed, so use the full screen. rcFrame.top = rcFrame.left = 0; rcFrame.right = GetSystemMetrics(SM_CXSCREEN); rcFrame.bottom = GetSystemMetrics(SM_CYSCREEN); } if(x + w > rcFrame.right) { x = rcFrame.right - w; } else if(x < rcFrame.left) { x = rcFrame.left; } if(y + h > rcFrame.bottom) { y = rcFrame.bottom - h; } else if(y < rcFrame.top) { y = rcFrame.top; } MoveWindow(hwnd,x,y,w,h,FALSE); } 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->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->CurrentSourceName) { MyFree(context->CurrentSourceName); } 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; PQUEUECONTEXT context = Context; MSG msg; VERDLGCONTEXT dialogContext; DWORD waitResult; 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. WaitForPostedThreadMessage(&msg,WMX_PROGRESSTHREAD); 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: 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; 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); } // Also need undecorated version for apps that were linked before // we had A and W versions. #undef SetupDefaultQueueCallback UINT SetupDefaultQueueCallback( IN PVOID Context, IN UINT Notification, IN UINT Param1, IN UINT Param2 ) { #ifdef UNICODE return(SetupDefaultQueueCallbackW(Context,Notification,Param1,Param2)); #else return(SetupDefaultQueueCallbackA(Context,Notification,Param1,Param2)); #endif }