예제 #1
0
        public static void AnimateWithAction(this Label label, Command command = null, ScaleType type = ScaleType.After)
        {
            var tapGesture = new TapGestureRecognizer ();
            tapGesture.Tapped += async (sender, args) => {
                switch (type) {
                case ScaleType.First:
                    command?.Execute (null);
                    await label.ScaleTo (0.75, 100, Easing.CubicOut);
                    await label.ScaleTo (1, 100, Easing.CubicIn);
                    break;
                case ScaleType.Midle:
                    await label.ScaleTo (0.75, 100, Easing.CubicOut);
                    command?.Execute (null);
                    await label.ScaleTo (1, 100, Easing.CubicIn);
                    break;
                case ScaleType.After:
                    await label.ScaleTo (0.75, 100, Easing.CubicOut);
                    await label.ScaleTo (1, 100, Easing.CubicIn);
                    command?.Execute (null);
                    break;
                default:
                    break;
                }

            };
            label.GestureRecognizers.Add (tapGesture);
        }
예제 #2
0
        public void InitializeScale(ScaleType scale)
        {
            var scaleFactor = 1;
            switch (scale)
            {
                case ScaleType.TwoX:
                case ScaleType.Hq2x:
                    scaleFactor = 2;
                    break;

                case ScaleType.ThreeX:
                case ScaleType.Hq3x:
                    scaleFactor = 3;
                    break;

                case ScaleType.FourX:
                case ScaleType.Hq4x:
                    scaleFactor = 4;
                    break;

                default:
                    break;
            }
            baseScale = scale;
            screenBuffer = new WriteableBitmap(baseWidth * scaleFactor, baseHeight * scaleFactor, 96, 96, PixelFormats.Bgra32, null);
            updateRegion = new Int32Rect(0, 0, screenBuffer.PixelWidth, screenBuffer.PixelHeight);
            stride = screenBuffer.PixelWidth * 4;
            backBuffer = new uint[baseWidth * baseHeight];
            frontBuffer = new uint[screenBuffer.PixelWidth * screenBuffer.PixelHeight];
            renderWindow.Source = screenBuffer;
        }
예제 #3
0
 public ScaleDecider(MelodyPlayer.Note note, ScaleType scaleType)
 {
     currentScale = CreateScale(note, scaleType);
     currentScaleType = scaleType;
     towerUnderHP = false;
     inTransition = false;
     clickCounter = 0;
     random = new Random();
     SCALE_CHANGE_HP_TRESHOLD = (App.Instance.Model.Tower.MaxHealth - 100) * 0;
 }
예제 #4
0
 /// <summary>
 /// Instanciates a SpriteTextbox. AssetName is the Textbox background assest to load. 
 /// </summary>
 /// <param name="game"></param>
 /// <param name="assetName">Name of background Image to load</param>
 /// <param name="fontName"></param>
 /// <param name="text"></param>
 /// <param name="wrapText"></param>
 /// <param name="scale"></param>
 /// <param name="textScale"></param>
 /// <param name="formFactor"></param>
 public SpriteTextBox(Game game, string assetName, string fontName, string text, bool wrapText, Vector2 scale, Vector2 textScale, ScaleType formFactor, SpriteFont a)
 {
     this.Text = text;
     this.WrapText = wrapText;
     this.TextScale = textScale;
     this.TextOffset = Vector2.Zero;
     this.FontName = fontName;
     this.FormFactor = formFactor;
     this.Font = a;
 }
예제 #5
0
        public PhotoViewDroid(Context context)
            : base(context, null, 0)
        {
            base.SetScaleType(ScaleType.Matrix);
            mAttacher = new PhotoViewDroidAttacher(this);

            if (null != mPendingScaleType) {
                SetScaleType(mPendingScaleType);
                mPendingScaleType = null;
            }
        }
예제 #6
0
        public PhotoViewDroid(Context context, IAttributeSet attr, int defStyle)
            : base(context, attr, defStyle)
        {
            base.SetScaleType(ScaleType.Matrix);
            mAttacher = new PhotoViewDroidAttacher(this);

            if (null != mPendingScaleType) {
                SetScaleType(mPendingScaleType);
                mPendingScaleType = null;
            }
        }
