#include <cardregion.h>

Collaboration diagram for CardRegion:

[legend]

Public Member Functions
void	SetBackColor (COLORREF cr)

void	SetCardStack (const CardStack &cs)

const CardStack &	GetCardStack ()

bool	SetDragRule (UINT uDragType, pCanDragProc proc=0)

bool	SetDropRule (UINT uDropType, pCanDropProc proc=0)

void	SetClickProc (pClickProc proc)

void	SetClickReleaseProc (pClickProc proc)

void	SetDblClickProc (pClickProc proc)

void	SetAddCardProc (pAddProc proc)

void	SetRemoveCardProc (pRemoveProc proc)

bool	SetThreedCount (int count)

void	SetOffsets (int x, int y)

void	SetPos (int x, int y)

void	Show (bool fShow)

bool	IsVisible ()

void	SetEmptyImage (UINT uImage)

void	SetBackCardIdx (UINT uBackIdx)

void	SetPlacement (UINT xJustify, UINT yJustify, int xAdjust, int yAdjust)

void	Update ()

void	Redraw ()

void	SetFaceDirection (UINT uDirType, int nOption)

UINT	GetFaceDirection (int *pnOption)

void	Flash (int count, int timeout)

void	StopFlash ()

int	Id ()

CardWindow &	GetCardWindow ()

bool	PlayCard (CardRegion *pDestStack, int value, int num)

bool	MoveCard (CardRegion *pDestStack, int nNumCards, bool fAnimate)

bool	SimulateDrag (CardRegion *pDestStack, int nNumCards, bool fAnimate)

bool	Lock ()

bool	UnLock ()

int	NumCards () const

void	NewDeck ()

void	Shuffle ()

void	Clear ()

void	Reverse ()

void	Push (const Card card)

void	Push (const CardStack &cs)

Card	Pop ()

CardStack	Pop (int items)

Card	Top ()

CardStack	Top (int items)

Private Member Functions
	CardRegion (CardWindow &parent, int id, bool fVisible, int x, int y, int xOffset, int yOffset)

	~CardRegion ()

void	DoFlash ()

void	RedrawIfNotDim (CardRegion *compare, bool fFullRedraw)

void	UpdateFaceDir (CardStack &cards)

void	Clip (HDC hdc)

void	Render (HDC hdc)

int	GetOverlapRatio (int x, int y, int width, int height)

void	MoveDragCardTo (HDC hdc, int x, int y)

void	ZoomCard (HDC hdc, int xpos, int ypos, CardRegion *dest)

void	RenderBottomMost (HDC hdc, int minustopmost=0)

void	PrepareDragBitmaps (int numtodrag)

void	PrepareDragBitmapsThreed (int numtodrag)

void	ReleaseDragBitmaps (void)

bool	CanDragCards (int iNumCards)

bool	CanDropCards (CardStack &cards)

void	CalcApparentCards ()

int	CalcApparentCards (int realnum)

void	UpdateSize ()

void	AdjustPosition (int winwidth, int winheight)

bool	IsPointInStack (int x, int y)

int	GetNumDragCards (int x, int y)

bool	OnLButtonDown (int x, int y)

bool	OnLButtonDblClk (int x, int y)

bool	OnMouseMove (int x, int y)

bool	OnLButtonUp (int x, int y)

void	ClickRelease (int x, int y)

Private Attributes
int	id

CardWindow &	parentWnd

CardStack	cardstack

CardStack	dragstack

bool	fMouseDragging

int	xpos

int	ypos

int	xoffset

int	yoffset

int	width

int	height

int	xjustify

int	yjustify

int	xadjust

int	yadjust

int	iNumDragCards

int	mousexoffset

int	mouseyoffset

int	oldx

int	oldy

int	nDragCardWidth

int	nDragCardHeight

HDC	hdcBackGnd

HBITMAP	hbmBackGnd

HDC	hdcDragCard

HBITMAP	hbmDragCard

int	nNumApparentCards

int	nThreedCount

bool	fVisible

int	nFlashCount

bool	fFlashVisible

UINT	uFlashTimer

COLORREF	crBackgnd

UINT	uEmptyImage

UINT	uFaceDirType

int	nFaceDirOption

int	nBackCardIdx

UINT	uDragRule

UINT	uDropRule

pCanDragProc	CanDragCallback

pCanDropProc	CanDropCallback

pClickProc	ClickCallback

pClickProc	ClickReleaseCallback

pClickProc	DblClickCallback

pAddProc	AddCallback

pRemoveProc	RemoveCallback

HANDLE	mxlock

Friends
class	CardWindow

class	CardStack

Detailed Description

