public static Bitmap getRoundedCroppedBitmap(Bitmap bitmap, int radius) {
			Bitmap finalBitmap;
			if (bitmap.Width != radius || bitmap.Height!= radius)
				finalBitmap = Bitmap.CreateScaledBitmap(bitmap, radius, radius,
					false);
			else
				finalBitmap = bitmap;
			Bitmap output = Bitmap.CreateBitmap(finalBitmap.Width,
				finalBitmap.Height, Bitmap.Config.Argb8888);
			Canvas canvas = new Canvas(output);

			 Paint paint = new Paint();
			Rect rect = new Rect(0, 0, finalBitmap.Width,
				finalBitmap.Height);

			paint.AntiAlias=true;
			paint.FilterBitmap=true;
			paint.Dither=true;
			canvas.DrawARGB(0, 0, 0, 0);
			paint.Color=Color.ParseColor("#BAB399");
			canvas.DrawCircle(finalBitmap.Width / 2 + 0.7f,
				finalBitmap.Height / 2 + 0.7f,
				finalBitmap.Width / 2 + 0.1f, paint);
			paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
			canvas.DrawBitmap(finalBitmap, rect, rect, paint);

			return output;
		}	
		// If you would like to create a circle of the image set pixels to half the width of the image.
		internal static   Bitmap GetRoundedCornerBitmap(Bitmap bitmap, int pixels)
		{
			Bitmap output = null;

			try
			{
				output = Bitmap.CreateBitmap(bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);
				Canvas canvas = new Canvas(output);

				Color color = new Color(66, 66, 66);
				Paint paint = new Paint();
				Rect rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
				RectF rectF = new RectF(rect);
				float roundPx = pixels;

				paint.AntiAlias = true;
				canvas.DrawARGB(0, 0, 0, 0);
				paint.Color = color;
				canvas.DrawRoundRect(rectF, roundPx, roundPx, paint);

				paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
				canvas.DrawBitmap(bitmap, rect, rect, paint);
			}
			catch (System.Exception err)
			{
				System.Console.WriteLine ("GetRoundedCornerBitmap Error - " + err.Message);
			}

			return output;
		}
 protected override void OnDraw(Canvas canvas)
 {
     Android.Graphics.Drawable.Drawable drawable = GetDrawable();
     if (drawable is BitmapDrawable)
     {
         RectF rectF = new RectF(drawable.GetBounds());
         int restoreCount = canvas.SaveLayer(rectF, null, Canvas.AllSaveFlag);
         GetImageMatrix().MapRect(rectF);
         Paint paint = ((BitmapDrawable)drawable).GetPaint();
         paint.SetAntiAlias(true);
         paint.SetColor(unchecked((int)(0xff000000)));
         canvas.DrawARGB(0, 0, 0, 0);
         canvas.DrawRoundRect(rectF, Radius, Radius, paint);
         Xfermode restoreMode = paint.GetXfermode();
         paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
         base.OnDraw(canvas);
         // Restore paint and canvas
         paint.SetXfermode(restoreMode);
         canvas.RestoreToCount(restoreCount);
     }
     else
     {
         base.OnDraw(canvas);
     }
 }
        static Bitmap GetCroppedBitmap (Bitmap bmp, int radius)
        {
            Bitmap sbmp;
            if (bmp.Width != radius || bmp.Height != radius)
                sbmp = Bitmap.CreateScaledBitmap (bmp, radius, radius, false);
            else
                sbmp = bmp;
            var output = Bitmap.CreateBitmap (sbmp.Width,
                             sbmp.Height, Bitmap.Config.Argb8888);
            var canvas = new Canvas (output);

            var paint = new Paint ();
            var rect = new Rect (0, 0, sbmp.Width, sbmp.Height);

            paint.AntiAlias = true;
            paint.FilterBitmap = true;
            paint.Dither = true;
            canvas.DrawARGB (0, 0, 0, 0);
            paint.Color = Color.ParseColor ("#BAB399");
            canvas.DrawCircle (sbmp.Width / 2 + 0.7f, sbmp.Height / 2 + 0.7f,
                sbmp.Width / 2 + 0.1f, paint);
            paint.SetXfermode (new PorterDuffXfermode (PorterDuff.Mode.SrcIn));
            canvas.DrawBitmap (sbmp, rect, rect, paint);

            return output;
        }