예제 #7
0
	public void ScaleToNormal() {
		if (Time.timeScale >= timeScaleNormal) {
			Time.timeScale = timeScaleNormal;
			return;
		}
		if (scaleType == ScaleType.ScaleUp) return;

		StopScalingTime();
		ScaleTime(timeScaleNormal, timeScaleUpDuration);
		scaleType = ScaleType.ScaleUp;
	}
예제 #8
0
	public void ScaleToSlow() {
		if (Time.timeScale <= timeScaleSlow) {
			Time.timeScale = timeScaleSlow;
			return;
		}
		if (scaleType == ScaleType.ScaleDown) return;

		StopScalingTime();
		ScaleTime(timeScaleSlow, timeScaleDownDuration);
		scaleType = ScaleType.ScaleDown;
	}
예제 #9
0
    public static Texture2D rescaleCenter(Texture2D srcTexture, Vector2 destSize, ScaleType scaleType)
    {
        var srcSize = new Vector2(
            srcTexture.width,
            srcTexture.height);
        var scale = Texture2DHelpers.scaleFactor(
            srcSize,
            destSize,
            scaleType);
        var scaledSize = srcSize * scale;

        // Convert float values to int
        var srcWidth = srcTexture.width;
        var scaledWidth = (int) scaledSize.x;
        var scaledHeight = (int) scaledSize.y;
        var destWidth = (int) destSize.x;
        var destHeight = (int) destSize.y;

        var minX = Helpers.clamp((destWidth - scaledWidth) / 2, 0, destWidth - 1);
        var maxX = destWidth - 1 - minX;
        var minY = Helpers.clamp((destHeight - scaledHeight) / 2, 0, destHeight - 1);
        var maxY = destHeight - 1 - minY;

        var srcPixels = srcTexture.GetPixels();
        var destPixels = new Color[destWidth * destHeight];
        for (var destX=0; destX < destWidth; ++destX) {
            for (var destY=0; destY < destHeight; ++destY) {
                Color destPixel;
                if (destX >= minX && destX <= maxX && destY >= minY && destY <= maxY) {
                    var scaledX = destX - minX;
                    var scaledY = destY - minY;

                    var srcX = (int) (scaledX / scale);
                    var srcY = (int) (scaledY / scale);

                    var srcOffset = srcY * srcWidth + srcX;
                    destPixel = srcPixels[srcOffset];
                } else {
                    destPixel = fillColor;
                }

                var destOffset = destY * destWidth + destX;
                destPixels[destOffset] = destPixel;
            }
        }

        var destTexture = new Texture2D(destWidth, destHeight);
        destTexture.SetPixels(destPixels);
        destTexture.Apply();
        return destTexture;
    }
예제 #10
0
        public SpriteFlatData(string name, Texture2D texture, float width, float height, ScaleType scaleType)
        {
            this.name = name;

            float textureWidth = texture.width;
            float textureHeight = texture.height;
            switch (scaleType) {
                case ScaleType.NONE:
                    this.width = textureWidth;
                    this.height = textureHeight;
                    break;
                case ScaleType.SCALED_WIDTH:
                    this.width = width;
                    this.height = width * textureHeight / textureWidth;
                    break;
                case ScaleType.SCALED_HEIGHT:
                    this.width = height * textureWidth / textureHeight;
                    this.height = height;
                    break;
                case ScaleType.SCALED:
                default:
                    this.width = width;
                    this.height = height;
                    break;
            }
            this.regionWidth = textureWidth;
            this.regionHeight =
                texture.wrapMode == TextureWrapMode.Repeat ?
                this.height * textureWidth / this.width :
                textureHeight
            ;

            Rect region = new Rect(0f, 0f, this.regionWidth, this.regionHeight);
            Vector2 anchor = new Vector2(this.regionWidth / 2, this.regionHeight / 2);

            tk2dRuntime.SpriteCollectionSize size = tk2dRuntime.SpriteCollectionSize.ForTk2dCamera();
            this.data = tk2dRuntime.SpriteCollectionGenerator.CreateFromTexture(texture, size, region, anchor);
            this.data.gameObject.name = String.Format("DataSpriteFlat{0}", name);
        }
