public cShapeOutline(ShapeTypes stNewShapeType, List<Point> plNewShapeCoordinates, Color cNewShapeColor)
{
stShapeType = stNewShapeType;
plShapeCoordinates = new List<Point>(plNewShapeCoordinates);
cShapeColor = cNewShapeColor;
sText = "Error";
}
/// <summary>
/// Create legend scheme from grid data
/// </summary>
/// <param name="aGridData">GridData</param>
/// <param name="aLT">legend type</param>
/// <param name="aST">shape type</param>
/// <param name="hasNoData">ref if has undefine data</param>
/// <returns>legend scheme</returns>
public static LegendScheme CreateLegendSchemeFromGridData(GridData aGridData,
LegendType aLT, ShapeTypes aST, ref Boolean hasNoData)
{
LegendScheme aLS = new LegendScheme(aST);
double[] CValues;
Color[] colors;
double MinData = 0;
double MaxData = 0;
hasNoData = ContourDraw.GetMaxMinValue(aGridData.Data, aGridData.MissingValue, ref MinData, ref MaxData);
CValues = CreateContourValues(MinData, MaxData);
colors = CreateRainBowColors(CValues.Length + 1);
//Generate lengendscheme
if (aLT == LegendType.UniqueValue)
{
aLS = CreateUniqValueLegendScheme(CValues, colors,
aST, MinData, MaxData, hasNoData, aGridData.MissingValue);
}
else
{
aLS = CreateGraduatedLegendScheme(CValues, colors,
aST, MinData, MaxData, hasNoData, aGridData.MissingValue);
}
return(aLS);
}
public static AbstractDetailsBase CreatShape(ShapeTypes shape)
{
Type type = null;
Assembly assembly = Assembly.Load(DllName);
switch (shape)
{
case ShapeTypes.Line:
type = assembly.GetType(LineTypeName);
break;
case ShapeTypes.Circle:
type = assembly.GetType(CircleTypeName);
break;
case ShapeTypes.Arc:
type = assembly.GetType(ArcTypeName);
break;
case ShapeTypes.PLine:
type = assembly.GetType(PLineTypeName);
break;
}
AbstractDetailsBase aShape = Activator.CreateInstance(type) as AbstractDetailsBase;
return(aShape);
}
public static IShape GetShape(ShapeTypes shapeType)
{
switch (shapeType)
{
case ShapeTypes.SimpleRectangle:
return(new SimpleRectangle());
case ShapeTypes.SimpleEllipse:
return(new SimpleEllipse());
case ShapeTypes.TextLabel:
return(new TextLabel());
case ShapeTypes.ClassShape:
return(new ClassShape());
case ShapeTypes.TextOnly:
return(new TextOnly());
case ShapeTypes.ImageShape:
return(new ImageShape());
case ShapeTypes.DecisionShape:
break;
default:
return(null);
}
return(null);
}
/// <summary>
/// Adds a predefined shape
/// </summary>
/// <param name="type"></param>
/// <param name="location"></param>
public ShapeBase AddShape(ShapeTypes type, Point location)
{
ShapeBase shape = null;
switch (type)
{
case ShapeTypes.Rectangular:
shape = new SimpleRectangle(this);
break;
case ShapeTypes.Oval:
shape = new OvalShape(this);
break;
case ShapeTypes.TextLabel:
shape = new TextLabel(this);
shape.Location = location;
shape.ShapeColor = Color.Transparent;
shape.Text = "A text label (change the text in the property grid)";
shape.Width = 350;
shape.Height = 30;
Shapes.Add(shape);
return(shape);
}
if (shape == null)
{
return(null);
}
shape.ShapeColor = Color.FromArgb(rnd.Next(0, 255), rnd.Next(0, 255), rnd.Next(0, 255));
shape.Location = location;
Shapes.Add(shape);
return(shape);
}
public static BaseShape CreateShape(Texture2D blockTexture, Board board, ShapeTypes shapeType)
{
switch (shapeType)
{
case ShapeTypes.I:
return(new IShape(blockTexture, board));
case ShapeTypes.J:
return(new JShape(blockTexture, board));
case ShapeTypes.L:
return(new LShape(blockTexture, board));
case ShapeTypes.O:
return(new OShape(blockTexture, board));
case ShapeTypes.S:
return(new SShape(blockTexture, board));
case ShapeTypes.T:
return(new TShape(blockTexture, board));
case ShapeTypes.Z:
return(new ZShape(blockTexture, board));
default:
return(null);
}
}
/// <summary>
/// Import legend scheme from XML node
/// </summary>
/// <param name="LSNode">xml node</param>
/// <param name="keepShape">if keep the legend shape type</param>
public void ImportFromXML(XmlNode LSNode, bool keepShape)
{
LegendBreaks = new List <ColorBreak>();
if (!(LSNode.Attributes["FieldName"] == null))
{
FieldName = LSNode.Attributes["FieldName"].InnerText;
}
LegendType = (LegendType)Enum.Parse(typeof(LegendType),
LSNode.Attributes["LegendType"].InnerText, true);
ShapeTypes aShapeType = (ShapeTypes)Enum.Parse(typeof(ShapeTypes),
LSNode.Attributes["ShapeType"].InnerText, true);
//BreakNum = Convert.ToInt32(LSNode.Attributes["BreakNum"].InnerText);
HasNoData = Convert.ToBoolean(LSNode.Attributes["HasNoData"].InnerText);
MinValue = Convert.ToDouble(LSNode.Attributes["MinValue"].InnerText);
MaxValue = Convert.ToDouble(LSNode.Attributes["MaxValue"].InnerText);
MissingValue = Convert.ToDouble(LSNode.Attributes["UNDEF"].InnerText);
if (!keepShape)
{
ShapeType = aShapeType;
}
bool sameShapeType = (ShapeType == aShapeType);
ImportBreaks(LSNode, sameShapeType);
}
public static string Dump(ShapeTypes value)
{
var assistant = new AssistantDumper();
Dump(assistant, value);
return(assistant.ToString());
}
internal static void Dump(AssistantDumper assistant, ShapeTypes value, bool withSeparator = false)
{
assistant.IncrementDepth();
if (assistant.MaximumDepthExceeded())
return;
assistant.AddStartObject();
assistant.AddType("Dogen.TestModels.CSharpModel.Package1.ShapeTypes", true/*withSeparator*/);
string valueAsString = "Unsupported Value";
switch (value)
{
case ShapeTypes.Invalid:
valueAsString = "Invalid";
break;
case ShapeTypes.Triangle:
valueAsString = "Triangle";
break;
case ShapeTypes.Square:
valueAsString = "Square";
break;
case ShapeTypes.Rectangle:
valueAsString = "Rectangle";
break;
case ShapeTypes.Cube:
valueAsString = "Cube";
break;
}
assistant.Add("value", valueAsString);
assistant.AddEndObject();
assistant.DecrementDepth();
}
private static int GetContentLength(object aShape, ShapeTypes aST)
{
int contentLength = 0;
switch (aST)
{
case ShapeTypes.Point:
contentLength = 2 + 4 * 2;
break;
case ShapeTypes.Polyline:
PolylineShape aPLS = (PolylineShape)aShape;
contentLength = 2 + 4 * 4 + 2 + 2 + 2 * aPLS.PartNum + 4 * 2 * aPLS.PointNum;
break;
case ShapeTypes.PolylineZ:
PolylineZShape aPLZS = (PolylineZShape)aShape;
contentLength = 2 + 4 * 4 + 2 + 2 + 2 * aPLZS.PartNum + 4 * 2 * aPLZS.PointNum +
4 + 4 + 4 * aPLZS.PointNum + 4 + 4 + 4 * aPLZS.PointNum;
break;
case ShapeTypes.Polygon:
PolygonShape aPGS = (PolygonShape)aShape;
contentLength = 2 + 4 * 4 + 2 + 2 + 2 * aPGS.PartNum + 4 * 2 * aPGS.PointNum;
break;
}
return(contentLength);
}
private bool GetUsesShell(ShapeTypes shapeType)
{
if (((shapeType != ShapeTypes.HemiSphereShell) && (shapeType != ShapeTypes.SphereShell)) && (((shapeType != ShapeTypes.ConeShell) && (shapeType != ShapeTypes.ConeVolumeShell)) && (shapeType != ShapeTypes.CircleEdge)))
{
return false;
}
return true;
}
/// <summary>Constructs the shape.</summary>
/// <param name="shapeType">The shape type.</param>
/// <param name="color">The color.</param>
/// <param name="rounding">The rounding.</param>
/// <param name="thickness">The thickness.</param>
/// <param name="visible">The visibility.</param>
private void ConstructShape(ShapeTypes shapeType, Color color, int rounding, int thickness, bool visible)
{
_color = color;
_rounding = rounding;
_thickness = thickness;
_shapeType = shapeType;
_visible = visible;
}
private bool GetUsesShell(ShapeTypes shapeType)
{
if (((shapeType != ShapeTypes.HemiSphereShell) && (shapeType != ShapeTypes.SphereShell)) && (((shapeType != ShapeTypes.ConeShell) && (shapeType != ShapeTypes.ConeVolumeShell)) && (shapeType != ShapeTypes.CircleEdge)))
{
return(false);
}
return(true);
}
public cShapeOutline(string sNewText, Point pLocation, Color cNewShapeColor)
{
stShapeType = ShapeTypes.Text;
plShapeCoordinates = new List<Point>();
plShapeCoordinates.Add(pLocation);
cShapeColor = cNewShapeColor;
sText = sNewText;
}
public static void AddShape(Connectable shape, ShapeTypes type)
{
if (shape == null)
throw new ArgumentNullException("A null cannot be added to the shape collection.");
//the undo trick
AddShapeCommand cmd = new AddShapeCommand(shape, type, Canvas);
UndoManager.Execute(cmd);
RaiseOnShapeAdded(shape);
}
public Shapefile(string filename)
{
FileStream fs = new FileStream(filename, FileMode.Open);
BinaryReader br = new BinaryReader(fs);
//读取文件头
fileCode = ReverseByte(br.ReadInt32());
for (int i = 1; i <= 5; i++)
{
br.ReadInt32();
}
fileLength = ReverseByte(br.ReadInt32()) * 2;
version = br.ReadInt32();
shapeTypeID = br.ReadInt32();
xmin = br.ReadDouble();
ymin = br.ReadDouble();
xmax = br.ReadDouble();
ymax = br.ReadDouble();
zmin = br.ReadDouble();
zmax = br.ReadDouble();
mmin = br.ReadDouble();
mmax = br.ReadDouble();
byteCount += 100;
switch (shapeTypeID)
{
case 1:
{
shapeType = ShapeTypes.Point;
feature = ReadPointShp(br);
break;
}
case 3:
{
shapeType = ShapeTypes.Polyline;
feature = ReadPolyLineShp(br);
break;
}
case 5:
{
shapeType = ShapeTypes.Polygon;
feature = ReadPolygonShp(br);
break;
}
default:
{
shapeType = ShapeTypes.NullShape;
feature = new FeatureClass();
break;
}
}
}
/// <summary>
/// 初始化对象
/// </summary>
/// <param name="rect">矩形对象</param>
/// <param name="type">图形类型</param>
/// <param name="BorderColor">边框色</param>
/// <param name="FillColor">背景色</param>
public ShapeDrawer(
System.Drawing.RectangleF rect,
ShapeTypes type,
System.Drawing.Color BorderColor,
System.Drawing.Color FillColor)
{
this.myBounds = rect;
this.intType = type;
this.myBorderPen = new Pen(BorderColor);
this.myFillBrush = new SolidBrush(FillColor);
}
public HMIIndicator()
{
this.TextRect = new Rectangle();
this.m_Color1 = Color.DarkGray;
this.m_Color2 = Color.Green;
this.m_Color3 = Color.Red;
this._OutlineColor = Color.Transparent;
this.m_OutlineWidth = 1;
this.m_Shape = ShapeTypes.Round;
this.sf = new StringFormat();
}
public static void AddShape(Connectable shape, ShapeTypes type)
{
if (shape == null)
{
throw new ArgumentNullException("A null cannot be added to the shape collection.");
}
//the undo trick
AddShapeCommand cmd = new AddShapeCommand(shape, type, Canvas);
UndoManager.Execute(cmd);
RaiseOnShapeAdded(shape);
}
public static List <Shadow> LookupShadowsByShapeType(ShapeTypes shapeType)
{
List <Shadow> list = new List <Shadow>();
foreach (Shadow shadow in shadowShapeMap.Values)
{
if (shadow.GetShapeType() == shapeType)
{
list.Add(shadow);
}
}
return(list);
}
public Shape CreateShape(ShapeTypes shapeType)
{
switch (shapeType)
{
case ShapeTypes.Rectangle: return(new Rectangle());
case ShapeTypes.Square: return(new Square());
case ShapeTypes.Circle: return(new Circle());
default: throw new Exception("invalid shapeType");
}
}
/// <summary>
/// Q: Is this method being an static an issue?
/// </summary>
/// <param name="shape"></param>
/// <returns></returns>
public static IShape Create(ShapeTypes shape)
{
switch (shape)
{
case ShapeTypes.Circle: return(new Circle());
case ShapeTypes.Square: return(new Square());
case ShapeTypes.Pentagon: return(new Pentagon());
default:
throw new NotSupportedException($"Unknown type {shape}");
}
}
public static void AddShape(Rect rect, ShapeTypes type)
{
Connectable shape = null;
if (creators.ContainsKey(type))
{
Type creatingType = creators[type];
IShapeCreator creator = Activator.CreateInstance(creatingType) as IShapeCreator;
shape = creator.Create(rect) as Connectable;
AddShape(shape, type);
}
}
public static IShape GetShape(ShapeTypes shapeTypes)
{
switch (shapeTypes)
{
case ShapeTypes.Circle:
return(new Circle());
case ShapeTypes.Rectangle:
return(new Rectangle());
default:
return(null);
}
}
public static void AddShape(Rect rect, ShapeTypes type)
{
Connectable shape = null;
if (creators.ContainsKey(type))
{
Type creatingType = creators[type];
IShapeCreator creator = Activator.CreateInstance(creatingType) as IShapeCreator;
shape = creator.Create(rect) as Connectable;
AddShape(shape, type);
}
}
public override IShape GetShape(ShapeTypes shapeType)
{
switch (shapeType)
{
case ShapeTypes.Rectangle:
return(new Rectangle());
case ShapeTypes.Square:
return(new Square());
default:
return(null);
}
}
public ShapeModuleUI(ParticleSystemUI owner, SerializedObject o, string displayName) : base(owner, o, "ShapeModule", displayName, ModuleUI.VisibilityState.VisibleAndFolded)
{
this.m_BoxEditor = new BoxEditor(true, s_BoxHash);
this.m_GuiNames = new string[] { "Sphere", "HemiSphere", "Cone", "Box", "Mesh", "Circle", "Edge" };
ShapeTypes[] typesArray1 = new ShapeTypes[7];
typesArray1[1] = ShapeTypes.HemiSphere;
typesArray1[2] = ShapeTypes.Cone;
typesArray1[3] = ShapeTypes.Box;
typesArray1[4] = ShapeTypes.Mesh;
typesArray1[5] = ShapeTypes.Circle;
typesArray1[6] = ShapeTypes.SingleSidedEdge;
this.m_GuiTypes = typesArray1;
this.m_TypeToGuiTypeIndex = new int[] { 0, 0, 1, 1, 2, 3, 4, 2, 2, 2, 5, 5, 6 };
base.m_ToolTip = "Shape of the emitter volume, which controls where particles are emitted and their initial direction.";
}
public ShapeModuleUI(ParticleSystemUI owner, SerializedObject o, string displayName) : base(owner, o, "ShapeModule", displayName, ModuleUI.VisibilityState.VisibleAndFolded)
{
this.m_BoxEditor = new BoxEditor(true, s_BoxHash);
this.m_GuiNames = new string[] { "Sphere", "HemiSphere", "Cone", "Box", "Mesh", "Circle", "Edge" };
ShapeTypes[] typesArray1 = new ShapeTypes[7];
typesArray1[1] = ShapeTypes.HemiSphere;
typesArray1[2] = ShapeTypes.Cone;
typesArray1[3] = ShapeTypes.Box;
typesArray1[4] = ShapeTypes.Mesh;
typesArray1[5] = ShapeTypes.Circle;
typesArray1[6] = ShapeTypes.SingleSidedEdge;
this.m_GuiTypes = typesArray1;
this.m_TypeToGuiTypeIndex = new int[] { 0, 0, 1, 1, 2, 3, 4, 2, 2, 2, 5, 5, 6 };
base.m_ToolTip = "Shape of the emitter volume, which controls where particles are emitted and their initial direction.";
}
// Order Shape Input
public static Shape OrderShapeInput(ShapeTypes shapeType)
{
var shapeVariants = ShapeVariants();
Console.WriteLine();
foreach (var variant in shapeVariants)
{
Console.Write($"Please input the number of {variant.ShapeColor.ToString()} {shapeType.ToString()}: ");
int.TryParse(UserInput(allowEmptyInput: true), out var qty);
variant.Qty = qty;
}
var shape = ShapeFactory.GetShape((int)shapeType, shapeVariants);
return(shape);
}
private bool ReadyForConnectorMove(out Cell nonArrowSideCell, out Shape fromShape)
{
nonArrowSideCell = null;
fromShape = null;
if (visioControl.Document.Application.ActiveWindow.Selection.Count != 1)
{
Common.ErrorMessage("A single connector must be selected");
return(false);
}
Shape connector = visioControl.Document.Application.ActiveWindow.Selection[1];
ShapeTypes type = Common.GetShapeType(connector);
if (type != ShapeTypes.Connector)
{
Common.ErrorMessage("A single connector must be selected");
return(false);
}
Shadow connectorShadow = PathMaker.LookupShadowByShape(connector);
if (connectorShadow == null)
{
Common.ErrorMessage("Connector is not a valid PathMaker shape");
return(false);
}
nonArrowSideCell = connector.get_Cells("BeginX");
Connect nonArrowSideConnect = null;
foreach (Connect c in connector.Connects)
{
if (c.FromCell.Name.Equals(Strings.BeginConnectionPointCellName))
{
nonArrowSideConnect = c;
}
}
if (nonArrowSideConnect == null)
{
Common.ErrorMessage("Connector must be connected on the non-arrow side");
return(false);
}
fromShape = nonArrowSideConnect.ToSheet;
return(true);
}
internal Shape CreateShape(ShapeTypes type, int[] dimensions)
{
switch (type)
{
case ShapeTypes.circle:
return(new Circle(dimensions));
case ShapeTypes.square:
return(new Square(dimensions));
//case ShapeTypes.triangle:
// break;
//case ShapeTypes.rectangle:
// break;
default:
return(null);
}
}
private int ConvertConeTypeToConeEmitFrom(ShapeTypes shapeType)
{
if (shapeType != ShapeTypes.Cone)
{
if (shapeType == ShapeTypes.ConeShell)
{
return(1);
}
if (shapeType == ShapeTypes.ConeVolume)
{
return(2);
}
if (shapeType == ShapeTypes.ConeVolumeShell)
{
return(3);
}
}
return(0);
}
public static Shapes GetShapes(ShapeTypes shapeTypes, dot[] Dots)
{
if (shapeTypes == ShapeTypes.Rectangle)
{
return(new Rectangle(Dots));
}
if (shapeTypes == ShapeTypes.Square)
{
return(new Square(Dots));
}
if (shapeTypes == ShapeTypes.Triangle)
{
return(new Triangle(Dots));
}
else
{
return(null);
}
}
private int ConvertConeTypeToConeEmitFrom(ShapeTypes shapeType)
{
if (shapeType != ShapeTypes.Cone)
{
if (shapeType == ShapeTypes.ConeShell)
{
return 1;
}
if (shapeType == ShapeTypes.ConeVolume)
{
return 2;
}
if (shapeType == ShapeTypes.ConeVolumeShell)
{
return 3;
}
}
return 0;
}
/// <summary>
/// Constructor
/// </summary>
public SymbolControl()
{
InitializeComponent();
this.AllowDrop = true;
this.SetStyle(
ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.OptimizedDoubleBuffer, true);
_shapeType = ShapeTypes.Point;
_markerType = MarkerType.Simple;
_cellSize = new Size(25, 25);
_symbolNumber = 256;
_colNumber = 10;
_rowNumber = 26;
_selectedCell = -1;
_imageList = new List <Image>();
}
public static IShape GetShape(ShapeTypes shapeType)
{
switch(shapeType)
{
case ShapeTypes.CObject:
return new CObject();
case ShapeTypes.ADTObject:
return new ADTObject();
case ShapeTypes.SMObject:
return new SMObject();
case ShapeTypes.SimpleRectangle:
return new SimpleRectangle();
case ShapeTypes.SimpleEllipse:
return new SimpleEllipse();
case ShapeTypes.TextLabel:
return new TextLabel();
case ShapeTypes.ClassShape:
return new ClassShape();
case ShapeTypes.TextOnly:
return new TextOnly();
case ShapeTypes.ImageShape:
return new ImageShape();
case ShapeTypes.DecisionShape:
break;
case ShapeTypes.DataStoreObject:
return new DataStoreObject();
break;
case ShapeTypes.DataSinkObject:
return new DataSinkObject();
break;
case ShapeTypes.Terminator:
return new Terminator();
break;
case ShapeTypes.CustomizedObject:
return new CustomizedObject();
break;
default:
return null;
}
return null;
}
public Shape GetShape(ShapeTypes shapeType)
{
switch (shapeType)
{
case ShapeTypes.None:
return(null);
case ShapeTypes.Rectangle:
return(new Rectangle());
case ShapeTypes.Circle:
return(new Circle());
case ShapeTypes.Square:
return(new Square());
default:
return(null);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="aLayer"></param>
/// <param name="aLayersTV"></param>
public VectorLayerSet(VectorLayer aLayer, LayersLegend aLayersTV)
{
m_LayerName = aLayer.LayerName;
m_FileName = aLayer.FileName;
m_Handle = aLayer.Handle;
m_Extent = aLayer.Extent;
m_Visible = aLayer.Visible;
m_LayerDrawType = aLayer.LayerDrawType;
m_LayerType = aLayer.LayerType;
m_ShapeType = aLayer.ShapeType;
m_AviodCollision = aLayer.AvoidCollision;
m_TransparencyPerc = aLayer.TransparencyPerc;
m_ShapeNum = aLayer.ShapeNum;
m_LayersTV = aLayersTV;
m_LegendSchemeE = new LegendSchemeE();
m_LegendSchemeE.LayerHandle = aLayer.Handle;
m_LegendSchemeE.LegendScheme = (LegendScheme)aLayer.LegendScheme.Clone();
m_LegendSchemeE.LayersTV = aLayersTV;
m_IsMaskout = aLayer.IsMaskout;
}
/// <summary>
/// Gets the shape.
/// </summary>
/// <param name="shapeType">Type of the shape.</param>
/// <returns></returns>
public static IShape GetShape(ShapeTypes shapeType) {
switch (shapeType) {
case ShapeTypes.SimpleRectangle:
return new SimpleRectangle();
case ShapeTypes.SimpleEllipse:
return new SimpleEllipse();
case ShapeTypes.TextLabel:
return new TextLabel();
case ShapeTypes.ClassShape:
return new ClassShape();
case ShapeTypes.TextOnly:
return new TextOnly();
case ShapeTypes.ImageShape:
return new ImageShape();
case ShapeTypes.ComplexRectangle:
return new ComplexRectangle();
default:
return null;
}
}
/// <summary>
/// Import legend scheme from an image color palette file
/// </summary>
/// <param name="aFile">file path</param>
public void ImportFromPaletteFile_Unique(string aFile)
{
StreamReader sr = new StreamReader(aFile);
this.ShapeType = ShapeTypes.Image;
this.LegendType = LegendType.UniqueValue;
this.LegendBreaks = new List <ColorBreak>();
ColorBreak aCB = new ColorBreak();
string[] dataArray;
int lastNonEmpty, i;
sr.ReadLine();
string aLine = sr.ReadLine();
while (aLine != null)
{
dataArray = aLine.Split();
lastNonEmpty = -1;
List <int> dataList = new List <int>();
for (i = 0; i < dataArray.Length; i++)
{
if (dataArray[i] != string.Empty)
{
lastNonEmpty++;
dataList.Add(int.Parse(dataArray[i]));
}
}
Color aColor = Color.FromArgb(255, dataList[3], dataList[2], dataList[1]);
aCB = new ColorBreak();
aCB.Color = aColor;
aCB.StartValue = dataList[0];
aCB.EndValue = dataList[0];
aCB.Caption = aCB.StartValue.ToString();
this.LegendBreaks.Add(aCB);
aLine = sr.ReadLine();
}
sr.Close();
}
public static List<Shadow> LookupShadowsByShapeType(ShapeTypes shapeType)
{
List<Shadow> list = new List<Shadow>();
foreach (Shadow shadow in shadowShapeMap.Values)
if (shadow.GetShapeType() == shapeType)
list.Add(shadow);
return list;
}
/// <summary>
/// Parses the first 100 bytes of a shapefile into the important values
/// </summary>
/// <param name="inFilename">The filename to read</param>
public void Open(string inFilename)
{
_filename = inFilename;
// Position Field Value Type ByteOrder
// --------------------------------------------------------------
// Byte 0 File Code 9994 Integer Big
// Byte 4 Unused 0 Integer Big
// Byte 8 Unused 0 Integer Big
// Byte 12 Unused 0 Integer Big
// Byte 16 Unused 0 Integer Big
// Byte 20 Unused 0 Integer Big
// Byte 24 File Length File Length Integer Big
// Byte 28 Version 1000 Integer Little
// Byte 32 Shape Type Shape Type Integer Little
// Byte 36 Bounding Box Xmin Double Little
// Byte 44 Bounding Box Ymin Double Little
// Byte 52 Bounding Box Xmax Double Little
// Byte 60 Bounding Box Ymax Double Little
// Byte 68 Bounding Box Zmin Double Little
// Byte 76 Bounding Box Zmax Double Little
// Byte 84 Bounding Box Mmin Double Little
// Byte 92 Bounding Box Mmax Double Little
BufferedBinaryReader bbReader = new BufferedBinaryReader(inFilename);
bbReader.FillBuffer(100); // we only need to read 100 bytes from the header.
bbReader.Close(); // Close the internal readers connected to the file, but don't close the file itself.
// Reading BigEndian simply requires us to reverse the byte order.
_fileCode = bbReader.ReadInt32(false);
// Skip the next 20 bytes because they are unused
bbReader.Seek(20, System.IO.SeekOrigin.Current);
// Read the file length in reverse sequence
_fileLength = bbReader.ReadInt32(false);
// From this point on, all the header values are in little endian
// Read the version
_version = bbReader.ReadInt32();
// Read in the shapetype that should be the shapetype for the whole shapefile
_shapeType = (ShapeTypes)bbReader.ReadInt32();
// Get the extents, each of which are double values.
_xMin = bbReader.ReadDouble();
_yMin = bbReader.ReadDouble();
_xMax = bbReader.ReadDouble();
_yMax = bbReader.ReadDouble();
_zMin = bbReader.ReadDouble();
_zMax = bbReader.ReadDouble();
_mMin = bbReader.ReadDouble();
_mMax = bbReader.ReadDouble();
bbReader.Dispose();
}
/// <summary>
/// Activates the corresponding tool to the given shapeType value if the tool is not already active, and then returns the previous tool
/// if a tool switch has occurred or null otherwise. If a switch did occur and this was called in e.g. an event handler, it should most
/// likely pass the event data on to the newly activated tool (accessing it using PintaCore.Tools.CurrentTool) and then return.
/// </summary>
/// <param name="shapeType">The index of the shape in SEngines to find the corresponding tool to and switch to.</param>
/// <param name="permanentSwitch">Whether the tool switch is permanent or just temporary (for drawing).</param>
/// <returns>The *previous* tool if a tool switch has occurred or null otherwise.</returns>
public static ShapeTool ActivateCorrespondingTool(ShapeTypes shapeType, bool permanentSwitch)
{
ShapeTool correspondingTool = GetCorrespondingTool(shapeType);
//Verify that the corresponding tool is valid and that it doesn't match the currently active tool.
if (correspondingTool != null && PintaCore.Tools.CurrentTool != correspondingTool)
{
ShapeTool oldTool = PintaCore.Tools.CurrentTool as ShapeTool;
//The active tool needs to be switched to the corresponding tool.
PintaCore.Tools.SetCurrentTool(correspondingTool);
ShapeTool newTool = (ShapeTool)PintaCore.Tools.CurrentTool;
//What happens next depends on whether the old tool was an editable ShapeTool.
if (oldTool != null && oldTool.IsEditableShapeTool)
{
if (permanentSwitch)
{
//Set the new tool's active shape and point to the old shape and point.
newTool.EditEngine.SelectedPointIndex = oldTool.EditEngine.SelectedPointIndex;
newTool.EditEngine.SelectedShapeIndex = oldTool.EditEngine.SelectedShapeIndex;
//Make sure neither tool thinks it is drawing anything.
newTool.EditEngine.is_drawing = false;
oldTool.EditEngine.is_drawing = false;
}
ShapeEngine activeEngine = newTool.EditEngine.ActiveShapeEngine;
if (activeEngine != null)
{
newTool.EditEngine.UpdateToolbarSettings(activeEngine);
}
}
else
{
if (permanentSwitch)
{
//Make sure that the new tool doesn't think it is drawing anything.
newTool.EditEngine.is_drawing = false;
}
}
//Let the caller know that the active tool has been switched.
return oldTool;
}
//Let the caller know that the active tool has not been switched.
return null;
}
/// <summary>
/// Gets the corresponding tool to the given shape type and then returns that tool.
/// </summary>
/// <param name="ShapeType">The shape type to find the corresponding tool to.</param>
/// <returns>The corresponding tool to the given shape type.</returns>
public static ShapeTool GetCorrespondingTool(ShapeTypes shapeType)
{
ShapeTool correspondingTool = null;
//Get the corresponding BaseTool reference to the shape type.
CorrespondingTools.TryGetValue(shapeType, out correspondingTool);
return correspondingTool;
}
public cShapeOutline GetAdjustedShape(List<Point> lpShapePoints, Color cShapeColor, ShapeTypes stShapeType)
{
for (int i = 0; i < lpShapePoints.Count; i++)
lpShapePoints[i] = GetAdjustedPoint(lpShapePoints[i]);
return new cShapeOutline(stShapeType, lpShapePoints, cShapeColor);
}
private int ConvertConeTypeToConeEmitFrom(ShapeTypes shapeType)
{
return Array.IndexOf<ShapeTypes>(this.coneShapes, shapeType);
}
private bool GetUsesShell(ShapeTypes shapeType)
{
return (Array.IndexOf<ShapeTypes>(this.shellShapes, shapeType) != -1);
}
public Shadow(Shape shape)
{
this.shape = shape;
this.shapeType = Common.GetShapeType(shape);
}
public static string Dump(ShapeTypes value)
{
var assistant = new AssistantDumper();
Dump(assistant, value);
return assistant.ToString();
}
/// <summary>
/// This creates a polygon shape from an extent.
/// </summary>
/// <param name="ext">The extent to turn into a polygon shape.</param>
public ShapeRange(Extent ext)
{
Extent = ext;
Parts = new List<PartRange>();
_numParts = -1;
// Counter clockwise
// 1 2
// 4 3
double[] coords = new double[8];
// C1
coords[0] = ext.XMin;
coords[1] = ext.YMax;
// C2
coords[2] = ext.XMax;
coords[3] = ext.YMax;
// C3
coords[4] = ext.XMax;
coords[5] = ext.YMin;
// C4
coords[6] = ext.XMin;
coords[7] = ext.YMin;
FeatureType = FeatureTypes.Polygon;
ShapeType = ShapeTypes.Polygon;
PartRange pr = new PartRange(coords, 0,0, FeatureTypes.Polygon);
pr.NumVertices = 4;
Parts.Add(pr);
}
/// <summary>
/// Adds a predefined shape
/// </summary>
/// <param name="type"></param>
/// <param name="location"></param>
public ShapeBase AddShape(ShapeTypes type, Point location)
{
ShapeBase shape = null;
switch(type)
{
case ShapeTypes.Rectangular:
shape = new SimpleRectangle(this);
break;
case ShapeTypes.Oval:
shape = new OvalShape(this);
break;
case ShapeTypes.TextLabel:
shape = new TextLabel(this);
shape.Location = location;
shape.ShapeColor = Color.Transparent;
shape.Text = "A text label (change the text in the property grid)";
shape.Width = 350;
shape.Height = 30;
Shapes.Add(shape);
return shape;
}
if(shape==null) return null;
shape.ShapeColor = Color.FromArgb(rnd.Next(0,255),rnd.Next(0,255),rnd.Next(0,255));
shape.Location = location;
Shapes.Add(shape);
return shape;
}
public AddShapeCommand(UIElement shape, ShapeTypes type, Canvas canvas)
{
mShapeType = type;
mShape = shape;
mCanvas = canvas;
}
