[Monodevelop-patches-list] r1702 - trunk/MonoDevelop/src/Libraries/Gdl

commit-watcher at mono-cvs.ximian.com commit-watcher at mono-cvs.ximian.com
Mon Jun 7 03:37:01 EDT 2004


Author: tberman
Date: 2004-06-07 03:37:01 -0400 (Mon, 07 Jun 2004)
New Revision: 1702

Removed:
   trunk/MonoDevelop/src/Libraries/Gdl/DockItemFlags.cs
Modified:
   trunk/MonoDevelop/src/Libraries/Gdl/DockItem.cs
   trunk/MonoDevelop/src/Libraries/Gdl/DockObjectFlags.cs
   trunk/MonoDevelop/src/Libraries/Gdl/Gdl.prjx
   trunk/MonoDevelop/src/Libraries/Gdl/Makefile.Gdl
Log:
more code that wont compile. lots more in fact. I think all I have left to port before I can try to compile is DockItemGrip, DockPlaceholder, DockPaned, DockNotebook, and do all the event hookups, and finish off the minor unported bits.
mmm
fun.


Modified: trunk/MonoDevelop/src/Libraries/Gdl/DockItem.cs
===================================================================
--- trunk/MonoDevelop/src/Libraries/Gdl/DockItem.cs	2004-06-07 04:15:04 UTC (rev 1701)
+++ trunk/MonoDevelop/src/Libraries/Gdl/DockItem.cs	2004-06-07 07:37:01 UTC (rev 1702)
@@ -5,24 +5,21 @@
 namespace Gdl
 {
 	public class DockItem : DockObject
-	{
-
-		private static bool has_grip;
-		
-		private Gtk.Widget child;
-		private DockItemBehavior behavior;
-		private Gtk.Orientation orientation;
+	{		
+		private Gtk.Widget child = null;
+		private DockItemBehavior behavior = DockItemBehavior.Normal;
+		private Gtk.Orientation orientation = Gtk.Orientation.Horizontal;
 		private uint resize = 1;
-		private int dragoff_x;
-		private int dragoff_y;
-		private Gtk.Menu menu;
+		private int dragoff_x = 0;
+		private int dragoff_y = 0;
+		private Gtk.Menu menu = null;
 		private bool grip_shown;
-		private Gtk.Widget grip;
+		private DockItemGrip grip;
 		private uint grip_size;
-		private Gtk.Widget tab_label;
-		private int preferred_width;
-		private int preferred_height;
-		private DockPlaceholder ph;
+		private Gtk.Widget tab_label = null;
+		private int preferred_width = -1;
+		private int preferred_height = -1;
+		private DockPlaceholder ph = null;
 		private int start_x;
 		private int start_y;
 		
@@ -36,13 +33,55 @@
 			                    "style : gtk \"gdl-dock-item-default\"\n");
 		}
 		
+		public DockItem ()
+		{
+			if (this.HasGrip) {
+				this.grip_shown = true;
+				this.grip = new DockItemGrip (this);
+				this.grip.Parent = this;
+				this.grip.Show ();
+			} else {
+				this.grip_shown = false;
+			}
+			this.DockObjectFlags &= ~(DockObjectFlags.Automatic);
+		}
+		
+		public DockItem (string name, string long_name, DockItemBehavior behavior) : this ()
+		{
+			this.Name = name;
+			this.LongName = long_name;
+			this.Behavior = behavior;
+			//FIXME: Set the tab label here, should it just be an hbox or that
+			//strange DockTabLabel with what looks like a lot of dead code
+			//from gdl-dock
+		}
+		
+		public DockItem (string name, string long_name, string stock_id, DockItemBehavior behavior) : this (name, long_name, behavior)
+		{
+			this.StockId = stock_id;
+		}
+		
+		public virtual bool HasGrip {
+			get { return true; }
+		}
+		
+		public int DragOffX {
+			get { return this.dragoff_x; }
+			set { this.dragoff_x = value; }
+		}
+		
+		public int DragOffY {
+			get { return this.dragoff_y; }
+			set { this.dragoff_y = value; }
+		}
+		
 		public override bool IsCompound {
 			get { return false; }
 		}
 		
 		public Gtk.Orientation Orientation {
 			get { return orientation; }
-			set { orientation = value; }
+			set { SetOrientation (value); }
 		}
 		
 		public bool Resize {
@@ -97,5 +136,615 @@
 			get { return this.preferred_height; }
 			set { this.preferred_height = value; }
 		}
+		
+		public bool InDrag {
+			get { return ((this.DockObjectFlags & DockObjectFlags.InDrag) != 0); }
+		}
+		
+		public bool InPreDrag {
+			get { return ((this.DockObjectFlags & DockObjectFlags.InPreDrag) != 0); }
+		}
+		
+		public bool Iconified {
+			get { return ((this.DockObjectFlags & DockObjectFlags.Iconified) != 0); }
+		}
+		
+		public bool UserAction {
+			get { return ((this.DockObjectFlags & DockObjectFlags.UserAction) != 0); }
+		}
+		
+		public bool GripShown {
+			get { return (this.HasGrip && !this.Locked && this.grip_shown); }
+		}
+		
+		protected override OnAdded (Gtk.Widget widget)
+		{
+			if (widget is DockObject) {
+				Console.WriteLine ("You can't add a DockObject to a DockItem");
+				return;
+			}
+			if (this.Child != null) {
+				Console.WriteLine ("This DockItem already has a child");
+				return;
+			}
+			widget.Parent = this;
+			this.Child = widget;
+		}
+		
+		protected override OnRemoved (Gtk.Widget widget)
+		{
+			if (this.grip == widget) {
+				bool grip_was_visible = widget.Visible;
+				widget.Unparent ();
+				this.grip = null;
+				if (grip_was_visible)
+					this.QueueResize ();
+				return;
+			}
+			if (this.InDrag) {
+				this.DragEnd (true);
+			}
+			
+			if (widget != this.Child)
+				return;
+			
+			bool was_visible = widget.Visible;
+			widget.Unparent ();
+			this.Child = null;
+			
+			if (was_visible)
+				this.QueueResize ();
+		}
+		
+		protected override void ForAll (bool include_internals, CallbackInvoker invoker)
+		{
+			if (include_internals && this.grip != null)
+				invoker.Invoke (this.grip);
+			if (this.Child != null)
+				invoker.Invoke (this.Child);
+		}
+		
+		protected void OnSizeRequested (ref Gtk.Requisition requisition)
+		{
+			Gtk.Requisition child_requisition = new Gtk.Requisition ();
+			Gtk.Requisition grip_requisition = new Gtk.Requisition ();
+			
+			if (this.Child)
+				child_requistion = this.Child.SizeRequest ();
+			else {
+				child_requisition.Width = 0;
+				child_requisition.Height = 0;
+			}
+			if (this.Orientation == Gtk.Orientation.Horizontal) {
+				if (this.GripShown) {
+					grip_requisition = this.grip.SizeRequest ();
+					requisition.Width = grip_requisition.Width;
+				} else {
+					requisition.Width = 0;
+				}
+				
+				if (this.Child != null) {
+					requisition.Width += child_requisition.Width;
+					requisition.Height = child_requisition.Height;
+				} else {
+					requisition.Height = 0;
+				}
+			} else {
+				if (this.GripShown) {
+					grip_requisition = this.grip.SizeRequest ();
+					requisition.Height = grip_requisition.Height;
+				} else {
+					requisition.Height = 0;
+				}
+				
+				if (this.Child != null) {
+					requisition.Width = child_requisition.Width;
+					requisition.Height += child_requisition.Height;
+				} else {
+					requisition.Width = 0;
+				}
+			}
+			requisition.Width += (this.BorderWidth + this.Style.XThickness) * 2;
+			requisition.Width += (this.BorderWidth + this.Style.YThickness) * 2;
+			this.SetSizeRequest (requisition.Width, requisition.Height);
+		}
+		
+		protected override OnSizeAllocated (ref Gdk.Rectangle allocation)
+		{
+			this.Allocation = allocation;
+			if (this.IsRealized) {
+				this.GdkWindow.MoveResize (allocation.X, allocation.Y, allocation.Width, allocation.Height);
+			}
+			if (this.Child != null && this.Child.Visible) {
+				int border_width = this.BorderWidth;
+				Gdk.Rectangle child_allocation = new Gdk.Rectangle ();
+				child_allocation.X = border_width + this.Style.XThickness;
+				child_allocation.Y = border_width + this.Style.YThickness;
+				child_allocation.Width = allocation.Width - 2 * (border_width + this.Style.XThickness);
+				child_allocation.Height = allocation.Height - 2 * (border_width + this.Style.YThickness);
+				
+				if (this.GripShown) {
+					Gdk.Rectangle grip_alloc = child_allocation;
+					Gtk.Requisition grip_req = this.grip.SizeRequest ();
+					if (this.Orientation == Gtk.Orientation.Horizontal) {
+						child_allocation.X += grip_req.Width;
+						child_allocation.Width -= grip_req.Width;
+						grip_alloc.Width = grip_req.Width;
+					} else {
+						child_allocation.Y += grip_req.Height;
+						child_allocation.Height -= grip_req.Height;
+						grip_alloc.Height = grip_req.Height;
+					}
+					if (this.grip != null) {
+						this.grip.SizeAllocate (grip_alloc);
+					}
+				}
+				this.Child.SizeAllocate (grip_alloc);
+			}
+		}
+		
+		protected override OnMapped ()
+		{
+			this.Flags |= (int)Gtk.WidgetFlags.Mapped;
+			this.GdkWindow.Show ();
+			if (this.Child != null && this.Child.Visible && !this.Child.IsMapped)
+				this.Child.Map ();
+			if (this.grip != null && this.grip.Visible && !this.grip.IsMapped)
+				this.grip.Map ();
+		}
+		
+		protected override OnUnmapped ()
+		{
+			this.Flags &= ~((int)Gtk.WidgetFlags.Mapped);
+			this.GdkWindow.Hide ();
+			if (this.grip != null)
+				this.grip.Unmap ();
+		}
+		
+		protected override OnRealized ()
+		{
+			this.Flags |= (int)Gtk.WidgetFlags.Realized;
+			Gdk.WindowAttr attributes;
+			attributes.X = this.Allocation.X;
+			attributes.Y = this.Allocation.Y;
+			attributes.Height = this.Allocation.Height;
+			attributes.Width = this.Allocation.Width;
+			attributes.WindowType = Gdk.WindowType.Child;
+			attributes.Wclass = Gdk.WindowClass.InputOutput;
+			attributes.visual = this.Visual;
+			attributes.colormap = this.Colormap;
+			attributes.EventMask = (this.Events | Gdk.EventMask.ExposureMask | Gdk.EventMask.Button1MotionMask | Gdk.EventMask.ButtonPressMask | Gdk.EventMask.ButtonReleaseMask);
+			Gdk.WindowAttributesType attributes_mask = Gdk.WindowAttributesType.X | Gdk.WindowAttributesType.Y | Gdk.WindowAttributesType.Colormap | Gdk.WindowAttributesType.Visual;
+			this.GdkWindow = new Gdk.Window (this.ParentWindow, attributes, (int)attributes_mask);
+			this.GdkWindow.UserData = this.Handle;
+			this.Style = this.Style.Attach (this.GdkWindow);
+			this.Style.SetBackground (this.GdkWindow, this.State);
+			this.GdkWindow.SetBackPixmap (null, true);
+			if (this.Child != null)
+				this.Child.ParentWindow = this.GdkWindow;
+			if (this.grip != null)
+				this.grip.ParentWindow = this.GdkWindow;
+		}
+		
+		protected override OnStyleSet (Gtk.Style previous_style)
+		{
+			if (this.IsRealized && !this.NoWindow) {
+				this.Style.SetBackground (this.GdkWindow, this.State);
+				if (this.Drawable) {
+					this.GdkWindow.Clear ();
+				}
+			}
+		}
+		
+		protected override bool OnExposeEvent (Gdk.EventExpose evnt)
+		{
+			if (this.Drawable && evnt.Window == this.GdkWindow) {
+				Gtk.Style.PaintBox (this.GdkWindow, this.State, Gtk.ShadowType.None, evnt.Area, this, "dockitem", 0, 0, -1, -1);
+				base.OnExposeEvent (evnt);
+			}
+			return false;
+		}
+		
+		private bool EventInGripWindow (Gdk.Event evnt)
+		{
+			if (this.grip != null && this.grip.TitleWindow == evnt.Window)
+				return true;
+			return false;
+		}
+		
+		protected override bool OnButtonPressEvent (Gdk.EventButton evnt)
+		{
+			if (!EventInGripWindow (evnt))
+				return false;
+			if (this.Locked)
+				return false;
+			
+			bool event_handled = false;
+			bool in_handle;
+			Gdk.Cursor cursor = null;
+			
+			switch (this.Orientation) {
+			case Gtk.Orientation.Horizontal:
+				in_handle = evnt.X < this.grip.Allocation.Width;
+				break;
+			case Gtk.Orientation.Vertical:
+				in_handle = evnt.Y < this.grip.Allocation.Height;
+				break;
+			default:
+				in_handle = false;
+				break;
+			}
+			
+			if (evnt.Button == 1 && evnt.Type == Gdk.EventType.ButtonPress) {
+				if (in_handle) {
+					this.start_x = evnt.X;
+					this.start_y = evnt.Y;
+					this.DockObjectFlags |= DockObjectFlags.InPreDrag;
+					cursor = new Gdk.Cursor (this.Display, (int)Gdk.CursorType.Fleur);
+					this.grip.TitleWindow.Cursor = cursor;
+					event_handled = true;
+				}
+			} else if (evnt.Type == Gdk.EventType.ButtonRelease && evnt.Button == 1) {
+				if (this.InDrag) {
+					this.DragEnd (false);
+					event_handled = true;
+				} else if (this.InPreDrag) {
+					this.DockObjectFlags &= ~(DockObjectFlags.InPreDrag);
+					event_handled = true;
+				}
+				
+				if (this.grip.TitleWindow != null) {
+					cursor = new Gdk.Cursor (this.Display, (int)Gdk.CursorType.Hand2);
+					this.grip.TitleWindow.Cursor = cursor;
+				}
+			} else if (evnt.Button == 3 && evnt.Type == Gdk.EventType.ButtonPress && in_handle) {
+				this.PopupMenu (evnt.Button, evnt.Time);
+				event_handled = true;
+			}
+			return event_handled;
+		}
+		
+		protected override bool OnButtonReleaseEvent (Gdk.EventButton evnt)
+		{
+			return OnButtonPressEvent (evnt);
+		}
+		
+		protected override bool OnMotionNotifyEvent (Gdk.EventMotion evnt)
+		{
+			if (!EventInGripWindow (evnt))
+				return false;
+			if (this.InPreDrag) {
+				if (Gtk.Drag.CheckThreshold (this, this.start_x, this.start_y, evnt.X, evnt.Y)) {
+					this.DockObjectFlags &= ~(DockObjectFlags.InPreDrag);
+					this.dragoff_x = this.start_x;
+					this.dragoff_y = this.start_y;
+					this.DragStart ();
+				}
+			}
+			
+			if (!this.InDrag)
+				return false;
+			
+			int new_x = evnt.XRoot;
+			int new_y = evnt.YRoot;
+			
+			//PORT THIS:
+			//    g_signal_emit (item, gdl_dock_item_signals [DOCK_DRAG_MOTION], 0, new_x, new_y);
+			return true;
+		}
+		
+		protected override bool OnKeyPressEvent (Gdk.EventKey evnt)
+		{
+			if (this.InDrag && evnt.Key == Gdk.Key.Escape) {
+				this.DragEnd (true);
+				return true;
+			}
+			return base.OnKeyPressEvent (evnt);
+		}
+		
+		protected static PreferredSize (DockItem item, ref Gdk.Rectangle req)
+		{
+			req.Width = Math.Max (item.preferred_width, item.Allocation.Width);
+			req.Height = Math.Max (item.preferred_height, item.Allocation.Height);
+		}
+		
+		public override bool DockRequest (int x, int y, DockRequest request)
+		{
+			Gdk.Rectangle alloc = this.Allocation;
+			int rel_x = x - alloc.X;
+			int rel_y = y - alloc.Y;
+			
+			if (rel_x > 0 && rel_x < alloc.Width && rel_y > 0 && rel_y < alloc.Width) {
+				Gdk.Rectangle other, my;
+				int divider;
+				DockItem.PreferredSize (request.Applicant, ref other);
+				DockItem.PreferredSize (this, ref my);
+				float rx = (float) rel_x / alloc.Width;
+				float ry = (float) rel_y / alloc.Height;
+				
+				if (rx < 0.4) {
+					request.Position = DockPlacement.Left;
+					divider = other.Width;
+				} else if (rx > (1 - 0.4) {
+					request.Position = DockPlacement.Right;
+					rx = 1 - rx;
+					divider = Math.Max (0, my.Width - other.Width);
+				} else if (ry < 0.4 && ry < rx) {
+					request.Position = DockPlacement.Top;
+					divider = other.Height;
+				} else if (ry > (1 - 0.4) && (1 - ry) < rx) {
+					request.Position = DockPlacement.Bottom;
+					divider = Math.Max (0, my.Height - other.Height);
+				} else
+					request.Position = DockPlacement.Center;
+				
+				Gdk.Rectangle req_rect = new Gdk.Rectangle ();
+				req_rect.X = 0;
+				req_rect.Y = 0;
+				req_rect.Width = alloc.Width;
+				req_rect.Height = alloc.Height;
+				
+				if (request.Applicant != this) {
+					switch (request.Position) {
+					case DockPlacement.Top:
+						req_rect.Height *= 0.4;
+						break;
+					case DockPlacement.Bottom:
+						req_rect.Y += req_rect.Height * (1 - 0.4);
+						req_rect.Height *= 0.4;
+						break;
+					case DockPlacement.Left:
+						req_rect.Width *= 0.4;
+						break;
+					case DockPlacement.Right:
+						req_rect.X += req_rect.Width * (1 - 0.4);
+						req_rect.Width *= 0.4;
+						break;
+					case DockPlacement.Center:
+						req_rect.X = req_rect.Width * 0.2;
+						req_rect.Y = req_rect.Height * 0.2;
+						req_rect.Width = (req_rect.Width * (1 - 0.2)) - req_rect.X;
+						req_rect.Height = (req_rect.Height * (1 - 0.2)) - req_rect.Y;
+						break;
+					default:
+						break;
+					}
+				}
+				
+				req_rect.X += alloc.X;
+				req_rect.Y += alloc.Y;
+				request.Target = this;
+				request.Rect = req_rect;
+				if (request.Position != DockPlacement.Center && divider >= 0)
+					request.Extra = divider;
+				return true;
+			} else
+				return false;
+		}
+		
+		public override void Dock (DockObject requestor, DockPlacement position, object other_data)
+		{
+			DockObject new_parent = null;
+			bool add_ourselves_first;
+			
+			switch (position) {
+			case DockPlacement.Top:
+			case DockPlacement.Bottom:
+				new_parent = new DockPaned (Gtk.Orientation.Vertical);
+				add_ourselves_first = (position == DockPlacement.Bottom);
+				break;
+			case DockPlacement.Left:
+			case DockPlacement.Right:
+				new_parent = new DockPaned (Gtk.Orientation.Horizontal);
+				add_ourselves_first = (position == DockPlacement.Right);
+				break;
+			case DockPlacement.Center:
+				new_parent = new DockNotebook ();
+				add_ourselves_first = true;
+				break;
+			default:
+				Console.WriteLine ("Unsupported docking strategy");
+				return;
+			}
+			
+			if (this.ParentObject != null)
+				this.ParentObject.Freeze ();
+			this.DockObjectFlags |= DockObjectFlags.InReflow;
+			this.Detach (false);
+			new_parent.Freeze ();
+			new_parent.Bind (this.Master);
+			
+			if (add_ourselves_first) {
+				new_parent.Add (this);
+				new_parent.Add (requestor);
+			} else {
+				new_parent.Add (requestor);
+				new_parent.Add (this);
+			}
+			
+			if (this.ParentObject != null)
+				this.ParentObject.Add (new_parent);
+			
+			if (this.Visible)
+				new_parent.Show ();
+			
+			if (position != DockPlacement.Center && other_data != null && other_data is System.Int32) {
+				//PORT THIS:
+				//g_object_set (G_OBJECT (new_parent), "position", g_value_get_uint (other_data), NULL);
+			}
+			
+			this.DockObjectFlags &= ~(DockObjectFlags.InReflow);
+			new_parent.Thaw ();
+			if (this.ParentObject != null)
+				this.ParentObject.Thaw ();
+		}
+		
+		private void DetachMenu (Gtk.Widget item, Gtk.Menu menu)
+		{
+			if (item is DockItem)
+				((DockItem)item).menu = null;
+		}
+		
+		public void PopupMenu (int button, int time)
+		{
+			if (this.menu == null) {
+				this.menu = new Gtk.Menu ();
+				this.menu.AttachToWidget (this, new MenuDetachFunc (DetachMenu));
+				
+				Gtk.MenuItem mitem = new Gtk.MenuItem ("Hide");
+				mitem.Activated += new EventHandler (ItemHideCb);
+				this.menu.Append (mitem);
+			}
+			this.menu.ShowAll ();
+			this.menu.Popup (null, null, null, null, button, time);
+		}
+		
+		private void ItemHideCb (object o, EventArgs e)
+		{
+			this.HideItem ();
+		}
+		
+		public void DragStart ()
+		{
+			Gdk.Cursor fleur = new Gdk.Cursor (Gdk.CursorType.Fleur);
+			
+			if (!this.IsRealized)
+				this.Realize ();
+			
+			this.DockObjectFlags |= DockObjectFlags.InDrag;
+			
+			Gtk.Grab.Add (this);
+			
+			//PORT THIS:
+			//g_signal_emit (item, gdl_dock_item_signals [DOCK_DRAG_BEGIN], 0);
+		}
+		
+		public void DragEnd ()
+		{
+			Gtk.Grab.Remove (Gtk.Grab.Current);
+			
+			//PORT THIS:
+			//g_signal_emit (item, gdl_dock_item_signals [DOCK_DRAG_END], 0);
+			
+			this.DockObjectFlags &= ~(DockObjectFlags.InDrag);
+		}
+		
+		private void ShowHideGrip ()
+		{
+			if (this.grip != null) {
+				if (this.GripShown)
+					this.grip.Show ();
+				else
+					this.grip.Hide ();
+			}
+			this.QueueResize ();
+		}
+		
+		public void DockTo (DockItem target, DockPlacement position, int docking_param)
+		{
+			if (target == null || position == DockPlacement.Floating)
+				return;
+			if (position == DockPlacement.Floating || target == null) {
+				if (!this.IsBound) {
+					Console.WriteLine ("Attempting to bind an unbound object");
+					return;
+				}
+				this.dragoff_x = this.dragoff_y = 0;
+				((Dock)this.Master.Controller).AddFloatingItem (this, 0, 0, -1, -1);
+			} else
+				target.Dock (item, position, null);
+		}
+		
+		public virtual void SetOrientation (Gtk.Orientation orientation)
+		{
+			if (this.Orientation != orientation) {
+				if (this.Child != null) {
+					//FIXME: Port this, prolly w/ reflection
+					            /*pspec = g_object_class_find_property (
+                G_OBJECT_GET_CLASS (item->child), "orientation");
+            if (pspec && pspec->value_type == GTK_TYPE_ORIENTATION)
+                g_object_set (G_OBJECT (item->child),
+                              "orientation", orientation,
+                              NULL);*/
+				}
+				//PORT THIS:
+				//        g_object_notify (G_OBJECT (item), "orientation");
+			}
+		}
+		
+		public void HideGrip ()
+		{
+			if (this.grip_shown) {
+				this.grip_shown = false;
+				this.ShowHideGrip ();
+			}
+		}
+		
+		public void ShowGrip ()
+		{
+			if (!this.grip_shown) {
+				this.grip_shown = true;
+				this.ShowHideGrip ();
+			}
+		}
+		
+		public void Bind (Dock dock)
+		{
+			if (dock == null)
+				return;
+			
+			this.Bind (dock.Master);
+		}
+		
+		public void HideItem ()
+		{
+			if (!this.IsAttached)
+				return;
+			
+			if (!this.IsAutomatic) {
+				this.ph = new DockPlaceholder (this, false);
+			}
+			
+			this.Freeze ();
+			if (this.IsCompound) {
+				this.Foreach (new Gtk.Callback (HideItem));
+			}
+			
+			this.Detach (true);
+			this.Thaw ();
+		}
+		
+		public void IconifyItem ()
+		{
+			this.DockObjectFlags |= DockObjectFlags.Iconified;
+			this.HideItem ();
+		}
+		
+		public void ShowItem ()
+		{
+			this.DockObjectFlags &= ~(DockObjectFlags.Iconified);
+			
+			if (this.ph != null) {
+				this.ph.Add (this);
+				this.ph = null;
+			} else if (this.IsBound) {
+				if (this.Master.Controller != null) {
+					this.Master.Controller.Dock (this, DockPlacement.Floating, null);
+				}
+			}
+		}
+		
+		public void SetDefaultPosition (DockObject reference)
+		{
+			this.ph = null;
+			
+			if (reference != null && reference.IsAttached) {
+				if (reference is DockPlaceholder) {
+					this.ph = reference;
+				} else {
+					this.ph = new DockPlaceholder (reference, true);
+				}
+			}
+		}
 	}
 }