Definition at line 11 of file cardregion.h.

Constructor & Destructor Documentation

◆ CardRegion()

CardRegion::CardRegion	(	CardWindow &	parent,
		int	id,
		bool	fVisible,
		int	x,
		int	y,
		int	xOffset,
		int	yOffset
	)

private

Definition at line 14 of file cardregion.cpp.

: 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::~CardRegion ( )

private

Definition at line 62 of file cardregion.cpp.

{
    CloseHandle(mxlock);
}

Member Function Documentation

◆ AdjustPosition()

void CardRegion::AdjustPosition	(	int	winwidth,
		int	winheight
	)

private

Definition at line 281 of file cardregion.cpp.

{
    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;
    }
 
}

Referenced by CardWindow::Update(), and CardWindow::WndProc().

◆ CalcApparentCards() [1/2]

void CardRegion::CalcApparentCards ( )

private

Definition at line 77 of file cardregion.cpp.

{
    nNumApparentCards = CalcApparentCards(cardstack.NumCards());
}

Referenced by CalcApparentCards(), PrepareDragBitmapsThreed(), and Update().

◆ CalcApparentCards() [2/2]

int CardRegion::CalcApparentCards ( int realnum )

private

Definition at line 72 of file cardregion.cpp.

{
    return ((realnum + nThreedCount - 1) - (realnum + nThreedCount - 1) % nThreedCount) / nThreedCount;
}

◆ CanDragCards()

bool CardRegion::CanDragCards ( int iNumCards )

private

Definition at line 141 of file cardrgnmouse.cpp.

{
    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;
    }
}

Referenced by OnLButtonDown(), and SimulateDrag().

◆ CanDropCards()

bool CardRegion::CanDropCards ( CardStack & cards )

private

Definition at line 185 of file cardrgnmouse.cpp.

{
    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;
    }
}

Referenced by OnLButtonUp(), and SimulateDrag().

◆ Clear()

void CardRegion::Clear ( )

inline

Definition at line 84 of file cardregion.h.

84{ cardstack.Clear(); }

CardStack::Clear

void Clear()

Definition: cardstack.cpp:37

Referenced by CardWindow::EmptyStacks(), and Undo().

◆ ClickRelease()

void CardRegion::ClickRelease	(	int	x,
		int	y
	)

private

Definition at line 279 of file cardrgnmouse.cpp.

{
    iNumDragCards = GetNumDragCards(x, y);
 
    if (ClickReleaseCallback)
        ClickReleaseCallback(*this, iNumDragCards);
}

Referenced by CardWindow::WndProc().

◆ Clip()

void CardRegion::Clip ( HDC hdc )

private

Definition at line 208 of file cardrgndraw.cpp.

{
    int numtoclip;
 
    if(fVisible == false)
        return;
 
    Update();                //Update this stack's size+card count
    numtoclip = nNumApparentCards;
 
    //if we are making this stack flash on/off, then only
    //clip the stack for drawing if the flash is in its ON state
    if(nFlashCount != 0)
    {
        if(fFlashVisible == FALSE)
            numtoclip = 0;
    }
 
    //if offset along a diagonal
    if(xoffset != 0 && yoffset != 0 && cardstack.NumCards() != 0)
    {
        for(int j = 0; j < numtoclip; j ++)
        {
            ClipCard(hdc, xpos + xoffset * j, ypos + yoffset * j, __cardwidth, __cardheight);
        }
    }
    //otherwise if just offset along a horizontal/vertical axis
    else
    {
        if(yoffset < 0 && numtoclip > 0)
        {
            ClipCard(hdc, xpos, ypos-((numtoclip-1)*-yoffset), width, height);
        }
        else if(xoffset < 0 && numtoclip > 0)
        {
            ClipCard(hdc, xpos-((numtoclip-1)*-xoffset), ypos, width, height);
        }
        else
        {
            ClipCard(hdc, xpos, ypos, width, height);
        }
    }
 
}

Referenced by CardWindow::Paint().

◆ DoFlash()

void CardRegion::DoFlash ( )

private

Definition at line 344 of file cardregion.cpp.

{
    if(uFlashTimer != (UINT)-1)
    {
        fFlashVisible = !fFlashVisible;
 
        if(--nFlashCount == 0)
        {
            KillTimer((HWND)parentWnd, uFlashTimer);
            uFlashTimer = (UINT)-1;
            fFlashVisible = true;
        }
 
        parentWnd.Redraw();
    }
}

Referenced by CardWindow::WndProc().

◆ Flash()

void CardRegion::Flash	(	int	count,
		int	timeout
	)

Definition at line 322 of file cardregion.cpp.

