diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 3835e2b078..ae91c837f2 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -16,6 +16,18 @@
    The license applies to all entries newer than 2009-04-28.
 */
 
+2011-04-30 17:57 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com)
+  * contrib/hbxbp/xbpparthandler.prg
+  * contrib/hbxbp/xbpprinter.prg
+  * contrib/hbxbp/xbpwindow.prg
+    ! Code optimizations.
+
+  * contrib/hbxbp/xbpgeneric.prg
+    ! Changed: the way event loop was being constructed and processed.
+      Now, no event is missed and is dealt with properly.
+      Not best of the ways but my experiments could not lead to 
+      any better algorithm.
+
 2011-04-30 16:21 UTC-0800 Pritpal Bedi (bedipritpal@hotmail.com)
   * contrib/gtwvg/gtwvg.c
   * contrib/gtwvg/gtwvg.h
diff --git a/harbour/contrib/hbxbp/xbpgeneric.prg b/harbour/contrib/hbxbp/xbpgeneric.prg
index 7f28606b38..65ddd5dfdd 100644
--- a/harbour/contrib/hbxbp/xbpgeneric.prg
+++ b/harbour/contrib/hbxbp/xbpgeneric.prg
@@ -73,14 +73,14 @@
 
 /*----------------------------------------------------------------------*/
 
-#define EVENT_BUFFER    200
+#define EVENT_BUFFER    128
 
 /*----------------------------------------------------------------------*/
 
 STATIC s_oDeskTop
 STATIC s_hLastEvent := {=>}
 
-THREAD STATIC t_events
+THREAD STATIC t_events    := {}
 
 THREAD STATIC t_nEventIn  := 0
 THREAD STATIC t_nEventOut := 0
@@ -118,12 +118,12 @@ EXIT PROCEDURE hbxbp_End()
  * Will be called from XbpDialog() | XbpCRT()
  */
 FUNCTION hbxbp_InitializeEventBuffer()
-
+#if 0
    IF empty( t_events )
       t_events := array( EVENT_BUFFER )
       aeval( t_events, {|e,i| HB_SYMBOL_UNUSED( e ), t_events[ i ] := { 0, NIL, NIL, NIL } } )
    ENDIF
-
+#endif
    RETURN nil
 
 /*----------------------------------------------------------------------*/
@@ -189,6 +189,62 @@ FUNCTION LastAppEvent( mp1, mp2, oXbp, nThreadID )
    RETURN nEvent
 
 /*----------------------------------------------------------------------*/
+#if 1
+/*----------------------------------------------------------------------*/
+
+FUNCTION NextAppEvent( mp1, mp2, oXbp )
+   LOCAL nEvent
+
+   IF ! empty( t_events )
+      nEvent := t_events[ 1, 1 ]
+      mp1    := t_events[ 1, 2 ]
+      mp2    := t_events[ 1, 3 ]
+      oXbp   := t_events[ 1, 4 ]
+   ENDIF
+
+   RETURN nEvent
+
+/*----------------------------------------------------------------------*/
+
+PROCEDURE SetAppEvent( nEvent, mp1, mp2, oXbp )
+
+   aadd( t_events, { nEvent, mp1, mp2, iif( empty( oXbp ), t_oAppWindow, oXbp ) } )
+
+   /* HB_TRACE( HB_TR_ALWAYS, len( t_events ) ) */
+
+   RETURN
+
+/*----------------------------------------------------------------------*/
+
+FUNCTION AppEvent( mp1, mp2, oXbp, nTimeout )
+   LOCAL nEvent := 0
+
+   HB_SYMBOL_UNUSED( nTimeOut )
+
+   DO WHILE ! empty( t_oEventLoop )
+      t_oEventLoop:processEvents( QEventLoop_AllEvents )
+
+      IF ! empty( t_events )
+         nEvent := t_events[ 1, 1 ]
+         mp1    := t_events[ 1, 2 ]
+         mp2    := t_events[ 1, 3 ]
+         oXbp   := t_events[ 1, 4 ]
+
+         hb_adel( t_events, 1, .t. )
+
+         EXIT
+      ENDIF
+
+      hb_releaseCPU()
+   ENDDO
+
+   s_hLastEvent[ hb_threadID() ] := { nEvent, mp1, mp2, oXbp }
+
+   RETURN nEvent
+
+/*----------------------------------------------------------------------*/
+#else
+/*----------------------------------------------------------------------*/
 
 FUNCTION NextAppEvent( mp1, mp2, oXbp )
    LOCAL nEvent, n