Exemple #5
0
        public override void Draw(Android.Graphics.Canvas canvas)
        {
            if (_reinitializeImages)
            {
                InitializeImages();
                _reinitializeImages = false;
            }

            UpdateSizes();

            // Clear the canvas
            canvas.DrawARGB(255, 255, 255, 255);

            if (_centerBitmap != null && _centerBitmap.Bitmap != null)
            {
                var dest = CalculateCentrationRect(_centerBitmap.Bitmap);
                canvas.DrawBitmap(_centerBitmap.Bitmap, dest.Left + _swipeCurrectXOffset, dest.Top, null);
            }
            else if (_centerBitmap != null)
            {
                DrawLoadingText(canvas, 0);
            }

            if (_leftBitmap != null && _leftBitmap.Bitmap != null)
            {
                var dest = CalculateCentrationRect(_leftBitmap.Bitmap);
                canvas.DrawBitmap(_leftBitmap.Bitmap, dest.Left + _swipeCurrectXOffset - this.Width, dest.Top, null);
            }
            else if (_leftBitmap != null)
            {
                DrawLoadingText(canvas, -Width);
            }

            if (_rightBitmap != null && _rightBitmap.Bitmap != null)
            {
                var dest = CalculateCentrationRect(_rightBitmap.Bitmap);
                canvas.DrawBitmap(_rightBitmap.Bitmap, dest.Left + _swipeCurrectXOffset + this.Width, dest.Top, null);
            }
            else if (_rightBitmap != null)
            {
                DrawLoadingText(canvas, Width);
            }
        }
		public static Bitmap GetRoundedCornerBitmap(Bitmap bitmap) {
			Bitmap output = Bitmap.CreateBitmap(bitmap.Width,
				bitmap.Height,Bitmap.Config.Argb8888);
			Canvas canvas = new Canvas(output);

			//int color = 0xff424242;
			Paint paint = new Paint();
			Rect rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
			RectF rectF = new RectF(rect);
			float roundPx = 12.0f;

			paint.AntiAlias=true;
			canvas.DrawARGB(0, 0, 0, 0);
			paint.Color = Color.Red; //color;//Color.Transparent;
			canvas.DrawRoundRect(rectF, roundPx, roundPx, paint);

			paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
			canvas.DrawBitmap(bitmap, rect, rect, paint);
			return output;
		}
Exemple #7
0
        public void InitWithBitmap(Bitmap imageSource, ALL11 filter)
        {
            //TODO:  Android.Opengl.GLUtils.GetInternalFormat()

            _format = SurfaceFormat.Color;
            if (imageSource.HasAlpha)
                _format = SurfaceFormat.Color;

            if (GraphicsDevice.OpenGLESVersion == OpenTK.Graphics.GLContextVersion.Gles2_0)
            {
                _width = imageSource.Width;
                _height = imageSource.Height;
            }
            else
            {
                // scale up bitmap to be power of 2 dimensions but dont exceed 1024x1024.
                // Note: may not have to do this with OpenGL 2+
                _width = (int)Math.Pow(2, Math.Min(10, Math.Ceiling(Math.Log10(imageSource.Width) / Math.Log10(2))));
                _height = (int)Math.Pow(2, Math.Min(10, Math.Ceiling(Math.Log10(imageSource.Height) / Math.Log10(2))));
            }

            _size.Width = _width;
            _size.Height = _height;

            using (Bitmap imagePadded = Bitmap.CreateBitmap(_width, _height, Bitmap.Config.Argb8888))
            {
                Canvas can = new Canvas(imagePadded);
                can.DrawARGB(0, 0, 0, 0);
                can.DrawBitmap(imageSource, 0, 0, null);
                if (GraphicsDevice.OpenGLESVersion == OpenTK.Graphics.GLContextVersion.Gles2_0)
                {
                    GL11.GenTextures(1, ref _name);
                    GL11.BindTexture(ALL11.Texture2D, _name);
                    GL11.TexParameter(ALL11.Texture2D, ALL11.TextureMinFilter, (int)filter);
                    GL11.TexParameter(ALL11.Texture2D, ALL11.TextureMagFilter, (int)filter);
                    Android.Opengl.GLUtils.TexImage2D((int)ALL11.Texture2D, 0, imagePadded, 0);

                    // free bitmap
                    imageSource.Recycle();

                    // error checking
                    int errAndroidGL = Android.Opengl.GLES20.GlGetError();
                    ALL20 errGenericGL = GL20.GetError();
                    if (errAndroidGL != Android.Opengl.GLES20.GlNoError || errGenericGL != ALL20.NoError)
                        Console.WriteLine(string.Format("OpenGL ES 2.0:\n\tAndroid error: {0,10:X}\n\tGeneric error: {1, 10:X}", errAndroidGL, errGenericGL));
                }
                else
                {
                    GL20.GenTextures(1, ref _name);
                    GL20.BindTexture(ALL20.Texture2D, _name);
                    GL20.TexParameter(ALL20.Texture2D, ALL20.TextureMinFilter, (int)filter);
                    GL20.TexParameter(ALL20.Texture2D, ALL20.TextureMagFilter, (int)filter);
                    Android.Opengl.GLUtils.TexImage2D((int)ALL20.Texture2D, 0, imagePadded, 0);
                }
            }

            _maxS = _size.Width / (float)_width;
            _maxT = _size.Height / (float)_height;
        }
