Package Property Overrides

gistfile1.cs

#region Default Package Properties

/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowFinishButton"/> for a full description..
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowFinishButton(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowCloseItem"/> for a full description..
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowCloseItem(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowHelp"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowHelp(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowProgressBar"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.YES"/> for a multi-SCO SCORM 1.2 package, otherwise it returns <see cref="YesNoValue.NO"/>.</returns>
public override YesNo DefaultShowProgressBar(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco || 
		learningStandard.IsScorm2004() ||
		learningStandard.IsAICC())
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultUseMeasureProgressBar"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>Value indicate whether to use a measure progress bar or not in the UI<see cref="YesNoValue.NO"/>.</returns>

public override YesNo DefaultUseMeasureProgressBar(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.Is20044thOrGreater())
    {
        return new YesNo(YesNoValue.YES);
    }
    else
    {
        return new YesNo(YesNoValue.NO);
    }
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowCourseStructure"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowCourseStructure(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultCourseStructureStartsOpen"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultCourseStructureStartsOpen(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowNavBar"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowNavBar(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultShowTitleBar"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultShowTitleBar(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultEnableFlowNav"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO or AICC course, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultEnableFlowNav(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco || learningStandard.IsAICC())
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultEnableChoiceNav"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/> for a single SCO, otherwise it returns <see cref="YesNoValue.YES"/>.</returns>
public override YesNo DefaultEnableChoiceNav(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return new YesNo(YesNoValue.NO);
	}
	else
	{
		return new YesNo(YesNoValue.YES);
	}	
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultDesiredWidth"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns> This implementation returns 960 for a single SCO, otherwise it returns 660.
/// These are the best defaults for a screen with 1024x768 resolution. The difference in width between a single and muli-SCO course is to account for the course outline
/// being shown by default for a multi-SCO course.</returns>
public override int DefaultDesiredWidth(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return 960;
	}
	else
	{
		return 660;
	}	

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultDesiredHeight"/> for a full description. 
/// This is the best default for a screen with 1024x768 resolution.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns 600.</returns>
public override int DefaultDesiredHeight(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return 600;
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultDesiredFullScreen"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.NO"/>.</returns>
public override YesNo DefaultDesiredFullScreen(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultCourseStructureWidth"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 0 for a single SCO, otherwise it returns 300.</returns>
public override int DefaultCourseStructureWidth(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco)
	{
		return 0;
	}
	else
	{
		return 300;
	}
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultScoLaunchType"/> for a full description. 
/// for a single SCO or AICC, otherwise it returns <see cref="LaunchTypeValue.FRAMESET"/>.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="LaunchTypeValue.NEW_WINDOW"/> </returns>
public override LaunchType DefaultScoLaunchType(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{

	if (singleSco || learningStandard.IsAICC())
	{
		return new LaunchType(LaunchTypeValue.NEW_WINDOW);
	}
	else
	{
		return new LaunchType(LaunchTypeValue.FRAMESET);
	}
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultScoLaunchType"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="LaunchTypeValue.FRAMESET"/>.</returns>
public override LaunchType DefaultPlayerLaunchType(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new LaunchType(LaunchTypeValue.FRAMESET);
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoSatisfiedNormalExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.GO_TO_NEXT_SCO"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoSatisfiedNormalExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.GO_TO_NEXT_SCO);
	}

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoSatisfiedSuspendExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoSatisfiedSuspendExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoSatisfiedTimeoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoSatisfiedTimeoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoSatisfiedLogoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.EXIT_COURSE_AFTER_CONFIRM"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoSatisfiedLogoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.EXIT_COURSE_AFTER_CONFIRM);
	}

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoNotSatisfiedNormalExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoNotSatisfiedNormalExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoNotSatisfiedSuspendExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoNotSatisfiedSuspendExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}

}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultIntermediateScoNotSatisfiedTimeoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoNotSatisfiedTimeoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}

}


/// <summary>
///  See <see cref="IntegrationInterface.DefaultIntermediateScoNotSatisfiedLogoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns> This implementation returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for SCORM 2004,
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC and
/// <see cref="ExitActionValue.EXIT_COURSE_AFTER_CONFIRM"/> for SCORM 1.2 or SCORM 1.1.</returns>
public override ExitAction DefaultIntermediateScoNotSatisfiedLogoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsScorm2004())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		return new ExitAction(ExitActionValue.EXIT_COURSE_AFTER_CONFIRM);
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseSatisfiedNormalExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DISPLAY_MESSAGE"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseSatisfiedNormalExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{

	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseSatisfiedSuspendExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseSatisfiedSuspendExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseSatisfiedTimeoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseSatisfiedTimeoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseSatisfiedLogoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns> This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.EXIT_COURSE"/>.</returns>
public override ExitAction DefaultFinalScoCourseSatisfiedLogoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseNotSatisfiedNormalExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseNotSatisfiedNormalExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseNotSatisfiedSuspendExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseNotSatisfiedSuspendExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseNotSatisfiedTimeoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.DISPLAY_MESSAGE"/>.</returns>
public override ExitAction DefaultFinalScoCourseNotSatisfiedTimeoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.DISPLAY_MESSAGE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinalScoCourseNotSatisfiedLogoutExitAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>
/// This implementation returns 
/// <see cref="ExitActionValue.DO_NOTHING"/> for AICC, 
/// otherwise if it is a single SCO, it returns <see cref="ExitActionValue.EXIT_COURSE"/>
/// otherwise, it returns <see cref="ExitActionValue.EXIT_COURSE"/>.</returns>
public override ExitAction DefaultFinalScoCourseNotSatisfiedLogoutExitAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsAICC())
	{
		return new ExitAction(ExitActionValue.DO_NOTHING);
	}
	else
	{
		if (singleSco)
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
		else
		{
			return new ExitAction(ExitActionValue.EXIT_COURSE);
		}
	}

}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultDisableRightClick"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultDisableRightClick(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultPreventWindowResize"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultPreventWindowResize(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultStatusDisplay"/> for a full description. 
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="StatusDisplayValue.SEPARATE"/>
/// for SCORM 2004, otherwise, it returns <see cref="StatusDisplayValue.COMBINED"/>.</returns>
public override StatusDisplay DefaultStatusDisplay(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (learningStandard.IsScorm2004())
	{
		return new StatusDisplay(StatusDisplayValue.SEPARATE);
	}
	else
	{
		return new StatusDisplay(StatusDisplayValue.COMBINED);
	}
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultScoreRollupMode"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="ScoreRollupMethodValue.AVERAGE_SCORE_OF_ALL_UNITS_WITH_SCORES"/></returns>
public override ScoreRollupMethod DefaultScoreRollupMode(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new ScoreRollupMethod(ScoreRollupMethodValue.AVERAGE_SCORE_OF_ALL_UNITS_WITH_SCORES, NullConstants.NullInt);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultStatusRollupMode"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="StatusRollupMethodValue.COMPLETE_WHEN_ALL_UNITS_COMPLETE_AND_NOT_FAILED"/> for SCORM courses 
/// and <see cref="StatusRollupMethodValue.COMPLETE_WHEN_ALL_UNITS_COMPLETE"/> for AICC</returns>
public override StatusRollupMethod DefaultStatusRollupMode(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsAICC())
    {
        // This rollup method most closely matches the original AICC rollup logic in the Registration class (when there
        // was only one way of doing AICC rollup and pkg props weren't used)
        return new StatusRollupMethod(StatusRollupMethodValue.COMPLETE_WHEN_ALL_UNITS_COMPLETE, NullConstants.NullDouble);
    }
    else
    {
        return new StatusRollupMethod(StatusRollupMethodValue.COMPLETE_WHEN_ALL_UNITS_COMPLETE_AND_NOT_FAILED, NullConstants.NullDouble);
    }
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultApplyRollupStatusToSuccess"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultApplyRollupStatusToSuccess(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFirstScoIsPretest"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultFirstScoIsPretest(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultWrapScoWindowWithApi"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultWrapScoWindowWithApi(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultFinishCausesImmediateCommit"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation always returns <see cref="YesNoValue.NO"/></returns>
public override YesNo DefaultFinishCausesImmediateCommit(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultDebugToCapture"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>Default values specified in the configuration repository under the "CONFIG_DEBUG" keys in <see cref="Constants"/></returns>
public override DebugToCapture DefaultDebugToCapture(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	DebugToCapture infoToCapture = new DebugToCapture();

	infoToCapture.ControlAudit = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_CONTROL_AUDIT));
	infoToCapture.ControlDetailed = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_CONTROL_DETAILED));

	infoToCapture.RteAudit = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_RTE_AUDIT));
	infoToCapture.RteDetailed = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_RTE_DETAILED));

   
    infoToCapture.SequencingAudit = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_SEQUENCING_AUDIT));
    infoToCapture.SequencingDetailed = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_SEQUENCING_DETAILED));

    if (learningStandard.Is20044thOrGreater()){
        //simple logs are only available starting with 4th Edition
        string defaultSimpleLogSetting;
        try
        {
            //put this config access in a try/catch to deal with upgrades that might not add the config setting
            defaultSimpleLogSetting = this.GetConfigurationSetting(Constants.CONFIG_DEBUG_SEQUENCING_DETAILED);
            infoToCapture.SequencingSimple = CommonFunctions.ConvertStringToBoolean(defaultSimpleLogSetting);
        }
        catch (ScormContentPlayerApplicationException)
        {
            infoToCapture.SequencingSimple = true;
        }
        

        if (infoToCapture.SequencingSimple == true)
        {
            infoToCapture.SequencingAudit = false;
            infoToCapture.SequencingDetailed = false;
        }

    }
    else{
        infoToCapture.SequencingSimple = false;
    }

	infoToCapture.LookAheadAudit = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_LOOKAHEAD_AUDIT));
	infoToCapture.LookAheadDetailed = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_LOOKAHEAD_DETAILED));	

	infoToCapture.IncludeTimestamps = CommonFunctions.ConvertStringToBoolean(this.GetConfigurationSetting(Constants.CONFIG_DEBUG_INCLUDE_TIMESTAMPS));	

	return infoToCapture;
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultCaptureHistory"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns true</returns>
public override YesNo DefaultCaptureHistory(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultCaptureHistoryDetailed"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns true</returns>
public override YesNo DefaultCaptureHistoryDetailed(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultCommMaxFailedSubmissions"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 2</returns>
public override int DefaultCommMaxFailedSubmissions(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return 2;
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultCommCommitFrequency"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns 10,000</returns>
public override int DefaultCommCommitFrequency(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return 10000;
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultInvalidMenuItemAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="InvalidMenuItemActionValue.DISABLE"/></returns>
public override InvalidMenuItemAction DefaultInvalidMenuItemAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new InvalidMenuItemAction(InvalidMenuItemActionValue.DISABLE);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultAlwaysFlowToFirstSco"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.YES"/> for a single sco package, and <see cref="YesNoValue.NO"/> otherwise.</returns>
public override YesNo DefaultAlwaysFlowToFirstSco(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (singleSco || learningStandard.Value == LearningStandardValue.SCORM_12)
	{
		return new YesNo(YesNoValue.YES);
	}
	else
	{
		return new YesNo(YesNoValue.NO);
	}
}
/// <summary>
/// See <see cref="IntegrationInterface.DefaultLogoutCausesPlayerExit"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="YesNoValue.YES"/></returns>
public override YesNo DefaultLogoutCausesPlayerExit(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultResetRunTimeData"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information.</param>
/// <returns>This implementation returns <see cref="ResetRunTimeDataTimingValue.WHEN_EXIT_IS_NOT_SUSPEND"/> for SCORM 2004 courses, <see cref="ResetRunTimeDataTimingValue.NEVER"/> for all other courses.</returns>
public override ResetRunTimeDataTiming DefaultResetRunTimeData(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if(learningStandard.IsScorm2004())
	{
		return new ResetRunTimeDataTiming(ResetRunTimeDataTimingValue.WHEN_EXIT_IS_NOT_SUSPEND);
	}
	else
	{
		return new ResetRunTimeDataTiming(ResetRunTimeDataTimingValue.NEVER);
	}
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultOfflineSynchMode"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override RsopSynchMode DefaultOfflineSynchMode(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new RsopSynchMode(RsopSynchModeType.Simple);
}


/// <summary>
/// See <see cref="IntegrationInterface.DefaultValidateInteractionResponses"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultValidateInteractionResponses(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultLookaheadSequencerMode"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override LookaheadSequencerMode DefaultLookaheadSequencerMode(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	if (learningStandard.IsScorm12())
	{
		return new LookaheadSequencerMode(LookaheadSequencerModeValue.REALTIME);
	}

	return new LookaheadSequencerMode(LookaheadSequencerModeValue.ENABLED);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultScoreOverridesStatus"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultScoreOverridesStatus(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.IsAICC())
    {
        return new YesNo(YesNoValue.YES);
    }
    else
    {
	return new YesNo(YesNoValue.NO);
}
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultAllowCompleteStatusChange"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultAllowCompleteStatusChange(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultScaleRawScore"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultScaleRawScore(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
	return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultRollupEmptySetToUnknown"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultRollupEmptySetToUnknown(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultReturnToLmsAction"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override ReturnToLmsAction DefaultReturnToLmsAction(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.Is20044thOrGreater())
    {
        return new ReturnToLmsAction(ReturnToLmsActionValue.Selectable);
    }
    else
    {
        return new ReturnToLmsAction(ReturnToLmsActionValue.Legacy);
    }
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultUseQuickLookaheadSequencer"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultUseQuickLookaheadSequencer(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultForceDisableRootChoice"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultForceDisableRootChoice(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultRollupRuntimeAtScoUnload"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultRollupRuntimeAtScoUnload(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.Value == LearningStandardValue.SCORM_12)
    {
        return new YesNo(YesNoValue.YES);
    }
    else
    {
    return new YesNo(YesNoValue.NO);
}
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultForceObjectiveCompletionSetByContent"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultForceObjectiveCompletionSetByContent(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultInvokeRollupAtSuspendAll"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultInvokeRollupAtSuspendAll(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultCompletionStatOfFailedSuccessStat"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override CompletionStatus DefaultCompletionStatOfFailedSuccessStat(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new CompletionStatus(CompletionStatusValue.Unknown);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultSatisfiedCausesCompletion"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultSatisfiedCausesCompletion(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// See <see cref="IntegrationInterface.DefaultMakeStudentPrefsGlobalToCourse"/> for a full description.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultMakeStudentPrefsGlobalToCourse(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.NO);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.LaunchCompletedRegsAsNoCredit"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultLaunchCompletedRegsAsNoCredit(LearningStandard learningStandard, bool singleSco,
                                                  ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.IsCompletionTracked"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultIsCompletionTracked(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.IsSatisfactionTracked"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultSatisfactionTracked(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.IsScoreTracked"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultIsScoreTracked(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.IsIncompleteScoreMeaningful"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultIsIncompleteScoreMeaningful(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting that should be used for the <see cref="PackageProperties.IsIncompleteSatisfactionMeaningful"/> package property when no other value is specified through
/// metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override YesNo DefaultIsIncompleteSatisfactionMeaningful(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    return new YesNo(YesNoValue.YES);
}

/// <summary>
/// Returns the default setting for the maximum permitted length in bytes for suspend data <see cref="RusticiSoftware.ScormContentPlayer.Logic.PackageProperties.SuspendDataMaxLength"/> 
/// when no other value is specified through metadata extensions.
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override int DefaultSuspendDataMaxLength(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    if (learningStandard.Value == LearningStandardValue.SCORM_2004_2ND_EDITION)
    {
        return 4000;  // Smallest permitted maximum for SCORM 2004 2nd ed.
    }
    else if (learningStandard.Value == LearningStandardValue.AICC
        || learningStandard.Value == LearningStandardValue.SCORM_12)
    {
        return 4096;   // Defined maximum for SCORM 1.2 and AICC
    }
    else
    {
        return 64000;  // Smallest permitted maximum for SCORM 2004 3rd and 4th ed.
    }
}

/// <summary>
/// Returns the default setting for the time limit for this course, specified in minutes
/// </summary>
/// <param name="learningStandard">The learning standard that governs delivery of the package</param>
/// <param name="singleSco">Will be true if there is only one SCO in the package (because this structure usually results in a different default setup)</param>
/// <param name="externalConfig">External configuration information that may be needed by the integration layer.</param>
/// <returns>Default setting for the property</returns>
public override int DefaultTimeLimit(LearningStandard learningStandard, bool singleSco, ExternalConfiguration externalConfig)
{
    //By default return 0, no limit;
    return 0;
}

#endregion