//=============================================================================
public static bool ChangeOffsetY(Column fixedColumn, double newGlobalOffset_Y, double DrawingLength, double DrawingWidth, bool bChangedViaProperties)
{
if (fixedColumn == null)
{
return(false);
}
DrawingSheet _sheet = fixedColumn.Sheet;
if (_sheet == null)
{
return(false);
}
//
newGlobalOffset_Y = Utils.GetWholeNumber(newGlobalOffset_Y);
if (newGlobalOffset_Y <= 0)
{
return(false);
}
//
DrawingControl drawing = null;
if (fixedColumn.Wrapper != null)
{
drawing = fixedColumn.Wrapper.Owner;
}
//
if (drawing == null)
{
return(false);
}
//
ColumnPattern pattern = fixedColumn.Pattern;
if (pattern == null)
{
return(false);
}
//
Point patternStartPoint;
int columnsCount;
int rowsCount;
List <Column> patternColumnsList;
List <List <Column> > patternRows;
if (!pattern.GetPatternInfo(out patternStartPoint, out columnsCount, out rowsCount, out patternColumnsList, out patternRows))
{
return(false);
}
//
if (columnsCount <= 0 ||
rowsCount <= 0 ||
patternColumnsList.Count < 1 ||
patternRows.Count < 1)
{
return(false);
}
// columns in the pattern cannot overlap each other
double rMaxWidth = 0;
for (int iColumnIndex = 0; iColumnIndex < columnsCount; ++iColumnIndex)
{
for (int iRowIndex = 0; iRowIndex < rowsCount - 1; ++iRowIndex)
{
Column currColumn = patternRows[iRowIndex][iColumnIndex];
Column nextColumn = patternRows[iRowIndex + 1][iColumnIndex];
if (currColumn == null || nextColumn == null)
{
continue;
}
double maxDist = currColumn.Length_Y / 2 + nextColumn.Length_Y / 2;
if (Utils.FGT(maxDist, rMaxWidth))
{
rMaxWidth = maxDist;
}
}
}
if (Utils.FLE(rMaxWidth, 0.0))
{
rMaxWidth = patternColumnsList[0].Length_Y;
}
//
if (Utils.FLE(rMaxWidth, 0.0))
{
return(false);
}
//
if (Utils.FLT(newGlobalOffset_Y, rMaxWidth))
{
if (bChangedViaProperties)
{
return(false);
}
newGlobalOffset_Y = rMaxWidth;
}
// calculate index zero based
int iCurRowIndex = Utils.GetWholeNumber((fixedColumn.Center_GlobalPoint.Y - patternStartPoint.Y) / pattern.GlobalOffset_Y);
int iCurColumnIndex = Utils.GetWholeNumber((fixedColumn.Center_GlobalPoint.X - patternStartPoint.X) / pattern.GlobalOffset_X);
//
if (iCurRowIndex >= patternRows.Count)
{
return(false);
}
// make preview column pattern and check layout
List <List <Column> > _previewRows = new List <List <Column> >();
foreach (List <Column> _row in patternRows)
{
List <Column> _previewRow = new List <Column>();
foreach (Column c in _row)
{
Column _previewColumn = null;
if (c != null)
{
_previewColumn = c.Clone() as Column;
}
;
if (_previewColumn != null)
{
_previewColumn.Sheet = _sheet;
_previewRow.Add(_previewColumn);
}
}
_previewRows.Add(_previewRow);
}
//
// change offset
List <BaseRectangleGeometry> _RectanglesToCheck = new List <BaseRectangleGeometry>();
foreach (List <Column> _previewRow in _previewRows)
{
int iPreviewRowIndex = _previewRows.IndexOf(_previewRow);
int iSign = 1;
if (iPreviewRowIndex < iCurRowIndex)
{
iSign = -1;
}
foreach (Column _previewColumn in _previewRow)
{
if (_previewColumn != null)
{
Point newTopLeftPoint = _previewColumn.Center_GlobalPoint;
newTopLeftPoint.X -= _previewColumn.Length_X / 2;
newTopLeftPoint.Y = fixedColumn.Center_GlobalPoint.Y;
newTopLeftPoint.Y += iSign * Math.Abs(iCurRowIndex - iPreviewRowIndex) * newGlobalOffset_Y;
newTopLeftPoint.Y -= _previewColumn.Length_Y / 2;
//
newTopLeftPoint = Utils.GetWholePoint(newTopLeftPoint);
//
_previewColumn.TopLeft_GlobalPoint = newTopLeftPoint;
_RectanglesToCheck.Add(_previewColumn);
}
}
}
// check borders
List <Column> _firstRow = _previewRows[0];
if (_firstRow == null)
{
return(false);
}
foreach (Column c in _firstRow)
{
if (c != null)
{
if (c.TopLeft_GlobalPoint.Y < 0)
{
return(false);
}
}
}
//
List <Column> _lastRow = _previewRows[_previewRows.Count - 1];
if (_lastRow == null)
{
return(false);
}
foreach (Column c in _lastRow)
{
if (c != null)
{
if (c.BottomRight_GlobalPoint.Y > DrawingWidth)
{
return(false);
}
}
}
//
List <BaseRectangleGeometry> _columnsToignore = new List <BaseRectangleGeometry>();
_columnsToignore.AddRange(patternColumnsList);
foreach (List <Column> _previewRow in _previewRows)
{
_columnsToignore.AddRange(_previewRow);
}
// check layout
List <BaseRectangleGeometry> overlappedRectangles;
if (_sheet.IsLayoutCorrect(_RectanglesToCheck, _columnsToignore, out overlappedRectangles))
{
pattern.GlobalOffset_Y = newGlobalOffset_Y;
// apply changes
foreach (List <Column> _row in patternRows)
{
int iRowIndex = patternRows.IndexOf(_row);
if (iRowIndex == iCurRowIndex)
{
continue;
}
//
int iSign = 1;
if (iRowIndex < iCurRowIndex)
{
iSign = -1;
}
foreach (Column _columnToChange in _row)
{
if (_columnToChange != null)
{
Point newTopLeftPoint = _columnToChange.Center_GlobalPoint;
newTopLeftPoint.X -= _columnToChange.Length_X / 2;
newTopLeftPoint.Y = fixedColumn.Center_GlobalPoint.Y;
newTopLeftPoint.Y += iSign * Math.Abs(iCurRowIndex - iRowIndex) * pattern.GlobalOffset_Y;
newTopLeftPoint.Y -= _columnToChange.Length_Y / 2;
//
//
newTopLeftPoint = Utils.GetWholePoint(newTopLeftPoint);
//
_columnToChange.TopLeft_GlobalPoint = newTopLeftPoint;
}
}
}
return(true);
}
return(false);
}
//=============================================================================
/// <summary>
/// Try to set new ColumnPattern.GlobalOffset_X.
/// </summary>
public static bool ChangeOffsetX(Column fixedColumn, double newGlobalOffset_X, double DrawingLength, double DrawingWidth, bool bChangedViaProperties)
{
if (fixedColumn == null)
{
return(false);
}
DrawingSheet sheet = fixedColumn.Sheet;
if (sheet == null)
{
return(false);
}
//
newGlobalOffset_X = Utils.GetWholeNumber(newGlobalOffset_X);
if (newGlobalOffset_X <= 0)
{
return(false);
}
//
DrawingControl drawing = null;
if (fixedColumn.Wrapper != null)
{
drawing = fixedColumn.Wrapper.Owner;
}
//
if (drawing == null)
{
return(false);
}
//
ColumnPattern pattern = fixedColumn.Pattern;
if (pattern == null)
{
return(false);
}
//
Point patternStartPoint;
int columnsCount;
int rowsCount;
List <Column> patternColumnsList;
List <List <Column> > patternRows;
if (!pattern.GetPatternInfo(out patternStartPoint, out columnsCount, out rowsCount, out patternColumnsList, out patternRows))
{
return(false);
}
//
if (columnsCount <= 0 ||
rowsCount <= 0 ||
patternColumnsList.Count < 1 ||
patternRows.Count < 1)
{
return(false);
}
// columns in the pattern cannot overlap each other
double rMaxLength = 0;
foreach (List <Column> row in patternRows)
{
if (row == null)
{
continue;
}
if (row.Count == 1 && row[0] != null)
{
if (Utils.FGT(row[0].Length_X, rMaxLength))
{
rMaxLength = row[0].Length_X;
}
continue;
}
for (int i = 0; i < row.Count - 1; ++i)
{
Column currColumn = row[i];
Column nextColumn = row[i + 1];
if (currColumn == null || nextColumn == null)
{
continue;
}
double maxDist = currColumn.Length_X / 2 + nextColumn.Length_X / 2;
if (Utils.FGT(maxDist, rMaxLength))
{
rMaxLength = maxDist;
}
}
}
//
if (Utils.FLE(rMaxLength, 0.0))
{
return(false);
}
//
if (Utils.FLT(newGlobalOffset_X, rMaxLength))
{
if (bChangedViaProperties)
{
return(false);
}
newGlobalOffset_X = rMaxLength;
}
// calculate index zero based
int iCurRowIndex = Utils.GetWholeNumber((fixedColumn.Center_GlobalPoint.Y - patternStartPoint.Y) / pattern.GlobalOffset_Y);
int iCurColumnIndex = Utils.GetWholeNumber((fixedColumn.Center_GlobalPoint.X - patternStartPoint.X) / pattern.GlobalOffset_X);
//
if (iCurRowIndex >= patternRows.Count)
{
return(false);
}
// make preview column pattern and check layout
List <List <Column> > previewRows = new List <List <Column> >();
foreach (List <Column> row in patternRows)
{
List <Column> previewRow = new List <Column>();
foreach (Column c in row)
{
Column previewColumn = null;
if (c != null)
{
previewColumn = c.Clone() as Column;
}
if (previewColumn != null)
{
previewColumn.Sheet = sheet;
previewRow.Add(previewColumn);
}
}
previewRows.Add(previewRow);
}
// change offset
List <BaseRectangleGeometry> _RectanglesToCheck = new List <BaseRectangleGeometry>();
foreach (List <Column> previewRow in previewRows)
{
Point curCenterPoint = patternStartPoint;
curCenterPoint.X += iCurColumnIndex * pattern.GlobalOffset_X;
curCenterPoint.Y += previewRows.IndexOf(previewRow) * pattern.GlobalOffset_Y;
// left side of the row
for (int iColumn = iCurColumnIndex - 1; iColumn >= 0; --iColumn)
{
Column _previewColumn = previewRow[iColumn];
if (_previewColumn != null)
{
Point newTopLeft_GlobalPoint = curCenterPoint;
newTopLeft_GlobalPoint.X -= newGlobalOffset_X * Math.Abs(iCurColumnIndex - iColumn);
newTopLeft_GlobalPoint.X -= _previewColumn.Length_X / 2;
newTopLeft_GlobalPoint.Y -= _previewColumn.Length_Y / 2;
//
newTopLeft_GlobalPoint = Utils.GetWholePoint(newTopLeft_GlobalPoint);
//
_previewColumn.TopLeft_GlobalPoint = newTopLeft_GlobalPoint;
_RectanglesToCheck.Add(_previewColumn);
}
}
// right side of the row
for (int iColumn = iCurColumnIndex + 1; iColumn < previewRow.Count; ++iColumn)
{
Column _previewColumn = previewRow[iColumn];
if (_previewColumn != null)
{
Point newTopLeft_GlobalPoint = curCenterPoint;
newTopLeft_GlobalPoint.X += newGlobalOffset_X * Math.Abs(iCurColumnIndex - iColumn);
newTopLeft_GlobalPoint.X -= _previewColumn.Length_X / 2;
newTopLeft_GlobalPoint.Y -= _previewColumn.Length_Y / 2;
//
newTopLeft_GlobalPoint = Utils.GetWholePoint(newTopLeft_GlobalPoint);
//
_previewColumn.TopLeft_GlobalPoint = newTopLeft_GlobalPoint;
_RectanglesToCheck.Add(_previewColumn);
}
}
}
// check borders
foreach (List <Column> previewRow in previewRows)
{
if (previewRow.Count == 0)
{
continue;
}
//
Column _first = previewRow[0];
Column _last = previewRow[previewRow.Count - 1];
//
if (_first == null || _last == null)
{
continue;
}
if (_first.TopLeft_GlobalPoint.X < 0)
{
return(false);
}
if (_first.TopLeft_GlobalPoint.Y < 0)
{
return(false);
}
if (_last.BottomRight_GlobalPoint.X > DrawingLength)
{
return(false);
}
if (_last.BottomRight_GlobalPoint.Y > DrawingWidth)
{
return(false);
}
}
//
List <BaseRectangleGeometry> _columnsToignore = new List <BaseRectangleGeometry>();
_columnsToignore.AddRange(patternColumnsList);
foreach (List <Column> _previewRow in previewRows)
{
_columnsToignore.AddRange(_previewRow);
}
// check layout
List <BaseRectangleGeometry> overlappedRectangles;
if (sheet.IsLayoutCorrect(_RectanglesToCheck, _columnsToignore, out overlappedRectangles))
{
Point fixedPoint = patternStartPoint;
fixedPoint.X += iCurColumnIndex * pattern.GlobalOffset_X;
//
pattern.GlobalOffset_X = newGlobalOffset_X;
// apply changes
foreach (List <Column> _row in patternRows)
{
Point curCenterPoint = fixedPoint;
curCenterPoint.Y += patternRows.IndexOf(_row) * pattern.GlobalOffset_Y;
// left side of the row
for (int iColumn = iCurColumnIndex - 1; iColumn >= 0; --iColumn)
{
Column _columnToChange = _row[iColumn];
if (_columnToChange != null)
{
Point newTopLeft_GlobalPoint = curCenterPoint;
newTopLeft_GlobalPoint.X -= newGlobalOffset_X * Math.Abs(iCurColumnIndex - iColumn);
newTopLeft_GlobalPoint.X -= _columnToChange.Length_X / 2;
newTopLeft_GlobalPoint.Y -= _columnToChange.Length_Y / 2;
//
newTopLeft_GlobalPoint = Utils.GetWholePoint(newTopLeft_GlobalPoint);
//
_columnToChange.TopLeft_GlobalPoint = newTopLeft_GlobalPoint;
}
}
// right side of the row
for (int iColumn = iCurColumnIndex + 1; iColumn < _row.Count; ++iColumn)
{
Column _columnToChange = _row[iColumn];
if (_columnToChange != null)
{
Point newTopLeft_GlobalPoint = curCenterPoint;
newTopLeft_GlobalPoint.X += newGlobalOffset_X * Math.Abs(iCurColumnIndex - iColumn);
newTopLeft_GlobalPoint.X -= _columnToChange.Length_X / 2;
newTopLeft_GlobalPoint.Y -= _columnToChange.Length_Y / 2;
//
newTopLeft_GlobalPoint = Utils.GetWholePoint(newTopLeft_GlobalPoint);
//
_columnToChange.TopLeft_GlobalPoint = newTopLeft_GlobalPoint;
}
}
}
return(true);
}
return(false);
}