userdialog.cpp

来自「把doc文档转成pdf后刻录成CD,用VC++开发,用了Nero的SDK和CXI」· C++ 代码 · 共 473 行

/******************************************************************************
|* THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|* ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|* PARTICULAR PURPOSE.
|* 
|* Copyright 1995-2004 Ahead Software AG. All Rights Reserved.
|*-----------------------------------------------------------------------------
|* NeroSDK / NeroCmd
|*
|* PROGRAM: UserDialog.cpp
|*
|* PURPOSE: Interaction with the user
******************************************************************************/


#include "stdafx.h"
#include "BurnContext.h"
#include "Response.h"

// IMPORTANT: Unimplemented DLG_ROBO_xxx messages !!!
// 


NeroUserDlgInOut NERO_CALLBACK_ATTR CBurnContext::UserDialog (void* pUserData, NeroUserDlgInOut type, void *data)
{
	_ASSERTE (pUserData != NULL);
	CBurnContext * pBurnContext = (CBurnContext*)pUserData;
	const bool bUserInteraction = pBurnContext->m_params->GetUserInteraction ();

	printf ("\r                                                                                \r");

	switch (type)
	{
		case DLG_AUTO_INSERT:
			{
				static const CResponsePairs mapping[] = 
				{ 
					"Install drivers & restart", DLG_RETURN_INSTALL_DRIVER,
					"Turn off & restart", DLG_RETURN_OFF_RESTART,
					"Exit", DLG_RETURN_EXIT,
					"Continue at own risk", DLG_RETURN_CONTINUE,
					NULL
				};

				puts ("Auto Insert Notification is turned on in the system configuration.\n"
					"This may cause serious problems while burning: your CD might be damaged,\n"
					"or the system might hang up.\n"
					"\n"
					"Nero is able to burn CDs with Auto Insert Notification turned on if all\n"
					"necessary drivers are installed.\n"
					"\n"
					"You can do the following:\n"
					"Install drivers and restart Windows\n"
					"Turn off Auto Insert Notification and restart Windows\n"
					"Exit Nero\n"
					"Continue at your own risk\n");

				CResponse response (mapping, 2);

				return response;
			}
		case DLG_DISCONNECT_RESTART:
		case DLG_DISCONNECT:
			{
				puts ("Disconnect is turned off in the system configuration.\n"
					"This may cause serious problems while burning: your CD\n"
					"might be damaged, or the system might hang up.\n");
				
				if (DLG_DISCONNECT_RESTART == type)
				{
					static const CResponsePairs mapping[] = 
					{ 
						"Turn on & restart", DLG_RETURN_ON_RESTART,
						"Don't turn on & restart\n", DLG_RETURN_RESTART,
						NULL
					};

					CResponse response (mapping, 0);

					return response;
				}
				else
				{
					static const CResponsePairs mapping[] = 
					{ 
						"Turn on & restart", DLG_RETURN_ON_RESTART,
						"Don't turn on & restart", DLG_RETURN_RESTART,
						"Continue at own risk", DLG_RETURN_CONTINUE,
						NULL
					};

					CResponse response (mapping, 0);

					return response;
				}
			}

		case DLG_AUTO_INSERT_RESTART:
			{
				puts ("Auto Insert Notification is now OFF. You should restart Windows.\n");

				CResponseOkay response;

				return response;
			}

		case DLG_RESTART:
			{
				puts ("Please restart Windows now.\n");

				CResponseOkay response;
				
				return response;
			}

		case DLG_SETTINGS_RESTART:
			{
				static const CResponsePairs mapping[] = 
				{ 
					"Restart", DLG_RETURN_RESTART,
					"Continue at own risk", DLG_RETURN_CONTINUE,
					NULL
				};
				
				puts ("Nero detected some modifications of your PC system configuration\n"
					"and needs to modify some settings. Please restart your PC to make\n"
					"the changes become effective.\n");

				CResponse response (mapping, 0);
				
				return response;
			}

		case DLG_OVERBURN:
			{
				puts ("Sorry, this compilation contains too much data to fit on the CD\n"
					"with respect to the normal CD capacity. Do you want to try\n"
					"overburn writing at your own risk (this might cause read\n"
					"errors at the end of the CD or might even damage your recorder)?\n\n"
					"Note: It is also possible, that SCSI/Atapi errors occur at the end\n"
					"of the simulation or burning. Even in this case there is a certain\n"
					"chance, that the CD is readable.\n");

				const DLG_OVERBURN_INFO * pInfo = (const DLG_OVERBURN_INFO *) data;
				_ASSERTE (pInfo != NULL);

				printf ("Total blocks to be written: %d\n", pInfo->dwTotalBlocksOnCD);
				printf ("Free capacity in blocks: %d\n", pInfo->dwTotalCapacity);

				CResponseYesNoDefaultIsYes response;
				
				return response;
			}

		case DLG_COPY_QUALITY_LOSS:
			{
				puts( "Disc must be written as 'track at once' ('disc at once' not\n"
					"supported or not able to write such a disc). This means\n"
					"there might be some minor quality loss (e.g. lost audio index\n"
					"or different pause between audio tracks). Do you want to\n"
					"proceed anyway?\n");

				CResponseYesNoDefaultIsYes response;
				
				return response;
			}
			
		case DLG_COPY_FULLRISK:
			{
				puts( "Disc must be written as 'track at once' ('disc at once' not\n"
					"supported or not able to write such a disc).  Unfortunately\n"
					"your image has a special format which can most likely only\n"
					"be written correctly with 'disc at once'. But you may\n"
					"PROCEED AT YOUR OWN RISK. Do you want to continue\n"
					"burning?\n");

				CResponseYesNoDefaultIsYes response;
				
				return response;
			}

		case DLG_AUDIO_PROBLEMS:
			{
				if (((DWORD)data) & AUP_NOTRACK_FOUND)
				{
					puts ("No tracks given.");
					return DLG_RETURN_EXIT;
				}
				if (((DWORD)data) == AUP_MEGA_FATAL)
				{
					puts ("fatal internal problem");
					return DLG_RETURN_EXIT;
				}
				
				puts ("Nero has detected that the following audio properties are not\n"
					"supported by your recorder in the current write mode and need\n"
					"to be modified:");

				if (((DWORD)data) & AUP_FIRST_TR_PAUSE) puts ("- CD specification allows only 2-3 Seconds pause for the first track");
				if (((DWORD)data) & AUP_PAUSE_SETTINGS) puts ("- Pause length between the tracks not supported");
				if (((DWORD)data) & AUP_INDEX_SETTINGS) puts ("- Additional index positions not supported");
				if (((DWORD)data) & AUP_ISRC_SETTINGS) puts ("- ISRC codes not supported");
				if (((DWORD)data) & AUP_COPYPROT_SETTINGS) puts ("- Copy protection bit not supported");
				
				puts ("Nero can change the audio track settings for you to fit the\n"
					"capabilities of your recorder. This might cause some audio\n"
					"properties to be lost. Do you want Nero to change the track\n"
					"settings for you?\n");

				CResponseYesNoDefaultIsYes response;
				
				return response;
			}
			
		case DLG_WAITCD:
			{
				NERO_WAITCD_TYPE waitcdType = (NERO_WAITCD_TYPE) (int)data;

				LPCSTR psText = NeroGetLocalizedWaitCDTexts (waitcdType);
				if (psText != NULL)
				{
					printf("\n%s\n", psText);
					NeroFreeMem ((void *) psText);
				}

				if (!bUserInteraction &&
					waitcdType != NERO_WAITCD_AUTOEJECTLOAD &&
					waitcdType != NERO_WAITCD_WAITING)
				{
					// If there is supposed to be no user interaction,
					// wait cd dialog would never be dismissed. Abort the
					// burning process immediatelly (but only if waitcd
					// type actually designates some user interaction).
					// 
					pBurnContext->s_bAborted = true;
					pBurnContext->m_bPrintUserInteractionErrorMessage = true;
				}				
			}
			break;

		case DLG_WAITCD_REMINDER:
			printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\b");
			break;

		case DLG_WAITCD_DONE:
			// nothing to be done in the text interface,
			// should close dialog box in a GUI
			break;

		case DLG_FILESEL_IMAGE:
			{
				printf ("Enter file name to save image to: ");

				LPCSTR psImageFilename = pBurnContext->m_params->GetOutputImageFileName ();

				// Check if the image filename was supplied at command
				// line.
				// 
				if (NULL == psImageFilename)
				{
					if (!bUserInteraction)
					{
						// If there should be no user interaction, fail! We need
						// this filename and this can't be supplied automatically.
						// 
						printf ("<nothing specified>\n");
						pBurnContext->m_bPrintUserInteractionErrorMessage = true;
						return DLG_RETURN_EXIT;
					}
					else
					{
						fgets ((char *) data, 255, stdin);
						// Remove the carriage return
						((char *)data)[strlen((char *)data)-1]=0; 
					}
				}
				else
				{
					// First clear the supplied buffer.
					// 
					memset (data, 0, 256);
					
					// Then copy at most 255 characters.
					// 
					strncpy ((char *) data, psImageFilename, 255);
					puts ((char *) data);
				}

				return DLG_RETURN_TRUE;
			}

		case DLG_BURNIMAGE_CANCEL:
			printf("There is not enough space available to burn the image.\n");
			break;

		case DLG_NON_EMPTY_CDRW:
		{
			static const CResponsePairs mapping[] = 
			{ 
				"Erase disc", DLG_RETURN_CONTINUE,
				"Eject disc", DLG_RETURN_RESTART,
				"Cancel", DLG_RETURN_EXIT,
				NULL
			};

			NeroUserDlgInOut res;

			puts ("This disc is not empty.");

			// Do not ask the user if the --force_erase_cdrw
			// command line parameter has been provided

			// pUserData holds a pointer to CBurnContext which we set 
			// when initializing NeroAPI.
			// We need this pointer to obtain settings and handles
			// from the CBurnContext class.

			if (((CBurnContext*)pUserData)->m_params->GetForceEraseCDRW())
			{
				res = DLG_RETURN_CONTINUE;
			}
			else
			{
				CResponse response (mapping, 2);

				res = response;
			}

			if (DLG_RETURN_CONTINUE == res)
			{
				// Erase the disc

				NEROAPI_CDRW_ERASE_MODE mode = NEROAPI_ERASE_QUICK;

				int time = NeroGetCDRWErasingTime(((CBurnContext*)pUserData)->m_NeroDeviceHandle,mode);

				// If time is negative, it means error.
				//
				switch (time)
				{
				case -1:
					puts("No disc inserted!");
					res = DLG_RETURN_RESTART;
					break;

				case -2:
					puts("This recorder does not support rewritable discs!");
					res = DLG_RETURN_EXIT;
					break;

				case -3:
					puts ("The inserted disc is NOT rewritable!");
					res = DLG_RETURN_RESTART;
					break;

				default:
					if (time < 0)
					{
						// If this is some unknown error (negative value)
						// we should print generic error message and not
						// even attepmt erasing.
						// 
						puts ("Unknown error while trying to erase disc!");
					}
					else
					{
						// If the value is positive, it is the approximate
						// second count the process will take.
						// 
						printf("Erasing disc. This will take %d seconds.\n",time);
						
						int err = NeroEraseDisc (((CBurnContext*)pUserData)->m_NeroDeviceHandle, mode, 0, NULL);
						if (err)
						{
							puts("Error erasing the disc");

							// There was an error erasing the disc so quit.
							// 
							res = DLG_RETURN_EXIT;
						}
					}
				}
			}

			if (res == DLG_RETURN_CONTINUE ||
				res == DLG_RETURN_RESTART)
			{
				// If aborted flag was set in DLG_WAITCD, reset it here
				// because we have successfully erased/ejected a rewritable
				// disc and the process can now continue. Idle callback
				// obviously hasn't yet been called at this point so
				// playing with the aborted flag had no influence on NeroAPI.
				// 
				pBurnContext->s_bAborted = false;
				pBurnContext->m_bPrintUserInteractionErrorMessage = false;
			}

			return res;
		}

		case DLG_WAITCD_MEDIA_INFO:
			{
				const NERO_DLG_WAITCD_MEDIA_INFO * pMediaInfo = (const NERO_DLG_WAITCD_MEDIA_INFO *) data;

				printf ("Last detected media: %s\n", pMediaInfo->ndwmiLastDetectedMediaName);
				printf ("Requested media: %s\n", pMediaInfo->ndwmiRequestedMediaName);

				// The return value is ignored.
				// 
			}
			break;

		case DLG_COMP_REC_CONFLICT:
			puts ("The compilation cannot be written on this recorder! "
					"You should modify your compilation settings or burn "
					"the disc on another recorder, that supports the required medium type.");
			break;

		case DLG_WRONG_MEDIUM:
			puts ("Another type of medium must be used to burn this compilation!");
			break;

		case DLG_MESSAGEBOX:
			{
				const NERODLG_MESSAGEBOX * pMsgBox = (const NERODLG_MESSAGEBOX *) data;
				_ASSERTE (pMsgBox != NULL);

				if (pMsgBox != NULL)
				{
					// Construct a generic reponse according to the parameters
					// passed.
					// 
					CResponseGeneric response (pMsgBox->type, pMsgBox->defaultReturn);

					// If data was interpreted correctly, proceed. If not, the
					// default handling will take place.
					// 
					if (response.IsOk ())
					{
						// Translate the icon type into a character.
						// 
						char chIcon;
						switch (pMsgBox->icon)
						{
						case NDIT_INFO:
							chIcon = 'i';
							break;
						case NDIT_WARNING:
							chIcon = '!';
							break;
						case NDIT_QUESTION:
							chIcon = '?';
							break;
						case NDIT_ERROR:
						default:
							chIcon = 'E';
						}

						// Print the message and ask for a response.
						// 
						printf ("[%c] %s\n", chIcon, pMsgBox->message);

						return response;
					}
				}
			}
			break;
	}

	return DLG_RETURN_NOT_HANDLED;
}