예제 #11
0
    public static float scaleFactor(Vector2 srcSize, Vector2 destSize, ScaleType scaleType)
    {
        var scaleX = destSize.x / srcSize.x;
        var scaleY = destSize.y / srcSize.y;
        float scale;
        switch (scaleType) {
        case ScaleType.kCrop:
            scale = Mathf.Max(scaleX, scaleY);
            break;

        case ScaleType.kInside:
            scale = Mathf.Min(scaleX, scaleY);
            break;

        default:
            Debug.LogWarning("unknow scale type");
            scale = 1.0f;
            break;
        }

        return scale;
    }
예제 #12
0
        /// <summary>
        /// Scales an image size, preserving aspect ratio.
        /// </summary>
        /// <param name="sourceSize"></param>
        /// <param name="width">Min or max allowed width. Min/Max controlled by the method parameter</param>
        /// <param name="height">Min or max allowed height. Min/Max controlled by the method parameter</param>
        /// <param name="method"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static Size Scale(this Size sourceSize, int width, int height, ScaleMethod method, ScaleType type)
        {
            if (type == ScaleType.Expand && sourceSize.Height > height && sourceSize.Width > width)
                return sourceSize;

            if (type == ScaleType.Shrink && sourceSize.Height < height && sourceSize.Width < width)
                return sourceSize;

            if (height == 0)
                height = sourceSize.Height;

            if (width == 0)
                width = sourceSize.Width;

            // calculate the two possible scaling factors
            var wAr = (float)width / sourceSize.Width;
            var hAr = (float)height / sourceSize.Height;

            // pick the scaling factor based on the scale method
            var ar = method == ScaleMethod.ToFit ? Math.Min(wAr, hAr) : Math.Max(wAr, hAr);

            return sourceSize.Scale(ar);
        }
예제 #13
0
		internal GridLines_Internal(Panel container, ScaleType scaleType, double[] points, double minimum, double maximum, double thickness, ChartObjectTag tag, Style lineStyle)
			: base(container, scaleType, tag)
		{
			LineStyle = lineStyle;
			Thickness = thickness;
			ReInit(scaleType, points, minimum, maximum);
		}
예제 #14
0
		internal ScalableChartObject(Panel container, ScaleType scaleType, ChartObjectTag tag)
			: base(container, tag)
		{
			ScaleType = scaleType;
		}
예제 #15
0
		public GridScale(ScaleType scaleType, double min, double max)
		{
			_ScaleType = scaleType;
			_Min = min;
			_Max = max;
		}
예제 #16
0
		internal void ReInit(ScaleType scaleTypeX, ScaleType scaleTypeY, double x0, double xN, double y0, double yN, double[,] points)
		{
			ScaleTypeX = scaleTypeX; ScaleTypeY = scaleTypeY;
			X0 = x0; XN = xN; Y0 = y0; YN = yN;
			DataPoints = points;
			Draw();
		}
예제 #17
0
 public StandardPartScaler(Part prefab, Part part, ScaleType scaleType, TweakScale ts) : base(prefab, part, scaleType, ts)
 {
 }
		public override void SetScaleType(ScaleType scale){
			if (scale != escala) {
				throw new AndroidException ("Chingado! Que no le muevas a la escala");
			}

		}
