Changeset 1298

Timestamp:

11/01/07 21:19:30 (10 months ago)

Author:

calvin

Message:

faster machine view redrawing when connecting and selecting

Location:

trunk/src/buzelib

Files:

• MachineView.cpp (modified) (31 diffs)
• MachineView.h (modified) (3 diffs)

trunk/src/buzelib/MachineView.cpp

@@ -19 +19 @@
 #include "Utils/Keymaps.h"
 
+#ifdef min
+#undef min
+#endif
+#ifdef max
+#undef max
+#endif
+
 using namespace std;
 using namespace zzub;
@@ -45 +52 @@
         moveType = MachineViewMoveNothing;
         SetRect(&prevDragRect, -1, -1, -1, -1);
+        prevConnectPos.x = prevConnectPos.y = -1;
 
         dirtyOffscreenBitmap = true;
@@ -274 +282 @@
 
 LRESULT CMachineView::OnRButtonDown(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) {
+        if (GetCapture() != 0) return 0;
+
         POINT pt={LOWORD(lParam),HIWORD(lParam)};
         RECT mRect;
@@ -287 +297 @@
 
                 document->selectMachine(propMachine);
-                invalidateMachines();
+
                 showMachineContext(pt, propMachine);
                 return 0;
@@ -302 +312 @@
 
         if (isVolumeSlider) {
-                isVolumeSlider=false;
-                invalidateMachines();
-        }
+                isVolumeSlider = false;
+        }
+
+        if (moveType != MachineViewMoveNothing) {
+                moveType = MachineViewMoveNothing;
+                dirtyBackground = true;
+                Invalidate(FALSE);
+        }
+
 
         RECT rc;
@@ -383 +399 @@
                 offY=pt.y;
 
-                invalidateMachines();
+                //invalidateMachines();
                 
                 // we are certainly clicking inside a machine:
@@ -401 +417 @@
                 if (!draggingMachine->minimized && conn && PtInRect(&pRect, pt)) {
                         initialPan = getConnectionPan(conn);
-                        isPanSlider=true;
-                        moveType=MachineViewMovePanSlider;
+                        isPanSlider = true;
+                        moveType = MachineViewMovePanSlider;
                 } else {
-                        isConnecting=((wParam&MK_SHIFT) != 0) || mbuttonState ;
-                        if (isConnecting)
-                                moveType=MachineViewMoveConnectMachines;
+                        isConnecting = ((wParam&MK_SHIFT) != 0) || mbuttonState ;
+                        if (isConnecting) {
+                                connectPos.x = (signed short)LOWORD(lParam);
+                                connectPos.y = (signed short)HIWORD(lParam);
+                                moveType = MachineViewMoveConnectMachines;
+                        }
                 }
 
@@ -444 +463 @@
                 } else {
                         document->clearSelectedMachines();
-                        invalidateMachines();   // selection is cleared, so lets 
                 }
 
@@ -458 +476 @@
 }
 