{
    if(count <= 0) return;
 
    nFlashCount        = count;
    fFlashVisible   = false;
    uFlashTimer        = SetTimer((HWND)parentWnd, (WPARAM)this, milliseconds, 0);
 
    parentWnd.Redraw();
}

Referenced by SuitStackAddProc().

◆ GetCardStack()

const CardStack & CardRegion::GetCardStack ( )

Definition at line 399 of file cardregion.cpp.

{
    //return reference to our internal stack
    return cardstack;
}

Referenced by CanDrop(), DeckClickProc(), MoveCard(), OnLButtonUp(), RowStackDblClickProc(), RowStackDropProc(), StackDragProc(), StackDropProc(), and Undo().

◆ GetCardWindow()

CardWindow & CardRegion::GetCardWindow ( )

inline

Definition at line 69 of file cardregion.h.

69{ return parentWnd; }

◆ GetFaceDirection()

UINT CardRegion::GetFaceDirection ( int * pnOption )

Definition at line 273 of file cardregion.cpp.

{
    if(pnOption)
        *pnOption = nFaceDirOption;
 
    return uFaceDirType;
}

Referenced by DeckClickProc(), RowStackClickProc(), RowStackDragProc(), StackDragProc(), StackDropProc(), and TurnStackCard().

◆ GetNumDragCards()

int CardRegion::GetNumDragCards	(	int	x,
		int	y
	)

private

Definition at line 76 of file cardrgnmouse.cpp.

{
    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;
}

Referenced by ClickRelease(), OnLButtonDblClk(), and OnLButtonDown().

◆ GetOverlapRatio()

int CardRegion::GetOverlapRatio	(	int	x,
		int	y,
		int	width,
		int	height
	)

private

Definition at line 120 of file cardregion.cpp.

{
    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;
    }
}

Referenced by CardWindow::GetBestStack().

◆ Id()

int CardRegion::Id ( )

Definition at line 361 of file cardregion.cpp.

{
    return id;
}

Referenced by PileClickProc(), RowStackClickProc(), RowStackDropProc(), StackDropProc(), SuitStackClickProc(), and SuitStackDropProc().

◆ IsPointInStack()

bool CardRegion::IsPointInStack	(	int	x,
		int	y
	)

private

Definition at line 65 of file cardrgnmouse.cpp.

{
    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;
}

◆ IsVisible()

bool CardRegion::IsVisible ( )

Definition at line 245 of file cardregion.cpp.

{
    return fVisible;
}

◆ Lock()

bool CardRegion::Lock ( )

Definition at line 552 of file cardregion.cpp.

{
    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;
}

◆ MoveCard()

bool CardRegion::MoveCard	(	CardRegion *	pDestStack,
		int	nNumCards,
		bool	fAnimate
	)

Definition at line 477 of file cardregion.cpp.

{
    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;
}

Referenced by PlayCard(), SimulateDrag(), and Undo().

◆ MoveDragCardTo()

void CardRegion::MoveDragCardTo	(	HDC	hdc,
		int	x,
		int	y
	)

private

Definition at line 424 of file cardrgnmouse.cpp.

{
    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);
}

Referenced by OnMouseMove(), and ZoomCard().

◆ NewDeck()

void CardRegion::NewDeck ( )

inline

Definition at line 82 of file cardregion.h.

82{ cardstack.NewDeck(); }

CardStack::NewDeck

void NewDeck()

Definition: cardstack.cpp:42

◆ NumCards()

int CardRegion::NumCards ( ) const

Definition at line 544 of file cardregion.cpp.

{
    if(fMouseDragging)
        return cardstack.NumCards() + dragstack.NumCards();
    else
        return cardstack.NumCards();
}

Referenced by FixIfOneCardLeft(), RowStackClickProc(), RowStackDragProc(), RowStackDropProc(), StackDragProc(), StackDropProc(), and TurnStackCard().

◆ OnLButtonDblClk()

bool CardRegion::OnLButtonDblClk	(	int	x,
		int	y
	)

private

Definition at line 218 of file cardrgnmouse.cpp.

{
    iNumDragCards = GetNumDragCards(x, y);
 
    if(DblClickCallback)
        DblClickCallback(*this, iNumDragCards);
 
    return true;
}

Referenced by CardWindow::WndProc().

◆ OnLButtonDown()

bool CardRegion::OnLButtonDown	(	int	x,
		int	y
	)

private

Definition at line 228 of file cardrgnmouse.cpp.

{
    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;
}

Referenced by CardWindow::WndProc().

◆ OnLButtonUp()

bool CardRegion::OnLButtonUp	(	int	x,
		int	y
	)

private

