public BigPointsAwardedEvent(Int32 score, Single x, Single y, Boolean increasesMultiplier)
 {
     this.Score = score;
     this.X = x;
     this.Y = y;
     this.IncreasesMultiplier = increasesMultiplier;
 }

 public static void Encode(Stream stream, Single val)
 {
     byte[] buf = BitConverter.GetBytes(val);
     if (EncodingHelpers.Endian != EndianTypes.LittleEndian)
         EncodingHelpers.ReverseBytes(buf);
     stream.Write(buf, 0, buf.Length);
 }

		/// <summary>
		/// Plays a sound.
		/// </summary>
		/// <param name="id">The ChannelId identifing the SoundManger playing the sound and the channel number.</param>
		/// <param name="buffer">A SecondaryBuffer containing the sound to be playing.</param>
		/// <param name="frequencymultiplier">The multiplier applied the sound to change its pitch. 1.0f for no change.</param>
		/// <param name="looping">Whether the sound should loop automatically until stopped.</param>
		/// <param name="volume">The volume level of the sound.</param>
		public void Play(ChannelId id, SecondaryBuffer buffer, Single frequencymultiplier, Boolean looping, Int32 volume)
		{
			if (buffer == null) throw new ArgumentNullException("buffer");
			if (volume > (Int32)Volume.Max || volume < (Int32)Volume.Min) throw new ArgumentOutOfRangeException("volume");

			Stop();

			m_usingid = id;
			m_buffer = buffer;

			BufferPlayFlags flags = (looping == true) ? BufferPlayFlags.Looping : BufferPlayFlags.Default;

			m_buffer.Frequency = (Int32)(m_buffer.Frequency * frequencymultiplier);
			m_buffer.SetCurrentPosition(0);
			m_buffer.Pan = (Int32)Pan.Center;
			m_buffer.Volume = volume;

			m_playflags = flags;

			try
			{
				m_buffer.Play(0, flags);
			}
			catch { }
		}

        public override void UnSerialize(XElement elem)
        {
            FirstStateSlot = (Byte)(Int32)elem.Attribute("slot");

            var autoComp = elem.Element("AutoComplete");
            if (autoComp != null && !autoComp.IsEmpty)
                AutoComplete = (Int32)autoComp != 0;

            var autoCompDist = elem.Element("AutoCompleteDistance");
            if (autoCompDist != null && !autoCompDist.IsEmpty)
                AutoCompleteDistance = (Single)autoCompDist;

            var autoFail = elem.Element("AutoFail");
            if (autoFail != null && !autoFail.IsEmpty)
                AutoFail = (Int32)autoFail != 0;

            var autoFailDist = elem.Element("AutoFailDistance");
            if (autoFailDist != null && !autoFailDist.IsEmpty)
                AutoFailDistance = (Single)autoFailDist;

            var contId = elem.Element("ContinentCBID");
            if (contId != null && !contId.IsEmpty)
                ContinentId = (Int32)contId;

            var laps = elem.Element("Laps");
            if (laps != null && !laps.IsEmpty)
                Laps = (Int32)laps;

            foreach (var el in elem.Elements("GenericTargetCOID"))
                if (TargetCount < 10)
                    GenericTargets[TargetCount++] = (Int64)el;
        }

 public PanelDragEvent(Single positionX, Single positionY, Single deltaX, Single deltaY)
 {
     this.PositionX = positionX;
     this.PositionY = positionY;
     this.DeltaX = deltaX;
     this.DeltaY = deltaY;
 }

 public NumericDialog(Single currentValue)
     : this()
 {
     this.numericUpDown1.Maximum = decimal.MaxValue;
     this.numericUpDown1.Minimum = decimal.MinValue;
     this.numericUpDown1.Value = Convert.ToDecimal(currentValue);
 }

 public ColourChanger()
 {
     _current = RandomGenerator.Default.GetRandomColour();
     _target = RandomGenerator.Default.GetRandomColour();
     _colourChangeTime = RandomGenerator.Default.GetRandomSingle(3f, 10f);
     _timer = _colourChangeTime;
 }

 public RectangleF(Single x, Single y, Single width, Single height)
 {
     this.X = x;
     this.Y = y;
     this.Width = width;
     this.Height = height;
 }

 public QuaternionReading(Single w, Single x, Single y, Single z)
 {
     W = w;
     X = x;
     Y = y;
     Z = z;
 }

 /// <summary>
 /// Asserts that this vector should have the specified components.
 /// </summary>
 /// <param name="x">The expected x-component.</param>
 /// <param name="y">The expected y-component.</param>
 /// <param name="z">The expected z-component.</param>
 /// <returns>The result object.</returns>
 public Vector3Result ShouldBe(Single x, Single y, Single z)
 {
     Assert.AreEqual(x, Value.X, delta);
     Assert.AreEqual(y, Value.Y, delta);
     Assert.AreEqual(z, Value.Z, delta);
     return this;
 }

        protected internal override void Process(Single deltaSeconds, ref ParticleIterator iterator)