-void minMaxRect(RECT* rcOut, RECT* rcIn) {
-        if (rcIn->left < rcOut->left)
-                rcOut->left = rcIn->left;
-        if (rcIn->top < rcOut->top)
-                rcOut->top = rcIn->top;
-        if (rcIn->right > rcOut->right)
-                rcOut->right = rcIn->right;
-        if (rcIn->bottom > rcOut->bottom)
-                rcOut->bottom = rcIn->bottom;
-}
-
 LRESULT CMachineView::OnMouseMove(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) {
 
-        if (moveType==MachineViewMoveConnectMachines) {
+        if (moveType == MachineViewMoveConnectMachines) {
                 if (((wParam&MK_SHIFT) != 0) || mbuttonState ) {
-                        connectPos.x=(signed short)LOWORD(lParam);
-                        connectPos.y=(signed short)HIWORD(lParam);
+                        connectPos.x = (signed short)LOWORD(lParam);
+                        connectPos.y = (signed short)HIWORD(lParam);
                 } else {
-                        draggingMachine=0;
-                        isConnecting=false;
-                        moveType=MachineViewMoveNothing;        // because, if we say there is connecting going on, and draggingMachine=0, there will be crashes
+                        // shift or mbutton was released, stop connection action
+                        // because, if we say there is connecting going on, and draggingMachine=0, there will be crashes
+                        draggingMachine = 0;
+                        isConnecting = false;
+                        moveType = MachineViewMoveNothing;      
+                        prevConnectPos.x = prevConnectPos.y = -1;
                         ReleaseCapture();
-                }
-                // redraw the line
-                invalidateMachines();
+                        dirtyBackground = true;
+                        Invalidate(FALSE);
+                        return 0;
+                }
+
+                // invalidate only the area covered by the line
+
+                dirtyConnecting = true;
+
+                RECT mRect;
+                getMachineRect(draggingMachine, &mRect);
+                POINT mp = { mRect.left + (mRect.right - mRect.left) / 2, mRect.top + (mRect.bottom - mRect.top) / 2 };
+
+                RECT rcCurrent = {
+                        std::min(mp.x, connectPos.x), std::min(mp.y, connectPos.y), 
+                        std::max(mp.x, connectPos.x), std::max(mp.y, connectPos.y), 
+                };
+                RECT rcPrev = {
+                        std::min(mp.x, prevConnectPos.x), std::min(mp.y, prevConnectPos.y), 
+                        std::max(mp.x, prevConnectPos.x), std::max(mp.y, prevConnectPos.y), 
+                };
+                UnionRect(&rcCurrent, &rcCurrent, &rcPrev);
+                InflateRect(&rcCurrent, 1, 1);
+                InvalidateRect(&rcCurrent, FALSE);
         } else
         if (moveType==MachineViewMovePanSlider) {
@@ -530 +561 @@
                         getMachineRect(selplugin, &selrc);
                         InflateRect(&selrc, 3, 3);
-                        minMaxRect(&rcInvalidate, &selrc);
+                        UnionRect(&rcInvalidate, &rcInvalidate, &selrc);
 
                         selplugin->x += mdx;
@@ -537 +568 @@
                         getMachineRect(selplugin, &selrc);
                         InflateRect(&selrc, 3, 3);
-                        minMaxRect(&rcInvalidate, &selrc);
+                        UnionRect(&rcInvalidate, &rcInvalidate, &selrc);
 
                         // make sure the invalidation rect covers all machines we are connected to
@@ -546 +577 @@
                                 getMachineRect(selconnplugin, &selrc);
                                 InflateRect(&selrc, 3, 3);
-                                minMaxRect(&rcInvalidate, &selrc);
+                                UnionRect(&rcInvalidate, &rcInvalidate, &selrc);
                         }
 
@@ -555 +586 @@
                                 getMachineRect(selconnplugin, &selrc);
                                 InflateRect(&selrc, 3, 3);
-                                minMaxRect(&rcInvalidate, &selrc);
+                                UnionRect(&rcInvalidate, &rcInvalidate, &selrc);
                         }
                 }
@@ -672 +703 @@
         isLButtonDown=false;
 
