cardrgnmouse.cpp

Go to the documentation of this file.

//
//    CardLib - CardRegion mouse-related stuff
//
//    Freeware
//    Copyright J Brown 2001
//
 
#include "cardlib.h"
 
#include <math.h>
 
#if 1
#define TRACE(s)
#else
#define TRACE(s) printf("%s(%i): %s",__FILE__,__LINE__,s)
#endif
 
double __CARDZOOMSPEED = 32;
 
int ClipCard(HDC hdc, int x, int y, int width, int height);
void DrawCard(HDC hdc, int x, int y, HDC hdcSource, int width, int height);
 
#ifdef _DEBUG
 
static pDebugClickProc DebugStackClickProc = 0;
 
void CardLib_SetStackClickProc(pDebugClickProc proc)
{
    DebugStackClickProc = proc;
}
 
#endif
 
CardRegion *CardWindow::GetBestStack(int x, int y, int w, int h)
{
    int maxoverlap    =  0;
    int maxoverlapidx = -1;
 
    //find the stack which is most covered by the dropped
    //cards. Only include those which allow drops.
    //
    for(int i = 0; i < nNumCardRegions; i++)
    {
        int percent = Regions[i]->GetOverlapRatio(x, y, w, h);
 
        //if this stack has the biggest coverage yet
        if(percent > maxoverlap && Regions[i]->IsVisible())
        {
            maxoverlap = percent;
            maxoverlapidx = i;
        }
    }
 
    //if we found a stack to drop onto
    if(maxoverlapidx != -1)
    {
        return Regions[maxoverlapidx];
    }
    else
    {
        return 0;
    }
}
 
bool CardRegion::IsPointInStack(int x, int y)
{
    int axpos = xoffset < 0 ? xpos + (nNumApparentCards-1)*xoffset : xpos;
    int aypos = yoffset < 0 ? ypos + (nNumApparentCards-1)*yoffset : ypos;
 
    if(x >= axpos && x < axpos + width && y >= aypos && y < aypos + height && fVisible)
        return true;
    else
        return false;
}
 
int CardRegion::GetNumDragCards(int x, int y)
{
    int cardindex = 0;        //index from stack start
    int maxidx;
 
    //make x,y relative to the stack's upper left corner
    x -= xpos + (xoffset < 0 ? (nNumApparentCards/*cardstack.NumCards()*/ - 1) * xoffset : 0);
    y -= ypos + (yoffset < 0 ? (nNumApparentCards/*cardstack.NumCards()*/ - 1) * yoffset : 0);
 
    //if stack is empty, cannot drag any cards from it
    if(cardstack.NumCards() <= 0)
        return 0;
 
    //see which card in the stack has been clicked on
    //top-bottom ordering
    if(yoffset > 0)
    {
        if(y < height - __cardheight)
            cardindex = y / yoffset;
        else
            cardindex = cardstack.NumCards() - 1;
    }
    else if(yoffset < 0)
    {
        if(y < __cardheight)
            cardindex = cardstack.NumCards() - 1;
        else
            cardindex = cardstack.NumCards() - ((y - __cardheight) / -yoffset) - 2;
    }
    else    //yoffset == 0
    {
        cardindex = cardstack.NumCards() - 1;
    }
 
    maxidx = cardindex;
 
    //if left-right
    if(xoffset > 0)
    {
        if(x < width - __cardwidth)
            cardindex = x / xoffset;
        else
            cardindex = cardstack.NumCards() - 1;
    }
    else if(xoffset < 0)
    {
        if(x < __cardwidth)
            cardindex = cardstack.NumCards() - 1;
        else
            cardindex = cardstack.NumCards() - ((x - __cardwidth) / -xoffset) - 2;
    }
    else
    {
        cardindex = cardstack.NumCards() - 1;
    }
 
    if(cardindex > maxidx) cardindex = maxidx;
 
    if(cardindex > cardstack.NumCards())
        cardindex = 1;
 
    //if are trying to drag too many cards at once
    return cardstack.NumCards() - cardindex;
}
 
