diff -r 000000000000 -r 951a5db380a0 videditor/ManualVideoEditor/src/VeiCutAudioContainer.cpp
--- /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