public NewLabelDefForm(string paperDefinitionsRootFolder, string labelDefinitionsRootFolder, LabelDef labeldefToLoad)
: this(paperDefinitionsRootFolder, labelDefinitionsRootFolder)
{
mode = Mode.edit;
this.labeldeftoLoad = labeldefToLoad;
idtxt.Text = labeldeftoLoad.ID;
idtxt.Enabled = false;
DPIXtxt.Text = labeldeftoLoad.coordinateSystem.dpiFactor.X.ToString();
DPIYtxt.Text = labeldeftoLoad.coordinateSystem.dpiFactor.Y.ToString();
unitcombo.Enabled = false;
DPIXtxt.Enabled = false;
DPIYtxt.Enabled = false;
foreach (LabelDef.PaperType papertype in labeldeftoLoad.PaperTypes)
{
if (availablepapertypelist.Items.Contains(papertype.ID))
{
availablepapertypelist.SelectedItem = papertype.ID;
addpapertypebtn_Click(null, null);
if (papertype.Default)
{
setAsDefault = papertype.ID;
}
}
else
{
MessageBox.Show("Paper ID " + papertype.ID + " is supported but was not found.", "", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
if (usedpapertypelist.Items.Count < 1)
{
Okbtn.Enabled = false;
}
}
public void Dispose()
{
if (_canvas != null)
{
if (_canvas.LayerContainer.VectorHost != null)
{
IMap map = (_canvas.LayerContainer.VectorHost as IVectorHostLayer).Map as IMap;
if (map != null && map.LayerContainer != null)
{
map.LayerContainer.Remove(_layer);
}
}
_canvas = null;
}
if (_mapRuntime != null)
{
_mapRuntime = null;
}
if (_datasource != null)
{
_datasource.Dispose();
_datasource = null;
}
if (_labeldef != null)
{
_labeldef.Dispose();
_labeldef = null;
}
if (_layer != null)
{
_layer.Dispose();
_layer = null;
}
OID = 0;
}
/// <summary>
/// 设置标注和矢量的绘制风格
/// </summary>
/// <param name="lyr"></param>
/// <param name="shpFname"></param>
private void TryApplyStyle(AgileMap.ILayer lyr, string shpFname)
{
string mcdfname = Path.ChangeExtension(shpFname, ".mcd");
if (!File.Exists(mcdfname))
{
return;
}
XDocument doc = XDocument.Load(mcdfname);
var result = doc.Element("Map").Element("Layers").Elements();
if (result == null)
{
return;
}
LabelDef labelDef = null;
IFeatureRenderer featureRender = null;
GetFeatureRenderFromMcd(doc, out labelDef, out featureRender);
if (labelDef != null)
{
(lyr as CodeCell.AgileMap.Core.IFeatureLayer).LabelDef = labelDef;
}
if (featureRender != null)
{
(lyr as CodeCell.AgileMap.Core.IFeatureLayer).Renderer = featureRender;
}
}
private static ILabelDef GetLabelDef(string dataName, IFeatureLayer layer)
{
string[] fields = (layer.Class as IFeatureClass).FieldNames;
string lbField = GetLabelFieldName(fields);
LabelDef def = new LabelDef(lbField, fields);
def.LabelFont = new Font("宋体", 9);
def.EnableLabeling = !string.IsNullOrEmpty(lbField);
def.MaskColor = Color.FromArgb(192, 192, 255);
def.EnableLabeling = false;
return(def);
}
private static void GetFeatureRenderFromMcd(XDocument doc, out LabelDef labelDef, out IFeatureRenderer featureRender)
{
labelDef = null;
featureRender = null;
try
{
var result = doc.Element("Map").Element("Layers");
if (result == null)
{
return;
}
var layerXmls = result.Elements("Layer");
if (layerXmls == null || layerXmls.Count() == 0)
{
return;
}
var layerXml = layerXmls.First();
var labelXmls = layerXml.Elements("LabelDef");
if (labelXmls != null && labelXmls.Count() != 0)
{
XElement labelXml = labelXmls.First();
labelDef = LabelDef.FromXElement(labelXml);
}
var renderXmls = layerXml.Elements("Renderer");
if (renderXmls != null && renderXmls.Count() != 0)
{
XElement renderXml = renderXmls.First();
XAttribute renderTypeAtt = renderXml.Attribute("type");
if (renderTypeAtt != null)
{
string renderType = renderTypeAtt.Value;
if (renderType == "CodeCell.AgileMap.Core.dll,CodeCell.AgileMap.Core.SimpleFeatureRenderer")
{
featureRender = SimpleFeatureRenderer.FromXElement(renderXml);
}
else if (renderType == "CodeCell.AgileMap.Core.dll,CodeCell.AgileMap.Core.SimpleTwoStepFeatureRenderer")
{
featureRender = SimpleTwoStepFeatureRenderer.FromXElement(renderXml);
}
else if (renderType == "CodeCell.AgileMap.Core.dll,CodeCell.AgileMap.Core.UniqueFeatureRenderer")
{
featureRender = UniqueFeatureRenderer.FromXElement(renderXml);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void SetLabel(CodeCell.AgileMap.Core.IFeatureLayer fetLayer)
{
LabelDef df = fetLayer.LabelDef as LabelDef;
if (df == null)
{
return;
}
df.EnableLabeling = true;
df.ForeColor = Color.Red;
df.Fieldname = "name";
_labeldef = df;
}
private static void TryApplyStyle(CodeCell.AgileMap.Core.IFeatureLayer fetLayer, string dataTypeId)
{
//根据文件类型应用显示方案
string[] mcdfnames = Directory.GetFiles(Path.GetDirectoryName(MicapsFileProcessor.DATATYPE_CONFIG_DIR), "*.mcd");
//应用默认方案
if (mcdfnames == null || mcdfnames.Length < 1)
{
SimpleMarkerSymbol sym = new SimpleMarkerSymbol(masSimpleMarkerStyle.Circle);
sym.Size = new System.Drawing.Size(3, 3);
fetLayer.Renderer = new SimpleFeatureRenderer(sym);
return;
}
else
{
string fname = null;
foreach (string item in mcdfnames)
{
if (dataTypeId == Path.GetFileNameWithoutExtension(item))
{
fname = item;
break;
}
}
if (fname != null)
{
XDocument doc = XDocument.Load(fname);
var result = doc.Element("Map").Element("Layers").Elements();
if (result == null)
{
return;
}
LabelDef labelDef = null;
IFeatureRenderer featureRender = null;
GetFeatureRenderFromMcd(doc, out labelDef, out featureRender);
if (labelDef != null)
{
fetLayer.LabelDef = labelDef;
}
if (featureRender != null)
{
fetLayer.Renderer = featureRender;
}
}
}
}
/// <summary>
/// Handles label definitions
/// [LBL, ARG*]
/// assumes first word is a label
/// </summary>
LabelDef ParseLabel()
{
tokenNum = 1;
var def = new LabelDef();
var signature = new List <string>();
var args = new List <string>();
def.identifier = words[0];
def.returnType = Tokens.NIL;
if (words.Length == 1)
{
// this label has no parameters (signature)
def.signature = new string[0];
def.identifier = def.identifier.Substring(0, words[0].Length - 1);
return(def);
}
bool open = false;
bool variable = false;
var expressionBuffer = new StringBuilder();
for (int i = 1; i < words.Length; i++)
{
tokenNum++;
string word = words[i].Trim();
if (word[word.Length - 1] == Tokens.DEF_MARKER)
{
// remove ':'
word = word.Substring(0, word.Length - 1);
}
if (word == Tokens.RET)
{
// next token must be a return type
i++;
word = words[i].Trim();
word = word.Substring(0, word.Length - 1);
if (Tokens.ValidType(word))
{
def.returnType = word;
}
else
{
throw new SyntaxError("Valid return type", word);
}
continue;
}
if (word[0] == Tokens.OPEN_PAREN)
{
// open parenthesis [(arg]
word = word.Substring(1);
open = true;
}
if (word[word.Length - 1] == Tokens.CLOSE_PAREN)
{
// close parenthesis and store literal [arg)]
word = word.Substring(0, word.Length - 1);
args.Add(word);
open = false;
continue;
}
if (open)
{
string tmp = word[word.Length - 1] == ',' ? word.Substring(0, word.Length - 1) : word;
// parentheses are open store value
if (variable)
{
args.Add(tmp);
}
else
{
signature.Add(tmp);
}
variable = !variable;
}
else
{
// if we have reached this point with no parenthesis this must
// be a label with an inline definition
// [label: (<arg>*) <expression>] | [label: <expression>]
expressionBuffer.Append(word);
expressionBuffer.Append(Tokens.SEPARATOR);
}
}
def.signature = signature.ToArray();
def.args = args.ToArray();
tokenNum = 0;
if (expressionBuffer.Length > 0)
{
// this label has an inline definition
labelBodyBuffer.Add(expressionBuffer.ToString());
// this will trigger the NonExpressionParser to close the block
def.inline = true;
}
return(def);
}
/// <summary>
/// Handles label definitions and comments
/// </summary>
/// <returns></returns>
bool ParseNonExecutable()
{
// split line into words
words = line.Split(Tokens.SEPARATOR);
string first = words[0].Trim();
// statement is documentation for the next open block
if (first.Length > 1 && first.Substring(0, 2) == Tokens.DOC)
{
labelDocBuffer.Add(line.Substring(2).Trim());
return(true);
}
// line is just a comment
if (first[0] == Tokens.COMMENT)
{
return(true);
}
if (first == Tokens.SECTION_DEF)
{
// this defines a section
// 'section' <identifier> ':'
preprocessor.ParsePreprocessorExp(Tokens.PREPROCESSOR_DEF + line.Split(Tokens.DEF_MARKER)[0]);
return(true);
}
if (first == Tokens.SECTION_END)
{
preprocessor.ParsePreprocessorExp(Tokens.PREPROCESSOR_DEF + first);
return(true);
}
if (!isLabelOpen && line.Contains(Tokens.DEF) && Tokens.ValidType(first))
{
// this defines a variable
// <type> <identifier> ':' <arg>
string[] tokens = line.Split(Tokens.DEF_MARKER);
if (tokens.Length < 2)
{
throw new SyntaxError("Variable definition", "<nil>");
}
// force type unless type is <var>
string typeCast = first == Tokens.VAR ? "" : first;
// get variable data
MetaSymbol arg = ParseArguments(tokens[1].Split(Tokens.SEPARATOR), typeCast, strictType: true)[0];
string varId = words[1];
// remove ':' from variable name if it exists
varId = varId[varId.Length - 1] == Tokens.DEF_MARKER ? varId.Substring(0, varId.Length - 1) : varId;
Push(varId, arg);
return(true);
}
if (!isLabelOpen && line.Contains(Tokens.DEF))
{
// this is a label definition
if (isLabelOpen)
{
// there was another label opened, close it
CloseBlock();
}
// parse the label and keep a reference to the result
isLabelOpen = true;
openLabel = ParseLabel();
if (openLabel.inline)
{
// this is an inline block and should be closed
CloseBlock();
isLabelOpen = false;
}
return(true);
}
if (first == Tokens.END)
{
// close this label
CloseBlock();
isLabelOpen = false;
return(true);
}
if (isLabelOpen)
{
// label is currently open, append new lines to its buffer
//labelBodyBuffer.Add(preprocessor.Compile(words));
labelBodyBuffer.Add(line);
return(true);
}
// this statement is not a special block
return(false);
}
//Main Functions
private void Okbtn_Click(object sender, EventArgs e)
{
if (CheckInput())
{
setDefaultLabel();
if (mode == Mode.create)
{
newLabelDef = new LabelDef();
newLabelDef.ID = idtxt.Text;
newLabelDef.coordinateSystem = new CoordinateSystem(Convert.ToUInt32(DPIXtxt.Text), Convert.ToUInt32(DPIYtxt.Text), unitcombo.SelectedItem.ToString());
List <LabelDef.PaperType> tempPaperTypeList = new List <LabelDef.PaperType>();
foreach (ACA.LabelX.Paper.PaperDef tempPaperDef in PaperTypeList.Values)
{
if (usedpapertypelist.Items.Contains(tempPaperDef.ID))
{
LabelDef.PaperType tempPaperType = new LabelDef.PaperType();
tempPaperType.ID = tempPaperDef.ID;
if (tempPaperDef.ID.Equals(setAsDefault))
{
tempPaperType.Default = true;
}
else
{
tempPaperType.Default = false;
}
tempPaperTypeList.Add(tempPaperType);
}
}
newLabelDef.PaperTypes = tempPaperTypeList;
saveLabelDefTo(labelDefinitionsRootFolder + @"\" + newLabelDef.ID + ".xml");
LabelName = newLabelDef.ID;
DialogResult = DialogResult.OK;
}
else if (mode == Mode.edit)
{
lock (ACA.LabelX.GlobalDataStore.LockClass)
{
setDefaultLabel();
string path = labelDefinitionsRootFolder + @"\" + labeldeftoLoad.ID + ".xml";
XmlDocument theDoc = new XmlDocument();
theDoc.Load(path);
XmlNode validpapertypes = theDoc.SelectSingleNode("/labeldef/validpapertypes");
validpapertypes.RemoveAll();
foreach (string papertype in usedpapertypelist.Items)
{
XmlElement paper = theDoc.CreateElement("paper");
paper.SetAttribute("type", papertype);
if (setAsDefault.Equals(papertype, StringComparison.OrdinalIgnoreCase))
{
paper.SetAttribute("default", "true");
}
else
{
paper.SetAttribute("default", "false");
}
validpapertypes.AppendChild(paper);
}
int teller = 0;
bool succes = false;
while ((teller < 5) && (succes == false))
{
theDoc.Save(path);
Thread.Sleep(2000);
succes = true;
teller++;
}
if (!succes)
{
MessageBox.Show("Error while saving file", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
DialogResult = DialogResult.OK;
LabelName = idtxt.Text;
}
this.Close();
}
else
{
MessageBox.Show(GetString("INVALIDINPUTERROR"), GetString("INVALIDINPUTERRORTITLE"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