Exemple #8
0
		public void InitWithBitmap(Bitmap imageSource, ALL11 filter, ALL11 wrap)
		{
			//TODO:  Android.Opengl.GLUtils.GetInternalFormat()
			try
			{
	            _format = SurfaceFormat.Color;
	            if (imageSource.HasAlpha)
	                _format = SurfaceFormat.Color;
	
				if (GraphicsDevice.OpenGLESVersion == OpenTK.Graphics.GLContextVersion.Gles2_0)
	            {
	                _width = imageSource.Width;
	                _height = imageSource.Height;
	
					// There are rules for npot textures that we must abide by (wrap = ClampToEdge and filter = Nearest or Linear)
					if (!MathHelper.IsPowerOfTwo(_width) || !MathHelper.IsPowerOfTwo(_height))
					{
						filter = ALL11.Linear;
						wrap = ALL11.ClampToEdge;
					}
	            }
	            else
	            {
	                //scale up bitmap to be power of 2 dimensions but dont exceed 1024x1024.
	                //Note: may not have to do this with OpenGL 2+
	                _width = (int)Math.Pow(2, Math.Min(10, Math.Ceiling(Math.Log10(imageSource.Width) / Math.Log10(2))));
	                _height = (int)Math.Pow(2, Math.Min(10, Math.Ceiling(Math.Log10(imageSource.Height) / Math.Log10(2))));
	            }
	
	            _size.Width = _width;
	            _size.Height = _height;
	
	            if (GraphicsDevice.OpenGLESVersion ==
	                OpenTK.Graphics.GLContextVersion.Gles2_0)
	            {
	                GL20.GenTextures(1, ref _name);
	            }
	            else
	            {
	                GL11.GenTextures(1, ref _name);
	            }
	
	            if (_name == 0)
	            {
	                _originalBitmap = imageSource;
	                _originalFilter = filter;
					_originalWrap = wrap;
	                PrimaryThreadLoader.AddToList(this);
                    _textureCreated = false;
	            }
	            else
	            {
                    _originalBitmap = null;
                    _textureCreated = true;

	                using (
	                    Bitmap imagePadded = Bitmap.CreateBitmap(_width, _height,
	                                                             Bitmap.Config.Argb8888)
	                    )
	                {
	                    
						using(Canvas can = new Canvas(imagePadded))
						{
		                    can.DrawARGB(0, 0, 0, 0);												
		
		                    if(AndroidCompatibility.ScaleImageToPowerOf2)
		                        can.DrawBitmap(imageSource, new Rect(0, 0, imageSource.Width, imageSource.Height),  new Rect(0, 0, _width, _height), null); //Scale to texture
		                    else
		                        can.DrawBitmap(imageSource, 0, 0, null);
		
		                    if (GraphicsDevice.OpenGLESVersion ==
		                        OpenTK.Graphics.GLContextVersion.Gles2_0)
		                    {
		                        GL20.BindTexture(ALL20.Texture2D, _name);
		                        GL20.TexParameter(ALL20.Texture2D, ALL20.TextureMinFilter,
		                                          (int)filter);
		                        GL20.TexParameter(ALL20.Texture2D, ALL20.TextureMagFilter,
		                                          (int)filter);
								GL20.TexParameter(ALL20.Texture2D, ALL20.TextureWrapS, (int)wrap);
								GL20.TexParameter(ALL20.Texture2D, ALL20.TextureWrapT, (int)wrap);
								Android.Opengl.GLUtils.TexImage2D((int)ALL20.Texture2D, 0,
		                                                          imagePadded, 0);
		
		                        // error checking
		                        //int errAndroidGL = Android.Opengl.GLES20.GlGetError();
		                        //ALL20 errGenericGL = GL20.GetError();
		                        //if (errAndroidGL != Android.Opengl.GLES20.GlNoError || errGenericGL != ALL20.NoError)
		                        //    Console.WriteLine(string.Format("OpenGL ES 2.0:\n\tAndroid error: {0,10:X}\n\tGeneric error: {1, 10:X}", errAndroidGL, errGenericGL));
		                    }
		                    else
		                    {
		                        GL11.BindTexture(ALL11.Texture2D, _name);
		                        GL11.TexParameter(ALL11.Texture2D, ALL11.TextureMinFilter,
		                                          (int)filter);
		                        GL11.TexParameter(ALL11.Texture2D, ALL11.TextureMagFilter,
		                                          (int)filter);
								GL11.TexParameter(ALL11.Texture2D, ALL11.TextureWrapS, (int)wrap);
								GL11.TexParameter(ALL11.Texture2D, ALL11.TextureWrapT, (int)wrap);
		                        GL11.TexParameter(ALL11.Texture2D, ALL11.GenerateMipmap, 1);
		                        Android.Opengl.GLUtils.TexImage2D((int)ALL11.Texture2D, 0,
		                                                          imagePadded, 0);
			                        
		                    }											
						}
	                }
	            }
			}
			finally
			{
                if (_originalBitmap != imageSource)
                {
                    // free bitmap
                    imageSource.Dispose();
                }
			}

            _maxS = _size.Width / (float)_width;
            _maxT = _size.Height / (float)_height;
        }
        private static Bitmap GetRoundedCornerBitmap(Bitmap bitmap, int roundPixels, Rect srcRect, Rect destRect, int width,
			    int height)
        {
            Bitmap output = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888);
            Canvas canvas = new Canvas(output);

            Paint paint = new Paint();
            RectF destRectF = new RectF(destRect);

            paint.AntiAlias = true;
            canvas.DrawARGB(0, 0, 0, 0);
            paint.Color = Color.Argb(0xFF, 0x00, 0x00, 0x00);
            canvas.DrawRoundRect(destRectF, roundPixels, roundPixels, paint);

            paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
            canvas.DrawBitmap(bitmap, srcRect, destRectF, paint);

            return output;
        }
        private static Bitmap MakeImageRound (Bitmap bitmap)
        {
            Bitmap output = Bitmap.CreateBitmap (bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);
            var canvas = new Canvas (output);

            var rect = new Rect (0, 0, bitmap.Width, bitmap.Height);
            var rectF = new RectF (rect);

            var paint = new Paint ();
            paint.AntiAlias = true;
            paint.Color = Color.Black;

            canvas.DrawARGB (0, 0, 0, 0);
            canvas.DrawRoundRect (rectF, bitmap.Width, bitmap.Height, paint);

            paint.SetXfermode (new PorterDuffXfermode (PorterDuff.Mode.SrcIn));

            canvas.DrawBitmap (bitmap, rect, rect, paint);

            return output;
        }
        protected override void OnCreate(Bundle bundle)
        {
            //Set Display/Interactions/Counter Vars
            base.OnCreate (bundle);
            SetContentView (Resource.Layout.Main);
            Button clear = FindViewById<Button> (Resource.Id.ClearButton);
            Button save = FindViewById<Button> (Resource.Id.SaveButton);
            int CountX = -7, CountY = -7;
            var IV = FindViewById<ImageView> (Resource.Id.DisplayView);
            float x1=0, y1=0, x2=0, y2=0;
            Bitmap BM = Bitmap.CreateBitmap (760, 800, Bitmap.Config.Argb8888);

            //Set up Paint
            var P = new Paint();
            P.Color = Color.White;
            P.StrokeWidth = 15;
            Canvas C = new Canvas(BM);

            //Draw on Bitmap When Touched
            IV.Touch += (s, e) => {
                if (e.Event.Action == MotionEventActions.Down)
                {
                    x1 = e.Event.GetX();
                    y1 = e.Event.GetY();
                    x2 = e.Event.GetX();
                    y2 = e.Event.GetY();
                    Console.WriteLine ("Touched at X:"+x1+" Y:"+y1);
                    BM.SetPixel ((int)x1, (int)y1, Color.White);
                    IV.SetImageBitmap (BM);
                }
                if (e.Event.Action == MotionEventActions.Move)
                {
                    x1 = e.Event.GetX();
                    y1 = e.Event.GetY();
                    while(CountY<=7){
                        while(CountX<=7){
                            BM.SetPixel ((int)x1+CountX, (int)y1+CountY, Color.White);
                            CountX++;
                        }
                        CountX=-7;
                        CountY++;
                    }
                    Console.WriteLine ("Touched at X:"+x1+" Y:"+y1);
                    C.DrawLine(x1, y1, x2, y2, P);
                    IV.SetImageBitmap(BM);
                    x2 = x1;
                    y2 = y1;
                }
            };

            //Clear
            clear.Click += delegate {
                C.DrawARGB(255,0,0,0);
                IV.SetImageBitmap (BM);
            };

            //Save
            save.Click += delegate {
                ExportBitmapAsPNG(BM);
            };
        }
		void OnZoomThumbnailClicked (object sender, EventArgs e)
		{
			View v = (View)sender;
			// Create a thumbnail animation.  We are going to build our thumbnail
			// just from the view that was pressed.  We make sure the view is
			// not selected, because by the time the animation starts we will
			// have finished with the selection of the tap.
			v.DrawingCacheEnabled = true;
			v.Pressed = false;
			v.RefreshDrawableState ();
			Bitmap bm = v.DrawingCache;
			Canvas c = new Canvas (bm);
			c.DrawARGB (255, 255, 0, 0);
			ActivityOptions opts = ActivityOptions.MakeThumbnailScaleUpAnimation (v, bm, 0, 0);

			// Request the activity be started, using the custom animation options.
			StartActivity (new Intent (this, typeof (AlertDialogSamples)), opts.ToBundle ());
			v.DrawingCacheEnabled = false;
		}
