/// <summary>
/// Find matching ranges that contain timeToCheck
/// </summary>
/// <param name="timeToCheck"></param>
/// <returns></returns>
public IEnumerable <SlotTimeRange> MatchingRange(DateTime timeToCheck)
{
var returnValue = new List <SlotTimeRange>();
returnValue.AddRange(TimeRanges.Where(x => x.BeginDate <= timeToCheck && x.EndDate >= timeToCheck));
return(returnValue);
}
public DateBoundTimeRanges RemoveTimeRange(TimeRange timeRange)
{
var timeRangesTemp = TimeRanges.ToList();
for (var i = 0; i < timeRangesTemp.Count; i++)
{
var storedTimeRange = timeRangesTemp[i];
if (storedTimeRange.Equals(timeRange))
{
timeRangesTemp.RemoveAt(i);
i--;
}
else if (TimeRangeSplitsStoredTimeRange(timeRange, storedTimeRange))
{
var newTimeRangeLower = new TimeRange(storedTimeRange.StartTime, timeRange.StartTime - storedTimeRange.StartTime);
var newTimeRangeUpper = new TimeRange(timeRange.EndTime, storedTimeRange.EndTime - timeRange.EndTime);
timeRangesTemp.RemoveAt(i);
timeRangesTemp.AddRange(new[] { newTimeRangeUpper, newTimeRangeLower });
break;
}
else if (TimeRangeCutsStartOfStoredTimeRange(timeRange, storedTimeRange))
{
// storedTimeRange.StartTime = timeRange.EndTime;
var newTimeRange = new TimeRange(timeRange.EndTime, storedTimeRange.Duration);
timeRangesTemp[i] = newTimeRange;
}
else if (TimeRangeCutsEndOfStoredTimeRange(timeRange, storedTimeRange))
{
storedTimeRange.Duration -= storedTimeRange.EndTime - timeRange.StartTime;
timeRangesTemp[i] = storedTimeRange;
}
}
TimeRanges = timeRangesTemp;
return(this);
}
/// <summary>
/// Add to the _datatable with a new column which contains zero rate for underlying timelength
/// </summary>
/// <param name="timeLength"></param>
private void BootstrappingOverOneYr(TimeRanges timeLength)
{
if (_zeroTable.Columns.Count == 1)
{
return;
}
string oldColumnName = _lookup[timeLength.ToString()];
string newColumnName = FormatColumnName(oldColumnName);
DataTable tempDT = SetupTempDatatable();
tempDT.Columns.Add(newColumnName, typeof(double));
foreach (DataRow dr in _datatable.Rows)
{
if (dr[oldColumnName] is double)
{
double zeroRate = AlgoBootstrappingOverOneYr(
(double)dr[_zeroTable.Columns.Count - 1], (double)dr[oldColumnName],
((double)timeLength - 6) / 12, (double)timeLength / 12
);
DataRow zeroRow = tempDT.NewRow();
zeroRow[newColumnName] = zeroRate;
zeroRow[_primaryKey.ColumnName] = dr[_primaryKey.ColumnName];
tempDT.Rows.Add(zeroRow);
}
}
_zeroTable.Merge(tempDT, false, MissingSchemaAction.Add);
}
/// <summary>
/// visszaadja a beállított időintervallumokat úgy, hogy szétdarabolja őket TimeUnit alapján
/// </summary>
public IEnumerable <TimeRange> GetDetailedTimeRanges()
{
ReloadData();
if (TimeUnit == TimeUnit.Infinity)
{
yield return(TimeRanges.First());
}
else
{
foreach (var actTimeRange in TimeRanges)
{
if (actTimeRange.DurationCount == 1)
{
yield return(actTimeRange);
}
else
{
for (var i = 0; i < actTimeRange.DurationCount; i++)
{
var tr = new TimeRange(AddDateTime(actTimeRange.DateTimeStart, i), 1, TimeUnit);
yield return(tr);
}
}
}
}
}
/// <summary>
/// Find order.
/// </summary>
private void _FindOrder()
{
Cursor = Cursors.Wait;
try
{
// Get range.
string keyword = txtOrderText.Text;
DateTime currentDate = DateTime.Now.Date;
TimeRanges rangeType = (TimeRanges)cbSearch.SelectedIndex;
TimeRange range = null;
if (rangeType == TimeRanges.SpecifiedTimeRange)
{
if (dpFrom.SelectedDate.HasValue && dpTo.SelectedDate.HasValue)
{
range = new TimeRange(dpFrom.SelectedDate.Value.Date, dpTo.SelectedDate.Value.Date);
}
}
else
{
range = TimeRangeHelper.GetRange(currentDate, rangeType);
}
// If range valid make search.
if (range != null)
{
if (_previousOrdersCollection != null)
{
_previousOrdersCollection.Dispose();
_previousOrdersCollection = null;
}
OrderManager manager = App.Current.Project.Orders;
IDataObjectCollection <Order> orders = manager.SearchByKeyword(range.Start, range.End.AddDays(1), keyword, true);
// Store orders collection to dispose.
_previousOrdersCollection = orders;
UpdateLayout();
_collectionSource.Source = null;
// Set orders collection.
_collectionSource.Source = orders;
// Save last search criteria.
Properties.Settings.Default.FindOrdersLastKeyword = txtOrderText.Text;
Properties.Settings.Default.FindOrdersSearchCriteria =
TimeRangeHelper.GetRangeSettingsName(rangeType);
Properties.Settings.Default.Save();
_needToClearSelection = true;
}
}
finally
{
Cursor = Cursors.Arrow;
}
}
public override void UpdateProviderFromPropertyValues()
{
prop["SimpleDisplay"] = prop["ranges"];
string ranges = prop["ranges"];
currentValue = new TimeRanges(ranges);
FireValueUpdateEvent();
}
public DateBoundTimeRanges Clear()
{
var timeRangesTemp = TimeRanges.ToList();
timeRangesTemp.Clear();
TimeRanges = timeRangesTemp;
return(this);
}
/// <summary>
/// Az adott időintervallumot hozzáadja a listában szereplőkhöz. Ha összeér, vagy belelóg egy vagy több már megjelölt időintervallumba, akkor összevonja az egybeérő időintervallumokat.
/// </summary>
public void AddTimeRange(TimeRange timeRange)
{
ReloadData();
if (TimeUnit == TimeUnit.Infinity)
{
if (!TimeRanges.Any())
{
AddTimeRangeToList(TaskControl_TimeRange.Infinity());
}
}
else
{
var tcTimeRange = newTaskControl_TimeRange(timeRange.DateTimeStart, timeRange.DurationCount);
/*var prev = TimeRanges.Where(x => x.DateTimeStart <= timeRange.DateTimeStart).OrderByDescending(x => x.DateTimeStart).FirstOrDefault();
* var next = TimeRanges.Where(x => x.DateTimeStart >= timeRange.DateTimeStart).OrderBy(x => x.DateTimeStart).FirstOrDefault();
* AddTimeRangeToList(timeRange);
*
* //előző bejegyzéshez vizsgálat+mergelés
* MergeInList(timeRange, prev);
*
* //következő bejegyzéshez vizsgálat+mergelés
* MergeInList(timeRange, next);*/
//kitörlöm az összes intervallumot, amit teljesen befed a hozzáadandó intervallum.
var toDelete = TimeRanges
.Where(x => x.DateTimeStart >= tcTimeRange.DateTimeStart && x.EndOfTimeRange(TimeUnit) <= tcTimeRange.EndOfTimeRange(TimeUnit))
.ToList();
foreach (var tr in toDelete)
{
RemoveTimeRangeFromList(tr);
}
//megnézem, van e olyan intervallum, amit a hozzáadandó időszak kezdetével összeér.
var startIntersecting = TimeRanges
.Where(x => x.DateTimeStart <= tcTimeRange.DateTimeStart && x.EndOfTimeRange(TimeUnit) >= tcTimeRange.DateTimeStart)
.FirstOrDefault();
//megnézem, van e olyan intervallum, amit a hozzáadandó időszak végével összeér.
var endIntersecting = TimeRanges
.Where(x => x.DateTimeStart <= tcTimeRange.EndOfTimeRange(TimeUnit) && x.EndOfTimeRange(TimeUnit) >= tcTimeRange.EndOfTimeRange(TimeUnit))
.FirstOrDefault();
var worktr = newTaskControl_TimeRange(tcTimeRange.DateTimeStart, tcTimeRange.DurationCount);
// Hozzáadoma listához az új időintervallumot
AddTimeRangeToList(worktr);
//megnézem, van e olyan intervallum, amit a hozzáadandó időszak kezdetével összeér. Ha van ilyen, akkor összevonom a hozzáadandó időszakkal.
var mergedtr = MergeInList(worktr, startIntersecting);
//megnézem, van e olyan intervallum, amit a hozzáadandó időszak végével összeér. Ha van ilyen, akkor összevonom a hozzáadandó időszakkal.
MergeInList(mergedtr, endIntersecting);
}
//Az új időintervallumot felveszem a listába
SaveChanges();
}
protected virtual void AddTimeRangeToList(TaskControl_TimeRange?timeRange)
{
if (timeRange == null)
{
return;
}
TimeRanges.Add(timeRange);
}
public string TimeRangesToString(bool showEndTimes = false, TimeType timeType = TimeType.Interval)
{
ReloadData();
if (TimeUnit == TimeUnit.Infinity)
{
return(TimeRanges.Any().ToString());
}
else
{
return(TimeFunctions.TimeRangesToString(TimeRanges, TimeUnit, timeType, showEndTimes));
}
}
/// <summary>
/// Get name of the time rangeTypeName type.
/// </summary>
/// <param name="rangeType">TimeRanges.</param>
/// <returns>Name of this time rangeTypeName type.</returns>
/// <remarks>Name isn't localizable, do not use in UI.</remarks>
public static string GetRangeSettingsName(TimeRanges rangeType)
{
string rangeTypeName = null;
// Find corresponding name.
switch (rangeType)
{
case TimeRanges.Today:
rangeTypeName = TODAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.Yesterday:
rangeTypeName = YESTERDAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.ThisWeek:
rangeTypeName = THIS_WEEK_SEARCH_RANGE_NAME;
break;
case TimeRanges.LastWeek:
rangeTypeName = LAST_WEEK_SEARCH_RANGE_NAME;
break;
case TimeRanges.ThisMonth:
rangeTypeName = THIS_MONTH_SEARCH_RANGE_NAME;
break;
case TimeRanges.LastMonth:
rangeTypeName = LAST_MONTH_SEARCH_RANGE_NAME;
break;
case TimeRanges.Anyday:
rangeTypeName = ANY_DAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.SpecifiedTimeRange:
rangeTypeName = SPECIFIED_SEARCH_RANGE_NAME;
break;
// New enum was added so corresponding name must be added too.
default:
System.Diagnostics.Debug.Assert(false);
break;
}
return(rangeTypeName);
}
/// <summary>
/// Get rangeTypeName type corresponding for this name.
/// </summary>
/// <param name="rangeTypeName">Time rangeTypeName type name.</param>
/// <returns>Corresponding value of TimeRanges enum.</returns>
/// <remarks>Name isn't localizable, do not use in UI.</remarks>
public static TimeRanges GetRangeType(string rangeTypeName)
{
TimeRanges rangeType = TimeRanges.Anyday;
// Find enum value, corresponding to this name.
switch (rangeTypeName)
{
case TODAY_SEARCH_RANGE_NAME:
rangeType = TimeRanges.Today;
break;
case YESTERDAY_SEARCH_RANGE_NAME:
rangeType = TimeRanges.Yesterday;
break;
case THIS_WEEK_SEARCH_RANGE_NAME:
rangeType = TimeRanges.ThisWeek;
break;
case LAST_WEEK_SEARCH_RANGE_NAME:
rangeType = TimeRanges.LastWeek;
break;
case THIS_MONTH_SEARCH_RANGE_NAME:
rangeType = TimeRanges.ThisMonth;
break;
case LAST_MONTH_SEARCH_RANGE_NAME:
rangeType = TimeRanges.LastMonth;
break;
case SPECIFIED_SEARCH_RANGE_NAME:
rangeType = TimeRanges.SpecifiedTimeRange;
break;
case ANY_DAY_SEARCH_RANGE_NAME:
rangeType = TimeRanges.Anyday;
break;
// There is no time rangeTypeName with such name.
default:
System.Diagnostics.Debug.Assert(false);
break;
}
return(rangeType);
}
/// <summary>
/// This method gets events from REDIS and filters out based on parameters
/// </summary>
/// <param name="position">GEO coordination</param>
/// <param name="hourRange">Hour range</param>
/// <param name="radiusRange">Radius range</param>
/// <param name="categories">Event categories</param>
/// <returns>An event list model</returns>
public EventListModel GetEvents(GeoCoordinate position, TimeRanges hourRange, RadiusRanges radiusRange, IList<EventTypes> categories)
{
EventListModel list = new EventListModel();
foreach (var category in categories)
{
var eventListModels = this.FetchFromRedis(category) ?? new EventListModel();
list.EventModels.AddRange(eventListModels.EventModels);
}
list.EventModels.RemoveAll(x => DateTime.UtcNow.AddHours((double)hourRange) < x.EventDate);
list.EventModels.RemoveAll(x => x.Venue == null);
list.EventModels.RemoveAll(x => !VenueHelper.IsVenueWithinRadius(x.Venue, position, (int)radiusRange));
return list;
}
public static TimeRange GetRange(DateTime currentDate, TimeRanges rangeType)
{
TimeRange range = null;
switch (rangeType)
{
case TimeRanges.Today:
range = new TimeRange(currentDate.Date, currentDate.Date);
break;
case TimeRanges.Yesterday:
DateTime yesterday = currentDate.AddDays(-1);
range = new TimeRange(yesterday, yesterday);
break;
case TimeRanges.ThisWeek:
range = _GetWeekRange(currentDate);
break;
case TimeRanges.LastWeek:
TimeRange currentWeekRange = _GetWeekRange(currentDate);
range = _GetWeekRange(currentWeekRange.Start.AddDays(-1));
break;
case TimeRanges.ThisMonth:
range = _GetMonthRange(currentDate);
break;
case TimeRanges.LastMonth:
TimeRange currentMonthRange = _GetMonthRange(currentDate);
range = _GetMonthRange(currentMonthRange.Start.AddDays(-1));
break;
case TimeRanges.Anyday:
range = new TimeRange(DateTime.MinValue.AddYears(1753), DateTime.MaxValue.AddYears(-1000));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
return(range);
}
public DateBoundTimeRanges AddTimeRange(TimeRange newTimeRange)
{
ValidateTimeRange(newTimeRange);
var timeRangesTemp = TimeRanges.ToList();
if (CheckIfTimeRangeToAddFitsWithinAnyStoredTimeRange(newTimeRange, timeRangesTemp))
{
return(this);
}
if (timeRangesTemp.Count != 0)
{
newTimeRange = MergePotentialOverlaps(newTimeRange, timeRangesTemp);
}
timeRangesTemp.Add(newTimeRange);
TimeRanges = timeRangesTemp;
return(this);
}
public static string Type2Text(TimeRanges value)
{
switch (value)
{
case TimeRanges.W1: return("01 " + Languages.Libs.GetString("week"));
case TimeRanges.W2: return("02 " + Languages.Libs.GetString("weeks"));
case TimeRanges.W3: return("03 " + Languages.Libs.GetString("weeks"));
case TimeRanges.M1: return("01 " + Languages.Libs.GetString("month"));
case TimeRanges.M2: return("02 " + Languages.Libs.GetString("months"));
case TimeRanges.M3: return("03 " + Languages.Libs.GetString("months"));
case TimeRanges.M4: return("04 " + Languages.Libs.GetString("months"));
case TimeRanges.M5: return("05 " + Languages.Libs.GetString("months"));
case TimeRanges.M6: return("06 " + Languages.Libs.GetString("months"));
case TimeRanges.YTD: return(Languages.Libs.GetString("YTD")); //Year to date
case TimeRanges.Y1: return("01 " + Languages.Libs.GetString("year"));
case TimeRanges.Y2: return("02 " + Languages.Libs.GetString("years"));
case TimeRanges.Y3: return("03 " + Languages.Libs.GetString("years"));
case TimeRanges.Y4: return("04 " + Languages.Libs.GetString("years"));
case TimeRanges.Y5: return("05 " + Languages.Libs.GetString("years"));
case TimeRanges.All: return(Languages.Libs.GetString("all"));
default: return(Languages.Libs.GetString("NA"));
}
}
/// <summary>
/// Az adott időintervallumot kiveszi a listából.
/// </summary>
public void RemoveTimeRange(TimeRange timeRange)
{
ReloadData();
if (TimeUnit == TimeUnit.Infinity)
{
foreach (var tr in TimeRanges.ToList())
{
RemoveTimeRangeFromList(tr);
}
}
else
{
var tcTimeRange = newTaskControl_TimeRange(timeRange.DateTimeStart, timeRange.DurationCount);
//1. megnézem, van e olyan intervallum, amit a törlendő időszak kezdetével összeér. Ha van ilyen, kettébontom 2 időszakra.
var startIntersecting = TimeRanges
.Where(x => x.DateTimeStart <= tcTimeRange.DateTimeStart && x.EndOfTimeRange(TimeUnit) >= tcTimeRange.DateTimeStart)
.FirstOrDefault();
SplitInList(startIntersecting, tcTimeRange.DateTimeStart);
//2. megnézem, van e olyan intervallum, amit a törlendő időszak végével összeér. Ha van ilyen, kettébontom 2 időszakra.
var entIntersecting = TimeRanges
.Where(x => x.DateTimeStart <= tcTimeRange.EndOfTimeRange(TimeUnit) && x.EndOfTimeRange(TimeUnit) >= tcTimeRange.EndOfTimeRange(TimeUnit))
.FirstOrDefault();
SplitInList(entIntersecting, tcTimeRange.EndOfTimeRange(TimeUnit));
//3. kitörlöm az összes intervallumot, amit teljesen befed a törlendő intervallum.
var toDelete = TimeRanges
.Where(x => x.DateTimeStart >= tcTimeRange.DateTimeStart && x.EndOfTimeRange(TimeUnit) <= tcTimeRange.EndOfTimeRange(TimeUnit))
.ToList();
foreach (var tr in toDelete)
{
RemoveTimeRangeFromList(tr);
}
}
//Az új időintervallumot felveszem a listába
SaveChanges();
}
/// <summary>
/// Using CMT(Constant Maturity Rate) to infer zero coupon rate.
/// </summary>
///
/// <remarks>
/// According to Dept of Treasury, CMT is taken directly from Treasury Yield Curve which is a par yield curve.
/// Bootstrapping method requires par yield datapoints for every six months and the time length difference between
/// any Treasuries over one year long is either equal or greater than one year. Thus, no zero rate for more than
/// a year can be inferred from this datasource by bootstraping. It is, however, possible to construct a complete
/// zero curve set if the missed datapoint is inferred from cubic spline model.
/// </remarks>
///
/// <see cref="http://www.treasury.gov/resource-center/faqs/Interest-Rates/Pages/faq.aspx"/>
///
public void Bootstrapping()
{
DataColumn primaryKeySrcTable = _datatable.PrimaryKey.First();
_primaryKey = new DataColumn(primaryKeySrcTable.ColumnName, primaryKeySrcTable.DataType);
_zeroTable.Columns.Add(_primaryKey);
_zeroTable.PrimaryKey = new DataColumn[] { _primaryKey };
foreach (string key in _lookup.Keys)
{
TimeRanges timeLength = (TimeRanges)Enum.Parse(typeof(TimeRanges), key);
if ((int)timeLength < (int)TimeRanges.oneYR)
{
BootstrappingUnderOneYr(timeLength);
}
else if ((int)timeLength == (int)TimeRanges.oneYR)
{
BootstrappingOverOneYr(timeLength);
}
}
_datatable.Merge(_zeroTable, false, MissingSchemaAction.Add);
}
void Update()
{
if (!_mediaPlayer)
{
return;
}
UpdateControlsVisibility();
UpdateAudioFading();
UpdateAudioSpectrum();
if (_mediaPlayer.Info != null)
{
TimeRange timelineRange = GetTimelineRange();
// Update timeline hover popup
#if (!ENABLE_INPUT_SYSTEM || ENABLE_LEGACY_INPUT_MANAGER)
if (_timelineTip != null)
{
if (_isHoveringOverTimeline)
{
Vector2 canvasPos;
RectTransformUtility.ScreenPointToLocalPointInRectangle(_canvasTransform, Input.mousePosition, null, out canvasPos);
_segmentsSeek.gameObject.SetActive(true);
_timelineTip.gameObject.SetActive(true);
Vector3 mousePos = _canvasTransform.TransformPoint(canvasPos);
_timelineTip.position = new Vector2(mousePos.x, _timelineTip.position.y);
if (UserInteraction.IsUserInputThisFrame())
{
// Work out position on the timeline
Bounds bounds = RectTransformUtility.CalculateRelativeRectTransformBounds(this._sliderTime.GetComponent <RectTransform>());
float x = Mathf.Clamp01((canvasPos.x - bounds.min.x) / bounds.size.x);
double time = (double)x * timelineRange.Duration;
// Seek to the new position
if (_thumbnailMediaPlayer != null && _thumbnailMediaPlayer.Control != null)
{
_thumbnailMediaPlayer.Control.SeekFast(time);
}
// Update time text
Text hoverText = _timelineTip.GetComponentInChildren <Text>();
if (hoverText != null)
{
time -= timelineRange.startTime;
time = System.Math.Max(time, 0.0);
time = System.Math.Min(time, timelineRange.Duration);
hoverText.text = Helper.GetTimeString(time, false);
}
{
// Update seek segment when hovering over timeline
if (_segmentsSeek != null)
{
float[] ranges = new float[2];
if (timelineRange.Duration > 0.0)
{
double t = ((_mediaPlayer.Control.GetCurrentTime() - timelineRange.startTime) / timelineRange.duration);
ranges[1] = x;
ranges[0] = (float)t;
}
_segmentsSeek.Segments = ranges;
}
}
}
}
else
{
_timelineTip.gameObject.SetActive(false);
_segmentsSeek.gameObject.SetActive(false);
}
}
#endif
// Updated stalled display
if (_overlayManager)
{
_overlayManager.Reset();
if (_mediaPlayer.Info.IsPlaybackStalled())
{
_overlayManager.TriggerStalled();
}
}
// Update keyboard input
if (_enableKeyboardControls)
{
#if (!ENABLE_INPUT_SYSTEM || ENABLE_LEGACY_INPUT_MANAGER)
// Keyboard toggle play/pause
if (Input.GetKeyDown(KeyTogglePlayPause))
{
TogglePlayPause();
}
// Keyboard seek 5 seconds
if (Input.GetKeyDown(KeyJumpBack))
{
SeekRelative(-_jumpDeltaTime);
}
else if (Input.GetKeyDown(KeyJumpForward))
{
SeekRelative(_jumpDeltaTime);
}
// Keyboard control volume
if (Input.GetKeyDown(KeyVolumeUp))
{
ChangeAudioVolume(_keyVolumeDelta);
}
else if (Input.GetKeyDown(KeyVolumeDown))
{
ChangeAudioVolume(-_keyVolumeDelta);
}
// Keyboard toggle mute
if (Input.GetKeyDown(KeyToggleMute))
{
ToggleMute();
}
#endif
}
// Animation play/pause button
if (_playPauseMaterial != null)
{
float t = _playPauseMaterial.GetFloat(_propMorph.Id);
float d = 1f;
if (_mediaPlayer.Control.IsPlaying())
{
d = -1f;
}
t += d * Time.deltaTime * 6f;
t = Mathf.Clamp01(t);
_playPauseMaterial.SetFloat(_propMorph.Id, t);
}
// Animation volume/mute button
if (_volumeMaterial != null)
{
float t = _volumeMaterial.GetFloat(_propMute.Id);
float d = 1f;
if (!_mediaPlayer.Control.IsMuted())
{
d = -1f;
}
t += d * Time.deltaTime * 6f;
t = Mathf.Clamp01(t);
_volumeMaterial.SetFloat(_propMute.Id, t);
_volumeMaterial.SetFloat(_propVolume.Id, _audioVolume);
}
// Animation subtitles button
if (_subtitlesMaterial)
{
float t = _subtitlesMaterial.GetFloat(_propMorph.Id);
float d = 1f;
if (_mediaPlayer.TextTracks.GetActiveTextTrack() == null)
{
d = -1f;
}
t += d * Time.deltaTime * 6f;
t = Mathf.Clamp01(t);
_subtitlesMaterial.SetFloat(_propMorph.Id, t);
}
// Animation options button
if (_optionsMaterial)
{
float t = _optionsMaterial.GetFloat(_propMorph.Id);
float d = 1f;
if (!_showOptions)
{
d = -1f;
}
t += d * Time.deltaTime * 6f;
t = Mathf.Clamp01(t);
_optionsMaterial.SetFloat(_propMorph.Id, t);
}
// Update time/duration text display
if (_textTimeDuration)
{
string t1 = Helper.GetTimeString((_mediaPlayer.Control.GetCurrentTime() - timelineRange.startTime), false);
string d1 = Helper.GetTimeString(timelineRange.duration, false);
_textTimeDuration.text = string.Format("{0} / {1}", t1, d1);
}
// Update volume slider
if (!_useAudioFading)
{
UpdateVolumeSlider();
}
// Update time slider position
if (_sliderTime)
{
double t = 0.0;
if (timelineRange.duration > 0.0)
{
t = ((_mediaPlayer.Control.GetCurrentTime() - timelineRange.startTime) / timelineRange.duration);
}
_sliderTime.value = Mathf.Clamp01((float)t);
}
// Update LIVE text visible
if (_liveItem)
{
_liveItem.SetActive(double.IsInfinity(_mediaPlayer.Info.GetDuration()));
}
// Update subtitle button visible
if (_buttonSubtitles)
{
_buttonSubtitles.gameObject.SetActive(_mediaPlayer.TextTracks.GetTextTracks().Count > 0);
}
// Update media name
if (_textMediaName)
{
#if MEDIA_NAME
string mediaName = string.Empty;
if (!string.IsNullOrEmpty(_mediaPlayer.VideoPath))
{
mediaName = System.IO.Path.GetFileName(_mediaPlayer.VideoPath);
if (mediaName.Length > 26)
{
mediaName = mediaName.Substring(0, 26);
}
}
#endif
string resolutionName = string.Empty;
if (_mediaPlayer.Info.GetVideoWidth() > 0)
{
resolutionName = Helper.GetFriendlyResolutionName(_mediaPlayer.Info.GetVideoWidth(), _mediaPlayer.Info.GetVideoHeight(), _mediaPlayer.Info.GetVideoFrameRate());
}
#if MEDIA_NAME
_textMediaName.text = string.Format("{0} {1}", mediaName, resolutionName);
#else
_textMediaName.text = resolutionName;
#endif
}
// Update buffered segments
if (_segmentsBuffered)
{
TimeRanges times = _mediaPlayer.Control.GetBufferedTimes();
float[] ranges = null;
if (times.Count > 0 && timelineRange.duration > 0.0)
{
ranges = new float[times.Count * 2];
for (int i = 0; i < times.Count; i++)
{
ranges[i * 2 + 0] = Mathf.Max(0f, (float)((times[i].StartTime - timelineRange.startTime) / timelineRange.duration));
ranges[i * 2 + 1] = Mathf.Min(1f, (float)((times[i].EndTime - timelineRange.startTime) / timelineRange.duration));
}
}
_segmentsBuffered.Segments = ranges;
}
// Update progress segment
if (_segmentsProgress)
{
TimeRanges times = _mediaPlayer.Control.GetBufferedTimes();
float[] ranges = null;
if (times.Count > 0 && timelineRange.Duration > 0.0)
{
ranges = new float[2];
double x1 = (times.MinTime - timelineRange.startTime) / timelineRange.duration;
double x2 = ((_mediaPlayer.Control.GetCurrentTime() - timelineRange.startTime) / timelineRange.duration);
ranges[0] = Mathf.Max(0f, (float)x1);
ranges[1] = Mathf.Min(1f, (float)x2);
}
_segmentsProgress.Segments = ranges;
}
}
}
void OnGUI()
{
// NOTE: These this IMGUI is just temporary until we implement the UI using uGUI
if (!_showOptions)
{
return;
}
if (!_mediaPlayer || _mediaPlayer.Control == null)
{
return;
}
GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(2f, 2f, 1f));
GUI.backgroundColor = Color.red;
GUILayout.BeginVertical(GUI.skin.box);
GUI.backgroundColor = Color.white;
GUILayout.Label("Duration " + _mediaPlayer.Info.GetDuration() + "s");
GUILayout.BeginHorizontal();
GUILayout.Label("States: ");
GUILayout.Toggle(_mediaPlayer.Control.HasMetaData(), "HasMetaData", GUI.skin.button);
GUILayout.Toggle(_mediaPlayer.Control.IsPaused(), "Paused", GUI.skin.button);
GUILayout.Toggle(_mediaPlayer.Control.IsPlaying(), "Playing", GUI.skin.button);
GUILayout.Toggle(_mediaPlayer.Control.IsBuffering(), "Buffering", GUI.skin.button);
GUILayout.Toggle(_mediaPlayer.Control.IsSeeking(), "Seeking", GUI.skin.button);
GUILayout.Toggle(_mediaPlayer.Control.IsFinished(), "Finished", GUI.skin.button);
GUILayout.EndHorizontal();
{
TimeRanges times = _mediaPlayer.Control.GetBufferedTimes();
if (times != null)
{
GUILayout.Label("Buffered Range " + times.MinTime + " - " + times.MaxTime);
}
}
{
TimeRanges times = _mediaPlayer.Control.GetSeekableTimes();
if (times != null)
{
GUILayout.Label("Seek Range " + times.MinTime + " - " + times.MaxTime);
}
}
{
GUILayout.Label("Video Tracks: " + _mediaPlayer.VideoTracks.GetVideoTracks().Count);
GUILayout.BeginVertical();
VideoTrack selectedTrack = null;
foreach (VideoTrack track in _mediaPlayer.VideoTracks.GetVideoTracks())
{
bool isSelected = (track == _mediaPlayer.VideoTracks.GetActiveVideoTrack());
if (isSelected)
{
GUI.color = Color.green;
}
if (GUILayout.Button(track.DisplayName, GUILayout.ExpandWidth(false)))
{
selectedTrack = track;
}
if (isSelected)
{
GUI.color = Color.white;
}
}
GUILayout.EndHorizontal();
if (selectedTrack != null)
{
_mediaPlayer.VideoTracks.SetActiveVideoTrack(selectedTrack);
}
}
{
GUILayout.Label("Audio Tracks: " + _mediaPlayer.AudioTracks.GetAudioTracks().Count);
GUILayout.BeginVertical();
AudioTrack selectedTrack = null;
foreach (AudioTrack track in _mediaPlayer.AudioTracks.GetAudioTracks())
{
bool isSelected = (track == _mediaPlayer.AudioTracks.GetActiveAudioTrack());
if (isSelected)
{
GUI.color = Color.green;
}
if (GUILayout.Button(track.DisplayName, GUILayout.ExpandWidth(false)))
{
selectedTrack = track;
}
if (isSelected)
{
GUI.color = Color.white;
}
}
GUILayout.EndHorizontal();
if (selectedTrack != null)
{
_mediaPlayer.AudioTracks.SetActiveAudioTrack(selectedTrack);
}
}
{
GUILayout.Label("Text Tracks: " + _mediaPlayer.TextTracks.GetTextTracks().Count);
GUILayout.BeginVertical();
TextTrack selectedTrack = null;
foreach (TextTrack track in _mediaPlayer.TextTracks.GetTextTracks())
{
bool isSelected = (track == _mediaPlayer.TextTracks.GetActiveTextTrack());
if (isSelected)
{
GUI.color = Color.green;
}
if (GUILayout.Button(track.DisplayName, GUILayout.ExpandWidth(false)))
{
selectedTrack = track;
}
if (isSelected)
{
GUI.color = Color.white;
}
}
GUILayout.EndHorizontal();
if (selectedTrack != null)
{
_mediaPlayer.TextTracks.SetActiveTextTrack(selectedTrack);
}
}
{
GUILayout.Label("FPS: " + _mediaPlayer.Info.GetVideoDisplayRate().ToString("F2"));
}
#if (UNITY_STANDALONE_WIN)
if (_mediaPlayer.PlatformOptionsWindows.bufferedFrameSelection != BufferedFrameSelectionMode.None)
{
IBufferedDisplay bufferedDisplay = _mediaPlayer.BufferedDisplay;
if (bufferedDisplay != null)
{
BufferedFramesState state = bufferedDisplay.GetBufferedFramesState();
GUILayout.BeginHorizontal();
GUILayout.Label("Buffered Frames: " + state.bufferedFrameCount);
GUILayout.HorizontalSlider(state.bufferedFrameCount, 0f, 12f);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Free Frames: " + state.freeFrameCount);
GUILayout.HorizontalSlider(state.freeFrameCount, 0f, 12f);
GUILayout.EndHorizontal();
GUILayout.Label("Min Timstamp: " + state.minTimeStamp);
GUILayout.Label("Max Timstamp: " + state.maxTimeStamp);
GUILayout.Label("Display Timstamp: " + _mediaPlayer.TextureProducer.GetTextureTimeStamp());
}
}
#endif
GUILayout.EndVertical();
}
public static string Type2Text(TimeRanges value)
{
switch (value)
{
case TimeRanges.W1: return "01 " + Languages.Libs.GetString("week");
case TimeRanges.W2: return "02 " + Languages.Libs.GetString("weeks");
case TimeRanges.W3: return "03 " + Languages.Libs.GetString("weeks");
case TimeRanges.M1: return "01 " + Languages.Libs.GetString("month");
case TimeRanges.M2: return "02 " + Languages.Libs.GetString("months");
case TimeRanges.M3: return "03 " + Languages.Libs.GetString("months");
case TimeRanges.M4: return "04 " + Languages.Libs.GetString("months");
case TimeRanges.M5: return "05 " + Languages.Libs.GetString("months");
case TimeRanges.M6: return "06 " + Languages.Libs.GetString("months");
case TimeRanges.YTD: return Languages.Libs.GetString("YTD"); //Year to date
case TimeRanges.Y1: return "01 " + Languages.Libs.GetString("year");
case TimeRanges.Y2: return "02 " + Languages.Libs.GetString("years");
case TimeRanges.Y3: return "03 " + Languages.Libs.GetString("years");
case TimeRanges.Y4: return "04 " + Languages.Libs.GetString("years");
case TimeRanges.Y5: return "05 " + Languages.Libs.GetString("years");
case TimeRanges.All: return Languages.Libs.GetString("all");
default: return Languages.Libs.GetString("NA");
}
}
/// <summary>
/// Invertálja a Timeranges-t. Olyan időintervallumokat tartalmazó TimeControl -t ad vissza, ami a beadott dátumok közötti összes meg nem jelölt időszakot tartalmazza.
/// </summary>
public TaskControl GetInverseTimeControl(TimeRange timeRange)
{
var res = new TaskControl(TimeUnit);
ReloadData();
if (TimeUnit == TimeUnit.Infinity)
{
if (TimeRanges.Any())
{
res.RemoveTimeRange(TimeRange.Infinity());
}
else
{
res.AddTimeRange(TimeRange.Infinity());
}
}
else
{
//Ez az az időpont, amelyik már éppen NINCS benne a vizsgált időszakban
DateTime realStartTime = TimeFunctions.TruncDateTime(TimeUnit, timeRange.DateTimeStart);
DateTime realEndTime = timeRange.EndOfTimeRange(TimeUnit);
/*if (TimeType == TimeType.Moment)//Ha időpontot vizsgálok, akkor a záró időpontot kiterjesztem a megadott időpontot tartalmazó időszak végéig.
* realEndTime = AddDateTime(realEndTime, 1);
* else//Ha időszakot vizsgálok, akkor a kapott endtime paraméterben levő időpontot még intervallumon belülinek veszem, ezért a záró időpontot kiterjesztem 1 legkisebb időegységgel.
* realEndTime = realEndTime/*.AddTicks(1)*/
;
//realEndTime =
var trInInterval = TimeRanges.Where(x => x.EndOfTimeRange(TimeUnit) > realStartTime && x.DateTimeStart < realEndTime).OrderBy(x => x.DateTimeStart);
//első időszak előtti rész
var first = trInInterval.FirstOrDefault();
if (first != null && first.DateTimeStart > realStartTime)
{
var tr = newTaskControl_TimeRange(realStartTime, TimeCountBetween(realStartTime, first.DateTimeStart));
res.TimeRanges.Add(tr);
}
TaskControl_TimeRange?prevTimeRange = null;
//hozzáadom az egyes időintervallumok között kihagyott időszakokat
foreach (var actTimeRange in trInInterval)
{
if (prevTimeRange != null)
{
var starttime = prevTimeRange.EndOfTimeRange(TimeUnit);
var tr = newTaskControl_TimeRange(starttime, TimeCountBetween(starttime, actTimeRange.DateTimeStart));
if (tr.DurationCount > 0)
{
res.TimeRanges.Add(tr);
}
}
prevTimeRange = actTimeRange;
}
//hozzáadom az utolsó utáni-t
var last = trInInterval.LastOrDefault();
if (last != null && AddDateTime(last.DateTimeStart, last.DurationCount) < realEndTime)
{
var starttime = last.EndOfTimeRange(TimeUnit);
var tr = newTaskControl_TimeRange(starttime, TimeCountBetween(starttime, realEndTime));
if (tr.DurationCount > 0)
{
res.TimeRanges.Add(tr);
}
}
if (!trInInterval.Any())
{
var tr = newTaskControl_TimeRange(realStartTime, TimeCountBetween(realStartTime, realEndTime));
res.TimeRanges.Add(tr);
}
}
return(res);
}
//private void AddTimeRangeToList(TimeRange timeRange) => AddTimeRangeToList(new TaskControl_TimeRange(timeRange.DateTimeStart, timeRange.DurationCount));
protected virtual void RemoveTimeRangeFromList(TaskControl_TimeRange timeRangeToMerge)
{
TimeRanges.Remove(timeRangeToMerge);
}
protected virtual void SaveChanges()
{
TimeRanges = TimeRanges.OrderBy(x => x.DateTimeStart).ToList();
}
public static TimeRange GetRange(DateTime currentDate, TimeRanges rangeType)
{
TimeRange range = null;
switch (rangeType)
{
case TimeRanges.Today:
range = new TimeRange(currentDate.Date, currentDate.Date);
break;
case TimeRanges.Yesterday:
DateTime yesterday = currentDate.AddDays(-1);
range = new TimeRange(yesterday, yesterday);
break;
case TimeRanges.ThisWeek:
range = _GetWeekRange(currentDate);
break;
case TimeRanges.LastWeek:
TimeRange currentWeekRange = _GetWeekRange(currentDate);
range = _GetWeekRange(currentWeekRange.Start.AddDays(-1));
break;
case TimeRanges.ThisMonth:
range = _GetMonthRange(currentDate);
break;
case TimeRanges.LastMonth:
TimeRange currentMonthRange = _GetMonthRange(currentDate);
range = _GetMonthRange(currentMonthRange.Start.AddDays(-1));
break;
case TimeRanges.Anyday:
range = new TimeRange(DateTime.MinValue.AddYears(1753), DateTime.MaxValue.AddYears(-1000));
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
return range;
}
private void OnInspectorGUI_Player(MediaPlayer mediaPlayer, ITextureProducer textureSource)
{
EditorGUILayout.BeginVertical(GUI.skin.box);
Rect titleRect = Rect.zero;
// Display filename as title of preview
{
string mediaFileName = string.Empty;
if ((MediaSource)_propMediaSource.enumValueIndex == MediaSource.Path)
{
mediaFileName = mediaPlayer.MediaPath.Path;
}
else if ((MediaSource)_propMediaSource.enumValueIndex == MediaSource.Reference)
{
if (_propMediaReference.objectReferenceValue != null)
{
mediaFileName = ((MediaReference)_propMediaReference.objectReferenceValue).GetCurrentPlatformMediaReference().MediaPath.Path;
}
}
// Display the file name, cropping if necessary
if (!string.IsNullOrEmpty(mediaFileName) &&
(0 > mediaFileName.IndexOfAny(System.IO.Path.GetInvalidPathChars())))
{
string text = System.IO.Path.GetFileName(mediaFileName);
titleRect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.label);
// Draw background
GUI.Box(titleRect, GUIContent.none, EditorStyles.toolbarButton);
DrawCenterCroppedLabel(titleRect, text);
}
}
// Toggle preview
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && Event.current.isMouse)
{
if (titleRect.Contains(Event.current.mousePosition))
{
_queuedToggleShowPreview = true;
}
}
if (_showPreview)
{
Texture texture = EditorGUIUtility.whiteTexture;
float textureRatio = 16f / 9f;
if (_lastTextureRatio > 0f)
{
textureRatio = _lastTextureRatio;
}
if (textureSource != null && textureSource.GetTexture() != null)
{
texture = textureSource.GetTexture();
if (_previewTexture)
{
texture = _previewTexture;
}
_lastTextureRatio = textureRatio = (float)texture.width / (float)texture.height;
}
// Reserve rectangle for texture
//GUILayout.BeginHorizontal(GUILayout.MaxHeight(Screen.height / 2f), GUILayout.ExpandHeight(true));
//GUILayout.FlexibleSpace();
Rect textureRect;
//textureRect = GUILayoutUtility.GetRect(256f, 256f);
if (texture != EditorGUIUtility.whiteTexture)
{
if (_showAlpha)
{
float rectRatio = textureRatio * 2f;
rectRatio = Mathf.Max(1f, rectRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true));
}
else
{
//textureRatio *= 2f;
float rectRatio = Mathf.Max(1f, textureRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true), GUILayout.Height(256f));
/*GUIStyle style = new GUIStyle(GUI.skin.box);
* style.stretchHeight = true;
* style.stretchWidth = true;
* style.fixedWidth = 0;
* style.fixedHeight = 0;
* textureRect = GUILayoutUtility.GetRect(Screen.width, Screen.width, 128f, Screen.height / 1.2f, style);*/
}
}
else
{
float rectRatio = Mathf.Max(1f, textureRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true), GUILayout.Height(256f));
}
if (textureRect.height > (Screen.height / 2f))
{
//textureRect.height = Screen.height / 2f;
}
//Debug.Log(textureRect.height + " " + Screen.height);
//GUILayout.FlexibleSpace();
//GUILayout.EndHorizontal();
// Pause / Play toggle on mouse click
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && Event.current.isMouse)
{
if (textureRect.Contains(Event.current.mousePosition))
{
if (mediaPlayer.Control != null)
{
if (mediaPlayer.Control.IsPaused())
{
mediaPlayer.Play();
}
else
{
mediaPlayer.Pause();
}
}
}
}
if (Event.current.type == EventType.Repaint)
{
GUI.color = Color.gray;
EditorGUI.DrawTextureTransparent(textureRect, Texture2D.blackTexture, ScaleMode.StretchToFill);
GUI.color = Color.white;
//EditorGUI.DrawTextureAlpha(textureRect, Texture2D.whiteTexture, ScaleMode.ScaleToFit);
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.StretchToFill, false);
//GUI.color = Color.white;
// Draw the texture
Matrix4x4 prevMatrix = GUI.matrix;
if (textureSource != null && textureSource.RequiresVerticalFlip())
{
// GUIUtility.ScaleAroundPivot(new Vector2(1f, -1f), new Vector2(0f, textureRect.y + (textureRect.height / 2f)));
}
if (!GUI.enabled)
{
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.ScaleToFit, false);
//GUI.color = Color.white;
}
else
{
if (_showPreview && texture != EditorGUIUtility.whiteTexture)
{
RenderPreview(mediaPlayer);
}
if (!_showAlpha)
{
if (texture != EditorGUIUtility.whiteTexture)
{
// TODO: In Linear mode, this displays the texture too bright, but GUI.DrawTexture displays it correctly
//GL.sRGBWrite = true;
//GUI.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, false);
if (_previewTexture)
{
EditorGUI.DrawPreviewTexture(textureRect, _previewTexture, _materialIMGUI, ScaleMode.ScaleToFit);
}
//EditorGUI.DrawTextureTransparent(textureRect, rt, ScaleMode.ScaleToFit);
//VideoRender.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, AlphaPacking.None, _materialPreview);
//GL.sRGBWrite = false;
}
else
{
// Fill with black
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.StretchToFill, false);
//GUI.color = Color.white;
}
}
else
{
textureRect.width /= 2f;
//GUI.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, false);
//GL.sRGBWrite = true;
//VideoRender.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, AlphaPacking.None, _materialIMGUI);
//GL.sRGBWrite = false;
textureRect.x += textureRect.width;
//EditorGUI.DrawTextureAlpha(textureRect, texture, ScaleMode.ScaleToFit);
}
}
GUI.matrix = prevMatrix;
}
}
IMediaInfo info = mediaPlayer.Info;
IMediaControl control = mediaPlayer.Control;
bool showBrowseMenu = false;
if (true)
{
bool isPlaying = false;
if (control != null)
{
isPlaying = control.IsPlaying();
}
// Slider layout
EditorGUILayout.BeginHorizontal(GUILayout.Height(EditorGUIUtility.singleLineHeight / 2f));
Rect sliderRect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.horizontalSlider, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
EditorGUILayout.EndHorizontal();
float currentTime = 0f;
float durationTime = 0.001f;
if (control != null)
{
currentTime = (float)control.GetCurrentTime();
durationTime = (float)info.GetDuration();
if (float.IsNaN(durationTime))
{
durationTime = 0f;
}
}
TimeRange timelineRange = new TimeRange(0.0, 0.001); // A tiny default duration to prevent divide by zero's
if (info != null)
{
timelineRange = Helper.GetTimelineRange(info.GetDuration(), control.GetSeekableTimes());
}
// Slider
{
// Draw buffering
if (control != null && timelineRange.Duration > 0.0 && Event.current.type == EventType.Repaint)
{
GUI.color = new Color(0f, 1f, 0f, 0.25f);
TimeRanges times = control.GetBufferedTimes();
if (timelineRange.Duration > 0.0)
{
for (int i = 0; i < times.Count; i++)
{
Rect bufferedRect = sliderRect;
float startT = Mathf.Clamp01((float)((times[i].StartTime - timelineRange.StartTime) / timelineRange.Duration));
float endT = Mathf.Clamp01((float)((times[i].EndTime - timelineRange.StartTime) / timelineRange.Duration));
bufferedRect.xMin = sliderRect.xMin + sliderRect.width * startT;
bufferedRect.xMax = sliderRect.xMin + sliderRect.width * endT;
bufferedRect.yMin += sliderRect.height * 0.5f;
GUI.DrawTexture(bufferedRect, Texture2D.whiteTexture);
}
}
GUI.color = Color.white;
}
// Timeline slider
{
float newTime = GUI.HorizontalSlider(sliderRect, currentTime, (float)timelineRange.StartTime, (float)timelineRange.EndTime);
if (newTime != currentTime)
{
if (control != null)
{
// NOTE: For unknown reasons the seeks here behave differently to the MediaPlayerUI demo
// When scrubbing (especially with NotchLC) while the video is playing, the frames will not update and a Stalled state will be shown,
// but using the MediaPlayerUI the same scrubbing will updates the frames. Perhaps it's just an execution order issue
control.Seek(newTime);
}
}
}
}
EditorGUILayout.BeginHorizontal();
string timeTotal = "∞";
if (!float.IsInfinity(durationTime))
{
timeTotal = Helper.GetTimeString(durationTime, false);
}
string timeUsed = Helper.GetTimeString(currentTime - (float)timelineRange.StartTime, false);
GUILayout.Label(timeUsed, GUILayout.ExpandWidth(false));
//GUILayout.Label("/", GUILayout.ExpandWidth(false));
GUILayout.FlexibleSpace();
GUILayout.Label(timeTotal, GUILayout.ExpandWidth(false));
EditorGUILayout.EndHorizontal();
// In non-pro we need to make these 3 icon content black as the buttons are light
// and the icons are white by default
if (!EditorGUIUtility.isProSkin)
{
GUI.contentColor = Color.black;
}
EditorGUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
// Play/Pause
{
float maxHeight = GUI.skin.button.CalcHeight(_iconSceneViewAudio, 0f);
if (!isPlaying)
{
GUI.color = Color.green;
if (GUILayout.Button(_iconPlayButton, GUILayout.ExpandWidth(false), GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.Play();
}
else
{
if (mediaPlayer.MediaSource == MediaSource.Path)
{
mediaPlayer.OpenMedia(mediaPlayer.MediaPath.PathType, mediaPlayer.MediaPath.Path, true);
}
else if (mediaPlayer.MediaSource == MediaSource.Reference)
{
mediaPlayer.OpenMedia(mediaPlayer.MediaReference, true);
}
}
}
}
else
{
GUI.color = Color.yellow;
if (GUILayout.Button(_iconPauseButton, GUILayout.ExpandWidth(false), GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.Pause();
}
}
}
GUI.color = Color.white;
}
// Looping
{
if (!_propLoop.boolValue)
{
GUI.color = Color.grey;
}
float maxHeight = GUI.skin.button.CalcHeight(_iconSceneViewAudio, 0f);
//GUIContent icon = new GUIContent("∞");
if (GUILayout.Button(_iconRotateTool, GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.SetLooping(!_propLoop.boolValue);
}
_propLoop.boolValue = !_propLoop.boolValue;
}
GUI.color = Color.white;
}
// Mute & Volume
EditorGUI.BeginDisabledGroup(UnityEditor.EditorUtility.audioMasterMute);
{
if (_propMuted.boolValue)
{
GUI.color = Color.gray;
}
float maxWidth = _iconPlayButton.image.width;
//if (GUILayout.Button("Muted", GUILayout.ExpandWidth(false), GUILayout.Height(EditorGUIUtility.singleLineHeight)))
//string iconName = "d_AudioListener Icon"; // Unity 2019+
if (GUILayout.Button(_iconSceneViewAudio)) //, GUILayout.Width(maxWidth), GUILayout.Height(EditorGUIUtility.singleLineHeight), GUILayout.ExpandHeight(false)))
{
if (control != null)
{
control.MuteAudio(!_propMuted.boolValue);
}
_propMuted.boolValue = !_propMuted.boolValue;
}
GUI.color = Color.white;
}
if (!_propMuted.boolValue)
{
EditorGUI.BeginChangeCheck();
float newVolume = GUILayout.HorizontalSlider(_propVolume.floatValue, 0f, 1f, GUILayout.ExpandWidth(true), GUILayout.MinWidth(64f));
if (EditorGUI.EndChangeCheck())
{
if (control != null)
{
control.SetVolume(newVolume);
}
_propVolume.floatValue = newVolume;
}
}
EditorGUI.EndDisabledGroup();
GUI.contentColor = Color.white;
GUILayout.FlexibleSpace();
if (Event.current.commandName == "ObjectSelectorClosed" &&
EditorGUIUtility.GetObjectPickerControlID() == 200)
{
_queuedLoadMediaRef = (MediaReference)EditorGUIUtility.GetObjectPickerObject();
}
if (GUILayout.Button(_iconProject, GUILayout.ExpandWidth(false)))
{
showBrowseMenu = true;
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
if (showBrowseMenu)
{
RecentMenu.Create(_propMediaPath, _propMediaSource, MediaFileExtensions, true, 200);
}
if (_queuedLoadMediaRef && Event.current.type == EventType.Repaint)
{
//MediaPlayer mediaPlayer = (MediaPlayer)_propMediaPath.serializedObject.targetObject;
if (mediaPlayer)
{
mediaPlayer.OpenMedia(_queuedLoadMediaRef, true);
_queuedLoadMediaRef = null;
}
}
if (_queuedToggleShowPreview)
{
_showPreview = !_showPreview;
_queuedToggleShowPreview = false;
this.Repaint();
}
}
/// <summary>
/// Get name of the time rangeTypeName type.
/// </summary>
/// <param name="rangeType">TimeRanges.</param>
/// <returns>Name of this time rangeTypeName type.</returns>
/// <remarks>Name isn't localizable, do not use in UI.</remarks>
public static string GetRangeSettingsName(TimeRanges rangeType)
{
string rangeTypeName = null;
// Find corresponding name.
switch (rangeType)
{
case TimeRanges.Today:
rangeTypeName = TODAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.Yesterday:
rangeTypeName = YESTERDAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.ThisWeek:
rangeTypeName = THIS_WEEK_SEARCH_RANGE_NAME;
break;
case TimeRanges.LastWeek:
rangeTypeName = LAST_WEEK_SEARCH_RANGE_NAME;
break;
case TimeRanges.ThisMonth:
rangeTypeName = THIS_MONTH_SEARCH_RANGE_NAME;
break;
case TimeRanges.LastMonth:
rangeTypeName = LAST_MONTH_SEARCH_RANGE_NAME;
break;
case TimeRanges.Anyday:
rangeTypeName = ANY_DAY_SEARCH_RANGE_NAME;
break;
case TimeRanges.SpecifiedTimeRange:
rangeTypeName = SPECIFIED_SEARCH_RANGE_NAME;
break;
// New enum was added so corresponding name must be added too.
default:
System.Diagnostics.Debug.Assert(false);
break;
}
return rangeTypeName;
}