예제 #19
0
		internal virtual void ReInit(ScaleType scaleType, Tuple<double, string>[] points, string dataPointsFormat)
		{
			if (Container.ActualHeight == 0.0 || Container.ActualWidth == 0.0 || points == null) return;
			if (scaleType != ScaleType || points != DataPoints || dataPointsFormat != DataPointsFormat)
			{
				ScaleType = scaleType;
				DataPoints = points;
				DataPointsFormat = dataPointsFormat;
				MyTBs.Clear();
				ClearChartObjectsWithMyTag();
				for (int i = 0; i <= DataPoints.GetUpperBound(0); i++)
				{
					TextBlock tb = new TextBlock() { Tag = Tag };
					MyTBs.Add(tb);
					Container.Children.Add(tb);
				}
			}

			Draw();
		}
        void SetSpaceAndType()
        {
            if (Input.GetKey(ActionKey))
            {
                return;
            }

            if (Input.GetKeyDown(SetMoveType))
            {
                type = TransformType.Move;
            }
            else if (Input.GetKeyDown(SetRotateType))
            {
                type = TransformType.Rotate;
            }
            else if (Input.GetKeyDown(SetScaleType))
            {
                type = TransformType.Scale;
            }

            if (Input.GetKeyDown(SetPivotModeToggle))
            {
                if (pivot == TransformPivot.Pivot)
                {
                    pivot = TransformPivot.Center;
                }
                else if (pivot == TransformPivot.Center)
                {
                    pivot = TransformPivot.Pivot;
                }

                SetPivotPoint();
            }

            if (Input.GetKeyDown(SetCenterTypeToggle))
            {
                if (centerType == CenterType.All)
                {
                    centerType = CenterType.Solo;
                }
                else if (centerType == CenterType.Solo)
                {
                    centerType = CenterType.All;
                }

                SetPivotPoint();
            }

            if (Input.GetKeyDown(SetSpaceToggle))
            {
                if (space == TransformSpace.Global)
                {
                    space = TransformSpace.Local;
                }
                else if (space == TransformSpace.Local)
                {
                    space = TransformSpace.Global;
                }
            }

            if (Input.GetKeyDown(SetScaleTypeToggle))
            {
                if (scaleType == ScaleType.FromPoint)
                {
                    scaleType = ScaleType.FromPointOffset;
                }
                else if (scaleType == ScaleType.FromPointOffset)
                {
                    scaleType = ScaleType.FromPoint;
                }
            }

            if (type == TransformType.Scale)
            {
                space = TransformSpace.Local; //Only support local scale
                if (pivot == TransformPivot.Pivot)
                {
                    scaleType = ScaleType.FromPoint;                                //FromPointOffset can be inaccurate and should only really be used in Center mode if desired.
                }
            }
        }
예제 #21
0
        public LinePlot(Transform plotOriginTransform, float[] x, float[] y, Material plotAxisMat, Material plotLineMat, float[] plotDrawScale, float plotLineWidth = 0.01f, ScaleType plotScaleType = ScaleType.linear, float[] plotXaxis = null, float[] plotYaxis = null)
        {
            scaleType = plotScaleType;
            if (scaleType == ScaleType.log10)
            {
                for (int i = 0; i < y.Length; i++)
                {
                    if (y[i] > 0.0001)
                    {
                        y[i] = Mathf.Log10(y[i]);
                    }
                    else
                    {
                        y[i] = -1000f;
                    }
                }
            }


            if (plotXaxis == null)
            {
                float max = -1e6f;
                float min = 1e6f;
                for (int i = 0; i < x.Length; i++)
                {
                    if (x[i] > max)
                    {
                        max = x[i];
                    }
                    if (x[i] < min)
                    {
                        min = x[i];
                    }
                }
                xaxis = new float[2] {
                    0, max *1.2f
                };
                max = -1e6f;
                min = 1e6f;
                for (int i = 0; i < y.Length; i++)
                {
                    if (y[i] > max)
                    {
                        max = y[i];
                    }
                    if (y[i] < min)
                    {
                        min = y[i];
                    }
                }
                if (min < 0)
                {
                    yaxis = new float[2] {
                        min *1.2f, max * 1.2f
                    }
                }
                ;
                else
                {
                    yaxis = new float[2] {
                        0, max *1.2f
                    }
                };
            }

            xdata     = x;
            ydata     = y;
            origin    = plotOriginTransform;
            axisMat   = plotAxisMat;
            lineMat   = plotLineMat;
            drawScale = plotDrawScale;
            lineWidth = plotLineWidth;

            Redraw();
        }
        /**
           * Controls how the image should be resized or moved to match the size
           * of this ImageView.
           *
           * @param scaleType The desired scaling mode.
           * @attr ref android.R.styleable#ImageView_scaleType
           */
        public override sealed void SetScaleType(ScaleType scaleType)
        {
            if (_mScaleType == scaleType) return;

            _mScaleType = scaleType;

            if (scaleType.Equals(ScaleType.Center) ||
                scaleType.Equals(ScaleType.CenterCrop) ||
                scaleType.Equals(ScaleType.CenterInside) ||
                scaleType.Equals(ScaleType.FitCenter) ||
                scaleType.Equals(ScaleType.FitStart) ||
                scaleType.Equals(ScaleType.FitEnd) ||
                scaleType.Equals(ScaleType.FitXy))
            {
                base.SetScaleType(ScaleType.FitXy);
            }
            else
            {
                base.SetScaleType(scaleType);
            }
            UpdateDrawableAttrs();
            UpdateBackgroundDrawableAttrs(false);
            Invalidate();
        }
