--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videditor/ManualVideoEditor/src/VeiCutAudioContainer.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,1296 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - Initial contribution
+*
+* Contributors:
+* Ixonos Plc
+*
+* Description:
+*
+*/
+
+
+// INCLUDE FILES
+// System includes
+#include <manualvideoeditor.rsg>
+#include <videoeditoruicomponents.mbg>
+#include <eikbtgpc.h>
+#include <coemain.h>
+#include <eikenv.h>
+#include <aknsbasicbackgroundcontrolcontext.h>
+#include <aknsdrawutils.h>
+#include <aknsdatacontext.h>
+#include <stringloader.h>
+#include <aknnotewrappers.h>
+#include <MdaAudioSamplePlayer.h>
+#include <eikprogi.h>
+#include <audiopreference.h>
+#include <aknlayoutscalable_avkon.cdl.h>
+#include <aknlayoutscalable_apps.cdl.h>
+// User includes
+#include "manualvideoeditor.hrh"
+#include "VeiAppUi.h"
+#include "VeiCutAudioContainer.h"
+#include "VeiCutAudioView.h"
+#include "VeiCutterBar.h"
+#include "veitextdisplay.h"
+#include "VideoEditorCommon.h" // Video Editor UID
+#include "VideoEditorHelp.hlp.hrh" // Topic contexts (literals)
+#include "VeiVideoEditorSettings.h"
+#include "VideoEditorUtils.h"
+#include "SampleArrayHandler.h"
+#include "VeiErrorUi.h"
+
+
+// ================= MEMBER FUNCTIONS =======================
+CVeiCutAudioContainer* CVeiCutAudioContainer::NewL( const TRect& aRect, CVeiCutAudioView& aView, CVeiErrorUI& aErrorUI )
+ {
+ CVeiCutAudioContainer* self = CVeiCutAudioContainer::NewLC( aRect, aView, aErrorUI );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+CVeiCutAudioContainer* CVeiCutAudioContainer::NewLC( const TRect& aRect, CVeiCutAudioView& aView, CVeiErrorUI& aErrorUI )
+ {
+ CVeiCutAudioContainer* self = new (ELeave) CVeiCutAudioContainer( aRect, aView, aErrorUI );
+ CleanupStack::PushL( self );
+ self->ConstructL( aRect, aView, aErrorUI );
+ return self;
+ }
+
+void CVeiCutAudioContainer::ConstructL( const TRect& aRect, CVeiCutAudioView& /*aView*/, CVeiErrorUI& /*aErrorUI*/ )
+ {
+ CreateWindowL();
+
+ iState = EStateInitializing;
+ iFrameReady = EFalse;
+
+ iSeekPos = TTimeIntervalMicroSeconds( 0 );
+ iSeeking = EFalse;
+ iCutAudioBar = CVeiCutterBar::NewL( this );
+ iCutTimeDisplay = CVeiTextDisplay::NewL( iCutTimeDisplayRect, this );
+
+ iPreviousScreenMode = -1;
+ iCurrentScreenMode = -1;
+
+ TFileName mbmPath( VideoEditorUtils::IconFileNameAndPath(KVideoEditorUiComponentsIconFileId) );
+
+ AknIconUtils::CreateIconL( iPauseBitmap, iPauseBitmapMask,
+ mbmPath, EMbmVideoeditoruicomponentsQgn_prop_ve_pause,
+ EMbmVideoeditoruicomponentsQgn_prop_ve_pause_mask );
+
+ SetRect( aRect );
+
+ iBgContext = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgAreaMain, Rect(), EFalse );
+
+ iAudioSamplePlayer = CMdaAudioPlayerUtility::NewL( *this,EMdaPriorityMax,
+ TMdaPriorityPreference( KAudioPrefVideoRecording ) );
+
+ iVideoBarTimer = CPeriodic::NewL( CActive::EPriorityLow );
+
+ iSampleArrayHandler = CSampleArrayHandler::NewL();
+
+ EnableDragEvents();
+
+ ActivateL();
+ }
+
+CVeiCutAudioContainer::CVeiCutAudioContainer( const TRect& /*aRect*/, CVeiCutAudioView& aView, CVeiErrorUI& aErrorUI ):iView( aView ), iErrorUI( aErrorUI )
+ {
+ }
+
+void CVeiCutAudioContainer::OpenAudioFileL( const TDesC& aFileName )
+ {
+ if ( iAudioSamplePlayer )
+ {
+ iAudioSamplePlayer->OpenFileL( aFileName );
+ }
+ GetVisualizationL();
+ }
+
+CVeiCutAudioContainer::~CVeiCutAudioContainer()
+ {
+ if ( iProgressNote )
+ {
+ delete iProgressNote;
+ iProgressNote = NULL;
+ }
+ if ( iCutAudioBar )
+ {
+ delete iCutAudioBar;
+ }
+ if ( iCutTimeDisplay )
+ {
+ delete iCutTimeDisplay;
+ }
+ if ( iBgContext )
+ {
+ delete iBgContext;
+ }
+ delete iPauseBitmap;
+ delete iPauseBitmapMask;
+
+ if ( iVideoBarTimer )
+ {
+ iVideoBarTimer->Cancel();
+ delete iVideoBarTimer;
+ }
+ if ( iAudioSamplePlayer )
+ {
+ delete iAudioSamplePlayer;
+ }
+ if (iSampleArrayHandler)
+ {
+ delete iSampleArrayHandler;
+ }
+
+ delete iCallBack;
+
+ delete iBufBitmap;
+ iBufBitmap = NULL;
+
+ delete iRemConTarget;
+ }
+
+void CVeiCutAudioContainer::SizeChanged()
+ {
+ TSize videoScreenSize;
+ TRect rect( Rect() );
+ if ( iBgContext )
+ {
+ iBgContext->SetRect( rect );
+ }
+
+ iPreviousScreenMode = iCurrentScreenMode;
+ iCurrentScreenMode = iEikonEnv->ScreenDevice()->CurrentScreenMode();
+
+
+ // Scissor icon
+ TAknLayoutRect scissorsIconLayout;
+ scissorsIconLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::main_vded_pane_g1());
+ iCutAudioBar->SetComponentRect(CVeiCutterBar::EScissorsIcon, scissorsIconLayout.Rect());
+
+ // Progress bar
+ TAknLayoutRect progressBarLayout;
+ progressBarLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::vded_slider_pane());
+ iCutAudioBar->SetComponentRect(CVeiCutterBar::EProgressBar, progressBarLayout.Rect());
+
+ // left end of the slider when that part is unselected
+ TAknLayoutRect sliderLeftEndLayout;
+ sliderLeftEndLayout.LayoutRect( progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g3() );
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderLeftEndIcon, sliderLeftEndLayout.Rect() );
+
+ // middle part of the slider when that part is unselected
+ TAknLayoutRect sliderMiddleLayout;
+ sliderMiddleLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g5());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderMiddleIcon, sliderMiddleLayout.Rect() );
+
+ // right end of the slider when that part is unselected
+ TAknLayoutRect sliderRightEndLayout;
+ sliderRightEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g4());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderRightEndIcon, sliderRightEndLayout.Rect() );
+
+ // left end of the cut selection slider
+ TAknLayoutRect sliderSelectedLeftEndLayout;
+ sliderSelectedLeftEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g3());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderSelectedLeftEndIcon, sliderSelectedLeftEndLayout.Rect() );
+
+ // middle part of the cut selection slider
+ TAknLayoutRect sliderSelectedMiddleLayout;
+ sliderSelectedMiddleLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g5());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderSelectedMiddleIcon, sliderSelectedMiddleLayout.Rect() );
+
+ // right end of the cut selection slider
+ TAknLayoutRect sliderSelectedRightEndLayout;
+ sliderSelectedRightEndLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g4());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ESliderSelectedRightEndIcon, sliderSelectedRightEndLayout.Rect() );
+
+ // playhead
+ TAknLayoutRect playheadLayout;
+ playheadLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g1());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::EPlayheadIcon, playheadLayout.Rect() );
+
+ // left/right border of cut selection slider
+ TAknLayoutRect cutAreaBorderLayout;
+ cutAreaBorderLayout.LayoutRect(progressBarLayout.Rect(),AknLayoutScalable_Apps::vded_slider_pane_g2());
+ iCutAudioBar->SetComponentRect( CVeiCutterBar::ECutAreaBorderIcon, cutAreaBorderLayout.Rect() );
+
+
+ // Start cut time text
+ TAknLayoutText startTimeTextLayout;
+ startTimeTextLayout.LayoutText(rect, AknLayoutScalable_Apps::main_vded_pane_t1() );
+ iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EStartTimeText, startTimeTextLayout.TextRect());
+
+ // End cut time text
+ TAknLayoutText endTimeTextLayout;
+ endTimeTextLayout.LayoutText(rect, AknLayoutScalable_Apps::main_vded_pane_t2() );
+ iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EEndTimeText, endTimeTextLayout.TextRect());
+
+ // Start cut time icon
+ TAknLayoutRect startTimeIconLayout;
+ startTimeIconLayout.LayoutRect(rect, AknLayoutScalable_Apps::main_vded_pane_g2() );
+ iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EStartTimeIcon, startTimeIconLayout.Rect());
+
+ // End cut time icon
+ TAknLayoutRect endTimeIconLayout;
+ endTimeIconLayout.LayoutRect(rect, AknLayoutScalable_Apps::main_vded_pane_g3() );
+ iCutTimeDisplay->SetComponentRect(CVeiTextDisplay::EEndTimeIcon, endTimeIconLayout.Rect());
+
+ // Pause icon
+
+
+
+ // Video Display
+ TAknLayoutRect videoDisplayLayout;
+ videoDisplayLayout.LayoutRect(Rect(),AknLayoutScalable_Apps::vded_video_pane());
+
+ iIconDisplayRect = videoDisplayLayout.Rect();
+ LOGFMT2(KVideoEditorLogFile, "CVeiCutAudioContainer::SizeChanged(): iIconDisplayRect: %d,%d", iIconDisplayRect.iBr.iX, iIconDisplayRect.iBr.iY);
+
+ //CVeiCutterBar
+ // : Change this when LAF data is ready
+ TPoint cutBarTl = TPoint(STATIC_CAST( TInt, rect.iBr.iX*0.0114 ),
+ STATIC_CAST( TInt, rect.iBr.iY*0.875 ) );
+ TSize cutBarSize = TSize(STATIC_CAST( TInt, rect.iBr.iX*0.9773 ),
+ STATIC_CAST( TInt, rect.iBr.iY*0.0973 ) );
+
+ TRect cutBarRect( cutBarTl, cutBarSize );
+ iCutAudioBar->SetRect( cutBarRect );
+
+ //CVeiTextDisplay
+ // : Change this when LAF data is ready
+ TPoint cutTimeDisplayTl = TPoint(cutBarTl.iX,
+ STATIC_CAST( TInt, rect.iBr.iY*0.757 ) );
+ TSize cutTimeDisplaySize = TSize(cutBarSize.iWidth,
+ STATIC_CAST( TInt, rect.iBr.iY*0.0903 ) );
+
+ iCutTimeDisplayRect = TRect( cutTimeDisplayTl, cutTimeDisplaySize );
+ iCutTimeDisplay->SetRect( iCutTimeDisplayRect );
+ iCutTimeDisplay->SetLayout( CVeiTextDisplay::ECutInCutOut );
+
+
+
+ TInt iconWidth = STATIC_CAST( TInt, rect.iBr.iX * 0.07954545455 );
+ AknIconUtils::SetSize( iPauseBitmap, TSize(iconWidth,iconWidth), EAspectRatioNotPreserved );
+
+ // Create buffer bitmap with the correct size
+ if (iBufBitmap)
+ {
+ delete iBufBitmap;
+ iBufBitmap = NULL;
+ }
+ TSize size = Rect().Size();
+ TDisplayMode dmode = EColor64K;
+ // " ... If the instantiation process really needs
+ // not to leave, use "new CXxx" and check for NULL."
+ iBufBitmap = new CFbsBitmap;
+ TInt err = KErrNone;
+ if (iBufBitmap)
+ {
+ err = iBufBitmap->Create(size, dmode);
+ }
+
+ if (iState != EStateInitializing && !err)
+ {
+ TRAP_IGNORE( DrawToBufBitmapL() );
+ }
+ }
+
+
+TTypeUid::Ptr CVeiCutAudioContainer::MopSupplyObject( TTypeUid aId )
+ {
+ if ( aId.iUid == MAknsControlContext::ETypeId && iBgContext )
+ {
+ return MAknsControlContext::SupplyMopObject( aId, iBgContext );
+ }
+ return CCoeControl::MopSupplyObject( aId );
+ }
+
+TInt CVeiCutAudioContainer::CountComponentControls() const
+ {
+ return 2;
+ }
+
+CCoeControl* CVeiCutAudioContainer::ComponentControl( TInt aIndex ) const
+ {
+ switch ( aIndex )
+ {
+ case 0:
+ return iCutAudioBar;
+ case 1:
+ return iCutTimeDisplay;
+ default:
+ return NULL;
+ }
+ }
+
+void CVeiCutAudioContainer::DrawToBufBitmapL()
+ {
+ // Create bitmap graphics context
+ CFbsBitmapDevice * bitmapDevice = CFbsBitmapDevice::NewL (iBufBitmap);
+ CleanupStack::PushL (bitmapDevice);
+ CFbsBitGc * bitmapContext = 0;
+ User::LeaveIfError (bitmapDevice->CreateContext (bitmapContext));
+ CleanupStack::PushL (bitmapContext);
+ CGraphicsContext * graphicsContext = 0;
+ User::LeaveIfError (bitmapDevice->CreateContext (graphicsContext));
+ CleanupStack::PushL (graphicsContext);
+
+ // Draw skin background
+ MAknsSkinInstance* skin = AknsUtils::SkinInstance();
+ MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
+ AknsDrawUtils::DrawBackground( skin, cc, this, *((CBitmapContext*)graphicsContext), TPoint(0,0), Rect(), KAknsDrawParamDefault );
+
+ if ( iState == EStatePaused )
+ {
+ TPoint pauseIconTl = TPoint( iIconDisplayRect.iTl.iX - STATIC_CAST( TInt, Rect().iBr.iX*0.105),
+ iIconDisplayRect.iTl.iY + STATIC_CAST( TInt, Rect().iBr.iY*0.178 ));
+ bitmapContext->BitBltMasked( pauseIconTl, iPauseBitmap,
+ TRect( TPoint(0,0), iPauseBitmap->SizeInPixels() ),
+ iPauseBitmapMask, EFalse );
+ }
+
+ if (iSampleArrayHandler)
+ {
+ bitmapContext->SetPenSize( TSize(2,1) );
+ bitmapContext->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ bitmapContext->SetBrushColor(KRgbWhite);
+ bitmapContext->SetPenColor( KRgbBlack);
+ bitmapContext->DrawRoundRect( iIconDisplayRect, TSize(4,4));
+
+ iSampleArrayHandler->ScaleAudioVisualization(iIconDisplayRect.Height()/2 - 3); // -2 to eliminate drawing columns to long
+
+ // how many pixels are reserved for each vertical sample line
+ TInt diff = 1;
+ // how many samples fit in rect
+ TInt samplesInDisplay = iIconDisplayRect.Width()/diff;
+
+ TBool started = EFalse;
+ TPoint topLeftHighlighted(iIconDisplayRect.iTl.iX, iIconDisplayRect.iTl.iY);
+ TPoint bottomRightLighted(iIconDisplayRect.iTl.iX, iIconDisplayRect.iBr.iY);
+
+ for (TInt i = 0; (iSampleArrayHandler->CurrentPoint()+i) - samplesInDisplay/2 < iSampleArrayHandler->Size() &&
+ iIconDisplayRect.iTl.iX + i*diff < iIconDisplayRect.iBr.iX; i++)
+ {
+ TInt x = iIconDisplayRect.iTl.iX + i*diff;
+ TInt y = iIconDisplayRect.iBr.iY - iIconDisplayRect.Height()/2;
+
+ // in the beginning of clip, nothing is drawn on the left side of the rect
+ if ((iSampleArrayHandler->CurrentPoint() + i) - samplesInDisplay/2 > 1)
+ {
+ if (iSampleArrayHandler->SampleCutted((iSampleArrayHandler->CurrentPoint()+i) - samplesInDisplay/2))
+ {
+ if (!started)
+ {
+ topLeftHighlighted.iX = x;
+ started = ETrue;
+ }
+ bottomRightLighted.iX = x;
+ bitmapContext->SetPenColor( KRgbRed );
+ }
+ else
+ {
+ bitmapContext->SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);
+ TRect rec(TPoint(1,1), TPoint(2,2));
+ bitmapContext->DrawRect( rec);
+ bitmapContext->SetPenColor( KRgbBlack);
+ }
+
+ // to eliminate from drawing over surrounding black rect
+ if (x > iIconDisplayRect.iTl.iX + 1)
+ {
+ bitmapContext->DrawLine(TPoint(x, y),
+ TPoint(x, (y - 1) - iSampleArrayHandler->Sample((iSampleArrayHandler->CurrentPoint()+i) - samplesInDisplay/2)));
+
+ bitmapContext->DrawLine(TPoint(x, y),
+ TPoint(x, (y + 1) + iSampleArrayHandler->Sample((iSampleArrayHandler->CurrentPoint()+i) - samplesInDisplay/2)));
+ }
+ }
+ }
+
+ // not selected area is "dimmed"
+ bitmapContext->SetPenColor( KRgbBlack);
+ bitmapContext->SetDrawMode(CGraphicsContext::EDrawModeAND);
+ bitmapContext->SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);
+
+ TPoint brArea1(topLeftHighlighted.iX, iIconDisplayRect.iBr.iY);
+ TRect rect1(iIconDisplayRect.iTl, brArea1);
+ bitmapContext->DrawRoundRect( rect1, TSize(4,4));
+
+ TPoint tlArea2(bottomRightLighted.iX, iIconDisplayRect.iTl.iY);
+ TRect rect2(tlArea2, iIconDisplayRect.iBr);
+ bitmapContext->DrawRoundRect( rect2, TSize(4,4));
+
+ bitmapContext->SetPenColor( KRgbGreen );
+ bitmapContext->DrawLine(TPoint((iIconDisplayRect.iTl.iX + iIconDisplayRect.iBr.iX)/2,
+ iIconDisplayRect.iTl.iY + 1),
+ TPoint((iIconDisplayRect.iTl.iX + iIconDisplayRect.iBr.iX)/2,
+ iIconDisplayRect.iBr.iY - 2));
+ }
+
+ CleanupStack::PopAndDestroy( graphicsContext );
+ CleanupStack::PopAndDestroy( bitmapContext );
+ CleanupStack::PopAndDestroy( bitmapDevice );
+ DrawDeferred();
+ }
+
+void CVeiCutAudioContainer::Draw( const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+
+ if ( iBufBitmap && iBufBitmap->Handle() )
+ {
+ gc.BitBlt(TPoint(0,0), iBufBitmap);
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CVeiCutAudioContainer::GetHelpContext(...) const
+//
+// Gets the control's help context. Associates the control with a particular
+// Help file and topic in a context sensitive application.
+// ----------------------------------------------------------------------------
+//
+void CVeiCutAudioContainer::GetHelpContext( TCoeHelpContext& aContext ) const
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::GetHelpContext(): In");
+
+ // Set UID of the CS Help file (same as application UID).
+ aContext.iMajor = KUidVideoEditor;
+
+ // Set the context/topic.
+ aContext.iContext = KVED_HLP_CUT_AUDIO_VIEW;
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::GetHelpContext(): Out");
+ }
+
+
+void CVeiCutAudioContainer::HandleControlEventL(
+ CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CVeiCutAudioContainer::HandlePointerEventL
+// From CCoeControl
+// ----------------------------------------------------------------------------
+//
+void CVeiCutAudioContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent )
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandlePointerEventL(): In");
+ if( AknLayoutUtils::PenEnabled() && iCutAudioBar )
+ {
+ CCoeControl::HandlePointerEventL( aPointerEvent );
+
+ switch( aPointerEvent.iType )
+ {
+ case TPointerEvent::EButton1Down:
+ {
+ iIsMarkDrag = EFalse;
+ iIsMarkTapped = EFalse;
+ TRect startMarkRect = iCutAudioBar->StartMarkRect();
+ TRect endMarkRect = iCutAudioBar->EndMarkRect();
+ // check if the pen goes down inside the start mark
+ if (startMarkRect.Contains(aPointerEvent.iPosition))
+ {
+ iIsMarkTapped = ETrue;
+ iTappedMark = EStartMark;
+ }
+ // check if the pen goes down inside the end mark
+ else if (endMarkRect.Contains(aPointerEvent.iPosition))
+ {
+ iIsMarkTapped = ETrue;
+ iTappedMark = EEndMark;
+ }
+
+ TRect progressBarRect(iCutAudioBar->ProgressBarRect());
+ // check if the pen goes down inside the progress bar
+ if( progressBarRect.Contains( aPointerEvent.iPosition ) )
+ {
+ iIsMarkDrag = EFalse;
+ }
+ break;
+ }
+ case TPointerEvent::EDrag:
+ {
+
+ TRect progressBarRect(iCutAudioBar->ProgressBarRect());
+ if ( progressBarRect.Contains( aPointerEvent.iPosition ) )
+ {
+
+ if (iIsMarkTapped)
+ {
+ iIsMarkDrag = ETrue;
+ HandleProgressBarTouchL( progressBarRect,
+ aPointerEvent.iPosition.iX,
+ ETrue,
+ iTappedMark );
+ }
+ else
+ {
+
+ HandleProgressBarTouchL( progressBarRect,
+ aPointerEvent.iPosition.iX,
+ EFalse);
+ }
+ }
+ break;
+ }
+ case TPointerEvent::EButton1Up:
+ {
+ // pen up event is handled if it wasn't dragged
+ if (!iIsMarkDrag)
+ {
+ TRect progressBarRect(iCutAudioBar->ProgressBarRect());
+ // Check if pressed position is in progress bar's rect
+ if( progressBarRect.Contains( aPointerEvent.iPosition ) )
+ {
+ HandleProgressBarTouchL( progressBarRect,
+ aPointerEvent.iPosition.iX,
+ EFalse);
+ }
+ }
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandlePointerEventL(): Out");
+ }
+
+
+// ----------------------------------------------------------------------------
+// CVeiCutAudioContainer::HandleProgressBarTouchL
+//
+// ----------------------------------------------------------------------------
+//
+void CVeiCutAudioContainer::HandleProgressBarTouchL( TRect aPBRect,
+ TInt aPressedPoint,
+ TBool aDragMarks,
+ CVeiCutAudioContainer::TCutMark aCutMark )
+ {
+ if ( (AknLayoutUtils::PenEnabled()) && ( iState!=EStateInitializing ))
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleProgressBarTouchL(): In");
+
+ if (iState == EStatePlaying)
+ {
+ StopL();
+ }
+
+ // Progress Bar start and end points, and length
+ TInt pbEndPoint( aPBRect.iBr.iX );
+ TInt pbStartPoint = ( aPBRect.iTl.iX );
+ TInt totalPBLength( pbEndPoint - pbStartPoint );
+
+ // calculate the time position from the tapped progress bar coordinates
+ TTimeIntervalMicroSeconds newPosition(
+ ( ( aPressedPoint - pbStartPoint ) *
+ iAudioSamplePlayer->Duration().Int64() ) /
+ totalPBLength );
+
+ // move cut marks
+ if (aDragMarks)
+ {
+ // check that the start mark doesn't go past the end mark
+ // and not to the beginning
+ if ((aCutMark == EStartMark) &&
+ (newPosition.Int64() > 0) &&
+ (aPressedPoint < iCutAudioBar->EndMarkPoint() - 2*iCutAudioBar->EndMarkRect().Width()))
+ {
+ iView.MoveStartOrEndMarkL(newPosition, EStartMark);
+ iCutAudioBar->SetInPoint( newPosition );
+ iCutTimeDisplay->SetCutIn( newPosition );
+ }
+ // check that the end mark doesn't go before the start mark
+ // and not too close to the beginning
+ else if ((aCutMark == EEndMark) &&
+ (newPosition.Int64() >= KMinCutVideoLength) &&
+ (aPressedPoint > iCutAudioBar->StartMarkPoint() + 2*iCutAudioBar->StartMarkRect().Width()))
+
+ {
+ iView.MoveStartOrEndMarkL(newPosition, EEndMark);
+ iCutAudioBar->SetOutPoint( newPosition );
+ iCutTimeDisplay->SetCutOut( newPosition );
+ }
+ }
+
+ // move playhead
+ else if (( newPosition != iLastPosition ) && !aDragMarks)
+ {
+ iLastPosition = newPosition;
+
+ iSeekPos = TTimeIntervalMicroSeconds( newPosition );
+
+ iCutAudioBar->SetCurrentPoint( (static_cast<TInt32>(iSeekPos.Int64() / 1000)));
+ iAudioSamplePlayer->SetPosition( iSeekPos );
+ UpdateVisualizationL();
+
+ iView.UpdateTimeL();
+ }
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleProgressBarTouchL(): Out");
+
+ }// PenEnabled
+
+ }
+
+
+void CVeiCutAudioContainer::PlayL( const TTimeIntervalMicroSeconds& aStartTime )
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL(): In, aStartTime:%Ld", aStartTime.Int64());
+ if ( aStartTime != TTimeIntervalMicroSeconds(0) )
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL() 2, setting pos:%Ld", aStartTime.Int64());
+ iAudioSamplePlayer->SetPosition( aStartTime );
+ UpdateVisualizationL();
+ }
+ else
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL() 3, setting pos:%Ld", iSeekPos.Int64());
+ iAudioSamplePlayer->SetPosition( iSeekPos );
+ UpdateVisualizationL();
+ }
+
+ SetStateL( EStatePlaying );
+
+ iAudioSamplePlayer->Play();
+ const TUint delay = 100000;
+
+ if ( !iVideoBarTimer->IsActive() )
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL() 4");
+ iVideoBarTimer->Start( delay, delay, TCallBack( CVeiCutAudioContainer::DoAudioBarUpdate, this ) );
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL() 5");
+ }
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PlayL(): Out");
+ }
+
+void CVeiCutAudioContainer::StopL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::StopL(): In");
+ iAudioSamplePlayer->Stop();
+
+ iSeekPos = TTimeIntervalMicroSeconds( 0 );
+ iLastPosition = TTimeIntervalMicroSeconds( 0 );
+ SetStateL( EStateStopped );
+ PlaybackPositionL();
+
+ iVideoBarTimer->Cancel();
+ iCutAudioBar->SetFinishedStatus( ETrue );
+
+ UpdateVisualizationL();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::StopL(): Out");
+ }
+
+void CVeiCutAudioContainer::PauseL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PauseL(): In");
+
+ PlaybackPositionL();
+
+ iVideoBarTimer->Cancel();
+ iAudioSamplePlayer->Pause();
+
+ if (iState != EStateInitializing)
+ {
+ SetStateL( EStatePaused );
+ }
+ else
+ {
+ SetStateL( EStateStoppedInitial );
+ }
+ iView.UpdateCBAL(iState);
+ // draw new visualization to bitmap
+ DrawToBufBitmapL();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PauseL(): Out");
+ }
+
+void CVeiCutAudioContainer::CloseStreamL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::CloseStreamL(): In");
+
+ PlaybackPositionL();
+ SetStateL( EStateStopped );
+
+ iAudioSamplePlayer->Stop();
+ iAudioSamplePlayer->Close();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::CloseStreamL(): Out");
+ }
+
+void CVeiCutAudioContainer::SetInTimeL( const TTimeIntervalMicroSeconds& aTime )
+ {
+ iMarkedInTime = aTime;
+ if ( iCutTimeDisplay )
+ {
+ iCutTimeDisplay->SetCutIn( aTime );
+ }
+ if ( iCutAudioBar )
+ {
+ iCutAudioBar->SetInPoint( aTime );
+ }
+ if (iSampleArrayHandler)
+ {
+ iSampleArrayHandler->SetCutInPoint(aTime);
+ }
+ // draw new visualization to bitmap
+ DrawToBufBitmapL();
+ }
+
+void CVeiCutAudioContainer::SetOutTimeL( const TTimeIntervalMicroSeconds& aTime )
+ {
+ iMarkedOutTime = aTime;
+ if ( iCutTimeDisplay )
+ {
+ iCutTimeDisplay->SetCutOut( aTime );
+ }
+ if ( iCutAudioBar )
+ {
+ iCutAudioBar->SetOutPoint( aTime );
+ }
+ if (iSampleArrayHandler)
+ {
+ iSampleArrayHandler->SetCutOutPoint(aTime);
+ }
+ // draw new visualization to bitmap
+ DrawToBufBitmapL();
+ }
+
+const TTimeIntervalMicroSeconds& CVeiCutAudioContainer::TotalLength()
+ {
+ return iDuration;
+ }
+
+const TTimeIntervalMicroSeconds& CVeiCutAudioContainer::PlaybackPositionL()
+ {
+ if (iSeeking)
+ {
+ return iSeekPos;
+ }
+ if (iState != EStatePlaying)
+ {
+ return iLastPosition;
+ }
+
+ TInt posError = iAudioSamplePlayer->GetPosition( iLastPosition );
+ //LOGFMT2(KVideoEditorLogFile, "CVeiCutAudioContainer::PlaybackPositionL(): %Ld, error: %d", iLastPosition.Int64(), posError);
+ posError = 0;
+
+ return iLastPosition;
+ }
+
+TKeyResponse CVeiCutAudioContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
+ {
+ if ( aType == EEventKeyDown )
+ {
+ iKeyRepeatCount = 0;
+
+ iAudioSamplePlayer->GetPosition( iSeekPos );
+
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::OfferKeyEventL(): EEventKeyDown, pos: %Ld", iSeekPos.Int64());
+
+ return EKeyWasConsumed;
+ }
+ else if ( aType == EEventKeyUp )
+ {
+
+ if ( iSeeking == EFalse )
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::OfferKeyEventL(): EEventKeyUp, seeking false");
+ return EKeyWasNotConsumed;
+ }
+
+ iSeeking = EFalse;
+ iLastPosition = iSeekPos;
+ iAudioSamplePlayer->SetPosition( iSeekPos );
+ UpdateVisualizationL();
+ if ( iState == EStatePlaying )
+ {
+ iAudioSamplePlayer->Play();
+ }
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::OfferKeyEventL(): EEventKeyUp, seeking true");
+
+ return EKeyWasConsumed;
+ }
+ else if ( aType == EEventKey )
+ {
+ if ( ( aKeyEvent.iRepeats == 0 ) &&
+ ( (aKeyEvent.iCode != EKeyDownArrow ) &&
+ ( aKeyEvent.iCode != EKeyUpArrow ) ) )
+ {
+ iAudioSamplePlayer->Pause();
+ }
+ iLastKeyCode = aKeyEvent.iCode;
+
+ switch (aKeyEvent.iCode)
+ {
+ case EKeyOK:
+ {
+ iView.HandleCommandL( EAknSoftkeyOk );
+ return EKeyWasConsumed;
+ }
+ case EKeyDownArrow:
+ {
+ iView.ProcessCommandL( EVeiCmdCutVideoVolumeDown );
+ return EKeyWasConsumed;
+ }
+ case EKeyUpArrow:
+ {
+ iView.ProcessCommandL( EVeiCmdCutVideoVolumeUp );
+ return EKeyWasConsumed;
+ }
+ case EKeyRightArrow:
+ {
+
+ if ( iSeeking == EFalse )
+ {
+ iAudioSamplePlayer->Pause();
+ }
+
+ iSeeking = ETrue;
+ iKeyRepeatCount++;
+
+ TInt adjustment = TimeIncrement( iKeyRepeatCount );
+
+ TInt64 newPos = iSeekPos.Int64() + adjustment;
+
+ if ( newPos > iAudioSamplePlayer->Duration().Int64() )
+ {
+ newPos = iAudioSamplePlayer->Duration().Int64();
+ }
+ iSeekPos = TTimeIntervalMicroSeconds( newPos );
+ iCutAudioBar->SetCurrentPoint( static_cast<TInt32>((iSeekPos.Int64() / 1000)));
+
+ iView.UpdateTimeL();
+
+ // mieti onko eka rivi tarpeen
+ iAudioSamplePlayer->SetPosition( iSeekPos );
+ UpdateVisualizationL();
+ return EKeyWasConsumed;
+ }
+
+ case EKeyLeftArrow:
+ {
+ if ( iSeeking == EFalse )
+ {
+ iAudioSamplePlayer->Pause();
+ }
+
+ iSeeking = ETrue;
+ iKeyRepeatCount++;
+
+ TInt adjustment = TimeIncrement( iKeyRepeatCount );
+
+ TInt64 newPos = iSeekPos.Int64() - adjustment;
+ if ( newPos < 0 )
+ {
+ newPos = 0;
+ }
+ iSeekPos = TTimeIntervalMicroSeconds( newPos );
+ iCutAudioBar->SetCurrentPoint(static_cast<TInt32>( (iSeekPos.Int64() / 1000)));
+
+ iView.UpdateTimeL();
+ iAudioSamplePlayer->SetPosition( iSeekPos );
+ UpdateVisualizationL();
+ return EKeyWasConsumed;
+ }
+ case EKeyBackspace: //Clear
+ {
+ iView.ClearInOutL( ETrue, ETrue );
+ UpdateVisualizationL();
+ return EKeyWasConsumed;
+ }
+ default:
+ {
+ return EKeyWasNotConsumed;
+ }
+ }
+ }
+ else
+ {
+ return EKeyWasNotConsumed;
+ }
+ }
+
+
+
+TInt CVeiCutAudioContainer::TimeIncrement(TInt aKeyCount) const
+ {
+ if ( aKeyCount < 3 )
+ {
+ return 100000;
+ }
+ else if ( aKeyCount < 4 )
+ {
+ return 300000;
+ }
+ else if ( aKeyCount < 5 )
+ {
+ return 500000;
+ }
+ else if ( aKeyCount < 10 )
+ {
+ return 1000000;
+ }
+ else if ( aKeyCount < 13 )
+ {
+ return 2000000;
+ }
+ else if ( aKeyCount < 15 )
+ {
+ return 3000000;
+ }
+ else
+ {
+ return 5000000;
+ }
+ }
+
+void CVeiCutAudioContainer::SetStateL(CVeiCutAudioContainer::TCutAudioState aState)
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::SetStateL(): In: aState:%d", aState);
+
+ iState = aState;
+ iView.UpdateCBAL( aState );
+
+ // If the foreground is lost while an arrow key is down, we do not get
+ // the key up -event, and iSeeking remains true. Reseting it here just in case.
+ iSeeking = EFalse;
+
+ // While playing, grab the volume keys for adjusting playback volume.
+ // In other states let them pass e.g. to the music player.
+ if(EStatePlaying == iState)
+ {
+ if (!iRemConTarget)
+ {
+ iRemConTarget = CVeiRemConTarget::NewL( *this );
+ }
+ }
+ else
+ {
+ delete iRemConTarget;
+ iRemConTarget = NULL;
+ }
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::SetStateL(): Out");
+ }
+
+void CVeiCutAudioContainer::MarkedInL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MarkedInL(): In");
+
+ if (iState == EStateInitializing || iState == EStateOpening)
+ {
+ return;
+ }
+
+ TTimeIntervalMicroSeconds cutIn = PlaybackPositionL();
+ if ( iCutTimeDisplay )
+ {
+ iCutTimeDisplay->SetCutIn( cutIn );
+ }
+ LOGFMT2(KVideoEditorLogFile, "\tIn point: %Ld, state: %d", cutIn.Int64(), iState);
+
+ iCutAudioBar->SetInPoint( cutIn );
+
+ if (iSampleArrayHandler)
+ {
+ iSampleArrayHandler->SetCutInPoint(cutIn);
+ }
+
+ if ( iState == EStatePlaying )
+ {
+ PauseL();
+ }
+ else
+ {
+ iView.UpdateCBAL( iState );
+ }
+
+ UpdateVisualizationL();
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MarkedInL(): Out");
+ }
+
+void CVeiCutAudioContainer::MarkedOutL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MarkedOutL(): In");
+
+ if (iState == EStateInitializing || iState == EStateOpening)
+ {
+ return;
+ }
+
+ TTimeIntervalMicroSeconds cutOut = PlaybackPositionL();
+
+ if ( iCutTimeDisplay )
+ {
+ iCutTimeDisplay->SetCutOut( cutOut );
+ }
+
+ LOGFMT2(KVideoEditorLogFile, "\tOut point: %Ld, state: %d", cutOut.Int64(), iState);
+ iCutAudioBar->SetOutPoint( cutOut );
+
+ if (iSampleArrayHandler)
+ {
+ iSampleArrayHandler->SetCutOutPoint(cutOut);
+ }
+
+ if ( iState == EStatePlaying )
+ {
+ PauseL();
+ }
+ else
+ {
+ iView.UpdateCBAL( iState );
+ }
+
+ UpdateVisualizationL();
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MarkedOutL(): Out");
+ }
+
+void CVeiCutAudioContainer::SetVolumeL( TInt aVolumeChange )
+ {
+ iInternalVolume += aVolumeChange;
+
+ if ( iInternalVolume < 0 )
+ {
+ iInternalVolume = 0;
+ }
+ if ( iInternalVolume > KMaxCutAudioVolumeLevel )
+ {
+ iInternalVolume = KMaxCutAudioVolumeLevel;
+ }
+
+ if ( iAudioSamplePlayer )
+ {
+ TInt vol = STATIC_CAST( TInt, (iInternalVolume*iMaxVolume)/KMaxCutAudioVolumeLevel );
+ iAudioSamplePlayer->SetVolume( vol );
+ }
+ }
+
+TInt CVeiCutAudioContainer::DoAudioBarUpdate( TAny* aThis )
+ {
+ STATIC_CAST( CVeiCutAudioContainer*, aThis )->DoUpdate();
+ return 42;
+ }
+
+void CVeiCutAudioContainer::DoUpdate()
+ {
+ TTimeIntervalMicroSeconds time;
+ iAudioSamplePlayer->GetPosition( time );
+
+ if ( iSeeking )
+ {
+ time = iSeekPos;
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::DoUpdate(): 1, time:%Ld", time.Int64());
+ }
+ else
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::DoUpdate(): 2, time:%Ld", time.Int64());
+ }
+
+ iCutAudioBar->SetCurrentPoint(static_cast<TInt32>( (time.Int64() / 1000)));
+ iCutAudioBar->DrawDeferred();
+
+ TRAP_IGNORE( UpdateVisualizationL() );
+ }
+
+
+void CVeiCutAudioContainer::UpdateVisualizationL()
+ {
+ TTimeIntervalMicroSeconds time;
+ iAudioSamplePlayer->GetPosition( time );
+ iSampleArrayHandler->SetCurrentPoint(time);
+
+ DrawToBufBitmapL();
+ }
+
+// @: not leave safe!
+void CVeiCutAudioContainer::MapcInitComplete( TInt aError,
+ const TTimeIntervalMicroSeconds& DEBUGLOG_ARG(aDuration) )
+ {
+ LOGFMT2(KVideoEditorLogFile, "CVeiCutAudioContainer::MapcInitComplete(): In, aError:%d, aDuration:%Ld", aError, aDuration.Int64());
+ if( aError == KErrNone ) // The sample is ready to play.
+ {
+ CVeiVideoEditorSettings::GetMediaPlayerVolumeLevelL( iInternalVolume );
+
+ iMaxVolume = iAudioSamplePlayer->MaxVolume();
+ TInt vol = STATIC_CAST( TInt, (iInternalVolume*iMaxVolume)/KMaxCutAudioVolumeLevel );
+ iAudioSamplePlayer->SetVolume( vol );
+ /* Show mute icon in navipane */
+ if ( vol == 0 )
+ {
+ iView.VolumeDownL();
+ }
+ }
+ iCutAudioBar->SetTotalDuration( iDuration );
+
+ SetStateL( EStateStoppedInitial );
+ iView.UpdateTimeL();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MapcInitComplete(): Out");
+ }
+
+void CVeiCutAudioContainer::SetDuration( const TTimeIntervalMicroSeconds& aDuration )
+ {
+ iDuration = aDuration;
+ iCutAudioBar->SetTotalDuration( iDuration );
+ }
+
+void CVeiCutAudioContainer::LaunchProgressNoteL()
+ {
+ iProgressNote = new ( ELeave ) CAknProgressDialog( REINTERPRET_CAST( CEikDialog**,
+ &iProgressNote), ETrue);
+ iProgressNote->SetCallback(this);
+ iProgressNote->PrepareLC( R_VEI_PROGRESS_NOTE_WITH_CANCEL );
+
+ HBufC* stringholder = StringLoader::LoadLC( R_VEI_PROGRESS_NOTE_CUT, iEikonEnv );
+ iProgressNote->SetTextL( *stringholder );
+ CleanupStack::PopAndDestroy(stringholder);
+
+ iProgressNote->GetProgressInfoL()->SetFinalValue( 100 );
+ iProgressNote->RunLD();
+ }
+
+void CVeiCutAudioContainer::MapcPlayComplete( TInt DEBUGLOG_ARG(aError) )
+ {
+ LOGFMT(KVideoEditorLogFile, "CVeiCutAudioContainer::MapcPlayComplete(): In, error:%d", aError);
+
+ if (EStateTerminating == iState)
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MapcPlayComplete: app is closing...");
+ return;
+ }
+
+ TRAP_IGNORE( SetStateL( EStateStopped ) );
+ iVideoBarTimer->Cancel();
+
+ iCutAudioBar->SetFinishedStatus( ETrue );
+ iLastPosition = TTimeIntervalMicroSeconds( 0 );
+ iSeekPos = 0;
+ TRAP_IGNORE( iView.StopNaviPaneUpdateL() );
+
+ TRAP_IGNORE( UpdateVisualizationL() );
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::MapcPlayComplete(): Out");
+ }
+
+void CVeiCutAudioContainer::NotifyAudioClipVisualizationStarted(const CVedAudioClipInfo& /*aInfo*/)
+ {
+ TRAP_IGNORE( LaunchProgressNoteL() );
+ }
+
+void CVeiCutAudioContainer::NotifyAudioClipVisualizationProgressed(const CVedAudioClipInfo& /*aInfo*/,
+ TInt aPercentage)
+ {
+ if ( iProgressNote )
+ {
+ TRAP_IGNORE( iProgressNote->GetProgressInfoL()->SetAndDraw( aPercentage ) );
+ }
+ }
+
+void CVeiCutAudioContainer::NotifyAudioClipVisualizationCompleted(const CVedAudioClipInfo& /*aInfo*/,
+ TInt aError, TInt8* aVisualization,
+ TInt aResolution)
+ {
+ if ( iProgressNote )
+ {
+ TRAP_IGNORE( iProgressNote->GetProgressInfoL()->SetAndDraw(100) );
+ TRAP_IGNORE( iProgressNote->ProcessFinishedL() );
+ }
+ if (KErrNone == aError)
+ {
+ iSampleArrayHandler->SetVisualizationArray(aVisualization, aResolution);
+ TRAP_IGNORE( DrawToBufBitmapL() );
+ }
+ }
+
+TInt CVeiCutAudioContainer::VisualizationResolution() const
+ {
+ return iIconDisplayRect.Width();
+ }
+
+void CVeiCutAudioContainer::DialogDismissedL( TInt aButtonId )
+ {
+ if (aButtonId != EAknSoftkeyDone )
+ {
+ iView.CancelVisualizationL();
+ if (! iCallBack)
+ {
+ TCallBack cb (CVeiCutAudioContainer::AsyncBack, this);
+ iCallBack = new (ELeave) CAsyncCallBack(cb, CActive::EPriorityStandard);
+ }
+ iCallBack->CallBack();
+ }
+ }
+
+TInt CVeiCutAudioContainer::AsyncBack(TAny* aThis)
+ {
+ LOG( KVideoEditorLogFile, "CVeiCutAudioContainer::AsyncExit");
+
+ CVeiCutAudioContainer* view = static_cast<CVeiCutAudioContainer*>(aThis);
+ TRAPD( err, view->HandleCommandL(EVeiCmdCutVideoViewBack) );
+
+ return err;
+ }
+
+
+void CVeiCutAudioContainer::HandleCommandL(TInt aCommand)
+ {
+ iView.HandleCommandL(aCommand);
+ }
+
+void CVeiCutAudioContainer::GetVisualizationL()
+ {
+ iView.GetAudioVisualizationL();
+ }
+
+//=============================================================================
+void CVeiCutAudioContainer::HandleVolumeUpL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleVolumeUpL: in");
+
+ iView.VolumeUpL();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleVolumeUpL: out");
+ }
+
+//=============================================================================
+void CVeiCutAudioContainer::HandleVolumeDownL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleVolumeDownL: in");
+
+ iView.VolumeDownL();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::HandleVolumeDownL: out");
+ }
+
+//=============================================================================
+void CVeiCutAudioContainer::PrepareForTerminationL()
+ {
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PrepareForTerminationL: in");
+
+ SetStateL( EStateTerminating );
+
+ iVideoBarTimer->Cancel();
+ iAudioSamplePlayer->Stop();
+ iAudioSamplePlayer->Close();
+
+ LOG(KVideoEditorLogFile, "CVeiCutAudioContainer::PrepareForTerminationL: out");
+ }
+
+// End of File