public RotateRulers(LayerRuler layer, List <Layer.LayerItem> texts, int rotateSteps, bool forceKeepLastCenter)
{
// call the common constructor
float angle = MapData.Layer.CurrentRotationStep * rotateSteps;
base.commonConstructor(layer, texts, angle, forceKeepLastCenter);
}
public ScaleRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem, PointF originalPosition, PointF newPosition)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
mOriginalPosition = originalPosition;
mNewPosition = newPosition;
}
public ScaleRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem, PointF originalPosition, PointF newPosition)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
mOriginalPosition = originalPosition;
mNewPosition = newPosition;
}
public EditRulerForm(LayerRuler.RulerItem rulerItem)
{
InitializeComponent();
// clone the specified ruler in a new instance that will receive the edited properties
mEditedRulerClone = rulerItem.Clone() as LayerRuler.RulerItem;
// set the different control with the current state of the ruler
// line appearance
this.lineThicknessNumericUpDown.Value = (decimal)(rulerItem.LineThickness);
this.lineColorPictureBox.BackColor = rulerItem.Color;
if (rulerItem is LayerRuler.LinearRuler)
this.allowOffsetCheckBox.Checked = (rulerItem as LayerRuler.LinearRuler).AllowOffset;
else
this.allowOffsetCheckBox.Enabled = false;
// guideline appearance
this.dashPatternLineNumericUpDown.Value = (decimal)(rulerItem.GuidelineDashPattern[0]);
this.dashPatternSpaceNumericUpDown.Value = (decimal)(rulerItem.GuidelineDashPattern[1]);
this.guidelineThicknessNumericUpDown.Value = (decimal)(rulerItem.GuidelineThickness);
this.guidelineColorPictureBox.BackColor = rulerItem.GuidelineColor;
// measure and unit
this.displayUnitCheckBox.Checked = rulerItem.DisplayUnit;
this.displayMeasureTextCheckBox.Checked = rulerItem.DisplayDistance;
this.unitComboBox.SelectedIndex = (int)(rulerItem.CurrentUnit);
this.fontColorPictureBox.BackColor = rulerItem.MeasureColor;
updateChosenFont(rulerItem.MeasureFont);
}
public AttachRulerToBrick(LayerRuler.RulerItem rulerItem, LayerBrick.Brick brick)
{
// compute the attach offset in local coordinate
PointF attachOffset = RulerAttachementSet.Anchor.sComputeLocalOffsetFromLayerItem(brick, rulerItem.CurrentControlPoint);
// create a new Anchor
mAnchor = new RulerAttachementSet.Anchor(rulerItem, rulerItem.CurrentControlPointIndex, attachOffset);
mBrick = brick;
}
public EditRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem, LayerRuler.RulerItem rulerItemTemplateForNewProperties)
{
mRulerLayer = layer;
// memorise the item
mRulerItem = rulerItem;
// and clone the two templates, for doing undo/redo and keeping the properties when the ruler change
mOldRulerItemTemplate = rulerItem.Clone() as LayerRuler.RulerItem;
mNewRulerItemTemplate = rulerItemTemplateForNewProperties.Clone() as LayerRuler.RulerItem;
}
public DeleteRuler(LayerRuler layer, List<Layer.LayerItem> rulers)
{
mRulerLayer = layer;
mRulerIndex = new List<int>(rulers.Count);
// copy the list, because the pointer may change (specially if it is the selection)
mRulers = new List<Layer.LayerItem>(rulers.Count);
foreach (Layer.LayerItem obj in rulers)
mRulers.Add(obj);
}
public EditRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem, LayerRuler.RulerItem rulerItemTemplateForNewProperties)
{
mRulerLayer = layer;
// memorise the item
mRulerItem = rulerItem;
// and clone the two templates, for doing undo/redo and keeping the properties when the ruler change
mOldRulerItemTemplate = rulerItem.Clone() as LayerRuler.RulerItem;
mNewRulerItemTemplate = rulerItemTemplateForNewProperties.Clone() as LayerRuler.RulerItem;
}
private List <int> mRulerIndex = null; // this list of index is for the redo, to add each ruler at the same place
public DeleteRuler(LayerRuler layer, List <Layer.LayerItem> rulers)
{
mRulerLayer = layer;
mRulerIndex = new List <int>(rulers.Count);
// copy the list, because the pointer may change (specially if it is the selection)
mRulers = new List <Layer.LayerItem>(rulers.Count);
foreach (Layer.LayerItem obj in rulers)
{
mRulers.Add(obj);
}
}
public MoveRulerControlPoint(LayerRuler layer, LayerRuler.RulerItem rulerItem, PointF originalPosition, PointF newPosition)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
mControlPointIndex = rulerItem.CurrentControlPointIndex;
mOriginalPosition = originalPosition;
mNewPosition = newPosition;
// compute the new attach offset if the control point is attached
if (rulerItem.IsCurrentControlPointAttached)
{
LayerBrick.Brick attachedBrick = rulerItem.BrickAttachedToCurrentControlPoint;
mAnchor = attachedBrick.getRulerAttachmentAnchor(rulerItem);
mOriginalLocalAttachOffset = mAnchor.LocalAttachOffsetFromCenter;
mNewLocalAttachOffset = RulerAttachementSet.Anchor.sComputeLocalOffsetFromLayerItem(attachedBrick, newPosition);
mAttachedBrickOrientation = attachedBrick.Orientation;
}
}
public MoveRulerControlPoint(LayerRuler layer, LayerRuler.RulerItem rulerItem, PointF originalPosition, PointF newPosition)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
mControlPointIndex = rulerItem.CurrentControlPointIndex;
mOriginalPosition = originalPosition;
mNewPosition = newPosition;
// compute the new attach offset if the control point is attached
if (rulerItem.IsCurrentControlPointAttached)
{
LayerBrick.Brick attachedBrick = rulerItem.BrickAttachedToCurrentControlPoint;
mAnchor = attachedBrick.getRulerAttachmentAnchor(rulerItem);
mOriginalLocalAttachOffset = mAnchor.LocalAttachOffsetFromCenter;
mNewLocalAttachOffset = RulerAttachementSet.Anchor.sComputeLocalOffsetFromLayerItem(attachedBrick, newPosition);
mAttachedBrickOrientation = attachedBrick.Orientation;
}
}
private void copyRulerProperties(LayerRuler.RulerItem rulerTemplate)
{
// line appearance
mRulerItem.LineThickness = rulerTemplate.LineThickness;
mRulerItem.Color = rulerTemplate.Color;
if (mRulerItem is LayerRuler.LinearRuler)
(mRulerItem as LayerRuler.LinearRuler).AllowOffset = (rulerTemplate as LayerRuler.LinearRuler).AllowOffset;
// guideline appearance
mRulerItem.GuidelineDashPattern = rulerTemplate.GuidelineDashPattern;
mRulerItem.GuidelineThickness = rulerTemplate.GuidelineThickness;
mRulerItem.GuidelineColor = rulerTemplate.GuidelineColor;
// measure and unit
mRulerItem.DisplayUnit = rulerTemplate.DisplayUnit;
mRulerItem.DisplayDistance = rulerTemplate.DisplayDistance;
mRulerItem.CurrentUnit = rulerTemplate.CurrentUnit;
mRulerItem.MeasureColor = rulerTemplate.MeasureColor;
mRulerItem.MeasureFont = rulerTemplate.MeasureFont;
// update the display data
mRulerItem.updateDisplayDataAndMesurementImage();
mRulerLayer.updateBoundingSelectionRectangle();
}
public void ReadXml(System.Xml.XmlReader reader)
{
// reset the counter of modifications because we just load the map (no modification done)
mNumberOfModificationSinceLastSave = 0;
// version
readVersionNumber(reader);
// check if the BlueBrick program is not too old, that
// means the user try to load a file generated with
/// a earlier version of BlueBrick
if (mDataVersionOfTheFileLoaded > CURRENT_DATA_VERSION)
{
MessageBox.Show(null, Properties.Resources.ErrorMsgProgramObsolete,
Properties.Resources.ErrorMsgTitleError, MessageBoxButtons.OK,
MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
return;
}
// get the number of layer for the progressbar
if (mDataVersionOfTheFileLoaded >= 3)
{
int nbItems = reader.ReadElementContentAsInt();
// init the progress bar with the real number of layer items (+1 for the header +1 for the link rebuilding)
MainForm.Instance.resetProgressBar(nbItems + 2);
}
// check is there is a background color
if (reader.Name.Equals("BackgroundColor"))
mBackgroundColor = XmlReadWrite.readColor(reader);
// data of the map
mAuthor = reader.ReadElementContentAsString();
mLUG = reader.ReadElementContentAsString();
mShow = reader.ReadElementContentAsString();
reader.ReadToDescendant("Day");
int day = reader.ReadElementContentAsInt();
int month = reader.ReadElementContentAsInt();
int year = reader.ReadElementContentAsInt();
mDate = new DateTime(year, month, day);
// read the comment if the version is greater than 0
if (mDataVersionOfTheFileLoaded > 0)
{
reader.ReadToFollowing("Comment");
mComment = reader.ReadElementContentAsString().Replace("\n", Environment.NewLine);
}
else
{
reader.ReadToFollowing("CurrentSnapGridSize");
}
if (mDataVersionOfTheFileLoaded < 2)
{
// skip the static data of layers that before we were saving
// but now I think it is stupid, since we don't have action to change that
// and we don't have way to update the enabled of the buttons
reader.ReadElementContentAsFloat(); // CurrentSnapGridSize
reader.ReadElementContentAsBoolean(); // SnapGridEnabled
reader.ReadElementContentAsFloat(); // CurrentRotationStep
}
// read the export data if the version is 5 or higher
if (mDataVersionOfTheFileLoaded > 4)
{
reader.ReadToDescendant("ExportPath");
// read the relative export path and store it temporarly in the absolute path variable
// the absolute path will be computed after the xml serialization is finished
mExportAbsoluteFileName = reader.ReadElementContentAsString();
// read the other export info
mExportFileTypeIndex = reader.ReadElementContentAsInt();
mExportArea = XmlReadWrite.readRectangleF(reader);
mExportScale = reader.ReadElementContentAsFloat();
// read even more info from version 8
if (mDataVersionOfTheFileLoaded > 7)
{
mExportWatermark = XmlReadWrite.readBoolean(reader);
mExportBrickHull = XmlReadWrite.readBoolean(reader);
mExportElectricCircuit = XmlReadWrite.readBoolean(reader);
mExportConnectionPoints = XmlReadWrite.readBoolean(reader);
}
reader.ReadEndElement();
}
// selected layer
int selectedLayerIndex = reader.ReadElementContentAsInt();
// step the progress bar after the read of the header
MainForm.Instance.stepProgressBar();
// layers
// first clear the hashtable that contains all the bricks
Map.sHashtableForRulerAttachementRebuilding.Clear();
// then load all the layers
bool layerFound = reader.ReadToDescendant("Layer");
while (layerFound)
{
// get the 'type' attribute of the layer
reader.ReadAttributeValue();
string layerType = reader.GetAttribute(0);
// instantiate the right layer according to the type
Layer layer = null;
if (layerType.Equals("grid"))
layer = new LayerGrid();
else if (layerType.Equals("brick"))
layer = new LayerBrick();
else if (layerType.Equals("text"))
layer = new LayerText();
else if (layerType.Equals("area"))
layer = new LayerArea();
else if (layerType.Equals("ruler"))
layer = new LayerRuler();
// read and add the new layer
if (layer != null)
{
layer.ReadXml(reader);
mLayers.Add(layer);
}
// read the next layer
layerFound = reader.ReadToNextSibling("Layer");
}
reader.ReadEndElement(); // end of Layers
// once we have finished to read all the layers thus all the items, we need to recreate all the links they have between them
foreach (Layer layer in mLayers)
layer.recreateLinksAfterLoading();
// then clear again the hash table to free the memory
Map.sHashtableForRulerAttachementRebuilding.Clear();
// step the progress bar after the rebuilding of links
MainForm.Instance.stepProgressBar();
// if the selected index is valid, reset the selected layer
// use the setter in order to enable the toolbar buttons
if ((selectedLayerIndex >= 0) && (selectedLayerIndex < mLayers.Count))
SelectedLayer = mLayers[selectedLayerIndex];
else
SelectedLayer = null;
// DO NOT READ YET THE BRICK URL LIST, BECAUSE THE BRICK DOWNLOAD FEATURE IS NOT READY
if (false)
{
// read the url of all the parts for version 5 or later
if ((mDataVersionOfTheFileLoaded > 5) && !reader.IsEmptyElement)
{
bool urlFound = reader.ReadToDescendant("BrickUrl");
while (urlFound)
{
// read the next url
urlFound = reader.ReadToNextSibling("BrickUrl");
}
reader.ReadEndElement();
}
}
// construct the watermark
computeGeneralInfoWatermark();
// for old version, make disapear the progress bar, since it was just an estimation
MainForm.Instance.finishProgressBar();
}
public MoveRulers(LayerRuler layer, List <Layer.LayerItem> rulers, PointF move)
: base(layer, rulers, move)
{
}
public DuplicateRuler(LayerRuler layer, List<Layer.LayerItem> itemsToDuplicate, bool needToAddOffset)
: base(itemsToDuplicate, needToAddOffset, false)
{
// init the layer
mRulerLayer = layer;
}
/// <summary>
/// get the anchor for the specified ruler for its current control point
/// </summary>
/// <param name="rulerItem">the anchor or null if the specified control point is not attached</param>
/// <returns></returns>
public RulerAttachementSet.Anchor getRulerAttachmentAnchor(LayerRuler.RulerItem rulerItem)
{
if (mAttachedRulers != null)
return mAttachedRulers.getRulerAttachmentAnchor(rulerItem);
return null;
}
/// <summary>
/// get the anchor for the specified ruler for its current control point
/// </summary>
/// <param name="rulerItem">the anchor or null if the specified control point is not attached</param>
/// <returns>the anchor that match both the ruler item and the connection point index</returns>
public RulerAttachementSet.Anchor getRulerAttachmentAnchor(LayerRuler.RulerItem rulerItem)
{
foreach (Anchor anchor in mAnchors)
if ((anchor.AttachedRuler == rulerItem) && (anchor.AttachedPointIndex == rulerItem.CurrentControlPointIndex))
return anchor;
return null;
}
private int mRulerItemIndex = -1; // this index is for the redo, to add the ruler at the same place, start with -1 to add it at the end of the list (so on top of the other rulers)
public AddRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
}
public Anchor(LayerRuler.RulerItem ruler, int index, PointF localAttachOffset)
{
mAttachedRuler = ruler;
mAttachedPointIndex = index;
mLocalAttachOffsetFromCenter = localAttachOffset;
mWorldAttachOffsetFromCenter = localAttachOffset; // initialize with a zero angle
}
public MoveRulers(LayerRuler layer, List<Layer.LayerItem> rulers, PointF move)
: base(layer, rulers, move)
{
}
public static void sChangeRulerSettingsFromRuler(LayerRuler.RulerItem rulerItem)
{
// line appearance
Settings.Default.RulerDefaultLineThickness = rulerItem.LineThickness;
Settings.Default.RulerDefaultLineColor = rulerItem.Color;
if (rulerItem is LayerRuler.LinearRuler)
Settings.Default.RulerDefaultAllowOffset = (rulerItem as LayerRuler.LinearRuler).AllowOffset;
// guideline appearance
Settings.Default.RulerDefaultDashPatternLine = rulerItem.GuidelineDashPattern[0];
Settings.Default.RulerDefaultDashPatternSpace = rulerItem.GuidelineDashPattern[1];
Settings.Default.RulerDefaultGuidelineThickness = rulerItem.GuidelineThickness;
Settings.Default.RulerDefaultGuidelineColor = rulerItem.GuidelineColor;
// measure and unit
Settings.Default.RulerDefaultDisplayUnit = rulerItem.DisplayUnit;
Settings.Default.RulerDefaultDisplayMeasureText = rulerItem.DisplayDistance;
Settings.Default.RulerDefaultUnit = (int)rulerItem.CurrentUnit;
Settings.Default.RulerDefaultFontColor = rulerItem.MeasureColor;
Settings.Default.RulerDefaultFont = rulerItem.MeasureFont;
}
public RotateRulers(LayerRuler layer, List <Layer.LayerItem> texts, int rotateSteps)
: this(layer, texts, rotateSteps, false)
{
}
public RotateRulers(LayerRuler layer, List<Layer.LayerItem> texts, int rotateSteps)
: this(layer, texts, rotateSteps, false)
{
}
public AddRuler(LayerRuler layer, LayerRuler.RulerItem rulerItem)
{
mRulerLayer = layer;
mRulerItem = rulerItem;
}
public DuplicateRuler(LayerRuler layer, List <Layer.LayerItem> itemsToDuplicate, bool needToAddOffset)
: base(itemsToDuplicate, needToAddOffset, false)
{
// init the layer
mRulerLayer = layer;
}
public RotateRulers(LayerRuler layer, List<Layer.LayerItem> texts, int rotateSteps, bool forceKeepLastCenter)
{
// call the common constructor
float angle = MapData.Layer.CurrentRotationStep * rotateSteps;
base.commonConstructor(layer, texts, angle, forceKeepLastCenter);
}
