eggclockappview.cpp

symbian s60环境一个鸡蛋型图像钟表源代码

/*
============================================================================
 Name        : EggClockView.cpp
 Author      : Michele Berionne
 Version     :
 Copyright   : 
 Description : Application container
============================================================================
*/

// INCLUDE FILES
#include <coemain.h>
#include <eikenv.h>
#include <akniconarray.h>     // Icon array
#include <gulicon.h>          // Icons
#include <aknnotewrappers.h>  // Error note
#include <AknsDrawUtils.h>    // Skin support
#include <AknsBasicBackgroundControlContext.h>

#include "EggClockAppView.h"
#include <EggClock_numbers_icons.mbg>
#include <EggClock.rsg>

#define  ONE_SECOND            1000 * 1000
#define  FLASH_TIME            700 * 1000
#define  CLOCK_SIDE_PADDING    15
#define  DIGIT_PADDING         2
#define  MAX_VOLUME            4

_LIT(KSettingsFileName, "eggtimer.txt");

struct stSettings
{
  TFileName iNotificationFile;
  TInt      iTotalTime;
  TInt      iVolume;
  TInt      iRepeatMinutes;
};
typedef TPckgBuf<stSettings> SETTINGS_BUF;


// ============================ MEMBER FUNCTIONS ===============================
CEggClockAppView* CEggClockAppView::NewL( const TRect& aRect )
{
  CEggClockAppView* self = CEggClockAppView::NewLC( aRect );
  CleanupStack::Pop( self );
  return self;
}

CEggClockAppView* CEggClockAppView::NewLC( const TRect& aRect )
{
  CEggClockAppView* self = new (ELeave) CEggClockAppView;
  CleanupStack::PushL( self );
  self->ConstructL( aRect );
  return self;
}