Definition at line 287 of file cardrgnmouse.cpp.

{
    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;
}

Referenced by CardWindow::WndProc().

◆ OnMouseMove()

bool CardRegion::OnMouseMove	(	int	x,
		int	y
	)

private

Definition at line 378 of file cardrgnmouse.cpp.

{
    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;
}

Referenced by CardWindow::WndProc().

◆ PlayCard()

bool CardRegion::PlayCard	(	CardRegion *	pDestStack,
		int	value,
		int	num
	)

Definition at line 583 of file cardregion.cpp.

{
    //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;
}

◆ Pop() [1/2]

Card CardRegion::Pop ( )

inline

Definition at line 91 of file cardregion.h.

91{ return cardstack.Pop(); }

Referenced by Undo().

◆ Pop() [2/2]

CardStack CardRegion::Pop ( int items )

inline

Definition at line 92 of file cardregion.h.

92{ return cardstack.Pop(items); }

items

static TCHAR * items[]

Definition: page1.c:45

◆ PrepareDragBitmaps()

void CardRegion::PrepareDragBitmaps ( int numtodrag )

private

Definition at line 379 of file cardrgndraw.cpp.

{
    RECT rect;
    HDC hdc;
    int icard;
    int numcards = cardstack.NumCards();
    int xoff, yoff;
 
    if(nThreedCount > 1)
    {
        PrepareDragBitmapsThreed(numtodrag);
        return;
    }
 
    //work out how big the bitmaps need to be
    nDragCardWidth  = (numtodrag - 1) * abs(xoffset) + __cardwidth;
    nDragCardHeight = (numtodrag - 1) * abs(yoffset) + __cardheight;
 
    //Create bitmap for the back-buffer
    hdc = GetDC(NULL);
    hdcBackGnd = CreateCompatibleDC(hdc);
    hbmBackGnd = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
    SelectObject(hdcBackGnd, hbmBackGnd);
 
    //Create bitmap for the drag-image
    hdcDragCard = CreateCompatibleDC(hdc);
    hbmDragCard = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
    SelectObject(hdcDragCard, hbmDragCard);
    ReleaseDC(NULL, hdc);
 
    UseNicePalette(hdcBackGnd,  __hPalette);
    UseNicePalette(hdcDragCard, __hPalette);
 
    int realvisible = numcards / nThreedCount;
 
    //if(numcards > 0 && realvisible == 0) realvisible = 1;
    int iwhichcard = numcards - 1;
    if(nThreedCount == 1) iwhichcard = 0;
 
    //grab the first bit of background so we can prep the back buffer; do this by
    //rendering the card stack (minus the card we are dragging) to the temporary
    //background buffer, so it appears if we have lifted the card from the stack
    //PaintRect(hdcBackGnd, &rect, crBackgnd);
    SetRect(&rect, 0, 0, nDragCardWidth, nDragCardHeight);
 
    xoff = calc_offset(xoffset, numcards, numtodrag, realvisible);
    yoff = calc_offset(yoffset, numcards, numtodrag, realvisible);
 
    parentWnd.PaintCardRgn(hdcBackGnd, 0, 0, nDragCardWidth, nDragCardHeight, xpos - xoff,    ypos - yoff);
 
    //
    //    Render the cardstack into the back-buffer. The stack
    //    has already had the dragcards removed, so just draw
    //    what is left
    //
    for(icard = 0; icard < realvisible; icard++)
    {
        Card card = cardstack.cardlist[iwhichcard];
        int nCardVal;
 
        nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
 
        xoff = xoffset * icard + calc_offset(xoffset, numcards, numtodrag, realvisible);//- xoffset * ((numcards+numtodrag) / nThreedCount - numtodrag);
        yoff = yoffset * icard + calc_offset(yoffset, numcards, numtodrag, realvisible);//- yoffset * ((numcards+numtodrag) / nThreedCount - numtodrag);
 
        CardBlt(hdcBackGnd, xoff, yoff, nCardVal);
        iwhichcard++;
    }
 
    //
    // If there are no cards under this one, just draw the place holder
    //
    if(numcards == 0)
    {
        int xoff = 0, yoff = 0;
 
        if(xoffset < 0)    xoff = nDragCardWidth  -  __cardwidth;
        if(yoffset < 0)    yoff = nDragCardHeight -  __cardheight;
 
        switch(uEmptyImage)
        {
        case CS_EI_NONE:
            //No need to draw anything: We already cleared the
            //back-buffer before the main loop..
 
            //SetRect(&rc, xoff, yoff, xoff+ __cardwidth, yoff + __cardheight);
            //PaintRect(hdcBackGnd, &rc, MAKE_PALETTERGB(crBackgnd));
            //parentWnd.PaintCardRgn(hdcBackGnd, xoff, yoff, __cardwidth, __cardheight, xpos, ypos);// + xoff, ypos + yoff);
            break;
 
        case CS_EI_SUNK:
            DrawCard(hdcBackGnd, xoff, yoff, __hdcPlaceHolder, __cardwidth, __cardheight);
            break;
 
        case CS_EI_CIRC:
        case CS_EI_X:
            CardBlt(hdc, xoff, yoff, uEmptyImage);
            break;
        }
    }
 
    //
    //    now render the drag-cards into the dragcard image
    //
    PaintRect(hdcDragCard, &rect, crBackgnd);
 
    for(icard = 0; icard < numtodrag; icard++)
    {
        int nCardVal;
 
        if(xoffset >= 0) xoff =  xoffset * icard;
        else              xoff = -xoffset * (numtodrag - icard - 1);
 
        if(yoffset >= 0) yoff =  yoffset * icard;
        else             yoff = -yoffset * (numtodrag - icard - 1);
 
        Card card = dragstack.cardlist[icard];
 
        nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
 
        CardBlt(hdcDragCard, xoff, yoff, nCardVal);
    }
}

