public void ModifyBookmark()
{
//create bookmark for deleting
IMark nBookmark = CreateTestBookmark("Bookmark Unmodified", "Original description");
//save bookmark
RepositManager.Bookmarks.Add((Bookmark)nBookmark);
RepositManager.Save();
//get id
var id = nBookmark.id;
//retrieve bookmark
IMark toModify = RepositManager.Bookmarks.FindById(id);
//modify
string modifedName = "Modified Bookmark";
string modifiedDescription = "New description";
toModify.Name = modifedName;
toModify.Description = modifiedDescription;
//save
RepositManager.Bookmarks.Update((Bookmark)toModify);
RepositManager.Save();
//retrieve
IMark modifedBookmark = RepositManager.Bookmarks.FindById(id);
//assert
Assert.AreEqual <string>(modifedName, modifedBookmark.Name);
Assert.AreEqual <string>(modifiedDescription, modifedBookmark.Description);
}
public MarkTimeInfo(IMark mark)
{
StartTime = mark.StartTime;
EndTime = mark.EndTime;
Duration = mark.Duration;
MarkCollection = mark.Parent;
}
public static SingleViewSpecification SetMark(IMark mark)
{
var eg = GetDefalut();
eg.Mark = mark;
return(eg);
}
private void MouseMove_Normal(Point gridLocation)
{
// Are we in a 'resize zone' at the front or back of an element?
IMark mark = MarkAt(gridLocation);
if (mark == null)
{
_markResizeZone = ResizeZone.None;
}
else
{
// smaller of constant, or half of element width
int grabThreshold = Math.Min(12, (int)(timeToPixels(mark.Duration) / 2));
float elemStart = timeToPixels(mark.StartTime);
float elemEnd = timeToPixels(mark.EndTime);
int x = gridLocation.X;
if ((x >= elemStart) && (x < (elemStart + grabThreshold)))
{
_markResizeZone = ResizeZone.Front;
}
else if ((x <= elemEnd) && (x > (elemEnd - grabThreshold)))
{
_markResizeZone = ResizeZone.Back;
}
else
{
_markResizeZone = ResizeZone.None;
}
}
Cursor = _markResizeZone == ResizeZone.None ? Cursors.Default : Cursors.SizeWE;
}
private void EndAllDrag()
{
_dragState = DragState.Normal;
Cursor = Cursors.Default;
_mouseDownMark = null;
//Invalidate();
}
public void AddMark(IMark mark)
{
_marks.Add(mark);
mark.Parent = this;
EnsureOrder();
OnPropertyChanged(nameof(Marks));
}
private void FindAllMarkTrans(Transform curTrans, string transFullName)
{
foreach (Transform childTrans in curTrans)
{
IMark uiMark = childTrans.GetComponent <IMark>();
if (uiMark != null)
{
if (!mPanelCodeData.mMarkObjInfos.Exists(objInfo => objInfo.mName.Equals(uiMark.mTransform.name)))
{
mPanelCodeData.mMarkObjInfos.Add(new MarkObjInfo
{
mName = uiMark.mTransform.name,
mMarkObj = uiMark,
mPathToElement = PathToParent(childTrans, mPanelCodeData.mPanelName),
});
mPanelCodeData.mDicNameToFullName.Add(uiMark.mTransform.name, transFullName + childTrans.name);
}
else
{
Debug.LogError("Repeat key: " + childTrans.name);
}
FindAllMarkTrans(childTrans, transFullName + childTrans.name + "/");
}
else
{
FindAllMarkTrans(childTrans, transFullName + childTrans.name + "/");
}
}
}
public void AddMark_ShouldThrow_WhenMarkParameterIsNull()
{
IMark mark = null;
var student = new Student("first", "last", (Grade)12);
Assert.That(() => student.AddMark(mark), Throws.ArgumentNullException);
}
public IEnumerable <IClass> EnumerateClasses(IMark mark)
{
foreach (var index in mark.EnumerateIndicies())
{
lock (this)
yield return(myIndexedClasses[index]);
}
}
public void Select(IMark mark)
{
if (mark != null && !SelectedMarks.Contains(mark))
{
_selectedMarks.Add(mark);
OnSelectionChanged();
}
}
public void AddMark(IStudent student, IMark mark)
{
if (student.Marks.Count >= MaxStudentMarksCount)
{
throw new ArgumentException($"The student's marks count exceed the maximum count of {MaxStudentMarksCount} marks");
}
student.Marks.Add(mark);
}
public void AddMark(IStudent student, IMark mark)
{
if (student.Marks.Count >= MaxStudentMarksCount)
{
throw new ArgumentException($"The student's marks count exceed the maximum count of {MaxStudentMarksCount} marks");
}
student.Marks.Add(mark);
}
public void AddMark(IMark mark)
{
if (this.Marks.Count == 20)
{
throw new ArgumentOutOfRangeException(GlobalConstants.StudentMaximumGradesReacher);
}
this.Marks.Add(mark);
}
public void AddMark(IMark mark)
{
if (this.Marks.Count == 20)
{
throw new ArgumentOutOfRangeException(GlobalConstants.StudentMaximumGradesReacher);
}
this.Marks.Add(mark);
}
public void AddMark(IMark mark)
{
if (this.marks.Count >= Constraints.MaxMarksCount)
{
throw new InvalidOperationException(
"The student have already reached maximum marks count");
}
this.marks.Add(mark);
}
public int CompareTo(IMark other)
{
int rv = StartTime.CompareTo(other.StartTime);
if (rv != 0)
{
return(rv);
}
return(EndTime.CompareTo(other.EndTime));
}
private VisualizerBase FindMarkVisualizer(IMark mark)
{
var t = mark.GetType();
if (markRules.ContainsKey(t))
{
return(markRules[t]);
}
throw new NotImplementedException(mark.ToString());
}
public static void SwapPlaces(IMark lhs, MarkTimeInfo rhs)
{
TimeSpan temp = lhs.StartTime;
lhs.StartTime = rhs.StartTime;
rhs.StartTime = temp;
temp = lhs.Duration;
lhs.Duration = rhs.Duration;
rhs.Duration = temp;
}
public void CopyFrom(IMark imark)
{
Mark = imark.Mark;
Name = imark.Name;
Priority = imark.Priority;
Value = imark.Value;
Max = imark.Max;
Default = imark.Default;
Offset = imark.Offset;
Type = imark.Type;
}
public ManageAccountController(IStudent students, IMessage messages, ISchoolClass schoolClass, IMark marks, IAssignment assignments, IParentAccount parentAccounts, ITeacherAccount teacherAccounts, UserManager <UserAccount> userManager)
{
_schoolClasses = schoolClass;
_messages = messages;
_students = students;
_userManager = userManager;
_parentAccounts = parentAccounts;
_teacherAccounts = teacherAccounts;
_assignments = assignments;
_marks = marks;
}
public void AddMark(Student studentToReceiveMark, IMark mark)
{
var studentTotalMarks = studentToReceiveMark.Marks.Count;
if (studentTotalMarks >= MaxNumberOfMarksPerStudent)
{
throw new ArgumentException($"Cannot add mark, because the student already has {MaxNumberOfMarksPerStudent} marks");
}
studentToReceiveMark.Marks.Add(mark);
}
public void AddMark(IStudent student, float mark)
{
if (student.Marks.Count >= MaxStudentMarksCount)
{
throw new ArgumentException($"The student's marks count exceed the maximum count of {MaxStudentMarksCount} marks");
}
IMark newMark = this.MarkFactory.CreateMark(this.Subject, mark);
student.Marks.Add(newMark);
}
private void DrawMark(Graphics g, MarkRow row, IMark mark, int top, Brush b)
{
int width;
//Sanity check - it is possible for .DisplayHeight to become zero if there are too many marks stacked.
//We set the DisplayHeight to the row height for the mark, and change the border to red.
var markStack = row.GetStackForMark(mark);
var displayHeight =
(markStack.StackCount > 1) ? ((row.Height - 2) / row.StackCount) : row.Height - 2;
var displayTop = top + displayHeight * markStack.StackIndex;
if (displayHeight == 0)
{
displayHeight = row.Height;
}
width = (int)timeToPixels(mark.Duration);
if (width <= 0)
{
return;
}
Size size = new Size(width, displayHeight);
Point finalDrawLocation = new Point((int)Math.Floor(timeToPixels(mark.StartTime)), displayTop);
Rectangle destRect = new Rectangle(finalDrawLocation.X, finalDrawLocation.Y, size.Width, displayHeight);
g.FillRectangle(b, destRect);
var isSelected = _marksSelectionManager.SelectedMarks.Contains(mark);
using (Pen bp = new Pen(Color.Black, isSelected?3:1))
{
g.DrawRectangle(bp, destRect);
}
if (isSelected)
{
using (Pen bp = new Pen(ThemeColorTable.ForeColor, 1))
{
bp.Alignment = PenAlignment.Inset;
bp.DashPattern = new [] { 1.0F, 2.0F };
g.DrawRectangle(bp, destRect);
}
}
//Draw the text
SolidBrush drawBrush = new SolidBrush(IdealTextColor(row.MarkDecorator.Color));
StringFormat drawFormat = new StringFormat();
g.DrawString(mark.Text, _textFont, drawBrush, destRect, drawFormat);
}
private void StartPntAdd1(MarkLayer markLayer, IMark mark, Point logicPnt)
{
Point MarkPnt = new Point(logicPnt.X, logicPnt.Y);
this.markLayer.ManuallyAddMarkObj = null;
NewMarkInfo = new AddMarket();
NewMarkInfo.markLayer = this.markLayer;
NewMarkInfo.tmp = mark as IMSMark;
NewMarkInfo.markPnt = MarkPnt;
NewMarkInfo.mapContainer = this.mapContainer;
NewMarkInfo.Show();
markLayer.ManuallyAddMarkOverCallback -= new ManuallyAddMarkDelegate(StartPntAdd1);
}
private void _defineUsersToMarks(IMark <TUser, TThing> mark)
{
if (_users.ContainsKey(mark.User))
{
_users[mark.User].Add(mark);
}
else
{
_users.Add(mark.User, new List <IMark <TUser, TThing> > {
mark
});
}
}
public void AddMark(IMark mark)
{
if (mark == null)
{
throw new ArgumentNullException(nameof(mark));
}
if (this.marks.Count == 20)
{
throw new ArgumentOutOfRangeException("Each student can have a maximum of 20 marks.");
}
this.marks.Add(mark);
}
public void AddMark(IMark mark)
{
if (mark == null)
{
throw new ArgumentNullException(nameof(mark), string.Format(Constants.NullObjectErrorMessage, "Student"));
}
if (this.Marks.Count >= MaxMarksCount)
{
throw new InvalidOperationException(string.Format(TooManyStudentMarksErrorMessage, MaxMarksCount));
}
this.Marks.Add(mark);
}
private static void AttachSerializeObj(GameObject obj, string behaviourName, System.Reflection.Assembly assembly,
List <IMark> processedMarks = null)
{
if (null == processedMarks)
{
processedMarks = new List <IMark>();
}
IMark uiMark = obj.GetComponent <IMark>();
string className = string.Empty;
className = behaviourName;
// 得到类名
System.Type t = assembly.GetType(className);
// GameObject上没有此组件就添加
Component com = obj.GetComponent(t) ?? obj.AddComponent(t);
// 序列化这个组件
SerializedObject sObj = new SerializedObject(com);
IMark[] uiMarks = obj.GetComponentsInChildren <IMark>(true);
foreach (var elementMark in uiMarks)
{
if (processedMarks.Contains(elementMark))
{
continue;
}
processedMarks.Add(elementMark);
string uiType = elementMark.mComponentTypeName;
// 成员变量名字
string propertyName = UICodeGenerator.mPreFormat + elementMark.mTransform.gameObject.name;
if (sObj.FindProperty(propertyName) == null)
{
Debug.LogFormat("sObj is Null:{0} {1} {2}", propertyName, uiType, sObj);
continue;
}
sObj.FindProperty(propertyName).objectReferenceValue = elementMark.mTransform.gameObject;
//AttachSerializeObj(elementMark.mTransform.gameObject, elementMark.ComponentName, assembly, processedMarks);
}
sObj.ApplyModifiedPropertiesWithoutUndo();
}
public void AddBookmark()
{
IMark nBookmark = CreateTestBookmark("Bookmark one", "First bookmark");
//save to file
RepositManager.Bookmarks.Add((Bookmark)nBookmark);
RepositManager.Save();
IMark results = RepositManager.Bookmarks.Find((Bookmark)nBookmark);
Assert.IsNotNull(results);
Assert.IsNotNull(results.id);
}
protected void MarkEach(IMark mark)
{
var eclosure = Eclosure();
var end = FindEnd();
ForEach((state) =>
{
if (eclosure.Contains(state) == false)
{
state.AddMark(mark);
}
});
end.Transition.Add(Epsilon, new State());
}
private void StartPntAdd2(MarkLayer markLayer, IMark mark, Point logicPnt)
{
m_barrierMark.Add(mark);
m_barrierDots += logicPnt.X + "," + logicPnt.Y + ",";
IMSMark markPnt = new IMSMark(new Image()
{
Source = new BitmapImage(new Uri("../images/mark/v0.png", UriKind.Relative))
})
{
EnableAnimation = false
};
MarkLayer.ManuallyAddMarkObj = markPnt;
MarkLayer.ManuallyAddMarkOverCallback = new ManuallyAddMarkDelegate(StartPntAdd2);
}
public bool IsSame(IMark mark)
{
return
((
this == mark
) ||
(
Mark == mark.Mark &&
Name == mark.Name &&
Value == mark.Value &&
Max == mark.Max &&
Default == mark.Default &&
Priority == mark.Priority &&
Offset == mark.Offset
));
}
public void AddMark(IMark mark)
{
_allMarks.Add(mark);
}
private static void SerializeMark(XmlWriter writer, int index, IMark mark)
{
writer.WriteStartElement("Mark");
writer.WriteAttributeString("id", index.ToString());
writer.WriteAttributeString("mark", mark.Mark.ToString());
writer.WriteAttributeString("name", mark.Name);
writer.WriteAttributeString("priority", mark.Priority.ToString());
writer.WriteAttributeString("value", mark.Value);
writer.WriteAttributeString("max", mark.Max.ToString());
writer.WriteAttributeString("default", mark.Default);
writer.WriteAttributeString("offset", mark.Offset.ToString());
writer.WriteAttributeString("type", mark.Type);
writer.WriteEndElement();
}
protected void MarkEach(IMark mark)
{
var eclosure = Eclosure();
var end = FindEnd();
ForEach((state) =>
{
if (eclosure.Contains(state) == false)
state.AddMark(mark);
});
end.Transition.Add(Epsilon, new State());
}
public VariableInfo(IMark mark)
: base(mark)
{
_shortname = GetShortName(Name);
}
public void AddVariable(IMark mark)
{
var shortname = VariableInfo.GetShortName(mark.Name);
Dictionary<string, VariableInfo> dictionary = null;
var mark1 = mark.Mark;
if (mark1 == Marks.Custom)
{
if (mark.Type == "ByteArrayPart")
mark1 = Marks.BeginRange;
if (mark.Type == "bool")
mark1 = Marks.Bool;
if (mark.Type == "int")
mark1 = Marks.Decimal;
}
switch (mark1)
{
case Marks.Custom:
if (string.IsNullOrEmpty(mark.Type) == false)
dictionary = _customs;
break;
case Marks.Const:
AddEnum(mark.Name, mark.Value);
break;
case Marks.BeginRange:
dictionary = _begins1;
break;
case Marks.EndRange:
dictionary = _ends1;
break;
case Marks.Count:
dictionary = _counts1;
break;
case Marks.Bool:
case Marks.BoolEx:
dictionary = _bools;
break;
case Marks.Decimal:
case Marks.Hex:
dictionary = _decimals1;
break;
}
if (dictionary != null)
if (dictionary.ContainsKey(shortname) == false)
dictionary.Add(shortname, new VariableInfo(mark));
}
public void RemoveMark(IMark mark)
{
_allMarks.Remove(mark);
}