void CEggClockAppView::ConstructL( const TRect& aRect )
{
  // Create the timers
  m_pTimer = CPeriodic::NewL(CActive::EPriorityIdle);
  m_pFlashTimer = CPeriodic::NewL(CActive::EPriorityIdle);

  // Load icons with numbers
  _LIT(KEggClockIconsFilename, "\\resource\\apps\\EggClock_numbers_icons.mbm");
  m_pDigitIcons = new (ELeave) CAknIconArray(10);
  for (TInt i = 0; i < 10; i++)
  {
    CFbsBitmap* pBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_icons0 + i);
    CleanupStack::PushL(pBitmap);  
    m_pDigitIcons->AppendL(CGulIcon::NewL(pBitmap, pBitmap));
    CleanupStack::Pop(); // pBitmap
  }
  
  // Load icon for colon
  CFbsBitmap* pColonBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsColon);
  CleanupStack::PushL(pColonBitmap);
  m_pColonIcon = CGulIcon::NewL(pColonBitmap, pColonBitmap);
  CleanupStack::Pop(); // pColonBitmap

  // Load icons for volume
  CFbsBitmap* pVolumeBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsVolume);
  CleanupStack::PushL(pVolumeBitmap);
  CFbsBitmap* pVolumeBitmapMask = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsVolume_mask);
  CleanupStack::PushL(pVolumeBitmapMask);
  m_pVolumeIcon = CGulIcon::NewL(pVolumeBitmap, pVolumeBitmapMask);
  CleanupStack::Pop(); // pVolumeBitmapMask
  CleanupStack::Pop(); // pVolumeBitmap
  CFbsBitmap* pVolumeMuteBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsVolume_mute);
  CleanupStack::PushL(pVolumeMuteBitmap);
  CFbsBitmap* pVolumeMuteBitmapMask = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsVolume_mute_mask);
  CleanupStack::PushL(pVolumeMuteBitmapMask);
  m_pVolumeMuteIcon = CGulIcon::NewL(pVolumeMuteBitmap, pVolumeMuteBitmapMask);
  CleanupStack::Pop(); // pVolumeMuteBitmapMask
  CleanupStack::Pop(); // m_pVolumeMuteIcon

  m_pVolumeValueIcons = new (ELeave) CAknIconArray(MAX_VOLUME + 1);
  for (TInt i = 0; i <= MAX_VOLUME; i++)
  {
    CFbsBitmap* pBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsVolume_0 + i);
    CleanupStack::PushL(pBitmap);  
    m_pVolumeValueIcons->AppendL(CGulIcon::NewL(pBitmap, pBitmap));
    CleanupStack::Pop(); // pBitmap
  }
  
  // Load icons for repeat
  CFbsBitmap* pRepeatOnceBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsRepeat_once);
  CleanupStack::PushL(pRepeatOnceBitmap);
  m_pRepeatOnceIcon = CGulIcon::NewL(pRepeatOnceBitmap, pRepeatOnceBitmap);
  CleanupStack::Pop(); // pRepeatOnceBitmap
  CFbsBitmap* pRepeatLoopBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsRepeat_loop);
  CleanupStack::PushL(pRepeatLoopBitmap);
  m_pRepeatLoopIcon = CGulIcon::NewL(pRepeatLoopBitmap, pRepeatLoopBitmap);
  CleanupStack::Pop(); // pRepeatLoopBitmap
  CFbsBitmap* pRepeatEveryXBitmap = iEikonEnv->CreateBitmapL(KEggClockIconsFilename, EMbmEggclock_numbers_iconsRepeat_every_x);
  CleanupStack::PushL(pRepeatEveryXBitmap);
  m_pRepeatEveryXIcon = CGulIcon::NewL(pRepeatEveryXBitmap, pRepeatEveryXBitmap);
  CleanupStack::Pop(); // pRepeatEveryXBitmap
  
  // Load settings
  LoadSettingsL();
  
  // Initialize player if required
  if (m_iNotificationFile.Length() > 0)
  {
#ifndef DRM_PLAYER
    m_pFilePlayer = CMdaAudioPlayerUtility::NewFilePlayerL(m_iNotificationFile, *this, EMdaPriorityNormal, EMdaPriorityPreferenceTime);
#else
    m_pFilePlayer = CDrmPlayerUtility::NewFilePlayerL(m_iNotificationFile, *this, EMdaPriorityNormal, EMdaPriorityPreferenceTime);
#endif
    if (m_pFilePlayer)
    {
      m_iAudioState = eAudioIniting;
    }
  }
  
  
  // Create a window for this application view and set the size
  CreateWindowL();
  SetRect(aRect);

  // Skin support
  m_pSkinBackground = CAknsBasicBackgroundControlContext::NewL(KAknsIIDQsnBgAreaMain, Rect(), EFalse);

  // Activate the control
  ActivateL();
}

CEggClockAppView::CEggClockAppView()
{
  m_iTotalDuration = 0;
  m_pFilePlayer    = NULL;
  m_iAudioState    = eAudioIdle;
  m_iVolume        = MAX_VOLUME;
}

CEggClockAppView::~CEggClockAppView()
{
  if (m_pTimer)
  {
    if (m_pTimer->IsActive())
    {
      m_pTimer->Cancel();
    }
    delete m_pTimer;
    m_pTimer = NULL;
  }
  if (m_pFlashTimer)
  {
    if (m_pFlashTimer->IsActive())
    {
      m_pFlashTimer->Cancel();
    }
    delete m_pFlashTimer;
    m_pFlashTimer = NULL;
  }
  if (m_pDigitIcons)
  {
    m_pDigitIcons->ResetAndDestroy();
    delete m_pDigitIcons;
    m_pDigitIcons = NULL;
  }
  if (m_pColonIcon)
  {
    delete m_pColonIcon;
    m_pColonIcon = NULL;
  }
  if (m_pVolumeIcon)
  {
    delete m_pVolumeIcon;
    m_pVolumeIcon = NULL;
  }
  if (m_pVolumeMuteIcon)
  {
    delete m_pVolumeMuteIcon;
    m_pVolumeMuteIcon = NULL;
  }
  if (m_pVolumeValueIcons)
  {
    m_pVolumeValueIcons->ResetAndDestroy();
    delete m_pVolumeValueIcons;
    m_pVolumeValueIcons = NULL;
  }
  if (m_pRepeatOnceIcon)
  {
    delete m_pRepeatOnceIcon;
    m_pRepeatOnceIcon = NULL;
  }
  if (m_pRepeatLoopIcon)
  {
    delete m_pRepeatLoopIcon;
    m_pRepeatLoopIcon = NULL;
  }
  if (m_pRepeatEveryXIcon)
  {
    delete m_pRepeatEveryXIcon;
    m_pRepeatEveryXIcon = NULL;
  }
  if (m_pFilePlayer)
  {
    delete m_pFilePlayer;
    m_pFilePlayer = NULL;
  }
  if (m_pSkinBackground)
  {
    delete m_pSkinBackground;
    m_pSkinBackground = NULL;
  }
}