bool CardRegion::CanDragCards(int iNumCards)
{
    if(iNumCards <= 0) return false;
    if(nThreedCount > 1 && iNumCards > 1) return false;
 
    if(WaitForSingleObject(mxlock, 0) != WAIT_OBJECT_0)
    {
//        TRACE("Failed to gain access to card stack\n");
        return false;
    }
 
    ReleaseMutex(mxlock);
 
    switch(uDragRule)
    {
    case CS_DRAG_ALL:
        return true;
 
    case CS_DRAG_TOP:
 
        if(iNumCards == 1)
            return true;
        else
            return false;
 
    case CS_DRAG_NONE:
        return false;
 
    case CS_DRAG_CALLBACK:
 
        if(CanDragCallback)
        {
            return CanDragCallback(*this, iNumCards);
        }
        else
        {
            return false;
        }
 
    default:
        return false;
    }
}
 
bool CardRegion::CanDropCards(CardStack &cards)
{
    if(WaitForSingleObject(mxlock, 0) != WAIT_OBJECT_0)
    {
        return false;
    }
 
    ReleaseMutex(mxlock);
 
    switch(uDropRule)
    {
    case CS_DROP_ALL:
        return true;
 
    case CS_DROP_NONE:
        return false;
 
    case CS_DROP_CALLBACK:
 
        if(CanDropCallback)
        {
            return CanDropCallback(*this, cards);
        }
        else
        {
            return false;
        }
 
    default:
        return false;
    }
}
 
bool CardRegion::OnLButtonDblClk(int x, int y)
{
    iNumDragCards = GetNumDragCards(x, y);
 
    if(DblClickCallback)
        DblClickCallback(*this, iNumDragCards);
 
    return true;
}
 
bool CardRegion::OnLButtonDown(int x, int y)
{
    iNumDragCards = GetNumDragCards(x, y);
 
#ifdef _DEBUG
    if(DebugStackClickProc)
    {
        if(!DebugStackClickProc(*this))
            return false;
    }
#endif
 
    if(ClickCallback)
        ClickCallback(*this, iNumDragCards);
 
    if(CanDragCards(iNumDragCards) != false)
    {
 
        //offset of the mouse cursor relative to the top-left corner
        //of the cards that are being dragged
        mousexoffset = x - xpos - xoffset * (nNumApparentCards - iNumDragCards);
        mouseyoffset = y - ypos - yoffset * (nNumApparentCards - iNumDragCards);
 
        if(xoffset < 0)
            mousexoffset += -xoffset * (iNumDragCards - 1);
 
        if(yoffset < 0)
            mouseyoffset += -yoffset * (iNumDragCards - 1);
 
        //remove the cards from the source stack
        dragstack = cardstack.Pop(iNumDragCards);
 
        //prepare the back buffer, and the drag image
        PrepareDragBitmaps(iNumDragCards);
 
        oldx = x - mousexoffset;
        oldy = y - mouseyoffset;
 
        Update();            //Update this stack's card count + size
 
        SetCapture((HWND)parentWnd);
 
        //set AFTER settings the dragstack...
        fMouseDragging = true;
 
        return true;
    }
 
    return false;
}
 
void CardRegion::ClickRelease(int x, int y)
{
    iNumDragCards = GetNumDragCards(x, y);
 
    if (ClickReleaseCallback)
        ClickReleaseCallback(*this, iNumDragCards);
}
 