\ No newline at end of file

Deleted: trunk/MonoDevelop/src/Libraries/Gdl/DockItemFlags.cs
===================================================================
--- trunk/MonoDevelop/src/Libraries/Gdl/DockItemFlags.cs	2004-06-07 04:15:04 UTC (rev 1701)
+++ trunk/MonoDevelop/src/Libraries/Gdl/DockItemFlags.cs	2004-06-07 07:37:01 UTC (rev 1702)
@@ -1,16 +0,0 @@
-// This file was generated by the Gtk# code generator.
-// Any changes made will be lost if regenerated.
-
-namespace Gdl {
-
-	using System;
-
-#region Autogenerated code
-	public enum DockItemFlags {
-
-		InDrag = 1,
-		InPredrag = 2,
-		UserAction = 3,
-	}
-#endregion
-}

Modified: trunk/MonoDevelop/src/Libraries/Gdl/DockObjectFlags.cs
===================================================================
--- trunk/MonoDevelop/src/Libraries/Gdl/DockObjectFlags.cs	2004-06-07 04:15:04 UTC (rev 1701)
+++ trunk/MonoDevelop/src/Libraries/Gdl/DockObjectFlags.cs	2004-06-07 07:37:01 UTC (rev 1702)
@@ -14,6 +14,10 @@
 		Attached = 1 << 1,
 		InReflow = 1 << 2,
 		InDetach = 1 << 3,
