protected static NameValue GetFieldValue(DataEntityFieldInfo fi, InsertType iops, object v)
{
if (fi.Key)
{
if (iops == InsertType.New)
{
v = null;
}
else if (v != null && iops == InsertType.Last_Insert_ID)
{
if (v.GetType().IsValueType)
{
if (v.Equals(TypeUtils.GetDefaultValue(v.GetType())) || v is string && (v as string) == "")
{
v = DbProvider.Adapter.LastInsertId();
}
}
}
}
if (v != null && fi.Attribute.SerializeType != SerializeType.None)
{
v = Burst.Utils.Serialize(v, fi.Attribute.SerializeType);
}
return(new NameValue("@" + fi.Attribute.DbFieldName, v));
}
public static Command GetInsertCommand(InsertType iops, IEnumerable <NameValue> pms)
{
if (pms.Count() == 0)
{
return(null);
}
StringBuilder ss = new StringBuilder(), vs = new StringBuilder();
NameValueList pre = new NameValueList(pms);
NameValueList _pms = new NameValueList();
foreach (var fi in AllFields)
{
if (pre.ContainsKey(fi.Attribute.DbFieldName))
{
if (iops == InsertType.New && fi.Key)
{
continue;
}
ss.AppendFormat("{0},", fi.EnsuredName);
vs.AppendFormat("@{0},", fi.Attribute.DbFieldName);
_pms.Add(GetFieldValue(fi, InsertType.None, pre[fi.Attribute.DbFieldName]));
}
}
if (ss.Length > 0)
{
ss.Remove(ss.Length - 1, 1);
vs.Remove(vs.Length - 1, 1);
}
return(DbProvider.CreateCommand(string.Format("insert into {0} ({1}) values ({2})", EnsuredTableName, ss, vs), _pms));
}
public virtual Command GetInsertCommand(InsertType iops)
{
StringBuilder ss = new StringBuilder(), vs = new StringBuilder();
foreach (var fi in AllFields)
{
if (fi.Key && iops == InsertType.New)
{
continue;
}
ss.AppendFormat("{0},", fi.EnsuredName);
vs.AppendFormat("@{0},", fi.Attribute.DbFieldName);
}
if (ss.Length > 0)
{
ss.Remove(ss.Length - 1, 1);
}
if (vs.Length > 0)
{
vs.Remove(vs.Length - 1, 1);
}
string cmd = string.Format("insert into {0} ({1}) values ({2})", EnsuredTableName, ss, vs);
return(DbProvider.CreateCommand(cmd, this.AsNameValueList(iops)));
}
//-------------------------------------------------------------------------------
/// <summary>
/// Insert new IP query into tree
/// </summary>
/// <param name="ip">IP of scanned computer</param>
/// <param name="RD">Data containing Port and OS information</param>
/// <param name="optionType">Inserting Action</param>
public void Add(RawData RD, InsertType optionType)
{
BSTNode ipNode = null;
if (_IPTree == null)
{
_IPTree = new BSTNode(RD.IP_ADDRESS);
ipNode = _IPTree;
}
else
{
ipNode = SearchForIP(RD.IP_ADDRESS);
if (ipNode == null)
{
InsertIPAddress(RD.IP_ADDRESS);
ipNode = SearchForIP(RD.IP_ADDRESS);
}
}
switch (optionType)
{
case InsertType.IP_OSInsert:
ipNode.InsertOSType(RD.OS_TYPE, RD.OS_VERSION);
break;
case InsertType.IP_PortInsert:
ipNode.InsertOnePort(RD);
break;
default:
break;
}
}
private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType)
{
XmlNode parent = xmlDocument.DocumentElement;
XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
string original = parent.InnerXml;
string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
: ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
: (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
// insert new child
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected, parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.Prepend || insertType == InsertType.Append)
TestHelper.Verify(refChild, newChild, insertType);
// delete new child
parent.RemoveChild(newChild);
Assert.Equal(2, parent.ChildNodes.Count);
TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
Assert.Equal(original, parent.InnerXml);
}
public static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
Assert.NotNull(refChild);
Assert.NotNull(newChild);
XmlNode prev = null;
XmlNode next = null;
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
prev = newChild;
next = refChild;
break;
case InsertType.Append:
case InsertType.InsertAfter:
prev = refChild;
next = newChild;
break;
default:
Assert.True(false, "Wrong InsertType: '" + insertType + "'");
break;
}
Assert.NotNull(prev);
Assert.NotNull(next);
Assert.Equal(next, prev.NextSibling);
Assert.Equal(prev, next.PreviousSibling);
}
private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType)
{
XmlNode parent = xmlDocument.DocumentElement;
XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
string original = parent.InnerXml;
string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
: ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
: (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
// insert new child
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected, parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.Prepend || insertType == InsertType.Append)
{
TestHelper.Verify(refChild, newChild, insertType);
}
// delete new child
parent.RemoveChild(newChild);
Assert.Equal(2, parent.ChildNodes.Count);
TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
Assert.Equal(original, parent.InnerXml);
}
private void TagToSetPriority(InsertType insertType, GridView view, MyClass droppedOnTask)
{
int[] selectedRows = view.GetSelectedRows();
var addnum = insertType == InsertType.After ? 1 : -1;
addnum *= 10;
if (insertType == InsertType.Before)
{
Array.Reverse(selectedRows);
}
var offset = addnum;
foreach (var rowNum in selectedRows)
{
var row = view.GetRow(rowNum);
if (!(row is MyClass task))
{
throw new Exception("Expected SalesOrderLineTask");
}
task.Priority = droppedOnTask.Priority + offset;
task.TagToSetPriority = true;
//offset = offset + 10;
offset += addnum;
}
// SaveTasksAndRefresh(view, true);
}
private static void InsertTestBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
string[] expected = new string[2];
var xmlDocument = new XmlDocument {
PreserveWhitespace = true
};
xmlDocument.LoadXml(xml);
XmlNode parent = xmlDocument.DocumentElement;
XmlNode firstChild = parent.FirstChild;
XmlNode lastChild = parent.LastChild;
XmlNode refChild = parent.FirstChild.NextSibling;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
expected[0] = parent.InnerXml;
expected[1] = (insertType == InsertType.InsertBefore)
? (firstChild.OuterXml + newChild.OuterXml + refChild.OuterXml + lastChild.OuterXml)
: (firstChild.OuterXml + refChild.OuterXml + newChild.OuterXml + lastChild.OuterXml);
// insertion
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(4, parent.ChildNodes.Count);
Assert.Equal(expected[1], parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.Verify(parent, firstChild, lastChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.InsertBefore)
{
TestHelper.VerifySiblings(firstChild, newChild, InsertType.Append);
TestHelper.VerifySiblings(newChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
}
else
{
TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, newChild, InsertType.Append);
TestHelper.VerifySiblings(newChild, lastChild, InsertType.Append);
}
// delete the newChild
parent.RemoveChild(newChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected[0], parent.InnerXml);
TestHelper.Verify(parent, firstChild, lastChild);
TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
}
public static PrefabExtensionInsertPatch ConstructInsertPatchPath(InsertType insertType, string path, int index = 0, bool removeRootNode = false)
{
var patch = CreatePatchPath(path, removeRootNode);
patch.Index.Returns(index);
patch.Type.Returns(insertType);
return(patch);
}
/// <summary>
/// Default Construtor
/// </summary>
/// <param name="tb"></param>
/// <param name="t"></param>
public UtilDialog(FastColoredTextBox tb, InsertType t)
{
InitializeComponent();
_it = t;
_fctb = tb;
Init(t);
textBox1.KeyDown += ProcessKeyDown;
numericTextBox1.KeyDown += ProcessKeyDown;
}
private static void TwoTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
XmlDocument xmlDocument = new XmlDocument {
PreserveWhitespace = true
};
xmlDocument.LoadXml(xml);
TwoTextNodeBase(xmlDocument, insertType, nodeType);
}
private void SampleTreeViewOnDragOver(object sender, DragEventArgs e)
{
ResetSeparator(_changedBlocks);
if (!(sender is ItemsControl itemsControl) || !e.Data.GetDataPresent(typeof(TreeViewItemInfo)))
{
return;
}
DragScroll(itemsControl, e);
var sourceItem = (TreeViewItemInfo)e.Data.GetData(typeof(TreeViewItemInfo));
var targetElement = HitTest <FrameworkElement>(itemsControl, e.GetPosition);
var parentGrid = targetElement?.GetParent <Grid>();
if (parentGrid == null || !(targetElement.DataContext is TreeViewItemInfo targetElementInfo) || targetElementInfo == sourceItem)
{
return;
}
if (targetElementInfo.ContainsParent(sourceItem))
{
return;
}
e.Effects = DragDropEffects.Move;
var targetParentLast = GetParentLastChild(targetElementInfo);
const int boundary = 10;
var pos = e.GetPosition(parentGrid);
if (pos.Y > 0 && pos.Y < boundary)
{
_insertType = InsertType.Before;
targetElementInfo.BeforeSeparatorVisibility = Visibility.Visible;
}
else if (targetParentLast == targetElementInfo &&
pos.Y < parentGrid.ActualHeight && pos.Y > parentGrid.ActualHeight - boundary)
{
_insertType = InsertType.After;
targetElementInfo.AfterSeparatorVisibility = Visibility.Visible;
}
else
{
_insertType = InsertType.Children;
targetElementInfo.Background = Brushes.Gray;
}
if (!_changedBlocks.Contains(targetElementInfo))
{
_changedBlocks.Add(targetElementInfo);
}
}
public void Insert(AdvancedString s, InsertType t)
{
if (t == InsertType.Beginning)
{
Strings.AddFirst(s);
}
else if (t == InsertType.End)
{
Strings.AddLast(s);
}
}
void SelectDiamond()
{
if (insertType == InsertType.Diamond)
{
insertType = InsertType.Null;
}
else
{
insertType = InsertType.Diamond;
}
}
void SelectPlayer()
{
if (insertType == InsertType.Player)
{
insertType = InsertType.Null;
}
else
{
insertType = InsertType.Player;
}
}
void SelectMine()
{
if (insertType == InsertType.Mine)
{
insertType = InsertType.Null;
}
else
{
insertType = InsertType.Mine;
}
}
private static void InsertTestBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
string[] expected = new string[2];
var xmlDocument = new XmlDocument { PreserveWhitespace = true };
xmlDocument.LoadXml(xml);
XmlNode parent = xmlDocument.DocumentElement;
XmlNode firstChild = parent.FirstChild;
XmlNode lastChild = parent.LastChild;
XmlNode refChild = parent.FirstChild.NextSibling;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
expected[0] = parent.InnerXml;
expected[1] = (insertType == InsertType.InsertBefore)
? (firstChild.OuterXml + newChild.OuterXml + refChild.OuterXml + lastChild.OuterXml)
: (firstChild.OuterXml + refChild.OuterXml + newChild.OuterXml + lastChild.OuterXml);
// insertion
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(4, parent.ChildNodes.Count);
Assert.Equal(expected[1], parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.Verify(parent, firstChild, lastChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.InsertBefore)
{
TestHelper.VerifySiblings(firstChild, newChild, InsertType.Append);
TestHelper.VerifySiblings(newChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
}
else
{
TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, newChild, InsertType.Append);
TestHelper.VerifySiblings(newChild, lastChild, InsertType.Append);
}
// delete the newChild
parent.RemoveChild(newChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected[0], parent.InnerXml);
TestHelper.Verify(parent, firstChild, lastChild);
TestHelper.VerifySiblings(firstChild, refChild, InsertType.Append);
TestHelper.VerifySiblings(refChild, lastChild, InsertType.Append);
}
private static void TwoTextNodeBase(XmlNodeType[] nodeTypes, InsertType insertType, XmlNodeType nodeType)
{
XmlDocument xmlDocument = new XmlDocument { PreserveWhitespace = true };
var elem = xmlDocument.CreateElement("elem");
xmlDocument.AppendChild(elem);
for (int i = 0; i < nodeTypes.Length; i++)
elem.AppendChild(TestHelper.CreateNode(xmlDocument, nodeTypes[i]));
TwoTextNodeBase(xmlDocument, insertType, nodeType);
}
public static InsertFrontOrEnd CreateInsertFrontOrEnd(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
return new InsertFrontOrEnd(PrependChild);
case InsertType.Append:
return new InsertFrontOrEnd(AppendChild);
default:
throw new ArgumentException("Not supported InsertType='" + insertType + "'");
}
}
/// <summary>
/// 写入错误日志
/// </summary>
/// <param name="msg">日志信息</param>
/// <param name="insertType">写入方法(数据库/记事本)</param>
/// <param name="logType">(错误/信息)</param>
/// Author : Napoleon
/// Created : 2015-06-05 09:47:20
public static void InsertLog4(string msg, LogType logType = LogType.Error, InsertType insertType = InsertType.All)
{
SystemLog log = new SystemLog();
log.IpAddress = IpFunc.GetIp();
log.OperateTime = DateTime.Now;
log.OperateUrl = HttpContext.Current.Request.Url.ToString();
log.UserName = "******";
log.OperateType = "系统错误";
log.OperateContent = msg;
log.InsertLog(logType, insertType);
}
public static string QueryText(this InsertType insertType)
{
switch (insertType)
{
case InsertType.Insert: return("INSERT");
case InsertType.InsertOrIgnore: return("INSERT OR IGNORE");
case InsertType.Replace: return("REPLACE");
default: throw new ArgumentOutOfRangeException("InsertType");
}
}
public static InsertFrontOrEnd CreateInsertFrontOrEnd(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
return new InsertFrontOrEnd(PrependChild);
case InsertType.Append:
return new InsertFrontOrEnd(AppendChild);
default:
Assert.True(false, "Not supported InsertType='" + insertType + "'");
return null;
}
}
private static void OneTextNode_OneNonTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType, bool deleteFirst)
{
var xmlDocument = new XmlDocument {
PreserveWhitespace = true
};
xmlDocument.LoadXml(xml);
XmlNode parent = xmlDocument.DocumentElement;
XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
XmlNode nodeToRemove = (deleteFirst) ? parent.FirstChild : parent.LastChild;
// populate the expected result, where expected[0] is the expected result after insertion, and expected[1] is the expected result after deletion
string[] expected = new string[2];
expected[0] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
: ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
: (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
if (deleteFirst)
{
expected[1] = (insertType == InsertType.Append) ? (parent.LastChild.OuterXml + newChild.OuterXml) : (newChild.OuterXml + parent.LastChild.OuterXml);
}
else
{
expected[1] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.FirstChild.OuterXml) : (parent.FirstChild.OuterXml + newChild.OuterXml);
}
// insert new child
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected[0], parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.Prepend || insertType == InsertType.Append)
{
TestHelper.Verify(refChild, newChild, insertType);
}
// delete new child
parent.RemoveChild(nodeToRemove);
Assert.Equal(2, parent.ChildNodes.Count);
TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
Assert.Equal(expected[1], parent.InnerXml);
}
public static InsertBeforeOrAfter CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
return new InsertBeforeOrAfter(InsertBefore);
case InsertType.Append:
case InsertType.InsertAfter:
return new InsertBeforeOrAfter(InsertAfter);
default:
throw new ArgumentException("Not supported InsertType '" + insertType + "'");
}
}
public void SetInsertionMark(TreeNode Node, InsertType insertPostion) {
tempTVItem.mask = 8;
tempTVItem.stateMask = 2;
if (pseudoSelectedNode != null) {
PseudoSelectNode(pseudoSelectedNode, false);
pseudoSelectedNode = null;
}
if (insertPostion == InsertType.InsideNode) {
PseudoSelectNode(Node, true);
pseudoSelectedNode = Node;
}
SendMessage(base.Handle, 0x111a, insertPostion == InsertType.AfterNode,
((Node == null) || (insertPostion == InsertType.InsideNode)) ? IntPtr.Zero : Node.Handle);
}
public static InsertFrontOrEnd CreateInsertFrontOrEnd(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
return(new InsertFrontOrEnd(PrependChild));
case InsertType.Append:
return(new InsertFrontOrEnd(AppendChild));
default:
throw new ArgumentException("Not supported InsertType='" + insertType + "'");
}
}
public static InsertBeforeOrAfter CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
return new InsertBeforeOrAfter(InsertBefore);
case InsertType.Append:
case InsertType.InsertAfter:
return new InsertBeforeOrAfter(InsertAfter);
default:
Assert.True(false, "Not supported InsertType '" + insertType + "'");
return null;
}
}
public static InsertFrontOrEnd CreateInsertFrontOrEnd(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
return(new InsertFrontOrEnd(PrependChild));
case InsertType.Append:
return(new InsertFrontOrEnd(AppendChild));
default:
Assert.True(false, "Not supported InsertType='" + insertType + "'");
return(null);
}
}
private static void OneTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
var insertDelegate = TestHelper.CreateInsertFrontOrEnd(insertType);
var xmlDocument = new XmlDocument {
PreserveWhitespace = true
};
xmlDocument.LoadXml(xml);
var parent = xmlDocument.DocumentElement;
var child = parent.FirstChild;
var newChild = TestHelper.CreateNode(xmlDocument, nodeType);
var expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + child.OuterXml) : (child.OuterXml + newChild.OuterXml);
// insert new child
insertDelegate(parent, newChild);
// verify
Assert.Equal(2, parent.ChildNodes.Count);
Assert.Equal(expected, parent.InnerXml);
TestHelper.Verify(parent, child, newChild);
TestHelper.Verify(child, newChild, insertType);
// delete new child
parent.RemoveChild(newChild);
// verify
Assert.Equal(1, parent.ChildNodes.Count);
// Verify single child
Assert.NotNull(parent);
Assert.NotNull(child);
Assert.Equal(child, parent.FirstChild);
Assert.Equal(child, parent.LastChild);
Assert.Null(child.NextSibling);
Assert.Null(child.PreviousSibling);
// delete the last child
parent.RemoveChild(child);
// verify
Assert.Equal(0, parent.ChildNodes.Count);
Assert.Null(parent.FirstChild);
Assert.Null(parent.LastChild);
Assert.False(parent.HasChildNodes);
}
private static void TwoTextNodeBase(XmlNodeType[] nodeTypes, InsertType insertType, XmlNodeType nodeType)
{
XmlDocument xmlDocument = new XmlDocument {
PreserveWhitespace = true
};
var elem = xmlDocument.CreateElement("elem");
xmlDocument.AppendChild(elem);
for (int i = 0; i < nodeTypes.Length; i++)
{
elem.AppendChild(TestHelper.CreateNode(xmlDocument, nodeTypes[i]));
}
TwoTextNodeBase(xmlDocument, insertType, nodeType);
}
public static InsertBeforeOrAfter CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
return(new InsertBeforeOrAfter(InsertBefore));
case InsertType.Append:
case InsertType.InsertAfter:
return(new InsertBeforeOrAfter(InsertAfter));
default:
throw new ArgumentException("Not supported InsertType '" + insertType + "'");
}
}
private static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
VerifySiblings(newChild, refChild);
break;
case InsertType.InsertAfter:
VerifySiblings(refChild, newChild);
break;
default:
throw new ArgumentException("Wrong InsertType: '" + insertType + "'");
}
}
public void SetInsertionMark(TreeNode node, InsertType insertPostion)
{
_tempTreeViewItem.Mask = 8;
_tempTreeViewItem.StateMask = 2;
if (_selectedNode != null)
{
PseudoSelectNode(_selectedNode, false);
_selectedNode = null;
}
if (insertPostion == InsertType.InsideNode)
{
PseudoSelectNode(node, true);
_selectedNode = node;
}
NativeMethods.SendMessage(Handle, 0x111a, new IntPtr(insertPostion == InsertType.AfterNode ? 1 : 0),
((node == null) || (insertPostion == InsertType.InsideNode)) ? IntPtr.Zero : node.Handle);
}
public void SetInsertionMark(TreeNode node, InsertType insertPostion)
{
_tempTreeViewItem.Mask = 8;
_tempTreeViewItem.StateMask = 2;
if (_selectedNode != null)
{
PseudoSelectNode(_selectedNode, false);
_selectedNode = null;
}
if (insertPostion == InsertType.InsideNode)
{
PseudoSelectNode(node, true);
_selectedNode = node;
}
NativeMethods.SendMessage(Handle, 0x111a, new IntPtr(insertPostion == InsertType.AfterNode ? 1 : 0),
((node == null) || (insertPostion == InsertType.InsideNode)) ? IntPtr.Zero : node.Handle);
}
public static InsertBeforeOrAfter CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
return(new InsertBeforeOrAfter(InsertBefore));
case InsertType.Append:
case InsertType.InsertAfter:
return(new InsertBeforeOrAfter(InsertAfter));
default:
Assert.True(false, "Not supported InsertType '" + insertType + "'");
return(null);
}
}
public void SetInsertionMark(TreeNode Node, InsertType insertPostion)
{
tempTVItem.mask = 8;
tempTVItem.stateMask = 2;
if (pseudoSelectedNode != null)
{
PseudoSelectNode(pseudoSelectedNode, false);
pseudoSelectedNode = null;
}
if (insertPostion == InsertType.InsideNode)
{
PseudoSelectNode(Node, true);
pseudoSelectedNode = Node;
}
SendMessage(base.Handle, 0x111a, insertPostion == InsertType.AfterNode,
((Node == null) || (insertPostion == InsertType.InsideNode)) ? IntPtr.Zero : Node.Handle);
}
private static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
VerifySiblings(newChild, refChild);
break;
case InsertType.InsertAfter:
VerifySiblings(refChild, newChild);
break;
default:
Assert.True(false, "Wrong InsertType: '" + insertType + "'");
break;
}
}
private static void OneTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
var insertDelegate = TestHelper.CreateInsertFrontOrEnd(insertType);
var xmlDocument = new XmlDocument { PreserveWhitespace = true };
xmlDocument.LoadXml(xml);
var parent = xmlDocument.DocumentElement;
var child = parent.FirstChild;
var newChild = TestHelper.CreateNode(xmlDocument, nodeType);
var expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + child.OuterXml) : (child.OuterXml + newChild.OuterXml);
// insert new child
insertDelegate(parent, newChild);
// verify
Assert.Equal(2, parent.ChildNodes.Count);
Assert.Equal(expected, parent.InnerXml);
TestHelper.Verify(parent, child, newChild);
TestHelper.Verify(child, newChild, insertType);
// delete new child
parent.RemoveChild(newChild);
// verify
Assert.Equal(1, parent.ChildNodes.Count);
// Verify single child
Assert.NotNull(parent);
Assert.NotNull(child);
Assert.Equal(child, parent.FirstChild);
Assert.Equal(child, parent.LastChild);
Assert.Null(child.NextSibling);
Assert.Null(child.PreviousSibling);
// delete the last child
parent.RemoveChild(child);
// verify
Assert.Equal(0, parent.ChildNodes.Count);
Assert.Null(parent.FirstChild);
Assert.Null(parent.LastChild);
Assert.False(parent.HasChildNodes);
}
// Insert or replace an object of type T using ORM, while logging to query log
public static int InsertObject <T>(this IDatabase database, T obj, InsertType insertType = InsertType.Insert)
{
ISQLiteConnection conn = null;
try {
// Get database connection, insert object and log query
conn = database.GetSqliteConnection();
return(conn.InsertLogged(obj, insertType));
} catch (Exception e) {
logger.Error("insert failed: " + obj);
logger.Error(e);
} finally {
database.CloseSqliteConnection(conn);
}
// Return 0 on exception, no rows affected
return(0);
}
private static void OneTextNode_OneNonTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType, bool deleteFirst)
{
var xmlDocument = new XmlDocument { PreserveWhitespace = true };
xmlDocument.LoadXml(xml);
XmlNode parent = xmlDocument.DocumentElement;
XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);
XmlNode nodeToRemove = (deleteFirst) ? parent.FirstChild : parent.LastChild;
// populate the expected result, where expected[0] is the expected result after insertion, and expected[1] is the expected result after deletion
string[] expected = new string[2];
expected[0] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
: ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
: (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));
if (deleteFirst)
expected[1] = (insertType == InsertType.Append) ? (parent.LastChild.OuterXml + newChild.OuterXml) : (newChild.OuterXml + parent.LastChild.OuterXml);
else
expected[1] = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.FirstChild.OuterXml) : (parent.FirstChild.OuterXml + newChild.OuterXml);
// insert new child
var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected[0], parent.InnerXml);
TestHelper.Verify(parent, refChild, newChild);
TestHelper.VerifySiblings(refChild, newChild, insertType);
if (insertType == InsertType.Prepend || insertType == InsertType.Append)
TestHelper.Verify(refChild, newChild, insertType);
// delete new child
parent.RemoveChild(nodeToRemove);
Assert.Equal(2, parent.ChildNodes.Count);
TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
Assert.Equal(expected[1], parent.InnerXml);
}
public InsertLine(FastColoredTextBoxNS.FastColoredTextBox tb, InsertType t)
{
InitializeComponent();
it = t;
fctb = tb;
if (t == InsertType.Line)
{
this.Text = "Insert Lines";
label1.Text = "Number of Lines To Insert :";
button1.Text = "Insert";
}
else if (t == InsertType.Column)
{
this.Text = "Insert Column";
label1.Text = "No. of Columns to Insert :";
button1.Text = "Insert";
}
else if (t == InsertType.Macro)
{
this.Text = "Run Macro Multiple Times";
label1.Text = "No. of Times to Run :";
button1.Text = "Run";
}
}
private static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
VerifySiblings(newChild, refChild);
break;
case InsertType.InsertAfter:
VerifySiblings(refChild, newChild);
break;
default:
Assert.True(false, "Wrong InsertType: '" + insertType + "'");
break;
}
}
/// <summary>
/// Verify that child and newChild are siblings according to insertType
/// </summary>
/// <param name="child"></param>
/// <param name="newChild"></param>
/// <param name="insertType"></param>
public static void Verify(XmlNode child, XmlNode newChild, InsertType insertType)
{
Assert.NotNull(child);
Assert.NotNull(newChild);
switch (insertType)
{
case InsertType.Prepend:
Assert.Equal(child, newChild.NextSibling);
Assert.Equal(newChild, child.PreviousSibling);
Assert.Null(newChild.PreviousSibling);
break;
case InsertType.Append:
Assert.Equal(newChild, child.NextSibling);
Assert.Equal(child, newChild.PreviousSibling);
Assert.Null(newChild.NextSibling);
break;
default:
throw new ArgumentException("Wrong insert type: '" + insertType + "'");
}
}
public static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
Assert.NotNull(refChild);
Assert.NotNull(newChild);
XmlNode prev = null;
XmlNode next = null;
switch (insertType)
{
case InsertType.Prepend:
case InsertType.InsertBefore:
prev = newChild;
next = refChild;
break;
case InsertType.Append:
case InsertType.InsertAfter:
prev = refChild;
next = newChild;
break;
default:
throw new ArgumentException("Wrong InsertType: '" + insertType + "'");
}
Assert.NotNull(prev);
Assert.NotNull(next);
Assert.Equal(next, prev.NextSibling);
Assert.Equal(prev, next.PreviousSibling);
}
private static Func<XmlNode, XmlNode, XmlNode, XmlNode> CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
return InsertBefore;
case InsertType.InsertAfter:
return InsertAfter;
}
Assert.True(false, "Unknown type");
return null;
}
void SelectMine()
{
if(insertType == InsertType.Mine) insertType = InsertType.Null;
else insertType = InsertType.Mine;
}
private static void VerifySiblings(XmlNode refChild, XmlNode newChild, InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
VerifySiblings(newChild, refChild);
break;
case InsertType.InsertAfter:
VerifySiblings(refChild, newChild);
break;
default:
throw new ArgumentException("Wrong InsertType: '" + insertType + "'");
}
}
/// <summary>
/// 进入添加模式
/// UI的改动
/// </summary>
private void gotoInsertMode()
{
// 相关按钮的内容
insertType = InsertType.INSERT;
btnInsert.Text = insertBtnTxt;
btnUndoInsert.Text = undoInsertBtnTxt;
txtCount.Enabled = true;
txtItemName.Enabled = true;
}
/// <summary>
/// 进入修改模式
/// UI的改动
/// </summary>
private void gotoModifyMode()
{
// 修改相关按钮的内容
insertType = InsertType.MODIFY;
btnInsert.Text = modifyBtnTxt;
btnUndoInsert.Text = undoModifyBtnTxt;
// 物品数量禁止修改
txtCount.Enabled = false;
txtItemName.Enabled = false;
}
void SelectDiamond()
{
if(insertType == InsertType.Diamond) insertType = InsertType.Null;
else insertType = InsertType.Diamond;
}
private static void TwoTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
XmlDocument xmlDocument = new XmlDocument { PreserveWhitespace = true };
xmlDocument.LoadXml(xml);
TwoTextNodeBase(xmlDocument, insertType, nodeType);
}
public void Insert(AdvancedString s, InsertType t)
{
if (t == InsertType.Beginning)
Strings.AddFirst(s);
else if (t == InsertType.End)
Strings.AddLast(s);
}
public EdgeDockingDropZone(InsertType insertType, IDragDropTarget source, Rect dimensions, Thickness dropZoneOffsets)
: base(source, dimensions, dropZoneOffsets)
{
_insertType = insertType;
InitUIProperties();
}
void SelectPlayer()
{
if(insertType == InsertType.Player) insertType = InsertType.Null;
else insertType = InsertType.Player;
}
private static Func<XmlNode, XmlNode, XmlNode, XmlNode> CreateInsertBeforeOrAfter(InsertType insertType)
{
switch (insertType)
{
case InsertType.InsertBefore:
return InsertBefore;
case InsertType.InsertAfter:
return InsertAfter;
}
throw new ArgumentException("Unknown type");
}
private static void DeleteNonTextNodeBase(string xml, InsertType insertType, XmlNodeType nodeType)
{
string[] expected = new string[3];
var xmlDocument = new XmlDocument { PreserveWhitespace = true };
xmlDocument.LoadXml(xml);
XmlNode parent = xmlDocument.DocumentElement;
XmlNode firstChild = parent.FirstChild;
XmlNode lastChild = parent.LastChild;
XmlNode nodeToRemove = parent.FirstChild.NextSibling;
expected[0] = firstChild.OuterXml + lastChild.OuterXml;
// deletion
parent.RemoveChild(nodeToRemove);
// verify
Assert.Equal(2, parent.ChildNodes.Count);
Assert.Equal(expected[0], parent.InnerXml);
Assert.Equal(firstChild.ParentNode, parent);
Assert.Equal(lastChild.ParentNode, parent);
VerifySiblings(firstChild, lastChild, InsertType.InsertAfter);
// now, parent contains two textnodes only
XmlNode newChild = CreateNode(xmlDocument, nodeType);
XmlNode refChild = (insertType == InsertType.InsertBefore) ? lastChild : firstChild;
expected[1] = firstChild.OuterXml + newChild.OuterXml + lastChild.OuterXml;
expected[2] = parent.InnerXml;
// insertion
var insertDelegate = CreateInsertBeforeOrAfter(insertType);
insertDelegate(parent, newChild, refChild);
// verify
Assert.Equal(3, parent.ChildNodes.Count);
Assert.Equal(expected[1], parent.InnerXml);
Assert.Equal(newChild.ParentNode, parent);
Assert.Equal(lastChild.ParentNode, parent);
Assert.Equal(firstChild.ParentNode, parent);
VerifySiblings(firstChild, newChild, InsertType.InsertAfter);
VerifySiblings(newChild, lastChild, InsertType.InsertAfter);
// delete the newChild
parent.RemoveChild(newChild);
// verify
Assert.Equal(2, parent.ChildNodes.Count);
Assert.Equal(expected[2], parent.InnerXml);
Assert.Equal(firstChild.ParentNode, parent);
Assert.Equal(lastChild.ParentNode, parent);
VerifySiblings(firstChild, lastChild, InsertType.InsertAfter);
}