TTypeUid::Ptr CEggClockAppView::MopSupplyObject(TTypeUid aId)
{
  if(aId.iUid == MAknsControlContext::ETypeId && m_pSkinBackground)
  {
    return MAknsControlContext::SupplyMopObject(aId, m_pSkinBackground);
  }
  return CCoeControl::MopSupplyObject(aId);
}

void CEggClockAppView::Draw(const TRect& aRect) const
{
  // Get the standard graphics context
  CWindowGc& gc = SystemGc();

  // Clears the screen
  if (m_pFlashTimer && m_pFlashTimer->IsActive() && m_bFlash)
  {
    gc.SetBrushColor(TRgb(255, 0, 0));
    gc.Clear(Rect());
  }
  else
  {
    // Skin support
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    MAknsControlContext* cc = AknsDrawUtils::ControlContext(this);
    AknsDrawUtils::Background(skin, cc, this, gc, aRect);
  }

  // Calculate numbers to show
  TInt iLargeNumber = (m_iRemainingDuration > 0) ? m_iRemainingDuration : 0;
  TInt iSmallNumber = (m_iRemainingDuration < 0) ? (0 - m_iRemainingDuration) : 0;

  // Large numbers
  TRAPD(r,
    DrawLargeNumberL(aRect, iLargeNumber);
    DrawSmallNumberL(aRect, iSmallNumber);
    DrawVolumeL(aRect);
  );
}

void CEggClockAppView::DrawLargeNumberL(const TRect& /*aRect*/, TInt iNumber) const
{
  TInt i;
  TInt iXPosition, iYPosition;
  
  // Get container size
  TSize iScreenSize = Size();

  // Prepare array with bitmaps
  CFbsBitmap* ppDigitBitmap[5];
  ppDigitBitmap[0] = m_pDigitIcons->At((iNumber / 60) / 10)->Bitmap();
  ppDigitBitmap[1] = m_pDigitIcons->At((iNumber / 60) % 10)->Bitmap();
  ppDigitBitmap[2] = m_pColonIcon->Bitmap();
  ppDigitBitmap[3] = m_pDigitIcons->At((iNumber % 60) / 10)->Bitmap();
  ppDigitBitmap[4] = m_pDigitIcons->At((iNumber % 60) % 10)->Bitmap();
  
  // Calculate zoom factor
  TInt iTotalWidth = ppDigitBitmap[0]->SizeInPixels().iWidth + ppDigitBitmap[1]->SizeInPixels().iWidth +
                     ppDigitBitmap[2]->SizeInPixels().iWidth + ppDigitBitmap[3]->SizeInPixels().iWidth +
                     ppDigitBitmap[4]->SizeInPixels().iWidth + (2 * CLOCK_SIDE_PADDING) + (4 * DIGIT_PADDING);
  TInt iZoomFactor = (100 * iScreenSize.iWidth) / iTotalWidth;

  // Calculate X and Y
  iXPosition = CLOCK_SIDE_PADDING * iZoomFactor / 100;
  iYPosition = 0;
  for (i = 0; i < 5; i++)
  {
    iYPosition = (ppDigitBitmap[0]->SizeInPixels().iHeight > iYPosition) ? ppDigitBitmap[0]->SizeInPixels().iHeight : iYPosition;
  }
  iYPosition = (iScreenSize.iHeight - (iYPosition * iZoomFactor / 100)) / 2;

  // Draw bitmaps
  CWindowGc& gc = SystemGc();
  for (i = 0; i < 5; i++)
  {
    TPoint iPoint(iXPosition, iYPosition);
    TSize  iSize(ppDigitBitmap[i]->SizeInPixels().iWidth * iZoomFactor / 100,
                 ppDigitBitmap[i]->SizeInPixels().iHeight * iZoomFactor / 100);
    
    gc.DrawBitmapMasked(TRect(iPoint, iSize), ppDigitBitmap[i], TRect(ppDigitBitmap[i]->SizeInPixels()), ppDigitBitmap[i], ETrue);
    
    iXPosition += iSize.iWidth + DIGIT_PADDING;
  }
}

