Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Package Property Overrides
#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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.