/// <summary>
 /// Analyses last char of password and removes all chars which are located on same phone key.
 /// </summary>
 /// <returns type="System.Char[]">Array of chars.</returns>
 public override char[] GetChars(Generator generator, Word password, char[] charsList)
 {
     ValidateInput(generator, password, charsList);
     if (charsList.Length == 0) return charsList;
     // Keep only letters and numbers.
     var chars = charsList.Intersect(charsets.Chars["Letnums"]);
     // Limit if this is second+ letter only.
     if (password.Chars.Length > 0)
     {
         // Get last char.
         var lastChar = password.Chars.Last();
         // Route thru GSM Phone keys.
         for (int i = 0; i == 9; i++)
         {
             char[] keys = charsets.Chars["PhoneKey" + i];
             // If current key contains last char of password then...
             if (keys.Contains(lastChar))
             {
                 // Remove all chars located on same key.
                 chars = chars.Intersect(keys);
                 break;
             }
         }
     }
     charsList = chars.ToArray();
     ValidateOutput(generator, password, charsList);
     return charsList;
 }

 /// <summary>
 ///     Create new ridge generator with user-supplied source. Usually one would use this with <see cref="ValueNoise" /> or
 ///     gradient noise with less dimensions, but
 ///     some weird effects may be achieved with other generators.
 /// </summary>
 /// <param name="source">noise source</param>
 public RidgeNoise(Generator source)
     : base(source)
 {
     Offset = 1;
     Gain = 2;
     m_exponent = 1;
 }

        public override void EmitCode(Generator generator, int depth, int ident)
        {
            if ( String.IsNullOrEmpty( GetName() ) )
                return;

            INode returntype;
            bool constness, pointer;

            string types = base.ResolveType( 1, out returntype, out constness, out pointer );

            types = generator.ResolveType( types, constness, pointer, true, false );

            generator.EmitLine( "public enum " + name + " : " + EnumShortCodes[types], depth );
            generator.EmitLine( "{", depth );

            foreach( INode child in children )
            {
                if ( child is EnumConstantNode )
                {
                    generator.EmitLine( String.Format( "{0} = {1},", child.GetName(), child.GetAttribute( "value" ) ), depth + 1 );
                }
            }

            generator.EmitLine( "};", depth );
            generator.EmitLine( "", depth );
        }

 // Use this for initialization
 void Start()
 {
     g = GameObject.Find("Main Camera").GetComponent<Generator>();
     var t = GetComponent<Renderer>().material;
     t.SetFloat("X_Curvature", g.sindelta * 0.005f);
     t.SetFloat("Y_Curvature", g.cosdelta * 0.005f);
 }

		///<summary>
		/// Create new translation
		///</summary>
		///<param name="source">Source generator</param>
		///<param name="x">Translate amount along X axis</param>
		///<param name="y">Translate amount along Y axis</param>
		///<param name="z">Translate amount along Z axis</param>
		public Translate(Generator source, float x, float y, float z)
		{
			m_source = source;
			m_z = z;
			m_y = y;
			m_x = x;
		}

 /// <summary>
 /// Analyses type of last char (volve or consonant) and removes all chars of same type.
 /// This creates <volve>,<consonant>,<volve>,<consonant>,... password.
 /// </summary>
 /// <returns type="System.Char[]">Array of chars.</returns>
 public override char[] GetChars(Generator generator, Word password, char[] charsList)
 {
     ValidateInput(generator, password, charsList);
     if (charsList.Length == 0) return charsList;
     // Keep only proper chars (volves and consonants).
     var chars = charsList.Intersect(charsets.Chars["Letters"]);
     // If password already contains some chars then...
     if (password.Chars.Length > 0)
     {
         // If last character is volve then...
         if (charsets.Chars["Volves"].Contains(password.Chars.Last()))
         {
             // Keep only consonants.
             chars = chars.Intersect(charsets.Chars["Consonants"]);
         }
         else
         {
             // Keep only volves.
             chars = chars.Intersect(charsets.Chars["Volves"]);
         }
     }
     charsList = chars.ToArray();
     ValidateOutput(generator, password, charsList);
     return charsList;
 }

		/// <summary>
		/// Clears the pen cache
		/// </summary>
		/// <remarks>
		/// This is useful if you are using the <see cref="Cached"/> method to cache pens and want to clear it
		/// to conserve memory or resources.
		/// </remarks>
		/// <param name="generator">Generator to clear the pen cache for</param>
		public static void ClearCache (Generator generator = null)
		{
			var cache = generator.Cache<PenKey, Pen> (cacheKey);
			lock (cache) {
				cache.Clear ();
			}
		}

		protected RadioMenuItem (Generator generator, Type type, RadioMenuItem controller, bool initialize = true)
			: base (generator, type, false)
		{
			Handler.Create (controller);
			if (initialize)
				Initialize ();
		}

 public virtual void ValidateOutput(Generator generator, Word password, char[] chars)
 {
     if (chars.Length == 0)
     {
         password.AppendLog("Error: '{0}' filter removed all chars from list.\r\n", FilterName);
     }
 }

        public void ParseTracker()
        {
            var generator = new Generator();
            generator.Settings.ContextNaming = ContextNaming.Preserve;
            generator.Settings.EntityNaming = EntityNaming.Singular;
            generator.Settings.RelationshipNaming = RelationshipNaming.ListSuffix;
            generator.Settings.TableNaming = TableNaming.Singular;

            var selector = GetDatabaseSchema("Tracker");
            Assert.IsNotNull(selector);

            EntityContext entityContext = generator.Generate(selector);

            Assert.IsNotNull(entityContext);

            var settings = new XmlWriterSettings { Indent = true };
            var serializer = new XmlSerializer(typeof(EntityContext));

            using (var writer = XmlWriter.Create(@"..\..\Tracker.Generated.xml", settings))
                serializer.Serialize(writer, entityContext);

            string contextDirectory = @"..\..\..\Tracker.Core";
            string mappingDirectory = @"..\..\..\Tracker.Core\Mapping";

            Synchronizer.UpdateFromSource(entityContext, contextDirectory, mappingDirectory);

            using (var writer = XmlWriter.Create(@"..\..\Tracker.Updated.xml", settings))
                serializer.Serialize(writer, entityContext);
        }

        static void Main(string[] args)
        {
            // Flag to indicate if we should write a report about every decision we make:
            var report = false;
            // Flag to indicate if we should launch the installer integrity tester at the end:
            var testIntegrity = false;
            // Flag to indicate if we should include all feature-unassigned files in FW_Core:
            var addOrphans = false;

            foreach (var arg in args)
            {
                switch (arg.ToLowerInvariant())
                {
                    case "report":
                        report = true;
                        break;
                    case "check":
                        testIntegrity = true;
                        break;
                    case "addorphans":
                        addOrphans = true;
                        break;
                }
            }
            var gen = new Generator(report, addOrphans, testIntegrity);
            gen.Run();
        }

		public GeneratorContext(Generator g)
		{
			previous = Generator.Current;
			previousValidate = Generator.ValidateGenerator;
			Generator.Initialize(g);
			Eto.Generator.ValidateGenerator = g;
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="Eto.Forms.Window"/> class.
		/// </summary>
		/// <param name="generator">Generator to create the handler instance</param>
		/// <param name="type">Type of interface to create for the handler, must implement <see cref="IWindow"/></param>
		/// <param name="initialize"><c>true</c> to initialize the handler, false if the subclass will initialize</param>
		protected Window(Generator generator, Type type, bool initialize = true)
			: base(generator, type, false)
		{
			if (initialize)
				Initialize();
			HandleEvent(ClosedEvent);
		}

 ///<summary>
 /// Create new scaling
 ///</summary>
 ///<param name="source">Source generator</param>
 ///<param name="x">Scale amount along X axis</param>
 ///<param name="y">Scale amount along Y axis</param>
 ///<param name="z">Scale amount along Z axis</param>
 public Scale(Generator source, float x, float y, float z)
 {
     m_Source = source;
     m_Z = z;
     m_Y = y;
     m_X = x;
 }

		protected Application(Generator g, Type type, bool initialize = true)
				: base(g, type, initialize)
		{
			Application.Instance = this;
			handler = (IApplication)base.Handler;
			Generator.Initialize(g); // make everything use this by default
		}

		public override ToolItem GenerateToolBarItem(Generator generator, ToolBarTextAlign textAlign)
		{
			var tbb = new SeparatorToolItem(generator) { Type = ToolBarType };
			if (!string.IsNullOrEmpty (ToolBarItemStyle))
				tbb.Style = ToolBarItemStyle;
			return tbb;
		}

		public override MenuItem Generate(Generator generator)
		{
			var mi = new SeparatorMenuItem(generator);
			if (!string.IsNullOrEmpty(MenuItemStyle))
				mi.Style = MenuItemStyle;
			return mi;
		}

        public void When_changing_only_single_bit_then_the_id_is_generated_correctly()
        {
            var numberOfGenerators = Math.Pow(2, Generator.NumberOfGeneratorIdBits);
            var target = new byte[8];
            var generator = new Generator((short)(numberOfGenerators - 1), DateTime.Today);

            generator.WriteValuesToByteArray(target, 4398046511103, 8191);
            Assert.Equal(new string('1', 64), GetString(target));

            generator.WriteValuesToByteArray(target, 4398046511103, 8190);
            Assert.Equal(new string('1', 63) + "0", GetString(target));

            generator.WriteValuesToByteArray(target, 4398046511102, 8191);
            Assert.Equal(
                new string('1', Generator.NumberOfTimeBits - 1) + "0" + new string('1', 64 - Generator.NumberOfTimeBits),
                GetString(target));

            generator = new Generator((short)(numberOfGenerators - 2), DateTime.Today);
            generator.WriteValuesToByteArray(target, 4398046511103, 8191);
            Assert.Equal(
                new string('1', 63 - Generator.NumberOfSequenceBits) + "0" + new string('1', Generator.NumberOfSequenceBits),
                GetString(target));

            for (int i = 0; i < numberOfGenerators; i++)
            {
                generator = new Generator((short)i, DateTime.Today);
                generator.WriteValuesToByteArray(target, 0, 0);
                Assert.Equal(new string('0', Generator.NumberOfTimeBits), GetString(target).Substring(0, Generator.NumberOfTimeBits));
                Assert.Equal(new string('0', Generator.NumberOfSequenceBits), GetString(target).Substring(64 - Generator.NumberOfSequenceBits, Generator.NumberOfSequenceBits));

                var m = Convert.ToString(i, 2).PadLeft(Generator.NumberOfGeneratorIdBits, '0');
                Assert.Equal(m, GetString(target).Substring(Generator.NumberOfTimeBits, Generator.NumberOfGeneratorIdBits));
            }
        }

 /// <summary>
 /// Analyse password and make suer that all char types set for use are used inside password.
 /// </summary>
 /// <returns type="System.Char[]">Array of chars.</returns>
 public override char[] GetChars(Generator generator, Word password, char[] charsList)
 {
     ValidateInput(generator, password, charsList);
     if (charsList.Length == 0) return charsList;
     Preset p = generator.Preset;
     // How many chars left to generate.
     int leftChars = p.PasswordLength - password.Chars.Length;
     bool haveUppercase = p.UseUppercase && password.Chars.Intersect(p.CharsUppercase).Count() > 0;
     bool haveLowercase = p.UseLowercase && password.Chars.Intersect(p.CharsLowercase).Count() > 0;
     bool haveNumbers = p.UseNumbers && password.Chars.Intersect(p.CharsNumbers).Count() > 0;
     bool haveSymbols = p.UseSymbols && password.Chars.Intersect(p.CharsSymbols).Count() > 0;
     bool haveExtra = p.UseExtra && p.CharsExtra.Length > 0 && password.Chars.Intersect(p.CharsExtra).Count() > 0;
     // How many char types are not used yet.
     int tc = 0;
     if (p.UseUppercase && !haveUppercase) tc++;
     if (p.UseLowercase && !haveLowercase) tc++;
     if (p.UseNumbers && !haveNumbers) tc++;
     if (p.UseSymbols && !haveSymbols) tc++;
     if (p.UseExtra && !haveExtra) tc++;
     // if no space for random generation left then...
     if (leftChars == tc)
     {
         Preset preset = generator.Preset.Copy();
         //Disable chars which were used
         if (preset.UseUppercase && haveUppercase) preset.UseUppercase = false;
         if (preset.UseLowercase && haveLowercase) preset.UseLowercase = false;
         if (preset.UseNumbers && haveNumbers) preset.UseNumbers = false;
         if (preset.UseSymbols && haveSymbols) preset.UseSymbols = false;
         if (preset.UseExtra && haveExtra) preset.UseExtra = false;
         // Generate new chars list.
         charsList = preset.GetChars().Intersect(charsList).ToArray();
     }
     ValidateOutput(generator, password, charsList);
     return charsList;
 }

 /// <summary>
 /// Creates a new fractal noise, supplying your own source generator
 /// </summary>
 /// <param name="source">source noise</param>
 protected FractalNoiseBase(Generator source)
 {
     m_Noise = source;
     Lacunarity = 2.17f;
     OctaveCount = 6;
     Frequency = 1;
 }