boss.cpp

Symbian C++ scmp.zip

// boss.cpp
//
// Copyright (c) 1998 Symbian Ltd.  All rights reserved.
//

#include <e32keys.h>

#include <coemain.h>

#include <eikenv.h>
#include <eikdef.h>
#include <eikon.hrh>
#include <eiklabel.h>
#include <eikfnlab.h>
#include <eiktbar.h>
#include <eikon.rsg>

#include <eikproc.h>
#include <coeutils.h>

#include <boss.rsg>
#include "boss.hrh"
#include "boss.h"

#include "bossview.h"

void CBossAppView::ConstructL(const TRect& aRect, TBossPuzzle* aModel)
    {
	iModel=aModel;
    CreateWindowL();
    Window().SetShadowDisabled(ETrue);
    iContext=this;
   	iBrushStyle=CGraphicsContext::ESolidBrush;
    iBrushColor=KRgbWhite;
    SetRect(aRect);
	ConstructViewL();
    ActivateL();
    }

CBossAppView::~CBossAppView()
    {
	delete iControl;
	delete iView;
    }
    
TInt CBossAppView::CountComponentControls() const
	{
	return 1;
	}

CCoeControl* CBossAppView::ComponentControl(TInt aIndex) const
	{
	switch (aIndex)
		{
	case 0: return iControl;
	default: return 0;
		};
	}

const TInt KQuartzBossZoom=1600; // 1.6x zoom, making approx 220 pixel wide board

void CBossAppView::ConstructViewL()
	{
	// make zoom factor for Quartz
	iZoom.SetGraphicsDeviceMap(iCoeEnv->ScreenDevice());
	iZoom.SetZoomFactor(KQuartzBossZoom);
	// make view
	iView=new (ELeave) CBossView(iModel);
	iView->ConstructL(&iZoom);
	// make control
	TSize viewSize=iView->GetSizeInPixels();
	TInt x=(Rect().Width() - viewSize.iWidth) / 2;
	TInt y=(Rect().Height() - viewSize.iHeight) / 2;
	TRect controlRect(TPoint(x,y), viewSize);
	iControl=new (ELeave) CBossControl(iModel, iView, this);
	iControl->ConstructL(this,controlRect);
	}

void CBossAppView::NotifyStatus(const TDesC& aMessage)
	{
	iEikonEnv->InfoMsg(aMessage);
	}

TKeyResponse CBossAppView::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
    {
	if	(iControl)
   		return ((CCoeControl*)iControl)->OfferKeyEventL(aKeyEvent,aType);
	else
		return EKeyWasNotConsumed;
    }

void CBossAppView::Draw(const TRect& /*aRect*/) const
	{
	CWindowGc& gc = SystemGc();
	gc.SetPenStyle(CGraphicsContext::ENullPen);
	gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
	gc.DrawRect(Rect());
	}

// handle commands

void CBossAppView::Move(TBossPuzzle::TMoveType aMoveType)
	{
	if (!iModel->CanMove(aMoveType))
		{
		TInt message=
			aMoveType==TBossPuzzle::EUp ? R_BOSS_CANNOT_MOVE_UP :
			aMoveType==TBossPuzzle::EDown ? R_BOSS_CANNOT_MOVE_DOWN :
			aMoveType==TBossPuzzle::ELeft ? R_BOSS_CANNOT_MOVE_LEFT :
			aMoveType==TBossPuzzle::ERight ? R_BOSS_CANNOT_MOVE_RIGHT :
				R_EIK_TBUF_NOT_AVAILABLE;
		iEikonEnv->InfoMsg(message);
		return;
		}
	MoveChecked(aMoveType);
	}

void CBossAppView::BCOMove(TInt aRow, TInt aCol)
	{
	if (iModel->IsBlank(aRow,aCol))
		{
		iEikonEnv->InfoMsg(R_BOSS_CANNOT_MOVE_BLANK);
		return;
		}
	if (!iModel->CanMove(aRow,aCol))
		{
		iEikonEnv->InfoMsg(R_BOSS_CANNOT_MOVE_PIECE);
		return;
		}
	MoveChecked(iModel->CanMoveType(aRow,aCol));
	}

void CBossAppView::BCOMove(TBossPuzzle::TMoveType aMoveType)
	{
	Move(aMoveType);
	}

void CBossAppView::MoveChecked(TBossPuzzle::TMoveType aMoveType)
	{ // assume all parameters checked
	iControl->FinishMove(); // finish any existing move
	// move and minimal redraw
	TInt oldRow, oldCol, newRow, newCol;
	iModel->LocateBlank(oldRow, oldCol);
	iModel->Move(aMoveType);
	iModel->LocateBlank(newRow, newCol);
	iControl->MoveTile(oldRow, oldCol, newRow, newCol);
	// check complete
	if (iModel->IsFullyOrdered())
		iEikonEnv->InfoMsg(R_BOSS_CONGRATULATIONS);
	}

void CBossAppView::SetFullyOrdered()
	{
	iControl->FinishMove();
	iModel->SetFullyOrdered();
	iControl->DrawNow();
	iEikonEnv->InfoMsg(R_BOSS_FULLY_ORDERED);
	}

void CBossAppView::SetBossOrdered()
	{
	iControl->FinishMove();
	iModel->SetBossOrdered();
	iControl->DrawNow();
	iEikonEnv->InfoMsg(R_BOSS_BOSS_ORDERED);
	}

//
// CBossAppUi
//