#endif
        {
            Single deltaStrength = this.Strength * deltaSeconds;

            Single deltaGravityX = this.GravityVector.X * deltaStrength;
            Single deltaGravityY = this.GravityVector.Y * deltaStrength;
            Single deltaGravityZ = this.GravityVector.Z * deltaStrength;

            var particle = iterator.First;

            do
            {
#if UNSAFE
                particle->Velocity.X += deltaGravityX;
                particle->Velocity.Y += deltaGravityY;
                particle->Velocity.Z += deltaGravityZ;
#else
                particle.Velocity.X += deltaGravityX;
                particle.Velocity.Y += deltaGravityY;
                particle.Velocity.Z += deltaGravityZ;
#endif
            }
#if UNSAFE
            while (iterator.MoveNext(&particle));
#else
            while (iterator.MoveNext(ref particle));
#endif
        }

 public DrawVWall(Single newPosX, Single newPosY, Single newWidth, Single newHeight)
 {
     posX = newPosX;
     posY = newPosY;
     width = newWidth;
     height = newHeight;
 }

		internal static object DBSpecific(string key, Single single)
		{
			object retVal = null;
			DatabaseSpecific dext = new DatabaseSpecific();

			if (key == DatabaseSpecific.EXTENDED_PROPERTIES) 
			{
				if (single is IColumn) 
				{
					retVal = dext.ExtendedProperties(single as IColumn);
				}
				else if (single is ITable) 
				{
					retVal = dext.ExtendedProperties(single as ITable);
				}
				else if (single is IProcedure) 
				{
					retVal = dext.ExtendedProperties(single as IProcedure);
				}
				else if (single is IView) 
				{
					retVal = dext.ExtendedProperties(single as IView);
				}
			}
			
			return retVal;
		}

        public void UpdateRow(CategoryEntity category, Single fontSize, SizeF imageViewSize)
        {
            LabelView.Text = category.Name;
            
            if (category.Picture != null && category.Picture != "BsonNull")
            {
                try
                {
                    var webClient = new WebClient();
                    webClient.DownloadDataCompleted += (s, e) =>
                    {
                        var bytes = e.Result; // get the downloaded data
                            ImageView.Image = ImageHandler.BytesToImage(bytes); // convert the data to an actual image
                    };
                    webClient.DownloadDataAsync(new Uri(category.Picture));
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Something went wrong loading image for cell..." + ex.Message);
                }
                
            }
     
            LabelView.Font = UIFont.FromName("HelveticaNeue-Bold", fontSize);

            ImageView.Frame = new RectangleF(0, 0, imageViewSize.Width, imageViewSize.Height);
            // Position category label below image
            LabelView.Frame = new RectangleF(0, (float) ImageView.Frame.Bottom+60, imageViewSize.Width, (float) (ContentView.Frame.Height - ImageView.Frame.Bottom));
        }

 internal RotateTransform(Single x, Single y, Single z, Single angle)
 {
     _x = x;
     _y = y;
     _z = z;
     _angle = angle;
 }

        /// <summary>
        /// Plays the specified song.
        /// </summary>
        /// <param name="song">The song to play.</param>
        /// <param name="volume">A value from 0.0 (silent) to 1.0 (full volume) representing the song's volume.</param>
        /// <param name="pitch">A value from -1.0 (down one octave) to 1.0 (up one octave) indicating the song's pitch adjustment.</param>
        /// <param name="pan">A value from -1.0 (full left) to 1.0 (full right) representing the song's panning position.</param>
        /// <param name="loop">A value indicating whether to loop the song.</param>
        /// <returns>true if the song began playing successfully; otherwise, false.</returns>
        public override Boolean Play(Song song, Single volume, Single pitch, Single pan, Boolean loop = false)
        {
            Contract.EnsureNotDisposed(this, Disposed);
            Contract.Require(song, "song");

            return PlayInternal(song, volume, pitch, pan, loop);
        }

        private static void RenderVerticalRanges(this Graphics Graphics, Rectangle ClientRectangle, Point Start, Int32 Length, Single MinimumValue, Single MaximumValue, LinearVerticalRangeDef Range)
        {
            if (!Range.Enabled)
                return;

            var valueAbsolute = Math.Abs(MaximumValue - MinimumValue);
            var scaleAdjustment = Math.Abs(Length / valueAbsolute);
            var scaleLength = (Length * scaleAdjustment);
            var rangeLength = Math.Abs((Range.End - Range.Start) * scaleAdjustment);
            var rangeStart = (Range.Start) * scaleAdjustment;
            var rangeEnd = (Range.End) * scaleAdjustment;

            Graphics.SetClip(ClientRectangle);
            Graphics.SmoothingMode = SmoothingMode.HighQuality;
            Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

            var x = (Single)Start.X;
            var y = (Single)((Start.Y + ((MaximumValue - Range.End) * scaleAdjustment)));
            var width = (Single)Range.Width;
            var height = (Single)rangeLength;

            using (var solidBrush = new SolidBrush(Range.ForeColor)) {
                Graphics.FillRectangle(solidBrush, new RectangleF(x, y, width, height));
            }
        }

 public MinimumBoundingBox(Single minX, Single minY, Single maxX, Single maxY)
 {
     this.minX = minX;
     this.minY = minY;
     this.maxX = maxX;
     this.maxY = maxY;
 }

 public void Add(Single value)
 {
     if(Words.Count <= 14)
     {
         Words.Add(new Word(value));
     }
 }

        protected internal override void Process(Single deltaSeconds, ref ParticleIterator iterator)
