diff options
Diffstat (limited to 'source/ShiftUI/System.Windows.Forms.VisualStyles/GtkPlus.cs')
| -rw-r--r-- | source/ShiftUI/System.Windows.Forms.VisualStyles/GtkPlus.cs | 1774 |
1 files changed, 1774 insertions, 0 deletions
diff --git a/source/ShiftUI/System.Windows.Forms.VisualStyles/GtkPlus.cs b/source/ShiftUI/System.Windows.Forms.VisualStyles/GtkPlus.cs new file mode 100644 index 0000000..ea5fb88 --- /dev/null +++ b/source/ShiftUI/System.Windows.Forms.VisualStyles/GtkPlus.cs @@ -0,0 +1,1774 @@ +// +// GtkPlus.cs: Wraps GTK+, exposing its Widget painting features to code +// that uses System.Drawing types (such as IDeviceContext, Rectangle). +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2008 George Giolfan +// +// Authors: +// George Giolfan ([email protected]) +// + +using gpointer = System.IntPtr; +using gboolean = System.Boolean; +using gint = System.Int32; +using guint = System.UInt32; +using guint8 = System.Byte; +using guint16 = System.UInt16; +using guint32 = System.UInt32; +using gfloat = System.Single; +using gdouble = System.Double; + +using PangoFontDescriptionPointer = System.IntPtr; + +using GDataPointer = System.IntPtr; +using GObjectPointer = System.IntPtr; +using GSListPointer = System.IntPtr; +using GType = System.IntPtr; +using GTypeClassPointer = System.IntPtr; +using GTypeInstancePointer = System.IntPtr; + +using GdkColormapPointer = System.IntPtr; +using GdkDrawablePointer = System.IntPtr; +using GdkGCPointer = System.IntPtr; +using GdkNativeWindowPointer = System.IntPtr; +using GdkPixbufPointer = System.IntPtr; +using GdkPixmapPointer = System.IntPtr; +using GdkWindowPointer = System.IntPtr; + +using GtkAdjustmentPointer = System.IntPtr; +using GtkBinPointer = System.IntPtr; +using GtkContainerPointer = System.IntPtr; +using GtkObjectPointer = System.IntPtr; +using GtkStylePointer = System.IntPtr; +using GtkToolbarPointer = System.IntPtr; +using GtkToolItemPointer = System.IntPtr; +using GtkTreeViewPointer = System.IntPtr; +using GtkTreeViewColumnPointer = System.IntPtr; +using GtkWidgetPointer = System.IntPtr; +using GtkWindowPointer = System.IntPtr; + +using GtkAllocation = ShiftUI.VisualStyles.GtkPlus.GdkRectangle; +using GInitiallyUnowned = ShiftUI.VisualStyles.GtkPlus.GObject; + +using System.Collections; +using System.Drawing; +using System.Drawing.Imaging; +using System.Reflection; +using System.Reflection.Emit; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI.VisualStyles +{ + /// <summary> + /// </summary> + /// <remarks> + /// Inspired by ThemeGtk and QGtkStyle (http://labs.trolltech.com/page/Projects/Styles/GtkStyle). Tries to use the exact GTK+ logic in order to be compatible with all its themes. + /// </remarks> + class GtkPlus + { + #region Instance + static GtkPlus instance; + public static GtkPlus Instance { + get { return instance; } + } + #endregion + #region GTK+ initialization + public static bool Initialize () + { + try { + if (gtk_check_version (2, 10, 0) != IntPtr.Zero) + return false; + //TODO: If we need to pass the actual arguments, duplicate the required code from GTK#. + int argc = 0; + string [] argv = new string [1]; + bool result = gtk_init_check (ref argc, ref argv); + if (result) + instance = new GtkPlus (); + return result; + } catch (DllNotFoundException) { + return false; + } + } + #endregion + + #region Fields + readonly int WidgetTypeCount = Enum.GetNames (typeof (WidgetType)).Length; + readonly GtkWidgetPointer [] widgets; + readonly GtkWidgetPointer window; + readonly GtkWidgetPointer @fixed; + readonly GtkStylePointer [] styles; + #region ComboBox + readonly GtkWidgetPointer combo_box_drop_down_toggle_button; + readonly GtkWidgetPointer combo_box_drop_down_arrow; + GtkStylePointer combo_box_drop_down_toggle_button_style; + GtkStylePointer combo_box_drop_down_arrow_style; + #endregion + #region ToolBar + readonly GtkWidgetPointer tool_bar_button; + readonly GtkWidgetPointer tool_bar_toggle_button; + GtkStylePointer tool_bar_button_style; + GtkStylePointer tool_bar_toggle_button_style; + #endregion + #region TreeView + readonly GtkTreeViewColumnPointer tree_view_column; + readonly GtkWidgetPointer tree_view_column_button; + GtkStylePointer tree_view_column_button_style; + #endregion + #region Painters + readonly ButtonPainter button_painter = new ButtonPainter (); + readonly CheckBoxPainter check_box_painter = new CheckBoxPainter (); + readonly RadioButtonPainter radio_button_painter = new RadioButtonPainter (); + #region ComboBox + readonly ComboBoxDropDownButtonPainter combo_box_drop_down_button_painter = new ComboBoxDropDownButtonPainter (); + readonly ComboBoxBorderPainter combo_box_border_painter = new ComboBoxBorderPainter (); + #endregion + #region GroupBox + readonly GroupBoxPainter group_box_painter = new GroupBoxPainter (); + #endregion + #region Header + readonly HeaderPainter header_painter = new HeaderPainter (); + #endregion + #region ProgressBar + readonly ProgressBarBarPainter progress_bar_bar_painter = new ProgressBarBarPainter (); + readonly ProgressBarChunkPainter progress_bar_chunk_painter = new ProgressBarChunkPainter (); + #endregion + #region ScrollBar + readonly ScrollBarArrowButtonPainter scroll_bar_arrow_button_painter = new ScrollBarArrowButtonPainter (); + readonly ScrollBarThumbButtonPainter scroll_bar_thumb_button_painter = new ScrollBarThumbButtonPainter (); + readonly ScrollBarTrackPainter scroll_bar_track_painter = new ScrollBarTrackPainter (); + #endregion + #region StatusBar + readonly StatusBarGripperPainter status_bar_gripper_painter = new StatusBarGripperPainter (); + #endregion + #region TabWidget + readonly TabWidgetPanePainter tab_Widget_pane_painter = new TabWidgetPanePainter (); + readonly TabWidgetTabItemPainter tab_Widget_tab_item_painter = new TabWidgetTabItemPainter (); + #endregion + readonly TextBoxPainter text_box_painter = new TextBoxPainter (); + #region ToolBar + readonly ToolBarPainter tool_bar_painter = new ToolBarPainter (); + readonly ToolBarButtonPainter tool_bar_button_painter = new ToolBarButtonPainter (); + readonly ToolBarCheckedButtonPainter tool_bar_checked_button_painter = new ToolBarCheckedButtonPainter (); + #endregion + #region TrackBar + readonly TrackBarTrackPainter track_bar_track_painter = new TrackBarTrackPainter (); + readonly TrackBarThumbPainter track_bar_thumb_painter = new TrackBarThumbPainter (); + #endregion + readonly TreeViewGlyphPainter tree_view_glyph_painter = new TreeViewGlyphPainter (); + readonly UpDownPainter up_down_painter = new UpDownPainter (); + #endregion + #endregion + #region Constructor and finalizer + protected GtkPlus () + { + widgets = new GtkWidgetPointer [WidgetTypeCount]; + styles = new GtkStylePointer [WidgetTypeCount]; + window = gtk_window_new (GtkWindowType.GTK_WINDOW_TOPLEVEL); + @fixed = gtk_fixed_new (); + gtk_container_add (window, @fixed); + #region Widget types + #region Button + gtk_container_add (@fixed, widgets [(int)WidgetType.Button] = gtk_button_new ()); + GTK_WIDGET_SET_FLAGS (widgets [(int)WidgetType.Button], GtkWidgetFlags.GTK_CAN_DEFAULT); + #endregion + #region CheckBox + gtk_container_add (@fixed, widgets [(int)WidgetType.CheckBox] = gtk_check_button_new ()); + #endregion + #region ComboBox + gtk_container_add (@fixed, widgets [(int)WidgetType.ComboBox] = gtk_combo_box_entry_new ()); + gtk_widget_realize (widgets [(int)WidgetType.ComboBox]); + combo_box_drop_down_toggle_button = GetFirstChildWidgetOfType.Get (widgets [(int)WidgetType.ComboBox], gtk_toggle_button_get_type ()); + gtk_widget_realize (combo_box_drop_down_toggle_button); + combo_box_drop_down_arrow = GetFirstChildWidgetOfType.Get (combo_box_drop_down_toggle_button, gtk_arrow_get_type ()); + g_object_ref (combo_box_drop_down_toggle_button_style = GetWidgetStyle (combo_box_drop_down_toggle_button)); + g_object_ref (combo_box_drop_down_arrow_style = GetWidgetStyle (combo_box_drop_down_arrow)); + #endregion + #region GroupBox + gtk_container_add (@fixed, widgets [(int)WidgetType.GroupBox] = gtk_frame_new (null)); + #endregion + #region ProgressBar + gtk_container_add (@fixed, widgets [(int)WidgetType.ProgressBar] = gtk_progress_bar_new ()); + #endregion + #region RadioButton + gtk_container_add (@fixed, widgets [(int)WidgetType.RadioButton] = gtk_radio_button_new (IntPtr.Zero)); + #endregion + #region ScrollBar + gtk_container_add (@fixed, widgets [(int)WidgetType.HScrollBar] = gtk_hscrollbar_new (IntPtr.Zero)); + gtk_container_add (@fixed, widgets [(int)WidgetType.VScrollBar] = gtk_vscrollbar_new (IntPtr.Zero)); + #endregion + #region StatusBar + gtk_container_add (@fixed, widgets [(int)WidgetType.StatusBar] = gtk_statusbar_new ()); + #endregion + #region TabWidget + gtk_container_add (@fixed, widgets [(int)WidgetType.TabWidget] = gtk_notebook_new ()); + #endregion + #region TextBox + gtk_container_add (@fixed, widgets [(int)WidgetType.TextBox] = gtk_entry_new ()); + #endregion + #region ToolBar + gtk_container_add (@fixed, widgets [(int)WidgetType.ToolBar] = gtk_toolbar_new ()); + + GtkToolItemPointer tool_button = gtk_tool_button_new (IntPtr.Zero, null); + gtk_toolbar_insert (widgets [(int)WidgetType.ToolBar], tool_button, -1); + tool_bar_button = gtk_bin_get_child (tool_button); + g_object_ref (tool_bar_button_style = GetWidgetStyle (tool_bar_button)); + + GtkToolItemPointer toggle_tool_button = gtk_toggle_tool_button_new (); + gtk_toolbar_insert (widgets [(int)WidgetType.ToolBar], toggle_tool_button, -1); + tool_bar_toggle_button = gtk_bin_get_child (toggle_tool_button); + g_object_ref (tool_bar_toggle_button_style = GetWidgetStyle (tool_bar_toggle_button)); + #endregion + #region TrackBar + gtk_container_add (@fixed, widgets [(int)WidgetType.HorizontalTrackBar] = gtk_hscale_new_with_range (0, 1, 1)); + gtk_container_add (@fixed, widgets [(int)WidgetType.VerticalTrackBar] = gtk_vscale_new_with_range (0, 1, 1)); + #endregion + #region TreeView + gtk_container_add (@fixed, widgets [(int)WidgetType.TreeView] = gtk_tree_view_new ()); + tree_view_column = gtk_tree_view_column_new (); + gtk_tree_view_insert_column (widgets [(int)WidgetType.TreeView], tree_view_column, -1); + GtkTreeViewColumn column_structure = (GtkTreeViewColumn)Marshal.PtrToStructure (tree_view_column, typeof (GtkTreeViewColumn)); + tree_view_column_button = column_structure.button; + g_object_ref (tree_view_column_button_style = GetWidgetStyle (tree_view_column_button)); + #endregion + #region UpDown + GtkAdjustmentPointer adjustment = gtk_adjustment_new (0, 0, 0, 0, 0, 0); + gtk_container_add (@fixed, widgets [(int)WidgetType.UpDown] = gtk_spin_button_new (adjustment, 0, 0)); + #endregion + #endregion + for (int widget_index = 0; widget_index < WidgetTypeCount; widget_index++) + g_object_ref (styles [widget_index] = GetWidgetStyle (widgets [widget_index])); + } + ~GtkPlus () + { + gtk_object_destroy (window); + for (int widget_index = 0; widget_index < WidgetTypeCount; widget_index++) + g_object_unref (styles [widget_index]); + #region ComboBox + g_object_unref (combo_box_drop_down_toggle_button_style); + g_object_unref (combo_box_drop_down_arrow_style); + #endregion + #region ToolBar + g_object_unref (tool_bar_button_style); + g_object_unref (tool_bar_toggle_button_style); + #endregion + #region TreeView + g_object_unref (tree_view_column_button_style); + #endregion + } + #endregion + #region Widgets + #region Button + public void ButtonPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, bool @default, GtkPlusState state) + { + button_painter.Configure (@default, state); + Paint (WidgetType.Button, bounds, dc, clippingArea, button_painter); + } + #endregion + #region CheckBox + public void CheckBoxPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, GtkPlusToggleButtonValue value) + { + check_box_painter.Configure (state, value); + Paint (WidgetType.CheckBox, bounds, dc, clippingArea, check_box_painter); + } + Size GetGtkCheckButtonIndicatorSize (WidgetType widgetType) + { + int indicator_size = GetWidgetStyleInteger (widgets [(int)widgetType], "indicator-size"); + return new Size (indicator_size, indicator_size); + } + public Size CheckBoxGetSize () + { + return GetGtkCheckButtonIndicatorSize (WidgetType.CheckBox); + } + #endregion + #region ComboBox + public void ComboBoxPaintDropDownButton (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state) + { + combo_box_drop_down_button_painter.Configure (state); + Paint (WidgetType.ComboBox, bounds, dc, clippingArea, combo_box_drop_down_button_painter); + } + public void ComboBoxPaintBorder (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.ComboBox, bounds, dc, clippingArea, combo_box_border_painter); + } + #endregion + #region GroupBox + public void GroupBoxPaint (IDeviceContext dc, Rectangle bounds, Rectangle excludedArea, GtkPlusState state) + { + group_box_painter.Configure (state); + PaintExcludingArea (WidgetType.GroupBox, bounds, dc, excludedArea, group_box_painter); + } + #endregion + #region Header + public void HeaderPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state) + { + header_painter.Configure (state); + Paint (WidgetType.TreeView, bounds, dc, clippingArea, header_painter); + } + #endregion + #region ProgressBar + public void ProgressBarPaintBar (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.ProgressBar, bounds, dc, clippingArea, progress_bar_bar_painter); + } + public void ProgressBarPaintChunk (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.ProgressBar, bounds, dc, clippingArea, progress_bar_chunk_painter); + } + public Rectangle ProgressBarGetBackgroundContentRectagle (Rectangle bounds) + { + GtkStyle style = (GtkStyle)Marshal.PtrToStructure (gtk_widget_get_style (widgets [(int)WidgetType.ProgressBar]), typeof(GtkStyle)); + bounds.Inflate (-style.xthickness, -style.ythickness); + return bounds; + } + #endregion + #region RadioButton + public void RadioButtonPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, GtkPlusToggleButtonValue value) + { + radio_button_painter.Configure (state, value); + Paint (WidgetType.RadioButton, bounds, dc, clippingArea, radio_button_painter); + } + public Size RadioButtonGetSize () + { + return GetGtkCheckButtonIndicatorSize (WidgetType.RadioButton); + } + #endregion + #region ScrollBar + public void ScrollBarPaintArrowButton (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, bool horizontal, bool upOrLeft) + { + scroll_bar_arrow_button_painter.Configure (state, horizontal, upOrLeft); + Paint (horizontal ? WidgetType.HScrollBar : WidgetType.VScrollBar, bounds, dc, clippingArea, scroll_bar_arrow_button_painter); + } + public void ScrollBarPaintThumbButton (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, bool horizontal) + { + scroll_bar_thumb_button_painter.Configure (state, horizontal); + Paint (horizontal ? WidgetType.HScrollBar : WidgetType.VScrollBar, bounds, dc, clippingArea, scroll_bar_thumb_button_painter); + } + public void ScrollBarPaintTrack (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, bool horizontal, bool upOrLeft) + { + scroll_bar_track_painter.Configure (state, upOrLeft); + Paint (horizontal ? WidgetType.HScrollBar : WidgetType.VScrollBar, bounds, dc, clippingArea, scroll_bar_track_painter); + } + #endregion + #region StatusBar + public void StatusBarPaintGripper (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.StatusBar, bounds, dc, clippingArea, status_bar_gripper_painter); + } + #endregion + #region TabWidget + public void TabWidgetPaintPane (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.TabWidget, bounds, dc, clippingArea, tab_Widget_pane_painter); + } + public void TabWidgetPaintTabItem (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state) + { + tab_Widget_tab_item_painter.Configure (state); + Paint (WidgetType.TabWidget, bounds, dc, clippingArea, tab_Widget_tab_item_painter); + } + #endregion + #region TextBox + public void TextBoxPaint (IDeviceContext dc, Rectangle bounds, Rectangle excludedArea, GtkPlusState state) + { + text_box_painter.Configure (state); + PaintExcludingArea (WidgetType.TextBox, bounds, dc, excludedArea, text_box_painter); + } + #endregion + #region ToolBar + public void ToolBarPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetType.ToolBar, bounds, dc, clippingArea, tool_bar_painter); + } + public void ToolBarPaintButton (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state) + { + tool_bar_button_painter.Configure (state); + Paint (WidgetTypeNotNeeded, bounds, dc, clippingArea, tool_bar_button_painter); + } + public void ToolBarPaintCheckedButton (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea) + { + Paint (WidgetTypeNotNeeded, bounds, dc, clippingArea, tool_bar_checked_button_painter); + } + #endregion + #region TrackBar + public void TrackBarPaintTrack (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, bool horizontal) + { + Paint (horizontal ? WidgetType.HorizontalTrackBar : WidgetType.VerticalTrackBar, bounds, dc, clippingArea, track_bar_track_painter); + } + public void TrackBarPaintThumb (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, GtkPlusState state, bool horizontal) + { + track_bar_thumb_painter.Configure (state, horizontal); + Paint (horizontal ? WidgetType.HorizontalTrackBar : WidgetType.VerticalTrackBar, bounds, dc, clippingArea, track_bar_thumb_painter); + } + #endregion + #region TreeView + public void TreeViewPaintGlyph (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, bool closed) + { + tree_view_glyph_painter.Configure (closed); + Paint (WidgetType.TreeView, bounds, dc, clippingArea, tree_view_glyph_painter); + } + #endregion + #region UpDown + public void UpDownPaint (IDeviceContext dc, Rectangle bounds, Rectangle clippingArea, bool up, GtkPlusState state) + { + up_down_painter.Configure (up, state); + Paint (WidgetType.UpDown, bounds, dc, clippingArea, up_down_painter); + } + #endregion + #endregion + #region Painting + void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, Rectangle clippingArea, Painter painter) + { + Paint (widgetType, bounds, dc, TransparencyType.Alpha, Color.Black, DeviceContextType.Native, clippingArea, painter, Rectangle.Empty); + } + void PaintExcludingArea (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, Rectangle excludedArea, Painter painter) + { + Paint (widgetType, bounds, dc, TransparencyType.Alpha, Color.Black, DeviceContextType.Native, bounds, painter, excludedArea); + } + void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, TransparencyType transparencyType, Color background, DeviceContextType deviceContextType, Rectangle clippingArea, Painter painter, Rectangle excludedArea) + { + Rectangle painted_area = Rectangle.Intersect (bounds, clippingArea); + if (painted_area.Width == 0 || painted_area.Height == 0) + return; + painted_area.Offset (-bounds.X, -bounds.Y); + excludedArea.Offset (-bounds.X, -bounds.Y); + GdkDrawablePointer drawable = gdk_pixmap_new (IntPtr.Zero, bounds.Width, bounds.Height, 24); + painter.AttachStyle (widgetType, drawable, this); + GdkPixbufPointer pixbuf; + IntPtr pixel_data; + int rowstride; + GdkGCPointer gc = gdk_gc_new (drawable); + GdkColor color = new GdkColor (background); + gdk_gc_set_rgb_fg_color (gc, ref color); + Paint (drawable, gc, bounds, widgetType, out pixbuf, out pixel_data, out rowstride, painted_area, painter, excludedArea); + GdkPixbufPointer white_pixbuf = IntPtr.Zero; + IntPtr white_pixel_data = IntPtr.Zero; + int white_rowstride = 0; + GdkColor white_color = new GdkColor(); + if (transparencyType == TransparencyType.Alpha) { + white_color.red = guint16.MaxValue; + white_color.green = guint16.MaxValue; + white_color.blue = guint16.MaxValue; + gdk_gc_set_rgb_fg_color (gc, ref white_color); + Paint (drawable, gc, bounds, widgetType, out white_pixbuf, out white_pixel_data, out white_rowstride, painted_area, painter, excludedArea); + } + g_object_unref (gc); + unsafe { + byte* row = (byte*)pixel_data; + byte* pixel; + byte* white_row = (byte*)white_pixel_data; + byte* white_pixel; + + for (int row_index = 0; row_index < painted_area.Height; row_index++) { + pixel = row; + white_pixel = white_row; + for (int pixel_index = 0; pixel_index < painted_area.Width; pixel_index++) { + const int GdkRedOffset = 0; + const int GdkGreenOffset = 1; + const int GdkBlueOffset = 2; + const int BitmapAlphaOffset = 3; + const int BitmapRedOffset = 2; + const int BitmapBlueOffset = 0; + switch (transparencyType) { + case TransparencyType.Alpha: + pixel [BitmapAlphaOffset] = (byte)(pixel [GdkRedOffset] - white_pixel [GdkRedOffset] + byte.MaxValue); + break; + case TransparencyType.Color: + if ( + pixel [GdkRedOffset] == background.R && + pixel [GdkGreenOffset] == background.G && + pixel [GdkBlueOffset] == background.B) { + const int AlphaFullyTransparent = 0; + pixel [BitmapAlphaOffset] = AlphaFullyTransparent; + } + break; + } + + byte temporary = pixel [GdkRedOffset]; + pixel [BitmapBlueOffset] = pixel [GdkBlueOffset]; + pixel [BitmapRedOffset] = temporary; + + const int PixelSize = 4; + pixel += PixelSize; + white_pixel += PixelSize; + } + row += rowstride; + white_row += white_rowstride; + } + } + if (transparencyType == TransparencyType.Alpha) + g_object_unref (white_pixbuf); + g_object_unref (drawable); + Bitmap bitmap = new Bitmap (painted_area.Width, painted_area.Height, rowstride, PixelFormat.Format32bppPArgb, pixel_data); + Graphics g; + bool graphics_is_from_hdc = false; + switch (deviceContextType) { + case DeviceContextType.Graphics: + g = (Graphics)dc; + break; + case DeviceContextType.Native: + g = Graphics.FromHdc (dc.GetHdc ()); + break; + default: + g = dc as Graphics; + if (g == null) { + graphics_is_from_hdc = true; + g = Graphics.FromHdc (dc.GetHdc ()); + } else + graphics_is_from_hdc = false; + break; + } + painted_area.Offset (bounds.X, bounds.Y); + g.DrawImage (bitmap, painted_area.Location); + switch (deviceContextType) { + case DeviceContextType.Graphics: + break; + case DeviceContextType.Native: + g.Dispose (); + dc.ReleaseHdc (); + break; + default: + if (graphics_is_from_hdc) { + g.Dispose (); + dc.ReleaseHdc (); + } + break; + } + bitmap.Dispose (); + g_object_unref (pixbuf); + } + void Paint (GdkDrawablePointer drawable, GdkGCPointer gc, Rectangle rectangle, WidgetType widgetType, out GdkPixbufPointer pixbuf, out IntPtr pixelData, out int rowstride, Rectangle clippingArea, Painter painter, Rectangle excludedArea) + { + gdk_draw_rectangle (drawable, gc, true, clippingArea.X, clippingArea.Y, clippingArea.Width, clippingArea.Height); + painter.Paint (styles [(int)widgetType], drawable, new GdkRectangle(clippingArea), widgets [(int)widgetType], 0, 0, rectangle.Width, rectangle.Height, this); + if (excludedArea.Width != 0) + gdk_draw_rectangle (drawable, gc, true, excludedArea.X, excludedArea.Y, excludedArea.Width, excludedArea.Height); + if ( + (pixbuf = gdk_pixbuf_new (GdkColorspace.GDK_COLORSPACE_RGB, true, 8, clippingArea.Width, clippingArea.Height)) == IntPtr.Zero || + gdk_pixbuf_get_from_drawable (pixbuf, drawable, IntPtr.Zero, clippingArea.X, clippingArea.Y, 0, 0, clippingArea.Width, clippingArea.Height) == IntPtr.Zero) + throw new OutOfMemoryException (); + pixelData = gdk_pixbuf_get_pixels (pixbuf); + rowstride = gdk_pixbuf_get_rowstride (pixbuf); + } + abstract class Painter + { + public virtual void AttachStyle (WidgetType widgetType, GdkDrawablePointer drawable, GtkPlus gtkPlus) + { + gtkPlus.styles [(int)widgetType] = gtk_style_attach (gtkPlus.styles [(int)widgetType], drawable); + } + public abstract void Paint (GtkStylePointer style, GdkWindowPointer window, GdkRectangle area, GtkWidgetPointer widget, gint x, gint y, gint width, gint height, GtkPlus gtkPlus); + } + enum TransparencyType + { + None, + Color, + Alpha + } + enum DeviceContextType + { + Unknown, + Graphics, + Native + } + #endregion + #region Painters + #region Button + class ButtonPainter : Painter + { + bool @default; + GtkPlusState state; + public void Configure (bool @default, GtkPlusState state) { + this.@default = @default; + this.state = state; + } + public override void Paint (GtkStylePointer style, GdkWindowPointer window, GdkRectangle area, GtkWidgetPointer widget, gint x, gint y, gint width, gint height, GtkPlus gtkPlus) + { + if (@default) { + gtk_window_set_default (gtkPlus.window, widget); + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + "buttondefault", + x, y, width, height); + gtk_window_set_default (gtkPlus.window, IntPtr.Zero); + } else + gtk_paint_box ( + style, + window, + (GtkStateType)state, + state == GtkPlusState.Pressed ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT, + ref area, + widget, + "button", + x, y, width, height); + } + } + #endregion + #region CheckBox, RadioButton + abstract class ToggleButtonPainter : Painter + { + GtkPlusState state; + GtkPlusToggleButtonValue value; + public void Configure (GtkPlusState state, GtkPlusToggleButtonValue value) + { + this.state = state; + this.value = value; + } + public override void Paint (GtkStylePointer style, GdkWindowPointer window, GdkRectangle area, GtkWidgetPointer widget, gint x, gint y, gint width, gint height, GtkPlus gtkPlus) + { + PaintFunction ( + style, + window, + (GtkStateType)state, + (GtkShadowType)value, + ref area, + widget, + Detail, + x, y, width,height); + } + protected abstract string Detail { get; } + protected abstract ToggleButtonPaintFunction PaintFunction { get; } + } + delegate void ToggleButtonPaintFunction (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, gint x, gint y, gint width, gint height); + class CheckBoxPainter : ToggleButtonPainter + { + protected override string Detail { + get { + return "checkbutton"; + } + } + protected override ToggleButtonPaintFunction PaintFunction { + get { + return gtk_paint_check; + } + } + } + class RadioButtonPainter : ToggleButtonPainter + { + protected override string Detail { + get { + return "radiobutton"; + } + } + protected override ToggleButtonPaintFunction PaintFunction { + get { + return gtk_paint_option; + } + } + } + #endregion + #region ComboBox + class ComboBoxDropDownButtonPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) + { + this.state = state; + } + public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus) + { + gtkPlus.combo_box_drop_down_toggle_button_style = gtk_style_attach (gtkPlus.combo_box_drop_down_toggle_button_style, drawable); + gtkPlus.combo_box_drop_down_arrow_style = gtk_style_attach (gtkPlus.combo_box_drop_down_arrow_style, drawable); + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + GtkShadowType shadow_type; + switch (state) { + case GtkPlusState.Disabled: + shadow_type = GtkShadowType.GTK_SHADOW_ETCHED_IN; + break; + case GtkPlusState.Pressed: + shadow_type = GtkShadowType.GTK_SHADOW_IN; + break; + default: + shadow_type = GtkShadowType.GTK_SHADOW_OUT; + break; + } + gtk_paint_box ( + gtkPlus.combo_box_drop_down_toggle_button_style, + window, + (GtkStateType)state, + shadow_type, + ref area, + gtkPlus.combo_box_drop_down_toggle_button, + "button", + x, y, width, height); + GtkMisc misc = (GtkMisc)Marshal.PtrToStructure (gtkPlus.combo_box_drop_down_arrow, typeof (GtkMisc)); + int extent = (int)(Math.Min (width - misc.xpad * 2, height - misc.ypad * 2) * GetWidgetStyleSingle (gtkPlus.combo_box_drop_down_arrow, "arrow-scaling")); + gtk_paint_arrow ( + gtkPlus.combo_box_drop_down_arrow_style, + window, + (GtkStateType)state, + GtkShadowType.GTK_SHADOW_NONE, + ref area, + gtkPlus.combo_box_drop_down_arrow, + "arrow", + GtkArrowType.GTK_ARROW_DOWN, + true, + (int)Math.Floor (x + misc.xpad + (width - extent) * misc.xalign), + (int)Math.Floor (y + misc.ypad + (height - extent) * misc.yalign), + extent, extent); + } + } + class ComboBoxBorderPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_shadow ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + "combobox", + x, y, width, height); + } + } + #endregion + #region GroupBox + class GroupBoxPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) + { + this.state = state; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_shadow ( + style, + window, + (GtkStateType)state, + GtkShadowType.GTK_SHADOW_ETCHED_IN, + ref area, + widget, + "frame", + x, y, width, height); + + } + } + #endregion + #region Header + class HeaderPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) + { + this.state = state; + } + public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus) + { + gtkPlus.tree_view_column_button_style = gtk_style_attach (gtkPlus.tree_view_column_button_style, drawable); + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + gtkPlus.tree_view_column_button_style, + window, + (GtkStateType)state, + state == GtkPlusState.Pressed ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT, + ref area, + gtkPlus.tree_view_column_button, + "button", + x, y, width, height); + } + } + #endregion + #region ProgressBar + class ProgressBarBarPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + "trough", + x, y, width, height); + } + } + class ProgressBarChunkPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_PRELIGHT, + GtkShadowType.GTK_SHADOW_OUT, + ref area, + widget, + "bar", + x, y, width, height); + } + } + #endregion + #region ScrollBar + class ScrollBarArrowButtonPainter : Painter + { + GtkPlusState state; + bool horizontal; + bool up_or_left; + public void Configure (GtkPlusState state, bool horizontal, bool upOrLeft) + { + this.state = state; + this.horizontal = horizontal; + up_or_left = upOrLeft; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gboolean can_focus; + g_object_get (widget, "can-focus", out can_focus, IntPtr.Zero); + if (can_focus) { + int focus_line_width; + int focus_padding; + gtk_widget_style_get (widget, + "focus-line-width", out focus_line_width, + "focus-padding", out focus_padding, + IntPtr.Zero); + int focus_width = focus_line_width + focus_padding; + if (horizontal) { + y -= focus_width; + height -= 2 * focus_width; + } else { + x -= focus_width; + width -= 2 * focus_width; + } + } + GtkShadowType shadow_type = state == GtkPlusState.Pressed ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT; + string detail = horizontal ? "hscrollbar" : "vscrollbar"; + gtk_paint_box ( + style, + window, + (GtkStateType)state, + shadow_type, + ref area, + widget, + detail, + x, y, width, height); + width /= 2; + height /= 2; + x += width / 2; + y += height / 2; + if (state == GtkPlusState.Pressed) { + int arrow_displacement_x; + int arrow_displacement_y; + gtk_widget_style_get (widget, + "arrow-displacement-x", out arrow_displacement_x, + "arrow-displacement-y", out arrow_displacement_y, + IntPtr.Zero); + x += arrow_displacement_x; + y += arrow_displacement_y; + } + gtk_paint_arrow ( + style, + window, + (GtkStateType)state, + shadow_type, + ref area, + widget, + detail, + horizontal ? up_or_left ? GtkArrowType.GTK_ARROW_LEFT : GtkArrowType.GTK_ARROW_RIGHT : up_or_left ? GtkArrowType.GTK_ARROW_UP : GtkArrowType.GTK_ARROW_DOWN, + true, + x, y, width, height); + } + } + abstract class RangeThumbButtonPainter : Painter + { + GtkPlusState state; + bool horizontal; + protected bool Horizontal { + get { return horizontal; } + } + public void Configure (GtkPlusState state, bool horizontal) + { + this.state = state; + this.horizontal = horizontal; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_slider ( + style, + window, + (GtkStateType)state, + state == GtkPlusState.Pressed && GetWidgetStyleBoolean (widget, "activate-slider") ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT, + ref area, + widget, + Detail, + x, y, width, height, + horizontal ? GtkOrientation.GTK_ORIENTATION_HORIZONTAL : GtkOrientation.GTK_ORIENTATION_VERTICAL); + } + protected abstract string Detail { get; } + } + class ScrollBarThumbButtonPainter : RangeThumbButtonPainter + { + protected override string Detail { + get { + return "slider"; + } + } + } + class ScrollBarTrackPainter : Painter + { + GtkPlusState state; + bool up_or_left; + public void Configure (GtkPlusState state, bool upOrLeft) + { + this.state = state; + up_or_left = upOrLeft; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + style, + window, + state == GtkPlusState.Pressed ? GtkStateType.GTK_STATE_ACTIVE : GtkStateType.GTK_STATE_INSENSITIVE, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + GetWidgetStyleBoolean (widget, "trough-side-details") ? + up_or_left ? "trough-upper" : "trough-lower" : + "trough", + x, y, width, height); + } + } + #endregion + #region StatusBar + class StatusBarGripperPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_resize_grip ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + ref area, + widget, + "statusbar", + GdkWindowEdge.GDK_WINDOW_EDGE_SOUTH_EAST, + x, y, width, height); + } + } + #endregion + #region TabWidget + class TabWidgetPanePainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box_gap ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GtkShadowType.GTK_SHADOW_OUT, + ref area, + widget, + "notebook", + x, y, width, height, + GtkPositionType.GTK_POS_TOP, + 0, + 0); + } + } + class TabWidgetTabItemPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) + { + this.state = state; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_extension ( + style, + window, + (GtkStateType)state, + GtkShadowType.GTK_SHADOW_OUT, + ref area, + widget, + "tab", + x, y, width, height, + GtkPositionType.GTK_POS_BOTTOM); + } + } + #endregion + #region TextBox + class TextBoxPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) + { + this.state = state; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_shadow ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + "entry", + x, y, width, height); + GtkStyle style_structure = (GtkStyle)Marshal.PtrToStructure (style, typeof (GtkStyle)); + x += style_structure.xthickness; + y += style_structure.ythickness; + width -= 2 * style_structure.xthickness; + height -= 2 * style_structure.ythickness; + gtk_paint_flat_box ( + style, + window, + (GtkStateType)state, + GtkShadowType.GTK_SHADOW_NONE, + ref area, + widget, + "entry_bg", + x, y, width, height); + } + } + #endregion + #region ToolBar + class ToolBarPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + GetWidgetStyleShadowType (widget), + ref area, + widget, + "toolbar", + x, y, width, height); + } + } + class ToolBarButtonPainter : Painter + { + GtkPlusState state; + public void Configure (GtkPlusState state) { + this.state = state; + } + public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus) + { + gtkPlus.tool_bar_button_style = gtk_style_attach (gtkPlus.tool_bar_button_style, drawable); + } + public override void Paint (GtkStylePointer style, GdkWindowPointer window, GdkRectangle area, GtkWidgetPointer widget, gint x, gint y, gint width, gint height, GtkPlus gtkPlus) + { + gtk_paint_box ( + gtkPlus.tool_bar_button_style, + window, + (GtkStateType)state, + state == GtkPlusState.Pressed ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT, + ref area, + gtkPlus.tool_bar_button, + "button", + x, y, width, height); + } + } + class ToolBarCheckedButtonPainter : Painter + { + public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus) + { + gtkPlus.tool_bar_toggle_button_style = gtk_style_attach (gtkPlus.tool_bar_toggle_button_style, drawable); + } + public override void Paint (GtkStylePointer style, GdkWindowPointer window, GdkRectangle area, GtkWidgetPointer widget, gint x, gint y, gint width, gint height, GtkPlus gtkPlus) + { + gtk_paint_box ( + gtkPlus.tool_bar_toggle_button_style, + window, + GtkStateType.GTK_STATE_ACTIVE, + GtkShadowType.GTK_SHADOW_IN, + ref area, + gtkPlus.tool_bar_toggle_button, + "button", + x, y, width, height); + } + } + #endregion + #region TrackBar + class TrackBarTrackPainter : Painter + { + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_ACTIVE, + GtkShadowType.GTK_SHADOW_IN, + ref area, + widget, + "trough", + x, y, width, height); + } + } + class TrackBarThumbPainter : RangeThumbButtonPainter + { + protected override string Detail { + get { + return Horizontal ? "hscale" : "vscale"; + } + } + } + #endregion + #region TreeView + class TreeViewGlyphPainter : Painter + { + bool closed; + public void Configure (bool closed) + { + this.closed = closed; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + gtk_paint_expander ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + ref area, + widget, + "treeview", + x + width / 2, + y + height / 2, + closed ? GtkExpanderStyle.GTK_EXPANDER_COLLAPSED : GtkExpanderStyle.GTK_EXPANDER_EXPANDED); + } + } + #endregion + #region UpDown + class UpDownPainter : Painter + { + bool up; + GtkPlusState state; + public void Configure (bool up, GtkPlusState state) + { + this.up = up; + this.state = state; + } + public override void Paint (IntPtr style, IntPtr window, GdkRectangle area, IntPtr widget, int x, int y, int width, int height, GtkPlus gtkPlus) + { + GtkShadowType shadow_type = GetWidgetStyleShadowType (widget); + if (shadow_type != GtkShadowType.GTK_SHADOW_NONE) + gtk_paint_box ( + style, + window, + GtkStateType.GTK_STATE_NORMAL, + shadow_type, + ref area, + widget, + "spinbutton", + x, y - (up ? 0 : height), width, height * 2); + shadow_type = state == GtkPlusState.Pressed ? GtkShadowType.GTK_SHADOW_IN : GtkShadowType.GTK_SHADOW_OUT; + gtk_paint_box ( + style, + window, + (GtkStateType)state, + shadow_type, + ref area, + widget, + up ? "spinbutton_up" : "spinbutton_down", + x, y, width, height); + if (up) + y += 2; + height -= 2; + width -= 3; + x += 1; + int w = width / 2; + w -= w % 2 - 1; + int h = (w + 1) / 2; + x += (width - w) / 2; + y += (height - h) / 2; + height = h; + width = w; + gtk_paint_arrow ( + style, + window, + (GtkStateType)state, + shadow_type, + ref area, + widget, + "spinbutton", + up ? GtkArrowType.GTK_ARROW_UP : GtkArrowType.GTK_ARROW_DOWN, + true, + x, y, width, height); + } + } + #endregion + #endregion + #region Widget types + const WidgetType WidgetTypeNotNeeded = (WidgetType)0; + enum WidgetType + { + Button, + CheckBox, + ComboBox, + GroupBox, + ProgressBar, + RadioButton, + #region ScrollBar + HScrollBar, + VScrollBar, + #endregion + StatusBar, + TabWidget, + TextBox, + ToolBar, + #region TrackBar + HorizontalTrackBar, + VerticalTrackBar, + #endregion + TreeView, + UpDown, + } + #endregion + #region GTK+ utility methods + static GtkShadowType GetWidgetStyleShadowType (GtkWidgetPointer widget) + { + GtkShadowType result; + gtk_widget_style_get (widget, "shadow-type", out result, IntPtr.Zero); + return result; + } + static int GetWidgetStyleInteger (GtkWidgetPointer widget, string propertyName) + { + gint result; + gtk_widget_style_get (widget, propertyName, out result, IntPtr.Zero); + return result; + } + static float GetWidgetStyleSingle (GtkWidgetPointer widget, string propertyName) + { + gfloat result; + gtk_widget_style_get (widget, propertyName, out result, IntPtr.Zero); + return result; + } + static bool GetWidgetStyleBoolean (GtkWidgetPointer widget, string propertyName) + { + gboolean result; + gtk_widget_style_get (widget, propertyName, out result, IntPtr.Zero); + return result; + } + #region GetFirstChildWidgetOfType + static class GetFirstChildWidgetOfType + { + public static GtkWidgetPointer Get (GtkContainerPointer parent, GType childType) + { + Type = childType; + Result = GtkWidgetPointer.Zero; + ContainersToSearch = new ArrayList (); + ContainersToSearch.Add (parent); + while (true) { + ArrayList containers_to_search = ContainersToSearch; + ContainersToSearch = new ArrayList (); + foreach (GtkContainerPointer container in containers_to_search) { + gtk_widget_realize (container); + gtk_container_forall (container, Callback, gpointer.Zero); + if (Result != GtkWidgetPointer.Zero) + return Result; + } + if (ContainersToSearch.Count == 0) + return GtkWidgetPointer.Zero; + } + } + static void Callback (GtkWidgetPointer widget, gpointer data) + { + if (Result != IntPtr.Zero) + return; + if (g_type_check_instance_is_a (widget, Type)) + Result = widget; + else if (g_type_check_instance_is_a (widget, gtk_container_get_type ())) + ContainersToSearch.Add (widget); + } + static GType Type; + static GtkWidgetPointer Result; + static ArrayList ContainersToSearch; + } + #endregion + static GtkStylePointer GetWidgetStyle (GtkWidgetPointer widget) + { + return gtk_rc_get_style (widget); + } + #endregion + #region Platform Invoke + #region Library names +#if VISUAL_STYLES_USE_GTKPLUS_ON_WINDOWS + const string GobjectLibraryName = "libgobject-2.0-0.dll"; + const string GdkLibraryName = "libgdk-win32-2.0-0.dll"; + const string GdkPixbufLibraryName = "libgdk_pixbuf-2.0-0.dll"; + const string GtkLibraryName = "libgtk-win32-2.0-0.dll"; +#else + const string GobjectLibraryName = "libgobject-2.0.so"; + const string GdkLibraryName = "libgdk-x11-2.0.so"; + const string GdkPixbufLibraryName = "libgdk_pixbuf-2.0.so"; + const string GtkLibraryName = "libgtk-x11-2.0.so"; +#endif + #endregion + #region GDK + [DllImport (GdkLibraryName)] + static extern void gdk_draw_rectangle (GdkDrawablePointer drawable, GdkGCPointer gc, gboolean filled, gint x, gint y, gint width, gint height); + [DllImport (GdkLibraryName)] + static extern GdkGCPointer gdk_gc_new (GdkDrawablePointer drawable); + [DllImport (GdkLibraryName)] + static extern void gdk_gc_set_rgb_fg_color (GdkGCPointer gc, ref GdkColor color); + [DllImport (GdkLibraryName)] + static extern GdkPixbufPointer gdk_pixbuf_get_from_drawable (GdkPixbufPointer dest, GdkDrawablePointer src, GdkColormapPointer cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); + [DllImport (GdkLibraryName)] + static extern GdkPixmapPointer gdk_pixmap_new (GdkDrawablePointer drawable, gint width, gint height, gint depth); + struct GdkColor{ + public guint32 pixel; + public guint16 red; + public guint16 green; + public guint16 blue; + public GdkColor (Color value) + { + pixel = 0; + red = (guint16)(value.R << 8); + green = (guint16)(value.G << 8); + blue = (guint16)(value.B << 8); + } + } + internal struct GdkRectangle { + public gint x; + public gint y; + public gint width; + public gint height; + public GdkRectangle (Rectangle value) + { + x = value.X; + y = value.Y; + width = value.Width; + height = value.Height; + } + } + #endregion + #region GdkPixbuf + [DllImport (GdkPixbufLibraryName)] + static extern IntPtr gdk_pixbuf_get_pixels (GdkPixbufPointer pixbuf); + [DllImport (GdkPixbufLibraryName)] + static extern int gdk_pixbuf_get_rowstride (GdkPixbufPointer pixbuf); + [DllImport (GdkPixbufLibraryName)] + static extern GdkPixbufPointer gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height); + enum GdkColorspace + { + GDK_COLORSPACE_RGB + } + #endregion + #region GTK + #region Functions + [DllImport (GtkLibraryName)] + static extern gboolean gtk_init_check (ref int argc, ref string[] argv); + [DllImport (GtkLibraryName)] + static extern IntPtr gtk_check_version (guint required_major, guint required_minor, guint required_micro); + [DllImport (GtkLibraryName)] + static extern void gtk_container_add (GtkContainerPointer container, GtkWidgetPointer widget); + [DllImport (GtkLibraryName)] + static extern void gtk_container_forall (GtkContainerPointer container, GtkCallback callback, gpointer callback_data); + [UnmanagedFunctionPointer (CallingConvention.Cdecl)] + delegate void GtkCallback (GtkWidgetPointer widget, gpointer data); + [DllImport (GtkLibraryName)] + static extern void gtk_object_destroy (GtkObjectPointer @object); + [DllImport (GtkLibraryName)] + static extern GtkStylePointer gtk_rc_get_style (GtkWidgetPointer widget); + [DllImport (GtkLibraryName)] + static extern GtkStylePointer gtk_style_attach (GtkStylePointer style, GdkWindowPointer window); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_realize (GtkWidgetPointer widget); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_style_get (GtkWidgetPointer widget, string property, out gint value, IntPtr nullTerminator); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_style_get (GtkWidgetPointer widget, string property, out gfloat value, IntPtr nullTerminator); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_style_get (GtkWidgetPointer widget, string property1, out gint value1, string property2, out gint value2, IntPtr nullTerminator); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_style_get (GtkWidgetPointer widget, string property, out GtkShadowType value, IntPtr nullTerminator); + [DllImport (GtkLibraryName)] + static extern void gtk_widget_style_get (GtkWidgetPointer widget, string property, out gboolean value, IntPtr nullTerminator); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_window_new (GtkWindowType type); + [DllImport (GtkLibraryName)] + static extern void gtk_window_set_default (GtkWindowPointer window, GtkWidgetPointer default_widget); + [DllImport (GtkLibraryName)] + static extern GtkObjectPointer gtk_adjustment_new (gdouble value, gdouble lower, gdouble upper, gdouble step_increment, gdouble page_increment, gdouble page_size); + [DllImport (GtkLibraryName)] + static extern GtkStylePointer gtk_widget_get_style (GtkWidgetPointer widget); + [DllImport (GtkLibraryName)] + static extern GtkTreeViewColumnPointer gtk_tree_view_column_new (); + [DllImport (GtkLibraryName)] + static extern gint gtk_tree_view_insert_column ( + GtkTreeViewPointer tree_view, + GtkTreeViewColumnPointer column, + gint position); + [DllImport (GtkLibraryName)] + static extern void gtk_toolbar_insert ( + GtkToolbarPointer toolbar, + GtkToolItemPointer item, + gint pos); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_bin_get_child (GtkBinPointer bin); + #region Widget type + [DllImport (GtkLibraryName)] + static extern GType gtk_arrow_get_type (); + [DllImport (GtkLibraryName)] + static extern GType gtk_container_get_type (); + [DllImport (GtkLibraryName)] + static extern GType gtk_toggle_button_get_type (); + #endregion + #region Widget creation + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_button_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_check_button_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_combo_box_entry_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_entry_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_fixed_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_frame_new (string label); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_hscale_new_with_range (gdouble min, gdouble max, gdouble step); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_hscrollbar_new (GtkAdjustmentPointer adjustment); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_notebook_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_progress_bar_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_radio_button_new (GSListPointer group); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_spin_button_new (GtkAdjustmentPointer adjustment, gdouble climb_rate, guint digits); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_statusbar_new (); + [DllImport (GtkLibraryName)] + static extern GtkToolItemPointer gtk_toggle_tool_button_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_toolbar_new (); + [DllImport (GtkLibraryName)] + static extern GtkToolItemPointer gtk_tool_button_new ( + GtkWidgetPointer icon_widget, + string label); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_tree_view_new (); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_vscale_new_with_range (gdouble min, gdouble max, gdouble step); + [DllImport (GtkLibraryName)] + static extern GtkWidgetPointer gtk_vscrollbar_new (GtkAdjustmentPointer adjustment); + #endregion + #region Painting + [DllImport (GtkLibraryName)] + static extern void gtk_paint_arrow (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, GtkArrowType arrow_type, gboolean fill, gint x, gint y, gint width, gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_box (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, gint x, gint y, gint width, gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_box_gap ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + GtkShadowType shadow_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side, + gint gap_x, + gint gap_width); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_check (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, gint x, gint y, gint width, gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_expander ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + gint x, + gint y, + GtkExpanderStyle expander_style); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_extension ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + GtkShadowType shadow_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + gint x, + gint y, + gint width, + gint height, + GtkPositionType gap_side); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_flat_box ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + GtkShadowType shadow_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + gint x, + gint y, + gint width, + gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_option (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, gint x, gint y, gint width, gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_resize_grip ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + GdkWindowEdge edge, + gint x, + gint y, + gint width, + gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_shadow (GtkStylePointer style, GdkWindowPointer window, GtkStateType state_type, GtkShadowType shadow_type, ref GdkRectangle area, GtkWidgetPointer widget, string detail, gint x, gint y, gint width, gint height); + [DllImport (GtkLibraryName)] + static extern void gtk_paint_slider ( + GtkStylePointer style, + GdkWindowPointer window, + GtkStateType state_type, + GtkShadowType shadow_type, + ref GdkRectangle area, + GtkWidgetPointer widget, + string detail, + gint x, + gint y, + gint width, + gint height, + GtkOrientation orientation); + #endregion + #endregion + #region Enumerations + internal enum GtkShadowType + { + GTK_SHADOW_NONE, + GTK_SHADOW_IN, + GTK_SHADOW_OUT, + GTK_SHADOW_ETCHED_IN, + GTK_SHADOW_ETCHED_OUT + } + enum GtkStateType + { + GTK_STATE_NORMAL, + GTK_STATE_ACTIVE, + GTK_STATE_PRELIGHT, + GTK_STATE_SELECTED, + GTK_STATE_INSENSITIVE + } + enum GtkWindowType + { + GTK_WINDOW_TOPLEVEL, + GTK_WINDOW_POPUP + } + enum GtkArrowType + { + GTK_ARROW_UP, + GTK_ARROW_DOWN, + GTK_ARROW_LEFT, + GTK_ARROW_RIGHT, + GTK_ARROW_NONE + } + enum GtkOrientation + { + GTK_ORIENTATION_HORIZONTAL, + GTK_ORIENTATION_VERTICAL + } + enum GtkExpanderStyle + { + GTK_EXPANDER_COLLAPSED, + GTK_EXPANDER_SEMI_COLLAPSED, + GTK_EXPANDER_SEMI_EXPANDED, + GTK_EXPANDER_EXPANDED + } + enum GtkPositionType + { + GTK_POS_LEFT, + GTK_POS_RIGHT, + GTK_POS_TOP, + GTK_POS_BOTTOM + } + enum GtkWidgetFlags : uint + { + GTK_CAN_DEFAULT = 1 << 13, + } + enum GdkWindowEdge + { + GDK_WINDOW_EDGE_NORTH_WEST, + GDK_WINDOW_EDGE_NORTH, + GDK_WINDOW_EDGE_NORTH_EAST, + GDK_WINDOW_EDGE_WEST, + GDK_WINDOW_EDGE_EAST, + GDK_WINDOW_EDGE_SOUTH_WEST, + GDK_WINDOW_EDGE_SOUTH, + GDK_WINDOW_EDGE_SOUTH_EAST + } + #endregion + #region Structures + struct GtkStyle + { +#pragma warning disable 169 + GObject parent_instance; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] fg; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] bg; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] light; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] dark; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] mid; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] text; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] @base; + [MarshalAs(UnmanagedType.ByValArray, SizeConst=5)] + GdkColor[] text_aa; + GdkColor black; + GdkColor white; + PangoFontDescriptionPointer font_desc; +#pragma warning restore 169 + public gint xthickness; + public gint ythickness; + } + struct GtkWidget + { +#pragma warning disable 169 + GtkObject @object; + guint16 private_flags; + guint8 state; + guint8 saved_state; + string name; + GtkStylePointer style; + GtkRequisition requisition; +#pragma warning restore 169 + public GtkAllocation allocation; +#pragma warning disable 169 + GdkWindowPointer window; + GtkWidgetPointer parent; +#pragma warning restore 169 + } + struct GtkObject + { +#pragma warning disable 169 + GInitiallyUnowned parent_instance; +#pragma warning restore 169 + public guint32 flags; + } + struct GtkRequisition + { +#pragma warning disable 169 + gint width; + gint height; +#pragma warning restore 169 + } + struct GtkMisc + { +#pragma warning disable 169 + GtkWidget widget; +#pragma warning restore 169 + public gfloat xalign; + public gfloat yalign; + public guint16 xpad; + public guint16 ypad; + } + struct GtkTreeViewColumn + { +#pragma warning disable 169 + GtkObject parent; + GtkWidgetPointer tree_view; +#pragma warning restore 169 + public GtkWidgetPointer button; + } + #endregion + #region Macros + static void GTK_WIDGET_SET_FLAGS (GtkWidgetPointer wid, GtkWidgetFlags flag) + { + GtkObject @object = (GtkObject)Marshal.PtrToStructure (wid, typeof (GtkObject)); + @object.flags |= (guint32)flag; + Marshal.StructureToPtr (@object, wid, false); + } + #endregion + #endregion + #region GObject + [DllImport (GobjectLibraryName)] + static extern gpointer g_object_ref (gpointer @object); + [DllImport (GobjectLibraryName)] + static extern void g_object_unref (gpointer @object); + [DllImport (GobjectLibraryName)] + static extern gboolean g_type_check_instance_is_a (GTypeInstancePointer type_instance, GType iface_type); + [DllImport (GobjectLibraryName)] + static extern void g_object_get (gpointer @object, string property_name, out gboolean value, IntPtr nullTerminator); + const int G_TYPE_FUNDAMENTAL_SHIFT = 2; + enum G_TYPE + { + } + struct GTypeInstance + { +#pragma warning disable 169 + GTypeClassPointer g_class; +#pragma warning restore 169 + } + internal struct GObject + { +#pragma warning disable 169 + GTypeInstance g_type_instance; + guint ref_count; + GDataPointer qdata; +#pragma warning restore 169 + } + #endregion + #endregion + } + #region Exposed constants + enum GtkPlusToggleButtonValue + { + Unchecked = GtkPlus.GtkShadowType.GTK_SHADOW_OUT, + Mixed = GtkPlus.GtkShadowType.GTK_SHADOW_ETCHED_IN, + Checked = GtkPlus.GtkShadowType.GTK_SHADOW_IN + } + enum GtkPlusState + { + Normal, + Pressed, + Hot, + Selected, + Disabled + } + #endregion +} |