public bool Synchronize()
{
bool changed = false;
foreach (ICheckElem _elem in elems)
{
if (_elem.HasChanged())
{
if (pPnts == null)
{
ChartPoints.Globals.processor.AddProjectChartPoints(projName, out pPnts);
}
if (fPnts == null)
{
fPnts = pPnts.AddFileChartPoints(fileName);
}
if (lPnts == null)
{
lPnts = fPnts.AddLineChartPoints(lineNum, linePos);
}
changed = lPnts.SyncChartPoint(_elem);
}
}
return(changed);
}
public bool RemoveLineChartPoints(ILineChartPoints linePnts)
{
bool ret = linePoints.Remove(linePnts);
if (ret)
{
remCPLineEvent.Fire(new CPFileEvArgs(this, linePnts));
}
return(ret);
}
public ILineChartPoints GetFileLineChartPoints(string fname, int lineNum)
{
ILineChartPoints lPnts = null;
IFileChartPoints fPnts = GetFileChartPoints(fname);
if (fPnts != null)
{
lPnts = fPnts.GetLineChartPoints(lineNum);
}
return(lPnts);
}
protected bool MoveLineChartPoints(ILineChartPoints linePnts, int linesAdd)
{
bool ret = linePoints.Remove(linePnts);
if (ret)
{
int prevLine = ((TextPosition)((LineChartPoints)linePnts).data.pos).lineNum;
((TextPosition)((LineChartPoints)linePnts).data.pos).lineNum += linesAdd;
linePoints.Add(linePnts);
//addCPLineEvent.Fire(new CPFileEvArgs(this, linePnts));
moveCPLineEvent.Fire(new CPLineMoveEvArgs(linePnts, prevLine, prevLine + linesAdd));
}
return(ret);
}
protected bool AddLineChartPoints(ILineChartPoints linePnts)
{
ILineChartPoints lPnts = GetLineChartPoints(linePnts.data.pos.lineNum);
if (lPnts == null)
{
linePoints.Add(linePnts);
linePnts.remCPEvent += OnRemCp;
addCPLineEvent.Fire(new CPFileEvArgs(this, linePnts));
return(true);
}
return(false);
}
public ILineChartPoints AddLineChartPoints(int lineNum, int linePos)
{
ILineChartPoints lPnts = GetLineChartPoints(lineNum);
if (lPnts == null)
{
CP.Code.IClassMethodElement classMethodElem = fileElem.GetMethodFromFilePos(lineNum, linePos);
if (classMethodElem != null)
{
lPnts = CP.Utils.IClassFactory.GetInstance().CreateLineCPs(classMethodElem, lineNum, linePos, data);
AddLineChartPoints(lPnts);
}
//else
//;
}
return(lPnts);
}
public bool RemoveChartPoints(string projName)
{
IProjectChartPoints pcp = GetProjectChartPoints(projName);
if (pcp != null)
{
IFileChartPoints fCPs = null;
while ((fCPs = pcp.filePoints.FirstOrDefault()) != null)
{
if (fCPs.linePoints.Count == 0)
{
pcp.filePoints.Remove(fCPs);
}
else
{
ILineChartPoints lCPs = null;
while ((lCPs = fCPs.linePoints.FirstOrDefault()) != null)
{
if (lCPs.chartPoints.Count == 0)
{
fCPs.RemoveLineChartPoints(lCPs);
}
else
{
IChartPoint cp = null;
while ((cp = lCPs.chartPoints.FirstOrDefault()) != null)
{
lCPs.RemoveChartPoint(cp);
}
}
}
}
}
data.projPoints.Remove(pcp);
}
return(true);
}
protected CPPropsDeSerializator(SerializationInfo info, StreamingContext context)
{
try
{
UInt32 projsCount = info.GetUInt32("projPoints.Count");
for (uint p = 0; p < projsCount; ++p)
{
string projName = info.GetString("projName_" + p.ToString());
Globals.processor.RemoveChartPoints(projName);
UInt32 filesCount = info.GetUInt32("filePoints.Count_" + p.ToString());
if (filesCount > 0)
{
IProjectChartPoints projCPs = Globals.processor.GetProjectChartPoints(projName);
if (projCPs == null)
{
Globals.processor.AddProjectChartPoints(projName, out projCPs);
}
if (projCPs != null)
{
for (uint f = 0; f < filesCount; ++f)
{
string fileName = info.GetString("fileName_" + p.ToString() + f.ToString());
IFileChartPoints fPnts = projCPs.AddFileChartPoints(fileName);
if (fPnts != null)
{
UInt32 linesCount = info.GetUInt32("linePoints.Count_" + p.ToString() + f.ToString());
for (uint l = 0; l < linesCount; ++l)
{
UInt32 lineNum = info.GetUInt32("lineNum_" + p.ToString() + f.ToString() + l.ToString());
UInt32 linePos = info.GetUInt32("linePos_" + p.ToString() + f.ToString() + l.ToString());
ILineChartPoints lPnts = fPnts.AddLineChartPoints((int)lineNum, (int)linePos);
if (lPnts != null)
{
UInt32 cpsCount = info.GetUInt32("cpsPoints.Count_" + p.ToString() + f.ToString() + l.ToString());
for (uint cp = 0; cp < cpsCount; ++cp)
{
IChartPoint chartPnt = null;
string uniqueName = info.GetString("uniqueName_" + p.ToString() + f.ToString() + l.ToString() + cp.ToString());
bool enabled = info.GetBoolean("enabled_" + p.ToString() + f.ToString() + l.ToString() + cp.ToString());
if (lPnts.AddChartPoint(uniqueName, out chartPnt))
{
chartPnt.SetStatus(enabled ? EChartPointStatus.SwitchedOn : EChartPointStatus.SwitchedOff);
}
}
}
if (lPnts.Count == 0)
{
fPnts.RemoveLineChartPoints(lPnts);
}
}
}
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
//public void MoveChartPoint(ILineChartPoints _lcps, IChartPoint cp, int _lineNum, int _linePos)
//{
// ILineChartPoints lcps = AddLineChartPoints(_lineNum, _linePos);
// lcps.AddChartPoint(cp);
//}
public ILineChartPoints GetLineChartPoints(int lineNum)
{
ILineChartPoints lPnts = linePoints.FirstOrDefault((lp) => (lp.data.pos.lineNum == lineNum));
return(lPnts);
}
public CPFileEvArgs(IFileChartPoints _fileCPs, ILineChartPoints _lineCPs)
{
fileCPs = _fileCPs;
lineCPs = _lineCPs;
}
public CPLineMoveEvArgs(ILineChartPoints _lineCPs, int _prevLine, int _newLine)
{
lineCPs = _lineCPs;
prevLine = _prevLine;
newLine = _newLine;
}
public CPLineEvArgs(ILineChartPoints _lineCPs, IChartPoint _cp)
{
lineCPs = _lineCPs;
cp = _cp;
}
public LineCPStatusEvArgs(ILineChartPoints _lineCPs)
{
lineCPs = _lineCPs;
}
