projects/mde: mde/gui/widget/Ifaces.d comparison

comparison mde/gui/widget/Ifaces.d @ 174:3d58adc17d20

Temporary commit to allow backup

author	Diggory Hardy <diggory.hardy@gmail.com>
date	Mon, 31 Aug 2009 13:54:23 +0200
parents	0dd49f333189
children	1cbde9807293

comparison

equal deleted inserted replaced

-:a1ba9157510e
+:3d58adc17d20
 * manager is a special widget only implementing IParentWidget; all other
 * widgets must implement IChildWidget and optionally IParentWidget.
 *
 * It's recommended that widgets inherit one of the A*Widget classes rather
 * than impement I*Widget directly.
+*
+* Protection: please keep it as tight as possible. List it explicitly for
+* every function in this module; then the compiler checks overridden functions
+* have the correct protection attribute.
+* BUG: currently it's a bit of a mess, because of a compiler bug.
 *****************************************************************************/
 module mde.gui.widget.Ifaces;
 public import mde.gui.types;
 public import mde.gui.renderer.IRenderer;
 * If the widget has subwidgets, it should also be recursively called on
 * these, returning true if any data was saved.
 *
 * Actually the return value is ignored; I think widgets still return it
 * correctly though. */
-bool saveChanges ();
+public bool saveChanges ();
+/** Draw, using the stored values of x and y.
+*
+* Maybe later enforce clipping of all sub-widget drawing, particularly for cases where only
+* part of the widget is visible: scroll bars or a hidden window. */
+public void draw ();
 /** Called on a widget when something is dragged onto it.
 *
 * Generally, content editing widgets should implement this as:
 * ---
-override bool dropContent (IContent content) {
+public override bool dropContent (IContent content) {
 	if (content_.setContent (content))
 	    return true;
 	return parent.dropContent (content);
 }
 * ---
 * return parent.dropContent (content);
 * ---
 *
 * Returns: true if the content was received (false if it reaches the
 *	WidgetManager and is still not used). */