-        if (moveType==MachineViewMoveConnectMachines) {
-                POINT pt={LOWORD(lParam),HIWORD(lParam)};
-                metaplugin* connectMachine=getMachineAtPt(pt);
+        if (moveType == MachineViewMoveConnectMachines) {
+                POINT pt = {LOWORD(lParam),HIWORD(lParam)};
+                metaplugin* connectMachine = getMachineAtPt(pt);
                 if (connectMachine && draggingMachine!=connectMachine) {
                         document->connectMachines(draggingMachine->getName(), connectMachine->getName());
                 }
-                draggingMachine=0;
-                isConnecting=false;
-
-                invalidateMachines();
+                
+                draggingMachine = 0;
+                prevConnectPos.x = prevConnectPos.y = -1;
+                isConnecting = false;
                 ReleaseCapture();
+                dirtyMachines = true;
+                Invalidate(FALSE);
         } else
         if (moveType==MachineViewMovePanSlider) {
@@ -702 +735 @@
         if (moveType==MachineViewMoveSelectRectangle) {
                 ReleaseCapture();
-                invalidateMachines();
                 SetRect(&prevDragRect, -1, -1, -1, -1);
+                dirtyBackground = true;
+                dirtySelectionRectangle = false;
+                Invalidate(FALSE);
         } else 
         if (moveType==MachineViewMoveNothing) {
@@ -724 +759 @@
         screenDC.GetClipBox(&rcClip);
 
+        RECT rcClient;
+        GetClientRect(&rcClient);
         if (dirtyOffscreenBitmap) {
                 if (offscreenBitmap.m_hBitmap)
                         offscreenBitmap.DeleteObject();
 
-                RECT rcClient;
-                GetClientRect(&rcClient);
                 offscreenBitmap.CreateCompatibleBitmap(screenDC, rcClient.right, rcClient.bottom);
 
@@ -737 +772 @@
         }
 
+        if (dirtyBackground) dirtyMachines = true;
+
         CBitmapHandle oldbitmap = offscreenDC.SelectBitmap(offscreenBitmap);
 
         if (dirtyMachines) {
-                offscreenDC.FillSolidRect(rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, backgroundColor);
+                if (dirtyBackground)
+                        offscreenDC.FillSolidRect(rcClient.left, rcClient.top, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, backgroundColor); else
+                        offscreenDC.FillSolidRect(rcClip.left, rcClip.top, rcClip.right - rcClip.left, rcClip.bottom - rcClip.top, backgroundColor);
                 paintMachines(offscreenDC);
                 dirtyStatus = true;
@@ -754 +793 @@
                 paintSelectionRect(offscreenDC);
 
-
-        dirtyMachines = dirtySelectionRectangle = dirtyStatus = dirtyVolumeSlider = false;
+        if (dirtyConnecting)
+                paintConnectionLine(offscreenDC);
+
+        dirtyBackground = dirtyMachines = dirtySelectionRectangle = dirtyStatus = dirtyVolumeSlider = dirtyConnecting = false;
 
     screenDC.BitBlt(
@@ -783 +824 @@
 
         SetRect(rc, minx, miny, maxx, maxy);
-}
-
-void CMachineView::paintSelectionRect(CDC& dc) {
-        RECT rc;
-        getDragRect(&rc);
-
-//      SetRect(&rc, minx, miny, maxx-minx, maxy-miny);
-        SIZE sz = { 2, 2 };
-
-        if (prevDragRect.left==-1) {
-                dc.DrawDragRect(&rc, sz, 0, sz);
-        } else {
-                dc.DrawDragRect(&rc, sz, &prevDragRect, sz);
-        }
-
-        prevDragRect = rc;
 }
 
@@ -1096 +1121 @@
 
 void CMachineView::invalidateMachines() {
-        dirtyMachines = true;
+        dirtyBackground = true;
         Invalidate(FALSE);
 }
@@ -1112 +1137 @@
 void CMachineView::invalidateSelectionRectangle() {
         dirtySelectionRectangle = true;
-        Invalidate(FALSE);
+        RECT rcSel;
+        getDragRect(&rcSel);
+        if (prevDragRect.left != -1) UnionRect(&rcSel, &rcSel, &prevDragRect);
+        InvalidateRect(&rcSel, FALSE);
 }
 
@@ -1203 +1231 @@
         pts[2].y=(hy+uy*-16*scale);
 
+        CPenHandle oldPen = dc.SelectPen(borderPen);
+        CBrushHandle oldBrush = dc.SelectBrush(arrowBrush);
+
         dc.Polygon(pts, 3);
 
@@ -1216 +1247 @@
         dc.TextOut(tp.x-4, tp.y-8, text.c_str());
         dc.SetBkMode(prevBkMode);
+
+        dc.SelectPen(oldPen);
+        dc.SelectBrush(oldBrush);
+
 }
 
@@ -1381 +1416 @@
 
 void CMachineView::paintMachines(CDC& dc) {
-
         CPenHandle oldPen = dc.SelectPen(linePen);
 
@@ -1406 +1440 @@
                         int destHalfWidth=(getMachineWidth(conn->plugin_in)/2) * scale;
                         int destHalfHeight=(getMachineHeight(conn->plugin_in)/2) * scale;
+
 
                         getMachineRect(conn->plugin_in, &sRect);
@@ -1424 +1459 @@
                                 }
                         }*/
-                        dc.SelectPen(borderPen);
-                        dc.SelectBrush(arrowBrush);
                         drawDirectionTriangle(dc, mRect, sRect, conntxt);
-                        dc.SelectPen(linePen);
-                }
-        }
-
-        if (draggingMachine && isConnecting) {
-                int halfWidth=(getMachineWidth(draggingMachine)/2) * scale;
-                int halfHeight=(getMachineHeight(draggingMachine)/2) * scale;
-                RECT mRect;
-                getMachineRect(draggingMachine, &mRect);
-                dc.MoveTo(mRect.left+halfWidth, mRect.top+halfHeight, 0);
-                dc.LineTo(connectPos.x, connectPos.y);
-        }
+                }
+        }
+
         dc.SelectPen(oldPen);
 
