示例#1
0
	/// <summary>
	/// <para>Create a new cursor, based on a pre-defined cursor type.</para>
	/// </summary>
	///
	/// <param name="type">
	/// <para>The pre-defined cursor type to use.</para>
	/// </param>
	public Cursor(CursorType type)
			{
				this.type = type;
				this.source = null;
				this.mask = null;
				this.cursor = XCursor.Zero;
			}
示例#2
0
        // Get the bitmap corresponding to a particular hatch style.
        private static Xsharp.Bitmap GetBitmap(HatchStyle style)
        {
            Xsharp.Bitmap bitmap;

            // See if we have a cached bitmap for this style.
            if (((int)style) >= 0 && ((int)style) <= 52)
            {
                if (hatchBitmaps == null)
                {
                    hatchBitmaps = new Xsharp.Bitmap [53];
                }
                bitmap = hatchBitmaps[(int)style];
                if (bitmap != null)
                {
                    return(bitmap);
                }
            }
            else
            {
                return(null);
            }

            // Get the raw bits for the hatch bitmap.
            byte[] bits = GetBits(style);
            if (bits == null)
            {
                return(null);
            }

            // Create the bitmap, cache it for later, and then return it.
            bitmap = new Xsharp.Bitmap(16, 16, bits);
            hatchBitmaps[(int)style] = bitmap;
            return(bitmap);
        }
示例#3
0
	/// <summary>
	/// <para>Constructs a new <see cref="T:Xsharp.Image"/> instance
	/// that represents an off-screen image.</para>
	/// </summary>
	///
	/// <param name="width">
	/// <para>The width of the new image.</para>
	/// </param>
	///
	/// <param name="height">
	/// <para>The height of the new image.</para>
	/// </param>
	///
	/// <param name="hasMask">
	/// <para>Set to <see langword="null"/> if the optional mask
	/// should also be created.</para>
	/// </param>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>The <paramref name="width"/> or <paramref name="height"/>
	/// values are out of range.</para>
	/// </exception>
	public Image(int width, int height, bool hasMask)
			{
				pixmap = new Pixmap(width, height);
				screen = pixmap.screen;
				if(hasMask)
				{
					mask = new Bitmap(width, height);
				}
				else
				{
					mask = null;
				}
			}
示例#4
0
	/// <summary>
	/// <para>Create a new cursor, based on a user-supplied image
	/// and mask.</para>
	/// </summary>
	///
	/// <param name="source">
	/// <para>The bitmap defining the source image for the cursor.</para>
	/// </param>
	///
	/// <param name="mask">
	/// <para>The bitmap defining the mask for the cursor.</para>
	/// </param>
	///
	/// <param name="hotspotX">
	/// <para>The X position of the cursor hotspot.</para>
	/// </param>
	///
	/// <param name="hotspotY">
	/// <para>The Y position of the cursor hotspot.</para>
	/// </param>
	///
	/// <exception cref="T:System.ArgumentNullException"/>
	/// <para>Raised if <paramref name="source"/> or <paramref name="mask"/>
	/// is <see langword="null"/>.</para>
	/// </exception>
	public Cursor(Bitmap source, Bitmap mask, int hotspotX, int hotspotY)
			{
				if(source == null)
				{
					throw new ArgumentNullException("source");
				}
				if(mask == null)
				{
					throw new ArgumentNullException("mask");
				}
				this.type = CursorType.XC_inherit_parent;
				this.source = source;
				this.mask = mask;
				this.cursor = XCursor.Zero;
			}
示例#5
0
 // Draw a bitmap-based glyph to a "Graphics" object.  "bits" must be
 // in the form of an xbm bitmap.
 public override void DrawGlyph(int x, int y,
                                byte[] bits, int bitsWidth, int bitsHeight,
                                System.Drawing.Color color)
 {
     Xsharp.Bitmap bitmap;
     bitmap = new Xsharp.Bitmap(bitsWidth, bitsHeight, bits);
     try
     {
         graphics.Foreground = DrawingToolkit.DrawingToXColor(color);
         graphics.SetFillStippled(bitmap, x, y);
         graphics.FillRectangle(x, y, bitsWidth, bitsHeight);
         graphics.SetFillSolid();
     }
     finally
     {
         bitmap.Destroy();
     }
 }
	// Convert an XImage mask into a Bitmap object.
	public static Bitmap XImageMaskToBitmap(Screen screen, IntPtr ximage)
			{
				int width, height;
				Xlib.XSharpGetImageSize(ximage, out width, out height);
				Bitmap bitmap = new Bitmap(screen, width, height);
				Graphics graphics = new Graphics(bitmap);
				graphics.PutXImage(ximage, 0, 0, 0, 0, width, height);
				graphics.Dispose();
				return bitmap;
			}