-bool dropContent (IContent content);
+public bool dropContent (IContent content);
 }
 /******************************************************************************
 * Interface for parent widgets, including IWidgetManager.
 *
 *  Layout widget: a widget containing multiple sub-widges (which hence
 *   controls how they are laid out).
 *****************************************************************************/
 interface IParentWidget : IWidget
 {
-/** Checks for recursion of unsafe widgets to prevent infinite recursion. */
+/** Checks for recursion of unsafe widgets to prevent infinite recursion.
+*
+* Only called by makeWidget() when creating child widgets and recursively
+* from the same method in a child widget. */
 void recursionCheck (widgetID, IContent);
 /** IPPWs return self, other widgets recurse call on parent. */
 IPopupParentWidget getParentIPPW ();
 /** Child widgets should call this on their parent if their minimal size
 * changes, since they cannot properly resize themselves.
 *
 * Parents $(I must) increase their child's size if the child is too small.
-* Parents $(I must not) decrease their own size, even if they are not
+* Parents $(I must not) change their own size, even if they are not
-* sizable; they may only decrease their childrens' sizes if it does not
+* sizable; they may only change their childrens' sizes if it does not
-* affect their own (i.e. WidgetManager and FloatingAreaWidget).
+* affect their own (i.e. WidgetManager and floating / popup widgets).
+*
+* (Hence most parents need to call this function on their parents to change
+* size. In this case they also must propegate setWidth/setHeight calls on
+* the child originally calling min[WH]Change.)
 *
 * Child widgets may depend on setPosition being called afterwards.
 *
 * Params:
 *	widget	= The child widget calling the function
 * NEVER and ALWAYS often don't result in usable GUIs, and aren't expected to be used except
 * for debugging.
 *
 * Note: ANY_SUBWIDGETS can cause problems like enlarging a menu bar containing a resizable
 * blank instead of the main part of a window. */
-enum SIZABILITY_ENUM {
+protected enum SIZABILITY_ENUM {
 NEVER		= 0,	/// Parents are never resizable
 ALL_SUBWIDGETS	= 3,	/// Parents are only resizable if all sub-widgets are
 ANY_SUBWIDGETS	= 2,	/// Parents are resizable if any sub-widgets are
 ALWAYS		= 1,	/// Parents are always resizable
 START_TRUE	= 1,	/// Flag set by ALWAYS and ALL_SUBWIDGETS
 SUBWIDGETS	= 2,	/// Flag set by ALL_SUBWIDGETS and ANY_SUBWIDGETS
 }
-static const SIZABILITY = SIZABILITY_ENUM.ANY_SUBWIDGETS;	/// ditto
+protected static const SIZABILITY = SIZABILITY_ENUM.ANY_SUBWIDGETS;	/// ditto
 }
 /******************************************************************************
 * Interface for parents of popups and the widget manager.
 *
 * All widgets should set their own size in this() or setup() (must be setup()
 * if it could change), although some parents may set child-widgets' size
 * during their creation.
 *****************************************************************************/
 //NOTE: add another this() without the data for default initialization, for the GUI editor?
-interface IChildWidget : IWidget
+abstract class IChildWidget : IWidget
 {
 //BEGIN Load and save
 /** 2nd stage of initialization for widgets; also called on some changes.
 *
 * Widgets should call recursively on their children, redo anything
 *		These flags are always true on first run.
 *
 * Returns:
 *	The method must return true on initial setup and if its dimensions
 *	(may) have changed. */
-bool setup (uint n, uint flags);
+bool setup (uint n, uint flags) {return 0;}
 /+ Use when widget editing is available? Requires widgets to know their parents.
 /** Called when a child widget's size has changed.
 *
 * Should be propegated up to parents. */
 * Normally, this means does the widget benifit from being enlarged? If not, the widget has
 * "fixed" dimensions equal to it's minimal size; however it $(I may) still be enlarged.
 *
 * Parents normally take their resizability from sub-widgets; see SIZABILITY for how they do
 * this. */
-bool isWSizable ();
+bool isWSizable () {return 0;}
-bool isHSizable (); /// ditto
+bool isHSizable () {return 0;} /// ditto
 /** The minimal size the widget could be shrunk to (or its fixed size).
 *
 * Takes into account child-widgets and any other contents. */
-wdim minWidth ();
+wdim minWidth () {return 0;}
-wdim minHeight ();	/// ditto
+wdim minHeight() {return 0;}	/// ditto
 /** Get the current size of the widget. */
-wdim width ();
+wdim width () {return 0;}
-wdim height();      /// ditto
+wdim height() {return 0;}      /// ditto
 /** (Smallest) coordinates of widget. */
-wdabs xPos ();
+wdabs xPos () {return 0;}
-wdabs yPos ();	/// ditto
+wdabs yPos () {return 0;}	/// ditto
 /** Used to adjust the size.
 *
 * Params:
 *  nw/nh	= The new width/height
 * A widget should never be resized smaller than it's minimal size (if it is, it should assume
 * it's minimal size and print a warning when in debug mode).
 * A "fixed" size widget should enlarge itself as requested.
 *
 * setPosition must be called after calling either setWidth or setHeight. */
-void setWidth (wdim nw, int dir);
+void setWidth (wdim nw, int dir) {}
-void setHeight (wdim nh, int dir);	/// ditto
+void setHeight (wdim nh, int dir) {}	/// ditto
 /** Set the current position (called after setup and to move widget). */
-void setPosition (wdim x, wdim y);
+void setPosition (wdim x, wdim y) {}
 //END Size and position
 //BEGIN Content
 /** Return the widget's content, or null. */
-IContent content ();
+IContent content () {return null;}
 /** Set the widget's content, if the widget takes content and changing it
 * at this stage is feasible. (Also pass to sub-widgets, where the
 * constructor normally does so.) */
-void setContent (IContent);
+void setContent (IContent) {}
 //END Content
 //BEGIN Events
 /** Recursively scan the widget tree to find the widget under (cx,cy).
 *
 *
 * In the case of Window this may not be the case; it should check and return null if not under
 * (cx,cy).
 *
 * Note: use global coordinates (cx,cy) not coordinates relative to the widget. */
-IChildWidget getWidget (wdabs cx, wdabs cy);
+IChildWidget getWidget (wdabs cx, wdabs cy) {return null;}
 /** Return true if (cx,cy) is on self's box (doesn't matter if actually on a subwidget). */
-bool onSelf (wdabs cx, wdabs cy);
+bool onSelf (wdabs cx, wdabs cy) {return 0;}
 /** Receive a mouse click event at cx,cy from button b (1-5 correspond to L,M,B, wheel up,down)
 * which is a down-click if state is true.
 *
 * Widget may assume coordinates are on the widget (caller must check).
 * $(TABLE
 * $(TR $(TD 1) $(TD Request keyboard input))
 * $(TR $(TD 2) $(TD Request the functions dragMotion and dragRelease are called))
 * $(TR $(TD 4) $(TD Display the widget's content while dragging (requires 2)))
 * ) */
-int clickEvent (wdabs cx, wdabs cy, ubyte b, bool state);
+int clickEvent (wdabs cx, wdabs cy, ubyte b, bool state) {return 0;}
 /** Called when dragging motion occurs, originating from this widget.
 *
 * Params: target = The widget under the mouse
 *
 * Only called if requested by clickEvent. */
-void dragMotion (wdabs cx, wdabs cy, IChildWidget target);
+void dragMotion (wdabs cx, wdabs cy, IChildWidget target) {}
 /** Called at the end of a drag which originated from this widget.
 *
 * Params: target = The widget under the mouse when the click was released
 *
 * Returns: true if the up-click event should not be passed to
 * clickEvent on the relevent widget.
 *
 * Only called if requested by clickEvent. */
-bool dragRelease (wdabs cx, wdabs cy, IChildWidget target);
+bool dragRelease (wdabs cx, wdabs cy, IChildWidget target) {return 0;}
 /** Receives keyboard events when requested.
 *
 * Params:
 *	sym	SDLKey key sym, useful for keys with no character code such as arrow keys
 *	letter	The character input, in UTF-8 */
-void keyEvent (ushort sym, char[] letter);
+public void keyEvent (ushort sym, char[] letter);
 /** Called when keyboard input focus is lost. */
-void keyFocusLost ();
+public void keyFocusLost ();
 /** Called on all widgets when the mouse moves over it (state == true) and
 * when it leaves (state == false). */
-void underMouse (bool state);
+void underMouse (bool state) {}
 /** When a pop-up is closed the manager calls requestRedraw and this function on its parent. */
-void popupClose ();
+protected void popupClose ();
 /** When a click is on the parent of a popup, this function is called instead of the usual
 * clickEvent.
 *
 * Returns:
 *	true to close the popup.
 *
 * Note: this means the parent can't receive text input without code changes. */
-bool popupParentClick ();
+protected bool popupParentClick ();
 //END Events
-/** Draw, using the stored values of x and y.
-*
-* Maybe later enforce clipping of all sub-widget drawing, particularly for cases where only
-* part of the widget is visible: scroll bars or a hidden window. */
-void draw ();
 /// Logs the current and minimal size of every widget.
-debug void logWidgetSize ();
+debug public void logWidgetSize ();
 }

Mercurial > projects > mde

comparison mde/gui/widget/Ifaces.d @ 174:3d58adc17d20