void Can_MouseMove(object sender, MouseEventArgs e)
{
double x,taktwidth = Can.ActualWidth / Convert.ToInt32(TBPer.Text);
Point p;
if (Mouse.LeftButton == MouseButtonState.Pressed)
{
if (DraggedChange != null)
{
int takt = Convert.ToInt32(Math.Floor(e.GetPosition(Can).X / taktwidth));
bool TaktAllow = true;
foreach (Change ch in Changes)
{
if (ch.Takt == takt)
{
TaktAllow = false;
break;
}
}
if (TaktAllow) DraggedChange.Takt = takt;
int previndex = Changes.IndexOf(DraggedChange) - 1;
if (takt < Changes[previndex].Takt)
{
Changes.Remove(DraggedChange);
Changes.Insert(previndex, DraggedChange);
Draw();
}
else if ((Changes.Last() != DraggedChange)&&(DraggedChange.Takt >= Changes[previndex + 2].Takt))
{
Changes.Remove(DraggedChange);
Changes.Insert(previndex + 2, DraggedChange);
Draw();
}
x = e.GetPosition(Can).X;
PLines[Changes.IndexOf(DraggedChange) - 1].Points.RemoveAt(2);
PLines[Changes.IndexOf(DraggedChange) - 1].Points.RemoveAt(1);
p = new Point { X = x, Y = startY + Change.GetHeightDelta(Changes[Changes.IndexOf(DraggedChange) - 1].Value, Settings.LineHeight) };
PLines[Changes.IndexOf(DraggedChange) - 1].Points.Add(p);
p = new Point { X = x, Y = startY + Change.GetHeightDelta(DraggedChange.Value, Settings.LineHeight) };
PLines[Changes.IndexOf(DraggedChange) - 1].Points.Add(p);
p = new Point { X = x, Y = startY + Change.GetHeightDelta(DraggedChange.Value, Settings.LineHeight) };
PLines[Changes.IndexOf(DraggedChange)].Points.RemoveAt(0);
PLines[Changes.IndexOf(DraggedChange)].Points.Insert(0, p);
}
}
else
{
if (DraggedChange != null)
{
DraggedChange = null;
for (int i = 0; i < Changes.Count - 1; i++)
{
if (Changes[i].Value == Changes[i + 1].Value)
{
Changes.RemoveAt(i + 1);
i--;
}
}
Draw();
}
}
}
void ChangeAdd(Change ch)
{
for (int i = 0; i < Changes.Count; i++)
{
if (Changes[i].Takt == ch.Takt)
{
Changes[i].Value = ch.Value;
return;
}
else if (Changes[i].Takt > ch.Takt)
{
Changes.Insert(i, ch);
return;
}
}
Changes.Add(ch);
for (int i = 0; i < Changes.Count - 1; i++)
{
if (Changes[i].Value == Changes[i + 1].Value)
{
Changes.RemoveAt(i + 1);
i--;
}
}
}
private void Can_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
double taktwidth = Can.ActualWidth / Convert.ToInt32(TBPer.Text);
foreach (Change ch in Changes)
{
if (Math.Abs(e.GetPosition(Can).X - ch.Takt * taktwidth) < 5)
{
if (ch != Changes[0])
DraggedChange = ch;
}
}
}
void Can_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (DraggedChange != null)
{
DraggedChange = null;
for (int i = 0; i < Changes.Count - 1; i++)
{
if (Changes[i].Value == Changes[i + 1].Value)
{
Changes.RemoveAt(i + 1);
i--;
}
}
Draw();
}
}
public abstract void ChangeAdd(Change ch);
public Signal getDrawChanges(int TaktCount, int BeginTakt, int EndTakt)
{
Signal DrawChangesSignal = new Signal();
if (Signal.Changes.Count == 0)
return DrawChangesSignal;
ChPrev = Signal.Changes[0].Copy();
DrawChangesSignal.Changes.Clear();
foreach (Change ch in Signal.Changes)
{
if ((ch.Takt >= BeginTakt) && (ch.Takt <= EndTakt))
{
DrawChangesSignal.ChangeAdd(ch.Copy());
}
else if ((ch.Takt < BeginTakt) && (ch.Takt > ChPrev.Takt))
ChPrev = ch.Copy();
}
int n, takt;
foreach (Period p in Signal.Periods)
{
n = (p.N == "&") ? ((TaktCount - p.Beg) / p.Per + 1) : Convert.ToInt32(p.N);
for (int i = 0; i < n; i++)
{
foreach (Change ch in p.Changes)
{
takt = p.Beg + ch.Takt + p.Per * i;
if ((takt >= BeginTakt) && (takt <= EndTakt))
DrawChangesSignal.ChangeAdd(new Change(takt, ch.Value));
else if ((takt < BeginTakt) && (takt > ChPrev.Takt))
ChPrev = new Change(takt, ch.Value);
}
}
}
if (DrawChangesSignal.Changes.Count == 0)
DrawChangesSignal.ChangeAdd(ChPrev);
return DrawChangesSignal;
}
public override void Redraw()
{
int i, j, BeginTakt = wnd.BeginTakt, EndTakt = wnd.EndTakt;
Sig = Signal;// getDrawChanges(wnd.TaktCount, BeginTakt, EndTakt);
ChPrev = Sig.Changes[0];
Canvas Can = CanLine;
int TTakt = Project.TTakt;
int TaktsDraw = EndTakt - BeginTakt + 1;
int TimeWidth = TaktsDraw * Project.TTakt;
CanWidth = (Can.Parent as TreeViewItem).ActualWidth;
if (CanWidth <= 0)
CanWidth = wnd.LBSigCans.ActualWidth;
double TaktWidth = CanWidth * 1.0 / TaktsDraw * 1.0;
double pixK = CanWidth * 1.0 / TimeWidth * 1.0;
double timeK = TimeWidth * 1.0 / CanWidth * 1.0;
int LineHeight = Settings.LineHeight;
for (i = 0; i < PChangesGens.Count; i++)
{
Can.Children.Remove(PChangesGens[i]);
}
//Can.Children.Clear();
PChangesGens.Clear();
foreach (PeriodVisual pv in PeriodVisuals)
{
wnd.GSVSignals.Children.Remove(pv.Can);
}
PeriodVisuals.Clear();
//Change ChCurrent;
int CurrentVal = ChPrev.Value;
double CurrentX = 0;
Polyline PLine;
PeriodVisual Pv;
foreach (Period p in Signal.Periods)
{
Pv = new PeriodVisual(p, Parent, wnd);
Pv.Redraw();
PeriodVisuals.Add(Pv);
}
int GEN_DRAW_TYPE = (Gen.Type == Generator.RZ) ? Generator.R0 : Gen.Type; // заменяет тип RZ на R0 (для упрощения switch)
switch (GEN_DRAW_TYPE)
{
case Generator.DNRZ:
for (i=0; i<Sig.Changes.Count; i++)
{
PLine = new Polyline();
PLine.StrokeThickness = (isSelected) ? Settings.SelectedThickness : Settings.SignalThickness;
PLine.Stroke = Sig.ChangeBrushes[CurrentVal];
PLine.Points.Add(new Point { X = CurrentX - 1, Y = Change.GetHeightDelta(CurrentVal, LineHeight) });
CurrentX = (Sig.Changes[i].Takt - BeginTakt) * TaktWidth;
if (CurrentX < 0) CurrentX = 0;
PLine.Points.Add(new Point { X = CurrentX, Y = Change.GetHeightDelta(CurrentVal, LineHeight) });
CurrentVal = Sig.Changes[i].Value;
PLine.Points.Add(new Point { X = CurrentX, Y = Change.GetHeightDelta(CurrentVal, LineHeight) });
PChangesGens.Add(PLine);
}
PLine = new Polyline();
PLine.StrokeThickness = (isSelected) ? Settings.SelectedThickness : Settings.SignalThickness;
PLine.Stroke = Sig.ChangeBrushes[CurrentVal];
PLine.Points.Add(new Point { X = CurrentX, Y = Change.GetHeightDelta(CurrentVal, LineHeight) });
PLine.Points.Add(new Point { X = CanWidth, Y = Change.GetHeightDelta(CurrentVal, LineHeight) });
PChangesGens.Add(PLine);
foreach (Polyline P in PChangesGens)
Can.Children.Add(P);
return;
case Generator.NRZ:
return;
case Generator.R0:
return;
case Generator.R1:
return;
}
}
public override void ChangeAdd(Change ch)
{
foreach(Signal signal in Signals)
signal.ChangeAdd(ch);
}
public override void ChangeAdd(Change ch)
{
switch (ch.Value)
{
case Change.Zero:
if (Mode == Modes.Out)
return;
break;
case Change.One:
if (Mode == Modes.Out)
return;
break;
case Change.Hash:
if (Mode == Modes.In)
return;
break;
case Change.Star:
if (Mode == Modes.In)
return;
break;
case Change.Z:
if (Mode == Modes.In)
return;
break;
case Change.X:
break;
}
int Count = Changes.Count;
int prevN = Int32.MaxValue;
for (int i = 1; i < Changes.Count; i++)
{
if (Changes[i].Takt > ch.Takt)
{
prevN = i - 1;
break;
}
}
if (prevN == Int32.MaxValue)
prevN = Count - 1;
//#################### I ###########################
if (Changes.Count == 0) // если в сигнале нет значений
{
Changes.Add(ch);
}
else if (Changes[prevN].Takt > ch.Takt)
{
if (Changes[prevN].Value == ch.Value)
Changes[prevN].Takt = ch.Takt;
else
Changes.Insert(prevN, ch);
}
//#################### II ###########################
else if (ch.Takt == 0)
{
if (Changes[0].Takt > 0)
Changes.Insert(0, ch);
else
Changes[0].Value = ch.Value;
}
else if (Changes[prevN].Takt == ch.Takt) // если такт совпадает с другим значением
{
if (ch.Takt == 0)
{
Changes[0].Value = ch.Value;
}
else if (prevN == 0)
{
if (Count > (prevN + 1))
{
if (Changes[prevN + 1].Value == ch.Value)
{
Changes.RemoveAt(prevN + 1);
Changes[prevN].Value = ch.Value;
}
}
}
else if (prevN == (Count - 1))
{
if (prevN > 0)
{
if (Changes[prevN - 1].Value == ch.Value)
{
Changes.RemoveAt(prevN);
}
else
{
Changes[prevN].Value = ch.Value;
}
}
}
else
{
if (Count > (prevN + 1))
{
if (Changes[prevN + 1].Value == ch.Value)
{
Changes.RemoveAt(prevN + 1);
Changes[prevN].Value = ch.Value;
}
else
{
Changes[prevN].Value = ch.Value;
}
}
if (prevN > 0)
{
if (Changes[prevN - 1].Value == ch.Value)
{
Changes.RemoveAt(prevN);
}
else
{
Changes[prevN].Value = ch.Value;
}
}
}
}
//#################### III ###########################
else if (Changes[prevN].Value == ch.Value) // случай, когда значение равно левому
{
}
//#################### IV ###########################
else if (prevN != Count - 1) // случай, когда значение равно правому
{
if (Changes[prevN + 1].Value == ch.Value)
{
Changes[prevN + 1].Takt = ch.Takt;
}
}
//#################### V ###########################
else
{
if (Changes[prevN].Takt > ch.Takt)
Changes.Insert(prevN, ch);
else
Changes.Insert(prevN + 1, ch);
}
foreach (GlobalLine GLine in GLines)
GLine.Redraw();
}