Referenced by MoveCard(), and OnLButtonDown().

◆ PrepareDragBitmapsThreed()

void CardRegion::PrepareDragBitmapsThreed ( int numtodrag )

private

Definition at line 503 of file cardrgndraw.cpp.

{
    RECT rect;
    HDC hdc;
    int icard;
    int numunder = 0;
    int iwhichcard;
 
    int numcards = cardstack.NumCards();
 
    //work out how big the bitmaps need to be
    nDragCardWidth  = (numtodrag - 1) * abs(xoffset) + __cardwidth;
    nDragCardHeight = (numtodrag - 1) * abs(yoffset) + __cardheight;
 
    //Create bitmap for the back-buffer
    hdc = GetDC(NULL);
    hdcBackGnd = CreateCompatibleDC(hdc);
    hbmBackGnd = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
    SelectObject(hdcBackGnd, hbmBackGnd);
 
    //create bitmap for the drag-image
    hdcDragCard = CreateCompatibleDC(hdc);
    hbmDragCard = CreateCompatibleBitmap(hdc, nDragCardWidth, nDragCardHeight);
    SelectObject(hdcDragCard, hbmDragCard);
    ReleaseDC(NULL, hdc);
 
    UseNicePalette(hdcBackGnd,  __hPalette);
    UseNicePalette(hdcDragCard, __hPalette);
 
    //grab the first bit of background so we can prep the back buffer; do this by
    //rendering the card stack (minus the card we are dragging) to the temporary
    //background buffer, so it appears if we have lifted the card from the stack
    //--SetRect(&rect, 0, 0, nDragCardWidth, nDragCardHeight);
    //--PaintRect(hdcBackGnd, &rect, crBackgnd);
 
    int threedadjust = numcards  % nThreedCount == 0;
 
    numunder = CalcApparentCards(numcards);
    iwhichcard = (numcards+numtodrag) - numunder - 1;
    if(nThreedCount == 1) iwhichcard = 0;
 
    int xoff = calc_offset(xoffset, numunder, numtodrag, numunder);
    int yoff = calc_offset(yoffset, numunder, numtodrag, numunder);
 
    parentWnd.PaintCardRgn(hdcBackGnd, 0,0,    nDragCardWidth,nDragCardHeight,    xpos - xoff,ypos - yoff);
 
    //
    //    Render the cardstack into the back-buffer. The stack
    //    has already had the dragcards removed, so just draw
    //    what is left
    //
    for(icard = 0; icard < numunder; icard++)
    {
        Card card = cardstack.cardlist[iwhichcard];
        int nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
 
        CardBlt(hdcBackGnd,
                xoffset * icard - xoffset*(numunder-numtodrag+threedadjust),
                yoffset * icard - yoffset*(numunder-numtodrag+threedadjust),
                nCardVal);
 
        iwhichcard++;
    }
 
    //
    // If there are no cards under this one, just draw the place holder
    //
    if(numcards == 0)
    {
        switch(uEmptyImage)
        {
        case CS_EI_NONE:
            //no need! we've already cleared the whole
            //back-buffer before the main loop!
            //SetRect(&rect, 0, 0, __cardwidth, __cardheight);
            //PaintRect(hdcBackGnd, &rect, MAKE_PALETTERGB(crBackgnd));
            break;
 
        case CS_EI_SUNK:
            DrawCard(hdcBackGnd, 0, 0, __hdcPlaceHolder, __cardwidth, __cardheight);
            break;
 
        case CS_EI_CIRC:
        case CS_EI_X:
            CardBlt(hdc, 0, 0, uEmptyImage);
            break;
        }
    }
 
    //
    //    now render the drag-cards into the dragcard image
    //
    PaintRect(hdcDragCard, &rect, crBackgnd);
 
    for(icard = 0; icard < numtodrag; icard++)
    {
        Card card = dragstack.cardlist[icard];
        int nCardVal = card.FaceUp() ? card.Idx() : nBackCardIdx;
 
        CardBlt(hdcDragCard, xoffset * icard, yoffset * icard, nCardVal);
    }
}