@@ -212,25 +268,43 @@ FUNCTION NextAppEvent( mp1, mp2, oXbp )
 /*
  *  Internal to the XbpParts, must NOT be called from application code
  */
-FUNCTION SetAppEvent( nEvent, mp1, mp2, oXbp )
+PROCEDURE SetAppEvent( nEvent, mp1, mp2, oXbp )
+   LOCAL ooXbp := iif( empty( oXbp ), t_oAppWindow, oXbp )
+   LOCAL nEventIn := t_nEventIn
 
    IF empty( t_events )
       hbxbp_InitializeEventBuffer()
    ENDIF
 
-   IF ++t_nEventIn > EVENT_BUFFER
-      t_nEventIn := 1
+   /* if current event is not taken and it is of same nature just update parameters */
+   IF ! empty( t_nEventIn ) .AND. ! empty( t_events[ nEventIn, 4 ] ) ;
+            .AND. nEvent == t_events[ nEventIn, 1 ] .AND. ooXbp == t_events[ nEventIn, 4 ]
+      t_events[ nEventIn, 2 ] := mp1
+      t_events[ nEventIn, 3 ] := mp2
+      RETURN
    ENDIF
 
-//HB_TRACE( HB_TR_DEBUG, "SetAppEvent ... ", t_nEventIn, nEvent, oXbp:className(), oXbp:title )
+   IF ++nEventIn > len( t_events )
+      nEventIn := 1
+   ENDIF
 
-   t_events[ t_nEventIn, 1 ] := nEvent
-   t_events[ t_nEventIn, 2 ] := mp1
-   t_events[ t_nEventIn, 3 ] := mp2
-   t_events[ t_nEventIn, 4 ] := iif( empty( oXbp ), t_oAppWindow, oXbp )
+   IF !empty( t_events[ nEventIn, 4 ] )
+      hb_ains( t_events, nEventIn, { nEvent, mp1, mp2, ooXbp }, .t. )
 
-//HB_TRACE( HB_TR_DEBUG, 1, "SetAppEvent ... ", hb_threadId(), nEvent )
-   RETURN nil
+      HB_TRACE( HB_TR_ALWAYS, "................t_nEventIn", 0, nEventIn )
+
+   ELSE
+      HB_TRACE( HB_TR_ALWAYS, "................t_nEventIn", 1, nEventIn )
+
+      t_events[ nEventIn, 1 ] := nEvent
+      t_events[ nEventIn, 2 ] := mp1
+      t_events[ nEventIn, 3 ] := mp2
+      t_events[ nEventIn, 4 ] := ooXbp
+   ENDIF
+
+   t_nEventIn := nEventIn
+
+   RETURN
 
 /*----------------------------------------------------------------------*/
 
@@ -238,36 +312,41 @@ FUNCTION AppEvent( mp1, mp2, oXbp, nTimeout )
    LOCAL nEvent := 0
    LOCAL nThreadID := hb_threadId()
 
-   //DEFAULT nTimeout TO 0
    HB_SYMBOL_UNUSED( nTimeOut )
 
-   IF ++t_nEventOut > EVENT_BUFFER
+   IF empty( t_nEventOut ) .OR. ++t_nEventOut > len( t_events )
       t_nEventOut := 1
    ENDIF
-//HB_TRACE( HB_TR_DEBUG, "            AppEvent ... ", nThreadID, t_nEventOut )
-   DO WHILE !empty( t_oEventLoop ) //.t.
+
+   HB_TRACE( HB_TR_ALWAYS, "t_nEventOut", t_nEventOut )
+
+   //DO WHILE ! empty( t_oEventLoop )
       t_oEventLoop:processEvents( QEventLoop_AllEvents )
 
-      IF !empty(   t_events[ t_nEventOut, 4 ] )
-         //
+      IF ! empty( t_events[ t_nEventOut, 4 ] )
          nEvent := t_events[ t_nEventOut, 1 ]
          mp1    := t_events[ t_nEventOut, 2 ]
          mp2    := t_events[ t_nEventOut, 3 ]
          oXbp   := t_events[ t_nEventOut, 4 ]
-         //
+
          t_events[ t_nEventOut, 4 ] := NIL
-         EXIT
+         //EXIT
+      ELSE
+         mp1 := NIL
+         mp2 := NIL
+         oXbp := t_oAppWindow
       ENDIF
+
       hb_releaseCPU()
-   ENDDO
+   //ENDDO
 
    s_hLastEvent[ nThreadID ] := { nEvent, mp1, mp2, oXbp }
 
-//HB_TRACE( HB_TR_DEBUG, "..........................", hb_threadId() )
-
    RETURN nEvent
 
 /*----------------------------------------------------------------------*/