示例#7
0
	/// <summary>
	/// <para>Create a new cursor, based on a user-supplied image frame.</para>
	/// </summary>
	///
	/// <param name="screen">
	/// <para>The screen to create the cursor for, or
	/// <see langword="null"/> for the default screen on the
	/// default display.</para>
	/// </param>
	///
	/// <param name="frame">
	/// <para>The frame defining the cursor image.</para>
	/// </param>
	///
	/// <exception cref="T:System.ArgumentNullException"/>
	/// <para>Raised if <paramref name="frame"/> is
	/// <see langword="null"/>.</para>
	/// </exception>
	public Cursor(Screen screen, Frame frame)
			{
				Display dpy;
				if(frame == null)
				{
					throw new ArgumentNullException("frame");
				}
				if(screen != null)
				{
					dpy = screen.DisplayOfScreen;
				}
				else
				{
					dpy = Application.Primary.Display;
					screen = dpy.DefaultScreenOfDisplay;
				}
				if( /* irgnore pixel format! frame.PixelFormat != PixelFormat.Format1bppIndexed  || */
				   frame.Mask == null)
				{
					// The frame is not suitable for use as a cursor.
					this.type = CursorType.XC_left_ptr;
					this.source = null;
					this.mask = null;
					this.cursor = XCursor.Zero;
				}
				else
				{
					this.type = CursorType.XC_inherit_parent;
					this.cursor = XCursor.Zero;
					try
					{
						dpy.Lock();
						IntPtr pixmapXImage =
							ConvertImage.FrameToXImageBitmap(screen, frame);
						IntPtr maskXImage = ConvertImage.MaskToXImage
							(screen, frame);
						source = ConvertImage.XImageMaskToBitmap
							(screen, pixmapXImage);
						mask = ConvertImage.XImageMaskToBitmap
							(screen, maskXImage);
						Xlib.XSharpDestroyImage(pixmapXImage);
						Xlib.XSharpDestroyImage(maskXImage);
						hotspotX = frame.HotspotX;
						hotspotY = frame.HotspotY;
						if(frame.Palette != null && frame.Palette[0] == 0)
						{
							reverse = true;
						}
					}
					finally
					{
						dpy.Unlock();
					}
				}
			}
示例#8
0
	/// <summary>
	/// <para>Destroy this image if it is currently active.</para>
	/// </summary>
	public void Destroy()
			{
				if(pixmap != null)
				{
					pixmap.Destroy();
					pixmap = null;
				}
				if(mask != null)
				{
					mask.Destroy();
					mask = null;
				}
				if(pixmapXImage != IntPtr.Zero)
				{
					Xlib.XSharpDestroyImage(pixmapXImage);
					pixmapXImage = IntPtr.Zero;
				}
				if(maskXImage != IntPtr.Zero)
				{
					Xlib.XSharpDestroyImage(maskXImage);
					maskXImage = IntPtr.Zero;
				}
			}
示例#9
0
	/// <summary>
	/// <para>Constructs a new <see cref="T:Xsharp.Image"/> instance
	/// that represents an off-screen image on a particular screen.</para>
	/// </summary>
	///
	/// <param name="screen">
	/// <para>The screen upon which to create the new pixmap.</para>
	/// </param>
	///
	/// <param name="width">
	/// <para>The width of the new image.</para>
	/// </param>
	///
	/// <param name="height">
	/// <para>The height of the new image.</para>
	/// </param>
	///
	/// <param name="image">
	/// <para>The bits that make up the image.</para>
	/// </param>
	///
	/// <param name="mask">
	/// <para>The bits that make up the mask.</para>
	/// </param>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>The <paramref name="width"/> or <paramref name="height"/>
	/// values are out of range.</para>
	/// </exception>
	public Image(Screen screen, int width, int height, byte[] image, byte[] mask)
			{
				Display dpy;
				if(screen != null)
				{
					dpy = screen.DisplayOfScreen;
				}
				else
				{
					dpy = Application.Primary.Display;
					screen = dpy.DefaultScreenOfDisplay;
				}
				this.screen = screen;
				if(width < 1 || width > 32767 ||
					height < 1 || height > 32767)
				{
					throw new XException(S._("X_InvalidBitmapSize"));
				}
				if(image == null)
				{
					throw new ArgumentNullException("bits");
				}
				if(((((width + 15) & ~15) * height) / 8) > image.Length)
				{
					throw new XException(S._("X_InvalidBitmapBits"));
				}
				try
				{
					IntPtr display = dpy.Lock();
					XDrawable drawable = (XDrawable)
						Xlib.XRootWindowOfScreen(screen.screen);
					XPixmap pixmap = Xlib.XCreateBitmapFromData
						(display, drawable, image, (uint)width, (uint)height);
					this.pixmap = new Pixmap(dpy, screen, pixmap);
				}
				finally
				{
					dpy.Unlock();
				}
				if (mask != null)
					this.mask = new Bitmap(screen, width, height, mask);
				
			}