bool CardRegion::OnLButtonUp(int x, int y)
{
    CardRegion *pDestStack = 0;
    HDC hdc;
    int dropstackid = CS_DROPZONE_NODROP;
 
    RECT dragrect;
    DropZone *dropzone;
 
    fMouseDragging = false;
 
    //first of all, see if any drop zones have been registered
    SetRect(&dragrect, x-mousexoffset, y-mouseyoffset, x-mousexoffset+nDragCardWidth, y-mouseyoffset+nDragCardHeight);
 
    dropzone = parentWnd.GetDropZoneFromRect(&dragrect);
 
    if(dropzone)
    {
        dropstackid = dropzone->DropCards(dragstack);
 
        if(dropstackid != CS_DROPZONE_NODROP)
            pDestStack = parentWnd.CardRegionFromId(dropstackid);
        else
            pDestStack = 0;
    }
    else
    {
        pDestStack = parentWnd.GetBestStack(x - mousexoffset, y - mouseyoffset, nDragCardWidth, nDragCardHeight);
    }
 
    // If have found a stack to drop onto
    //
    TRACE ( "can I drop card?\n" );
    if(pDestStack && pDestStack->CanDropCards(dragstack))
    {
        TRACE ( "yes, dropping card\n" );
        hdc = GetDC((HWND)parentWnd);
        //            UseNicePalette(hdc);
        ZoomCard(hdc, x - mousexoffset, y  - mouseyoffset, pDestStack);
        ReleaseDC((HWND)parentWnd, hdc);
 
        //
        //add the cards to the destination stack
        //
        CardStack temp = pDestStack->GetCardStack();
        temp.Push(dragstack);
 
        pDestStack->SetCardStack(temp);
//        pDestStack->Update();        //Update this stack's card count + size
//        pDestStack->UpdateFaceDir(temp);
 
        //    Call the remove callback on THIS stack, if one is specified
        //
        if(RemoveCallback)
            RemoveCallback(*this, iNumDragCards);
 
        //    Call the add callback, if one is specified
        //
        if(pDestStack->AddCallback)
            pDestStack->AddCallback(*pDestStack, pDestStack->cardstack);//index, deststack->numcards);
 
        RedrawIfNotDim(pDestStack, true);
        TRACE ( "done dropping card\n" );
    }
 
    //
    //    Otherwise, let the cards snap back onto this stack
    //
    else
    {
        TRACE ( "no, putting card back\n" );
        hdc = GetDC((HWND)parentWnd);
        TRACE ( "calling ZoomCard()\n" );
        ZoomCard(hdc, x - mousexoffset, y - mouseyoffset, this);
        TRACE ( "cardstack += dragstack\n" );
        cardstack += dragstack;
        TRACE ( "calling ReleaseDC()\n" );
        ReleaseDC((HWND)parentWnd, hdc);
 
        TRACE ( "calling Update()\n" );
        Update();        //Update this stack's card count + size
        TRACE ( "done putting card back\n" );
    }
 
    ReleaseDragBitmaps();
    ReleaseCapture();
 
    TRACE ( "OnLButtonUp() done\n" );
    return true;
}
 
bool CardRegion::OnMouseMove(int x, int y)
{
    HDC hdc;
 
    hdc = GetDC((HWND)parentWnd);
 
    x -= mousexoffset;
    y -= mouseyoffset;
 
    MoveDragCardTo(hdc, x, y);
 
    //BitBlt(hdc, nDragCardWidth+10, 0, nDragCardWidth, nDragCardHeight, hdcBackGnd, 0, 0, SRCCOPY);
    //BitBlt(hdc, 0, 0, nDragCardWidth, nDragCardHeight, hdcDragCard, 0, 0, SRCCOPY);
 
    ReleaseDC((HWND)parentWnd, hdc);
 
    oldx = x;
    oldy = y;
 
    return true;
}
 
//
//    There is a bug in BitBlt when the source x,y
//    become < 0. So this wrapper function simply adjusts
//    the coords so that we never try to blt in from this range
//
BOOL ClippedBitBlt(HDC hdcDest, int x, int y, int width, int height, HDC hdcSrc, int srcx, int srcy, DWORD dwROP)
{
    if(srcx < 0)
    {
        x = 0 - srcx;
        width = width + srcx;
        srcx = 0;
    }
 
    if(srcy < 0)
    {
        y = 0 - srcy;
        height = height + srcy;
        srcy = 0;
    }
 
    return BitBlt(hdcDest, x, y, width, height, hdcSrc, srcx, srcy, dwROP);
}
 