예제 #23
0
파일: Scaler.cs 프로젝트: Silenthal/gbemu
 public static void ScaleImage(uint[] inputImage, uint[] outputImage, int baseWidth, int baseHeight, ScaleType baseScale)
 {
     switch (baseScale)
     {
         case ScaleType.Hq2x:
             {
                 Hq2x.hq2x_32(inputImage, outputImage, baseWidth, baseHeight);
                 break;
             }
         case ScaleType.Hq3x:
             {
                 Hq3x.hq3x_32(inputImage, outputImage, baseWidth, baseHeight);
                 break;
             }
         case ScaleType.TwoX:
             {
                 for (int y = 0; y < baseHeight; y++)
                 {
                     for (int x = 0; x < baseWidth; x++)
                     {
                         outputImage[(((y * 2) + 0) * baseWidth * 2) + (x * 2) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 2) + 0) * baseWidth * 2) + (x * 2) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 2) + 1) * baseWidth * 2) + (x * 2) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 2) + 1) * baseWidth * 2) + (x * 2) + 1] = inputImage[(y * baseWidth) + x];
                     }
                 }
                 break;
             }
         case ScaleType.ThreeX:
             {
                 for (int y = 0; y < baseHeight; y++)
                 {
                     for (int x = 0; x < baseWidth; x++)
                     {
                         outputImage[(((y * 3) + 0) * baseWidth * 3) + (x * 3) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 0) * baseWidth * 3) + (x * 3) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 0) * baseWidth * 3) + (x * 3) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 1) * baseWidth * 3) + (x * 3) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 1) * baseWidth * 3) + (x * 3) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 1) * baseWidth * 3) + (x * 3) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 2) * baseWidth * 3) + (x * 3) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 2) * baseWidth * 3) + (x * 3) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 3) + 2) * baseWidth * 3) + (x * 3) + 2] = inputImage[(y * baseWidth) + x];
                     }
                 }
                 break;
             }
         case ScaleType.FourX:
             {
                 for (int y = 0; y < baseHeight; y++)
                 {
                     for (int x = 0; x < baseWidth; x++)
                     {
                         outputImage[(((y * 4) + 0) * baseWidth * 4) + (x * 4) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 0) * baseWidth * 4) + (x * 4) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 0) * baseWidth * 4) + (x * 4) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 0) * baseWidth * 4) + (x * 4) + 3] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 1) * baseWidth * 4) + (x * 4) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 1) * baseWidth * 4) + (x * 4) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 1) * baseWidth * 4) + (x * 4) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 1) * baseWidth * 4) + (x * 4) + 3] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 2) * baseWidth * 4) + (x * 4) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 2) * baseWidth * 4) + (x * 4) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 2) * baseWidth * 4) + (x * 4) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 2) * baseWidth * 4) + (x * 4) + 3] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 3) * baseWidth * 4) + (x * 4) + 0] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 3) * baseWidth * 4) + (x * 4) + 1] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 3) * baseWidth * 4) + (x * 4) + 2] = inputImage[(y * baseWidth) + x];
                         outputImage[(((y * 4) + 3) * baseWidth * 4) + (x * 4) + 3] = inputImage[(y * baseWidth) + x];
                     }
                 }
                 break;
             }
         default:
             {
                 for (int i = 0; i < inputImage.Length; i++)
                 {
                     outputImage[i] = inputImage[i];
                 }
                 break;
             }
     }
 }
예제 #24
0
        static public Management.Monitor.Management.Models.ScaleType ConvertNamespace(ScaleType operatorType)
        {
            int value = (int)operatorType;

            return((Management.Monitor.Management.Models.ScaleType)value);
        }
예제 #25
0
		internal virtual void ReInit(ScaleType scaleType, double[] points, double minimum, double maximum)
		{
			if (Container.ActualHeight == 0.0 || Container.ActualWidth == 0.0 || points == null) return;
			if (scaleType != ScaleType || points != DataPoints || minimum != Minimum || maximum != Maximum)
			{
				ScaleType = scaleType;
				DataPoints = points;
				Minimum = minimum;
				Maximum = maximum;
				MyLines.Clear();
				ClearChartObjectsWithMyTag();
				for (int i = 0; i <= DataPoints.GetUpperBound(0); i++)
				{
					Line line = new Line() { StrokeThickness = Thickness, Tag = Tag, Style = LineStyle };//TEST
					MyLines.Add(line);
					Container.Children.Add(line);
				}
			}
			Draw();
		}
