public override string EinfuegeTextPreProcessing(
string einfuegeText,
XMLCursorPos woEinfuegen,
out XmlNode ersatzNode)
{
return(base.EinfuegeTextPreProcessing(einfuegeText, woEinfuegen, out ersatzNode));
}
public virtual bool AktionDelete(UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
if (this.IstRootNodeSelektiert)
{
return(false);
}
if (undoSnapshotSetzen == UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(ResReader.Reader.GetString("AktionLoeschen"), this._cursor);
}
XMLCursor cursor = this._cursor;
cursor.SelektionOptimieren();
XMLCursorPos xMLCursorPos = default(XMLCursorPos);
if (cursor.SelektionLoeschen(out xMLCursorPos))
{
this._cursor.BeideCursorPosSetzen(xMLCursorPos.AktNode, xMLCursorPos.PosAmNode, xMLCursorPos.PosImTextnode);
this.ContentChanged();
return(true);
}
return(false);
}
public bool AktionNodeOderZeichenHinterCursorPosLoeschen(
XMLCursorPos position,
XMLEditor.UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
if (undoSnapshotSetzen == XMLEditor.UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(de.springwald.xml.ResReader.Reader.GetString("AktionLoeschen"), this._cursor);
}
XMLCursor xmlCursor = new XMLCursor();
xmlCursor.StartPos.CursorSetzen(position.AktNode, position.PosAmNode, position.PosImTextnode);
XMLCursorPos xmlCursorPos = xmlCursor.StartPos.Clone();
xmlCursorPos.MoveRight(this._rootNode, this.Regelwerk);
xmlCursor.EndPos.CursorSetzen(xmlCursorPos.AktNode, xmlCursorPos.PosAmNode, xmlCursorPos.PosImTextnode);
xmlCursor.SelektionOptimieren();
XMLCursorPos neueCursorPosNachLoeschen;
if (xmlCursor.StartPos.AktNode == this._rootNode || !xmlCursor.SelektionLoeschen(out neueCursorPosNachLoeschen))
{
return(false);
}
this._cursor.BeideCursorPosSetzen(neueCursorPosNachLoeschen.AktNode, neueCursorPosNachLoeschen.PosAmNode, neueCursorPosNachLoeschen.PosImTextnode);
this._cursor.ErzwingeChanged();
this.ContentChanged();
return(true);
}
public bool AktionNodeOderZeichenHinterCursorPosLoeschen(XMLCursorPos position, UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
if (undoSnapshotSetzen == UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(ResReader.Reader.GetString("AktionLoeschen"), this._cursor);
}
XMLCursor xMLCursor = new XMLCursor();
xMLCursor.StartPos.CursorSetzen(position.AktNode, position.PosAmNode, position.PosImTextnode);
XMLCursorPos xMLCursorPos = xMLCursor.StartPos.Clone();
xMLCursorPos.MoveRight(this._rootNode, this.Regelwerk);
xMLCursor.EndPos.CursorSetzen(xMLCursorPos.AktNode, xMLCursorPos.PosAmNode, xMLCursorPos.PosImTextnode);
xMLCursor.SelektionOptimieren();
if (xMLCursor.StartPos.AktNode == this._rootNode)
{
return(false);
}
XMLCursorPos xMLCursorPos2 = default(XMLCursorPos);
if (xMLCursor.SelektionLoeschen(out xMLCursorPos2))
{
this._cursor.BeideCursorPosSetzen(xMLCursorPos2.AktNode, xMLCursorPos2.PosAmNode, xMLCursorPos2.PosImTextnode);
this._cursor.ErzwingeChanged();
this.ContentChanged();
return(true);
}
return(false);
}
public override string[] ErlaubteEinfuegeElemente_(
XMLCursorPos zielPunkt,
bool pcDATAMitAuflisten,
bool kommentareMitAuflisten)
{
return(base.ErlaubteEinfuegeElemente_(zielPunkt, pcDATAMitAuflisten, kommentareMitAuflisten));
}
public override string EinfuegeTextPreProcessing(string einfuegeText, XMLCursorPos woEinfuegen, out XmlNode ersatzNode)
{
XmlNode xmlNode = (!(woEinfuegen.AktNode is XmlText)) ? woEinfuegen.AktNode : woEinfuegen.AktNode.ParentNode;
if (einfuegeText == "*")
{
switch (xmlNode.Name)
{
default:
ersatzNode = woEinfuegen.AktNode.OwnerDocument.CreateElement("star");
return("");
case "pattern":
case "that":
case "script":
break;
}
}
string name = xmlNode.Name;
string result;
if (!(name == "srai"))
{
if (name == "pattern")
{
StringBuilder stringBuilder = new StringBuilder(einfuegeText.ToUpper());
stringBuilder.Replace("Ä", "AE");
stringBuilder.Replace("Ö", "OE");
stringBuilder.Replace("Ü", "UE");
stringBuilder.Replace("ß", "SS");
char[] array = stringBuilder.ToString().ToCharArray();
ArrayList arrayList = new ArrayList();
for (int i = 0; i < array.Length; i++)
{
if ((array[i] == '*' || array[i] == '_') && xmlNode.Name == "pattern")
{
arrayList.Add(array[i]);
}
else if ((array[i] > '@' & array[i] < '[') || (array[i] > '`' & array[i] < '{') || (array[i] > '/' & array[i] < ':') || array[i] == ' ')
{
arrayList.Add(array[i]);
}
}
char[] array2 = new char[arrayList.Count];
for (int j = 0; j < arrayList.Count; j++)
{
array2[j] = (char)arrayList[j];
}
result = new string(array2);
ersatzNode = null;
return(result);
}
return(base.EinfuegeTextPreProcessing(einfuegeText, woEinfuegen, out ersatzNode));
}
result = einfuegeText.Replace("*", "");
result = result.Replace("_", "");
ersatzNode = null;
return(result);
}
public virtual string EinfuegeTextPreProcessing(
string einfuegeText,
XMLCursorPos woEinfuegen,
out XmlNode ersatzNode)
{
ersatzNode = (XmlNode)null;
return(einfuegeText);
}
public override string[] ErlaubteEinfuegeElemente_(XMLCursorPos zielPunkt, bool pcDATAMitAuflisten, bool kommentareMitAuflisten)
{
if (zielPunkt.AktNode != null && zielPunkt.AktNode.Name.ToLower() == "category")
{
return(new string[0]);
}
return(base.ErlaubteEinfuegeElemente_(zielPunkt, pcDATAMitAuflisten, kommentareMitAuflisten));
}
public override string EinfuegeTextPreProcessing(
string einfuegeText,
XMLCursorPos woEinfuegen,
out XmlNode ersatzNode)
{
XmlNode xmlNode = !(woEinfuegen.AktNode is XmlText) ? woEinfuegen.AktNode : woEinfuegen.AktNode.ParentNode;
if (einfuegeText == "*")
{
string name = xmlNode.Name;
if (!(name == "pattern") && !(name == "that") && !(name == "script"))
{
ersatzNode = (XmlNode)woEinfuegen.AktNode.OwnerDocument.CreateElement("star");
return("");
}
}
string name1 = xmlNode.Name;
if (!(name1 == "srai"))
{
if (!(name1 == "pattern"))
{
return(base.EinfuegeTextPreProcessing(einfuegeText, woEinfuegen, out ersatzNode));
}
StringBuilder stringBuilder = new StringBuilder(einfuegeText.ToUpper());
stringBuilder.Replace("Ä", "AE");
stringBuilder.Replace("Ö", "OE");
stringBuilder.Replace("Ü", "UE");
stringBuilder.Replace("ß", "SS");
char[] charArray = stringBuilder.ToString().ToCharArray();
ArrayList arrayList = new ArrayList();
for (int index = 0; index < charArray.Length; ++index)
{
if ((charArray[index] == '*' || charArray[index] == '_') && xmlNode.Name == "pattern")
{
arrayList.Add((object)charArray[index]);
}
else if (charArray[index] > '@' & charArray[index] < '[' || charArray[index] > '`' & charArray[index] < '{' || charArray[index] > '/' & charArray[index] < ':' || charArray[index] == ' ')
{
arrayList.Add((object)charArray[index]);
}
}
char[] chArray = new char[arrayList.Count];
for (int index = 0; index < arrayList.Count; ++index)
{
chArray[index] = (char)arrayList[index];
}
string str = new string(chArray);
ersatzNode = (XmlNode)null;
return(str);
}
string str1 = einfuegeText.Replace("*", "").Replace("_", "");
ersatzNode = (XmlNode)null;
return(str1);
}
private List <DTDTestmuster> GetAlleTestmuster(XMLCursorPos cursorPos)
{
List <DTDTestmuster> alleMuster = new List <DTDTestmuster>();
if (cursorPos.AktNode == null)
{
throw new ApplicationException("GetAlleTestmuster: cursorPos.AktNode=NULL!");
}
switch (cursorPos.PosAmNode)
{
case XMLCursorPositionen.CursorVorDemNode:
case XMLCursorPositionen.CursorAufNodeSelbstVorderesTag:
case XMLCursorPositionen.CursorAufNodeSelbstHinteresTag:
case XMLCursorPositionen.CursorInDemLeeremNode:
case XMLCursorPositionen.CursorInnerhalbDesTextNodes:
case XMLCursorPositionen.CursorHinterDemNode:
if (!(cursorPos.AktNode is XmlComment))
{
StringCollection stringCollection;
if (cursorPos.PosAmNode == XMLCursorPositionen.CursorInDemLeeremNode)
{
DTDElement dtdElement = this._dtd.DTDElementByName(cursorPos.AktNode.Name, false);
stringCollection = dtdElement != null ? dtdElement.AlleElementNamenWelcheAlsDirektesChildZulaessigSind : new StringCollection();
}
else if (cursorPos.AktNode.OwnerDocument == null)
{
stringCollection = new StringCollection();
}
else if (cursorPos.AktNode == cursorPos.AktNode.OwnerDocument.DocumentElement)
{
stringCollection = new StringCollection();
}
else
{
DTDElement dtdElement = this._dtd.DTDElementByName(cursorPos.AktNode.ParentNode.Name, false);
stringCollection = dtdElement != null ? dtdElement.AlleElementNamenWelcheAlsDirektesChildZulaessigSind : new StringCollection();
}
foreach (string elementName in stringCollection)
{
DTDTestmuster testMuster = this.CreateTestMuster(elementName, cursorPos);
alleMuster.Add(testMuster);
}
}
if (!de.springwald.toolbox.Debugger.WORKAROUND)
{
this.PruefeAlleTestmuster(alleMuster, cursorPos);
}
return(alleMuster);
default:
throw new ApplicationException(string.Format("unknown cursorPos.StartPos.PosAmNode '{0}' detected.", (object)cursorPos.PosAmNode));
}
}
private void PruefeAlleTestmuster(List <DTDTestmuster> alleMuster, XMLCursorPos cursorPos)
{
XmlNode aktNode = cursorPos.AktNode;
DTDElement element;
if (cursorPos.PosAmNode == XMLCursorPositionen.CursorInDemLeeremNode)
{
element = this._dtd.DTDElementByName(DTD.GetElementNameFromNode(aktNode), false);
}
else
{
if (aktNode.OwnerDocument == null || aktNode.OwnerDocument.DocumentElement == null)
{
return;
}
if (aktNode == aktNode.OwnerDocument.DocumentElement)
{
using (List <DTDTestmuster> .Enumerator enumerator = alleMuster.GetEnumerator())
{
while (enumerator.MoveNext())
{
DTDTestmuster current = enumerator.Current;
if (current.ElementName == aktNode.Name)
{
current.Erfolgreich = true;
}
}
return;
}
}
else
{
element = this._dtd.DTDElementByName(DTD.GetElementNameFromNode(aktNode.ParentNode), false);
}
}
foreach (DTDTestmuster muster in alleMuster)
{
if (element == null)
{
muster.Erfolgreich = false;
}
else if (!muster.Erfolgreich)
{
muster.Erfolgreich = this.PasstMusterInElement(muster, element);
}
}
}
private bool AktionRootNodeDurchClipboardInhaltErsetzen(UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
string text = "";
try
{
text = Clipboard.GetText(TextDataFormat.Text);
XmlTextReader xmlTextReader = new XmlTextReader(text, XmlNodeType.Element, null);
xmlTextReader.MoveToContent();
XmlNode xmlNode = this._rootNode.OwnerDocument.ReadNode(xmlTextReader);
if (xmlNode.Name != this._rootNode.Name)
{
return(false);
}
if (undoSnapshotSetzen == UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(ResReader.Reader.GetString("RootNodedurchZwischenablageersetzen"), this._cursor);
}
this._rootNode.RemoveAll();
while (xmlNode.Attributes.Count > 0)
{
XmlAttribute node = xmlNode.Attributes.Remove(xmlNode.Attributes[0]);
this._rootNode.Attributes.Append(node);
}
XMLCursorPos xMLCursorPos = new XMLCursorPos();
xMLCursorPos.CursorSetzen(this._rootNode, XMLCursorPositionen.CursorInDemLeeremNode);
XMLCursorPos xMLCursorPos2 = xMLCursorPos.Clone();
while (xmlNode.ChildNodes.Count > 0)
{
XmlNode newChild = xmlNode.RemoveChild(xmlNode.FirstChild);
this._rootNode.AppendChild(newChild);
}
this.ContentChanged();
this._cursor.BeideCursorPosSetzen(this._rootNode, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
this._cursor.ErzwingeChanged();
return(true);
}
catch (Exception ex)
{
Debugger.GlobalDebugger.Protokolliere(string.Format("AktionRootNodeDurchClipboardInhaltErsetzen:Fehler für Einfügetext '{0}':{1}", text, ex.Message), Debugger.ProtokollTypen.Fehlermeldung);
return(false);
}
}
public bool IstDerNodeAnDieserStelleErlaubt(XmlNode node)
{
if (node.ParentNode is XmlDocument)
{
return(true);
}
XMLCursorPos cursorPos = new XMLCursorPos();
cursorPos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
DTDTestmuster testMuster = this.CreateTestMuster(DTD.GetElementNameFromNode(node), cursorPos);
this.PruefeAlleTestmuster(new List <DTDTestmuster>()
{
testMuster
}, cursorPos);
return(testMuster.Erfolgreich);
}
private bool PruefeNodePos(XmlNode node)
{
if (node is XmlWhitespace)
{
return(true);
}
if (this._dtd.IstDTDElementBekannt(DTD.GetElementNameFromNode(node)))
{
try
{
if (this.NodeChecker.IstDerNodeAnDieserStelleErlaubt(node))
{
return(true);
}
this._fehlermeldungen.AppendFormat(ResReader.Reader.GetString("TagHierNichtErlaubt"), (object)node.Name);
XMLCursorPos zuTestendeCursorPos = new XMLCursorPos();
zuTestendeCursorPos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
string[] strArray = this.NodeChecker.AnDieserStelleErlaubteTags_(zuTestendeCursorPos, false, false);
if ((uint)strArray.Length > 0U)
{
this._fehlermeldungen.Append(ResReader.Reader.GetString("ErlaubteTags"));
foreach (object obj in strArray)
{
this._fehlermeldungen.AppendFormat("{0} ", obj);
}
}
else
{
this._fehlermeldungen.Append(ResReader.Reader.GetString("AnDieserStelleKeineTagsErlaubt"));
}
return(false);
}
catch (DTD.XMLUnknownElementException ex)
{
this._fehlermeldungen.AppendFormat(ResReader.Reader.GetString("UnbekanntesElement"), (object)ex.ElementName);
return(false);
}
}
else
{
this._fehlermeldungen.AppendFormat(ResReader.Reader.GetString("UnbekanntesElement"), (object)DTD.GetElementNameFromNode(node));
return(false);
}
}
public virtual string[] ErlaubteEinfuegeElemente_(XMLCursorPos zielPunkt, bool pcDATAMitAuflisten, bool kommentareMitAuflisten)
{
if (zielPunkt.AktNode == null)
{
return(new string[0]);
}
if (this._dtd == null)
{
return(new string[1]
{
""
});
}
if (this._checker == null)
{
this._checker = new DTDNodeEditCheck(this._dtd);
}
return(this._checker.AnDieserStelleErlaubteTags_(zielPunkt, pcDATAMitAuflisten, kommentareMitAuflisten));
}
public string[] AnDieserStelleErlaubteTags_(
XMLCursorPos zuTestendeCursorPos,
bool pcDATAMitAuflisten,
bool kommentareMitAufListen)
{
List <DTDTestmuster> alleTestmuster = this.GetAlleTestmuster(zuTestendeCursorPos.Clone());
List <string> stringList = new List <string>();
foreach (DTDTestmuster dtdTestmuster in alleTestmuster)
{
if (dtdTestmuster.Erfolgreich)
{
if (dtdTestmuster.ElementName == null)
{
stringList.Add("");
}
else
{
string lower = dtdTestmuster.ElementName.ToLower();
if (!(lower == "#pcdata"))
{
if (lower == "#comment")
{
if (kommentareMitAufListen)
{
stringList.Add(dtdTestmuster.ElementName);
}
}
else
{
stringList.Add(dtdTestmuster.ElementName);
}
}
else if (pcDATAMitAuflisten)
{
stringList.Add(dtdTestmuster.ElementName);
}
}
}
}
return(stringList.ToArray());
}
public bool IstDerNodeAnDieserStelleErlaubt(XmlNode node)
{
if (node.ParentNode is XmlDocument)
{
return(true);
}
XMLCursorPos xMLCursorPos = new XMLCursorPos();
xMLCursorPos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
string elementNameFromNode = DTD.GetElementNameFromNode(node);
DTDTestmuster dTDTestmuster = this.CreateTestMuster(elementNameFromNode, xMLCursorPos);
List <DTDTestmuster> list = new List <DTDTestmuster>();
list.Add(dTDTestmuster);
this.PruefeAlleTestmuster(list, xMLCursorPos);
if (dTDTestmuster.Erfolgreich)
{
return(true);
}
return(false);
}
private void PruefeAlleTestmuster(List <DTDTestmuster> alleMuster, XMLCursorPos cursorPos)
{
XmlNode aktNode = cursorPos.AktNode;
DTDElement dTDElement;
if (cursorPos.PosAmNode == XMLCursorPositionen.CursorInDemLeeremNode)
{
dTDElement = this._dtd.DTDElementByName(DTD.GetElementNameFromNode(aktNode), false);
goto IL_00dd;
}
if (aktNode.OwnerDocument != null && aktNode.OwnerDocument.DocumentElement != null)
{
if (aktNode != aktNode.OwnerDocument.DocumentElement)
{
dTDElement = this._dtd.DTDElementByName(DTD.GetElementNameFromNode(aktNode.ParentNode), false);
goto IL_00dd;
}
foreach (DTDTestmuster item in alleMuster)
{
if (item.ElementName == aktNode.Name)
{
item.Erfolgreich = true;
}
}
}
return;
IL_00dd:
foreach (DTDTestmuster item2 in alleMuster)
{
if (dTDElement == null)
{
item2.Erfolgreich = false;
}
else if (!item2.Erfolgreich)
{
item2.Erfolgreich = this.PasstMusterInElement(item2, dTDElement);
}
}
}
public bool IstDiesesTagAnDieserStelleErlaubt(string tagname, XMLCursorPos zielPunkt)
{
return(((IEnumerable <string>) this.ErlaubteEinfuegeElemente_(zielPunkt, true, true)).Where <string>((Func <string, bool>)(e => e == tagname)).Count <string>() > 0);
}
public bool IstDiesesTagAnDieserStelleErlaubt(string tagname, XMLCursorPos zielPunkt)
{
return((from e in this.ErlaubteEinfuegeElemente_(zielPunkt, true, true)
where e == tagname
select e).Count() > 0);
}
private void zeichnungsSteuerelement_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
{
if (!this.Regelwerk.PreviewKeyDown(e, out this._naechsteTasteBeiKeyPressAlsTextAufnehmen, this))
{
this._naechsteTasteBeiKeyPressAlsTextAufnehmen = false;
switch (e.KeyData)
{
case Keys.Escape:
case Keys.Control:
break;
case Keys.Return:
case Keys.LButton | Keys.MButton | Keys.Back | Keys.Shift:
this.AktionenEnterGedrueckt();
break;
case Keys.Tab:
{
XmlNode xmlNode = this._cursor.StartPos.AktNode;
bool flag = false;
if (xmlNode.FirstChild != null)
{
xmlNode = xmlNode.FirstChild;
}
else if (xmlNode.NextSibling != null)
{
xmlNode = xmlNode.NextSibling;
}
else if (xmlNode.ParentNode.NextSibling != null)
{
xmlNode = xmlNode.ParentNode.NextSibling;
}
else
{
flag = true;
}
if (!flag)
{
this._cursor.BeideCursorPosSetzen(xmlNode, XMLCursorPositionen.CursorInDemLeeremNode);
}
this._naechstesLostFokusVerhindern = true;
break;
}
case Keys.LButton | Keys.MButton | Keys.Space | Keys.Shift:
this._cursor.EndPos.MoveLeft(this._rootNode, this.Regelwerk);
break;
case Keys.LButton | Keys.RButton | Keys.MButton | Keys.Space | Keys.Shift:
this._cursor.EndPos.MoveRight(this._rootNode, this.Regelwerk);
break;
case (Keys)131137:
this.AktionAllesMarkieren();
break;
case (Keys)131160:
this.AktionCutToClipboard(UndoSnapshotSetzenOptionen.ja);
break;
case (Keys)131139:
this.AktionCopyToClipboard();
break;
case (Keys)131158:
this.AktionPasteFromClipboard(UndoSnapshotSetzenOptionen.ja);
break;
case Keys.Home:
this.AktionCursorAufPos1();
break;
case (Keys)131162:
this.UnDo();
break;
case Keys.Left:
{
XMLCursorPos xMLCursorPos = this._cursor.StartPos.Clone();
xMLCursorPos.MoveLeft(this._rootNode, this.Regelwerk);
this._cursor.BeideCursorPosSetzen(xMLCursorPos.AktNode, xMLCursorPos.PosAmNode, xMLCursorPos.PosImTextnode);
break;
}
case Keys.Right:
{
XMLCursorPos xMLCursorPos = this._cursor.StartPos.Clone();
xMLCursorPos.MoveRight(this._rootNode, this.Regelwerk);
this._cursor.BeideCursorPosSetzen(xMLCursorPos.AktNode, xMLCursorPos.PosAmNode, xMLCursorPos.PosImTextnode);
break;
}
case Keys.Back:
case Keys.Back | Keys.Shift:
if (this._cursor.IstEtwasSelektiert)
{
this.AktionDelete(UndoSnapshotSetzenOptionen.ja);
}
else
{
this.AktionNodeOderZeichenVorDerCursorPosLoeschen(this._cursor.StartPos, UndoSnapshotSetzenOptionen.ja);
}
break;
case Keys.Delete:
case Keys.RButton | Keys.MButton | Keys.Back | Keys.Space | Keys.Shift:
if (this._cursor.IstEtwasSelektiert)
{
this.AktionDelete(UndoSnapshotSetzenOptionen.ja);
}
else
{
this.AktionNodeOderZeichenHinterCursorPosLoeschen(this._cursor.StartPos, UndoSnapshotSetzenOptionen.ja);
}
break;
default:
this._naechsteTasteBeiKeyPressAlsTextAufnehmen = true;
break;
}
}
}
private List <DTDTestmuster> GetAlleTestmuster(XMLCursorPos cursorPos)
{
List <DTDTestmuster> list = new List <DTDTestmuster>();
if (cursorPos.AktNode == null)
{
throw new ApplicationException("GetAlleTestmuster: cursorPos.AktNode=NULL!");
}
switch (cursorPos.PosAmNode)
{
default:
throw new ApplicationException(string.Format("unknown cursorPos.StartPos.PosAmNode '{0}' detected.", cursorPos.PosAmNode));
case XMLCursorPositionen.CursorVorDemNode:
case XMLCursorPositionen.CursorAufNodeSelbstVorderesTag:
case XMLCursorPositionen.CursorAufNodeSelbstHinteresTag:
case XMLCursorPositionen.CursorInDemLeeremNode:
case XMLCursorPositionen.CursorInnerhalbDesTextNodes:
case XMLCursorPositionen.CursorHinterDemNode:
if (!(cursorPos.AktNode is XmlComment))
{
StringCollection stringCollection;
if (cursorPos.PosAmNode == XMLCursorPositionen.CursorInDemLeeremNode)
{
DTDElement dTDElement = this._dtd.DTDElementByName(cursorPos.AktNode.Name, false);
stringCollection = ((dTDElement != null) ? dTDElement.AlleElementNamenWelcheAlsDirektesChildZulaessigSind : new StringCollection());
}
else if (cursorPos.AktNode.OwnerDocument == null)
{
stringCollection = new StringCollection();
}
else if (cursorPos.AktNode == cursorPos.AktNode.OwnerDocument.DocumentElement)
{
stringCollection = new StringCollection();
}
else
{
DTDElement dTDElement2 = this._dtd.DTDElementByName(cursorPos.AktNode.ParentNode.Name, false);
stringCollection = ((dTDElement2 != null) ? dTDElement2.AlleElementNamenWelcheAlsDirektesChildZulaessigSind : new StringCollection());
}
StringEnumerator enumerator = stringCollection.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string current = enumerator.Current;
DTDTestmuster item = this.CreateTestMuster(current, cursorPos);
list.Add(item);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
this.PruefeAlleTestmuster(list, cursorPos);
return(list);
}
}
public virtual bool AktionPasteFromClipboard(UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
string text = "";
try
{
XMLCursorPos startPos;
if (Clipboard.ContainsText(TextDataFormat.Text))
{
if (this.IstRootNodeSelektiert)
{
return(this.AktionRootNodeDurchClipboardInhaltErsetzen(undoSnapshotSetzen));
}
if (this.IstEtwasSelektiert)
{
if (this.AktionDelete(UndoSnapshotSetzenOptionen.nein))
{
startPos = this._cursor.StartPos;
goto IL_008a;
}
return(false);
}
startPos = this.CursorOptimiert.StartPos;
goto IL_008a;
}
return(false);
IL_008a:
if (undoSnapshotSetzen == UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(ResReader.Reader.GetString("AktionEinfuegen"), this._cursor);
}
text = Clipboard.GetText(TextDataFormat.Text);
text = text.Replace("\r\n", " ");
text = text.Replace("\n\r", " ");
text = text.Replace("\r", " ");
text = text.Replace("\n", " ");
text = text.Replace("\t", " ");
string xmlFragment = string.Format("<paste>{0}</paste>", text);
XmlTextReader xmlTextReader = new XmlTextReader(xmlFragment, XmlNodeType.Element, null);
xmlTextReader.MoveToContent();
XmlNode xmlNode = this._rootNode.OwnerDocument.ReadNode(xmlTextReader);
XMLCursorPos xMLCursorPos = startPos.Clone();
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (childNode is XmlText)
{
XmlNode xmlNode3 = null;
xMLCursorPos.TextEinfuegen(childNode.Clone().Value, this.Regelwerk, out xmlNode3);
if (xmlNode3 != null)
{
xMLCursorPos.InsertXMLNode(xmlNode3.Clone(), this.Regelwerk, true);
}
}
else
{
xMLCursorPos.InsertXMLNode(childNode.Clone(), this.Regelwerk, true);
}
}
XMLCursorPositionen posAmNode = this._cursor.EndPos.PosAmNode;
if (posAmNode == XMLCursorPositionen.CursorVorDemNode || posAmNode == XMLCursorPositionen.CursorInnerhalbDesTextNodes)
{
this._cursor.BeideCursorPosSetzen(xMLCursorPos.AktNode, xMLCursorPos.PosAmNode, xMLCursorPos.PosImTextnode);
}
else
{
this._cursor.BeideCursorPosSetzen(xMLCursorPos.AktNode, XMLCursorPositionen.CursorHinterDemNode);
}
return(true);
}
catch (Exception ex)
{
Debugger.GlobalDebugger.Protokolliere(string.Format("AktionPasteFromClipboard:Fehler für Einfügetext '{0}':{1}", text, ex.Message), Debugger.ProtokollTypen.Fehlermeldung);
return(false);
}
}
public virtual bool AktionPasteFromClipboard(
XMLEditor.UndoSnapshotSetzenOptionen undoSnapshotSetzen)
{
if (!this.AktionenMoeglich)
{
return(false);
}
string str = "";
try
{
if (!Clipboard.ContainsText(TextDataFormat.Text))
{
return(false);
}
if (this.IstRootNodeSelektiert)
{
return(this.AktionRootNodeDurchClipboardInhaltErsetzen(undoSnapshotSetzen));
}
XMLCursorPos startPos;
if (this.IstEtwasSelektiert)
{
if (!this.AktionDelete(XMLEditor.UndoSnapshotSetzenOptionen.nein))
{
return(false);
}
startPos = this._cursor.StartPos;
}
else
{
startPos = this.CursorOptimiert.StartPos;
}
if (undoSnapshotSetzen == XMLEditor.UndoSnapshotSetzenOptionen.ja)
{
this._undoHandler.SnapshotSetzen(de.springwald.xml.ResReader.Reader.GetString("AktionEinfuegen"), this._cursor);
}
str = Clipboard.GetText(TextDataFormat.Text);
str = str.Replace("\r\n", " ");
str = str.Replace("\n\r", " ");
str = str.Replace("\r", " ");
str = str.Replace("\n", " ");
str = str.Replace("\t", " ");
XmlTextReader xmlTextReader = new XmlTextReader(string.Format("<paste>{0}</paste>", (object)str), XmlNodeType.Element, (XmlParserContext)null);
int content = (int)xmlTextReader.MoveToContent();
XmlNode xmlNode = this._rootNode.OwnerDocument.ReadNode((XmlReader)xmlTextReader);
XMLCursorPos xmlCursorPos = startPos.Clone();
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (childNode is XmlText)
{
XmlNode ersatzNode = (XmlNode)null;
xmlCursorPos.TextEinfuegen(childNode.Clone().Value, this.Regelwerk, out ersatzNode);
if (ersatzNode != null)
{
xmlCursorPos.InsertXMLNode(ersatzNode.Clone(), this.Regelwerk, true);
}
}
else
{
xmlCursorPos.InsertXMLNode(childNode.Clone(), this.Regelwerk, true);
}
}
switch (this._cursor.EndPos.PosAmNode)
{
case XMLCursorPositionen.CursorVorDemNode:
case XMLCursorPositionen.CursorInnerhalbDesTextNodes:
this._cursor.BeideCursorPosSetzen(xmlCursorPos.AktNode, xmlCursorPos.PosAmNode, xmlCursorPos.PosImTextnode);
break;
default:
this._cursor.BeideCursorPosSetzen(xmlCursorPos.AktNode, XMLCursorPositionen.CursorHinterDemNode);
break;
}
return(true);
}
catch (Exception ex)
{
Debugger.GlobalDebugger.Protokolliere(string.Format("AktionPasteFromClipboard:Fehler für Einfügetext '{0}':{1}", (object)str, (object)ex.Message), Debugger.ProtokollTypen.Fehlermeldung);
return(false);
}
}
private DTDTestmuster CreateTestMuster(string elementName, XMLCursorPos cursorPos)
{
XmlNode aktNode = cursorPos.AktNode;
DTDTestmuster dtdTestmuster;
if (cursorPos.PosAmNode == XMLCursorPositionen.CursorInDemLeeremNode)
{
dtdTestmuster = new DTDTestmuster(elementName, DTD.GetElementNameFromNode(aktNode));
dtdTestmuster.AddElement(elementName);
}
else
{
if (aktNode.ParentNode is XmlDocument)
{
throw new ApplicationException(ResReader.Reader.GetString("FuerRootElementKeinTestmuster"));
}
dtdTestmuster = new DTDTestmuster(elementName, DTD.GetElementNameFromNode(aktNode.ParentNode));
for (XmlNode node = aktNode.ParentNode.FirstChild; node != null; node = node.NextSibling)
{
if (!(node is XmlWhitespace))
{
if (node == aktNode)
{
if (node is XmlComment)
{
dtdTestmuster.AddElement("#COMMENT");
}
else if (this._dtd.DTDElementByName(DTD.GetElementNameFromNode(aktNode), false) != null)
{
switch (cursorPos.PosAmNode)
{
case XMLCursorPositionen.CursorVorDemNode:
if (elementName == null)
{
throw new ApplicationException("CreateTestMuster: Löschen darf bei XMLCursorPositionen.CursorVorDemNode nicht geprüft werden!");
}
dtdTestmuster.AddElement(elementName);
dtdTestmuster.AddElement(DTD.GetElementNameFromNode(aktNode));
break;
case XMLCursorPositionen.CursorAufNodeSelbstVorderesTag:
case XMLCursorPositionen.CursorAufNodeSelbstHinteresTag:
if (elementName != null)
{
dtdTestmuster.AddElement(elementName);
break;
}
break;
case XMLCursorPositionen.CursorInDemLeeremNode:
if (elementName == null)
{
throw new ApplicationException("CreateTestMuster: Löschen darf bei XMLCursorPositionen.CursorHinterDemNode nicht geprüft werden!");
}
throw new ApplicationException("CreateTestMuster: CursorInDemLeeremNode can´t be handled at this place!");
case XMLCursorPositionen.CursorInnerhalbDesTextNodes:
if (elementName == null)
{
throw new ApplicationException("CreateTestMuster: Löschen darf bei XMLCursorPositionen.CursorInnerhalbDesTextNodes nicht geprüft werden!");
}
if (DTD.GetElementNameFromNode(aktNode) != "#PCDATA")
{
throw new ApplicationException("CreateTestMuster: CursorInnerhalbDesTextNodes angegeben, aber node.name=" + DTD.GetElementNameFromNode(aktNode));
}
dtdTestmuster.AddElement("#PCDATA");
dtdTestmuster.AddElement(elementName);
dtdTestmuster.AddElement("#PCDATA");
break;
case XMLCursorPositionen.CursorHinterDemNode:
if (elementName == null)
{
throw new ApplicationException("CreateTestMuster: Löschen darf bei XMLCursorPositionen.CursorHinterDemNode nicht geprüft werden!");
}
dtdTestmuster.AddElement(DTD.GetElementNameFromNode(aktNode));
dtdTestmuster.AddElement(elementName);
break;
default:
throw new ApplicationException("Unknown XMLCursorPositionen value:" + (object)cursorPos.PosAmNode);
}
}
}
else
{
dtdTestmuster.AddElement(DTD.GetElementNameFromNode(node));
}
}
}
}
return(dtdTestmuster);
}
