public void ModifyValue(HeroPropertyType property, AddType addType, float resultValue) { var value = this[property]; switch (addType) { case AddType.Append: { value.SetAppendValue((int)resultValue); } break; case AddType.Base: { value.SetBaseValue((int)resultValue); } break; case AddType.Rate: { value.SetRate((int)resultValue); } break; } View.ProtertyChange(property, value.FinalValue); }
static async Task AddType(AddType obj) { var json = JsonConvert.SerializeObject(obj); var httpContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json"); HttpClient client = new HttpClient(); HttpResponseMessage httpResponseMessage = await client.PostAsync("http://localhost:2794/DictionaryConferenceType/AddType", httpContent); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { AddType covert = (value is AddType) ? (AddType)value : AddType.all; switch (covert) { case AddType.all: return("ostatnie 30dni"); case AddType.last14days: return("ostatnie 14dni"); case AddType.last7days: return("ostatnie 7dni"); case AddType.last3days: return("ostatnie 3dni"); case AddType.last24h: return("ostatnie 24h"); default: goto case AddType.all; } }
private static MyLinkedList <int> AddFunction(int[] nums, AddType addType) { MyLinkedList <int> list = new MyLinkedList <int>(); switch (addType) { case AddType.AddLast: for (int i = 0; i < nums.Length; i++) { list.AddLast(nums[i]); } break; case AddType.AddFirst: for (int i = 0; i < nums.Length; i++) { list.AddFirst(nums[i]); } break; default: throw new Exception("Invalid add type"); } return(list); }
// picks random ad from given list for given type public static Ad_S1 GetAdd(List <Ad_S1> _ads, AddType _type) { bool _contains = false; // check that list contains type foreach (Ad_S1 _ad in _ads) { if (_ad.Type == _type) { _contains = true; break; } } if (!_contains) { throw new ArgumentException(string.Format("List of ads does not contain given type \"{0}\"", _type.ToString())); } // pick a random ad while (true) { Random _rand = new Random(); int _index = _rand.Next(_ads.Count); Ad_S1 _ad = _ads[_index]; if (_ad.Type == _type) { return(_ad); } } }
public ActionResult EditType(AddType obj) { if (ModelState.IsValid) { var user = dobj.Users.Where(x => x.EmailID == User.Identity.Name).FirstOrDefault(); var type = dobj.NoteTypes.Where(x => x.ID == obj.ID).FirstOrDefault(); if (type == null) { return(HttpNotFound()); } type.Name = obj.Name.Trim(); type.Description = obj.Description.Trim(); type.ModifiedDate = DateTime.Now; type.ModifiedBy = user.ID; dobj.Entry(type).State = EntityState.Modified; dobj.SaveChanges(); return(RedirectToAction("ManageType")); } else { return(View(obj)); } }
public void StartLambda() { // tildeles en metode - som lambda udtryk Sum = (x, y) => x + y; int res = Sum(5, 8); Console.WriteLine(res); Sum = EnAndenMetode; res = Sum(5, 8); Console.WriteLine(res); stringMetode = (s) => { Console.WriteLine("Dette er en tekst " + s); }; talMetode = (x, y) => x + y; stringMetode("Peter"); int res2 = talMetode(4, 9); Console.WriteLine("Talmetode = " + res2); }
public static void AddParagraph(string ident, string text, AddType type = AddType.ActivePage) { PDFDocument document = documents[ident]; Section sect = document.getSection(type); sect.AddParagraph(text); }
private void BtnAddType_Click(object sender, EventArgs e) { AddType addType = new AddType(); this.Hide(); addType.Show(); }
private void btnAdd_Click(object sender, System.EventArgs e) { var addForm = new AddType(repository); addForm.ShowDialog(); Reload(); }
/// <summary> /// Adds a generic AddType to a DateTime object /// </summary> /// <param name="now"><seealso cref="System.DateTime"/></param> /// <param name="adder">Type structure that acts as a switcher for what type of add to perform</param> /// <param name="much">How much AddType to add to each element for creating list of data</param> /// <returns>A DateTime object with the added AddType amounts</returns> public static DateTime Add(this DateTime now, AddType adder, double much) { DateTime ret = now; switch (adder) { case AddType.Years: { ret = now.AddYears((int)much); break; } case AddType.Months: { ret = now.AddMonths((int)much); break; } case AddType.Days: { ret = now.AddDays(much); break; } case AddType.Hours: { ret = now.AddHours(much); break; } case AddType.Minutes: { ret = now.AddMinutes(much); break; } case AddType.Seconds: { ret = now.AddSeconds(much); break; } case AddType.Milliseconds: { ret = now.AddMilliseconds(much); break; } case AddType.Ticks: { ret = now.AddTicks((long)much); break; } } return(ret); }
public override bool Equals(object obj) { var other = obj as AddNode; if (other == null) { return(false); } return(AddType.Equals(other.AddType) && ListsAreEqual(FileGlobs, other.FileGlobs)); }
public override string ToString() { var properties = new Dictionary <string, string> { { "AddType", AddType.ToString() }, { "FileGlobs", StringifyList(FileGlobs) } }; return(StringifyValues(GetType().ToString(), properties)); }
private void buttonShowTypesEdit_Click(object sender, RoutedEventArgs e) { ResourceType rt = (ResourceType)TypesTable.SelectedValue; if (rt != null) { AddType window = new AddType(rt); showNewWindow(window); } }
public ActionResult UpdateType(int id) { var type = _context.GetType(id); AddType model = new AddType { Id = id, TypeName = type.Name, Description = type.Description }; return(View("AddType", model)); }
protected void Page_Load(object sender, EventArgs e) { CheckAccount(); if (!string.IsNullOrEmpty(Request["id"])) { _id = Int32.Parse(Request["id"]); phAddRecord.Visible = false; phEditRecord.Visible = true; } App_Code.Base db = new App_Code.Base(WebConfigurationManager.ConnectionStrings["DefaultConnection"].ToString()); _data = db.GetEnviromentAddresses(); if (!IsPostBack) { AddAddress.DataSource = _data; AddAddress.DataBind(); EditAddress.DataSource = _data; EditAddress.DataBind(); if (_data.Count > 0) { AddAddress.SelectedIndex = 0; EditAddress.SelectedIndex = 0; } List <string> list = db.GetEnviromentType(); AddType.DataSource = list; AddType.DataBind(); AddType.SelectedIndex = 0; EditType.DataSource = list; EditType.DataBind(); EditType.SelectedIndex = 0; if (_id > 0) { using (SqlConnection conn = new SqlConnection(WebConfigurationManager.ConnectionStrings["DefaultConnection"].ToString())) { conn.Open(); SqlCommand cmd = new SqlCommand("e.[Name], e.Type, ea.Address, e.[Description] from [Enviroment] e " + "join EnviromentAddresses ea on ea.Id=e.AddressId where e.Id=@id", conn); cmd.Parameters.AddWithValue("id", _id); SqlDataAdapter da = new SqlDataAdapter(cmd); DataTable dt = new DataTable(); da.Fill(dt); if (dt.Rows.Count > 0) { EditType.SelectedValue = dt.Rows[0]["Type"].ToString(); EditName.Text = dt.Rows[0]["Name"].ToString(); EditAddress.SelectedValue = dt.Rows[0]["Address"].ToString(); EditDescription.Text = dt.Rows[0]["Description"].ToString(); } } } } }
private void buttonAddNewType_Click(object sender, RoutedEventArgs e) { if (Database.GetManifestation(autoCompleteBoxTypes.Text) == null) { AddType addType = new AddType(autoCompleteBoxTypes.Text); addType.ShowDialog(); } else { AddType addType = new AddType(); addType.ShowDialog(); } }
public AddForm(AddType type) { InitializeComponent(); if (type == AddType.Group) { label1.Text = "Group Name"; Text = "Add Group"; } else { label1.Text = "User Name"; Text = "Add User"; } }
/// <summary> /// /// </summary> /// <param name="task"></param> /// <param name="namesToCheck">List or array of tasks you want to try to process. Returns on first sucess</param> /// <param name="type"></param> /// <param name="stoponerror"></param> /// <returns></returns> public static bool AddTask(ITask task, IEnumerable <string> namesToCheck, AddType type, bool stoponerror = true) { if (namesToCheck.Any(name => AddTask(task, name, type, false))) { return(true); } CommunityLib.Log.ErrorFormat($"[Task](Array) Failed to add \"{task.Name}\"."); if (stoponerror) { BotManager.Stop(); } return(false); }
/// <summary> /// Adds a generic AddType to a DateTime object /// </summary> /// <param name="now"><seealso cref="System.DateTime"/></param> /// <param name="adder">Type structure that acts as a switcher for what type of add to perform</param> /// <param name="much">How much AddType to add to each element for creating list of data</param> /// <returns>A DateTime object with the added AddType amounts</returns> public static DateTime Add(this DateTime now, AddType adder, double much) { DateTime ret = now; switch (adder) { case AddType.Years: { ret = now.AddYears((int)much); break; } case AddType.Months: { ret = now.AddMonths((int)much); break; } case AddType.Days: { ret = now.AddDays(much); break; } case AddType.Hours: { ret = now.AddHours(much); break; } case AddType.Minutes: { ret = now.AddMinutes(much); break; } case AddType.Seconds: { ret = now.AddSeconds(much); break; } case AddType.Milliseconds: { ret = now.AddMilliseconds(much); break; } case AddType.Ticks: { ret = now.AddTicks((long)much); break; } } return ret; }
public ActionResult EditType(int TypeID) { var emailid = User.Identity.Name.ToString(); Users admin = dbobj.Users.Where(x => x.EmailID == emailid).FirstOrDefault(); NoteTypes obj = dbobj.NoteTypes.Where(x => x.ID == TypeID).FirstOrDefault(); AddType model = new AddType(); model.TypeID = obj.ID; model.TypeName = obj.Name; model.Description = obj.Description; ViewBag.ProfilePicture = dbobj.Admin.Where(x => x.UserID == admin.ID).Select(x => x.ProfilePicture).FirstOrDefault(); return(View(model)); }
public static void AddHeader(string ident, string text, HeaderType htype, AddType type = AddType.ActivePage) { PDFDocument document = documents[ident]; Section sect = document.getSection(type); string style = ""; switch (htype) { case HeaderType.first: style = "Heading1"; break; case HeaderType.second: style = "Heading2"; break; case HeaderType.third: style = "Heading3"; break; } Paragraph par = sect.AddParagraph(text, style); }
public void AddCommands_SetsAddItem(AddType?parameter, AddType expected) { var mocker = new AutoMocker() .WithDefaults(); using var scope = mocker.WithDbScope(); using var _ = mocker.WithAutoDIResolver(); var vm = mocker.CreateInstance <MainWindowViewModel>(); Assert.IsTrue(vm.ShowAddCommand.CanExecute(parameter)); vm.ShowAddCommand.Execute(parameter); Assert.IsNotNull(vm.AddItem); Assert.AreEqual(expected, vm.AddItem?.SelectedType); }
public override Resources GetById(int id) { string str = string.Format("select * from AddType where Id=" + id); DataTable dt = helper.GetData(str); if (dt != null && dt.Rows.Count > 0) { DataRow row = dt.Rows[0]; AddType addType = new AddType(); addType.Id = int.Parse(row[0].ToString()); addType.Name = row[1].ToString(); return(addType); } else { return(null); } }
public ActionResult EditType(int id) { var type = dobj.NoteTypes.Where(x => x.ID == id).FirstOrDefault(); if (type == null) { return(HttpNotFound()); } AddType editType = new AddType { ID = type.ID, Name = type.Name, Description = type.Description }; return(View(editType)); }
public void AddPercAll(int figure, AddType type) { switch (type) { case AddType.common: AddPerc(figure, AttributeData.Hp); AddPerc(figure, AttributeData.Mp); AddPerc(figure, AttributeData.AT); AddPerc(figure, AttributeData.AD); AddPerc(figure, AttributeData.MT); AddPerc(figure, AttributeData.MD); break; case AddType.barChart: AddPerc(figure, AttributeData.Hp); AddPerc(figure, AttributeData.Mp); break; case AddType.phy: AddPerc(figure, AttributeData.AT); AddPerc(figure, AttributeData.AD); break; case AddType.mage: AddPerc(figure, AttributeData.MT); AddPerc(figure, AttributeData.MD); break; case AddType.allA: for (int i = 0; i < (int)AttributeData.End; i++) { AddPerc(figure, (AttributeData)i); } break; case AddType.resist: for (int i = 0; i < (int)StateTag.End; i++) { AddPerc(figure, (StateTag)i); } break; } }
public static double GetCurrentAndAdd(AddType Type, int Valor) { DateTime Test; switch (Type) { case AddType.Milisegundos: Test = DateTime.Now.AddMilliseconds(Valor); break; case AddType.Segundos: Test = DateTime.Now.AddSeconds(Valor); break; case AddType.Minutos: Test = DateTime.Now.AddMinutes(Valor); break; case AddType.Horas: Test = DateTime.Now.AddHours(Valor); break; case AddType.Dias: Test = DateTime.Now.AddDays(Valor); break; case AddType.Meses: Test = DateTime.Now.AddMonths(Valor); break; case AddType.Años: Test = DateTime.Now.AddYears(Valor); break; default: Test = DateTime.Now.AddSeconds(Valor); break; } TimeSpan span = (TimeSpan)(Test - new DateTime(0x7b2, 1, 1, 0, 0, 0)); return(span.TotalSeconds); }
private void OnGUI() { targetObject = EditorGUILayout.ObjectField( "ParentObject", targetObject, typeof(GameObject), true ) as GameObject; addType = (AddType)EditorGUILayout.EnumPopup("Add Type", addType); guiRigidbody(); guiObjectSync(); guiPickup(); guiBoxCollider(); guiAction(); }
public ActionResult AddType(AddType model) { var emailid = User.Identity.Name.ToString(); Users admin = dbobj.Users.Where(x => x.EmailID == emailid).FirstOrDefault(); if (ModelState.IsValid) { NoteTypes obj = new NoteTypes(); obj.Name = model.TypeName; obj.Description = model.Description; obj.CreatedDate = DateTime.Now; obj.CreaedBy = admin.ID; obj.IsActive = true; dbobj.NoteTypes.Add(obj); dbobj.SaveChanges(); return(RedirectToAction("ManageTypes")); } return(View()); }
public Ad_S1(SqlDataReader _reader) { int _id = (int)_reader["AdID"]; string _typeStr = ((string)_reader["Type"]).ToLower(); string _link = ((string)_reader["Link"]).Trim(); AddType _type = AddType.Invalid; if (_typeStr.Equals("h")) { _type = AddType.Horizontal; } else if (_typeStr.Equals("v")) { _type = AddType.Vertical; } ID = _id; Type = _type; Link = _link; }
protected string TypeName(object value, AddType addType) { Type t = value.GetType(); string fullName = t.AssemblyQualifiedName; switch (addType) { case AddType.Short: return(fullName.Substring(0, fullName.IndexOf(',')) + ", " + t.Assembly.GetName().Name); case AddType.ShortForCurrentAssembly: return((!t.Assembly.Equals(Assembly.GetExecutingAssembly())) ? fullName : fullName.Substring(0, fullName.IndexOf(',')) + ", " + t.Assembly.GetName().Name); default: case AddType.Default: case AddType.Full: return(fullName); } }
/// <summary> /// Adds a file under a Folder ID /// </summary> /// <param name="Name"></param> /// <param name="xIOIn"></param> /// <param name="FolderID"></param> /// <param name="xType"></param> /// <returns></returns> public bool MakeFile(string Name, DJsIO xIOIn, ushort FolderID, AddType xType) { if (!ActiveCheck()) return false; foreach (FileEntry x in xFileDirectory) { if (x.FolderPointer == FolderID && x.Name.ToLower() == Name.ToLower()) { if (xType == AddType.NoOverWrite) return (xActive = false); return x.Replace(xIOIn); } } try { return xAddFile(xIOIn, Name, FolderID); } catch { return (xActive = false); } }
/// <summary> /// Calculates average time between two dates /// </summary> /// <param name="now"><seealso cref="System.DateTime"/></param> /// <param name="span"><seealso cref="System.DateTime"/>, end of span time</param> /// <param name="adder">Type structure that acts as a switcher for what type of add to perform</param> /// <param name="much">How much AddType to add to each element for creating list of data</param> /// <returns>Average DateTime object</returns> public static DateTime Average(this DateTime now, DateTime span, AddType adder, double much) { return GetDateRange(now, span, adder, much).Average(); }
/// <summary> /// Adds a file /// </summary> /// <param name="FileName"></param> /// <param name="FileLocation"></param> /// <param name="xType"></param> /// <returns></returns> public bool AddFile(string FileName, string FileLocation, AddType xType) { FileName.IsValidXboxName(); if (xDrive.ActiveCheck()) return false; DJsIO xIOIn = null; try { xIOIn = new DJsIO(FileLocation, DJFileMode.Open, true); } catch { return (xDrive.xActive = false); } try { FATXReadContents xconts = xRead(); foreach (FATXFileEntry x in xconts.xfiles) { if (x.Name == FileName) { bool xreturn = false; if (xType == AddType.NoOverWrite) return (xDrive.xActive = false); else if (xType == AddType.Inject) xreturn = x.xInject(xIOIn); else xreturn = x.xReplace(xIOIn); return (xreturn & !(xDrive.xActive = false)); } } uint xnew = 0; long xpos = GetNewEntryPos(out xnew); if (xpos == -1) return (xDrive.xActive = false); uint[] blocks = Partition.xTable.GetNewBlockChain(xIOIn.BlockCountFATX(Partition), xnew + 1); if (blocks.Length == 0) return (xDrive.xActive = false); if (!Partition.WriteFile(blocks, ref xIOIn)) return (xDrive.xActive = false); FATXEntry y = new FATXEntry(FileName, blocks[0], (int)xIOIn.Length, xpos, false, ref xDrive); if (!y.xWriteEntry()) return (xDrive.xActive = false); if (xnew > 0) { List<uint> fileblocks = new List<uint>(Partition.xTable.GetBlocks(xStartBlock)); fileblocks.Add(xnew); uint[] xtemp = fileblocks.ToArray(); if (!Partition.xTable.WriteChain(ref xtemp)) return (xDrive.xActive = false); } if (!Partition.xTable.WriteChain(ref blocks)) return (xDrive.xActive = false); if (Partition.WriteAllocTable()) return !(xDrive.xActive = false); return (xDrive.xActive = false); } catch { xIOIn.Close(); return (xDrive.xActive = false); } }
public bool AddFile(string FileName, byte[] fileData, AddType xType) { if (!VariousFunctions.IsValidXboxName(FileName)) return false; if (xDrive.ActiveCheck()) return false; DJsIO xIOIn = null; byte[] b = fileData; xIOIn = new DJsIO(b, true); try { FATXReadContents xconts = xRead(); foreach (FATXFileEntry x in xconts.xfiles) { if (string.Compare(x.Name, FileName, true) == 0) { bool xreturn = false; if (xType == AddType.NoOverWrite) { xIOIn.Close(); return (xDrive.xActive = false); } else if (xType == AddType.Inject) { xreturn = x.xInject(xIOIn); } else { xreturn = x.xReplace(xIOIn); } xIOIn.Close(); return (xreturn & !(xDrive.xActive = false)); } } uint xnew = 0; long xpos = GetNewEntryPos(out xnew); if (xpos == -1) return (xDrive.xActive = false); var count = xIOIn.BlockCountFATX(Partition); uint[] blocks = Partition.xTable.GetNewBlockChain(count, xnew + 1); if (blocks.Length == 0) return (xDrive.xActive = false); if (!Partition.WriteFile(blocks, ref xIOIn)) return (xDrive.xActive = false); FATXEntry y = new FATXEntry(this, FileName, blocks[0], (int)xIOIn.Length, xpos, false, ref xDrive); if (!y.xWriteEntry()) return (xDrive.xActive = false); if (xnew > 0) { var filebx = Partition.xTable.GetBlocks(xStartBlock); List<uint> fileblocks = new List<uint>(filebx); fileblocks.Add(xnew); uint[] xtemp = fileblocks.ToArray(); if (!Partition.xTable.WriteChain(ref xtemp)) return (xDrive.xActive = false); } if (!Partition.xTable.WriteChain(ref blocks)) return (xDrive.xActive = false); if (Partition.WriteAllocTable()) return !(xDrive.xActive = false); return (xDrive.xActive = false); } catch { xIOIn.Close(); return (xDrive.xActive = false); } }
/// <summary> /// Adds a file /// </summary> /// <param name="FileName"></param> /// <param name="FileLocation"></param> /// <param name="xType"></param> /// <returns></returns> /// public bool AddFile(string FileName, string FileLocation, AddType xType) { try { byte[] b = File.ReadAllBytes(FileLocation); if (b != null) { return AddFile(FileName, b, xType); } else { return false; } } catch { return false; } }
/// <summary> /// Gets a range of DateTimes /// </summary> /// <param name="StartingDate">Starting DateTime</param> /// <param name="EndingDate">Ending DateTime</param> /// <param name="add">Type structure that acts as a switcher for what type of add to perform</param> /// <param name="much">How much AddType to add to each element for creating list of data</param> /// <returns>A list of DateTime objects that corresponds in the interval between StartingDate and EndingDate</returns> public static List<DateTime> GetDateRange(this DateTime StartingDate, DateTime EndingDate, AddType add, double much) { if (StartingDate > EndingDate) { return null; } List<DateTime> rv = new List<DateTime>(); DateTime tmpDate = StartingDate; do { rv.Add(tmpDate); tmpDate = tmpDate.Add(AddType.Minutes, much); } while (tmpDate <= EndingDate); return rv; }
private void ImportWorker(IncludeStatus statusToImport, AddAssembly addAssembly, AddType addType, AddTypeForwarder addTypeForwarder, AddMember addMember) { foreach (ThinAssembly assembly in _thinModel.Assemblies.Values) { if (assembly.IncludeStatus == statusToImport) addAssembly(assembly); foreach (ThinTypeForwarder typeForwarder in assembly.TypeForwarders.Values) { if (typeForwarder.IncludeStatus == statusToImport) { // Assembly may not have already been added because they might not have the correct IncludedStatus. addAssembly(assembly); addTypeForwarder(typeForwarder); } } foreach (ThinType type in assembly.Types.Values) { if (type.IncludeStatus == statusToImport) { // Assembly may not have already been added because they might not have the correct IncludedStatus. addAssembly(assembly); addType(type); } foreach (ThinMember member in type.Members.Values) { if (member.IncludeStatus == statusToImport) { // Assembly and Type may not have already been added because they might not have the correct IncludedStatus. addAssembly(assembly); addType(type); addMember(member); } } } } }
/// <summary> /// Adds a file /// </summary> /// <param name="Path"></param> /// <param name="xIOIn"></param> /// <param name="xType"></param> /// <returns></returns> public bool MakeFile(string Path, DJsIO xIOIn, AddType xType) { if (!ActiveCheck()) return false; if (Path == null || Path == "") return (xActive = false); Path = Path.Replace("\\", "/"); if (Path[0] == '/') Path = Path.Substring(1, Path.Length - 1); if (Path[Path.Length - 1] == '/') Path = Path.Substring(0, Path.Length - 1); FolderEntry parent = xGetParentFolder(Path); if (parent == null) return (xActive = false); string file = Path.Split(new char[] { '/' }).LastValue(); if (file == null || file == "") return (xActive = false); FileEntry z = xGetFile(file, parent.FolderPointer); if (z != null && xType == AddType.NoOverWrite) return (xActive = false); if (z == null) { if (xFileDirectory.Count + xFolderDirectory.Count + 1 >= 65535) return (xActive = false); return xAddFile(xIOIn, file, parent.FolderPointer); } else if (xType == AddType.Inject) return z.xInject(xIOIn); else return z.xReplace(xIOIn); }