1213 lines
31 KiB
C
1213 lines
31 KiB
C
#include "sol.h"
|
|
VSZASSERT
|
|
|
|
|
|
/* Klondike init stuff */
|
|
LRESULT KlondGmProc(GM *pgm, INT msgg, WPARAM wp1, LPARAM wp2);
|
|
LRESULT DeckColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
|
|
LRESULT DiscardColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
|
|
LRESULT TabColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
|
|
LRESULT FoundColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
|
|
|
|
|
|
|
|
// Imported from Win3.1
|
|
BOOL FInitKlondGm()
|
|
{
|
|
COLCLS *pcolcls;
|
|
GM *pgm;
|
|
DX dxCrdOffUp;
|
|
DX dyCrdOffUp;
|
|
DX dyCrdOffDn;
|
|
int icol;
|
|
int icrdMax;
|
|
|
|
/* KLUDGE to get klondike going */
|
|
FreeGm(pgmCur);
|
|
|
|
if((pgm = pgmCur = PAlloc(sizeof(GM)+(13-1)*sizeof(COL *))) == NULL)
|
|
return fFalse;
|
|
|
|
pgm->lpfnGmProc = KlondGmProc;
|
|
SendGmMsg(pgm, msggInit, fTrue, 0);
|
|
pgm->icolMax = 13;
|
|
pgm->dqsecScore = 10*4;
|
|
|
|
if(!FInitUndo(&pgm->udr))
|
|
goto OOM;
|
|
|
|
/* Initialize all the column types but don't position yet */
|
|
for(icol = 0; icol < pgm->icolMax; icol++)
|
|
{
|
|
switch(icol)
|
|
{
|
|
case icolDeck:
|
|
pcolcls = PcolclsCreate(tclsDeck, (COLCLSCREATEFUNC)DeckColProc,
|
|
0, 0, 2, 1, 1, 10);
|
|
icrdMax = icrdDeckMax;
|
|
break;
|
|
|
|
case icolDiscard:
|
|
dxCrdOffUp = dxCrd / 5;
|
|
pcolcls = PcolclsCreate(tclsDiscard, (COLCLSCREATEFUNC)DiscardColProc,
|
|
dxCrdOffUp, 1, 2, 1, 1, 10);
|
|
icrdMax = icrdDiscardMax;
|
|
break;
|
|
|
|
case icolFoundFirst:
|
|
pcolcls = PcolclsCreate(tclsFound, (COLCLSCREATEFUNC)FoundColProc,
|
|
2, 1, 0, 0, 4, 1);
|
|
Assert(icol - 1 == icolDiscard);
|
|
icrdMax = icrdFoundMax;
|
|
break;
|
|
|
|
case icolTabFirst:
|
|
Assert(fHalfCards == 1 || fHalfCards == 0);
|
|
dyCrdOffUp = dyCrd * 4 / 25 - fHalfCards;
|
|
dyCrdOffDn = dyCrd / 25;
|
|
pgm->dyDragMax = dyCrd + 12 * dyCrdOffUp;
|
|
pcolcls = PcolclsCreate(tclsTab, (COLCLSCREATEFUNC)TabColProc,
|
|
0, dyCrdOffUp, 0, dyCrdOffDn, 1, 1);
|
|
icrdMax = icrdTabMax;
|
|
break;
|
|
}
|
|
|
|
if(pcolcls == NULL)
|
|
{
|
|
OOM:
|
|
OOM();
|
|
FreeGm(pgmCur);
|
|
Assert(pgmCur == NULL);
|
|
return fFalse;
|
|
}
|
|
|
|
if((pgm->rgpcol[icol] = PcolCreate(pcolcls, 0, 0, 0, 0, icrdMax))
|
|
== NULL)
|
|
{
|
|
FreeP(pcolcls);
|
|
goto OOM;
|
|
}
|
|
pgm->icolMac++;
|
|
}
|
|
|
|
/* Return without positioning the cards. This will be done at
|
|
* WM_SIZE message time.
|
|
*/
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* PositionCols
|
|
* Positions the card columns. Note that this has been revised to
|
|
* allow card positioning at times other than at the start of the
|
|
* game.
|
|
*/
|
|
|
|
BOOL PositionCols(void)
|
|
{
|
|
DX dxMarg;
|
|
DY dyMarg;
|
|
DX dx;
|
|
X xLeft;
|
|
X xRight;
|
|
Y yTop;
|
|
Y yBot;
|
|
int icol;
|
|
DY dyCrdOffUp;
|
|
DY dyCrdOffDn;
|
|
COL *pcol;
|
|
GM *pgm;
|
|
WORD i;
|
|
|
|
/* The game we're using is always the current one */
|
|
pgm = pgmCur;
|
|
|
|
/* Before doing the column classes, replace all card X coordinates with
|
|
* offsets from the column class.
|
|
*/
|
|
for (icol = 0 ; icol < 13 ; ++icol)
|
|
{
|
|
/* Get a pointer to this COL structure */
|
|
pcol = pgm->rgpcol[icol];
|
|
|
|
/* Loop through all the cards in this column */
|
|
for (i = 0 ; i < pcol->icrdMax ; ++i)
|
|
pcol->rgcrd[i].pt.x -= pcol->rc.xLeft;
|
|
}
|
|
|
|
/* Set the card margins. Note that xCardMargin is computed in SOL.C
|
|
* at the time the original window is created and is changed on
|
|
* WM_SIZE messages.
|
|
*/
|
|
dxMarg = xCardMargin;
|
|
dyMarg = MulDiv(dyCrd, 5, 100);
|
|
|
|
/* Loop through all column types */
|
|
for(icol = 0 ; icol < 13 ; icol++)
|
|
{
|
|
switch(icol)
|
|
{
|
|
case icolDeck:
|
|
xLeft = dxMarg;
|
|
yTop = dyMarg;
|
|
xRight = xLeft + dxCrd + icrdDeckMax / 10 * 2;
|
|
yBot = yTop + dyCrd + icrdDeckMax / 10;
|
|
dx = 0;
|
|
break;
|
|
|
|
case icolDiscard:
|
|
xLeft += dxMarg + dxCrd;
|
|
xRight = xLeft + 7 * dxCrd / 5 + icrdDiscardMax / 10 * 2;
|
|
break;
|
|
|
|
case icolFoundFirst:
|
|
xLeft = 4 * dxMarg + 3 * dxCrd;
|
|
xRight = xLeft + dxCrd + icrdFoundMax / 4 * 2;
|
|
dx = dxMarg + dxCrd;
|
|
break;
|
|
|
|
case icolTabFirst:
|
|
dyCrdOffUp = dyCrd * 4 / 25 - fHalfCards;
|
|
dyCrdOffDn = dyCrd / 25;
|
|
xLeft = dxMarg;
|
|
xRight = xLeft + dxCrd;
|
|
yTop = yBot + 1;
|
|
yBot = yTop + 12 * dyCrdOffUp + dyCrd + 6 * dyCrdOffDn;
|
|
break;
|
|
}
|
|
|
|
/* Set this information into the structure */
|
|
pcol = pgm->rgpcol[icol];
|
|
pcol->rc.xLeft = xLeft;
|
|
pcol->rc.yTop = yTop;
|
|
pcol->rc.xRight = xRight;
|
|
pcol->rc.yBot = yBot;
|
|
|
|
/* Prepare for the next loop */
|
|
xLeft += dx;
|
|
xRight += dx;
|
|
}
|
|
|
|
/* Now that the column offsets are correct, move the cards back */
|
|
for (icol = 0 ; icol < 13 ; ++icol)
|
|
{
|
|
/* Get a pointer to this COL structure */
|
|
pcol = pgm->rgpcol[icol];
|
|
|
|
/* Loop through all the cards in this column */
|
|
for (i = 0 ; i < pcol->icrdMax ; ++i)
|
|
pcol->rgcrd[i].pt.x += pcol->rc.xLeft;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* TABLEAU col Proc stuff */
|
|
|
|
|
|
BOOL FTabValidMove(COL *pcolDest, COL *pcolSrc)
|
|
{
|
|
RA raSrc, raDest;
|
|
SU suSrc, suDest;
|
|
INT icrdSel;
|
|
CD cd;
|
|
|
|
Assert(pcolSrc->pmove != NULL);
|
|
icrdSel = pcolSrc->pmove->icrdSel;
|
|
|
|
Assert(icrdSel < pcolSrc->icrdMac);
|
|
Assert(pcolSrc->icrdMac > 0);
|
|
cd = pcolSrc->rgcrd[icrdSel].cd;
|
|
raSrc = RaFromCd(cd);
|
|
suSrc = SuFromCd(cd);
|
|
if(raSrc == raKing)
|
|
return (pcolDest->icrdMac == 0);
|
|
if(pcolDest->icrdMac == 0)
|
|
return fFalse;
|
|
if(!pcolDest->rgcrd[pcolDest->icrdMac-1].fUp)
|
|
return fFalse;
|
|
cd = pcolDest->rgcrd[pcolDest->icrdMac-1].cd;
|
|
raDest = RaFromCd(cd);
|
|
suDest = SuFromCd(cd);
|
|
/* invalid moves */
|
|
Assert((suClub ^ suSpade) == 0x03);
|
|
Assert((suHeart ^ suDiamond) == 0x03);
|
|
/* valid moves */
|
|
Assert((suClub ^ suDiamond) < 0x03);
|
|
Assert((suClub ^ suHeart) < 0x03);
|
|
Assert((suSpade ^ suDiamond) < 0x03);
|
|
Assert((suSpade ^ suHeart) < 0x03);
|
|
|
|
return (((suSrc ^ suDest) < 0x03) && suSrc != suDest && raSrc+1 == raDest);
|
|
}
|
|
|
|
|
|
INT TabHit(COL *pcol, PT *ppt, INT icrdMin)
|
|
{
|
|
CRD *pcrd;
|
|
|
|
if(pcol->icrdMac > 0 && !(pcrd=&pcol->rgcrd[pcol->icrdMac-1])->fUp && FPtInCrd(pcrd, *ppt))
|
|
{
|
|
SendGmMsg(pgmCur, msggKillUndo, 0, 0);
|
|
SendColMsg(pcol, msgcSel, icrdEnd, 1);
|
|
SendColMsg(pcol, msgcFlip, fTrue, 0);
|
|
SendColMsg(pcol, msgcComputeCrdPos, pcol->icrdMac-1, fFalse);
|
|
SendColMsg(pcol, msgcRender, pcol->icrdMac-1, icrdToEnd);
|
|
SendGmMsg(pgmCur, msggChangeScore, csKlondTabFlip, 0);
|
|
SendColMsg(pcol, msgcEndSel, fFalse, 0);
|
|
/* should I return this? */
|
|
return icrdNil;
|
|
}
|
|
return DefColProc(pcol, msgcHit, (INT_PTR) ppt, icrdMin);
|
|
}
|
|
|
|
|
|
BOOL TabDiscardDblClk(COL *pcol, PT *ppt, INT icol)
|
|
{
|
|
CRD *pcrd;
|
|
INT icolDest;
|
|
COL *pcolDest;
|
|
BOOL fResult;
|
|
|
|
fResult = fFalse;
|
|
if(pcol->icrdMac > 0 && (pcrd=&pcol->rgcrd[pcol->icrdMac-1])->fUp && FPtInCrd(pcrd, *ppt))
|
|
{
|
|
if(pcol->pmove == NULL)
|
|
SendColMsg(pcol, msgcSel, icrdEnd, ccrdToEnd);
|
|
Assert(pcol->pmove != NULL);
|
|
for(icolDest = icolFoundFirst; icolDest < icolFoundFirst+ccolFound; icolDest++)
|
|
{
|
|
pcolDest = pgmCur->rgpcol[icolDest];
|
|
if(SendColMsg(pcolDest, msgcValidMove, (INT_PTR)pcol, 0))
|
|
{
|
|
SendGmMsg(pgmCur, msggSaveUndo, icolDest, icol);
|
|
fResult = SendColMsg(pcolDest, msgcMove, (INT_PTR) pcol, icrdToEnd) &&
|
|
(fOutlineDrag || SendColMsg(pcol, msgcRender, pcol->icrdMac-1, icrdToEnd)) &&
|
|
SendGmMsg(pgmCur, msggScore, (INT_PTR) pcolDest, (INT_PTR) pcol);
|
|
if(SendGmMsg(pgmCur, msggIsWinner, 0, 0))
|
|
SendGmMsg(pgmCur, msggWinner, 0, 0);
|
|
goto Return;
|
|
}
|
|
}
|
|
SendColMsg(pcol, msgcEndSel, fFalse, 0);
|
|
}
|
|
|
|
Return:
|
|
return fResult;
|
|
}
|
|
|
|
|
|
|
|
LRESULT TabColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
|
|
{
|
|
|
|
switch(msgc)
|
|
{
|
|
case msgcHit:
|
|
/* should this go in DefProc? */
|
|
return TabHit(pcol, (PT *)wp1, (INT)wp2);
|
|
|
|
case msgcDblClk:
|
|
return TabDiscardDblClk(pcol, (PT *)wp1, (INT)wp2);
|
|
|
|
case msgcValidMove:
|
|
return FTabValidMove(pcol, (COL *) wp1);
|
|
}
|
|
return DefColProc(pcol, msgc, wp1, wp2);
|
|
}
|
|
|
|
|
|
|
|
BOOL FFoundRender(COL *pcol, INT icrdFirst, INT icrdLast)
|
|
{
|
|
#define dxFoundDn 2
|
|
#define dyFoundDn 1
|
|
|
|
if(pcol->icrdMac == 0 || icrdLast == 0)
|
|
{
|
|
if(!FGetHdc())
|
|
return fFalse;
|
|
DrawCardExt((PT *)(&pcol->rc.xLeft), 0, GHOST);
|
|
DrawBackExcl(pcol, (PT *) &pcol->rc);
|
|
ReleaseHdc();
|
|
return fTrue;
|
|
}
|
|
else
|
|
return DefColProc(pcol, msgcRender, icrdFirst, icrdLast);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOL FFoundValidMove(COL *pcolDest, COL *pcolSrc)
|
|
{
|
|
RA raSrc;
|
|
SU suSrc;
|
|
INT icrdSel;
|
|
|
|
Assert(pcolSrc->pmove != NULL);
|
|
icrdSel = pcolSrc->pmove->icrdSel;
|
|
Assert(icrdSel < pcolSrc->icrdMac);
|
|
Assert(pcolSrc->icrdMac > 0);
|
|
if(pcolSrc->pmove->ccrdSel != 1)
|
|
return fFalse;
|
|
raSrc = RaFromCd(pcolSrc->rgcrd[icrdSel].cd);
|
|
suSrc = SuFromCd(pcolSrc->rgcrd[icrdSel].cd);
|
|
if(pcolDest->icrdMac == 0)
|
|
return(raSrc == raAce);
|
|
return (raSrc == RaFromCd(pcolDest->rgcrd[pcolDest->icrdMac-1].cd)+1 &&
|
|
suSrc == SuFromCd(pcolDest->rgcrd[pcolDest->icrdMac-1].cd));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Foundation stuff */
|
|
LRESULT FoundColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
|
|
{
|
|
switch(msgc)
|
|
{
|
|
case msgcValidMove:
|
|
return FFoundValidMove(pcol, (COL *) wp1);
|
|
|
|
case msgcRender:
|
|
return FFoundRender(pcol, (INT)wp1, (INT)wp2);
|
|
}
|
|
return DefColProc(pcol, msgc, wp1, wp2);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* DeckStuff */
|
|
|
|
|
|
BOOL DeckInit(COL *pcol)
|
|
{
|
|
CRD *pcrd;
|
|
INT icrd;
|
|
|
|
Assert(pcol->icrdMax == icrdDeckMax);
|
|
for(icrd = 0; icrd < icrdDeckMax; icrd++)
|
|
{
|
|
pcrd = &pcol->rgcrd[icrd];
|
|
pcrd->cd = (unsigned short)icrd;
|
|
pcrd->pt = *(PT *)&pcol->rc;
|
|
pcrd->fUp = fFalse;
|
|
}
|
|
pcol->icrdMac = icrdDeckMax;
|
|
SendColMsg(pcol, msgcShuffle, 0, 0);
|
|
SendColMsg(pcol, msgcComputeCrdPos, 0, fFalse);
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
INT DeckHit(COL *pcol, PT *ppt, INT icrdMin)
|
|
{
|
|
RC rc;
|
|
INT ccrd;
|
|
|
|
if(pcol->icrdMac == 0)
|
|
{
|
|
CrdRcFromPt((PT *) &pcol->rc, &rc);
|
|
if(PtInRect((LPRECT) &rc, *(POINT *)ppt))
|
|
return icrdEmpty;
|
|
else
|
|
return icrdNil;
|
|
}
|
|
else
|
|
if(!FPtInCrd(&pcol->rgcrd[pcol->icrdMac-1], *ppt))
|
|
return icrdNil;
|
|
|
|
ccrd = ((GetKeyState(VK_SHIFT) & GetKeyState(VK_CONTROL) & GetKeyState(VK_MENU)) < 0) ? 1 : pgmCur->ccrdDeal;
|
|
|
|
move.icrdSel = WMax(pcol->icrdMac-ccrd, 0);
|
|
move.ccrdSel = pcol->icrdMac - move.icrdSel;
|
|
Assert(pcol->pmove == NULL);
|
|
pcol->pmove = &move;
|
|
return move.icrdSel;
|
|
}
|
|
|
|
|
|
BOOL FDeckRender(COL *pcol, INT icrdFirst, INT icrdLast)
|
|
{
|
|
INT mode;
|
|
BOOL f;
|
|
PT pt;
|
|
|
|
/* to avoid redrawing the deck multiple times during dealing */
|
|
if(!pgmCur->fDealt && pcol->icrdMac%10 != 9)
|
|
return fTrue;
|
|
if(!FGetHdc())
|
|
return fFalse;
|
|
if(pcol->icrdMac == 0)
|
|
{
|
|
mode = (smd == smdVegas && pgmCur->irep == ccrdDeal-1) ? DECKX : DECKO;
|
|
DrawCardExt((PT *) &pcol->rc, 0, mode);
|
|
DrawBackExcl(pcol, (PT *) &pcol->rc);
|
|
f = fTrue;
|
|
}
|
|
else
|
|
{
|
|
f = DefColProc(pcol, msgcRender, icrdFirst, icrdLast);
|
|
if((icrdLast == pcol->icrdMac || icrdLast == icrdToEnd) && !fHalfCards)
|
|
{
|
|
pt.x = pcol->rgcrd[pcol->icrdMac-1].pt.x+dxCrd-1;
|
|
pt.y = pcol->rgcrd[pcol->icrdMac-1].pt.y+dyCrd-1;
|
|
SetPixel(hdcCur, pt.x-xOrgCur, pt.y-yOrgCur, rgbTable);
|
|
SetPixel(hdcCur, pt.x-1-xOrgCur, pt.y-yOrgCur, rgbTable);
|
|
SetPixel(hdcCur, pt.x-xOrgCur, pt.y-1-yOrgCur, rgbTable);
|
|
}
|
|
}
|
|
ReleaseHdc();
|
|
return f;
|
|
}
|
|
|
|
|
|
VOID DrawAnimate(INT cd, PT *ppt, INT iani)
|
|
{
|
|
|
|
if(!FGetHdc())
|
|
return;
|
|
cdtAnimate(hdcCur, cd, ppt->x, ppt->y, iani);
|
|
ReleaseHdc();
|
|
}
|
|
|
|
|
|
BOOL DeckAnimate(COL *pcol, INT iqsec)
|
|
{
|
|
INT iani;
|
|
PT pt;
|
|
|
|
// we removed the older card decks that required Animation. The new
|
|
// card deck doesn't involve any animation.
|
|
|
|
#ifdef UNUSEDCODE
|
|
|
|
if(pcol->icrdMac > 0 && !fHalfCards)
|
|
{
|
|
pt = pcol->rgcrd[pcol->icrdMac-1].pt;
|
|
switch(modeFaceDown)
|
|
{
|
|
case IDFACEDOWN3:
|
|
DrawAnimate(IDFACEDOWN3, &pt, iqsec % 4);
|
|
break;
|
|
case IDFACEDOWN10: /* krazy kastle */
|
|
DrawAnimate(IDFACEDOWN10, &pt, iqsec % 2);
|
|
break;
|
|
|
|
case IDFACEDOWN11: /* sanflipe */
|
|
if((iani = (iqsec+4) % (50*4)) < 4)
|
|
DrawAnimate(IDFACEDOWN11, &pt, iani);
|
|
else
|
|
/* if a menu overlapps an ani while it is ani'ing, leaves deck
|
|
bitmap in inconsistent state... */
|
|
if(iani % 6 == 0)
|
|
DrawAnimate(IDFACEDOWN11, &pt, 3);
|
|
break;
|
|
case IDFACEDOWN12: /* SLIME */
|
|
if((iani = (iqsec+4) % (15*4)) < 4)
|
|
DrawAnimate(IDFACEDOWN12, &pt, iani);
|
|
else
|
|
/* if a menu overlapps an ani while it is ani'ing, leaves deck
|
|
bitmap in inconsistent state... */
|
|
if(iani % 6 == 0)
|
|
DrawAnimate(IDFACEDOWN12, &pt, 3);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LRESULT DeckColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
|
|
{
|
|
|
|
switch(msgc)
|
|
{
|
|
case msgcInit:
|
|
return DeckInit(pcol);
|
|
case msgcValidMove:
|
|
case msgcDrawOutline:
|
|
return fFalse;
|
|
case msgcValidMovePt:
|
|
return icrdNil;
|
|
case msgcHit:
|
|
return DeckHit(pcol, (PT *) wp1, (INT)wp2);
|
|
case msgcRender:
|
|
return FDeckRender(pcol, (INT) wp1, (INT) wp2);
|
|
case msgcValidKbdColSel:
|
|
return !wp1;
|
|
case msgcValidKbdCrdSel:
|
|
return pcol->icrdMac == 0 || wp1 == (WPARAM) pcol->icrdMac-1;
|
|
case msgcAnimate:
|
|
return DeckAnimate(pcol, (INT)wp1);
|
|
}
|
|
return DefColProc(pcol, msgc, wp1, wp2);
|
|
}
|
|
|
|
|
|
BOOL DiscardRemove(COL *pcol, COL *pcolDest, LPARAM wp2)
|
|
{
|
|
return DefColProc(pcol, msgcRemove, (INT_PTR) pcolDest, wp2);
|
|
}
|
|
|
|
|
|
BOOL DiscardMove(COL *pcolDest, COL *pcolSrc, INT icrd)
|
|
{
|
|
BOOL fResult;
|
|
|
|
SendColMsg(pcolDest, msgcComputeCrdPos, WMax(0, pcolDest->icrdMac-3), fTrue);
|
|
|
|
/* YUCK: Default ComputeCrdPos doesn't quite work for discard because
|
|
up cards are handled specially for Discard piles. To keep
|
|
code size down we have this global hack variable which DefComputeCrdPos
|
|
uses.
|
|
*/
|
|
fMegaDiscardHack = fTrue;
|
|
fResult = DefColProc(pcolDest, msgcMove, (INT_PTR) pcolSrc, icrd);
|
|
fMegaDiscardHack = fFalse;
|
|
return fResult;
|
|
}
|
|
|
|
|
|
|
|
INT DiscardHit(COL *pcol, PT *ppt, INT icrdMin)
|
|
{
|
|
return DefColProc(pcol, msgcHit, (INT_PTR) ppt, WMax(0, pcol->icrdMac-1));
|
|
}
|
|
|
|
|
|
BOOL DiscardRender(COL *pcol, INT icrdFirst, INT icrdLast)
|
|
{
|
|
PT pt;
|
|
INT icrd;
|
|
COLCLS *pcolcls;
|
|
|
|
if(DefColProc(pcol, msgcRender, icrdFirst, icrdLast))
|
|
{
|
|
if(FGetHdc())
|
|
{
|
|
pcolcls = pcol->pcolcls;
|
|
for(icrd = pcol->icrdMac-1; icrd >= 0 && icrd >= pcol->icrdMac-2; icrd--)
|
|
{
|
|
pt = pcol->rgcrd[icrd].pt;
|
|
/* 3 is a kludge value here */
|
|
DrawBackground(pt.x+dxCrd-pcolcls->dxUp, pt.y-pcolcls->dyUp*3,
|
|
pt.x+dxCrd, pt.y);
|
|
}
|
|
ReleaseHdc();
|
|
}
|
|
return fTrue;
|
|
}
|
|
return fFalse;
|
|
}
|
|
|
|
|
|
|
|
/* Discard Stuff */
|
|
LRESULT DiscardColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
|
|
{
|
|
switch(msgc)
|
|
{
|
|
case msgcDblClk:
|
|
return TabDiscardDblClk(pcol, (PT *)wp1, (INT)wp2);
|
|
case msgcHit:
|
|
return DiscardHit(pcol, (PT *)wp1, (INT)wp2);
|
|
case msgcMove:
|
|
return DiscardMove(pcol, (COL *) wp1, (INT)wp2);
|
|
case msgcRemove:
|
|
return DiscardRemove(pcol, (COL *) wp1, wp2);
|
|
case msgcValidMovePt:
|
|
return icrdNil;
|
|
case msgcValidKbdColSel:
|
|
return !wp1;
|
|
case msgcRender:
|
|
return DiscardRender(pcol, (INT)wp1, (INT)wp2);
|
|
case msgcValidKbdCrdSel:
|
|
return pcol->icrdMac == 0 || wp1 == (WPARAM) pcol->icrdMac-1;
|
|
}
|
|
|
|
return DefColProc(pcol, msgc, wp1, wp2);
|
|
}
|
|
|
|
|
|
|
|
|
|
/* GAME stuff */
|
|
|
|
BOOL KlondDeal(GM *pgm, BOOL fZeroScore)
|
|
{
|
|
INT icrdSel;
|
|
INT icol;
|
|
INT irw;
|
|
COL *pcolDeck;
|
|
VOID StatString();
|
|
|
|
if(!FGetHdc())
|
|
{
|
|
OOM();
|
|
return fFalse;
|
|
}
|
|
|
|
EraseScreen();
|
|
for(icol = 0; icol < pgm->icolMac; icol++)
|
|
SendColMsg(pgm->rgpcol[icol], msgcClearCol, 0, 0);
|
|
|
|
pcolDeck = pgm->rgpcol[icolDeck];
|
|
SendColMsg(pcolDeck, msgcInit, 0, 0);
|
|
|
|
SendGmMsg(pgm, msggKillUndo, 0, 0);
|
|
SendGmMsg(pgm, msggInit, !(smd == smdVegas && fKeepScore) || fZeroScore, 0);
|
|
|
|
StatString(idsNil);
|
|
pgm->fDealt = fTrue;
|
|
SendGmMsg(pgm, msggChangeScore, csKlondDeal, 0);
|
|
SendColMsg(pcolDeck, msgcRender, 0, icrdToEnd);
|
|
pgm->fDealt = fFalse;
|
|
for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
|
|
SendColMsg(pgm->rgpcol[icol], msgcRender, 0, icrdToEnd);
|
|
|
|
// BabakJ: What the %@!&$* is this?! irw is always less than irw + ccolTab!!!
|
|
// Note: ccolTab if #ifdef'ed as 7
|
|
// for(irw = 0; irw < irw+ccolTab; irw++)
|
|
|
|
for(irw = 0; irw < ccolTab; irw++)
|
|
for(icol = irw; icol < ccolTab; icol++)
|
|
{
|
|
icrdSel = SendColMsg(pcolDeck, msgcSel, icrdEnd, 0);
|
|
if(icol == irw)
|
|
SendColMsg(pcolDeck, msgcFlip, fTrue, 0);
|
|
SendColMsg(pgm->rgpcol[icol+icolTabFirst], msgcMove, (INT_PTR) pcolDeck, icrdToEnd);
|
|
SendColMsg(pcolDeck, msgcRender, icrdSel-1, icrdToEnd);
|
|
}
|
|
NewKbdColAbs(pgm, 0);
|
|
pgm->fDealt = fTrue;
|
|
ReleaseHdc();
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL KlondMouseDown(GM *pgm, PT *ppt)
|
|
{
|
|
INT icrdSel;
|
|
INT icrd;
|
|
COL *pcolDeck, *pcolDiscard;
|
|
|
|
/* Kbd sel already in effect */
|
|
if(FSelOfGm(pgm) || !pgm->fDealt)
|
|
return fFalse;
|
|
/* place the next cards on discard pile */
|
|
if((icrd = SendColMsg(pgm->rgpcol[icolDeck], msgcHit, (INT_PTR) ppt, 0)) != icrdNil)
|
|
{
|
|
pgm->fInput = fTrue;
|
|
pcolDeck = pgm->rgpcol[icolDeck];
|
|
pcolDiscard = pgm->rgpcol[icolDiscard];
|
|
if(icrd == icrdEmpty)
|
|
{
|
|
/* repeat */
|
|
if(SendColMsg(pcolDiscard, msgcNumCards, 0, 0) == 0)
|
|
{
|
|
/* both deck and discard are empty */
|
|
Assert(pcolDeck->pmove == NULL);
|
|
return fFalse;
|
|
}
|
|
if(smd == smdVegas && pgm->irep == ccrdDeal-1)
|
|
return fFalse;
|
|
|
|
pgm->irep++;
|
|
pgm->udr.fEndDeck = TRUE;
|
|
|
|
return SendGmMsg(pgm, msggSaveUndo, icolDiscard, icolDeck) &&
|
|
SendColMsg(pcolDiscard, msgcSel, 0, ccrdToEnd) != icrdNil &&
|
|
SendColMsg(pcolDiscard, msgcFlip, fFalse, 0) &&
|
|
SendColMsg(pcolDiscard, msgcInvert, 0, 0) &&
|
|
SendGmMsg(pgm, msggScore, (INT_PTR) pcolDeck, (INT_PTR) pcolDiscard) &&
|
|
SendColMsg(pcolDeck, msgcMove, (INT_PTR) pcolDiscard, icrdToEnd) &&
|
|
SendColMsg(pcolDiscard, msgcRender, 0, icrdToEnd);
|
|
}
|
|
else
|
|
{
|
|
icrdSel = pcolDeck->pmove->icrdSel-1;
|
|
/* deal next cards to discard */
|
|
return SendGmMsg(pgm, msggSaveUndo, icolDiscard, icolDeck) &&
|
|
SendColMsg(pcolDeck, msgcFlip, fTrue, 0) &&
|
|
SendColMsg(pcolDeck, msgcInvert, 0, 0) &&
|
|
SendColMsg(pcolDiscard, msgcMove, (INT_PTR)pcolDeck, icrdToEnd) &&
|
|
SendColMsg(pcolDeck, msgcRender, icrdSel, icrdToEnd);
|
|
}
|
|
}
|
|
return DefGmProc(pgm, msggMouseDown, (INT_PTR) ppt, icolDiscard);
|
|
}
|
|
|
|
|
|
BOOL KlondIsWinner(GM *pgm)
|
|
{
|
|
INT icol;
|
|
|
|
for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
|
|
if(pgm->rgpcol[icol]->icrdMac != icrdFoundMax)
|
|
return fFalse;
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
BOOL FAbort()
|
|
{
|
|
MSG msg;
|
|
|
|
if (MsgWaitForMultipleObjects(0, NULL, FALSE, 5, QS_ALLINPUT) != WAIT_OBJECT_0)
|
|
return FALSE;
|
|
|
|
if(PeekMessage(&msg, hwndApp, 0, 0, PM_NOREMOVE))
|
|
{
|
|
switch(msg.message)
|
|
{
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_KEYDOWN:
|
|
case WM_SYSKEYDOWN:
|
|
case WM_MENUSELECT:
|
|
case WM_NCLBUTTONDOWN:
|
|
case WM_NCMBUTTONDOWN:
|
|
case WM_NCRBUTTONDOWN:
|
|
return fTrue;
|
|
}
|
|
|
|
PeekMessage(&msg, hwndApp, 0, 0, PM_REMOVE);
|
|
TranslateMessage((LPMSG)&msg);
|
|
DispatchMessage((LPMSG)&msg);
|
|
}
|
|
return fFalse;
|
|
}
|
|
|
|
|
|
|
|
// Hack for making winning animation faster:
|
|
// At cascading time we have: KlondWinner -> DrawCardPt ->cdtDrawExt
|
|
// so we set a flag so cdtDrawExt knows it is cascading and does not need
|
|
// to round up corners.
|
|
BOOL fKlondWinner = FALSE;
|
|
|
|
BOOL KlondWinner(GM *pgm)
|
|
{
|
|
INT icol;
|
|
INT icrd;
|
|
CRD *pcrd;
|
|
PT pt;
|
|
PT ptV;
|
|
INT dxp;
|
|
INT dyp;
|
|
RC rcT;
|
|
INT dsco;
|
|
TCHAR *pch;
|
|
TCHAR szBonus[84];
|
|
VOID StatString();
|
|
UINT cchUsed, cchTmp;
|
|
|
|
fKlondWinner = TRUE;
|
|
|
|
dsco = (INT)SendGmMsg(pgmCur, msggChangeScore, csKlondWin, 0);
|
|
pgm->udr.fAvail = fFalse;
|
|
pgm->fDealt = fFalse;
|
|
pgm->fWon = fTrue;
|
|
|
|
if(smd == smdStandard)
|
|
{
|
|
cchUsed = CchString(szBonus, idsBonus, ARRAYSIZE(szBonus));
|
|
pch = &szBonus[cchUsed];
|
|
|
|
cchTmp = CchDecodeInt(pch, dsco);
|
|
pch += cchTmp;
|
|
cchUsed += cchTmp;
|
|
|
|
*pch++ = TEXT(' ');
|
|
cchUsed++;
|
|
|
|
*pch++ = TEXT(' ');
|
|
cchUsed++;
|
|
}
|
|
else
|
|
{
|
|
pch = szBonus;
|
|
cchUsed = 0;
|
|
}
|
|
if (cchUsed < ARRAYSIZE(szBonus))
|
|
{
|
|
CchString(pch, idsEndWinner, ARRAYSIZE(szBonus) - cchUsed);
|
|
}
|
|
|
|
StatStringSz(szBonus);
|
|
if(!FGetHdc())
|
|
goto ByeNoRel;
|
|
Assert(xOrgCur == 0);
|
|
Assert(yOrgCur == 0);
|
|
GetClientRect(hwndApp, (RECT *)&rcT);
|
|
dxp = rcT.xRight;
|
|
dyp = rcT.yBot - dyCrd;
|
|
|
|
for(icrd = icrdFoundMax-1; icrd >= 0; icrd--)
|
|
{
|
|
for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
|
|
{
|
|
ptV.x = rand() % 110 - 65; /* favor up and to left */
|
|
if(abs(ptV.x) < 15) /* kludge so doesn't bounce forever */
|
|
ptV.x = -20;
|
|
ptV.y = rand() % 110 - 75;
|
|
pt = (pcrd = &pgm->rgpcol[icol]->rgcrd[icrd])->pt;
|
|
|
|
while(pt.x > -dxCrd && pt.x < dxp)
|
|
{
|
|
DrawCardPt(pcrd, &pt);
|
|
pt.x += ptV.x/10;
|
|
pt.y += ptV.y/10;
|
|
ptV.y+= 3;
|
|
if(pt.y > dyp && ptV.y > 0)
|
|
ptV.y = -(ptV.y*8)/10;
|
|
if(FAbort())
|
|
goto ByeBye;
|
|
}
|
|
|
|
}
|
|
}
|
|
ByeBye:
|
|
ReleaseHdc();
|
|
ByeNoRel:
|
|
StatString(idsNil);
|
|
EraseScreen();
|
|
|
|
fKlondWinner = FALSE;
|
|
|
|
return DefGmProc(pgm, msggWinner, 0, 0);
|
|
}
|
|
|
|
BOOL KlondForceWin(GM *pgm)
|
|
{
|
|
INT icol;
|
|
CRD *pcrd;
|
|
COL *pcol;
|
|
RA ra;
|
|
SU su;
|
|
|
|
for(icol = 0; icol < pgm->icolMac; icol++)
|
|
SendColMsg(pgm->rgpcol[icol], msgcClearCol, 0, 0);
|
|
for(su = suFirst, icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++, su++)
|
|
{
|
|
Assert(raFirst == 0);
|
|
for(ra = raFirst; ra < raMax; ra++)
|
|
{
|
|
pcol = pgm->rgpcol[icol];
|
|
pcrd = &pcol->rgcrd[ra];
|
|
pcrd->cd = Cd(ra, su);
|
|
pcrd->pt.x = pcol->rc.xLeft;
|
|
pcrd->pt.y = pcol->rc.yTop;
|
|
pcrd->fUp = fTrue;
|
|
}
|
|
pgm->rgpcol[icol]->icrdMac = icrdFoundMax;
|
|
}
|
|
Assert(SendGmMsg(pgm, msggIsWinner, 0, 0));
|
|
return (BOOL)SendGmMsg(pgm, msggWinner, 0, 0);
|
|
}
|
|
|
|
|
|
/* Note: assumes is called once a second */
|
|
/* if pcolDest == pcolSrc == NULL, then is a timer msg */
|
|
BOOL KlondScore(GM *pgm, COL *pcolDest, COL *pcolSrc)
|
|
{
|
|
INT cs;
|
|
INT tclsSrc, tclsDest;
|
|
|
|
|
|
if(smd == smdNone)
|
|
return fTrue;
|
|
cs = csNil;
|
|
|
|
Assert(FValidCol(pcolSrc));
|
|
Assert(FValidCol(pcolDest));
|
|
|
|
|
|
tclsSrc = pcolSrc->pcolcls->tcls;
|
|
tclsDest = pcolDest->pcolcls->tcls;
|
|
|
|
switch(tclsDest)
|
|
{
|
|
default:
|
|
return fTrue;
|
|
case tclsDeck:
|
|
if(tclsSrc == tclsDiscard)
|
|
cs = csKlondDeckFlip;
|
|
break;
|
|
case tclsFound:
|
|
switch(tclsSrc)
|
|
{
|
|
default:
|
|
return fTrue;
|
|
case tclsDiscard:
|
|
case tclsTab:
|
|
cs = csKlondFound;
|
|
break;
|
|
}
|
|
break;
|
|
case tclsTab:
|
|
switch(tclsSrc)
|
|
{
|
|
default:
|
|
return fTrue;
|
|
case tclsDiscard:
|
|
cs = csKlondTab;
|
|
break;
|
|
case tclsFound:
|
|
cs = csKlondFoundTab;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
SendGmMsg(pgm, msggChangeScore, cs, 0);
|
|
return fTrue;
|
|
}
|
|
|
|
INT mpcsdscoStd[] = { -2, -20, 10, 5, 5, -15, 0, 0};
|
|
INT mpcsdscoVegas[] = {0, 0, 5, 0, 0, -5, -52, 0};
|
|
|
|
|
|
BOOL KlondChangeScore(GM *pgm, INT cs, INT sco)
|
|
{
|
|
INT dsco;
|
|
INT csNew;
|
|
INT *pmpcsdsco;
|
|
INT ret;
|
|
|
|
if(cs < 0)
|
|
return DefGmProc(pgm, msggChangeScore, cs, sco);
|
|
Assert(FInRange(cs, 0, csKlondMax-1));
|
|
switch(smd)
|
|
{
|
|
default:
|
|
Assert(smd == smdNone);
|
|
return fTrue;
|
|
case smdVegas:
|
|
pmpcsdsco = mpcsdscoVegas;
|
|
break;
|
|
|
|
case smdStandard:
|
|
pmpcsdsco = mpcsdscoStd;
|
|
if(cs == csKlondWin && fTimedGame)
|
|
{
|
|
#ifdef DEBUG
|
|
pgm->iqsecScore = WMax(120, pgm->iqsecScore);
|
|
#endif
|
|
/* check if timer set properly */
|
|
if(pgm->iqsecScore >= 120)
|
|
dsco = (20000/(pgm->iqsecScore>>2))*(350/10);
|
|
else
|
|
dsco = 0;
|
|
goto DoScore;
|
|
}
|
|
if(cs == csKlondDeckFlip)
|
|
{
|
|
if(ccrdDeal == 1 && pgm->irep >= 1)
|
|
{
|
|
dsco = -100;
|
|
goto DoScore;
|
|
}
|
|
else if(ccrdDeal == 3 && pgm->irep > 3)
|
|
break;
|
|
else
|
|
return fTrue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
dsco = pmpcsdsco[cs];
|
|
DoScore:
|
|
csNew = smd == smdVegas ? csDel : csDelPos;
|
|
ret = DefGmProc(pgm, msggChangeScore, csNew, dsco);
|
|
if(cs == csKlondWin)
|
|
return dsco;
|
|
else
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
BOOL KlondTimer(GM *pgm, INT wp1, INT wp2)
|
|
{
|
|
|
|
if(fTimedGame && pgm->fDealt && pgm->fInput && !fIconic)
|
|
{
|
|
pgm->iqsecScore = WMin(pgm->iqsecScore+1, 0x7ffe);
|
|
if(pgm->icolSel == icolNil)
|
|
SendColMsg(pgm->rgpcol[icolDeck], msgcAnimate, pgm->iqsecScore, 0);
|
|
if(pgm->dqsecScore != 0 && (pgm->iqsecScore)%pgm->dqsecScore == 0)
|
|
{
|
|
SendGmMsg(pgm, msggChangeScore, csKlondTime, 0);
|
|
}
|
|
else
|
|
{
|
|
/* update status bar once as second */
|
|
if(~(pgm->iqsecScore & 0x03))
|
|
StatUpdate();
|
|
return fTrue;
|
|
}
|
|
}
|
|
return fFalse;
|
|
}
|
|
|
|
BOOL KlondDrawStatus(GM *pgm, RC *prc)
|
|
{
|
|
TCHAR *pch;
|
|
TCHAR sz[80];
|
|
RC rc;
|
|
LONG rgb;
|
|
BOOL fNegSco;
|
|
SIZE iSize;
|
|
extern INT iCurrency;
|
|
extern TCHAR szCurrency[];
|
|
HFONT hFontOld = NULL;
|
|
HFONT hStatusFont = NULL;
|
|
|
|
|
|
// store the old font and replace the status font by MS Shell Dlg
|
|
// as it supports FE characters as well as euro characters.
|
|
|
|
hStatusFont = CreateFont(-MulDiv(9, GetDeviceCaps(hdcCur, LOGPIXELSY), 72), 0, 0, 0, FW_BOLD, 0, 0, 0,
|
|
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
|
|
DEFAULT_PITCH, TEXT("MS Shell Dlg"));
|
|
|
|
if (hStatusFont && hdcCur);
|
|
hFontOld = SelectObject(hdcCur, hStatusFont);
|
|
|
|
pch = sz;
|
|
if(fTimedGame)
|
|
{
|
|
pch += CchString(pch, idsTime, ARRAYSIZE(sz));
|
|
pch += CchDecodeInt(pch, (pgm->iqsecScore>>2));
|
|
}
|
|
#ifdef DEBUG
|
|
if(!fScreenShots)
|
|
{
|
|
*pch++ = TEXT(' ');
|
|
pch = PszCopy(TEXT("Game # "), pch);
|
|
pch += CchDecodeInt(pch, igmCur);
|
|
}
|
|
#endif
|
|
if(pch != sz)
|
|
{
|
|
DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) prc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
|
|
}
|
|
|
|
if(smd != smdNone)
|
|
{
|
|
rc = *prc;
|
|
GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
|
|
rc.xRight -= iSize.cx;
|
|
pch = sz;
|
|
if(fNegSco = pgm->sco < 0)
|
|
*pch++ = TEXT('-');
|
|
if(smd == smdVegas)
|
|
{
|
|
if(!(iCurrency&1))
|
|
{
|
|
pch = PszCopy(szCurrency, pch);
|
|
if(iCurrency == 2)
|
|
*pch++ = TEXT(' ');
|
|
}
|
|
}
|
|
pch += CchDecodeInt(pch, fNegSco ? -pgm->sco : pgm->sco);
|
|
if(smd == smdVegas)
|
|
{
|
|
if(iCurrency&1)
|
|
{
|
|
if(iCurrency == 3)
|
|
*pch++ = TEXT(' ');
|
|
pch = PszCopy(szCurrency, pch);
|
|
}
|
|
}
|
|
*pch++ = TEXT(' ');
|
|
rgb = SetTextColor(hdcCur, (!fBW && fNegSco) ? RGB(0xff, 0, 0) : RGB(0, 0, 0));
|
|
DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) &rc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
|
|
SetTextColor(hdcCur, rgb);
|
|
|
|
GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
|
|
rc.xRight -= iSize.cx;
|
|
pch = PszCopy(szScore, sz);
|
|
DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) &rc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
|
|
GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
|
|
rc.xRight -= iSize.cx;
|
|
rc.xLeft = rc.xRight - 4 * dxChar;
|
|
PatBlt(hdcCur, rc.xLeft, rc.yTop, rc.xRight-rc.xLeft, rc.yBot-rc.yTop, PATCOPY);
|
|
}
|
|
|
|
|
|
// restore the font
|
|
if (hFontOld);
|
|
SelectObject(hdcCur, hFontOld);
|
|
|
|
// close the created font handle
|
|
if (hStatusFont)
|
|
DeleteObject(hStatusFont);
|
|
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
|
|
|
|
LRESULT KlondGmProc(GM *pgm, INT msgg, WPARAM wp1, LPARAM wp2)
|
|
{
|
|
switch(msgg)
|
|
{
|
|
case msggMouseDblClk:
|
|
if(DefGmProc(pgm, msggMouseDblClk, wp1, wp2))
|
|
return fTrue;
|
|
/* fall thru so works for deck double clicks */
|
|
case msggMouseDown:
|
|
return KlondMouseDown(pgm, (PT *)wp1);
|
|
|
|
case msggDeal:
|
|
return KlondDeal(pgm, (BOOL)wp1);
|
|
|
|
case msggIsWinner:
|
|
return KlondIsWinner(pgm);
|
|
|
|
case msggWinner:
|
|
return KlondWinner(pgm);
|
|
|
|
case msggForceWin:
|
|
return KlondForceWin(pgm);
|
|
|
|
case msggScore:
|
|
return KlondScore(pgm, (COL *) wp1, (COL *)wp2);
|
|
|
|
case msggChangeScore:
|
|
return KlondChangeScore(pgm, (INT)wp1, (INT)wp2);
|
|
|
|
case msggTimer:
|
|
return KlondTimer(pgm, (INT)wp1, (INT)wp2);
|
|
|
|
|
|
case msggDrawStatus:
|
|
return KlondDrawStatus(pgm, (RC *) wp1);
|
|
}
|
|
return DefGmProc(pgm, msgg, wp1, wp2);
|
|
}
|