+#endif
+/*----------------------------------------------------------------------*/
 
 FUNCTION SetAppWindow( oXbp )
    LOCAL oldAppWindow := t_oAppWindow
diff --git a/harbour/contrib/hbxbp/xbpparthandler.prg b/harbour/contrib/hbxbp/xbpparthandler.prg
index 4f5d6dfe73..68ea286ff8 100644
--- a/harbour/contrib/hbxbp/xbpparthandler.prg
+++ b/harbour/contrib/hbxbp/xbpparthandler.prg
@@ -320,7 +320,7 @@ METHOD XbpPartHandler:moveOwned( nOffSetX, nOffSetY )
    LOCAL oXbp, oPos
 
    FOR EACH oXbp IN ::a_Owned
-      IF __objHasMsg( oXbp, "MOVEWITHOWNER" ) .AND. oXbp:moveWithOwner
+      IF __objHasData( oXbp, "MOVEWITHOWNER" ) .AND. oXbp:moveWithOwner
          IF !( oXbp:oParent:className() == "XBPDRAWINGAREA" )
             oPos := oXbp:oWidget:pos()
             oXbp:oWidget:move( oPos:x() + nOffSetX, oPos:y() + nOffSetY )
diff --git a/harbour/contrib/hbxbp/xbpprinter.prg b/harbour/contrib/hbxbp/xbpprinter.prg
index c05cb3c8e6..6e9769cec6 100644
--- a/harbour/contrib/hbxbp/xbpprinter.prg
+++ b/harbour/contrib/hbxbp/xbpprinter.prg
@@ -522,7 +522,6 @@ METHOD XbpPrinter:startDoc( cDocName )
 /*----------------------------------------------------------------------*/
 
 METHOD XbpPrinter:getEngineProperty( nProperty )
-   //LOCAL oVariant := QVariantFromPointer( ::oEngine:property( nProperty ) )
    LOCAL oVariant := ::oEngine:property( nProperty )
 
    DO CASE
diff --git a/harbour/contrib/hbxbp/xbpwindow.prg b/harbour/contrib/hbxbp/xbpwindow.prg
index e71445ca6e..d95a279290 100644
--- a/harbour/contrib/hbxbp/xbpwindow.prg
+++ b/harbour/contrib/hbxbp/xbpwindow.prg
@@ -559,16 +559,12 @@ METHOD XbpWindow:clearSlots()
 
 METHOD XbpWindow:grabEvent( nEvent, oEvent )
    LOCAL nXbpKey, oP0, oP1, oObj_O, oObj_N
