- added WMGetLabelText()

- added WMReparentWidget()
- added WMCreateTabViewItem()
- added W_CreateUnmanagedTopView()
- fixed deletion from tree bag

WINGs/ChangeLog

@@ -4,6 +4,12 @@ changes since wmaker 0.62.1:
 - added WText widget (rtf multiline text widget) 
 	Nwanua Elumeze <nwanua@colorado.edu>
 - added a new AUTO option for the UseMultiByte option
+- added WMRaiseWidget()/WMLowerWidget()
+- added missing EscapeTextMovement to textfield delegate/notification
+- added WMGetLabelText()
+- added WMReparentWidget()
+- added WMCreateTabViewItem()
+- added W_CreateUnmanagedTopView()
 
 changes since wmaker 0.62.0:
 ............................

WINGs/WINGs.h

@@ -805,6 +805,10 @@ void WMUnmapWidget(WMWidget *w);
 
 void WMMapWidget(WMWidget *w);
 
+void WMRaiseWidget(WMWidget *w);
+
+void WMLowerWidget(WMWidget *w);
+
 void WMMoveWidget(WMWidget *w, int x, int y);
 
 void WMResizeWidget(WMWidget *w, unsigned int width, unsigned int height);
@@ -976,6 +980,8 @@ void WMSetLabelImage(WMLabel *lPtr, WMPixmap *image);
 
 WMPixmap *WMGetLabelImage(WMLabel *lPtr);
 
+char *WMGetLabelText(WMLabel *lPtr);
+
 void WMSetLabelImagePosition(WMLabel *lPtr, WMImagePosition position);
 	
 void WMSetLabelTextAlignment(WMLabel *lPtr, WMAlignment alignment);
@@ -1404,7 +1410,7 @@ WMRuler *WMCreateRuler (WMWidget *parent);
 
 void WMShowRulerTabs(WMRuler *rPtr, Bool Show);
 
-WMRulerMargins WMGetRulerMargins(WMRuler *rPtr);
+int WMGetRulerMargin(WMRuler *rPtr, int which);
 
 void WMSetRulerMargins(WMRuler *rPtr, WMRulerMargins margins);
 
@@ -1522,6 +1528,8 @@ void WMSelectTabViewItemAtIndex(WMTabView *tPtr, int index);
 void WMSetTabViewDelegate(WMTabView *tPtr, WMTabViewDelegate *delegate);
 
 
+WMTabViewItem *WMCreateTabViewItem(int identifier, char *label);
+
 WMTabViewItem *WMCreateTabViewItemWithIdentifier(int identifier);
 
 int WMGetTabViewItemIdentifier(WMTabViewItem *item);

WINGs/WINGsP.h

@@ -327,7 +327,7 @@ typedef struct W_View {
     
     struct W_View *nextSister;	       /* next on parent's children list */
     
-    struct W_EventHandler *handlerList;/* list of event handlers for this window */
+    WMBag *eventHandlers;	       /* event handlers for this window */
 
     unsigned long attribFlags;
     XSetWindowAttributes attribs;
@@ -377,8 +377,6 @@ typedef struct W_EventHandler {
     WMEventProc *proc;
 
     void *clientData;
-
-    struct W_EventHandler *nextHandler;
 } W_EventHandler;
 
 
@@ -408,6 +406,7 @@ extern _WINGsConfiguration WINGsConfiguration;
 #define W_VIEW_REALIZED(view)	(view)->flags.realized
 #define W_VIEW_MAPPED(view)	(view)->flags.mapped
  
+#define W_VIEW_DISPLAY(view)    (view)->screen->display
 #define W_VIEW_SCREEN(view)	(view)->screen
 #define W_VIEW_DRAWABLE(view)	(view)->window
     
@@ -429,6 +428,8 @@ W_View *W_CreateView(W_View *parent);
 
 W_View *W_CreateTopView(W_Screen *screen);
 
+W_View *W_CreateUnmanagedTopView(W_Screen *screen);
+
 
 W_View *W_CreateRootView(W_Screen *screen);
 
@@ -438,6 +439,11 @@ void W_RealizeView(W_View *view);
 
 void W_ReparentView(W_View *view, W_View *newParent, int x, int y);
 
+void W_RaiseView(W_View *view);
+
+void W_LowerView(W_View *view);
+
+
 void W_MapView(W_View *view);
 
 void W_MapSubviews(W_View *view);

WINGs/bagtree.c

@@ -248,7 +248,7 @@ static void rbDeleteFixup(W_TreeBag *tree, W_Node *node)
 	    if (w->color == 'R') {
 		w->color = 'B';
 		node->parent->color = 'R';
-		leftRotate(tree, node->parent);
+		rightRotate(tree, node->parent);
 		w = node->parent->left;
 	    }
 	    if (w->left->color == 'B' && w->right->color == 'B') {
@@ -258,18 +258,19 @@ static void rbDeleteFixup(W_TreeBag *tree, W_Node *node)
 		if (w->left->color == 'B') {
 		    w->right->color = 'B';
 		    w->color = 'R';
-		    rightRotate(tree, w);
+		    leftRotate(tree, w);
 		    w = node->parent->left;
 		}
 		w->color = node->parent->color;
 		node->parent->color = 'B';
 		w->left->color = 'B';
-		leftRotate(tree, node->parent);
+		rightRotate(tree, node->parent);
 		node = tree->root;
 	    }	    
 	}
     }
     node->color = 'B';