#endif
        {
            Single initialForceDeltaX = this.InitialForce.X * deltaSeconds;
            Single initialForceDeltaY = this.InitialForce.Y * deltaSeconds;
            Single initialForceDeltaZ = this.InitialForce.Z * deltaSeconds;

            Single finalForceDeltaX = this.FinalForce.X * deltaSeconds;
            Single finalForceDeltaY = this.FinalForce.Y * deltaSeconds;
            Single finalForceDeltaZ = this.FinalForce.Z * deltaSeconds;

            var particle = iterator.First;

            do
            {
#if UNSAFE
                particle->Velocity.X += initialForceDeltaX + ((finalForceDeltaX - initialForceDeltaX) * particle->Age);
                particle->Velocity.Y += initialForceDeltaY + ((finalForceDeltaY - initialForceDeltaY) * particle->Age);
                particle->Velocity.Z += initialForceDeltaZ + ((finalForceDeltaZ - initialForceDeltaZ) * particle->Age);
#else
                particle.Velocity.X += initialForceDeltaX + ((finalForceDeltaX - initialForceDeltaX) * particle.Age);
                particle.Velocity.Y += initialForceDeltaY + ((finalForceDeltaY - initialForceDeltaY) * particle.Age);
                particle.Velocity.Z += initialForceDeltaZ + ((finalForceDeltaZ - initialForceDeltaZ) * particle.Age);
#endif
            }
#if UNSAFE
            while (iterator.MoveNext(&particle));
#else
            while (iterator.MoveNext(ref particle));
#endif
        }