internal PublishStatusControl(HighlightObject highlightObject, PublishWorker.PublishWorkerTypes publishWorkerType)
: this(highlightObject)
{
this.publishWorkerType = publishWorkerType;
ConnectEvents();
}
internal SaveWorker(HighlightObject highlightObject)
: base(highlightObject)
{
double framesToSave = (highlightObject.EndTime - highlightObject.StartTime).TotalSeconds * highlightObject.InputFileObject.FramesPerSecond;
TotalProgressUnits = framesToSave;
OutputFormat = OutputFormats.Original; // default
}
void OnEnable()
{
this.highLight = gameObject.GetComponent <HighlightObject>();
if (this.highLight == null)
{
gameObject.AddComponent <HighlightObject>();
gameObject.GetComponent <HighlightObject>().SwithHightlight(false);
}
EasyTouch.On_SimpleTap += ShowMediaInfoPanel;
}
internal PublishStatusControl(HighlightObject highlightObject)
{
InitializeComponent();
this.BackColor = Color.Transparent; // so we can see it in the designer
DesignLanguage.ApplyCustomFont(this.Controls);
this._highlightObject = highlightObject;
ShowOpenHighlight();
}
private void OnTriggerExit(Collider other)
{
if (other.gameObject.layer == 15)
{
HighlightObject highlightComponent = other.GetComponent <HighlightObject>();
if (highlightComponent != null)
{
highlightComponent.DeSelect();
}
grabbable = null;
}
}
private void UpdateHighlights()
{
highlightObjects.Clear();
// Add highlight to each object and cache reference
foreach (GameObject obj in nextInteractions)
{
HighlightObject highlight = obj.AddComponent <HighlightObject>();
highlight.SetColor(highlightColor);
highlight.SetOutlineWidth(outlineWidth);
highlightObjects.Add(highlight);
}
}
private void OnTriggerEnter(Collider other)
{
if (other.gameObject.layer == 15)
{
if (grabbable != null)
{
grabbable.GetComponent <HighlightObject>().DeSelect();
}
grabbable = other.gameObject;
HighlightObject highlightComponent = grabbable.GetComponent <HighlightObject>();
if (highlightComponent != null)
{
highlightComponent.Select();
}
}
}
public void ShowHint(int state)
{
if (tutorialNumber < 8)
{
return;
}
if (state == 1)
{
UpdateCoins(-20);
negativeCoinChange = 0;
HighlightObject.StopIt();
hintBox.SetActive(true);
//hintBox.GetComponentInChildren<Text>().text =
}
else
{
hintBox.SetActive(false);
}
}
internal PublishWorker(HighlightObject highlightObject)
{
HighlightObject = highlightObject;
Id = DateTime.Now.Ticks; // (new Random()).Next();
Logger.Info("Starting new " + this.GetType().Name + "[" + Id + "] on " + highlightObject.InputFileObject.SourceFileInfo.FullName);
#if DEBUG
Logger.Info("At bookmarkTime " + highlightObject.BookmarkTime.TotalSeconds);
#endif
// do this in main thread
activationState = Protection.GetLicenseStatus(true);
WorkerReportsProgress = true;
WorkerSupportsCancellation = true;
DoWork += new DoWorkEventHandler(PublishWorker_DoWork);
PublishWorkerResult = PublishWorkerResults.NotFinished;
}
/// <summary>
/// Coroutine which adjusts the highlights and stability pointer on the number line during a stability update.
/// </summary>
/// <param name="numerator">Numerator of affecting fraction</param>
/// <param name="denominator">Denominator of affecting fraction</param>
/// <param name="color">Highlight Color</param>
/// <param name="isAdd">If it is addition operation.</param>
/// <param name="block">Ghost Block affecting the stability.</param>
/// <param name="isInstant">If the process should be done instantly.</param>
/// <returns>None</returns>
public IEnumerator ManipulateStability(float numerator, float denominator, Color color, bool isAdd, HollowBlock block, bool isInstant)
{
Debug.LogError("Entered manipulate");
block.ProcessBlock();
if (isAdd)
{
Debug.LogError("INSTANT ADD");
//Debug.Log("<color=pink>INSTANT ADD</color>");
HighlightObject highlight = new HighlightObject(numerator, denominator, color, isAdd, block);
//float endPosition = this.GetLineLength() * numerator / denominator / GetMaxPoint();
//float endPosition = (this.GetLineLength() / (GetMaxPoint() + 1)) * numerator / denominator;
//float otherEndPosition = this.GetLineLength() * GetNumerator() / GetDenominator() / GetMaxPoint();
//float startPosition = this.GetHighlightEnd();
//Debug.Log("<color=pink>start position is </color>" + startPosition);
//Debug.Log("<color=pink>end position is </color>"+endPosition);
//Debug.Log("<color=pink>original end position was </color>" + otherEndPosition);
// Added highlight's start position will be the end position of the last highlight
yield return(StartCoroutine(AddStabilityInstant(numerator, denominator, color)));
//this.AddHighlightInstant(numerator, denominator, color, startPosition, endPosition);
//StartCoroutine(AddHighlight(numerator, denominator, color, startPosition, endPosition));
block.ProcessingDone();
}
else
{
Debug.LogError("INSTANT SUBTRACT");
//Debug.Log("<color=pink>INSTANT SUBTRACT</color>");
HighlightObject highlight = new HighlightObject(numerator, denominator, color, isAdd, block);
yield return(StartCoroutine(SubtractStabilityInstant(numerator, denominator, color)));
block.ProcessingDone();
}
yield return(null);
}
internal FacebookShareWorker(HighlightObject highlightObject)
: base(highlightObject)
{
}
private void HighlightObject(HighlightObject highlightObject, bool highlight)
{
if (highlight)
{
if (highlightObject.Highlight != null)
{
highlightObject.Highlight.gameObject.SetActive(true);
}
else if (highlightObject.Object != null)
{
var renderer = highlightObject.Object.GetComponent<Renderer>();
if (renderer != null && renderer.material != null)
{
renderer.material.color = _highlightColor;
}
}
highlightObject.Highlighted = true;
}
else
{
if (highlightObject.Highlight != null)
{
highlightObject.Highlight.gameObject.SetActive(false);
}
if (highlightObject.Object != null)
{
var renderer = highlightObject.Object.GetComponent<Renderer>();
if (renderer != null && renderer.material != null)
{
renderer.material.color = highlightObject.StandardColor;
}
}
highlightObject.Highlighted = false;
}
}
private void AddHighlightToPanel(HighlightObject highlightObject)
{
var highlightThumbnailControl = new HighlightThumbnailControl();
highlightThumbnailControl.HighlightObject = highlightObject;
highlightThumbnailControl.HighlightDetailsOpening += highlightThumbnailControl_HighlightDetailsOpening;
highlightThumbnailControl.HighlightRemoved += new HighlightThumbnailControl.HighlightRemovedEventHandler(highlightThumbnailControl_HighlightRemoved);
highlightThumbnailControl.Margin = Padding.Empty;
innerHighlightsPanel.Controls.Add(highlightThumbnailControl);
highlightThumbnailControl.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; // this must be set after we add the control, otherwise it doesn't stick
if (highlightObject.HighlightObjectIndex == 0)
highlightThumbnailControl.ShowPlayOverlay();
}
private void RemoveHighlight(HighlightObject highlightObject)
{
// remove control
foreach (Control c in innerHighlightsPanel.Controls)
{
var h = c as HighlightThumbnailControl;
if (h != null && h.HighlightObject == highlightObject)
{
innerHighlightsPanel.Controls.Remove(h);
h.Dispose();
h = null;
}
}
// remove from HighlightObjects
MainModel.HighlightObjects.Remove(highlightObject);
// recount highlightObjectIndex
var newIndex = 0;
foreach (var objects in MainModel.HighlightObjects)
{
objects.HighlightObjectIndex = newIndex++;
}
// update divider
foreach (Control c in innerHighlightsPanel.Controls)
{
var d = c as HighlightDividerBarControl;
if (d != null && d.InputFileObject == highlightObject.InputFileObject)
d.RefreshHighlightCount();
}
}
public OnHighlightClick(HighlightObject _highlight)
{
highlight = _highlight;
}
private void HighlightObject(HighlightObject highlightObject, bool highlight)
{
if (highlight)
{
foreach (var highlighted in _highlightObjects)
{
highlighted.DeHighlight();
}
highlightObject.Highlight();
//else if (highlightObject.Object != null)
//{
// var renderer = highlightObject.Object.GetComponent<Renderer>();
// if (renderer != null && renderer.material != null)
// {
// renderer.material.color = _highlightColor;
// }
//}
//highlightObject.Highlighted = true;
}
//else
//{
// //highlighted.Highlighted = false;
// //if (highlightObject.Highlight != null)
// //{
// // highlightObject.Highlight.gameObject.SetActive(false);
// //}
// //if (highlightObject.Object != null)
// //{
// // var renderer = highlightObject.Object.GetComponent<Renderer>();
// // if (renderer != null && renderer.material != null)
// // {
// // renderer.material.color = highlightObject.StandardColor;
// // }
// //}
// //highlightObject.Highlighted = false;
//}
}
// Update is called once per frame
void Update()
{
if (tutorialNumber < 8)
{
tutorialBoxes[tutorialNumber].SetActive(true);
HighlightObject.Highlight(tutorialNumber);
}
else
{
HighlightObject.StopIt();
if (coins < coinsTarget)
{
coins++;
}
else if (coins > coinsTarget)
{
coins--;
}
totalCoins.GetComponentInChildren <Text>().text = coins.ToString();
if (!paused)
{
negativeCoinChange += Time.deltaTime;
time += Time.deltaTime;
if (negativeCoinChange > 5.0f)
{
HighlightObject.Highlight(1);
}
}
if (level == 0)
{
var firstNotSecond = ports.Except(SolutionPorts).ToList();
var secondNotFirst = SolutionPorts.Except(ports).ToList();
if (!firstNotSecond.Any() && !secondNotFirst.Any())
{
ShowNmapScan(0);
ShowPortBlocker(0);
feedbackBox.GetComponentInChildren <Text>().text = "Nice! You have completed this level";
feedbackBox.SetActive(true);
}
}
if (level == 2)
{
if (!levelPassed)
{
IPSliderWindow.SetActive(true);
}
else
{
IPSliderWindow.SetActive(false);
feedbackBox.GetComponentInChildren <Text>().text = "Nice! You have completed this level";
feedbackBox.SetActive(true);
}
}
if (level == 1)
{
if (!levelPassed)
{
GraphWindow.SetActive(true);
}
else
{
GraphWindow.SetActive(false);
feedbackBox.GetComponentInChildren <Text>().text = "Nice! You have completed this level";
feedbackBox.SetActive(true);
}
}
}
}
/// <summary>
/// Collapse nearby frame locations into single frames
/// </summary>
/// <param name="darkFrameNumbers"></param>
/// <param name="captureDurationInSeconds"> </param>
/// <param name="ignoreEarlyHighlights"> </param>
/// <param name="useCaptureOffset"> </param>
/// <returns>Number of highlights created</returns>
internal int CreateHighlightObjects(List<long> darkFrameNumbers,
int captureDurationInSeconds, bool ignoreEarlyHighlights,
bool useCaptureOffset)
{
if (MainModel.IsAuthorized() == false)
throw new Exception("Odessa Engine Not Authorized!");
#region print input (DEBUG only)
#if DEBUG
Logger.Info("Results of collapsing:");
for (int darkFrameIndex = 0; darkFrameIndex < darkFrameNumbers.Count; darkFrameIndex++)
{
//Application.DoEvents(); // REMED out on 7/27/11 because this is no longer on app thread
var darkFrameTimeSpan = TimeSpan.FromSeconds(darkFrameNumbers[darkFrameIndex] / InputFileObject.FramesPerSecond);
Logger.Info("Dark frames at " + darkFrameNumbers[darkFrameIndex] +
" (" + darkFrameTimeSpan.ToString() + ")");
}
#endif
#endregion print input (DEBUG only)
#region see if we should ignore early highlights
int earlyHighlightTimeframeInSeconds = 0;
if (ignoreEarlyHighlights)
{
earlyHighlightTimeframeInSeconds = 10; // we ignore all highlights within 10 seconds of start
Logger.Info("Removing early highlights");
}
/* I think we should just turn it off. It's too deceiving because it can hide what's really going on
#if RELEASE // when testing, *NEVER* ignore highlights. otherwise this gives us a false perception of false positives
else
{
earlyHighlightTimeframeInSeconds = 2; // always ignore highlights within first 2 seconds
Logger.Info("Keeping early highlights but ignoring before 2 seconds");
}
#endif
*/
var earlyHighlightFrameNumber = (int)(earlyHighlightTimeframeInSeconds * InputFileObject.FramesPerSecond);
Logger.Info("Removing highlights before frame " + earlyHighlightFrameNumber);
for (int blackFrameIndex = 0; blackFrameIndex < darkFrameNumbers.Count; blackFrameIndex++)
{
if (darkFrameNumbers[blackFrameIndex] < earlyHighlightFrameNumber)
{
darkFrameNumbers.RemoveAt(blackFrameIndex);
blackFrameIndex--;
}
}
#endregion see if we should ignore early highlights
#region print output (DEBUG only)
#if DEBUG
Logger.Info("Results of threshold validation and early highlight removal:");
for (int darkFrameIndex = 0; darkFrameIndex < darkFrameNumbers.Count; darkFrameIndex++)
{
var darkFrameTimeSpan = TimeSpan.FromSeconds((darkFrameNumbers[darkFrameIndex] / InputFileObject.FramesPerSecond));
Logger.Info("Dark frames at " + darkFrameNumbers[darkFrameIndex] +
" (" + darkFrameTimeSpan.ToString() + ")");
}
#endif
#endregion print output (DEBUG only)
#region now that we've removed ones that are too close, let's create the HighlightObject
foreach (long darkFrame in darkFrameNumbers)
{
const double captureOffsetInSeconds = 0; // 0.5; let's get right up to the bookmark
// let's capture another few seconds so we see the user's hand cover the lens
// how long before the bookmark should we end the highlight?
double secondsBeforeBookmark = 2.0;
/*
int captureOffsetInFrames = 0;
if (useCaptureOffset)
captureOffsetInFrames = (int)(captureOffsetInSeconds * InputFileObject.FramesPerSecond);
long framesAfterDarkFrame = (long)(InputFileObject.VideoDurationInSeconds * InputFileObject.FramesPerSecond) - darkFrame;
long adjustedDarkFrame = darkFrame;
if (framesAfterDarkFrame > captureOffsetInFrames)
{
// we can add the full offset
adjustedDarkFrame += captureOffsetInFrames;
}
else
{
// we can only add the number of frames after the ending frame
adjustedDarkFrame += framesAfterDarkFrame;
}
*/
var bookmarkTimeSpan = TimeSpan.FromSeconds(darkFrame / InputFileObject.FramesPerSecond);
if (useCaptureOffset)
bookmarkTimeSpan = bookmarkTimeSpan.Add(TimeSpan.FromSeconds(captureOffsetInSeconds));
if (bookmarkTimeSpan.TotalSeconds > InputFileObject.VideoDurationInSeconds)
bookmarkTimeSpan = TimeSpan.FromSeconds(InputFileObject.VideoDurationInSeconds);
var endTimeSpan = bookmarkTimeSpan.Subtract(TimeSpan.FromSeconds(secondsBeforeBookmark));
if (endTimeSpan.TotalSeconds < 0)
endTimeSpan = bookmarkTimeSpan;
if (endTimeSpan.TotalSeconds < secondsBeforeBookmark)
endTimeSpan = TimeSpan.FromSeconds(secondsBeforeBookmark);
var startTimeSpan = endTimeSpan.Subtract(TimeSpan.FromSeconds(captureDurationInSeconds));
if (startTimeSpan.TotalSeconds < 0)
startTimeSpan = TimeSpan.Zero;
var highlightObject = new HighlightObject();
highlightObject.InputFileObject = InputFileObject;
highlightObject.BookmarkTime = bookmarkTimeSpan;
highlightObject.StartTime = startTimeSpan;
highlightObject.EndTime = endTimeSpan;
highlightObject.GenerateHighlightTitle(); // do this before adding
MainModel.HighlightObjects.Add(highlightObject);
#if DEBUG
Logger.Info("Adding new highlight from " + highlightObject.StartTime.ToString() + " " +
"to " + highlightObject.EndTime.ToString() +
" with bookmark = " + highlightObject.BookmarkTime.ToString());
#endif
}
#endregion now that we've removed ones that are too close, let's create the HighlightObject
return darkFrameNumbers.Count;
}
internal HighlightEventArgs(HighlightObject highlightObject)
{
this.HighlightObject = highlightObject;
}
