Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

sdk/lib/3rdparty/cardlib/cardregion.cpp

@@ -0,0 +1,659 @@
+//
+//    CardLib - CardRegion class
+//
+//    Freeware
+//    Copyright J Brown 2001
+//
+
+#include "cardlib.h"
+
+HBITMAP CreateSinkBmp(HDC hdcCompat, HDC hdc, int width, int height);
+
+void PaintRect(HDC hdc, RECT *rect, COLORREF colour);
+
+CardRegion::CardRegion(CardWindow &parent, int Id, bool visible, int x, int y, int xOffset, int yOffset)
+: id(Id), parentWnd(parent), xpos(x), ypos(y), xoffset(xOffset), yoffset(yOffset), fVisible(visible)
+{
+    width  = __cardwidth;
+    height = __cardheight;
+
+    crBackgnd  = RGB(0, 64, 100);
+
+    uFaceDirType   = CS_FACE_UP;
+    nFaceDirOption = 0;
+    uEmptyImage  = CS_EI_SUNK;
+
+    fVisible     = visible;
+
+    nThreedCount = 1;
+
+    Update();                //Update this stack's size+card count
+
+    hdcBackGnd = 0;
+    hbmBackGnd = 0;
+    hdcDragCard = 0;
+    hbmDragCard = 0;
+
+    nDragCardWidth = 0;
+    nDragCardHeight = 0;
+
+    CanDragCallback  = 0;
+    CanDropCallback  = 0;
+    AddCallback      = 0;
+    RemoveCallback   = 0;
+    ClickCallback    = 0;
+    ClickReleaseCallback = 0;
+    DblClickCallback = 0;
+
+    uDragRule = CS_DRAG_ALL;
+    uDropRule = CS_DROP_ALL;
+
+    xjustify = yjustify = xadjust = yadjust = 0;
+
+    nFlashCount        = 0;
+    fFlashVisible    = false;
+    uFlashTimer        = (UINT)-1;
+
+    fMouseDragging = false;
+
+    mxlock = CreateMutex(0, FALSE, 0);
+}
+
+CardRegion::~CardRegion()
+{
+    CloseHandle(mxlock);
+}
+
+void CardRegion::SetBackColor(COLORREF cr)
+{
+    crBackgnd = cr;
+}
+
+int CardRegion::CalcApparentCards(int realnum)
+{
+    return ((realnum + nThreedCount - 1) - (realnum + nThreedCount - 1) % nThreedCount) / nThreedCount;
+}
+
+void CardRegion::CalcApparentCards()
+{
+    nNumApparentCards = CalcApparentCards(cardstack.NumCards());
+}
+
+
+void CardRegion::UpdateSize(void)
+{
+    if(cardstack.NumCards() > 0)
+    {
+        if(xoffset > 0)
+            width  = (nNumApparentCards - 1) * xoffset + __cardwidth;
+        else
+            width  = (nNumApparentCards - 1) * -xoffset + __cardwidth;
+
+        if(yoffset > 0)
+            height = (nNumApparentCards - 1) * yoffset + __cardheight;
+        else
+            height = (nNumApparentCards - 1) * -yoffset + __cardheight;
+    }
+    else
+    {
+        width = __cardwidth;
+        height = __cardheight;
+    }
+}
+
+CardRegion *CardWindow::CreateRegion(int id, bool fVisible, int x, int y, int xoffset, int yoffset)
+{
+    CardRegion *cr;
+
+    if(nNumCardRegions == MAXCARDSTACKS)
+        return FALSE;
+
+    cr = new CardRegion(*this, id, fVisible, x, y, xoffset, yoffset);
+    cr->SetBackColor(crBackgnd);
+    cr->SetBackCardIdx(nBackCardIdx);
+
+    Regions[nNumCardRegions++] = cr;
+
+    return cr;
+}
+
+int CardRegion::GetOverlapRatio(int x, int y, int w, int h)
+{
+    RECT me, him;
+    RECT inter;
+    SetRect(&him, x, y, x+w, y+h);
+    SetRect(&me,  xpos, ypos, xpos+width, ypos+height);
+
+    //see if the specified rectangle overlaps us
+    if(IntersectRect(&inter, &me, &him))
+    {
+        int wi = inter.right  - inter.left;
+        int hi = inter.bottom - inter.top;
+
+        int overlap = wi * hi;
+        int total   = width * height;
+
+        int percent = (overlap << 16) / total;
+        return (percent * 100) >> 16;
+    }
+    //do not overlap
+    else
+    {
+        return 0;
+    }
+}
+
+bool CardRegion::SetDragRule(UINT uDragType, pCanDragProc proc)
+{
+    switch(uDragType)
+    {
+    case CS_DRAG_NONE: case CS_DRAG_ALL: case CS_DRAG_TOP:
+        uDragRule = uDragType;
+        return true;
+
+    case CS_DRAG_CALLBACK:
+        uDragRule = uDragType;
+        CanDragCallback = proc;
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+bool CardRegion::SetDropRule(UINT uDropType, pCanDropProc proc)
+{
+    switch(uDropType)
+    {
+    case CS_DROP_NONE: case CS_DROP_ALL:
+        uDropRule = uDropType;
+        return true;
+
+    case CS_DROP_CALLBACK:
+        uDropRule = uDropType;
+        CanDropCallback = proc;
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+void CardRegion::SetClickProc(pClickProc proc)
+{
+    ClickCallback = proc;
+}
+
+void CardRegion::SetClickReleaseProc(pClickProc proc)
+{
+    ClickReleaseCallback = proc;
+}
+
+void CardRegion::SetDblClickProc(pClickProc proc)
+{
+    DblClickCallback = proc;
+}
+
+void CardRegion::SetAddCardProc(pAddProc proc)
+{
+    AddCallback = proc;
+}
+
+void CardRegion::SetRemoveCardProc(pRemoveProc proc)
+{
+    RemoveCallback = proc;
+}
+
+void CardRegion::Update()
+{
+    CalcApparentCards();
+    UpdateSize();
+    UpdateFaceDir(cardstack);
+}
+
+
+bool CardRegion::SetThreedCount(int count)
+{
+    if(count < 1)
+    {
+        return false;
+    }
+    else
+    {
+        nThreedCount = count;
+        return true;
+    }
+}
+
+void CardRegion::SetOffsets(int x, int y)
+{
+    xoffset = x;
+    yoffset = y;
+}
+
+void CardRegion::SetPos(int x, int y)
+{
+    xpos = x;
+    ypos = y;
+}
+
+void CardRegion::Show(bool fShow)
+{
+    fVisible = fShow;
+}
+
+bool CardRegion::IsVisible()
+{
+    return fVisible;
+}
+
+void CardRegion::SetPlacement(UINT xJustify, UINT yJustify, int xAdjust, int yAdjust)
+{
+    xjustify = xJustify;
+    yjustify = yJustify;
+    xadjust  = xAdjust;
+    yadjust  = yAdjust;
+}
+
+void CardRegion::SetFaceDirection(UINT uDirType, int nOption)
+{
+    switch(uDirType)
+    {
+    case CS_FACE_UP:     case CS_FACE_DOWN: case CS_FACE_DOWNUP:
+    case CS_FACE_UPDOWN: case CS_FACE_ANY:
+        uFaceDirType    = uDirType;
+        nFaceDirOption  = nOption;
+
+        UpdateFaceDir(cardstack);
+
+        break;
+    }
+}
+
+UINT CardRegion::GetFaceDirection(int *pnOption)
+{
+    if(pnOption)
+        *pnOption = nFaceDirOption;
+
+    return uFaceDirType;
+}
+
+void CardRegion::AdjustPosition(int winwidth, int winheight)
+{
+    Update();            //Update this stack's card count + size
+
+    switch(xjustify)
+    {
+    default: case CS_XJUST_NONE: break;
+
+    case CS_XJUST_CENTER:        //centered
+        xpos = (winwidth - (width & ~0x1)) / 2;
+        xpos += xadjust;
+
+        if(xoffset < 0)    xpos += (width - __cardwidth);
+
+        break;
+
+    case CS_XJUST_RIGHT:        //right-aligned
+        xpos = winwidth - __cardwidth;//width - 20;
+        xpos += xadjust;
+        break;
+    }
+
+    switch(yjustify)
+    {
+    default: case CS_YJUST_NONE: break;
+
+    case CS_YJUST_CENTER:        //centered
+        ypos = (winheight - height) / 2;
+        ypos += yadjust;
+        if(yoffset < 0)    ypos += (height - __cardheight);
+        break;
+
+    case CS_YJUST_BOTTOM:        //bottom-aligned
+        ypos = winheight - __cardheight;//height - 20;
+        ypos += yadjust;
+        break;
+    }
+
+}
+
+
+void CardRegion::Flash(int count, int milliseconds)
+{
+    if(count <= 0) return;
+
+    nFlashCount        = count;
+    fFlashVisible   = false;
+    uFlashTimer        = SetTimer((HWND)parentWnd, (WPARAM)this, milliseconds, 0);
+
+    parentWnd.Redraw();
+}
+
+void CardRegion::StopFlash()
+{
+    if(uFlashTimer != (UINT)-1)
+    {
+        KillTimer((HWND)parentWnd, uFlashTimer);
+        nFlashCount        = 0;
+        uFlashTimer        = (UINT)-1;
+        fFlashVisible    = true;
+    }
+}
+
+void CardRegion::DoFlash()
+{
+    if(uFlashTimer != (UINT)-1)
+    {
+        fFlashVisible = !fFlashVisible;
+
+        if(--nFlashCount == 0)
+        {
+            KillTimer((HWND)parentWnd, uFlashTimer);
+            uFlashTimer = (UINT)-1;
+            fFlashVisible = true;
+        }
+
+        parentWnd.Redraw();
+    }
+}
+
+int CardRegion::Id()
+{
+    return id;
+}
+
+void CardRegion::SetEmptyImage(UINT uImage)
+{
+    switch(uImage)
+    {
+    case CS_EI_NONE:
+    case CS_EI_SUNK:
+    case CS_EI_CIRC:
+    case CS_EI_X:
+        uEmptyImage = uImage;
+        break;
+
+    default:
+        uEmptyImage = CS_EI_NONE;
+        break;
+    }
+
+}
+
+void CardRegion::SetBackCardIdx(UINT uBackIdx)
+{
+    if(uBackIdx >= 52 && uBackIdx <= 68)
+        nBackCardIdx = uBackIdx;
+}
+
+void CardRegion::SetCardStack(const CardStack &cs)
+{
+    //make a complete copy of the specified stack..
+    cardstack = cs;
+
+    // Update the face-direction and stack-size
+    Update();
+}
+
+const CardStack & CardRegion::GetCardStack()
+{
+    //return reference to our internal stack
+    return cardstack;
+}
+
+//
+//    Update specified card-stack using THIS stack's
+//  face direction rules!
+//
+void CardRegion::UpdateFaceDir(CardStack &cards)
+{
+    int i, n, num;
+
+    num = cards.NumCards();
+
+    //Now apply the face direction rules..
+    switch(uFaceDirType)
+    {
+    case CS_FACE_UP:
+
+        for(i = 0; i < num; i++)
+        {
+            cards[i].SetFaceUp(true);
+        }
+
+        break;
+
+    case CS_FACE_DOWN:
+
+        for(i = 0; i < num; i++)
+        {
+            cards[i].SetFaceUp(false);
+        }
+
+        break;
+
+    case CS_FACE_DOWNUP:
+
+        num = cardstack.NumCards();
+        n = min(nFaceDirOption, num);
+
+        //bottom n cards..
+        for(i = 0; i < n; i++)
+        {
+            cards[num - i - 1].SetFaceUp(false);
+        }
+
+        for(i = n; i < num; i++)
+        {
+            cards[num - i - 1].SetFaceUp(true);
+        }
+
+        break;
+
+    case CS_FACE_UPDOWN:
+
+        num = cardstack.NumCards();
+        n = min(nFaceDirOption, num);
+
+        for(i = 0; i < n; i++)
+        {
+            cards[num - i - 1].SetFaceUp(true);
+        }
+
+        for(i = n; i < num; i++)
+        {
+            cards[num - i - 1].SetFaceUp(false);
+        }
+
+        break;
+
+    case CS_FACE_ANY:    //cards can be any orientation
+    default:
+        break;
+    }
+}
+
+bool CardRegion::MoveCard(CardRegion *pDestStack, int nNumCards, bool fAnimate)
+{
+    HDC hdc;
+
+    int x, y;
+
+    if(pDestStack == 0) return false; //{ forcedfacedir = -1 ;return 0; }
+
+    if(nNumCards < 0 || nNumCards > cardstack.NumCards())
+        return false;
+
+    x = xpos + xoffset * (nNumApparentCards - nNumCards);
+    y = ypos + yoffset * (nNumApparentCards - nNumCards);
+
+    oldx = x;
+    oldy = y;
+
+    dragstack = cardstack.Pop(nNumCards);
+
+    //Alter the drag-stack so that it's cards are the same way up
+    //as the destination. Use the destination's drag-rules
+    //instead of this ones!!
+    CardStack temp;
+    temp.Push(pDestStack->GetCardStack());
+    temp.Push(dragstack);
+
+    pDestStack->UpdateFaceDir(temp);
+
+    dragstack = temp.Pop(nNumCards);
+
+    if(fAnimate)
+    {
+        iNumDragCards = nNumCards;
+        PrepareDragBitmaps(nNumCards);
+    }
+
+    Update();        //Update this stack's size+card count
+
+    if(fAnimate)
+    {
+        hdc = GetDC((HWND)parentWnd);
+
+        ZoomCard(hdc, x, y, pDestStack);
+
+        ReleaseDC((HWND)parentWnd, hdc);
+        ReleaseDragBitmaps();
+    }
+
+    // Get a copy of the cardstack
+    CardStack cs = pDestStack->GetCardStack();
+    cs.Push(dragstack);
+
+    pDestStack->SetCardStack(cs);
+
+    //cs = pDestStack->GetCardStack();
+    //pDestStack->Update();
+    //pDestStack->UpdateFaceDir(cs);
+
+    RedrawIfNotDim(pDestStack, false);
+
+    //forcedfacedir = -1;
+    return true;
+}
+
+//
+//    Simple wrappers
+//
+int CardRegion::NumCards() const
+{
+    if(fMouseDragging)
+        return cardstack.NumCards() + dragstack.NumCards();
+    else
+        return cardstack.NumCards();
+}
+
+bool CardRegion::Lock()
+{
+    DWORD dw = WaitForSingleObject(mxlock, 0);
+
+    if(dw == WAIT_OBJECT_0)
+    {
+        //TRACE("LockStack succeeded\n");
+        return true;
+    }
+    else
+    {
+        //TRACE("LockStack failed\n");
+        return false;
+    }
+    return false;
+}
+
+bool CardRegion::UnLock()
+{
+    if(ReleaseMutex(mxlock))
+    {
+        //TRACE("Unlocking stack\n");
+        return true;
+    }
+    else
+    {
+        //TRACE("Unlocking stack failed\n");
+        return false;
+    }
+}
+
+bool CardRegion::PlayCard(CardRegion *pDestStack, int value, int num)
+{
+    //search the stack for the specified card value...
+    while(num--)
+    {
+        for(int i = 0; i < cardstack.NumCards(); i++)
+        {
+            if(cardstack[i].HiVal() == value)
+            {
+                //swap the card with one at top pos...
+                Card card = cardstack.RemoveCard(i);
+                cardstack.Push(card);
+
+                Redraw();
+
+                MoveCard(pDestStack, 1, true);
+                break;
+            }
+        }
+    }
+
+    return true;
+}
+
+//
+//    Redraw the current stack if it has a different
+//    layout than the comparison stack.
+//
+void CardRegion::RedrawIfNotDim(CardRegion *pCompare, bool fFullRedraw)
+{
+    //
+    //
+    //
+    if( pCompare->xoffset != xoffset ||
+        pCompare->yoffset != yoffset ||
+        pCompare->nThreedCount != nThreedCount ||
+        pCompare->uFaceDirType != uFaceDirType ||
+        pCompare->uFaceDirType != CS_FACE_ANY
+        )
+    {
+        if(fFullRedraw)
+            parentWnd.Redraw();
+        else
+            pCompare->Redraw();
+    }
+
+}
+
+//
+//    SimulateDrag mimicks the complete drag+drop process.
+//  It basically just a MoveCard(..), but it calls the
+//  event callbacks as well.
+//
+bool CardRegion::SimulateDrag(CardRegion *pDestStack, int iNumDragCards, bool fAnimate)
+{
+    if(pDestStack == 0)
+        return false;
+
+    if(CanDragCards(iNumDragCards) != false)
+    {
+        if(pDestStack->CanDropCards(cardstack))
+        {
+            MoveCard(pDestStack, iNumDragCards, fAnimate);
+
+            if(RemoveCallback)
+                RemoveCallback(*this, iNumDragCards);
+
+            if(pDestStack->AddCallback)
+                pDestStack->AddCallback(*pDestStack, pDestStack->cardstack);
+
+            RedrawIfNotDim(pDestStack, true);
+        }
+
+    }
+
+    return true;
+}