@@ -1497 +1521 @@
 
 void CMachineView::paintVolume(CDC& dc) {
-        if (!isVolumeSlider) return ;
+        if (moveType != MachineViewMoveVolumeSlider) return ;
         connection* conn=document->getSelectedConnection();
         int amp = 0x4000;
@@ -1510 +1534 @@
         getVolumeSliderRect(conn, &vsr);
         drawVolumeSlider(dc, vsr, amp);
+}
+
+
+void CMachineView::paintSelectionRect(CDC& dc) {
+        RECT rc;
+        getDragRect(&rc);
+
+        SIZE sz = { 2, 2 };
+
+        if (prevDragRect.left==-1) {
+                dc.DrawDragRect(&rc, sz, 0, sz);
+        } else {
+                dc.DrawDragRect(&rc, sz, &prevDragRect, sz);
+        }
+
+        prevDragRect = rc;
+}
+
+void CMachineView::paintConnectionLine(CDC& dc) {
+
+        if (draggingMachine && moveType == MachineViewMoveConnectMachines) {
+
+                int halfWidth = (getMachineWidth(draggingMachine)/2) * scale;
+                int halfHeight = (getMachineHeight(draggingMachine)/2) * scale;
+
+                RECT mRect;
+                getMachineRect(draggingMachine, &mRect);
+
+                CPenHandle oldPen = dc.SelectPen(linePen);
+                int prevROP = dc.SetROP2(R2_NOT);
+
+                if (prevConnectPos.x != -1) {
+                        dc.MoveTo(mRect.left + halfWidth, mRect.top + halfHeight, 0);
+                        dc.LineTo(prevConnectPos.x, prevConnectPos.y);
+                }
+
+                dc.MoveTo(mRect.left + halfWidth, mRect.top + halfHeight, 0);
+                dc.LineTo(connectPos.x, connectPos.y);
+
+                dc.SetROP2(prevROP);
+                dc.SelectPen(oldPen);
+
+                prevConnectPos = connectPos;
+        }
+
 }
 
@@ -1557 +1626 @@
                 document->selectMachine(machine);
         }
-        invalidateMachines();
         return 0;
 }
@@ -1563 +1631 @@
 LRESULT CMachineView::OnClearSelection(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& bHandled) {
         document->clearSelectedMachines();
-        invalidateMachines();
         return 0;
 }
@@ -1576 +1643 @@
                         document->clearSelectedMachines();
                         document->selectMachine(document->player->master);
-                        invalidateMachines();
                         break;
                 case UpdateMachines:

trunk/src/buzelib/MachineView.h

@@ -31 +31 @@
         zzub::metaplugin* draggingMachine;
         bool isConnecting, isVolumeSlider, isPanSlider;
-        POINT connectPos, beginDragPt;
+        POINT connectPos, prevConnectPos, beginDragPt;
         RECT prevDragRect;
         std::vector<zzub::metaplugin*> machinesInDragRect;
@@ -66 +66 @@
         CBrush ampHandleBrush;
 
-        bool dirtyMachines, dirtyStatus, dirtySelectionRectangle, dirtyVolumeSlider;
+        bool dirtyBackground, dirtyMachines, dirtyStatus, dirtySelectionRectangle, dirtyVolumeSlider, dirtyConnecting;
         bool dirtyOffscreenBitmap;
         CBitmap offscreenBitmap;
@@ -176 +176 @@
         void paintMachineStatus(CDC& dc);
         void paintSelectionRect(CDC& dc);
+        void paintConnectionLine(CDC& dc);
         void showMachineContext(POINT pt, zzub::metaplugin* mac);
         void showConnectionContext(POINT pt, zzub::connection* conn);