示例#10
0
	/// <summary>
	/// <para>Constructs a new <see cref="T:Xsharp.Image"/> instance
	/// that represents an off-screen image on a particular screen.</para>
	/// </summary>
	///
	/// <param name="screen">
	/// <para>The screen upon which to create the new pixmap.</para>
	/// </param>
	///
	/// <param name="width">
	/// <para>The width of the new image.</para>
	/// </param>
	///
	/// <param name="height">
	/// <para>The height of the new image.</para>
	/// </param>
	///
	/// <param name="hasMask">
	/// <para>Set to <see langword="null"/> if the optional mask
	/// should also be created.</para>
	/// </param>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>The <paramref name="width"/> or <paramref name="height"/>
	/// values are out of range.</para>
	/// </exception>
	public Image(Screen screen, int width, int height, bool hasMask)
			{
				pixmap = new Xsharp.Pixmap(screen, width, height);
				screen = pixmap.screen;
				if(hasMask)
				{
					mask = new Bitmap(screen, width, height);
				}
				else
				{
					mask = null;
				}
			}
	// Draw a bitmap-based glyph to a "Graphics" object.  "bits" must be
	// in the form of an xbm bitmap.
	public override void DrawGlyph(int x, int y,
				   				   byte[] bits, int bitsWidth, int bitsHeight,
				   				   System.Drawing.Color color)
			{
				Xsharp.Bitmap bitmap;
				bitmap = new Xsharp.Bitmap(bitsWidth, bitsHeight, bits);
				try
				{
					graphics.Foreground = DrawingToolkit.DrawingToXColor(color);
					graphics.SetFillStippled(bitmap, x, y);
					graphics.FillRectangle(x, y, bitsWidth, bitsHeight);
					graphics.SetFillSolid();
				}
				finally
				{
					bitmap.Destroy();
				}
			}
	// Get the bitmap corresponding to a particular hatch style.
	private static Xsharp.Bitmap GetBitmap(HatchStyle style)
			{
				Xsharp.Bitmap bitmap;

				// See if we have a cached bitmap for this style.
				if(((int)style) >= 0 && ((int)style) <= 52)
				{
					if(hatchBitmaps == null)
					{
						hatchBitmaps = new Xsharp.Bitmap [53];
					}
					bitmap = hatchBitmaps[(int)style];
					if(bitmap != null)
					{
						return bitmap;
					}
				}
				else
				{
					return null;
				}

				// Get the raw bits for the hatch bitmap.
				byte[] bits = GetBits(style);
				if(bits == null)
				{
					return null;
				}

				// Create the bitmap, cache it for later, and then return it.
				bitmap = new Xsharp.Bitmap(16, 16, bits);
				hatchBitmaps[(int)style] = bitmap;
				return bitmap;
			}
示例#13
0
	/// <summary>
	/// <para>Set the fill style mode to "solid".</para>
	/// </summary>
	public void SetFillSolid()
			{
				try
				{
					IntPtr display = Lock();
					Xlib.XSetFillStyle
						(display, gc, (int)(Xsharp.FillStyle.FillSolid));
					if(tile != null)
					{
						Xlib.XSetTSOrigin(display, gc, 0, 0);
						tile = null;
					}
					else if(stipple != null)
					{
						Xlib.XSetTSOrigin(display, gc, 0, 0);
						stipple = null;
					}
				}
				finally
				{
					dpy.Unlock();
				}
			}