Referenced by PrepareDragBitmaps().

◆ Push() [1/2]

void CardRegion::Push ( const Card card )

inline

Definition at line 88 of file cardregion.h.

88{ cardstack.Push(card); }

Referenced by Undo().

◆ Push() [2/2]

void CardRegion::Push ( const CardStack & cs )

inline

Definition at line 89 of file cardregion.h.

89{ cardstack.Push(cs); }

◆ Redraw()

void CardRegion::Redraw ( )

Definition at line 618 of file cardrgndraw.cpp.

{
    HDC hdc = GetDC((HWND)parentWnd);
 
    Update();
    Render(hdc);
 
    ReleaseDC((HWND)parentWnd, hdc);
}

Referenced by PlayCard(), RedrawIfNotDim(), RowStackClickProc(), and TurnStackCard().

◆ RedrawIfNotDim()

void CardRegion::RedrawIfNotDim	(	CardRegion *	compare,
		bool	fFullRedraw
	)

private

Definition at line 611 of file cardregion.cpp.

{
    //
    //
    //
    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();
    }
 
}

Referenced by MoveCard(), OnLButtonUp(), and SimulateDrag().

◆ ReleaseDragBitmaps()

void CardRegion::ReleaseDragBitmaps ( void )

private

Definition at line 606 of file cardrgndraw.cpp.

{
    //SelectObject(hdcBackGnd, hOld1);
    DeleteObject(hbmBackGnd);
    DeleteDC(hdcBackGnd);
 
    //SelectObject(hdcDragCard, hOld2);
    DeleteObject(hbmDragCard);
    DeleteDC(hdcDragCard);
}

Referenced by MoveCard(), and OnLButtonUp().

◆ Render()

void CardRegion::Render ( HDC hdc )

private

Definition at line 253 of file cardrgndraw.cpp.

{
    int cardnum = 0;
    int numtodraw;
    BOOL fDrawTips;
 
    Update();            //Update this stack's card count + size
 
    numtodraw = nNumApparentCards;
 
    if(nFlashCount != 0)
    {
        if(fFlashVisible == false)
            numtodraw = 0;
    }
 
    if(fVisible == 0) return;
 
    cardnum = cardstack.NumCards() - numtodraw;
    int counter;
 
    for(counter = 0; counter < numtodraw; counter++)
    {
        int cardval;
 
        int x = xoffset * counter + xpos;
        int y = yoffset * counter + ypos;
 
        //if about to draw last card, then actually draw the top card
        if(counter == numtodraw - 1) cardnum = cardstack.NumCards() - 1;
 
        Card card = cardstack.cardlist[cardnum];
        cardval = card.Idx();
 
        if(card.FaceDown())
            cardval = nBackCardIdx;    //card-back
 
        //only draw the visible part of the card
        if(counter < numtodraw - 1)
        {
            if(yoffset != 0 && xoffset != 0)
                fDrawTips = FALSE;
            else
                fDrawTips = TRUE;
 
            if((yoffset != 0 && abs(xoffset) == 1) || (xoffset != 0 && abs(yoffset) == 1))
                fDrawTips = TRUE;
 
            //draw horizontal strips
            if(yoffset > 0)
            {
                DrawHorzCardStrip(hdc, x, y, cardval, yoffset, fDrawTips);
            }
            else if(yoffset < 0)
            {
                DrawHorzCardStrip(hdc, x, y+__cardheight+yoffset, cardval, yoffset, fDrawTips);
            }
 
            //draw some vertical bars
            if(xoffset > 0)
            {
                DrawVertCardStrip(hdc, x, y, cardval, xoffset, fDrawTips);
            }
            else if(xoffset < 0)
            {
                DrawVertCardStrip(hdc, x+__cardwidth+xoffset, y, cardval, xoffset, fDrawTips);
            }
 
            if(yoffset != 0 && xoffset != 0)//fDrawTips == FALSE)
            {
                //if we didn't draw any tips, then this is a 2-dim stack
                //(i.e, it goes at a diagonal).
                //in this case, we need to fill in the small triangle in
                //each corner!
                DrawCardCorner(hdc, x, y, cardval, xoffset, yoffset);
            }
        }
        //if the top card, draw the whole thing
        else
        {
            CardBlt(hdc, x, y, cardval);
        }
 
        cardnum ++;
 
    } //end of index
 
    if(counter == 0)    //if the cardstack is empty, then draw it that way
    {
        int x = xpos;
        int y = ypos;
 
        switch(uEmptyImage)
        {
        default:
        case CS_EI_NONE:
            //this wipes the RECT variable, so watch out!
            //SetRect(&rect, x, y, x+__cardwidth, y+__cardheight);
            //PaintRect(hdc, &rect, MAKE_PALETTERGB(crBackgnd));
            parentWnd.PaintCardRgn(hdc, x, y, __cardwidth, __cardheight, x, y);
            break;
 
        case CS_EI_SUNK:
            DrawCard(hdc, x, y, __hdcPlaceHolder, __cardwidth, __cardheight);
            break;
 
        case CS_EI_CIRC:
        case CS_EI_X:
            CardBlt(hdc, x, y, uEmptyImage);
            break;
        }
 
    }
 
    return;
}

