public EnumerationAttribute(string name, Enumerations enumerations, string selectedEnumeration, bool canBeNull)
 {
     Name = name;
     Enumerations = enumerations;
     SelectedEnumeration = selectedEnumeration;
     CanBeNull = canBeNull;
 }

 protected void ParameterChanged(Enumerations.ManipulationTypes ManipulationType)
 {
     if (DomainSharedModel.ImageManipulationItems.OnInitializeFilters == false)
     {
         DomainSharedModel.ImageManipulationItems.SaveFilter(this);
     }
 }

        /// <summary>
        /// Initializes a new instance of class CodeControl
        /// </summary>
        /// <param name="content">Base64 content of the web resource</param>
        /// <param name="type">Web resource type</param>
        public CodeControl(string content, Enumerations.WebResourceType type)
        {
            InitializeComponent();

            textEditor = new TextEditor
            {
                ShowLineNumbers = true,
                FontSize = 12,
                FontFamily = new System.Windows.Media.FontFamily("Consolas"),
                //Focusable = true,
                //IsHitTestVisible = true
            };

            var wpfHost = new ElementHost
            {
                Child = textEditor,
                Dock = DockStyle.Fill,
                BackColorTransparent = true,
            };

            Controls.Add(wpfHost);

            if (!string.IsNullOrEmpty(content))
            {
                // Converts base64 content to string
                byte[] b = Convert.FromBase64String(content);
                innerContent = System.Text.Encoding.UTF8.GetString(b);
                originalContent = innerContent;
                innerType = type;
            }
        }

 public RegularExpressionAttribute(string friendlyName, string pattern, System.Text.RegularExpressions.RegexOptions options, bool escapeCharacters, Enumerations.Action action = Enumerations.Action.All)
     : base(friendlyName, action)
 {
     Pattern = pattern;
     Options = options;
     EscapeCharacters = escapeCharacters;
 }

 public static void ChatMessage(Int32 id, Int32 sender, String msg, Enumerations.MessageType type)
 {
     if (Data.TempPlayers.ContainsKey(sender) && Data.Players.ContainsKey(sender)) {
         using (var buffer = new DataBuffer()) {
         buffer.WriteInt32((Int32)Packets.Server.ChatMessage);
         buffer.WriteByte((Byte)type);
             if (Data.TempPlayers[sender].InGame) {
                 switch (type) {
                     case Enumerations.MessageType.System:
                     buffer.WriteString(String.Format("<SYSTEM> {0}", msg));
                     break;
                     case Enumerations.MessageType.Error:
                     buffer.WriteString(String.Format("<ERROR> {0}", msg));
                     break;
                     case Enumerations.MessageType.World:
                     buffer.WriteString(String.Format("[W] {0}: {1}", Data.Players[sender].Characters[Data.TempPlayers[sender].CurrentCharacter].Name, msg));
                     break;
                     case Enumerations.MessageType.Map:
                     buffer.WriteString(String.Format("[S] {0}: {1}", Data.Players[sender].Characters[Data.TempPlayers[sender].CurrentCharacter].Name, msg));
                     break;
                     case Enumerations.MessageType.Emote:
                     buffer.WriteString(String.Format("{0} {1}", Data.Players[sender].Characters[Data.TempPlayers[sender].CurrentCharacter].Name, msg));
                     break;
                 }
             }
             SendDataTo(id, buffer);
         }
     }
 }

    private static Player CreateWarrior(Player newPlayer, string playerName, Enumerations.Gender M_F)
    {
        newPlayer.PlayerName = playerName;
        newPlayer.CharClass = Enumerations.CharClass.Warrior;
        newPlayer.Class = new WarriorClass();
        newPlayer.Gender = M_F;
        newPlayer.IDPlayer = GetLastPlayerID();

        newPlayer.PhysicalDMG = 15;
        newPlayer.MagicDMG = 5;
        newPlayer.MoveSpeed = 20;
        newPlayer.JumpForce = 5;

        newPlayer.PhysDMGMultiplication = 1;
        newPlayer.MagicDMGMultiplication = 1;

        newPlayer.CurrentSceneName = "LEVEL_1";
        newPlayer.PosX = 179.5f;
        newPlayer.PosY = 5.6f;
        newPlayer.PosZ = 10.3f;

        newPlayer.MaxHealth = 110;
        newPlayer.CurrentHealth = 110;
        newPlayer.MaxMana = 80;
        newPlayer.CurrentMana = 80;

        newPlayer.PlayerLvl = 1;
        newPlayer.Experience = 550;     //ZA DEBUG

        newPlayer.PathToSave = Application.dataPath + "\\Saves\\" + newPlayer.PlayerName + "_" + newPlayer.IDPlayer + ".save";
        return SerializePlayerToDat(newPlayer);
    }

 public UserContext(string _nomeusuario, string _userid, Enumerations.TipoPerfil _tipoPerfil, string _computador)
 {
     this.NomeUsuario = _nomeusuario;
     this.UserID = _userid;
     this.TipoPerfil = _tipoPerfil;
     this.NomeComputador = _computador;
 }

 public SocialSecurityAttribute(string friendlyName, bool isClearNumber, Enumerations.Action action = Enumerations.Action.All)
     : base(friendlyName, Constants.RegularExpressionPatterns.SocialSecurity, System.Text.RegularExpressions.RegexOptions.None, false, action)
 {
     if (isClearNumber)
         Pattern = Constants.RegularExpressionPatterns.SocialSecurity_Clear;
     else
         Pattern = Constants.RegularExpressionPatterns.SocialSecurity;
 }

        /// <summary>
        /// Initializes a new instance of class ImageControl
        /// </summary>
        /// <param name="content">Base64 content of the web resource</param>
        /// <param name="type">Web resource type</param>
        public ImageControl(string content, Enumerations.WebResourceType type)
        {
            InitializeComponent();

            innerType = type;
            originalContent = content;
            innerContent = content;
        }

 /// <summary>
 ///   Date: 10/16/2011
 ///   Adds a lock on behalf of a transaction to the active locks.
 /// </summary>
 /// <param name = "transactionId">The transaction id.</param>
 /// <param name = "operationMode">The operation mode.</param>
 /// <remarks>
 ///   Side effects: the new lock is added to the table entry
 /// </remarks>
 public void AddToActiveLocks(int transactionId, Enumerations.OperationMode operationMode)
 {
     Lock lockToAdd = new Lock(transactionId, operationMode);
     Lock result =
         ActiveLocks.Find(matching => matching.TransactionId == transactionId && matching.Mode == operationMode);
     if (result == null)
         ActiveLocks.Add(lockToAdd);
 }

 public ZipCodeAttribute(string friendlyName, bool isClear, Enumerations.Action action = Enumerations.Action.All)
     : base(friendlyName, Constants.RegularExpressionPatterns.ZipCode, System.Text.RegularExpressions.RegexOptions.None, false, action)
 {
     IsClear = isClear;
     if (IsClear)
         Pattern = Constants.RegularExpressionPatterns.ZipCode_Clear;
     else
         Pattern = Constants.RegularExpressionPatterns.ZipCode;
 }

        public byte[] ExportTask(List<TaskItem> taskItems, Enumerations.ContentType contentType)
        {
            var xmlSerializer = new XmlSerializer(typeof(List<TaskItem>));

            MemoryStream memoryStream = new MemoryStream();
            xmlSerializer.Serialize(memoryStream, taskItems);

            return memoryStream.GetBuffer();
        }

 public void Mod(Enumerations.SysInfoType sysInfoType, string content)
 {
     SysInfo model = Get(sysInfoType);
     model.Attach();
     model.Content = content;
     model.ModTime = DateTime.Now;
     model.Detach();
     Update(model);
 }

 public List<Widget> GetAllWidgets(Enumerations.WidgetType widgetType)
 {
     return this.GetAllWidgets().Where(w => w.WidgetType == (int)widgetType).ToList();
     //return AspectF.Define
     //    .CacheList<Widget, List<Widget>>(_cacheResolver, CacheKeys.WidgetKeys.WidgetsByType((int)widgetType),
     //    w => CacheKeys.WidgetKeys.Widget(w.ID))
     //    .Return<List<Widget>>(() =>
     //        _database.GetList<Widget, Enumerations.WidgetTypeEnum>(widgetType, CompiledQueries.WidgetQueries.GetAllWidgets_ByWidgetType));
 }

 /// <summary>
 ///   10/17/2011
 ///   Initializes a new instance of the <see cref = "Operation" /> class.
 /// </summary>
 /// <param name = "mode">The operation mode.</param>
 /// <param name = "transId">The ID of the transaction on whose behalf the operation is created</param>
 /// <param name = "dataId">The index of the data item the operation operates on (or a sentinel value in case its a begin/commit/abort op)</param>
 /// <param name = "newValue">The new value to write in case the operation is a write op.</param>
 /// <param name = "ro">Whether the transaction issuing the operation is a read only transaction - used for MVCC</param>
 /// <param name = "ts">The timestamp of the operation.</param>
 public Operation(Enumerations.OperationMode mode, int transId, int dataId = -1, int newValue = -1,
     bool ro = false, int ts = 0)
 {
     opMode = mode;
     transactionNumber = transId;
     dataItem = dataId;
     this.newValue = newValue;
     readOnly = ro;
     timeStamp = ts;
 }

 public static void AddCharacter(String name, Int32 pclass, Enumerations.Gender gender)
 {
     using (var buffer = new DataBuffer()) {
         buffer.WriteInt32((Int32)Packets.Client.AddCharacter);
         buffer.WriteString(name);
         buffer.WriteInt32(pclass);
         buffer.WriteByte((Byte)gender);
         SendData(buffer);
     }
 }

 public static void ChatMessageWorld(Int32 sender, String msg, Enumerations.MessageType type)
 {
     for (var i = 0; i < Data.Players.Count; i++) {
         if (Data.Players.ContainsKey(Data.Players.ElementAt(i).Key)) {
             var key = Data.Players.ElementAt(i).Key;
             if (Data.TempPlayers.ContainsKey(key)) {
                 if (Data.TempPlayers[key].InGame) Send.ChatMessage(key, sender, msg, type);
             }
         }
     }
 }

 public List<Widget> GetWidgetList(string username, Enumerations.WidgetType widgetType)
 {            
     var userGuid = this.GetUserGuidFromUserName(username);
     var userRoles = this.userRepository.GetRolesOfUser(userGuid);
     var widgets = this.widgetRepository.GetAllWidgets(widgetType);
     if (userRoles.Count > 0)
         return widgets.Where(w => this.widgetsInRolesRepository.GetWidgetsInRolesByWidgetId(w.ID)
             .Exists(wr => userRoles.Exists(role => role.RoleId == wr.AspNetRole.RoleId))).ToList();
     else
         return widgets;
 }

 public List<Ability> GetAbilitys(Enumerations.CharClass charClass, int level)
 {
     switch (charClass)
     {
         case Enumerations.CharClass.Warrior:
             return allWarriorAbilitys[level];
         case Enumerations.CharClass.Mage:
             return allMageAbilitys[level];
         default:
             return null;
     }
 }

 public static void Kill(Enumerations.Events.Kills enumCase)
 {
     switch (Manage.CurrentAnnouncer)
     {
         case Enumerations.SoundPacks.Portal2:
             Portal2.Kills(enumCase);
             break;
         case Enumerations.SoundPacks.StanlyParable:
             StanleyParable.Kills(enumCase);
             break;
     }
 }