Exemple #13
0
        public void InitWithBitmap(Bitmap imageSource, All filter)
        {
            //TODO:  Android.Opengl.GLUtils.GetInternalFormat()

            _format = SurfaceFormat.Color;
            if(imageSource.HasAlpha)
                _format = SurfaceFormat.Color;

            // scale up bitmap to be power of 2 dimensions but dont exceed 1024x1024.
            // Note: may not have to do this with OpenGL 2+
            _width = (int)Math.Pow(2, Math.Min(10,Math.Ceiling(Math.Log10(imageSource.Width) / Math.Log10(2))));
            _height = (int)Math.Pow(2, Math.Min(10,Math.Ceiling(Math.Log10(imageSource.Height) / Math.Log10(2))));
            _size.Width =_width;
            _size.Height = _height;

            using (Bitmap imagePadded = Bitmap.CreateBitmap(_width, _height, Bitmap.Config.Argb8888))
            {
                Canvas can = new Canvas(imagePadded);
                can.DrawARGB(0, 0, 0, 0);
                can.DrawBitmap(imageSource, 0, 0, null);
                GL.GenTextures(1, ref _name);
                GL.BindTexture(All.Texture2D, _name);
                GL.TexParameter(All.Texture2D, All.TextureMinFilter, (int)filter);
                GL.TexParameter(All.Texture2D, All.TextureMagFilter, (int)filter);

                Android.Opengl.GLUtils.TexImage2D((int)All.Texture2D, 0, imagePadded, 0);
            }

            _maxS = _size.Width / (float)_width;
            _maxT = _size.Height / (float)_height;
        }
		public static Bitmap getCircleBitmap(Context context, Bitmap input, int w , int h) 
		{
			//CREAMOS UN BITMAP TEMP CON LAS DIMENSIONES QUE LE PASAMOS
			Bitmap output = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888);
			//CRAMOS UN CANVAS EL CUAL NOS PERMITIRA DIBUJAR EL CIRCULO QUE NOS SERVIRA COMO MASCARA Y LE ASIGNAMOS EL BITMAP
			Canvas canvas = new Canvas(output);
			canvas.DrawARGB(0, 255, 0, 0);


			//DEFINIMOS UNA BROCHA YA QUE ES NECESARIA PARA DIBUJAR EL CIRCULO 
			Paint paint = new Paint();
			paint.AntiAlias=true;
			//string color = "#ff0002";
			//paint.Color=Color.ParseColor (color);

			//DIBUJAMOS EL CIRCULO DENTRO DEL CANVAS 
			canvas.DrawCircle(canvas.Height /2,canvas.Height /2,canvas.Height /2, paint);


			//LE APLICAMOS UN FILTRO A NUESTRA BROCHA PARA QUE CUANDO SE CONBINEN LOS ELEMENTOS DE LA IMAGEN ORIGINAL CON LA DIBUJADA EN EL CANVAS
			//ESTA APLIQUE EL RECORTE DE LA MASCARA
			paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));

			//LE ASIGNAMOS AL FONDO DE NUESTRO CANVAS LA IMAGEN QUE QUEREMOS QUE SE APLIQUE LA MASCARA, EN ESTE CASO ES LA IMAGEN
			//QUE SE LE ASIGNO AL CONTROL
			canvas.DrawBitmap(input, 0,0, paint);

			//REGRESAMOS LA IMAGEN YA RECOTADA 
			return output;
		}
        internal CCTexture2D CreateTextSprite(string text, CCFontDefinition textDefinition)
        {
            if (string.IsNullOrEmpty(text))
                return new CCTexture2D();

            int imageWidth;
            int imageHeight;
            var textDef = textDefinition;
            var contentScaleFactorWidth = CCLabel.DefaultTexelToContentSizeRatios.Width;
            var contentScaleFactorHeight = CCLabel.DefaultTexelToContentSizeRatios.Height;

            textDef.FontSize *= contentScaleFactorWidth;
            textDef.Dimensions.Width *= contentScaleFactorWidth;
            textDef.Dimensions.Height *= contentScaleFactorHeight;

            bool hasPremultipliedAlpha;

            var display = Game.Activity.WindowManager.DefaultDisplay;
            var metrics = new DisplayMetrics();
            display.GetMetrics(metrics);

            // Do not take into account ScaleDensity for now.
//            var fontScaleFactor = metrics.ScaledDensity;
//            textDef.FontSize = (int)(textDef.FontSize * fontScaleFactor);


            // out paint object to hold our drawn text
//            var paintFlags = new PaintFlags();
//            if (textDefinition.isShouldAntialias)
//                paintFlags = PaintFlags.AntiAlias | PaintFlags.SubpixelText;
            
            var textPaint = new TextPaint();
            textPaint.Color = Android.Graphics.Color.White;
            textPaint.TextAlign = Paint.Align.Left;
            textPaint.AntiAlias = textDefinition.isShouldAntialias;

            textPaint.TextSize = textDef.FontSize;

            var fontName = textDef.FontName;
            var ext = System.IO.Path.GetExtension(fontName);
            if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
            {
                
                CCContentManager.SharedContentManager.GetAssetStreamAsBytes(fontName, out fontName);

                var activity = Game.Activity;

                try
                {
                    var typeface = Typeface.CreateFromAsset(activity.Assets, fontName);
                    textPaint.SetTypeface(typeface);
                }
                catch (Exception)
                {
                    textPaint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
                }
            }
            else
            {
                textPaint.SetTypeface(Typeface.Create(fontName, TypefaceStyle.Normal));
            }

            // color
            var foregroundColor = Android.Graphics.Color.White;

            textPaint.Color = foregroundColor;

            // alignment
            var horizontalAlignment = textDef.Alignment;
            var verticleAlignement = textDef.LineAlignment;

            var textAlign = (CCTextAlignment.Right == horizontalAlignment) ? Layout.Alignment.AlignOpposite
                : (CCTextAlignment.Center == horizontalAlignment) ? Layout.Alignment.AlignCenter
                : Layout.Alignment.AlignNormal;

            // LineBreak
            // TODO: Find a way to specify the type of line breaking if possible.

            var dimensions = new CCSize(textDef.Dimensions.Width, textDef.Dimensions.Height);

            var layoutAvailable = true;
            if (dimensions.Width <= 0)
            {
                dimensions.Width = 8388608;
                layoutAvailable = false;
            }

            if (dimensions.Height <= 0)
            {
                dimensions.Height = 8388608;
                layoutAvailable = false;
            }


            // Get bounding rectangle - we need its attribute and method values
            var layout = new StaticLayout(text, textPaint, 
                (int)dimensions.Width, textAlign, 1.0f, 0.0f, false);

            var boundingRect = new Rect();
            var lineBounds = new Rect();

            // Loop through all the lines so we can find our drawing offsets
            var lineCount = layout.LineCount;

            // early out if something went wrong somewhere and nothing is to be drawn
            if (lineCount == 0)
                return new CCTexture2D();

            for (int lc = 0; lc < lineCount; lc++)
            {
                layout.GetLineBounds(lc, lineBounds);
                var max = (int)Math.Ceiling(layout.GetLineMax(lc));

                if (boundingRect.Right < max)
                    boundingRect.Right = max;

                boundingRect.Bottom = lineBounds.Bottom;
            }

            if (!layoutAvailable)
            {
                if (dimensions.Width == 8388608)
                {
                    dimensions.Width = boundingRect.Right;
                }
                if (dimensions.Height == 8388608)
                {
                    dimensions.Height = boundingRect.Bottom;
                }
            }

            imageWidth = (int)dimensions.Width;
            imageHeight = (int)dimensions.Height;

            // Recreate our layout based on calculated dimensions so that we can draw the text correctly
            // in our image when Alignment is not Left.
            if (textAlign != Layout.Alignment.AlignNormal)
            {
                layout = new StaticLayout(text, textPaint, 
                    (int)dimensions.Width, textAlign, 1.0f, 0.0f, false);
              
            }


            // Line alignment
            var yOffset = (CCVerticalTextAlignment.Bottom == verticleAlignement 
                || boundingRect.Bottom >= dimensions.Height) ? dimensions.Height - boundingRect.Bottom  // align to bottom
                : (CCVerticalTextAlignment.Top == verticleAlignement) ? 0                    // align to top
                : (imageHeight - boundingRect.Bottom) * 0.5f;                                   // align to center

            try {

                // Create our platform dependant image to be drawn to.
                using (Bitmap textureBitmap = Bitmap.CreateBitmap(imageWidth, imageHeight, Bitmap.Config.Argb8888))
                {
                    using (Canvas drawingCanvas = new Canvas(textureBitmap))
                    {
                        drawingCanvas.DrawARGB(0, 255, 255, 255);

                        // Set our vertical alignment
                        drawingCanvas.Translate(0, yOffset);

                        // Now draw the text using our layout
                        layout.Draw(drawingCanvas);

                        // Create a pixel array
                        int[] pixels = new int[imageWidth * imageHeight];

                        // Now lets get our pixels.
                        // We use CopyPixelsToBuffer so that it is in Premultiplied Alpha already.
                        // Using Bitmap.GetPixels return non Premultiplied Alpha which causes blending problems
                        Java.Nio.IntBuffer byteBuffer = Java.Nio.IntBuffer.Allocate(imageWidth * imageHeight);
                        textureBitmap.CopyPixelsToBuffer(byteBuffer);
                        if (byteBuffer.HasArray)
                        {
                            byteBuffer.Rewind();
                            byteBuffer.Get(pixels, 0, pixels.Length);
                        }

                        // Make sure we recycle - Let's keep it green
                        textureBitmap.Recycle();

                        // Here we create our Texture and then set our pixel data.
                        var texture = new CCTexture2D(imageWidth, imageHeight);
                        texture.XNATexture.SetData<int>(pixels);

                        return texture;
                    }
                }   
            }
            catch (Exception exc)
            {
                CCLog.Log ("CCLabel Android: Error creating native label:{0}\n{1}", exc.Message, exc.StackTrace);
                return new CCTexture2D();
            }
        }