Referenced by CardWindow::Paint(), and Redraw().

◆ RenderBottomMost()

void CardRegion::RenderBottomMost	(	HDC	hdc,
		int	minustopmost = `0`
	)

private

◆ Reverse()

void CardRegion::Reverse ( )

inline

Definition at line 86 of file cardregion.h.

86{ cardstack.Reverse(); }

CardStack::Reverse

void Reverse()

Definition: cardstack.cpp:73

Referenced by Undo().

◆ SetAddCardProc()

void CardRegion::SetAddCardProc ( pAddProc proc )

Definition at line 197 of file cardregion.cpp.

{
    AddCallback = proc;
}

Referenced by CreateSol(), and CreateSpider().

◆ SetBackCardIdx()

void CardRegion::SetBackCardIdx ( UINT uBackIdx )

Definition at line 384 of file cardregion.cpp.

{
    if(uBackIdx >= 52 && uBackIdx <= 68)
        nBackCardIdx = uBackIdx;
}

Referenced by CardWindow::CreateRegion().

◆ SetBackColor()

void CardRegion::SetBackColor ( COLORREF cr )

Definition at line 67 of file cardregion.cpp.

{
    crBackgnd = cr;
}

Referenced by CardWindow::CreateRegion(), and CardWindow::SetBackColor().

◆ SetCardStack()

void CardRegion::SetCardStack ( const CardStack & cs )

Definition at line 390 of file cardregion.cpp.

{
    //make a complete copy of the specified stack..
    cardstack = cs;
 
    // Update the face-direction and stack-size
    Update();
}

Referenced by DeckClickProc(), FixIfOneCardLeft(), MoveCard(), NewGame(), OnLButtonUp(), StackDropProc(), and Undo().

◆ SetClickProc()

void CardRegion::SetClickProc ( pClickProc proc )

Definition at line 182 of file cardregion.cpp.

{
    ClickCallback = proc;
}

Referenced by CreateSol().

◆ SetClickReleaseProc()

void CardRegion::SetClickReleaseProc ( pClickProc proc )

Definition at line 187 of file cardregion.cpp.

{
    ClickReleaseCallback = proc;
}

Referenced by CreateSpider().

◆ SetDblClickProc()

void CardRegion::SetDblClickProc ( pClickProc proc )

Definition at line 192 of file cardregion.cpp.

{
    DblClickCallback = proc;
}

Referenced by CreateSol().

◆ SetDragRule()

bool CardRegion::SetDragRule	(	UINT	uDragType,
		pCanDragProc	proc = `0`
	)

Definition at line 146 of file cardregion.cpp.

{
    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;
    }
}

Referenced by CreateSol(), and CreateSpider().

◆ SetDropRule()

bool CardRegion::SetDropRule	(	UINT	uDropType,
		pCanDropProc	proc = `0`
	)

Definition at line 164 of file cardregion.cpp.

{
    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;
    }
}

Referenced by CreateSol(), and CreateSpider().

◆ SetEmptyImage()

void CardRegion::SetEmptyImage ( UINT uImage )

Definition at line 366 of file cardregion.cpp.

{
    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;
    }
 
}

Referenced by CreateSol(), and CreateSpider().

◆ SetFaceDirection()

void CardRegion::SetFaceDirection	(	UINT	uDirType,
		int	nOption
	)

Definition at line 258 of file cardregion.cpp.

{
    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;
    }
}