예제 #26
0
		internal YGridLines_Internal(Panel container, ScaleType scaleType, double[] points, double minimum, double maximum, double thickness, ChartObjectTag tag, Style lineStyle)
			: base(container, scaleType, points, minimum, maximum, thickness, tag, lineStyle)
		{ }
예제 #27
0
    public static TimeRequestHandle RequestTimeScale(float timeScale, Object context, ScaleType scaleType, float fadeInDuration)
    {
        if (context == null)
        {
            Debug.LogError("TimeManager:RequestTimeScale: context was null, ignoring request!");
            return null;
        }

        TimeRequestHandle trh = new TimeRequestHandle(timeScale, context, scaleType, fadeInDuration);
        requestList.Add(trh);

        EvaluateRequests();
        return trh;
    }
예제 #28
0
		internal YGridLabels_Internal(LolloChart root, Panel container, ScaleType scaleType, Tuple<double, string>[] points, string dataPointsFormat, ChartObjectTag tag)
			: base(root, container, scaleType, points, dataPointsFormat, tag)
		{ }
예제 #29
0
 public TimeRequestHandle(float inScale, Object inContext, ScaleType inScaleType, float inFadeInDuration)
 {
     scale = inScale;
     context = inContext;
     scaleType = inScaleType;
     fadeDuration = inFadeInDuration;
     fadingIn = true;
 }
예제 #30
0
 /// <summary>
 /// Activates the scale component with all the set variables.
 /// The objects scale value will be set to the starting scale value by default.
 /// </summary>
 /// <param name="typeOfScaleMode">The type of scale mode which should be used. This variable overrides the existing scale mode setting for this component.</param>
 public void StartScale(ScaleType typeOfScaleMode)
 {
     m_elapsedTime = 0.0f;
     TypeOfScaleMode = typeOfScaleMode;
     m_isActive = true;
 }
예제 #31
0
		internal XYDataSeries_Internal(Panel container, ScaleType scaleTypeX, ScaleType scaleTypeY, double x0, double xN, double y0, double yN, double[,] points,
			ChartObjectTag tag, Style lineStyle, bool isHistogram = false, StrokeDashArrays sda = StrokeDashArrays.Continue)
			: base(container, tag)
		{
			_isHistogram = isHistogram;

			if (Dashed.Count == 0) { Dashed.Add(2); Dashed.Add(2); }

			MyPolyline.Style = lineStyle;
			MyPolyline.StrokeThickness = LolloChart.DataSeriesThickness;
			switch (sda)
			{
				case StrokeDashArrays.Dashed:
					MyPolyline.StrokeDashArray = Dashed;
					break;
				case StrokeDashArrays.Continue:
					MyPolyline.StrokeDashArray = null;
					break;
				default:
					break;
			}
			Container.Children.Add(MyPolyline);
			Container.Children.Add(CrossCanvas);
			ReInit(scaleTypeX, scaleTypeY, x0, xN, y0, yN, points);
		}
예제 #32
0
    // Use this for initialization
    void Start()
    {
        //walls[1].wall.localScale = new Vector3(walls[1].wall.localScale.x, 0.2f, walls[1].wall.localScale.z);

        for(int c = 0; c < wallCount; c++){
            walls[c].wallObjects = walls[c].wall.FindChild("Wall Objects");
            if(scale == 0)
                scaleCall = ChangeScaleX;
            else if(scale == 1)
                scaleCall = ChangeScaleY;
            else if(scale == 2)
                scaleCall = ChangeScaleZ;
        }

        ChangeWallVisibility(turnAngle);
    }
 public static void SetScaleType(DependencyObject obj, ScaleType value)
 {
     obj.SetValue(ScaleTypeProperty, value);
 }
예제 #34
0
	public void StopScalingTime() {
		scaleType = ScaleType.None;
	}
예제 #35
0
 public ScaleAnim()
 {
     time      = 0.2f;
     scaleType = ScaleType.CenterXY;
 }