+		InDrag = 1 << 4,
+		InPreDrag = 1 << 5,
+		Iconified = 1 << 6,
+		UserAction = 1 << 7 
 	}
 #endregion
 }

Modified: trunk/MonoDevelop/src/Libraries/Gdl/Gdl.prjx
===================================================================
--- trunk/MonoDevelop/src/Libraries/Gdl/Gdl.prjx	2004-06-07 04:15:04 UTC (rev 1701)
+++ trunk/MonoDevelop/src/Libraries/Gdl/Gdl.prjx	2004-06-07 07:37:01 UTC (rev 1702)
@@ -3,7 +3,6 @@
     <File name="./DockObject.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
     <File name="./AssemblyInfo.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
     <File name="./DockItemBehavior.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
-    <File name="./DockItemFlags.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
     <File name="./DockObjectFlags.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
     <File name="./DockParamFlags.cs" subtype="Code" buildaction="Compile" dependson="" data="" />
     <File name="./Stock.cs" subtype="Code" buildaction="Compile" dependson="" data="" />

Modified: trunk/MonoDevelop/src/Libraries/Gdl/Makefile.Gdl
===================================================================
--- trunk/MonoDevelop/src/Libraries/Gdl/Makefile.Gdl	2004-06-07 04:15:04 UTC (rev 1701)
+++ trunk/MonoDevelop/src/Libraries/Gdl/Makefile.Gdl	2004-06-07 07:37:01 UTC (rev 1702)
@@ -5,7 +5,6 @@
 ./DockObject.cs \
 ./AssemblyInfo.cs \
 ./DockItemBehavior.cs \
-./DockItemFlags.cs \
 ./DockObjectFlags.cs \
 ./DockParamFlags.cs \
 ./Stock.cs \




More information about the Monodevelop-patches-list mailing list