Referenced by CreateSol(), CreateSpider(), NewGame(), RowStackClickProc(), and TurnStackCard().

◆ SetOffsets()

void CardRegion::SetOffsets	(	int	x,
		int	y
	)

Definition at line 228 of file cardregion.cpp.

{
    xoffset = x;
    yoffset = y;
}

Referenced by DeckClickProc(), FixIfOneCardLeft(), NewGame(), and Undo().

◆ SetPlacement()

void CardRegion::SetPlacement	(	UINT	xJustify,
		UINT	yJustify,
		int	xAdjust,
		int	yAdjust
	)

Definition at line 250 of file cardregion.cpp.

{
    xjustify = xJustify;
    yjustify = yJustify;
    xadjust  = xAdjust;
    yadjust  = yAdjust;
}

Referenced by CreateSol(), and CreateSpider().

◆ SetPos()

void CardRegion::SetPos	(	int	x,
		int	y
	)

Definition at line 234 of file cardregion.cpp.

{
    xpos = x;
    ypos = y;
}

◆ SetRemoveCardProc()

void CardRegion::SetRemoveCardProc ( pRemoveProc proc )

Definition at line 202 of file cardregion.cpp.

{
    RemoveCallback = proc;
}

Referenced by CreateSol().

◆ SetThreedCount()

bool CardRegion::SetThreedCount ( int count )

Definition at line 215 of file cardregion.cpp.

{
    if(count < 1)
    {
        return false;
    }
    else
    {
        nThreedCount = count;
        return true;
    }
}

Referenced by CreateSol().

◆ Show()

void CardRegion::Show ( bool fShow )

Definition at line 240 of file cardregion.cpp.

{
    fVisible = fShow;
}

◆ Shuffle()

void CardRegion::Shuffle ( )

inline

Definition at line 83 of file cardregion.h.

83{ cardstack.Shuffle(); }

CardStack::Shuffle

void Shuffle()

Definition: cardstack.cpp:50

◆ SimulateDrag()

bool CardRegion::SimulateDrag	(	CardRegion *	pDestStack,
		int	nNumCards,
		bool	fAnimate
	)

Definition at line 636 of file cardregion.cpp.

{
    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;
}

Referenced by RowStackDblClickProc().

◆ StopFlash()

void CardRegion::StopFlash ( )

Definition at line 333 of file cardregion.cpp.

{
    if(uFlashTimer != (UINT)-1)
    {
        KillTimer((HWND)parentWnd, uFlashTimer);
        nFlashCount        = 0;
        uFlashTimer        = (UINT)-1;
        fFlashVisible    = true;
    }
}

◆ Top() [1/2]

Card CardRegion::Top ( )

inline

Definition at line 94 of file cardregion.h.

94{ return cardstack.Top(); }

CardStack::Top

Card Top()

Definition: cardstack.cpp:151

Referenced by TConsole::DeleteCharacter(), TConsole::InsertCharacter(), and TConsole::InsertLine().

◆ Top() [2/2]

CardStack CardRegion::Top ( int items )

inline

Definition at line 95 of file cardregion.h.

95{ return cardstack.Top(items); }

◆ UnLock()

bool CardRegion::UnLock ( )

Definition at line 569 of file cardregion.cpp.

{
    if(ReleaseMutex(mxlock))
    {
        //TRACE("Unlocking stack\n");
        return true;
    }
    else
    {
        //TRACE("Unlocking stack failed\n");
        return false;
    }
}

◆ Update()

void CardRegion::Update ( )

Definition at line 207 of file cardregion.cpp.

{
    CalcApparentCards();
    UpdateSize();
    UpdateFaceDir(cardstack);
}

Referenced by AdjustPosition(), CardRegion(), Clip(), DeckClickProc(), CardWindow::EmptyStacks(), MoveCard(), NewGame(), OnLButtonDown(), OnLButtonUp(), Redraw(), Render(), and SetCardStack().

◆ UpdateFaceDir()

void CardRegion::UpdateFaceDir ( CardStack & cards )

private

Definition at line 409 of file cardregion.cpp.

{
    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;
    }
}

Referenced by MoveCard(), SetFaceDirection(), and Update().

◆ UpdateSize()

void CardRegion::UpdateSize ( void )

private

Definition at line 83 of file cardregion.cpp.

{
    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;
    }
}

Referenced by CardWindow::DistributeStacks(), and Update().

◆ ZoomCard()

void CardRegion::ZoomCard	(	HDC	hdc,
		int	xpos,
		int	ypos,
		CardRegion *	dest
	)

private

Definition at line 553 of file cardrgnmouse.cpp.

{
    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" );
}