+					  
 }
 
 
@@ -481,11 +482,13 @@ static int appendBag(WMBag *self, WMBag *bag)
     return 1;
 }
 
+extern WMBag *bla;
 
 static int putInBag(WMBag *self, void *item)
 {
     W_Node *ptr;
     
+    
     ptr = wmalloc(sizeof(W_Node));
     
     ptr->data = item;
@@ -569,6 +572,8 @@ static int eraseFromBag(WMBag *self, int index)
 	    self->destructor(ptr->data);
 	free(ptr);
 
+	wassertrv(SELF->count == 0||SELF->root->index >= 0, 1);
+
 	return 1;
     } else {
 	return 0;
@@ -596,6 +601,8 @@ static int deleteFromBag(WMBag *self, int index)
 	    self->destructor(ptr->data);
 	free(ptr);
 
+	wassertrv(SELF->count == 0||SELF->root->index >= 0, 1);
+	
 	return 1;
     } else {
 	return 0;

WINGs/dragsource.c

@@ -713,7 +713,7 @@ WMDragImageFromView(WMView *view, WMPixmap *image, char *dataTypes[],
     /* start pointer grab */
     XGrabPointer(dpy, scr->rootWin, False,
 		 ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
-		 GrabModeSync, GrabModeAsync, None, scr->defaultCursor,
+		 GrabModeAsync, GrabModeAsync, None, scr->defaultCursor,
 		 CurrentTime);
 
     XFlush(dpy);
@@ -739,7 +739,6 @@ WMDragImageFromView(WMView *view, WMPixmap *image, char *dataTypes[],
     state = 1;
 
     while (state != 6 && state != 0 && !_XErrorOccured) {
-	XAllowEvents(dpy, SyncPointer, CurrentTime);
 	WMNextEvent(dpy, &ev);
 
 	switch (ev.type) {

WINGs/wballoon.c

@@ -61,16 +61,13 @@ W_CreateBalloon(WMScreen *scr)
     bPtr = wmalloc(sizeof(Balloon));
     memset(bPtr, 0, sizeof(Balloon));
 
-    bPtr->view = W_CreateTopView(scr);
+    bPtr->view = W_CreateUnmanagedTopView(scr);
     if (!bPtr->view) {
 	wfree(bPtr);
 	return NULL;
     }
     bPtr->view->self = bPtr;
 
-    bPtr->view->attribFlags |= CWOverrideRedirect;
-    bPtr->view->attribs.override_redirect = True;
-
     bPtr->textColor = WMRetainColor(bPtr->view->screen->black);
 
     WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);

WINGs/wevent.c

@@ -403,38 +403,27 @@ void
 WMCreateEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
 		     void *clientData)
 {
-    W_EventHandler *handler;
+    W_EventHandler *handler, *ptr;
-    W_EventHandler *ptr = view->handlerList;
     unsigned long eventMask;
+    WMBagIterator iter;
 
-    if (ptr==NULL) {
-	handler = wmalloc(sizeof(W_EventHandler));
     
-	handler->nextHandler = NULL;
-	
-	view->handlerList = handler;
-	
-	eventMask = mask;
-    } else {
     handler = NULL;
     eventMask = mask;
-	while (ptr != NULL) {
+
+    WM_ITERATE_BAG(view->eventHandlers, ptr, iter) {
 	if (ptr->clientData == clientData && ptr->proc == eventProc) {
 	    handler = ptr;
-	    }	    
 	    eventMask |= ptr->eventMask;
-	    
+	}
-	    ptr = ptr->nextHandler;
     }
     if (!handler) {
 	handler = wmalloc(sizeof(W_EventHandler));
-	    handler->nextHandler = view->handlerList;
-	    view->handlerList = handler;
-	}	
-    }
 
+	WMPutInBag(view->eventHandlers, handler);
+    }
     /* select events for window */
-    handler->eventMask = mask;
+    handler->eventMask = eventMask;
     handler->proc = eventProc;
     handler->clientData = clientData;
 }
@@ -450,31 +439,24 @@ void
 WMDeleteEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc, 
 		     void *clientData)
 {
-    W_EventHandler *handler, *ptr, *pptr;
+    W_EventHandler *handler, *ptr;
-    
+    WMBagIterator iter;
-    ptr = view->handlerList;
         
     handler = NULL;
-    pptr = NULL;
     
-    while (ptr!=NULL) {
+    WM_ITERATE_BAG(view->eventHandlers, ptr, iter) {
 	if (ptr->eventMask == mask && ptr->proc == eventProc 
 	    && ptr->clientData == clientData) {
 	    handler = ptr;
 	    break;
 	}
-	pptr = ptr;
-	ptr = ptr->nextHandler;
     }
     
     if (!handler)
 	return;
     
-    if (!pptr) {
+    WMRemoveFromBag(view->eventHandlers, handler);
-	view->handlerList = handler->nextHandler;
+
-    } else {
-	pptr->nextHandler = handler->nextHandler;
-    }
     wfree(handler);
 }
 
@@ -483,14 +465,11 @@ WMDeleteEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
 void
 W_CleanUpEvents(WMView *view)
 {
-    W_EventHandler *ptr, *nptr;
+    W_EventHandler *ptr;
+    WMBagIterator iter;
     
-    ptr = view->handlerList;
+    WM_ITERATE_BAG(view->eventHandlers, ptr, iter) {
-        
-    while (ptr!=NULL) {
-	nptr = ptr->nextHandler;
 	wfree(ptr);
-	ptr = nptr;
     }
 }
 
@@ -529,18 +508,17 @@ void
 W_CallDestroyHandlers(W_View *view)
 {
     XEvent event;
+    WMBagIterator iter;
     W_EventHandler *hPtr;
     
     event.type = DestroyNotify;
     event.xdestroywindow.window = view->window;
     event.xdestroywindow.event = view->window;
-    hPtr = view->handlerList;
+
-    while (hPtr!=NULL) {
+    WM_ITERATE_BAG(view->eventHandlers, hPtr, iter) {
 	if (hPtr->eventMask & StructureNotifyMask) {
 	    (*hPtr->proc)(&event, hPtr->clientData);
 	}
-	
-	hPtr = hPtr->nextHandler;
     }
 }
 
@@ -552,6 +530,7 @@ WMHandleEvent(XEvent *event)
     W_View *view, *vPtr, *toplevel;
     unsigned long mask;
     Window window;
+    WMBagIterator iter;
 
     if (event->type == MappingNotify) {
 	XRefreshKeyboardMapping(&event->xmapping);
@@ -570,6 +549,7 @@ WMHandleEvent(XEvent *event)
 	}
     }
     view = W_GetViewForXWindow(event->xany.display, window);
+
     if (!view) {
 	if (extraEventHandler)
 	    (extraEventHandler)(event);
@@ -642,34 +622,23 @@ WMHandleEvent(XEvent *event)
      * might destroy the widget. */
     W_RetainView(toplevel);
 
-    hPtr = view->handlerList;
+    WM_ITERATE_BAG(view->eventHandlers, hPtr, iter) {
-
-    while (hPtr!=NULL) {
-	W_EventHandler *tmp;
-
-	tmp = hPtr->nextHandler;
-
 	if ((hPtr->eventMask & mask)) {
 	    (*hPtr->proc)(event, hPtr->clientData);
 	}
-	
-	hPtr = tmp;
     }
 
     /* pass the event to the top level window of the widget */
+    /* TODO: change this to a responder chain */
     if (view->parent != NULL) {
 	vPtr = view;
 	while (vPtr->parent != NULL)
 	    vPtr = vPtr->parent;
 
-	hPtr = vPtr->handlerList;
+	WM_ITERATE_BAG(vPtr->eventHandlers, hPtr, iter) {
-
-	while (hPtr != NULL) {
-	
 	    if (hPtr->eventMask & mask) {
 		(*hPtr->proc)(event, hPtr->clientData);
 	    }
-	    hPtr = hPtr->nextHandler;
 	}
     }
 

WINGs/widgets.c

@@ -880,6 +880,13 @@ WMMapWidget(WMWidget *w)
 }
 
 
+void
+WMReparentWidget(WMWidget *w, WMWidget *newParent, int x, int y)
+{
+    W_ReparentView(W_VIEW(w), newParent, x, y);
+}
+
+
 static void
 makeChildrenAutomap(W_View *view, int flag)
 {
@@ -930,6 +937,22 @@ void
 WMSetWidgetBackgroundColor(WMWidget *w, WMColor *color)
 {    
     W_SetViewBackgroundColor(W_VIEW(w), color);
+    if (W_VIEW(w)->flags.mapped)
+	WMRedisplayWidget(w);
+}
+
+
+void
+WMRaiseWidget(WMWidget *w)
+{
+     W_RaiseView(W_VIEW(w));
+}
+
+
+void
+WMLowerWidget(WMWidget *w)
+{
+     W_LowerView(W_VIEW(w));
 }
 
 

WINGs/wlabel.c

@@ -98,6 +98,13 @@ WMGetLabelImage(WMLabel *lPtr)
 }
 
 
+char *
+WMGetLabelText(WMLabel *lPtr)
+{
+    return lPtr->caption;
+}
+
+
 void
 WMSetLabelImagePosition(WMLabel *lPtr, WMImagePosition position)
 {

WINGs/wpopupbutton.c

@@ -95,9 +95,7 @@ WMCreatePopUpButton(WMWidget *parent)
 
     bPtr->selectedItemIndex = -1;
 
-    bPtr->menuView = W_CreateTopView(scr);
+    bPtr->menuView = W_CreateUnmanagedTopView(scr);
-    bPtr->menuView->attribs.override_redirect = True;
-    bPtr->menuView->attribFlags |= CWOverrideRedirect;
 
     W_ResizeView(bPtr->menuView, bPtr->view->size.width, 1);
 

WINGs/wruler.c

@@ -43,8 +43,7 @@ typedef struct W_Ruler {
    |
 
  */
-static void
+static void drawLeftMarker(Ruler * rPtr)
-drawLeftMarker(Ruler *rPtr)
 {
     XPoint points[4];
     int xpos = (rPtr->flags.whichMarker == 1 ?
@@ -74,8 +73,7 @@ drawLeftMarker(Ruler *rPtr)
    |
 
  */
-static void
+static void drawRightMarker(Ruler * rPtr)
-drawRightMarker(Ruler *rPtr)
 {
     XPoint points[4];
     int xpos = (rPtr->flags.whichMarker == 2 ?
@@ -102,11 +100,11 @@ drawRightMarker(Ruler *rPtr)
    |
 
  */
-static void
+static void drawFirstMarker(Ruler * rPtr)
-drawFirstMarker(Ruler *rPtr)
 {
     int xpos = ((rPtr->flags.whichMarker == 3 || rPtr->flags.whichMarker == 6) ?
 		rPtr->motion : rPtr->margins.first);
+
     XFillRectangle(rPtr->view->screen->display, rPtr->drawBuffer,
 		   rPtr->fg, xpos - 5, 10, 11, 5);
     XDrawLine(rPtr->view->screen->display, rPtr->drawBuffer,
@@ -118,12 +116,12 @@ drawFirstMarker(Ruler *rPtr)
    \   /
    \./
  */
-static void
+static void drawBodyMarker(Ruler * rPtr)
-drawBodyMarker(Ruler *rPtr)
 {
     XPoint points[4];
     int xpos = ((rPtr->flags.whichMarker == 4 || rPtr->flags.whichMarker == 6) ?
 		rPtr->motion : rPtr->margins.body);
+
     points[0].x = xpos - 5;
     points[0].y = 16;
     points[1].x = points[0].x + 11;
@@ -135,8 +133,7 @@ drawBodyMarker(Ruler *rPtr)
 }
 
 
-static void
+static void createDrawBuffer(Ruler * rPtr)
-createDrawBuffer(Ruler *rPtr)
 {
     if (rPtr->drawBuffer)
 	XFreePixmap(rPtr->view->screen->display, rPtr->drawBuffer);
@@ -148,12 +145,12 @@ createDrawBuffer(Ruler *rPtr)
 }
 
 
-static void
+static void drawRulerOnPixmap(Ruler * rPtr)
-drawRulerOnPixmap(Ruler *rPtr)
 {
     int i, j, w, m;
     char c[3];
-    int marks[9] = {11, 3, 5, 3, 7, 3, 5, 3};
+    int marks[9] =
+    {11, 3, 5, 3, 7, 3, 5, 3};
 
     if (!rPtr->drawBuffer)
 	createDrawBuffer(rPtr);
@@ -196,14 +193,13 @@ drawRulerOnPixmap(Ruler *rPtr)
 }
 
 
-static void
+static void paintRuler(Ruler * rPtr)
-paintRuler(Ruler *rPtr)
 {
     WMScreen *screen = rPtr->view->screen;
+
     if (1 || !rPtr->drawBuffer) {
 	drawRulerOnPixmap(rPtr);
     }
-
     XCopyArea(rPtr->view->screen->display, rPtr->drawBuffer,
 	  rPtr->view->window, rPtr->bg, 0, 0, rPtr->view->size.width, 40,
 	      0, 0);
@@ -256,8 +252,7 @@ verifyMarkerMove(Ruler *rPtr, int x)
 }
 
 
-static int
+static int whichMarker(Ruler * rPtr, int x, int y)
-whichMarker(Ruler *rPtr, int x, int y)
 {
     if (x < rPtr->offset || y > 22)
 	return 0;
@@ -267,13 +262,11 @@ whichMarker(Ruler *rPtr, int x, int y)
 	rPtr->motion = rPtr->margins.left;
 	return 1;
     }
-
     if (rPtr->margins.right - x >= -1 && y <= 11
 	&& rPtr->margins.right - x <= 5 && y >= 4) {
 	rPtr->motion = rPtr->margins.right;
 	return 2;
     }
-
 #if 0
     /* both first and body? */
     if (rPtr->margins.first - x <= 4 && rPtr->margins.first - x >= -5
@@ -289,14 +282,11 @@ whichMarker(Ruler *rPtr, int x, int y)
 	rPtr->motion = rPtr->margins.first;
 	return 3;
     }
-
     if (rPtr->margins.body - x <= 4 && y <= 21 &&
 	rPtr->margins.body - x >= -5 && y >= 17) {
 	rPtr->motion = rPtr->margins.body;
 	return 4;
     }
-
-
     /* do tabs (5) */
 
 
@@ -304,8 +294,7 @@ whichMarker(Ruler *rPtr, int x, int y)
 }
 
 
-static void
+static void handleEvents(XEvent * event, void *data)
-handleEvents(XEvent *event, void *data)
 {
     Ruler *rPtr = (Ruler *) data;
     Display *dpy = event->xany.display;
@@ -320,6 +309,7 @@ handleEvents(XEvent *event, void *data)
 	      && (event->xmotion.state & Button1Mask)) {
 	      if (verifyMarkerMove(rPtr, event->xmotion.x)) {
 		  GC gc = WMColorGC(WMDarkGrayColor(rPtr->view->screen));
+
 		  paintRuler(rPtr);
 		  if (rPtr->moveAction)
 		      (rPtr->moveAction) (rPtr, rPtr->clientData);
@@ -349,16 +339,26 @@ handleEvents(XEvent *event, void *data)
 	  switch (rPtr->flags.whichMarker) {
 	    case 1:{
 		    int change = rPtr->margins.left - rPtr->motion;
+
 		    rPtr->margins.first -= change;
 		    rPtr->margins.body -= change;
 		    rPtr->margins.left = rPtr->motion;
-            paintRuler(rPtr); break;
+		    paintRuler(rPtr);
+		    break;
 		}
-        case 2: rPtr->margins.right = rPtr->motion; break;
+	    case 2:
-        case 3: rPtr->margins.first = rPtr->motion; break;
+		rPtr->margins.right = rPtr->motion;
-        case 4: rPtr->margins.body = rPtr->motion; break;
+		break;
-        case 6: rPtr->margins.first = rPtr->margins.body
+	    case 3:
-            = rPtr->motion; break;
+		rPtr->margins.first = rPtr->motion;
+		break;
+	    case 4:
+		rPtr->margins.body = rPtr->motion;
+		break;
+	    case 6:
+		rPtr->margins.first = rPtr->margins.body
+		    = rPtr->motion;
+		break;
 	  }
 	  if (rPtr->releaseAction)
 	      (rPtr->releaseAction) (rPtr, rPtr->clientData);
@@ -366,8 +366,7 @@ handleEvents(XEvent *event, void *data)
     }
 }
 
-static void
+static void rulerDidResize(W_ViewDelegate * self, WMView * view)
-rulerDidResize(W_ViewDelegate *self, WMView *view)
 {
     Ruler *rPtr = (Ruler *) view->self;
 
@@ -437,8 +436,7 @@ WMCreateRuler(WMWidget *parent)
 }
 
 
-void
+void WMSetRulerMargins(WMRuler * rPtr, WMRulerMargins margins)
-WMSetRulerMargins(WMRuler *rPtr, WMRulerMargins margins)
 {
     if (!rPtr)
 	return;
@@ -471,8 +469,7 @@ WMGetRulerMargins(WMRuler *rPtr)
 }
 
 
-void
+void WMSetRulerOffset(WMRuler * rPtr, int pixels)
-WMSetRulerOffset(WMRuler *rPtr, int pixels)
 {
     if (!rPtr || pixels < 0 || pixels + MIN_DOC_WIDTH >= rPtr->view->size.width)
 	return;
@@ -481,8 +478,7 @@ WMSetRulerOffset(WMRuler *rPtr, int pixels)
 }
 
 
-int
+int WMGetRulerOffset(WMRuler * rPtr)
-WMGetRulerOffset(WMRuler *rPtr)
 {
     if (!rPtr)
 	return;
@@ -490,8 +486,7 @@ WMGetRulerOffset(WMRuler *rPtr)
 }
 
 
-void
+void WMSetRulerReleaseAction(WMRuler * rPtr, WMAction * action, void *clientData)
-WMSetRulerReleaseAction(WMRuler *rPtr, WMAction *action, void *clientData)
 {
     if (!rPtr)
 	return;
@@ -501,8 +496,7 @@ WMSetRulerReleaseAction(WMRuler *rPtr, WMAction *action, void *clientData)
 }
 
 
-void
+void WMSetRulerMoveAction(WMRuler * rPtr, WMAction * action, void *clientData)
-WMSetRulerMoveAction(WMRuler *rPtr, WMAction *action, void *clientData)
 {
     if (!rPtr)
 	return;
@@ -513,8 +507,7 @@ WMSetRulerMoveAction(WMRuler *rPtr, WMAction *action, void *clientData)
 
 
 /* _which_ one was released */
-int
+int WMGetReleasedRulerMargin(WMRuler * rPtr)
-WMGetReleasedRulerMargin(WMRuler *rPtr)
 {
     if (!rPtr)
 	return 0;
@@ -523,12 +516,9 @@ WMGetReleasedRulerMargin(WMRuler *rPtr)
 
 
 /* _which_ one is being grabbed */
-int
+int WMGetGrabbedRulerMargin(WMRuler * rPtr)
-WMGetGrabbedRulerMargin(WMRuler *rPtr)
 {
     if (!rPtr)
 	return 0;
     return rPtr->flags.whichMarker;
 }
-
-

WINGs/wscrollview.c

@@ -424,6 +424,8 @@ WMSetScrollViewRelief(WMScrollView *sPtr, WMReliefType type)
 {
     sPtr->flags.relief = type;
     
+    reorganizeInterior(sPtr);
+    
     if (sPtr->view->flags.mapped)
 	paintScrollView(sPtr);
     

WINGs/wtabview.c

@@ -724,6 +724,22 @@ WMCreateTabViewItemWithIdentifier(int identifier)
 }
 
 
+WMTabViewItem*
+WMCreateTabViewItem(int identifier, char *label)
+{
+    WMTabViewItem *item;
+
+    item = wmalloc(sizeof(WMTabViewItem));
+    memset(item, 0, sizeof(WMTabViewItem));
+
+    item->identifier = identifier;
+    WMSetTabViewItemLabel(item, label);
+
+    return item;
+}
+
+
+
 int
 WMGetTabViewItemIdentifier(WMTabViewItem *item)
 {

WINGs/wtest.c

@@ -140,6 +140,44 @@ testList(WMScreen *scr)
 }
 
 
+void
+testButton(WMScreen *scr)
+{
+    WMWindow *win;
+    int i;
+    char *types[] = {
+	"MomentaryPush",
+	    "PushOnPushOff",
+	    "Toggle",
+	    "Switch",
+	    "Radio",
+	    "MomentaryChange",
+	    "OnOff",
+	    "MomentaryLigh"
+    };
+
+    windowCount++;
+    
+    win = WMCreateWindow(scr, "testButton");
+    WMResizeWidget(win, 300, 300);
+    WMSetWindowTitle(win, "Buttons");
+
+    WMSetWindowCloseAction(win, closeAction, NULL);
+
+    for (i = 1; i < 9; i++) {
+	WMButton *b;
+	b = WMCreateButton(win, i);
+	WMResizeWidget(b, 150, 24);
+	WMMoveWidget(b, 20, i*30);
+	WMSetButtonText(b, types[i-1]);
+    }
+
+    WMRealizeWidget(win);
+    WMMapSubwidgets(win);
+    WMMapWidget(win);
+}
+
+
 void
 testGradientButtons(WMScreen *scr)
 {
@@ -1042,6 +1080,10 @@ int main(int argc, char **argv)
     testDragAndDrop(scr);
     testDragAndDrop(scr);
 
+    testScrollView(scr);
+    
+    testButton(scr);
+
 #if 0    
     testFrame(scr);
 
@@ -1061,7 +1103,6 @@ int main(int argc, char **argv)
 
     testOpenFilePanel(scr);
     testList(scr);
-    testScrollView(scr);
 
 
     testSlider(scr);

WINGs/wtextfield.c

@@ -298,6 +298,7 @@ _notification(void *observerData, WMNotification *notification)
     if (to != tw) lostHandler(to->view, XA_PRIMARY, NULL);
 }
 
+
 WMTextField*
 WMCreateTextField(WMWidget *parent)
 {
@@ -1028,6 +1029,11 @@ handleTextFieldKeyPress(TextField *tPtr, XEvent *event)
         textEvent = WMTextDidEndEditingNotification;
 	break;
 
+     case XK_Escape:
+        data = (void*)WMEscapeTextMovement;
+        textEvent = WMTextDidEndEditingNotification;
+	break;
+
      case XK_Return:
         data = (void*)WMReturnTextMovement;
         textEvent = WMTextDidEndEditingNotification;
@@ -1229,9 +1235,11 @@ handleTextFieldKeyPress(TextField *tPtr, XEvent *event)
             if (textEvent==WMTextDidBeginEditingNotification &&
                 tPtr->delegate->didBeginEditing)
                 (*tPtr->delegate->didBeginEditing)(tPtr->delegate, notif);
+
             else if (textEvent==WMTextDidEndEditingNotification &&
                      tPtr->delegate->didEndEditing)
                 (*tPtr->delegate->didEndEditing)(tPtr->delegate, notif);
+
             else if (textEvent==WMTextDidChangeNotification &&
                      tPtr->delegate->didChange)
                 (*tPtr->delegate->didChange)(tPtr->delegate, notif);

WINGs/wview.c

@@ -113,8 +113,6 @@ createView(W_Screen *screen, W_View *parent)
     view = wmalloc(sizeof(W_View));
     memset(view, 0, sizeof(W_View));
 
-    view->refCount = 1;
-    
     view->screen = screen;
 
     if (parent!=NULL) {
@@ -132,6 +130,8 @@ createView(W_Screen *screen, W_View *parent)
 	adoptChildView(parent, view);
     }
     
+    view->eventHandlers = WMCreateBag(4);
+
     return view;
 }
 
@@ -182,6 +182,24 @@ W_CreateTopView(W_Screen *screen)
 }
 
 
+W_View*
+W_CreateUnmanagedTopView(W_Screen *screen)
+{
+    W_View *view;
+    
+    view = createView(screen, screen->rootView);
+    if (!view)
+	return NULL;
+
+    view->flags.topLevel = 1;
+    view->attribs.event_mask |= StructureNotifyMask;
+
+    view->attribFlags |= CWOverrideRedirect;
+    view->attribs.override_redirect = True;
+
+    return view;
+}
+
 
 void
 W_RealizeView(W_View *view)
@@ -253,6 +271,23 @@ W_ReparentView(W_View *view, W_View *newParent, int x, int y)
 }
 
 
+void
+W_RaiseView(W_View *view)
+{
+    if (W_VIEW_REALIZED(view))
+	XRaiseWindow(W_VIEW_DISPLAY(view), W_VIEW_DRAWABLE(view));
+}
+
+
+
+void
+W_LowerView(W_View *view)
+{
+    if (W_VIEW_REALIZED(view))
+	XLowerWindow(W_VIEW_DISPLAY(view), W_VIEW_DRAWABLE(view));
+}
+
+
 
 void
 W_MapView(W_View *view)
@@ -324,7 +359,9 @@ W_TopLevelOfView(W_View *view)
 {
     W_View *toplevel;
     
-    for (toplevel=view; !toplevel->flags.topLevel; toplevel=toplevel->parent);
+    for (toplevel=view;
+	 toplevel && !toplevel->flags.topLevel; 
+	 toplevel=toplevel->parent);
     
     return toplevel;
 }
@@ -391,7 +428,8 @@ destroyView(W_View *view)
     W_CallDestroyHandlers(view);
 
     if (view->flags.realized) {
-	XDeleteContext(view->screen->display, view->window, ViewContext);
+	XDeleteContext(view->screen->display,
+		       view->window, ViewContext);
     
 	/* if parent is being destroyed, it will die naturaly */
 	if (!view->flags.parentDying || view->flags.topLevel)
@@ -403,6 +441,9 @@ destroyView(W_View *view)
 
     W_CleanUpEvents(view);
     
+    WMFreeBag(view->eventHandlers);
+    view->eventHandlers = NULL;
+    
     WMUnregisterViewDraggedTypes(view);
     
 #if 0    
@@ -424,7 +465,8 @@ destroyView(W_View *view)
 void
 W_DestroyView(W_View *view)
 {
-    W_ReleaseView(view);
+    if (view->refCount == 0)
+	destroyView(view);
 }
 
 
@@ -607,6 +649,7 @@ WMView*
 W_RetainView(WMView *view)
 {
     view->refCount++;
+
     return view;
 }
 
@@ -616,7 +659,8 @@ void
 W_ReleaseView(WMView *view)
 {
     view->refCount--;
-    if (view->refCount < 1) {
+
+    if (view->refCount < 0) {
 	destroyView(view);
     }
 }