void CBossAppUi::ConstructL()
    {
    BaseConstructL();
	iModel=((CBossDocument*)iDocument)->Model();
    iAppView=new(ELeave) CBossAppView;
    iAppView->ConstructL(ClientRect(),iModel);
	AddToStackL(iAppView); // app view should go onto control stack
    }

CBossAppUi::~CBossAppUi()
	{
	RemoveFromStack(iAppView);
	if (iDoorObserver)
		iDoorObserver->NotifyExit(MApaEmbeddedDocObserver::EKeepChanges);
    delete iAppView;
	}

void CBossAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
	case EBossUp:
		iAppView->Move(TBossPuzzle::EUp);
		return;
	case EBossDown:
		iAppView->Move(TBossPuzzle::EDown);
		return;
	case EBossLeft:
		iAppView->Move(TBossPuzzle::ELeft);
		return;
	case EBossRight:
		iAppView->Move(TBossPuzzle::ERight);
		return;
	case EBossSetFullyOrdered:
		iAppView->SetFullyOrdered();
		return;
	case EBossSetBossOrdered:
		iAppView->SetBossOrdered();
		return;
	case EEikCmdExit: 
		SaveL();
		Exit();
		return;
		}
	}

// file handling

TBool CBossAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName, const TDesC& /*aTail*/)
	{
	if (aCommand==EApaCommandCreate)
		return EFalse; // assume aDocumentName is valid
	if (aCommand==EApaCommandRun || aCommand==EApaCommandBackground)
		{
		TFileName fileName=iEikonEnv->Process()->LastUsedFileL(CEikProcess::ELastOpenFile);
		if (ConeUtils::FileExists(fileName))
			{
			aDocumentName=fileName;
			return(ETrue);
			}
		Application()->GetDefaultDocumentFileName(aDocumentName);
		}
	return ConeUtils::FileExists(aDocumentName);
	}

void CBossAppUi::HandleModelChangeL()
	{
	iAppView->DrawNow();
#if 0
	// filename on toolbar
	iEikonEnv->UpdateTaskNameL();
	CEikFileNameLabel* filenameLabel=(CEikFileNameLabel*) iToolBar->ControlById(EBossCmdFileName);
	filenameLabel->UpdateL();
	filenameLabel->DrawNow();
#endif
	}

TFileName CBossAppUi::MainDocPath() const
	{
	TParsePtrC parser(Document()->Process()->MainDocFileName());
	return parser.DriveAndPath();
	}

//
// CBossDocument
//

CEikAppUi* CBossDocument::CreateAppUiL()
	{
    return(new(ELeave) CBossAppUi);
	}

void CBossDocument::RestoreL(const CStreamStore& aStore,const CStreamDictionary& aStreamDic)
	{
	TStreamId id=aStreamDic.At(KUidBossApp);
	iModel.RestoreL(aStore, id);
	}

void CBossDocument::StoreL(CStreamStore& aStore,CStreamDictionary& aStreamDic) const
	{
	TStreamId id=iModel.StoreL(aStore);
	aStreamDic.AssignL(KUidBossApp,id);
	}

CApaDocument::TCapability CBossDocument::Capability()const
	{
	TCapability capability;
	capability.SetCanDrawGlass();
	return capability;
	}

CPicture* CBossDocument::GlassPictureL()
	{
	CBossGlassDoor* door=new(ELeave) CBossGlassDoor(&iModel);
	CleanupStack::PushL(door);
	door->ConstructL();
	CleanupStack::Pop();
	return door;
	}

//
// CBossGlassDoor
//

CBossGlassDoor::CBossGlassDoor(TBossPuzzle* aModel)
	{
	iModel=aModel;
	iScaleFactorWidth=1000;
	iScaleFactorHeight=1000;
	}

void CBossGlassDoor::ConstructL()
	{
	iView=new (ELeave) CBossView(iModel);
	iView->ConstructL(0); // no device map
	}

CBossGlassDoor::~CBossGlassDoor()
	{
	delete iView;
	}

void CBossGlassDoor::GetOriginalSizeInTwips(TSize& aSize) const
	{
	iView->GetOriginalSizeInTwips(aSize);
	}

TPictureCapability CBossGlassDoor::Capability() const
	{
	return TPictureCapability(TPictureCapability::EFullyScaleable, EFalse);
		// supports scaling but no cropping
	}

void CBossGlassDoor::SetScaleFactor(TInt aScaleFactorWidth,TInt aScaleFactorHeight)
	{
	iScaleFactorWidth=aScaleFactorWidth;
	iScaleFactorHeight=aScaleFactorHeight;
	}

TInt CBossGlassDoor::ScaleFactorWidth() const
	{
	return(iScaleFactorWidth);
	}

TInt CBossGlassDoor::ScaleFactorHeight() const
	{
	return(iScaleFactorHeight);
	}

void CBossGlassDoor::Draw(CGraphicsContext& aGc,const TPoint& aTopLeft, const TRect& aClipRect, MGraphicsDeviceMap* aMap) const
	{
	// this function might leave!! - but name doesn't end in L!!
	iView->SetDeviceMapL(aMap);
	iView->Draw(aGc, aClipRect, aTopLeft);
	iView->SetDeviceMapL(0); // because map will soon be deallocated
	}

//
// CBossApplication
//

TUid CBossApplication::AppDllUid() const
	{
	return KUidBossApp;
	}


CApaDocument* CBossApplication::CreateDocumentL()
	{
	return new(ELeave) CBossDocument(*this);
	}

//
// EXPORTed functions
//

EXPORT_C CApaApplication* NewApplication()
	{
	return new CBossApplication;
	}

GLDEF_C TInt E32Dll(TDllReason)
	{
	return KErrNone;
	}