void CardRegion::MoveDragCardTo(HDC hdc, int x, int y)
{
    RECT inter, rect1, rect2;
 
    //mask off the new position of the drag-card, so
    //that it will not be painted over
    ClipCard(hdc, x, y, nDragCardWidth, nDragCardHeight);
 
    //restore the area covered by the card at its previous position
    BitBlt(hdc, oldx, oldy, nDragCardWidth, nDragCardHeight, hdcBackGnd, 0, 0, SRCCOPY);
 
    //remove clipping so we can draw the card at its new place
    SelectClipRgn(hdc, NULL);
 
    //if the card's old and new positions overlap, then we
    //need some funky code to update the "saved background" image,
    SetRect(&rect1, oldx, oldy, oldx+nDragCardWidth, oldy+nDragCardHeight);
    SetRect(&rect2,    x,    y,    x+nDragCardWidth,    y+nDragCardHeight);
 
    if(IntersectRect(&inter, &rect1, &rect2))
    {
        int interwidth = inter.right-inter.left;
        int interheight = inter.bottom-inter.top;
        int destx, desty, srcx, srcy;
 
        if(rect2.left > rect1.left)
        {
            destx = 0; srcx = nDragCardWidth - interwidth;
        }
        else
        {
            destx = nDragCardWidth  - interwidth; srcx = 0;
        }
 
        if(rect2.top  > rect1.top)
        {
            desty = 0; srcy = nDragCardHeight - interheight;
        }
        else
        {
            desty = nDragCardHeight - interheight; srcy = 0;
        }
 
        //shift the bit we didn't use for the restore (due to the clipping)
        //into the opposite corner
        BitBlt(hdcBackGnd, destx,desty, interwidth, interheight, hdcBackGnd, srcx, srcy, SRCCOPY);
 
        ExcludeClipRect(hdcBackGnd, destx, desty, destx+interwidth, desty+interheight);
 
        //this bit requires us to clip the BitBlt (from screen to background)
        //as BitBlt is a bit buggy it seems
        ClippedBitBlt(hdcBackGnd, 0,0, nDragCardWidth, nDragCardHeight, hdc, x, y, SRCCOPY);
        SelectClipRgn(hdcBackGnd, NULL);
    }
    else
    {
        BitBlt(hdcBackGnd, 0,0, nDragCardWidth, nDragCardHeight, hdc, x, y, SRCCOPY);
    }
 
    //finally draw the card to the screen
    DrawCard(hdc, x, y, hdcDragCard, nDragCardWidth, nDragCardHeight);
}
 
 
//extern "C" int _fltused(void) { return 0; }
//extern "C" int _ftol(void) { return 0; }
 