void CEggClockAppView::DrawSmallNumberL(const TRect& /*aRect*/, TInt iNumber) const
{  
  // Small number
  if (iNumber > 0)
  {
    CWindowGc& gc = SystemGc();

    TBuf<128> iOvertimeString;
    iCoeEnv->ReadResourceL(iOvertimeString, R_STRING_OVERTIME);

    iOvertimeString.Append(' ');
    iOvertimeString.AppendNum((iNumber / 60) / 10);
    iOvertimeString.AppendNum((iNumber / 60) % 10);
    iOvertimeString.Append(':');
    iOvertimeString.AppendNum((iNumber % 60) / 10);
    iOvertimeString.AppendNum((iNumber % 60) % 10);
    
    TRgb iFontColor(0, 0, 0);
    const CFont* iFont = iEikonEnv->DenseFont();
    gc.SetPenColor(iFontColor);
    gc.UseFont(iFont);
    
    gc.DrawText(iOvertimeString, TPoint(CLOCK_SIDE_PADDING, Size().iHeight - CLOCK_SIDE_PADDING));
    gc.DiscardFont();
  }
}

void CEggClockAppView::DrawVolumeL(const TRect& /*aRect*/) const
{
  if (m_iVolume >= 0 && m_iVolume <= MAX_VOLUME)
  {
    CWindowGc& gc = SystemGc();
  
    CFbsBitmap* pRepeat = m_iRepeatMinutes == 0 ? m_pRepeatLoopIcon->Bitmap() :
                          (m_iRepeatMinutes >= INFINITE_MINUTES ? m_pRepeatOnceIcon->Bitmap() : m_pRepeatEveryXIcon->Bitmap());
    CFbsBitmap* pVolume = (m_iNotificationFile.Length() > 0 && m_iAudioState != eAudioIdle) ? m_pVolumeIcon->Bitmap() : m_pVolumeMuteIcon->Bitmap();
    CFbsBitmap* pVolumeValue = m_pVolumeValueIcons->At(m_iVolume)->Bitmap();
    
    if (pRepeat && pVolume && pVolumeValue)
    {
      if (m_iNotificationFile.Length() > 0)
      {
        TInt iTotalWidth = pRepeat->SizeInPixels().iWidth + DIGIT_PADDING +
                           pVolume->SizeInPixels().iWidth + DIGIT_PADDING +
                           pVolumeValue->SizeInPixels().iWidth + CLOCK_SIDE_PADDING;

        TPoint iPoint(Size().iWidth - iTotalWidth, CLOCK_SIDE_PADDING);
        gc.DrawBitmapMasked(TRect(iPoint, pRepeat->SizeInPixels()), pRepeat, TRect(pRepeat->SizeInPixels()), pRepeat, ETrue);

        iPoint = iPoint + TPoint(pRepeat->SizeInPixels().iWidth + DIGIT_PADDING, 0);
        gc.DrawBitmapMasked(TRect(iPoint, pVolume->SizeInPixels()), pVolume, TRect(pVolume->SizeInPixels()), pVolume, ETrue);
      
        iPoint = iPoint + TPoint(pVolume->SizeInPixels().iWidth + DIGIT_PADDING, 0);
        gc.DrawBitmapMasked(TRect(iPoint, pVolumeValue->SizeInPixels()), pVolumeValue, TRect(pVolumeValue->SizeInPixels()), pVolumeValue, ETrue);
      }