Exemple #16
0
		public static Bitmap GetRoundedCornerBitmap (Bitmap bitmap, int cornerRadius)
		{
			Bitmap output = Bitmap.CreateBitmap (bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);

			Canvas canvas = new Canvas(output);

			Paint paint = new Paint();
			Rect rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
			RectF rectF = new RectF(rect);
			float roundPx = cornerRadius;

			paint.AntiAlias = true;
			canvas.DrawARGB(0, 0, 0, 0);
			paint.SetColorFilter (new ColorFilter ());
			canvas.DrawRoundRect(rectF, roundPx, roundPx, paint);
			paint.SetXfermode (new PorterDuffXfermode (PorterDuff.Mode.SrcIn));
			canvas.DrawBitmap (bitmap, rect, rect, paint);

			return output;
		}
Exemple #17
0
        private Bitmap GetCircleBitmap(int radius)
        {
            var output = Bitmap.CreateBitmap (_originBitmap.Width, _originBitmap.Height, Bitmap.Config.Argb8888);
            using (var canvas = new Canvas (output))
            using (var paint = new Paint (PaintFlags.AntiAlias))
            using (var rect = new Rect ((int)(_x - radius), (int)(_y - radius), (int)(_x + radius), (int)(_y + radius))) {
                canvas.DrawARGB (0, 0, 0, 0);
                canvas.DrawCircle (_x, _y, radius, paint);

                paint.SetXfermode (new PorterDuffXfermode (PorterDuff.Mode.SrcIn));
                canvas.DrawBitmap (_originBitmap, rect, rect, paint);

                return output;
            }
        }
        /// <summary>
        /// Reshapes the image.
        /// </summary>
        /// <param name="sourceBitmap">The source bitmap.</param>
        private void ReshapeImage(Bitmap sourceBitmap)
        {
            if (sourceBitmap == null) return;

            using (var sourceRect = GetScaledRect(sourceBitmap.Height, sourceBitmap.Width))
            using (var rect = this.GetTargetRect(sourceBitmap.Height, sourceBitmap.Width))
            using (var output = Bitmap.CreateBitmap(rect.Width(), rect.Height(), Bitmap.Config.Argb8888))
            using (var canvas = new Canvas(output))
            using (var paint = new Paint())
            using (var rectF = new RectF(rect))
            {
                var roundRx = rect.Width() / 2;
                var roundRy = rect.Height() / 2;

                paint.AntiAlias = true;
                canvas.DrawARGB(0, 0, 0, 0);
                paint.Color = Android.Graphics.Color.ParseColor("#ff424242");
                canvas.DrawRoundRect(rectF, roundRx, roundRy, paint);

                paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
                canvas.DrawBitmap(sourceBitmap, sourceRect, rect, paint);

                //this.DrawBorder(canvas, rect.Width(), rect.Height());

                this.Control.SetImageBitmap(output);
                // Forces the internal method of InvalidateMeasure to be called.
                this.Element.WidthRequest = this.Element.WidthRequest;
            }
        }
		/// <summary>
		/// Gets the oval bitmap.
		/// </summary>
		/// <returns>The oval bitmap.</returns>
		/// <param name="bitmap">Bitmap.</param>
		private Bitmap GetOvalBitmap(Bitmap bitmap) 
		{
			Bitmap output = null;

			if(bitmap != null)
			{
				output = Bitmap.CreateBitmap(bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);
				Canvas canvas = new Canvas(output);

				Paint paint = new Paint();
				Rect rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
				RectF rectF = new RectF(rect);

				paint.AntiAlias = true;
				canvas.DrawARGB(0, 0, 0, 0);
				paint.Color = Color.Red;
				canvas.DrawOval(rectF, paint);

				paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
				canvas.DrawBitmap(bitmap, rect, rect, paint);
			}

			return output;
		}