//
//    Better do this in fixed-point, to stop
//    VC from linking in floatingpoint-long conversions
//
//#define FIXED_PREC_MOVE
#ifdef  FIXED_PREC_MOVE
#define PRECISION 12
void ZoomCard(HDC hdc, int xpos, int ypos, CARDSTACK *dest)
{
    long dx, dy, x , y;
 
 
    int apparentcards;
    x = xpos << PRECISION; y = ypos << PRECISION;
 
    oldx = (int)xpos;
    oldy = (int)ypos;
 
    apparentcards=dest->numcards/dest->threedcount;
 
    int idestx = dest->xpos + dest->xoffset * (apparentcards);// - iNumDragCards);
    int idesty = dest->ypos + dest->yoffset * (apparentcards);// - iNumDragCards);
 
    //normalise the motion vector
    dx = (idestx<<PRECISION) - x;
    dy = (idesty<<PRECISION) - y;
    long recip = (1 << PRECISION) / 1;//sqrt(dx*dx + dy*dy);
 
    dx *= recip * 16;//CARDZOOMSPEED;
    dy *= recip * 16;//CARDZOOMSPEED;
 
    //if(dx < 0) dxinc = 1.001; else
 
    for(;;)
    {
        int ix, iy;
        x += dx;
        y += dy;
 
        ix = (int)x>>PRECISION;
        iy = (int)y>>PRECISION;
        if(dx < 0 && ix < idestx) ix = idestx;
        else if(dx > 0 && ix > idestx) ix = idestx;
 
        if(dy < 0 && iy < idesty) iy = idesty;
        else if(dy > 0 && iy > idesty) iy = idesty;
 
        MoveDragCardTo(hdc, ix, iy);
 
        if(ix == idestx && iy == idesty)
            break;
 
        oldx = (int)x >> PRECISION;
        oldy = (int)y >> PRECISION;
 
        //dx *= 1.2;
        //dy *= 1.2;
 
        Sleep(10);
    }
}
#else
void CardRegion::ZoomCard(HDC hdc, int xpos, int ypos, CardRegion *pDestStack)
{
    TRACE ( "ENTER ZoomCard()\n" );
    double dx, dy, x ,y;
    int apparentcards;
    x = (double)xpos; y = (double)ypos;
 
    oldx = (int)x;
    oldy = (int)y;
 
    apparentcards = pDestStack->cardstack.NumCards() / pDestStack->nThreedCount;
 
    int idestx = pDestStack->xpos + pDestStack->xoffset * (apparentcards);
    int idesty = pDestStack->ypos + pDestStack->yoffset * (apparentcards);
 
    if(pDestStack->yoffset < 0)
        idesty += pDestStack->yoffset * (iNumDragCards-1);
 
    if(pDestStack->xoffset < 0)
        idestx += pDestStack->xoffset * (iNumDragCards-1);
 
    //normalise the motion vector
    dx = idestx - x;
    dy = idesty - y;
    if ( fabs(dx) + fabs(dy) < 0.001f )
    {
        MoveDragCardTo(hdc, idestx, idesty);
        return;
    }
    double recip = 1.0 / sqrt(dx*dx + dy*dy);
    dx *= recip * __CARDZOOMSPEED; dy *= recip * __CARDZOOMSPEED;
 
    //if(dx < 0) dxinc = 1.001; else
 
    for(;;)
    {
        bool attarget = true;
        int ix, iy;
        x += dx;
        y += dy;
 
        ix = (int)x;
        iy = (int)y;
 
        if(dx < 0.0 && ix < idestx) ix = idestx;
        else if(dx > 0.0 && ix > idestx) ix = idestx;
        else attarget = false;
 
        if(dy < 0.0 && iy < idesty) iy = idesty;
        else if(dy > 0.0 && iy > idesty) iy = idesty;
        else attarget = false;
 
        //if the target stack wants the drag cards drawn differently
        //to how they are, then redraw the drag card image just before
        //the cards land
        /*if(attarget == true)
        {
            for(int i = 0; i < iNumDragCards; i++)
            {
                int xdraw = pDestStack->xoffset*i;
                int ydraw = pDestStack->yoffset*i;
 
                if(pDestStack->yoffset < 0)
                    ydraw = -pDestStack->yoffset * (iNumDragCards-i-1);
                if(pDestStack->xoffset < 0)
                    xdraw = -pDestStack->xoffset * (iNumDragCards-i-1);
 
                if(pDestStack->facedirection == CS_FACEUP &&
                    pDestStack->numcards+i >= dest->numfacedown)
                {
                    //cdtDraw(hdcDragCard, xdraw, ydraw, iDragCards[i], ectFACES, 0);
                }
                else
                {
                    //cdtDraw(hdcDragCard, xdraw, ydraw, CARDSTACK::backcard, ectBACKS, 0);
                }
            }
        }*/
 
        MoveDragCardTo(hdc, ix, iy);
 
        if(attarget || (ix == idestx && iy == idesty))
            break;
 
        oldx = (int)x;
        oldy = (int)y;
 
        //dx *= 1.2;
        //dy *= 1.2;
 
        Sleep(10);
    }
    TRACE ( "EXIT ZoomCard()\n" );
}
#endif