/// <summary>
/// Moves all intervals that lie within the given interval.
/// </summary>
/// <param name = "interval">The interval which specifies which elements will be moved.</param>
/// <param name = "offset">The offset where to move the values in the interval.</param>
public void MoveInterval(IInterval <TMath> interval, TMath offset)
{
// Keep track of the intervals that need to be moved.
var movedIntervals = new List <IntervalValues>();
foreach (IntervalValues intersectingRange in FindIntersections(interval))
{
IInterval <TMath> intersection = intersectingRange.Interval.Intersection(interval);
// Remove part of the interval which will be moved, static parts can stay.
SplitRemoveIntersection(intersectingRange, intersection);
// Add moved remainder to list to be added again.
var movedInterval = new Interval <TMath>(
Operator <TMath> .Add(intersection.Start, offset),
intersection.IsStartIncluded,
Operator <TMath> .Add(intersection.End, offset),
intersection.IsEndIncluded);
movedIntervals.Add(new IntervalValues(intersectingRange.Values, movedInterval));
}
// Add moved intervals again.
foreach (IntervalValues newRange in movedIntervals)
{
Add(newRange.Interval, newRange.Values);
}
}
/// <summary>
/// Определяет пересекаются ли два интервала
/// </summary>
/// <param name="zone"></param>
/// <param name="interval1Param"></param>
/// <param name="interval2Param"></param>
/// <returns></returns>
public static bool DoesIntervalsIntersect(this ISerialAccessZone zone, IInterval interval1Param, IInterval interval2Param)
{
// Принимаем интервалы;
var interval1 = interval1Param;
var interval2 = interval2Param;
// Определяем какой из них левый, а какой правый:
// Если начальный момент одного меньше начального момента другого => первый является левым
IInterval leftInterval;
IInterval rightInterval;
if (interval1.StartMoment.Value < interval2.StartMoment.Value)
{
leftInterval = interval1;
rightInterval = interval2;
}
else
{
leftInterval = interval2;
rightInterval = interval1;
}
// Если начальный момент правого интервала меньше конечного момента левого интервала => пересечение;
// Если нет => нет пересечения;
return(rightInterval.StartMoment.Value < leftInterval.EndMoment.Value);
}
public void Union_NullOther_ThrowsInvalidOperationException()
{
IInterval <int> a = Interval.Create(10, 20);
IInterval <int> b = null;
Assert.Throws <InvalidOperationException>(() => a.GetUnion(b));
}
public void Union_NullInterval_ThrowsInvalidOperationException()
{
IInterval <int> a = null;
IInterval <int> b = Interval.Create(15, 25);
Assert.Throws <InvalidOperationException>(() => a.GetUnion(b));
}
/// <summary>
/// Determine whether this interval intersects another
/// </summary>
/// <remarks>Same as !Disjoint(...)</remarks>
/// <param name="other">Other interval</param>
/// <returns>Whether there is an intersection</returns>
public bool IntersectsWith(IInterval <TPoint, TSpan, TEndpoint, T> other)
{
return
((this.PointIsWithin(other.Left) && ((this.RightEndpoint.Inclusive && other.LeftEndpoint.Inclusive) || this.Right.CompareTo(other.Left) != 0)) ||
(this.PointIsWithin(other.Right) && ((this.LeftEndpoint.Inclusive && other.RightEndpoint.Inclusive) || this.Left.CompareTo(other.Right) != 0)) ||
(other.PointIsWithin(this.Left) && other.PointIsWithin(this.Right)));
}
public Poller(IInterval interval, Func <bool> work, int workers = 1)
{
_workers = workers;
_work = work;
_interval = interval;
_cancellationTokenSources = new CancellationTokenSource[workers];
}
public void Union_IntervalsThatDoNotOverlapNorAreAdjacent_ThrowsInvalidOperationException()
{
IInterval <int> a = Interval.Create(10, 20);
IInterval <int> b = Interval.Create(25, 30);
Assert.Throws <InvalidOperationException>(() => a.GetUnion(b));
}
/// <summary>
/// The get edges.
/// </summary>
/// <param name="interval">
/// The interval.
/// </param>
/// <returns>
/// The <see cref="IEnumerable{T}"/>.
/// </returns>
public static IEnumerable <IEndPoint <T> > GetEndPoints <T>(this IInterval <T> interval)
where T : IComparable <T>
{
return(new List <IEndPoint <T> > {
interval.Min, interval.Max
});
}
internal static Status DecideAnnotationStatus(IInterval variant, IInterval transcript, AnnotationBehavior behavior)
{
bool overlapsTranscript = variant.Overlaps(transcript);
if (!behavior.ReducedTranscriptAnnotation)
{
// handle small variants
if (overlapsTranscript)
{
return(Status.FullAnnotation);
}
if (behavior.NeedFlankingTranscripts && variant.Overlaps(transcript, OverlapBehavior.FlankingLength))
{
return(Status.FlankingAnnotation);
}
}
else if (overlapsTranscript)
{
// handle large variants
if (behavior.CanonicalTranscriptOnly)
{
return(Status.RohAnnotation);
}
return(Status.ReducedAnnotation);
}
return(Status.NoAnnotation);
}
public IInterval <T> Pop()
{
if (_Elements.Count == 0)
{
throw new InvalidOperationException("Cannot pop from the heap, it is currently empty");
}
IInterval <T> lastElement = _Elements[_Elements.Count - 1];
assume(lastElement != null);
_Elements.RemoveAt(_Elements.Count - 1);
IInterval <T> returnItem;
if (_Elements.Count > 0)
{
returnItem = _Elements[0];
assume(returnItem != null);
_Elements[0] = lastElement;
SiftUp(0);
}
else
{
returnItem = lastElement;
}
return(returnItem);
}
private void SiftUp(int pos)
{
int endPos = Count;
int startPos = pos;
IInterval <T> newItem = _Elements[pos];
// Bubble up the smaller child until hitting a leaf.
int childPos = 2 * pos + 1;
while (childPos < endPos)
{
// Set childpos to index of smaller child.
int rightPos = childPos + 1;
if (rightPos < endPos)
{
assume(_Elements[rightPos] != null && _Elements[childPos] != null);
if (_Elements[rightPos].End.CompareTo(_Elements[childPos].End) <= 0)
{
childPos = rightPos;
}
}
// Move the smaller child up.
_Elements[pos] = _Elements[childPos];
pos = childPos;
childPos = 2 * pos + 1;
}
_Elements[pos] = newItem;
SiftDown(startPos, pos);
}
/// <summary>
/// Tests if interval would be valid if it shared a track with another interval</summary>
/// <param name="interval">Interval that is being modified</param>
/// <param name="start">Prospective interval start; may be modified to make start valid</param>
/// <param name="length">Prospective interval length; may be modified to make length valid</param>
/// <param name="other">Other interval</param>
/// <returns>True iff interval would be valid if it shared a track with the other interval</returns>
public override bool IsIntervalValid(IInterval interval, ref float start, ref float length, IInterval other)
{
// If there is no overlap or a simple trimming will fix any overlap, then
// we're done.
if (ClipAgainst(interval, ref start, ref length, other))
return true;
// Otherwise, try to reposition to the right.
// Note: it would be helpful if Intervals were sorted.
start = other.Start + other.Length;
if (interval.Track != null)
{
IList<IInterval> intervals = interval.Track.Intervals;
for (int i = 0; i < intervals.Count; i++)
{
other = intervals[i];
if (other == interval)
continue;
if (!ClipAgainst(interval, ref start, ref length, other))
{
// position to the right of 'other' and try again
start = other.Start + other.Length;
i = -1;
}
}
}
return true;
}
private static IInterval[] GetMicroRnas()
{
var introns = new IInterval[1];
introns[0] = new Interval(100, 200);
return(introns);
}
public static bool IsMergedWith(this IInterval self, IInterval other)
{
var s = self.ToInterval();
var o = other.ToInterval();
return(s.Start == o.Start && o.End == s.End);
}
void PerformStabbingQuery(IntervalNode node, IInterval <TPoint> interval, List <IntervalNode> result)
{
if (node == null)
{
return;
}
if (interval.Start.CompareTo(node.MaxEndPoint) > 0)
{
return;
}
if (node.Left != null)
{
PerformStabbingQuery(node.Left, interval, result);
}
if (DoIntervalsOverlap(node, interval))
{
result.Add(node);
}
if (interval.End.CompareTo(node.Start) < 0)
{
return;
}
if (node.Right != null)
{
PerformStabbingQuery(node.Right, interval, result);
}
}
/// <summary>
/// Метод, возвращающий задержки при добавлении нового судна в конец очереди
/// </summary>
/// <param name="aircraftInterval"></param>
/// <param name="safeMergeValueParam"></param>
/// <returns></returns>
private Tuple <int, int> GetDelaysForNewLastAircraft(IInterval aircraftInterval, int safeMergeValueParam)
{
// Принимаем интервал обратившегося судна;
var currentInterval = aircraftInterval;
var safeMergeValue = safeMergeValueParam;
// Получаем начальный момент последнего записанного судна
var lastWrittenStartMoment = OccupationIntervals.Keys.OrderBy(key => key).Last();
// Получаем конечный момент последнего записанного судна
var lastWrittenEndMoment = OccupationIntervals[lastWrittenStartMoment];
// Сохраняем интервал ожидания обработки = момент покидания площадки последним записанным судном
// минус момент прибытия (без задержки) обратившегося судна;
var processingDelay = lastWrittenEndMoment.Value - currentInterval.StartMoment.Value;
// Сдвигаем текущий интервал на полученную задержку
var shiftedCurrentInterval = ShiftInterval(currentInterval, processingDelay);
// Получаем задержку для соблюдения интервала безопасного слияния
var safeMergeDelay = GetSafeMergeDelay(new Interval(lastWrittenStartMoment, lastWrittenEndMoment),
shiftedCurrentInterval, safeMergeValue);
// 4) Возвращаем в кортеже задержку для ожидания обработки и задержку для безопасного слияния;
return(Tuple.Create(processingDelay, safeMergeDelay));
}
public static IInterval <T> TryGetOverlappingInterval <T>([CanBeNull] this IInterval <T> interval, [CanBeNull] IInterval <T> other)
where T : struct, IComparable <T>
{
if (ReferenceEquals(interval, other))
{
return(interval);
}
if (interval == null || other == null)
{
return(null);
}
T start = interval.Start;
if (other.Start.CompareTo(start) > 0)
{
start = other.Start;
}
T end = interval.End;
if (other.End.CompareTo(end) < 0)
{
end = other.End;
}
if (start.CompareTo(end) >= 0)
{
return(null);
}
return(new Interval <T>(start, end));
}
private GeneralBnd(IVcfVariant variant, IInterval <uint> interval, bool is3Prime, ISimpleBreakEnd mate)
{
_baseVariant = variant;
_interval = interval;
Is3Prime = is3Prime;
Mate = mate;
}
internal static Status DecideAnnotationStatus(IInterval variant, IInterval transcript,
AnnotationBehavior behavior, IInterval gene)
{
if (variant.Contains(gene) && behavior.ReducedTranscriptAnnotation)
{
return(Status.SvCompleteOverlapAnnotation);
}
if (variant.Contains(gene) && !behavior.ReducedTranscriptAnnotation)
{
return(Status.FullAnnotation);
}
if (!variant.Contains(gene) && variant.Overlaps(transcript) && behavior.ReducedTranscriptAnnotation)
{
return(Status.ReducedAnnotation);
}
if (!variant.Contains(gene) && variant.Overlaps(transcript) && !behavior.ReducedTranscriptAnnotation)
{
return(Status.FullAnnotation);
}
if (!variant.Overlaps(transcript) && variant.Overlaps(transcript, OverlapBehavior.FlankingLength) && behavior.NeedFlankingTranscript)
{
return(Status.FlankingAnnotation);
}
return(Status.NoAnnotation);
}
/// <summary>
/// Checks if an interval contains a value
/// </summary>
/// <typeparam name="T">Type of the interval values</typeparam>
/// <param name="owningInterval">Owning interval</param>
/// <param name="value">Value</param>
/// <param name="captureEqual">True if equal values should be considered as containing, otherwise false</param>
/// <returns>True if the interval contains the value, otherwise false</returns>
/// <exception cref="ArgumentNullException">Throws if any provided value is null</exception>
public static bool Contains <T>(this IInterval <T> owningInterval, T value, bool captureEqual = true)
where T : IComparable <T>
{
if (owningInterval == null)
{
throw new ArgumentNullException(nameof(owningInterval), "Owning interval is null");
}
else if (owningInterval.Start == null)
{
throw new ArgumentNullException(nameof(owningInterval.Start), "Owning interval Start is null");
}
else if (owningInterval.Stop == null)
{
throw new ArgumentNullException(nameof(owningInterval.Stop), "Owning interval Stop is null");
}
else if (value == null)
{
throw new ArgumentNullException(nameof(value), "Value is null");
}
else
{
if (captureEqual)
{
return(owningInterval.Start.CompareTo(value) <= 0 && owningInterval.Stop.CompareTo(value) >= 0);
}
else
{
return(owningInterval.Start.CompareTo(value) < 0 && owningInterval.Stop.CompareTo(value) > 0);
}
}
}
/// <summary>
/// Gets the intersection between two intervals
/// </summary>
/// <typeparam name="T">Type of the intervals</typeparam>
/// <param name="owningInterval">Owning interval</param>
/// <param name="interval">Interval</param>
/// <param name="captureEqual">True if equal values should be considered as intersecting, otherwise false</param>
/// <returns>Intersection</returns>
/// <exception cref="ArgumentNullException">Throws if any provided value is null</exception>
/// <exception cref="ArgumentException">Throws if the provided values does not intersect</exception>
public static IInterval <T> GetIntersection <T>(this IInterval <T> owningInterval, IInterval <T> interval, bool captureEqual = true)
where T : IComparable <T>
{
if (interval == null)
{
throw new ArgumentNullException(nameof(interval), "Interval is null");
}
else
{
try
{
return(GetIntersection(owningInterval, interval.Start, interval.Stop, captureEqual));
}
catch (ArgumentNullException ex)
{
if (ex.ParamName == "firstValue")
{
throw new ArgumentNullException(nameof(interval.Start), "Interval Start is null");
}
else if (ex.ParamName == "secondValue")
{
throw new ArgumentNullException(nameof(interval.Stop), "Interval Stop is null");
}
else
{
throw;
}
}
}
}
public virtual IInterval <T> Overlap(IInterval <T> other)
{
if (Intersects(other))
{
if (Start.CompareTo(other.Start) <= 0)
{
if (End.CompareTo(other.End) <= 0)
{
return(Construct(other.Start, End));
}
else
{
return(Construct(other.Start, other.End));
}
}
else
{
if (End.CompareTo(other.End) <= 0)
{
return(Construct(Start, End));
}
else
{
return(Construct(Start, other.End));
}
}
}
else
{
return(null);
}
}
public override void Add(TValue value)
{
// Get position for the new point.
TMath position = default(TMath);
if (_data.Count > 0)
{
// Add the new key point, with the accumulated distance since the last key point.
KeyPoint last = _data[_data.Count - 1];
TMath distance = DistanceBetween(last.Value, value);
position = Operator <TMath> .Add(last.Position, distance);
}
// Create new key point.
var newKeyPoint = new KeyPoint
{
Position = position,
Value = value
};
// Update data range.
if (_dataRange == null)
{
// First object has zero distance.
_dataRange = new Interval <TMath>(_zero, _zero);
}
else
{
_dataRange = _dataRange.ExpandTo(position);
}
_data.Add(newKeyPoint);
}
/// <summary>
/// Performans a range query.
/// All items with overlapping ranges are returned.
/// </summary>
public IEnumerable <IInterval <T> > Query(IInterval <T> range)
{
// If the node has items, check their ranges.
if (this._items != null)
{
var localSearch = this._items
.TakeWhile(o => o.Min.Value.CompareTo(range.Max.Value) <= 0)
.Where(o => o.Overlaps(range));
foreach (var o in localSearch)
{
yield return(o);
}
}
// go to the left or go to the right of the tree, depending
// where the query value lies compared to the center
if (range.Min.Value.CompareTo(this._center) < 0 && this._leftNode != null)
{
foreach (var leftValue in this._leftNode.Query(range))
{
yield return(leftValue);
}
}
if (range.Max.Value.CompareTo(this._center) > 0 && this._rightNode != null)
{
foreach (var rightValue in this._rightNode.Query(range))
{
yield return(rightValue);
}
}
}
private void owner_MouseDownPicked(object sender, HitEventArgs e)
{
if (e.MouseEvent.Button != MouseButtons.Left)
{
return;
}
TimelinePath hitPath = e.HitRecord.HitPath;
bool isResizing = false;
switch (e.HitRecord.Type)
{
case HitType.IntervalResizeLeft:
if (Owner.IsEditable(hitPath) && (
Owner.Selection.SelectionContains(hitPath) ||
Owner.Select <IEvent>(hitPath)))
{
IInterval hitInterval = e.HitRecord.HitTimelineObject as IInterval;
m_resizer = new Resizer(Side.Left, ScaleMode.InPlace, hitInterval.Start, Owner);
isResizing = true;
}
break;
case HitType.IntervalResizeRight:
if (Owner.IsEditable(hitPath) && (
Owner.Selection.SelectionContains(hitPath) ||
Owner.Select <IEvent>(hitPath)))
{
IInterval hitInterval = e.HitRecord.HitTimelineObject as IInterval;
m_resizer = new Resizer(Side.Right, ScaleMode.InPlace, hitInterval.Start + hitInterval.Length, Owner);
isResizing = true;
}
break;
case HitType.Custom:
{
HitRecordObject hitManipulator = e.HitRecord.HitObject as HitRecordObject;
if (hitManipulator != null)
{
if (hitManipulator.Side == Side.Left)
{
m_resizer = new Resizer(Side.Left, ScaleMode.TimePeriod, m_worldMin, Owner);
}
else
{
m_resizer = new Resizer(Side.Right, ScaleMode.TimePeriod, m_worldMax, Owner);
}
isResizing = true;
}
}
break;
default:
m_resizer = null;
break;
}
Owner.IsResizingSelection = isResizing; //legacy. obsolete.
}
internal static WittyerVariantInternal Create([NotNull] IVcfVariant baseVariant,
IInterval <uint> baseInterval,
WittyerVariantType svType,
IContigAndInterval startInterval, Winner win,
List <OverlapAnnotation> overlapInfo, IWittyerSample sample, IContigAndInterval endInterval)
=> new WittyerVariantInternal(baseVariant, baseInterval, svType, startInterval, win,
overlapInfo, sample, endInterval);
public static bool Finishes(this IInterval self, IInterval other)
{
var s = self.ToInterval();
var o = other.ToInterval();
return(s.Start > o.Start && s.End == o.End);
}
// Gets the track and group that contains 'target'. Also handles if 'target' is a track or group.
private static void GetTrackAndGroup(ITimelineObject target, out ITrack targetTrack, out IGroup targetGroup)
{
IInterval interval = target as IInterval;
if (interval != null)
{
targetTrack = interval.Track;
}
else
{
IKey key = target as IKey;
if (key != null)
{
targetTrack = key.Track;
}
else
{
targetTrack = target as ITrack;
}
}
if (targetTrack != null)
{
targetGroup = targetTrack.Group;
}
else
{
targetGroup = target as IGroup;
}
}
List <IntervalNode> PerformStabbingQuery(IntervalNode node, IInterval <TPoint> interval)
{
var result = new List <IntervalNode>();
PerformStabbingQuery(node, interval, result);
return(result);
}
public void DetermineExonicEffect(ITranscript transcript, IInterval variant, IMappedPosition position,
int coveredCdnaStart, int coveredCdnaEnd, int coveredCdsStart, int coveredCdsEnd, string altAllele,
bool startCodonInsertionWithNoImpact)
{
HasExonOverlap = position.ExonStart != -1 || position.ExonEnd != -1;
if (transcript.Translation != null)
{
var codingRegion = transcript.Translation.CodingRegion;
AfterCoding = IsAfterCoding(variant.Start, variant.End, transcript.End, codingRegion.End);
BeforeCoding = IsBeforeCoding(variant.Start, variant.End, transcript.Start, codingRegion.Start);
WithinCds = IsWithinCds(coveredCdsStart, coveredCdsEnd, codingRegion, variant);
IsCoding = !startCodonInsertionWithNoImpact && (position.CdsStart != -1 || position.CdsEnd != -1);
}
WithinCdna = IsWithinCdna(coveredCdnaStart, coveredCdnaEnd, transcript.TotalExonLength);
if (coveredCdsStart != -1 && coveredCdsEnd != -1)
{
var varLen = coveredCdsEnd - coveredCdsStart + 1;
var alleleLen = altAllele?.Length ?? 0;
HasFrameShift = position.CdsStart != -1 && position.CdsEnd != -1 && !Codons.IsTriplet(alleleLen - varLen);
}
OverlapWithMicroRna = IsMatureMirnaVariant(position.CdnaStart, position.CdnaEnd, transcript.MicroRnas,
transcript.BioType == BioType.miRNA);
}
public static bool Meets(this IInterval self, IInterval other)
{
var s = self.ToInterval();
var o = other.ToInterval();
return(s.End == o.Start);
}
/// <summary>
/// Tests if length would be valid for the given interval</summary>
/// <param name="interval">Interval</param>
/// <param name="length">Prospective length; may be modified to make length valid</param>
/// <returns>True iff length value would be valid for the given interval</returns>
public override bool IsLengthValid(IInterval interval, ref float length)
{
// 0 length intervals will crash DefaultTimelineRenderer
if (length > 0)
return true;
length = 1;
return false;
}
/// <summary>
/// If you want to use it as a pulser.
/// Use this constructor to raise events
/// </summary>
/// <param name="interval"></param>
/// <param name="work"></param>
public AsyncPoller(IInterval interval, Func<CancellationToken, Task<IEnumerable<Event>>> work)
{
_work = async (token) =>
{
var events = await work(token);
var any = events.Any();
PulseGenerated(this, events);
return false;
};
_interval = interval;
}
public override RefResult NotifyRefChanged(IInterval changeInt, IReferenceTarget hTarget, ref UIntPtr partID, RefMessage message)
{
if (hTarget.Handle != target._Target.Handle)
return RefResult.Dontcare;
if (message == this.message)
action();
if (message == RefMessage.RefDeleted)
{
Kernel.listeners.Remove(this);
Dispose();
}
return RefResult.Succeed;
}
private bool ClipAgainst(IInterval interval, ref float start, ref float length, IInterval other)
{
// trim interval to avoid overlaps; interval is invalid only if that forces its
// length to be 0 or less
float end = start + length;
float otherStart = other.Start;
float otherEnd = otherStart + other.Length;
// if disjoint, return true
if (start >= otherEnd || end <= otherStart)
return true;
// if interval encloses and is larger than the other, cut as little as possible
if (start <= otherStart && end >= otherEnd && length > other.Length)
{
if ((end - otherEnd) < (otherStart - start))
length = otherStart - start;
else
{
start = otherEnd;
length = end - start;
}
return true;
}
// if interval contains other's start, try to trim its length
if (start < otherStart)
{
length = otherStart - start;
return true;
}
// if interval contains other's end, try to move its start
if (start < otherEnd && end > otherEnd)
{
length = end - otherEnd;
start = otherEnd;
return true;
}
// interval is the same as other or is inside other
return false;
}
/// <summary>
/// Gets the bounding rectangle for an interval, in timeline coordinates</summary>
/// <param name="interval">Interval</param>
/// <param name="trackTop">Top of track holding interval, in timeline coordinates</param>
/// <param name="transform">Transform, taking timeline coordinates to display</param>
/// <param name="clientRectangle">Bounds of displayed area of timeline, in screen space</param>
/// <returns>Bounding rectangle for the interval, in timeline coordinates</returns>
public RectangleF GetBounds(IInterval interval, float trackTop, Matrix transform,
RectangleF clientRectangle)
{
var c = new Context(this, transform, clientRectangle, m_graphics);
return GetBounds(interval, trackTop, c);
}
/// <summary> /// Gets the bounding rectangle for an interval, in timeline coordinates</summary> /// <param name="interval">Interval</param> /// <param name="trackTop">Top of track holding interval, in timeline coordinates</param> /// <param name="c">Drawing context</param> /// <returns>Bounding rectangle for the interval, in timeline coordinates</returns> protected abstract RectangleF GetBounds(IInterval interval, float trackTop, Context c);
/// <summary>
/// Finds hits on an interval, given a picking rectangle</summary>
/// <param name="interval">Interval</param>
/// <param name="bounds">Bounding rectangle, computed during layout phase</param>
/// <param name="pickRect">Picking rectangle</param>
/// <param name="c">Drawing context</param>
/// <returns>Type of hit</returns>
protected virtual HitType Pick(IInterval interval, RectangleF bounds, RectangleF pickRect, Context c)
{
if (!bounds.IntersectsWith(pickRect))
return HitType.None;
if (pickRect.Left <= bounds.Left && pickRect.Right >= bounds.Left)
return HitType.IntervalResizeLeft;
if (pickRect.Left <= bounds.Right && pickRect.Right >= bounds.Right)
return HitType.IntervalResizeRight;
return HitType.Interval;
}
/// <summary> /// Draws an interval</summary> /// <param name="interval">Interval</param> /// <param name="bounds">Bounding rectangle, in screen space</param> /// <param name="drawMode">Drawing mode</param> /// <param name="c">Drawing context</param> protected abstract void Draw(IInterval interval, RectangleF bounds, DrawMode drawMode, Context c);
/// <summary>
/// Draws an interval</summary>
/// <param name="interval">Interval</param>
/// <param name="bounds">Bounding rectangle, in screen space</param>
/// <param name="drawMode">Drawing mode</param>
/// <param name="c">Drawing context</param>
protected override void Draw(IInterval interval, RectangleF bounds, DrawMode drawMode, Context c)
{
Color color = interval.Color;
switch (drawMode & DrawMode.States)
{
case DrawMode.Normal:
RectangleF realPart = new RectangleF(
bounds.X,
bounds.Y,
GdiUtil.TransformVector(c.Transform, interval.Length),
bounds.Height);
bool hasTail = realPart.Width < MinimumDrawnIntervalLength;
float h = color.GetHue();
float s = color.GetSaturation();
float b = color.GetBrightness();
Color endColor = ColorUtil.FromAhsb(color.A, h, s * 0.3f, b);
c.Graphics.FillRectangle(
realPart,
new PointF(0, realPart.Top),new PointF(0, realPart.Bottom),
color, endColor);
if (hasTail)
{
endColor = ColorUtil.FromAhsb(64, h, s * 0.3f, b);
RectangleF tailPart = new RectangleF(
realPart.Right,
bounds.Y,
bounds.Width - realPart.Width,
bounds.Height);
c.Graphics.FillRectangle(tailPart, endColor);
}
if (color.R + color.G + color.B < 3 * 160)
TextBrush.Color = SystemColors.HighlightText;
else
TextBrush.Color = SystemColors.WindowText;
c.Graphics.DrawText(interval.Name, c.TextFormat, bounds.Location, TextBrush);
if ((drawMode & DrawMode.Selected) != 0)
{
c.Graphics.DrawRectangle(
new RectangleF(bounds.X + 1, bounds.Y + 1, bounds.Width - 2, bounds.Height - 2),
SelectedBrush, 3.0f);
}
break;
case DrawMode.Collapsed:
c.Graphics.FillRectangle(bounds, CollapsedBrush);
break;
case DrawMode.Ghost:
c.Graphics.FillRectangle(bounds, Color.FromArgb(128, color));
bool showRight = (drawMode & DrawMode.ResizeRight) != 0;
float x = showRight ? bounds.Right : bounds.Left;
c.Graphics.DrawText(
GetXPositionString(x, c),
c.TextFormat,
new PointF(x, bounds.Bottom - c.FontHeight),
TextBrush);
break;
case DrawMode.Invalid:
c.Graphics.FillRectangle(bounds, InvalidBrush);
break;
}
}
public Interval(IInterval i) { this.start = i.Start; this.end = i.End; }
public void Given()
{
_interval = new Interval(null);
_policy = _interval as Rainbow.ObjectFlow.Policies.Policy;
Assert.IsNotNull(_policy);
}
/// <summary>
/// Draws an interval</summary>
/// <param name="interval">Interval</param>
/// <param name="bounds">Bounding rectangle, in screen space</param>
/// <param name="drawMode">Drawing mode</param>
/// <param name="c">Drawing context</param>
protected override void Draw(IInterval interval, RectangleF bounds, DrawMode drawMode, Context c)
{
Color color = interval.Color;
switch (drawMode & DrawMode.States)
{
case DrawMode.Normal:
RectangleF realPart = new RectangleF(
bounds.X,
bounds.Y,
GdiUtil.TransformVector(c.Transform, interval.Length),
bounds.Height);
bool hasTail = realPart.Width < MinimumDrawnIntervalLength;
float h = color.GetHue();
float s = color.GetSaturation();
float b = color.GetBrightness();
Color endColor = ColorUtil.FromAhsb(color.A, h, s * 0.3f, b);
using (LinearGradientBrush intervalBrush =
new LinearGradientBrush(realPart, color, endColor, LinearGradientMode.Vertical))
{
c.Graphics.FillRectangle(intervalBrush, realPart);
if (hasTail)
{
Color[] colors = intervalBrush.LinearColors;
colors[0] = Color.FromArgb(64, colors[0]);
colors[1] = Color.FromArgb(64, colors[1]);
intervalBrush.LinearColors = colors;
RectangleF tailPart = new RectangleF(
realPart.Right,
bounds.Y,
bounds.Width - realPart.Width,
bounds.Height);
c.Graphics.FillRectangle(intervalBrush, tailPart);
}
}
Brush textBrush = SystemBrushes.WindowText;
if ((int)color.R + (int)color.G + (int)color.B < 3 * 160)
textBrush = SystemBrushes.HighlightText;
c.Graphics.DrawString(interval.Name, c.Font, textBrush, bounds.Location);
if ((drawMode & DrawMode.Selected) != 0)
{
c.Graphics.DrawRectangle(m_selectedPen, bounds.X + 1, bounds.Y + 1, bounds.Width - 2, bounds.Height - 2);
}
break;
case DrawMode.Collapsed:
c.Graphics.FillRectangle(m_collapsedBrush, bounds);
break;
case DrawMode.Ghost:
using (Brush brush = new SolidBrush(Color.FromArgb(128, color)))
{
c.Graphics.FillRectangle(brush, bounds);
bool showRight = (drawMode & DrawMode.ResizeRight) != 0;
float x = showRight ? bounds.Right : bounds.Left;
c.Graphics.DrawString(GetXPositionString(x, c), c.Font, SystemBrushes.WindowText, x, bounds.Bottom - c.FontHeight);
}
break;
case DrawMode.Invalid:
c.Graphics.FillRectangle(m_invalidBrush, bounds);
break;
}
}
public PollingWorker(IInterval interval, Func<bool> work)
{
_work = work;
_interval = interval;
}
/// <summary> /// Tests if the interval would be valid if it shared a track with another interval. /// Any modification to 'start' and 'length' should not invalidate a previous test /// against a different interval, during a paste operation, for example.</summary> /// <param name="interval">Interval that is being modified</param> /// <param name="start">Prospective interval start; may be modified to make start valid</param> /// <param name="length">Prospective interval length; may be modified to make length valid</param> /// <param name="other">Other interval</param> /// <returns>True iff interval would be valid if it shared a track with the other interval</returns> public abstract bool IsIntervalValid(IInterval interval, ref float start, ref float length, IInterval other);
private void SplitUnselectedInterval(IInterval interval, float fraction)
{
m_owner.TransactionContext.DoTransaction(delegate
{
DoSplit(interval, fraction);
},
"Split Interval");
}
public AsyncPoller(IInterval interval, Func<CancellationToken, Task<bool>> work)
{
_work = work;
_interval = interval;
}
/// <summary>
/// Gets the bounding rectangle for an interval, in timeline coordinates</summary>
/// <param name="interval">Interval</param>
/// <param name="trackTop">Top of track holding interval</param>
/// <param name="c">Drawing context</param>
/// <returns>Bounding rectangle for the interval, in timeline coordinates</returns>
protected override RectangleF GetBounds(IInterval interval, float trackTop, Context c)
{
// Calculate the width, in timeline coordinates. If the group is expanded, then
// make sure that interval meets the minimum visible width requirement.
float visibleWidth = interval.Length;
if (interval.Track != null &&
interval.Track.Group != null &&
interval.Track.Group.Expanded)
{
float minimumTimelineUnits = c.PixelSize.Width * MinimumDrawnIntervalLength;
visibleWidth = Math.Max(visibleWidth, minimumTimelineUnits);
}
return new RectangleF(
interval.Start,
trackTop,
visibleWidth,
TrackHeight);
}
/// <summary> /// Tests if length would be valid for the given interval</summary> /// <param name="interval">Interval</param> /// <param name="length">Prospective length; may be modified to make length valid</param> /// <returns>True iff length value would be valid for the given interval</returns> public abstract bool IsLengthValid(IInterval interval, ref float length);
private IInterval DoSplit(IInterval interval, float fraction)
{
IInterval rightSide = null;
float originalStart = interval.Start;
float originalLength = interval.Length;
float worldX = originalStart + originalLength * fraction;
worldX = m_owner.ConstrainFrameOffset(worldX);
if (worldX > originalStart &&
worldX < originalStart + originalLength)
{
// 'interval' becomes the left side and we create a new interval for the right side.
rightSide = m_owner.Create(interval);
rightSide.Start = worldX;
rightSide.Length = originalLength - (worldX - originalStart);
interval.Length = worldX - originalStart;
interval.Track.Intervals.Add(rightSide);
}
return rightSide;
}