-   LOCAL lRet := .t.
-
-//HB_TRACE( HB_TR_DEBUG, hb_threadId(), "XbpWindow:grabEvent", nEvent )
 
    SWITCH ( nEvent )
 
    CASE QEvent_MouseMove                     // :motion()
       SetAppEvent( xbeM_Motion, { oEvent:x(), oEvent:y() }, NIL, self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_MouseButtonPress              // :lbClick() :mbClick() :rbClick()
                                              // :lbDown() :mbDown() :rbDown()
       DO CASE
@@ -579,8 +575,7 @@ METHOD XbpWindow:grabEvent( nEvent, oEvent )
       CASE oEvent:button() == Qt_RightButton
          SetAppEvent( xbeM_RbDown, { oEvent:x(), oEvent:y() }, NIL, self )
       ENDCASE
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_MouseButtonRelease            // :mbUp() :rbUp() :lbUp()
       DO CASE
       CASE oEvent:button() == Qt_LeftButton
@@ -590,8 +585,7 @@ METHOD XbpWindow:grabEvent( nEvent, oEvent )
       CASE oEvent:button() == Qt_RightButton
          SetAppEvent( xbeM_RbUp, { oEvent:x(), oEvent:y() }, NIL, self )
       ENDCASE
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_MouseButtonDblClick           // :lbDblClick() :mbDblClick() :rbDblClick()
       DO CASE
       CASE oEvent:button() == Qt_LeftButton
@@ -601,8 +595,7 @@ METHOD XbpWindow:grabEvent( nEvent, oEvent )
       CASE oEvent:button() == Qt_RightButton
          SetAppEvent( xbeM_RbDblClick, { oEvent:x(), oEvent:y() }, NIL, self )
       ENDCASE
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_ContextMenu                   //
       //SetAppEvent( xbeM_Context, { oEvent:globalX(), oEvent:globalY() }, NIL, self )
       ::hbContextMenu( { oEvent:globalX(), oEvent:globalY() } )
@@ -611,90 +604,62 @@ METHOD XbpWindow:grabEvent( nEvent, oEvent )
       IF ( ::lTrack )
          SetAppEvent( xbeM_Enter, { oEvent:x(), oEvent:y() }, NIL, self )
       ENDIF
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_Leave                         // :leave()
       IF ( ::lTrack )
          SetAppEvent( xbeM_Leave, { oEvent:x(), oEvent:y() }, NIL, self )
       ENDIF
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_Wheel                         // :wheel()
       SetAppEvent( xbeM_Wheel, { oEvent:x(), oEvent:y() }, { oEvent:buttons(), oEvent:delta() }, self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_FocusIn                       // :setInputFocus()
       SetAppEvent( xbeP_SetInputFocus, NIL, NIL, Self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_FocusOut                      // :killInputFocus()
       SetAppEvent( xbeP_KillInputFocus, NIL, NIL, Self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_Paint                         // :paint()
       oObj_N      := oEvent:rect()
       SetAppEvent( xbeP_Paint, { oObj_N:left(), oObj_N:top(), oObj_N:right(), oObj_N:bottom() }, NIL, Self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_Move                          // :move()
       oP0         := oEvent:oldPos()
       oP1         := oEvent:pos()
       ::moveOwned( oP1:x() - oP0:x(), oP1:y() - oP0:y() )
-      SetAppEvent( xbeP_Move, { oP0:x(), oP0:y() }, { oP1:x(), oP1:y() }, Self )
-      lRet := .f.
-      EXIT
+   //   SetAppEvent( xbeP_Move, { oP0:x(), oP0:y() }, { oP1:x(), oP1:y() }, Self )
+      RETURN .f.
    CASE QEvent_Resize                        // :resize()
       oObj_O      := oEvent:oldSize()
       oObj_N      := oEvent:size()
       SetAppEvent( xbeP_Resize, { oObj_O:width(), oObj_O:height() }, { oObj_N:width(), oObj_N:height() }, Self )
-      lRet := .f.
-      EXIT
+      RETURN .f.
    CASE QEvent_DragEnter                     // :dragEnter()
       oObj_O      := oEvent:pos()
       SetAppEvent( xbeP_DragEnter, { oEvent:mouseButtons(), { oObj_O:x(), oObj_O:y() } }, /* oDragObj */, Self )
-      EXIT
+      RETURN .f.
    CASE QEvent_DragLeave                     // :dragLeave()
       SetAppEvent( xbeP_DragLeave, NIL, NIL, Self )
-      EXIT
+      RETURN .f.
    CASE QEvent_DragMove                      // :dragMotion()
       oObj_O      := oEvent:pos()
       SetAppEvent( xbeP_DragMotion, { oEvent:mouseButtons(), { oObj_O:x(), oObj_O:y() } }, NIL, Self )
-      EXIT
+      RETURN .f.
    CASE QEvent_Drop                          // :dragDrop()
       oObj_O      := oEvent:pos()
       SetAppEvent( xbeP_DragDrop, { oEvent:mouseButtons()  , { oObj_O:x(), oObj_O:y() } }, /* oDragObj */, Self )
-      EXIT
+      RETURN .f.
    CASE QEvent_WhatsThis                     // :helpRequest()
       SetAppEvent( xbeP_HelpRequest, NIL, NIL, Self )
-      EXIT
+      RETURN .f.
    CASE QEvent_KeyPress                      // :keyBoard()
       nXbpkey := hbxbp_QKeyEventToAppEvent( oEvent )
       SetAppEvent( xbeP_Keyboard, nXbpKey, NIL, self )
-      EXIT
+      RETURN .t.
 
-   #if 0
-   CASE QEvent_Close
-      IF hb_isBlock( ::sl_close )
-         lRet := eval( ::sl_close, NIL, NIL, Self )
-         IF lRet
-            SetAppEvent( xbeP_Close, NIL, NIL, Self )
-         ENDIF
-      ELSE
-         SetAppEvent( xbeP_Close, NIL, NIL, Self )
-      ENDIF
-      EXIT
-   CASE QEvent_WindowActivate
-      SetAppEvent( xbeP_SetDisplayFocus, NIL, NIL, Self )
-      lRet := .T.
-      EXIT
-   CASE QEvent_WindowDeactivate
-      SetAppEvent( xbeP_KillDisplayFocus, NIL, NIL, Self )
-      lRet := .T.
-      EXIT
-   #endif
    END SWITCH
 
-   RETURN lRet
+   RETURN .f.
 
 /*----------------------------------------------------------------------*/