示例#14
0
	/// <summary>
	/// <para>Set the clip area to a bitmap mask, with a specified
	/// clip origin.</para>
	/// </summary>
	///
	/// <param name="mask">
	/// <para>The mask to set, or <see langword="null"/> to clear the
	/// clip mask.</para>
	/// </param>
	///
	/// <param name="xorigin">
	/// <para>The X co-ordinate of the clipping origin.</para>
	/// </param>
	///
	/// <param name="yorigin">
	/// <para>The Y co-ordinate of the clipping origin.</para>
	/// </param>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>The <paramref name="xorigin"/> or <paramref name="yorigin"/>
	/// value is out of range.</para>
	/// </exception>
	///
	/// <exception cref="T:System.XInvalidOperationException">
	/// <para>The <paramref name="mask"/> value is disposed.</para>
	/// </exception>
	public void SetClipMask(Bitmap mask, int xorigin, int yorigin)
			{
				if(xorigin < -32768 || xorigin > 32767 ||
				   yorigin < -32768 || yorigin > 32767)
				{
					throw new XException(S._("X_PointCoordRange"));
				}
				try
				{
					IntPtr display = Lock();
					Xlib.XSetClipOrigin(display, gc, xorigin, yorigin);
					if(mask != null)
					{
						Xlib.XSetClipMask(display, gc, mask.GetPixmapHandle());
					}
					else
					{
						Xlib.XSetClipMask(display, gc, XPixmap.Zero);
					}
				}
				finally
				{
					dpy.Unlock();
				}
			}
示例#15
0
	/// <summary>
	/// <para>Set the clip area to a bitmap mask</para>
	/// </summary>
	///
	/// <param name="mask">
	/// <para>The mask to set, or <see langword="null"/> to clear the
	/// clip mask.</para>
	/// </param>
	///
	/// <exception cref="T:System.XInvalidOperationException">
	/// <para>The <paramref name="mask"/> value is disposed.</para>
	/// </exception>
	public void SetClipMask(Bitmap mask)
			{
				try
				{
					IntPtr display = Lock();
					Xlib.XSetClipOrigin(display, gc, 0, 0);
					if(mask != null)
					{
						Xlib.XSetClipMask(display, gc, mask.GetPixmapHandle());
					}
					else
					{
						Xlib.XSetClipMask(display, gc, XPixmap.Zero);
					}
				}
				finally
				{
					dpy.Unlock();
				}
			}
示例#16
0
	/// <summary>
	/// <para>Set the fill style mode to "opaque stippled", with a specific
	/// stippling bitmap.</para>
	/// </summary>
	///
	/// <param name="stipple">
	/// <para>The stippling bitmap to use.</para>
	/// </param>
	///
	/// <param name="xorigin">
	/// <para>The X co-ordinate of the stippling origin.</para>
	/// </param>
	///
	/// <param name="yorigin">
	/// <para>The Y co-ordinate of the stippling origin.</para>
	/// </param>
	///
	/// <exception cref="T:System.ArgumentNullException">
	/// <para>The <paramref name="stipple"/> value is
	/// <see langword="null"/>.</para>
	/// </exception>
	///
	/// <exception cref="T:Xsharp.XException">
	/// <para>The <paramref name="xorigin"/> or <paramref name="yorigin"/>
	/// value is out of range.</para>
	/// </exception>
	///
	/// <exception cref="T:System.XInvalidOperationException">
	/// <para>The <paramref name="tile"/> value is disposed.</para>
	/// </exception>
	public void SetFillOpaqueStippled(Bitmap stipple, int xorigin, int yorigin)
			{
				if(stipple == null)
				{
					throw new ArgumentNullException("stipple");
				}
				if(xorigin < -32768 || xorigin > 32767 ||
				   yorigin < -32768 || yorigin > 32767)
				{
					throw new XException(S._("X_PointCoordRange"));
				}
				try
				{
					IntPtr display = Lock();
					Xlib.XSetStipple(display, gc, stipple.GetPixmapHandle());
					Xlib.XSetFillStyle
						(display, gc,
						 (int)(Xsharp.FillStyle.FillOpaqueStippled));
					Xlib.XSetTSOrigin(display, gc, xorigin, yorigin);
					this.stipple = stipple;
					tile = null;
				}
				finally
				{
					dpy.Unlock();
				}
			}